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
  72 def inject(context):
  73     """ Decorator factory. """
  74     def variable_injector(func):
  75         @wraps(func)
  76         def decorator(*args, **kwargs):
  77             try:
  78                 func_globals = func.__globals__  # Python 2.6+
  79             except AttributeError:
  80                 func_globals = func.func_globals  # Earlier versions.
  81
  82             saved_values = func_globals.copy()  # Shallow copy of dict.
  83             func_globals.update(context)
  84
  85             result = func(*args, **kwargs)
  86             #exec (func.__code__, func_globals)
  87
  88             #finally:
  89             #    func_globals = saved_values  # Undo changes.
  90
  91             return result
  92
  93         return decorator
  94
  95     return variable_injector
  96
  97 if __name__ == '__main__':
  98     d = {'1': 1}
  99     namespace = {'a': 5, 'b': 3, 'd': d}
 100
 101     @inject(namespace)
 102     def test():
 103         print (globals())
 104         print('a:', a)
 105         print('b:', b)
 106         print('d1:', d['1'])
 107         d[2] = 5
 108
 109         return locals()
 110
 111     test()
 112
 113     print (namespace)