src/soc/decoder/isa/caller.py

   1 from functools import wraps
   2 from soc.decoder.selectable_int import SelectableInt, selectconcat
   3
   4
   5 class Mem:
   6
   7     def __init__(self):
   8         self.mem = []
   9         for i in range(128):
  10             self.mem.append(i)
  11
  12     def __call__(self, addr, sz):
  13         res = []
  14         for s in range(sz): # TODO: big/little-end
  15             res.append(SelectableInt(self.mem[addr.value + s], 8))
  16         print ("memread", addr, sz, res)
  17         return selectconcat(*res)
  18
  19     def memassign(self, addr, sz, val):
  20         print ("memassign", addr, sz, val)
  21         for s in range(sz):
  22             byte = (val.value) >> (s*8) & 0xff # TODO: big/little-end
  23             self.mem[addr.value + s] = byte
  24
  25
  26 class GPR(dict):
  27     def __init__(self, decoder, regfile):
  28         dict.__init__(self)
  29         self.sd = decoder
  30         for i in range(32):
  31             self[i] = SelectableInt(regfile[i], 64)
  32
  33     def __call__(self, ridx):
  34         return self[ridx]
  35
  36     def set_form(self, form):
  37         self.form = form
  38
  39     def getz(self, rnum):
  40         #rnum = rnum.value # only SelectableInt allowed
  41         print("GPR getzero", rnum)
  42         if rnum == 0:
  43             return SelectableInt(0, 64)
  44         return self[rnum]
  45
  46     def _get_regnum(self, attr):
  47         getform = self.sd.sigforms[self.form]
  48         rnum = getattr(getform, attr)
  49         return rnum
  50
  51     def ___getitem__(self, attr):
  52         print("GPR getitem", attr)
  53         rnum = self._get_regnum(attr)
  54         return self.regfile[rnum]
  55
  56
  57 class ISACaller:
  58     # decoder2 - an instance of power_decoder2
  59     # regfile - a list of initial values for the registers
  60     def __init__(self, decoder2, regfile):
  61         self.gpr = GPR(decoder2, regfile)
  62         self.mem = Mem()
  63         self.namespace = {'GPR': self.gpr,
  64                           'MEM': self.mem,
  65                           'memassign': self.memassign
  66                           }
  67
  68     def memassign(self, ea, sz, val):
  69         self.mem.memassign(ea, sz, val)
  70
  71     def call(self, name):
  72         function, read_regs, uninit_regs, write_regs = self.instrs[name]
  73
  74
  75
  76
  77 def inject(context):
  78     """ Decorator factory. """
  79     def variable_injector(func):
  80         @wraps(func)
  81         def decorator(*args, **kwargs):
  82             try:
  83                 func_globals = func.__globals__  # Python 2.6+
  84             except AttributeError:
  85                 func_globals = func.func_globals  # Earlier versions.
  86
  87             saved_values = func_globals.copy()  # Shallow copy of dict.
  88             func_globals.update(context)
  89
  90             result = func(*args, **kwargs)
  91             #exec (func.__code__, func_globals)
  92
  93             #finally:
  94             #    func_globals = saved_values  # Undo changes.
  95
  96             return result
  97
  98         return decorator
  99
 100     return variable_injector
 101
 102 if __name__ == '__main__':
 103     d = {'1': 1}
 104     namespace = {'a': 5, 'b': 3, 'd': d}
 105
 106     @inject(namespace)
 107     def test():
 108         print (globals())
 109         print('a:', a)
 110         print('b:', b)
 111         print('d1:', d['1'])
 112         d[2] = 5
 113
 114         return locals()
 115
 116     test()
 117
 118     print (namespace)