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