mono/mini/mini-ppc.c

   1 /*
   2  * mini-ppc.c: PowerPC backend for the Mono code generator
   3  *
   4  * Authors:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *   Dietmar Maurer (dietmar@ximian.com)
   7  *   Andreas Faerber <andreas.faerber@web.de>
   8  *
   9  * (C) 2003 Ximian, Inc.
  10  * (C) 2007-2008 Andreas Faerber
  11  */
  12 #include "mini.h"
  13 #include <string.h>
  14
  15 #include <mono/metadata/appdomain.h>
  16 #include <mono/metadata/debug-helpers.h>
  17 #include <mono/utils/mono-proclib.h>
  18 #include <mono/utils/mono-mmap.h>
  19
  20 #include "mini-ppc.h"
  21 #ifdef TARGET_POWERPC64
  22 #include "cpu-ppc64.h"
  23 #else
  24 #include "cpu-ppc.h"
  25 #endif
  26 #include "trace.h"
  27 #include "ir-emit.h"
  28 #ifdef __APPLE__
  29 #include <sys/sysctl.h>
  30 #endif
  31 #ifdef __linux__
  32 #include <unistd.h>
  33 #endif
  34
  35 #define FORCE_INDIR_CALL 1
  36
  37 enum {
  38         TLS_MODE_DETECT,
  39         TLS_MODE_FAILED,
  40         TLS_MODE_LTHREADS,
  41         TLS_MODE_NPTL,
  42         TLS_MODE_DARWIN_G4,
  43         TLS_MODE_DARWIN_G5
  44 };
  45
  46 /* cpu_hw_caps contains the flags defined below */
  47 static int cpu_hw_caps = 0;
  48 static int cachelinesize = 0;
  49 static int cachelineinc = 0;
  50 enum {
  51         PPC_ICACHE_SNOOP      = 1 << 0,
  52         PPC_MULTIPLE_LS_UNITS = 1 << 1,
  53         PPC_SMP_CAPABLE       = 1 << 2,
  54         PPC_ISA_2X            = 1 << 3,
  55         PPC_ISA_64            = 1 << 4,
  56         PPC_MOVE_FPR_GPR      = 1 << 5,
  57         PPC_HW_CAP_END
  58 };
  59
  60 #define BREAKPOINT_SIZE (PPC_LOAD_SEQUENCE_LENGTH + 4)
  61
  62 /* This mutex protects architecture specific caches */
  63 #define mono_mini_arch_lock() EnterCriticalSection (&mini_arch_mutex)
  64 #define mono_mini_arch_unlock() LeaveCriticalSection (&mini_arch_mutex)
  65 static CRITICAL_SECTION mini_arch_mutex;
  66
  67 int mono_exc_esp_offset = 0;
  68 static int tls_mode = TLS_MODE_DETECT;
  69 static int lmf_pthread_key = -1;
  70 static int monodomain_key = -1;
  71
  72 /*
  73  * The code generated for sequence points reads from this location, which is
  74  * made read-only when single stepping is enabled.
  75  */
  76 static gpointer ss_trigger_page;
  77
  78 /* Enabled breakpoints read from this trigger page */
  79 static gpointer bp_trigger_page;
  80
  81 static int
  82 offsets_from_pthread_key (guint32 key, int *offset2)
  83 {
  84         int idx1 = key / 32;
  85         int idx2 = key % 32;
  86         *offset2 = idx2 * sizeof (gpointer);
  87         return 284 + idx1 * sizeof (gpointer);
  88 }
  89
  90 #define emit_linuxthreads_tls(code,dreg,key) do {\
  91                 int off1, off2; \
  92                 off1 = offsets_from_pthread_key ((key), &off2); \
  93                 ppc_ldptr ((code), (dreg), off1, ppc_r2);       \
  94                 ppc_ldptr ((code), (dreg), off2, (dreg));       \
  95         } while (0);
  96
  97 #define emit_darwing5_tls(code,dreg,key) do {\
  98                 int off1 = 0x48 + key * sizeof (gpointer);      \
  99                 ppc_mfspr ((code), (dreg), 104);        \
 100                 ppc_ldptr ((code), (dreg), off1, (dreg));       \
 101         } while (0);
 102
 103 /* FIXME: ensure the sc call preserves all but r3 */
 104 #define emit_darwing4_tls(code,dreg,key) do {\
 105                 int off1 = 0x48 + key * sizeof (gpointer);      \
 106                 if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r11, ppc_r3); \
 107                 ppc_li ((code), ppc_r0, 0x7FF2);        \
 108                 ppc_sc ((code));        \
 109                 ppc_lwz ((code), (dreg), off1, ppc_r3); \
 110                 if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r3, ppc_r11); \
 111         } while (0);
 112
 113 #ifdef PPC_THREAD_PTR_REG
 114 #define emit_nptl_tls(code,dreg,key) do { \
 115                 int off1 = key; \
 116                 int off2 = key >> 15; \
 117                 if ((off2 == 0) || (off2 == -1)) { \
 118                         ppc_ldptr ((code), (dreg), off1, PPC_THREAD_PTR_REG);   \
 119                 } else { \
 120                         int off3 = (off2 + 1) > 1; \
 121                         ppc_addis ((code), ppc_r11, PPC_THREAD_PTR_REG, off3); \
 122                         ppc_ldptr ((code), (dreg), off1, ppc_r11);      \
 123                 } \
 124         } while (0);
 125 #else
 126 #define emit_nptl_tls(code,dreg,key) do {       \
 127                 g_assert_not_reached ();        \
 128         } while (0)
 129 #endif
 130
 131 #define emit_tls_access(code,dreg,key) do {     \
 132                 switch (tls_mode) {     \
 133                 case TLS_MODE_LTHREADS: emit_linuxthreads_tls(code,dreg,key); break;    \
 134                 case TLS_MODE_NPTL: emit_nptl_tls(code,dreg,key); break;        \
 135                 case TLS_MODE_DARWIN_G5: emit_darwing5_tls(code,dreg,key); break;       \
 136                 case TLS_MODE_DARWIN_G4: emit_darwing4_tls(code,dreg,key); break;       \
 137                 default: g_assert_not_reached ();       \
 138                 }       \
 139         } while (0)
 140
 141 #define MONO_EMIT_NEW_LOAD_R8(cfg,dr,addr) do { \
 142                 MonoInst *inst;                                                    \
 143                 MONO_INST_NEW ((cfg), (inst), OP_R8CONST); \
 144                 inst->type = STACK_R8;                     \
 145                 inst->dreg = (dr);                     \
 146                 inst->inst_p0 = (void*)(addr);         \
 147                 mono_bblock_add_inst (cfg->cbb, inst); \
 148         } while (0)
 149
 150 const char*
 151 mono_arch_regname (int reg) {
 152         static const char rnames[][4] = {
 153                 "r0", "sp", "r2", "r3", "r4",
 154                 "r5", "r6", "r7", "r8", "r9",
 155                 "r10", "r11", "r12", "r13", "r14",
 156                 "r15", "r16", "r17", "r18", "r19",
 157                 "r20", "r21", "r22", "r23", "r24",
 158                 "r25", "r26", "r27", "r28", "r29",
 159                 "r30", "r31"
 160         };
 161         if (reg >= 0 && reg < 32)
 162                 return rnames [reg];
 163         return "unknown";
 164 }
 165
 166 const char*
 167 mono_arch_fregname (int reg) {
 168         static const char rnames[][4] = {
 169                 "f0", "f1", "f2", "f3", "f4",
 170                 "f5", "f6", "f7", "f8", "f9",
 171                 "f10", "f11", "f12", "f13", "f14",
 172                 "f15", "f16", "f17", "f18", "f19",
 173                 "f20", "f21", "f22", "f23", "f24",
 174                 "f25", "f26", "f27", "f28", "f29",
 175                 "f30", "f31"
 176         };
 177         if (reg >= 0 && reg < 32)
 178                 return rnames [reg];
 179         return "unknown";
 180 }
 181
 182 /* this function overwrites r0, r11, r12 */
 183 static guint8*
 184 emit_memcpy (guint8 *code, int size, int dreg, int doffset, int sreg, int soffset)
 185 {
 186         /* unrolled, use the counter in big */
 187         if (size > sizeof (gpointer) * 5) {
 188                 long shifted = size / SIZEOF_VOID_P;
 189                 guint8 *copy_loop_start, *copy_loop_jump;
 190
 191                 ppc_load (code, ppc_r0, shifted);
 192                 ppc_mtctr (code, ppc_r0);
 193                 g_assert (sreg == ppc_r11);
 194                 ppc_addi (code, ppc_r12, dreg, (doffset - sizeof (gpointer)));
 195                 ppc_addi (code, ppc_r11, sreg, (soffset - sizeof (gpointer)));
 196                 copy_loop_start = code;
 197                 ppc_ldptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r11);
 198                 ppc_stptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r12);
 199                 copy_loop_jump = code;
 200                 ppc_bc (code, PPC_BR_DEC_CTR_NONZERO, 0, 0);
 201                 ppc_patch (copy_loop_jump, copy_loop_start);
 202                 size -= shifted * sizeof (gpointer);
 203                 doffset = soffset = 0;
 204                 dreg = ppc_r12;
 205         }
 206 #ifdef __mono_ppc64__
 207         /* the hardware has multiple load/store units and the move is long
 208            enough to use more then one regiester, then use load/load/store/store
 209            to execute 2 instructions per cycle. */
 210         if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r12) && (sreg != ppc_r12)) {
 211                 while (size >= 16) {
 212                         ppc_ldptr (code, ppc_r0, soffset, sreg);
 213                         ppc_ldptr (code, ppc_r12, soffset+8, sreg);
 214                         ppc_stptr (code, ppc_r0, doffset, dreg);
 215                         ppc_stptr (code, ppc_r12, doffset+8, dreg);
 216                         size -= 16;
 217                         soffset += 16;
 218                         doffset += 16;
 219                 }
 220         }
 221         while (size >= 8) {
 222                 ppc_ldr (code, ppc_r0, soffset, sreg);
 223                 ppc_str (code, ppc_r0, doffset, dreg);
 224                 size -= 8;
 225                 soffset += 8;
 226                 doffset += 8;
 227         }
 228 #else
 229         if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r12) && (sreg != ppc_r12)) {
 230                 while (size >= 8) {
 231                         ppc_lwz (code, ppc_r0, soffset, sreg);
 232                         ppc_lwz (code, ppc_r12, soffset+4, sreg);
 233                         ppc_stw (code, ppc_r0, doffset, dreg);
 234                         ppc_stw (code, ppc_r12, doffset+4, dreg);
 235                         size -= 8;
 236                         soffset += 8;
 237                         doffset += 8;
 238                 }
 239         }
 240 #endif
 241         while (size >= 4) {
 242                 ppc_lwz (code, ppc_r0, soffset, sreg);
 243                 ppc_stw (code, ppc_r0, doffset, dreg);
 244                 size -= 4;
 245                 soffset += 4;
 246                 doffset += 4;
 247         }
 248         while (size >= 2) {
 249                 ppc_lhz (code, ppc_r0, soffset, sreg);
 250                 ppc_sth (code, ppc_r0, doffset, dreg);
 251                 size -= 2;
 252                 soffset += 2;
 253                 doffset += 2;
 254         }
 255         while (size >= 1) {
 256                 ppc_lbz (code, ppc_r0, soffset, sreg);
 257                 ppc_stb (code, ppc_r0, doffset, dreg);
 258                 size -= 1;
 259                 soffset += 1;
 260                 doffset += 1;
 261         }
 262         return code;
 263 }
 264
 265 /*
 266  * mono_arch_get_argument_info:
 267  * @csig:  a method signature
 268  * @param_count: the number of parameters to consider
 269  * @arg_info: an array to store the result infos
 270  *
 271  * Gathers information on parameters such as size, alignment and
 272  * padding. arg_info should be large enought to hold param_count + 1 entries.
 273  *
 274  * Returns the size of the activation frame.
 275  */
 276 int
 277 mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
 278 {
 279 #ifdef __mono_ppc64__
 280         NOT_IMPLEMENTED;
 281         return -1;
 282 #else
 283         int k, frame_size = 0;
 284         int size, align, pad;
 285         int offset = 8;
 286
 287         if (MONO_TYPE_ISSTRUCT (csig->ret)) {
 288                 frame_size += sizeof (gpointer);
 289                 offset += 4;
 290         }
 291
 292         arg_info [0].offset = offset;
 293
 294         if (csig->hasthis) {
 295                 frame_size += sizeof (gpointer);
 296                 offset += 4;
 297         }
 298
 299         arg_info [0].size = frame_size;
 300
 301         for (k = 0; k < param_count; k++) {
 302
 303                 if (csig->pinvoke)
 304                         size = mono_type_native_stack_size (csig->params [k], (guint32*)&align);
 305                 else
 306                         size = mini_type_stack_size (NULL, csig->params [k], &align);
 307
 308                 /* ignore alignment for now */
 309                 align = 1;
 310
 311                 frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 312                 arg_info [k].pad = pad;
 313                 frame_size += size;
 314                 arg_info [k + 1].pad = 0;
 315                 arg_info [k + 1].size = size;
 316                 offset += pad;
 317                 arg_info [k + 1].offset = offset;
 318                 offset += size;
 319         }
 320
 321         align = MONO_ARCH_FRAME_ALIGNMENT;
 322         frame_size += pad = (align - (frame_size & (align - 1))) & (align - 1);
 323         arg_info [k].pad = pad;
 324
 325         return frame_size;
 326 #endif
 327 }
 328
 329 #ifdef __mono_ppc64__
 330 static gboolean
 331 is_load_sequence (guint32 *seq)
 332 {
 333         return ppc_opcode (seq [0]) == 15 && /* lis */
 334                 ppc_opcode (seq [1]) == 24 && /* ori */
 335                 ppc_opcode (seq [2]) == 30 && /* sldi */
 336                 ppc_opcode (seq [3]) == 25 && /* oris */
 337                 ppc_opcode (seq [4]) == 24; /* ori */
 338 }
 339
 340 #define ppc_load_get_dest(l)    (((l)>>21) & 0x1f)
 341 #define ppc_load_get_off(l)     ((gint16)((l) & 0xffff))
 342 #endif
 343
 344 /* code must point to the blrl */
 345 gboolean
 346 mono_ppc_is_direct_call_sequence (guint32 *code)
 347 {
 348 #ifdef __mono_ppc64__
 349         g_assert(*code == 0x4e800021 || *code == 0x4e800020 || *code == 0x4e800420);
 350
 351         /* the thunk-less direct call sequence: lis/ori/sldi/oris/ori/mtlr/blrl */
 352         if (ppc_opcode (code [-1]) == 31) { /* mtlr */
 353                 if (ppc_opcode (code [-2]) == 58 && ppc_opcode (code [-3]) == 58) { /* ld/ld */
 354                         if (!is_load_sequence (&code [-8]))
 355                                 return FALSE;
 356                         /* one of the loads must be "ld r2,8(rX)" */
 357                         return (ppc_load_get_dest (code [-2]) == ppc_r2 && ppc_load_get_off (code [-2]) == 8) ||
 358                                 (ppc_load_get_dest (code [-3]) == ppc_r2 && ppc_load_get_off (code [-3]) == 8);
 359                 }
 360                 if (ppc_opcode (code [-2]) == 24 && ppc_opcode (code [-3]) == 31) /* mr/nop */
 361                         return is_load_sequence (&code [-8]);
 362                 else
 363                         return is_load_sequence (&code [-6]);
 364         }
 365         return FALSE;
 366 #else
 367         g_assert(*code == 0x4e800021);
 368
 369         /* the thunk-less direct call sequence: lis/ori/mtlr/blrl */
 370         return ppc_opcode (code [-1]) == 31 &&
 371                 ppc_opcode (code [-2]) == 24 &&
 372                 ppc_opcode (code [-3]) == 15;
 373 #endif
 374 }
 375
 376 gpointer
 377 mono_arch_get_vcall_slot (guint8 *code_ptr, mgreg_t *regs, int *displacement)
 378 {
 379         char *o = NULL;
 380         int reg, offset = 0;
 381         guint32* code = (guint32*)code_ptr;
 382         mgreg_t *r = (mgreg_t*)regs;
 383
 384         *displacement = 0;
 385
 386         /* This is the 'blrl' instruction */
 387         --code;
 388
 389         /* Sanity check: instruction must be 'blrl' */
 390         if (*code != 0x4e800021)
 391                 return NULL;
 392
 393         if (mono_ppc_is_direct_call_sequence (code))
 394                 return NULL;
 395
 396         /* FIXME: more sanity checks here */
 397         /* OK, we're now at the 'blrl' instruction. Now walk backwards
 398         till we get to a 'mtlr rA' */
 399         for (; --code;) {
 400                 if((*code & 0x7c0803a6) == 0x7c0803a6) {
 401                         gint16 soff;
 402                         /* Here we are: we reached the 'mtlr rA'.
 403                         Extract the register from the instruction */
 404                         reg = (*code & 0x03e00000) >> 21;
 405                         --code;
 406                         /* ok, this is a lwz reg, offset (vtreg)
 407                          * it is emitted with:
 408                          * ppc_emit32 (c, (32 << 26) | ((D) << 21) | ((a) << 16) | (guint16)(d))
 409                          */
 410                         soff = (*code & 0xffff);
 411                         offset = soff;
 412                         reg = (*code >> 16) & 0x1f;
 413                         g_assert (reg != ppc_r1);
 414                         /*g_print ("patching reg is %d\n", reg);*/
 415                         o = (gpointer)(gsize)r [reg];
 416                         break;
 417                 }
 418         }
 419         *displacement = offset;
 420         return o;
 421 }
 422
 423 #define MAX_ARCH_DELEGATE_PARAMS 7
 424
 425 static gpointer
 426 get_delegate_invoke_impl (gboolean has_target, guint32 param_count, guint32 *code_len, gboolean aot)
 427 {
 428         guint8 *code, *start;
 429
 430         if (has_target) {
 431                 int size = MONO_PPC_32_64_CASE (32, 32) + PPC_FTNPTR_SIZE;
 432
 433                 start = code = mono_global_codeman_reserve (size);
 434                 if (!aot)
 435                         code = mono_ppc_create_pre_code_ftnptr (code);
 436
 437                 /* Replace the this argument with the target */
 438                 ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET (MonoDelegate, method_ptr), ppc_r3);
 439 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
 440                 /* it's a function descriptor */
 441                 /* Can't use ldptr as it doesn't work with r0 */
 442                 ppc_ldptr_indexed (code, ppc_r0, 0, ppc_r0);
 443 #endif
 444                 ppc_mtctr (code, ppc_r0);
 445                 ppc_ldptr (code, ppc_r3, G_STRUCT_OFFSET (MonoDelegate, target), ppc_r3);
 446                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
 447
 448                 g_assert ((code - start) <= size);
 449
 450                 mono_arch_flush_icache (start, size);
 451         } else {
 452                 int size, i;
 453
 454                 size = MONO_PPC_32_64_CASE (32, 32) + param_count * 4 + PPC_FTNPTR_SIZE;
 455                 start = code = mono_global_codeman_reserve (size);
 456                 if (!aot)
 457                         code = mono_ppc_create_pre_code_ftnptr (code);
 458
 459                 ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET (MonoDelegate, method_ptr), ppc_r3);
 460 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
 461                 /* it's a function descriptor */
 462                 ppc_ldptr_indexed (code, ppc_r0, 0, ppc_r0);
 463 #endif
 464                 ppc_mtctr (code, ppc_r0);
 465                 /* slide down the arguments */
 466                 for (i = 0; i < param_count; ++i) {
 467                         ppc_mr (code, (ppc_r3 + i), (ppc_r3 + i + 1));
 468                 }
 469                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
 470
 471                 g_assert ((code - start) <= size);
 472
 473                 mono_arch_flush_icache (start, size);
 474         }
 475
 476         if (code_len)
 477                 *code_len = code - start;
 478
 479         return start;
 480 }
 481
 482 GSList*
 483 mono_arch_get_delegate_invoke_impls (void)
 484 {
 485         GSList *res = NULL;
 486         guint8 *code;
 487         guint32 code_len;
 488         int i;
 489
 490         code = get_delegate_invoke_impl (TRUE, 0, &code_len, TRUE);
 491         res = g_slist_prepend (res, mono_aot_tramp_info_create (g_strdup ("delegate_invoke_impl_has_target"), code, code_len));
 492
 493         for (i = 0; i < MAX_ARCH_DELEGATE_PARAMS; ++i) {
 494                 code = get_delegate_invoke_impl (FALSE, i, &code_len, TRUE);
 495                 res = g_slist_prepend (res, mono_aot_tramp_info_create (g_strdup_printf ("delegate_invoke_impl_target_%d", i), code, code_len));
 496         }
 497
 498         return res;
 499 }
 500
 501 gpointer
 502 mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target)
 503 {
 504         guint8 *code, *start;
 505
 506         /* FIXME: Support more cases */
 507         if (MONO_TYPE_ISSTRUCT (sig->ret))
 508                 return NULL;
 509
 510         if (has_target) {
 511                 static guint8* cached = NULL;
 512
 513                 if (cached)
 514                         return cached;
 515
 516                 if (mono_aot_only)
 517                         start = mono_aot_get_named_code ("delegate_invoke_impl_has_target");
 518                 else
 519                         start = get_delegate_invoke_impl (TRUE, 0, NULL, FALSE);
 520
 521                 mono_memory_barrier ();
 522
 523                 cached = start;
 524         } else {
 525                 static guint8* cache [MAX_ARCH_DELEGATE_PARAMS + 1] = {NULL};
 526                 int i;
 527
 528                 if (sig->param_count > MAX_ARCH_DELEGATE_PARAMS)
 529                         return NULL;
 530                 for (i = 0; i < sig->param_count; ++i)
 531                         if (!mono_is_regsize_var (sig->params [i]))
 532                                 return NULL;
 533
 534
 535                 code = cache [sig->param_count];
 536                 if (code)
 537                         return code;
 538
 539                 if (mono_aot_only) {
 540                         char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", sig->param_count);
 541                         start = mono_aot_get_named_code (name);
 542                         g_free (name);
 543                 } else {
 544                         start = get_delegate_invoke_impl (FALSE, sig->param_count, NULL, FALSE);
 545                 }
 546
 547                 mono_memory_barrier ();
 548
 549                 cache [sig->param_count] = start;
 550         }
 551         return start;
 552 }
 553
 554 gpointer
 555 mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
 556 {
 557         mgreg_t *r = (mgreg_t*)regs;
 558
 559         /* FIXME: handle returning a struct */
 560         if (MONO_TYPE_ISSTRUCT (sig->ret))
 561                 return (gpointer)(gsize)r [ppc_r4];
 562         return (gpointer)(gsize)r [ppc_r3];
 563 }
 564
 565 typedef struct {
 566         long int type;
 567         long int value;
 568 } AuxVec;
 569
 570 #ifdef USE_ENVIRON_HACK
 571 static AuxVec*
 572 linux_find_auxv (int *count)
 573 {
 574         AuxVec *vec;
 575         int c = 0;
 576         char **result = __environ;
 577         /* Scan over the env vector looking for the ending NULL */
 578         for (; *result != NULL; ++result) {
 579         }
 580         /* Bump the pointer one more step, which should be the auxv. */
 581         ++result;
 582         vec = (AuxVec *)result;
 583         if (vec->type != 22 /*AT_IGNOREPPC*/) {
 584                 *count = 0;
 585                 return NULL;
 586         }
 587         while (vec->type != 0 /*AT_NULL*/) {
 588                 vec++;
 589                 c++;
 590         }
 591         *count = c;
 592         return (AuxVec *)result;
 593 }
 594 #endif
 595
 596 #define MAX_AUX_ENTRIES 128
 597 /*
 598  * PPC_FEATURE_POWER4, PPC_FEATURE_POWER5, PPC_FEATURE_POWER5_PLUS, PPC_FEATURE_CELL,
 599  * PPC_FEATURE_PA6T, PPC_FEATURE_ARCH_2_05 are considered supporting 2X ISA features
 600  */
 601 #define ISA_2X (0x00080000 | 0x00040000 | 0x00020000 | 0x00010000 | 0x00000800 | 0x00001000)
 602
 603 /* define PPC_FEATURE_64 HWCAP for 64-bit category.  */
 604 #define ISA_64 0x40000000
 605
 606 /* define PPC_FEATURE_POWER6_EXT HWCAP for power6x mffgpr/mftgpr instructions.  */
 607 #define ISA_MOVE_FPR_GPR 0x00000200
 608 /*
 609  * Initialize the cpu to execute managed code.
 610  */
 611 void
 612 mono_arch_cpu_init (void)
 613 {
 614 #ifdef __APPLE__
 615         int mib [3];
 616         size_t len;
 617         mib [0] = CTL_HW;
 618         mib [1] = HW_CACHELINE;
 619         len = sizeof (cachelinesize);
 620         if (sysctl (mib, 2, &cachelinesize, (size_t*)&len, NULL, 0) == -1) {
 621                 perror ("sysctl");
 622                 cachelinesize = 128;
 623         } else {
 624                 cachelineinc = cachelinesize;
 625         }
 626 #elif defined(__linux__)
 627         AuxVec vec [MAX_AUX_ENTRIES];
 628         int i, vec_entries = 0;
 629         /* sadly this will work only with 2.6 kernels... */
 630         FILE* f = fopen ("/proc/self/auxv", "rb");
 631         if (f) {
 632                 vec_entries = fread (&vec, sizeof (AuxVec), MAX_AUX_ENTRIES, f);
 633                 fclose (f);
 634 #ifdef USE_ENVIRON_HACK
 635         } else {
 636                 AuxVec *evec = linux_find_auxv (&vec_entries);
 637                 if (vec_entries)
 638                         memcpy (&vec, evec, sizeof (AuxVec) * MIN (vec_entries, MAX_AUX_ENTRIES));
 639 #endif
 640         }
 641         for (i = 0; i < vec_entries; i++) {
 642                 int type = vec [i].type;
 643                 if (type == 19) { /* AT_DCACHEBSIZE */
 644                         cachelinesize = vec [i].value;
 645                         continue;
 646                 } else if (type == 16) { /* AT_HWCAP */
 647                         if (vec [i].value & 0x00002000 /*PPC_FEATURE_ICACHE_SNOOP*/)
 648                                 cpu_hw_caps |= PPC_ICACHE_SNOOP;
 649                         if (vec [i].value & ISA_2X)
 650                                 cpu_hw_caps |= PPC_ISA_2X;
 651                         if (vec [i].value & ISA_64)
 652                                 cpu_hw_caps |= PPC_ISA_64;
 653                         if (vec [i].value & ISA_MOVE_FPR_GPR)
 654                                 cpu_hw_caps |= PPC_MOVE_FPR_GPR;
 655                         continue;
 656                 } else if (type == 15) { /* AT_PLATFORM */
 657                         const char *arch = (char*)vec [i].value;
 658                         if (strcmp (arch, "ppc970") == 0 ||
 659                                         (strncmp (arch, "power", 5) == 0 && arch [5] >= '4' && arch [5] <= '7'))
 660                                 cpu_hw_caps |= PPC_MULTIPLE_LS_UNITS;
 661                         /*printf ("cpu: %s\n", (char*)vec [i].value);*/
 662                         continue;
 663                 }
 664         }
 665 #elif defined(G_COMPILER_CODEWARRIOR)
 666         cachelinesize = 32;
 667         cachelineinc = 32;
 668 #elif defined(MONO_CROSS_COMPILE)
 669 #else
 670 //#error Need a way to get cache line size
 671 #endif
 672         if (!cachelinesize)
 673                 cachelinesize = 32;
 674         if (!cachelineinc)
 675                 cachelineinc = cachelinesize;
 676
 677         if (mono_cpu_count () > 1)
 678                 cpu_hw_caps |= PPC_SMP_CAPABLE;
 679 }
 680
 681 /*
 682  * Initialize architecture specific code.
 683  */
 684 void
 685 mono_arch_init (void)
 686 {
 687         InitializeCriticalSection (&mini_arch_mutex);
 688
 689         ss_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ|MONO_MMAP_32BIT);
 690         bp_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ|MONO_MMAP_32BIT);
 691         mono_mprotect (bp_trigger_page, mono_pagesize (), 0);
 692 }
 693
 694 /*
 695  * Cleanup architecture specific code.
 696  */
 697 void
 698 mono_arch_cleanup (void)
 699 {
 700         DeleteCriticalSection (&mini_arch_mutex);
 701 }
 702
 703 /*
 704  * This function returns the optimizations supported on this cpu.
 705  */
 706 guint32
 707 mono_arch_cpu_optimizazions (guint32 *exclude_mask)
 708 {
 709         guint32 opts = 0;
 710
 711         /* no ppc-specific optimizations yet */
 712         *exclude_mask = 0;
 713         return opts;
 714 }
 715
 716 #ifdef __mono_ppc64__
 717 #define CASE_PPC32(c)
 718 #define CASE_PPC64(c)   case c:
 719 #else
 720 #define CASE_PPC32(c)   case c:
 721 #define CASE_PPC64(c)
 722 #endif
 723
 724 static gboolean
 725 is_regsize_var (MonoType *t) {
 726         if (t->byref)
 727                 return TRUE;
 728         t = mini_type_get_underlying_type (NULL, t);
 729         switch (t->type) {
 730         case MONO_TYPE_I4:
 731         case MONO_TYPE_U4:
 732         CASE_PPC64 (MONO_TYPE_I8)
 733         CASE_PPC64 (MONO_TYPE_U8)
 734         case MONO_TYPE_I:
 735         case MONO_TYPE_U:
 736         case MONO_TYPE_PTR:
 737         case MONO_TYPE_FNPTR:
 738                 return TRUE;
 739         case MONO_TYPE_OBJECT:
 740         case MONO_TYPE_STRING:
 741         case MONO_TYPE_CLASS:
 742         case MONO_TYPE_SZARRAY:
 743         case MONO_TYPE_ARRAY:
 744                 return TRUE;
 745         case MONO_TYPE_GENERICINST:
 746                 if (!mono_type_generic_inst_is_valuetype (t))
 747                         return TRUE;
 748                 return FALSE;
 749         case MONO_TYPE_VALUETYPE:
 750                 return FALSE;
 751         }
 752         return FALSE;
 753 }
 754
 755 #ifndef DISABLE_JIT
 756 GList *
 757 mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
 758 {
 759         GList *vars = NULL;
 760         int i;
 761
 762         for (i = 0; i < cfg->num_varinfo; i++) {
 763                 MonoInst *ins = cfg->varinfo [i];
 764                 MonoMethodVar *vmv = MONO_VARINFO (cfg, i);
 765
 766                 /* unused vars */
 767                 if (vmv->range.first_use.abs_pos >= vmv->range.last_use.abs_pos)
 768                         continue;
 769
 770                 if (ins->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) || (ins->opcode != OP_LOCAL && ins->opcode != OP_ARG))
 771                         continue;
 772
 773                 /* we can only allocate 32 bit values */
 774                 if (is_regsize_var (ins->inst_vtype)) {
 775                         g_assert (MONO_VARINFO (cfg, i)->reg == -1);
 776                         g_assert (i == vmv->idx);
 777                         vars = mono_varlist_insert_sorted (cfg, vars, vmv, FALSE);
 778                 }
 779         }
 780
 781         return vars;
 782 }
 783 #endif /* ifndef DISABLE_JIT */
 784
 785 GList *
 786 mono_arch_get_global_int_regs (MonoCompile *cfg)
 787 {
 788         GList *regs = NULL;
 789         int i, top = 32;
 790         if (cfg->frame_reg != ppc_sp)
 791                 top = 31;
 792         /* ppc_r13 is used by the system on PPC EABI */
 793         for (i = 14; i < top; ++i) {
 794                 /*
 795                  * Reserve r29 for holding the vtable address for virtual calls in AOT mode,
 796                  * since the trampolines can clobber r11.
 797                  */
 798                 if (!(cfg->compile_aot && i == 29))
 799                         regs = g_list_prepend (regs, GUINT_TO_POINTER (i));
 800         }
 801
 802         return regs;
 803 }
 804
 805 /*
 806  * mono_arch_regalloc_cost:
 807  *
 808  *  Return the cost, in number of memory references, of the action of
 809  * allocating the variable VMV into a register during global register
 810  * allocation.
 811  */
 812 guint32
 813 mono_arch_regalloc_cost (MonoCompile *cfg, MonoMethodVar *vmv)
 814 {
 815         /* FIXME: */
 816         return 2;
 817 }
 818
 819 void
 820 mono_arch_flush_icache (guint8 *code, gint size)
 821 {
 822 #ifdef MONO_CROSS_COMPILE
 823 #else
 824         register guint8 *p;
 825         guint8 *endp, *start;
 826
 827         p = start = code;
 828         endp = p + size;
 829         start = (guint8*)((gsize)start & ~(cachelinesize - 1));
 830         /* use dcbf for smp support, later optimize for UP, see pem._64bit.d20030611.pdf page 211 */
 831 #if defined(G_COMPILER_CODEWARRIOR)
 832         if (cpu_hw_caps & PPC_SMP_CAPABLE) {
 833                 for (p = start; p < endp; p += cachelineinc) {
 834                         asm { dcbf 0, p };
 835                 }
 836         } else {
 837                 for (p = start; p < endp; p += cachelineinc) {
 838                         asm { dcbst 0, p };
 839                 }
 840         }
 841         asm { sync };
 842         p = code;
 843         for (p = start; p < endp; p += cachelineinc) {
 844                 asm {
 845                         icbi 0, p
 846                         sync
 847                 }
 848         }
 849         asm {
 850                 sync
 851                 isync
 852         }
 853 #else
 854         /* For POWER5/6 with ICACHE_SNOOPing only one icbi in the range is required.
 855          * The sync is required to insure that the store queue is completely empty.
 856          * While the icbi performs no cache operations, icbi/isync is required to
 857          * kill local prefetch.
 858          */
 859         if (cpu_hw_caps & PPC_ICACHE_SNOOP) {
 860                 asm ("sync");
 861                 asm ("icbi 0,%0;" : : "r"(code) : "memory");
 862                 asm ("isync");
 863                 return;
 864         }
 865         /* use dcbf for smp support, see pem._64bit.d20030611.pdf page 211 */
 866         if (cpu_hw_caps & PPC_SMP_CAPABLE) {
 867                 for (p = start; p < endp; p += cachelineinc) {
 868                         asm ("dcbf 0,%0;" : : "r"(p) : "memory");
 869                 }
 870         } else {
 871                 for (p = start; p < endp; p += cachelineinc) {
 872                         asm ("dcbst 0,%0;" : : "r"(p) : "memory");
 873                 }
 874         }
 875         asm ("sync");
 876         p = code;
 877         for (p = start; p < endp; p += cachelineinc) {
 878                 /* for ISA2.0+ implementations we should not need any extra sync between the
 879                  * icbi instructions.  Both the 2.0 PEM and the PowerISA-2.05 say this.
 880                  * So I am not sure which chip had this problem but its not an issue on
 881                  * of the ISA V2 chips.
 882                  */
 883                 if (cpu_hw_caps & PPC_ISA_2X)
 884                         asm ("icbi 0,%0;" : : "r"(p) : "memory");
 885                 else
 886                         asm ("icbi 0,%0; sync;" : : "r"(p) : "memory");
 887         }
 888         if (!(cpu_hw_caps & PPC_ISA_2X))
 889                 asm ("sync");
 890         asm ("isync");
 891 #endif
 892 #endif
 893 }
 894
 895 void
 896 mono_arch_flush_register_windows (void)
 897 {
 898 }
 899
 900 #ifdef __APPLE__
 901 #define ALWAYS_ON_STACK(s) s
 902 #define FP_ALSO_IN_REG(s) s
 903 #else
 904 #ifdef __mono_ppc64__
 905 #define ALWAYS_ON_STACK(s) s
 906 #define FP_ALSO_IN_REG(s) s
 907 #else
 908 #define ALWAYS_ON_STACK(s)
 909 #define FP_ALSO_IN_REG(s)
 910 #endif
 911 #define ALIGN_DOUBLES
 912 #endif
 913
 914 enum {
 915         RegTypeGeneral,
 916         RegTypeBase,
 917         RegTypeFP,
 918         RegTypeStructByVal,
 919         RegTypeStructByAddr
 920 };
 921
 922 typedef struct {
 923         gint32  offset;
 924         guint32 vtsize; /* in param area */
 925         guint8  reg;
 926         guint8  vtregs; /* number of registers used to pass a RegTypeStructByVal */
 927         guint8  regtype : 4; /* 0 general, 1 basereg, 2 floating point register, see RegType* */
 928         guint8  size    : 4; /* 1, 2, 4, 8, or regs used by RegTypeStructByVal */
 929         guint8  bytes   : 4; /* size in bytes - only valid for
 930                                 RegTypeStructByVal if the struct fits
 931                                 in one word, otherwise it's 0*/
 932 } ArgInfo;
 933
 934 typedef struct {
 935         int nargs;
 936         guint32 stack_usage;
 937         guint32 struct_ret;
 938         ArgInfo ret;
 939         ArgInfo sig_cookie;
 940         ArgInfo args [1];
 941 } CallInfo;
 942
 943 #define DEBUG(a)
 944
 945 static void inline
 946 add_general (guint *gr, guint *stack_size, ArgInfo *ainfo, gboolean simple)
 947 {
 948 #ifdef __mono_ppc64__
 949         g_assert (simple);
 950 #endif
 951
 952         if (simple) {
 953                 if (*gr >= 3 + PPC_NUM_REG_ARGS) {
 954                         ainfo->offset = PPC_STACK_PARAM_OFFSET + *stack_size;
 955                         ainfo->reg = ppc_sp; /* in the caller */
 956                         ainfo->regtype = RegTypeBase;
 957                         *stack_size += sizeof (gpointer);
 958                 } else {
 959                         ALWAYS_ON_STACK (*stack_size += sizeof (gpointer));
 960                         ainfo->reg = *gr;
 961                 }
 962         } else {
 963                 if (*gr >= 3 + PPC_NUM_REG_ARGS - 1) {
 964 #ifdef ALIGN_DOUBLES
 965                         //*stack_size += (*stack_size % 8);
 966 #endif
 967                         ainfo->offset = PPC_STACK_PARAM_OFFSET + *stack_size;
 968                         ainfo->reg = ppc_sp; /* in the caller */
 969                         ainfo->regtype = RegTypeBase;
 970                         *stack_size += 8;
 971                 } else {
 972 #ifdef ALIGN_DOUBLES
 973                 if (!((*gr) & 1))
 974                         (*gr) ++;
 975 #endif
 976                         ALWAYS_ON_STACK (*stack_size += 8);
 977                         ainfo->reg = *gr;
 978                 }
 979                 (*gr) ++;
 980         }
 981         (*gr) ++;
 982 }
 983
 984 #if defined(__APPLE__) || defined(__mono_ppc64__)
 985 static gboolean
 986 has_only_a_r48_field (MonoClass *klass)
 987 {
 988         gpointer iter;
 989         MonoClassField *f;
 990         gboolean have_field = FALSE;
 991         iter = NULL;
 992         while ((f = mono_class_get_fields (klass, &iter))) {
 993                 if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
 994                         if (have_field)
 995                                 return FALSE;
 996                         if (!f->type->byref && (f->type->type == MONO_TYPE_R4 || f->type->type == MONO_TYPE_R8))
 997                                 have_field = TRUE;
 998                         else
 999                                 return FALSE;
1000                 }
1001         }
1002         return have_field;
1003 }
1004 #endif
1005
1006 static CallInfo*
1007 calculate_sizes (MonoMethodSignature *sig, gboolean is_pinvoke)
1008 {
1009         guint i, fr, gr;
1010         int n = sig->hasthis + sig->param_count;
1011         MonoType *simpletype;
1012         guint32 stack_size = 0;
1013         CallInfo *cinfo = g_malloc0 (sizeof (CallInfo) + sizeof (ArgInfo) * n);
1014
1015         fr = PPC_FIRST_FPARG_REG;
1016         gr = PPC_FIRST_ARG_REG;
1017
1018         /* FIXME: handle returning a struct */
1019         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
1020                 add_general (&gr, &stack_size, &cinfo->ret, TRUE);
1021                 cinfo->struct_ret = PPC_FIRST_ARG_REG;
1022         }
1023
1024         n = 0;
1025         if (sig->hasthis) {
1026                 add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1027                 n++;
1028         }
1029         DEBUG(printf("params: %d\n", sig->param_count));
1030         for (i = 0; i < sig->param_count; ++i) {
1031                 if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
1032                         /* Prevent implicit arguments and sig_cookie from
1033                            being passed in registers */
1034                         gr = PPC_LAST_ARG_REG + 1;
1035                         /* FIXME: don't we have to set fr, too? */
1036                         /* Emit the signature cookie just before the implicit arguments */
1037                         add_general (&gr, &stack_size, &cinfo->sig_cookie, TRUE);
1038                 }
1039                 DEBUG(printf("param %d: ", i));
1040                 if (sig->params [i]->byref) {
1041                         DEBUG(printf("byref\n"));
1042                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1043                         n++;
1044                         continue;
1045                 }
1046                 simpletype = mini_type_get_underlying_type (NULL, sig->params [i]);
1047                 switch (simpletype->type) {
1048                 case MONO_TYPE_BOOLEAN:
1049                 case MONO_TYPE_I1:
1050                 case MONO_TYPE_U1:
1051                         cinfo->args [n].size = 1;
1052                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1053                         n++;
1054                         break;
1055                 case MONO_TYPE_CHAR:
1056                 case MONO_TYPE_I2:
1057                 case MONO_TYPE_U2:
1058                         cinfo->args [n].size = 2;
1059                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1060                         n++;
1061                         break;
1062                 case MONO_TYPE_I4:
1063                 case MONO_TYPE_U4:
1064                         cinfo->args [n].size = 4;
1065                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1066                         n++;
1067                         break;
1068                 case MONO_TYPE_I:
1069                 case MONO_TYPE_U:
1070                 case MONO_TYPE_PTR:
1071                 case MONO_TYPE_FNPTR:
1072                 case MONO_TYPE_CLASS:
1073                 case MONO_TYPE_OBJECT:
1074                 case MONO_TYPE_STRING:
1075                 case MONO_TYPE_SZARRAY:
1076                 case MONO_TYPE_ARRAY:
1077                         cinfo->args [n].size = sizeof (gpointer);
1078                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1079                         n++;
1080                         break;
1081                 case MONO_TYPE_GENERICINST:
1082                         if (!mono_type_generic_inst_is_valuetype (simpletype)) {
1083                                 cinfo->args [n].size = sizeof (gpointer);
1084                                 add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1085                                 n++;
1086                                 break;
1087                         }
1088                         /* Fall through */
1089                 case MONO_TYPE_VALUETYPE:
1090                 case MONO_TYPE_TYPEDBYREF: {
1091                         gint size;
1092                         MonoClass *klass;
1093
1094                         klass = mono_class_from_mono_type (sig->params [i]);
1095                         if (simpletype->type == MONO_TYPE_TYPEDBYREF)
1096                                 size = sizeof (MonoTypedRef);
1097                         else if (is_pinvoke)
1098                             size = mono_class_native_size (klass, NULL);
1099                         else
1100                             size = mono_class_value_size (klass, NULL);
1101
1102 #if defined(__APPLE__) || defined(__mono_ppc64__)
1103                         if ((size == 4 || size == 8) && has_only_a_r48_field (klass)) {
1104                                 cinfo->args [n].size = size;
1105
1106                                 /* It was 7, now it is 8 in LinuxPPC */
1107                                 if (fr <= PPC_LAST_FPARG_REG) {
1108                                         cinfo->args [n].regtype = RegTypeFP;
1109                                         cinfo->args [n].reg = fr;
1110                                         fr ++;
1111                                         FP_ALSO_IN_REG (gr ++);
1112                                         if (size == 8)
1113                                                 FP_ALSO_IN_REG (gr ++);
1114                                         ALWAYS_ON_STACK (stack_size += size);
1115                                 } else {
1116                                         cinfo->args [n].offset = PPC_STACK_PARAM_OFFSET + stack_size;
1117                                         cinfo->args [n].regtype = RegTypeBase;
1118                                         cinfo->args [n].reg = ppc_sp; /* in the caller*/
1119                                         stack_size += 8;
1120                                 }
1121                                 n++;
1122                                 break;
1123                         }
1124 #endif
1125                         DEBUG(printf ("load %d bytes struct\n",
1126                                       mono_class_native_size (sig->params [i]->data.klass, NULL)));
1127
1128 #if PPC_PASS_STRUCTS_BY_VALUE
1129                         {
1130                                 int align_size = size;
1131                                 int nregs = 0;
1132                                 int rest = PPC_LAST_ARG_REG - gr + 1;
1133                                 int n_in_regs;
1134
1135                                 align_size += (sizeof (gpointer) - 1);
1136                                 align_size &= ~(sizeof (gpointer) - 1);
1137                                 nregs = (align_size + sizeof (gpointer) -1 ) / sizeof (gpointer);
1138                                 n_in_regs = MIN (rest, nregs);
1139                                 if (n_in_regs < 0)
1140                                         n_in_regs = 0;
1141 #ifdef __APPLE__
1142                                 /* FIXME: check this */
1143                                 if (size >= 3 && size % 4 != 0)
1144                                         n_in_regs = 0;
1145 #endif
1146                                 cinfo->args [n].regtype = RegTypeStructByVal;
1147                                 cinfo->args [n].vtregs = n_in_regs;
1148                                 cinfo->args [n].size = n_in_regs;
1149                                 cinfo->args [n].vtsize = nregs - n_in_regs;
1150                                 cinfo->args [n].reg = gr;
1151
1152 #ifdef __mono_ppc64__
1153                                 if (nregs == 1 && is_pinvoke)
1154                                         cinfo->args [n].bytes = size;
1155                                 else
1156 #endif
1157                                         cinfo->args [n].bytes = 0;
1158                                 gr += n_in_regs;
1159                                 cinfo->args [n].offset = PPC_STACK_PARAM_OFFSET + stack_size;
1160                                 /*g_print ("offset for arg %d at %d\n", n, PPC_STACK_PARAM_OFFSET + stack_size);*/
1161                                 stack_size += nregs * sizeof (gpointer);
1162                         }
1163 #else
1164                         add_general (&gr, &stack_size, cinfo->args + n, TRUE);
1165                         cinfo->args [n].regtype = RegTypeStructByAddr;
1166                         cinfo->args [n].vtsize = size;
1167 #endif
1168                         n++;
1169                         break;
1170                 }
1171                 case MONO_TYPE_U8:
1172                 case MONO_TYPE_I8:
1173                         cinfo->args [n].size = 8;
1174                         add_general (&gr, &stack_size, cinfo->args + n, SIZEOF_REGISTER == 8);
1175                         n++;
1176                         break;
1177                 case MONO_TYPE_R4:
1178                         cinfo->args [n].size = 4;
1179
1180                         /* It was 7, now it is 8 in LinuxPPC */
1181                         if (fr <= PPC_LAST_FPARG_REG) {
1182                                 cinfo->args [n].regtype = RegTypeFP;
1183                                 cinfo->args [n].reg = fr;
1184                                 fr ++;
1185                                 FP_ALSO_IN_REG (gr ++);
1186                                 ALWAYS_ON_STACK (stack_size += SIZEOF_REGISTER);
1187                         } else {
1188                                 cinfo->args [n].offset = PPC_STACK_PARAM_OFFSET + stack_size + MONO_PPC_32_64_CASE (0, 4);
1189                                 cinfo->args [n].regtype = RegTypeBase;
1190                                 cinfo->args [n].reg = ppc_sp; /* in the caller*/
1191                                 stack_size += SIZEOF_REGISTER;
1192                         }
1193                         n++;
1194                         break;
1195                 case MONO_TYPE_R8:
1196                         cinfo->args [n].size = 8;
1197                         /* It was 7, now it is 8 in LinuxPPC */
1198                         if (fr <= PPC_LAST_FPARG_REG) {
1199                                 cinfo->args [n].regtype = RegTypeFP;
1200                                 cinfo->args [n].reg = fr;
1201                                 fr ++;
1202                                 FP_ALSO_IN_REG (gr += sizeof (double) / SIZEOF_REGISTER);
1203                                 ALWAYS_ON_STACK (stack_size += 8);
1204                         } else {
1205                                 cinfo->args [n].offset = PPC_STACK_PARAM_OFFSET + stack_size;
1206                                 cinfo->args [n].regtype = RegTypeBase;
1207                                 cinfo->args [n].reg = ppc_sp; /* in the caller*/
1208                                 stack_size += 8;
1209                         }
1210                         n++;
1211                         break;
1212                 default:
1213                         g_error ("Can't trampoline 0x%x", sig->params [i]->type);
1214                 }
1215         }
1216
1217         if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos)) {
1218                 /* Prevent implicit arguments and sig_cookie from
1219                    being passed in registers */
1220                 gr = PPC_LAST_ARG_REG + 1;
1221                 /* Emit the signature cookie just before the implicit arguments */
1222                 add_general (&gr, &stack_size, &cinfo->sig_cookie, TRUE);
1223         }
1224
1225         {
1226                 simpletype = mini_type_get_underlying_type (NULL, sig->ret);
1227                 switch (simpletype->type) {
1228                 case MONO_TYPE_BOOLEAN:
1229                 case MONO_TYPE_I1:
1230                 case MONO_TYPE_U1:
1231                 case MONO_TYPE_I2:
1232                 case MONO_TYPE_U2:
1233                 case MONO_TYPE_CHAR:
1234                 case MONO_TYPE_I4:
1235                 case MONO_TYPE_U4:
1236                 case MONO_TYPE_I:
1237                 case MONO_TYPE_U:
1238                 case MONO_TYPE_PTR:
1239                 case MONO_TYPE_FNPTR:
1240                 case MONO_TYPE_CLASS:
1241                 case MONO_TYPE_OBJECT:
1242                 case MONO_TYPE_SZARRAY:
1243                 case MONO_TYPE_ARRAY:
1244                 case MONO_TYPE_STRING:
1245                         cinfo->ret.reg = ppc_r3;
1246                         break;
1247                 case MONO_TYPE_U8:
1248                 case MONO_TYPE_I8:
1249                         cinfo->ret.reg = ppc_r3;
1250                         break;
1251                 case MONO_TYPE_R4:
1252                 case MONO_TYPE_R8:
1253                         cinfo->ret.reg = ppc_f1;
1254                         cinfo->ret.regtype = RegTypeFP;
1255                         break;
1256                 case MONO_TYPE_GENERICINST:
1257                         if (!mono_type_generic_inst_is_valuetype (simpletype)) {
1258                                 cinfo->ret.reg = ppc_r3;
1259                                 break;
1260                         }
1261                         break;
1262                 case MONO_TYPE_VALUETYPE:
1263                         break;
1264                 case MONO_TYPE_TYPEDBYREF:
1265                 case MONO_TYPE_VOID:
1266                         break;
1267                 default:
1268                         g_error ("Can't handle as return value 0x%x", sig->ret->type);
1269                 }
1270         }
1271
1272         /* align stack size to 16 */
1273         DEBUG (printf ("      stack size: %d (%d)\n", (stack_size + 15) & ~15, stack_size));
1274         stack_size = (stack_size + 15) & ~15;
1275
1276         cinfo->stack_usage = stack_size;
1277         return cinfo;
1278 }
1279
1280 static void
1281 allocate_tailcall_valuetype_addrs (MonoCompile *cfg)
1282 {
1283 #if !PPC_PASS_STRUCTS_BY_VALUE
1284         MonoMethodSignature *sig = mono_method_signature (cfg->method);
1285         int num_structs = 0;
1286         int i;
1287
1288         if (!(cfg->flags & MONO_CFG_HAS_TAIL))
1289                 return;
1290
1291         for (i = 0; i < sig->param_count; ++i) {
1292                 MonoType *type = mono_type_get_underlying_type (sig->params [i]);
1293                 if (type->type == MONO_TYPE_VALUETYPE)
1294                         num_structs++;
1295         }
1296
1297         if (num_structs) {
1298                 cfg->tailcall_valuetype_addrs =
1299                         mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst*) * num_structs);
1300                 for (i = 0; i < num_structs; ++i) {
1301                         cfg->tailcall_valuetype_addrs [i] =
1302                                 mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_LOCAL);
1303                         cfg->tailcall_valuetype_addrs [i]->flags |= MONO_INST_INDIRECT;
1304                 }
1305         }
1306 #endif
1307 }
1308
1309 /*
1310  * Set var information according to the calling convention. ppc version.
1311  * The locals var stuff should most likely be split in another method.
1312  */
1313 void
1314 mono_arch_allocate_vars (MonoCompile *m)
1315 {
1316         MonoMethodSignature *sig;
1317         MonoMethodHeader *header;
1318         MonoInst *inst;
1319         int i, offset, size, align, curinst;
1320         int frame_reg = ppc_sp;
1321         gint32 *offsets;
1322         guint32 locals_stack_size, locals_stack_align;
1323
1324         allocate_tailcall_valuetype_addrs (m);
1325
1326         m->flags |= MONO_CFG_HAS_SPILLUP;
1327
1328         /* allow room for the vararg method args: void* and long/double */
1329         if (mono_jit_trace_calls != NULL && mono_trace_eval (m->method))
1330                 m->param_area = MAX (m->param_area, sizeof (gpointer)*8);
1331         /* this is bug #60332: remove when #59509 is fixed, so no weird vararg
1332          * call convs needs to be handled this way.
1333          */
1334         if (m->flags & MONO_CFG_HAS_VARARGS)
1335                 m->param_area = MAX (m->param_area, sizeof (gpointer)*8);
1336         /* gtk-sharp and other broken code will dllimport vararg functions even with
1337          * non-varargs signatures. Since there is little hope people will get this right
1338          * we assume they won't.
1339          */
1340         if (m->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
1341                 m->param_area = MAX (m->param_area, sizeof (gpointer)*8);
1342
1343         header = m->header;
1344
1345         /*
1346          * We use the frame register also for any method that has
1347          * exception clauses. This way, when the handlers are called,
1348          * the code will reference local variables using the frame reg instead of
1349          * the stack pointer: if we had to restore the stack pointer, we'd
1350          * corrupt the method frames that are already on the stack (since
1351          * filters get called before stack unwinding happens) when the filter
1352          * code would call any method (this also applies to finally etc.).
1353          */
1354         if ((m->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
1355                 frame_reg = ppc_r31;
1356         m->frame_reg = frame_reg;
1357         if (frame_reg != ppc_sp) {
1358                 m->used_int_regs |= 1 << frame_reg;
1359         }
1360
1361         sig = mono_method_signature (m->method);
1362
1363         offset = 0;
1364         curinst = 0;
1365         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
1366                 m->ret->opcode = OP_REGVAR;
1367                 m->ret->inst_c0 = m->ret->dreg = ppc_r3;
1368         } else {
1369                 /* FIXME: handle long values? */
1370                 switch (mini_type_get_underlying_type (m->generic_sharing_context, sig->ret)->type) {
1371                 case MONO_TYPE_VOID:
1372                         break;
1373                 case MONO_TYPE_R4:
1374                 case MONO_TYPE_R8:
1375                         m->ret->opcode = OP_REGVAR;
1376                         m->ret->inst_c0 = m->ret->dreg = ppc_f1;
1377                         break;
1378                 default:
1379                         m->ret->opcode = OP_REGVAR;
1380                         m->ret->inst_c0 = m->ret->dreg = ppc_r3;
1381                         break;
1382                 }
1383         }
1384         /* local vars are at a positive offset from the stack pointer */
1385         /*
1386          * also note that if the function uses alloca, we use ppc_r31
1387          * to point at the local variables.
1388          */
1389         offset = PPC_MINIMAL_STACK_SIZE; /* linkage area */
1390         /* align the offset to 16 bytes: not sure this is needed here  */
1391         //offset += 16 - 1;
1392         //offset &= ~(16 - 1);
1393
1394         /* add parameter area size for called functions */
1395         offset += m->param_area;
1396         offset += 16 - 1;
1397         offset &= ~(16 - 1);
1398
1399         /* allow room to save the return value */
1400         if (mono_jit_trace_calls != NULL && mono_trace_eval (m->method))
1401                 offset += 8;
1402
1403         /* the MonoLMF structure is stored just below the stack pointer */
1404
1405 #if 0
1406         /* this stuff should not be needed on ppc and the new jit,
1407          * because a call on ppc to the handlers doesn't change the
1408          * stack pointer and the jist doesn't manipulate the stack pointer
1409          * for operations involving valuetypes.
1410          */
1411         /* reserve space to store the esp */
1412         offset += sizeof (gpointer);
1413
1414         /* this is a global constant */
1415         mono_exc_esp_offset = offset;
1416 #endif
1417
1418         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
1419                 offset += sizeof(gpointer) - 1;
1420                 offset &= ~(sizeof(gpointer) - 1);
1421
1422                 m->vret_addr->opcode = OP_REGOFFSET;
1423                 m->vret_addr->inst_basereg = frame_reg;
1424                 m->vret_addr->inst_offset = offset;
1425
1426                 if (G_UNLIKELY (m->verbose_level > 1)) {
1427                         printf ("vret_addr =");
1428                         mono_print_ins (m->vret_addr);
1429                 }
1430
1431                 offset += sizeof(gpointer);
1432         }
1433
1434         offsets = mono_allocate_stack_slots_full (m, FALSE, &locals_stack_size, &locals_stack_align);
1435         if (locals_stack_align) {
1436                 offset += (locals_stack_align - 1);
1437                 offset &= ~(locals_stack_align - 1);
1438         }
1439         for (i = m->locals_start; i < m->num_varinfo; i++) {
1440                 if (offsets [i] != -1) {
1441                         MonoInst *inst = m->varinfo [i];
1442                         inst->opcode = OP_REGOFFSET;
1443                         inst->inst_basereg = frame_reg;
1444                         inst->inst_offset = offset + offsets [i];
1445                         /*
1446                         g_print ("allocating local %d (%s) to %d\n",
1447                                 i, mono_type_get_name (inst->inst_vtype), inst->inst_offset);
1448                         */
1449                 }
1450         }
1451         offset += locals_stack_size;
1452
1453         curinst = 0;
1454         if (sig->hasthis) {
1455                 inst = m->args [curinst];
1456                 if (inst->opcode != OP_REGVAR) {
1457                         inst->opcode = OP_REGOFFSET;
1458                         inst->inst_basereg = frame_reg;
1459                         offset += sizeof (gpointer) - 1;
1460                         offset &= ~(sizeof (gpointer) - 1);
1461                         inst->inst_offset = offset;
1462                         offset += sizeof (gpointer);
1463                 }
1464                 curinst++;
1465         }
1466
1467         for (i = 0; i < sig->param_count; ++i) {
1468                 inst = m->args [curinst];
1469                 if (inst->opcode != OP_REGVAR) {
1470                         inst->opcode = OP_REGOFFSET;
1471                         inst->inst_basereg = frame_reg;
1472                         if (sig->pinvoke) {
1473                                 size = mono_type_native_stack_size (sig->params [i], (guint32*)&align);
1474                                 inst->backend.is_pinvoke = 1;
1475                         } else {
1476                                 size = mono_type_size (sig->params [i], &align);
1477                         }
1478                         if (MONO_TYPE_ISSTRUCT (sig->params [i]) && size < sizeof (gpointer))
1479                                 size = align = sizeof (gpointer);
1480                         offset += align - 1;
1481                         offset &= ~(align - 1);
1482                         inst->inst_offset = offset;
1483                         offset += size;
1484                 }
1485                 curinst++;
1486         }
1487
1488         /* some storage for fp conversions */
1489         offset += 8 - 1;
1490         offset &= ~(8 - 1);
1491         m->arch.fp_conv_var_offset = offset;
1492         offset += 8;
1493
1494         /* align the offset to 16 bytes */
1495         offset += 16 - 1;
1496         offset &= ~(16 - 1);
1497
1498         /* change sign? */
1499         m->stack_offset = offset;
1500
1501         if (sig->call_convention == MONO_CALL_VARARG) {
1502                 CallInfo *cinfo = calculate_sizes (m->method->signature, m->method->signature->pinvoke);
1503
1504                 m->sig_cookie = cinfo->sig_cookie.offset;
1505
1506                 g_free(cinfo);
1507         }
1508 }
1509
1510 void
1511 mono_arch_create_vars (MonoCompile *cfg)
1512 {
1513         MonoMethodSignature *sig = mono_method_signature (cfg->method);
1514
1515         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
1516                 cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
1517         }
1518 }
1519
1520 /* Fixme: we need an alignment solution for enter_method and mono_arch_call_opcode,
1521  * currently alignment in mono_arch_call_opcode is computed without arch_get_argument_info
1522  */
1523
1524 static void
1525 emit_sig_cookie (MonoCompile *cfg, MonoCallInst *call, CallInfo *cinfo)
1526 {
1527         int sig_reg = mono_alloc_ireg (cfg);
1528
1529         /* FIXME: Add support for signature tokens to AOT */
1530         cfg->disable_aot = TRUE;
1531
1532         MONO_EMIT_NEW_ICONST (cfg, sig_reg, (gulong)call->signature);
1533         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG,
1534                         ppc_r1, cinfo->sig_cookie.offset, sig_reg);
1535 }
1536
1537 void
1538 mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call)
1539 {
1540         MonoInst *in, *ins;
1541         MonoMethodSignature *sig;
1542         int i, n;
1543         CallInfo *cinfo;
1544
1545         sig = call->signature;
1546         n = sig->param_count + sig->hasthis;
1547
1548         cinfo = calculate_sizes (sig, sig->pinvoke);
1549
1550         for (i = 0; i < n; ++i) {
1551                 ArgInfo *ainfo = cinfo->args + i;
1552                 MonoType *t;
1553
1554                 if (i >= sig->hasthis)
1555                         t = sig->params [i - sig->hasthis];
1556                 else
1557                         t = &mono_defaults.int_class->byval_arg;
1558                 t = mini_type_get_underlying_type (cfg->generic_sharing_context, t);
1559
1560                 if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (i == sig->sentinelpos))
1561                         emit_sig_cookie (cfg, call, cinfo);
1562
1563                 in = call->args [i];
1564
1565                 if (ainfo->regtype == RegTypeGeneral) {
1566 #ifndef __mono_ppc64__
1567                         if (!t->byref && ((t->type == MONO_TYPE_I8) || (t->type == MONO_TYPE_U8))) {
1568                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
1569                                 ins->dreg = mono_alloc_ireg (cfg);
1570                                 ins->sreg1 = in->dreg + 1;
1571                                 MONO_ADD_INS (cfg->cbb, ins);
1572                                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, ainfo->reg + 1, FALSE);
1573
1574                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
1575                                 ins->dreg = mono_alloc_ireg (cfg);
1576                                 ins->sreg1 = in->dreg + 2;
1577                                 MONO_ADD_INS (cfg->cbb, ins);
1578                                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, ainfo->reg, FALSE);
1579                         } else
1580 #endif
1581                         {
1582                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
1583                                 ins->dreg = mono_alloc_ireg (cfg);
1584                                 ins->sreg1 = in->dreg;
1585                                 MONO_ADD_INS (cfg->cbb, ins);
1586
1587                                 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, ainfo->reg, FALSE);
1588                         }
1589                 } else if (ainfo->regtype == RegTypeStructByAddr) {
1590                         MONO_INST_NEW (cfg, ins, OP_OUTARG_VT);
1591                         ins->opcode = OP_OUTARG_VT;
1592                         ins->sreg1 = in->dreg;
1593                         ins->klass = in->klass;
1594                         ins->inst_p0 = call;
1595                         ins->inst_p1 = mono_mempool_alloc (cfg->mempool, sizeof (ArgInfo));
1596                         memcpy (ins->inst_p1, ainfo, sizeof (ArgInfo));
1597                         MONO_ADD_INS (cfg->cbb, ins);
1598                 } else if (ainfo->regtype == RegTypeStructByVal) {
1599                         /* this is further handled in mono_arch_emit_outarg_vt () */
1600                         MONO_INST_NEW (cfg, ins, OP_OUTARG_VT);
1601                         ins->opcode = OP_OUTARG_VT;
1602                         ins->sreg1 = in->dreg;
1603                         ins->klass = in->klass;
1604                         ins->inst_p0 = call;
1605                         ins->inst_p1 = mono_mempool_alloc (cfg->mempool, sizeof (ArgInfo));
1606                         memcpy (ins->inst_p1, ainfo, sizeof (ArgInfo));
1607                         MONO_ADD_INS (cfg->cbb, ins);
1608                 } else if (ainfo->regtype == RegTypeBase) {
1609                         if (!t->byref && ((t->type == MONO_TYPE_I8) || (t->type == MONO_TYPE_U8))) {
1610                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI8_MEMBASE_REG, ppc_r1, ainfo->offset, in->dreg);
1611                         } else if (!t->byref && ((t->type == MONO_TYPE_R4) || (t->type == MONO_TYPE_R8))) {
1612                                 if (t->type == MONO_TYPE_R8)
1613                                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORER8_MEMBASE_REG, ppc_r1, ainfo->offset, in->dreg);
1614                                 else
1615                                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORER4_MEMBASE_REG, ppc_r1, ainfo->offset, in->dreg);
1616                         } else {
1617                                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, ppc_r1, ainfo->offset, in->dreg);
1618                         }
1619                 } else if (ainfo->regtype == RegTypeFP) {
1620                         if (t->type == MONO_TYPE_VALUETYPE) {
1621                                 /* this is further handled in mono_arch_emit_outarg_vt () */
1622                                 MONO_INST_NEW (cfg, ins, OP_OUTARG_VT);
1623                                 ins->opcode = OP_OUTARG_VT;
1624                                 ins->sreg1 = in->dreg;
1625                                 ins->klass = in->klass;
1626                                 ins->inst_p0 = call;
1627                                 ins->inst_p1 = mono_mempool_alloc (cfg->mempool, sizeof (ArgInfo));
1628                                 memcpy (ins->inst_p1, ainfo, sizeof (ArgInfo));
1629                                 MONO_ADD_INS (cfg->cbb, ins);
1630
1631                                 cfg->flags |= MONO_CFG_HAS_FPOUT;
1632                         } else {
1633                                 int dreg = mono_alloc_freg (cfg);
1634
1635                                 if (ainfo->size == 4) {
1636                                         MONO_EMIT_NEW_UNALU (cfg, OP_FCONV_TO_R4, dreg, in->dreg);
1637                                 } else {
1638                                         MONO_INST_NEW (cfg, ins, OP_FMOVE);
1639                                         ins->dreg = dreg;
1640                                         ins->sreg1 = in->dreg;
1641                                         MONO_ADD_INS (cfg->cbb, ins);
1642                                 }
1643
1644                                 mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, TRUE);
1645                                 cfg->flags |= MONO_CFG_HAS_FPOUT;
1646                         }
1647                 } else {
1648                         g_assert_not_reached ();
1649                 }
1650         }
1651
1652         /* Emit the signature cookie in the case that there is no
1653            additional argument */
1654         if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (n == sig->sentinelpos))
1655                 emit_sig_cookie (cfg, call, cinfo);
1656
1657         if (cinfo->struct_ret) {
1658                 MonoInst *vtarg;
1659
1660                 MONO_INST_NEW (cfg, vtarg, OP_MOVE);
1661                 vtarg->sreg1 = call->vret_var->dreg;
1662                 vtarg->dreg = mono_alloc_preg (cfg);
1663                 MONO_ADD_INS (cfg->cbb, vtarg);
1664
1665                 mono_call_inst_add_outarg_reg (cfg, call, vtarg->dreg, cinfo->struct_ret, FALSE);
1666         }
1667
1668         call->stack_usage = cinfo->stack_usage;
1669         cfg->param_area = MAX (PPC_MINIMAL_PARAM_AREA_SIZE, MAX (cfg->param_area, cinfo->stack_usage));
1670         cfg->flags |= MONO_CFG_HAS_CALLS;
1671
1672         g_free (cinfo);
1673 }
1674
1675 void
1676 mono_arch_emit_outarg_vt (MonoCompile *cfg, MonoInst *ins, MonoInst *src)
1677 {
1678         MonoCallInst *call = (MonoCallInst*)ins->inst_p0;
1679         ArgInfo *ainfo = ins->inst_p1;
1680         int ovf_size = ainfo->vtsize;
1681         int doffset = ainfo->offset;
1682         int i, soffset, dreg;
1683
1684         if (ainfo->regtype == RegTypeStructByVal) {
1685 #ifdef __APPLE__
1686                 guint32 size = 0;
1687 #endif
1688                 soffset = 0;
1689 #ifdef __APPLE__
1690                 /*
1691                  * Darwin pinvokes needs some special handling for 1
1692                  * and 2 byte arguments
1693                  */
1694                 g_assert (ins->klass);
1695                 if (call->signature->pinvoke)
1696                         size =  mono_class_native_size (ins->klass, NULL);
1697                 if (size == 2 || size == 1) {
1698                         int tmpr = mono_alloc_ireg (cfg);
1699                         if (size == 1)
1700                                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI1_MEMBASE, tmpr, src->dreg, soffset);
1701                         else
1702                                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI2_MEMBASE, tmpr, src->dreg, soffset);
1703                         dreg = mono_alloc_ireg (cfg);
1704                         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, dreg, tmpr);
1705                         mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, FALSE);
1706                 } else
1707 #endif
1708                         for (i = 0; i < ainfo->vtregs; ++i) {
1709                                 int antipadding = 0;
1710                                 if (ainfo->bytes) {
1711                                         g_assert (i == 0);
1712                                         antipadding = sizeof (gpointer) - ainfo->bytes;
1713                                 }
1714                                 dreg = mono_alloc_ireg (cfg);
1715                                 MONO_EMIT_NEW_LOAD_MEMBASE (cfg, dreg, src->dreg, soffset);
1716                                 if (antipadding)
1717                                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_UN_IMM, dreg, dreg, antipadding * 8);
1718                                 mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg + i, FALSE);
1719                                 soffset += sizeof (gpointer);
1720                         }
1721                 if (ovf_size != 0)
1722                         mini_emit_memcpy (cfg, ppc_r1, doffset + soffset, src->dreg, soffset, ovf_size * sizeof (gpointer), 0);
1723         } else if (ainfo->regtype == RegTypeFP) {
1724                 int tmpr = mono_alloc_freg (cfg);
1725                 if (ainfo->size == 4)
1726                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR4_MEMBASE, tmpr, src->dreg, 0);
1727                 else
1728                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR8_MEMBASE, tmpr, src->dreg, 0);
1729                 dreg = mono_alloc_freg (cfg);
1730                 MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, dreg, tmpr);
1731                 mono_call_inst_add_outarg_reg (cfg, call, dreg, ainfo->reg, TRUE);
1732         } else {
1733                 MonoInst *vtcopy = mono_compile_create_var (cfg, &src->klass->byval_arg, OP_LOCAL);
1734                 MonoInst *load;
1735                 guint32 size;
1736
1737                 /* FIXME: alignment? */
1738                 if (call->signature->pinvoke) {
1739                         size = mono_type_native_stack_size (&src->klass->byval_arg, NULL);
1740                         vtcopy->backend.is_pinvoke = 1;
1741                 } else {
1742                         size = mini_type_stack_size (cfg->generic_sharing_context, &src->klass->byval_arg, NULL);
1743                 }
1744                 if (size > 0)
1745                         g_assert (ovf_size > 0);
1746
1747                 EMIT_NEW_VARLOADA (cfg, load, vtcopy, vtcopy->inst_vtype);
1748                 mini_emit_memcpy (cfg, load->dreg, 0, src->dreg, 0, size, 0);
1749
1750                 if (ainfo->offset)
1751                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, ppc_r1, ainfo->offset, load->dreg);
1752                 else
1753                         mono_call_inst_add_outarg_reg (cfg, call, load->dreg, ainfo->reg, FALSE);
1754         }
1755 }
1756
1757 void
1758 mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
1759 {
1760         MonoType *ret = mini_type_get_underlying_type (cfg->generic_sharing_context,
1761                         mono_method_signature (method)->ret);
1762
1763         if (!ret->byref) {
1764 #ifndef __mono_ppc64__
1765                 if (ret->type == MONO_TYPE_I8 || ret->type == MONO_TYPE_U8) {
1766                         MonoInst *ins;
1767
1768                         MONO_INST_NEW (cfg, ins, OP_SETLRET);
1769                         ins->sreg1 = val->dreg + 1;
1770                         ins->sreg2 = val->dreg + 2;
1771                         MONO_ADD_INS (cfg->cbb, ins);
1772                         return;
1773                 }
1774 #endif
1775                 if (ret->type == MONO_TYPE_R8 || ret->type == MONO_TYPE_R4) {
1776                         MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, cfg->ret->dreg, val->dreg);
1777                         return;
1778                 }
1779         }
1780         MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg, val->dreg);
1781 }
1782
1783 /* FIXME: this is just a useless hint: fix the interface to include the opcode */
1784 gboolean
1785 mono_arch_is_inst_imm (gint64 imm)
1786 {
1787        return TRUE;
1788 }
1789
1790 /*
1791  * Allow tracing to work with this interface (with an optional argument)
1792  */
1793
1794 void*
1795 mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
1796 {
1797         guchar *code = p;
1798
1799         ppc_load_ptr (code, ppc_r3, cfg->method);
1800         ppc_li (code, ppc_r4, 0); /* NULL ebp for now */
1801         ppc_load_func (code, ppc_r0, func);
1802         ppc_mtlr (code, ppc_r0);
1803         ppc_blrl (code);
1804         return code;
1805 }
1806
1807 enum {
1808         SAVE_NONE,
1809         SAVE_STRUCT,
1810         SAVE_ONE,
1811         SAVE_TWO,
1812         SAVE_FP
1813 };
1814
1815 void*
1816 mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers)
1817 {
1818         guchar *code = p;
1819         int save_mode = SAVE_NONE;
1820         int offset;
1821         MonoMethod *method = cfg->method;
1822         int rtype = mini_type_get_underlying_type (cfg->generic_sharing_context,
1823                         mono_method_signature (method)->ret)->type;
1824         int save_offset = PPC_STACK_PARAM_OFFSET + cfg->param_area;
1825         save_offset += 15;
1826         save_offset &= ~15;
1827
1828         offset = code - cfg->native_code;
1829         /* we need about 16 instructions */
1830         if (offset > (cfg->code_size - 16 * 4)) {
1831                 cfg->code_size *= 2;
1832                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
1833                 code = cfg->native_code + offset;
1834         }
1835
1836         switch (rtype) {
1837         case MONO_TYPE_VOID:
1838                 /* special case string .ctor icall */
1839                 if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class)
1840                         save_mode = SAVE_ONE;
1841                 else
1842                         save_mode = SAVE_NONE;
1843                 break;
1844 #ifndef __mono_ppc64__
1845         case MONO_TYPE_I8:
1846         case MONO_TYPE_U8:
1847                 save_mode = SAVE_TWO;
1848                 break;
1849 #endif
1850         case MONO_TYPE_R4:
1851         case MONO_TYPE_R8:
1852                 save_mode = SAVE_FP;
1853                 break;
1854         case MONO_TYPE_VALUETYPE:
1855                 save_mode = SAVE_STRUCT;
1856                 break;
1857         default:
1858                 save_mode = SAVE_ONE;
1859                 break;
1860         }
1861
1862         switch (save_mode) {
1863         case SAVE_TWO:
1864                 ppc_stw (code, ppc_r3, save_offset, cfg->frame_reg);
1865                 ppc_stw (code, ppc_r4, save_offset + 4, cfg->frame_reg);
1866                 if (enable_arguments) {
1867                         ppc_mr (code, ppc_r5, ppc_r4);
1868                         ppc_mr (code, ppc_r4, ppc_r3);
1869                 }
1870                 break;
1871         case SAVE_ONE:
1872                 ppc_stptr (code, ppc_r3, save_offset, cfg->frame_reg);
1873                 if (enable_arguments) {
1874                         ppc_mr (code, ppc_r4, ppc_r3);
1875                 }
1876                 break;
1877         case SAVE_FP:
1878                 ppc_stfd (code, ppc_f1, save_offset, cfg->frame_reg);
1879                 if (enable_arguments) {
1880                         /* FIXME: what reg?  */
1881                         ppc_fmr (code, ppc_f3, ppc_f1);
1882                         /* FIXME: use 8 byte load on PPC64 */
1883                         ppc_lwz (code, ppc_r4, save_offset, cfg->frame_reg);
1884                         ppc_lwz (code, ppc_r5, save_offset + 4, cfg->frame_reg);
1885                 }
1886                 break;
1887         case SAVE_STRUCT:
1888                 if (enable_arguments) {
1889                         /* FIXME: get the actual address  */
1890                         ppc_mr (code, ppc_r4, ppc_r3);
1891                 }
1892                 break;
1893         case SAVE_NONE:
1894         default:
1895                 break;
1896         }
1897
1898         ppc_load_ptr (code, ppc_r3, cfg->method);
1899         ppc_load_func (code, ppc_r0, func);
1900         ppc_mtlr (code, ppc_r0);
1901         ppc_blrl (code);
1902
1903         switch (save_mode) {
1904         case SAVE_TWO:
1905                 ppc_lwz (code, ppc_r3, save_offset, cfg->frame_reg);
1906                 ppc_lwz (code, ppc_r4, save_offset + 4, cfg->frame_reg);
1907                 break;
1908         case SAVE_ONE:
1909                 ppc_ldptr (code, ppc_r3, save_offset, cfg->frame_reg);
1910                 break;
1911         case SAVE_FP:
1912                 ppc_lfd (code, ppc_f1, save_offset, cfg->frame_reg);
1913                 break;
1914         case SAVE_NONE:
1915         default:
1916                 break;
1917         }
1918
1919         return code;
1920 }
1921 /*
1922  * Conditional branches have a small offset, so if it is likely overflowed,
1923  * we do a branch to the end of the method (uncond branches have much larger
1924  * offsets) where we perform the conditional and jump back unconditionally.
1925  * It's slightly slower, since we add two uncond branches, but it's very simple
1926  * with the current patch implementation and such large methods are likely not
1927  * going to be perf critical anyway.
1928  */
1929 typedef struct {
1930         union {
1931                 MonoBasicBlock *bb;
1932                 const char *exception;
1933         } data;
1934         guint32 ip_offset;
1935         guint16 b0_cond;
1936         guint16 b1_cond;
1937 } MonoOvfJump;
1938
1939 #define EMIT_COND_BRANCH_FLAGS(ins,b0,b1) \
1940 if (0 && ins->inst_true_bb->native_offset) { \
1941         ppc_bc (code, (b0), (b1), (code - cfg->native_code + ins->inst_true_bb->native_offset) & 0xffff); \
1942 } else { \
1943         int br_disp = ins->inst_true_bb->max_offset - offset;   \
1944         if (!ppc_is_imm16 (br_disp + 1024) || ! ppc_is_imm16 (ppc_is_imm16 (br_disp - 1024))) { \
1945                 MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));    \
1946                 ovfj->data.bb = ins->inst_true_bb;      \
1947                 ovfj->ip_offset = 0;    \
1948                 ovfj->b0_cond = (b0);   \
1949                 ovfj->b1_cond = (b1);   \
1950                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB_OVF, ovfj); \
1951                 ppc_b (code, 0);        \
1952         } else {        \
1953                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \
1954                 ppc_bc (code, (b0), (b1), 0);   \
1955         }       \
1956 }
1957
1958 #define EMIT_COND_BRANCH(ins,cond) EMIT_COND_BRANCH_FLAGS(ins, branch_b0_table [(cond)], branch_b1_table [(cond)])
1959
1960 /* emit an exception if condition is fail
1961  *
1962  * We assign the extra code used to throw the implicit exceptions
1963  * to cfg->bb_exit as far as the big branch handling is concerned
1964  */
1965 #define EMIT_COND_SYSTEM_EXCEPTION_FLAGS(b0,b1,exc_name)            \
1966         do {                                                        \
1967                 int br_disp = cfg->bb_exit->max_offset - offset;        \
1968                 if (!ppc_is_imm16 (br_disp + 1024) || ! ppc_is_imm16 (ppc_is_imm16 (br_disp - 1024))) { \
1969                         MonoOvfJump *ovfj = mono_mempool_alloc (cfg->mempool, sizeof (MonoOvfJump));    \
1970                         ovfj->data.exception = (exc_name);      \
1971                         ovfj->ip_offset = code - cfg->native_code;      \
1972                         ovfj->b0_cond = (b0);   \
1973                         ovfj->b1_cond = (b1);   \
1974                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC_OVF, ovfj); \
1975                         ppc_bl (code, 0);       \
1976                         cfg->bb_exit->max_offset += 24; \
1977                 } else {        \
1978                         mono_add_patch_info (cfg, code - cfg->native_code,   \
1979                                     MONO_PATCH_INFO_EXC, exc_name);  \
1980                         ppc_bcl (code, (b0), (b1), 0);  \
1981                 }       \
1982         } while (0);
1983
1984 #define EMIT_COND_SYSTEM_EXCEPTION(cond,exc_name) EMIT_COND_SYSTEM_EXCEPTION_FLAGS(branch_b0_table [(cond)], branch_b1_table [(cond)], (exc_name))
1985
1986 void
1987 mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb)
1988 {
1989 }
1990
1991 static int
1992 normalize_opcode (int opcode)
1993 {
1994         switch (opcode) {
1995 #ifndef __mono_ilp32__
1996         case MONO_PPC_32_64_CASE (OP_LOADI4_MEMBASE, OP_LOADI8_MEMBASE):
1997                 return OP_LOAD_MEMBASE;
1998         case MONO_PPC_32_64_CASE (OP_LOADI4_MEMINDEX, OP_LOADI8_MEMINDEX):
1999                 return OP_LOAD_MEMINDEX;
2000         case MONO_PPC_32_64_CASE (OP_STOREI4_MEMBASE_REG, OP_STOREI8_MEMBASE_REG):
2001                 return OP_STORE_MEMBASE_REG;
2002         case MONO_PPC_32_64_CASE (OP_STOREI4_MEMBASE_IMM, OP_STOREI8_MEMBASE_IMM):
2003                 return OP_STORE_MEMBASE_IMM;
2004         case MONO_PPC_32_64_CASE (OP_STOREI4_MEMINDEX, OP_STOREI8_MEMINDEX):
2005                 return OP_STORE_MEMINDEX;
2006 #endif
2007         case MONO_PPC_32_64_CASE (OP_ISHR_IMM, OP_LSHR_IMM):
2008                 return OP_SHR_IMM;
2009         case MONO_PPC_32_64_CASE (OP_ISHR_UN_IMM, OP_LSHR_UN_IMM):
2010                 return OP_SHR_UN_IMM;
2011         default:
2012                 return opcode;
2013         }
2014 }
2015
2016 void
2017 mono_arch_peephole_pass_2 (MonoCompile *cfg, MonoBasicBlock *bb)
2018 {
2019         MonoInst *ins, *n, *last_ins = NULL;
2020
2021         MONO_BB_FOR_EACH_INS_SAFE (bb, n, ins) {
2022                 switch (normalize_opcode (ins->opcode)) {
2023                 case OP_MUL_IMM:
2024                         /* remove unnecessary multiplication with 1 */
2025                         if (ins->inst_imm == 1) {
2026                                 if (ins->dreg != ins->sreg1) {
2027                                         ins->opcode = OP_MOVE;
2028                                 } else {
2029                                         MONO_DELETE_INS (bb, ins);
2030                                         continue;
2031                                 }
2032                         } else {
2033                                 int power2 = mono_is_power_of_two (ins->inst_imm);
2034                                 if (power2 > 0) {
2035                                         ins->opcode = OP_SHL_IMM;
2036                                         ins->inst_imm = power2;
2037                                 }
2038                         }
2039                         break;
2040                 case OP_LOAD_MEMBASE:
2041                         /*
2042                          * OP_STORE_MEMBASE_REG reg, offset(basereg)
2043                          * OP_LOAD_MEMBASE offset(basereg), reg
2044                          */
2045                         if (last_ins && normalize_opcode (last_ins->opcode) == OP_STORE_MEMBASE_REG &&
2046                             ins->inst_basereg == last_ins->inst_destbasereg &&
2047                             ins->inst_offset == last_ins->inst_offset) {
2048                                 if (ins->dreg == last_ins->sreg1) {
2049                                         MONO_DELETE_INS (bb, ins);
2050                                         continue;
2051                                 } else {
2052                                         //static int c = 0; printf ("MATCHX %s %d\n", cfg->method->name,c++);
2053                                         ins->opcode = OP_MOVE;
2054                                         ins->sreg1 = last_ins->sreg1;
2055                                 }
2056
2057                         /*
2058                          * Note: reg1 must be different from the basereg in the second load
2059                          * OP_LOAD_MEMBASE offset(basereg), reg1
2060                          * OP_LOAD_MEMBASE offset(basereg), reg2
2061                          * -->
2062                          * OP_LOAD_MEMBASE offset(basereg), reg1
2063                          * OP_MOVE reg1, reg2
2064                          */
2065                         } else if (last_ins && normalize_opcode (last_ins->opcode) == OP_LOAD_MEMBASE &&
2066                               ins->inst_basereg != last_ins->dreg &&
2067                               ins->inst_basereg == last_ins->inst_basereg &&
2068                               ins->inst_offset == last_ins->inst_offset) {
2069
2070                                 if (ins->dreg == last_ins->dreg) {
2071                                         MONO_DELETE_INS (bb, ins);
2072                                         continue;
2073                                 } else {
2074                                         ins->opcode = OP_MOVE;
2075                                         ins->sreg1 = last_ins->dreg;
2076                                 }
2077
2078                                 //g_assert_not_reached ();
2079
2080 #if 0
2081                         /*
2082                          * OP_STORE_MEMBASE_IMM imm, offset(basereg)
2083                          * OP_LOAD_MEMBASE offset(basereg), reg
2084                          * -->
2085                          * OP_STORE_MEMBASE_IMM imm, offset(basereg)
2086                          * OP_ICONST reg, imm
2087                          */
2088                         } else if (last_ins && normalize_opcode (last_ins->opcode) == OP_STORE_MEMBASE_IMM &&
2089                                    ins->inst_basereg == last_ins->inst_destbasereg &&
2090                                    ins->inst_offset == last_ins->inst_offset) {
2091                                 //static int c = 0; printf ("MATCHX %s %d\n", cfg->method->name,c++);
2092                                 ins->opcode = OP_ICONST;
2093                                 ins->inst_c0 = last_ins->inst_imm;
2094                                 g_assert_not_reached (); // check this rule
2095 #endif
2096                         }
2097                         break;
2098                 case OP_LOADU1_MEMBASE:
2099                 case OP_LOADI1_MEMBASE:
2100                         if (last_ins && (last_ins->opcode == OP_STOREI1_MEMBASE_REG) &&
2101                                         ins->inst_basereg == last_ins->inst_destbasereg &&
2102                                         ins->inst_offset == last_ins->inst_offset) {
2103                                 ins->opcode = (ins->opcode == OP_LOADI1_MEMBASE) ? OP_ICONV_TO_I1 : OP_ICONV_TO_U1;
2104                                 ins->sreg1 = last_ins->sreg1;
2105                         }
2106                         break;
2107                 case OP_LOADU2_MEMBASE:
2108                 case OP_LOADI2_MEMBASE:
2109                         if (last_ins && (last_ins->opcode == OP_STOREI2_MEMBASE_REG) &&
2110                                         ins->inst_basereg == last_ins->inst_destbasereg &&
2111                                         ins->inst_offset == last_ins->inst_offset) {
2112                                 ins->opcode = (ins->opcode == OP_LOADI2_MEMBASE) ? OP_ICONV_TO_I2 : OP_ICONV_TO_U2;
2113                                 ins->sreg1 = last_ins->sreg1;
2114                         }
2115                         break;
2116 #ifdef __mono_ppc64__
2117                 case OP_LOADU4_MEMBASE:
2118                 case OP_LOADI4_MEMBASE:
2119                         if (last_ins && (last_ins->opcode == OP_STOREI4_MEMBASE_REG) &&
2120                                         ins->inst_basereg == last_ins->inst_destbasereg &&
2121                                         ins->inst_offset == last_ins->inst_offset) {
2122                                 ins->opcode = (ins->opcode == OP_LOADI4_MEMBASE) ? OP_ICONV_TO_I4 : OP_ICONV_TO_U4;
2123                                 ins->sreg1 = last_ins->sreg1;
2124                         }
2125                         break;
2126 #endif
2127                 case OP_MOVE:
2128                         ins->opcode = OP_MOVE;
2129                         /*
2130                          * OP_MOVE reg, reg
2131                          */
2132                         if (ins->dreg == ins->sreg1) {
2133                                 MONO_DELETE_INS (bb, ins);
2134                                 continue;
2135                         }
2136                         /*
2137                          * OP_MOVE sreg, dreg
2138                          * OP_MOVE dreg, sreg
2139                          */
2140                         if (last_ins && last_ins->opcode == OP_MOVE &&
2141                             ins->sreg1 == last_ins->dreg &&
2142                             ins->dreg == last_ins->sreg1) {
2143                                 MONO_DELETE_INS (bb, ins);
2144                                 continue;
2145                         }
2146                         break;
2147                 }
2148                 last_ins = ins;
2149                 ins = ins->next;
2150         }
2151         bb->last_ins = last_ins;
2152 }
2153
2154 void
2155 mono_arch_decompose_opts (MonoCompile *cfg, MonoInst *ins)
2156 {
2157         switch (ins->opcode) {
2158         case OP_ICONV_TO_R_UN: {
2159 #if G_BYTE_ORDER == G_BIG_ENDIAN
2160                 static const guint64 adjust_val = 0x4330000000000000ULL;
2161 #else
2162                 static const guint64 adjust_val = 0x0000000000003043ULL;
2163 #endif
2164                 int msw_reg = mono_alloc_ireg (cfg);
2165                 int adj_reg = mono_alloc_freg (cfg);
2166                 int tmp_reg = mono_alloc_freg (cfg);
2167                 int basereg = ppc_sp;
2168                 int offset = -8;
2169                 MONO_EMIT_NEW_ICONST (cfg, msw_reg, 0x43300000);
2170                 if (!ppc_is_imm16 (offset + 4)) {
2171                         basereg = mono_alloc_ireg (cfg);
2172                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IADD_IMM, basereg, cfg->frame_reg, offset);
2173                 }
2174                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, basereg, offset, msw_reg);
2175                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, basereg, offset + 4, ins->sreg1);
2176                 MONO_EMIT_NEW_LOAD_R8 (cfg, adj_reg, &adjust_val);
2177                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR8_MEMBASE, tmp_reg, basereg, offset);
2178                 MONO_EMIT_NEW_BIALU (cfg, OP_FSUB, ins->dreg, tmp_reg, adj_reg);
2179                 ins->opcode = OP_NOP;
2180                 break;
2181         }
2182 #ifndef __mono_ppc64__
2183         case OP_ICONV_TO_R4:
2184         case OP_ICONV_TO_R8: {
2185                 /* If we have a PPC_FEATURE_64 machine we can avoid
2186                    this and use the fcfid instruction.  Otherwise
2187                    on an old 32-bit chip and we have to do this the
2188                    hard way.  */
2189                 if (!(cpu_hw_caps & PPC_ISA_64)) {
2190                         /* FIXME: change precision for CEE_CONV_R4 */
2191                         static const guint64 adjust_val = 0x4330000080000000ULL;
2192                         int msw_reg = mono_alloc_ireg (cfg);
2193                         int xored = mono_alloc_ireg (cfg);
2194                         int adj_reg = mono_alloc_freg (cfg);
2195                         int tmp_reg = mono_alloc_freg (cfg);
2196                         int basereg = ppc_sp;
2197                         int offset = -8;
2198                         if (!ppc_is_imm16 (offset + 4)) {
2199                                 basereg = mono_alloc_ireg (cfg);
2200                                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IADD_IMM, basereg, cfg->frame_reg, offset);
2201                         }
2202                         MONO_EMIT_NEW_ICONST (cfg, msw_reg, 0x43300000);
2203                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, basereg, offset, msw_reg);
2204                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_XOR_IMM, xored, ins->sreg1, 0x80000000);
2205                         MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI4_MEMBASE_REG, basereg, offset + 4, xored);
2206                         MONO_EMIT_NEW_LOAD_R8 (cfg, adj_reg, (gpointer)&adjust_val);
2207                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADR8_MEMBASE, tmp_reg, basereg, offset);
2208                         MONO_EMIT_NEW_BIALU (cfg, OP_FSUB, ins->dreg, tmp_reg, adj_reg);
2209                         if (ins->opcode == OP_ICONV_TO_R4)
2210                                 MONO_EMIT_NEW_UNALU (cfg, OP_FCONV_TO_R4, ins->dreg, ins->dreg);
2211                         ins->opcode = OP_NOP;
2212                 }
2213                 break;
2214         }
2215 #endif
2216         case OP_CKFINITE: {
2217                 int msw_reg = mono_alloc_ireg (cfg);
2218                 int basereg = ppc_sp;
2219                 int offset = -8;
2220                 if (!ppc_is_imm16 (offset + 4)) {
2221                         basereg = mono_alloc_ireg (cfg);
2222                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_IADD_IMM, basereg, cfg->frame_reg, offset);
2223                 }
2224                 MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORER8_MEMBASE_REG, basereg, offset, ins->sreg1);
2225                 MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, msw_reg, basereg, offset);
2226                 MONO_EMIT_NEW_UNALU (cfg, OP_CHECK_FINITE, -1, msw_reg);
2227                 MONO_EMIT_NEW_UNALU (cfg, OP_FMOVE, ins->dreg, ins->sreg1);
2228                 ins->opcode = OP_NOP;
2229                 break;
2230         }
2231 #ifdef __mono_ppc64__
2232         case OP_IADD_OVF:
2233         case OP_IADD_OVF_UN:
2234         case OP_ISUB_OVF: {
2235                 int shifted1_reg = mono_alloc_ireg (cfg);
2236                 int shifted2_reg = mono_alloc_ireg (cfg);
2237                 int result_shifted_reg = mono_alloc_ireg (cfg);
2238
2239                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, shifted1_reg, ins->sreg1, 32);
2240                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, shifted2_reg, ins->sreg2, 32);
2241                 MONO_EMIT_NEW_BIALU (cfg, ins->opcode, result_shifted_reg, shifted1_reg, shifted2_reg);
2242                 if (ins->opcode == OP_IADD_OVF_UN)
2243                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_UN_IMM, ins->dreg, result_shifted_reg, 32);
2244                 else
2245                         MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHR_IMM, ins->dreg, result_shifted_reg, 32);
2246                 ins->opcode = OP_NOP;
2247         }
2248 #endif
2249         }
2250 }
2251
2252 void
2253 mono_arch_decompose_long_opts (MonoCompile *cfg, MonoInst *ins)
2254 {
2255         switch (ins->opcode) {
2256         case OP_LADD_OVF:
2257                 /* ADC sets the condition code */
2258                 MONO_EMIT_NEW_BIALU (cfg, OP_ADDCC, ins->dreg + 1, ins->sreg1 + 1, ins->sreg2 + 1);
2259                 MONO_EMIT_NEW_BIALU (cfg, OP_ADD_OVF_CARRY, ins->dreg + 2, ins->sreg1 + 2, ins->sreg2 + 2);
2260                 NULLIFY_INS (ins);
2261                 break;
2262         case OP_LADD_OVF_UN:
2263                 /* ADC sets the condition code */
2264                 MONO_EMIT_NEW_BIALU (cfg, OP_ADDCC, ins->dreg + 1, ins->sreg1 + 1, ins->sreg2 + 1);
2265                 MONO_EMIT_NEW_BIALU (cfg, OP_ADD_OVF_UN_CARRY, ins->dreg + 2, ins->sreg1 + 2, ins->sreg2 + 2);
2266                 NULLIFY_INS (ins);
2267                 break;
2268         case OP_LSUB_OVF:
2269                 /* SBB sets the condition code */
2270                 MONO_EMIT_NEW_BIALU (cfg, OP_SUBCC, ins->dreg + 1, ins->sreg1 + 1, ins->sreg2 + 1);
2271                 MONO_EMIT_NEW_BIALU (cfg, OP_SUB_OVF_CARRY, ins->dreg + 2, ins->sreg1 + 2, ins->sreg2 + 2);
2272                 NULLIFY_INS (ins);
2273                 break;
2274         case OP_LSUB_OVF_UN:
2275                 /* SBB sets the condition code */
2276                 MONO_EMIT_NEW_BIALU (cfg, OP_SUBCC, ins->dreg + 1, ins->sreg1 + 1, ins->sreg2 + 1);
2277                 MONO_EMIT_NEW_BIALU (cfg, OP_SUB_OVF_UN_CARRY, ins->dreg + 2, ins->sreg1 + 2, ins->sreg2 + 2);
2278                 NULLIFY_INS (ins);
2279                 break;
2280         case OP_LNEG:
2281                 /* This is the old version from inssel-long32.brg */
2282                 MONO_EMIT_NEW_UNALU (cfg, OP_INOT, ins->dreg + 1, ins->sreg1 + 1);
2283                 MONO_EMIT_NEW_UNALU (cfg, OP_INOT, ins->dreg + 2, ins->sreg1 + 2);
2284                 /* ADC sets the condition codes */
2285                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADC_IMM, ins->dreg + 1, ins->dreg + 1, 1);
2286                 MONO_EMIT_NEW_BIALU_IMM (cfg, OP_ADC_IMM, ins->dreg + 2, ins->dreg + 2, 0);
2287                 NULLIFY_INS (ins);
2288                 break;
2289         default:
2290                 break;
2291         }
2292 }
2293
2294 /*
2295  * the branch_b0_table should maintain the order of these
2296  * opcodes.
2297 case CEE_BEQ:
2298 case CEE_BGE:
2299 case CEE_BGT:
2300 case CEE_BLE:
2301 case CEE_BLT:
2302 case CEE_BNE_UN:
2303 case CEE_BGE_UN:
2304 case CEE_BGT_UN:
2305 case CEE_BLE_UN:
2306 case CEE_BLT_UN:
2307  */
2308 static const guchar
2309 branch_b0_table [] = {
2310         PPC_BR_TRUE,
2311         PPC_BR_FALSE,
2312         PPC_BR_TRUE,
2313         PPC_BR_FALSE,
2314         PPC_BR_TRUE,
2315
2316         PPC_BR_FALSE,
2317         PPC_BR_FALSE,
2318         PPC_BR_TRUE,
2319         PPC_BR_FALSE,
2320         PPC_BR_TRUE
2321 };
2322
2323 static const guchar
2324 branch_b1_table [] = {
2325         PPC_BR_EQ,
2326         PPC_BR_LT,
2327         PPC_BR_GT,
2328         PPC_BR_GT,
2329         PPC_BR_LT,
2330
2331         PPC_BR_EQ,
2332         PPC_BR_LT,
2333         PPC_BR_GT,
2334         PPC_BR_GT,
2335         PPC_BR_LT
2336 };
2337
2338 #define NEW_INS(cfg,dest,op) do {                                       \
2339                 MONO_INST_NEW((cfg), (dest), (op));                     \
2340                 mono_bblock_insert_after_ins (bb, last_ins, (dest));    \
2341         } while (0)
2342
2343 static int
2344 map_to_reg_reg_op (int op)
2345 {
2346         switch (op) {
2347         case OP_ADD_IMM:
2348                 return OP_IADD;
2349         case OP_SUB_IMM:
2350                 return OP_ISUB;
2351         case OP_AND_IMM:
2352                 return OP_IAND;
2353         case OP_COMPARE_IMM:
2354                 return OP_COMPARE;
2355         case OP_ICOMPARE_IMM:
2356                 return OP_ICOMPARE;
2357         case OP_LCOMPARE_IMM:
2358                 return OP_LCOMPARE;
2359         case OP_ADDCC_IMM:
2360                 return OP_IADDCC;
2361         case OP_ADC_IMM:
2362                 return OP_IADC;
2363         case OP_SUBCC_IMM:
2364                 return OP_ISUBCC;
2365         case OP_SBB_IMM:
2366                 return OP_ISBB;
2367         case OP_OR_IMM:
2368                 return OP_IOR;
2369         case OP_XOR_IMM:
2370                 return OP_IXOR;
2371         case OP_MUL_IMM:
2372                 return OP_IMUL;
2373         case OP_LOAD_MEMBASE:
2374                 return OP_LOAD_MEMINDEX;
2375         case OP_LOADI4_MEMBASE:
2376                 return OP_LOADI4_MEMINDEX;
2377         case OP_LOADU4_MEMBASE:
2378                 return OP_LOADU4_MEMINDEX;
2379         case OP_LOADI8_MEMBASE:
2380                 return OP_LOADI8_MEMINDEX;
2381         case OP_LOADU1_MEMBASE:
2382                 return OP_LOADU1_MEMINDEX;
2383         case OP_LOADI2_MEMBASE:
2384                 return OP_LOADI2_MEMINDEX;
2385         case OP_LOADU2_MEMBASE:
2386                 return OP_LOADU2_MEMINDEX;
2387         case OP_LOADI1_MEMBASE:
2388                 return OP_LOADI1_MEMINDEX;
2389         case OP_LOADR4_MEMBASE:
2390                 return OP_LOADR4_MEMINDEX;
2391         case OP_LOADR8_MEMBASE:
2392                 return OP_LOADR8_MEMINDEX;
2393         case OP_STOREI1_MEMBASE_REG:
2394                 return OP_STOREI1_MEMINDEX;
2395         case OP_STOREI2_MEMBASE_REG:
2396                 return OP_STOREI2_MEMINDEX;
2397         case OP_STOREI4_MEMBASE_REG:
2398                 return OP_STOREI4_MEMINDEX;
2399         case OP_STOREI8_MEMBASE_REG:
2400                 return OP_STOREI8_MEMINDEX;
2401         case OP_STORE_MEMBASE_REG:
2402                 return OP_STORE_MEMINDEX;
2403         case OP_STORER4_MEMBASE_REG:
2404                 return OP_STORER4_MEMINDEX;
2405         case OP_STORER8_MEMBASE_REG:
2406                 return OP_STORER8_MEMINDEX;
2407         case OP_STORE_MEMBASE_IMM:
2408                 return OP_STORE_MEMBASE_REG;
2409         case OP_STOREI1_MEMBASE_IMM:
2410                 return OP_STOREI1_MEMBASE_REG;
2411         case OP_STOREI2_MEMBASE_IMM:
2412                 return OP_STOREI2_MEMBASE_REG;
2413         case OP_STOREI4_MEMBASE_IMM:
2414                 return OP_STOREI4_MEMBASE_REG;
2415         case OP_STOREI8_MEMBASE_IMM:
2416                 return OP_STOREI8_MEMBASE_REG;
2417         }
2418         return mono_op_imm_to_op (op);
2419 }
2420
2421 //#define map_to_reg_reg_op(op) (cfg->new_ir? mono_op_imm_to_op (op): map_to_reg_reg_op (op))
2422
2423 #define compare_opcode_is_unsigned(opcode) \
2424                 (((opcode) >= CEE_BNE_UN && (opcode) <= CEE_BLT_UN) ||  \
2425                 ((opcode) >= OP_IBNE_UN && (opcode) <= OP_IBLT_UN) ||   \
2426                 ((opcode) >= OP_LBNE_UN && (opcode) <= OP_LBLT_UN) ||   \
2427                 ((opcode) >= OP_COND_EXC_NE_UN && (opcode) <= OP_COND_EXC_LT_UN) ||     \
2428                 ((opcode) >= OP_COND_EXC_INE_UN && (opcode) <= OP_COND_EXC_ILT_UN) ||   \
2429                 ((opcode) == OP_CLT_UN || (opcode) == OP_CGT_UN ||      \
2430                  (opcode) == OP_ICLT_UN || (opcode) == OP_ICGT_UN ||    \
2431                  (opcode) == OP_LCLT_UN || (opcode) == OP_LCGT_UN))
2432
2433 /*
2434  * Remove from the instruction list the instructions that can't be
2435  * represented with very simple instructions with no register
2436  * requirements.
2437  */
2438 void
2439 mono_arch_lowering_pass (MonoCompile *cfg, MonoBasicBlock *bb)
2440 {
2441         MonoInst *ins, *next, *temp, *last_ins = NULL;
2442         int imm;
2443
2444         MONO_BB_FOR_EACH_INS (bb, ins) {
2445 loop_start:
2446                 switch (ins->opcode) {
2447                 case OP_IDIV_UN_IMM:
2448                 case OP_IDIV_IMM:
2449                 case OP_IREM_IMM:
2450                 case OP_IREM_UN_IMM:
2451                         NEW_INS (cfg, temp, OP_ICONST);
2452                         temp->inst_c0 = ins->inst_imm;
2453                         temp->dreg = mono_alloc_ireg (cfg);
2454                         ins->sreg2 = temp->dreg;
2455                         if (ins->opcode == OP_IDIV_IMM)
2456                                 ins->opcode = OP_IDIV;
2457                         else if (ins->opcode == OP_IREM_IMM)
2458                                 ins->opcode = OP_IREM;
2459                         else if (ins->opcode == OP_IDIV_UN_IMM)
2460                                 ins->opcode = OP_IDIV_UN;
2461                         else if (ins->opcode == OP_IREM_UN_IMM)
2462                                 ins->opcode = OP_IREM_UN;
2463                         last_ins = temp;
2464                         /* handle rem separately */
2465                         goto loop_start;
2466                 case OP_IREM:
2467                 case OP_IREM_UN:
2468                 CASE_PPC64 (OP_LREM)
2469                 CASE_PPC64 (OP_LREM_UN) {
2470                         MonoInst *mul;
2471                         /* we change a rem dest, src1, src2 to
2472                          * div temp1, src1, src2
2473                          * mul temp2, temp1, src2
2474                          * sub dest, src1, temp2
2475                          */
2476                         if (ins->opcode == OP_IREM || ins->opcode == OP_IREM_UN) {
2477                                 NEW_INS (cfg, mul, OP_IMUL);
2478                                 NEW_INS (cfg, temp, ins->opcode == OP_IREM? OP_IDIV: OP_IDIV_UN);
2479                                 ins->opcode = OP_ISUB;
2480                         } else {
2481                                 NEW_INS (cfg, mul, OP_LMUL);
2482                                 NEW_INS (cfg, temp, ins->opcode == OP_LREM? OP_LDIV: OP_LDIV_UN);
2483                                 ins->opcode = OP_LSUB;
2484                         }
2485                         temp->sreg1 = ins->sreg1;
2486                         temp->sreg2 = ins->sreg2;
2487                         temp->dreg = mono_alloc_ireg (cfg);
2488                         mul->sreg1 = temp->dreg;
2489                         mul->sreg2 = ins->sreg2;
2490                         mul->dreg = mono_alloc_ireg (cfg);
2491                         ins->sreg2 = mul->dreg;
2492                         break;
2493                 }
2494                 case OP_IADD_IMM:
2495                 CASE_PPC64 (OP_LADD_IMM)
2496                 case OP_ADD_IMM:
2497                 case OP_ADDCC_IMM:
2498                         if (!ppc_is_imm16 (ins->inst_imm)) {
2499                                 NEW_INS (cfg,  temp, OP_ICONST);
2500                                 temp->inst_c0 = ins->inst_imm;
2501                                 temp->dreg = mono_alloc_ireg (cfg);
2502                                 ins->sreg2 = temp->dreg;
2503                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
2504                         }
2505                         break;
2506                 case OP_ISUB_IMM:
2507                 CASE_PPC64 (OP_LSUB_IMM)
2508                 case OP_SUB_IMM:
2509                         if (!ppc_is_imm16 (-ins->inst_imm)) {
2510                                 NEW_INS (cfg, temp, OP_ICONST);
2511                                 temp->inst_c0 = ins->inst_imm;
2512                                 temp->dreg = mono_alloc_ireg (cfg);
2513                                 ins->sreg2 = temp->dreg;
2514                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
2515                         }
2516                         break;
2517                 case OP_IAND_IMM:
2518                 case OP_IOR_IMM:
2519                 case OP_IXOR_IMM:
2520                 case OP_LAND_IMM:
2521                 case OP_LOR_IMM:
2522                 case OP_LXOR_IMM:
2523                 case OP_AND_IMM:
2524                 case OP_OR_IMM:
2525                 case OP_XOR_IMM: {
2526                         gboolean is_imm = ((ins->inst_imm & 0xffff0000) && (ins->inst_imm & 0xffff));
2527 #ifdef __mono_ppc64__
2528                         if (ins->inst_imm & 0xffffffff00000000ULL)
2529                                 is_imm = TRUE;
2530 #endif
2531                         if (is_imm) {
2532                                 NEW_INS (cfg, temp, OP_ICONST);
2533                                 temp->inst_c0 = ins->inst_imm;
2534                                 temp->dreg = mono_alloc_ireg (cfg);
2535                                 ins->sreg2 = temp->dreg;
2536                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
2537                         }
2538                         break;
2539                 }
2540                 case OP_ISBB_IMM:
2541                 case OP_IADC_IMM:
2542                 case OP_SBB_IMM:
2543                 case OP_SUBCC_IMM:
2544                 case OP_ADC_IMM:
2545                         NEW_INS (cfg, temp, OP_ICONST);
2546                         temp->inst_c0 = ins->inst_imm;
2547                         temp->dreg = mono_alloc_ireg (cfg);
2548                         ins->sreg2 = temp->dreg;
2549                         ins->opcode = map_to_reg_reg_op (ins->opcode);
2550                         break;
2551                 case OP_COMPARE_IMM:
2552                 case OP_ICOMPARE_IMM:
2553                 CASE_PPC64 (OP_LCOMPARE_IMM)
2554                         next = ins->next;
2555                         /* Branch opts can eliminate the branch */
2556                         if (!next || (!(MONO_IS_COND_BRANCH_OP (next) || MONO_IS_COND_EXC (next) || MONO_IS_SETCC (next)))) {
2557                                 ins->opcode = OP_NOP;
2558                                 break;
2559                         }
2560                         g_assert(next);
2561                         if (compare_opcode_is_unsigned (next->opcode)) {
2562                                 if (!ppc_is_uimm16 (ins->inst_imm)) {
2563                                         NEW_INS (cfg, temp, OP_ICONST);
2564                                         temp->inst_c0 = ins->inst_imm;
2565                                         temp->dreg = mono_alloc_ireg (cfg);
2566                                         ins->sreg2 = temp->dreg;
2567                                         ins->opcode = map_to_reg_reg_op (ins->opcode);
2568                                 }
2569                         } else {
2570                                 if (!ppc_is_imm16 (ins->inst_imm)) {
2571                                         NEW_INS (cfg, temp, OP_ICONST);
2572                                         temp->inst_c0 = ins->inst_imm;
2573                                         temp->dreg = mono_alloc_ireg (cfg);
2574                                         ins->sreg2 = temp->dreg;
2575                                         ins->opcode = map_to_reg_reg_op (ins->opcode);
2576                                 }
2577                         }
2578                         break;
2579                 case OP_IMUL_IMM:
2580                 case OP_MUL_IMM:
2581                         if (ins->inst_imm == 1) {
2582                                 ins->opcode = OP_MOVE;
2583                                 break;
2584                         }
2585                         if (ins->inst_imm == 0) {
2586                                 ins->opcode = OP_ICONST;
2587                                 ins->inst_c0 = 0;
2588                                 break;
2589                         }
2590                         imm = mono_is_power_of_two (ins->inst_imm);
2591                         if (imm > 0) {
2592                                 ins->opcode = OP_SHL_IMM;
2593                                 ins->inst_imm = imm;
2594                                 break;
2595                         }
2596                         if (!ppc_is_imm16 (ins->inst_imm)) {
2597                                 NEW_INS (cfg, temp, OP_ICONST);
2598                                 temp->inst_c0 = ins->inst_imm;
2599                                 temp->dreg = mono_alloc_ireg (cfg);
2600                                 ins->sreg2 = temp->dreg;
2601                                 ins->opcode = map_to_reg_reg_op (ins->opcode);
2602                         }
2603                         break;
2604                 case OP_LOCALLOC_IMM:
2605                         NEW_INS (cfg, temp, OP_ICONST);
2606                         temp->inst_c0 = ins->inst_imm;
2607                         temp->dreg = mono_alloc_ireg (cfg);
2608                         ins->sreg1 = temp->dreg;
2609                         ins->opcode = OP_LOCALLOC;
2610                         break;
2611                 case OP_LOAD_MEMBASE:
2612                 case OP_LOADI4_MEMBASE:
2613                 CASE_PPC64 (OP_LOADI8_MEMBASE)
2614                 case OP_LOADU4_MEMBASE:
2615                 case OP_LOADI2_MEMBASE:
2616                 case OP_LOADU2_MEMBASE:
2617                 case OP_LOADI1_MEMBASE:
2618                 case OP_LOADU1_MEMBASE:
2619                 case OP_LOADR4_MEMBASE:
2620                 case OP_LOADR8_MEMBASE:
2621                 case OP_STORE_MEMBASE_REG:
2622                 CASE_PPC64 (OP_STOREI8_MEMBASE_REG)
2623                 case OP_STOREI4_MEMBASE_REG:
2624                 case OP_STOREI2_MEMBASE_REG:
2625                 case OP_STOREI1_MEMBASE_REG:
2626                 case OP_STORER4_MEMBASE_REG:
2627                 case OP_STORER8_MEMBASE_REG:
2628                         /* we can do two things: load the immed in a register
2629                          * and use an indexed load, or see if the immed can be
2630                          * represented as an ad_imm + a load with a smaller offset
2631                          * that fits. We just do the first for now, optimize later.
2632                          */
2633                         if (ppc_is_imm16 (ins->inst_offset))
2634                                 break;
2635                         NEW_INS (cfg, temp, OP_ICONST);
2636                         temp->inst_c0 = ins->inst_offset;
2637                         temp->dreg = mono_alloc_ireg (cfg);
2638                         ins->sreg2 = temp->dreg;
2639                         ins->opcode = map_to_reg_reg_op (ins->opcode);
2640                         break;
2641                 case OP_STORE_MEMBASE_IMM:
2642                 case OP_STOREI1_MEMBASE_IMM:
2643                 case OP_STOREI2_MEMBASE_IMM:
2644                 case OP_STOREI4_MEMBASE_IMM:
2645                 CASE_PPC64 (OP_STOREI8_MEMBASE_IMM)
2646                         NEW_INS (cfg, temp, OP_ICONST);
2647                         temp->inst_c0 = ins->inst_imm;
2648                         temp->dreg = mono_alloc_ireg (cfg);
2649                         ins->sreg1 = temp->dreg;
2650                         ins->opcode = map_to_reg_reg_op (ins->opcode);
2651                         last_ins = temp;
2652                         goto loop_start; /* make it handle the possibly big ins->inst_offset */
2653                 case OP_R8CONST:
2654                 case OP_R4CONST:
2655                         if (cfg->compile_aot) {
2656                                 /* Keep these in the aot case */
2657                                 break;
2658                         }
2659                         NEW_INS (cfg, temp, OP_ICONST);
2660                         temp->inst_c0 = (gulong)ins->inst_p0;
2661                         temp->dreg = mono_alloc_ireg (cfg);
2662                         ins->inst_basereg = temp->dreg;
2663                         ins->inst_offset = 0;
2664                         ins->opcode = ins->opcode == OP_R4CONST? OP_LOADR4_MEMBASE: OP_LOADR8_MEMBASE;
2665                         last_ins = temp;
2666                         /* make it handle the possibly big ins->inst_offset
2667                          * later optimize to use lis + load_membase
2668                          */
2669                         goto loop_start;
2670                 }
2671                 last_ins = ins;
2672         }
2673         bb->last_ins = last_ins;
2674         bb->max_vreg = cfg->next_vreg;
2675 }
2676
2677 static guchar*
2678 emit_float_to_int (MonoCompile *cfg, guchar *code, int dreg, int sreg, int size, gboolean is_signed)
2679 {
2680         long offset = cfg->arch.fp_conv_var_offset;
2681         long sub_offset;
2682         /* sreg is a float, dreg is an integer reg. ppc_f0 is used a scratch */
2683 #ifdef __mono_ppc64__
2684         if (size == 8) {
2685                 ppc_fctidz (code, ppc_f0, sreg);
2686                 sub_offset = 0;
2687         } else
2688 #endif
2689         {
2690                 ppc_fctiwz (code, ppc_f0, sreg);
2691                 sub_offset = 4;
2692         }
2693         if (ppc_is_imm16 (offset + sub_offset)) {
2694                 ppc_stfd (code, ppc_f0, offset, cfg->frame_reg);
2695                 if (size == 8)
2696                         ppc_ldr (code, dreg, offset + sub_offset, cfg->frame_reg);
2697                 else
2698                         ppc_lwz (code, dreg, offset + sub_offset, cfg->frame_reg);
2699         } else {
2700                 ppc_load (code, dreg, offset);
2701                 ppc_add (code, dreg, dreg, cfg->frame_reg);
2702                 ppc_stfd (code, ppc_f0, 0, dreg);
2703                 if (size == 8)
2704                         ppc_ldr (code, dreg, sub_offset, dreg);
2705                 else
2706                         ppc_lwz (code, dreg, sub_offset, dreg);
2707         }
2708         if (!is_signed) {
2709                 if (size == 1)
2710                         ppc_andid (code, dreg, dreg, 0xff);
2711                 else if (size == 2)
2712                         ppc_andid (code, dreg, dreg, 0xffff);
2713 #ifdef __mono_ppc64__
2714                 else if (size == 4)
2715                         ppc_clrldi (code, dreg, dreg, 32);
2716 #endif
2717         } else {
2718                 if (size == 1)
2719                         ppc_extsb (code, dreg, dreg);
2720                 else if (size == 2)
2721                         ppc_extsh (code, dreg, dreg);
2722 #ifdef __mono_ppc64__
2723                 else if (size == 4)
2724                         ppc_extsw (code, dreg, dreg);
2725 #endif
2726         }
2727         return code;
2728 }
2729
2730 typedef struct {
2731         guchar *code;
2732         const guchar *target;
2733         int absolute;
2734         int found;
2735 } PatchData;
2736
2737 #define is_call_imm(diff) ((glong)(diff) >= -33554432 && (glong)(diff) <= 33554431)
2738
2739 static int
2740 search_thunk_slot (void *data, int csize, int bsize, void *user_data) {
2741 #ifdef __mono_ppc64__
2742         g_assert_not_reached ();
2743 #else
2744         PatchData *pdata = (PatchData*)user_data;
2745         guchar *code = data;
2746         guint32 *thunks = data;
2747         guint32 *endthunks = (guint32*)(code + bsize);
2748         guint32 load [2];
2749         guchar *templ;
2750         int count = 0;
2751         int difflow, diffhigh;
2752
2753         /* always ensure a call from pdata->code can reach to the thunks without further thunks */
2754         difflow = (char*)pdata->code - (char*)thunks;
2755         diffhigh = (char*)pdata->code - (char*)endthunks;
2756         if (!((is_call_imm (thunks) && is_call_imm (endthunks)) || (is_call_imm (difflow) && is_call_imm (diffhigh))))
2757                 return 0;
2758
2759         templ = (guchar*)load;
2760         ppc_load_sequence (templ, ppc_r0, pdata->target);
2761
2762         //g_print ("thunk nentries: %d\n", ((char*)endthunks - (char*)thunks)/16);
2763         if ((pdata->found == 2) || (pdata->code >= code && pdata->code <= code + csize)) {
2764                 while (thunks < endthunks) {
2765                         //g_print ("looking for target: %p at %p (%08x-%08x)\n", pdata->target, thunks, thunks [0], thunks [1]);
2766                         if ((thunks [0] == load [0]) && (thunks [1] == load [1])) {
2767                                 ppc_patch (pdata->code, (guchar*)thunks);
2768                                 pdata->found = 1;
2769                                 /*{
2770                                         static int num_thunks = 0;
2771                                         num_thunks++;
2772                                         if ((num_thunks % 20) == 0)
2773                                                 g_print ("num_thunks lookup: %d\n", num_thunks);
2774                                 }*/
2775                                 return 1;
2776                         } else if ((thunks [0] == 0) && (thunks [1] == 0)) {
2777                                 /* found a free slot instead: emit thunk */
2778                                 code = (guchar*)thunks;
2779                                 ppc_lis (code, ppc_r0, (gulong)(pdata->target) >> 16);
2780                                 ppc_ori (code, ppc_r0, ppc_r0, (gulong)(pdata->target) & 0xffff);
2781                                 ppc_mtctr (code, ppc_r0);
2782                                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
2783                                 mono_arch_flush_icache ((guchar*)thunks, 16);
2784
2785                                 ppc_patch (pdata->code, (guchar*)thunks);
2786                                 pdata->found = 1;
2787                                 /*{
2788                                         static int num_thunks = 0;
2789                                         num_thunks++;
2790                                         if ((num_thunks % 20) == 0)
2791                                                 g_print ("num_thunks: %d\n", num_thunks);
2792                                 }*/
2793                                 return 1;
2794                         }
2795                         /* skip 16 bytes, the size of the thunk */
2796                         thunks += 4;
2797                         count++;
2798                 }
2799                 //g_print ("failed thunk lookup for %p from %p at %p (%d entries)\n", pdata->target, pdata->code, data, count);
2800         }
2801 #endif
2802         return 0;
2803 }
2804
2805 static void
2806 handle_thunk (int absolute, guchar *code, const guchar *target) {
2807         MonoDomain *domain = mono_domain_get ();
2808         PatchData pdata;
2809
2810         pdata.code = code;
2811         pdata.target = target;
2812         pdata.absolute = absolute;
2813         pdata.found = 0;
2814
2815         mono_domain_lock (domain);
2816         mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
2817
2818         if (!pdata.found) {
2819                 /* this uses the first available slot */
2820                 pdata.found = 2;
2821                 mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
2822         }
2823         mono_domain_unlock (domain);
2824
2825         if (pdata.found != 1)
2826                 g_print ("thunk failed for %p from %p\n", target, code);
2827         g_assert (pdata.found == 1);
2828 }
2829
2830 static void
2831 patch_ins (guint8 *code, guint32 ins)
2832 {
2833         *(guint32*)code = GUINT32_TO_BE (ins);
2834         mono_arch_flush_icache (code, 4);
2835 }
2836
2837 void
2838 ppc_patch_full (guchar *code, const guchar *target, gboolean is_fd)
2839 {
2840         guint32 ins = GUINT32_FROM_BE (*(guint32*)code);
2841         guint32 prim = ins >> 26;
2842         guint32 ovf;
2843
2844         //g_print ("patching 0x%08x (0x%08x) to point to 0x%08x\n", code, ins, target);
2845         if (prim == 18) {
2846                 // prefer relative branches, they are more position independent (e.g. for AOT compilation).
2847                 gint diff = target - code;
2848                 g_assert (!is_fd);
2849                 if (diff >= 0){
2850                         if (diff <= 33554431){
2851                                 ins = (18 << 26) | (diff) | (ins & 1);
2852                                 patch_ins (code, ins);
2853                                 return;
2854                         }
2855                 } else {
2856                         /* diff between 0 and -33554432 */
2857                         if (diff >= -33554432){
2858                                 ins = (18 << 26) | (diff & ~0xfc000000) | (ins & 1);
2859                                 patch_ins (code, ins);
2860                                 return;
2861                         }
2862                 }
2863
2864                 if ((glong)target >= 0){
2865                         if ((glong)target <= 33554431){
2866                                 ins = (18 << 26) | ((gulong) target) | (ins & 1) | 2;
2867                                 patch_ins (code, ins);
2868                                 return;
2869                         }
2870                 } else {
2871                         if ((glong)target >= -33554432){
2872                                 ins = (18 << 26) | (((gulong)target) & ~0xfc000000) | (ins & 1) | 2;
2873                                 patch_ins (code, ins);
2874                                 return;
2875                         }
2876                 }
2877
2878                 handle_thunk (TRUE, code, target);
2879                 return;
2880
2881                 g_assert_not_reached ();
2882         }
2883
2884
2885         if (prim == 16) {
2886                 g_assert (!is_fd);
2887                 // absolute address
2888                 if (ins & 2) {
2889                         guint32 li = (gulong)target;
2890                         ins = (ins & 0xffff0000) | (ins & 3);
2891                         ovf  = li & 0xffff0000;
2892                         if (ovf != 0 && ovf != 0xffff0000)
2893                                 g_assert_not_reached ();
2894                         li &= 0xffff;
2895                         ins |= li;
2896                         // FIXME: assert the top bits of li are 0
2897                 } else {
2898                         gint diff = target - code;
2899                         ins = (ins & 0xffff0000) | (ins & 3);
2900                         ovf  = diff & 0xffff0000;
2901                         if (ovf != 0 && ovf != 0xffff0000)
2902                                 g_assert_not_reached ();
2903                         diff &= 0xffff;
2904                         ins |= diff;
2905                 }
2906                 patch_ins (code, ins);
2907                 return;
2908         }
2909
2910         if (prim == 15 || ins == 0x4e800021 || ins == 0x4e800020 || ins == 0x4e800420) {
2911 #ifdef __mono_ppc64__
2912                 guint32 *seq = (guint32*)code;
2913                 guint32 *branch_ins;
2914
2915                 /* the trampoline code will try to patch the blrl, blr, bcctr */
2916                 if (ins == 0x4e800021 || ins == 0x4e800020 || ins == 0x4e800420) {
2917                         branch_ins = seq;
2918                         if (ppc_opcode (seq [-3]) == 58 || ppc_opcode (seq [-3]) == 31) /* ld || mr */
2919                                 code -= 32;
2920                         else
2921                                 code -= 24;
2922                 } else {
2923                         if (ppc_opcode (seq [5]) == 58 || ppc_opcode (seq [5]) == 31) /* ld || mr */
2924                                 branch_ins = seq + 8;
2925                         else
2926                                 branch_ins = seq + 6;
2927                 }
2928
2929                 seq = (guint32*)code;
2930                 /* this is the lis/ori/sldi/oris/ori/(ld/ld|mr/nop)/mtlr/blrl sequence */
2931                 g_assert (mono_ppc_is_direct_call_sequence (branch_ins));
2932
2933                 if (ppc_opcode (seq [5]) == 58) {       /* ld */
2934                         g_assert (ppc_opcode (seq [6]) == 58); /* ld */
2935
2936                         if (!is_fd) {
2937                                 guint8 *buf = (guint8*)&seq [5];
2938                                 ppc_mr (buf, ppc_r0, ppc_r11);
2939                                 ppc_nop (buf);
2940                         }
2941                 } else {
2942                         if (is_fd)
2943                                 target = mono_get_addr_from_ftnptr ((gpointer)target);
2944                 }
2945
2946                 /* FIXME: make this thread safe */
2947                 /* FIXME: we're assuming we're using r11 here */
2948                 ppc_load_ptr_sequence (code, ppc_r11, target);
2949                 mono_arch_flush_icache ((guint8*)seq, 28);
2950 #else
2951                 guint32 *seq;
2952                 /* the trampoline code will try to patch the blrl, blr, bcctr */
2953                 if (ins == 0x4e800021 || ins == 0x4e800020 || ins == 0x4e800420) {
2954                         code -= 12;
2955                 }
2956                 /* this is the lis/ori/mtlr/blrl sequence */
2957                 seq = (guint32*)code;
2958                 g_assert ((seq [0] >> 26) == 15);
2959                 g_assert ((seq [1] >> 26) == 24);
2960                 g_assert ((seq [2] >> 26) == 31);
2961                 g_assert (seq [3] == 0x4e800021 || seq [3] == 0x4e800020 || seq [3] == 0x4e800420);
2962                 /* FIXME: make this thread safe */
2963                 ppc_lis (code, ppc_r0, (guint32)(target) >> 16);
2964                 ppc_ori (code, ppc_r0, ppc_r0, (guint32)(target) & 0xffff);
2965                 mono_arch_flush_icache (code - 8, 8);
2966 #endif
2967         } else {
2968                 g_assert_not_reached ();
2969         }
2970 //      g_print ("patched with 0x%08x\n", ins);
2971 }
2972
2973 void
2974 ppc_patch (guchar *code, const guchar *target)
2975 {
2976         ppc_patch_full (code, target, FALSE);
2977 }
2978
2979 void
2980 mono_ppc_patch (guchar *code, const guchar *target)
2981 {
2982         ppc_patch (code, target);
2983 }
2984
2985 static guint8*
2986 emit_move_return_value (MonoCompile *cfg, MonoInst *ins, guint8 *code)
2987 {
2988         switch (ins->opcode) {
2989         case OP_FCALL:
2990         case OP_FCALL_REG:
2991         case OP_FCALL_MEMBASE:
2992                 if (ins->dreg != ppc_f1)
2993                         ppc_fmr (code, ins->dreg, ppc_f1);
2994                 break;
2995         }
2996
2997         return code;
2998 }
2999
3000 /*
3001  * emit_load_volatile_arguments:
3002  *
3003  *  Load volatile arguments from the stack to the original input registers.
3004  * Required before a tail call.
3005  */
3006 static guint8*
3007 emit_load_volatile_arguments (MonoCompile *cfg, guint8 *code)
3008 {
3009         MonoMethod *method = cfg->method;
3010         MonoMethodSignature *sig;
3011         MonoInst *inst;
3012         CallInfo *cinfo;
3013         guint32 i, pos;
3014         int struct_index = 0;
3015
3016         sig = mono_method_signature (method);
3017
3018         /* This is the opposite of the code in emit_prolog */
3019
3020         pos = 0;
3021
3022         cinfo = calculate_sizes (sig, sig->pinvoke);
3023
3024         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
3025                 ArgInfo *ainfo = &cinfo->ret;
3026                 inst = cfg->vret_addr;
3027                 g_assert (ppc_is_imm16 (inst->inst_offset));
3028                 ppc_ldptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3029         }
3030         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
3031                 ArgInfo *ainfo = cinfo->args + i;
3032                 inst = cfg->args [pos];
3033
3034                 g_assert (inst->opcode != OP_REGVAR);
3035                 g_assert (ppc_is_imm16 (inst->inst_offset));
3036
3037                 switch (ainfo->regtype) {
3038                 case RegTypeGeneral:
3039                         switch (ainfo->size) {
3040                                 case 1:
3041                                         ppc_lbz (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3042                                         break;
3043                                 case 2:
3044                                         ppc_lhz (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3045                                         break;
3046 #ifdef __mono_ppc64__
3047                                 case 4:
3048                                         ppc_lwz (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3049                                         break;
3050 #endif
3051                                 default:
3052                                         ppc_ldptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3053                                         break;
3054                         }
3055                         break;
3056
3057                 case RegTypeFP:
3058                         switch (ainfo->size) {
3059                                 case 4:
3060                                         ppc_lfs (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3061                                         break;
3062                                 case 8:
3063                                         ppc_lfd (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
3064                                         break;
3065                                 default:
3066                                         g_assert_not_reached ();
3067                         }
3068                         break;
3069
3070                 case RegTypeBase: {
3071                         MonoType *type = mini_type_get_underlying_type (cfg->generic_sharing_context,
3072                                 &inst->klass->byval_arg);
3073
3074 #ifndef __mono_ppc64__
3075                         if (type->type == MONO_TYPE_I8)
3076                                 NOT_IMPLEMENTED;
3077 #endif
3078
3079                         if (MONO_TYPE_IS_REFERENCE (type) || type->type == MONO_TYPE_I8) {
3080                                 ppc_ldptr (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
3081                                 ppc_stptr (code, ppc_r0, ainfo->offset, ainfo->reg);
3082                         } else if (type->type == MONO_TYPE_I4) {
3083                                 ppc_lwz (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
3084                                 ppc_stw (code, ppc_r0, ainfo->offset, ainfo->reg);
3085                         } else {
3086                                 NOT_IMPLEMENTED;
3087                         }
3088
3089                         break;
3090                 }
3091
3092                 case RegTypeStructByVal: {
3093 #ifdef __APPLE__
3094                         guint32 size = 0;
3095 #endif
3096                         int j;
3097
3098                         /* FIXME: */
3099                         if (ainfo->vtsize)
3100                                 NOT_IMPLEMENTED;
3101 #ifdef __APPLE__
3102                         /*
3103                          * Darwin pinvokes needs some special handling
3104                          * for 1 and 2 byte arguments
3105                          */
3106                         if (method->signature->pinvoke)
3107                                 size = mono_class_native_size (inst->klass, NULL);
3108                         if (size == 1 || size == 2) {
3109                                 /* FIXME: */
3110                                 NOT_IMPLEMENTED;
3111                         } else
3112 #endif
3113                                 for (j = 0; j < ainfo->vtregs; ++j) {
3114                                         ppc_ldptr (code, ainfo->reg + j,
3115                                                         inst->inst_offset + j * sizeof (gpointer),
3116                                                         inst->inst_basereg);
3117                                         /* FIXME: shift to the right */
3118                                         if (ainfo->bytes)
3119                                                 NOT_IMPLEMENTED;
3120                                 }
3121                         break;
3122                 }
3123
3124                 case RegTypeStructByAddr: {
3125                         MonoInst *addr = cfg->tailcall_valuetype_addrs [struct_index];
3126
3127                         g_assert (ppc_is_imm16 (addr->inst_offset));
3128                         g_assert (!ainfo->offset);
3129                         ppc_ldptr (code, ainfo->reg, addr->inst_offset, addr->inst_basereg);
3130
3131                         struct_index++;
3132                         break;
3133                 }
3134
3135                 default:
3136                         g_assert_not_reached ();
3137                 }
3138
3139                 pos ++;
3140         }
3141
3142         g_free (cinfo);
3143
3144         return code;
3145 }
3146
3147 /* This must be kept in sync with emit_load_volatile_arguments(). */
3148 static int
3149 ins_native_length (MonoCompile *cfg, MonoInst *ins)
3150 {
3151         int len = ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
3152         MonoMethodSignature *sig;
3153         MonoCallInst *call;
3154         CallInfo *cinfo;
3155         int i;
3156
3157         if (ins->opcode != OP_JMP)
3158                 return len;
3159
3160         call = (MonoCallInst*)ins;
3161         sig = mono_method_signature (cfg->method);
3162         cinfo = calculate_sizes (sig, sig->pinvoke);
3163
3164         if (MONO_TYPE_ISSTRUCT (sig->ret))
3165                 len += 4;
3166         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
3167                 ArgInfo *ainfo = cinfo->args + i;
3168
3169                 switch (ainfo->regtype) {
3170                 case RegTypeGeneral:
3171                 case RegTypeFP:
3172                         len += 4;
3173                         break;
3174
3175                 case RegTypeBase:
3176                         len += 8;
3177                         break;
3178
3179                 case RegTypeStructByVal:
3180                         len += 4 * ainfo->size;
3181                         break;
3182
3183                 case RegTypeStructByAddr:
3184                         len += 4;
3185                         break;
3186
3187                 default:
3188                         g_assert_not_reached ();
3189                 }
3190         }
3191
3192         g_free (cinfo);
3193
3194         return len;
3195 }
3196
3197 static guint8*
3198 emit_reserve_param_area (MonoCompile *cfg, guint8 *code)
3199 {
3200         long size = cfg->param_area;
3201
3202         size += MONO_ARCH_FRAME_ALIGNMENT - 1;
3203         size &= -MONO_ARCH_FRAME_ALIGNMENT;
3204
3205         if (!size)
3206                 return code;
3207
3208         ppc_ldptr (code, ppc_r0, 0, ppc_sp);
3209         if (ppc_is_imm16 (-size)) {
3210                 ppc_stptr_update (code, ppc_r0, -size, ppc_sp);
3211         } else {
3212                 ppc_load (code, ppc_r11, -size);
3213                 ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11);
3214         }
3215
3216         return code;
3217 }
3218
3219 static guint8*
3220 emit_unreserve_param_area (MonoCompile *cfg, guint8 *code)
3221 {
3222         long size = cfg->param_area;
3223
3224         size += MONO_ARCH_FRAME_ALIGNMENT - 1;
3225         size &= -MONO_ARCH_FRAME_ALIGNMENT;
3226
3227         if (!size)
3228                 return code;
3229
3230         ppc_ldptr (code, ppc_r0, 0, ppc_sp);
3231         if (ppc_is_imm16 (size)) {
3232                 ppc_stptr_update (code, ppc_r0, size, ppc_sp);
3233         } else {
3234                 ppc_load (code, ppc_r11, size);
3235                 ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11);
3236         }
3237
3238         return code;
3239 }
3240
3241 #define MASK_SHIFT_IMM(i)       ((i) & MONO_PPC_32_64_CASE (0x1f, 0x3f))
3242
3243 #ifndef DISABLE_JIT
3244 void
3245 mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
3246 {
3247         MonoInst *ins, *next;
3248         MonoCallInst *call;
3249         guint offset;
3250         guint8 *code = cfg->native_code + cfg->code_len;
3251         MonoInst *last_ins = NULL;
3252         guint last_offset = 0;
3253         int max_len, cpos;
3254         int L;
3255
3256         /* we don't align basic blocks of loops on ppc */
3257
3258         if (cfg->verbose_level > 2)
3259                 g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset);
3260
3261         cpos = bb->max_offset;
3262
3263         if (cfg->prof_options & MONO_PROFILE_COVERAGE) {
3264                 //MonoCoverageInfo *cov = mono_get_coverage_info (cfg->method);
3265                 //g_assert (!mono_compile_aot);
3266                 //cpos += 6;
3267                 //if (bb->cil_code)
3268                 //      cov->data [bb->dfn].iloffset = bb->cil_code - cfg->cil_code;
3269                 /* this is not thread save, but good enough */
3270                 /* fixme: howto handle overflows? */
3271                 //x86_inc_mem (code, &cov->data [bb->dfn].count);
3272         }
3273
3274         MONO_BB_FOR_EACH_INS (bb, ins) {
3275                 offset = code - cfg->native_code;
3276
3277                 max_len = ins_native_length (cfg, ins);
3278
3279                 if (offset > (cfg->code_size - max_len - 16)) {
3280                         cfg->code_size *= 2;
3281                         cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
3282                         code = cfg->native_code + offset;
3283                 }
3284         //      if (ins->cil_code)
3285         //              g_print ("cil code\n");
3286                 mono_debug_record_line_number (cfg, ins, offset);
3287
3288                 switch (normalize_opcode (ins->opcode)) {
3289                 case OP_RELAXED_NOP:
3290                 case OP_NOP:
3291                 case OP_DUMMY_USE:
3292                 case OP_DUMMY_STORE:
3293                 case OP_NOT_REACHED:
3294                 case OP_NOT_NULL:
3295                         break;
3296                 case OP_SEQ_POINT: {
3297                         int i;
3298
3299                         if (cfg->compile_aot)
3300                                 NOT_IMPLEMENTED;
3301
3302                         /*
3303                          * Read from the single stepping trigger page. This will cause a
3304                          * SIGSEGV when single stepping is enabled.
3305                          * We do this _before_ the breakpoint, so single stepping after
3306                          * a breakpoint is hit will step to the next IL offset.
3307                          */
3308                         if (ins->flags & MONO_INST_SINGLE_STEP_LOC) {
3309                                 ppc_load (code, ppc_r11, (gsize)ss_trigger_page);
3310                                 ppc_ldptr (code, ppc_r11, 0, ppc_r11);
3311                         }
3312
3313                         mono_add_seq_point (cfg, bb, ins, code - cfg->native_code);
3314
3315                         /*
3316                          * A placeholder for a possible breakpoint inserted by
3317                          * mono_arch_set_breakpoint ().
3318                          */
3319                         for (i = 0; i < BREAKPOINT_SIZE / 4; ++i)
3320                                 ppc_nop (code);
3321                         break;
3322                 }
3323                 case OP_TLS_GET:
3324                         emit_tls_access (code, ins->dreg, ins->inst_offset);
3325                         break;
3326                 case OP_BIGMUL:
3327                         ppc_mullw (code, ppc_r0, ins->sreg1, ins->sreg2);
3328                         ppc_mulhw (code, ppc_r3, ins->sreg1, ins->sreg2);
3329                         ppc_mr (code, ppc_r4, ppc_r0);
3330                         break;
3331                 case OP_BIGMUL_UN:
3332                         ppc_mullw (code, ppc_r0, ins->sreg1, ins->sreg2);
3333                         ppc_mulhwu (code, ppc_r3, ins->sreg1, ins->sreg2);
3334                         ppc_mr (code, ppc_r4, ppc_r0);
3335                         break;
3336                 case OP_MEMORY_BARRIER:
3337                         ppc_sync (code);
3338                         break;
3339                 case OP_STOREI1_MEMBASE_REG:
3340                         if (ppc_is_imm16 (ins->inst_offset)) {
3341                                 ppc_stb (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
3342                         } else {
3343                                 if (ppc_is_imm32 (ins->inst_offset)) {
3344                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
3345                                         ppc_stb (code, ins->sreg1, ins->inst_offset, ppc_r12);
3346                                 } else {
3347                                         ppc_load (code, ppc_r0, ins->inst_offset);
3348                                         ppc_stbx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
3349                                 }
3350                         }
3351                         break;
3352                 case OP_STOREI2_MEMBASE_REG:
3353                         if (ppc_is_imm16 (ins->inst_offset)) {
3354                                 ppc_sth (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
3355                         } else {
3356                                 if (ppc_is_imm32 (ins->inst_offset)) {
3357                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
3358                                         ppc_sth (code, ins->sreg1, ins->inst_offset, ppc_r12);
3359                                 } else {
3360                                         ppc_load (code, ppc_r0, ins->inst_offset);
3361                                         ppc_sthx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
3362                                 }
3363                         }
3364                         break;
3365                 case OP_STORE_MEMBASE_REG:
3366                         if (ppc_is_imm16 (ins->inst_offset)) {
3367                                 ppc_stptr (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
3368                         } else {
3369                                 if (ppc_is_imm32 (ins->inst_offset)) {
3370                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
3371                                         ppc_stptr (code, ins->sreg1, ins->inst_offset, ppc_r12);
3372                                 } else {
3373                                         ppc_load (code, ppc_r0, ins->inst_offset);
3374                                         ppc_stptr_indexed (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
3375                                 }
3376                         }
3377                         break;
3378 #ifdef __mono_ilp32__
3379                 case OP_STOREI8_MEMBASE_REG:
3380                         if (ppc_is_imm16 (ins->inst_offset)) {
3381                                 ppc_str (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
3382                         } else {
3383                                 ppc_load (code, ppc_r0, ins->inst_offset);
3384                                 ppc_str_indexed (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
3385                         }
3386                         break;
3387 #endif
3388                 case OP_STOREI1_MEMINDEX:
3389                         ppc_stbx (code, ins->sreg1, ins->inst_destbasereg, ins->sreg2);
3390                         break;
3391                 case OP_STOREI2_MEMINDEX:
3392                         ppc_sthx (code, ins->sreg1, ins->inst_destbasereg, ins->sreg2);
3393                         break;
3394                 case OP_STORE_MEMINDEX:
3395                         ppc_stptr_indexed (code, ins->sreg1, ins->inst_destbasereg, ins->sreg2);
3396                         break;
3397                 case OP_LOADU4_MEM:
3398                         g_assert_not_reached ();
3399                         break;
3400                 case OP_LOAD_MEMBASE:
3401                         if (ppc_is_imm16 (ins->inst_offset)) {
3402                                 ppc_ldptr (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3403                         } else {
3404                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3405                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3406                                         ppc_ldptr (code, ins->dreg, ins->inst_offset, ins->dreg);
3407                                 } else {
3408                                         ppc_load (code, ppc_r0, ins->inst_offset);
3409                                         ppc_ldptr_indexed (code, ins->dreg, ins->inst_basereg, ppc_r0);
3410                                 }
3411                         }
3412                         break;
3413                 case OP_LOADI4_MEMBASE:
3414 #ifdef __mono_ppc64__
3415                         if (ppc_is_imm16 (ins->inst_offset)) {
3416                                 ppc_lwa (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3417                         } else {
3418                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3419                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3420                                         ppc_lwa (code, ins->dreg, ins->inst_offset, ins->dreg);
3421                                 } else {
3422                                         ppc_load (code, ppc_r0, ins->inst_offset);
3423                                         ppc_lwax (code, ins->dreg, ins->inst_basereg, ppc_r0);
3424                                 }
3425                         }
3426                         break;
3427 #endif
3428                 case OP_LOADU4_MEMBASE:
3429                         if (ppc_is_imm16 (ins->inst_offset)) {
3430                                 ppc_lwz (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3431                         } else {
3432                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3433                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3434                                         ppc_lwz (code, ins->dreg, ins->inst_offset, ins->dreg);
3435                                 } else {
3436                                         ppc_load (code, ppc_r0, ins->inst_offset);
3437                                         ppc_lwzx (code, ins->dreg, ins->inst_basereg, ppc_r0);
3438                                 }
3439                         }
3440                         break;
3441                 case OP_LOADI1_MEMBASE:
3442                 case OP_LOADU1_MEMBASE:
3443                         if (ppc_is_imm16 (ins->inst_offset)) {
3444                                 ppc_lbz (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3445                         } else {
3446                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3447                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3448                                         ppc_lbz (code, ins->dreg, ins->inst_offset, ins->dreg);
3449                                 } else {
3450                                         ppc_load (code, ppc_r0, ins->inst_offset);
3451                                         ppc_lbzx (code, ins->dreg, ins->inst_basereg, ppc_r0);
3452                                 }
3453                         }
3454                         if (ins->opcode == OP_LOADI1_MEMBASE)
3455                                 ppc_extsb (code, ins->dreg, ins->dreg);
3456                         break;
3457                 case OP_LOADU2_MEMBASE:
3458                         if (ppc_is_imm16 (ins->inst_offset)) {
3459                                 ppc_lhz (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3460                         } else {
3461                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3462                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3463                                         ppc_lhz (code, ins->dreg, ins->inst_offset, ins->dreg);
3464                                 } else {
3465                                         ppc_load (code, ppc_r0, ins->inst_offset);
3466                                         ppc_lhzx (code, ins->dreg, ins->inst_basereg, ppc_r0);
3467                                 }
3468                         }
3469                         break;
3470                 case OP_LOADI2_MEMBASE:
3471                         if (ppc_is_imm16 (ins->inst_offset)) {
3472                                 ppc_lha (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3473                         } else {
3474                                 if (ppc_is_imm32 (ins->inst_offset) && (ins->dreg > 0)) {
3475                                         ppc_addis (code, ins->dreg, ins->inst_basereg, ppc_ha(ins->inst_offset));
3476                                         ppc_lha (code, ins->dreg, ins->inst_offset, ins->dreg);
3477                                 } else {
3478                                         ppc_load (code, ppc_r0, ins->inst_offset);
3479                                         ppc_lhax (code, ins->dreg, ins->inst_basereg, ppc_r0);
3480                                 }
3481                         }
3482                         break;
3483 #ifdef __mono_ilp32__
3484                 case OP_LOADI8_MEMBASE:
3485                         if (ppc_is_imm16 (ins->inst_offset)) {
3486                                 ppc_ldr (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
3487                         } else {
3488                                 ppc_load (code, ppc_r0, ins->inst_offset);
3489                                 ppc_ldr_indexed (code, ins->dreg, ins->inst_basereg, ppc_r0);
3490                         }
3491                         break;
3492 #endif
3493                 case OP_LOAD_MEMINDEX:
3494                         ppc_ldptr_indexed (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3495                         break;
3496                 case OP_LOADI4_MEMINDEX:
3497 #ifdef __mono_ppc64__
3498                         ppc_lwax (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3499                         break;
3500 #endif
3501                 case OP_LOADU4_MEMINDEX:
3502                         ppc_lwzx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3503                         break;
3504                 case OP_LOADU2_MEMINDEX:
3505                         ppc_lhzx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3506                         break;
3507                 case OP_LOADI2_MEMINDEX:
3508                         ppc_lhax (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3509                         break;
3510                 case OP_LOADU1_MEMINDEX:
3511                         ppc_lbzx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3512                         break;
3513                 case OP_LOADI1_MEMINDEX:
3514                         ppc_lbzx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
3515                         ppc_extsb (code, ins->dreg, ins->dreg);
3516                         break;
3517                 case OP_ICONV_TO_I1:
3518                 CASE_PPC64 (OP_LCONV_TO_I1)
3519                         ppc_extsb (code, ins->dreg, ins->sreg1);
3520                         break;
3521                 case OP_ICONV_TO_I2:
3522                 CASE_PPC64 (OP_LCONV_TO_I2)
3523                         ppc_extsh (code, ins->dreg, ins->sreg1);
3524                         break;
3525                 case OP_ICONV_TO_U1:
3526                 CASE_PPC64 (OP_LCONV_TO_U1)
3527                         ppc_clrlwi (code, ins->dreg, ins->sreg1, 24);
3528                         break;
3529                 case OP_ICONV_TO_U2:
3530                 CASE_PPC64 (OP_LCONV_TO_U2)
3531                         ppc_clrlwi (code, ins->dreg, ins->sreg1, 16);
3532                         break;
3533                 case OP_COMPARE:
3534                 case OP_ICOMPARE:
3535                 CASE_PPC64 (OP_LCOMPARE)
3536                         L = (sizeof (mgreg_t) == 4 || ins->opcode == OP_ICOMPARE) ? 0 : 1;
3537                         next = ins->next;
3538                         if (next && compare_opcode_is_unsigned (next->opcode))
3539                                 ppc_cmpl (code, 0, L, ins->sreg1, ins->sreg2);
3540                         else
3541                                 ppc_cmp (code, 0, L, ins->sreg1, ins->sreg2);
3542                         break;
3543                 case OP_COMPARE_IMM:
3544                 case OP_ICOMPARE_IMM:
3545                 CASE_PPC64 (OP_LCOMPARE_IMM)
3546                         L = (sizeof (mgreg_t) == 4 || ins->opcode == OP_ICOMPARE_IMM) ? 0 : 1;
3547                         next = ins->next;
3548                         if (next && compare_opcode_is_unsigned (next->opcode)) {
3549                                 if (ppc_is_uimm16 (ins->inst_imm)) {
3550                                         ppc_cmpli (code, 0, L, ins->sreg1, (ins->inst_imm & 0xffff));
3551                                 } else {
3552                                         g_assert_not_reached ();
3553                                 }
3554                         } else {
3555                                 if (ppc_is_imm16 (ins->inst_imm)) {
3556                                         ppc_cmpi (code, 0, L, ins->sreg1, (ins->inst_imm & 0xffff));
3557                                 } else {
3558                                         g_assert_not_reached ();
3559                                 }
3560                         }
3561                         break;
3562                 case OP_BREAK:
3563                         ppc_break (code);
3564                         break;
3565                 case OP_ADDCC:
3566                 case OP_IADDCC:
3567                         ppc_addco (code, ins->dreg, ins->sreg1, ins->sreg2);
3568                         break;
3569                 case OP_IADD:
3570                 CASE_PPC64 (OP_LADD)
3571                         ppc_add (code, ins->dreg, ins->sreg1, ins->sreg2);
3572                         break;
3573                 case OP_ADC:
3574                 case OP_IADC:
3575                         ppc_adde (code, ins->dreg, ins->sreg1, ins->sreg2);
3576                         break;
3577                 case OP_ADDCC_IMM:
3578                         if (ppc_is_imm16 (ins->inst_imm)) {
3579                                 ppc_addic (code, ins->dreg, ins->sreg1, ins->inst_imm);
3580                         } else {
3581                                 g_assert_not_reached ();
3582                         }
3583                         break;
3584                 case OP_ADD_IMM:
3585                 case OP_IADD_IMM:
3586                 CASE_PPC64 (OP_LADD_IMM)
3587                         if (ppc_is_imm16 (ins->inst_imm)) {
3588                                 ppc_addi (code, ins->dreg, ins->sreg1, ins->inst_imm);
3589                         } else {
3590                                 g_assert_not_reached ();
3591                         }
3592                         break;
3593                 case OP_IADD_OVF:
3594                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3595                          */
3596                         ppc_addo (code, ins->dreg, ins->sreg1, ins->sreg2);
3597                         ppc_mfspr (code, ppc_r0, ppc_xer);
3598                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3599                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3600                         break;
3601                 case OP_IADD_OVF_UN:
3602                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3603                          */
3604                         ppc_addco (code, ins->dreg, ins->sreg1, ins->sreg2);
3605                         ppc_mfspr (code, ppc_r0, ppc_xer);
3606                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<13));
3607                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3608                         break;
3609                 case OP_ISUB_OVF:
3610                 CASE_PPC64 (OP_LSUB_OVF)
3611                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3612                          */
3613                         ppc_subfo (code, ins->dreg, ins->sreg2, ins->sreg1);
3614                         ppc_mfspr (code, ppc_r0, ppc_xer);
3615                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3616                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3617                         break;
3618                 case OP_ISUB_OVF_UN:
3619                 CASE_PPC64 (OP_LSUB_OVF_UN)
3620                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3621                          */
3622                         ppc_subfc (code, ins->dreg, ins->sreg2, ins->sreg1);
3623                         ppc_mfspr (code, ppc_r0, ppc_xer);
3624                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<13));
3625                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_TRUE, PPC_BR_EQ, "OverflowException");
3626                         break;
3627                 case OP_ADD_OVF_CARRY:
3628                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3629                          */
3630                         ppc_addeo (code, ins->dreg, ins->sreg1, ins->sreg2);
3631                         ppc_mfspr (code, ppc_r0, ppc_xer);
3632                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3633                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3634                         break;
3635                 case OP_ADD_OVF_UN_CARRY:
3636                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3637                          */
3638                         ppc_addeo (code, ins->dreg, ins->sreg1, ins->sreg2);
3639                         ppc_mfspr (code, ppc_r0, ppc_xer);
3640                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<13));
3641                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3642                         break;
3643                 case OP_SUB_OVF_CARRY:
3644                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3645                          */
3646                         ppc_subfeo (code, ins->dreg, ins->sreg2, ins->sreg1);
3647                         ppc_mfspr (code, ppc_r0, ppc_xer);
3648                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3649                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3650                         break;
3651                 case OP_SUB_OVF_UN_CARRY:
3652                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
3653                          */
3654                         ppc_subfeo (code, ins->dreg, ins->sreg2, ins->sreg1);
3655                         ppc_mfspr (code, ppc_r0, ppc_xer);
3656                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<13));
3657                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_TRUE, PPC_BR_EQ, "OverflowException");
3658                         break;
3659                 case OP_SUBCC:
3660                 case OP_ISUBCC:
3661                         ppc_subfco (code, ins->dreg, ins->sreg2, ins->sreg1);
3662                         break;
3663                 case OP_ISUB:
3664                 CASE_PPC64 (OP_LSUB)
3665                         ppc_subf (code, ins->dreg, ins->sreg2, ins->sreg1);
3666                         break;
3667                 case OP_SBB:
3668                 case OP_ISBB:
3669                         ppc_subfe (code, ins->dreg, ins->sreg2, ins->sreg1);
3670                         break;
3671                 case OP_SUB_IMM:
3672                 case OP_ISUB_IMM:
3673                 CASE_PPC64 (OP_LSUB_IMM)
3674                         // we add the negated value
3675                         if (ppc_is_imm16 (-ins->inst_imm))
3676                                 ppc_addi (code, ins->dreg, ins->sreg1, -ins->inst_imm);
3677                         else {
3678                                 g_assert_not_reached ();
3679                         }
3680                         break;
3681                 case OP_PPC_SUBFIC:
3682                         g_assert (ppc_is_imm16 (ins->inst_imm));
3683                         ppc_subfic (code, ins->dreg, ins->sreg1, ins->inst_imm);
3684                         break;
3685                 case OP_PPC_SUBFZE:
3686                         ppc_subfze (code, ins->dreg, ins->sreg1);
3687                         break;
3688                 case OP_IAND:
3689                 CASE_PPC64 (OP_LAND)
3690                         /* FIXME: the ppc macros as inconsistent here: put dest as the first arg! */
3691                         ppc_and (code, ins->sreg1, ins->dreg, ins->sreg2);
3692                         break;
3693                 case OP_AND_IMM:
3694                 case OP_IAND_IMM:
3695                 CASE_PPC64 (OP_LAND_IMM)
3696                         if (!(ins->inst_imm & 0xffff0000)) {
3697                                 ppc_andid (code, ins->sreg1, ins->dreg, ins->inst_imm);
3698                         } else if (!(ins->inst_imm & 0xffff)) {
3699                                 ppc_andisd (code, ins->sreg1, ins->dreg, ((guint32)ins->inst_imm >> 16));
3700                         } else {
3701                                 g_assert_not_reached ();
3702                         }
3703                         break;
3704                 case OP_IDIV:
3705                 CASE_PPC64 (OP_LDIV) {
3706                         guint8 *divisor_is_m1;
3707                          /* XER format: SO, OV, CA, reserved [21 bits], count [8 bits]
3708                          */
3709                         ppc_compare_reg_imm (code, 0, ins->sreg2, -1);
3710                         divisor_is_m1 = code;
3711                         ppc_bc (code, PPC_BR_FALSE | PPC_BR_LIKELY, PPC_BR_EQ, 0);
3712                         ppc_lis (code, ppc_r0, 0x8000);
3713 #ifdef __mono_ppc64__
3714                         if (ins->opcode == OP_LDIV)
3715                                 ppc_sldi (code, ppc_r0, ppc_r0, 32);
3716 #endif
3717                         ppc_compare (code, 0, ins->sreg1, ppc_r0);
3718                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_TRUE, PPC_BR_EQ, "ArithmeticException");
3719                         ppc_patch (divisor_is_m1, code);
3720                          /* XER format: SO, OV, CA, reserved [21 bits], count [8 bits]
3721                          */
3722                         if (ins->opcode == OP_IDIV)
3723                                 ppc_divwod (code, ins->dreg, ins->sreg1, ins->sreg2);
3724 #ifdef __mono_ppc64__
3725                         else
3726                                 ppc_divdod (code, ins->dreg, ins->sreg1, ins->sreg2);
3727 #endif
3728                         ppc_mfspr (code, ppc_r0, ppc_xer);
3729                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3730                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "DivideByZeroException");
3731                         break;
3732                 }
3733                 case OP_IDIV_UN:
3734                 CASE_PPC64 (OP_LDIV_UN)
3735                         if (ins->opcode == OP_IDIV_UN)
3736                                 ppc_divwuod (code, ins->dreg, ins->sreg1, ins->sreg2);
3737 #ifdef __mono_ppc64__
3738                         else
3739                                 ppc_divduod (code, ins->dreg, ins->sreg1, ins->sreg2);
3740 #endif
3741                         ppc_mfspr (code, ppc_r0, ppc_xer);
3742                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3743                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "DivideByZeroException");
3744                         break;
3745                 case OP_DIV_IMM:
3746                 case OP_IREM:
3747                 case OP_IREM_UN:
3748                 case OP_REM_IMM:
3749                         g_assert_not_reached ();
3750                 case OP_IOR:
3751                 CASE_PPC64 (OP_LOR)
3752                         ppc_or (code, ins->dreg, ins->sreg1, ins->sreg2);
3753                         break;
3754                 case OP_OR_IMM:
3755                 case OP_IOR_IMM:
3756                 CASE_PPC64 (OP_LOR_IMM)
3757                         if (!(ins->inst_imm & 0xffff0000)) {
3758                                 ppc_ori (code, ins->sreg1, ins->dreg, ins->inst_imm);
3759                         } else if (!(ins->inst_imm & 0xffff)) {
3760                                 ppc_oris (code, ins->dreg, ins->sreg1, ((guint32)(ins->inst_imm) >> 16));
3761                         } else {
3762                                 g_assert_not_reached ();
3763                         }
3764                         break;
3765                 case OP_IXOR:
3766                 CASE_PPC64 (OP_LXOR)
3767                         ppc_xor (code, ins->dreg, ins->sreg1, ins->sreg2);
3768                         break;
3769                 case OP_IXOR_IMM:
3770                 case OP_XOR_IMM:
3771                 CASE_PPC64 (OP_LXOR_IMM)
3772                         if (!(ins->inst_imm & 0xffff0000)) {
3773                                 ppc_xori (code, ins->sreg1, ins->dreg, ins->inst_imm);
3774                         } else if (!(ins->inst_imm & 0xffff)) {
3775                                 ppc_xoris (code, ins->sreg1, ins->dreg, ((guint32)(ins->inst_imm) >> 16));
3776                         } else {
3777                                 g_assert_not_reached ();
3778                         }
3779                         break;
3780                 case OP_ISHL:
3781                 CASE_PPC64 (OP_LSHL)
3782                         ppc_shift_left (code, ins->dreg, ins->sreg1, ins->sreg2);
3783                         break;
3784                 case OP_SHL_IMM:
3785                 case OP_ISHL_IMM:
3786                 CASE_PPC64 (OP_LSHL_IMM)
3787                         ppc_shift_left_imm (code, ins->dreg, ins->sreg1, MASK_SHIFT_IMM (ins->inst_imm));
3788                         break;
3789                 case OP_ISHR:
3790                         ppc_sraw (code, ins->dreg, ins->sreg1, ins->sreg2);
3791                         break;
3792                 case OP_SHR_IMM:
3793                         ppc_shift_right_arith_imm (code, ins->dreg, ins->sreg1, MASK_SHIFT_IMM (ins->inst_imm));
3794                         break;
3795                 case OP_SHR_UN_IMM:
3796                         if (MASK_SHIFT_IMM (ins->inst_imm))
3797                                 ppc_shift_right_imm (code, ins->dreg, ins->sreg1, MASK_SHIFT_IMM (ins->inst_imm));
3798                         else
3799                                 ppc_mr (code, ins->dreg, ins->sreg1);
3800                         break;
3801                 case OP_ISHR_UN:
3802                         ppc_srw (code, ins->dreg, ins->sreg1, ins->sreg2);
3803                         break;
3804                 case OP_INOT:
3805                 CASE_PPC64 (OP_LNOT)
3806                         ppc_not (code, ins->dreg, ins->sreg1);
3807                         break;
3808                 case OP_INEG:
3809                 CASE_PPC64 (OP_LNEG)
3810                         ppc_neg (code, ins->dreg, ins->sreg1);
3811                         break;
3812                 case OP_IMUL:
3813                 CASE_PPC64 (OP_LMUL)
3814                         ppc_multiply (code, ins->dreg, ins->sreg1, ins->sreg2);
3815                         break;
3816                 case OP_IMUL_IMM:
3817                 case OP_MUL_IMM:
3818                 CASE_PPC64 (OP_LMUL_IMM)
3819                         if (ppc_is_imm16 (ins->inst_imm)) {
3820                             ppc_mulli (code, ins->dreg, ins->sreg1, ins->inst_imm);
3821                         } else {
3822                             g_assert_not_reached ();
3823                         }
3824                         break;
3825                 case OP_IMUL_OVF:
3826                 CASE_PPC64 (OP_LMUL_OVF)
3827                         /* we annot use mcrxr, since it's not implemented on some processors
3828                          * XER format: SO, OV, CA, reserved [21 bits], count [8 bits]
3829                          */
3830                         if (ins->opcode == OP_IMUL_OVF)
3831                                 ppc_mullwo (code, ins->dreg, ins->sreg1, ins->sreg2);
3832 #ifdef __mono_ppc64__
3833                         else
3834                                 ppc_mulldo (code, ins->dreg, ins->sreg1, ins->sreg2);
3835 #endif
3836                         ppc_mfspr (code, ppc_r0, ppc_xer);
3837                         ppc_andisd (code, ppc_r0, ppc_r0, (1<<14));
3838                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, "OverflowException");
3839                         break;
3840                 case OP_IMUL_OVF_UN:
3841                 CASE_PPC64 (OP_LMUL_OVF_UN)
3842                         /* we first multiply to get the high word and compare to 0
3843                          * to set the flags, then the result is discarded and then
3844                          * we multiply to get the lower * bits result
3845                          */
3846                         if (ins->opcode == OP_IMUL_OVF_UN)
3847                                 ppc_mulhwu (code, ppc_r0, ins->sreg1, ins->sreg2);
3848 #ifdef __mono_ppc64__
3849                         else
3850                                 ppc_mulhdu (code, ppc_r0, ins->sreg1, ins->sreg2);
3851 #endif
3852                         ppc_cmpi (code, 0, 0, ppc_r0, 0);
3853                         EMIT_COND_SYSTEM_EXCEPTION (CEE_BNE_UN - CEE_BEQ, "OverflowException");
3854                         ppc_multiply (code, ins->dreg, ins->sreg1, ins->sreg2);
3855                         break;
3856                 case OP_ICONST:
3857                         ppc_load (code, ins->dreg, ins->inst_c0);
3858                         break;
3859                 case OP_I8CONST: {
3860                         ppc_load (code, ins->dreg, ins->inst_l);
3861                         break;
3862                 }
3863                 case OP_LOAD_GOTADDR:
3864                         /* The PLT implementation depends on this */
3865                         g_assert (ins->dreg == ppc_r30);
3866
3867                         code = mono_arch_emit_load_got_addr (cfg->native_code, code, cfg, NULL);
3868                         break;
3869                 case OP_GOT_ENTRY:
3870                         // FIXME: Fix max instruction length
3871                         mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_right->inst_i1, ins->inst_right->inst_p0);
3872                         /* arch_emit_got_access () patches this */
3873                         ppc_load32 (code, ppc_r0, 0);
3874                         ppc_ldptr_indexed (code, ins->dreg, ins->inst_basereg, ppc_r0);
3875                         break;
3876                 case OP_AOTCONST:
3877                         mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3878                         ppc_load_sequence (code, ins->dreg, 0);
3879                         break;
3880                 CASE_PPC32 (OP_ICONV_TO_I4)
3881                 CASE_PPC32 (OP_ICONV_TO_U4)
3882                 case OP_MOVE:
3883                         ppc_mr (code, ins->dreg, ins->sreg1);
3884                         break;
3885                 case OP_SETLRET: {
3886                         int saved = ins->sreg1;
3887                         if (ins->sreg1 == ppc_r3) {
3888                                 ppc_mr (code, ppc_r0, ins->sreg1);
3889                                 saved = ppc_r0;
3890                         }
3891                         if (ins->sreg2 != ppc_r3)
3892                                 ppc_mr (code, ppc_r3, ins->sreg2);
3893                         if (saved != ppc_r4)
3894                                 ppc_mr (code, ppc_r4, saved);
3895                         break;
3896                 }
3897                 case OP_FMOVE:
3898                         ppc_fmr (code, ins->dreg, ins->sreg1);
3899                         break;
3900                 case OP_FCONV_TO_R4:
3901                         ppc_frsp (code, ins->dreg, ins->sreg1);
3902                         break;
3903                 case OP_JMP: {
3904                         int i, pos;
3905
3906                         /*
3907                          * Keep in sync with mono_arch_emit_epilog
3908                          */
3909                         g_assert (!cfg->method->save_lmf);
3910                         /*
3911                          * Note: we can use ppc_r11 here because it is dead anyway:
3912                          * we're leaving the method.
3913                          */
3914                         if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
3915                                 long ret_offset = cfg->stack_usage + PPC_RET_ADDR_OFFSET;
3916                                 if (ppc_is_imm16 (ret_offset)) {
3917                                         ppc_ldptr (code, ppc_r0, ret_offset, cfg->frame_reg);
3918                                 } else {
3919                                         ppc_load (code, ppc_r11, ret_offset);
3920                                         ppc_ldptr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r11);
3921                                 }
3922                                 ppc_mtlr (code, ppc_r0);
3923                         }
3924
3925                         code = emit_load_volatile_arguments (cfg, code);
3926
3927                         if (ppc_is_imm16 (cfg->stack_usage)) {
3928                                 ppc_addi (code, ppc_r11, cfg->frame_reg, cfg->stack_usage);
3929                         } else {
3930                                 /* cfg->stack_usage is an int, so we can use
3931                                  * an addis/addi sequence here even in 64-bit.  */
3932                                 ppc_addis (code, ppc_r11, cfg->frame_reg, ppc_ha(cfg->stack_usage));
3933                                 ppc_addi (code, ppc_r11, ppc_r11, cfg->stack_usage);
3934                         }
3935                         if (!cfg->method->save_lmf) {
3936                                 /*for (i = 31; i >= 14; --i) {
3937                                         if (cfg->used_float_regs & (1 << i)) {
3938                                                 pos += sizeof (double);
3939                                                 ppc_lfd (code, i, -pos, cfg->frame_reg);
3940                                         }
3941                                 }*/
3942                                 pos = 0;
3943                                 for (i = 31; i >= 13; --i) {
3944                                         if (cfg->used_int_regs & (1 << i)) {
3945                                                 pos += sizeof (gpointer);
3946                                                 ppc_ldptr (code, i, -pos, ppc_r11);
3947                                         }
3948                                 }
3949                         } else {
3950                                 /* FIXME restore from MonoLMF: though this can't happen yet */
3951                         }
3952                         ppc_mr (code, ppc_sp, ppc_r11);
3953                         mono_add_patch_info (cfg, (guint8*) code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, ins->inst_p0);
3954                         if (cfg->compile_aot) {
3955                                 /* arch_emit_got_access () patches this */
3956                                 ppc_load32 (code, ppc_r0, 0);
3957 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
3958                                 ppc_ldptr_indexed (code, ppc_r11, ppc_r30, ppc_r0);
3959                                 ppc_ldptr (code, ppc_r0, 0, ppc_r11);
3960 #else
3961                                 ppc_ldptr_indexed (code, ppc_r0, ppc_r30, ppc_r0);
3962 #endif
3963                                 ppc_mtctr (code, ppc_r0);
3964                                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
3965                         } else {
3966                                 ppc_b (code, 0);
3967                         }
3968                         break;
3969                 }
3970                 case OP_CHECK_THIS:
3971                         /* ensure ins->sreg1 is not NULL */
3972                         ppc_ldptr (code, ppc_r0, 0, ins->sreg1);
3973                         break;
3974                 case OP_ARGLIST: {
3975                         long cookie_offset = cfg->sig_cookie + cfg->stack_usage;
3976                         if (ppc_is_imm16 (cookie_offset)) {
3977                                 ppc_addi (code, ppc_r0, cfg->frame_reg, cookie_offset);
3978                         } else {
3979                                 ppc_load (code, ppc_r0, cookie_offset);
3980                                 ppc_add (code, ppc_r0, cfg->frame_reg, ppc_r0);
3981                         }
3982                         ppc_stptr (code, ppc_r0, 0, ins->sreg1);
3983                         break;
3984                 }
3985                 case OP_FCALL:
3986                 case OP_LCALL:
3987                 case OP_VCALL:
3988                 case OP_VCALL2:
3989                 case OP_VOIDCALL:
3990                 case OP_CALL:
3991                         call = (MonoCallInst*)ins;
3992                         if (ins->flags & MONO_INST_HAS_METHOD)
3993                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_METHOD, call->method);
3994                         else
3995                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, call->fptr);
3996                         if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
3997                                 ppc_load_func (code, ppc_r0, 0);
3998                                 ppc_mtlr (code, ppc_r0);
3999                                 ppc_blrl (code);
4000                         } else {
4001                                 ppc_bl (code, 0);
4002                         }
4003                         /* FIXME: this should be handled somewhere else in the new jit */
4004                         code = emit_move_return_value (cfg, ins, code);
4005                         break;
4006                 case OP_FCALL_REG:
4007                 case OP_LCALL_REG:
4008                 case OP_VCALL_REG:
4009                 case OP_VCALL2_REG:
4010                 case OP_VOIDCALL_REG:
4011                 case OP_CALL_REG:
4012 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
4013                         ppc_ldptr (code, ppc_r0, 0, ins->sreg1);
4014                         /* FIXME: if we know that this is a method, we
4015                            can omit this load */
4016                         ppc_ldptr (code, ppc_r2, 8, ins->sreg1);
4017                         ppc_mtlr (code, ppc_r0);
4018 #else
4019                         ppc_mtlr (code, ins->sreg1);
4020 #endif
4021                         ppc_blrl (code);
4022                         /* FIXME: this should be handled somewhere else in the new jit */
4023                         code = emit_move_return_value (cfg, ins, code);
4024                         break;
4025                 case OP_FCALL_MEMBASE:
4026                 case OP_LCALL_MEMBASE:
4027                 case OP_VCALL_MEMBASE:
4028                 case OP_VCALL2_MEMBASE:
4029                 case OP_VOIDCALL_MEMBASE:
4030                 case OP_CALL_MEMBASE:
4031                         if (cfg->compile_aot && ins->sreg1 == ppc_r11) {
4032                                 /* The trampolines clobber this */
4033                                 ppc_mr (code, ppc_r29, ins->sreg1);
4034                                 ppc_ldptr (code, ppc_r0, ins->inst_offset, ppc_r29);
4035                         } else {
4036                                 ppc_ldptr (code, ppc_r0, ins->inst_offset, ins->sreg1);
4037                         }
4038                         ppc_mtlr (code, ppc_r0);
4039                         ppc_blrl (code);
4040                         /* FIXME: this should be handled somewhere else in the new jit */
4041                         code = emit_move_return_value (cfg, ins, code);
4042                         break;
4043                 case OP_LOCALLOC: {
4044                         guint8 * zero_loop_jump, * zero_loop_start;
4045                         /* keep alignment */
4046                         int alloca_waste = PPC_STACK_PARAM_OFFSET + cfg->param_area + 31;
4047                         int area_offset = alloca_waste;
4048                         area_offset &= ~31;
4049                         ppc_addi (code, ppc_r11, ins->sreg1, alloca_waste + 31);
4050                         /* FIXME: should be calculated from MONO_ARCH_FRAME_ALIGNMENT */
4051                         ppc_clear_right_imm (code, ppc_r11, ppc_r11, 4);
4052                         /* use ctr to store the number of words to 0 if needed */
4053                         if (ins->flags & MONO_INST_INIT) {
4054                                 /* we zero 4 bytes at a time:
4055                                  * we add 7 instead of 3 so that we set the counter to
4056                                  * at least 1, otherwise the bdnz instruction will make
4057                                  * it negative and iterate billions of times.
4058                                  */
4059                                 ppc_addi (code, ppc_r0, ins->sreg1, 7);
4060                                 ppc_shift_right_arith_imm (code, ppc_r0, ppc_r0, 2);
4061                                 ppc_mtctr (code, ppc_r0);
4062                         }
4063                         ppc_ldptr (code, ppc_r0, 0, ppc_sp);
4064                         ppc_neg (code, ppc_r11, ppc_r11);
4065                         ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11);
4066
4067                         /* FIXME: make this loop work in 8 byte
4068                            increments on PPC64 */
4069                         if (ins->flags & MONO_INST_INIT) {
4070                                 /* adjust the dest reg by -4 so we can use stwu */
4071                                 /* we actually adjust -8 because we let the loop
4072                                  * run at least once
4073                                  */
4074                                 ppc_addi (code, ins->dreg, ppc_sp, (area_offset - 8));
4075                                 ppc_li (code, ppc_r11, 0);
4076                                 zero_loop_start = code;
4077                                 ppc_stwu (code, ppc_r11, 4, ins->dreg);
4078                                 zero_loop_jump = code;
4079                                 ppc_bc (code, PPC_BR_DEC_CTR_NONZERO, 0, 0);
4080                                 ppc_patch (zero_loop_jump, zero_loop_start);
4081                         }
4082                         ppc_addi (code, ins->dreg, ppc_sp, area_offset);
4083                         break;
4084                 }
4085                 case OP_THROW: {
4086                         //ppc_break (code);
4087                         ppc_mr (code, ppc_r3, ins->sreg1);
4088                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
4089                                              (gpointer)"mono_arch_throw_exception");
4090                         if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
4091                                 ppc_load_func (code, ppc_r0, 0);
4092                                 ppc_mtlr (code, ppc_r0);
4093                                 ppc_blrl (code);
4094                         } else {
4095                                 ppc_bl (code, 0);
4096                         }
4097                         break;
4098                 }
4099                 case OP_RETHROW: {
4100                         //ppc_break (code);
4101                         ppc_mr (code, ppc_r3, ins->sreg1);
4102                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
4103                                              (gpointer)"mono_arch_rethrow_exception");
4104                         if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
4105                                 ppc_load_func (code, ppc_r0, 0);
4106                                 ppc_mtlr (code, ppc_r0);
4107                                 ppc_blrl (code);
4108                         } else {
4109                                 ppc_bl (code, 0);
4110                         }
4111                         break;
4112                 }
4113                 case OP_START_HANDLER: {
4114                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4115                         g_assert (spvar->inst_basereg != ppc_sp);
4116                         code = emit_reserve_param_area (cfg, code);
4117                         ppc_mflr (code, ppc_r0);
4118                         if (ppc_is_imm16 (spvar->inst_offset)) {
4119                                 ppc_stptr (code, ppc_r0, spvar->inst_offset, spvar->inst_basereg);
4120                         } else {
4121                                 ppc_load (code, ppc_r11, spvar->inst_offset);
4122                                 ppc_stptr_indexed (code, ppc_r0, ppc_r11, spvar->inst_basereg);
4123                         }
4124                         break;
4125                 }
4126                 case OP_ENDFILTER: {
4127                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4128                         g_assert (spvar->inst_basereg != ppc_sp);
4129                         code = emit_unreserve_param_area (cfg, code);
4130                         if (ins->sreg1 != ppc_r3)
4131                                 ppc_mr (code, ppc_r3, ins->sreg1);
4132                         if (ppc_is_imm16 (spvar->inst_offset)) {
4133                                 ppc_ldptr (code, ppc_r0, spvar->inst_offset, spvar->inst_basereg);
4134                         } else {
4135                                 ppc_load (code, ppc_r11, spvar->inst_offset);
4136                                 ppc_ldptr_indexed (code, ppc_r0, spvar->inst_basereg, ppc_r11);
4137                         }
4138                         ppc_mtlr (code, ppc_r0);
4139                         ppc_blr (code);
4140                         break;
4141                 }
4142                 case OP_ENDFINALLY: {
4143                         MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region);
4144                         g_assert (spvar->inst_basereg != ppc_sp);
4145                         code = emit_unreserve_param_area (cfg, code);
4146                         ppc_ldptr (code, ppc_r0, spvar->inst_offset, spvar->inst_basereg);
4147                         ppc_mtlr (code, ppc_r0);
4148                         ppc_blr (code);
4149                         break;
4150                 }
4151                 case OP_CALL_HANDLER:
4152                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_target_bb);
4153                         ppc_bl (code, 0);
4154                         mono_cfg_add_try_hole (cfg, ins->inst_eh_block, code, bb);
4155                         break;
4156                 case OP_LABEL:
4157                         ins->inst_c0 = code - cfg->native_code;
4158                         break;
4159                 case OP_BR:
4160                         /*if (ins->inst_target_bb->native_offset) {
4161                                 ppc_b (code, 0);
4162                                 //x86_jump_code (code, cfg->native_code + ins->inst_target_bb->native_offset);
4163                         } else*/ {
4164                                 mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_BB, ins->inst_target_bb);
4165                                 ppc_b (code, 0);
4166                         }
4167                         break;
4168                 case OP_BR_REG:
4169                         ppc_mtctr (code, ins->sreg1);
4170                         ppc_bcctr (code, PPC_BR_ALWAYS, 0);
4171                         break;
4172                 case OP_CEQ:
4173                 case OP_ICEQ:
4174                 CASE_PPC64 (OP_LCEQ)
4175                         ppc_li (code, ins->dreg, 0);
4176                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 2);
4177                         ppc_li (code, ins->dreg, 1);
4178                         break;
4179                 case OP_CLT:
4180                 case OP_CLT_UN:
4181                 case OP_ICLT:
4182                 case OP_ICLT_UN:
4183                 CASE_PPC64 (OP_LCLT)
4184                 CASE_PPC64 (OP_LCLT_UN)
4185                         ppc_li (code, ins->dreg, 1);
4186                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_LT, 2);
4187                         ppc_li (code, ins->dreg, 0);
4188                         break;
4189                 case OP_CGT:
4190                 case OP_CGT_UN:
4191                 case OP_ICGT:
4192                 case OP_ICGT_UN:
4193                 CASE_PPC64 (OP_LCGT)
4194                 CASE_PPC64 (OP_LCGT_UN)
4195                         ppc_li (code, ins->dreg, 1);
4196                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_GT, 2);
4197                         ppc_li (code, ins->dreg, 0);
4198                         break;
4199                 case OP_COND_EXC_EQ:
4200                 case OP_COND_EXC_NE_UN:
4201                 case OP_COND_EXC_LT:
4202                 case OP_COND_EXC_LT_UN:
4203                 case OP_COND_EXC_GT:
4204                 case OP_COND_EXC_GT_UN:
4205                 case OP_COND_EXC_GE:
4206                 case OP_COND_EXC_GE_UN:
4207                 case OP_COND_EXC_LE:
4208                 case OP_COND_EXC_LE_UN:
4209                         EMIT_COND_SYSTEM_EXCEPTION (ins->opcode - OP_COND_EXC_EQ, ins->inst_p1);
4210                         break;
4211                 case OP_COND_EXC_IEQ:
4212                 case OP_COND_EXC_INE_UN:
4213                 case OP_COND_EXC_ILT:
4214                 case OP_COND_EXC_ILT_UN:
4215                 case OP_COND_EXC_IGT:
4216                 case OP_COND_EXC_IGT_UN:
4217                 case OP_COND_EXC_IGE:
4218                 case OP_COND_EXC_IGE_UN:
4219                 case OP_COND_EXC_ILE:
4220                 case OP_COND_EXC_ILE_UN:
4221                         EMIT_COND_SYSTEM_EXCEPTION (ins->opcode - OP_COND_EXC_IEQ, ins->inst_p1);
4222                         break;
4223                 case OP_IBEQ:
4224                 case OP_IBNE_UN:
4225                 case OP_IBLT:
4226                 case OP_IBLT_UN:
4227                 case OP_IBGT:
4228                 case OP_IBGT_UN:
4229                 case OP_IBGE:
4230                 case OP_IBGE_UN:
4231                 case OP_IBLE:
4232                 case OP_IBLE_UN:
4233                         EMIT_COND_BRANCH (ins, ins->opcode - OP_IBEQ);
4234                         break;
4235
4236                 /* floating point opcodes */
4237                 case OP_R8CONST:
4238                         g_assert (cfg->compile_aot);
4239
4240                         /* FIXME: Optimize this */
4241                         ppc_bl (code, 1);
4242                         ppc_mflr (code, ppc_r11);
4243                         ppc_b (code, 3);
4244                         *(double*)code = *(double*)ins->inst_p0;
4245                         code += 8;
4246                         ppc_lfd (code, ins->dreg, 8, ppc_r11);
4247                         break;
4248                 case OP_R4CONST:
4249                         g_assert_not_reached ();
4250                         break;
4251                 case OP_STORER8_MEMBASE_REG:
4252                         if (ppc_is_imm16 (ins->inst_offset)) {
4253                                 ppc_stfd (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
4254                         } else {
4255                                 if (ppc_is_imm32 (ins->inst_offset)) {
4256                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
4257                                         ppc_stfd (code, ins->sreg1, ins->inst_offset, ppc_r12);
4258                                 } else {
4259                                         ppc_load (code, ppc_r0, ins->inst_offset);
4260                                         ppc_stfdx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
4261                                 }
4262                         }
4263                         break;
4264                 case OP_LOADR8_MEMBASE:
4265                         if (ppc_is_imm16 (ins->inst_offset)) {
4266                                 ppc_lfd (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
4267                         } else {
4268                                 if (ppc_is_imm32 (ins->inst_offset)) {
4269                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
4270                                         ppc_lfd (code, ins->dreg, ins->inst_offset, ppc_r12);
4271                                 } else {
4272                                         ppc_load (code, ppc_r0, ins->inst_offset);
4273                                         ppc_lfdx (code, ins->dreg, ins->inst_destbasereg, ppc_r0);
4274                                 }
4275                         }
4276                         break;
4277                 case OP_STORER4_MEMBASE_REG:
4278                         ppc_frsp (code, ins->sreg1, ins->sreg1);
4279                         if (ppc_is_imm16 (ins->inst_offset)) {
4280                                 ppc_stfs (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
4281                         } else {
4282                                 if (ppc_is_imm32 (ins->inst_offset)) {
4283                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
4284                                         ppc_stfs (code, ins->sreg1, ins->inst_offset, ppc_r12);
4285                                 } else {
4286                                         ppc_load (code, ppc_r0, ins->inst_offset);
4287                                         ppc_stfsx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
4288                                 }
4289                         }
4290                         break;
4291                 case OP_LOADR4_MEMBASE:
4292                         if (ppc_is_imm16 (ins->inst_offset)) {
4293                                 ppc_lfs (code, ins->dreg, ins->inst_offset, ins->inst_basereg);
4294                         } else {
4295                                 if (ppc_is_imm32 (ins->inst_offset)) {
4296                                         ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset));
4297                                         ppc_lfs (code, ins->dreg, ins->inst_offset, ppc_r12);
4298                                 } else {
4299                                         ppc_load (code, ppc_r0, ins->inst_offset);
4300                                         ppc_lfsx (code, ins->dreg, ins->inst_destbasereg, ppc_r0);
4301                                 }
4302                         }
4303                         break;
4304                 case OP_LOADR4_MEMINDEX:
4305                         ppc_lfsx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
4306                         break;
4307                 case OP_LOADR8_MEMINDEX:
4308                         ppc_lfdx (code, ins->dreg, ins->inst_basereg, ins->sreg2);
4309                         break;
4310                 case OP_STORER4_MEMINDEX:
4311                         ppc_frsp (code, ins->sreg1, ins->sreg1);
4312                         ppc_stfsx (code, ins->sreg1, ins->inst_destbasereg, ins->sreg2);
4313                         break;
4314                 case OP_STORER8_MEMINDEX:
4315                         ppc_stfdx (code, ins->sreg1, ins->inst_destbasereg, ins->sreg2);
4316                         break;
4317                 case CEE_CONV_R_UN:
4318                 case CEE_CONV_R4: /* FIXME: change precision */
4319                 case CEE_CONV_R8:
4320                         g_assert_not_reached ();
4321                 case OP_FCONV_TO_I1:
4322                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, TRUE);
4323                         break;
4324                 case OP_FCONV_TO_U1:
4325                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, FALSE);
4326                         break;
4327                 case OP_FCONV_TO_I2:
4328                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, TRUE);
4329                         break;
4330                 case OP_FCONV_TO_U2:
4331                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 2, FALSE);
4332                         break;
4333                 case OP_FCONV_TO_I4:
4334                 case OP_FCONV_TO_I:
4335                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, TRUE);
4336                         break;
4337                 case OP_FCONV_TO_U4:
4338                 case OP_FCONV_TO_U:
4339                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 4, FALSE);
4340                         break;
4341                 case OP_LCONV_TO_R_UN:
4342                         g_assert_not_reached ();
4343                         /* Implemented as helper calls */
4344                         break;
4345                 case OP_LCONV_TO_OVF_I4_2:
4346                 case OP_LCONV_TO_OVF_I: {
4347 #ifdef __mono_ppc64__
4348                         NOT_IMPLEMENTED;
4349 #else
4350                         guint8 *negative_branch, *msword_positive_branch, *msword_negative_branch, *ovf_ex_target;
4351                         // Check if its negative
4352                         ppc_cmpi (code, 0, 0, ins->sreg1, 0);
4353                         negative_branch = code;
4354                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_LT, 0);
4355                         // Its positive msword == 0
4356                         ppc_cmpi (code, 0, 0, ins->sreg2, 0);
4357                         msword_positive_branch = code;
4358                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0);
4359
4360                         ovf_ex_target = code;
4361                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_ALWAYS, 0, "OverflowException");
4362                         // Negative
4363                         ppc_patch (negative_branch, code);
4364                         ppc_cmpi (code, 0, 0, ins->sreg2, -1);
4365                         msword_negative_branch = code;
4366                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
4367                         ppc_patch (msword_negative_branch, ovf_ex_target);
4368
4369                         ppc_patch (msword_positive_branch, code);
4370                         if (ins->dreg != ins->sreg1)
4371                                 ppc_mr (code, ins->dreg, ins->sreg1);
4372                         break;
4373 #endif
4374                 }
4375                 case OP_SQRT:
4376                         ppc_fsqrtd (code, ins->dreg, ins->sreg1);
4377                         break;
4378                 case OP_FADD:
4379                         ppc_fadd (code, ins->dreg, ins->sreg1, ins->sreg2);
4380                         break;
4381                 case OP_FSUB:
4382                         ppc_fsub (code, ins->dreg, ins->sreg1, ins->sreg2);
4383                         break;
4384                 case OP_FMUL:
4385                         ppc_fmul (code, ins->dreg, ins->sreg1, ins->sreg2);
4386                         break;
4387                 case OP_FDIV:
4388                         ppc_fdiv (code, ins->dreg, ins->sreg1, ins->sreg2);
4389                         break;
4390                 case OP_FNEG:
4391                         ppc_fneg (code, ins->dreg, ins->sreg1);
4392                         break;
4393                 case OP_FREM:
4394                         /* emulated */
4395                         g_assert_not_reached ();
4396                         break;
4397                 case OP_FCOMPARE:
4398                         ppc_fcmpu (code, 0, ins->sreg1, ins->sreg2);
4399                         break;
4400                 case OP_FCEQ:
4401                         ppc_fcmpo (code, 0, ins->sreg1, ins->sreg2);
4402                         ppc_li (code, ins->dreg, 0);
4403                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 2);
4404                         ppc_li (code, ins->dreg, 1);
4405                         break;
4406                 case OP_FCLT:
4407                         ppc_fcmpo (code, 0, ins->sreg1, ins->sreg2);
4408                         ppc_li (code, ins->dreg, 1);
4409                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_LT, 2);
4410                         ppc_li (code, ins->dreg, 0);
4411                         break;
4412                 case OP_FCLT_UN:
4413                         ppc_fcmpu (code, 0, ins->sreg1, ins->sreg2);
4414                         ppc_li (code, ins->dreg, 1);
4415                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 3);
4416                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_LT, 2);
4417                         ppc_li (code, ins->dreg, 0);
4418                         break;
4419                 case OP_FCGT:
4420                         ppc_fcmpo (code, 0, ins->sreg1, ins->sreg2);
4421                         ppc_li (code, ins->dreg, 1);
4422                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_GT, 2);
4423                         ppc_li (code, ins->dreg, 0);
4424                         break;
4425                 case OP_FCGT_UN:
4426                         ppc_fcmpu (code, 0, ins->sreg1, ins->sreg2);
4427                         ppc_li (code, ins->dreg, 1);
4428                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 3);
4429                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_GT, 2);
4430                         ppc_li (code, ins->dreg, 0);
4431                         break;
4432                 case OP_FBEQ:
4433                         EMIT_COND_BRANCH (ins, CEE_BEQ - CEE_BEQ);
4434                         break;
4435                 case OP_FBNE_UN:
4436                         EMIT_COND_BRANCH (ins, CEE_BNE_UN - CEE_BEQ);
4437                         break;
4438                 case OP_FBLT:
4439                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 2);
4440                         EMIT_COND_BRANCH (ins, CEE_BLT - CEE_BEQ);
4441                         break;
4442                 case OP_FBLT_UN:
4443                         EMIT_COND_BRANCH_FLAGS (ins, PPC_BR_TRUE, PPC_BR_SO);
4444                         EMIT_COND_BRANCH (ins, CEE_BLT_UN - CEE_BEQ);
4445                         break;
4446                 case OP_FBGT:
4447                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 2);
4448                         EMIT_COND_BRANCH (ins, CEE_BGT - CEE_BEQ);
4449                         break;
4450                 case OP_FBGT_UN:
4451                         EMIT_COND_BRANCH_FLAGS (ins, PPC_BR_TRUE, PPC_BR_SO);
4452                         EMIT_COND_BRANCH (ins, CEE_BGT_UN - CEE_BEQ);
4453                         break;
4454                 case OP_FBGE:
4455                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 2);
4456                         EMIT_COND_BRANCH (ins, CEE_BGE - CEE_BEQ);
4457                         break;
4458                 case OP_FBGE_UN:
4459                         EMIT_COND_BRANCH (ins, CEE_BGE_UN - CEE_BEQ);
4460                         break;
4461                 case OP_FBLE:
4462                         ppc_bc (code, PPC_BR_TRUE, PPC_BR_SO, 2);
4463                         EMIT_COND_BRANCH (ins, CEE_BLE - CEE_BEQ);
4464                         break;
4465                 case OP_FBLE_UN:
4466                         EMIT_COND_BRANCH (ins, CEE_BLE_UN - CEE_BEQ);
4467                         break;
4468                 case OP_CKFINITE:
4469                         g_assert_not_reached ();
4470                 case OP_CHECK_FINITE: {
4471                         ppc_rlwinm (code, ins->sreg1, ins->sreg1, 0, 1, 31);
4472                         ppc_addis (code, ins->sreg1, ins->sreg1, -32752);
4473                         ppc_rlwinmd (code, ins->sreg1, ins->sreg1, 1, 31, 31);
4474                         EMIT_COND_SYSTEM_EXCEPTION (CEE_BEQ - CEE_BEQ, "ArithmeticException");
4475                         break;
4476                 case OP_JUMP_TABLE:
4477                         mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
4478 #ifdef __mono_ppc64__
4479                         ppc_load_sequence (code, ins->dreg, (guint64)0x0f0f0f0f0f0f0f0fLL);
4480 #else
4481                         ppc_load_sequence (code, ins->dreg, (gulong)0x0f0f0f0fL);
4482 #endif
4483                         break;
4484                 }
4485
4486 #ifdef __mono_ppc64__
4487                 case OP_ICONV_TO_I4:
4488                 case OP_SEXT_I4:
4489                         ppc_extsw (code, ins->dreg, ins->sreg1);
4490                         break;
4491                 case OP_ICONV_TO_U4:
4492                 case OP_ZEXT_I4:
4493                         ppc_clrldi (code, ins->dreg, ins->sreg1, 32);
4494                         break;
4495                 case OP_ICONV_TO_R4:
4496                 case OP_ICONV_TO_R8:
4497                 case OP_LCONV_TO_R4:
4498                 case OP_LCONV_TO_R8: {
4499                         int tmp;
4500                         if (ins->opcode == OP_ICONV_TO_R4 || ins->opcode == OP_ICONV_TO_R8) {
4501                                 ppc_extsw (code, ppc_r0, ins->sreg1);
4502                                 tmp = ppc_r0;
4503                         } else {
4504                                 tmp = ins->sreg1;
4505                         }
4506                         if (cpu_hw_caps & PPC_MOVE_FPR_GPR) {
4507                                 ppc_mffgpr (code, ins->dreg, tmp);
4508                         } else {
4509                                 ppc_str (code, tmp, -8, ppc_r1);
4510                                 ppc_lfd (code, ins->dreg, -8, ppc_r1);
4511                         }
4512                         ppc_fcfid (code, ins->dreg, ins->dreg);
4513                         if (ins->opcode == OP_ICONV_TO_R4 || ins->opcode == OP_LCONV_TO_R4)
4514                                 ppc_frsp (code, ins->dreg, ins->dreg);
4515                         break;
4516                 }
4517                 case OP_LSHR:
4518                         ppc_srad (code, ins->dreg, ins->sreg1, ins->sreg2);
4519                         break;
4520                 case OP_LSHR_UN:
4521                         ppc_srd (code, ins->dreg, ins->sreg1, ins->sreg2);
4522                         break;
4523                 case OP_COND_EXC_C:
4524                         /* check XER [0-3] (SO, OV, CA): we can't use mcrxr
4525                          */
4526                         ppc_mfspr (code, ppc_r0, ppc_xer);
4527                         ppc_andisd (code, ppc_r0, ppc_r0, (1 << 13)); /* CA */
4528                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, ins->inst_p1);
4529                         break;
4530                 case OP_COND_EXC_OV:
4531                         ppc_mfspr (code, ppc_r0, ppc_xer);
4532                         ppc_andisd (code, ppc_r0, ppc_r0, (1 << 14)); /* OV */
4533                         EMIT_COND_SYSTEM_EXCEPTION_FLAGS (PPC_BR_FALSE, PPC_BR_EQ, ins->inst_p1);
4534                         break;
4535                 case OP_LBEQ:
4536                 case OP_LBNE_UN:
4537                 case OP_LBLT:
4538                 case OP_LBLT_UN:
4539                 case OP_LBGT:
4540                 case OP_LBGT_UN:
4541                 case OP_LBGE:
4542                 case OP_LBGE_UN:
4543                 case OP_LBLE:
4544                 case OP_LBLE_UN:
4545                         EMIT_COND_BRANCH (ins, ins->opcode - OP_LBEQ);
4546                         break;
4547                 case OP_FCONV_TO_I8:
4548                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 8, TRUE);
4549                         break;
4550                 case OP_FCONV_TO_U8:
4551                         code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 8, FALSE);
4552                         break;
4553                 case OP_STOREI4_MEMBASE_REG:
4554                         if (ppc_is_imm16 (ins->inst_offset)) {
4555                                 ppc_stw (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg);
4556                         } else {
4557                                 ppc_load (code, ppc_r0, ins->inst_offset);
4558                                 ppc_stwx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0);
4559                         }
4560                         break;
4561                 case OP_STOREI4_MEMINDEX:
4562                         ppc_stwx (code, ins->sreg1, ins->sreg2, ins->inst_destbasereg);
4563                         break;
4564                 case OP_ISHR_IMM:
4565                         ppc_srawi (code, ins->dreg, ins->sreg1, (ins->inst_imm & 0x1f));
4566                         break;
4567                 case OP_ISHR_UN_IMM:
4568                         if (ins->inst_imm & 0x1f)
4569                                 ppc_srwi (code, ins->dreg, ins->sreg1, (ins->inst_imm & 0x1f));
4570                         else
4571                                 ppc_mr (code, ins->dreg, ins->sreg1);
4572                         break;
4573                 case OP_ATOMIC_ADD_NEW_I4:
4574                 case OP_ATOMIC_ADD_NEW_I8: {
4575                         guint8 *loop = code, *branch;
4576                         g_assert (ins->inst_offset == 0);
4577                         if (ins->opcode == OP_ATOMIC_ADD_NEW_I4)
4578                                 ppc_lwarx (code, ppc_r0, 0, ins->inst_basereg);
4579                         else
4580                                 ppc_ldarx (code, ppc_r0, 0, ins->inst_basereg);
4581                         ppc_add (code, ppc_r0, ppc_r0, ins->sreg2);
4582                         if (ins->opcode == OP_ATOMIC_ADD_NEW_I4)
4583                                 ppc_stwcxd (code, ppc_r0, 0, ins->inst_basereg);
4584                         else
4585                                 ppc_stdcxd (code, ppc_r0, 0, ins->inst_basereg);
4586                         branch = code;
4587                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
4588                         ppc_patch (branch, loop);
4589                         ppc_mr (code, ins->dreg, ppc_r0);
4590                         break;
4591                 }
4592 #else
4593                 case OP_ICONV_TO_R4:
4594                 case OP_ICONV_TO_R8: {
4595                         if (cpu_hw_caps & PPC_ISA_64) {
4596                                 ppc_srawi(code, ppc_r0, ins->sreg1, 31);
4597                                 ppc_stw (code, ppc_r0, -8, ppc_r1);
4598                                 ppc_stw (code, ins->sreg1, -4, ppc_r1);
4599                                 ppc_lfd (code, ins->dreg, -8, ppc_r1);
4600                                 ppc_fcfid (code, ins->dreg, ins->dreg);
4601                                 if (ins->opcode == OP_ICONV_TO_R4)
4602                                         ppc_frsp (code, ins->dreg, ins->dreg);
4603                                 }
4604                         break;
4605                 }
4606 #endif
4607                 case OP_ATOMIC_CAS_I4:
4608                 CASE_PPC64 (OP_ATOMIC_CAS_I8) {
4609                         int location = ins->sreg1;
4610                         int value = ins->sreg2;
4611                         int comparand = ins->sreg3;
4612                         guint8 *start, *not_equal, *lost_reservation;
4613
4614                         start = code;
4615                         if (ins->opcode == OP_ATOMIC_CAS_I4)
4616                                 ppc_lwarx (code, ppc_r0, 0, location);
4617 #ifdef __mono_ppc64__
4618                         else
4619                                 ppc_ldarx (code, ppc_r0, 0, location);
4620 #endif
4621                         ppc_cmp (code, 0, ins->opcode == OP_ATOMIC_CAS_I4 ? 0 : 1, ppc_r0, comparand);
4622
4623                         not_equal = code;
4624                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
4625                         if (ins->opcode == OP_ATOMIC_CAS_I4)
4626                                 ppc_stwcxd (code, value, 0, location);
4627 #ifdef __mono_ppc64__
4628                         else
4629                                 ppc_stdcxd (code, value, 0, location);
4630 #endif
4631
4632                         lost_reservation = code;
4633                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
4634                         ppc_patch (lost_reservation, start);
4635
4636                         ppc_patch (not_equal, code);
4637                         ppc_mr (code, ins->dreg, ppc_r0);
4638                         break;
4639                 }
4640
4641                 default:
4642                         g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
4643                         g_assert_not_reached ();
4644                 }
4645
4646                 if ((cfg->opt & MONO_OPT_BRANCH) && ((code - cfg->native_code - offset) > max_len)) {
4647                         g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %ld)",
4648                                    mono_inst_name (ins->opcode), max_len, (glong)(code - cfg->native_code - offset));
4649                         g_assert_not_reached ();
4650                 }
4651
4652                 cpos += max_len;
4653
4654                 last_ins = ins;
4655                 last_offset = offset;
4656         }
4657
4658         cfg->code_len = code - cfg->native_code;
4659 }
4660 #endif /* !DISABLE_JIT */
4661
4662 void
4663 mono_arch_register_lowlevel_calls (void)
4664 {
4665         /* The signature doesn't matter */
4666         mono_register_jit_icall (mono_ppc_throw_exception, "mono_ppc_throw_exception", mono_create_icall_signature ("void"), TRUE);
4667 }
4668
4669 #ifdef __mono_ppc64__
4670 #define patch_load_sequence(ip,val) do {\
4671                 guint16 *__load = (guint16*)(ip);       \
4672                 g_assert (sizeof (val) == sizeof (gsize)); \
4673                 __load [1] = (((guint64)(gsize)(val)) >> 48) & 0xffff;  \
4674                 __load [3] = (((guint64)(gsize)(val)) >> 32) & 0xffff;  \
4675                 __load [7] = (((guint64)(gsize)(val)) >> 16) & 0xffff;  \
4676                 __load [9] =  ((guint64)(gsize)(val))        & 0xffff;  \
4677         } while (0)
4678 #else
4679 #define patch_load_sequence(ip,val) do {\
4680                 guint16 *__lis_ori = (guint16*)(ip);    \
4681                 __lis_ori [1] = (((gulong)(val)) >> 16) & 0xffff;       \
4682                 __lis_ori [3] = ((gulong)(val)) & 0xffff;       \
4683         } while (0)
4684 #endif
4685
4686 #ifndef DISABLE_JIT
4687 void
4688 mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, MonoJumpInfo *ji, gboolean run_cctors)
4689 {
4690         MonoJumpInfo *patch_info;
4691         gboolean compile_aot = !run_cctors;
4692
4693         for (patch_info = ji; patch_info; patch_info = patch_info->next) {
4694                 unsigned char *ip = patch_info->ip.i + code;
4695                 unsigned char *target;
4696                 gboolean is_fd = FALSE;
4697
4698                 target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
4699
4700                 if (compile_aot) {
4701                         switch (patch_info->type) {
4702                         case MONO_PATCH_INFO_BB:
4703                         case MONO_PATCH_INFO_LABEL:
4704                                 break;
4705                         default:
4706                                 /* No need to patch these */
4707                                 continue;
4708                         }
4709                 }
4710
4711                 switch (patch_info->type) {
4712                 case MONO_PATCH_INFO_IP:
4713                         patch_load_sequence (ip, ip);
4714                         continue;
4715                 case MONO_PATCH_INFO_METHOD_REL:
4716                         g_assert_not_reached ();
4717                         *((gpointer *)(ip)) = code + patch_info->data.offset;
4718                         continue;
4719                 case MONO_PATCH_INFO_SWITCH: {
4720                         gpointer *table = (gpointer *)patch_info->data.table->table;
4721                         int i;
4722
4723                         patch_load_sequence (ip, table);
4724
4725                         for (i = 0; i < patch_info->data.table->table_size; i++) {
4726                                 table [i] = (glong)patch_info->data.table->table [i] + code;
4727                         }
4728                         /* we put into the table the absolute address, no need for ppc_patch in this case */
4729                         continue;
4730                 }
4731                 case MONO_PATCH_INFO_METHODCONST:
4732                 case MONO_PATCH_INFO_CLASS:
4733                 case MONO_PATCH_INFO_IMAGE:
4734                 case MONO_PATCH_INFO_FIELD:
4735                 case MONO_PATCH_INFO_VTABLE:
4736                 case MONO_PATCH_INFO_IID:
4737                 case MONO_PATCH_INFO_SFLDA:
4738                 case MONO_PATCH_INFO_LDSTR:
4739                 case MONO_PATCH_INFO_TYPE_FROM_HANDLE:
4740                 case MONO_PATCH_INFO_LDTOKEN:
4741                         /* from OP_AOTCONST : lis + ori */
4742                         patch_load_sequence (ip, target);
4743                         continue;
4744                 case MONO_PATCH_INFO_R4:
4745                 case MONO_PATCH_INFO_R8:
4746                         g_assert_not_reached ();
4747                         *((gconstpointer *)(ip + 2)) = patch_info->data.target;
4748                         continue;
4749                 case MONO_PATCH_INFO_EXC_NAME:
4750                         g_assert_not_reached ();
4751                         *((gconstpointer *)(ip + 1)) = patch_info->data.name;
4752                         continue;
4753                 case MONO_PATCH_INFO_NONE:
4754                 case MONO_PATCH_INFO_BB_OVF:
4755                 case MONO_PATCH_INFO_EXC_OVF:
4756                         /* everything is dealt with at epilog output time */
4757                         continue;
4758 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
4759                 case MONO_PATCH_INFO_INTERNAL_METHOD:
4760                 case MONO_PATCH_INFO_ABS:
4761                 case MONO_PATCH_INFO_CLASS_INIT:
4762                 case MONO_PATCH_INFO_RGCTX_FETCH:
4763                         is_fd = TRUE;
4764                         break;
4765 #endif
4766                 default:
4767                         break;
4768                 }
4769                 ppc_patch_full (ip, target, is_fd);
4770         }
4771 }
4772
4773 /*
4774  * Emit code to save the registers in used_int_regs or the registers in the MonoLMF
4775  * structure at positive offset pos from register base_reg. pos is guaranteed to fit into
4776  * the instruction offset immediate for all the registers.
4777  */
4778 static guint8*
4779 save_registers (MonoCompile *cfg, guint8* code, int pos, int base_reg, gboolean save_lmf, guint32 used_int_regs, int cfa_offset)
4780 {
4781         int i;
4782         if (!save_lmf) {
4783                 for (i = 13; i <= 31; i++) {
4784                         if (used_int_regs & (1 << i)) {
4785                                 ppc_str (code, i, pos, base_reg);
4786                                 mono_emit_unwind_op_offset (cfg, code, i, pos - cfa_offset);
4787                                 pos += sizeof (mgreg_t);
4788                         }
4789                 }
4790         } else {
4791                 /* pos is the start of the MonoLMF structure */
4792                 int offset = pos + G_STRUCT_OFFSET (MonoLMF, iregs);
4793                 for (i = 13; i <= 31; i++) {
4794                         ppc_str (code, i, offset, base_reg);
4795                         mono_emit_unwind_op_offset (cfg, code, i, offset - cfa_offset);
4796                         offset += sizeof (mgreg_t);
4797                 }
4798                 offset = pos + G_STRUCT_OFFSET (MonoLMF, fregs);
4799                 for (i = 14; i < 32; i++) {
4800                         ppc_stfd (code, i, offset, base_reg);
4801                         offset += sizeof (gdouble);
4802                 }
4803         }
4804         return code;
4805 }
4806
4807 /*
4808  * Stack frame layout:
4809  *
4810  *   ------------------- sp
4811  *      MonoLMF structure or saved registers
4812  *   -------------------
4813  *      spilled regs
4814  *   -------------------
4815  *      locals
4816  *   -------------------
4817  *      optional 8 bytes for tracing
4818  *   -------------------
4819  *      param area             size is cfg->param_area
4820  *   -------------------
4821  *      linkage area           size is PPC_STACK_PARAM_OFFSET
4822  *   ------------------- sp
4823  *      red zone
4824  */
4825 guint8 *
4826 mono_arch_emit_prolog (MonoCompile *cfg)
4827 {
4828         MonoMethod *method = cfg->method;
4829         MonoBasicBlock *bb;
4830         MonoMethodSignature *sig;
4831         MonoInst *inst;
4832         long alloc_size, pos, max_offset, cfa_offset;
4833         int i;
4834         guint8 *code;
4835         CallInfo *cinfo;
4836         int tracing = 0;
4837         int lmf_offset = 0;
4838         int tailcall_struct_index;
4839
4840         if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
4841                 tracing = 1;
4842
4843         sig = mono_method_signature (method);
4844         cfg->code_size = MONO_PPC_32_64_CASE (260, 384) + sig->param_count * 20;
4845         code = cfg->native_code = g_malloc (cfg->code_size);
4846
4847         cfa_offset = 0;
4848
4849         /* We currently emit unwind info for aot, but don't use it */
4850         mono_emit_unwind_op_def_cfa (cfg, code, ppc_r1, 0);
4851
4852         if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
4853                 ppc_mflr (code, ppc_r0);
4854                 ppc_str (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
4855                 mono_emit_unwind_op_offset (cfg, code, ppc_lr, PPC_RET_ADDR_OFFSET);
4856         }
4857
4858         alloc_size = cfg->stack_offset;
4859         pos = 0;
4860
4861         if (!method->save_lmf) {
4862                 for (i = 31; i >= 13; --i) {
4863                         if (cfg->used_int_regs & (1 << i)) {
4864                                 pos += sizeof (mgreg_t);
4865                         }
4866                 }
4867         } else {
4868                 pos += sizeof (MonoLMF);
4869                 lmf_offset = pos;
4870         }
4871         alloc_size += pos;
4872         // align to MONO_ARCH_FRAME_ALIGNMENT bytes
4873         if (alloc_size & (MONO_ARCH_FRAME_ALIGNMENT - 1)) {
4874                 alloc_size += MONO_ARCH_FRAME_ALIGNMENT - 1;
4875                 alloc_size &= ~(MONO_ARCH_FRAME_ALIGNMENT - 1);
4876         }
4877
4878         cfg->stack_usage = alloc_size;
4879         g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
4880         if (alloc_size) {
4881                 if (ppc_is_imm16 (-alloc_size)) {
4882                         ppc_str_update (code, ppc_sp, -alloc_size, ppc_sp);
4883                         cfa_offset = alloc_size;
4884                         mono_emit_unwind_op_def_cfa_offset (cfg, code, alloc_size);
4885                         code = save_registers (cfg, code, alloc_size - pos, ppc_sp, method->save_lmf, cfg->used_int_regs, cfa_offset);
4886                 } else {
4887                         if (pos)
4888                                 ppc_addi (code, ppc_r11, ppc_sp, -pos);
4889                         ppc_load (code, ppc_r0, -alloc_size);
4890                         ppc_str_update_indexed (code, ppc_sp, ppc_sp, ppc_r0);
4891                         cfa_offset = alloc_size;
4892                         mono_emit_unwind_op_def_cfa_offset (cfg, code, alloc_size);
4893                         code = save_registers (cfg, code, 0, ppc_r11, method->save_lmf, cfg->used_int_regs, cfa_offset);
4894                 }
4895         }
4896         if (cfg->frame_reg != ppc_sp) {
4897                 ppc_mr (code, cfg->frame_reg, ppc_sp);
4898                 mono_emit_unwind_op_def_cfa_reg (cfg, code, cfg->frame_reg);
4899         }
4900
4901         /* store runtime generic context */
4902         if (cfg->rgctx_var) {
4903                 g_assert (cfg->rgctx_var->opcode == OP_REGOFFSET &&
4904                                 (cfg->rgctx_var->inst_basereg == ppc_r1 || cfg->rgctx_var->inst_basereg == ppc_r31));
4905
4906                 ppc_stptr (code, MONO_ARCH_RGCTX_REG, cfg->rgctx_var->inst_offset, cfg->rgctx_var->inst_basereg);
4907         }
4908
4909         /* compute max_offset in order to use short forward jumps
4910          * we always do it on ppc because the immediate displacement
4911          * for jumps is too small
4912          */
4913         max_offset = 0;
4914         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4915                 MonoInst *ins;
4916                 bb->max_offset = max_offset;
4917
4918                 if (cfg->prof_options & MONO_PROFILE_COVERAGE)
4919                         max_offset += 6;
4920
4921                 MONO_BB_FOR_EACH_INS (bb, ins)
4922                         max_offset += ins_native_length (cfg, ins);
4923         }
4924
4925         /* load arguments allocated to register from the stack */
4926         pos = 0;
4927
4928         cinfo = calculate_sizes (sig, sig->pinvoke);
4929
4930         if (MONO_TYPE_ISSTRUCT (sig->ret)) {
4931                 ArgInfo *ainfo = &cinfo->ret;
4932
4933                 inst = cfg->vret_addr;
4934                 g_assert (inst);
4935
4936                 if (ppc_is_imm16 (inst->inst_offset)) {
4937                         ppc_stptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
4938                 } else {
4939                         ppc_load (code, ppc_r11, inst->inst_offset);
4940                         ppc_stptr_indexed (code, ainfo->reg, ppc_r11, inst->inst_basereg);
4941                 }
4942         }
4943
4944         tailcall_struct_index = 0;
4945         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
4946                 ArgInfo *ainfo = cinfo->args + i;
4947                 inst = cfg->args [pos];
4948
4949                 if (cfg->verbose_level > 2)
4950                         g_print ("Saving argument %d (type: %d)\n", i, ainfo->regtype);
4951                 if (inst->opcode == OP_REGVAR) {
4952                         if (ainfo->regtype == RegTypeGeneral)
4953                                 ppc_mr (code, inst->dreg, ainfo->reg);
4954                         else if (ainfo->regtype == RegTypeFP)
4955                                 ppc_fmr (code, inst->dreg, ainfo->reg);
4956                         else if (ainfo->regtype == RegTypeBase) {
4957                                 ppc_ldr (code, ppc_r11, 0, ppc_sp);
4958                                 ppc_ldptr (code, inst->dreg, ainfo->offset, ppc_r11);
4959                         } else
4960                                 g_assert_not_reached ();
4961
4962                         if (cfg->verbose_level > 2)
4963                                 g_print ("Argument %ld assigned to register %s\n", pos, mono_arch_regname (inst->dreg));
4964                 } else {
4965                         /* the argument should be put on the stack: FIXME handle size != word  */
4966                         if (ainfo->regtype == RegTypeGeneral) {
4967                                 switch (ainfo->size) {
4968                                 case 1:
4969                                         if (ppc_is_imm16 (inst->inst_offset)) {
4970                                                 ppc_stb (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
4971                                         } else {
4972                                                 if (ppc_is_imm32 (inst->inst_offset)) {
4973                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
4974                                                         ppc_stb (code, ainfo->reg, ppc_r11, inst->inst_offset);
4975                                                 } else {
4976                                                         ppc_load (code, ppc_r11, inst->inst_offset);
4977                                                         ppc_stbx (code, ainfo->reg, inst->inst_basereg, ppc_r11);
4978                                                 }
4979                                         }
4980                                         break;
4981                                 case 2:
4982                                         if (ppc_is_imm16 (inst->inst_offset)) {
4983                                                 ppc_sth (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
4984                                         } else {
4985                                                 if (ppc_is_imm32 (inst->inst_offset)) {
4986                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
4987                                                         ppc_sth (code, ainfo->reg, ppc_r11, inst->inst_offset);
4988                                                 } else {
4989                                                         ppc_load (code, ppc_r11, inst->inst_offset);
4990                                                         ppc_sthx (code, ainfo->reg, inst->inst_basereg, ppc_r11);
4991                                                 }
4992                                         }
4993                                         break;
4994 #ifdef __mono_ppc64__
4995                                 case 4:
4996                                         if (ppc_is_imm16 (inst->inst_offset)) {
4997                                                 ppc_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
4998                                         } else {
4999                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5000                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5001                                                         ppc_stw (code, ainfo->reg, ppc_r11, inst->inst_offset);
5002                                                 } else {
5003                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5004                                                         ppc_stwx (code, ainfo->reg, inst->inst_basereg, ppc_r11);
5005                                                 }
5006                                         }
5007                                         break;
5008                                 case 8:
5009                                         if (ppc_is_imm16 (inst->inst_offset)) {
5010                                                 ppc_str (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
5011                                         } else {
5012                                                 ppc_load (code, ppc_r11, inst->inst_offset);
5013                                                 ppc_str_indexed (code, ainfo->reg, ppc_r11, inst->inst_basereg);
5014                                         }
5015                                         break;
5016 #else
5017                                 case 8:
5018                                         if (ppc_is_imm16 (inst->inst_offset + 4)) {
5019                                                 ppc_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
5020                                                 ppc_stw (code, ainfo->reg + 1, inst->inst_offset + 4, inst->inst_basereg);
5021                                         } else {
5022                                                 ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5023                                                 ppc_addi (code, ppc_r11, ppc_r11, inst->inst_offset);
5024                                                 ppc_stw (code, ainfo->reg, 0, ppc_r11);
5025                                                 ppc_stw (code, ainfo->reg + 1, 4, ppc_r11);
5026                                         }
5027                                         break;
5028 #endif
5029                                 default:
5030                                         if (ppc_is_imm16 (inst->inst_offset)) {
5031                                                 ppc_stptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
5032                                         } else {
5033                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5034                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5035                                                         ppc_stptr (code, ainfo->reg, ppc_r11, inst->inst_offset);
5036                                                 } else {
5037                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5038                                                         ppc_stptr_indexed (code, ainfo->reg, inst->inst_basereg, ppc_r11);
5039                                                 }
5040                                         }
5041                                         break;
5042                                 }
5043                         } else if (ainfo->regtype == RegTypeBase) {
5044                                 g_assert (ppc_is_imm16 (ainfo->offset));
5045                                 /* load the previous stack pointer in r11 */
5046                                 ppc_ldr (code, ppc_r11, 0, ppc_sp);
5047                                 ppc_ldptr (code, ppc_r0, ainfo->offset, ppc_r11);
5048                                 switch (ainfo->size) {
5049                                 case 1:
5050                                         if (ppc_is_imm16 (inst->inst_offset)) {
5051                                                 ppc_stb (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5052                                         } else {
5053                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5054                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5055                                                         ppc_stb (code, ppc_r0, ppc_r11, inst->inst_offset);
5056                                                 } else {
5057                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5058                                                         ppc_stbx (code, ppc_r0, inst->inst_basereg, ppc_r11);
5059                                                 }
5060                                         }
5061                                         break;
5062                                 case 2:
5063                                         if (ppc_is_imm16 (inst->inst_offset)) {
5064                                                 ppc_sth (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5065                                         } else {
5066                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5067                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5068                                                         ppc_sth (code, ppc_r0, ppc_r11, inst->inst_offset);
5069                                                 } else {
5070                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5071                                                         ppc_sthx (code, ppc_r0, inst->inst_basereg, ppc_r11);
5072                                                 }
5073                                         }
5074                                         break;
5075 #ifdef __mono_ppc64__
5076                                 case 4:
5077                                         if (ppc_is_imm16 (inst->inst_offset)) {
5078                                                 ppc_stw (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5079                                         } else {
5080                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5081                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5082                                                         ppc_stw (code, ppc_r0, ppc_r11, inst->inst_offset);
5083                                                 } else {
5084                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5085                                                         ppc_stwx (code, ppc_r0, inst->inst_basereg, ppc_r11);
5086                                                 }
5087                                         }
5088                                         break;
5089                                 case 8:
5090                                         if (ppc_is_imm16 (inst->inst_offset)) {
5091                                                 ppc_str (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5092                                         } else {
5093                                                 ppc_load (code, ppc_r11, inst->inst_offset);
5094                                                 ppc_str_indexed (code, ppc_r0, ppc_r11, inst->inst_basereg);
5095                                         }
5096                                         break;
5097 #else
5098                                 case 8:
5099                                         g_assert (ppc_is_imm16 (ainfo->offset + 4));
5100                                         if (ppc_is_imm16 (inst->inst_offset + 4)) {
5101                                                 ppc_stw (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5102                                                 ppc_lwz (code, ppc_r0, ainfo->offset + 4, ppc_r11);
5103                                                 ppc_stw (code, ppc_r0, inst->inst_offset + 4, inst->inst_basereg);
5104                                         } else {
5105                                                 /* use r12 to load the 2nd half of the long before we clobber r11.  */
5106                                                 ppc_lwz (code, ppc_r12, ainfo->offset + 4, ppc_r11);
5107                                                 ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5108                                                 ppc_addi (code, ppc_r11, ppc_r11, inst->inst_offset);
5109                                                 ppc_stw (code, ppc_r0, 0, ppc_r11);
5110                                                 ppc_stw (code, ppc_r12, 4, ppc_r11);
5111                                         }
5112                                         break;
5113 #endif
5114                                 default:
5115                                         if (ppc_is_imm16 (inst->inst_offset)) {
5116                                                 ppc_stptr (code, ppc_r0, inst->inst_offset, inst->inst_basereg);
5117                                         } else {
5118                                                 if (ppc_is_imm32 (inst->inst_offset)) {
5119                                                         ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset));
5120                                                         ppc_stptr (code, ppc_r0, ppc_r11, inst->inst_offset);
5121                                                 } else {
5122                                                         ppc_load (code, ppc_r11, inst->inst_offset);
5123                                                         ppc_stptr_indexed (code, ppc_r0, inst->inst_basereg, ppc_r11);
5124                                                 }
5125                                         }
5126                                         break;
5127                                 }
5128                         } else if (ainfo->regtype == RegTypeFP) {
5129                                 g_assert (ppc_is_imm16 (inst->inst_offset));
5130                                 if (ainfo->size == 8)
5131                                         ppc_stfd (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
5132                                 else if (ainfo->size == 4)
5133                                         ppc_stfs (code, ainfo->reg, inst->inst_offset, inst->inst_basereg);
5134                                 else
5135                                         g_assert_not_reached ();
5136                         } else if (ainfo->regtype == RegTypeStructByVal) {
5137                                 int doffset = inst->inst_offset;
5138                                 int soffset = 0;
5139                                 int cur_reg;
5140                                 int size = 0;
5141                                 g_assert (ppc_is_imm16 (inst->inst_offset));
5142                                 g_assert (ppc_is_imm16 (inst->inst_offset + ainfo->vtregs * sizeof (gpointer)));
5143                                 /* FIXME: what if there is no class? */
5144                                 if (sig->pinvoke && mono_class_from_mono_type (inst->inst_vtype))
5145                                         size = mono_class_native_size (mono_class_from_mono_type (inst->inst_vtype), NULL);
5146                                 for (cur_reg = 0; cur_reg < ainfo->vtregs; ++cur_reg) {
5147 #if __APPLE__
5148                                         /*
5149                                          * Darwin handles 1 and 2 byte
5150                                          * structs specially by
5151                                          * loading h/b into the arg
5152                                          * register.  Only done for
5153                                          * pinvokes.
5154                                          */
5155                                         if (size == 2)
5156                                                 ppc_sth (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg);
5157                                         else if (size == 1)
5158                                                 ppc_stb (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg);
5159                                         else
5160 #endif
5161                                         {
5162 #ifdef __mono_ppc64__
5163                                                 if (ainfo->bytes) {
5164                                                         g_assert (cur_reg == 0);
5165                                                         ppc_sldi (code, ppc_r0, ainfo->reg,
5166                                                                         (sizeof (gpointer) - ainfo->bytes) * 8);
5167                                                         ppc_stptr (code, ppc_r0, doffset, inst->inst_basereg);
5168                                                 } else
5169 #endif
5170                                                 {
5171                                                         ppc_stptr (code, ainfo->reg + cur_reg, doffset,
5172                                                                         inst->inst_basereg);
5173                                                 }
5174                                         }
5175                                         soffset += sizeof (gpointer);
5176                                         doffset += sizeof (gpointer);
5177                                 }
5178                                 if (ainfo->vtsize) {
5179                                         /* FIXME: we need to do the shifting here, too */
5180                                         if (ainfo->bytes)
5181                                                 NOT_IMPLEMENTED;
5182                                         /* load the previous stack pointer in r11 (r0 gets overwritten by the memcpy) */
5183                                         ppc_ldr (code, ppc_r11, 0, ppc_sp);
5184                                         if ((size & MONO_PPC_32_64_CASE (3, 7)) != 0) {
5185                                                 code = emit_memcpy (code, size - soffset,
5186                                                         inst->inst_basereg, doffset,
5187                                                         ppc_r11, ainfo->offset + soffset);
5188                                         } else {
5189                                                 code = emit_memcpy (code, ainfo->vtsize * sizeof (gpointer),
5190                                                         inst->inst_basereg, doffset,
5191                                                         ppc_r11, ainfo->offset + soffset);
5192                                         }
5193                                 }
5194                         } else if (ainfo->regtype == RegTypeStructByAddr) {
5195                                 /* if it was originally a RegTypeBase */
5196                                 if (ainfo->offset) {
5197                                         /* load the previous stack pointer in r11 */
5198                                         ppc_ldr (code, ppc_r11, 0, ppc_sp);
5199                                         ppc_ldptr (code, ppc_r11, ainfo->offset, ppc_r11);
5200                                 } else {
5201                                         ppc_mr (code, ppc_r11, ainfo->reg);
5202                                 }
5203
5204                                 if (cfg->tailcall_valuetype_addrs) {
5205                                         MonoInst *addr = cfg->tailcall_valuetype_addrs [tailcall_struct_index];
5206
5207                                         g_assert (ppc_is_imm16 (addr->inst_offset));
5208                                         ppc_stptr (code, ppc_r11, addr->inst_offset, addr->inst_basereg);
5209
5210                                         tailcall_struct_index++;
5211                                 }
5212
5213                                 g_assert (ppc_is_imm16 (inst->inst_offset));
5214                                 code = emit_memcpy (code, ainfo->vtsize, inst->inst_basereg, inst->inst_offset, ppc_r11, 0);
5215                                 /*g_print ("copy in %s: %d bytes from %d to offset: %d\n", method->name, ainfo->vtsize, ainfo->reg, inst->inst_offset);*/
5216                         } else
5217                                 g_assert_not_reached ();
5218                 }
5219                 pos++;
5220         }
5221
5222         if (method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
5223                 if (cfg->compile_aot)
5224                         /* AOT code is only used in the root domain */
5225                         ppc_load_ptr (code, ppc_r3, 0);
5226                 else
5227                         ppc_load_ptr (code, ppc_r3, cfg->domain);
5228                 mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, (gpointer)"mono_jit_thread_attach");
5229                 if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
5230                         ppc_load_func (code, ppc_r0, 0);
5231                         ppc_mtlr (code, ppc_r0);
5232                         ppc_blrl (code);
5233                 } else {
5234                         ppc_bl (code, 0);
5235                 }
5236         }
5237
5238         if (method->save_lmf) {
5239                 if (lmf_pthread_key != -1) {
5240                         emit_tls_access (code, ppc_r3, lmf_pthread_key);
5241                         if (tls_mode != TLS_MODE_NPTL && G_STRUCT_OFFSET (MonoJitTlsData, lmf))
5242                                 ppc_addi (code, ppc_r3, ppc_r3, G_STRUCT_OFFSET (MonoJitTlsData, lmf));
5243                 } else {
5244                         if (cfg->compile_aot) {
5245                                 /* Compute the got address which is needed by the PLT entry */
5246                                 code = mono_arch_emit_load_got_addr (cfg->native_code, code, cfg, NULL);
5247                         }
5248                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD,
5249                                      (gpointer)"mono_get_lmf_addr");
5250                         if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
5251                                 ppc_load_func (code, ppc_r0, 0);
5252                                 ppc_mtlr (code, ppc_r0);
5253                                 ppc_blrl (code);
5254                         } else {
5255                                 ppc_bl (code, 0);
5256                         }
5257                 }
5258                 /* we build the MonoLMF structure on the stack - see mini-ppc.h */
5259                 /* lmf_offset is the offset from the previous stack pointer,
5260                  * alloc_size is the total stack space allocated, so the offset
5261                  * of MonoLMF from the current stack ptr is alloc_size - lmf_offset.
5262                  * The pointer to the struct is put in ppc_r11 (new_lmf).
5263                  * The callee-saved registers are already in the MonoLMF structure
5264                  */
5265                 ppc_addi (code, ppc_r11, ppc_sp, alloc_size - lmf_offset);
5266                 /* ppc_r3 is the result from mono_get_lmf_addr () */
5267                 ppc_stptr (code, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
5268                 /* new_lmf->previous_lmf = *lmf_addr */
5269                 ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
5270                 ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
5271                 /* *(lmf_addr) = r11 */
5272                 ppc_stptr (code, ppc_r11, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3);
5273                 /* save method info */
5274                 if (cfg->compile_aot)
5275                         // FIXME:
5276                         ppc_load (code, ppc_r0, 0);
5277                 else
5278                         ppc_load_ptr (code, ppc_r0, method);
5279                 ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11);
5280                 ppc_stptr (code, ppc_sp, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r11);
5281                 /* save the current IP */
5282                 if (cfg->compile_aot) {
5283                         ppc_bl (code, 1);
5284                         ppc_mflr (code, ppc_r0);
5285                 } else {
5286                         mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_IP, NULL);
5287 #ifdef __mono_ppc64__
5288                         ppc_load_sequence (code, ppc_r0, (guint64)0x0101010101010101LL);
5289 #else
5290                         ppc_load_sequence (code, ppc_r0, (gulong)0x01010101L);
5291 #endif
5292                 }
5293                 ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11);
5294         }
5295
5296         if (tracing)
5297                 code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
5298
5299         cfg->code_len = code - cfg->native_code;
5300         g_assert (cfg->code_len <= cfg->code_size);
5301         g_free (cinfo);
5302
5303         return code;
5304 }
5305
5306 void
5307 mono_arch_emit_epilog (MonoCompile *cfg)
5308 {
5309         MonoMethod *method = cfg->method;
5310         int pos, i;
5311         int max_epilog_size = 16 + 20*4;
5312         guint8 *code;
5313
5314         if (cfg->method->save_lmf)
5315                 max_epilog_size += 128;
5316
5317         if (mono_jit_trace_calls != NULL)
5318                 max_epilog_size += 50;
5319
5320         if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
5321                 max_epilog_size += 50;
5322
5323         while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
5324                 cfg->code_size *= 2;
5325                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
5326                 mono_jit_stats.code_reallocs++;
5327         }
5328
5329         /*
5330          * Keep in sync with OP_JMP
5331          */
5332         code = cfg->native_code + cfg->code_len;
5333
5334         if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) {
5335                 code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
5336         }
5337         pos = 0;
5338
5339         if (method->save_lmf) {
5340                 int lmf_offset;
5341                 pos +=  sizeof (MonoLMF);
5342                 lmf_offset = pos;
5343                 /* save the frame reg in r8 */
5344                 ppc_mr (code, ppc_r8, cfg->frame_reg);
5345                 ppc_addi (code, ppc_r11, cfg->frame_reg, cfg->stack_usage - lmf_offset);
5346                 /* r5 = previous_lmf */
5347                 ppc_ldptr (code, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11);
5348                 /* r6 = lmf_addr */
5349                 ppc_ldptr (code, ppc_r6, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11);
5350                 /* *(lmf_addr) = previous_lmf */
5351                 ppc_stptr (code, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r6);
5352                 /* FIXME: speedup: there is no actual need to restore the registers if
5353                  * we didn't actually change them (idea from Zoltan).
5354                  */
5355                 /* restore iregs */
5356                 ppc_ldr_multiple (code, ppc_r13, G_STRUCT_OFFSET(MonoLMF, iregs), ppc_r11);
5357                 /* restore fregs */
5358                 /*for (i = 14; i < 32; i++) {
5359                         ppc_lfd (code, i, G_STRUCT_OFFSET(MonoLMF, fregs) + ((i-14) * sizeof (gdouble)), ppc_r11);
5360                 }*/
5361                 g_assert (ppc_is_imm16 (cfg->stack_usage + PPC_RET_ADDR_OFFSET));
5362                 /* use the saved copy of the frame reg in r8 */
5363                 if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
5364                         ppc_ldr (code, ppc_r0, cfg->stack_usage + PPC_RET_ADDR_OFFSET, ppc_r8);
5365                         ppc_mtlr (code, ppc_r0);
5366                 }
5367                 ppc_addic (code, ppc_sp, ppc_r8, cfg->stack_usage);
5368         } else {
5369                 if (1 || cfg->flags & MONO_CFG_HAS_CALLS) {
5370                         long return_offset = cfg->stack_usage + PPC_RET_ADDR_OFFSET;
5371                         if (ppc_is_imm16 (return_offset)) {
5372                                 ppc_ldr (code, ppc_r0, return_offset, cfg->frame_reg);
5373                         } else {
5374                                 ppc_load (code, ppc_r11, return_offset);
5375                                 ppc_ldr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r11);
5376                         }
5377                         ppc_mtlr (code, ppc_r0);
5378                 }
5379                 if (ppc_is_imm16 (cfg->stack_usage)) {
5380                         int offset = cfg->stack_usage;
5381                         for (i = 13; i <= 31; i++) {
5382                                 if (cfg->used_int_regs & (1 << i))
5383                                         offset -= sizeof (mgreg_t);
5384                         }
5385                         if (cfg->frame_reg != ppc_sp)
5386                                 ppc_mr (code, ppc_r11, cfg->frame_reg);
5387                         /* note r31 (possibly the frame register) is restored last */
5388                         for (i = 13; i <= 31; i++) {
5389                                 if (cfg->used_int_regs & (1 << i)) {
5390                                         ppc_ldr (code, i, offset, cfg->frame_reg);
5391                                         offset += sizeof (mgreg_t);
5392                                 }
5393                         }
5394                         if (cfg->frame_reg != ppc_sp)
5395                                 ppc_addi (code, ppc_sp, ppc_r11, cfg->stack_usage);
5396                         else
5397                                 ppc_addi (code, ppc_sp, ppc_sp, cfg->stack_usage);
5398                 } else {
5399                         ppc_load32 (code, ppc_r11, cfg->stack_usage);
5400                         if (cfg->used_int_regs) {
5401                                 ppc_add (code, ppc_r11, cfg->frame_reg, ppc_r11);
5402                                 for (i = 31; i >= 13; --i) {
5403                                         if (cfg->used_int_regs & (1 << i)) {
5404                                                 pos += sizeof (mgreg_t);
5405                                                 ppc_ldr (code, i, -pos, ppc_r11);
5406                                         }
5407                                 }
5408                                 ppc_mr (code, ppc_sp, ppc_r11);
5409                         } else {
5410                                 ppc_add (code, ppc_sp, cfg->frame_reg, ppc_r11);
5411                         }
5412                 }
5413
5414         }
5415         ppc_blr (code);
5416
5417         cfg->code_len = code - cfg->native_code;
5418
5419         g_assert (cfg->code_len < cfg->code_size);
5420
5421 }
5422 #endif /* ifndef DISABLE_JIT */
5423
5424 /* remove once throw_exception_by_name is eliminated */
5425 static int
5426 exception_id_by_name (const char *name)
5427 {
5428         if (strcmp (name, "IndexOutOfRangeException") == 0)
5429                 return MONO_EXC_INDEX_OUT_OF_RANGE;
5430         if (strcmp (name, "OverflowException") == 0)
5431                 return MONO_EXC_OVERFLOW;
5432         if (strcmp (name, "ArithmeticException") == 0)
5433                 return MONO_EXC_ARITHMETIC;
5434         if (strcmp (name, "DivideByZeroException") == 0)
5435                 return MONO_EXC_DIVIDE_BY_ZERO;
5436         if (strcmp (name, "InvalidCastException") == 0)
5437                 return MONO_EXC_INVALID_CAST;
5438         if (strcmp (name, "NullReferenceException") == 0)
5439                 return MONO_EXC_NULL_REF;
5440         if (strcmp (name, "ArrayTypeMismatchException") == 0)
5441                 return MONO_EXC_ARRAY_TYPE_MISMATCH;
5442         g_error ("Unknown intrinsic exception %s\n", name);
5443         return 0;
5444 }
5445
5446 #ifndef DISABLE_JIT
5447 void
5448 mono_arch_emit_exceptions (MonoCompile *cfg)
5449 {
5450         MonoJumpInfo *patch_info;
5451         int i;
5452         guint8 *code;
5453         const guint8* exc_throw_pos [MONO_EXC_INTRINS_NUM] = {NULL};
5454         guint8 exc_throw_found [MONO_EXC_INTRINS_NUM] = {0};
5455         int max_epilog_size = 50;
5456
5457         /* count the number of exception infos */
5458
5459         /*
5460          * make sure we have enough space for exceptions
5461          */
5462         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
5463                 if (patch_info->type == MONO_PATCH_INFO_EXC) {
5464                         i = exception_id_by_name (patch_info->data.target);
5465                         if (!exc_throw_found [i]) {
5466                                 max_epilog_size += (2 * PPC_LOAD_SEQUENCE_LENGTH) + 5 * 4;
5467                                 exc_throw_found [i] = TRUE;
5468                         }
5469                 } else if (patch_info->type == MONO_PATCH_INFO_BB_OVF)
5470                         max_epilog_size += 12;
5471                 else if (patch_info->type == MONO_PATCH_INFO_EXC_OVF) {
5472                         MonoOvfJump *ovfj = (MonoOvfJump*)patch_info->data.target;
5473                         i = exception_id_by_name (ovfj->data.exception);
5474                         if (!exc_throw_found [i]) {
5475                                 max_epilog_size += (2 * PPC_LOAD_SEQUENCE_LENGTH) + 5 * 4;
5476                                 exc_throw_found [i] = TRUE;
5477                         }
5478                         max_epilog_size += 8;
5479                 }
5480         }
5481
5482         while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
5483                 cfg->code_size *= 2;
5484                 cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
5485                 mono_jit_stats.code_reallocs++;
5486         }
5487
5488         code = cfg->native_code + cfg->code_len;
5489
5490         /* add code to raise exceptions */
5491         for (patch_info = cfg->patch_info; patch_info; patch_info = patch_info->next) {
5492                 switch (patch_info->type) {
5493                 case MONO_PATCH_INFO_BB_OVF: {
5494                         MonoOvfJump *ovfj = (MonoOvfJump*)patch_info->data.target;
5495                         unsigned char *ip = patch_info->ip.i + cfg->native_code;
5496                         /* patch the initial jump */
5497                         ppc_patch (ip, code);
5498                         ppc_bc (code, ovfj->b0_cond, ovfj->b1_cond, 2);
5499                         ppc_b (code, 0);
5500                         ppc_patch (code - 4, ip + 4); /* jump back after the initiali branch */
5501                         /* jump back to the true target */
5502                         ppc_b (code, 0);
5503                         ip = ovfj->data.bb->native_offset + cfg->native_code;
5504                         ppc_patch (code - 4, ip);
5505                         patch_info->type = MONO_PATCH_INFO_NONE;
5506                         break;
5507                 }
5508                 case MONO_PATCH_INFO_EXC_OVF: {
5509                         MonoOvfJump *ovfj = (MonoOvfJump*)patch_info->data.target;
5510                         MonoJumpInfo *newji;
5511                         unsigned char *ip = patch_info->ip.i + cfg->native_code;
5512                         unsigned char *bcl = code;
5513                         /* patch the initial jump: we arrived here with a call */
5514                         ppc_patch (ip, code);
5515                         ppc_bc (code, ovfj->b0_cond, ovfj->b1_cond, 0);
5516                         ppc_b (code, 0);
5517                         ppc_patch (code - 4, ip + 4); /* jump back after the initiali branch */
5518                         /* patch the conditional jump to the right handler */
5519                         /* make it processed next */
5520                         newji = mono_mempool_alloc (cfg->mempool, sizeof (MonoJumpInfo));
5521                         newji->type = MONO_PATCH_INFO_EXC;
5522                         newji->ip.i = bcl - cfg->native_code;
5523                         newji->data.target = ovfj->data.exception;
5524                         newji->next = patch_info->next;
5525                         patch_info->next = newji;
5526                         patch_info->type = MONO_PATCH_INFO_NONE;
5527                         break;
5528                 }
5529                 case MONO_PATCH_INFO_EXC: {
5530                         MonoClass *exc_class;
5531
5532                         unsigned char *ip = patch_info->ip.i + cfg->native_code;
5533                         i = exception_id_by_name (patch_info->data.target);
5534                         if (exc_throw_pos [i] && !(ip > exc_throw_pos [i] && ip - exc_throw_pos [i] > 50000)) {
5535                                 ppc_patch (ip, exc_throw_pos [i]);
5536                                 patch_info->type = MONO_PATCH_INFO_NONE;
5537                                 break;
5538                         } else {
5539                                 exc_throw_pos [i] = code;
5540                         }
5541
5542                         exc_class = mono_class_from_name (mono_defaults.corlib, "System", patch_info->data.name);
5543                         g_assert (exc_class);
5544
5545                         ppc_patch (ip, code);
5546                         /*mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC_NAME, patch_info->data.target);*/
5547                         ppc_load (code, ppc_r3, exc_class->type_token);
5548                         /* we got here from a conditional call, so the calling ip is set in lr */
5549                         ppc_mflr (code, ppc_r4);
5550                         patch_info->type = MONO_PATCH_INFO_INTERNAL_METHOD;
5551                         patch_info->data.name = "mono_arch_throw_corlib_exception";
5552                         patch_info->ip.i = code - cfg->native_code;
5553                         if (FORCE_INDIR_CALL || cfg->method->dynamic) {
5554                                 ppc_load_func (code, ppc_r0, 0);
5555                                 ppc_mtctr (code, ppc_r0);
5556                                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
5557                         } else {
5558                                 ppc_bl (code, 0);
5559                         }
5560                         break;
5561                 }
5562                 default:
5563                         /* do nothing */
5564                         break;
5565                 }
5566         }
5567
5568         cfg->code_len = code - cfg->native_code;
5569
5570         g_assert (cfg->code_len <= cfg->code_size);
5571 }
5572 #endif
5573
5574 #if DEAD_CODE
5575 static int
5576 try_offset_access (void *value, guint32 idx)
5577 {
5578         register void* me __asm__ ("r2");
5579         void ***p = (void***)((char*)me + 284);
5580         int idx1 = idx / 32;
5581         int idx2 = idx % 32;
5582         if (!p [idx1])
5583                 return 0;
5584         if (value != p[idx1][idx2])
5585                 return 0;
5586         return 1;
5587 }
5588 #endif
5589
5590 static void
5591 setup_tls_access (void)
5592 {
5593         guint32 ptk;
5594
5595 #if defined(__linux__) && defined(_CS_GNU_LIBPTHREAD_VERSION)
5596         size_t conf_size = 0;
5597         char confbuf[128];
5598 #else
5599         /* FIXME for darwin */
5600         guint32 *ins, *code;
5601         guint32 cmplwi_1023, li_0x48, blr_ins;
5602 #endif
5603
5604 #ifdef TARGET_PS3
5605         tls_mode = TLS_MODE_FAILED;
5606 #endif
5607
5608         if (tls_mode == TLS_MODE_FAILED)
5609                 return;
5610         if (g_getenv ("MONO_NO_TLS")) {
5611                 tls_mode = TLS_MODE_FAILED;
5612                 return;
5613         }
5614
5615         if (tls_mode == TLS_MODE_DETECT) {
5616 #if defined(__APPLE__) && defined(__mono_ppc__) && !defined(__mono_ppc64__)
5617                 tls_mode = TLS_MODE_DARWIN_G4;
5618 #elif defined(__linux__) && defined(_CS_GNU_LIBPTHREAD_VERSION)
5619                 conf_size = confstr ( _CS_GNU_LIBPTHREAD_VERSION, confbuf, sizeof(confbuf));
5620                 if ((conf_size > 4) && (strncmp (confbuf, "NPTL", 4) == 0))
5621                         tls_mode = TLS_MODE_NPTL;
5622 #elif !defined(TARGET_PS3)
5623                 ins = (guint32*)pthread_getspecific;
5624                 /* uncond branch to the real method */
5625                 if ((*ins >> 26) == 18) {
5626                         gint32 val;
5627                         val = (*ins & ~3) << 6;
5628                         val >>= 6;
5629                         if (*ins & 2) {
5630                                 /* absolute */
5631                                 ins = (guint32*)(long)val;
5632                         } else {
5633                                 ins = (guint32*) ((char*)ins + val);
5634                         }
5635                 }
5636                 code = &cmplwi_1023;
5637                 ppc_cmpli (code, 0, 0, ppc_r3, 1023);
5638                 code = &li_0x48;
5639                 ppc_li (code, ppc_r4, 0x48);
5640                 code = &blr_ins;
5641                 ppc_blr (code);
5642                 if (*ins == cmplwi_1023) {
5643                         int found_lwz_284 = 0;
5644                         for (ptk = 0; ptk < 20; ++ptk) {
5645                                 ++ins;
5646                                 if (!*ins || *ins == blr_ins)
5647                                         break;
5648                                 if ((guint16)*ins == 284 && (*ins >> 26) == 32) {
5649                                         found_lwz_284 = 1;
5650                                         break;
5651                                 }
5652                         }
5653                         if (!found_lwz_284) {
5654                                 tls_mode = TLS_MODE_FAILED;
5655                                 return;
5656                         }
5657                         tls_mode = TLS_MODE_LTHREADS;
5658                 } else if (*ins == li_0x48) {
5659                         ++ins;
5660                         /* uncond branch to the real method */
5661                         if ((*ins >> 26) == 18) {
5662                                 gint32 val;
5663                                 val = (*ins & ~3) << 6;
5664                                 val >>= 6;
5665                                 if (*ins & 2) {
5666                                         /* absolute */
5667                                         ins = (guint32*)(long)val;
5668                                 } else {
5669                                         ins = (guint32*) ((char*)ins + val);
5670                                 }
5671                                 code = (guint32*)&val;
5672                                 ppc_li (code, ppc_r0, 0x7FF2);
5673                                 if (ins [1] == val) {
5674                                         /* Darwin on G4, implement */
5675                                         tls_mode = TLS_MODE_FAILED;
5676                                         return;
5677                                 } else {
5678                                         code = (guint32*)&val;
5679                                         ppc_mfspr (code, ppc_r3, 104);
5680                                         if (ins [1] != val) {
5681                                                 tls_mode = TLS_MODE_FAILED;
5682                                                 return;
5683                                         }
5684                                         tls_mode = TLS_MODE_DARWIN_G5;
5685                                 }
5686                         } else {
5687                                 tls_mode = TLS_MODE_FAILED;
5688                                 return;
5689                         }
5690                 } else {
5691                         tls_mode = TLS_MODE_FAILED;
5692                         return;
5693                 }
5694 #endif
5695         }
5696 #ifndef TARGET_PS3
5697         if (tls_mode == TLS_MODE_DETECT)
5698                 tls_mode = TLS_MODE_FAILED;
5699         if (tls_mode == TLS_MODE_FAILED)
5700                 return;
5701         if ((monodomain_key == -1) && (tls_mode == TLS_MODE_NPTL)) {
5702                 monodomain_key = mono_domain_get_tls_offset();
5703         }
5704         /* if not TLS_MODE_NPTL or local dynamic (as indicated by
5705            mono_domain_get_tls_offset returning -1) then use keyed access. */
5706         if (monodomain_key == -1) {
5707                 ptk = mono_domain_get_tls_key ();
5708                 if (ptk < 1024) {
5709                         ptk = mono_pthread_key_for_tls (ptk);
5710                         if (ptk < 1024) {
5711                                 monodomain_key = ptk;
5712                         }
5713                 }
5714         }
5715
5716         if ((lmf_pthread_key == -1) && (tls_mode == TLS_MODE_NPTL)) {
5717                 lmf_pthread_key = mono_get_lmf_addr_tls_offset();
5718         }
5719         /* if not TLS_MODE_NPTL or local dynamic (as indicated by
5720            mono_get_lmf_addr_tls_offset returning -1) then use keyed access. */
5721         if (lmf_pthread_key == -1) {
5722                 ptk = mono_pthread_key_for_tls (mono_jit_tls_id);
5723                 if (ptk < 1024) {
5724                         /*g_print ("MonoLMF at: %d\n", ptk);*/
5725                         /*if (!try_offset_access (mono_get_lmf_addr (), ptk)) {
5726                                 init_tls_failed = 1;
5727                                 return;
5728                         }*/
5729                         lmf_pthread_key = ptk;
5730                 }
5731         }
5732 #endif
5733 }
5734
5735 void
5736 mono_arch_setup_jit_tls_data (MonoJitTlsData *tls)
5737 {
5738         setup_tls_access ();
5739 }
5740
5741 void
5742 mono_arch_free_jit_tls_data (MonoJitTlsData *tls)
5743 {
5744 }
5745
5746 #ifdef MONO_ARCH_HAVE_IMT
5747
5748 #define CMP_SIZE (PPC_LOAD_SEQUENCE_LENGTH + 4)
5749 #define BR_SIZE 4
5750 #define LOADSTORE_SIZE 4
5751 #define JUMP_IMM_SIZE 12
5752 #define JUMP_IMM32_SIZE (PPC_LOAD_SEQUENCE_LENGTH + 8)
5753 #define ENABLE_WRONG_METHOD_CHECK 0
5754
5755 /*
5756  * LOCKING: called with the domain lock held
5757  */
5758 gpointer
5759 mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count,
5760         gpointer fail_tramp)
5761 {
5762         int i;
5763         int size = 0;
5764         guint8 *code, *start;
5765
5766         for (i = 0; i < count; ++i) {
5767                 MonoIMTCheckItem *item = imt_entries [i];
5768                 if (item->is_equals) {
5769                         if (item->check_target_idx) {
5770                                 if (!item->compare_done)
5771                                         item->chunk_size += CMP_SIZE;
5772                                 if (item->has_target_code)
5773                                         item->chunk_size += BR_SIZE + JUMP_IMM32_SIZE;
5774                                 else
5775                                         item->chunk_size += LOADSTORE_SIZE + BR_SIZE + JUMP_IMM_SIZE;
5776                         } else {
5777                                 if (fail_tramp) {
5778                                         item->chunk_size += CMP_SIZE + BR_SIZE + JUMP_IMM32_SIZE * 2;
5779                                         if (!item->has_target_code)
5780                                                 item->chunk_size += LOADSTORE_SIZE;
5781                                 } else {
5782                                         item->chunk_size += LOADSTORE_SIZE + JUMP_IMM_SIZE;
5783 #if ENABLE_WRONG_METHOD_CHECK
5784                                         item->chunk_size += CMP_SIZE + BR_SIZE + 4;
5785 #endif
5786                                 }
5787                         }
5788                 } else {
5789                         item->chunk_size += CMP_SIZE + BR_SIZE;
5790                         imt_entries [item->check_target_idx]->compare_done = TRUE;
5791                 }
5792                 size += item->chunk_size;
5793         }
5794         /* the initial load of the vtable address */
5795         size += PPC_LOAD_SEQUENCE_LENGTH + LOADSTORE_SIZE;
5796         if (fail_tramp) {
5797                 code = mono_method_alloc_generic_virtual_thunk (domain, size);
5798         } else {
5799                 code = mono_domain_code_reserve (domain, size);
5800         }
5801         start = code;
5802
5803         /*
5804          * We need to save and restore r11 because it might be
5805          * used by the caller as the vtable register, so
5806          * clobbering it will trip up the magic trampoline.
5807          *
5808          * FIXME: Get rid of this by making sure that r11 is
5809          * not used as the vtable register in interface calls.
5810          */
5811         ppc_stptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp);
5812         ppc_load (code, ppc_r11, (gsize)(& (vtable->vtable [0])));
5813
5814         for (i = 0; i < count; ++i) {
5815                 MonoIMTCheckItem *item = imt_entries [i];
5816                 item->code_target = code;
5817                 if (item->is_equals) {
5818                         if (item->check_target_idx) {
5819                                 if (!item->compare_done) {
5820                                         ppc_load (code, ppc_r0, (gsize)item->key);
5821                                         ppc_compare_log (code, 0, MONO_ARCH_IMT_REG, ppc_r0);
5822                                 }
5823                                 item->jmp_code = code;
5824                                 ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
5825                                 if (item->has_target_code) {
5826                                         ppc_load_ptr (code, ppc_r0, item->value.target_code);
5827                                 } else {
5828                                         ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r11);
5829                                         ppc_ldptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp);
5830                                 }
5831                                 ppc_mtctr (code, ppc_r0);
5832                                 ppc_bcctr (code, PPC_BR_ALWAYS, 0);
5833                         } else {
5834                                 if (fail_tramp) {
5835                                         ppc_load (code, ppc_r0, (gulong)item->key);
5836                                         ppc_compare_log (code, 0, MONO_ARCH_IMT_REG, ppc_r0);
5837                                         item->jmp_code = code;
5838                                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
5839                                         if (item->has_target_code) {
5840                                                 ppc_load_ptr (code, ppc_r0, item->value.target_code);
5841                                         } else {
5842                                                 g_assert (vtable);
5843                                                 ppc_load_ptr (code, ppc_r0, & (vtable->vtable [item->value.vtable_slot]));
5844                                                 ppc_ldptr_indexed (code, ppc_r0, 0, ppc_r0);
5845                                         }
5846                                         ppc_mtctr (code, ppc_r0);
5847                                         ppc_bcctr (code, PPC_BR_ALWAYS, 0);
5848                                         ppc_patch (item->jmp_code, code);
5849                                         ppc_load_ptr (code, ppc_r0, fail_tramp);
5850                                         ppc_mtctr (code, ppc_r0);
5851                                         ppc_bcctr (code, PPC_BR_ALWAYS, 0);
5852                                         item->jmp_code = NULL;
5853                                 } else {
5854                                         /* enable the commented code to assert on wrong method */
5855 #if ENABLE_WRONG_METHOD_CHECK
5856                                         ppc_load (code, ppc_r0, (guint32)item->key);
5857                                         ppc_compare_log (code, 0, MONO_ARCH_IMT_REG, ppc_r0);
5858                                         item->jmp_code = code;
5859                                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0);
5860 #endif
5861                                         ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r11);
5862                                         ppc_ldptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp);
5863                                         ppc_mtctr (code, ppc_r0);
5864                                         ppc_bcctr (code, PPC_BR_ALWAYS, 0);
5865 #if ENABLE_WRONG_METHOD_CHECK
5866                                         ppc_patch (item->jmp_code, code);
5867                                         ppc_break (code);
5868                                         item->jmp_code = NULL;
5869 #endif
5870                                 }
5871                         }
5872                 } else {
5873                         ppc_load (code, ppc_r0, (gulong)item->key);
5874                         ppc_compare_log (code, 0, MONO_ARCH_IMT_REG, ppc_r0);
5875                         item->jmp_code = code;
5876                         ppc_bc (code, PPC_BR_FALSE, PPC_BR_LT, 0);
5877                 }
5878         }
5879         /* patch the branches to get to the target items */
5880         for (i = 0; i < count; ++i) {
5881                 MonoIMTCheckItem *item = imt_entries [i];
5882                 if (item->jmp_code) {
5883                         if (item->check_target_idx) {
5884                                 ppc_patch (item->jmp_code, imt_entries [item->check_target_idx]->code_target);
5885                         }
5886                 }
5887         }
5888
5889         if (!fail_tramp)
5890                 mono_stats.imt_thunks_size += code - start;
5891         g_assert (code - start <= size);
5892         mono_arch_flush_icache (start, size);
5893         return start;
5894 }
5895
5896 MonoMethod*
5897 mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
5898 {
5899         mgreg_t *r = (mgreg_t*)regs;
5900
5901         return (MonoMethod*)(gsize) r [MONO_ARCH_IMT_REG];
5902 }
5903 #endif
5904
5905 MonoVTable*
5906 mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
5907 {
5908         mgreg_t *r = (mgreg_t*)regs;
5909
5910         return (MonoVTable*)(gsize) r [MONO_ARCH_RGCTX_REG];
5911 }
5912
5913 MonoInst*
5914 mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
5915 {
5916         /* FIXME: */
5917         return NULL;
5918 }
5919
5920 gboolean
5921 mono_arch_print_tree (MonoInst *tree, int arity)
5922 {
5923         return 0;
5924 }
5925
5926 MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg)
5927 {
5928         MonoInst* ins;
5929
5930         setup_tls_access ();
5931         if (monodomain_key == -1)
5932                 return NULL;
5933
5934         MONO_INST_NEW (cfg, ins, OP_TLS_GET);
5935         ins->inst_offset = monodomain_key;
5936         return ins;
5937 }
5938
5939 gpointer
5940 mono_arch_context_get_int_reg (MonoContext *ctx, int reg)
5941 {
5942         if (reg == ppc_r1)
5943                 return MONO_CONTEXT_GET_SP (ctx);
5944
5945         g_assert (reg >= ppc_r13);
5946
5947         return (gpointer)(gsize)ctx->regs [reg - ppc_r13];
5948 }
5949
5950 guint32
5951 mono_arch_get_patch_offset (guint8 *code)
5952 {
5953         return 0;
5954 }
5955
5956 /*
5957  * mono_aot_emit_load_got_addr:
5958  *
5959  *   Emit code to load the got address.
5960  * On PPC, the result is placed into r30.
5961  */
5962 guint8*
5963 mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji)
5964 {
5965         ppc_bl (code, 1);
5966         ppc_mflr (code, ppc_r30);
5967         if (cfg)
5968                 mono_add_patch_info (cfg, code - start, MONO_PATCH_INFO_GOT_OFFSET, NULL);
5969         else
5970                 *ji = mono_patch_info_list_prepend (*ji, code - start, MONO_PATCH_INFO_GOT_OFFSET, NULL);
5971         /* arch_emit_got_address () patches this */
5972 #if defined(TARGET_POWERPC64)
5973         ppc_nop (code);
5974         ppc_nop (code);
5975         ppc_nop (code);
5976         ppc_nop (code);
5977 #else
5978         ppc_load32 (code, ppc_r0, 0);
5979         ppc_add (code, ppc_r30, ppc_r30, ppc_r0);
5980 #endif
5981
5982         return code;
5983 }
5984
5985 /*
5986  * mono_ppc_emit_load_aotconst:
5987  *
5988  *   Emit code to load the contents of the GOT slot identified by TRAMP_TYPE and
5989  * TARGET from the mscorlib GOT in full-aot code.
5990  * On PPC, the GOT address is assumed to be in r30, and the result is placed into
5991  * r11.
5992  */
5993 guint8*
5994 mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
5995 {
5996         /* Load the mscorlib got address */
5997         ppc_ldptr (code, ppc_r11, sizeof (gpointer), ppc_r30);
5998         *ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target);
5999         /* arch_emit_got_access () patches this */
6000         ppc_load32 (code, ppc_r0, 0);
6001         ppc_ldptr_indexed (code, ppc_r11, ppc_r11, ppc_r0);
6002
6003         return code;
6004 }
6005
6006 /* Soft Debug support */
6007 #ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
6008
6009 /*
6010  * BREAKPOINTS
6011  */
6012
6013 /*
6014  * mono_arch_set_breakpoint:
6015  *
6016  *   See mini-amd64.c for docs.
6017  */
6018 void
6019 mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip)
6020 {
6021         guint8 *code = ip;
6022         guint8 *orig_code = code;
6023
6024         ppc_load_sequence (code, ppc_r11, (gsize)bp_trigger_page);
6025         ppc_ldptr (code, ppc_r11, 0, ppc_r11);
6026
6027         g_assert (code - orig_code == BREAKPOINT_SIZE);
6028
6029         mono_arch_flush_icache (orig_code, code - orig_code);
6030 }
6031
6032 /*
6033  * mono_arch_clear_breakpoint:
6034  *
6035  *   See mini-amd64.c for docs.
6036  */
6037 void
6038 mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip)
6039 {
6040         guint8 *code = ip;
6041         int i;
6042
6043         for (i = 0; i < BREAKPOINT_SIZE / 4; ++i)
6044                 ppc_nop (code);
6045
6046         mono_arch_flush_icache (ip, code - ip);
6047 }
6048
6049 /*
6050  * mono_arch_is_breakpoint_event:
6051  *
6052  *   See mini-amd64.c for docs.
6053  */
6054 gboolean
6055 mono_arch_is_breakpoint_event (void *info, void *sigctx)
6056 {
6057         siginfo_t* sinfo = (siginfo_t*) info;
6058         /* Sometimes the address is off by 4 */
6059         if (sinfo->si_addr >= bp_trigger_page && (guint8*)sinfo->si_addr <= (guint8*)bp_trigger_page + 128)
6060                 return TRUE;
6061         else
6062                 return FALSE;
6063 }
6064
6065 /*
6066  * mono_arch_get_ip_for_breakpoint:
6067  *
6068  *   See mini-amd64.c for docs.
6069  */
6070 guint8*
6071 mono_arch_get_ip_for_breakpoint (MonoJitInfo *ji, MonoContext *ctx)
6072 {
6073         guint8 *ip = MONO_CONTEXT_GET_IP (ctx);
6074
6075         /* ip points at the ldptr instruction */
6076         ip -= PPC_LOAD_SEQUENCE_LENGTH;
6077
6078         return ip;
6079 }
6080
6081 /*
6082  * mono_arch_skip_breakpoint:
6083  *
6084  *   See mini-amd64.c for docs.
6085  */
6086 void
6087 mono_arch_skip_breakpoint (MonoContext *ctx)
6088 {
6089         /* skip the ldptr */
6090         MONO_CONTEXT_SET_IP (ctx, (guint8*)MONO_CONTEXT_GET_IP (ctx) + 4);
6091 }
6092
6093 /*
6094  * SINGLE STEPPING
6095  */
6096
6097 /*
6098  * mono_arch_start_single_stepping:
6099  *
6100  *   See mini-amd64.c for docs.
6101  */
6102 void
6103 mono_arch_start_single_stepping (void)
6104 {
6105         mono_mprotect (ss_trigger_page, mono_pagesize (), 0);
6106 }
6107
6108 /*
6109  * mono_arch_stop_single_stepping:
6110  *
6111  *   See mini-amd64.c for docs.
6112  */
6113 void
6114 mono_arch_stop_single_stepping (void)
6115 {
6116         mono_mprotect (ss_trigger_page, mono_pagesize (), MONO_MMAP_READ);
6117 }
6118
6119 /*
6120  * mono_arch_is_single_step_event:
6121  *
6122  *   See mini-amd64.c for docs.
6123  */
6124 gboolean
6125 mono_arch_is_single_step_event (void *info, void *sigctx)
6126 {
6127         siginfo_t* sinfo = (siginfo_t*) info;
6128         /* Sometimes the address is off by 4 */
6129         if (sinfo->si_addr >= ss_trigger_page && (guint8*)sinfo->si_addr <= (guint8*)ss_trigger_page + 128)
6130                 return TRUE;
6131         else
6132                 return FALSE;
6133 }
6134
6135 /*
6136  * mono_arch_get_ip_for_single_step:
6137  *
6138  *   See mini-amd64.c for docs.
6139  */
6140 guint8*
6141 mono_arch_get_ip_for_single_step (MonoJitInfo *ji, MonoContext *ctx)
6142 {
6143         guint8 *ip = MONO_CONTEXT_GET_IP (ctx);
6144
6145         /* ip points after the ldptr instruction */
6146         return ip;
6147 }
6148
6149 /*
6150  * mono_arch_skip_single_step:
6151  *
6152  *   See mini-amd64.c for docs.
6153  */
6154 void
6155 mono_arch_skip_single_step (MonoContext *ctx)
6156 {
6157         /* skip the ldptr */
6158         MONO_CONTEXT_SET_IP (ctx, (guint8*)MONO_CONTEXT_GET_IP (ctx) + 4);
6159 }
6160
6161 /*
6162  * mono_arch_create_seq_point_info:
6163  *
6164  *   See mini-amd64.c for docs.
6165  */
6166 gpointer
6167 mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code)
6168 {
6169         NOT_IMPLEMENTED;
6170         return NULL;
6171 }
6172
6173 #endif