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