src/openpower/decoder/isa/test_caller_exts.py

   1 import codecs
   2 import csv
   3 import glob
   4 import os
   5 import re
   6 import unittest
   7
   8 from nmutil.formaltest import FHDLTestCase
   9
  10 from openpower.decoder.power_decoder import create_pdecode
  11 from openpower.decoder.power_decoder2 import (PowerDecode2)
  12 from openpower.simulator.program import Program
  13 from openpower.decoder.selectable_int import SelectableInt
  14
  15 from openpower.decoder.isa.test_runner import run_tst
  16
  17
  18 def tstgen(mapping):
  19     zeros = [0] * 32
  20     for chunk in (mapping[idx:idx+32] for idx in range(0, len(mapping), 32)):
  21         instrs = []
  22         iregs = []
  23         oregs = []
  24         for (idx, (instr, ireg, oreg)) in enumerate(chunk):
  25             instrs.append(f"{instr} {idx}, {idx}")
  26             iregs.append(ireg)
  27             oregs.append(oreg)
  28         iregs = (iregs + zeros)[:32]
  29         oregs = (oregs + zeros)[:32]
  30         yield (instrs, iregs, oregs)
  31
  32
  33 class EXTSTestCase(FHDLTestCase):
  34     CWD = os.path.dirname(os.path.realpath(__file__))
  35     ISAFN = os.path.normpath(os.path.join(CWD,
  36         "..", "..", "..", "..", "openpower", "isafunctions"))
  37     REGEX = re.compile(r"extsxl_(0x[0-9A-Fa-f]{16}).csv")
  38     XLENS = (64, 32, 16, 8)
  39
  40     def __init__(self, *args, **kwargs):
  41         super().__init__(*args, **kwargs)
  42         pdecode = create_pdecode(include_fp=True)
  43         self.pdecode2 = PowerDecode2(pdecode)
  44
  45     def run_tst(self, mapping, xlen):
  46         for (instrs, iregs, oregs) in tstgen(mapping):
  47             nr = len(instrs)
  48             with self.subTest():
  49                 with Program(instrs, bigendian=False) as program:
  50                     sim = self.run_tst_program(program, iregs)
  51                     for (idx, gpr) in enumerate(range(nr)):
  52                         print(f"{instrs[idx]} {iregs[idx]:016x} {oregs[idx]:016x}")
  53                         self.assertEqual(sim.gpr(gpr),
  54                                         SelectableInt(oregs[gpr], xlen))
  55
  56     def test(self):
  57         data = {xlen:[] for xlen in EXTSTestCase.XLENS}
  58         wildcard = os.path.join(EXTSTestCase.ISAFN, "extsxl_*.csv")
  59         for path in glob.glob(wildcard):
  60             name = path[len(EXTSTestCase.ISAFN + os.path.sep):]
  61             match = EXTSTestCase.REGEX.match(name)
  62             if match is None:
  63                 continue
  64             ireg = int(match[1], 16)
  65             with codecs.open(path, "rb", "UTF-8") as stream:
  66                 csv_reader = csv.reader(stream, delimiter=",")
  67                 _ = stream.readline() # we already know the format
  68                 for row in csv_reader:
  69                     assert len(row) == len(("instr",) + EXTSTestCase.XLENS)
  70                     row = tuple(map(lambda s: s.strip(), row))
  71                     instr = row[0]
  72                     xlens = dict(zip(
  73                         EXTSTestCase.XLENS,
  74                         map(lambda v: int(v, 16), row[1:])))
  75                     for (xlen, oreg) in xlens.items():
  76                         data[xlen].append((instr, ireg, oreg))
  77
  78         # FIXME drop filter once XLEN != 64 is unlocked
  79         for xlen in filter(lambda v: v == 64, data):
  80             self.run_tst(data[xlen], xlen)
  81
  82     def run_tst_program(self, prog, initial_regs=[0] * 32):
  83         simulator = run_tst(prog, initial_regs, pdecode2=self.pdecode2)
  84         simulator.gpr.dump()
  85         return simulator
  86
  87 if __name__ == "__main__":
  88     unittest.main()