PageRenderTime 1308ms CodeModel.GetById 11ms RepoModel.GetById 1ms app.codeStats 0ms

/rpython/jit/backend/arm/test/test_regalloc.py

https://bitbucket.org/pypy/pypy/
Python | 796 lines | 758 code | 35 blank | 3 comment | 3 complexity | c231b510288da04915d264d262005050 MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0 
    

  1. 

  2. """ Tests for register allocation for common constructs
    3. 

  3. """
    4. 

    5. 

  5. import py
    6. 

  6. from rpython.jit.metainterp.history import (BasicFailDescr,
    7. 

  7.                                         BasicFinalDescr,
    8. 

  8.                                         JitCellToken,
    9. 

  9.                                         TargetToken)
    10. 

  10. from rpython.jit.metainterp.resoperation import rop
    11. 

  11. from rpython.jit.backend.llsupport.descr import GcCache
    12. 

  12. from rpython.jit.backend.detect_cpu import getcpuclass
    13. 

  13. from rpython.jit.backend.arm.regalloc import Regalloc, ARMFrameManager
    14. 

  14. from rpython.jit.backend.llsupport.regalloc import is_comparison_or_ovf_op
    15. 

  15. from rpython.jit.tool.oparser import parse
    16. 

  16. from rpython.rtyper.lltypesystem import lltype, llmemory
    17. 

  17. from rpython.rtyper.annlowlevel import llhelper
    18. 

  18. from rpython.rtyper.lltypesystem import rstr
    19. 

  19. from rpython.rtyper import rclass
    20. 

  20. from rpython.jit.codewriter.effectinfo import EffectInfo
    21. 

  21. from rpython.jit.codewriter import longlong
    22. 

  22. from rpython.jit.backend.llsupport.test.test_regalloc_integration import BaseTestRegalloc
    23. 

  23. 

  24. 

  25. def test_is_comparison_or_ovf_op():
    26. 

  26.     assert not is_comparison_or_ovf_op(rop.INT_ADD)
    27. 

  27.     assert is_comparison_or_ovf_op(rop.INT_ADD_OVF)
    28. 

  28.     assert is_comparison_or_ovf_op(rop.INT_EQ)
    29. 

  29. 

  30. CPU = getcpuclass()
    31. 

  31. 

  32. 

  33. class MockGcDescr(GcCache):
    34. 

  34.     def get_funcptr_for_new(self):
    35. 

  35.         return 123
    36. 

  36.     get_funcptr_for_newarray = get_funcptr_for_new
    37. 

  37.     get_funcptr_for_newstr = get_funcptr_for_new
    38. 

  38.     get_funcptr_for_newunicode = get_funcptr_for_new
    39. 

  39. 

  40.     def rewrite_assembler(self, cpu, operations):
    41. 

  41.         pass
    42. 

  42. 

  43. 

  44. class MockAssembler(object):
    45. 

  45.     gcrefs = None
    46. 

  46.     _float_constants = None
    47. 

  47. 

  48.     def __init__(self, cpu=None, gc_ll_descr=None):
    49. 

  49.         self.movs = []
    50. 

  50.         self.performs = []
    51. 

  51.         self.lea = []
    52. 

  52.         if cpu is None:
    53. 

  53.             cpu = CPU(None, None)
    54. 

  54.             cpu.setup_once()
    55. 

  55.         self.cpu = cpu
    56. 

  56.         if gc_ll_descr is None:
    57. 

  57.             gc_ll_descr = MockGcDescr(False)
    58. 

  58.         self.cpu.gc_ll_descr = gc_ll_descr
    59. 

  59. 

  60.     def dump(self, *args):
    61. 

  61.         pass
    62. 

  62. 

  63.     def regalloc_mov(self, from_loc, to_loc):
    64. 

  64.         self.movs.append((from_loc, to_loc))
    65. 

  65. 

  66.     def regalloc_perform(self, op, arglocs, resloc):
    67. 

  67.         self.performs.append((op, arglocs, resloc))
    68. 

  68. 

  69.     def regalloc_perform_discard(self, op, arglocs):
    70. 

  70.         self.performs.append((op, arglocs))
    71. 

  71. 

  72.     def load_effective_addr(self, *args):
    73. 

  73.         self.lea.append(args)
    74. 

  74. 

  75. 

  76. class RegAllocForTests(Regalloc):
    77. 

  77.     position = 0
    78. 

  78. 

  79.     def _compute_next_usage(self, v, _):
    80. 

  80.         return -1
    81. 

  81. 

  82. 

  83. def get_zero_division_error(self):
    84. 

  84.     # for tests, a random emulated ll_inst will do
    85. 

  85.     ll_inst = lltype.malloc(rclass.OBJECT)
    86. 

  86.     ll_inst.typeptr = lltype.malloc(rclass.OBJECT_VTABLE,
    87. 

  87.                                     immortal=True)
    88. 

  88.     _zer_error_vtable = llmemory.cast_ptr_to_adr(ll_inst.typeptr)
    89. 

  89.     zer_vtable = self.cast_adr_to_int(_zer_error_vtable)
    90. 

  90.     zer_inst = lltype.cast_opaque_ptr(llmemory.GCREF, ll_inst)
    91. 

  91.     return zer_vtable, zer_inst
    92. 

  92. 

  93. 

  94. class CustomBaseTestRegalloc(BaseTestRegalloc):
    95. 

  95.     cpu = CPU(None, None)
    96. 

  96.     cpu.setup_once()
    97. 

  97. 

  98.     def raising_func(i):
    99. 

  99.         if i:
    100. 

  100.             raise LLException(zero_division_error,
    101. 

  101.                               zero_division_value)
    102. 

  102.     FPTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Void))
    103. 

  103.     raising_fptr = llhelper(FPTR, raising_func)
    104. 

  104. 

  105.     def f(a):
    106. 

  106.         return 23
    107. 

  107. 

  108.     FPTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
    109. 

  109.     f_fptr = llhelper(FPTR, f)
    110. 

  110.     f_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT,
    111. 

  111.                                                     EffectInfo.MOST_GENERAL)
    112. 

  112. 

  113.     zero_division_tp, zero_division_value = get_zero_division_error(cpu)
    114. 

  114.     zd_addr = cpu.cast_int_to_adr(zero_division_tp)
    115. 

  115.     zero_division_error = llmemory.cast_adr_to_ptr(zd_addr,
    116. 

  116.                                             lltype.Ptr(rclass.OBJECT_VTABLE))
    117. 

  117.     raising_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT,
    118. 

  118.                                                     EffectInfo.MOST_GENERAL)
    119. 

  119. 

  120.     targettoken = TargetToken()
    121. 

  121.     targettoken2 = TargetToken()
    122. 

  122.     fdescr1 = BasicFailDescr(1)
    123. 

  123.     fdescr2 = BasicFailDescr(2)
    124. 

  124.     fdescr3 = BasicFailDescr(3)
    125. 

  125. 

  126.     def setup_method(self, meth):
    127. 

  127.         self.targettoken._ll_loop_code = 0
    128. 

  128.         self.targettoken2._ll_loop_code = 0
    129. 

  129. 

  130.     def f1(x):
    131. 

  131.         return x + 1
    132. 

  132. 

  133.     def f2(x, y):
    134. 

  134.         return x * y
    135. 

  135. 

  136.     def f10(*args):
    137. 

  137.         assert len(args) == 10
    138. 

  138.         return sum(args)
    139. 

  139. 

  140.     F1PTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
    141. 

  141.     F2PTR = lltype.Ptr(lltype.FuncType([lltype.Signed] * 2, lltype.Signed))
    142. 

  142.     F10PTR = lltype.Ptr(lltype.FuncType([lltype.Signed] * 10, lltype.Signed))
    143. 

  143.     f1ptr = llhelper(F1PTR, f1)
    144. 

  144.     f2ptr = llhelper(F2PTR, f2)
    145. 

  145.     f10ptr = llhelper(F10PTR, f10)
    146. 

  146. 

  147.     f1_calldescr = cpu.calldescrof(F1PTR.TO, F1PTR.TO.ARGS, F1PTR.TO.RESULT,
    148. 

  148.                                                     EffectInfo.MOST_GENERAL)
    149. 

  149.     f2_calldescr = cpu.calldescrof(F2PTR.TO, F2PTR.TO.ARGS, F2PTR.TO.RESULT,
    150. 

  150.                                                     EffectInfo.MOST_GENERAL)
    151. 

  151.     f10_calldescr = cpu.calldescrof(F10PTR.TO, F10PTR.TO.ARGS,
    152. 

  152.                                     F10PTR.TO.RESULT, EffectInfo.MOST_GENERAL)
    153. 

  153.     typesystem = 'lltype'
    154. 

  154.     namespace = locals().copy()
    155. 

  155. 

  156. class TestRegallocSimple(CustomBaseTestRegalloc):
    157. 

  157.     def test_simple_loop(self):
    158. 

  158.         ops = '''
    159. 

  159.         [i0]
    160. 

  160.         label(i0, descr=targettoken)
    161. 

  161.         i1 = int_add(i0, 1)
    162. 

  162.         i2 = int_lt(i1, 20)
    163. 

  163.         guard_true(i2) [i1]
    164. 

  164.         jump(i1, descr=targettoken)
    165. 

  165.         '''
    166. 

  166.         self.interpret(ops, [0])
    167. 

  167.         assert self.getint(0) == 20
    168. 

  168. 

  169.     def test_two_loops_and_a_bridge(self):
    170. 

  170.         ops = '''
    171. 

  171.         [i0, i1, i2, i3]
    172. 

  172.         label(i0, i1, i2, i3, descr=targettoken)
    173. 

  173.         i4 = int_add(i0, 1)
    174. 

  174.         i5 = int_lt(i4, 20)
    175. 

  175.         guard_true(i5) [i4, i1, i2, i3]
    176. 

  176.         jump(i4, i1, i2, i3, descr=targettoken)
    177. 

  177.         '''
    178. 

  178.         loop = self.interpret(ops, [0, 0, 0, 0])
    179. 

  179.         ops2 = '''
    180. 

  180.         [i5, i6, i7, i8]
    181. 

  181.         label(i5, descr=targettoken2)
    182. 

  182.         i1 = int_add(i5, 1)
    183. 

  183.         i3 = int_add(i1, 1)
    184. 

  184.         i4 = int_add(i3, 1)
    185. 

  185.         i2 = int_lt(i4, 30)
    186. 

  186.         guard_true(i2) [i4]
    187. 

  187.         jump(i4, descr=targettoken2)
    188. 

  188.         '''
    189. 

  189.         loop2 = self.interpret(ops2, [0, 0, 0, 0])
    190. 

  190.         bridge_ops = '''
    191. 

  191.         [i4]
    192. 

  192.         jump(i4, i4, i4, i4, descr=targettoken)
    193. 

  193.         '''
    194. 

  194.         bridge = self.attach_bridge(bridge_ops, loop2, 5)
    195. 

  195.         self.run(loop2, 0, 0, 0, 0)
    196. 

  196.         assert self.getint(0) == 31
    197. 

  197.         assert self.getint(1) == 30
    198. 

  198.         assert self.getint(2) == 30
    199. 

  199.         assert self.getint(3) == 30
    200. 

  200. 

  201.     def test_pointer_arg(self):
    202. 

  202.         ops = '''
    203. 

  203.         [i0, p0]
    204. 

  204.         label(i0, p0, descr=targettoken)
    205. 

  205.         i1 = int_add(i0, 1)
    206. 

  206.         i2 = int_lt(i1, 10)
    207. 

  207.         guard_true(i2) [p0]
    208. 

  208.         jump(i1, p0, descr=targettoken)
    209. 

  209.         '''
    210. 

  210.         S = lltype.GcStruct('S')
    211. 

  211.         ptr = lltype.malloc(S)
    212. 

  212.         self.interpret(ops, [0, ptr])
    213. 

  213.         assert self.getptr(0, lltype.Ptr(S)) == ptr
    214. 

  214. 

  215.     def test_exception_bridge_no_exception(self):
    216. 

  216.         ops = '''
    217. 

  217.         [i0]
    218. 

  218.         i1 = same_as_i(1)
    219. 

  219.         call_n(ConstClass(raising_fptr), i0, descr=raising_calldescr)
    220. 

  220.         guard_exception(ConstClass(zero_division_error)) [i1]
    221. 

  221.         finish(0)
    222. 

  222.         '''
    223. 

  223.         bridge_ops = '''
    224. 

  224.         [i3]
    225. 

  225.         i2 = same_as_i(2)
    226. 

  226.         guard_no_exception() [i2]
    227. 

  227.         finish(1)
    228. 

  228.         '''
    229. 

  229.         loop = self.interpret(ops, [0])
    230. 

  230.         assert self.getint(0) == 1
    231. 

  231.         bridge = self.attach_bridge(bridge_ops, loop, 2)
    232. 

  232.         self.run(loop, 0)
    233. 

  233.         assert self.getint(0) == 1
    234. 

  234. 

  235.     def test_inputarg_unused(self):
    236. 

  236.         ops = '''
    237. 

  237.         [i0]
    238. 

  238.         finish(1)
    239. 

  239.         '''
    240. 

  240.         self.interpret(ops, [0])
    241. 

  241.         # assert did not explode
    242. 

  242. 

  243.     def test_nested_guards(self):
    244. 

  244.         ops = '''
    245. 

  245.         [i0, i1]
    246. 

  246.         guard_true(i0) [i0, i1]
    247. 

  247.         finish(4)
    248. 

  248.         '''
    249. 

  249.         bridge_ops = '''
    250. 

  250.         [i0, i1]
    251. 

  251.         guard_true(i0) [i0, i1]
    252. 

  252.         finish(3)
    253. 

  253.         '''
    254. 

  254.         loop = self.interpret(ops, [0, 10])
    255. 

  255.         assert self.getint(0) == 0
    256. 

  256.         assert self.getint(1) == 10
    257. 

  257.         bridge = self.attach_bridge(bridge_ops, loop, 0)
    258. 

  258.         self.run(loop, 0, 10)
    259. 

  259.         assert self.getint(0) == 0
    260. 

  260.         assert self.getint(1) == 10
    261. 

  261. 

  262.     def test_nested_unused_arg(self):
    263. 

  263.         ops = '''
    264. 

  264.         [i0, i1]
    265. 

  265.         guard_true(i0) [i0, i1]
    266. 

  266.         finish(1)
    267. 

  267.         '''
    268. 

  268.         loop = self.interpret(ops, [0, 1])
    269. 

  269.         assert self.getint(0) == 0
    270. 

  270.         bridge_ops = '''
    271. 

  271.         [i0, i1]
    272. 

  272.         guard_true(i0) [i0]
    273. 

  273.         finish(1)
    274. 

  274.         '''
    275. 

  275.         self.attach_bridge(bridge_ops, loop, 0)
    276. 

  276.         self.run(loop, 0, 1)
    277. 

  277. 

  278.     def test_spill_for_constant(self):
    279. 

  279.         ops = '''
    280. 

  280.         [i0, i1, i2, i3]
    281. 

  281.         label(i0, i1, i2, i3, descr=targettoken)
    282. 

  282.         i4 = int_add(3, i1)
    283. 

  283.         i5 = int_lt(i4, 30)
    284. 

  284.         guard_true(i5) [i0, i4, i2, i3]
    285. 

  285.         jump(1, i4, 3, 4, descr=targettoken)
    286. 

  286.         '''
    287. 

  287.         self.interpret(ops, [0, 0, 0, 0])
    288. 

  288.         assert self.getints(4) == [1, 30, 3, 4]
    289. 

  289. 

  290.     def test_spill_for_constant_lshift(self):
    291. 

  291.         ops = '''
    292. 

  292.         [i0, i2, i1, i3]
    293. 

  293.         label(i0, i2, i1, i3, descr=targettoken)
    294. 

  294.         i4 = int_lshift(1, i1)
    295. 

  295.         i5 = int_add(1, i1)
    296. 

  296.         i6 = int_lt(i5, 30)
    297. 

  297.         guard_true(i6) [i4, i5, i2, i3]
    298. 

  298.         jump(i4, 3, i5, 4, descr=targettoken)
    299. 

  299.         '''
    300. 

  300.         self.interpret(ops, [0, 0, 0, 0])
    301. 

  301.         assert self.getints(4) == [1<<29, 30, 3, 4]
    302. 

  302.         ops = '''
    303. 

  303.         [i0, i1, i2, i3]
    304. 

  304.         label(i0, i1, i2, i3, descr=targettoken)
    305. 

  305.         i4 = int_lshift(1, i1)
    306. 

  306.         i5 = int_add(1, i1)
    307. 

  307.         i6 = int_lt(i5, 30)
    308. 

  308.         guard_true(i6) [i4, i5, i2, i3]
    309. 

  309.         jump(i4, i5, 3, 4, descr=targettoken)
    310. 

  310.         '''
    311. 

  311.         self.interpret(ops, [0, 0, 0, 0])
    312. 

  312.         assert self.getints(4) == [1<<29, 30, 3, 4]
    313. 

  313.         ops = '''
    314. 

  314.         [i0, i3, i1, i2]
    315. 

  315.         label(i0, i3, i1, i2, descr=targettoken)
    316. 

  316.         i4 = int_lshift(1, i1)
    317. 

  317.         i5 = int_add(1, i1)
    318. 

  318.         i6 = int_lt(i5, 30)
    319. 

  319.         guard_true(i6) [i4, i5, i2, i3]
    320. 

  320.         jump(i4, 4, i5, 3, descr=targettoken)
    321. 

  321.         '''
    322. 

  322.         self.interpret(ops, [0, 0, 0, 0])
    323. 

  323.         assert self.getints(4) == [1<<29, 30, 3, 4]
    324. 

  324. 

  325.     def test_result_selected_reg_via_neg(self):
    326. 

  326.         ops = '''
    327. 

  327.         [i0, i1, i2, i3]
    328. 

  328.         label(i0, i1, i2, i3, descr=targettoken)
    329. 

  329.         i6 = int_neg(i2)
    330. 

  330.         i7 = int_add(1, i1)
    331. 

  331.         i4 = int_lt(i7, 10)
    332. 

  332.         guard_true(i4) [i0, i6, i7]
    333. 

  333.         jump(1, i7, i2, i6, descr=targettoken)
    334. 

  334.         '''
    335. 

  335.         self.interpret(ops, [0, 0, 3, 0])
    336. 

  336.         assert self.getints(3) == [1, -3, 10]
    337. 

  337. 

  338.     def test_compare_memory_result_survives(self):
    339. 

  339.         ops = '''
    340. 

  340.         [i0, i1, i2, i3]
    341. 

  341.         label(i0, i1, i2, i3, descr=targettoken)
    342. 

  342.         i4 = int_lt(i0, i1)
    343. 

  343.         i5 = int_add(i3, 1)
    344. 

  344.         i6 = int_lt(i5, 30)
    345. 

  345.         guard_true(i6) [i4]
    346. 

  346.         jump(i0, i1, i4, i5, descr=targettoken)
    347. 

  347.         '''
    348. 

  348.         self.interpret(ops, [0, 10, 0, 0])
    349. 

  349.         assert self.getint(0) == 1
    350. 

  350. 

  351.     def test_jump_different_args(self):
    352. 

  352.         ops = '''
    353. 

  353.         [i0, i15, i16, i18, i1, i2, i3]
    354. 

  354.         label(i0, i15, i16, i18, i1, i2, i3, descr=targettoken)
    355. 

  355.         i4 = int_add(i3, 1)
    356. 

  356.         i5 = int_lt(i4, 20)
    357. 

  357.         guard_true(i5) [i2, i1]
    358. 

  358.         jump(i0, i18, i15, i16, i2, i1, i4, descr=targettoken)
    359. 

  359.         '''
    360. 

  360.         self.interpret(ops, [0, 1, 2, 3, 0, 0, 0])
    361. 

  361. 

  362.     def test_op_result_unused(self):
    363. 

  363.         ops = '''
    364. 

  364.         [i0, i1]
    365. 

  365.         i2 = int_add(i0, i1)
    366. 

  366.         finish(0)
    367. 

  367.         '''
    368. 

  368.         self.interpret(ops, [0, 0])
    369. 

  369. 

  370.     def test_guard_value_two_boxes(self):
    371. 

  371.         ops = '''
    372. 

  372.         [i0, i1, i2, i3, i4, i5, i6, i7]
    373. 

  373.         guard_value(i6, i1) [i0, i2, i3, i4, i5, i6]
    374. 

  374.         finish(i0)
    375. 

  375.         '''
    376. 

  376.         self.interpret(ops, [0, 0, 0, 0, 0, 0, 0, 0])
    377. 

  377.         assert self.getint(0) == 0
    378. 

  378. 

  379.     def test_bug_wrong_stack_adj(self):
    380. 

  380.         ops = '''
    381. 

  381.         [i0, i1, i2, i3, i4, i5, i6, i7, i8]
    382. 

  382.         i9 = same_as_i(0)
    383. 

  383.         guard_true(i0) [i9, i0, i1, i2, i3, i4, i5, i6, i7, i8]
    384. 

  384.         finish(1)
    385. 

  385.         '''
    386. 

  386.         loop = self.interpret(ops, [0, 1, 2, 3, 4, 5, 6, 7, 8])
    387. 

  387.         assert self.getint(0) == 0
    388. 

  388.         bridge_ops = '''
    389. 

  389.         [i9, i0, i1, i2, i3, i4, i5, i6, i7, i8]
    390. 

  390.         call_n(ConstClass(raising_fptr), 0, descr=raising_calldescr)
    391. 

  391.         guard_true(i0) [i0, i1, i2, i3, i4, i5, i6, i7, i8]
    392. 

  392.         finish(1)
    393. 

  393.         '''
    394. 

  394.         self.attach_bridge(bridge_ops, loop, 1)
    395. 

  395.         self.run(loop, 0, 1, 2, 3, 4, 5, 6, 7, 8)
    396. 

  396.         assert self.getints(9) == range(9)
    397. 

  397. 

  398.     def test_loopargs(self):
    399. 

  399.         ops = """
    400. 

  400.         [i0, i1, i2, i3]
    401. 

  401.         i4 = int_add(i0, i1)
    402. 

  402.         jump(i4, i1, i2, i3)
    403. 

  403.         """
    404. 

  404.         regalloc = self.prepare_loop(ops)
    405. 

  405.         assert len(regalloc.rm.reg_bindings) == 0
    406. 

  406.         assert len(regalloc.frame_manager.bindings) == 4
    407. 

  407. 

  408.     def test_loopargs_2(self):
    409. 

  409.         ops = """
    410. 

  410.         [i0, i1, i2, i3]
    411. 

  411.         i4 = int_add(i0, i1)
    412. 

  412.         guard_false(i0) [i4, i1, i2, i3]
    413. 

  413.         """
    414. 

  414.         regalloc = self.prepare_loop(ops)
    415. 

  415.         assert len(regalloc.frame_manager.bindings) == 4
    416. 

  416. 

  417.     def test_loopargs_3(self):
    418. 

  418.         ops = """
    419. 

  419.         [i0, i1, i2, i3]
    420. 

  420.         i4 = int_add(i0, i1)
    421. 

  421.         guard_true(i4) [i0, i1, i2, i3, i4]
    422. 

  422.         jump(i4, i1, i2, i3)
    423. 

  423.         """
    424. 

  424.         regalloc = self.prepare_loop(ops)
    425. 

  425.         assert len(regalloc.frame_manager.bindings) == 4
    426. 

  426. 

  427. 

  428. class TestRegallocCompOps(CustomBaseTestRegalloc):
    429. 

  429. 

  430.     def test_cmp_op_0(self):
    431. 

  431.         ops = '''
    432. 

  432.         [i0, i3]
    433. 

  433.         i1 = same_as_i(1)
    434. 

  434.         i2 = int_lt(i0, 100)
    435. 

  435.         guard_true(i3) [i1, i2]
    436. 

  436.         finish(i2)
    437. 

  437.         '''
    438. 

  438.         self.interpret(ops, [0, 1])
    439. 

  439.         assert self.getint(0) == 1
    440. 

  440. 

  441. 

  442. class TestRegallocMoreRegisters(CustomBaseTestRegalloc):
    443. 

  443. 

  444.     cpu = CustomBaseTestRegalloc.cpu
    445. 

  445.     targettoken = TargetToken()
    446. 

  446. 

  447.     S = lltype.GcStruct('S', ('field', lltype.Char))
    448. 

  448.     fielddescr = cpu.fielddescrof(S, 'field')
    449. 

  449. 

  450.     A = lltype.GcArray(lltype.Char)
    451. 

  451.     I = lltype.GcArray(lltype.Signed)
    452. 

  452.     arraydescr = cpu.arraydescrof(A)
    453. 

  453.     arraydescr_i = cpu.arraydescrof(I)
    454. 

  454. 

  455.     namespace = locals().copy()
    456. 

  456. 

  457.     def test_int_is_true(self):
    458. 

  458.         ops = '''
    459. 

  459.         [i0, i1, i2, i3, i4, i5, i6, i7]
    460. 

  460.         i10 = int_is_true(i0)
    461. 

  461.         i11 = int_is_true(i1)
    462. 

  462.         i12 = int_is_true(i2)
    463. 

  463.         i13 = int_is_true(i3)
    464. 

  464.         i14 = int_is_true(i4)
    465. 

  465.         i15 = int_is_true(i5)
    466. 

  466.         i16 = int_is_true(i6)
    467. 

  467.         i17 = int_is_true(i7)
    468. 

  468.         guard_true(i0) [i10, i11, i12, i13, i14, i15, i16, i17]
    469. 

  469.         '''
    470. 

  470.         self.interpret(ops, [0, 42, 12, 0, 13, 0, 0, 3333])
    471. 

  471.         assert self.getints(8) == [0, 1, 1, 0, 1, 0, 0, 1]
    472. 

  472. 

  473.     def test_comparison_ops(self):
    474. 

  474.         ops = '''
    475. 

  475.         [i0, i1, i2, i3, i4, i5, i6]
    476. 

  476.         i10 = int_lt(i0, i1)
    477. 

  477.         i11 = int_le(i2, i3)
    478. 

  478.         i12 = int_ge(i4, i5)
    479. 

  479.         i13 = int_eq(i5, i6)
    480. 

  480.         i14 = int_gt(i6, i2)
    481. 

  481.         i15 = int_ne(i2, i6)
    482. 

  482.         guard_true(i0) [i10, i11, i12, i13, i14, i15]
    483. 

  483. 

  484.         '''
    485. 

  485.         self.interpret(ops, [0, 1, 2, 3, 4, 5, 6])
    486. 

  486.         assert self.getints(6) == [1, 1, 0, 0, 1, 1]
    487. 

  487. 

  488.     def test_strsetitem(self):
    489. 

  489.         ops = '''
    490. 

  490.         [p0, i]
    491. 

  491.         strsetitem(p0, 1, i)
    492. 

  492.         finish()
    493. 

  493.         '''
    494. 

  494.         llstr = rstr.mallocstr(10)
    495. 

  495.         self.interpret(ops, [llstr, ord('a')])
    496. 

  496.         assert llstr.chars[1] == 'a'
    497. 

  497. 

  498.     def test_setfield_char(self):
    499. 

  499.         ops = '''
    500. 

  500.         [p0, i]
    501. 

  501.         setfield_gc(p0, i, descr=fielddescr)
    502. 

  502.         finish()
    503. 

  503.         '''
    504. 

  504.         s = lltype.malloc(self.S)
    505. 

  505.         self.interpret(ops, [s, ord('a')])
    506. 

  506.         assert s.field == 'a'
    507. 

  507. 

  508.     def test_setarrayitem_gc(self):
    509. 

  509.         ops = '''
    510. 

  510.         [p0, i]
    511. 

  511.         setarrayitem_gc(p0, 1, i, descr=arraydescr)
    512. 

  512.         finish()
    513. 

  513.         '''
    514. 

  514.         s = lltype.malloc(self.A, 3)
    515. 

  515.         self.interpret(ops, [s, ord('a')])
    516. 

  516.         assert s[1] == 'a'
    517. 

  517. 

  518.     def test_setarrayitem2_gc(self):
    519. 

  519.         ops = '''
    520. 

  520.         [p0, i, i1]
    521. 

  521.         setarrayitem_gc(p0, i1, i, descr=arraydescr)
    522. 

  522.         finish()
    523. 

  523.         '''
    524. 

  524.         s = lltype.malloc(self.A, 3)
    525. 

  525.         self.interpret(ops, [s, ord('a'), 1])
    526. 

  526.         assert s[1] == 'a'
    527. 

  527. 

  528.     def test_setarrayitem3_gc(self):
    529. 

  529.         ops = '''
    530. 

  530.         [p0, i0, i1]
    531. 

  531.         setarrayitem_gc(p0, i1, i0, descr=arraydescr_i)
    532. 

  532.         finish()
    533. 

  533.         '''
    534. 

  534.         s = lltype.malloc(self.I, 3)
    535. 

  535.         self.interpret(ops, [s, 1234567890, 1])
    536. 

  536.         assert s[1] == 1234567890
    537. 

  537. 

  538.     def test_setarrayitem4_gc(self):
    539. 

  539.         ops = '''
    540. 

  540.         [p0, i0]
    541. 

  541.         setarrayitem_gc(p0, 1, i0, descr=arraydescr_i)
    542. 

  542.         finish()
    543. 

  543.         '''
    544. 

  544.         s = lltype.malloc(self.I, 3)
    545. 

  545.         self.interpret(ops, [s, 1234567890])
    546. 

  546.         assert s[1] == 1234567890
    547. 

  547. 

  548. 

  549. class TestRegallocFloats(CustomBaseTestRegalloc):
    550. 

  550.     def test_float_add(self):
    551. 

  551.         if not self.cpu.supports_floats:
    552. 

  552.             py.test.skip("requires floats")
    553. 

  553.         ops = '''
    554. 

  554.         [f0, f1]
    555. 

  555.         f2 = float_add(f0, f1)
    556. 

  556.         guard_value(f0, f1) [f2, f0, f1]
    557. 

  557.         '''
    558. 

  558.         self.interpret(ops, [3.0, 1.5])
    559. 

  559.         assert self.getfloats(3) == [4.5, 3.0, 1.5]
    560. 

  560. 

  561.     def test_float_adds_stack(self):
    562. 

  562.         if not self.cpu.supports_floats:
    563. 

  563.             py.test.skip("requires floats")
    564. 

  564.         ops = '''
    565. 

  565.         [f0, f1, f2, f3, f4, f5, f6, f7, f8]
    566. 

  566.         f9 = float_add(f0, f1)
    567. 

  567.         f10 = float_add(f8, 3.5)
    568. 

  568.         guard_value(f0, f1) [f9, f10, f2, f3, f4, f5, f6, f7, f8]
    569. 

  569.         '''
    570. 

  570.         self.interpret(ops, [0.1, .2, .3, .4, .5, .6, .7, .8, .9])
    571. 

  571.         assert self.getfloats(9) == [.1 + .2, .9 + 3.5, .3,
    572. 

  572.                                         .4, .5, .6, .7, .8, .9]
    573. 

  573. 

  574.     def test_lt_const(self):
    575. 

  575.         if not self.cpu.supports_floats:
    576. 

  576.             py.test.skip("requires floats")
    577. 

  577.         ops = '''
    578. 

  578.         [f0]
    579. 

  579.         i1 = float_lt(3.5, f0)
    580. 

  580.         finish(i1)
    581. 

  581.         '''
    582. 

  582.         self.interpret(ops, [0.1])
    583. 

  583.         assert self.getint(0) == 0
    584. 

  584. 

  585.     def test_bug_float_is_true_stack(self):
    586. 

  586.         if not self.cpu.supports_floats:
    587. 

  587.             py.test.skip("requires floats")
    588. 

  588.         # NB. float_is_true no longer exists.  Unsure if keeping this test
    589. 

  589.         # makes sense any more.
    590. 

  590.         ops = '''
    591. 

  591.         [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9]
    592. 

  592.         i0 = float_ne(f0, 0.0)
    593. 

  593.         i1 = float_ne(f1, 0.0)
    594. 

  594.         i2 = float_ne(f2, 0.0)
    595. 

  595.         i3 = float_ne(f3, 0.0)
    596. 

  596.         i4 = float_ne(f4, 0.0)
    597. 

  597.         i5 = float_ne(f5, 0.0)
    598. 

  598.         i6 = float_ne(f6, 0.0)
    599. 

  599.         i7 = float_ne(f7, 0.0)
    600. 

  600.         i8 = float_ne(f8, 0.0)
    601. 

  601.         i9 = float_ne(f9, 0.0)
    602. 

  602.         guard_false(i9), [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9]
    603. 

  603.         '''
    604. 

  604.         self.interpret(ops, [0.0, .1, .2, .3, .4, .5, .6, .7, .8, .9])
    605. 

  605.         assert self.getints(9) == [0, 1, 1, 1, 1, 1, 1, 1, 1]
    606. 

  606. 

  607. 

  608. class TestRegAllocCallAndStackDepth(CustomBaseTestRegalloc):
    609. 

  609.     def expected_param_depth(self, num_args):
    610. 

  610.         # Assumes the arguments are all non-float
    611. 

  611.         return num_args
    612. 

  612. 

  613.     def test_one_call(self):
    614. 

  614.         ops = '''
    615. 

  615.         [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9]
    616. 

  616.         i10 = call_i(ConstClass(f1ptr), i0, descr=f1_calldescr)
    617. 

  617.         guard_false(i10), [i10, i1, i2, i3, i4, i5, i6, i7, i8, i9]
    618. 

  618.         '''
    619. 

  619.         self.interpret(ops, [4, 7, 9, 9, 9, 9, 9, 9, 9, 9])
    620. 

  620.         assert self.getints(10) == [5, 7, 9, 9, 9, 9, 9, 9, 9, 9]
    621. 

  621. 

  622.     def test_two_calls(self):
    623. 

  623.         ops = '''
    624. 

  624.         [i0, i1,  i2, i3, i4, i5, i6, i7, i8, i9]
    625. 

  625.         i10 = call_i(ConstClass(f1ptr), i0, descr=f1_calldescr)
    626. 

  626.         i11 = call_i(ConstClass(f2ptr), i10, i1, descr=f2_calldescr)
    627. 

  627.         guard_false(i11) [i11, i1,  i2, i3, i4, i5, i6, i7, i8, i9]
    628. 

  628.         '''
    629. 

  629.         self.interpret(ops, [4, 7, 9, 9, 9, 9, 9, 9, 9, 9])
    630. 

  630.         assert self.getints(10) == [5 * 7, 7, 9, 9, 9, 9, 9, 9, 9, 9]
    631. 

  631. 

  632.     def test_call_many_arguments(self):
    633. 

  633.         ops = '''
    634. 

  634.         [i0, i1, i2, i3, i4, i5, i6, i7]
    635. 

  635.         i8 = call_i(ConstClass(f10ptr), 1, i0, i1, i2, i3, i4, i5, i6, i7, 10, descr=f10_calldescr)
    636. 

  636.         finish(i8)
    637. 

  637.         '''
    638. 

  638.         self.interpret(ops, [2, 3, 4, 5, 6, 7, 8, 9])
    639. 

  639.         assert self.getint(0) == 55
    640. 

  640. 

  641.     def test_bridge_calls_1(self):
    642. 

  642.         ops = '''
    643. 

  643.         [i0, i1]
    644. 

  644.         i2 = call_i(ConstClass(f1ptr), i0, descr=f1_calldescr)
    645. 

  645.         guard_value(i2, 0, descr=fdescr1) [i2, i1]
    646. 

  646.         finish(i1)
    647. 

  647.         '''
    648. 

  648.         loop = self.interpret(ops, [4, 7])
    649. 

  649.         assert self.getint(0) == 5
    650. 

  650.         ops = '''
    651. 

  651.         [i2, i1]
    652. 

  652.         i3 = call_i(ConstClass(f2ptr), i2, i1, descr=f2_calldescr)
    653. 

  653.         finish(i3)
    654. 

  654.         '''
    655. 

  655.         self.attach_bridge(ops, loop, -2)
    656. 

  656. 

  657.         self.run(loop, 4, 7)
    658. 

  658.         assert self.getint(0) == 5 * 7
    659. 

  659. 

  660.     def test_bridge_calls_2(self):
    661. 

  661.         ops = '''
    662. 

  662.         [i0, i1]
    663. 

  663.         i2 = call_i(ConstClass(f2ptr), i0, i1, descr=f2_calldescr)
    664. 

  664.         guard_value(i2, 0, descr=fdescr1) [i2]
    665. 

  665.         finish(i1)
    666. 

  666.         '''
    667. 

  667.         loop = self.interpret(ops, [4, 7])
    668. 

  668.         assert self.getint(0) == 4 * 7
    669. 

  669.         ops = '''
    670. 

  670.         [i2]
    671. 

  671.         i3 = call_i(ConstClass(f1ptr), i2, descr=f1_calldescr)
    672. 

  672.         finish(i3)
    673. 

  673.         '''
    674. 

  674.         self.attach_bridge(ops, loop, -2)
    675. 

  675. 

  676.         self.run(loop, 4, 7)
    677. 

  677.         assert self.getint(0) == 29
    678. 

  678. 

  679. 

  680. class TestJumps(TestRegallocSimple):
    681. 

  681.     def test_jump_with_consts(self):
    682. 

  682.         loop = """
    683. 

  683.         [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]
    684. 

  684.         label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, descr=targettoken)
    685. 

  685.         jump(i1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, descr=targettoken)
    686. 

  686.         """
    687. 

  687.         self.interpret(loop, range(15), run=False)
    688. 

  688.         # ensure compiling this loop works
    689. 

  689.         assert 1
    690. 

  690. 

  691.     def test_from_loop_to_loop(self):
    692. 

  692.         def assembler_helper(failindex, virtualizable):
    693. 

  693.             return 3
    694. 

  694. 

  695.         FUNCPTR = lltype.Ptr(lltype.FuncType([lltype.Signed, llmemory.GCREF],
    696. 

  696.                                              lltype.Signed))
    697. 

  697. 

  698.         class FakeJitDriverSD:
    699. 

  699.             index_of_virtualizable = -1
    700. 

  700.             _assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
    701. 

  701.             assembler_helper_adr = llmemory.cast_ptr_to_adr(
    702. 

  702.                 _assembler_helper_ptr)
    703. 

  703. 

  704.         FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
    705. 

  705.             lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)), \
    706. 

  706.                     [lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
    707. 

  707.         self.cpu.done_with_this_frame_descr_int = BasicFinalDescr()
    708. 

  708.         loop1 = """
    709. 

  709.         [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
    710. 

  710.         i11 = int_add(i0, i1)
    711. 

  711.         guard_false(i0) [i11, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
    712. 

  712.         """
    713. 

  713.         large = self.interpret(loop1, range(11), run=False)
    714. 

  714.         large._jitcelltoken.outermost_jitdriver_sd = FakeJitDriverSD()
    715. 

  715.         self.namespace['looptoken'] = large._jitcelltoken
    716. 

  716.         assert self.namespace['looptoken']._ll_function_addr != 0
    717. 

  717.         loop2 = """
    718. 

  718.         [i0]
    719. 

  719.         i1 = force_token()
    720. 

  720.         i2 = call_assembler_i(1,2,3,4,5,6,7,8,9,10,11, descr=looptoken)
    721. 

  721.         guard_not_forced() [i0]
    722. 

  722.         guard_false(i0) [i0, i2]
    723. 

  723.         """
    724. 

    725. 

  725.         self.interpret(loop2, [110])
    726. 

  726.         assert self.getint(0) == 110
    727. 

  727.         assert self.getint(1) == 3
    728. 

  728. 

  729.     def test_far_far_jump(self):
    730. 

  730.         ops = """
    731. 

  731.         [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
    732. 

  732.         label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, descr=targettoken)
    733. 

  733.         i11 = int_add(i0, 1)
    734. 

  734.         i12 = int_lt(i11, 2)
    735. 

  735.         i13 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    736. 

  736.         i14 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    737. 

  737.         i15 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    738. 

  738.         i16 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    739. 

  739.         i17 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    740. 

  740.         i18 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    741. 

  741.         i19 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    742. 

  742.         i20 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    743. 

  743.         i21 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    744. 

  744.         i22 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    745. 

  745.         i23 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    746. 

  746.         i24 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    747. 

  747.         i26 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    748. 

  748.         i27 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    749. 

  749.         i28 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    750. 

  750.         i29 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    751. 

  751.         i30 = call_i(ConstClass(f_fptr), i12, descr=f_calldescr)
    752. 

  752.         guard_true(i12) [i11, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]
    753. 

  753.         jump(i11, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, descr=targettoken)
    754. 

  754.         """
    755. 

  755.         self.interpret(ops, range(11))
    756. 

  756.         assert self.getint(0) == 2  # and not segfault()
    757. 

  757. 

  758. 

  759. class TestStrOps(CustomBaseTestRegalloc):
    760. 

  760.     def test_newstr(self):
    761. 

  761.         ops = """
    762. 

  762.         [i0]
    763. 

  763.         p1 = newstr(300)
    764. 

  764.         i2 = strlen(p1)
    765. 

  765.         finish(i2)
    766. 

  766.         """
    767. 

  767.         self.interpret(ops, [0])
    768. 

  768.         assert self.getint(0) == 300
    769. 

  769.         ops = """
    770. 

  770.         [i0]
    771. 

  771.         p1 = newstr(i0)
    772. 

  772.         i2 = strlen(p1)
    773. 

  773.         finish(i2)
    774. 

  774.         """
    775. 

  775.         self.interpret(ops, [300])
    776. 

  776.         assert self.getint(0) == 300
    777. 

  777. 

  778.     def test_strlen(self):
    779. 

  779.         s = rstr.mallocstr(300)
    780. 

  780.         ops = """
    781. 

  781.         [p0]
    782. 

  782.         i1 = strlen(p0)
    783. 

  783.         finish(i1)
    784. 

  784.         """
    785. 

  785.         self.interpret(ops, [s])
    786. 

  786.         assert self.getint(0) == 300
    787. 

  787. 

  788.     def test_len_of_newstr(self):
    789. 

  789.         ops = """
    790. 

  790.         []
    791. 

  791.         p0 = newstr(300)
    792. 

  792.         finish(p0)
    793. 

  793.         """
    794. 

  794.         self.interpret(ops, [])
    795. 

  795.         string = self.getptr(0, lltype.Ptr(rstr.STR))
    796. 

  796.         assert len(string.chars) == 300
    797. 

  797.