PageRenderTime 41ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 0ms

/pypy/jit/backend/x86/test/test_regalloc.py

https://bitbucket.org/pypy/pypy/
Python | 694 lines | 657 code | 35 blank | 2 comment | 12 complexity | e62766430acb07534dfcf6c9eee2d861 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 pypy.jit.metainterp.history import BoxInt, ConstInt,\
    7. 

  7.      BoxPtr, ConstPtr, BasicFailDescr, JitCellToken, TargetToken
    8. 

  8. from pypy.jit.metainterp.resoperation import rop, ResOperation
    9. 

  9. from pypy.jit.backend.llsupport.descr import GcCache
    10. 

  10. from pypy.jit.backend.detect_cpu import getcpuclass
    11. 

  11. from pypy.jit.backend.x86.regalloc import RegAlloc, X86RegisterManager,\
    12. 

  12.      is_comparison_or_ovf_op
    13. 

  13. from pypy.jit.backend.x86.arch import IS_X86_32, IS_X86_64
    14. 

  14. from pypy.jit.tool.oparser import parse
    15. 

  15. from pypy.rpython.lltypesystem import lltype, llmemory, rffi
    16. 

  16. from pypy.rpython.annlowlevel import llhelper
    17. 

  17. from pypy.rpython.lltypesystem import rclass, rstr
    18. 

  18. from pypy.jit.codewriter import longlong
    19. 

  19. from pypy.jit.codewriter.effectinfo import EffectInfo
    20. 

  20. from pypy.jit.backend.x86.rx86 import *
    21. 

  21. 

  22. def test_is_comparison_or_ovf_op():
    23. 

  23.     assert not is_comparison_or_ovf_op(rop.INT_ADD)
    24. 

  24.     assert is_comparison_or_ovf_op(rop.INT_ADD_OVF)
    25. 

  25.     assert is_comparison_or_ovf_op(rop.INT_EQ)
    26. 

  26. 

  27. CPU = getcpuclass()
    28. 

  28. class MockGcDescr(GcCache):
    29. 

  29.     def get_funcptr_for_new(self):
    30. 

  30.         return 123
    31. 

  31.     get_funcptr_for_newarray = get_funcptr_for_new
    32. 

  32.     get_funcptr_for_newstr = get_funcptr_for_new
    33. 

  33.     get_funcptr_for_newunicode = get_funcptr_for_new
    34. 

  34.  
    35. 

  35.     def rewrite_assembler(self, cpu, operations):
    36. 

  36.         pass
    37. 

  37. 

  38. class MockAssembler(object):
    39. 

  39.     gcrefs = None
    40. 

  40.     _float_constants = None
    41. 

  41. 

  42.     def __init__(self, cpu=None, gc_ll_descr=None):
    43. 

  43.         self.movs = []
    44. 

  44.         self.performs = []
    45. 

  45.         self.lea = []
    46. 

  46.         if cpu is None:
    47. 

  47.             cpu = CPU(None, None)
    48. 

  48.             cpu.setup_once()
    49. 

  49.         self.cpu = cpu
    50. 

  50.         if gc_ll_descr is None:
    51. 

  51.             gc_ll_descr = MockGcDescr(False)
    52. 

  52.         self.cpu.gc_ll_descr = gc_ll_descr
    53. 

  53. 

  54.     def dump(self, *args):
    55. 

  55.         pass
    56. 

  56. 

  57.     def regalloc_mov(self, from_loc, to_loc):
    58. 

  58.         self.movs.append((from_loc, to_loc))
    59. 

  59. 

  60.     def regalloc_perform(self, op, arglocs, resloc):
    61. 

  61.         self.performs.append((op, arglocs, resloc))
    62. 

  62. 

  63.     def regalloc_perform_discard(self, op, arglocs):
    64. 

  64.         self.performs.append((op, arglocs))
    65. 

  65. 

  66.     def load_effective_addr(self, *args):
    67. 

  67.         self.lea.append(args)
    68. 

  68. 

  69. def fill_regs(regalloc, cls=BoxInt):
    70. 

  70.     allboxes = []
    71. 

  71.     for reg in X86RegisterManager.all_regs:
    72. 

  72.         box = cls()
    73. 

  73.         allboxes.append(box)
    74. 

  74.         regalloc.rm.try_allocate_reg()
    75. 

  75.     return allboxes
    76. 

  76.     
    77. 

  77. class RegAllocForTests(RegAlloc):
    78. 

  78.     position = 0
    79. 

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

  80.         return -1
    81. 

  81. 

  82. class BaseTestRegalloc(object):
    83. 

  83.     cpu = CPU(None, None)
    84. 

  84.     cpu.setup_once()
    85. 

  85. 

  86.     def raising_func(i):
    87. 

  87.         if i:
    88. 

  88.             raise LLException(zero_division_error,
    89. 

  89.                               zero_division_value)
    90. 

  90.     FPTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Void))
    91. 

  91.     raising_fptr = llhelper(FPTR, raising_func)
    92. 

  92.     zero_division_tp, zero_division_value = cpu.get_zero_division_error()
    93. 

  93.     zd_addr = cpu.cast_int_to_adr(zero_division_tp)
    94. 

  94.     zero_division_error = llmemory.cast_adr_to_ptr(zd_addr,
    95. 

  95.                                             lltype.Ptr(rclass.OBJECT_VTABLE))
    96. 

  96.     raising_calldescr = cpu.calldescrof(FPTR.TO, FPTR.TO.ARGS, FPTR.TO.RESULT,
    97. 

  97.                                         EffectInfo.MOST_GENERAL)
    98. 

  98. 

  99.     targettoken = TargetToken()
    100. 

  100.     targettoken2 = TargetToken()
    101. 

  101.     fdescr1 = BasicFailDescr(1)
    102. 

  102.     fdescr2 = BasicFailDescr(2)
    103. 

  103.     fdescr3 = BasicFailDescr(3)
    104. 

  104. 

  105.     def setup_method(self, meth):
    106. 

  106.         self.targettoken._x86_loop_code = 0
    107. 

  107.         self.targettoken2._x86_loop_code = 0
    108. 

  108. 

  109.     def f1(x):
    110. 

  110.         return x+1
    111. 

  111. 

  112.     def f2(x, y):
    113. 

  113.         return x*y
    114. 

  114. 

  115.     def f10(*args):
    116. 

  116.         assert len(args) == 10
    117. 

  117.         return sum(args)
    118. 

  118. 

  119.     F1PTR = lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed))
    120. 

  120.     F2PTR = lltype.Ptr(lltype.FuncType([lltype.Signed]*2, lltype.Signed))
    121. 

  121.     F10PTR = lltype.Ptr(lltype.FuncType([lltype.Signed]*10, lltype.Signed))
    122. 

  122.     f1ptr = llhelper(F1PTR, f1)
    123. 

  123.     f2ptr = llhelper(F2PTR, f2)
    124. 

  124.     f10ptr = llhelper(F10PTR, f10)
    125. 

  125. 

  126.     f1_calldescr = cpu.calldescrof(F1PTR.TO, F1PTR.TO.ARGS, F1PTR.TO.RESULT,
    127. 

  127.                                    EffectInfo.MOST_GENERAL)
    128. 

  128.     f2_calldescr = cpu.calldescrof(F2PTR.TO, F2PTR.TO.ARGS, F2PTR.TO.RESULT,
    129. 

  129.                                    EffectInfo.MOST_GENERAL)
    130. 

  130.     f10_calldescr= cpu.calldescrof(F10PTR.TO, F10PTR.TO.ARGS, F10PTR.TO.RESULT,
    131. 

  131.                                    EffectInfo.MOST_GENERAL)
    132. 

  132. 

  133.     namespace = locals().copy()
    134. 

  134.     type_system = 'lltype'
    135. 

  135. 

  136.     def parse(self, s, boxkinds=None):
    137. 

  137.         return parse(s, self.cpu, self.namespace,
    138. 

  138.                      type_system=self.type_system,
    139. 

  139.                      boxkinds=boxkinds)
    140. 

  140. 

  141.     def interpret(self, ops, args, run=True):
    142. 

  142.         loop = self.parse(ops)
    143. 

  143.         looptoken = JitCellToken()
    144. 

  144.         self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
    145. 

  145.         arguments = []
    146. 

  146.         for arg in args:
    147. 

  147.             if isinstance(arg, int):
    148. 

  148.                 arguments.append(arg)
    149. 

  149.             elif isinstance(arg, float):
    150. 

  150.                 arg = longlong.getfloatstorage(arg)
    151. 

  151.                 arguments.append(arg)
    152. 

  152.             else:
    153. 

  153.                 assert isinstance(lltype.typeOf(arg), lltype.Ptr)
    154. 

  154.                 llgcref = lltype.cast_opaque_ptr(llmemory.GCREF, arg)
    155. 

  155.                 arguments.append(llgcref)
    156. 

  156.         loop._jitcelltoken = looptoken
    157. 

  157.         if run:
    158. 

  158.             self.cpu.execute_token(looptoken, *arguments)
    159. 

  159.         return loop
    160. 

  160. 

  161.     def prepare_loop(self, ops):
    162. 

  162.         loop = self.parse(ops)
    163. 

  163.         regalloc = RegAlloc(self.cpu.assembler, False)
    164. 

  164.         regalloc.prepare_loop(loop.inputargs, loop.operations,
    165. 

  165.                               loop.original_jitcell_token, [])
    166. 

  166.         return regalloc
    167. 

  167. 

  168.     def getint(self, index):
    169. 

  169.         return self.cpu.get_latest_value_int(index)
    170. 

  170. 

  171.     def getfloat(self, index):
    172. 

  172.         return self.cpu.get_latest_value_float(index)
    173. 

  173. 

  174.     def getints(self, end):
    175. 

  175.         return [self.cpu.get_latest_value_int(index) for
    176. 

  176.                 index in range(0, end)]
    177. 

  177. 

  178.     def getfloats(self, end):
    179. 

  179.         return [longlong.getrealfloat(self.cpu.get_latest_value_float(index))
    180. 

  180.                 for index in range(0, end)]
    181. 

  181. 

  182.     def getptr(self, index, T):
    183. 

  183.         gcref = self.cpu.get_latest_value_ref(index)
    184. 

  184.         return lltype.cast_opaque_ptr(T, gcref)
    185. 

  185. 

  186.     def attach_bridge(self, ops, loop, guard_op_index, **kwds):
    187. 

  187.         guard_op = loop.operations[guard_op_index]
    188. 

  188.         assert guard_op.is_guard()
    189. 

  189.         bridge = self.parse(ops, **kwds)
    190. 

  190.         assert ([box.type for box in bridge.inputargs] ==
    191. 

  191.                 [box.type for box in guard_op.getfailargs()])
    192. 

  192.         faildescr = guard_op.getdescr()
    193. 

  193.         self.cpu.compile_bridge(faildescr, bridge.inputargs, bridge.operations,
    194. 

  194.                                 loop._jitcelltoken)
    195. 

  195.         return bridge
    196. 

  196. 

  197.     def run(self, loop, *arguments):
    198. 

  198.         return self.cpu.execute_token(loop._jitcelltoken, *arguments)
    199. 

  199. 

  200. class TestRegallocSimple(BaseTestRegalloc):
    201. 

  201.     def test_simple_loop(self):
    202. 

  202.         ops = '''
    203. 

  203.         [i0]
    204. 

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

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

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

  207.         guard_true(i2) [i1]
    208. 

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

  209.         '''
    210. 

  210.         self.interpret(ops, [0])
    211. 

  211.         assert self.getint(0) == 20
    212. 

  212. 

  213.     def test_two_loops_and_a_bridge(self):
    214. 

  214.         ops = '''
    215. 

  215.         [i0, i1, i2, i3]
    216. 

  216.         label(i0, i1, i2, i3, descr=targettoken)
    217. 

  217.         i4 = int_add(i0, 1)
    218. 

  218.         i5 = int_lt(i4, 20)
    219. 

  219.         guard_true(i5) [i4, i1, i2, i3]
    220. 

  220.         jump(i4, i1, i2, i3, descr=targettoken)
    221. 

  221.         '''
    222. 

  222.         loop = self.interpret(ops, [0, 0, 0, 0])
    223. 

  223.         ops2 = '''
    224. 

  224.         [i5, i6, i7, i8]
    225. 

  225.         label(i5, descr=targettoken2)
    226. 

  226.         i1 = int_add(i5, 1)
    227. 

  227.         i3 = int_add(i1, 1)
    228. 

  228.         i4 = int_add(i3, 1)
    229. 

  229.         i2 = int_lt(i4, 30)
    230. 

  230.         guard_true(i2) [i4]
    231. 

  231.         jump(i4, descr=targettoken2)
    232. 

  232.         '''
    233. 

  233.         loop2 = self.interpret(ops2, [0, 0, 0, 0])
    234. 

  234.         bridge_ops = '''
    235. 

  235.         [i4]
    236. 

  236.         jump(i4, i4, i4, i4, descr=targettoken)
    237. 

  237.         '''
    238. 

  238.         bridge = self.attach_bridge(bridge_ops, loop2, 5)
    239. 

  239.         self.run(loop2, 0, 0, 0, 0)
    240. 

  240.         assert self.getint(0) == 31
    241. 

  241.         assert self.getint(1) == 30
    242. 

  242.         assert self.getint(2) == 30
    243. 

  243.         assert self.getint(3) == 30
    244. 

  244. 

  245.     def test_pointer_arg(self):
    246. 

  246.         ops = '''
    247. 

  247.         [i0, p0]
    248. 

  248.         label(i0, p0, descr=targettoken)
    249. 

  249.         i1 = int_add(i0, 1)
    250. 

  250.         i2 = int_lt(i1, 10)
    251. 

  251.         guard_true(i2) [p0]
    252. 

  252.         jump(i1, p0, descr=targettoken)
    253. 

  253.         '''
    254. 

  254.         S = lltype.GcStruct('S')
    255. 

  255.         ptr = lltype.malloc(S)
    256. 

  256.         self.cpu.clear_latest_values(2)
    257. 

  257.         self.interpret(ops, [0, ptr])
    258. 

  258.         assert self.getptr(0, lltype.Ptr(S)) == ptr
    259. 

  259. 

  260.     def test_exception_bridge_no_exception(self):
    261. 

  261.         ops = '''
    262. 

  262.         [i0]
    263. 

  263.         i1 = same_as(1)
    264. 

  264.         call(ConstClass(raising_fptr), i0, descr=raising_calldescr)
    265. 

  265.         guard_exception(ConstClass(zero_division_error)) [i1]
    266. 

  266.         finish(0)
    267. 

  267.         '''
    268. 

  268.         bridge_ops = '''
    269. 

  269.         [i3]
    270. 

  270.         i2 = same_as(2)
    271. 

  271.         guard_no_exception() [i2]
    272. 

  272.         finish(1)
    273. 

  273.         '''
    274. 

  274.         loop = self.interpret(ops, [0])
    275. 

  275.         assert self.getint(0) == 1
    276. 

  276.         bridge = self.attach_bridge(bridge_ops, loop, 2)
    277. 

  277.         self.run(loop, 0)
    278. 

  278.         assert self.getint(0) == 1
    279. 

  279. 

  280.     def test_inputarg_unused(self):
    281. 

  281.         ops = '''
    282. 

  282.         [i0]
    283. 

  283.         finish(1)
    284. 

  284.         '''
    285. 

  285.         self.interpret(ops, [0])
    286. 

  286.         # assert did not explode
    287. 

  287. 

  288.     def test_nested_guards(self):
    289. 

  289.         ops = '''
    290. 

  290.         [i0, i1]
    291. 

  291.         guard_true(i0) [i0, i1]
    292. 

  292.         finish(4)
    293. 

  293.         '''
    294. 

  294.         bridge_ops = '''
    295. 

  295.         [i0, i1]
    296. 

  296.         guard_true(i0) [i0, i1]
    297. 

  297.         finish(3)
    298. 

  298.         '''
    299. 

  299.         loop = self.interpret(ops, [0, 10])
    300. 

  300.         assert self.getint(0) == 0
    301. 

  301.         assert self.getint(1) == 10
    302. 

  302.         bridge = self.attach_bridge(bridge_ops, loop, 0)
    303. 

  303.         self.run(loop, 0, 10)
    304. 

  304.         assert self.getint(0) == 0
    305. 

  305.         assert self.getint(1) == 10
    306. 

  306. 

  307.     def test_nested_unused_arg(self):
    308. 

  308.         ops = '''
    309. 

  309.         [i0, i1]
    310. 

  310.         guard_true(i0) [i0, i1]
    311. 

  311.         finish(1)
    312. 

  312.         '''
    313. 

  313.         loop = self.interpret(ops, [0, 1])
    314. 

  314.         assert self.getint(0) == 0
    315. 

  315.         bridge_ops = '''
    316. 

  316.         [i0, i1]
    317. 

  317.         finish(1, 2)
    318. 

  318.         '''
    319. 

  319.         self.attach_bridge(bridge_ops, loop, 0)
    320. 

  320.         self.run(loop, 0, 1)
    321. 

  321. 

  322.     def test_spill_for_constant(self):
    323. 

  323.         ops = '''
    324. 

  324.         [i0, i1, i2, i3]
    325. 

  325.         label(i0, i1, i2, i3, descr=targettoken)
    326. 

  326.         i4 = int_add(3, i1)
    327. 

  327.         i5 = int_lt(i4, 30)
    328. 

  328.         guard_true(i5) [i0, i4, i2, i3]
    329. 

  329.         jump(1, i4, 3, 4, descr=targettoken)
    330. 

  330.         '''
    331. 

  331.         self.interpret(ops, [0, 0, 0, 0])
    332. 

  332.         assert self.getints(4) == [1, 30, 3, 4]
    333. 

  333. 

  334.     def test_spill_for_constant_lshift(self):
    335. 

  335.         ops = '''
    336. 

  336.         [i0, i2, i1, i3]
    337. 

  337.         label(i0, i2, i1, i3, descr=targettoken)
    338. 

  338.         i4 = int_lshift(1, i1)
    339. 

  339.         i5 = int_add(1, i1)
    340. 

  340.         i6 = int_lt(i5, 30)
    341. 

  341.         guard_true(i6) [i4, i5, i2, i3]
    342. 

  342.         jump(i4, 3, i5, 4, descr=targettoken)
    343. 

  343.         '''
    344. 

  344.         self.interpret(ops, [0, 0, 0, 0])
    345. 

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

  346.         ops = '''
    347. 

  347.         [i0, i1, i2, i3]
    348. 

  348.         label(i0, i1, i2, i3, descr=targettoken)
    349. 

  349.         i4 = int_lshift(1, i1)
    350. 

  350.         i5 = int_add(1, i1)
    351. 

  351.         i6 = int_lt(i5, 30)
    352. 

  352.         guard_true(i6) [i4, i5, i2, i3]
    353. 

  353.         jump(i4, i5, 3, 4, descr=targettoken)
    354. 

  354.         '''
    355. 

  355.         self.interpret(ops, [0, 0, 0, 0])
    356. 

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

  357.         ops = '''
    358. 

  358.         [i0, i3, i1, i2]
    359. 

  359.         label(i0, i3, i1, i2, descr=targettoken)
    360. 

  360.         i4 = int_lshift(1, i1)
    361. 

  361.         i5 = int_add(1, i1)
    362. 

  362.         i6 = int_lt(i5, 30)
    363. 

  363.         guard_true(i6) [i4, i5, i2, i3]
    364. 

  364.         jump(i4, 4, i5, 3, descr=targettoken)
    365. 

  365.         '''
    366. 

  366.         self.interpret(ops, [0, 0, 0, 0])
    367. 

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

  368. 

  369.     def test_result_selected_reg_via_neg(self):
    370. 

  370.         ops = '''
    371. 

  371.         [i0, i1, i2, i3]
    372. 

  372.         label(i0, i1, i2, i3, descr=targettoken)
    373. 

  373.         i6 = int_neg(i2)
    374. 

  374.         i7 = int_add(1, i1)
    375. 

  375.         i4 = int_lt(i7, 10)
    376. 

  376.         guard_true(i4) [i0, i6, i7]
    377. 

  377.         jump(1, i7, i2, i6, descr=targettoken)
    378. 

  378.         '''
    379. 

  379.         self.interpret(ops, [0, 0, 3, 0])
    380. 

  380.         assert self.getints(3) == [1, -3, 10]
    381. 

  381.         
    382. 

  382.     def test_compare_memory_result_survives(self):
    383. 

  383.         ops = '''
    384. 

  384.         [i0, i1, i2, i3]
    385. 

  385.         label(i0, i1, i2, i3, descr=targettoken)
    386. 

  386.         i4 = int_lt(i0, i1)
    387. 

  387.         i5 = int_add(i3, 1)
    388. 

  388.         i6 = int_lt(i5, 30)
    389. 

  389.         guard_true(i6) [i4]
    390. 

  390.         jump(i0, i1, i4, i5, descr=targettoken)
    391. 

  391.         '''
    392. 

  392.         self.interpret(ops, [0, 10, 0, 0])
    393. 

  393.         assert self.getint(0) == 1
    394. 

  394. 

  395.     def test_jump_different_args(self):
    396. 

  396.         ops = '''
    397. 

  397.         [i0, i15, i16, i18, i1, i2, i3]
    398. 

  398.         label(i0, i15, i16, i18, i1, i2, i3, descr=targettoken)
    399. 

  399.         i4 = int_add(i3, 1)
    400. 

  400.         i5 = int_lt(i4, 20)
    401. 

  401.         guard_true(i5) [i2, i1]
    402. 

  402.         jump(i0, i18, i15, i16, i2, i1, i4, descr=targettoken)
    403. 

  403.         '''
    404. 

  404.         self.interpret(ops, [0, 1, 2, 3, 0, 0, 0])
    405. 

  405. 

  406.     def test_op_result_unused(self):
    407. 

  407.         ops = '''
    408. 

  408.         [i0, i1]
    409. 

  409.         i2 = int_add(i0, i1)
    410. 

  410.         finish(0)
    411. 

  411.         '''
    412. 

  412.         self.interpret(ops, [0, 0])
    413. 

  413. 

  414.     def test_guard_value_two_boxes(self):
    415. 

  415.         ops = '''
    416. 

  416.         [i0, i1, i2, i3, i4, i5, i6, i7]
    417. 

  417.         guard_value(i6, i1) [i0, i2, i3, i4, i5, i6]
    418. 

  418.         finish(i0, i2, i3, i4, i5, i6)
    419. 

  419.         '''
    420. 

  420.         self.interpret(ops, [0, 0, 0, 0, 0, 0, 0, 0])
    421. 

  421.         assert self.getint(0) == 0
    422. 

  422. 

  423.     def test_bug_wrong_stack_adj(self):
    424. 

  424.         ops = '''
    425. 

  425.         [i0, i1, i2, i3, i4, i5, i6, i7, i8]
    426. 

  426.         i9 = same_as(0)
    427. 

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

  428.         finish(1, i0, i1, i2, i3, i4, i5, i6, i7, i8)
    429. 

  429.         '''
    430. 

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

  431.         assert self.getint(0) == 0
    432. 

  432.         bridge_ops = '''
    433. 

  433.         [i9, i0, i1, i2, i3, i4, i5, i6, i7, i8]
    434. 

  434.         call(ConstClass(raising_fptr), 0, descr=raising_calldescr)
    435. 

  435.         finish(i0, i1, i2, i3, i4, i5, i6, i7, i8)
    436. 

  436.         '''
    437. 

  437.         self.attach_bridge(bridge_ops, loop, 1)
    438. 

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

  439.         assert self.getints(9) == range(9)
    440. 

  440. 

  441.     def test_loopargs(self):
    442. 

  442.         ops = """
    443. 

  443.         [i0, i1, i2, i3]
    444. 

  444.         i4 = int_add(i0, i1)
    445. 

  445.         jump(i4, i1, i2, i3)
    446. 

  446.         """
    447. 

  447.         regalloc = self.prepare_loop(ops)
    448. 

  448.         if IS_X86_64:
    449. 

  449.             assert len(regalloc.rm.reg_bindings) == 4
    450. 

  450.             assert len(regalloc.fm.bindings) == 0
    451. 

  451.         else:
    452. 

  452.             assert len(regalloc.rm.reg_bindings) == 0
    453. 

  453.             assert len(regalloc.fm.bindings) == 4
    454. 

  454. 

  455. 

  456. class TestRegallocCompOps(BaseTestRegalloc):
    457. 

  457.     
    458. 

  458.     def test_cmp_op_0(self):
    459. 

  459.         ops = '''
    460. 

  460.         [i0, i3]
    461. 

  461.         i1 = same_as(1)
    462. 

  462.         i2 = int_lt(i0, 100)
    463. 

  463.         guard_true(i3) [i1, i2]
    464. 

  464.         finish(0, i2)
    465. 

  465.         '''
    466. 

  466.         self.interpret(ops, [0, 1])
    467. 

  467.         assert self.getint(0) == 0
    468. 

  468. 

  469. class TestRegallocMoreRegisters(BaseTestRegalloc):
    470. 

  470. 

  471.     cpu = BaseTestRegalloc.cpu
    472. 

  472.     targettoken = TargetToken()
    473. 

  473. 

  474.     S = lltype.GcStruct('S', ('field', lltype.Char))
    475. 

  475.     fielddescr = cpu.fielddescrof(S, 'field')
    476. 

  476. 

  477.     A = lltype.GcArray(lltype.Char)
    478. 

  478.     arraydescr = cpu.arraydescrof(A)
    479. 

  479. 

  480.     namespace = locals().copy()
    481. 

  481. 

  482.     def test_int_is_true(self):
    483. 

  483.         ops = '''
    484. 

  484.         [i0, i1, i2, i3, i4, i5, i6, i7]
    485. 

  485.         i10 = int_is_true(i0)
    486. 

  486.         i11 = int_is_true(i1)
    487. 

  487.         i12 = int_is_true(i2)
    488. 

  488.         i13 = int_is_true(i3)
    489. 

  489.         i14 = int_is_true(i4)
    490. 

  490.         i15 = int_is_true(i5)
    491. 

  491.         i16 = int_is_true(i6)
    492. 

  492.         i17 = int_is_true(i7)
    493. 

  493.         finish(i10, i11, i12, i13, i14, i15, i16, i17)
    494. 

  494.         '''
    495. 

  495.         self.interpret(ops, [0, 42, 12, 0, 13, 0, 0, 3333])
    496. 

  496.         assert self.getints(8) == [0, 1, 1, 0, 1, 0, 0, 1]
    497. 

  497. 

  498.     def test_comparison_ops(self):
    499. 

  499.         ops = '''
    500. 

  500.         [i0, i1, i2, i3, i4, i5, i6]
    501. 

  501.         i10 = int_lt(i0, i1)
    502. 

  502.         i11 = int_le(i2, i3)
    503. 

  503.         i12 = int_ge(i4, i5)
    504. 

  504.         i13 = int_eq(i5, i6)
    505. 

  505.         i14 = int_gt(i6, i2)
    506. 

  506.         i15 = int_ne(i2, i6)
    507. 

  507.         finish(i10, i11, i12, i13, i14, i15)
    508. 

  508.         '''
    509. 

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

  510.         assert self.getints(6) == [1, 1, 0, 0, 1, 1]
    511. 

  511. 

  512.     def test_strsetitem(self):
    513. 

  513.         ops = '''
    514. 

  514.         [p0, i]
    515. 

  515.         strsetitem(p0, 1, i)
    516. 

  516.         finish()
    517. 

  517.         '''
    518. 

  518.         llstr  = rstr.mallocstr(10)
    519. 

  519.         self.interpret(ops, [llstr, ord('a')])
    520. 

  520.         assert llstr.chars[1] == 'a'
    521. 

  521. 

  522.     def test_setfield_char(self):
    523. 

  523.         ops = '''
    524. 

  524.         [p0, i]
    525. 

  525.         setfield_gc(p0, i, descr=fielddescr)
    526. 

  526.         finish()
    527. 

  527.         '''
    528. 

  528.         s = lltype.malloc(self.S)
    529. 

  529.         self.interpret(ops, [s, ord('a')])
    530. 

  530.         assert s.field == 'a'
    531. 

  531. 

  532.     def test_setarrayitem_gc(self):
    533. 

  533.         ops = '''
    534. 

  534.         [p0, i]
    535. 

  535.         setarrayitem_gc(p0, 1, i, descr=arraydescr)
    536. 

  536.         finish()
    537. 

  537.         '''
    538. 

  538.         s = lltype.malloc(self.A, 3)
    539. 

  539.         self.interpret(ops, [s, ord('a')])
    540. 

  540.         assert s[1] == 'a'
    541. 

  541. 

  542.     def test_division_optimized(self):
    543. 

  543.         ops = '''
    544. 

  544.         [i7, i6]
    545. 

  545.         label(i7, i6, descr=targettoken)
    546. 

  546.         i18 = int_floordiv(i7, i6)
    547. 

  547.         i19 = int_xor(i7, i6)
    548. 

  548.         i21 = int_lt(i19, 0)
    549. 

  549.         i22 = int_mod(i7, i6)
    550. 

  550.         i23 = int_is_true(i22)
    551. 

  551.         i24 = int_eq(i6, 4)
    552. 

  552.         guard_false(i24) [i18]
    553. 

  553.         jump(i18, i6, descr=targettoken)
    554. 

  554.         '''
    555. 

  555.         self.interpret(ops, [10, 4])
    556. 

  556.         assert self.getint(0) == 2
    557. 

  557.         # FIXME: Verify that i19 - i23 are removed
    558. 

  558. 

  559. class TestRegallocFloats(BaseTestRegalloc):
    560. 

  560.     def test_float_add(self):
    561. 

  561.         ops = '''
    562. 

  562.         [f0, f1]
    563. 

  563.         f2 = float_add(f0, f1)
    564. 

  564.         finish(f2, f0, f1)
    565. 

  565.         '''
    566. 

  566.         self.interpret(ops, [3.0, 1.5])
    567. 

  567.         assert self.getfloats(3) == [4.5, 3.0, 1.5]
    568. 

  568. 

  569.     def test_float_adds_stack(self):
    570. 

  570.         ops = '''
    571. 

  571.         [f0, f1, f2, f3, f4, f5, f6, f7, f8]
    572. 

  572.         f9 = float_add(f0, f1)
    573. 

  573.         f10 = float_add(f8, 3.5)
    574. 

  574.         finish(f9, f10, f2, f3, f4, f5, f6, f7, f8)
    575. 

  575.         '''
    576. 

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

  577.         assert self.getfloats(9) == [.1+.2, .9+3.5, .3, .4, .5, .6, .7, .8, .9]
    578. 

  578. 

  579.     def test_lt_const(self):
    580. 

  580.         ops = '''
    581. 

  581.         [f0]
    582. 

  582.         i1 = float_lt(3.5, f0)
    583. 

  583.         finish(i1)
    584. 

  584.         '''
    585. 

  585.         self.interpret(ops, [0.1])
    586. 

  586.         assert self.getint(0) == 0
    587. 

  587. 

  588.     def test_bug_float_is_true_stack(self):
    589. 

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

  590.         # makes sense any more.
    591. 

  591.         ops = '''
    592. 

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

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

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

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

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

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

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

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

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

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

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

  603.         finish(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
    604. 

  604.         '''
    605. 

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

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

  607. 

  608. class TestRegAllocCallAndStackDepth(BaseTestRegalloc):
    609. 

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

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

  611.         if IS_X86_32:
    612. 

  612.             return num_args
    613. 

  613.         elif IS_X86_64:
    614. 

  614.             return max(num_args - 6, 0)
    615. 

  615. 

  616.     def test_one_call(self):
    617. 

  617.         ops = '''
    618. 

  618.         [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9]
    619. 

  619.         i10 = call(ConstClass(f1ptr), i0, descr=f1_calldescr)
    620. 

  620.         finish(i10, i1, i2, i3, i4, i5, i6, i7, i8, i9)
    621. 

  621.         '''
    622. 

  622.         loop = self.interpret(ops, [4, 7, 9, 9 ,9, 9, 9, 9, 9, 9])
    623. 

  623.         assert self.getints(10) == [5, 7, 9, 9, 9, 9, 9, 9, 9, 9]
    624. 

  624.         clt = loop._jitcelltoken.compiled_loop_token
    625. 

  625.         assert clt.param_depth == self.expected_param_depth(1)
    626. 

  626. 

  627.     def test_two_calls(self):
    628. 

  628.         ops = '''
    629. 

  629.         [i0, i1,  i2, i3, i4, i5, i6, i7, i8, i9]
    630. 

  630.         i10 = call(ConstClass(f1ptr), i0, descr=f1_calldescr)
    631. 

  631.         i11 = call(ConstClass(f2ptr), i10, i1, descr=f2_calldescr)        
    632. 

  632.         finish(i11, i1,  i2, i3, i4, i5, i6, i7, i8, i9)
    633. 

  633.         '''
    634. 

  634.         loop = self.interpret(ops, [4, 7, 9, 9 ,9, 9, 9, 9, 9, 9])
    635. 

  635.         assert self.getints(10) == [5*7, 7, 9, 9, 9, 9, 9, 9, 9, 9]
    636. 

  636.         clt = loop._jitcelltoken.compiled_loop_token
    637. 

  637.         assert clt.param_depth == self.expected_param_depth(2)
    638. 

  638. 

  639.     def test_call_many_arguments(self):
    640. 

  640.         # NB: The first and last arguments in the call are constants. This
    641. 

  641.         # is primarily for x86-64, to ensure that loading a constant to an
    642. 

  642.         # argument register or to the stack works correctly
    643. 

  643.         ops = '''
    644. 

  644.         [i0, i1, i2, i3, i4, i5, i6, i7]
    645. 

  645.         i8 = call(ConstClass(f10ptr), 1, i0, i1, i2, i3, i4, i5, i6, i7, 10, descr=f10_calldescr)
    646. 

  646.         finish(i8)
    647. 

  647.         '''
    648. 

  648.         loop = self.interpret(ops, [2, 3, 4, 5, 6, 7, 8, 9])
    649. 

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

  650.         clt = loop._jitcelltoken.compiled_loop_token
    651. 

  651.         assert clt.param_depth == self.expected_param_depth(10)
    652. 

  652. 

  653.     def test_bridge_calls_1(self):
    654. 

  654.         ops = '''
    655. 

  655.         [i0, i1]
    656. 

  656.         i2 = call(ConstClass(f1ptr), i0, descr=f1_calldescr)
    657. 

  657.         guard_value(i2, 0, descr=fdescr1) [i2, i1]
    658. 

  658.         finish(i1)
    659. 

  659.         '''
    660. 

  660.         loop = self.interpret(ops, [4, 7])
    661. 

  661.         assert self.getint(0) == 5
    662. 

  662.         ops = '''
    663. 

  663.         [i2, i1]
    664. 

  664.         i3 = call(ConstClass(f2ptr), i2, i1, descr=f2_calldescr)        
    665. 

  665.         finish(i3, descr=fdescr2)        
    666. 

  666.         '''
    667. 

  667.         bridge = self.attach_bridge(ops, loop, -2)
    668. 

  668. 

  669.         assert loop.operations[-2].getdescr()._x86_bridge_param_depth == self.expected_param_depth(2)
    670. 

  670. 

  671.         self.run(loop, 4, 7)
    672. 

  672.         assert self.getint(0) == 5*7
    673. 

  673. 

  674.     def test_bridge_calls_2(self):
    675. 

  675.         ops = '''
    676. 

  676.         [i0, i1]
    677. 

  677.         i2 = call(ConstClass(f2ptr), i0, i1, descr=f2_calldescr)
    678. 

  678.         guard_value(i2, 0, descr=fdescr1) [i2]
    679. 

  679.         finish(i1)
    680. 

  680.         '''
    681. 

  681.         loop = self.interpret(ops, [4, 7])
    682. 

  682.         assert self.getint(0) == 4*7
    683. 

  683.         ops = '''
    684. 

  684.         [i2]
    685. 

  685.         i3 = call(ConstClass(f1ptr), i2, descr=f1_calldescr)        
    686. 

  686.         finish(i3, descr=fdescr2)        
    687. 

  687.         '''
    688. 

  688.         bridge = self.attach_bridge(ops, loop, -2)
    689. 

  689. 

  690.         assert loop.operations[-2].getdescr()._x86_bridge_param_depth == self.expected_param_depth(2)
    691. 

  691. 

  692.         self.run(loop, 4, 7)
    693. 

  693.         assert self.getint(0) == 29
    694. 

  694. 

  695.