src/bigint_presentation_code/test_toom_cook.py

   1 import unittest
   2
   3 from bigint_presentation_code.compiler_ir import (GPR_SIZE_IN_BYTES, SSAGPR, VL, FixedGPRRangeType, Fn,
   4                                                   GlobalMem, GPRRange,
   5                                                   GPRRangeType, OpCopy,
   6                                                   OpFuncArg, OpInputMem,
   7                                                   OpSetVLImm, OpStore, PreRASimState, SSAGPRRange, XERBit,
   8                                                   generate_assembly)
   9 from bigint_presentation_code.register_allocator import allocate_registers
  10 from bigint_presentation_code.toom_cook import ToomCookInstance, simple_mul
  11 from bigint_presentation_code.util import FMap
  12
  13
  14 class SimpleMul192x192:
  15     def __init__(self):
  16         self.fn = fn = Fn()
  17         self.mem_in = mem = OpInputMem(fn).out
  18         self.dest_ptr_in = OpFuncArg(fn, FixedGPRRangeType(GPRRange(3))).out
  19         self.lhs_in = OpFuncArg(fn, FixedGPRRangeType(GPRRange(4, 3))).out
  20         self.rhs_in = OpFuncArg(fn, FixedGPRRangeType(GPRRange(7, 3))).out
  21         dest_ptr = OpCopy(fn, self.dest_ptr_in, GPRRangeType()).dest
  22         vl = OpSetVLImm(fn, 3).out
  23         lhs = OpCopy(fn, self.lhs_in, GPRRangeType(3), vl=vl).dest
  24         rhs = OpCopy(fn, self.rhs_in, GPRRangeType(3), vl=vl).dest
  25         retval = simple_mul(fn, lhs, rhs)
  26         vl = OpSetVLImm(fn, 6).out
  27         self.mem_out = OpStore(fn, RS=retval, RA=dest_ptr, offset=0,
  28                                mem_in=mem, vl=vl).mem_out
  29
  30
  31 class TestToomCook(unittest.TestCase):
  32     maxDiff = None
  33
  34     def test_toom_2_repr(self):
  35         TOOM_2 = ToomCookInstance.make_toom_2()
  36         # print(repr(repr(TOOM_2)))
  37         self.assertEqual(
  38             repr(TOOM_2),
  39             "ToomCookInstance(lhs_part_count=2, rhs_part_count=2, "
  40             "eval_points=(0, 1, POINT_AT_INFINITY), "
  41             "lhs_eval_ops=("
  42             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  43             "EvalOpAdd(lhs="
  44             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  45             "rhs="
  46             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
  47             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(1, 1)})), "
  48             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)}))),"
  49             " rhs_eval_ops=("
  50             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  51             "EvalOpAdd(lhs="
  52             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  53             "rhs="
  54             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
  55             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(1, 1)})), "
  56             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)}))),"
  57             " prod_eval_ops=("
  58             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  59             "EvalOpSub(lhs="
  60             "EvalOpSub(lhs="
  61             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
  62             "rhs="
  63             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  64             "poly=EvalOpPoly({0: Fraction(-1, 1), 1: Fraction(1, 1)})), "
  65             "rhs="
  66             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
  67             "poly=EvalOpPoly({"
  68             "0: Fraction(-1, 1), 1: Fraction(1, 1), 2: Fraction(-1, 1)})), "
  69             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)}))))"
  70         )
  71
  72     def test_toom_2_5_repr(self):
  73         TOOM_2_5 = ToomCookInstance.make_toom_2_5()
  74         # print(repr(repr(TOOM_2_5)))
  75         self.assertEqual(
  76             repr(TOOM_2_5),
  77             "ToomCookInstance(lhs_part_count=3, rhs_part_count=2, "
  78             "eval_points=(0, 1, -1, POINT_AT_INFINITY), lhs_eval_ops=("
  79             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  80             "EvalOpAdd(lhs="
  81             "EvalOpAdd(lhs="
  82             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  83             "rhs=EvalOpInput(lhs=2, rhs=0, "
  84             "poly=EvalOpPoly({2: Fraction(1, 1)})), "
  85             "poly=EvalOpPoly({0: Fraction(1, 1), 2: Fraction(1, 1)})), "
  86             "rhs=EvalOpInput(lhs=1, rhs=0, "
  87             "poly=EvalOpPoly({1: Fraction(1, 1)})), "
  88             "poly=EvalOpPoly({"
  89             "0: Fraction(1, 1), 1: Fraction(1, 1), 2: Fraction(1, 1)})), "
  90             "EvalOpSub(lhs="
  91             "EvalOpAdd(lhs="
  92             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
  93             "rhs=EvalOpInput(lhs=2, rhs=0, "
  94             "poly=EvalOpPoly({2: Fraction(1, 1)})), "
  95             "poly=EvalOpPoly({0: Fraction(1, 1), 2: Fraction(1, 1)})), "
  96             "rhs=EvalOpInput(lhs=1, rhs=0, "
  97             "poly=EvalOpPoly({1: Fraction(1, 1)})), poly=EvalOpPoly("
  98             "{0: Fraction(1, 1), 1: Fraction(-1, 1), 2: Fraction(1, 1)})), "
  99             "EvalOpInput(lhs=2, rhs=0, "
 100             "poly=EvalOpPoly({2: Fraction(1, 1)}))), rhs_eval_ops=("
 101             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 102             "EvalOpAdd(lhs=EvalOpInput(lhs=0, rhs=0, "
 103             "poly=EvalOpPoly({0: Fraction(1, 1)})), rhs="
 104             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 105             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(1, 1)})), "
 106             "EvalOpSub(lhs="
 107             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 108             "rhs=EvalOpInput(lhs=1, rhs=0, "
 109             "poly=EvalOpPoly({1: Fraction(1, 1)})), "
 110             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(-1, 1)})), "
 111             "EvalOpInput(lhs=1, rhs=0, "
 112             "poly=EvalOpPoly({1: Fraction(1, 1)}))), "
 113             "prod_eval_ops=("
 114             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 115             "EvalOpSub(lhs=EvalOpExactDiv(lhs=EvalOpSub(lhs="
 116             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 117             "rhs=EvalOpInput(lhs=2, rhs=0, "
 118             "poly=EvalOpPoly({2: Fraction(1, 1)})), "
 119             "poly=EvalOpPoly({1: Fraction(1, 1), 2: Fraction(-1, 1)})), "
 120             "rhs=2, "
 121             "poly=EvalOpPoly({1: Fraction(1, 2), 2: Fraction(-1, 2)})), rhs="
 122             "EvalOpInput(lhs=3, rhs=0, poly=EvalOpPoly({3: Fraction(1, 1)})), "
 123             "poly=EvalOpPoly("
 124             "{1: Fraction(1, 2), 2: Fraction(-1, 2), 3: Fraction(-1, 1)})), "
 125             "EvalOpSub(lhs=EvalOpExactDiv(lhs=EvalOpAdd(lhs="
 126             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 127             "rhs="
 128             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
 129             "poly=EvalOpPoly({1: Fraction(1, 1), 2: Fraction(1, 1)})), rhs=2, "
 130             "poly=EvalOpPoly({1: Fraction(1, 2), 2: Fraction(1, 2)})), rhs="
 131             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 132             "poly=EvalOpPoly("
 133             "{0: Fraction(-1, 1), 1: Fraction(1, 2), 2: Fraction(1, 2)})), "
 134             "EvalOpInput(lhs=3, rhs=0, poly=EvalOpPoly({3: Fraction(1, 1)}))))"
 135         )
 136
 137     def test_reversed_toom_2_5_repr(self):
 138         TOOM_2_5 = ToomCookInstance.make_toom_2_5().reversed()
 139         # print(repr(repr(TOOM_2_5)))
 140         self.assertEqual(
 141             repr(TOOM_2_5),
 142             "ToomCookInstance(lhs_part_count=2, rhs_part_count=3, "
 143             "eval_points=(0, 1, -1, POINT_AT_INFINITY), lhs_eval_ops=("
 144             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 145             "EvalOpAdd(lhs="
 146             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 147             "rhs="
 148             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 149             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(1, 1)})), "
 150             "EvalOpSub(lhs="
 151             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 152             "rhs="
 153             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 154             "poly=EvalOpPoly({0: Fraction(1, 1), 1: Fraction(-1, 1)})), "
 155             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)}))),"
 156             " rhs_eval_ops=("
 157             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 158             "EvalOpAdd(lhs=EvalOpAdd(lhs="
 159             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 160             "rhs="
 161             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
 162             "poly=EvalOpPoly({0: Fraction(1, 1), 2: Fraction(1, 1)})), rhs="
 163             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 164             "poly=EvalOpPoly("
 165             "{0: Fraction(1, 1), 1: Fraction(1, 1), 2: Fraction(1, 1)})), "
 166             "EvalOpSub(lhs=EvalOpAdd(lhs="
 167             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 168             "rhs="
 169             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
 170             "poly=EvalOpPoly({0: Fraction(1, 1), 2: Fraction(1, 1)})), rhs="
 171             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 172             "poly=EvalOpPoly("
 173             "{0: Fraction(1, 1), 1: Fraction(-1, 1), 2: Fraction(1, 1)})), "
 174             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)}))),"
 175             " prod_eval_ops=("
 176             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 177             "EvalOpSub(lhs=EvalOpExactDiv(lhs=EvalOpSub(lhs="
 178             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 179             "rhs="
 180             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
 181             "poly=EvalOpPoly({1: Fraction(1, 1), 2: Fraction(-1, 1)})), "
 182             "rhs=2, "
 183             "poly=EvalOpPoly({1: Fraction(1, 2), 2: Fraction(-1, 2)})), rhs="
 184             "EvalOpInput(lhs=3, rhs=0, poly=EvalOpPoly({3: Fraction(1, 1)})), "
 185             "poly=EvalOpPoly("
 186             "{1: Fraction(1, 2), 2: Fraction(-1, 2), 3: Fraction(-1, 1)})), "
 187             "EvalOpSub(lhs=EvalOpExactDiv(lhs=EvalOpAdd(lhs="
 188             "EvalOpInput(lhs=1, rhs=0, poly=EvalOpPoly({1: Fraction(1, 1)})), "
 189             "rhs="
 190             "EvalOpInput(lhs=2, rhs=0, poly=EvalOpPoly({2: Fraction(1, 1)})), "
 191             "poly=EvalOpPoly({1: Fraction(1, 1), 2: Fraction(1, 1)})), rhs=2, "
 192             "poly=EvalOpPoly({1: Fraction(1, 2), 2: Fraction(1, 2)})), rhs="
 193             "EvalOpInput(lhs=0, rhs=0, poly=EvalOpPoly({0: Fraction(1, 1)})), "
 194             "poly=EvalOpPoly("
 195             "{0: Fraction(-1, 1), 1: Fraction(1, 2), 2: Fraction(1, 2)})), "
 196             "EvalOpInput(lhs=3, rhs=0, poly=EvalOpPoly({3: Fraction(1, 1)}))))"
 197         )
 198
 199     def test_simple_mul_192x192_pre_ra_sim(self):
 200         # test multiplying:
 201         #   0x000191acb262e15b_4c6b5f2b19e1a53e_821a2342132c5b57
 202         # * 0x4a37c0567bcbab53_cf1f597598194ae6_208a49071aeec507
 203         # ==
 204         # int("0x00074736574206e_6f69746163696c70"
 205         #     "_69746c756d207469_622d3438333e2d32"
 206         #     "_3931783239312079_7261727469627261", base=0)
 207         # == int.from_bytes(b"arbitrary 192x192->384-bit multiplication test",
 208         #                   'little')
 209         code = SimpleMul192x192()
 210         dest_ptr = 0x100
 211         state = PreRASimState(
 212             gprs={}, VLs={}, CAs={}, global_mems={code.mem_in: FMap()},
 213             stack_slots={}, fixed_gprs={
 214                 code.dest_ptr_in: (dest_ptr,),
 215                 code.lhs_in: (0x821a2342132c5b57, 0x4c6b5f2b19e1a53e,
 216                               0x000191acb262e15b),
 217                 code.rhs_in: (0x208a49071aeec507, 0xcf1f597598194ae6,
 218                               0x4a37c0567bcbab53)
 219             })
 220         code.fn.pre_ra_sim(state)
 221         expected_bytes = b"arbitrary 192x192->384-bit multiplication test"
 222         OUT_BYTE_COUNT = 6 * GPR_SIZE_IN_BYTES
 223         expected_bytes = expected_bytes.ljust(OUT_BYTE_COUNT, b'\0')
 224         mem_out = state.global_mems[code.mem_out]
 225         out_bytes = bytes(
 226             mem_out.get(dest_ptr + i, 0) for i in range(OUT_BYTE_COUNT))
 227         self.assertEqual(out_bytes, expected_bytes)
 228
 229     def test_simple_mul_192x192_ops(self):
 230         code = SimpleMul192x192()
 231         fn = code.fn
 232         self.assertEqual([repr(v) for v in fn.ops], [
 233             'OpInputMem(#0, <#0.out: GlobalMemType()>)',
 234             'OpFuncArg(#1, <#1.out: <fixed(<r3>)>>)',
 235             'OpFuncArg(#2, <#2.out: <fixed(<r4..len=3>)>>)',
 236             'OpFuncArg(#3, <#3.out: <fixed(<r7..len=3>)>>)',
 237             'OpCopy(#4, <#4.dest: <gpr_ty[1]>>, src=<#1.out: <fixed(<r3>)>>, '
 238             'vl=None)',
 239             'OpSetVLImm(#5, <#5.out: KnownVLType(length=3)>)',
 240             'OpCopy(#6, <#6.dest: <gpr_ty[3]>>, '
 241             'src=<#2.out: <fixed(<r4..len=3>)>>, '
 242             'vl=<#5.out: KnownVLType(length=3)>)',
 243             'OpCopy(#7, <#7.dest: <gpr_ty[3]>>, '
 244             'src=<#3.out: <fixed(<r7..len=3>)>>, '
 245             'vl=<#5.out: KnownVLType(length=3)>)',
 246             'OpSplit(#8, results=(<#8.results[0]: <gpr_ty[1]>>, '
 247             '<#8.results[1]: <gpr_ty[1]>>, <#8.results[2]: <gpr_ty[1]>>), '
 248             'src=<#7.dest: <gpr_ty[3]>>)',
 249             'OpSetVLImm(#9, <#9.out: KnownVLType(length=3)>)',
 250             'OpLI(#10, <#10.out: <gpr_ty[1]>>, value=0, vl=None)',
 251             'OpBigIntMulDiv(#11, <#11.RT: <gpr_ty[3]>>, '
 252             'RA=<#6.dest: <gpr_ty[3]>>, RB=<#8.results[0]: <gpr_ty[1]>>, '
 253             'RC=<#10.out: <gpr_ty[1]>>, <#11.RS: <gpr_ty[1]>>, is_div=False, '
 254             'vl=<#9.out: KnownVLType(length=3)>)',
 255             'OpConcat(#12, <#12.dest: <gpr_ty[4]>>, sources=('
 256             '<#11.RT: <gpr_ty[3]>>, <#11.RS: <gpr_ty[1]>>))',
 257             'OpBigIntMulDiv(#13, <#13.RT: <gpr_ty[3]>>, '
 258             'RA=<#6.dest: <gpr_ty[3]>>, RB=<#8.results[1]: <gpr_ty[1]>>, '
 259             'RC=<#10.out: <gpr_ty[1]>>, <#13.RS: <gpr_ty[1]>>, is_div=False, '
 260             'vl=<#9.out: KnownVLType(length=3)>)',
 261             'OpSplit(#14, results=(<#14.results[0]: <gpr_ty[1]>>, '
 262             '<#14.results[1]: <gpr_ty[3]>>), src=<#12.dest: <gpr_ty[4]>>)',
 263             'OpSetCA(#15, <#15.out: CAType()>, value=False)',
 264             'OpBigIntAddSub(#16, <#16.out: <gpr_ty[3]>>, '
 265             'lhs=<#13.RT: <gpr_ty[3]>>, rhs=<#14.results[1]: <gpr_ty[3]>>, '
 266             'CA_in=<#15.out: CAType()>, <#16.CA_out: CAType()>, is_sub=False, '
 267             'vl=<#9.out: KnownVLType(length=3)>)',
 268             'OpBigIntAddSub(#17, <#17.out: <gpr_ty[1]>>, '
 269             'lhs=<#13.RS: <gpr_ty[1]>>, rhs=<#10.out: <gpr_ty[1]>>, '
 270             'CA_in=<#16.CA_out: CAType()>, <#17.CA_out: CAType()>, '
 271             'is_sub=False, vl=None)',
 272             'OpConcat(#18, <#18.dest: <gpr_ty[5]>>, sources=('
 273             '<#14.results[0]: <gpr_ty[1]>>, <#16.out: <gpr_ty[3]>>, '
 274             '<#17.out: <gpr_ty[1]>>))',
 275             'OpBigIntMulDiv(#19, <#19.RT: <gpr_ty[3]>>, '
 276             'RA=<#6.dest: <gpr_ty[3]>>, RB=<#8.results[2]: <gpr_ty[1]>>, '
 277             'RC=<#10.out: <gpr_ty[1]>>, <#19.RS: <gpr_ty[1]>>, is_div=False, '
 278             'vl=<#9.out: KnownVLType(length=3)>)',
 279             'OpSplit(#20, results=(<#20.results[0]: <gpr_ty[2]>>, '
 280             '<#20.results[1]: <gpr_ty[3]>>), src=<#18.dest: <gpr_ty[5]>>)',
 281             'OpSetCA(#21, <#21.out: CAType()>, value=False)',
 282             'OpBigIntAddSub(#22, <#22.out: <gpr_ty[3]>>, '
 283             'lhs=<#19.RT: <gpr_ty[3]>>, rhs=<#20.results[1]: <gpr_ty[3]>>, '
 284             'CA_in=<#21.out: CAType()>, <#22.CA_out: CAType()>, is_sub=False, '
 285             'vl=<#9.out: KnownVLType(length=3)>)',
 286             'OpBigIntAddSub(#23, <#23.out: <gpr_ty[1]>>, '
 287             'lhs=<#19.RS: <gpr_ty[1]>>, rhs=<#10.out: <gpr_ty[1]>>, '
 288             'CA_in=<#22.CA_out: CAType()>, <#23.CA_out: CAType()>, '
 289             'is_sub=False, vl=None)',
 290             'OpConcat(#24, <#24.dest: <gpr_ty[6]>>, sources=('
 291             '<#20.results[0]: <gpr_ty[2]>>, <#22.out: <gpr_ty[3]>>, '
 292             '<#23.out: <gpr_ty[1]>>))',
 293             'OpSetVLImm(#25, <#25.out: KnownVLType(length=6)>)',
 294             'OpStore(#26, RS=<#24.dest: <gpr_ty[6]>>, '
 295             'RA=<#4.dest: <gpr_ty[1]>>, offset=0, '
 296             'mem_in=<#0.out: GlobalMemType()>, '
 297             '<#26.mem_out: GlobalMemType()>, '
 298             'vl=<#25.out: KnownVLType(length=6)>)'
 299         ])
 300
 301     # FIXME: register allocator currently allocates wrong registers
 302     @unittest.expectedFailure
 303     def test_simple_mul_192x192_reg_alloc(self):
 304         code = SimpleMul192x192()
 305         fn = code.fn
 306         assigned_registers = allocate_registers(fn.ops)
 307         self.assertEqual(assigned_registers, {
 308             fn.ops[13].RS: GPRRange(9),  # type: ignore
 309             fn.ops[14].results[0]: GPRRange(6),  # type: ignore
 310             fn.ops[14].results[1]: GPRRange(7, length=3),  # type: ignore
 311             fn.ops[15].out: XERBit.CA,  # type: ignore
 312             fn.ops[16].out: GPRRange(7, length=3),  # type: ignore
 313             fn.ops[16].CA_out: XERBit.CA,  # type: ignore
 314             fn.ops[17].out: GPRRange(10),  # type: ignore
 315             fn.ops[17].CA_out: XERBit.CA,  # type: ignore
 316             fn.ops[18].dest: GPRRange(6, length=5),  # type: ignore
 317             fn.ops[19].RT: GPRRange(3, length=3),  # type: ignore
 318             fn.ops[19].RS: GPRRange(9),  # type: ignore
 319             fn.ops[20].results[0]: GPRRange(6, length=2),  # type: ignore
 320             fn.ops[20].results[1]: GPRRange(8, length=3),  # type: ignore
 321             fn.ops[21].out: XERBit.CA,  # type: ignore
 322             fn.ops[22].out: GPRRange(8, length=3),  # type: ignore
 323             fn.ops[22].CA_out: XERBit.CA,  # type: ignore
 324             fn.ops[23].out: GPRRange(11),  # type: ignore
 325             fn.ops[23].CA_out: XERBit.CA,  # type: ignore
 326             fn.ops[24].dest: GPRRange(6, length=6),  # type: ignore
 327             fn.ops[25].out: VL.VL_MAXVL,  # type: ignore
 328             fn.ops[26].mem_out: GlobalMem.GlobalMem,  # type: ignore
 329             fn.ops[0].out: GlobalMem.GlobalMem,  # type: ignore
 330             fn.ops[1].out: GPRRange(3),  # type: ignore
 331             fn.ops[2].out: GPRRange(4, length=3),  # type: ignore
 332             fn.ops[3].out: GPRRange(7, length=3),  # type: ignore
 333             fn.ops[4].dest: GPRRange(12),  # type: ignore
 334             fn.ops[5].out: VL.VL_MAXVL,  # type: ignore
 335             fn.ops[6].dest: GPRRange(17, length=3),  # type: ignore
 336             fn.ops[7].dest: GPRRange(14, length=3),  # type: ignore
 337             fn.ops[8].results[0]: GPRRange(14),  # type: ignore
 338             fn.ops[8].results[1]: GPRRange(15),  # type: ignore
 339             fn.ops[8].results[2]: GPRRange(16),  # type: ignore
 340             fn.ops[9].out: VL.VL_MAXVL,  # type: ignore
 341             fn.ops[10].out: GPRRange(9),  # type: ignore
 342             fn.ops[11].RT: GPRRange(6, length=3),  # type: ignore
 343             fn.ops[11].RS: GPRRange(9),  # type: ignore
 344             fn.ops[12].dest: GPRRange(6, length=4),  # type: ignore
 345             fn.ops[13].RT: GPRRange(3, length=3)  # type: ignore
 346         })
 347         self.fail("register allocator currently allocates wrong registers")
 348
 349     # FIXME: register allocator currently allocates wrong registers
 350     @unittest.expectedFailure
 351     def test_simple_mul_192x192_asm(self):
 352         code = SimpleMul192x192()
 353         asm = generate_assembly(code.fn.ops)
 354         self.assertEqual(asm, [
 355             'or 12, 3, 3',
 356             'setvl 0, 0, 3, 0, 1, 1',
 357             'sv.or *17, *4, *4',
 358             'sv.or *14, *7, *7',
 359             'setvl 0, 0, 3, 0, 1, 1',
 360             'addi 9, 0, 0',
 361             'sv.maddedu *6, *17, 14, 9',
 362             'sv.maddedu *3, *17, 15, 9',
 363             'addic 0, 0, 0',
 364             'sv.adde *7, *3, *7',
 365             'adde 10, 9, 9',
 366             'sv.maddedu *3, *17, 16, 9',
 367             'addic 0, 0, 0',
 368             'sv.adde *8, *3, *8',
 369             'adde 11, 9, 9',
 370             'setvl 0, 0, 6, 0, 1, 1',
 371             'sv.std *6, 0(12)',
 372             'bclr 20, 0, 0'
 373         ])
 374         self.fail("register allocator currently allocates wrong registers")
 375
 376
 377 if __name__ == "__main__":
 378     unittest.main()