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 #code = testmul
 138 #code = testgetzero
 139 #code = testcat
 140 #code = testgpr
 141 #code = testmem
 142 code = testgprslice
 143 #code = testreg
 144 #code = cnttzd
 145 #code = cmpi
 146 #code = cmpeqb
 147 #code = addpcis
 148 #code = bpermd
 149
 150
 151 def tolist(num):
 152     l = []
 153     for i in range(64):
 154         l.append(1 if (num & (1 << i)) else 0)
 155     l.reverse()
 156     return l
 157
 158
 159 def get_reg_hex(reg):
 160     return hex(reg.value)
 161
 162 def convert_to_python(pcode):
 163
 164     gsc = GardenSnakeCompiler()
 165
 166     tree = gsc.compile(pcode, mode="exec", filename="string")
 167     tree = ast.fix_missing_locations(tree)
 168     regsused = {'read_regs': gsc.parser.read_regs,
 169                 'write_regs': gsc.parser.write_regs,
 170                 'uninit_regs': gsc.parser.uninit_regs}
 171     return astor.to_source(tree), regsused
 172
 173
 174 def test():
 175
 176     gsc = GardenSnakeCompiler()
 177
 178     gsc.regfile = {}
 179     for i in range(32):
 180         gsc.regfile[i] = i
 181     gsc.gpr = GPR(gsc.parser.sd, gsc.regfile)
 182     gsc.mem = Mem()
 183
 184     _compile = gsc.compile
 185
 186     tree = _compile(code, mode="single", filename="string")
 187     tree = ast.fix_missing_locations(tree)
 188     print(ast.dump(tree))
 189
 190     print("astor dump")
 191     print(astor.dump_tree(tree))
 192     print("to source")
 193     source = astor.to_source(tree)
 194     print(source)
 195
 196     # sys.exit(0)
 197
 198     # Set up the GardenSnake run-time environment
 199     def print_(*args):
 200         print("args", args)
 201         print("-->", " ".join(map(str, args)))
 202
 203     from soc.decoder.helpers import (EXTS64, EXTZ64, ROTL64, ROTL32, MASK,)
 204
 205     d = {}
 206     d["print"] = print_
 207     d["EXTS64"] = EXTS64
 208     d["EXTZ64"] = EXTZ64
 209     d["SelectableInt"] = SelectableInt
 210     d["concat"] = selectconcat
 211     d["GPR"] = gsc.gpr
 212     d["MEM"] = gsc.mem
 213     d["memassign"] = gsc.mem.memassign
 214
 215     form = 'X'
 216     gsc.gpr.set_form(form)
 217     getform = gsc.parser.sd.sigforms[form]._asdict()
 218     #print ("getform", form)
 219     # for k, f in getform.items():
 220     #print (k, f)
 221     #d[k] = getform[k]
 222
 223     compiled_code = compile(source, mode="exec", filename="<string>")
 224
 225     m = Module()
 226     comb = m.d.comb
 227     instruction = Signal(32)
 228
 229     m.submodules.decode = decode = gsc.parser.sd
 230     comb += decode.raw_opcode_in.eq(instruction)
 231     sim = Simulator(m)
 232
 233     instr = [0x11111117]
 234
 235     def process():
 236         for ins in instr:
 237             print("0x{:X}".format(ins & 0xffffffff))
 238
 239             # ask the decoder to decode this binary data (endian'd)
 240             yield decode.bigendian.eq(0)  # little / big?
 241             yield instruction.eq(ins)          # raw binary instr.
 242             yield Delay(1e-6)
 243
 244             # uninitialised regs, drop them into dict for function
 245             for rname in gsc.parser.uninit_regs:
 246                 d[rname] = SelectableInt(0, 64)  # uninitialised (to zero)
 247                 print("uninitialised", rname, get_reg_hex(d[rname]))
 248
 249             # read regs, drop them into dict for function
 250             for rname in gsc.parser.read_regs:
 251                 regidx = yield getattr(decode.sigforms['X'], rname)
 252                 d[rname] = gsc.gpr[regidx] # contents of regfile
 253                 d["_%s" % rname] = regidx # actual register value
 254                 print("read reg", rname, regidx, get_reg_hex(d[rname]))
 255
 256             exec(compiled_code, d)  # code gets executed here in dict "d"
 257             print("Done")
 258
 259             print(d.keys())  # shows the variables that may have been created
 260
 261             print(decode.sigforms['X'])
 262             x = yield decode.sigforms['X'].RS
 263             ra = yield decode.sigforms['X'].RA
 264             rb = yield decode.sigforms['X'].RB
 265             print("RA", ra, d['RA'])
 266             print("RB", rb, d['RB'])
 267             print("RS", x)
 268
 269             for wname in gsc.parser.write_regs:
 270                 reg = getform[wname]
 271                 regidx = yield reg
 272                 print("write regs", regidx, wname, d[wname], reg)
 273                 gsc.gpr[regidx] = d[wname]
 274
 275     sim.add_process(process)
 276     with sim.write_vcd("simulator.vcd", "simulator.gtkw",
 277                        traces=decode.ports()):
 278         sim.run()
 279
 280     for i in range(len(gsc.gpr)):
 281         print("regfile", i, get_reg_hex(gsc.gpr[i]))
 282
 283     for i in range(0, len(gsc.mem.mem), 16):
 284         hexstr = []
 285         for j in range(16):
 286             hexstr.append("%02x" % gsc.mem.mem[i+j])
 287         hexstr = ' '.join(hexstr)
 288         print ("mem %4x" % i, hexstr)
 289
 290 if __name__ == '__main__':
 291     test()