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