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