src/jit/ppc/core.jit

   1 ;
   2 ; ppc/core.jit
   3 ;
   4 ;
   5 ; $Id$
   6 ;
   7
   8 # TODO complete this
   9 #define P_ARITH ((PREV_OP == dec_i) || (PREV_OP == inc_i) || (PREV_OP == sub_i_i_i))
  10 Parrot_end {
  11     jit_emit_lwz(NATIVECODE, r1, 0, r1);
  12     jit_emit_lwz(NATIVECODE, r0, 8, r1);
  13
  14     jit_emit_call_func(NATIVECODE, (void *)Parrot_ppc_jit_restore_nonvolatile_registers);
  15
  16     jit_emit_mtlr(NATIVECODE, r0);
  17     jit_emit_lmw(NATIVECODE, r13, -PPC_JIT_GP_REGISTER_SAVE_SPACE, r1);
  18
  19     jit_emit_blr(NATIVECODE);
  20 }
  21
  22 Parrot_noop {
  23 ; preferred no-op on ppc
  24     jit_emit_ori(NATIVECODE, r0, r0, 0);
  25 }
  26
  27 Parrot_set_i_ic {
  28     if (MAP[1]) {
  29         jit_emit_mov_ri_i(NATIVECODE, MAP[1], *INT_CONST[2]);
  30     }
  31     else {
  32         jit_emit_mov_ri_i(NATIVECODE, ISR1, *INT_CONST[2]);
  33         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
  34     }
  35 }
  36
  37 Parrot_set_i_n {
  38     if (MAP[2]) {
  39     jit_emit_fctiwz  (NATIVECODE, FSR2, MAP[2]);
  40     }
  41     else {
  42         jit_emit_mov_rm_n(NATIVECODE, FSR1, ROFFS_NUM(2));
  43     jit_emit_fctiwz  (NATIVECODE, FSR2, FSR1);
  44     }
  45     if (MAP[1]) {
  46     jit_emit_add_rri_i(NATIVECODE, ISR1, 0, -4);
  47     jit_emit_stfiwx   (NATIVECODE, FSR2, ISR1, r1);   /* -> -4(sp) */
  48     jit_emit_lwz      (NATIVECODE, MAP[1], -4, r1);
  49     }
  50     else {
  51     jit_emit_add_rri_i(NATIVECODE, ISR1, 0, ROFFS_INT(1));
  52     jit_emit_stfiwx   (NATIVECODE, FSR2, ISR1, r13);   /* -> offs(base) */
  53     }
  54 }
  55
  56 Parrot_set_n_ic {
  57     static double xx = 4503601774854144.0; /* 0x4330000080000000L; */
  58     jit_emit_mov_ri_i(NATIVECODE, ISR1, *INT_CONST[2]);
  59     jit_emit_xoris(   NATIVECODE, ISR1, ISR1, 0x8000);
  60     /* use redzone for intermediate */
  61     jit_emit_stw(     NATIVECODE, ISR1, -4, r1);
  62     jit_emit_addis(   NATIVECODE, ISR1, r31, 0x4330);
  63     jit_emit_stw(     NATIVECODE, ISR1, -8, r1);
  64     jit_emit_lfd(     NATIVECODE, FSR1, -8, r1);
  65     /* we should keep this magic const in a preserved eg eg. f31 */
  66     jit_emit_mov_ri_i(NATIVECODE, ISR2, &xx);
  67     jit_emit_lfd(     NATIVECODE, FSR2, 0, ISR2);
  68     if (MAP[1]) {
  69     jit_emit_fsub_rrr(NATIVECODE, MAP[1], FSR1, FSR2);
  70     }
  71     else {
  72     jit_emit_fsub_rrr(NATIVECODE, FSR1, FSR1, FSR2);
  73         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR1);
  74     }
  75 }
  76
  77 Parrot_set_n_i {
  78     static double xx = 4503601774854144.0; /* 0x4330000080000000L; */
  79     if (MAP[2]) {
  80     jit_emit_xoris(   NATIVECODE, ISR1, MAP[2], 0x8000);
  81     }
  82     else {
  83         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(2));
  84     jit_emit_xoris(   NATIVECODE, ISR1, ISR1, 0x8000);
  85     }
  86     /* use redzone for intermediate */
  87     jit_emit_stw(     NATIVECODE, ISR1, -4, r1);
  88     jit_emit_addis(   NATIVECODE, ISR1, r31, 0x4330);
  89     jit_emit_stw(     NATIVECODE, ISR1, -8, r1);
  90     jit_emit_lfd(     NATIVECODE, FSR1, -8, r1);
  91     /* we should keep this magic const in a preserved eg  f31 */
  92     jit_emit_mov_ri_i(NATIVECODE, ISR2, &xx);
  93     jit_emit_lfd(     NATIVECODE, FSR2, 0, ISR2);
  94     if (MAP[1]) {
  95     jit_emit_fsub_rrr(NATIVECODE, MAP[1], FSR1, FSR2);
  96     }
  97     else {
  98     jit_emit_fsub_rrr(NATIVECODE, FSR1, FSR1, FSR2);
  99         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR1);
 100     }
 101 }
 102
 103 Parrot_null_i {
 104     if (MAP[1]) {
 105         jit_emit_mov_rr(NATIVECODE, MAP[1], r31);
 106     }
 107     else {
 108         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), r31);
 109     }
 110 }
 111
 112 TEMPLATE Parrot_set_x_x {
 113     if (MAP[1] && MAP[2]) {
 114         jit_emit_mov_rr(NATIVECODE, MAP[1], MAP[2]);
 115     }
 116     else if (MAP[1]) {
 117         jit_emit_mov_rm_i(NATIVECODE, MAP[1], ROFFS_INT(2));
 118     }
 119     else if (MAP[2]) {
 120         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), MAP[2]);
 121     }
 122     else {
 123         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(2));
 124         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 125     }
 126 }
 127
 128 Parrot_set_i_i {
 129     Parrot_set_x_x
 130 }
 131
 132 Parrot_set_s_s {
 133     Parrot_set_x_x s/INT/STR/`
 134 }
 135
 136 Parrot_set_p_p {
 137     Parrot_set_x_x s/INT/PMC/
 138 }
 139
 140 Parrot_set_n_n {
 141     if (MAP[1] && MAP[2]) {
 142         jit_emit_mov_rr_n(NATIVECODE, MAP[1], MAP[2]);
 143     }
 144     else if (MAP[1]) {
 145     jit_emit_mov_rm_n(NATIVECODE, MAP[1], ROFFS_NUM(2));
 146     }
 147     else if (MAP[2]) {
 148         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), MAP[2]);
 149     }
 150     else {
 151     jit_emit_mov_rm_n(NATIVECODE, FSR1, ROFFS_NUM(2));
 152         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR1);
 153     }
 154 }
 155
 156 Parrot_set_n_nc {
 157     if (MAP[1]) {
 158         jit_emit_mov_ri_i(NATIVECODE, ISR1, &NUM_CONST[2]);
 159         jit_emit_lfd(NATIVECODE, MAP[1], 0, ISR1);
 160     }
 161     else {
 162         jit_emit_mov_ri_i(NATIVECODE, ISR1, &NUM_CONST[2]);
 163         jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
 164         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR1);
 165     }
 166 }
 167
 168 TEMPLATE unary_x_x {
 169     if (MAP[1] && MAP[2]) {
 170         jit_emit_<op>_rr<_N>(NATIVECODE, MAP[1], MAP[2]);
 171     }
 172     else if (MAP[1]) {
 173         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(2));
 174         jit_emit_<op>_rr<_N>(NATIVECODE, MAP[1], <s1>);
 175     }
 176     else if (MAP[2]) {
 177         jit_emit_<op>_rr<_N>(NATIVECODE, <s1>, MAP[1]);
 178         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 179     }
 180     else {
 181         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(2));
 182         jit_emit_<op>_rr<_N>(NATIVECODE, <s1>, <s1>);
 183         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 184     }
 185 }
 186
 187 TEMPLATE unary_i_i {
 188     unary_x_x s/<_N>/_i/ s/<t>/INT/ s/<s1>/ISR1/
 189 }
 190
 191 TEMPLATE unary_n_n {
 192     unary_x_x s/<_N>/_n/ s/<t>/NUM/ s/<s1>/FSR1/
 193 }
 194
 195 Parrot_neg_i_i {
 196     unary_i_i s/<op>/neg/
 197 }
 198
 199 Parrot_neg_n_n {
 200     unary_n_n s/<op>/neg/
 201 }
 202
 203 Parrot_abs_n_n {
 204     unary_n_n s/<op>/abs/
 205 }
 206
 207 TEMPLATE binop_x_xc {
 208     int im;
 209     if (MAP[1]) {
 210 #ifdef jit_emit_<op>_rri<_N>
 211     im = *INT_CONST[2];
 212     /* *if* immediate constant is small and there is a dedicated
 213      * opcode, just use it
 214      * _n variants don't have immediates, only _i
 215      *
 216      * This could be further improved, if there exists also
 217      * a shifted opcode variant like 'oris'. But then this code
 218      * should be factored out into jit_emit.h. This OTOH needs some
 219      * convention about scratch register usage.
 220      */
 221     if (!(im >> 16)) {
 222         jit_emit_<op>_rri_i(NATIVECODE, MAP[1], MAP[1], im);
 223     }
 224     else
 225 #endif
 226     {
 227         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[2]);
 228         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[1], <s1>);
 229     }
 230     }
 231     else {
 232         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(1));
 233 #ifdef jit_emit_<op>_rri<_N>
 234     im = *INT_CONST[2];
 235     if (!(im >> 16)) {
 236         jit_emit_<op>_rri_i(NATIVECODE, <s1>, <s1>, im);
 237     }
 238     else
 239 #endif
 240     {
 241         jit_emit_mov_ri<_N>(NATIVECODE, <s2>, <c>_CONST[2]);
 242         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s1>, <s2>);
 243     }
 244         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 245     }
 246 }
 247
 248 TEMPLATE binop_n_nc {
 249     binop_x_xc s/<_N>/_n/ s/<t>/NUM/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<c>/&NUM/
 250 }
 251
 252 TEMPLATE binop_i_ic {
 253     binop_x_xc s/<_N>/_i/ s/<t>/INT/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<c>/*INT/
 254 }
 255
 256 TEMPLATE binop_x_x {
 257     if (MAP[1] && MAP[2]) {
 258         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[1], MAP[2]);
 259     }
 260     else if (MAP[1]) {
 261         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(2));
 262         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[1], <s1>);
 263     }
 264     else if (MAP[2]) {
 265         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(1));
 266         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s1>, MAP[2]);
 267         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 268     }
 269     else {
 270         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(1));
 271         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<T>(2));
 272         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s1>, <s2>);
 273         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 274     }
 275 }
 276
 277 TEMPLATE binop_x_x_x {
 278     if (MAP[1] && MAP[2] && MAP[3]) {
 279         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[2], MAP[3]);
 280     }
 281     else if (MAP[1] && MAP[2]) {
 282         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(3));
 283         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[2], <s1>);
 284     }
 285     else if (MAP[1] && MAP[3]) {
 286         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(2));
 287         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], <s1>, MAP[3]);
 288     }
 289     else if (MAP[2] && MAP[3]) {
 290         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, MAP[2], MAP[3]);
 291         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 292     }
 293     else if (MAP[1]) {
 294         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(3));
 295         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<T>(2));
 296         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], <s2>, <s1>);
 297     }
 298     else if (MAP[2]) {
 299         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(3));
 300         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, MAP[2], <s1>);
 301         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 302     }
 303     else if (MAP[3]) {
 304         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(2));
 305         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s1>, MAP[3]);
 306         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 307     }
 308     else {
 309         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<T>(3));
 310         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<T>(2));
 311         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s2>, <s1>);
 312         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<T>(1), <s1>);
 313     }
 314 }
 315
 316 TEMPLATE binop_x_xc_x {
 317     if (MAP[1] && MAP[3]) {
 318         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[2]);
 319         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], <s1>, MAP[3]);
 320     }
 321     else if (MAP[1]) {
 322         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 323         jit_emit_mov_ri<_N>(NATIVECODE, <s2>, <c>_CONST[2]);
 324         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], <s2>, <s1>);
 325     }
 326     else if (MAP[3]) {
 327         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[2]);
 328         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s1>, MAP[3]);
 329         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 330     }
 331     else {
 332         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 333         jit_emit_mov_ri<_N>(NATIVECODE, <s2>, <c>_CONST[2]);
 334         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s2>, <s1>);
 335         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 336     }
 337 }
 338
 339 TEMPLATE binop_i_ic_i {
 340     binop_x_xc_x  s/<_N>/_i/ s/<t>/INT/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<c>/*INT/
 341 }
 342 TEMPLATE binop_n_nc_n {
 343     binop_x_xc_x  s/<_N>/_n/ s/<t>/NUM/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<c>/&NUM/
 344 }
 345
 346 TEMPLATE binop_x_x_xc {
 347     if (MAP[1] && MAP[2]) {
 348 #ifdef jit_emit_<op>_rri<_N>
 349         /* common case - operands are MAPped */
 350     int im = *INT_CONST[3];
 351     if (!(im >> 16)) {
 352         jit_emit_<op>_rri_i(NATIVECODE, MAP[1], MAP[2], im);
 353     }
 354     else
 355 #endif
 356     {
 357         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[3]);
 358         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], MAP[2], <s1>);
 359     }
 360     }
 361     else if (MAP[1]) {
 362         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[3]);
 363         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<t>(2));
 364         jit_emit_<op>_rrr<_N>(NATIVECODE, MAP[1], <s2>, <s1>);
 365     }
 366     else if (MAP[2]) {
 367         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[3]);
 368         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, MAP[2], <s1>);
 369         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 370     }
 371     else {
 372         jit_emit_mov_ri<_N>(NATIVECODE, <s1>, <c>_CONST[3]);
 373         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<t>(2));
 374         jit_emit_<op>_rrr<_N>(NATIVECODE, <s1>, <s2>, <s1>);
 375         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_<t>(1), <s1>);
 376     }
 377 }
 378
 379 TEMPLATE binop_i_i_ic {
 380     binop_x_x_xc  s/<_N>/_i/ s/<t>/INT/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<c>/*INT/
 381 }
 382
 383 TEMPLATE binop_n_n_nc {
 384     binop_x_x_xc  s/<_N>/_n/ s/<t>/NUM/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<c>/&NUM/
 385 }
 386
 387 Parrot_band_i_i {
 388     binop_x_x s/<_N>/_i/ s/<op>/and/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 389 }
 390
 391 Parrot_bor_i_i {
 392     binop_x_x s/<_N>/_i/ s/<op>/or/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 393 }
 394
 395 Parrot_bxor_i_i {
 396     binop_x_x s/<_N>/_i/ s/<op>/xor/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 397 }
 398
 399 Parrot_shr_i_i {
 400     binop_x_x s/<_N>/_i/ s/<op>/shr/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 401 }
 402
 403 Parrot_shl_i_i {
 404     binop_x_x s/<_N>/_i/ s/<op>/shl/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 405 }
 406
 407 Parrot_lsr_i_i {
 408     binop_x_x s/<_N>/_i/ s/<op>/lsr/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 409 }
 410
 411 Parrot_add_i_i {
 412     binop_x_x s/<_N>/_i/ s/<op>/add/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 413 }
 414
 415 Parrot_sub_i_i {
 416     binop_x_x s/<_N>/_i/ s/<op>/sub/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 417 }
 418
 419 Parrot_mul_i_i {
 420     binop_x_x s/<_N>/_i/ s/<op>/mul/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 421 }
 422
 423 Parrot_div_i_i {
 424     binop_x_x s/<_N>/_i/ s/<op>/div/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 425 }
 426
 427 Parrot_cmod_i_i {
 428     binop_x_x s/<_N>/_i/ s/<op>/cmod/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 429 }
 430
 431 Parrot_band_i_ic {
 432     binop_i_ic s/<op>/and/
 433 }
 434
 435 Parrot_bor_i_ic {
 436     binop_i_ic s/<op>/or/
 437 }
 438
 439 Parrot_bxor_i_ic {
 440     binop_i_ic s/<op>/xor/
 441 }
 442
 443 Parrot_shr_i_ic {
 444     binop_i_ic s/<op>/shr/
 445 }
 446
 447 Parrot_shl_i_ic {
 448     binop_i_ic s/<op>/shl/
 449 }
 450
 451 Parrot_lsr_i_ic {
 452     binop_i_ic s/<op>/lsr/
 453 }
 454
 455 Parrot_add_i_ic {
 456     binop_i_ic s/<op>/add/
 457 }
 458
 459 Parrot_sub_i_ic {
 460     binop_i_ic s/<op>/sub/
 461 }
 462
 463 Parrot_mul_i_ic {
 464     binop_i_ic s/<op>/mul/
 465 }
 466
 467 Parrot_div_i_ic {
 468     binop_i_ic s/<op>/div/
 469 }
 470
 471 Parrot_cmod_i_ic {
 472     binop_i_ic s/<op>/cmod/
 473 }
 474
 475 Parrot_add_n_nc {
 476     binop_n_nc s/<op>/add/
 477 }
 478
 479 Parrot_sub_n_nc {
 480     binop_n_nc s/<op>/sub/
 481 }
 482
 483 Parrot_mul_n_nc {
 484     binop_n_nc s/<op>/mul/
 485 }
 486
 487 Parrot_div_n_nc {
 488     binop_n_nc s/<op>/div/
 489 }
 490
 491 Parrot_add_n_n {
 492     binop_x_x s/<_N>/_n/ s/<op>/add/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 493 }
 494
 495 Parrot_div_n_n {
 496     binop_x_x s/<_N>/_n/ s/<op>/div/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 497 }
 498
 499 Parrot_mul_n_n {
 500     binop_x_x s/<_N>/_n/ s/<op>/mul/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 501 }
 502
 503 Parrot_sub_n_n {
 504     binop_x_x s/<_N>/_n/ s/<op>/sub/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 505 }
 506
 507 Parrot_band_i_i_i {
 508     binop_x_x_x s/<_N>/_i/ s/<op>/and/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 509 }
 510
 511 Parrot_bor_i_i_i {
 512     binop_x_x_x s/<_N>/_i/ s/<op>/or/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 513 }
 514
 515 Parrot_bxor_i_i_i {
 516     binop_x_x_x s/<_N>/_i/ s/<op>/xor/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 517 }
 518
 519 Parrot_add_i_i_i {
 520     binop_x_x_x s/<_N>/_i/ s/<op>/add/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 521 }
 522
 523 Parrot_sub_i_i_i {
 524     binop_x_x_x s/<_N>/_i/ s/<op>/sub/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 525 }
 526
 527 Parrot_mul_i_i_i {
 528     binop_x_x_x s/<_N>/_i/ s/<op>/mul/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 529 }
 530
 531 Parrot_div_i_i_i {
 532     binop_x_x_x s/<_N>/_i/ s/<op>/div/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 533 }
 534
 535 Parrot_cmod_i_i_i {
 536     binop_x_x_x s/<_N>/_i/ s/<op>/cmod/ s/<s1>/ISR1/ s/<s2>/ISR2/ s/<T>/INT/
 537 }
 538
 539 Parrot_band_i_i_ic {
 540     binop_i_i_ic s/<op>/and/
 541 }
 542
 543 Parrot_bor_i_i_ic {
 544     binop_i_i_ic s/<op>/or/
 545 }
 546
 547 Parrot_bxor_i_i_ic {
 548     binop_i_i_ic s/<op>/xor/
 549 }
 550
 551 Parrot_shr_i_i_ic {
 552     binop_i_i_ic s/<op>/shr/
 553 }
 554
 555 Parrot_shl_i_i_ic {
 556     binop_i_i_ic s/<op>/shl/
 557 }
 558
 559 Parrot_lsr_i_i_ic {
 560     binop_i_i_ic s/<op>/lsr/
 561 }
 562
 563 Parrot_add_i_i_ic {
 564     binop_i_i_ic s/<op>/add/
 565 }
 566
 567 Parrot_sub_i_i_ic {
 568     binop_i_i_ic s/<op>/sub/
 569 }
 570
 571 Parrot_mul_i_i_ic {
 572     binop_i_i_ic s/<op>/mul/
 573 }
 574
 575 Parrot_div_i_i_ic {
 576     binop_i_i_ic s/<op>/div/
 577 }
 578
 579 Parrot_cmod_i_i_ic {
 580     binop_i_i_ic s/<op>/cmod/
 581 }
 582
 583 Parrot_add_n_n_nc {
 584     binop_n_n_nc s/<op>/add/
 585 }
 586
 587 Parrot_sub_n_n_nc {
 588     binop_n_n_nc s/<op>/sub/
 589 }
 590
 591 Parrot_mul_n_n_ic {
 592     binop_n_n_nc s/<op>/mul/
 593 }
 594
 595 Parrot_div_n_n_nc {
 596     binop_n_n_nc s/<op>/div/
 597 }
 598
 599 Parrot_band_i_ic_i {
 600     binop_i_ic_i s/<op>/and/
 601 }
 602
 603 Parrot_bor_i_ic_i {
 604     binop_i_ic_i s/<op>/or/
 605 }
 606
 607 Parrot_bxor_i_ic_i {
 608     binop_i_ic_i s/<op>/xor/
 609 }
 610
 611 Parrot_shr_i_ic_i {
 612     binop_i_ic_i s/<op>/shr/
 613 }
 614
 615 Parrot_lsr_i_ic_i {
 616     binop_i_ic_i s/<op>/lsr/
 617 }
 618
 619 Parrot_shl_i_ic_i {
 620     binop_i_ic_i s/<op>/shl/
 621 }
 622
 623 Parrot_add_i_ic_i {
 624     binop_i_ic_i s/<op>/add/
 625 }
 626
 627 Parrot_sub_i_ic_i {
 628     binop_i_ic_i s/<op>/sub/
 629 }
 630
 631 Parrot_mul_i_ic_i {
 632     binop_i_ic_i s/<op>/mul/
 633 }
 634
 635 Parrot_div_i_ic_i {
 636     binop_i_ic_i s/<op>/div/
 637 }
 638
 639 Parrot_cmod_i_ic_i {
 640     binop_i_ic_i s/<op>/cmod/
 641 }
 642
 643 Parrot_add_n_nc_n {
 644     binop_n_nc_n s/<op>/add/
 645 }
 646
 647 Parrot_sub_n_nc_n {
 648     binop_n_nc_n s/<op>/sub/
 649 }
 650
 651 Parrot_mul_n_nc_n {
 652     binop_n_nc_n s/<op>/mul/
 653 }
 654
 655 Parrot_div_n_nc_n {
 656     binop_n_nc_n s/<op>/div/
 657 }
 658
 659 Parrot_add_n_n_n {
 660     binop_x_x_x s/<_N>/_n/ s/<op>/add/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 661 }
 662
 663 Parrot_sub_n_n_n {
 664     binop_x_x_x s/<_N>/_n/ s/<op>/sub/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 665 }
 666
 667 Parrot_mul_n_n_n {
 668     binop_x_x_x s/<_N>/_n/ s/<op>/mul/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 669 }
 670
 671 Parrot_div_n_n_n {
 672     binop_x_x_x s/<_N>/_n/ s/<op>/div/ s/<s1>/FSR1/ s/<s2>/FSR2/ s/<T>/NUM/
 673 }
 674
 675 Parrot_rot_i_i_ic_ic {
 676     int rc = *INT_CONST[3];
 677     int bw = *INT_CONST[4];
 678     if (rc < 0)
 679     rc = bw + rc;
 680     if (MAP[1] && MAP[2]) {
 681     jit_emit_rot_rri(NATIVECODE, MAP[1], MAP[2], rc);
 682     }
 683     else if (MAP[1]) {
 684         jit_emit_mov_rm_i(NATIVECODE, ISR2, ROFFS_INT(2));
 685     jit_emit_rot_rri(NATIVECODE, MAP[1], ISR2, rc);
 686     }
 687     else if (MAP[2]) {
 688         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 689     jit_emit_rot_rri(NATIVECODE, ISR1, MAP[2], rc);
 690         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 691     }
 692     else {
 693         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 694         jit_emit_mov_rm_i(NATIVECODE, ISR2, ROFFS_INT(2));
 695     jit_emit_rot_rri(NATIVECODE, ISR1, ISR2, rc);
 696         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 697     }
 698
 699 }
 700
 701 ; actually this covers islt too, by passing the bit
 702 TEMPLATE iseq_i_x_x {
 703     if (MAP[2] && MAP[3]) {
 704         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], MAP[3]);
 705     }
 706     else if (MAP[2]) {
 707         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 708         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], <s1>);
 709     }
 710     else if (MAP[3]) {
 711         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(2));
 712         jit_emit_cmp_rr<_N>(NATIVECODE, <s1>, MAP[3]);
 713     }
 714     else {
 715         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<t>(2));
 716         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 717         jit_emit_cmp_rr<_N>(NATIVECODE, <s2>, <s1>);
 718     }
 719     jit_emit_mfcr(NATIVECODE, ISR1);
 720     /* bits 0 LT, 1 GT, 2 EQ */
 721     /* see also extrwi */
 722     if (MAP[1]) {
 723     jit_emit_rlwinm(NATIVECODE, MAP[1], ISR1, <b>, 31, 31);
 724     }
 725     else {
 726     jit_emit_rlwinm(NATIVECODE, ISR1, ISR1, <b>, 31, 31);
 727         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 728     }
 729 }
 730
 731 TEMPLATE isle_i_x_x {
 732     if (MAP[2] && MAP[3]) {
 733         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], MAP[3]);
 734     }
 735     else if (MAP[2]) {
 736         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 737         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], <s1>);
 738     }
 739     else if (MAP[3]) {
 740         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(2));
 741         jit_emit_cmp_rr<_N>(NATIVECODE, <s1>, MAP[3]);
 742     }
 743     else {
 744         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<t>(2));
 745         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 746         jit_emit_cmp_rr<_N>(NATIVECODE, <s2>, <s1>);
 747     }
 748     jit_emit_mfcr(NATIVECODE, ISR1);
 749     /* bits 0 LT, 1 GT, 2 EQ */
 750     /* this is LT or LE - get LT */
 751     jit_emit_rlwinm(NATIVECODE, ISR2, ISR1, 1, 31, 31);
 752     /* get EQ and or the bits into destination */
 753     jit_emit_rlwinm(NATIVECODE, ISR1, ISR1, 3, 31, 31);
 754     if (MAP[1]) {
 755     jit_emit_or_rrr(NATIVECODE, MAP[1], ISR1, ISR2);
 756     }
 757     else {
 758     jit_emit_or_rrr(NATIVECODE, ISR1, ISR1, ISR2);
 759         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 760     }
 761 }
 762
 763 TEMPLATE cmp_i_x_x {
 764     if (MAP[2] && MAP[3]) {
 765         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], MAP[3]);
 766     }
 767     else if (MAP[2]) {
 768         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 769         jit_emit_cmp_rr<_N>(NATIVECODE, MAP[2], <s1>);
 770     }
 771     else if (MAP[3]) {
 772         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(2));
 773         jit_emit_cmp_rr<_N>(NATIVECODE, <s1>, MAP[3]);
 774     }
 775     else {
 776         jit_emit_mov_rm<_N>(NATIVECODE, <s2>, ROFFS_<t>(2));
 777         jit_emit_mov_rm<_N>(NATIVECODE, <s1>, ROFFS_<t>(3));
 778         jit_emit_cmp_rr<_N>(NATIVECODE, <s2>, <s1>);
 779     }
 780     jit_emit_mfcr(NATIVECODE, ISR1);
 781     /* bits 0 LT, 1 GT, 2 EQ */
 782     /* get LT -> 0/1 */
 783     jit_emit_rlwinm(NATIVECODE, ISR2, ISR1, 1, 31, 31);
 784     /* reverse bit */
 785     jit_emit_xori  (NATIVECODE, ISR2, ISR2, 1);
 786     /* sub 1 -> -1 / 0 */
 787     jit_emit_subi  (NATIVECODE, ISR2, ISR2, 1);
 788     /* get GT  or the bits into destination */
 789     jit_emit_rlwinm(NATIVECODE, ISR1, ISR1, 2, 31, 31);
 790     if (MAP[1]) {
 791     jit_emit_or_rrr(NATIVECODE, MAP[1], ISR1, ISR2);
 792     }
 793     else {
 794     jit_emit_or_rrr(NATIVECODE, ISR1, ISR1, ISR2);
 795         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 796     }
 797 }
 798 Parrot_iseq_i_i_i {
 799     iseq_i_x_x  s/<s1>/ISR1/ s/<s2>/ISR2/ s/<t>/INT/ s/<_N>/_i/ s/<b>/3/
 800 }
 801
 802 Parrot_iseq_i_n_n {
 803     iseq_i_x_x  s/<s1>/FSR1/ s/<s2>/FSR2/ s/<t>/NUM/ s/<_N>/_n/ s/<b>/3/
 804 }
 805
 806 Parrot_islt_i_i_i {
 807     iseq_i_x_x  s/<s1>/ISR1/ s/<s2>/ISR2/ s/<t>/INT/ s/<_N>/_i/ s/<b>/1/
 808 }
 809
 810 Parrot_islt_i_n_n {
 811     iseq_i_x_x  s/<s1>/FSR1/ s/<s2>/FSR2/ s/<t>/NUM/ s/<_N>/_n/ s/<b>/1/
 812 }
 813
 814 Parrot_isle_i_i_i {
 815     isle_i_x_x  s/<s1>/ISR1/ s/<s2>/ISR2/ s/<t>/INT/ s/<_N>/_i/
 816 }
 817
 818 Parrot_isle_i_n_n {
 819     isle_i_x_x  s/<s1>/FSR1/ s/<s2>/FSR2/ s/<t>/NUM/ s/<_N>/_n/
 820 }
 821
 822 Parrot_cmp_i_i_i {
 823     cmp_i_x_x  s/<s1>/ISR1/ s/<s2>/ISR2/ s/<t>/INT/ s/<_N>/_i/
 824 }
 825
 826 Parrot_cmp_i_n_n {
 827     cmp_i_x_x  s/<s1>/FSR1/ s/<s2>/FSR2/ s/<t>/NUM/ s/<_N>/_n/
 828 }
 829
 830 Parrot_inc_i {
 831     if (MAP[1]) {
 832         jit_emit_add_rri_i (NATIVECODE, MAP[1], MAP[1], 1);
 833     }
 834     else {
 835         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 836         jit_emit_add_rri_i (NATIVECODE, ISR1, ISR1, 1);
 837         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 838     }
 839 }
 840
 841 Parrot_dec_i {
 842     if (MAP[1]) {
 843         jit_emit_add_rri_i (NATIVECODE, MAP[1], MAP[1], -1);
 844     }
 845     else {
 846         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 847         jit_emit_add_rri_i (NATIVECODE, ISR1, ISR1, -1);
 848         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 849     }
 850 }
 851
 852 Parrot_inc_n {
 853     static const double one = 1.0;
 854     jit_emit_mov_ri_i(NATIVECODE, ISR1, &one);
 855     jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
 856     if (MAP[1]) {
 857         jit_emit_fadd_rrr(NATIVECODE, MAP[1], MAP[1], FSR1);
 858     }
 859     else {
 860     jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(1));
 861         jit_emit_fadd_rrr(NATIVECODE, FSR2, FSR2, FSR1);
 862         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR2);
 863     }
 864 }
 865
 866 Parrot_dec_n {
 867     static const double one = 1.0;
 868     jit_emit_mov_ri_i(NATIVECODE, ISR1, &one);
 869     jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
 870     if (MAP[1]) {
 871         jit_emit_fsub_rrr(NATIVECODE, MAP[1], MAP[1], FSR1);
 872     }
 873     else {
 874     jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(1));
 875         jit_emit_fsub_rrr(NATIVECODE, FSR2, FSR2, FSR1);
 876         jit_emit_mov_mr_n(NATIVECODE, ROFFS_NUM(1), FSR2);
 877     }
 878 }
 879
 880
 881 TEMPLATE Parrot_unaryop_x {
 882     if (MAP[1]) {
 883         jit_emit_<op>_rr<_N>(NATIVECODE, MAP[1], MAP[1]);
 884     }
 885     else {
 886         jit_emit_mov_rm<_N>(NATIVECODE, SCRATCH1, ROFFS_INT(1));
 887         jit_emit_<op>_rr<_N>(NATIVECODE, SCRATCH1, SCRATCH1);
 888         jit_emit_mov_mr<_N>(NATIVECODE, ROFFS_INT(1), SCRATCH1);
 889     }
 890 }
 891
 892 ; a recursive template
 893 TEMPLATE Parrot_unaryop_i {
 894     Parrot_unaryop_x s/<_N>/_i/  s/SCRATCH1/ISR1/
 895 }
 896
 897 TEMPLATE Parrot_unaryop_n {
 898     Parrot_unaryop_x s/<_N>/_n/ s/INT/NUM/ s/SCRATCH1/FSR1/
 899 }
 900
 901 Parrot_neg_i {
 902     Parrot_unaryop_i s/<op>/neg/
 903 }
 904
 905 Parrot_neg_n {
 906     Parrot_unaryop_n s/<op>/neg/
 907 }
 908
 909 Parrot_abs_n {
 910     Parrot_unaryop_n s/<op>/abs/
 911 }
 912
 913 Parrot_abs_i {
 914     if (MAP[1]) {
 915         jit_emit_srawi(NATIVECODE, ISR1, MAP[1], 31);
 916         jit_emit_add_rrr(NATIVECODE, ISR2, ISR1, MAP[1]);
 917         jit_emit_xor_rrr(NATIVECODE, MAP[1], ISR2, ISR1);
 918     }
 919     else {
 920         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 921         jit_emit_srawi(NATIVECODE, ISR2, ISR1, 31);
 922         jit_emit_add_rrr(NATIVECODE, ISR1, ISR2, ISR1);
 923         jit_emit_xor_rrr(NATIVECODE, ISR1, ISR1, ISR2);
 924         jit_emit_mov_mr_i(NATIVECODE, ROFFS_INT(1), ISR1);
 925     }
 926 }
 927
 928
 929 TEMPLATE Parrot_ifunless_i_ic {
 930     if (P_ARITH && MAP[1]) {
 931         /* set the Rc bit of prev for the sake of +50% more MOPS  */
 932         NATIVECODE[-1] |= 1;
 933     }
 934     else if (MAP[1]) {
 935         jit_emit_cmp_ri(NATIVECODE, MAP[1], 0);
 936     }
 937     else {
 938         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 939         jit_emit_cmp_ri(NATIVECODE, ISR1, 0);
 940     }
 941     jit_emit_bc(jit_info, <COND>, *INT_CONST[2]);
 942 }
 943
 944 Parrot_if_i_ic {
 945     Parrot_ifunless_i_ic s/<COND>/BNE/
 946 }
 947
 948 Parrot_unless_i_ic {
 949     Parrot_ifunless_i_ic s/<COND>/BEQ/
 950 }
 951
 952 TEMPLATE Parrot_ifunless_n_ic {
 953     static const double zero = 0.0;
 954     jit_emit_mov_ri_i(NATIVECODE, ISR1, &zero);
 955     jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
 956     if (MAP[1]) {
 957         jit_emit_cmp_rr_n(NATIVECODE, MAP[1], FSR1);
 958     }
 959     else {
 960     jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(1));
 961         jit_emit_cmp_rr_n(NATIVECODE, FSR2, FSR1);
 962     }
 963     jit_emit_bc(jit_info, <COND>, *INT_CONST[2]);
 964 }
 965
 966 Parrot_if_n_ic {
 967     Parrot_ifunless_n_ic s/<COND>/BNE/
 968 }
 969
 970 Parrot_unless_n_ic {
 971     Parrot_ifunless_n_ic s/<COND>/BEQ/
 972 }
 973
 974 TEMPLATE Parrot_branch_i_i_ic {
 975 ; First, emit the compare op:
 976     if (MAP[1] && MAP[2]) {
 977         jit_emit_cmp_rr_i(NATIVECODE, MAP[1], MAP[2]);
 978     }
 979     else if (MAP[1]) {
 980         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(2));
 981         jit_emit_cmp_rr_i(NATIVECODE, MAP[1], ISR1);
 982     }
 983     else if (MAP[2]) {
 984         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
 985         jit_emit_cmp_rr_i(NATIVECODE, ISR1, MAP[2]);
 986     }
 987     else {
 988         jit_emit_mov_rm_i(NATIVECODE, ISR2, ROFFS_INT(1));
 989         jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(2));
 990         jit_emit_cmp_rr_i(NATIVECODE, ISR2, ISR1);
 991     }
 992 ; Now the branch. XXX: need to handle large displacements.
 993     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
 994 }
 995
 996 TEMPLATE Parrot_branch_i_ic_ic {
 997     jit_emit_mov_ri_i(NATIVECODE, ISR1, *INT_CONST[2]);
 998
 999     if (MAP[1]) {
1000         jit_emit_cmp_rr_i(NATIVECODE, MAP[1], ISR1);
1001     }
1002     else {
1003         jit_emit_mov_rm_i(NATIVECODE, ISR2, ROFFS_INT(1));
1004         jit_emit_cmp_rr_i(NATIVECODE, ISR2, ISR1);
1005     }
1006 ; Now the branch. XXX: need to handle large displacements.
1007     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
1008
1009 }
1010
1011 TEMPLATE Parrot_branch_ic_i_ic {
1012     jit_emit_mov_ri_i(NATIVECODE, ISR1, *INT_CONST[1]);
1013
1014     if (MAP[2]) {
1015         jit_emit_cmp_rr_i(NATIVECODE, ISR1, MAP[2]);
1016     }
1017     else {
1018         jit_emit_mov_rm_i(NATIVECODE, ISR2, ROFFS_INT(2));
1019         jit_emit_cmp_rr_i(NATIVECODE, ISR1, ISR2);
1020     }
1021 ; Now the branch. XXX: need to handle large displacements.
1022     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
1023 }
1024
1025 Parrot_eq_i_i_ic {
1026     Parrot_branch_i_i_ic s/<CON>/BEQ/
1027 }
1028
1029 Parrot_eq_i_ic_ic {
1030     Parrot_branch_i_ic_ic s/<CON>/BEQ/
1031 }
1032
1033 Parrot_eq_ic_i_ic {
1034     Parrot_branch_ic_i_ic s/<CON>/BEQ/
1035 }
1036
1037
1038 Parrot_lt_i_i_ic {
1039     Parrot_branch_i_i_ic s/<CON>/BLT/
1040 }
1041
1042 Parrot_lt_i_ic_ic {
1043     Parrot_branch_i_ic_ic s/<CON>/BLT/
1044 }
1045
1046 Parrot_lt_ic_i_ic {
1047     Parrot_branch_ic_i_ic s/<CON>/BLT/
1048 }
1049
1050 Parrot_le_i_i_ic {
1051     Parrot_branch_i_i_ic s/<CON>/BLE/
1052 }
1053
1054 Parrot_le_i_ic_ic {
1055     Parrot_branch_i_ic_ic s/<CON>/BLE/
1056 }
1057
1058 Parrot_le_ic_i_ic {
1059     Parrot_branch_ic_i_ic s/<CON>/BLE/
1060 }
1061
1062
1063 Parrot_ne_i_i_ic {
1064     Parrot_branch_i_i_ic s/<CON>/BNE/
1065 }
1066
1067 Parrot_ne_i_ic_ic {
1068     Parrot_branch_i_ic_ic s/<CON>/BNE/
1069 }
1070
1071 Parrot_ne_ic_i_ic {
1072     Parrot_branch_ic_i_ic s/<CON>/BNE/
1073 }
1074
1075
1076 TEMPLATE Parrot_branch_n_n_ic {
1077     if (MAP[1] && MAP[2]) {
1078         jit_emit_cmp_rr_n(NATIVECODE, MAP[1], MAP[2]);
1079     }
1080     else if (MAP[1]) {
1081         jit_emit_mov_rm_n(NATIVECODE, FSR1, ROFFS_NUM(2));
1082         jit_emit_cmp_rr_n(NATIVECODE, MAP[1], FSR1);
1083     }
1084     else if (MAP[2]) {
1085         jit_emit_mov_rm_n(NATIVECODE, FSR1, ROFFS_NUM(1));
1086         jit_emit_cmp_rr_n(NATIVECODE, FSR1, MAP[2]);
1087     }
1088     else {
1089         jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(1));
1090         jit_emit_mov_rm_n(NATIVECODE, FSR1, ROFFS_NUM(2));
1091         jit_emit_cmp_rr_n(NATIVECODE, FSR2, FSR1);
1092     }
1093     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
1094 }
1095
1096 TEMPLATE Parrot_branch_n_nc_ic {
1097     jit_emit_mov_ri_n(NATIVECODE, FSR1, &NUM_CONST[2]);
1098     if (MAP[1]) {
1099         jit_emit_cmp_rr_n(NATIVECODE, MAP[1], FSR1);
1100     }
1101     else {
1102         jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(1));
1103         jit_emit_cmp_rr_n(NATIVECODE, FSR2, FSR1);
1104     }
1105     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
1106 }
1107
1108 TEMPLATE Parrot_branch_nc_n_ic {
1109     if (MAP[2]) {
1110         jit_emit_mov_ri_i(NATIVECODE, ISR1, &NUM_CONST[1]);
1111         jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
1112         jit_emit_cmp_rr_n(NATIVECODE, FSR1, MAP[2]);
1113     }
1114     else {
1115         jit_emit_mov_rm_n(NATIVECODE, FSR2, ROFFS_NUM(2));
1116         jit_emit_mov_ri_i(NATIVECODE, ISR1, &NUM_CONST[1]);
1117         jit_emit_lfd(NATIVECODE, FSR1, 0, ISR1);
1118         jit_emit_cmp_rr_n(NATIVECODE, FSR1, FSR2);
1119     }
1120     jit_emit_bc(jit_info, <CON>, *INT_CONST[3]);
1121 }
1122
1123 Parrot_eq_n_n_ic {
1124         Parrot_branch_n_n_ic s/<CON>/BEQ/
1125 }
1126
1127 Parrot_eq_n_nc_ic {
1128     Parrot_branch_n_nc_ic s/<CON>/BEQ/
1129 }
1130
1131 Parrot_eq_nc_n_ic {
1132     Parrot_branch_nc_n_ic s/<CON>/BEQ/
1133 }
1134
1135
1136 Parrot_lt_n_n_ic {
1137     Parrot_branch_n_n_ic s/<CON>/BLT/
1138 }
1139
1140 Parrot_lt_n_nc_ic {
1141     Parrot_branch_n_nc_ic s/<CON>/BLT/
1142 }
1143
1144 Parrot_lt_nc_n_ic {
1145     Parrot_branch_nc_n_ic s/<CON>/BLT/
1146 }
1147
1148
1149 Parrot_le_n_n_ic {
1150     Parrot_branch_n_n_ic s/<CON>/BLE/
1151 }
1152
1153 Parrot_le_n_nc_ic {
1154     Parrot_branch_n_nc_ic s/<CON>/BLE/
1155 }
1156
1157 Parrot_le_nc_n_ic {
1158     Parrot_branch_nc_n_ic s/<CON>/BLE/
1159 }
1160
1161 Parrot_ne_n_n_ic {
1162     Parrot_branch_n_n_ic s/<CON>/BNE/
1163 }
1164
1165 Parrot_ne_n_nc_ic {
1166     Parrot_branch_n_nc_ic s/<CON>/BNE/
1167 }
1168
1169 Parrot_ne_nc_n_ic {
1170     Parrot_branch_nc_n_ic s/<CON>/BLE/
1171 }
1172
1173
1174 Parrot_branch_ic {
1175     jit_emit_bx(jit_info, 0, *INT_CONST[1]);
1176 }
1177
1178 Parrot_branch_i {
1179     jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_INT(1));
1180     jit_emit_mtlr(NATIVECODE, ISR1);
1181     jit_emit_blr(NATIVECODE);
1182 }
1183
1184 TEMPLATE Parrot_set_or_clone_s_sc {
1185 ; string_copy(Interp *interp, STRING *s)
1186     jit_emit_mov_rr(NATIVECODE, r3, r16);
1187     jit_emit_mov_ri_i(NATIVECODE, r4, CONST(2)->u.string);
1188
1189     jit_emit_call_func(NATIVECODE, (void*) string_copy);
1190
1191     jit_emit_mov_mr_i(NATIVECODE, ROFFS_STR(1), r3);
1192 }
1193
1194 Parrot_set_s_sc {
1195     Parrot_set_or_clone_s_sc
1196 }
1197
1198 Parrot_clone_s_sc {
1199     Parrot_set_or_clone_s_sc
1200 }
1201
1202 Parrot_set_s_s {
1203     jit_emit_mov_rm_i(NATIVECODE, ISR1, ROFFS_STR(2));
1204     jit_emit_mov_mr_i(NATIVECODE, ROFFS_STR(1), ISR1);
1205 }
1206
1207 Parrot_clone_s_s {
1208     jit_emit_mov_rr(NATIVECODE, r3, r16);
1209     jit_emit_mov_rm_i(NATIVECODE, r4, ROFFS_STR(2));
1210
1211     jit_emit_call_func(NATIVECODE, (void*) string_copy);
1212
1213     jit_emit_mov_mr_i(NATIVECODE,ROFFS_STR(1), r3);
1214 }
1215
1216 Parrot_set_p_pc {
1217     jit_emit_mov_ri_i(NATIVECODE, ISR1, CONST(2)->u.key);
1218     jit_emit_mov_mr_i(NATIVECODE, ROFFS_PMC(1), ISR1);
1219 }
1220
1221 ; the following 4 ops don't branch but are translated as cpfp
1222 ; which adds unneeded overhead - convert to normal ops
1223 ; or just JIT (TODO)  the 2 easy ones
1224 Parrot_set_args_pc {
1225     if (jit_info->code_type == JIT_CODE_FILE) {
1226     jit_emit_mov_ri_i(NATIVECODE, ISR1, jit_info->cur_op);
1227     jit_emit_stw(NATIVECODE, ISR1, offsetof(Interp, current_args), r16);
1228     }
1229     else  {
1230         jit_set_args_pc(jit_info, interp,
1231             jit_info->flags & JIT_CODE_RECURSIVE);
1232     }
1233 }
1234
1235 extern Parrot_set_returns_pc {
1236     if (jit_info->code_type == JIT_CODE_FILE)
1237     Parrot_jit_normal_op(jit_info, interp);
1238     else {
1239         jit_set_returns_pc(jit_info, interp,
1240             jit_info->flags & JIT_CODE_RECURSIVE);
1241     }
1242 }
1243
1244 extern Parrot_returncc {
1245     if (jit_info->code_type == JIT_CODE_FILE)
1246     Parrot_jit_restart_op(jit_info, interp);
1247     else {
1248     /* fetch args[n+1] -> retval */
1249         if (!(jit_info->flags & JIT_CODE_RECURSIVE)) {
1250         jit_emit_lwz(jit_info->native_ptr, r1, 0, r1);
1251         jit_emit_lwz(jit_info->native_ptr, r3, 4 + jit_info->n_args * 4, r5);
1252         jit_emit_lwz(jit_info->native_ptr, r31, -4, r1);
1253         jit_emit_lwz(jit_info->native_ptr, r0, 8, r1);   /* get link reg */
1254         jit_emit_mtlr(jit_info->native_ptr, r0);   /* move to link reg */
1255     }
1256     jit_emit_blr(jit_info->native_ptr);
1257     }
1258 }
1259
1260 Parrot_pic_callr___pc {
1261     PackFile_Constant **constants  = CONTEXT(interp)->constants;
1262     PMC                *sig_result = constants[CUR_OPCODE[1]]->u.key;
1263     opcode_t           *params     = jit_info->optimizer->sections->begin;
1264     PMC                *sig_params = constants[params[1]]->u.key;
1265     int                 op_i       = SIG_ELEMS(sig_params) + 2;
1266     int                 offset     = jit_info->arena.op_map[op_i].offset;
1267     int                 here       = NATIVECODE - jit_info->arena.start;
1268     int                 skip;
1269
1270     /* TODO preserve necessary regs */
1271     assert(*CUR_OPCODE == PARROT_OP_get_results_pc);
1272
1273     if (!SIG_ELEMS(sig_result))
1274         skip = -1;
1275     /* skip result - save rest */
1276     else
1277         skip = MAP(2);
1278
1279     offset -= here;
1280
1281     /* bl */
1282     _emit_bx(NATIVECODE, 1, offset);
1283
1284     jit_restore_regs_call(jit_info, interp, skip);
1285 }
1286
1287 extern Parrot_get_params_pc {
1288     if (jit_info->code_type == JIT_CODE_FILE)
1289     Parrot_jit_normal_op(jit_info, interp);
1290     else if (!(jit_info->flags & JIT_CODE_RECURSIVE)) {
1291         jit_get_params_pc(jit_info, interp);
1292     }
1293 }
1294
1295 Parrot_get_results_pc {
1296     if (jit_info->code_type == JIT_CODE_FILE) {
1297     jit_emit_mov_ri_i(NATIVECODE, ISR1, jit_info->cur_op);
1298     jit_emit_lwz(NATIVECODE, ISR2, offsetof(Interp, ctx.state), r16);
1299     jit_emit_stw(NATIVECODE, ISR1,
1300         offsetof(parrot_context_t, current_results), ISR2);
1301     }
1302     else {
1303     PackFile_Constant **constants  = CONTEXT(interp)->constants;
1304     PMC                *sig_result = constants[CUR_OPCODE[1]]->u.key;
1305
1306     if (!SIG_ELEMS(sig_result))
1307         return;
1308
1309     /* result is r3 TODO Nums */
1310     jit_emit_mov_rr(NATIVECODE, MAP(2), r3);
1311     }
1312 }