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, sd, regfile):
  28         dict.__init__(self)
  29         self.sd = sd
  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     def __init__(self):
  59         self.gpr = GPR()
  60         self.mem = Mem()
  61         self.namespace = {'GPR': self.gpr,
  62                           'MEM': self.mem,
  63                           'memassign': self.memassign
  64                          }
  65
  66     def memassign(self, ea, sz, val):
  67         self.mem.memassign(ea, sz, val)
  68
  69
  70 def inject(context):
  71     """ Decorator factory. """
  72     def variable_injector(func):
  73         @wraps(func)
  74         def decorator(*args, **kwargs):
  75             try:
  76                 func_globals = func.__globals__  # Python 2.6+
  77             except AttributeError:
  78                 func_globals = func.func_globals  # Earlier versions.
  79
  80             saved_values = func_globals.copy()  # Shallow copy of dict.
  81             func_globals.update(context)
  82
  83             result = func(*args, **kwargs)
  84             #exec (func.__code__, func_globals)
  85
  86             #finally:
  87             #    func_globals = saved_values  # Undo changes.
  88
  89             return result
  90
  91         return decorator
  92
  93     return variable_injector
  94
  95 if __name__ == '__main__':
  96     d = {'1': 1}
  97     namespace = {'a': 5, 'b': 3, 'd': d}
  98
  99     @inject(namespace)
 100     def test():
 101         print (globals())
 102         print('a:', a)
 103         print('b:', b)
 104         print('d1:', d['1'])
 105         d[2] = 5
 106
 107         return locals()
 108
 109     test()
 110
 111     print (namespace)