PageRenderTime 52ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/rpython/jit/metainterp/optimizeopt/test/test_util.py

https://bitbucket.org/pypy/pypy/
Python | 673 lines | 667 code | 6 blank | 0 comment | 3 complexity | c1518f29bc459a3a83b3fcf7de55711a MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0 
    

  1. import py, random, string
    2. 

  2. 

  3. from rpython.rlib.debug import debug_print
    4. 

  4. from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
    5. 

  5. from rpython.rtyper import rclass
    6. 

  6. from rpython.rtyper.rclass import (
    7. 

  7.     OBJECT, OBJECT_VTABLE, FieldListAccessor, IR_QUASIIMMUTABLE)
    8. 

  8. 

  9. from rpython.jit.backend.llgraph import runner
    10. 

  10. from rpython.jit.metainterp.history import (TreeLoop, AbstractDescr,
    11. 

  11.                                             JitCellToken, TargetToken)
    12. 

  12. from rpython.jit.metainterp.optimizeopt.util import sort_descrs, equaloplists
    13. 

  13. from rpython.jit.codewriter.effectinfo import EffectInfo, compute_bitstrings
    14. 

  14. from rpython.jit.metainterp.logger import LogOperations
    15. 

  15. from rpython.jit.tool.oparser import OpParser, pure_parse, convert_loop_to_trace
    16. 

  16. from rpython.jit.metainterp.quasiimmut import QuasiImmutDescr
    17. 

  17. from rpython.jit.metainterp import compile, resume, history
    18. 

  18. from rpython.jit.metainterp.jitprof import EmptyProfiler
    19. 

  19. from rpython.jit.metainterp.counter import DeterministicJitCounter
    20. 

  20. from rpython.config.translationoption import get_combined_translation_config
    21. 

  21. from rpython.jit.metainterp.resoperation import (rop, ResOperation,
    22. 

  22.         InputArgRef, AbstractValue, OpHelpers)
    23. 

  23. from rpython.jit.metainterp.optimizeopt.util import args_dict
    24. 

  24. from rpython.rlib.rjitlog import rjitlog as jl
    25. 

  25. 

  26. 

  27. def test_sort_descrs():
    28. 

  28.     class PseudoDescr(AbstractDescr):
    29. 

  29.         def __init__(self, n):
    30. 

  30.             self.n = n
    31. 

  31.         def sort_key(self):
    32. 

  32.             return self.n
    33. 

  33.     for i in range(17):
    34. 

  34.         lst = [PseudoDescr(j) for j in range(i)]
    35. 

  35.         lst2 = lst[:]
    36. 

  36.         random.shuffle(lst2)
    37. 

  37.         sort_descrs(lst2)
    38. 

  38.         assert lst2 == lst
    39. 

  39. 

  40. def make_remap(inp1, inp2):
    41. 

  41.     remap = {}
    42. 

  42.     for a, b in zip(inp1, inp2):
    43. 

  43.         remap[b] = a
    44. 

  44.     return remap
    45. 

  45. 

  46. def test_equaloplists():
    47. 

  47.     ops = """
    48. 

  48.     [i0]
    49. 

  49.     i1 = int_add(i0, 1)
    50. 

  50.     i2 = int_add(i1, 1)
    51. 

  51.     guard_true(i1) [i2]
    52. 

  52.     jump(i1)
    53. 

  53.     """
    54. 

  54.     namespace = {}
    55. 

  55.     loop1 = pure_parse(ops, namespace=namespace)
    56. 

  56.     loop2 = pure_parse(ops, namespace=namespace)
    57. 

  57.     loop3 = pure_parse(ops.replace("i2 = int_add", "i2 = int_sub"),
    58. 

  58.                        namespace=namespace)
    59. 

  59.     assert equaloplists(loop1.operations, loop2.operations,
    60. 

  60.                         remap=make_remap(loop1.inputargs,
    61. 

  61.                                          loop2.inputargs))
    62. 

  62.     py.test.raises(AssertionError,
    63. 

  63.                    "equaloplists(loop1.operations, loop3.operations,"
    64. 

  64.                    "remap=make_remap(loop1.inputargs, loop3.inputargs))")
    65. 

  65. 

  66. def test_equaloplists_fail_args():
    67. 

  67.     ops = """
    68. 

  68.     [i0]
    69. 

  69.     i1 = int_add(i0, 1)
    70. 

  70.     i2 = int_add(i1, 1)
    71. 

  71.     guard_true(i1) [i2, i1]
    72. 

  72.     jump(i1)
    73. 

  73.     """
    74. 

  74.     namespace = {}
    75. 

  75.     loop1 = pure_parse(ops, namespace=namespace)
    76. 

  76.     loop2 = pure_parse(ops.replace("[i2, i1]", "[i1, i2]"),
    77. 

  77.                        namespace=namespace)
    78. 

  78.     py.test.raises(AssertionError,
    79. 

  79.                    "equaloplists(loop1.operations, loop2.operations,"
    80. 

  80.                    "remap=make_remap(loop1.inputargs, loop2.inputargs))")
    81. 

  81.     assert equaloplists(loop1.operations, loop2.operations,
    82. 

  82.                         remap=make_remap(loop1.inputargs, loop2.inputargs),
    83. 

  83.                         strict_fail_args=False)
    84. 

  84.     loop3 = pure_parse(ops.replace("[i2, i1]", "[i2, i0]"),
    85. 

  85.                        namespace=namespace)
    86. 

  86.     py.test.raises(AssertionError,
    87. 

  87.                    "equaloplists(loop1.operations, loop3.operations,"
    88. 

  88.                    " remap=make_remap(loop1.inputargs, loop3.inputargs))")
    89. 

  89. 

  90. # ____________________________________________________________
    91. 

  91. 

  92. class LLtypeMixin(object):
    93. 

  93.     def get_class_of_box(self, box):
    94. 

  94.         base = box.getref_base()
    95. 

  95.         return lltype.cast_opaque_ptr(rclass.OBJECTPTR, base).typeptr
    96. 

  96. 

  97.     node_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    98. 

  98.     node_vtable.name = rclass.alloc_array_name('node')
    99. 

  99.     node_vtable_adr = llmemory.cast_ptr_to_adr(node_vtable)
    100. 

  100.     node_vtable2 = lltype.malloc(OBJECT_VTABLE, immortal=True)
    101. 

  101.     node_vtable2.name = rclass.alloc_array_name('node2')
    102. 

  102.     node_vtable_adr2 = llmemory.cast_ptr_to_adr(node_vtable2)
    103. 

  103.     node_vtable3 = lltype.malloc(OBJECT_VTABLE, immortal=True)
    104. 

  104.     node_vtable3.name = rclass.alloc_array_name('node3')
    105. 

  105.     node_vtable_adr3 = llmemory.cast_ptr_to_adr(node_vtable3)
    106. 

  106.     cpu = runner.LLGraphCPU(None)
    107. 

  107. 

  108.     NODE = lltype.GcForwardReference()
    109. 

  109.     S = lltype.GcForwardReference()
    110. 

  110.     NODE.become(lltype.GcStruct('NODE', ('parent', OBJECT),
    111. 

  111.                                         ('value', lltype.Signed),
    112. 

  112.                                         ('floatval', lltype.Float),
    113. 

  113.                                         ('charval', lltype.Char),
    114. 

  114.                                         ('nexttuple', lltype.Ptr(S)),
    115. 

  115.                                         ('next', lltype.Ptr(NODE))))
    116. 

  116.     S.become(lltype.GcStruct('TUPLE', ('a', lltype.Signed), ('abis', lltype.Signed),
    117. 

  117.                         ('b', lltype.Ptr(NODE))))
    118. 

  118.     NODE2 = lltype.GcStruct('NODE2', ('parent', NODE),
    119. 

  119.                                      ('other', lltype.Ptr(NODE)))
    120. 

  120. 

  121.     NODE3 = lltype.GcForwardReference()
    122. 

  122.     NODE3.become(lltype.GcStruct('NODE3', ('parent', OBJECT),
    123. 

  123.                             ('value', lltype.Signed),
    124. 

  124.                             ('next', lltype.Ptr(NODE3)),
    125. 

  125.                             hints={'immutable': True}))
    126. 

  126. 

  127.     big_fields = [('big' + i, lltype.Signed) for i in string.ascii_lowercase]
    128. 

  128.     BIG = lltype.GcForwardReference()
    129. 

  129.     BIG.become(lltype.GcStruct('BIG', *big_fields, hints={'immutable': True}))
    130. 

  130. 

  131.     for field, _ in big_fields:
    132. 

  132.         locals()[field + 'descr'] = cpu.fielddescrof(BIG, field)
    133. 

  133. 

  134.     node = lltype.malloc(NODE)
    135. 

  135.     node.value = 5
    136. 

  136.     node.next = node
    137. 

  137.     node.parent.typeptr = node_vtable
    138. 

  138.     nodeaddr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
    139. 

  139.     #nodebox = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node))
    140. 

  140.     node2 = lltype.malloc(NODE2)
    141. 

  141.     node2.parent.parent.typeptr = node_vtable2
    142. 

  142.     node2addr = lltype.cast_opaque_ptr(llmemory.GCREF, node2)
    143. 

  143.     myptr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
    144. 

  144.     mynodeb = lltype.malloc(NODE)
    145. 

  145.     myarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(lltype.GcArray(lltype.Signed), 13, zero=True))
    146. 

  146.     mynodeb.parent.typeptr = node_vtable
    147. 

  147.     myptrb = lltype.cast_opaque_ptr(llmemory.GCREF, mynodeb)
    148. 

  148.     myptr2 = lltype.malloc(NODE2)
    149. 

  149.     myptr2.parent.parent.typeptr = node_vtable2
    150. 

  150.     myptr2 = lltype.cast_opaque_ptr(llmemory.GCREF, myptr2)
    151. 

  151.     nullptr = lltype.nullptr(llmemory.GCREF.TO)
    152. 

  152. 

  153.     mynode3 = lltype.malloc(NODE3)
    154. 

  154.     mynode3.parent.typeptr = node_vtable3
    155. 

  155.     mynode3.value = 7
    156. 

  156.     mynode3.next = mynode3
    157. 

  157.     myptr3 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode3)   # a NODE2
    158. 

  158.     mynode4 = lltype.malloc(NODE3)
    159. 

  159.     mynode4.parent.typeptr = node_vtable3
    160. 

  160.     myptr4 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode4)   # a NODE3
    161. 

  161. 

  162. 

  163.     nullptr = lltype.nullptr(llmemory.GCREF.TO)
    164. 

  164.     #nodebox2 = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node2))
    165. 

  165.     nodesize = cpu.sizeof(NODE, node_vtable)
    166. 

  166.     node_tid = nodesize.get_type_id()
    167. 

  167.     nodesize2 = cpu.sizeof(NODE2, node_vtable2)
    168. 

  168.     nodesize3 = cpu.sizeof(NODE3, node_vtable3)
    169. 

  169.     valuedescr = cpu.fielddescrof(NODE, 'value')
    170. 

  170.     floatdescr = cpu.fielddescrof(NODE, 'floatval')
    171. 

  171.     chardescr = cpu.fielddescrof(NODE, 'charval')
    172. 

  172.     nextdescr = cpu.fielddescrof(NODE, 'next')
    173. 

  173.     nexttupledescr = cpu.fielddescrof(NODE, 'nexttuple')
    174. 

  174.     otherdescr = cpu.fielddescrof(NODE2, 'other')
    175. 

  175.     valuedescr3 = cpu.fielddescrof(NODE3, 'value')
    176. 

  176.     nextdescr3 = cpu.fielddescrof(NODE3, 'next')
    177. 

  177.     assert valuedescr3.is_always_pure()
    178. 

  178.     assert nextdescr3.is_always_pure()
    179. 

  179. 

  180.     accessor = FieldListAccessor()
    181. 

  181.     accessor.initialize(None, {'inst_field': IR_QUASIIMMUTABLE})
    182. 

  182.     QUASI = lltype.GcStruct('QUASIIMMUT', ('inst_field', lltype.Signed),
    183. 

  183.                             ('mutate_field', rclass.OBJECTPTR),
    184. 

  184.                             hints={'immutable_fields': accessor})
    185. 

  185.     quasisize = cpu.sizeof(QUASI, None)
    186. 

  186.     quasi = lltype.malloc(QUASI, immortal=True)
    187. 

  187.     quasi.inst_field = -4247
    188. 

  188.     quasifielddescr = cpu.fielddescrof(QUASI, 'inst_field')
    189. 

  189.     quasiptr = lltype.cast_opaque_ptr(llmemory.GCREF, quasi)
    190. 

  190.     quasiimmutdescr = QuasiImmutDescr(cpu, quasiptr, quasifielddescr,
    191. 

  191.                                       cpu.fielddescrof(QUASI, 'mutate_field'))
    192. 

  192. 

  193.     NODEOBJ = lltype.GcStruct('NODEOBJ', ('parent', OBJECT),
    194. 

  194.                                          ('ref', lltype.Ptr(OBJECT)))
    195. 

  195.     nodeobj = lltype.malloc(NODEOBJ)
    196. 

  196.     nodeobjvalue = lltype.cast_opaque_ptr(llmemory.GCREF, nodeobj)
    197. 

  197.     refdescr = cpu.fielddescrof(NODEOBJ, 'ref')
    198. 

  198. 

  199.     INTOBJ_NOIMMUT = lltype.GcStruct('INTOBJ_NOIMMUT', ('parent', OBJECT),
    200. 

  200.                                                 ('intval', lltype.Signed))
    201. 

  201.     INTOBJ_IMMUT = lltype.GcStruct('INTOBJ_IMMUT', ('parent', OBJECT),
    202. 

  202.                                             ('intval', lltype.Signed),
    203. 

  203.                                             hints={'immutable': True})
    204. 

  204.     intobj_noimmut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    205. 

  205.     intobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    206. 

  206.     noimmut_intval = cpu.fielddescrof(INTOBJ_NOIMMUT, 'intval')
    207. 

  207.     immut_intval = cpu.fielddescrof(INTOBJ_IMMUT, 'intval')
    208. 

  208.     immut = lltype.malloc(INTOBJ_IMMUT, zero=True)
    209. 

  209.     immutaddr = lltype.cast_opaque_ptr(llmemory.GCREF, immut)
    210. 

  210.     noimmut_descr = cpu.sizeof(INTOBJ_NOIMMUT, intobj_noimmut_vtable)
    211. 

  211.     immut_descr = cpu.sizeof(INTOBJ_IMMUT, intobj_immut_vtable)
    212. 

  212. 

  213.     PTROBJ_IMMUT = lltype.GcStruct('PTROBJ_IMMUT', ('parent', OBJECT),
    214. 

  214.                                             ('ptrval', lltype.Ptr(OBJECT)),
    215. 

  215.                                             hints={'immutable': True})
    216. 

  216.     ptrobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    217. 

  217.     ptrobj_immut_descr = cpu.sizeof(PTROBJ_IMMUT, ptrobj_immut_vtable)
    218. 

  218.     immut_ptrval = cpu.fielddescrof(PTROBJ_IMMUT, 'ptrval')
    219. 

  219. 

  220.     arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed))
    221. 

  221.     int32arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.INT))
    222. 

  222.     int16arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.SHORT))
    223. 

  223.     float32arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.SingleFloat))
    224. 

  224.     arraydescr_tid = arraydescr.get_type_id()
    225. 

  225.     array = lltype.malloc(lltype.GcArray(lltype.Signed), 15, zero=True)
    226. 

  226.     arrayref = lltype.cast_opaque_ptr(llmemory.GCREF, array)
    227. 

  227.     array2 = lltype.malloc(lltype.GcArray(lltype.Ptr(S)), 15, zero=True)
    228. 

  228.     array2ref = lltype.cast_opaque_ptr(llmemory.GCREF, array2)
    229. 

  229.     gcarraydescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF))
    230. 

  230.     gcarraydescr_tid = gcarraydescr.get_type_id()
    231. 

  231.     floatarraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Float))
    232. 

  232. 

  233.     arrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed, hints={"immutable": True}))
    234. 

  234.     immutarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(arrayimmutdescr.A, 13, zero=True))
    235. 

  235.     gcarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF, hints={"immutable": True}))
    236. 

  236.     floatarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Float, hints={"immutable": True}))
    237. 

  237. 

  238.     # a GcStruct not inheriting from OBJECT
    239. 

  239.     tpl = lltype.malloc(S, zero=True)
    240. 

  240.     tupleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, tpl)
    241. 

  241.     nodefull2 = lltype.malloc(NODE, zero=True)
    242. 

  242.     nodefull2addr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull2)
    243. 

  243.     ssize = cpu.sizeof(S, None)
    244. 

  244.     adescr = cpu.fielddescrof(S, 'a')
    245. 

  245.     abisdescr = cpu.fielddescrof(S, 'abis')
    246. 

  246.     bdescr = cpu.fielddescrof(S, 'b')
    247. 

  247.     #sbox = BoxPtr(lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S)))
    248. 

  248.     arraydescr2 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(S)))
    249. 

  249. 

  250.     T = lltype.GcStruct('TUPLE',
    251. 

  251.                         ('c', lltype.Signed),
    252. 

  252.                         ('d', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))
    253. 

  253. 

  254.     W_ROOT = lltype.GcStruct('W_ROOT', ('parent', OBJECT),
    255. 

  255.         ('inst_w_seq', llmemory.GCREF), ('inst_index', lltype.Signed),
    256. 

  256.         ('inst_w_list', llmemory.GCREF), ('inst_length', lltype.Signed),
    257. 

  257.         ('inst_start', lltype.Signed), ('inst_step', lltype.Signed))
    258. 

  258.     inst_w_seq = cpu.fielddescrof(W_ROOT, 'inst_w_seq')
    259. 

  259.     inst_index = cpu.fielddescrof(W_ROOT, 'inst_index')
    260. 

  260.     inst_length = cpu.fielddescrof(W_ROOT, 'inst_length')
    261. 

  261.     inst_start = cpu.fielddescrof(W_ROOT, 'inst_start')
    262. 

  262.     inst_step = cpu.fielddescrof(W_ROOT, 'inst_step')
    263. 

  263.     inst_w_list = cpu.fielddescrof(W_ROOT, 'inst_w_list')
    264. 

  264.     w_root_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    265. 

  265.     
    266. 

  266.     tsize = cpu.sizeof(T, None)
    267. 

  267.     cdescr = cpu.fielddescrof(T, 'c')
    268. 

  268.     ddescr = cpu.fielddescrof(T, 'd')
    269. 

  269.     arraydescr3 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(NODE3)))
    270. 

  270. 

  271.     U = lltype.GcStruct('U',
    272. 

  272.                         ('parent', OBJECT),
    273. 

  273.                         ('one', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))
    274. 

  274.     u_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    275. 

  275.     u_vtable_adr = llmemory.cast_ptr_to_adr(u_vtable)
    276. 

  276.     SIMPLE = lltype.GcStruct('simple',
    277. 

  277.         ('parent', OBJECT),
    278. 

  278.         ('value', lltype.Signed))
    279. 

  279.     simplevalue = cpu.fielddescrof(SIMPLE, 'value')
    280. 

  280.     simple_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
    281. 

  281.     simpledescr = cpu.sizeof(SIMPLE, simple_vtable)
    282. 

  282.     simple = lltype.malloc(SIMPLE, zero=True)
    283. 

  283.     simpleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, simple)
    284. 

  284.     #usize = cpu.sizeof(U, ...)
    285. 

  285.     onedescr = cpu.fielddescrof(U, 'one')
    286. 

  286. 

  287.     FUNC = lltype.FuncType([lltype.Signed], lltype.Signed)
    288. 

  288.     plaincalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    289. 

  289.                                      EffectInfo.MOST_GENERAL)
    290. 

  290.     elidablecalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    291. 

  291.                                     EffectInfo([valuedescr], [], [],
    292. 

  292.                                                [valuedescr], [], [],
    293. 

  293.                                          EffectInfo.EF_ELIDABLE_CANNOT_RAISE))
    294. 

  294.     elidable2calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    295. 

  295.                                     EffectInfo([valuedescr], [], [],
    296. 

  296.                                                [valuedescr], [], [],
    297. 

  297.                                          EffectInfo.EF_ELIDABLE_OR_MEMORYERROR))
    298. 

  298.     elidable3calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    299. 

  299.                                     EffectInfo([valuedescr], [], [],
    300. 

  300.                                                [valuedescr], [], [],
    301. 

  301.                                          EffectInfo.EF_ELIDABLE_CAN_RAISE))
    302. 

  302.     nonwritedescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    303. 

  303.                                     EffectInfo([], [], [], [], [], []))
    304. 

  304.     writeadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    305. 

  305.                                   EffectInfo([], [], [], [adescr], [], []))
    306. 

  306.     writearraydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    307. 

  307.                                   EffectInfo([], [], [], [adescr], [arraydescr],
    308. 

  308.                                              []))
    309. 

  309.     writevalue3descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    310. 

  310.                                        EffectInfo([], [], [], [valuedescr3], [], []))
    311. 

  311.     readadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    312. 

  312.                                  EffectInfo([adescr], [], [], [], [], []))
    313. 

  313.     mayforcevirtdescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    314. 

  314.                  EffectInfo([nextdescr], [], [], [], [], [],
    315. 

  315.                             EffectInfo.EF_FORCES_VIRTUAL_OR_VIRTUALIZABLE,
    316. 

  316.                             can_invalidate=True))
    317. 

  317.     arraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    318. 

  318.              EffectInfo([], [arraydescr], [], [], [arraydescr], [],
    319. 

  319.                         EffectInfo.EF_CANNOT_RAISE,
    320. 

  320.                         oopspecindex=EffectInfo.OS_ARRAYCOPY))
    321. 

  321. 

  322.     raw_malloc_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    323. 

  323.              EffectInfo([], [], [], [], [], [],
    324. 

  324.                         EffectInfo.EF_CAN_RAISE,
    325. 

  325.                         oopspecindex=EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR))
    326. 

  326.     raw_free_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    327. 

  327.              EffectInfo([], [], [], [], [], [],
    328. 

  328.                         EffectInfo.EF_CANNOT_RAISE,
    329. 

  329.                         oopspecindex=EffectInfo.OS_RAW_FREE))
    330. 

  330. 

  331.     chararray = lltype.GcArray(lltype.Char)
    332. 

  332.     chararraydescr = cpu.arraydescrof(chararray)
    333. 

  333.     u2array = lltype.GcArray(rffi.USHORT)
    334. 

  334.     u2arraydescr = cpu.arraydescrof(u2array)
    335. 

  335. 

  336.     nodefull = lltype.malloc(NODE2, zero=True)
    337. 

  337.     nodefull.parent.next = lltype.cast_pointer(lltype.Ptr(NODE), nodefull)
    338. 

  338.     nodefull.parent.nexttuple = tpl
    339. 

  339.     nodefulladdr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull)
    340. 

  340. 

  341.     # array of structs (complex data)
    342. 

  342.     complexarray = lltype.GcArray(
    343. 

  343.         lltype.Struct("complex",
    344. 

  344.             ("real", lltype.Float),
    345. 

  345.             ("imag", lltype.Float),
    346. 

  346.         )
    347. 

  347.     )
    348. 

  348.     complexarraydescr = cpu.arraydescrof(complexarray)
    349. 

  349.     complexrealdescr = cpu.interiorfielddescrof(complexarray, "real")
    350. 

  350.     compleximagdescr = cpu.interiorfielddescrof(complexarray, "imag")
    351. 

  351.     complexarraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    352. 

  352.             EffectInfo([], [complexarraydescr], [], [], [complexarraydescr], [],
    353. 

  353.                        EffectInfo.EF_CANNOT_RAISE,
    354. 

  354.                        oopspecindex=EffectInfo.OS_ARRAYCOPY))
    355. 

  355. 

  356.     rawarraydescr = cpu.arraydescrof(lltype.Array(lltype.Signed,
    357. 

  357.                                                   hints={'nolength': True}))
    358. 

  358.     rawarraydescr_char = cpu.arraydescrof(lltype.Array(lltype.Char,
    359. 

  359.                                                        hints={'nolength': True}))
    360. 

  360.     rawarraydescr_float = cpu.arraydescrof(lltype.Array(lltype.Float,
    361. 

  361.                                                         hints={'nolength': True}))
    362. 

  362. 

  363.     fc_array = lltype.GcArray(
    364. 

  364.         lltype.Struct(
    365. 

  365.             "floatchar", ("float", lltype.Float), ("char", lltype.Char)))
    366. 

  366.     fc_array_descr = cpu.arraydescrof(fc_array)
    367. 

  367.     fc_array_floatdescr = cpu.interiorfielddescrof(fc_array, "float")
    368. 

  368.     fc_array_chardescr = cpu.interiorfielddescrof(fc_array, "char")
    369. 

  369. 

  370.     for _name, _os in [
    371. 

  371.         ('strconcatdescr',               'OS_STR_CONCAT'),
    372. 

  372.         ('strslicedescr',                'OS_STR_SLICE'),
    373. 

  373.         ('strequaldescr',                'OS_STR_EQUAL'),
    374. 

  374.         ('streq_slice_checknull_descr',  'OS_STREQ_SLICE_CHECKNULL'),
    375. 

  375.         ('streq_slice_nonnull_descr',    'OS_STREQ_SLICE_NONNULL'),
    376. 

  376.         ('streq_slice_char_descr',       'OS_STREQ_SLICE_CHAR'),
    377. 

  377.         ('streq_nonnull_descr',          'OS_STREQ_NONNULL'),
    378. 

  378.         ('streq_nonnull_char_descr',     'OS_STREQ_NONNULL_CHAR'),
    379. 

  379.         ('streq_checknull_char_descr',   'OS_STREQ_CHECKNULL_CHAR'),
    380. 

  380.         ('streq_lengthok_descr',         'OS_STREQ_LENGTHOK'),
    381. 

  381.         ]:
    382. 

  382.         if _name in ('strconcatdescr', 'strslicedescr'):
    383. 

  383.             _extra = EffectInfo.EF_ELIDABLE_OR_MEMORYERROR
    384. 

  384.         else:
    385. 

  385.             _extra = EffectInfo.EF_ELIDABLE_CANNOT_RAISE
    386. 

  386.         _oopspecindex = getattr(EffectInfo, _os)
    387. 

  387.         locals()[_name] = \
    388. 

  388.             cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    389. 

  389.                 EffectInfo([], [], [], [], [], [], _extra,
    390. 

  390.                            oopspecindex=_oopspecindex))
    391. 

  391.         #
    392. 

  392.         _oopspecindex = getattr(EffectInfo, _os.replace('STR', 'UNI'))
    393. 

  393.         locals()[_name.replace('str', 'unicode')] = \
    394. 

  394.             cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    395. 

  395.                 EffectInfo([], [], [], [], [], [], _extra,
    396. 

  396.                            oopspecindex=_oopspecindex))
    397. 

  397. 

  398.     s2u_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
    399. 

  399.             EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CAN_RAISE,
    400. 

  400.                        oopspecindex=EffectInfo.OS_STR2UNICODE))
    401. 

  401.     #
    402. 

  402. 

  403.     class LoopToken(AbstractDescr):
    404. 

  404.         pass
    405. 

  405.     asmdescr = LoopToken() # it can be whatever, it's not a descr though
    406. 

    407. 

  407.     from rpython.jit.metainterp.virtualref import VirtualRefInfo
    408. 

  408. 

  409.     class FakeWarmRunnerDesc:
    410. 

  410.         pass
    411. 

  411.     FakeWarmRunnerDesc.cpu = cpu
    412. 

  412.     vrefinfo = VirtualRefInfo(FakeWarmRunnerDesc)
    413. 

  413.     virtualtokendescr = vrefinfo.descr_virtual_token
    414. 

  414.     virtualforceddescr = vrefinfo.descr_forced
    415. 

  415.     FUNC = lltype.FuncType([], lltype.Void)
    416. 

  416.     ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_CANNOT_RAISE,
    417. 

  417.                     can_invalidate=False,
    418. 

  418.                     oopspecindex=EffectInfo.OS_JIT_FORCE_VIRTUALIZABLE)
    419. 

  419.     clear_vable = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)
    420. 

  420. 

  421.     jit_virtual_ref_vtable = vrefinfo.jit_virtual_ref_vtable
    422. 

  422.     jvr_vtable_adr = llmemory.cast_ptr_to_adr(jit_virtual_ref_vtable)
    423. 

  423.     vref_descr = cpu.sizeof(vrefinfo.JIT_VIRTUAL_REF, jit_virtual_ref_vtable)
    424. 

  424. 

  425.     FUNC = lltype.FuncType([lltype.Signed, lltype.Signed], lltype.Signed)
    426. 

  426.     ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CANNOT_RAISE,
    427. 

  427.                     can_invalidate=False,
    428. 

  428.                     oopspecindex=EffectInfo.OS_INT_PY_DIV)
    429. 

  429.     int_py_div_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)
    430. 

  430.     ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CANNOT_RAISE,
    431. 

  431.                     can_invalidate=False,
    432. 

  432.                     oopspecindex=EffectInfo.OS_INT_UDIV)
    433. 

  433.     int_udiv_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)
    434. 

  434.     ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CANNOT_RAISE,
    435. 

  435.                     can_invalidate=False,
    436. 

  436.                     oopspecindex=EffectInfo.OS_INT_PY_MOD)
    437. 

  437.     int_py_mod_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)
    438. 

  438. 

  439.     namespace = locals()
    440. 

  440. 

  441. 

  442. class FakeCallInfoCollection:
    443. 

  443.     def callinfo_for_oopspec(self, oopspecindex):
    444. 

  444.         calldescrtype = type(LLtypeMixin.strequaldescr)
    445. 

  445.         effectinfotype = type(LLtypeMixin.strequaldescr.get_extra_info())
    446. 

  446.         for value in LLtypeMixin.__dict__.values():
    447. 

  447.             if isinstance(value, calldescrtype):
    448. 

  448.                 extra = value.get_extra_info()
    449. 

  449.                 if (extra and isinstance(extra, effectinfotype) and
    450. 

  450.                     extra.oopspecindex == oopspecindex):
    451. 

  451.                     # returns 0 for 'func' in this test
    452. 

  452.                     return value, 0
    453. 

  453.         raise AssertionError("not found: oopspecindex=%d" %
    454. 

  454.                              oopspecindex)
    455. 

  455. 

  456.     calldescr_udiv = LLtypeMixin.int_udiv_descr
    457. 

  457.     #calldescr_umod = LLtypeMixin.int_umod_descr
    458. 

  458. 

  459. LLtypeMixin.callinfocollection = FakeCallInfoCollection()
    460. 

  460. 

  461. 

  462. # ____________________________________________________________
    463. 

  463. 

  464. 

  465. class Fake(object):
    466. 

  466.     failargs_limit = 1000
    467. 

  467.     storedebug = None
    468. 

  468. 

  469. class FakeWarmState(object):
    470. 

  470.     vec = True # default is on
    471. 

  471.     vec_all = False
    472. 

  472.     vec_cost = 0
    473. 

  473.     def __init__(self, enable_opts):
    474. 

  474.         self.enable_opts = enable_opts
    475. 

  475. 

  476. class FakeJitDriverStaticData(object):
    477. 

  477.     vec = False
    478. 

  478. 

  479. class FakeMetaInterpStaticData(object):
    480. 

  480.     all_descrs = []
    481. 

  481. 

  482.     def __init__(self, cpu):
    483. 

  483.         self.cpu = cpu
    484. 

  484.         self.profiler = EmptyProfiler()
    485. 

  485.         self.options = Fake()
    486. 

  486.         self.globaldata = Fake()
    487. 

  487.         self.config = get_combined_translation_config(translating=True)
    488. 

  488.         self.jitlog = jl.JitLogger()
    489. 

  489. 

  490.     class logger_noopt:
    491. 

  491.         @classmethod
    492. 

  492.         def log_loop(*args, **kwds):
    493. 

  493.             pass
    494. 

  494. 

  495.         @classmethod
    496. 

  496.         def log_loop_from_trace(*args, **kwds):
    497. 

  497.             pass
    498. 

  498. 

  499.     class logger_ops:
    500. 

  500.         repr_of_resop = repr
    501. 

  501. 

  502.     class warmrunnerdesc:
    503. 

  503.         class memory_manager:
    504. 

  504.             retrace_limit = 5
    505. 

  505.             max_retrace_guards = 15
    506. 

  506.         jitcounter = DeterministicJitCounter()
    507. 

  507. 

  508.     def get_name_from_address(self, addr):
    509. 

  509.         # hack
    510. 

  510.         try:
    511. 

  511.             return "".join(addr.ptr.name.chars)
    512. 

  512.         except AttributeError:
    513. 

  513.             return ""
    514. 

  514. 

  515. class Info(object):
    516. 

  516.     def __init__(self, preamble, short_preamble=None, virtual_state=None):
    517. 

  517.         self.preamble = preamble
    518. 

  518.         self.short_preamble = short_preamble
    519. 

  519.         self.virtual_state = virtual_state
    520. 

  520. 

  521. class Storage(compile.ResumeGuardDescr):
    522. 

  522.     "for tests."
    523. 

  523.     def __init__(self, metainterp_sd=None, original_greenkey=None):
    524. 

  524.         self.metainterp_sd = metainterp_sd
    525. 

  525.         self.original_greenkey = original_greenkey
    526. 

  526.     def store_final_boxes(self, op, boxes, metainterp_sd):
    527. 

  527.         op.setfailargs(boxes)
    528. 

  528.     def __eq__(self, other):
    529. 

  529.         return True # screw this
    530. 

  530.         #return type(self) is type(other)      # xxx obscure
    531. 

  531. 

  532. def _sortboxes(boxes):
    533. 

  533.     _kind2count = {history.INT: 1, history.REF: 2, history.FLOAT: 3}
    534. 

  534.     return sorted(boxes, key=lambda box: _kind2count[box.type])
    535. 

  535. 

  536. final_descr = history.BasicFinalDescr()
    537. 

  537. 

  538. class BaseTest(object):
    539. 

  539. 

  540.     def parse(self, s, boxkinds=None, want_fail_descr=True, postprocess=None):
    541. 

  541.         AbstractValue._repr_memo.counter = 0
    542. 

  542.         self.oparse = OpParser(s, self.cpu, self.namespace, boxkinds,
    543. 

  543.                                None, False, postprocess)
    544. 

  544.         return self.oparse.parse()
    545. 

  545. 

  546.     def add_guard_future_condition(self, res):
    547. 

  547.         # invent a GUARD_FUTURE_CONDITION to not have to change all tests
    548. 

  548.         if res.operations[-1].getopnum() == rop.JUMP:
    549. 

  549.             guard = ResOperation(rop.GUARD_FUTURE_CONDITION, [])
    550. 

  550.             res.operations.insert(-1, guard)
    551. 

  551. 

  552.     @staticmethod
    553. 

  553.     def assert_equal(optimized, expected, text_right=None):
    554. 

  554.         from rpython.jit.metainterp.optimizeopt.util import equaloplists
    555. 

  555.         assert len(optimized.inputargs) == len(expected.inputargs)
    556. 

  556.         remap = {}
    557. 

  557.         for box1, box2 in zip(optimized.inputargs, expected.inputargs):
    558. 

  558.             assert box1.type == box2.type
    559. 

  559.             remap[box2] = box1
    560. 

  560.         assert equaloplists(optimized.operations,
    561. 

  561.                             expected.operations, False, remap, text_right)
    562. 

  562. 

  563.     def _do_optimize_loop(self, compile_data):
    564. 

  564.         from rpython.jit.metainterp.optimizeopt import optimize_trace
    565. 

  565.         metainterp_sd = FakeMetaInterpStaticData(self.cpu)
    566. 

  566.         if hasattr(self, 'vrefinfo'):
    567. 

  567.             metainterp_sd.virtualref_info = self.vrefinfo
    568. 

  568.         if hasattr(self, 'callinfocollection'):
    569. 

  569.             metainterp_sd.callinfocollection = self.callinfocollection
    570. 

  570.         compute_bitstrings(self.cpu.fetch_all_descrs())
    571. 

  571.         #
    572. 

  572.         compile_data.enable_opts = self.enable_opts
    573. 

  573.         state = optimize_trace(metainterp_sd, None, compile_data)
    574. 

  574.         return state
    575. 

  575. 

  576.     def _convert_call_pure_results(self, d):
    577. 

  577.         from rpython.jit.metainterp.optimizeopt.util import args_dict
    578. 

  578. 

  579.         if d is None:
    580. 

  580.             return
    581. 

  581.         call_pure_results = args_dict()
    582. 

  582.         for k, v in d.items():
    583. 

  583.             call_pure_results[list(k)] = v
    584. 

  584.         return call_pure_results
    585. 

  585. 

  586.     def convert_values(self, inpargs, values):
    587. 

  587.         from rpython.jit.metainterp.history import IntFrontendOp, RefFrontendOp
    588. 

  588.         if values:
    589. 

  589.             r = []
    590. 

  590.             for arg, v in zip(inpargs, values):
    591. 

  591.                 if arg.type == 'i':
    592. 

  592.                     n = IntFrontendOp(0)
    593. 

  593.                     if v is not None:
    594. 

  594.                         n.setint(v)
    595. 

  595.                 else:
    596. 

  596.                     n = RefFrontendOp(0)
    597. 

  597.                     if v is not None:
    598. 

  598.                         n.setref_base(v)
    599. 

  599.                     assert arg.type == 'r'
    600. 

  600.                 r.append(n)
    601. 

  601.             return r
    602. 

  602.         return inpargs
    603. 

  603. 

  604.     def unroll_and_optimize(self, loop, call_pure_results=None,
    605. 

  605.                             jump_values=None):
    606. 

  606.         self.add_guard_future_condition(loop)
    607. 

  607.         jump_op = loop.operations[-1]
    608. 

  608.         assert jump_op.getopnum() == rop.JUMP
    609. 

  609.         celltoken = JitCellToken()
    610. 

  610.         runtime_boxes = self.pack_into_boxes(jump_op, jump_values)
    611. 

  611.         jump_op.setdescr(celltoken)
    612. 

  612.         #start_label = ResOperation(rop.LABEL, loop.inputargs,
    613. 

  613.         #                           descr=jump_op.getdescr())
    614. 

  614.         #end_label = jump_op.copy_and_change(opnum=rop.LABEL)
    615. 

  615.         call_pure_results = self._convert_call_pure_results(call_pure_results)
    616. 

  616.         t = convert_loop_to_trace(loop, FakeMetaInterpStaticData(self.cpu))
    617. 

  617.         preamble_data = compile.LoopCompileData(t, runtime_boxes,
    618. 

  618.                                                 call_pure_results)
    619. 

  619.         start_state, preamble_ops = self._do_optimize_loop(preamble_data)
    620. 

  620.         preamble_data.forget_optimization_info()
    621. 

  621.         loop_data = compile.UnrolledLoopData(preamble_data.trace,
    622. 

  622.             celltoken, start_state, call_pure_results)
    623. 

  623.         loop_info, ops = self._do_optimize_loop(loop_data)
    624. 

  624.         preamble = TreeLoop('preamble')
    625. 

  625.         preamble.inputargs = start_state.renamed_inputargs
    626. 

  626.         start_label = ResOperation(rop.LABEL, start_state.renamed_inputargs)
    627. 

  627.         preamble.operations = ([start_label] + preamble_ops +
    628. 

  628.                                loop_info.extra_same_as + [loop_info.label_op])
    629. 

  629.         loop.inputargs = loop_info.label_op.getarglist()[:]
    630. 

  630.         loop.operations = [loop_info.label_op] + ops
    631. 

  631.         return Info(preamble, loop_info.target_token.short_preamble,
    632. 

  632.                     start_state.virtual_state)
    633. 

  633. 

  634.     def pack_into_boxes(self, jump_op, jump_values):
    635. 

  635.         assert jump_op.getopnum() == rop.JUMP
    636. 

  636.         r = []
    637. 

  637.         if jump_values is not None:
    638. 

  638.             assert len(jump_values) == len(jump_op.getarglist())
    639. 

  639.             for i, v in enumerate(jump_values):
    640. 

  640.                 if v is not None:
    641. 

  641.                     r.append(InputArgRef(v))
    642. 

  642.                 else:
    643. 

  643.                     r.append(None)
    644. 

  644.         else:
    645. 

  645.             for i, box in enumerate(jump_op.getarglist()):
    646. 

  646.                 if box.type == 'r' and not box.is_constant():
    647. 

  647.                     # NOTE: we arbitrarily set the box contents to a NODE2
    648. 

  648.                     # object here.  If you need something different, you
    649. 

  649.                     # need to pass a 'jump_values' argument to e.g.
    650. 

  650.                     # optimize_loop()
    651. 

  651.                     r.append(InputArgRef(self.nodefulladdr))
    652. 

  652.                 else:
    653. 

  653.                     r.append(None)
    654. 

  654.         return r
    655. 

  655. 

  656. class FakeDescr(compile.ResumeGuardDescr):
    657. 

  657.     def clone_if_mutable(self):
    658. 

  658.         return FakeDescr()
    659. 

  659.     def __eq__(self, other):
    660. 

  660.         return isinstance(other, FakeDescr)
    661. 

  661. 

  662. def convert_old_style_to_targets(loop, jump):
    663. 

  663.     newloop = TreeLoop(loop.name)
    664. 

  664.     newloop.inputargs = loop.inputargs
    665. 

  665.     newloop.operations = [ResOperation(rop.LABEL, loop.inputargs, descr=FakeDescr())] + \
    666. 

  666.                       loop.operations
    667. 

  667.     if not jump:
    668. 

  668.         assert newloop.operations[-1].getopnum() == rop.JUMP
    669. 

  669.         newloop.operations[-1] = newloop.operations[-1].copy_and_change(
    670. 

  670.             rop.LABEL)
    671. 

  671.     return newloop
    672. 

  672. 

  673. # ____________________________________________________________
    674. 

  674.