src/soc/decoder/power_pseudo.py

   1 # Based on GardenSnake - a parser generator demonstration program
   2 # GardenSnake was released into the Public Domain by Andrew Dalke.
   3
   4 # Portions of this work are derived from Python's Grammar definition
   5 # and may be covered under the Python copyright and license
   6 #
   7 #          Andrew Dalke / Dalke Scientific Software, LLC
   8 #             30 August 2006 / Cape Town, South Africa
   9
  10 # Modifications for inclusion in PLY distribution
  11 import sys
  12 from pprint import pprint
  13 from copy import copy
  14 from ply import lex, yacc
  15 import astor
  16 import ast
  17
  18 from soc.decoder.power_decoder import create_pdecode
  19 from nmigen.back.pysim import Simulator, Delay
  20 from nmigen import Module, Signal
  21
  22 from soc.decoder.pseudo.parser import GardenSnakeCompiler
  23 from soc.decoder.selectable_int import SelectableInt, selectconcat
  24
  25 ####### Test code #######
  26
  27 bpermd = r"""
  28 perm <- [0] * 8
  29 if index < 64:
  30     index <- (RS)[8*i:8*i+7]
  31 RA <- [0]*56 || perm[0:7]
  32 print (RA)
  33 """
  34
  35 bpermd = r"""
  36 if index < 64 then index <- 0
  37 else index <- 5
  38 do while index < 5
  39     index <- 0
  40     leave
  41 for i = 0 to 7
  42     index <- 0
  43 """
  44
  45 _bpermd = r"""
  46 for i = 0 to 7
  47    index <- (RS)[8*i:8*i+7]
  48    if index < 64 then
  49         permi <- (RB)[index]
  50    else
  51         permi <- 0
  52 RA <- [0]*56|| perm[0:7]
  53 """
  54
  55 cnttzd = """
  56 n  <- 0
  57 do while n < 64
  58     print (n)
  59     if (RS)[63-n] = 0b1 then
  60         leave
  61     n  <- n + 1
  62 RA <- EXTZ64(n)
  63 print (RA)
  64 """
  65
  66 cmpi = """
  67 if      a < EXTS(SI) then
  68     c <- 0b100
  69 else if a > EXTS(SI) then
  70     c <- 0b010
  71 """
  72
  73 cmpi = """
  74 RA[0:1] <- 0b11
  75 """
  76
  77 cmpi = """
  78 in_range <-  ((x | y) &
  79               (a | b))
  80 in_range <-  (x + y) - (a + b)
  81 """
  82
  83 cmpi = """
  84 (RA)[0:1] <- 1
  85 src1    <- EXTZ((RA)[56:63])
  86 CR[4*BF+32] <- 0b0
  87 in_range <- src21lo  <= src1 & src1 <=  src21hi
  88 """
  89
  90 cmpeqb = """
  91 src1 <- GPR[RA]
  92 src1 <- src1[0:56]
  93 """
  94
  95 addpcis = """
  96 D <- d0||d1||d2
  97 """
  98
  99 testmul = """
 100 x <- [0] * 16
 101 RT <- (RA) + EXTS(SI || [0]*16)
 102 """
 103
 104 testgetzero = """
 105 RS <- (RA|0)
 106 RS <- RS + 1
 107 print(RS)
 108 """
 109
 110 testcat = """
 111 RT <- (load_data[56:63] || load_data[48:55]
 112     || load_data[40:47] || load_data[32:39]
 113     || load_data[24:31] || load_data[16:23]
 114     || load_data[8:15]  || load_data[0:7])
 115 """
 116
 117 testgpr = """
 118 GPR(5) <- x
 119 """
 120 #code = testmul
 121 #code = testgetzero
 122 #code = testcat
 123 code = testgpr
 124 #code = testreg
 125 #code = cnttzd
 126 #code = cmpi
 127 #code = cmpeqb
 128 #code = addpcis
 129 #code = bpermd
 130
 131
 132 def tolist(num):
 133     l = []
 134     for i in range(64):
 135         l.append(1 if (num & (1 << i)) else 0)
 136     l.reverse()
 137     return l
 138
 139
 140 def get_reg_hex(reg):
 141     return hex(reg.value)
 142
 143
 144 class GPR(dict):
 145     def __init__(self, sd, regfile):
 146         dict.__init__(self)
 147         self.sd = sd
 148         for i in range(32):
 149             self[i] = SelectableInt(regfile[i], 64)
 150
 151     def set_form(self, form):
 152         self.form = form
 153
 154     def getz(self, rnum):
 155         #rnum = rnum.value # only SelectableInt allowed
 156         print("GPR getzero", rnum)
 157         if rnum == 0:
 158             return SelectableInt(0, 64)
 159         return self[rnum]
 160
 161     def _get_regnum(self, attr):
 162         getform = self.sd.sigforms[self.form]
 163         rnum = getattr(getform, attr)
 164         return rnum
 165
 166     def ___getitem__(self, attr):
 167         print("GPR getitem", attr)
 168         rnum = self._get_regnum(attr)
 169         return self.regfile[rnum]
 170
 171
 172 def convert_to_python(pcode):
 173
 174     gsc = GardenSnakeCompiler()
 175
 176     tree = gsc.compile(pcode, mode="exec", filename="string")
 177     tree = ast.fix_missing_locations(tree)
 178     regsused = {'read_regs': gsc.parser.read_regs,
 179                 'write_regs': gsc.parser.write_regs,
 180                 'uninit_regs': gsc.parser.uninit_regs}
 181     return astor.to_source(tree), regsused
 182
 183
 184 def test():
 185
 186     gsc = GardenSnakeCompiler()
 187
 188     # XXX unused!  see GPR instead
 189     gsc.regfile = {}
 190     for i in range(32):
 191         gsc.regfile[i] = i
 192     gsc.gpr = GPR(gsc.parser.sd, gsc.regfile)
 193
 194     _compile = gsc.compile
 195
 196     tree = _compile(code, mode="single", filename="string")
 197     tree = ast.fix_missing_locations(tree)
 198     print(ast.dump(tree))
 199
 200     print("astor dump")
 201     print(astor.dump_tree(tree))
 202     print("to source")
 203     source = astor.to_source(tree)
 204     print(source)
 205
 206     # sys.exit(0)
 207
 208     # Set up the GardenSnake run-time environment
 209     def print_(*args):
 210         print("args", args)
 211         print("-->", " ".join(map(str, args)))
 212
 213     from soc.decoder.helpers import (EXTS64, EXTZ64, ROTL64, ROTL32, MASK,)
 214
 215     d = {}
 216     d["print"] = print_
 217     d["EXTS64"] = EXTS64
 218     d["EXTZ64"] = EXTZ64
 219     d["SelectableInt"] = SelectableInt
 220     d["concat"] = selectconcat
 221     d["GPR"] = gsc.gpr
 222
 223     form = 'X'
 224     gsc.gpr.set_form(form)
 225     getform = gsc.parser.sd.sigforms[form]._asdict()
 226     #print ("getform", form)
 227     # for k, f in getform.items():
 228     #print (k, f)
 229     #d[k] = getform[k]
 230
 231     compiled_code = compile(source, mode="exec", filename="<string>")
 232
 233     m = Module()
 234     comb = m.d.comb
 235     instruction = Signal(32)
 236
 237     m.submodules.decode = decode = gsc.parser.sd
 238     comb += decode.raw_opcode_in.eq(instruction)
 239     sim = Simulator(m)
 240
 241     instr = [0x11111117]
 242
 243     def process():
 244         for ins in instr:
 245             print("0x{:X}".format(ins & 0xffffffff))
 246
 247             # ask the decoder to decode this binary data (endian'd)
 248             yield decode.bigendian.eq(0)  # little / big?
 249             yield instruction.eq(ins)          # raw binary instr.
 250             yield Delay(1e-6)
 251
 252             # uninitialised regs, drop them into dict for function
 253             for rname in gsc.parser.uninit_regs:
 254                 d[rname] = SelectableInt(0, 64)  # uninitialised (to zero)
 255                 print("uninitialised", rname, get_reg_hex(d[rname]))
 256
 257             # read regs, drop them into dict for function
 258             for rname in gsc.parser.read_regs:
 259                 regidx = yield getattr(decode.sigforms['X'], rname)
 260                 d[rname] = gsc.gpr[regidx] # contents of regfile
 261                 d["_%s" % rname] = regidx # actual register value
 262                 print("read reg", rname, regidx, get_reg_hex(d[rname]))
 263
 264             exec(compiled_code, d)  # code gets executed here in dict "d"
 265             print("Done")
 266
 267             print(d.keys())  # shows the variables that may have been created
 268
 269             print(decode.sigforms['X'])
 270             x = yield decode.sigforms['X'].RS
 271             ra = yield decode.sigforms['X'].RA
 272             print("RA", ra, d['RA'])
 273             print("RS", x)
 274
 275             for wname in gsc.parser.write_regs:
 276                 reg = getform[wname]
 277                 regidx = yield reg
 278                 print("write regs", regidx, wname, d[wname], reg)
 279                 gsc.gpr[regidx] = d[wname]
 280
 281     sim.add_process(process)
 282     with sim.write_vcd("simulator.vcd", "simulator.gtkw",
 283                        traces=decode.ports()):
 284         sim.run()
 285
 286     for i in range(len(gsc.gpr)):
 287         print("regfile", i, get_reg_hex(gsc.gpr[i]))
 288
 289
 290 if __name__ == '__main__':
 291     test()