PageRenderTime 52ms CodeModel.GetById 14ms RepoModel.GetById 1ms app.codeStats 0ms

/rpython/jit/backend/ppc/codebuilder.py

https://bitbucket.org/pypy/pypy/
Python | 1294 lines | 1050 code | 206 blank | 38 comment | 28 complexity | 36e55a2236e77e331cc962b0654597e7 MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0 
    

  1. import os
    2. 

  2. from rpython.jit.backend.ppc.ppc_form import PPCForm as Form
    3. 

  3. from rpython.jit.backend.ppc.locations import RegisterLocation
    4. 

  4. from rpython.jit.backend.ppc.ppc_field import ppc_fields
    5. 

  5. from rpython.jit.backend.ppc.arch import (IS_PPC_32, WORD, IS_PPC_64,
    6. 

  6.                                 LR_BC_OFFSET, IS_BIG_ENDIAN, IS_LITTLE_ENDIAN)
    7. 

  7. import rpython.jit.backend.ppc.register as r
    8. 

  8. import rpython.jit.backend.ppc.condition as c
    9. 

  9. from rpython.jit.backend.llsupport.asmmemmgr import BlockBuilderMixin
    10. 

  10. from rpython.jit.backend.llsupport.assembler import GuardToken
    11. 

  11. from rpython.rtyper.lltypesystem import lltype, rffi
    12. 

  12. from rpython.jit.metainterp.resoperation import rop
    13. 

  13. from rpython.tool.udir import udir
    14. 

  14. from rpython.rlib.objectmodel import we_are_translated
    15. 

  15. 

  16. from rpython.translator.tool.cbuild import ExternalCompilationInfo
    17. 

  17. from rpython.jit.backend.ppc.rassemblermaker import make_rassembler
    18. 

  18. 

  19. 

  20. # the following instructions can't accept "r0" as the second argument
    21. 

  21. # (i.e. the base address): it is recognized as "0" instead, or is
    22. 

  22. # even invalid (load-with-update, store-with-update).
    23. 

  23. #
    24. 

  24. #    any load or store instruction
    25. 

  25. #    addi rD, r0, immed
    26. 

  26. #    subi rD, r0, immed
    27. 

  27. #    addis rD, r0, immed
    28. 

  28. #    subis rD, r0, immed
    29. 

  29. 

  30. 

  31. A = Form("frD", "frA", "frB", "XO3", "Rc")
    32. 

  32. A1 = Form("frD", "frB", "XO3", "Rc")
    33. 

  33. A2 = Form("frD", "frA", "frC", "XO3", "Rc")
    34. 

  34. A3 = Form("frD", "frA", "frC", "frB", "XO3", "Rc")
    35. 

  35. 

  36. I = Form("LI", "AA", "LK")
    37. 

  37. 

  38. B = Form("BO", "BI", "BD", "AA", "LK")
    39. 

  39. 

  40. SC = Form("AA") # fudge
    41. 

  41. 

  42. DD = Form("rD", "rA", "SIMM")
    43. 

  43. DDO = Form("rD", "rA", "ds", "XO4")
    44. 

  44. DS = Form("rA", "rS", "UIMM")
    45. 

  45. 

  46. X = Form("XO1")
    47. 

  47. XS = Form("rA", "rS", "rB", "XO1", "Rc")
    48. 

  48. XSO = Form("rS", "rA", "rB", "XO1")
    49. 

  49. XD = Form("rD", "rA", "rB", "XO1")
    50. 

  50. XO = Form("rD", "rA", "rB", "OE", "XO2", "Rc")
    51. 

  51. XO0 = Form("rD", "rA", "OE", "XO2", "Rc")
    52. 

  52. XDB = Form("frD", "frB", "XO1", "Rc")
    53. 

  53. XS0 = Form("rA", "rS", "XO1", "Rc")
    54. 

  54. X0 = Form("rA", "rB", "XO1")
    55. 

  55. XcAB = Form("crfD", "rA", "rB", "XO1")
    56. 

  56. XN = Form("rD", "rA", "NB", "XO1")
    57. 

  57. XL = Form("crbD", "crbA", "crbB", "XO1")
    58. 

  58. XL1 = Form("crfD", "crfS")
    59. 

  59. XL2 = Form("crbD", "XO1", "Rc")
    60. 

  60. XFL = Form("FM", "frB", "XO1", "Rc")
    61. 

  61. XFX = Form("CRM", "rS", "XO1")
    62. 

  62. XLL = Form("LL", "XO1")
    63. 

  63. 

  64. MI = Form("rA", "rS", "SH", "MB", "ME", "Rc")
    65. 

  65. MB = Form("rA", "rS", "rB", "MB", "ME", "Rc")
    66. 

  66. MDI = Form("rA", "rS", "sh", "mbe", "XO5", "Rc")
    67. 

  67. MDS = Form("rA", "rS", "rB", "mbe", "XO7", "Rc")
    68. 

  68. 

  69. class BasicPPCAssembler(object):
    70. 

  70. 

  71.     def disassemble(cls, inst, labels={}, pc=0):
    72. 

  72.         cache = cls.__dict__.get('idesc cache')
    73. 

  73.         if cache is None:
    74. 

  74.             idescs = cls.get_idescs()
    75. 

  75.             cache = {}
    76. 

  76.             for n, i in idescs:
    77. 

  77.                 cache.setdefault(i.specializations[ppc_fields['opcode']],
    78. 

  78.                                  []).append((n,i))
    79. 

  79.             setattr(cls, 'idesc cache', cache)
    80. 

  80.         matches = []
    81. 

  81.         idescs = cache[ppc_fields['opcode'].decode(inst)]
    82. 

  82.         for name, idesc in idescs:
    83. 

  83.             m = idesc.match(inst)
    84. 

  84.             if m > 0:
    85. 

  85.                 matches.append((m, idesc, name))
    86. 

  86.         if matches:
    87. 

  87.             score, idesc, name = max(matches)
    88. 

  88.             return idesc.disassemble(name, inst, labels, pc)
    89. 

  89.     disassemble = classmethod(disassemble)
    90. 

  90. 

  91.     # "basic" means no simplified mnemonics
    92. 

  92. 

  93.     # I form
    94. 

  94.     b   = I(18, AA=0, LK=0)
    95. 

  95.     ba  = I(18, AA=1, LK=0)
    96. 

  96.     bl  = I(18, AA=0, LK=1)
    97. 

  97.     bla = I(18, AA=1, LK=1)
    98. 

  98. 

  99.     # B form
    100. 

  100.     bc   = B(16, AA=0, LK=0)
    101. 

  101.     bcl  = B(16, AA=0, LK=1)
    102. 

  102.     bca  = B(16, AA=1, LK=0)
    103. 

  103.     bcla = B(16, AA=1, LK=1)
    104. 

  104. 

  105.     # SC form
    106. 

  106.     sc = SC(17, AA=1) # it's not really the aa field...
    107. 

    108. 

  108.     # D form
    109. 

  109.     addi   = DD(14)
    110. 

  110.     addic  = DD(12)
    111. 

  111.     addicx = DD(13)
    112. 

  112.     addis  = DD(15)
    113. 

  113. 

  114.     andix  = DS(28)
    115. 

  115.     andisx = DS(29)
    116. 

  116. 

  117.     cmpi  = Form("crfD", "L", "rA", "SIMM")(11)
    118. 

  118.     cmpi.default(L=0).default(crfD=0)
    119. 

  119.     cmpli = Form("crfD", "L", "rA", "UIMM")(10)
    120. 

  120.     cmpli.default(L=0).default(crfD=0)
    121. 

  121. 

  122.     lbz  = DD(34)
    123. 

  123.     lbzu = DD(35)
    124. 

  124.     ld   = DDO(58, XO4=0)
    125. 

  125.     ldu  = DDO(58, XO4=1)
    126. 

  126.     lfd  = DD(50)
    127. 

  127.     lfdu = DD(51)
    128. 

  128.     lfs  = DD(48)
    129. 

  129.     lfsu = DD(49)
    130. 

  130.     lha  = DD(42)
    131. 

  131.     lhau = DD(43)
    132. 

  132.     lhz  = DD(40)
    133. 

  133.     lhzu = DD(41)
    134. 

  134.     lmw  = DD(46)
    135. 

  135.     lwa  = DDO(58, XO4=2)
    136. 

  136.     lwz  = DD(32)
    137. 

  137.     lwzu = DD(33)
    138. 

  138. 

  139.     mulli = DD(7)
    140. 

  140.     ori   = DS(24)
    141. 

  141.     oris  = DS(25)
    142. 

  142. 

  143.     stb   = DD(38)
    144. 

  144.     stbu  = DD(39)
    145. 

  145.     std   = DDO(62, XO4=0)
    146. 

  146.     stdu  = DDO(62, XO4=1)
    147. 

  147.     stfd  = DD(54)
    148. 

  148.     stfdu = DD(55)
    149. 

  149.     stfs  = DD(52)
    150. 

  150.     stfsu = DD(53)
    151. 

  151.     sth   = DD(44)
    152. 

  152.     sthu  = DD(45)
    153. 

  153.     stmw  = DD(47)
    154. 

  154.     stw   = DD(36)
    155. 

  155.     stwu  = DD(37)
    156. 

  156. 

  157.     subfic = DD(8)
    158. 

  158.     tdi    = Form("TO", "rA", "SIMM")(2)
    159. 

  159.     twi    = Form("TO", "rA", "SIMM")(3)
    160. 

  160.     xori   = DS(26)
    161. 

  161.     xoris  = DS(27)
    162. 

  162. 

  163.     # X form
    164. 

  164. 

  165.     and_  = XS(31, XO1=28, Rc=0)
    166. 

  166.     and_x = XS(31, XO1=28, Rc=1)
    167. 

  167. 

  168.     andc_  = XS(31, XO1=60, Rc=0)
    169. 

  169.     andc_x = XS(31, XO1=60, Rc=1)
    170. 

  170. 

  171.     # is the L bit for 64 bit compares? hmm
    172. 

  172.     cmp  = Form("crfD", "L", "rA", "rB", "XO1")(31, XO1=0)
    173. 

  173.     cmp.default(L=0).default(crfD=0)
    174. 

  174.     cmpl = Form("crfD", "L", "rA", "rB", "XO1")(31, XO1=32)
    175. 

  175.     cmpl.default(L=0).default(crfD=0)
    176. 

  176. 

  177.     cntlzd  = XS0(31, XO1=58, Rc=0)
    178. 

  178.     cntlzdx = XS0(31, XO1=58, Rc=1)
    179. 

  179.     cntlzw  = XS0(31, XO1=26, Rc=0)
    180. 

  180.     cntlzwx = XS0(31, XO1=26, Rc=1)
    181. 

  181. 

  182.     dcba   = X0(31, XO1=758)
    183. 

  183.     dcbf   = X0(31, XO1=86)
    184. 

  184.     dcbi   = X0(31, XO1=470)
    185. 

  185.     dcbst  = X0(31, XO1=54)
    186. 

  186.     dcbt   = X0(31, XO1=278)
    187. 

  187.     dcbtst = X0(31, XO1=246)
    188. 

  188.     dcbz   = X0(31, XO1=1014)
    189. 

  189. 

  190.     eciwx = XD(31, XO1=310)
    191. 

  191.     ecowx = XS(31, XO1=438, Rc=0)
    192. 

  192. 

  193.     eieio = X(31, XO1=854)
    194. 

  194. 

  195.     eqv  = XS(31, XO1=284, Rc=0)
    196. 

  196.     eqvx = XS(31, XO1=284, Rc=1)
    197. 

  197. 

  198.     extsb  = XS0(31, XO1=954, Rc=0)
    199. 

  199.     extsbx = XS0(31, XO1=954, Rc=1)
    200. 

  200. 

  201.     extsh  = XS0(31, XO1=922, Rc=0)
    202. 

  202.     extshx = XS0(31, XO1=922, Rc=1)
    203. 

  203. 

  204.     extsw  = XS0(31, XO1=986, Rc=0)
    205. 

  205.     extswx = XS0(31, XO1=986, Rc=1)
    206. 

  206. 

  207.     fabs  = XDB(63, XO1=264, Rc=0)
    208. 

  208.     fabsx = XDB(63, XO1=264, Rc=1)
    209. 

  209. 

  210.     fcmpo = XcAB(63, XO1=32)
    211. 

  211.     fcmpu = XcAB(63, XO1=0)
    212. 

  212. 

  213.     fcfid  = XDB(63, XO1=846, Rc=0)
    214. 

  214.     fcfidx = XDB(63, XO1=846, Rc=1)
    215. 

  215. 

  216.     fctid  = XDB(63, XO1=814, Rc=0)
    217. 

  217.     fctidx = XDB(63, XO1=814, Rc=1)
    218. 

  218. 

  219.     fctidz  = XDB(63, XO1=815, Rc=0)
    220. 

  220.     fctidzx = XDB(63, XO1=815, Rc=1)
    221. 

  221. 

  222.     fctiw  = XDB(63, XO1=14, Rc=0)
    223. 

  223.     fctiwx = XDB(63, XO1=14, Rc=1)
    224. 

  224. 

  225.     fctiwz  = XDB(63, XO1=15, Rc=0)
    226. 

  226.     fctiwzx = XDB(63, XO1=15, Rc=1)
    227. 

  227. 

  228.     fmr  = XDB(63, XO1=72, Rc=0)
    229. 

  229.     fmrx = XDB(63, XO1=72, Rc=1)
    230. 

  230. 

  231.     fnabs  = XDB(63, XO1=136, Rc=0)
    232. 

  232.     fnabsx = XDB(63, XO1=136, Rc=1)
    233. 

  233. 

  234.     fneg  = XDB(63, XO1=40, Rc=0)
    235. 

  235.     fnegx = XDB(63, XO1=40, Rc=1)
    236. 

  236. 

  237.     frsp  = XDB(63, XO1=12, Rc=0)
    238. 

  238.     frspx = XDB(63, XO1=12, Rc=1)
    239. 

  239. 

  240.     fsqrt = XDB(63, XO1=22, Rc=0)
    241. 

  241. 

  242.     mffgpr = XS(31, XO1=607, Rc=0)
    243. 

  243.     mftgpr = XS(31, XO1=735, Rc=0)
    244. 

  244. 

  245.     icbi = X0(31, XO1=982)
    246. 

  246. 

  247.     lbzux = XD(31, XO1=119)
    248. 

  248.     lbzx  = XD(31, XO1=87)
    249. 

  249.     ldarx = XD(31, XO1=84)
    250. 

  250.     ldux  = XD(31, XO1=53)
    251. 

  251.     ldx   = XD(31, XO1=21)
    252. 

  252.     lfdux = XD(31, XO1=631)
    253. 

  253.     lfdx  = XD(31, XO1=599)
    254. 

  254.     lfsux = XD(31, XO1=567)
    255. 

  255.     lfsx  = XD(31, XO1=535)
    256. 

  256.     lhaux = XD(31, XO1=375)
    257. 

  257.     lhax  = XD(31, XO1=343)
    258. 

  258.     lhbrx = XD(31, XO1=790)
    259. 

  259.     lhzux = XD(31, XO1=311)
    260. 

  260.     lhzx  = XD(31, XO1=279)
    261. 

  261.     lswi  = XD(31, XO1=597)
    262. 

  262.     lswx  = XD(31, XO1=533)
    263. 

  263.     lwarx = XD(31, XO1=20)
    264. 

  264.     lwaux = XD(31, XO1=373)
    265. 

  265.     lwax  = XD(31, XO1=341)
    266. 

  266.     lwbrx = XD(31, XO1=534)
    267. 

  267.     lwzux = XD(31, XO1=55)
    268. 

  268.     lwzx  = XD(31, XO1=23)
    269. 

  269. 

  270.     mcrfs  = Form("crfD", "crfS", "XO1")(63, XO1=64)
    271. 

  271.     mcrxr  = Form("crfD", "XO1")(31, XO1=512)
    272. 

  272.     mfcr   = Form("rD", "XO1")(31, XO1=19)
    273. 

  273.     mffs   = Form("frD", "XO1", "Rc")(63, XO1=583, Rc=0)
    274. 

  274.     mffsx  = Form("frD", "XO1", "Rc")(63, XO1=583, Rc=1)
    275. 

  275.     mfmsr  = Form("rD", "XO1")(31, XO1=83)
    276. 

  276.     mfsr   = Form("rD", "SR", "XO1")(31, XO1=595)
    277. 

  277.     mfsrin = XDB(31, XO1=659, Rc=0)
    278. 

  278. 

  279.     add   = XO(31, XO2=266, OE=0, Rc=0)
    280. 

  280.     addx  = XO(31, XO2=266, OE=0, Rc=1)
    281. 

  281.     addo  = XO(31, XO2=266, OE=1, Rc=0)
    282. 

  282.     addox = XO(31, XO2=266, OE=1, Rc=1)
    283. 

  283. 

  284.     addc   = XO(31, XO2=10, OE=0, Rc=0)
    285. 

  285.     addcx  = XO(31, XO2=10, OE=0, Rc=1)
    286. 

  286.     addco  = XO(31, XO2=10, OE=1, Rc=0)
    287. 

  287.     addcox = XO(31, XO2=10, OE=1, Rc=1)
    288. 

  288. 

  289.     adde   = XO(31, XO2=138, OE=0, Rc=0)
    290. 

  290.     addex  = XO(31, XO2=138, OE=0, Rc=1)
    291. 

  291.     addeo  = XO(31, XO2=138, OE=1, Rc=0)
    292. 

  292.     addeox = XO(31, XO2=138, OE=1, Rc=1)
    293. 

  293. 

  294.     addme   = XO(31, rB=0, XO2=234, OE=0, Rc=0)
    295. 

  295.     addmex  = XO(31, rB=0, XO2=234, OE=0, Rc=1)
    296. 

  296.     addmeo  = XO(31, rB=0, XO2=234, OE=1, Rc=0)
    297. 

  297.     addmeox = XO(31, rB=0, XO2=234, OE=1, Rc=1)
    298. 

  298. 

  299.     addze   = XO(31, rB=0, XO2=202, OE=0, Rc=0)
    300. 

  300.     addzex  = XO(31, rB=0, XO2=202, OE=0, Rc=1)
    301. 

  301.     addzeo  = XO(31, rB=0, XO2=202, OE=1, Rc=0)
    302. 

  302.     addzeox = XO(31, rB=0, XO2=202, OE=1, Rc=1)
    303. 

  303. 

  304.     bcctr  = Form("BO", "BI", "XO1", "LK")(19, XO1=528, LK=0)
    305. 

  305.     bcctrl = Form("BO", "BI", "XO1", "LK")(19, XO1=528, LK=1)
    306. 

  306. 

  307.     bclr  = Form("BO", "BI", "XO1", "LK")(19, XO1=16, LK=0)
    308. 

  308.     bclrl = Form("BO", "BI", "XO1", "LK")(19, XO1=16, LK=1)
    309. 

  309. 

  310.     crand  = XL(19, XO1=257)
    311. 

  311.     crandc = XL(19, XO1=129)
    312. 

  312.     creqv  = XL(19, XO1=289)
    313. 

  313.     crnand = XL(19, XO1=225)
    314. 

  314.     crnor  = XL(19, XO1=33)
    315. 

  315.     cror   = XL(19, XO1=449)
    316. 

  316.     crorc  = XL(19, XO1=417)
    317. 

  317.     crxor  = XL(19, XO1=193)
    318. 

  318. 

  319.     divd    = XO(31, XO2=489, OE=0, Rc=0)
    320. 

  320.     divdx   = XO(31, XO2=489, OE=0, Rc=1)
    321. 

  321.     divdo   = XO(31, XO2=489, OE=1, Rc=0)
    322. 

  322.     divdox  = XO(31, XO2=489, OE=1, Rc=1)
    323. 

  323. 

  324.     divdu   = XO(31, XO2=457, OE=0, Rc=0)
    325. 

  325.     divdux  = XO(31, XO2=457, OE=0, Rc=1)
    326. 

  326.     divduo  = XO(31, XO2=457, OE=1, Rc=0)
    327. 

  327.     divduox = XO(31, XO2=457, OE=1, Rc=1)
    328. 

  328. 

  329.     divw    = XO(31, XO2=491, OE=0, Rc=0)
    330. 

  330.     divwx   = XO(31, XO2=491, OE=0, Rc=1)
    331. 

  331.     divwo   = XO(31, XO2=491, OE=1, Rc=0)
    332. 

  332.     divwox  = XO(31, XO2=491, OE=1, Rc=1)
    333. 

  333. 

  334.     divwu   = XO(31, XO2=459, OE=0, Rc=0)
    335. 

  335.     divwux  = XO(31, XO2=459, OE=0, Rc=1)
    336. 

  336.     divwuo  = XO(31, XO2=459, OE=1, Rc=0)
    337. 

  337.     divwuox = XO(31, XO2=459, OE=1, Rc=1)
    338. 

  338. 

  339.     fadd   = A(63, XO3=21, Rc=0)
    340. 

  340.     faddx  = A(63, XO3=21, Rc=1)
    341. 

  341.     fadds  = A(59, XO3=21, Rc=0)
    342. 

  342.     faddsx = A(59, XO3=21, Rc=1)
    343. 

  343. 

  344.     fdiv   = A(63, XO3=18, Rc=0)
    345. 

  345.     fdivx  = A(63, XO3=18, Rc=1)
    346. 

  346.     fdivs  = A(59, XO3=18, Rc=0)
    347. 

  347.     fdivsx = A(59, XO3=18, Rc=1)
    348. 

  348. 

  349.     fmadd   = A3(63, XO3=19, Rc=0)
    350. 

  350.     fmaddx  = A3(63, XO3=19, Rc=1)
    351. 

  351.     fmadds  = A3(59, XO3=19, Rc=0)
    352. 

  352.     fmaddsx = A3(59, XO3=19, Rc=1)
    353. 

  353. 

  354.     fmsub   = A3(63, XO3=28, Rc=0)
    355. 

  355.     fmsubx  = A3(63, XO3=28, Rc=1)
    356. 

  356.     fmsubs  = A3(59, XO3=28, Rc=0)
    357. 

  357.     fmsubsx = A3(59, XO3=28, Rc=1)
    358. 

  358. 

  359.     fmul   = A2(63, XO3=25, Rc=0)
    360. 

  360.     fmulx  = A2(63, XO3=25, Rc=1)
    361. 

  361.     fmuls  = A2(59, XO3=25, Rc=0)
    362. 

  362.     fmulsx = A2(59, XO3=25, Rc=1)
    363. 

  363. 

  364.     fnmadd   = A3(63, XO3=31, Rc=0)
    365. 

  365.     fnmaddx  = A3(63, XO3=31, Rc=1)
    366. 

  366.     fnmadds  = A3(59, XO3=31, Rc=0)
    367. 

  367.     fnmaddsx = A3(59, XO3=31, Rc=1)
    368. 

  368. 

  369.     fnmsub   = A3(63, XO3=30, Rc=0)
    370. 

  370.     fnmsubx  = A3(63, XO3=30, Rc=1)
    371. 

  371.     fnmsubs  = A3(59, XO3=30, Rc=0)
    372. 

  372.     fnmsubsx = A3(59, XO3=30, Rc=1)
    373. 

  373. 

  374.     fres     = A1(59, XO3=24, Rc=0)
    375. 

  375.     fresx    = A1(59, XO3=24, Rc=1)
    376. 

  376. 

  377.     frsp     = A1(63, XO3=12, Rc=0)
    378. 

  378.     frspx    = A1(63, XO3=12, Rc=1)
    379. 

  379. 

  380.     frsqrte  = A1(63, XO3=26, Rc=0)
    381. 

  381.     frsqrtex = A1(63, XO3=26, Rc=1)
    382. 

  382. 

  383.     fsel     = A3(63, XO3=23, Rc=0)
    384. 

  384.     fselx    = A3(63, XO3=23, Rc=1)
    385. 

  385. 

  386.     frsqrt   = A1(63, XO3=22, Rc=0)
    387. 

  387.     frsqrtx  = A1(63, XO3=22, Rc=1)
    388. 

  388.     frsqrts  = A1(59, XO3=22, Rc=0)
    389. 

  389.     frsqrtsx = A1(59, XO3=22, Rc=1)
    390. 

  390. 

  391.     fsub   = A(63, XO3=20, Rc=0)
    392. 

  392.     fsubx  = A(63, XO3=20, Rc=1)
    393. 

  393.     fsubs  = A(59, XO3=20, Rc=0)
    394. 

  394.     fsubsx = A(59, XO3=20, Rc=1)
    395. 

  395. 

  396.     isync = X(19, XO1=150)
    397. 

  397. 

  398.     mcrf = XL1(19)
    399. 

  399. 

  400.     mfspr = Form("rD", "spr", "XO1")(31, XO1=339)
    401. 

  401.     mftb  = Form("rD", "spr", "XO1")(31, XO1=371)
    402. 

  402. 

  403.     mtcrf = XFX(31, XO1=144)
    404. 

  404. 

  405.     mtfsb0  = XL2(63, XO1=70, Rc=0)
    406. 

  406.     mtfsb0x = XL2(63, XO1=70, Rc=1)
    407. 

  407.     mtfsb1  = XL2(63, XO1=38, Rc=0)
    408. 

  408.     mtfsb1x = XL2(63, XO1=38, Rc=1)
    409. 

  409. 

  410.     mtfsf   = XFL(63, XO1=711, Rc=0)
    411. 

  411.     mtfsfx  = XFL(63, XO1=711, Rc=1)
    412. 

  412. 

  413.     mtfsfi  = Form("crfD", "IMM", "XO1", "Rc")(63, XO1=134, Rc=0)
    414. 

  414.     mtfsfix = Form("crfD", "IMM", "XO1", "Rc")(63, XO1=134, Rc=1)
    415. 

  415. 

  416.     mtmsr = Form("rS", "XO1")(31, XO1=146)
    417. 

  417. 

  418.     mtspr = Form("rS", "spr", "XO1")(31, XO1=467)
    419. 

  419. 

  420.     mtsr   = Form("rS", "SR", "XO1")(31, XO1=210)
    421. 

  421.     mtsrin = Form("rS", "rB", "XO1")(31, XO1=242)
    422. 

  422. 

  423.     mulhd   = XO(31, OE=0, XO2=73, Rc=0)
    424. 

  424.     mulhdx  = XO(31, OE=0, XO2=73, Rc=1)
    425. 

  425. 

  426.     mulhdu  = XO(31, OE=0, XO2=9, Rc=0)
    427. 

  427.     mulhdux = XO(31, OE=0, XO2=9, Rc=1)
    428. 

  428. 

  429.     mulld   = XO(31, OE=0, XO2=233, Rc=0)
    430. 

  430.     mulldx  = XO(31, OE=0, XO2=233, Rc=1)
    431. 

  431.     mulldo  = XO(31, OE=1, XO2=233, Rc=0)
    432. 

  432.     mulldox = XO(31, OE=1, XO2=233, Rc=1)
    433. 

  433. 

  434.     mulhw   = XO(31, OE=0, XO2=75, Rc=0)
    435. 

  435.     mulhwx  = XO(31, OE=0, XO2=75, Rc=1)
    436. 

  436. 

  437.     mulhwu  = XO(31, OE=0, XO2=11, Rc=0)
    438. 

  438.     mulhwux = XO(31, OE=0, XO2=11, Rc=1)
    439. 

  439. 

  440.     mullw   = XO(31, OE=0, XO2=235, Rc=0)
    441. 

  441.     mullwx  = XO(31, OE=0, XO2=235, Rc=1)
    442. 

  442.     mullwo  = XO(31, OE=1, XO2=235, Rc=0)
    443. 

  443.     mullwox = XO(31, OE=1, XO2=235, Rc=1)
    444. 

  444. 

  445.     nand  = XS(31, XO1=476, Rc=0)
    446. 

  446.     nandx = XS(31, XO1=476, Rc=1)
    447. 

  447. 

  448.     neg   = XO0(31, OE=0, XO2=104, Rc=0)
    449. 

  449.     negx  = XO0(31, OE=0, XO2=104, Rc=1)
    450. 

  450.     nego  = XO0(31, OE=1, XO2=104, Rc=0)
    451. 

  451.     negox = XO0(31, OE=1, XO2=104, Rc=1)
    452. 

  452. 

  453.     nor   = XS(31, XO1=124, Rc=0)
    454. 

  454.     norx  = XS(31, XO1=124, Rc=1)
    455. 

  455. 

  456.     or_   = XS(31, XO1=444, Rc=0)
    457. 

  457.     or_x  = XS(31, XO1=444, Rc=1)
    458. 

  458. 

  459.     orc   = XS(31, XO1=412, Rc=0)
    460. 

  460.     orcx  = XS(31, XO1=412, Rc=1)
    461. 

  461. 

  462.     rfi   = X(19, XO1=50)
    463. 

  463. 

  464.     rfid  = X(19, XO1=18)
    465. 

  465. 

  466.     rldcl   = MDS(30, XO7=8, Rc=0)
    467. 

  467.     rldclx  = MDS(30, XO7=8, Rc=1)
    468. 

  468.     rldcr   = MDS(30, XO7=9, Rc=0)
    469. 

  469.     rldcrx  = MDS(30, XO7=9, Rc=1)
    470. 

  470. 

  471.     rldic   = MDI(30, XO5=2, Rc=0)
    472. 

  472.     rldicx  = MDI(30, XO5=2, Rc=1)
    473. 

  473.     rldicl  = MDI(30, XO5=0, Rc=0)
    474. 

  474.     rldiclx = MDI(30, XO5=0, Rc=1)
    475. 

  475.     rldicr  = MDI(30, XO5=1, Rc=0)
    476. 

  476.     rldicrx = MDI(30, XO5=1, Rc=1)
    477. 

  477.     rldimi  = MDI(30, XO5=3, Rc=0)
    478. 

  478.     rldimix = MDI(30, XO5=3, Rc=1)
    479. 

  479. 

  480.     rlwimi  = MI(20, Rc=0)
    481. 

  481.     rlwimix = MI(20, Rc=1)
    482. 

  482. 

  483.     rlwinm  = MI(21, Rc=0)
    484. 

  484.     rlwinmx = MI(21, Rc=1)
    485. 

  485. 

  486.     rlwnm   = MB(23, Rc=0)
    487. 

  487.     rlwnmx  = MB(23, Rc=1)
    488. 

  488. 

  489.     sld     = XS(31, XO1=27, Rc=0)
    490. 

  490.     sldx    = XS(31, XO1=27, Rc=1)
    491. 

  491. 

  492.     slw     = XS(31, XO1=24, Rc=0)
    493. 

  493.     slwx    = XS(31, XO1=24, Rc=1)
    494. 

  494. 

  495.     srad    = XS(31, XO1=794, Rc=0)
    496. 

  496.     sradx   = XS(31, XO1=794, Rc=1)
    497. 

  497. 

  498.     sradi   = Form("rA", "rS", "SH", "XO6", "sh", "Rc")(31, XO6=413, Rc=0)
    499. 

  499.     sradix  = Form("rA", "rS", "SH", "XO6", "sh", "Rc")(31, XO6=413, Rc=1)
    500. 

  500. 

  501.     sraw    = XS(31, XO1=792, Rc=0)
    502. 

  502.     srawx   = XS(31, XO1=792, Rc=1)
    503. 

  503. 

  504.     srawi   = Form("rA", "rS", "SH", "XO1", "Rc")(31, XO1=824, Rc=0)
    505. 

  505.     srawix  = Form("rA", "rS", "SH", "XO1", "Rc")(31, XO1=824, Rc=1)
    506. 

  506. 

  507.     srd     = XS(31, XO1=539, Rc=0)
    508. 

  508.     srdx    = XS(31, XO1=539, Rc=1)
    509. 

  509. 

  510.     srw     = XS(31, XO1=536, Rc=0)
    511. 

  511.     srwx    = XS(31, XO1=536, Rc=1)
    512. 

  512. 

  513.     stbux   = XSO(31, XO1=247)
    514. 

  514.     stbx    = XSO(31, XO1=215)
    515. 

  515.     stdcxx  = Form("rS", "rA", "rB", "XO1", "Rc")(31, XO1=214, Rc=1)
    516. 

  516.     stdux   = XSO(31, XO1=181)
    517. 

  517.     stdx    = XSO(31, XO1=149)
    518. 

  518.     stfdux  = XSO(31, XO1=759)
    519. 

  519.     stfdx   = XSO(31, XO1=727)
    520. 

  520.     stfiwx  = XSO(31, XO1=983)
    521. 

  521.     stfsux  = XSO(31, XO1=695)
    522. 

  522.     stfsx   = XSO(31, XO1=663)
    523. 

  523.     sthbrx  = XSO(31, XO1=918)
    524. 

  524.     sthux   = XSO(31, XO1=439)
    525. 

  525.     sthx    = XSO(31, XO1=407)
    526. 

  526.     stswi   = Form("rS", "rA", "NB", "XO1")(31, XO1=725)
    527. 

  527.     stswx   = XSO(31, XO1=661)
    528. 

  528.     stwbrx  = XSO(31, XO1=662)
    529. 

  529.     stwcxx  = Form("rS", "rA", "rB", "XO1", "Rc")(31, XO1=150, Rc=1)
    530. 

  530.     stwux   = XSO(31, XO1=183)
    531. 

  531.     stwx    = XSO(31, XO1=151)
    532. 

  532. 

  533.     subf    = XO(31, XO2=40, OE=0, Rc=0)
    534. 

  534.     subfx   = XO(31, XO2=40, OE=0, Rc=1)
    535. 

  535.     subfo   = XO(31, XO2=40, OE=1, Rc=0)
    536. 

  536.     subfox  = XO(31, XO2=40, OE=1, Rc=1)
    537. 

  537. 

  538.     subfc   = XO(31, XO2=8, OE=0, Rc=0)
    539. 

  539.     subfcx  = XO(31, XO2=8, OE=0, Rc=1)
    540. 

  540.     subfco  = XO(31, XO2=8, OE=1, Rc=0)
    541. 

  541.     subfcox = XO(31, XO2=8, OE=1, Rc=1)
    542. 

  542. 

  543.     subfe   = XO(31, XO2=136, OE=0, Rc=0)
    544. 

  544.     subfex  = XO(31, XO2=136, OE=0, Rc=1)
    545. 

  545.     subfeo  = XO(31, XO2=136, OE=1, Rc=0)
    546. 

  546.     subfeox = XO(31, XO2=136, OE=1, Rc=1)
    547. 

  547. 

  548.     subfme  = XO0(31, OE=0, XO2=232, Rc=0)
    549. 

  549.     subfmex = XO0(31, OE=0, XO2=232, Rc=1)
    550. 

  550.     subfmeo = XO0(31, OE=1, XO2=232, Rc=0)
    551. 

  551.     subfmeox= XO0(31, OE=1, XO2=232, Rc=1)
    552. 

  552. 

  553.     subfze  = XO0(31, OE=0, XO2=200, Rc=0)
    554. 

  554.     subfzex = XO0(31, OE=0, XO2=200, Rc=1)
    555. 

  555.     subfzeo = XO0(31, OE=1, XO2=200, Rc=0)
    556. 

  556.     subfzeox= XO0(31, OE=1, XO2=200, Rc=1)
    557. 

  557. 

  558.     sync    = XLL(31, LL=0, XO1=598)
    559. 

  559.     lwsync  = XLL(31, LL=1, XO1=598)
    560. 

  560. 

  561.     tlbia = X(31, XO1=370)
    562. 

  562.     tlbie = Form("rB", "XO1")(31, XO1=306)
    563. 

  563.     tlbsync = X(31, XO1=566)
    564. 

  564. 

  565.     td = Form("TO", "rA", "rB", "XO1")(31, XO1=68)
    566. 

  566.     tw = Form("TO", "rA", "rB", "XO1")(31, XO1=4)
    567. 

  567. 

  568.     xor = XS(31, XO1=316, Rc=0)
    569. 

  569.     xorx = XS(31, XO1=316, Rc=1)
    570. 

  570. 

  571. class PPCAssembler(BasicPPCAssembler):
    572. 

  572.     BA = BasicPPCAssembler
    573. 

  573. 

  574.     # awkward mnemonics:
    575. 

  575.     # mftb
    576. 

  576.     # most of the branch mnemonics...
    577. 

  577. 

  578.     # F.2 Simplified Mnemonics for Subtract Instructions
    579. 

  579. 

  580.     def subi(self, rD, rA, value):
    581. 

  581.         self.addi(rD, rA, -value)
    582. 

  582.     def subis(self, rD, rA, value):
    583. 

  583.         self.addis(rD, rA, -value)
    584. 

  584.     def subic(self, rD, rA, value):
    585. 

  585.         self.addic(rD, rA, -value)
    586. 

  586.     def subicx(self, rD, rA, value):
    587. 

  587.         self.addicx(rD, rA, -value)
    588. 

  588. 

  589.     def sub(self, rD, rA, rB):
    590. 

  590.         self.subf(rD, rB, rA)
    591. 

  591.     def subc(self, rD, rA, rB):
    592. 

  592.         self.subfc(rD, rB, rA)
    593. 

  593.     def subx(self, rD, rA, rB):
    594. 

  594.         self.subfx(rD, rB, rA)
    595. 

  595.     def subcx(self, rD, rA, rB):
    596. 

  596.         self.subfcx(rD, rB, rA)
    597. 

  597.     def subo(self, rD, rA, rB):
    598. 

  598.         self.subfo(rD, rB, rA)
    599. 

  599.     def subco(self, rD, rA, rB):
    600. 

  600.         self.subfco(rD, rB, rA)
    601. 

  601.     def subox(self, rD, rA, rB):
    602. 

  602.         self.subfox(rD, rB, rA)
    603. 

  603.     def subcox(self, rD, rA, rB):
    604. 

  604.         self.subfcox(rD, rB, rA)
    605. 

  605. 

  606.     # F.3 Simplified Mnemonics for Compare Instructions
    607. 

  607. 

  608.     cmpdi  = BA.cmpi(L=1)
    609. 

  609.     cmpwi  = BA.cmpi(L=0)
    610. 

  610.     cmpldi = BA.cmpli(L=1)
    611. 

  611.     cmplwi = BA.cmpli(L=0)
    612. 

  612.     cmpd   = BA.cmp(L=1)
    613. 

  613.     cmpw   = BA.cmp(L=0)
    614. 

  614.     cmpld  = BA.cmpl(L=1)
    615. 

  615.     cmplw  = BA.cmpl(L=0)
    616. 

  616. 

  617.     # F.4 Simplified Mnemonics for Rotate and Shift Instructions
    618. 

  618. 

  619.     def extlwi(self, rA, rS, n, b):
    620. 

  620.         self.rlwinm(rA, rS, b, 0, n-1)
    621. 

  621. 

  622.     def extrwi(self, rA, rS, n, b):
    623. 

  623.         self.rlwinm(rA, rS, b+n, 32-n, 31)
    624. 

  624. 

  625.     def inslwi(self, rA, rS, n, b):
    626. 

  626.         self.rwlimi(rA, rS, 32-b, b, b + n -1)
    627. 

  627. 

  628.     def insrwi(self, rA, rS, n, b):
    629. 

  629.         self.rwlimi(rA, rS, 32-(b+n), b, b + n -1)
    630. 

  630. 

  631.     def rotlwi(self, rA, rS, n):
    632. 

  632.         self.rlwinm(rA, rS, n, 0, 31)
    633. 

  633. 

  634.     def rotrwi(self, rA, rS, n):
    635. 

  635.         self.rlwinm(rA, rS, 32-n, 0, 31)
    636. 

  636. 

  637.     def rotlw(self, rA, rS, rB):
    638. 

  638.         self.rlwnm(rA, rS, rB, 0, 31)
    639. 

  639. 

  640.     def slwi(self, rA, rS, n):
    641. 

  641.         self.rlwinm(rA, rS, n, 0, 31-n)
    642. 

  642. 

  643.     def srwi(self, rA, rS, n):
    644. 

  644.         self.rlwinm(rA, rS, 32-n, n, 31)
    645. 

  645. 

  646.     def sldi(self, rA, rS, n):
    647. 

  647.         self.rldicr(rA, rS, n, 63-n)
    648. 

  648. 

  649.     def srdi(self, rA, rS, n):
    650. 

  650.         self.rldicl(rA, rS, 64-n, n)
    651. 

  651. 

  652.     # F.5 Simplified Mnemonics for Branch Instructions
    653. 

  653. 

  654.     # there's a lot of these!
    655. 

  655.     bt       = BA.bc(BO=12)
    656. 

  656.     bf       = BA.bc(BO=4)
    657. 

  657.     bdnz     = BA.bc(BO=16, BI=0)
    658. 

  658.     bdnzt    = BA.bc(BO=8)
    659. 

  659.     bdnzf    = BA.bc(BO=0)
    660. 

  660.     bdz      = BA.bc(BO=18, BI=0)
    661. 

  661.     bdzt     = BA.bc(BO=10)
    662. 

  662.     bdzf     = BA.bc(BO=2)
    663. 

  663. 

  664.     bta      = BA.bca(BO=12)
    665. 

  665.     bfa      = BA.bca(BO=4)
    666. 

  666.     bdnza    = BA.bca(BO=16, BI=0)
    667. 

  667.     bdnzta   = BA.bca(BO=8)
    668. 

  668.     bdnzfa   = BA.bca(BO=0)
    669. 

  669.     bdza     = BA.bca(BO=18, BI=0)
    670. 

  670.     bdzta    = BA.bca(BO=10)
    671. 

  671.     bdzfa    = BA.bca(BO=2)
    672. 

  672. 

  673.     btl      = BA.bcl(BO=12)
    674. 

  674.     bfl      = BA.bcl(BO=4)
    675. 

  675.     bdnzl    = BA.bcl(BO=16, BI=0)
    676. 

  676.     bdnztl   = BA.bcl(BO=8)
    677. 

  677.     bdnzfl   = BA.bcl(BO=0)
    678. 

  678.     bdzl     = BA.bcl(BO=18, BI=0)
    679. 

  679.     bdztl    = BA.bcl(BO=10)
    680. 

  680.     bdzfl    = BA.bcl(BO=2)
    681. 

  681. 

  682.     btla     = BA.bcla(BO=12)
    683. 

  683.     bfla     = BA.bcla(BO=4)
    684. 

  684.     bdnzla   = BA.bcla(BO=16, BI=0)
    685. 

  685.     bdnztla  = BA.bcla(BO=8)
    686. 

  686.     bdnzfla  = BA.bcla(BO=0)
    687. 

  687.     bdzla    = BA.bcla(BO=18, BI=0)
    688. 

  688.     bdztla   = BA.bcla(BO=10)
    689. 

  689.     bdzfla   = BA.bcla(BO=2)
    690. 

  690. 

  691.     blr      = BA.bclr(BO=20, BI=0)
    692. 

  692.     btlr     = BA.bclr(BO=12)
    693. 

  693.     bflr     = BA.bclr(BO=4)
    694. 

  694.     bdnzlr   = BA.bclr(BO=16, BI=0)
    695. 

  695.     bdnztlr  = BA.bclr(BO=8)
    696. 

  696.     bdnzflr  = BA.bclr(BO=0)
    697. 

  697.     bdzlr    = BA.bclr(BO=18, BI=0)
    698. 

  698.     bdztlr   = BA.bclr(BO=10)
    699. 

  699.     bdzflr   = BA.bclr(BO=2)
    700. 

  700. 

  701.     bctr     = BA.bcctr(BO=20, BI=0)
    702. 

  702.     btctr    = BA.bcctr(BO=12)
    703. 

  703.     bfctr    = BA.bcctr(BO=4)
    704. 

  704. 

  705.     blrl     = BA.bclrl(BO=20, BI=0)
    706. 

  706.     btlrl    = BA.bclrl(BO=12)
    707. 

  707.     bflrl    = BA.bclrl(BO=4)
    708. 

  708.     bdnzlrl  = BA.bclrl(BO=16, BI=0)
    709. 

  709.     bdnztlrl = BA.bclrl(BO=8)
    710. 

  710.     bdnzflrl = BA.bclrl(BO=0)
    711. 

  711.     bdzlrl   = BA.bclrl(BO=18, BI=0)
    712. 

  712.     bdztlrl  = BA.bclrl(BO=10)
    713. 

  713.     bdzflrl  = BA.bclrl(BO=2)
    714. 

  714. 

  715.     bctrl    = BA.bcctrl(BO=20, BI=0)
    716. 

  716.     btctrl   = BA.bcctrl(BO=12)
    717. 

  717.     bfctrl   = BA.bcctrl(BO=4)
    718. 

  718. 

  719.     # these should/could take a[n optional] crf argument, but it's a
    720. 

  720.     # bit hard to see how to arrange that.
    721. 

  721. 

  722.     blt      = BA.bc(BO=12, BI=0)
    723. 

  723.     ble      = BA.bc(BO=4,  BI=1)
    724. 

  724.     beq      = BA.bc(BO=12, BI=2)
    725. 

  725.     bge      = BA.bc(BO=4,  BI=0)
    726. 

  726.     bgt      = BA.bc(BO=12, BI=1)
    727. 

  727.     bnl      = BA.bc(BO=4,  BI=0)
    728. 

  728.     bne      = BA.bc(BO=4,  BI=2)
    729. 

  729.     bng      = BA.bc(BO=4,  BI=1)
    730. 

  730.     bso      = BA.bc(BO=12, BI=3)
    731. 

  731.     bns      = BA.bc(BO=4,  BI=3)
    732. 

  732.     bun      = BA.bc(BO=12, BI=3)
    733. 

  733.     bnu      = BA.bc(BO=4,  BI=3)
    734. 

  734. 

  735.     blta     = BA.bca(BO=12, BI=0)
    736. 

  736.     blea     = BA.bca(BO=4,  BI=1)
    737. 

  737.     beqa     = BA.bca(BO=12, BI=2)
    738. 

  738.     bgea     = BA.bca(BO=4,  BI=0)
    739. 

  739.     bgta     = BA.bca(BO=12, BI=1)
    740. 

  740.     bnla     = BA.bca(BO=4,  BI=0)
    741. 

  741.     bnea     = BA.bca(BO=4,  BI=2)
    742. 

  742.     bnga     = BA.bca(BO=4,  BI=1)
    743. 

  743.     bsoa     = BA.bca(BO=12, BI=3)
    744. 

  744.     bnsa     = BA.bca(BO=4,  BI=3)
    745. 

  745.     buna     = BA.bca(BO=12, BI=3)
    746. 

  746.     bnua     = BA.bca(BO=4,  BI=3)
    747. 

  747. 

  748.     bltl     = BA.bcl(BO=12, BI=0)
    749. 

  749.     blel     = BA.bcl(BO=4,  BI=1)
    750. 

  750.     beql     = BA.bcl(BO=12, BI=2)
    751. 

  751.     bgel     = BA.bcl(BO=4,  BI=0)
    752. 

  752.     bgtl     = BA.bcl(BO=12, BI=1)
    753. 

  753.     bnll     = BA.bcl(BO=4,  BI=0)
    754. 

  754.     bnel     = BA.bcl(BO=4,  BI=2)
    755. 

  755.     bngl     = BA.bcl(BO=4,  BI=1)
    756. 

  756.     bsol     = BA.bcl(BO=12, BI=3)
    757. 

  757.     bnsl     = BA.bcl(BO=4,  BI=3)
    758. 

  758.     bunl     = BA.bcl(BO=12, BI=3)
    759. 

  759.     bnul     = BA.bcl(BO=4,  BI=3)
    760. 

  760. 

  761.     bltla    = BA.bcla(BO=12, BI=0)
    762. 

  762.     blela    = BA.bcla(BO=4,  BI=1)
    763. 

  763.     beqla    = BA.bcla(BO=12, BI=2)
    764. 

  764.     bgela    = BA.bcla(BO=4,  BI=0)
    765. 

  765.     bgtla    = BA.bcla(BO=12, BI=1)
    766. 

  766.     bnlla    = BA.bcla(BO=4,  BI=0)
    767. 

  767.     bnela    = BA.bcla(BO=4,  BI=2)
    768. 

  768.     bngla    = BA.bcla(BO=4,  BI=1)
    769. 

  769.     bsola    = BA.bcla(BO=12, BI=3)
    770. 

  770.     bnsla    = BA.bcla(BO=4,  BI=3)
    771. 

  771.     bunla    = BA.bcla(BO=12, BI=3)
    772. 

  772.     bnula    = BA.bcla(BO=4,  BI=3)
    773. 

  773. 

  774.     bltlr    = BA.bclr(BO=12, BI=0)
    775. 

  775.     blelr    = BA.bclr(BO=4,  BI=1)
    776. 

  776.     beqlr    = BA.bclr(BO=12, BI=2)
    777. 

  777.     bgelr    = BA.bclr(BO=4,  BI=0)
    778. 

  778.     bgtlr    = BA.bclr(BO=12, BI=1)
    779. 

  779.     bnllr    = BA.bclr(BO=4,  BI=0)
    780. 

  780.     bnelr    = BA.bclr(BO=4,  BI=2)
    781. 

  781.     bnglr    = BA.bclr(BO=4,  BI=1)
    782. 

  782.     bsolr    = BA.bclr(BO=12, BI=3)
    783. 

  783.     bnslr    = BA.bclr(BO=4,  BI=3)
    784. 

  784.     bunlr    = BA.bclr(BO=12, BI=3)
    785. 

  785.     bnulr    = BA.bclr(BO=4,  BI=3)
    786. 

  786. 

  787.     bltctr   = BA.bcctr(BO=12, BI=0)
    788. 

  788.     blectr   = BA.bcctr(BO=4,  BI=1)
    789. 

  789.     beqctr   = BA.bcctr(BO=12, BI=2)
    790. 

  790.     bgectr   = BA.bcctr(BO=4,  BI=0)
    791. 

  791.     bgtctr   = BA.bcctr(BO=12, BI=1)
    792. 

  792.     bnlctr   = BA.bcctr(BO=4,  BI=0)
    793. 

  793.     bnectr   = BA.bcctr(BO=4,  BI=2)
    794. 

  794.     bngctr   = BA.bcctr(BO=4,  BI=1)
    795. 

  795.     bsoctr   = BA.bcctr(BO=12, BI=3)
    796. 

  796.     bnsctr   = BA.bcctr(BO=4,  BI=3)
    797. 

  797.     bunctr   = BA.bcctr(BO=12, BI=3)
    798. 

  798.     bnuctr   = BA.bcctr(BO=4,  BI=3)
    799. 

  799. 

  800.     bltlrl   = BA.bclrl(BO=12, BI=0)
    801. 

  801.     blelrl   = BA.bclrl(BO=4,  BI=1)
    802. 

  802.     beqlrl   = BA.bclrl(BO=12, BI=2)
    803. 

  803.     bgelrl   = BA.bclrl(BO=4,  BI=0)
    804. 

  804.     bgtlrl   = BA.bclrl(BO=12, BI=1)
    805. 

  805.     bnllrl   = BA.bclrl(BO=4,  BI=0)
    806. 

  806.     bnelrl   = BA.bclrl(BO=4,  BI=2)
    807. 

  807.     bnglrl   = BA.bclrl(BO=4,  BI=1)
    808. 

  808.     bsolrl   = BA.bclrl(BO=12, BI=3)
    809. 

  809.     bnslrl   = BA.bclrl(BO=4,  BI=3)
    810. 

  810.     bunlrl   = BA.bclrl(BO=12, BI=3)
    811. 

  811.     bnulrl   = BA.bclrl(BO=4,  BI=3)
    812. 

  812. 

  813.     bltctrl  = BA.bcctrl(BO=12, BI=0)
    814. 

  814.     blectrl  = BA.bcctrl(BO=4,  BI=1)
    815. 

  815.     beqctrl  = BA.bcctrl(BO=12, BI=2)
    816. 

  816.     bgectrl  = BA.bcctrl(BO=4,  BI=0)
    817. 

  817.     bgtctrl  = BA.bcctrl(BO=12, BI=1)
    818. 

  818.     bnlctrl  = BA.bcctrl(BO=4,  BI=0)
    819. 

  819.     bnectrl  = BA.bcctrl(BO=4,  BI=2)
    820. 

  820.     bngctrl  = BA.bcctrl(BO=4,  BI=1)
    821. 

  821.     bsoctrl  = BA.bcctrl(BO=12, BI=3)
    822. 

  822.     bnsctrl  = BA.bcctrl(BO=4,  BI=3)
    823. 

  823.     bunctrl  = BA.bcctrl(BO=12, BI=3)
    824. 

  824.     bnuctrl  = BA.bcctrl(BO=4,  BI=3)
    825. 

  825. 

  826.     # whew!  and we haven't even begun the predicted versions...
    827. 

    828. 

  828.     # F.6 Simplified Mnemonics for Condition Register
    829. 

  829.     #     Logical Instructions
    830. 

  830. 

  831.     crset = BA.creqv(crbA="crbD", crbB="crbD")
    832. 

  832.     crclr = BA.crxor(crbA="crbD", crbB="crbD")
    833. 

  833.     crmove = BA.cror(crbA="crbB")
    834. 

  834.     crnot = BA.crnor(crbA="crbB")
    835. 

  835. 

  836.     # F.7 Simplified Mnemonics for Trap Instructions
    837. 

  837. 

  838.     trap = BA.tw(TO=31, rA=0, rB=0)
    839. 

  839.     twlt = BA.tw(TO=16)
    840. 

  840.     twle = BA.tw(TO=20)
    841. 

  841.     tweq = BA.tw(TO=4)
    842. 

  842.     twge = BA.tw(TO=12)
    843. 

  843.     twgt = BA.tw(TO=8)
    844. 

  844.     twnl = BA.tw(TO=12)
    845. 

  845.     twng = BA.tw(TO=24)
    846. 

  846.     twllt = BA.tw(TO=2)
    847. 

  847.     twlle = BA.tw(TO=6)
    848. 

  848.     twlge = BA.tw(TO=5)
    849. 

  849.     twlgt = BA.tw(TO=1)
    850. 

  850.     twlnl = BA.tw(TO=5)
    851. 

  851.     twlng = BA.tw(TO=6)
    852. 

  852. 

  853.     twlti = BA.twi(TO=16)
    854. 

  854.     twlei = BA.twi(TO=20)
    855. 

  855.     tweqi = BA.twi(TO=4)
    856. 

  856.     twgei = BA.twi(TO=12)
    857. 

  857.     twgti = BA.twi(TO=8)
    858. 

  858.     twnli = BA.twi(TO=12)
    859. 

  859.     twnei = BA.twi(TO=24)
    860. 

  860.     twngi = BA.twi(TO=20)
    861. 

  861.     twllti = BA.twi(TO=2)
    862. 

  862.     twllei = BA.twi(TO=6)
    863. 

  863.     twlgei = BA.twi(TO=5)
    864. 

  864.     twlgti = BA.twi(TO=1)
    865. 

  865.     twlnli = BA.twi(TO=5)
    866. 

  866.     twlngi = BA.twi(TO=6)
    867. 

  867. 

  868.     # F.8 Simplified Mnemonics for Special-Purpose
    869. 

  869.     #     Registers
    870. 

  870. 

  871.     mfctr = BA.mfspr(spr=9)
    872. 

  872.     mflr  = BA.mfspr(spr=8)
    873. 

  873.     mftbl = BA.mftb(spr=268)
    874. 

  874.     mftbu = BA.mftb(spr=269)
    875. 

  875.     mfxer = BA.mfspr(spr=1)
    876. 

  876. 

  877.     mtctr = BA.mtspr(spr=9)
    878. 

  878.     mtlr  = BA.mtspr(spr=8)
    879. 

  879.     mtxer = BA.mtspr(spr=1)
    880. 

  880. 

  881.     # F.9 Recommended Simplified Mnemonics
    882. 

  882. 

  883.     nop = BA.ori(rS=0, rA=0, UIMM=0)
    884. 

  884. 

  885.     li = BA.addi(rA=0)
    886. 

  886.     lis = BA.addis(rA=0)
    887. 

  887. 

  888.     mr = BA.or_(rB="rS")
    889. 

  889.     mrx = BA.or_x(rB="rS")
    890. 

  890. 

  891.     not_ = BA.nor(rB="rS")
    892. 

  892.     not_x = BA.norx(rB="rS")
    893. 

  893. 

  894.     mtcr = BA.mtcrf(CRM=0xFF)
    895. 

  895. 

  896. PPCAssembler = make_rassembler(PPCAssembler)
    897. 

  897. 

  898. def hi(w):
    899. 

  899.     return w >> 16
    900. 

  900. 

  901. def ha(w):
    902. 

  902.     if (w >> 15) & 1:
    903. 

  903.         return (w >> 16) + 1
    904. 

  904.     else:
    905. 

  905.         return w >> 16
    906. 

  906. 

  907. def lo(w):
    908. 

  908.     return w & 0x0000FFFF
    909. 

  909. 

  910. def la(w):
    911. 

  911.     v = w & 0x0000FFFF
    912. 

  912.     if v & 0x8000:
    913. 

  913.         return -((v ^ 0xFFFF) + 1) # "sign extend" to 32 bits
    914. 

  914.     return v
    915. 

  915. 

  916. def highest(w):
    917. 

  917.     return w >> 48
    918. 

  918. 

  919. def higher(w):
    920. 

  920.     return (w >> 32) & 0x0000FFFF
    921. 

  921. 

  922. def high(w):
    923. 

  923.     return (w >> 16) & 0x0000FFFF
    924. 

  924. 

  925. _eci = ExternalCompilationInfo(post_include_bits=[
    926. 

  926.     '#define rpython_flush_icache()  asm("isync":::"memory")\n'
    927. 

  927.     ])
    928. 

  928. flush_icache = rffi.llexternal(
    929. 

  929.     "rpython_flush_icache",
    930. 

  930.     [],
    931. 

  931.     lltype.Void,
    932. 

  932.     compilation_info=_eci,
    933. 

  933.     _nowrapper=True,
    934. 

  934.     sandboxsafe=True)
    935. 

  935. 

  936. 

  937. class PPCGuardToken(GuardToken):
    938. 

  938.     def __init__(self, cpu, gcmap, descr, failargs, faillocs,
    939. 

  939.                  guard_opnum, frame_depth, faildescrindex, fcond=c.cond_none):
    940. 

  940.         GuardToken.__init__(self, cpu, gcmap, descr, failargs, faillocs,
    941. 

  941.                             guard_opnum, frame_depth, faildescrindex)
    942. 

  942.         self.fcond = fcond
    943. 

  943. 

  944. 

  945. class OverwritingBuilder(PPCAssembler):
    946. 

  946.     def __init__(self, mc, start, num_insts=0):
    947. 

  947.         PPCAssembler.__init__(self)
    948. 

  948.         self.mc = mc
    949. 

  949.         self.index = start
    950. 

  950. 

  951.     def currpos(self):
    952. 

  952.         assert 0, "not implemented"
    953. 

  953. 

  954.     def write32(self, word):
    955. 

  955.         index = self.index
    956. 

  956.         if IS_BIG_ENDIAN:
    957. 

  957.             self.mc.overwrite(index,     chr((word >> 24) & 0xff))
    958. 

  958.             self.mc.overwrite(index + 1, chr((word >> 16) & 0xff))
    959. 

  959.             self.mc.overwrite(index + 2, chr((word >> 8) & 0xff))
    960. 

  960.             self.mc.overwrite(index + 3, chr(word & 0xff))
    961. 

  961.         elif IS_LITTLE_ENDIAN:
    962. 

  962.             self.mc.overwrite(index    , chr(word & 0xff))
    963. 

  963.             self.mc.overwrite(index + 1, chr((word >> 8) & 0xff))
    964. 

  964.             self.mc.overwrite(index + 2, chr((word >> 16) & 0xff))
    965. 

  965.             self.mc.overwrite(index + 3, chr((word >> 24) & 0xff))
    966. 

  966.         self.index = index + 4
    967. 

  967. 

  968.     def overwrite(self):
    969. 

  969.         pass
    970. 

  970. 

  971. class PPCBuilder(BlockBuilderMixin, PPCAssembler):
    972. 

  972.     def __init__(self):
    973. 

  973.         PPCAssembler.__init__(self)
    974. 

  974.         self.init_block_builder()
    975. 

  975.         self.ops_offset = {}
    976. 

  976. 

  977.     def mark_op(self, op):
    978. 

  978.         pos = self.get_relative_pos()
    979. 

  979.         self.ops_offset[op] = pos
    980. 

  980. 

  981.     def check(self, desc, v, *args):
    982. 

  982.         desc.__get__(self)(*args)
    983. 

  983.         ins = self.insts.pop()
    984. 

  984.         expected = ins.assemble()
    985. 

  985.         if expected < 0:
    986. 

  986.             expected += 1<<32
    987. 

  987.         assert v == expected
    988. 

  988. 

  989.     def load_imm(self, dest_reg, word):
    990. 

  990.         rD = dest_reg.value
    991. 

  991.         if word <= 32767 and word >= -32768:
    992. 

  992.             self.li(rD, word)
    993. 

  993.         elif IS_PPC_32 or (word <= 2147483647 and word >= -2147483648):
    994. 

  994.             self.lis(rD, hi(word))
    995. 

  995.             if word & 0xFFFF != 0:
    996. 

  996.                 self.ori(rD, rD, lo(word))
    997. 

  997.         else:
    998. 

  998.             self.load_imm(dest_reg, word>>32)
    999. 

  999.             self.sldi(rD, rD, 32)
    1000. 

  1000.             if word & 0xFFFF0000 != 0:
    1001. 

  1001.                 self.oris(rD, rD, high(word))
    1002. 

  1002.             if word & 0xFFFF != 0:
    1003. 

  1003.                 self.ori(rD, rD, lo(word))
    1004. 

  1004. 

  1005.     def load_imm_plus(self, dest_reg, word):
    1006. 

  1006.         """Like load_imm(), but with one instruction less, and
    1007. 

  1007.         leaves the loaded value off by some signed 16-bit difference.
    1008. 

  1008.         Returns that difference."""
    1009. 

  1009.         diff = rffi.cast(lltype.Signed, rffi.cast(rffi.SHORT, word))
    1010. 

  1010.         word -= diff
    1011. 

  1011.         assert word & 0xFFFF == 0
    1012. 

  1012.         self.load_imm(dest_reg, word)
    1013. 

  1013.         return diff
    1014. 

  1014. 

  1015.     def load_from_addr(self, rD, rT, addr):
    1016. 

  1016.         # load [addr] into rD.  rT is a temporary register which can be
    1017. 

  1017.         # equal to rD, but can't be r0.
    1018. 

  1018.         assert rT is not r.r0
    1019. 

  1019.         diff = self.load_imm_plus(rT, addr)
    1020. 

  1020.         if IS_PPC_32:
    1021. 

  1021.             self.lwz(rD.value, rT.value, diff)
    1022. 

  1022.         else:
    1023. 

  1023.             self.ld(rD.value, rT.value, diff)
    1024. 

  1024. 

  1025.     def b_offset(self, target):
    1026. 

  1026.         curpos = self.currpos()
    1027. 

  1027.         offset = target - curpos
    1028. 

  1028.         assert offset < (1 << 24)
    1029. 

  1029.         self.b(offset)
    1030. 

  1030. 

  1031.     def b_cond_offset(self, offset, condition):
    1032. 

  1032.         assert condition != c.cond_none
    1033. 

  1033.         BI, BO = c.encoding[condition]
    1034. 

  1034. 

  1035.         pos = self.currpos()
    1036. 

  1036.         target_ofs = offset - pos
    1037. 

  1037.         self.bc(BO, BI, target_ofs)
    1038. 

  1038. 

  1039.     def b_cond_abs(self, addr, condition):
    1040. 

  1040.         assert condition != c.cond_none
    1041. 

  1041.         BI, BO = c.encoding[condition]
    1042. 

  1042. 

  1043.         with scratch_reg(self):
    1044. 

  1044.             self.load_imm(r.SCRATCH, addr)
    1045. 

  1045.             self.mtctr(r.SCRATCH.value)
    1046. 

  1046.         self.bcctr(BO, BI)
    1047. 

  1047. 

  1048.     def b_abs(self, address, trap=False):
    1049. 

  1049.         with scratch_reg(self):
    1050. 

  1050.             self.load_imm(r.SCRATCH, address)
    1051. 

  1051.             self.mtctr(r.SCRATCH.value)
    1052. 

  1052.         if trap:
    1053. 

  1053.             self.trap()
    1054. 

  1054.         self.bctr()
    1055. 

  1055. 

  1056.     def bl_abs(self, address):
    1057. 

  1057.         with scratch_reg(self):
    1058. 

  1058.             self.load_imm(r.SCRATCH, address)
    1059. 

  1059.             self.mtctr(r.SCRATCH.value)
    1060. 

  1060.         self.bctrl()
    1061. 

  1061. 

  1062.     if IS_BIG_ENDIAN:
    1063. 

  1063.         RAW_CALL_REG = r.r2
    1064. 

  1064.     else:
    1065. 

  1065.         RAW_CALL_REG = r.r12
    1066. 

  1066. 

  1067.     def raw_call(self, call_reg=RAW_CALL_REG):
    1068. 

  1068.         """Emit a call to the address stored in the register 'call_reg',
    1069. 

  1069.         which must be either RAW_CALL_REG or r12.  This is a regular C
    1070. 

  1070.         function pointer, which means on big-endian that it is actually
    1071. 

  1071.         the address of a three-words descriptor.
    1072. 

  1072.         """
    1073. 

  1073.         if IS_BIG_ENDIAN:
    1074. 

  1074.             # Load the function descriptor (currently in r2) from memory:
    1075. 

  1075.             #  [r2 + 0]  -> ctr
    1076. 

  1076.             #  [r2 + 16] -> r11
    1077. 

  1077.             #  [r2 + 8]  -> r2  (= TOC)
    1078. 

  1078.             assert self.RAW_CALL_REG is r.r2
    1079. 

  1079.             assert call_reg is r.r2 or call_reg is r.r12
    1080. 

  1080.             self.ld(r.SCRATCH.value, call_reg.value, 0)
    1081. 

  1081.             self.ld(r.r11.value, call_reg.value, 16)
    1082. 

  1082.             self.mtctr(r.SCRATCH.value)
    1083. 

  1083.             self.ld(r.TOC.value, call_reg.value, 8)  # must be last: TOC is r2
    1084. 

  1084.         elif IS_LITTLE_ENDIAN:
    1085. 

  1085.             assert self.RAW_CALL_REG is r.r12     # 'r12' is fixed by this ABI
    1086. 

  1086.             assert call_reg is r.r12
    1087. 

  1087.             self.mtctr(r.r12.value)
    1088. 

  1088.         # Call the function
    1089. 

  1089.         self.bctrl()
    1090. 

  1090. 

  1091. 

  1092.     def load(self, target_reg, base_reg, offset):
    1093. 

  1093.         if IS_PPC_32:
    1094. 

  1094.             self.lwz(target_reg, base_reg, offset)
    1095. 

  1095.         else:
    1096. 

  1096.             self.ld(target_reg, base_reg, offset)
    1097. 

  1097. 

  1098.     def loadx(self, target_reg, base_reg, offset_reg):
    1099. 

  1099.         if IS_PPC_32:
    1100. 

  1100.             self.lwzx(target_reg, base_reg, offset_reg)
    1101. 

  1101.         else:
    1102. 

  1102.             self.ldx(target_reg, base_reg, offset_reg)
    1103. 

  1103. 

  1104.     def store(self, from_reg, base_reg, offset):
    1105. 

  1105.         if IS_PPC_32:
    1106. 

  1106.             self.stw(from_reg, base_reg, offset)
    1107. 

  1107.         else:
    1108. 

  1108.             self.std(from_reg, base_reg, offset)
    1109. 

  1109. 

  1110.     def storex(self, from_reg, base_reg, offset_reg):
    1111. 

  1111.         if IS_PPC_32:
    1112. 

  1112.             self.stwx(from_reg, base_reg, offset_reg)
    1113. 

  1113.         else:
    1114. 

  1114.             self.stdx(from_reg, base_reg, offset_reg)
    1115. 

  1115. 

  1116.     def store_update(self, target_reg, from_reg, offset):
    1117. 

  1117.         if IS_PPC_32:
    1118. 

  1118.             self.stwu(target_reg, from_reg, offset)
    1119. 

  1119.         else:
    1120. 

  1120.             self.stdu(target_reg, from_reg, offset)
    1121. 

  1121. 

  1122.     def srli_op(self, target_reg, from_reg, numbits):
    1123. 

  1123.         if IS_PPC_32:
    1124. 

  1124.             self.srwi(target_reg, from_reg, numbits)
    1125. 

  1125.         else:
    1126. 

  1126.             self.srdi(target_reg, from_reg, numbits)
    1127. 

  1127. 

  1128.     def sl_op(self, target_reg, from_reg, numbit_reg):
    1129. 

  1129.         if IS_PPC_32:
    1130. 

  1130.             self.slw(target_reg, from_reg, numbit_reg)
    1131. 

  1131.         else:
    1132. 

  1132.             self.sld(target_reg, from_reg, numbit_reg)
    1133. 

  1133. 

  1134.     def _dump_trace(self, addr, name, formatter=-1):
    1135. 

  1135.         if not we_are_translated():
    1136. 

  1136.             if formatter != -1:
    1137. 

  1137.                 name = name % formatter
    1138. 

  1138.             dir = udir.ensure('asm', dir=True)
    1139. 

  1139.             f = dir.join(name).open('wb')
    1140. 

  1140.             data = rffi.cast(rffi.CCHARP, addr)
    1141. 

  1141.             for i in range(self.currpos()):
    1142. 

  1142.                 f.write(data[i])
    1143. 

  1143.             f.close()
    1144. 

  1144. 

  1145.     def write32(self, word):
    1146. 

  1146.         if IS_BIG_ENDIAN:
    1147. 

  1147.             self.writechar(chr((word >> 24) & 0xFF))
    1148. 

  1148.             self.writechar(chr((word >> 16) & 0xFF))
    1149. 

  1149.             self.writechar(chr((word >> 8) & 0xFF))
    1150. 

  1150.             self.writechar(chr(word & 0xFF))
    1151. 

  1151.         elif IS_LITTLE_ENDIAN:
    1152. 

  1152.             self.writechar(chr(word & 0xFF))
    1153. 

  1153.             self.writechar(chr((word >> 8) & 0xFF))
    1154. 

  1154.             self.writechar(chr((word >> 16) & 0xFF))
    1155. 

  1155.             self.writechar(chr((word >> 24) & 0xFF))
    1156. 

  1156. 

  1157.     def write64(self, word):
    1158. 

  1158.         if IS_BIG_ENDIAN:
    1159. 

  1159.             self.writechar(chr((word >> 56) & 0xFF))
    1160. 

  1160.             self.writechar(chr((word >> 48) & 0xFF))
    1161. 

  1161.             self.writechar(chr((word >> 40) & 0xFF))
    1162. 

  1162.             self.writechar(chr((word >> 32) & 0xFF))
    1163. 

  1163.             self.writechar(chr((word >> 24) & 0xFF))
    1164. 

  1164.             self.writechar(chr((word >> 16) & 0xFF))
    1165. 

  1165.             self.writechar(chr((word >> 8) & 0xFF))
    1166. 

  1166.             self.writechar(chr(word & 0xFF))
    1167. 

  1167.         elif IS_LITTLE_ENDIAN:
    1168. 

  1168.             self.writechar(chr(word & 0xFF))
    1169. 

  1169.             self.writechar(chr((word >> 8) & 0xFF))
    1170. 

  1170.             self.writechar(chr((word >> 16) & 0xFF))
    1171. 

  1171.             self.writechar(chr((word >> 24) & 0xFF))
    1172. 

  1172.             self.writechar(chr((word >> 32) & 0xFF))
    1173. 

  1173.             self.writechar(chr((word >> 40) & 0xFF))
    1174. 

  1174.             self.writechar(chr((word >> 48) & 0xFF))
    1175. 

  1175.             self.writechar(chr((word >> 56) & 0xFF))
    1176. 

  1176. 

  1177.     def currpos(self):
    1178. 

  1178.         return self.get_relative_pos()
    1179. 

  1179. 

  1180.     def copy_to_raw_memory(self, addr):
    1181. 

  1181.         self._copy_to_raw_memory(addr)
    1182. 

  1182.         if we_are_translated():
    1183. 

  1183.             flush_icache()
    1184. 

  1184.         self._dump(addr, "jit-backend-dump", 'ppc')
    1185. 

  1185. 

  1186.     def cmp_op(self, block, a, b, imm=False, signed=True, fp=False):
    1187. 

  1187.         if fp == True:
    1188. 

  1188.             self.fcmpu(block, a, b)
    1189. 

  1189.         elif IS_PPC_32:
    1190. 

  1190.             if signed:
    1191. 

  1191.                 if imm:
    1192. 

  1192.                     # 32 bit immediate signed
    1193. 

  1193.                     self.cmpwi(block, a, b)
    1194. 

  1194.                 else:
    1195. 

  1195.                     # 32 bit signed
    1196. 

  1196.                     self.cmpw(block, a, b)
    1197. 

  1197.             else:
    1198. 

  1198.                 if imm:
    1199. 

  1199.                     # 32 bit immediate unsigned
    1200. 

  1200.                     self.cmplwi(block, a, b)
    1201. 

  1201.                 else:
    1202. 

  1202.                     # 32 bit unsigned
    1203. 

  1203.                     self.cmplw(block, a, b)
    1204. 

  1204.         else:
    1205. 

  1205.             if signed:
    1206. 

  1206.                 if imm:
    1207. 

  1207.                     # 64 bit immediate signed
    1208. 

  1208.                     self.cmpdi(block, a, b)
    1209. 

  1209.                 else:
    1210. 

  1210.                     # 64 bit signed
    1211. 

  1211.                     self.cmpd(block, a, b)
    1212. 

  1212.             else:
    1213. 

  1213.                 if imm:
    1214. 

  1214.                     # 64 bit immediate unsigned
    1215. 

  1215.                     self.cmpldi(block, a, b)
    1216. 

  1216.                 else:
    1217. 

  1217.                     # 64 bit unsigned
    1218. 

  1218.                     self.cmpld(block, a, b)
    1219. 

  1219.                 
    1220. 

  1220.     def alloc_scratch_reg(self):
    1221. 

  1221.         pass
    1222. 

  1222.         #assert not self.r0_in_use
    1223. 

  1223.         #self.r0_in_use = True
    1224. 

  1224. 

  1225.     def free_scratch_reg(self):
    1226. 

  1226.         pass
    1227. 

  1227.         #assert self.r0_in_use
    1228. 

  1228.         #self.r0_in_use = False
    1229. 

  1229. 

  1230.     def get_assembler_function(self):
    1231. 

  1231.         "NOT_RPYTHON: tests only"
    1232. 

  1232.         from rpython.jit.backend.llsupport.asmmemmgr import AsmMemoryManager
    1233. 

  1233.         class FakeCPU:
    1234. 

  1234.             HAS_CODEMAP = False
    1235. 

  1235.             asmmemmgr = AsmMemoryManager()
    1236. 

  1236.         addr = self.materialize(FakeCPU(), [])
    1237. 

  1237.         if IS_BIG_ENDIAN:
    1238. 

  1238.             mc = PPCBuilder()
    1239. 

  1239.             mc.write64(addr)     # the 3-words descriptor
    1240. 

  1240.             mc.write64(0)
    1241. 

  1241.             mc.write64(0)
    1242. 

  1242.             addr = mc.materialize(FakeCPU(), [])
    1243. 

  1243.         return rffi.cast(lltype.Ptr(lltype.FuncType([], lltype.Signed)), addr)
    1244. 

  1244. 

  1245. 

  1246. class scratch_reg(object):
    1247. 

  1247.     def __init__(self, mc):
    1248. 

  1248.         self.mc = mc
    1249. 

  1249. 

  1250.     def __enter__(self):
    1251. 

  1251.         self.mc.alloc_scratch_reg()
    1252. 

  1252. 

  1253.     def __exit__(self, *args):
    1254. 

  1254.         self.mc.free_scratch_reg()
    1255. 

  1255. 

  1256. class BranchUpdater(PPCAssembler):
    1257. 

  1257.     def __init__(self):
    1258. 

  1258.         PPCAssembler.__init__(self)
    1259. 

  1259.         self.init_block_builder()
    1260. 

  1260. 

  1261.     def write_to_mem(self, addr):
    1262. 

  1262.         self.assemble()
    1263. 

  1263.         self.copy_to_raw_memory(addr)
    1264. 

  1264.         
    1265. 

  1265.     def assemble(self, dump=os.environ.has_key('PYPY_DEBUG')):
    1266. 

  1266.         insns = self.assemble0(dump)
    1267. 

  1267.         for i in insns:
    1268. 

  1268.             self.emit(i)
    1269. 

  1269. 

  1270. def b(n):
    1271. 

  1271.     r = []
    1272. 

  1272.     for i in range(32):
    1273. 

  1273.         r.append(n&1)
    1274. 

  1274.         n >>= 1
    1275. 

  1275.     r.reverse()
    1276. 

  1276.     return ''.join(map(str, r))
    1277. 

  1277. 

  1278. def make_operations():
    1279. 

  1279.     def not_implemented(builder, trace_op, cpu, *rest_args):
    1280. 

  1280.         import pdb; pdb.set_trace()
    1281. 

  1281. 

  1282.     oplist = [None] * (rop._LAST + 1)
    1283. 

  1283.     for key, val in rop.__dict__.items():
    1284. 

  1284.         if key.startswith("_") or not isinstance(val, int):
    1285. 

  1285.             continue
    1286. 

  1286.         opname = key.lower()
    1287. 

  1287.         methname = "emit_%s" % opname
    1288. 

  1288.         if hasattr(PPCBuilder, methname):
    1289. 

  1289.             oplist[val] = getattr(PPCBuilder, methname).im_func
    1290. 

  1290.         else:
    1291. 

  1291.             oplist[val] = not_implemented
    1292. 

  1292.     return oplist
    1293. 

  1293. 

  1294. PPCBuilder.operations = make_operations()
    1295. 

  1295.