mono/mini/mini-llvm.c

   1 /*
   2  * mini-llvm.c: llvm "Backend" for the mono JIT
   3  *
   4  * Copyright 2009-2011 Novell Inc (http://www.novell.com)
   5  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
   6  */
   7
   8 #include "mini.h"
   9 #include <mono/metadata/debug-helpers.h>
  10 #include <mono/metadata/mempool-internals.h>
  11 #include <mono/utils/mono-tls.h>
  12 #include <mono/utils/mono-dl.h>
  13
  14 #ifndef __STDC_LIMIT_MACROS
  15 #define __STDC_LIMIT_MACROS
  16 #endif
  17 #ifndef __STDC_CONSTANT_MACROS
  18 #define __STDC_CONSTANT_MACROS
  19 #endif
  20
  21 #include "llvm-c/Core.h"
  22 #include "llvm-c/ExecutionEngine.h"
  23 #include "llvm-c/BitWriter.h"
  24 #include "llvm-c/Analysis.h"
  25
  26 #include "mini-llvm-cpp.h"
  27
  28  /*
  29   * Information associated by mono with LLVM modules.
  30   */
  31 typedef struct {
  32         LLVMModuleRef module;
  33         LLVMValueRef throw, rethrow, throw_corlib_exception;
  34         GHashTable *llvm_types;
  35         LLVMValueRef got_var;
  36         const char *got_symbol;
  37         GHashTable *plt_entries;
  38 } MonoLLVMModule;
  39
  40 /*
  41  * Information associated by the backend with mono basic blocks.
  42  */
  43 typedef struct {
  44         LLVMBasicBlockRef bblock, end_bblock;
  45         LLVMValueRef finally_ind;
  46         gboolean added, invoke_target;
  47         /*
  48          * If this bblock is the start of a finally clause, this is a list of bblocks it
  49          * needs to branch to in ENDFINALLY.
  50          */
  51         GSList *call_handler_return_bbs;
  52         /*
  53          * If this bblock is the start of a finally clause, this is the bblock that
  54          * CALL_HANDLER needs to branch to.
  55          */
  56         LLVMBasicBlockRef call_handler_target_bb;
  57         /* The list of switch statements generated by ENDFINALLY instructions */
  58         GSList *endfinally_switch_ins_list;
  59         GSList *phi_nodes;
  60 } BBInfo;
  61
  62 /*
  63  * Structure containing emit state
  64  */
  65 typedef struct {
  66         MonoMemPool *mempool;
  67
  68         /* Maps method names to the corresponding LLVMValueRef */
  69         GHashTable *emitted_method_decls;
  70
  71         MonoCompile *cfg;
  72         LLVMValueRef lmethod;
  73         MonoLLVMModule *lmodule;
  74         LLVMModuleRef module;
  75         BBInfo *bblocks;
  76         int sindex, default_index, ex_index;
  77         LLVMBuilderRef builder;
  78         LLVMValueRef *values, *addresses;
  79         MonoType **vreg_cli_types;
  80         LLVMCallInfo *linfo;
  81         MonoMethodSignature *sig;
  82         GSList *builders;
  83         GHashTable *region_to_handler;
  84         LLVMBuilderRef alloca_builder;
  85         LLVMValueRef last_alloca;
  86         LLVMValueRef rgctx_arg;
  87         LLVMTypeRef *vreg_types;
  88         gboolean *is_dead;
  89         gboolean *unreachable;
  90         int *pindexes;
  91
  92         char temp_name [32];
  93 } EmitContext;
  94
  95 typedef struct {
  96         MonoBasicBlock *bb;
  97         MonoInst *phi;
  98         MonoBasicBlock *in_bb;
  99         int sreg;
 100 } PhiNode;
 101
 102 /*
 103  * Instruction metadata
 104  * This is the same as ins_info, but LREG != IREG.
 105  */
 106 #ifdef MINI_OP
 107 #undef MINI_OP
 108 #endif
 109 #ifdef MINI_OP3
 110 #undef MINI_OP3
 111 #endif
 112 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2, ' ',
 113 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
 114 #define NONE ' '
 115 #define IREG 'i'
 116 #define FREG 'f'
 117 #define VREG 'v'
 118 #define XREG 'x'
 119 #define LREG 'l'
 120 /* keep in sync with the enum in mini.h */
 121 const char
 122 llvm_ins_info[] = {
 123 #include "mini-ops.h"
 124 };
 125 #undef MINI_OP
 126 #undef MINI_OP3
 127
 128 #if SIZEOF_VOID_P == 4
 129 #define GET_LONG_IMM(ins) (((guint64)(ins)->inst_ms_word << 32) | (guint64)(guint32)(ins)->inst_ls_word)
 130 #else
 131 #define GET_LONG_IMM(ins) ((ins)->inst_imm)
 132 #endif
 133
 134 #define LLVM_INS_INFO(opcode) (&llvm_ins_info [((opcode) - OP_START - 1) * 4])
 135
 136 #if 0
 137 #define TRACE_FAILURE(msg) do { printf ("%s\n", msg); } while (0)
 138 #else
 139 #define TRACE_FAILURE(msg)
 140 #endif
 141
 142 #ifdef TARGET_X86
 143 #define IS_TARGET_X86 1
 144 #else
 145 #define IS_TARGET_X86 0
 146 #endif
 147
 148 #define LLVM_FAILURE(ctx, reason) do { \
 149         TRACE_FAILURE (reason); \
 150         (ctx)->cfg->exception_message = g_strdup (reason); \
 151         (ctx)->cfg->disable_llvm = TRUE; \
 152         goto FAILURE; \
 153 } while (0)
 154
 155 #define CHECK_FAILURE(ctx) do { \
 156     if ((ctx)->cfg->disable_llvm) \
 157                 goto FAILURE; \
 158 } while (0)
 159
 160 static LLVMIntPredicate cond_to_llvm_cond [] = {
 161         LLVMIntEQ,
 162         LLVMIntNE,
 163         LLVMIntSLE,
 164         LLVMIntSGE,
 165         LLVMIntSLT,
 166         LLVMIntSGT,
 167         LLVMIntULE,
 168         LLVMIntUGE,
 169         LLVMIntULT,
 170         LLVMIntUGT,
 171 };
 172
 173 static LLVMRealPredicate fpcond_to_llvm_cond [] = {
 174         LLVMRealOEQ,
 175         LLVMRealUNE,
 176         LLVMRealOLE,
 177         LLVMRealOGE,
 178         LLVMRealOLT,
 179         LLVMRealOGT,
 180         LLVMRealULE,
 181         LLVMRealUGE,
 182         LLVMRealULT,
 183         LLVMRealUGT,
 184 };
 185
 186 static LLVMExecutionEngineRef ee;
 187 static MonoNativeTlsKey current_cfg_tls_id;
 188
 189 static MonoLLVMModule jit_module, aot_module;
 190 static gboolean jit_module_inited;
 191 static int memset_param_count, memcpy_param_count;
 192 static const char *memset_func_name;
 193 static const char *memcpy_func_name;
 194
 195 static void init_jit_module (void);
 196
 197 /*
 198  * IntPtrType:
 199  *
 200  *   The LLVM type with width == sizeof (gpointer)
 201  */
 202 static LLVMTypeRef
 203 IntPtrType (void)
 204 {
 205         return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 206 }
 207
 208 /*
 209  * get_vtype_size:
 210  *
 211  *   Return the size of the LLVM representation of the vtype T.
 212  */
 213 static guint32
 214 get_vtype_size (MonoType *t)
 215 {
 216         int size;
 217
 218         size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
 219
 220         while (size < sizeof (gpointer) && mono_is_power_of_two (size) == -1)
 221                 size ++;
 222
 223         return size;
 224 }
 225
 226 /*
 227  * simd_class_to_llvm_type:
 228  *
 229  *   Return the LLVM type corresponding to the Mono.SIMD class KLASS
 230  */
 231 static LLVMTypeRef
 232 simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
 233 {
 234         if (!strcmp (klass->name, "Vector2d")) {
 235                 return LLVMVectorType (LLVMDoubleType (), 2);
 236         } else if (!strcmp (klass->name, "Vector2l")) {
 237                 return LLVMVectorType (LLVMInt64Type (), 2);
 238         } else if (!strcmp (klass->name, "Vector2ul")) {
 239                 return LLVMVectorType (LLVMInt64Type (), 2);
 240         } else if (!strcmp (klass->name, "Vector4i")) {
 241                 return LLVMVectorType (LLVMInt32Type (), 4);
 242         } else if (!strcmp (klass->name, "Vector4ui")) {
 243                 return LLVMVectorType (LLVMInt32Type (), 4);
 244         } else if (!strcmp (klass->name, "Vector4f")) {
 245                 return LLVMVectorType (LLVMFloatType (), 4);
 246         } else if (!strcmp (klass->name, "Vector8s")) {
 247                 return LLVMVectorType (LLVMInt16Type (), 8);
 248         } else if (!strcmp (klass->name, "Vector8us")) {
 249                 return LLVMVectorType (LLVMInt16Type (), 8);
 250         } else if (!strcmp (klass->name, "Vector16sb")) {
 251                 return LLVMVectorType (LLVMInt8Type (), 16);
 252         } else if (!strcmp (klass->name, "Vector16b")) {
 253                 return LLVMVectorType (LLVMInt8Type (), 16);
 254         } else {
 255                 printf ("%s\n", klass->name);
 256                 NOT_IMPLEMENTED;
 257                 return NULL;
 258         }
 259 }
 260
 261 /* Return the 128 bit SIMD type corresponding to the mono type TYPE */
 262 static inline G_GNUC_UNUSED LLVMTypeRef
 263 type_to_simd_type (int type)
 264 {
 265         switch (type) {
 266         case MONO_TYPE_I1:
 267                 return LLVMVectorType (LLVMInt8Type (), 16);
 268         case MONO_TYPE_I2:
 269                 return LLVMVectorType (LLVMInt16Type (), 8);
 270         case MONO_TYPE_I4:
 271                 return LLVMVectorType (LLVMInt32Type (), 4);
 272         case MONO_TYPE_I8:
 273                 return LLVMVectorType (LLVMInt64Type (), 2);
 274         case MONO_TYPE_R8:
 275                 return LLVMVectorType (LLVMDoubleType (), 2);
 276         case MONO_TYPE_R4:
 277                 return LLVMVectorType (LLVMFloatType (), 4);
 278         default:
 279                 g_assert_not_reached ();
 280                 return NULL;
 281         }
 282 }
 283
 284 /*
 285  * type_to_llvm_type:
 286  *
 287  *   Return the LLVM type corresponding to T.
 288  */
 289 static LLVMTypeRef
 290 type_to_llvm_type (EmitContext *ctx, MonoType *t)
 291 {
 292         if (t->byref)
 293                 return LLVMPointerType (LLVMInt8Type (), 0);
 294         switch (t->type) {
 295         case MONO_TYPE_VOID:
 296                 return LLVMVoidType ();
 297         case MONO_TYPE_I1:
 298                 return LLVMInt8Type ();
 299         case MONO_TYPE_I2:
 300                 return LLVMInt16Type ();
 301         case MONO_TYPE_I4:
 302                 return LLVMInt32Type ();
 303         case MONO_TYPE_U1:
 304                 return LLVMInt8Type ();
 305         case MONO_TYPE_U2:
 306                 return LLVMInt16Type ();
 307         case MONO_TYPE_U4:
 308                 return LLVMInt32Type ();
 309         case MONO_TYPE_BOOLEAN:
 310                 return LLVMInt8Type ();
 311         case MONO_TYPE_I8:
 312         case MONO_TYPE_U8:
 313                 return LLVMInt64Type ();
 314         case MONO_TYPE_CHAR:
 315                 return LLVMInt16Type ();
 316         case MONO_TYPE_R4:
 317                 return LLVMFloatType ();
 318         case MONO_TYPE_R8:
 319                 return LLVMDoubleType ();
 320         case MONO_TYPE_I:
 321         case MONO_TYPE_U:
 322                 return IntPtrType ();
 323         case MONO_TYPE_OBJECT:
 324         case MONO_TYPE_CLASS:
 325         case MONO_TYPE_ARRAY:
 326         case MONO_TYPE_SZARRAY:
 327         case MONO_TYPE_STRING:
 328         case MONO_TYPE_PTR:
 329                 return IntPtrType ();
 330         case MONO_TYPE_VAR:
 331         case MONO_TYPE_MVAR:
 332                 /* Because of generic sharing */
 333                 return IntPtrType ();
 334         case MONO_TYPE_GENERICINST:
 335                 if (!mono_type_generic_inst_is_valuetype (t))
 336                         return IntPtrType ();
 337                 /* Fall through */
 338         case MONO_TYPE_VALUETYPE:
 339         case MONO_TYPE_TYPEDBYREF: {
 340                 MonoClass *klass;
 341                 LLVMTypeRef ltype;
 342
 343                 klass = mono_class_from_mono_type (t);
 344
 345                 if (MONO_CLASS_IS_SIMD (ctx->cfg, klass))
 346                         return simd_class_to_llvm_type (ctx, klass);
 347
 348                 if (klass->enumtype)
 349                         return type_to_llvm_type (ctx, mono_class_enum_basetype (klass));
 350                 ltype = g_hash_table_lookup (ctx->lmodule->llvm_types, klass);
 351                 if (!ltype) {
 352                         int i, size;
 353                         LLVMTypeRef *eltypes;
 354                         char *name;
 355
 356                         size = get_vtype_size (t);
 357
 358                         eltypes = g_new (LLVMTypeRef, size);
 359                         for (i = 0; i < size; ++i)
 360                                 eltypes [i] = LLVMInt8Type ();
 361
 362                         name = mono_type_full_name (&klass->byval_arg);
 363                         ltype = LLVMStructCreateNamed (LLVMGetGlobalContext (), name);
 364                         LLVMStructSetBody (ltype, eltypes, size, FALSE);
 365                         g_hash_table_insert (ctx->lmodule->llvm_types, klass, ltype);
 366                         g_free (eltypes);
 367                 }
 368                 return ltype;
 369         }
 370
 371         default:
 372                 printf ("X: %d\n", t->type);
 373                 ctx->cfg->exception_message = g_strdup_printf ("type %s", mono_type_full_name (t));
 374                 ctx->cfg->disable_llvm = TRUE;
 375                 return NULL;
 376         }
 377 }
 378
 379 /*
 380  * type_is_unsigned:
 381  *
 382  *   Return whenever T is an unsigned int type.
 383  */
 384 static gboolean
 385 type_is_unsigned (EmitContext *ctx, MonoType *t)
 386 {
 387         if (t->byref)
 388                 return FALSE;
 389         switch (t->type) {
 390         case MONO_TYPE_U1:
 391         case MONO_TYPE_U2:
 392         case MONO_TYPE_U4:
 393         case MONO_TYPE_U8:
 394                 return TRUE;
 395         default:
 396                 return FALSE;
 397         }
 398 }
 399
 400 /*
 401  * type_to_llvm_arg_type:
 402  *
 403  *   Same as type_to_llvm_type, but treat i8/i16 as i32.
 404  */
 405 static LLVMTypeRef
 406 type_to_llvm_arg_type (EmitContext *ctx, MonoType *t)
 407 {
 408         LLVMTypeRef ptype = type_to_llvm_type (ctx, t);
 409
 410         if (ptype == LLVMInt8Type () || ptype == LLVMInt16Type ()) {
 411                 /*
 412                  * LLVM generates code which only sets the lower bits, while JITted
 413                  * code expects all the bits to be set.
 414                  */
 415                 ptype = LLVMInt32Type ();
 416         }
 417
 418         return ptype;
 419 }
 420
 421 /*
 422  * llvm_type_to_stack_type:
 423  *
 424  *   Return the LLVM type which needs to be used when a value of type TYPE is pushed
 425  * on the IL stack.
 426  */
 427 static G_GNUC_UNUSED LLVMTypeRef
 428 llvm_type_to_stack_type (LLVMTypeRef type)
 429 {
 430         if (type == NULL)
 431                 return NULL;
 432         if (type == LLVMInt8Type ())
 433                 return LLVMInt32Type ();
 434         else if (type == LLVMInt16Type ())
 435                 return LLVMInt32Type ();
 436         else if (type == LLVMFloatType ())
 437                 return LLVMDoubleType ();
 438         else
 439                 return type;
 440 }
 441
 442 /*
 443  * regtype_to_llvm_type:
 444  *
 445  *   Return the LLVM type corresponding to the regtype C used in instruction
 446  * descriptions.
 447  */
 448 static LLVMTypeRef
 449 regtype_to_llvm_type (char c)
 450 {
 451         switch (c) {
 452         case 'i':
 453                 return LLVMInt32Type ();
 454         case 'l':
 455                 return LLVMInt64Type ();
 456         case 'f':
 457                 return LLVMDoubleType ();
 458         default:
 459                 return NULL;
 460         }
 461 }
 462
 463 /*
 464  * op_to_llvm_type:
 465  *
 466  *   Return the LLVM type corresponding to the unary/binary opcode OPCODE.
 467  */
 468 static LLVMTypeRef
 469 op_to_llvm_type (int opcode)
 470 {
 471         switch (opcode) {
 472         case OP_ICONV_TO_I1:
 473         case OP_LCONV_TO_I1:
 474                 return LLVMInt8Type ();
 475         case OP_ICONV_TO_U1:
 476         case OP_LCONV_TO_U1:
 477                 return LLVMInt8Type ();
 478         case OP_ICONV_TO_I2:
 479         case OP_LCONV_TO_I2:
 480                 return LLVMInt16Type ();
 481         case OP_ICONV_TO_U2:
 482         case OP_LCONV_TO_U2:
 483                 return LLVMInt16Type ();
 484         case OP_ICONV_TO_I4:
 485         case OP_LCONV_TO_I4:
 486                 return LLVMInt32Type ();
 487         case OP_ICONV_TO_U4:
 488         case OP_LCONV_TO_U4:
 489                 return LLVMInt32Type ();
 490         case OP_ICONV_TO_I8:
 491                 return LLVMInt64Type ();
 492         case OP_ICONV_TO_R4:
 493                 return LLVMFloatType ();
 494         case OP_ICONV_TO_R8:
 495                 return LLVMDoubleType ();
 496         case OP_ICONV_TO_U8:
 497                 return LLVMInt64Type ();
 498         case OP_FCONV_TO_I4:
 499                 return LLVMInt32Type ();
 500         case OP_FCONV_TO_I8:
 501                 return LLVMInt64Type ();
 502         case OP_FCONV_TO_I1:
 503         case OP_FCONV_TO_U1:
 504                 return LLVMInt8Type ();
 505         case OP_FCONV_TO_I2:
 506         case OP_FCONV_TO_U2:
 507                 return LLVMInt16Type ();
 508         case OP_FCONV_TO_I:
 509         case OP_FCONV_TO_U:
 510                 return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 511         case OP_IADD_OVF:
 512         case OP_IADD_OVF_UN:
 513         case OP_ISUB_OVF:
 514         case OP_ISUB_OVF_UN:
 515         case OP_IMUL_OVF:
 516         case OP_IMUL_OVF_UN:
 517                 return LLVMInt32Type ();
 518         case OP_LADD_OVF:
 519         case OP_LADD_OVF_UN:
 520         case OP_LSUB_OVF:
 521         case OP_LSUB_OVF_UN:
 522         case OP_LMUL_OVF:
 523         case OP_LMUL_OVF_UN:
 524                 return LLVMInt64Type ();
 525         default:
 526                 printf ("%s\n", mono_inst_name (opcode));
 527                 g_assert_not_reached ();
 528                 return NULL;
 529         }
 530 }
 531
 532 /*
 533  * load_store_to_llvm_type:
 534  *
 535  *   Return the size/sign/zero extension corresponding to the load/store opcode
 536  * OPCODE.
 537  */
 538 static LLVMTypeRef
 539 load_store_to_llvm_type (int opcode, int *size, gboolean *sext, gboolean *zext)
 540 {
 541         *sext = FALSE;
 542         *zext = FALSE;
 543
 544         switch (opcode) {
 545         case OP_LOADI1_MEMBASE:
 546         case OP_STOREI1_MEMBASE_REG:
 547         case OP_STOREI1_MEMBASE_IMM:
 548                 *size = 1;
 549                 *sext = TRUE;
 550                 return LLVMInt8Type ();
 551         case OP_LOADU1_MEMBASE:
 552         case OP_LOADU1_MEM:
 553                 *size = 1;
 554                 *zext = TRUE;
 555                 return LLVMInt8Type ();
 556         case OP_LOADI2_MEMBASE:
 557         case OP_STOREI2_MEMBASE_REG:
 558         case OP_STOREI2_MEMBASE_IMM:
 559                 *size = 2;
 560                 *sext = TRUE;
 561                 return LLVMInt16Type ();
 562         case OP_LOADU2_MEMBASE:
 563         case OP_LOADU2_MEM:
 564                 *size = 2;
 565                 *zext = TRUE;
 566                 return LLVMInt16Type ();
 567         case OP_LOADI4_MEMBASE:
 568         case OP_LOADU4_MEMBASE:
 569         case OP_LOADI4_MEM:
 570         case OP_LOADU4_MEM:
 571         case OP_STOREI4_MEMBASE_REG:
 572         case OP_STOREI4_MEMBASE_IMM:
 573                 *size = 4;
 574                 return LLVMInt32Type ();
 575         case OP_LOADI8_MEMBASE:
 576         case OP_LOADI8_MEM:
 577         case OP_STOREI8_MEMBASE_REG:
 578         case OP_STOREI8_MEMBASE_IMM:
 579                 *size = 8;
 580                 return LLVMInt64Type ();
 581         case OP_LOADR4_MEMBASE:
 582         case OP_STORER4_MEMBASE_REG:
 583                 *size = 4;
 584                 return LLVMFloatType ();
 585         case OP_LOADR8_MEMBASE:
 586         case OP_STORER8_MEMBASE_REG:
 587                 *size = 8;
 588                 return LLVMDoubleType ();
 589         case OP_LOAD_MEMBASE:
 590         case OP_LOAD_MEM:
 591         case OP_STORE_MEMBASE_REG:
 592         case OP_STORE_MEMBASE_IMM:
 593                 *size = sizeof (gpointer);
 594                 return IntPtrType ();
 595         default:
 596                 g_assert_not_reached ();
 597                 return NULL;
 598         }
 599 }
 600
 601 /*
 602  * ovf_op_to_intrins:
 603  *
 604  *   Return the LLVM intrinsics corresponding to the overflow opcode OPCODE.
 605  */
 606 static const char*
 607 ovf_op_to_intrins (int opcode)
 608 {
 609         switch (opcode) {
 610         case OP_IADD_OVF:
 611                 return "llvm.sadd.with.overflow.i32";
 612         case OP_IADD_OVF_UN:
 613                 return "llvm.uadd.with.overflow.i32";
 614         case OP_ISUB_OVF:
 615                 return "llvm.ssub.with.overflow.i32";
 616         case OP_ISUB_OVF_UN:
 617                 return "llvm.usub.with.overflow.i32";
 618         case OP_IMUL_OVF:
 619                 return "llvm.smul.with.overflow.i32";
 620         case OP_IMUL_OVF_UN:
 621                 return "llvm.umul.with.overflow.i32";
 622         case OP_LADD_OVF:
 623                 return "llvm.sadd.with.overflow.i64";
 624         case OP_LADD_OVF_UN:
 625                 return "llvm.uadd.with.overflow.i64";
 626         case OP_LSUB_OVF:
 627                 return "llvm.ssub.with.overflow.i64";
 628         case OP_LSUB_OVF_UN:
 629                 return "llvm.usub.with.overflow.i64";
 630         case OP_LMUL_OVF:
 631                 return "llvm.smul.with.overflow.i64";
 632         case OP_LMUL_OVF_UN:
 633                 return "llvm.umul.with.overflow.i64";
 634         default:
 635                 g_assert_not_reached ();
 636                 return NULL;
 637         }
 638 }
 639
 640 static const char*
 641 simd_op_to_intrins (int opcode)
 642 {
 643         switch (opcode) {
 644 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 645         case OP_MINPD:
 646                 return "llvm.x86.sse2.min.pd";
 647         case OP_MINPS:
 648                 return "llvm.x86.sse.min.ps";
 649         case OP_PMIND_UN:
 650                 return "llvm.x86.sse41.pminud";
 651         case OP_PMINW_UN:
 652                 return "llvm.x86.sse41.pminuw";
 653         case OP_PMINB_UN:
 654                 return "llvm.x86.sse2.pminu.b";
 655         case OP_PMINW:
 656                 return "llvm.x86.sse2.pmins.w";
 657         case OP_MAXPD:
 658                 return "llvm.x86.sse2.max.pd";
 659         case OP_MAXPS:
 660                 return "llvm.x86.sse.max.ps";
 661         case OP_HADDPD:
 662                 return "llvm.x86.sse3.hadd.pd";
 663         case OP_HADDPS:
 664                 return "llvm.x86.sse3.hadd.ps";
 665         case OP_HSUBPD:
 666                 return "llvm.x86.sse3.hsub.pd";
 667         case OP_HSUBPS:
 668                 return "llvm.x86.sse3.hsub.ps";
 669         case OP_PMAXD_UN:
 670                 return "llvm.x86.sse41.pmaxud";
 671         case OP_PMAXW_UN:
 672                 return "llvm.x86.sse41.pmaxuw";
 673         case OP_PMAXB_UN:
 674                 return "llvm.x86.sse2.pmaxu.b";
 675         case OP_ADDSUBPS:
 676                 return "llvm.x86.sse3.addsub.ps";
 677         case OP_ADDSUBPD:
 678                 return "llvm.x86.sse3.addsub.pd";
 679         case OP_EXTRACT_MASK:
 680                 return "llvm.x86.sse2.pmovmskb.128";
 681         case OP_PSHRW:
 682         case OP_PSHRW_REG:
 683                 return "llvm.x86.sse2.psrli.w";
 684         case OP_PSHRD:
 685         case OP_PSHRD_REG:
 686                 return "llvm.x86.sse2.psrli.d";
 687         case OP_PSHRQ:
 688         case OP_PSHRQ_REG:
 689                 return "llvm.x86.sse2.psrli.q";
 690         case OP_PSHLW:
 691         case OP_PSHLW_REG:
 692                 return "llvm.x86.sse2.pslli.w";
 693         case OP_PSHLD:
 694         case OP_PSHLD_REG:
 695                 return "llvm.x86.sse2.pslli.d";
 696         case OP_PSHLQ:
 697         case OP_PSHLQ_REG:
 698                 return "llvm.x86.sse2.pslli.q";
 699         case OP_PSARW:
 700         case OP_PSARW_REG:
 701                 return "llvm.x86.sse2.psrai.w";
 702         case OP_PSARD:
 703         case OP_PSARD_REG:
 704                 return "llvm.x86.sse2.psrai.d";
 705         case OP_PADDB_SAT:
 706                 return "llvm.x86.sse2.padds.b";
 707         case OP_PADDW_SAT:
 708                 return "llvm.x86.sse2.padds.w";
 709         case OP_PSUBB_SAT:
 710                 return "llvm.x86.sse2.psubs.b";
 711         case OP_PSUBW_SAT:
 712                 return "llvm.x86.sse2.psubs.w";
 713         case OP_PADDB_SAT_UN:
 714                 return "llvm.x86.sse2.paddus.b";
 715         case OP_PADDW_SAT_UN:
 716                 return "llvm.x86.sse2.paddus.w";
 717         case OP_PSUBB_SAT_UN:
 718                 return "llvm.x86.sse2.psubus.b";
 719         case OP_PSUBW_SAT_UN:
 720                 return "llvm.x86.sse2.psubus.w";
 721         case OP_PAVGB_UN:
 722                 return "llvm.x86.sse2.pavg.b";
 723         case OP_PAVGW_UN:
 724                 return "llvm.x86.sse2.pavg.w";
 725         case OP_SQRTPS:
 726                 return "llvm.x86.sse.sqrt.ps";
 727         case OP_SQRTPD:
 728                 return "llvm.x86.sse2.sqrt.pd";
 729         case OP_RSQRTPS:
 730                 return "llvm.x86.sse.rsqrt.ps";
 731         case OP_RCPPS:
 732                 return "llvm.x86.sse.rcp.ps";
 733         case OP_CVTDQ2PD:
 734                 return "llvm.x86.sse2.cvtdq2pd";
 735         case OP_CVTDQ2PS:
 736                 return "llvm.x86.sse2.cvtdq2ps";
 737         case OP_CVTPD2DQ:
 738                 return "llvm.x86.sse2.cvtpd2dq";
 739         case OP_CVTPS2DQ:
 740                 return "llvm.x86.sse2.cvtps2dq";
 741         case OP_CVTPD2PS:
 742                 return "llvm.x86.sse2.cvtpd2ps";
 743         case OP_CVTPS2PD:
 744                 return "llvm.x86.sse2.cvtps2pd";
 745         case OP_CVTTPD2DQ:
 746                 return "llvm.x86.sse2.cvttpd2dq";
 747         case OP_CVTTPS2DQ:
 748                 return "llvm.x86.sse2.cvttps2dq";
 749         case OP_COMPPS:
 750                 return "llvm.x86.sse.cmp.ps";
 751         case OP_COMPPD:
 752                 return "llvm.x86.sse2.cmp.pd";
 753         case OP_PACKW:
 754                 return "llvm.x86.sse2.packsswb.128";
 755         case OP_PACKD:
 756                 return "llvm.x86.sse2.packssdw.128";
 757         case OP_PACKW_UN:
 758                 return "llvm.x86.sse2.packuswb.128";
 759         case OP_PACKD_UN:
 760                 return "llvm.x86.sse41.packusdw";
 761         case OP_PMULW_HIGH:
 762                 return "llvm.x86.sse2.pmulh.w";
 763         case OP_PMULW_HIGH_UN:
 764                 return "llvm.x86.sse2.pmulhu.w";
 765 #endif
 766         default:
 767                 g_assert_not_reached ();
 768                 return NULL;
 769         }
 770 }
 771
 772 static LLVMTypeRef
 773 simd_op_to_llvm_type (int opcode)
 774 {
 775 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 776         switch (opcode) {
 777         case OP_EXTRACT_R8:
 778         case OP_EXPAND_R8:
 779                 return type_to_simd_type (MONO_TYPE_R8);
 780         case OP_EXTRACT_I8:
 781         case OP_EXPAND_I8:
 782                 return type_to_simd_type (MONO_TYPE_I8);
 783         case OP_EXTRACT_I4:
 784         case OP_EXPAND_I4:
 785                 return type_to_simd_type (MONO_TYPE_I4);
 786         case OP_EXTRACT_I2:
 787         case OP_EXTRACT_U2:
 788         case OP_EXTRACTX_U2:
 789         case OP_EXPAND_I2:
 790                 return type_to_simd_type (MONO_TYPE_I2);
 791         case OP_EXTRACT_I1:
 792         case OP_EXTRACT_U1:
 793         case OP_EXPAND_I1:
 794                 return type_to_simd_type (MONO_TYPE_I1);
 795         case OP_EXPAND_R4:
 796                 return type_to_simd_type (MONO_TYPE_R4);
 797         case OP_CVTDQ2PD:
 798         case OP_CVTDQ2PS:
 799                 return type_to_simd_type (MONO_TYPE_I4);
 800         case OP_CVTPD2DQ:
 801         case OP_CVTPD2PS:
 802         case OP_CVTTPD2DQ:
 803                 return type_to_simd_type (MONO_TYPE_R8);
 804         case OP_CVTPS2DQ:
 805         case OP_CVTPS2PD:
 806         case OP_CVTTPS2DQ:
 807                 return type_to_simd_type (MONO_TYPE_R4);
 808         case OP_EXTRACT_MASK:
 809                 return type_to_simd_type (MONO_TYPE_I1);
 810         case OP_SQRTPS:
 811         case OP_RSQRTPS:
 812         case OP_RCPPS:
 813         case OP_DUPPS_LOW:
 814         case OP_DUPPS_HIGH:
 815                 return type_to_simd_type (MONO_TYPE_R4);
 816         case OP_SQRTPD:
 817         case OP_DUPPD:
 818                 return type_to_simd_type (MONO_TYPE_R8);
 819         default:
 820                 g_assert_not_reached ();
 821                 return NULL;
 822         }
 823 #else
 824         return NULL;
 825 #endif
 826 }
 827
 828 /*
 829  * get_bb:
 830  *
 831  *   Return the LLVM basic block corresponding to BB.
 832  */
 833 static LLVMBasicBlockRef
 834 get_bb (EmitContext *ctx, MonoBasicBlock *bb)
 835 {
 836         char bb_name [128];
 837
 838         if (ctx->bblocks [bb->block_num].bblock == NULL) {
 839                 if (bb->flags & BB_EXCEPTION_HANDLER) {
 840                         int clause_index = (mono_get_block_region_notry (ctx->cfg, bb->region) >> 8) - 1;
 841                         sprintf (bb_name, "EH_CLAUSE%d_BB%d", clause_index, bb->block_num);
 842                 } else {
 843                         sprintf (bb_name, "BB%d", bb->block_num);
 844                 }
 845
 846                 ctx->bblocks [bb->block_num].bblock = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
 847                 ctx->bblocks [bb->block_num].end_bblock = ctx->bblocks [bb->block_num].bblock;
 848         }
 849
 850         return ctx->bblocks [bb->block_num].bblock;
 851 }
 852
 853 /*
 854  * get_end_bb:
 855  *
 856  *   Return the last LLVM bblock corresponding to BB.
 857  * This might not be equal to the bb returned by get_bb () since we need to generate
 858  * multiple LLVM bblocks for a mono bblock to handle throwing exceptions.
 859  */
 860 static LLVMBasicBlockRef
 861 get_end_bb (EmitContext *ctx, MonoBasicBlock *bb)
 862 {
 863         get_bb (ctx, bb);
 864         return ctx->bblocks [bb->block_num].end_bblock;
 865 }
 866
 867 static LLVMBasicBlockRef
 868 gen_bb (EmitContext *ctx, const char *prefix)
 869 {
 870         char bb_name [128];
 871
 872         sprintf (bb_name, "%s%d", prefix, ++ ctx->ex_index);
 873         return LLVMAppendBasicBlock (ctx->lmethod, bb_name);
 874 }
 875
 876 /*
 877  * resolve_patch:
 878  *
 879  *   Return the target of the patch identified by TYPE and TARGET.
 880  */
 881 static gpointer
 882 resolve_patch (MonoCompile *cfg, MonoJumpInfoType type, gconstpointer target)
 883 {
 884         MonoJumpInfo ji;
 885
 886         memset (&ji, 0, sizeof (ji));
 887         ji.type = type;
 888         ji.data.target = target;
 889
 890         return mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
 891 }
 892
 893 /*
 894  * convert_full:
 895  *
 896  *   Emit code to convert the LLVM value V to DTYPE.
 897  */
 898 static LLVMValueRef
 899 convert_full (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype, gboolean is_unsigned)
 900 {
 901         LLVMTypeRef stype = LLVMTypeOf (v);
 902
 903         if (stype != dtype) {
 904                 gboolean ext = FALSE;
 905
 906                 /* Extend */
 907                 if (dtype == LLVMInt64Type () && (stype == LLVMInt32Type () || stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
 908                         ext = TRUE;
 909                 else if (dtype == LLVMInt32Type () && (stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
 910                         ext = TRUE;
 911                 else if (dtype == LLVMInt16Type () && (stype == LLVMInt8Type ()))
 912                         ext = TRUE;
 913
 914                 if (ext)
 915                         return is_unsigned ? LLVMBuildZExt (ctx->builder, v, dtype, "") : LLVMBuildSExt (ctx->builder, v, dtype, "");
 916
 917                 if (dtype == LLVMDoubleType () && stype == LLVMFloatType ())
 918                         return LLVMBuildFPExt (ctx->builder, v, dtype, "");
 919
 920                 /* Trunc */
 921                 if (stype == LLVMInt64Type () && (dtype == LLVMInt32Type () || dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
 922                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 923                 if (stype == LLVMInt32Type () && (dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
 924                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 925                 if (stype == LLVMInt16Type () && dtype == LLVMInt8Type ())
 926                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 927                 if (stype == LLVMDoubleType () && dtype == LLVMFloatType ())
 928                         return LLVMBuildFPTrunc (ctx->builder, v, dtype, "");
 929
 930                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind && LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
 931                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 932                 if (LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
 933                         return LLVMBuildIntToPtr (ctx->builder, v, dtype, "");
 934                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind)
 935                         return LLVMBuildPtrToInt (ctx->builder, v, dtype, "");
 936
 937                 if (mono_arch_is_soft_float ()) {
 938                         if (stype == LLVMInt32Type () && dtype == LLVMFloatType ())
 939                                 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 940                         if (stype == LLVMInt32Type () && dtype == LLVMDoubleType ())
 941                                 return LLVMBuildBitCast (ctx->builder, LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), ""), dtype, "");
 942                 }
 943
 944                 if (LLVMGetTypeKind (stype) == LLVMVectorTypeKind && LLVMGetTypeKind (dtype) == LLVMVectorTypeKind)
 945                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 946
 947                 LLVMDumpValue (v);
 948                 LLVMDumpValue (LLVMConstNull (dtype));
 949                 g_assert_not_reached ();
 950                 return NULL;
 951         } else {
 952                 return v;
 953         }
 954 }
 955
 956 static LLVMValueRef
 957 convert (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype)
 958 {
 959         return convert_full (ctx, v, dtype, FALSE);
 960 }
 961
 962 /*
 963  * emit_volatile_load:
 964  *
 965  *   If vreg is volatile, emit a load from its address.
 966  */
 967 static LLVMValueRef
 968 emit_volatile_load (EmitContext *ctx, int vreg)
 969 {
 970         MonoType *t;
 971
 972         LLVMValueRef v = LLVMBuildLoad (ctx->builder, ctx->addresses [vreg], "");
 973         t = ctx->vreg_cli_types [vreg];
 974         if (t && !t->byref) {
 975                 /*
 976                  * Might have to zero extend since llvm doesn't have
 977                  * unsigned types.
 978                  */
 979                 if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_U2 || t->type == MONO_TYPE_CHAR || t->type == MONO_TYPE_BOOLEAN)
 980                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt32Type (), "");
 981                 else if (t->type == MONO_TYPE_U8)
 982                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), "");
 983         }
 984
 985         return v;
 986 }
 987
 988 /*
 989  * emit_volatile_store:
 990  *
 991  *   If VREG is volatile, emit a store from its value to its address.
 992  */
 993 static void
 994 emit_volatile_store (EmitContext *ctx, int vreg)
 995 {
 996         MonoInst *var = get_vreg_to_inst (ctx->cfg, vreg);
 997
 998         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
 999                 g_assert (ctx->addresses [vreg]);
1000                 LLVMBuildStore (ctx->builder, convert (ctx, ctx->values [vreg], type_to_llvm_type (ctx, var->inst_vtype)), ctx->addresses [vreg]);
1001         }
1002 }
1003
1004 typedef struct {
1005         /*
1006          * Maps parameter indexes in the original signature to parameter indexes
1007          * in the LLVM signature.
1008          */
1009         int *pindexes;
1010         /* The indexes of various special arguments in the LLVM signature */
1011         int vret_arg_pindex, this_arg_pindex, rgctx_arg_pindex, imt_arg_pindex;
1012 } LLVMSigInfo;
1013
1014 /*
1015  * sig_to_llvm_sig_full:
1016  *
1017  *   Return the LLVM signature corresponding to the mono signature SIG using the
1018  * calling convention information in CINFO. Return parameter mapping information in SINFO.
1019  */
1020 static LLVMTypeRef
1021 sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo *cinfo,
1022                                           LLVMSigInfo *sinfo)
1023 {
1024         LLVMTypeRef ret_type;
1025         LLVMTypeRef *param_types = NULL;
1026         LLVMTypeRef res;
1027         int i, j, pindex, vret_arg_pindex = 0;
1028         int *pindexes;
1029         gboolean vretaddr = FALSE;
1030
1031         if (sinfo)
1032                 memset (sinfo, 0, sizeof (LLVMSigInfo));
1033
1034         ret_type = type_to_llvm_type (ctx, sig->ret);
1035         CHECK_FAILURE (ctx);
1036
1037         if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
1038                 /* LLVM models this by returning an aggregate value */
1039                 if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgNone) {
1040                         LLVMTypeRef members [2];
1041
1042                         members [0] = IntPtrType ();
1043                         ret_type = LLVMStructType (members, 1, FALSE);
1044                 } else {
1045                         g_assert_not_reached ();
1046                 }
1047         } else if (cinfo && mini_type_is_vtype (ctx->cfg, sig->ret)) {
1048                 g_assert (cinfo->ret.storage == LLVMArgVtypeRetAddr);
1049                 vretaddr = TRUE;
1050                 ret_type = LLVMVoidType ();
1051         }
1052
1053         pindexes = g_new0 (int, sig->param_count);
1054         param_types = g_new0 (LLVMTypeRef, (sig->param_count * 2) + 3);
1055         pindex = 0;
1056         if (cinfo && cinfo->rgctx_arg) {
1057                 if (sinfo)
1058                         sinfo->rgctx_arg_pindex = pindex;
1059                 param_types [pindex] = IntPtrType ();
1060                 pindex ++;
1061         }
1062         if (cinfo && cinfo->imt_arg) {
1063                 if (sinfo)
1064                         sinfo->imt_arg_pindex = pindex;
1065                 param_types [pindex] = IntPtrType ();
1066                 pindex ++;
1067         }
1068         if (vretaddr) {
1069                 /* Compute the index in the LLVM signature where the vret arg needs to be passed */
1070                 vret_arg_pindex = pindex;
1071                 if (cinfo->vret_arg_index == 1) {
1072                         /* Add the slots consumed by the first argument */
1073                         LLVMArgInfo *ainfo = &cinfo->args [0];
1074                         switch (ainfo->storage) {
1075                         case LLVMArgVtypeInReg:
1076                                 for (j = 0; j < 2; ++j) {
1077                                         if (ainfo->pair_storage [j] == LLVMArgInIReg)
1078                                                 vret_arg_pindex ++;
1079                                 }
1080                                 break;
1081                         default:
1082                                 vret_arg_pindex ++;
1083                         }
1084                 }
1085
1086                 if (sinfo)
1087                         sinfo->vret_arg_pindex = vret_arg_pindex;
1088         }
1089
1090         if (vretaddr && vret_arg_pindex == pindex)
1091                 param_types [pindex ++] = IntPtrType ();
1092         if (sig->hasthis) {
1093                 if (sinfo)
1094                         sinfo->this_arg_pindex = pindex;
1095                 param_types [pindex ++] = IntPtrType ();
1096         }
1097         if (vretaddr && vret_arg_pindex == pindex)
1098                 param_types [pindex ++] = IntPtrType ();
1099         for (i = 0; i < sig->param_count; ++i) {
1100                 if (vretaddr && vret_arg_pindex == pindex)
1101                         param_types [pindex ++] = IntPtrType ();
1102                 pindexes [i] = pindex;
1103                 if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeInReg) {
1104                         for (j = 0; j < 2; ++j) {
1105                                 switch (cinfo->args [i + sig->hasthis].pair_storage [j]) {
1106                                 case LLVMArgInIReg:
1107                                         param_types [pindex ++] = LLVMIntType (sizeof (gpointer) * 8);
1108                                         break;
1109                                 case LLVMArgNone:
1110                                         break;
1111                                 default:
1112                                         g_assert_not_reached ();
1113                                 }
1114                         }
1115                 } else if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal) {
1116                         param_types [pindex] = type_to_llvm_arg_type (ctx, sig->params [i]);
1117                         CHECK_FAILURE (ctx);
1118                         param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1119                         pindex ++;
1120                 } else {
1121                         param_types [pindex ++] = type_to_llvm_arg_type (ctx, sig->params [i]);
1122                 }
1123         }
1124         if (vretaddr && vret_arg_pindex == pindex)
1125                 param_types [pindex ++] = IntPtrType ();
1126
1127         CHECK_FAILURE (ctx);
1128
1129         res = LLVMFunctionType (ret_type, param_types, pindex, FALSE);
1130         g_free (param_types);
1131
1132         if (sinfo) {
1133                 sinfo->pindexes = pindexes;
1134         } else {
1135                 g_free (pindexes);
1136         }
1137
1138         return res;
1139
1140  FAILURE:
1141         g_free (param_types);
1142
1143         return NULL;
1144 }
1145
1146 static LLVMTypeRef
1147 sig_to_llvm_sig (EmitContext *ctx, MonoMethodSignature *sig)
1148 {
1149         return sig_to_llvm_sig_full (ctx, sig, NULL, NULL);
1150 }
1151
1152 /*
1153  * LLVMFunctionType1:
1154  *
1155  *   Create an LLVM function type from the arguments.
1156  */
1157 static G_GNUC_UNUSED LLVMTypeRef
1158 LLVMFunctionType1(LLVMTypeRef ReturnType,
1159                                   LLVMTypeRef ParamType1,
1160                                   int IsVarArg)
1161 {
1162         LLVMTypeRef param_types [1];
1163
1164         param_types [0] = ParamType1;
1165
1166         return LLVMFunctionType (ReturnType, param_types, 1, IsVarArg);
1167 }
1168
1169 /*
1170  * LLVMFunctionType2:
1171  *
1172  *   Create an LLVM function type from the arguments.
1173  */
1174 static G_GNUC_UNUSED LLVMTypeRef
1175 LLVMFunctionType2(LLVMTypeRef ReturnType,
1176                                   LLVMTypeRef ParamType1,
1177                                   LLVMTypeRef ParamType2,
1178                                   int IsVarArg)
1179 {
1180         LLVMTypeRef param_types [2];
1181
1182         param_types [0] = ParamType1;
1183         param_types [1] = ParamType2;
1184
1185         return LLVMFunctionType (ReturnType, param_types, 2, IsVarArg);
1186 }
1187
1188 /*
1189  * LLVMFunctionType3:
1190  *
1191  *   Create an LLVM function type from the arguments.
1192  */
1193 static G_GNUC_UNUSED LLVMTypeRef
1194 LLVMFunctionType3(LLVMTypeRef ReturnType,
1195                                   LLVMTypeRef ParamType1,
1196                                   LLVMTypeRef ParamType2,
1197                                   LLVMTypeRef ParamType3,
1198                                   int IsVarArg)
1199 {
1200         LLVMTypeRef param_types [3];
1201
1202         param_types [0] = ParamType1;
1203         param_types [1] = ParamType2;
1204         param_types [2] = ParamType3;
1205
1206         return LLVMFunctionType (ReturnType, param_types, 3, IsVarArg);
1207 }
1208
1209 /*
1210  * create_builder:
1211  *
1212  *   Create an LLVM builder and remember it so it can be freed later.
1213  */
1214 static LLVMBuilderRef
1215 create_builder (EmitContext *ctx)
1216 {
1217         LLVMBuilderRef builder = LLVMCreateBuilder ();
1218
1219         ctx->builders = g_slist_prepend_mempool (ctx->cfg->mempool, ctx->builders, builder);
1220
1221         return builder;
1222 }
1223
1224 static LLVMValueRef
1225 get_plt_entry (EmitContext *ctx, LLVMTypeRef llvm_sig, MonoJumpInfoType type, gconstpointer data)
1226 {
1227         char *callee_name = mono_aot_get_plt_symbol (type, data);
1228         LLVMValueRef callee;
1229
1230         if (!callee_name)
1231                 return NULL;
1232
1233         if (ctx->cfg->compile_aot)
1234                 /* Add a patch so referenced wrappers can be compiled in full aot mode */
1235                 mono_add_patch_info (ctx->cfg, 0, type, data);
1236
1237         // FIXME: Locking
1238         callee = g_hash_table_lookup (ctx->lmodule->plt_entries, callee_name);
1239         if (!callee) {
1240                 callee = LLVMAddFunction (ctx->module, callee_name, llvm_sig);
1241
1242                 LLVMSetVisibility (callee, LLVMHiddenVisibility);
1243
1244                 g_hash_table_insert (ctx->lmodule->plt_entries, (char*)callee_name, callee);
1245         }
1246
1247         return callee;
1248 }
1249
1250 static int
1251 get_handler_clause (MonoCompile *cfg, MonoBasicBlock *bb)
1252 {
1253         MonoMethodHeader *header = cfg->header;
1254         MonoExceptionClause *clause;
1255         int i;
1256
1257         /* Directly */
1258         if (bb->region != -1 && MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))
1259                 return (bb->region >> 8) - 1;
1260
1261         /* Indirectly */
1262         for (i = 0; i < header->num_clauses; ++i) {
1263                 clause = &header->clauses [i];
1264
1265                 if (MONO_OFFSET_IN_CLAUSE (clause, bb->real_offset) && clause->flags == MONO_EXCEPTION_CLAUSE_NONE)
1266                         return i;
1267         }
1268
1269         return -1;
1270 }
1271
1272 static void
1273 set_metadata_flag (LLVMValueRef v, const char *flag_name)
1274 {
1275         LLVMValueRef md_arg;
1276         int md_kind;
1277
1278         md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1279         md_arg = LLVMMDString ("mono", 4);
1280         LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1281 }
1282
1283 /*
1284  * emit_call:
1285  *
1286  *   Emit an LLVM call or invoke instruction depending on whenever the call is inside
1287  * a try region.
1288  */
1289 static LLVMValueRef
1290 emit_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, LLVMValueRef callee, LLVMValueRef *args, int pindex)
1291 {
1292         MonoCompile *cfg = ctx->cfg;
1293         LLVMValueRef lcall;
1294         LLVMBuilderRef builder = *builder_ref;
1295         int clause_index;
1296
1297         clause_index = get_handler_clause (cfg, bb);
1298
1299         if (clause_index != -1) {
1300                 MonoMethodHeader *header = cfg->header;
1301                 MonoExceptionClause *ec = &header->clauses [clause_index];
1302                 MonoBasicBlock *tblock;
1303                 LLVMBasicBlockRef ex_bb, noex_bb;
1304
1305                 /*
1306                  * Have to use an invoke instead of a call, branching to the
1307                  * handler bblock of the clause containing this bblock.
1308                  */
1309
1310                 g_assert (ec->flags == MONO_EXCEPTION_CLAUSE_NONE || ec->flags == MONO_EXCEPTION_CLAUSE_FINALLY);
1311
1312                 tblock = cfg->cil_offset_to_bb [ec->handler_offset];
1313                 g_assert (tblock);
1314
1315                 ctx->bblocks [tblock->block_num].invoke_target = TRUE;
1316
1317                 ex_bb = get_bb (ctx, tblock);
1318
1319                 noex_bb = gen_bb (ctx, "NOEX_BB");
1320
1321                 /* Use an invoke */
1322                 lcall = LLVMBuildInvoke (builder, callee, args, pindex, noex_bb, ex_bb, "");
1323
1324                 builder = ctx->builder = create_builder (ctx);
1325                 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1326
1327                 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1328         } else {
1329                 lcall = LLVMBuildCall (builder, callee, args, pindex, "");
1330                 ctx->builder = builder;
1331         }
1332
1333         *builder_ref = ctx->builder;
1334
1335         return lcall;
1336 }
1337
1338 static LLVMValueRef
1339 emit_load (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef addr, const char *name, gboolean is_faulting)
1340 {
1341         const char *intrins_name;
1342         LLVMValueRef args [16], res;
1343         LLVMTypeRef addr_type;
1344
1345         if (is_faulting && bb->region != -1) {
1346                 /*
1347                  * We handle loads which can fault by calling a mono specific intrinsic
1348                  * using an invoke, so they are handled properly inside try blocks.
1349                  * We can't use this outside clauses, since LLVM optimizes intrinsics which
1350                  * are marked with IntrReadArgMem.
1351                  */
1352                 switch (size) {
1353                 case 1:
1354                         intrins_name = "llvm.mono.load.i8.p0i8";
1355                         break;
1356                 case 2:
1357                         intrins_name = "llvm.mono.load.i16.p0i16";
1358                         break;
1359                 case 4:
1360                         intrins_name = "llvm.mono.load.i32.p0i32";
1361                         break;
1362                 case 8:
1363                         intrins_name = "llvm.mono.load.i64.p0i64";
1364                         break;
1365                 default:
1366                         g_assert_not_reached ();
1367                 }
1368
1369                 addr_type = LLVMTypeOf (addr);
1370                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0) || addr_type == LLVMPointerType (LLVMFloatType (), 0))
1371                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1372
1373                 args [0] = addr;
1374                 args [1] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1375                 args [2] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1376                 res = emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 3);
1377
1378                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0))
1379                         res = LLVMBuildBitCast (*builder_ref, res, LLVMDoubleType (), "");
1380                 else if (addr_type == LLVMPointerType (LLVMFloatType (), 0))
1381                         res = LLVMBuildBitCast (*builder_ref, res, LLVMFloatType (), "");
1382
1383                 return res;
1384         } else {
1385                 LLVMValueRef res;
1386
1387                 /*
1388                  * We emit volatile loads for loads which can fault, because otherwise
1389                  * LLVM will generate invalid code when encountering a load from a
1390                  * NULL address.
1391                  */
1392                  res = mono_llvm_build_load (*builder_ref, addr, name, is_faulting);
1393
1394                  /* Mark it with a custom metadata */
1395                  /*
1396                  if (is_faulting)
1397                          set_metadata_flag (res, "mono.faulting.load");
1398                  */
1399
1400                  return res;
1401         }
1402 }
1403
1404 static void
1405 emit_store (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef value, LLVMValueRef addr, gboolean is_faulting)
1406 {
1407         const char *intrins_name;
1408         LLVMValueRef args [16];
1409
1410         if (is_faulting && bb->region != -1) {
1411                 switch (size) {
1412                 case 1:
1413                         intrins_name = "llvm.mono.store.i8.p0i8";
1414                         break;
1415                 case 2:
1416                         intrins_name = "llvm.mono.store.i16.p0i16";
1417                         break;
1418                 case 4:
1419                         intrins_name = "llvm.mono.store.i32.p0i32";
1420                         break;
1421                 case 8:
1422                         intrins_name = "llvm.mono.store.i64.p0i64";
1423                         break;
1424                 default:
1425                         g_assert_not_reached ();
1426                 }
1427
1428                 if (LLVMTypeOf (value) == LLVMDoubleType () || LLVMTypeOf (value) == LLVMFloatType ()) {
1429                         value = LLVMBuildBitCast (*builder_ref, value, LLVMIntType (size * 8), "");
1430                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1431                 }
1432
1433                 args [0] = value;
1434                 args [1] = addr;
1435                 args [2] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1436                 args [3] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1437                 emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 4);
1438         } else {
1439                 LLVMBuildStore (*builder_ref, value, addr);
1440         }
1441 }
1442
1443 /*
1444  * emit_cond_system_exception:
1445  *
1446  *   Emit code to throw the exception EXC_TYPE if the condition CMP is false.
1447  * Might set the ctx exception.
1448  */
1449 static void
1450 emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *exc_type, LLVMValueRef cmp)
1451 {
1452         LLVMBasicBlockRef ex_bb, noex_bb;
1453         LLVMBuilderRef builder;
1454         MonoClass *exc_class;
1455         LLVMValueRef args [2];
1456
1457         ex_bb = gen_bb (ctx, "EX_BB");
1458         noex_bb = gen_bb (ctx, "NOEX_BB");
1459
1460         LLVMBuildCondBr (ctx->builder, cmp, ex_bb, noex_bb);
1461
1462         exc_class = mono_class_from_name (mono_get_corlib (), "System", exc_type);
1463         g_assert (exc_class);
1464
1465         /* Emit exception throwing code */
1466         builder = create_builder (ctx);
1467         LLVMPositionBuilderAtEnd (builder, ex_bb);
1468
1469         if (!ctx->lmodule->throw_corlib_exception) {
1470                 LLVMValueRef callee;
1471                 LLVMTypeRef sig;
1472                 const char *icall_name;
1473
1474                 MonoMethodSignature *throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 2);
1475                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
1476                 throw_sig->params [0] = &mono_get_int32_class ()->byval_arg;
1477                 icall_name = "llvm_throw_corlib_exception_abs_trampoline";
1478                 throw_sig->params [1] = &mono_get_intptr_class ()->byval_arg;
1479                 sig = sig_to_llvm_sig (ctx, throw_sig);
1480
1481                 if (ctx->cfg->compile_aot) {
1482                         callee = get_plt_entry (ctx, sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
1483                 } else {
1484                         callee = LLVMAddFunction (ctx->module, "llvm_throw_corlib_exception_trampoline", sig_to_llvm_sig (ctx, throw_sig));
1485
1486                         /*
1487                          * Differences between the LLVM/non-LLVM throw corlib exception trampoline:
1488                          * - On x86, LLVM generated code doesn't push the arguments
1489                          * - When using the LLVM mono branch, the trampoline takes the throw address as an
1490                          *   arguments, not a pc offset.
1491                          */
1492                         LLVMAddGlobalMapping (ee, callee, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
1493                 }
1494
1495                 mono_memory_barrier ();
1496                 ctx->lmodule->throw_corlib_exception = callee;
1497         }
1498
1499         if (IS_TARGET_X86)
1500                 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
1501         else
1502                 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token, FALSE);
1503
1504         /*
1505          * The LLVM mono branch contains changes so a block address can be passed as an
1506          * argument to a call.
1507          */
1508         args [1] = LLVMBuildPtrToInt (builder, LLVMBlockAddress (ctx->lmethod, ex_bb), IntPtrType (), "");
1509         emit_call (ctx, bb, &builder, ctx->lmodule->throw_corlib_exception, args, 2);
1510
1511         LLVMBuildUnreachable (builder);
1512
1513         ctx->builder = create_builder (ctx);
1514         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1515
1516         ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1517
1518         ctx->ex_index ++;
1519         return;
1520 }
1521
1522 /*
1523  * emit_reg_to_vtype:
1524  *
1525  *   Emit code to store the vtype in the registers REGS to the address ADDRESS.
1526  */
1527 static void
1528 emit_reg_to_vtype (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs)
1529 {
1530         int j, size;
1531
1532         size = get_vtype_size (t);
1533
1534         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1535                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1536         }
1537
1538         for (j = 0; j < 2; ++j) {
1539                 LLVMValueRef index [2], addr;
1540                 int part_size = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1541                 LLVMTypeRef part_type;
1542
1543                 if (ainfo->pair_storage [j] == LLVMArgNone)
1544                         continue;
1545
1546                 part_type = LLVMIntType (part_size * 8);
1547                 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1548                         index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1549                         addr = LLVMBuildGEP (builder, address, index, 1, "");
1550                 } else {
1551                         index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1552                         index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1553                         addr = LLVMBuildGEP (builder, address, index, 2, "");
1554                 }
1555                 switch (ainfo->pair_storage [j]) {
1556                 case LLVMArgInIReg:
1557                         LLVMBuildStore (builder, convert (ctx, regs [j], part_type), LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (part_type, 0), ""));
1558                         break;
1559                 case LLVMArgNone:
1560                         break;
1561                 default:
1562                         g_assert_not_reached ();
1563                 }
1564
1565                 size -= sizeof (gpointer);
1566         }
1567 }
1568
1569 /*
1570  * emit_vtype_to_reg:
1571  *
1572  *   Emit code to load a vtype at address ADDRESS into registers. Store the registers
1573  * into REGS, and the number of registers into NREGS.
1574  */
1575 static void
1576 emit_vtype_to_reg (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs, guint32 *nregs)
1577 {
1578         int pindex = 0;
1579         int j, size;
1580
1581         size = get_vtype_size (t);
1582
1583         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1584                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1585         }
1586
1587         for (j = 0; j < 2; ++j) {
1588                 LLVMValueRef index [2], addr;
1589                 int partsize = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1590
1591                 if (ainfo->pair_storage [j] == LLVMArgNone)
1592                         continue;
1593
1594                 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1595                         index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1596                         addr = LLVMBuildGEP (builder, address, index, 1, "");
1597                 } else {
1598                         index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1599                         index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1600                         addr = LLVMBuildGEP (builder, address, index, 2, "");
1601                 }
1602                 switch (ainfo->pair_storage [j]) {
1603                 case LLVMArgInIReg:
1604                         regs [pindex ++] = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (LLVMIntType (partsize * 8), 0), ""), ""), IntPtrType ());
1605                         break;
1606                 case LLVMArgNone:
1607                         break;
1608                 default:
1609                         g_assert_not_reached ();
1610                 }
1611                 size -= sizeof (gpointer);
1612         }
1613
1614         *nregs = pindex;
1615 }
1616
1617 static LLVMValueRef
1618 build_alloca (EmitContext *ctx, MonoType *t)
1619 {
1620         MonoClass *k = mono_class_from_mono_type (t);
1621         int align;
1622
1623         if (MONO_CLASS_IS_SIMD (ctx->cfg, k))
1624                 align = 16;
1625         else
1626                 align = mono_class_min_align (k);
1627
1628         /* Sometimes align is not a power of 2 */
1629         while (mono_is_power_of_two (align) == -1)
1630                 align ++;
1631
1632         /*
1633          * Have to place all alloca's at the end of the entry bb, since otherwise they would
1634          * get executed every time control reaches them.
1635          */
1636         LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca);
1637
1638         ctx->last_alloca = mono_llvm_build_alloca (ctx->alloca_builder, type_to_llvm_type (ctx, t), NULL, align, "");
1639         return ctx->last_alloca;
1640 }
1641
1642 /*
1643  * Put the global into the 'llvm.used' array to prevent it from being optimized away.
1644  */
1645 static void
1646 mark_as_used (LLVMModuleRef module, LLVMValueRef global)
1647 {
1648         LLVMTypeRef used_type;
1649         LLVMValueRef used, used_elem;
1650
1651         used_type = LLVMArrayType (LLVMPointerType (LLVMInt8Type (), 0), 1);
1652         used = LLVMAddGlobal (module, used_type, "llvm.used");
1653         used_elem = LLVMConstBitCast (global, LLVMPointerType (LLVMInt8Type (), 0));
1654         LLVMSetInitializer (used, LLVMConstArray (LLVMPointerType (LLVMInt8Type (), 0), &used_elem, 1));
1655         LLVMSetLinkage (used, LLVMAppendingLinkage);
1656         LLVMSetSection (used, "llvm.metadata");
1657 }
1658
1659 /*
1660  * emit_entry_bb:
1661  *
1662  *   Emit code to load/convert arguments.
1663  */
1664 static void
1665 emit_entry_bb (EmitContext *ctx, LLVMBuilderRef builder)
1666 {
1667         int i, pindex;
1668         MonoCompile *cfg = ctx->cfg;
1669         MonoMethodSignature *sig = ctx->sig;
1670         LLVMCallInfo *linfo = ctx->linfo;
1671         MonoBasicBlock *bb;
1672
1673         ctx->alloca_builder = create_builder (ctx);
1674
1675         /*
1676          * Handle indirect/volatile variables by allocating memory for them
1677          * using 'alloca', and storing their address in a temporary.
1678          */
1679         for (i = 0; i < cfg->num_varinfo; ++i) {
1680                 MonoInst *var = cfg->varinfo [i];
1681                 LLVMTypeRef vtype;
1682
1683                 if (var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) || mini_type_is_vtype (cfg, var->inst_vtype)) {
1684                         vtype = type_to_llvm_type (ctx, var->inst_vtype);
1685                         CHECK_FAILURE (ctx);
1686                         /* Could be already created by an OP_VPHI */
1687                         if (!ctx->addresses [var->dreg])
1688                                 ctx->addresses [var->dreg] = build_alloca (ctx, var->inst_vtype);
1689                         ctx->vreg_cli_types [var->dreg] = var->inst_vtype;
1690                 }
1691         }
1692
1693         for (i = 0; i < sig->param_count; ++i) {
1694                 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
1695                 int reg = cfg->args [i + sig->hasthis]->dreg;
1696
1697                 if (ainfo->storage == LLVMArgVtypeInReg) {
1698                         LLVMValueRef regs [2];
1699
1700                         /*
1701                          * Emit code to save the argument from the registers to
1702                          * the real argument.
1703                          */
1704                         pindex = ctx->pindexes [i];
1705                         regs [0] = LLVMGetParam (ctx->lmethod, pindex);
1706                         if (ainfo->pair_storage [1] != LLVMArgNone)
1707                                 regs [1] = LLVMGetParam (ctx->lmethod, pindex + 1);
1708                         else
1709                                 regs [1] = NULL;
1710
1711                         ctx->addresses [reg] = build_alloca (ctx, sig->params [i]);
1712
1713                         emit_reg_to_vtype (ctx, builder, sig->params [i], ctx->addresses [reg], ainfo, regs);
1714
1715                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1716                                 /* Treat these as normal values */
1717                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1718                         }
1719                 } else if (ainfo->storage == LLVMArgVtypeByVal) {
1720                         ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, ctx->pindexes [i]);
1721
1722                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1723                                 /* Treat these as normal values */
1724                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1725                         }
1726                 } else {
1727                         ctx->values [reg] = convert (ctx, ctx->values [reg], llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->params [i])));
1728                 }
1729         }
1730
1731         if (cfg->vret_addr)
1732                 emit_volatile_store (ctx, cfg->vret_addr->dreg);
1733         if (sig->hasthis)
1734                 emit_volatile_store (ctx, cfg->args [0]->dreg);
1735         for (i = 0; i < sig->param_count; ++i)
1736                 if (!mini_type_is_vtype (cfg, sig->params [i]))
1737                         emit_volatile_store (ctx, cfg->args [i + sig->hasthis]->dreg);
1738
1739         if (sig->hasthis && !cfg->rgctx_var && cfg->generic_sharing_context) {
1740                 LLVMValueRef this_alloc;
1741
1742                 /*
1743                  * The exception handling code needs the location where the this argument was
1744                  * stored for gshared methods. We create a separate alloca to hold it, and mark it
1745                  * with the "mono.this" custom metadata to tell llvm that it needs to save its
1746                  * location into the LSDA.
1747                  */
1748                 this_alloc = mono_llvm_build_alloca (builder, IntPtrType (), LLVMConstInt (LLVMInt32Type (), 1, FALSE), 0, "");
1749                 /* This volatile store will keep the alloca alive */
1750                 mono_llvm_build_store (builder, ctx->values [cfg->args [0]->dreg], this_alloc, TRUE);
1751
1752                 set_metadata_flag (this_alloc, "mono.this");
1753         }
1754
1755         if (cfg->rgctx_var) {
1756                 LLVMValueRef rgctx_alloc, store;
1757
1758                 /*
1759                  * We handle the rgctx arg similarly to the this pointer.
1760                  */
1761                 g_assert (ctx->addresses [cfg->rgctx_var->dreg]);
1762                 rgctx_alloc = ctx->addresses [cfg->rgctx_var->dreg];
1763                 /* This volatile store will keep the alloca alive */
1764                 store = mono_llvm_build_store (builder, ctx->rgctx_arg, rgctx_alloc, TRUE);
1765
1766                 set_metadata_flag (rgctx_alloc, "mono.this");
1767         }
1768
1769         /*
1770          * For finally clauses, create an indicator variable telling OP_ENDFINALLY whenever
1771          * it needs to continue normally, or return back to the exception handling system.
1772          */
1773         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1774                 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER))
1775                         g_hash_table_insert (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)), bb);
1776                 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER) && bb->in_scount == 0) {
1777                         char name [128];
1778                         LLVMValueRef val;
1779
1780                         sprintf (name, "finally_ind_bb%d", bb->block_num);
1781                         val = LLVMBuildAlloca (builder, LLVMInt32Type (), name);
1782                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), val);
1783
1784                         ctx->bblocks [bb->block_num].finally_ind = val;
1785
1786                         /*
1787                          * Create a new bblock which CALL_HANDLER can branch to, because branching to the
1788                          * LLVM bblock containing the call to llvm.eh.selector causes problems for the
1789                          * LLVM optimizer passes.
1790                          */
1791                         sprintf (name, "BB_%d_CALL_HANDLER_TARGET", bb->block_num);
1792                         ctx->bblocks [bb->block_num].call_handler_target_bb = LLVMAppendBasicBlock (ctx->lmethod, name);
1793                 }
1794         }
1795
1796  FAILURE:
1797         ;
1798 }
1799
1800 /* Have to export this for AOT */
1801 void
1802 mono_personality (void);
1803
1804 void
1805 mono_personality (void)
1806 {
1807         /* Not used */
1808         g_assert_not_reached ();
1809 }
1810
1811 static void
1812 process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, MonoInst *ins)
1813 {
1814         MonoCompile *cfg = ctx->cfg;
1815         LLVMModuleRef module = ctx->module;
1816         LLVMValueRef *values = ctx->values;
1817         LLVMValueRef *addresses = ctx->addresses;
1818         MonoCallInst *call = (MonoCallInst*)ins;
1819         MonoMethodSignature *sig = call->signature;
1820         LLVMValueRef callee = NULL, lcall;
1821         LLVMValueRef *args;
1822         LLVMCallInfo *cinfo;
1823         GSList *l;
1824         int i, len, nargs;
1825         gboolean vretaddr;
1826         LLVMTypeRef llvm_sig;
1827         gpointer target;
1828         gboolean virtual, calli;
1829         LLVMBuilderRef builder = *builder_ref;
1830         LLVMSigInfo sinfo;
1831
1832         if (call->signature->call_convention != MONO_CALL_DEFAULT)
1833                 LLVM_FAILURE (ctx, "non-default callconv");
1834
1835         cinfo = call->cinfo;
1836         if (call->rgctx_arg_reg)
1837                 cinfo->rgctx_arg = TRUE;
1838         if (call->imt_arg_reg)
1839                 cinfo->imt_arg = TRUE;
1840
1841         vretaddr = cinfo && cinfo->ret.storage == LLVMArgVtypeRetAddr;
1842
1843         llvm_sig = sig_to_llvm_sig_full (ctx, sig, cinfo, &sinfo);
1844         CHECK_FAILURE (ctx);
1845
1846         virtual = (ins->opcode == OP_VOIDCALL_MEMBASE || ins->opcode == OP_CALL_MEMBASE || ins->opcode == OP_VCALL_MEMBASE || ins->opcode == OP_LCALL_MEMBASE || ins->opcode == OP_FCALL_MEMBASE);
1847         calli = (ins->opcode == OP_VOIDCALL_REG || ins->opcode == OP_CALL_REG || ins->opcode == OP_VCALL_REG || ins->opcode == OP_LCALL_REG || ins->opcode == OP_FCALL_REG);
1848
1849         /* FIXME: Avoid creating duplicate methods */
1850
1851         if (ins->flags & MONO_INST_HAS_METHOD) {
1852                 if (virtual) {
1853                         callee = NULL;
1854                 } else {
1855                         if (cfg->compile_aot) {
1856                                 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_METHOD, call->method);
1857                                 if (!callee)
1858                                         LLVM_FAILURE (ctx, "can't encode patch");
1859                         } else {
1860                                 callee = LLVMAddFunction (module, "", llvm_sig);
1861
1862                                 target =
1863                                         mono_create_jit_trampoline_in_domain (mono_domain_get (),
1864                                                                                                                   call->method);
1865                                 LLVMAddGlobalMapping (ee, callee, target);
1866                         }
1867                 }
1868         } else if (calli) {
1869         } else {
1870                 MonoJitICallInfo *info = mono_find_jit_icall_by_addr (call->fptr);
1871
1872                 if (info) {
1873                         /*
1874                           MonoJumpInfo ji;
1875
1876                           memset (&ji, 0, sizeof (ji));
1877                           ji.type = MONO_PATCH_INFO_JIT_ICALL_ADDR;
1878                           ji.data.target = info->name;
1879
1880                           target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
1881                         */
1882                         if (cfg->compile_aot) {
1883                                 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_INTERNAL_METHOD, (char*)info->name);
1884                                 if (!callee)
1885                                         LLVM_FAILURE (ctx, "can't encode patch");
1886                         } else {
1887                                 callee = LLVMAddFunction (module, "", llvm_sig);
1888                                 target = (gpointer)mono_icall_get_wrapper (info);
1889                                 LLVMAddGlobalMapping (ee, callee, target);
1890                         }
1891                 } else {
1892                         if (cfg->compile_aot) {
1893                                 callee = NULL;
1894                                 if (cfg->abs_patches) {
1895                                         MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1896                                         if (abs_ji) {
1897                                                 callee = get_plt_entry (ctx, llvm_sig, abs_ji->type, abs_ji->data.target);
1898                                                 if (!callee)
1899                                                         LLVM_FAILURE (ctx, "can't encode patch");
1900                                         }
1901                                 }
1902                                 if (!callee)
1903                                         LLVM_FAILURE (ctx, "aot");
1904                         } else {
1905                                 callee = LLVMAddFunction (module, "", llvm_sig);
1906                                 target = NULL;
1907                                 if (cfg->abs_patches) {
1908                                         MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1909                                         if (abs_ji) {
1910                                                 /*
1911                                                  * FIXME: Some trampolines might have
1912                                                  * their own calling convention on some platforms.
1913                                                  */
1914 #ifndef TARGET_AMD64
1915                                                 if (abs_ji->type == MONO_PATCH_INFO_MONITOR_ENTER || abs_ji->type == MONO_PATCH_INFO_MONITOR_EXIT || abs_ji->type == MONO_PATCH_INFO_GENERIC_CLASS_INIT)
1916                                                         LLVM_FAILURE (ctx, "trampoline with own cconv");
1917 #endif
1918                                                 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, abs_ji, FALSE);
1919                                                 LLVMAddGlobalMapping (ee, callee, target);
1920                                         }
1921                                 }
1922                                 if (!target)
1923                                         LLVMAddGlobalMapping (ee, callee, (gpointer)call->fptr);
1924                         }
1925                 }
1926         }
1927
1928         if (virtual) {
1929                 int size = sizeof (gpointer);
1930                 LLVMValueRef index;
1931
1932                 g_assert (ins->inst_offset % size == 0);
1933                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
1934
1935                 callee = convert (ctx, LLVMBuildLoad (builder, LLVMBuildGEP (builder, convert (ctx, values [ins->inst_basereg], LLVMPointerType (LLVMPointerType (IntPtrType (), 0), 0)), &index, 1, ""), ""), LLVMPointerType (llvm_sig, 0));
1936         } else if (calli) {
1937                 callee = convert (ctx, values [ins->sreg1], LLVMPointerType (llvm_sig, 0));
1938         } else {
1939                 if (ins->flags & MONO_INST_HAS_METHOD) {
1940                 }
1941         }
1942
1943         /*
1944          * Collect and convert arguments
1945          */
1946         nargs = (sig->param_count * 2) + sig->hasthis + vretaddr + call->rgctx_reg + call->imt_arg_reg;
1947         len = sizeof (LLVMValueRef) * nargs;
1948         args = alloca (len);
1949         memset (args, 0, len);
1950         l = call->out_ireg_args;
1951
1952         if (call->rgctx_arg_reg) {
1953                 g_assert (values [call->rgctx_arg_reg]);
1954                 g_assert (sinfo.rgctx_arg_pindex < nargs);
1955                 args [sinfo.rgctx_arg_pindex] = values [call->rgctx_arg_reg];
1956         }
1957         if (call->imt_arg_reg) {
1958                 g_assert (values [call->imt_arg_reg]);
1959                 g_assert (sinfo.imt_arg_pindex < nargs);
1960                 args [sinfo.imt_arg_pindex] = values [call->imt_arg_reg];
1961         }
1962
1963         if (vretaddr) {
1964                 if (!addresses [call->inst.dreg])
1965                         addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
1966                 g_assert (sinfo.vret_arg_pindex < nargs);
1967                 args [sinfo.vret_arg_pindex] = LLVMBuildPtrToInt (builder, addresses [call->inst.dreg], IntPtrType (), "");
1968         }
1969
1970         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1971                 guint32 regpair;
1972                 int reg, pindex;
1973                 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i] : NULL;
1974
1975                 if (sig->hasthis) {
1976                         if (i == 0)
1977                                 pindex = sinfo.this_arg_pindex;
1978                         else
1979                                 pindex = sinfo.pindexes [i - 1];
1980                 } else {
1981                         pindex = sinfo.pindexes [i];
1982                 }
1983
1984                 regpair = (guint32)(gssize)(l->data);
1985                 reg = regpair & 0xffffff;
1986                 args [pindex] = values [reg];
1987                 if (ainfo->storage == LLVMArgVtypeInReg) {
1988                         int j;
1989                         LLVMValueRef regs [2];
1990                         guint32 nregs;
1991
1992                         g_assert (ainfo);
1993
1994                         g_assert (addresses [reg]);
1995
1996                         emit_vtype_to_reg (ctx, builder, sig->params [i - sig->hasthis], addresses [reg], ainfo, regs, &nregs);
1997                         for (j = 0; j < nregs; ++j)
1998                                 args [pindex ++] = regs [j];
1999
2000                         // FIXME: alignment
2001                         // FIXME: Get rid of the VMOVE
2002                 } else if (ainfo->storage == LLVMArgVtypeByVal) {
2003                         g_assert (addresses [reg]);
2004                         args [pindex] = addresses [reg];
2005                 } else {
2006                         g_assert (args [pindex]);
2007                         if (i == 0 && sig->hasthis)
2008                                 args [pindex] = convert (ctx, args [pindex], IntPtrType ());
2009                         else
2010                                 args [pindex] = convert (ctx, args [pindex], type_to_llvm_arg_type (ctx, sig->params [i - sig->hasthis]));
2011                 }
2012
2013                 l = l->next;
2014         }
2015
2016         // FIXME: Align call sites
2017
2018         /*
2019          * Emit the call
2020          */
2021
2022         lcall = emit_call (ctx, bb, &builder, callee, args, LLVMCountParamTypes (llvm_sig));
2023
2024 #ifdef LLVM_MONO_BRANCH
2025         /*
2026          * Modify cconv and parameter attributes to pass rgctx/imt correctly.
2027          */
2028 #if defined(MONO_ARCH_IMT_REG) && defined(MONO_ARCH_RGCTX_REG)
2029         g_assert (MONO_ARCH_IMT_REG == MONO_ARCH_RGCTX_REG);
2030 #endif
2031         /* The two can't be used together, so use only one LLVM calling conv to pass them */
2032         g_assert (!(call->rgctx_arg_reg && call->imt_arg_reg));
2033         if (!sig->pinvoke)
2034                 LLVMSetInstructionCallConv (lcall, LLVMMono1CallConv);
2035
2036         if (call->rgctx_arg_reg)
2037                 LLVMAddInstrAttribute (lcall, 1 + sinfo.rgctx_arg_pindex, LLVMInRegAttribute);
2038         if (call->imt_arg_reg)
2039                 LLVMAddInstrAttribute (lcall, 1 + sinfo.imt_arg_pindex, LLVMInRegAttribute);
2040 #endif
2041
2042         /* Add byval attributes if needed */
2043         for (i = 0; i < sig->param_count; ++i) {
2044                 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i + sig->hasthis] : NULL;
2045
2046                 if (ainfo && ainfo->storage == LLVMArgVtypeByVal) {
2047                         LLVMAddInstrAttribute (lcall, 1 + sinfo.pindexes [i], LLVMByValAttribute);
2048                 }
2049         }
2050
2051         /*
2052          * Convert the result
2053          */
2054         if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
2055                 LLVMValueRef regs [2];
2056
2057                 if (!addresses [ins->dreg])
2058                         addresses [ins->dreg] = build_alloca (ctx, sig->ret);
2059
2060                 regs [0] = LLVMBuildExtractValue (builder, lcall, 0, "");
2061                 if (cinfo->ret.pair_storage [1] != LLVMArgNone)
2062                         regs [1] = LLVMBuildExtractValue (builder, lcall, 1, "");
2063
2064                 emit_reg_to_vtype (ctx, builder, sig->ret, addresses [ins->dreg], &cinfo->ret, regs);
2065         } else if (sig->ret->type != MONO_TYPE_VOID && !vretaddr) {
2066                 /* If the method returns an unsigned value, need to zext it */
2067
2068                 values [ins->dreg] = convert_full (ctx, lcall, llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->ret)), type_is_unsigned (ctx, sig->ret));
2069         }
2070
2071         *builder_ref = ctx->builder;
2072
2073         g_free (sinfo.pindexes);
2074
2075         return;
2076  FAILURE:
2077         return;
2078 }
2079
2080 static void
2081 process_bb (EmitContext *ctx, MonoBasicBlock *bb)
2082 {
2083         MonoCompile *cfg = ctx->cfg;
2084         MonoMethodSignature *sig = ctx->sig;
2085         LLVMValueRef method = ctx->lmethod;
2086         LLVMValueRef *values = ctx->values;
2087         LLVMValueRef *addresses = ctx->addresses;
2088         int i;
2089         LLVMCallInfo *linfo = ctx->linfo;
2090         LLVMModuleRef module = ctx->module;
2091         BBInfo *bblocks = ctx->bblocks;
2092         MonoInst *ins;
2093         LLVMBasicBlockRef cbb;
2094         LLVMBuilderRef builder, starting_builder;
2095         gboolean has_terminator;
2096         LLVMValueRef v;
2097         LLVMValueRef lhs, rhs;
2098         int nins = 0;
2099
2100         cbb = get_bb (ctx, bb);
2101         builder = create_builder (ctx);
2102         ctx->builder = builder;
2103         LLVMPositionBuilderAtEnd (builder, cbb);
2104
2105         if (bb == cfg->bb_entry)
2106                 emit_entry_bb (ctx, builder);
2107         CHECK_FAILURE (ctx);
2108
2109         if (bb->flags & BB_EXCEPTION_HANDLER) {
2110                 LLVMTypeRef i8ptr;
2111                 LLVMValueRef personality;
2112                 LLVMBasicBlockRef target_bb;
2113                 MonoInst *exvar;
2114                 static gint32 mapping_inited;
2115                 static int ti_generator;
2116                 char ti_name [128];
2117                 MonoClass **ti;
2118                 LLVMValueRef type_info;
2119                 int clause_index;
2120
2121                 if (!bblocks [bb->block_num].invoke_target) {
2122                         /*
2123                          * LLVM asserts if llvm.eh.selector is called from a bblock which
2124                          * doesn't have an invoke pointing at it.
2125                          * Update: LLVM no longer asserts, but some tests in exceptions.exe now fail.
2126                          */
2127                         LLVM_FAILURE (ctx, "handler without invokes");
2128                 }
2129
2130                 // <resultval> = landingpad <somety> personality <type> <pers_fn> <clause>+
2131
2132                 if (cfg->compile_aot) {
2133                         /* Use a dummy personality function */
2134                         personality = LLVMGetNamedFunction (module, "mono_aot_personality");
2135                         g_assert (personality);
2136                 } else {
2137                         personality = LLVMGetNamedFunction (module, "mono_personality");
2138                         if (InterlockedCompareExchange (&mapping_inited, 1, 0) == 0)
2139                                 LLVMAddGlobalMapping (ee, personality, mono_personality);
2140                 }
2141
2142                 i8ptr = LLVMPointerType (LLVMInt8Type (), 0);
2143
2144                 clause_index = (mono_get_block_region_notry (cfg, bb->region) >> 8) - 1;
2145
2146                 /*
2147                  * Create the type info
2148                  */
2149                 sprintf (ti_name, "type_info_%d", ti_generator);
2150                 ti_generator ++;
2151
2152                 if (cfg->compile_aot) {
2153                         /* decode_eh_frame () in aot-runtime.c will decode this */
2154                         type_info = LLVMAddGlobal (module, LLVMInt32Type (), ti_name);
2155                         LLVMSetInitializer (type_info, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE));
2156
2157                         /*
2158                          * These symbols are not really used, the clause_index is embedded into the EH tables generated by DwarfMonoException in LLVM.
2159                          */
2160                         LLVMSetLinkage (type_info, LLVMInternalLinkage);
2161
2162                         /*
2163                          * Enabling this causes llc to crash:
2164                          * http://llvm.org/bugs/show_bug.cgi?id=6102
2165                          */
2166                         //LLVM_FAILURE (ctx, "aot+clauses");
2167 #ifdef TARGET_ARM
2168                         // test_0_invalid_unbox_arrays () fails
2169                         LLVM_FAILURE (ctx, "aot+clauses");
2170 #endif
2171                 } else {
2172                         /*
2173                          * After the cfg mempool is freed, the type info will point to stale memory,
2174                          * but this is not a problem, since we decode it once in exception_cb during
2175                          * compilation.
2176                          */
2177                         ti = mono_mempool_alloc (cfg->mempool, sizeof (gint32));
2178                         *(gint32*)ti = clause_index;
2179
2180                         type_info = LLVMAddGlobal (module, i8ptr, ti_name);
2181
2182                         LLVMAddGlobalMapping (ee, type_info, ti);
2183                 }
2184
2185                 {
2186                         LLVMTypeRef members [2], ret_type;
2187                         LLVMValueRef landing_pad;
2188
2189                         members [0] = i8ptr;
2190                         members [1] = LLVMInt32Type ();
2191                         ret_type = LLVMStructType (members, 2, FALSE);
2192
2193                         landing_pad = LLVMBuildLandingPad (builder, ret_type, personality, 1, "");
2194                         LLVMAddClause (landing_pad, type_info);
2195
2196                         /* Store the exception into the exvar */
2197                         if (bb->in_scount == 1) {
2198                                 g_assert (bb->in_scount == 1);
2199                                 exvar = bb->in_stack [0];
2200
2201                                 // FIXME: This is shared with filter clauses ?
2202                                 g_assert (!values [exvar->dreg]);
2203
2204                                 values [exvar->dreg] = LLVMBuildExtractValue (builder, landing_pad, 0, "ex_obj");
2205                                 emit_volatile_store (ctx, exvar->dreg);
2206                         }
2207                 }
2208
2209                 /* Start a new bblock which CALL_HANDLER can branch to */
2210                 target_bb = bblocks [bb->block_num].call_handler_target_bb;
2211                 if (target_bb) {
2212                         LLVMBuildBr (builder, target_bb);
2213
2214                         ctx->builder = builder = create_builder (ctx);
2215                         LLVMPositionBuilderAtEnd (ctx->builder, target_bb);
2216
2217                         ctx->bblocks [bb->block_num].end_bblock = target_bb;
2218                 }
2219         }
2220
2221         has_terminator = FALSE;
2222         starting_builder = builder;
2223         for (ins = bb->code; ins; ins = ins->next) {
2224                 const char *spec = LLVM_INS_INFO (ins->opcode);
2225                 char *dname = NULL;
2226                 char dname_buf [128];
2227
2228                 nins ++;
2229                 if (nins > 5000 && builder == starting_builder) {
2230                         /* some steps in llc are non-linear in the size of basic blocks, see #5714 */
2231                         LLVM_FAILURE (ctx, "basic block too long");
2232                 }
2233
2234                 if (has_terminator)
2235                         /* There could be instructions after a terminator, skip them */
2236                         break;
2237
2238                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins)) {
2239                         sprintf (dname_buf, "t%d", ins->dreg);
2240                         dname = dname_buf;
2241                 }
2242
2243                 if (spec [MONO_INST_SRC1] != ' ' && spec [MONO_INST_SRC1] != 'v') {
2244                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg1);
2245
2246                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2247                                 lhs = emit_volatile_load (ctx, ins->sreg1);
2248                         } else {
2249                                 /* It is ok for SETRET to have an uninitialized argument */
2250                                 if (!values [ins->sreg1] && ins->opcode != OP_SETRET)
2251                                         LLVM_FAILURE (ctx, "sreg1");
2252                                 lhs = values [ins->sreg1];
2253                         }
2254                 } else {
2255                         lhs = NULL;
2256                 }
2257
2258                 if (spec [MONO_INST_SRC2] != ' ' && spec [MONO_INST_SRC2] != ' ') {
2259                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg2);
2260                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2261                                 rhs = emit_volatile_load (ctx, ins->sreg2);
2262                         } else {
2263                                 if (!values [ins->sreg2])
2264                                         LLVM_FAILURE (ctx, "sreg2");
2265                                 rhs = values [ins->sreg2];
2266                         }
2267                 } else {
2268                         rhs = NULL;
2269                 }
2270
2271                 //mono_print_ins (ins);
2272                 switch (ins->opcode) {
2273                 case OP_NOP:
2274                 case OP_NOT_NULL:
2275                 case OP_LIVERANGE_START:
2276                 case OP_LIVERANGE_END:
2277                         break;
2278                 case OP_ICONST:
2279                         values [ins->dreg] = LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE);
2280                         break;
2281                 case OP_I8CONST:
2282 #if SIZEOF_VOID_P == 4
2283                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2284 #else
2285                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), (gint64)ins->inst_c0, FALSE);
2286 #endif
2287                         break;
2288                 case OP_R8CONST:
2289                         values [ins->dreg] = LLVMConstReal (LLVMDoubleType (), *(double*)ins->inst_p0);
2290                         break;
2291                 case OP_R4CONST:
2292                         values [ins->dreg] = LLVMConstFPExt (LLVMConstReal (LLVMFloatType (), *(float*)ins->inst_p0), LLVMDoubleType ());
2293                         break;
2294                 case OP_BR:
2295                         LLVMBuildBr (builder, get_bb (ctx, ins->inst_target_bb));
2296                         has_terminator = TRUE;
2297                         break;
2298                 case OP_SWITCH: {
2299                         int i;
2300                         LLVMValueRef v;
2301                         char bb_name [128];
2302                         LLVMBasicBlockRef new_bb;
2303                         LLVMBuilderRef new_builder;
2304
2305                         // The default branch is already handled
2306                         // FIXME: Handle it here
2307
2308                         /* Start new bblock */
2309                         sprintf (bb_name, "SWITCH_DEFAULT_BB%d", ctx->default_index ++);
2310                         new_bb = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
2311
2312                         lhs = convert (ctx, lhs, LLVMInt32Type ());
2313                         v = LLVMBuildSwitch (builder, lhs, new_bb, GPOINTER_TO_UINT (ins->klass));
2314                         for (i = 0; i < GPOINTER_TO_UINT (ins->klass); ++i) {
2315                                 MonoBasicBlock *target_bb = ins->inst_many_bb [i];
2316
2317                                 LLVMAddCase (v, LLVMConstInt (LLVMInt32Type (), i, FALSE), get_bb (ctx, target_bb));
2318                         }
2319
2320                         new_builder = create_builder (ctx);
2321                         LLVMPositionBuilderAtEnd (new_builder, new_bb);
2322                         LLVMBuildUnreachable (new_builder);
2323
2324                         has_terminator = TRUE;
2325                         g_assert (!ins->next);
2326
2327                         break;
2328                 }
2329
2330                 case OP_SETRET:
2331                         if (linfo->ret.storage == LLVMArgVtypeInReg) {
2332                                 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
2333                                 LLVMValueRef part1, retval;
2334                                 int size;
2335
2336                                 size = get_vtype_size (sig->ret);
2337
2338                                 g_assert (addresses [ins->sreg1]);
2339
2340                                 g_assert (linfo->ret.pair_storage [0] == LLVMArgInIReg);
2341                                 g_assert (linfo->ret.pair_storage [1] == LLVMArgNone);
2342
2343                                 part1 = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMIntType (size * 8), 0), ""), ""), IntPtrType ());
2344
2345                                 retval = LLVMBuildInsertValue (builder, LLVMGetUndef (ret_type), part1, 0, "");
2346
2347                                 LLVMBuildRet (builder, retval);
2348                                 break;
2349                         }
2350
2351                         if (linfo->ret.storage == LLVMArgVtypeRetAddr) {
2352                                 LLVMBuildRetVoid (builder);
2353                                 break;
2354                         }
2355
2356                         if (!lhs || ctx->is_dead [ins->sreg1]) {
2357                                 /*
2358                                  * The method did not set its return value, probably because it
2359                                  * ends with a throw.
2360                                  */
2361                                 if (cfg->vret_addr)
2362                                         LLVMBuildRetVoid (builder);
2363                                 else
2364                                         LLVMBuildRet (builder, LLVMConstNull (type_to_llvm_type (ctx, sig->ret)));
2365                         } else {
2366                                 LLVMBuildRet (builder, convert (ctx, lhs, type_to_llvm_type (ctx, sig->ret)));
2367                         }
2368                         has_terminator = TRUE;
2369                         break;
2370                 case OP_ICOMPARE:
2371                 case OP_FCOMPARE:
2372                 case OP_LCOMPARE:
2373                 case OP_COMPARE:
2374                 case OP_ICOMPARE_IMM:
2375                 case OP_LCOMPARE_IMM:
2376                 case OP_COMPARE_IMM: {
2377                         CompRelation rel;
2378                         LLVMValueRef cmp;
2379
2380                         if (ins->next->opcode == OP_NOP)
2381                                 break;
2382
2383                         if (ins->next->opcode == OP_BR)
2384                                 /* The comparison result is not needed */
2385                                 continue;
2386
2387                         rel = mono_opcode_to_cond (ins->next->opcode);
2388
2389                         if (ins->opcode == OP_ICOMPARE_IMM) {
2390                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2391                                 rhs = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2392                         }
2393                         if (ins->opcode == OP_LCOMPARE_IMM) {
2394                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
2395                                 rhs = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2396                         }
2397                         if (ins->opcode == OP_LCOMPARE) {
2398                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
2399                                 rhs = convert (ctx, rhs, LLVMInt64Type ());
2400                         }
2401                         if (ins->opcode == OP_ICOMPARE) {
2402                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2403                                 rhs = convert (ctx, rhs, LLVMInt32Type ());
2404                         }
2405
2406                         if (lhs && rhs) {
2407                                 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2408                                         rhs = convert (ctx, rhs, LLVMTypeOf (lhs));
2409                                 else if (LLVMGetTypeKind (LLVMTypeOf (rhs)) == LLVMPointerTypeKind)
2410                                         lhs = convert (ctx, lhs, LLVMTypeOf (rhs));
2411                         }
2412
2413                         /* We use COMPARE+SETcc/Bcc, llvm uses SETcc+br cond */
2414                         if (ins->opcode == OP_FCOMPARE)
2415                                 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2416                         else if (ins->opcode == OP_COMPARE_IMM)
2417                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), "");
2418                         else if (ins->opcode == OP_LCOMPARE_IMM) {
2419                                 if (SIZEOF_REGISTER == 4 && COMPILE_LLVM (cfg))  {
2420                                         /* The immediate is encoded in two fields */
2421                                         guint64 l = ((guint64)(guint32)ins->inst_offset << 32) | ((guint32)ins->inst_imm);
2422                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), l, FALSE), "");
2423                                 } else {
2424                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), ins->inst_imm, FALSE), "");
2425                                 }
2426                         }
2427                         else if (ins->opcode == OP_COMPARE)
2428                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), convert (ctx, rhs, IntPtrType ()), "");
2429                         else
2430                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, rhs, "");
2431
2432                         if (MONO_IS_COND_BRANCH_OP (ins->next)) {
2433                                 if (ins->next->inst_true_bb == ins->next->inst_false_bb) {
2434                                         /*
2435                                          * If the target bb contains PHI instructions, LLVM requires
2436                                          * two PHI entries for this bblock, while we only generate one.
2437                                          * So convert this to an unconditional bblock. (bxc #171).
2438                                          */
2439                                         LLVMBuildBr (builder, get_bb (ctx, ins->next->inst_true_bb));
2440                                 } else {
2441                                         LLVMBuildCondBr (builder, cmp, get_bb (ctx, ins->next->inst_true_bb), get_bb (ctx, ins->next->inst_false_bb));
2442                                 }
2443                                 has_terminator = TRUE;
2444                         } else if (MONO_IS_SETCC (ins->next)) {
2445                                 sprintf (dname_buf, "t%d", ins->next->dreg);
2446                                 dname = dname_buf;
2447                                 values [ins->next->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2448
2449                                 /* Add stores for volatile variables */
2450                                 emit_volatile_store (ctx, ins->next->dreg);
2451                         } else if (MONO_IS_COND_EXC (ins->next)) {
2452                                 emit_cond_system_exception (ctx, bb, ins->next->inst_p1, cmp);
2453                                 CHECK_FAILURE (ctx);
2454                                 builder = ctx->builder;
2455                         } else {
2456                                 LLVM_FAILURE (ctx, "next");
2457                         }
2458
2459                         ins = ins->next;
2460                         break;
2461                 }
2462                 case OP_FCEQ:
2463                 case OP_FCLT:
2464                 case OP_FCLT_UN:
2465                 case OP_FCGT:
2466                 case OP_FCGT_UN: {
2467                         CompRelation rel;
2468                         LLVMValueRef cmp;
2469
2470                         rel = mono_opcode_to_cond (ins->opcode);
2471
2472                         cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2473                         values [ins->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2474                         break;
2475                 }
2476                 case OP_PHI:
2477                 case OP_FPHI:
2478                 case OP_VPHI:
2479                 case OP_XPHI: {
2480                         int i;
2481                         gboolean empty = TRUE;
2482
2483                         /* Check that all input bblocks really branch to us */
2484                         for (i = 0; i < bb->in_count; ++i) {
2485                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_NOT_REACHED)
2486                                         ins->inst_phi_args [i + 1] = -1;
2487                                 else
2488                                         empty = FALSE;
2489                         }
2490
2491                         if (empty) {
2492                                 /* LLVM doesn't like phi instructions with zero operands */
2493                                 ctx->is_dead [ins->dreg] = TRUE;
2494                                 break;
2495                         }
2496
2497                         /* Created earlier, insert it now */
2498                         LLVMInsertIntoBuilder (builder, values [ins->dreg]);
2499
2500                         for (i = 0; i < ins->inst_phi_args [0]; i++) {
2501                                 int sreg1 = ins->inst_phi_args [i + 1];
2502                                 int count, j;
2503
2504                                 /*
2505                                  * Count the number of times the incoming bblock branches to us,
2506                                  * since llvm requires a separate entry for each.
2507                                  */
2508                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_SWITCH) {
2509                                         MonoInst *switch_ins = bb->in_bb [i]->last_ins;
2510
2511                                         count = 0;
2512                                         for (j = 0; j < GPOINTER_TO_UINT (switch_ins->klass); ++j) {
2513                                                 if (switch_ins->inst_many_bb [j] == bb)
2514                                                         count ++;
2515                                         }
2516                                 } else {
2517                                         count = 1;
2518                                 }
2519
2520                                 /* Remember for later */
2521                                 for (j = 0; j < count; ++j) {
2522                                         PhiNode *node = mono_mempool_alloc0 (ctx->mempool, sizeof (PhiNode));
2523                                         node->bb = bb;
2524                                         node->phi = ins;
2525                                         node->in_bb = bb->in_bb [i];
2526                                         node->sreg = sreg1;
2527                                         bblocks [bb->in_bb [i]->block_num].phi_nodes = g_slist_prepend_mempool (ctx->mempool, bblocks [bb->in_bb [i]->block_num].phi_nodes, node);
2528                                 }
2529                         }
2530                         break;
2531                 }
2532                 case OP_MOVE:
2533                 case OP_LMOVE:
2534                 case OP_XMOVE:
2535                 case OP_SETFRET:
2536                         g_assert (lhs);
2537                         values [ins->dreg] = lhs;
2538                         break;
2539                 case OP_FMOVE: {
2540                         MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
2541
2542                         g_assert (lhs);
2543                         values [ins->dreg] = lhs;
2544
2545                         if (var && var->klass->byval_arg.type == MONO_TYPE_R4) {
2546                                 /*
2547                                  * This is added by the spilling pass in case of the JIT,
2548                                  * but we have to do it ourselves.
2549                                  */
2550                                 values [ins->dreg] = convert (ctx, values [ins->dreg], LLVMFloatType ());
2551                         }
2552                         break;
2553                 }
2554                 case OP_IADD:
2555                 case OP_ISUB:
2556                 case OP_IAND:
2557                 case OP_IMUL:
2558                 case OP_IDIV:
2559                 case OP_IDIV_UN:
2560                 case OP_IREM:
2561                 case OP_IREM_UN:
2562                 case OP_IOR:
2563                 case OP_IXOR:
2564                 case OP_ISHL:
2565                 case OP_ISHR:
2566                 case OP_ISHR_UN:
2567                 case OP_FADD:
2568                 case OP_FSUB:
2569                 case OP_FMUL:
2570                 case OP_FDIV:
2571                 case OP_LADD:
2572                 case OP_LSUB:
2573                 case OP_LMUL:
2574                 case OP_LDIV:
2575                 case OP_LDIV_UN:
2576                 case OP_LREM:
2577                 case OP_LREM_UN:
2578                 case OP_LAND:
2579                 case OP_LOR:
2580                 case OP_LXOR:
2581                 case OP_LSHL:
2582                 case OP_LSHR:
2583                 case OP_LSHR_UN:
2584                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2585                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2586
2587                         switch (ins->opcode) {
2588                         case OP_IADD:
2589                         case OP_LADD:
2590                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, dname);
2591                                 break;
2592                         case OP_ISUB:
2593                         case OP_LSUB:
2594                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, dname);
2595                                 break;
2596                         case OP_IMUL:
2597                         case OP_LMUL:
2598                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, dname);
2599                                 break;
2600                         case OP_IREM:
2601                         case OP_LREM:
2602                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, rhs, dname);
2603                                 break;
2604                         case OP_IREM_UN:
2605                         case OP_LREM_UN:
2606                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, rhs, dname);
2607                                 break;
2608                         case OP_IDIV:
2609                         case OP_LDIV:
2610                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, rhs, dname);
2611                                 break;
2612                         case OP_IDIV_UN:
2613                         case OP_LDIV_UN:
2614                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, rhs, dname);
2615                                 break;
2616                         case OP_FDIV:
2617                                 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, dname);
2618                                 break;
2619                         case OP_IAND:
2620                         case OP_LAND:
2621                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, dname);
2622                                 break;
2623                         case OP_IOR:
2624                         case OP_LOR:
2625                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, dname);
2626                                 break;
2627                         case OP_IXOR:
2628                         case OP_LXOR:
2629                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, dname);
2630                                 break;
2631                         case OP_ISHL:
2632                         case OP_LSHL:
2633                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, rhs, dname);
2634                                 break;
2635                         case OP_ISHR:
2636                         case OP_LSHR:
2637                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, rhs, dname);
2638                                 break;
2639                         case OP_ISHR_UN:
2640                         case OP_LSHR_UN:
2641                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, rhs, dname);
2642                                 break;
2643
2644                         case OP_FADD:
2645                                 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, dname);
2646                                 break;
2647                         case OP_FSUB:
2648                                 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, dname);
2649                                 break;
2650                         case OP_FMUL:
2651                                 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, dname);
2652                                 break;
2653
2654                         default:
2655                                 g_assert_not_reached ();
2656                         }
2657                         break;
2658                 case OP_IADD_IMM:
2659                 case OP_ISUB_IMM:
2660                 case OP_IMUL_IMM:
2661                 case OP_IREM_IMM:
2662                 case OP_IREM_UN_IMM:
2663                 case OP_IDIV_IMM:
2664                 case OP_IDIV_UN_IMM:
2665                 case OP_IAND_IMM:
2666                 case OP_IOR_IMM:
2667                 case OP_IXOR_IMM:
2668                 case OP_ISHL_IMM:
2669                 case OP_ISHR_IMM:
2670                 case OP_ISHR_UN_IMM:
2671                 case OP_LADD_IMM:
2672                 case OP_LSUB_IMM:
2673                 case OP_LREM_IMM:
2674                 case OP_LAND_IMM:
2675                 case OP_LOR_IMM:
2676                 case OP_LXOR_IMM:
2677                 case OP_LSHL_IMM:
2678                 case OP_LSHR_IMM:
2679                 case OP_LSHR_UN_IMM:
2680                 case OP_ADD_IMM:
2681                 case OP_AND_IMM:
2682                 case OP_MUL_IMM:
2683                 case OP_SHL_IMM:
2684                 case OP_SHR_IMM: {
2685                         LLVMValueRef imm;
2686
2687                         if (spec [MONO_INST_SRC1] == 'l') {
2688                                 imm = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2689                         } else {
2690                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2691                         }
2692
2693 #if SIZEOF_VOID_P == 4
2694                         if (ins->opcode == OP_LSHL_IMM || ins->opcode == OP_LSHR_IMM || ins->opcode == OP_LSHR_UN_IMM)
2695                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2696 #endif
2697
2698                         if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2699                                 lhs = convert (ctx, lhs, IntPtrType ());
2700                         imm = convert (ctx, imm, LLVMTypeOf (lhs));
2701                         switch (ins->opcode) {
2702                         case OP_IADD_IMM:
2703                         case OP_LADD_IMM:
2704                         case OP_ADD_IMM:
2705                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, imm, dname);
2706                                 break;
2707                         case OP_ISUB_IMM:
2708                         case OP_LSUB_IMM:
2709                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, imm, dname);
2710                                 break;
2711                         case OP_IMUL_IMM:
2712                         case OP_MUL_IMM:
2713                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, imm, dname);
2714                                 break;
2715                         case OP_IDIV_IMM:
2716                         case OP_LDIV_IMM:
2717                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, imm, dname);
2718                                 break;
2719                         case OP_IDIV_UN_IMM:
2720                         case OP_LDIV_UN_IMM:
2721                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, imm, dname);
2722                                 break;
2723                         case OP_IREM_IMM:
2724                         case OP_LREM_IMM:
2725                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, imm, dname);
2726                                 break;
2727                         case OP_IREM_UN_IMM:
2728                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, imm, dname);
2729                                 break;
2730                         case OP_IAND_IMM:
2731                         case OP_LAND_IMM:
2732                         case OP_AND_IMM:
2733                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, imm, dname);
2734                                 break;
2735                         case OP_IOR_IMM:
2736                         case OP_LOR_IMM:
2737                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, imm, dname);
2738                                 break;
2739                         case OP_IXOR_IMM:
2740                         case OP_LXOR_IMM:
2741                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, imm, dname);
2742                                 break;
2743                         case OP_ISHL_IMM:
2744                         case OP_LSHL_IMM:
2745                         case OP_SHL_IMM:
2746                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, imm, dname);
2747                                 break;
2748                         case OP_ISHR_IMM:
2749                         case OP_LSHR_IMM:
2750                         case OP_SHR_IMM:
2751                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, imm, dname);
2752                                 break;
2753                         case OP_ISHR_UN_IMM:
2754                                 /* This is used to implement conv.u4, so the lhs could be an i8 */
2755                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2756                                 imm = convert (ctx, imm, LLVMInt32Type ());
2757                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2758                                 break;
2759                         case OP_LSHR_UN_IMM:
2760                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2761                                 break;
2762                         default:
2763                                 g_assert_not_reached ();
2764                         }
2765                         break;
2766                 }
2767                 case OP_INEG:
2768                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2769                         break;
2770                 case OP_LNEG:
2771                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt64Type (), 0, FALSE), lhs, dname);
2772                         break;
2773                 case OP_FNEG:
2774                         lhs = convert (ctx, lhs, LLVMDoubleType ());
2775                         values [ins->dreg] = LLVMBuildFSub (builder, LLVMConstReal (LLVMDoubleType (), 0.0), lhs, dname);
2776                         break;
2777                 case OP_INOT: {
2778                         guint32 v = 0xffffffff;
2779                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt32Type (), v, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2780                         break;
2781                 }
2782                 case OP_LNOT: {
2783                         guint64 v = 0xffffffffffffffffLL;
2784                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt64Type (), v, FALSE), lhs, dname);
2785                         break;
2786                 }
2787 #if defined(TARGET_X86) || defined(TARGET_AMD64)
2788                 case OP_X86_LEA: {
2789                         LLVMValueRef v1, v2;
2790
2791                         v1 = LLVMBuildMul (builder, convert (ctx, rhs, IntPtrType ()), LLVMConstInt (IntPtrType (), (1 << ins->backend.shift_amount), FALSE), "");
2792                         v2 = LLVMBuildAdd (builder, convert (ctx, lhs, IntPtrType ()), v1, "");
2793                         values [ins->dreg] = LLVMBuildAdd (builder, v2, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), dname);
2794                         break;
2795                 }
2796 #endif
2797
2798                 case OP_ICONV_TO_I1:
2799                 case OP_ICONV_TO_I2:
2800                 case OP_ICONV_TO_I4:
2801                 case OP_ICONV_TO_U1:
2802                 case OP_ICONV_TO_U2:
2803                 case OP_ICONV_TO_U4:
2804                 case OP_LCONV_TO_I1:
2805                 case OP_LCONV_TO_I2:
2806                 case OP_LCONV_TO_U1:
2807                 case OP_LCONV_TO_U2:
2808                 case OP_LCONV_TO_U4: {
2809                         gboolean sign;
2810
2811                         sign = (ins->opcode == OP_ICONV_TO_I1) || (ins->opcode == OP_ICONV_TO_I2) || (ins->opcode == OP_ICONV_TO_I4) || (ins->opcode == OP_LCONV_TO_I1) || (ins->opcode == OP_LCONV_TO_I2);
2812
2813                         /* Have to do two casts since our vregs have type int */
2814                         v = LLVMBuildTrunc (builder, lhs, op_to_llvm_type (ins->opcode), "");
2815                         if (sign)
2816                                 values [ins->dreg] = LLVMBuildSExt (builder, v, LLVMInt32Type (), dname);
2817                         else
2818                                 values [ins->dreg] = LLVMBuildZExt (builder, v, LLVMInt32Type (), dname);
2819                         break;
2820                 }
2821                 case OP_ICONV_TO_I8:
2822                         values [ins->dreg] = LLVMBuildSExt (builder, lhs, LLVMInt64Type (), dname);
2823                         break;
2824                 case OP_ICONV_TO_U8:
2825                         values [ins->dreg] = LLVMBuildZExt (builder, lhs, LLVMInt64Type (), dname);
2826                         break;
2827                 case OP_FCONV_TO_I4:
2828                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt32Type (), dname);
2829                         break;
2830                 case OP_FCONV_TO_I1:
2831                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2832                         break;
2833                 case OP_FCONV_TO_U1:
2834                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2835                         break;
2836                 case OP_FCONV_TO_I2:
2837                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2838                         break;
2839                 case OP_FCONV_TO_U2:
2840                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2841                         break;
2842                 case OP_FCONV_TO_I8:
2843                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt64Type (), dname);
2844                         break;
2845                 case OP_FCONV_TO_I:
2846                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, IntPtrType (), dname);
2847                         break;
2848                 case OP_ICONV_TO_R8:
2849                 case OP_LCONV_TO_R8:
2850                         values [ins->dreg] = LLVMBuildSIToFP (builder, lhs, LLVMDoubleType (), dname);
2851                         break;
2852                 case OP_LCONV_TO_R_UN:
2853                         values [ins->dreg] = LLVMBuildUIToFP (builder, lhs, LLVMDoubleType (), dname);
2854                         break;
2855 #if SIZEOF_VOID_P == 4
2856                 case OP_LCONV_TO_U:
2857 #endif
2858                 case OP_LCONV_TO_I4:
2859                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2860                         break;
2861                 case OP_ICONV_TO_R4:
2862                 case OP_LCONV_TO_R4:
2863                         v = LLVMBuildSIToFP (builder, lhs, LLVMFloatType (), "");
2864                         values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2865                         break;
2866                 case OP_FCONV_TO_R4:
2867                         v = LLVMBuildFPTrunc (builder, lhs, LLVMFloatType (), "");
2868                         values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2869                         break;
2870                 case OP_SEXT_I4:
2871                         values [ins->dreg] = LLVMBuildSExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2872                         break;
2873                 case OP_ZEXT_I4:
2874                         values [ins->dreg] = LLVMBuildZExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2875                         break;
2876                 case OP_TRUNC_I4:
2877                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2878                         break;
2879                 case OP_LOCALLOC_IMM: {
2880                         LLVMValueRef v;
2881
2882                         guint32 size = ins->inst_imm;
2883                         size = (size + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
2884
2885                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), LLVMConstInt (LLVMInt32Type (), size, FALSE), MONO_ARCH_FRAME_ALIGNMENT, "");
2886
2887                         if (ins->flags & MONO_INST_INIT) {
2888                                 LLVMValueRef args [5];
2889
2890                                 args [0] = v;
2891                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2892                                 args [2] = LLVMConstInt (LLVMInt32Type (), size, FALSE);
2893                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2894                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2895                                 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2896                         }
2897
2898                         values [ins->dreg] = v;
2899                         break;
2900                 }
2901                 case OP_LOCALLOC: {
2902                         LLVMValueRef v, size;
2903
2904                         size = LLVMBuildAnd (builder, LLVMBuildAdd (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT - 1, FALSE), ""), LLVMConstInt (LLVMInt32Type (), ~ (MONO_ARCH_FRAME_ALIGNMENT - 1), FALSE), "");
2905
2906                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), size, MONO_ARCH_FRAME_ALIGNMENT, "");
2907
2908                         if (ins->flags & MONO_INST_INIT) {
2909                                 LLVMValueRef args [5];
2910
2911                                 args [0] = v;
2912                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2913                                 args [2] = size;
2914                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2915                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2916                                 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2917                         }
2918                         values [ins->dreg] = v;
2919                         break;
2920                 }
2921
2922                 case OP_LOADI1_MEMBASE:
2923                 case OP_LOADU1_MEMBASE:
2924                 case OP_LOADI2_MEMBASE:
2925                 case OP_LOADU2_MEMBASE:
2926                 case OP_LOADI4_MEMBASE:
2927                 case OP_LOADU4_MEMBASE:
2928                 case OP_LOADI8_MEMBASE:
2929                 case OP_LOADR4_MEMBASE:
2930                 case OP_LOADR8_MEMBASE:
2931                 case OP_LOAD_MEMBASE:
2932                 case OP_LOADI8_MEM:
2933                 case OP_LOADU1_MEM:
2934                 case OP_LOADU2_MEM:
2935                 case OP_LOADI4_MEM:
2936                 case OP_LOADU4_MEM:
2937                 case OP_LOAD_MEM: {
2938                         int size = 8;
2939                         LLVMValueRef base, index, addr;
2940                         LLVMTypeRef t;
2941                         gboolean sext = FALSE, zext = FALSE;
2942                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
2943
2944                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
2945
2946                         if (sext || zext)
2947                                 dname = (char*)"";
2948
2949                         if ((ins->opcode == OP_LOADI8_MEM) || (ins->opcode == OP_LOAD_MEM) || (ins->opcode == OP_LOADI4_MEM) || (ins->opcode == OP_LOADU4_MEM) || (ins->opcode == OP_LOADU1_MEM) || (ins->opcode == OP_LOADU2_MEM)) {
2950                                 addr = LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE);
2951                         } else {
2952                                 /* _MEMBASE */
2953                                 base = lhs;
2954
2955                                 if (ins->inst_offset == 0) {
2956                                         addr = base;
2957                                 } else if (ins->inst_offset % size != 0) {
2958                                         /* Unaligned load */
2959                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
2960                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
2961                                 } else {
2962                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
2963                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
2964                                 }
2965                         }
2966
2967                         addr = convert (ctx, addr, LLVMPointerType (t, 0));
2968
2969                         values [ins->dreg] = emit_load (ctx, bb, &builder, size, addr, dname, is_volatile);
2970
2971                         if (!is_volatile && (ins->flags & MONO_INST_CONSTANT_LOAD)) {
2972                                 /*
2973                                  * These will signal LLVM that these loads do not alias any stores, and
2974                                  * they can't fail, allowing them to be hoisted out of loops.
2975                                  */
2976                                 set_metadata_flag (values [ins->dreg], "mono.noalias");
2977                                 set_metadata_flag (values [ins->dreg], "mono.nofail.load");
2978                         }
2979
2980                         if (sext)
2981                                 values [ins->dreg] = LLVMBuildSExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
2982                         else if (zext)
2983                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
2984                         else if (ins->opcode == OP_LOADR4_MEMBASE)
2985                                 values [ins->dreg] = LLVMBuildFPExt (builder, values [ins->dreg], LLVMDoubleType (), dname);
2986                         break;
2987                 }
2988
2989                 case OP_STOREI1_MEMBASE_REG:
2990                 case OP_STOREI2_MEMBASE_REG:
2991                 case OP_STOREI4_MEMBASE_REG:
2992                 case OP_STOREI8_MEMBASE_REG:
2993                 case OP_STORER4_MEMBASE_REG:
2994                 case OP_STORER8_MEMBASE_REG:
2995                 case OP_STORE_MEMBASE_REG: {
2996                         int size = 8;
2997                         LLVMValueRef index, addr;
2998                         LLVMTypeRef t;
2999                         gboolean sext = FALSE, zext = FALSE;
3000                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3001
3002                         if (!values [ins->inst_destbasereg])
3003                                 LLVM_FAILURE (ctx, "inst_destbasereg");
3004
3005                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3006
3007                         if (ins->inst_offset % size != 0) {
3008                                 /* Unaligned store */
3009                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3010                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3011                         } else {
3012                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3013                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3014                         }
3015                         emit_store (ctx, bb, &builder, size, convert (ctx, values [ins->sreg1], t), convert (ctx, addr, LLVMPointerType (t, 0)), is_volatile);
3016                         break;
3017                 }
3018
3019                 case OP_STOREI1_MEMBASE_IMM:
3020                 case OP_STOREI2_MEMBASE_IMM:
3021                 case OP_STOREI4_MEMBASE_IMM:
3022                 case OP_STOREI8_MEMBASE_IMM:
3023                 case OP_STORE_MEMBASE_IMM: {
3024                         int size = 8;
3025                         LLVMValueRef index, addr;
3026                         LLVMTypeRef t;
3027                         gboolean sext = FALSE, zext = FALSE;
3028                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3029
3030                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3031
3032                         if (ins->inst_offset % size != 0) {
3033                                 /* Unaligned store */
3034                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3035                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3036                         } else {
3037                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3038                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3039                         }
3040                         emit_store (ctx, bb, &builder, size, convert (ctx, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), t), addr, is_volatile);
3041                         break;
3042                 }
3043
3044                 case OP_CHECK_THIS:
3045                         emit_load (ctx, bb, &builder, sizeof (gpointer), convert (ctx, lhs, LLVMPointerType (IntPtrType (), 0)), "", TRUE);
3046                         break;
3047                 case OP_OUTARG_VTRETADDR:
3048                         break;
3049                 case OP_VOIDCALL:
3050                 case OP_CALL:
3051                 case OP_LCALL:
3052                 case OP_FCALL:
3053                 case OP_VCALL:
3054                 case OP_VOIDCALL_MEMBASE:
3055                 case OP_CALL_MEMBASE:
3056                 case OP_LCALL_MEMBASE:
3057                 case OP_FCALL_MEMBASE:
3058                 case OP_VCALL_MEMBASE:
3059                 case OP_VOIDCALL_REG:
3060                 case OP_CALL_REG:
3061                 case OP_LCALL_REG:
3062                 case OP_FCALL_REG:
3063                 case OP_VCALL_REG: {
3064                         process_call (ctx, bb, &builder, ins);
3065                         CHECK_FAILURE (ctx);
3066                         break;
3067                 }
3068                 case OP_AOTCONST: {
3069                         guint32 got_offset;
3070                         LLVMValueRef indexes [2];
3071                         MonoJumpInfo *ji;
3072                         LLVMValueRef got_entry_addr;
3073
3074                         /*
3075                          * FIXME: Can't allocate from the cfg mempool since that is freed if
3076                          * the LLVM compile fails.
3077                          */
3078                         ji = g_new0 (MonoJumpInfo, 1);
3079                         ji->type = (MonoJumpInfoType)ins->inst_i1;
3080                         ji->data.target = ins->inst_p0;
3081
3082                         ji = mono_aot_patch_info_dup (ji);
3083
3084                         ji->next = cfg->patch_info;
3085                         cfg->patch_info = ji;
3086
3087                         //mono_add_patch_info (cfg, 0, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3088                         got_offset = mono_aot_get_got_offset (cfg->patch_info);
3089
3090                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3091                         indexes [1] = LLVMConstInt (LLVMInt32Type (), (gssize)got_offset, FALSE);
3092                         got_entry_addr = LLVMBuildGEP (builder, ctx->lmodule->got_var, indexes, 2, "");
3093
3094                         // FIXME: This doesn't work right now, because it must be
3095                         // paired with an invariant.end, and even then, its only in effect
3096                         // inside its basic block
3097 #if 0
3098                         {
3099                                 LLVMValueRef args [3];
3100                                 LLVMValueRef ptr, val;
3101
3102                                 ptr = LLVMBuildBitCast (builder, got_entry_addr, LLVMPointerType (LLVMInt8Type (), 0), "ptr");
3103
3104                                 args [0] = LLVMConstInt (LLVMInt64Type (), sizeof (gpointer), FALSE);
3105                                 args [1] = ptr;
3106                                 val = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.invariant.start"), args, 2, "");
3107                         }
3108 #endif
3109
3110                         values [ins->dreg] = LLVMBuildLoad (builder, got_entry_addr, dname);
3111                         break;
3112                 }
3113                 case OP_NOT_REACHED:
3114                         LLVMBuildUnreachable (builder);
3115                         has_terminator = TRUE;
3116                         g_assert (bb->block_num < cfg->max_block_num);
3117                         ctx->unreachable [bb->block_num] = TRUE;
3118                         /* Might have instructions after this */
3119                         while (ins->next) {
3120                                 MonoInst *next = ins->next;
3121                                 /*
3122                                  * FIXME: If later code uses the regs defined by these instructions,
3123                                  * compilation will fail.
3124                                  */
3125                                 MONO_DELETE_INS (bb, next);
3126                         }
3127                         break;
3128                 case OP_LDADDR: {
3129                         MonoInst *var = ins->inst_p0;
3130
3131                         values [ins->dreg] = addresses [var->dreg];
3132                         break;
3133                 }
3134                 case OP_SIN: {
3135                         LLVMValueRef args [1];
3136
3137                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3138                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sin.f64"), args, 1, dname);
3139                         break;
3140                 }
3141                 case OP_COS: {
3142                         LLVMValueRef args [1];
3143
3144                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3145                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.cos.f64"), args, 1, dname);
3146                         break;
3147                 }
3148                 case OP_SQRT: {
3149                         LLVMValueRef args [1];
3150
3151 #if 0
3152                         /* This no longer seems to happen */
3153                         /*
3154                          * LLVM optimizes sqrt(nan) into undefined in
3155                          * lib/Analysis/ConstantFolding.cpp
3156                          * Also, sqrt(NegativeInfinity) is optimized into 0.
3157                          */
3158                         LLVM_FAILURE (ctx, "sqrt");
3159 #endif
3160                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3161                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sqrt.f64"), args, 1, dname);
3162                         break;
3163                 }
3164                 case OP_ABS: {
3165                         LLVMValueRef args [1];
3166
3167                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3168                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "fabs"), args, 1, dname);
3169                         break;
3170                 }
3171
3172                 case OP_IMIN:
3173                 case OP_LMIN:
3174                 case OP_IMAX:
3175                 case OP_LMAX:
3176                 case OP_IMIN_UN:
3177                 case OP_LMIN_UN:
3178                 case OP_IMAX_UN:
3179                 case OP_LMAX_UN: {
3180                         LLVMValueRef v;
3181
3182                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3183                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3184
3185                         switch (ins->opcode) {
3186                         case OP_IMIN:
3187                         case OP_LMIN:
3188                                 v = LLVMBuildICmp (builder, LLVMIntSLE, lhs, rhs, "");
3189                                 break;
3190                         case OP_IMAX:
3191                         case OP_LMAX:
3192                                 v = LLVMBuildICmp (builder, LLVMIntSGE, lhs, rhs, "");
3193                                 break;
3194                         case OP_IMIN_UN:
3195                         case OP_LMIN_UN:
3196                                 v = LLVMBuildICmp (builder, LLVMIntULE, lhs, rhs, "");
3197                                 break;
3198                         case OP_IMAX_UN:
3199                         case OP_LMAX_UN:
3200                                 v = LLVMBuildICmp (builder, LLVMIntUGE, lhs, rhs, "");
3201                                 break;
3202                         default:
3203                                 g_assert_not_reached ();
3204                                 break;
3205                         }
3206                         values [ins->dreg] = LLVMBuildSelect (builder, v, lhs, rhs, dname);
3207                         break;
3208                 }
3209                 case OP_ATOMIC_EXCHANGE_I4: {
3210                         LLVMValueRef args [2];
3211
3212                         g_assert (ins->inst_offset == 0);
3213
3214                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt32Type (), 0));
3215                         args [1] = rhs;
3216
3217                         values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
3218                         break;
3219                 }
3220                 case OP_ATOMIC_EXCHANGE_I8: {
3221                         LLVMValueRef args [2];
3222
3223                         g_assert (ins->inst_offset == 0);
3224
3225                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt64Type (), 0));
3226                         args [1] = convert (ctx, rhs, LLVMInt64Type ());
3227                         values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
3228                         break;
3229                 }
3230                 case OP_ATOMIC_ADD_NEW_I4: {
3231                         LLVMValueRef args [2];
3232
3233                         g_assert (ins->inst_offset == 0);
3234
3235                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt32Type (), 0));
3236                         args [1] = rhs;
3237                         values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
3238                         break;
3239                 }
3240                 case OP_ATOMIC_ADD_NEW_I8: {
3241                         LLVMValueRef args [2];
3242
3243                         g_assert (ins->inst_offset == 0);
3244
3245                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt64Type (), 0));
3246                         args [1] = convert (ctx, rhs, LLVMInt64Type ());
3247                         values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
3248                         break;
3249                 }
3250                 case OP_ATOMIC_CAS_I4:
3251                 case OP_ATOMIC_CAS_I8: {
3252                         LLVMValueRef args [3];
3253                         LLVMTypeRef t;
3254
3255                         if (ins->opcode == OP_ATOMIC_CAS_I4) {
3256                                 t = LLVMInt32Type ();
3257                         } else {
3258                                 t = LLVMInt64Type ();
3259                         }
3260
3261                         args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
3262                         /* comparand */
3263                         args [1] = convert (ctx, values [ins->sreg3], t);
3264                         /* new value */
3265                         args [2] = convert (ctx, values [ins->sreg2], t);
3266                         values [ins->dreg] = mono_llvm_build_cmpxchg (builder, args [0], args [1], args [2]);
3267                         break;
3268                 }
3269                 case OP_MEMORY_BARRIER: {
3270                         mono_llvm_build_fence (builder);
3271                         break;
3272                 }
3273                 case OP_RELAXED_NOP: {
3274 #if defined(TARGET_AMD64) || defined(TARGET_X86)
3275                         emit_call (ctx, bb, &builder, LLVMGetNamedFunction (ctx->module, "llvm.x86.sse2.pause"), NULL, 0);
3276                         break;
3277 #else
3278                         break;
3279 #endif
3280                 }
3281                 case OP_TLS_GET: {
3282 #if (defined(TARGET_AMD64) || defined(TARGET_X86)) && defined(__linux__)
3283 #ifdef TARGET_AMD64
3284                         // 257 == FS segment register
3285                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 257);
3286 #else
3287                         // 256 == GS segment register
3288                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3289 #endif
3290
3291                         // FIXME: XEN
3292                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), ins->inst_offset, TRUE), ptrtype, ""), "");
3293 #else
3294                         LLVM_FAILURE (ctx, "opcode tls-get");
3295 #endif
3296
3297                         break;
3298                 }
3299
3300                         /*
3301                          * Overflow opcodes.
3302                          */
3303                 case OP_IADD_OVF:
3304                 case OP_IADD_OVF_UN:
3305                 case OP_ISUB_OVF:
3306                 case OP_ISUB_OVF_UN:
3307                 case OP_IMUL_OVF:
3308                 case OP_IMUL_OVF_UN:
3309 #if SIZEOF_VOID_P == 8
3310                 case OP_LADD_OVF:
3311                 case OP_LADD_OVF_UN:
3312                 case OP_LSUB_OVF:
3313                 case OP_LSUB_OVF_UN:
3314                 case OP_LMUL_OVF:
3315                 case OP_LMUL_OVF_UN:
3316 #endif
3317                         {
3318                                 LLVMValueRef args [2], val, ovf, func;
3319
3320                                 args [0] = convert (ctx, lhs, op_to_llvm_type (ins->opcode));
3321                                 args [1] = convert (ctx, rhs, op_to_llvm_type (ins->opcode));
3322                                 func = LLVMGetNamedFunction (module, ovf_op_to_intrins (ins->opcode));
3323                                 g_assert (func);
3324                                 val = LLVMBuildCall (builder, func, args, 2, "");
3325                                 values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, dname);
3326                                 ovf = LLVMBuildExtractValue (builder, val, 1, "");
3327                                 emit_cond_system_exception (ctx, bb, "OverflowException", ovf);
3328                                 CHECK_FAILURE (ctx);
3329                                 builder = ctx->builder;
3330                                 break;
3331                         }
3332
3333                         /*
3334                          * Valuetypes.
3335                          *   We currently model them using arrays. Promotion to local vregs is
3336                          * disabled for them in mono_handle_global_vregs () in the LLVM case,
3337                          * so we always have an entry in cfg->varinfo for them.
3338                          * FIXME: Is this needed ?
3339                          */
3340                 case OP_VZERO: {
3341                         MonoClass *klass = ins->klass;
3342                         LLVMValueRef args [5];
3343
3344                         if (!klass) {
3345                                 // FIXME:
3346                                 LLVM_FAILURE (ctx, "!klass");
3347                                 break;
3348                         }
3349
3350                         if (!addresses [ins->dreg])
3351                                 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3352                         args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3353                         args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
3354                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3355                         // FIXME: Alignment
3356                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3357                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3358                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
3359                         break;
3360                 }
3361
3362                 case OP_STOREV_MEMBASE:
3363                 case OP_LOADV_MEMBASE:
3364                 case OP_VMOVE: {
3365                         MonoClass *klass = ins->klass;
3366                         LLVMValueRef src = NULL, dst, args [5];
3367                         gboolean done = FALSE;
3368
3369                         if (!klass) {
3370                                 // FIXME:
3371                                 LLVM_FAILURE (ctx, "!klass");
3372                                 break;
3373                         }
3374
3375                         if (mini_is_gsharedvt_klass (cfg, klass)) {
3376                                 // FIXME:
3377                                 LLVM_FAILURE (ctx, "gsharedvt");
3378                                 break;
3379                         }
3380
3381                         switch (ins->opcode) {
3382                         case OP_STOREV_MEMBASE:
3383                                 if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg) {
3384                                         /* FIXME: Emit write barriers like in mini_emit_stobj () */
3385                                         LLVM_FAILURE (ctx, "storev_membase + write barriers");
3386                                         break;
3387                                 }
3388                                 if (!addresses [ins->sreg1]) {
3389                                         /* SIMD */
3390                                         g_assert (values [ins->sreg1]);
3391                                         dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (type_to_llvm_type (ctx, &klass->byval_arg), 0));
3392                                         LLVMBuildStore (builder, values [ins->sreg1], dst);
3393                                         done = TRUE;
3394                                 } else {
3395                                         src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3396                                         dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3397                                 }
3398                                 break;
3399                         case OP_LOADV_MEMBASE:
3400                                 if (!addresses [ins->dreg])
3401                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3402                                 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3403                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3404                                 break;
3405                         case OP_VMOVE:
3406                                 if (!addresses [ins->sreg1])
3407                                         addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
3408                                 if (!addresses [ins->dreg])
3409                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3410                                 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3411                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3412                                 break;
3413                         default:
3414                                 g_assert_not_reached ();
3415                         }
3416                         CHECK_FAILURE (ctx);
3417
3418                         if (done)
3419                                 break;
3420
3421                         args [0] = dst;
3422                         args [1] = src;
3423                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3424                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3425                         // FIXME: Alignment
3426                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3427                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3428                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memcpy_func_name), args, memcpy_param_count, "");
3429                         break;
3430                 }
3431                 case OP_LLVM_OUTARG_VT:
3432                         if (!addresses [ins->sreg1]) {
3433                                 addresses [ins->sreg1] = build_alloca (ctx, &ins->klass->byval_arg);
3434                                 g_assert (values [ins->sreg1]);
3435                                 LLVMBuildStore (builder, values [ins->sreg1], addresses [ins->sreg1]);
3436                         }
3437                         addresses [ins->dreg] = addresses [ins->sreg1];
3438                         break;
3439
3440                         /*
3441                          * SIMD
3442                          */
3443 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3444                 case OP_XZERO: {
3445                         values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
3446                         break;
3447                 }
3448                 case OP_LOADX_MEMBASE: {
3449                         LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
3450                         LLVMValueRef src;
3451
3452                         src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3453                         values [ins->dreg] = mono_llvm_build_aligned_load (builder, src, "", FALSE, 1);
3454                         break;
3455                 }
3456                 case OP_STOREX_MEMBASE: {
3457                         LLVMTypeRef t = LLVMTypeOf (values [ins->sreg1]);
3458                         LLVMValueRef dest;
3459
3460                         dest = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3461                         mono_llvm_build_aligned_store (builder, values [ins->sreg1], dest, FALSE, 1);
3462                         break;
3463                 }
3464                 case OP_PADDB:
3465                 case OP_PADDW:
3466                 case OP_PADDD:
3467                 case OP_PADDQ:
3468                         values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, "");
3469                         break;
3470                 case OP_ADDPD:
3471                 case OP_ADDPS:
3472                         values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, "");
3473                         break;
3474                 case OP_PSUBB:
3475                 case OP_PSUBW:
3476                 case OP_PSUBD:
3477                 case OP_PSUBQ:
3478                         values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, "");
3479                         break;
3480                 case OP_SUBPD:
3481                 case OP_SUBPS:
3482                         values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, "");
3483                         break;
3484                 case OP_MULPD:
3485                 case OP_MULPS:
3486                         values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, "");
3487                         break;
3488                 case OP_DIVPD:
3489                 case OP_DIVPS:
3490                         values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, "");
3491                         break;
3492                 case OP_PAND:
3493                         values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, "");
3494                         break;
3495                 case OP_POR:
3496                         values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, "");
3497                         break;
3498                 case OP_PXOR:
3499                         values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, "");
3500                         break;
3501                 case OP_PMULW:
3502                 case OP_PMULD:
3503                         values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, "");
3504                         break;
3505                 case OP_ANDPS:
3506                 case OP_ANDNPS:
3507                 case OP_ORPS:
3508                 case OP_XORPS:
3509                 case OP_ANDPD:
3510                 case OP_ANDNPD:
3511                 case OP_ORPD:
3512                 case OP_XORPD: {
3513                         LLVMTypeRef t, rt;
3514                         LLVMValueRef v = NULL;
3515
3516                         switch (ins->opcode) {
3517                         case OP_ANDPS:
3518                         case OP_ANDNPS:
3519                         case OP_ORPS:
3520                         case OP_XORPS:
3521                                 t = LLVMVectorType (LLVMInt32Type (), 4);
3522                                 rt = LLVMVectorType (LLVMFloatType (), 4);
3523                                 break;
3524                         case OP_ANDPD:
3525                         case OP_ANDNPD:
3526                         case OP_ORPD:
3527                         case OP_XORPD:
3528                                 t = LLVMVectorType (LLVMInt64Type (), 2);
3529                                 rt = LLVMVectorType (LLVMDoubleType (), 2);
3530                                 break;
3531                         default:
3532                                 t = LLVMInt32Type ();
3533                                 rt = LLVMInt32Type ();
3534                                 g_assert_not_reached ();
3535                         }
3536
3537                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3538                         rhs = LLVMBuildBitCast (builder, rhs, t, "");
3539                         switch (ins->opcode) {
3540                         case OP_ANDPS:
3541                         case OP_ANDPD:
3542                                 v = LLVMBuildAnd (builder, lhs, rhs, "");
3543                                 break;
3544                         case OP_ORPS:
3545                         case OP_ORPD:
3546                                 v = LLVMBuildOr (builder, lhs, rhs, "");
3547                                 break;
3548                         case OP_XORPS:
3549                         case OP_XORPD:
3550                                 v = LLVMBuildXor (builder, lhs, rhs, "");
3551                                 break;
3552                         case OP_ANDNPS:
3553                         case OP_ANDNPD:
3554                                 v = LLVMBuildAnd (builder, rhs, LLVMBuildNot (builder, lhs, ""), "");
3555                                 break;
3556                         }
3557                         values [ins->dreg] = LLVMBuildBitCast (builder, v, rt, "");
3558                         break;
3559                 }
3560                 case OP_MINPD:
3561                 case OP_MINPS:
3562                 case OP_MAXPD:
3563                 case OP_MAXPS:
3564                 case OP_ADDSUBPD:
3565                 case OP_ADDSUBPS:
3566                 case OP_PMIND_UN:
3567                 case OP_PMINW_UN:
3568                 case OP_PMINB_UN:
3569                 case OP_PMINW:
3570                 case OP_PMAXD_UN:
3571                 case OP_PMAXW_UN:
3572                 case OP_PMAXB_UN:
3573                 case OP_HADDPD:
3574                 case OP_HADDPS:
3575                 case OP_HSUBPD:
3576                 case OP_HSUBPS:
3577                 case OP_PADDB_SAT:
3578                 case OP_PADDW_SAT:
3579                 case OP_PSUBB_SAT:
3580                 case OP_PSUBW_SAT:
3581                 case OP_PADDB_SAT_UN:
3582                 case OP_PADDW_SAT_UN:
3583                 case OP_PSUBB_SAT_UN:
3584                 case OP_PSUBW_SAT_UN:
3585                 case OP_PAVGB_UN:
3586                 case OP_PAVGW_UN:
3587                 case OP_PACKW:
3588                 case OP_PACKD:
3589                 case OP_PACKW_UN:
3590                 case OP_PACKD_UN:
3591                 case OP_PMULW_HIGH:
3592                 case OP_PMULW_HIGH_UN: {
3593                         LLVMValueRef args [2];
3594
3595                         args [0] = lhs;
3596                         args [1] = rhs;
3597
3598                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3599                         break;
3600                 }
3601                 case OP_PCMPEQB:
3602                 case OP_PCMPEQW:
3603                 case OP_PCMPEQD:
3604                 case OP_PCMPEQQ: {
3605                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntEQ, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3606                         break;
3607                 }
3608                 case OP_PCMPGTB: {
3609                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntSGT, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3610                         break;
3611                 }
3612                 case OP_EXTRACT_R8:
3613                 case OP_EXTRACT_I8:
3614                 case OP_EXTRACT_I4:
3615                 case OP_EXTRACT_I2:
3616                 case OP_EXTRACT_U2:
3617                 case OP_EXTRACTX_U2:
3618                 case OP_EXTRACT_I1:
3619                 case OP_EXTRACT_U1: {
3620                         LLVMTypeRef t;
3621                         gboolean zext = FALSE;
3622
3623                         t = simd_op_to_llvm_type (ins->opcode);
3624
3625                         switch (ins->opcode) {
3626                         case OP_EXTRACT_R8:
3627                         case OP_EXTRACT_I8:
3628                         case OP_EXTRACT_I4:
3629                         case OP_EXTRACT_I2:
3630                         case OP_EXTRACT_I1:
3631                                 break;
3632                         case OP_EXTRACT_U2:
3633                         case OP_EXTRACTX_U2:
3634                         case OP_EXTRACT_U1:
3635                                 zext = TRUE;
3636                                 break;
3637                         default:
3638                                 t = LLVMInt32Type ();
3639                                 g_assert_not_reached ();
3640                         }
3641
3642                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3643                         values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
3644                         if (zext)
3645                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
3646                         break;
3647                 }
3648
3649                 case OP_EXPAND_I1:
3650                 case OP_EXPAND_I2:
3651                 case OP_EXPAND_I4:
3652                 case OP_EXPAND_I8:
3653                 case OP_EXPAND_R4:
3654                 case OP_EXPAND_R8: {
3655                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3656                         LLVMValueRef mask [16], v;
3657
3658                         for (i = 0; i < 16; ++i)
3659                                 mask [i] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3660
3661                         v = convert (ctx, values [ins->sreg1], LLVMGetElementType (t));
3662
3663                         values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (t), v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3664                         values [ins->dreg] = LLVMBuildShuffleVector (builder, values [ins->dreg], LLVMGetUndef (t), LLVMConstVector (mask, LLVMGetVectorSize (t)), "");
3665                         break;
3666                 }
3667
3668                 case OP_INSERT_I1:
3669                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3670                         break;
3671                 case OP_INSERT_I2:
3672                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3673                         break;
3674                 case OP_INSERT_I4:
3675                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3676                         break;
3677                 case OP_INSERT_I8:
3678                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3679                         break;
3680                 case OP_INSERT_R4:
3681                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3682                         break;
3683                 case OP_INSERT_R8:
3684                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3685                         break;
3686
3687                 case OP_CVTDQ2PD:
3688                 case OP_CVTDQ2PS:
3689                 case OP_CVTPD2DQ:
3690                 case OP_CVTPS2DQ:
3691                 case OP_CVTPD2PS:
3692                 case OP_CVTPS2PD:
3693                 case OP_CVTTPD2DQ:
3694                 case OP_CVTTPS2DQ:
3695                 case OP_EXTRACT_MASK:
3696                 case OP_SQRTPS:
3697                 case OP_SQRTPD:
3698                 case OP_RSQRTPS:
3699                 case OP_RCPPS: {
3700                         LLVMValueRef v;
3701
3702                         v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
3703
3704                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
3705                         break;
3706                 }
3707
3708                 case OP_ICONV_TO_R8_RAW:
3709                         /* Same as OP_ICONV_TO_R8 */
3710                         values [ins->dreg] = convert (ctx, LLVMBuildBitCast (builder, lhs, LLVMFloatType (), ""), LLVMDoubleType ());
3711                         break;
3712
3713                 case OP_COMPPS:
3714                 case OP_COMPPD: {
3715                         LLVMValueRef args [3];
3716
3717                         args [0] = lhs;
3718                         args [1] = rhs;
3719                         args [2] = LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE);
3720
3721                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 3, dname);
3722                         break;
3723                 }
3724
3725                 case OP_ICONV_TO_X:
3726                         /* This is only used for implementing shifts by non-immediate */
3727                         values [ins->dreg] = lhs;
3728                         break;
3729
3730                 case OP_PSHRW:
3731                 case OP_PSHRD:
3732                 case OP_PSHRQ:
3733                 case OP_PSARW:
3734                 case OP_PSARD:
3735                 case OP_PSHLW:
3736                 case OP_PSHLD:
3737                 case OP_PSHLQ: {
3738                         LLVMValueRef args [3];
3739
3740                         args [0] = lhs;
3741                         args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
3742
3743                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3744                         break;
3745                 }
3746
3747                 case OP_PSHRW_REG:
3748                 case OP_PSHRD_REG:
3749                 case OP_PSHRQ_REG:
3750                 case OP_PSARW_REG:
3751                 case OP_PSARD_REG:
3752                 case OP_PSHLW_REG:
3753                 case OP_PSHLD_REG:
3754                 case OP_PSHLQ_REG: {
3755                         LLVMValueRef args [3];
3756
3757                         args [0] = lhs;
3758                         args [1] = values [ins->sreg2];
3759
3760                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3761                         break;
3762                 }
3763
3764                 case OP_SHUFPS:
3765                 case OP_SHUFPD:
3766                 case OP_PSHUFLED:
3767                 case OP_PSHUFLEW_LOW:
3768                 case OP_PSHUFLEW_HIGH: {
3769                         int mask [16];
3770                         LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
3771                         int i, mask_size = 0;
3772                         int imask = ins->inst_c0;
3773
3774                         /* Convert the x86 shuffle mask to LLVM's */
3775                         switch (ins->opcode) {
3776                         case OP_SHUFPS:
3777                                 mask_size = 4;
3778                                 mask [0] = ((imask >> 0) & 3);
3779                                 mask [1] = ((imask >> 2) & 3);
3780                                 mask [2] = ((imask >> 4) & 3) + 4;
3781                                 mask [3] = ((imask >> 6) & 3) + 4;
3782                                 v1 = values [ins->sreg1];
3783                                 v2 = values [ins->sreg2];
3784                                 break;
3785                         case OP_SHUFPD:
3786                                 mask_size = 2;
3787                                 mask [0] = ((imask >> 0) & 1);
3788                                 mask [1] = ((imask >> 1) & 1) + 2;
3789                                 v1 = values [ins->sreg1];
3790                                 v2 = values [ins->sreg2];
3791                                 break;
3792                         case OP_PSHUFLEW_LOW:
3793                                 mask_size = 8;
3794                                 mask [0] = ((imask >> 0) & 3);
3795                                 mask [1] = ((imask >> 2) & 3);
3796                                 mask [2] = ((imask >> 4) & 3);
3797                                 mask [3] = ((imask >> 6) & 3);
3798                                 mask [4] = 4 + 0;
3799                                 mask [5] = 4 + 1;
3800                                 mask [6] = 4 + 2;
3801                                 mask [7] = 4 + 3;
3802                                 v1 = values [ins->sreg1];
3803                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3804                                 break;
3805                         case OP_PSHUFLEW_HIGH:
3806                                 mask_size = 8;
3807                                 mask [0] = 0;
3808                                 mask [1] = 1;
3809                                 mask [2] = 2;
3810                                 mask [3] = 3;
3811                                 mask [4] = 4 + ((imask >> 0) & 3);
3812                                 mask [5] = 4 + ((imask >> 2) & 3);
3813                                 mask [6] = 4 + ((imask >> 4) & 3);
3814                                 mask [7] = 4 + ((imask >> 6) & 3);
3815                                 v1 = values [ins->sreg1];
3816                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3817                                 break;
3818                         case OP_PSHUFLED:
3819                                 mask_size = 4;
3820                                 mask [0] = ((imask >> 0) & 3);
3821                                 mask [1] = ((imask >> 2) & 3);
3822                                 mask [2] = ((imask >> 4) & 3);
3823                                 mask [3] = ((imask >> 6) & 3);
3824                                 v1 = values [ins->sreg1];
3825                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3826                                 break;
3827                         default:
3828                                 g_assert_not_reached ();
3829                         }
3830                         for (i = 0; i < mask_size; ++i)
3831                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3832
3833                         values [ins->dreg] =
3834                                 LLVMBuildShuffleVector (builder, v1, v2,
3835                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3836                         break;
3837                 }
3838
3839                 case OP_UNPACK_LOWB:
3840                 case OP_UNPACK_LOWW:
3841                 case OP_UNPACK_LOWD:
3842                 case OP_UNPACK_LOWQ:
3843                 case OP_UNPACK_LOWPS:
3844                 case OP_UNPACK_LOWPD:
3845                 case OP_UNPACK_HIGHB:
3846                 case OP_UNPACK_HIGHW:
3847                 case OP_UNPACK_HIGHD:
3848                 case OP_UNPACK_HIGHQ:
3849                 case OP_UNPACK_HIGHPS:
3850                 case OP_UNPACK_HIGHPD: {
3851                         int mask [16];
3852                         LLVMValueRef mask_values [16];
3853                         int i, mask_size = 0;
3854                         gboolean low = FALSE;
3855
3856                         switch (ins->opcode) {
3857                         case OP_UNPACK_LOWB:
3858                                 mask_size = 16;
3859                                 low = TRUE;
3860                                 break;
3861                         case OP_UNPACK_LOWW:
3862                                 mask_size = 8;
3863                                 low = TRUE;
3864                                 break;
3865                         case OP_UNPACK_LOWD:
3866                         case OP_UNPACK_LOWPS:
3867                                 mask_size = 4;
3868                                 low = TRUE;
3869                                 break;
3870                         case OP_UNPACK_LOWQ:
3871                         case OP_UNPACK_LOWPD:
3872                                 mask_size = 2;
3873                                 low = TRUE;
3874                                 break;
3875                         case OP_UNPACK_HIGHB:
3876                                 mask_size = 16;
3877                                 break;
3878                         case OP_UNPACK_HIGHW:
3879                                 mask_size = 8;
3880                                 break;
3881                         case OP_UNPACK_HIGHD:
3882                         case OP_UNPACK_HIGHPS:
3883                                 mask_size = 4;
3884                                 break;
3885                         case OP_UNPACK_HIGHQ:
3886                         case OP_UNPACK_HIGHPD:
3887                                 mask_size = 2;
3888                                 break;
3889                         default:
3890                                 g_assert_not_reached ();
3891                         }
3892
3893                         if (low) {
3894                                 for (i = 0; i < (mask_size / 2); ++i) {
3895                                         mask [(i * 2)] = i;
3896                                         mask [(i * 2) + 1] = mask_size + i;
3897                                 }
3898                         } else {
3899                                 for (i = 0; i < (mask_size / 2); ++i) {
3900                                         mask [(i * 2)] = (mask_size / 2) + i;
3901                                         mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
3902                                 }
3903                         }
3904
3905                         for (i = 0; i < mask_size; ++i)
3906                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3907
3908                         values [ins->dreg] =
3909                                 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
3910                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3911                         break;
3912                 }
3913
3914                 case OP_DUPPD: {
3915                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3916                         LLVMValueRef v, val;
3917
3918                         v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3919                         val = LLVMConstNull (t);
3920                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3921                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
3922
3923                         values [ins->dreg] = val;
3924                         break;
3925                 }
3926                 case OP_DUPPS_LOW:
3927                 case OP_DUPPS_HIGH: {
3928                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3929                         LLVMValueRef v1, v2, val;
3930
3931
3932                         if (ins->opcode == OP_DUPPS_LOW) {
3933                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3934                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3935                         } else {
3936                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3937                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3938                         }
3939                         val = LLVMConstNull (t);
3940                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3941                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3942                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3943                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3944
3945                         values [ins->dreg] = val;
3946                         break;
3947                 }
3948
3949 #endif /* SIMD */
3950
3951                 case OP_DUMMY_USE:
3952                         break;
3953
3954                         /*
3955                          * EXCEPTION HANDLING
3956                          */
3957                 case OP_IMPLICIT_EXCEPTION:
3958                         /* This marks a place where an implicit exception can happen */
3959                         if (bb->region != -1)
3960                                 LLVM_FAILURE (ctx, "implicit-exception");
3961                         break;
3962                 case OP_THROW:
3963                 case OP_RETHROW: {
3964                         MonoMethodSignature *throw_sig;
3965                         LLVMValueRef callee, arg;
3966                         gboolean rethrow = (ins->opcode == OP_RETHROW);
3967                         const char *icall_name;
3968
3969                         callee = rethrow ? ctx->lmodule->rethrow : ctx->lmodule->throw;
3970                         icall_name = rethrow ? "mono_arch_rethrow_exception" : "mono_arch_throw_exception";
3971
3972                         if (!callee) {
3973                                 throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
3974                                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
3975                                 throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
3976                                 if (cfg->compile_aot) {
3977                                         callee = get_plt_entry (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3978                                 } else {
3979                                         callee = LLVMAddFunction (module, icall_name, sig_to_llvm_sig (ctx, throw_sig));
3980
3981 #ifdef TARGET_X86
3982                                         /*
3983                                          * LLVM doesn't push the exception argument, so we need a different
3984                                          * trampoline.
3985                                          */
3986                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, rethrow ? "llvm_rethrow_exception_trampoline" : "llvm_throw_exception_trampoline"));
3987 #else
3988                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
3989 #endif
3990                                 }
3991
3992                                 mono_memory_barrier ();
3993                                 if (rethrow)
3994                                         ctx->lmodule->rethrow = callee;
3995                                 else
3996                                         ctx->lmodule->throw = callee;
3997                         }
3998                         arg = convert (ctx, lhs, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
3999                         emit_call (ctx, bb, &builder, callee, &arg, 1);
4000                         break;
4001                 }
4002                 case OP_CALL_HANDLER: {
4003                         /*
4004                          * We don't 'call' handlers, but instead simply branch to them.
4005                          * The code generated by ENDFINALLY will branch back to us.
4006                          */
4007                         LLVMBasicBlockRef noex_bb;
4008                         GSList *bb_list;
4009                         BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
4010
4011                         bb_list = info->call_handler_return_bbs;
4012
4013                         /*
4014                          * Set the indicator variable for the finally clause.
4015                          */
4016                         lhs = info->finally_ind;
4017                         g_assert (lhs);
4018                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
4019
4020                         /* Branch to the finally clause */
4021                         LLVMBuildBr (builder, info->call_handler_target_bb);
4022
4023                         noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
4024                         info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
4025
4026                         builder = ctx->builder = create_builder (ctx);
4027                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
4028
4029                         bblocks [bb->block_num].end_bblock = noex_bb;
4030                         break;
4031                 }
4032                 case OP_START_HANDLER: {
4033                         break;
4034                 }
4035                 case OP_ENDFINALLY: {
4036                         LLVMBasicBlockRef resume_bb;
4037                         MonoBasicBlock *handler_bb;
4038                         LLVMValueRef val, switch_ins, callee;
4039                         GSList *bb_list;
4040                         BBInfo *info;
4041
4042                         handler_bb = g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
4043                         g_assert (handler_bb);
4044                         info = &bblocks [handler_bb->block_num];
4045                         lhs = info->finally_ind;
4046                         g_assert (lhs);
4047
4048                         bb_list = info->call_handler_return_bbs;
4049
4050                         resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
4051
4052                         /* Load the finally variable */
4053                         val = LLVMBuildLoad (builder, lhs, "");
4054
4055                         /* Reset the variable */
4056                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
4057
4058                         /* Branch to either resume_bb, or to the bblocks in bb_list */
4059                         switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
4060                         /*
4061                          * The other targets are added at the end to handle OP_CALL_HANDLER
4062                          * opcodes processed later.
4063                          */
4064                         info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
4065
4066                         builder = ctx->builder = create_builder (ctx);
4067                         LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
4068
4069                         if (ctx->cfg->compile_aot) {
4070                                 callee = get_plt_entry (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
4071                         } else {
4072                                 callee = LLVMGetNamedFunction (module, "llvm_resume_unwind_trampoline");
4073                         }
4074                         LLVMBuildCall (builder, callee, NULL, 0, "");
4075
4076                         LLVMBuildUnreachable (builder);
4077                         has_terminator = TRUE;
4078                         break;
4079                 }
4080                 default: {
4081                         char reason [128];
4082
4083                         sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
4084                         LLVM_FAILURE (ctx, reason);
4085                         break;
4086                 }
4087                 }
4088
4089                 /* Convert the value to the type required by phi nodes */
4090                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
4091                         if (!values [ins->dreg])
4092                                 /* vtypes */
4093                                 values [ins->dreg] = addresses [ins->dreg];
4094                         else
4095                                 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
4096                 }
4097
4098                 /* Add stores for volatile variables */
4099                 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
4100                         emit_volatile_store (ctx, ins->dreg);
4101         }
4102
4103         if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0))
4104                 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
4105
4106         if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID)
4107                 LLVMBuildRetVoid (builder);
4108
4109         if (bb == cfg->bb_entry)
4110                 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
4111
4112         return;
4113
4114  FAILURE:
4115         return;
4116 }
4117
4118 /*
4119  * mono_llvm_check_method_supported:
4120  *
4121  *   Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
4122  * compiling a method twice.
4123  */
4124 void
4125 mono_llvm_check_method_supported (MonoCompile *cfg)
4126 {
4127         MonoMethodHeader *header = cfg->header;
4128         MonoExceptionClause *clause;
4129         int i;
4130
4131         if (cfg->method->save_lmf) {
4132                 cfg->exception_message = g_strdup ("lmf");
4133                 cfg->disable_llvm = TRUE;
4134         }
4135
4136 #if 1
4137         for (i = 0; i < header->num_clauses; ++i) {
4138                 clause = &header->clauses [i];
4139
4140                 if (i > 0 && clause->try_offset <= header->clauses [i - 1].handler_offset + header->clauses [i - 1].handler_len) {
4141                         /*
4142                          * FIXME: Some tests still fail with nested clauses.
4143                          */
4144                         cfg->exception_message = g_strdup ("nested clauses");
4145                         cfg->disable_llvm = TRUE;
4146                 }
4147         }
4148 #endif
4149
4150         /* FIXME: */
4151         if (cfg->method->dynamic) {
4152                 cfg->exception_message = g_strdup ("dynamic.");
4153                 cfg->disable_llvm = TRUE;
4154         }
4155 }
4156
4157 /*
4158  * mono_llvm_emit_method:
4159  *
4160  *   Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
4161  */
4162 void
4163 mono_llvm_emit_method (MonoCompile *cfg)
4164 {
4165         EmitContext *ctx;
4166         MonoMethodSignature *sig;
4167         MonoBasicBlock *bb;
4168         LLVMTypeRef method_type;
4169         LLVMValueRef method = NULL;
4170         char *method_name;
4171         LLVMValueRef *values;
4172         int i, max_block_num, bb_index;
4173         gboolean last = FALSE;
4174         GPtrArray *phi_values;
4175         LLVMCallInfo *linfo;
4176         GSList *l;
4177         LLVMModuleRef module;
4178         BBInfo *bblocks;
4179         GPtrArray *bblock_list;
4180         MonoMethodHeader *header;
4181         MonoExceptionClause *clause;
4182         LLVMSigInfo sinfo;
4183         char **names;
4184
4185         /* The code below might acquire the loader lock, so use it for global locking */
4186         mono_loader_lock ();
4187
4188         /* Used to communicate with the callbacks */
4189         mono_native_tls_set_value (current_cfg_tls_id, cfg);
4190
4191         ctx = g_new0 (EmitContext, 1);
4192         ctx->cfg = cfg;
4193         ctx->mempool = cfg->mempool;
4194
4195         /*
4196          * This maps vregs to the LLVM instruction defining them
4197          */
4198         values = g_new0 (LLVMValueRef, cfg->next_vreg);
4199         /*
4200          * This maps vregs for volatile variables to the LLVM instruction defining their
4201          * address.
4202          */
4203         ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
4204         ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
4205         ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
4206         phi_values = g_ptr_array_new ();
4207         /*
4208          * This signals whenever the vreg was defined by a phi node with no input vars
4209          * (i.e. all its input bblocks end with NOT_REACHABLE).
4210          */
4211         ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
4212         /* Whenever the bblock is unreachable */
4213         ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
4214
4215         bblock_list = g_ptr_array_new ();
4216
4217         ctx->values = values;
4218         ctx->region_to_handler = g_hash_table_new (NULL, NULL);
4219
4220         if (cfg->compile_aot) {
4221                 ctx->lmodule = &aot_module;
4222                 method_name = mono_aot_get_method_name (cfg);
4223                 cfg->llvm_method_name = g_strdup (method_name);
4224         } else {
4225                 init_jit_module ();
4226                 ctx->lmodule = &jit_module;
4227                 method_name = mono_method_full_name (cfg->method, TRUE);
4228         }
4229
4230         module = ctx->module = ctx->lmodule->module;
4231
4232         if (cfg->gsharedvt)
4233                 LLVM_FAILURE (ctx, "gsharedvt");
4234
4235 #if 1
4236         {
4237                 static int count = 0;
4238                 count ++;
4239
4240                 if (getenv ("LLVM_COUNT")) {
4241                         if (count == atoi (getenv ("LLVM_COUNT"))) {
4242                                 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
4243                                 fflush (stdout);
4244                                 last = TRUE;
4245                         }
4246                         if (count > atoi (getenv ("LLVM_COUNT")))
4247                                 LLVM_FAILURE (ctx, "");
4248                 }
4249         }
4250 #endif
4251
4252         sig = mono_method_signature (cfg->method);
4253         ctx->sig = sig;
4254
4255         linfo = mono_arch_get_llvm_call_info (cfg, sig);
4256         ctx->linfo = linfo;
4257         CHECK_FAILURE (ctx);
4258
4259         if (cfg->rgctx_var)
4260                 linfo->rgctx_arg = TRUE;
4261         method_type = sig_to_llvm_sig_full (ctx, sig, linfo, &sinfo);
4262         CHECK_FAILURE (ctx);
4263
4264         /*
4265          * This maps parameter indexes in the original signature to the indexes in
4266          * the LLVM signature.
4267          */
4268         ctx->pindexes = sinfo.pindexes;
4269
4270         method = LLVMAddFunction (module, method_name, method_type);
4271         ctx->lmethod = method;
4272
4273 #ifdef LLVM_MONO_BRANCH
4274         LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
4275 #endif
4276         LLVMSetLinkage (method, LLVMPrivateLinkage);
4277
4278         LLVMAddFunctionAttr (method, LLVMUWTable);
4279
4280         if (cfg->compile_aot) {
4281                 LLVMSetLinkage (method, LLVMInternalLinkage);
4282                 LLVMSetVisibility (method, LLVMHiddenVisibility);
4283         } else {
4284                 LLVMSetLinkage (method, LLVMPrivateLinkage);
4285         }
4286
4287         if (cfg->method->save_lmf)
4288                 LLVM_FAILURE (ctx, "lmf");
4289
4290         if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
4291                 LLVM_FAILURE (ctx, "pinvoke signature");
4292
4293         header = cfg->header;
4294         for (i = 0; i < header->num_clauses; ++i) {
4295                 clause = &header->clauses [i];
4296                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
4297                         LLVM_FAILURE (ctx, "non-finally/catch clause.");
4298         }
4299
4300         if (linfo->rgctx_arg) {
4301                 ctx->rgctx_arg = LLVMGetParam (method, sinfo.rgctx_arg_pindex);
4302                 /*
4303                  * We mark the rgctx parameter with the inreg attribute, which is mapped to
4304                  * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
4305                  * CC_X86_64_Mono in X86CallingConv.td.
4306                  */
4307                 LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
4308                 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
4309         }
4310         if (cfg->vret_addr) {
4311                 values [cfg->vret_addr->dreg] = LLVMGetParam (method, sinfo.vret_arg_pindex);
4312                 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
4313         }
4314         if (sig->hasthis) {
4315                 values [cfg->args [0]->dreg] = LLVMGetParam (method, sinfo.this_arg_pindex);
4316                 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
4317         }
4318
4319         names = g_new (char *, sig->param_count);
4320         mono_method_get_param_names (cfg->method, (const char **) names);
4321
4322         for (i = 0; i < sig->param_count; ++i) {
4323                 char *name;
4324
4325                 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, sinfo.pindexes [i]);
4326                 if (names [i] && names [i][0] != '\0')
4327                         name = g_strdup_printf ("arg_%s", names [i]);
4328                 else
4329                         name = g_strdup_printf ("arg_%d", i);
4330                 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
4331                 g_free (name);
4332                 if (linfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal)
4333                         LLVMAddAttribute (LLVMGetParam (method, sinfo.pindexes [i]), LLVMByValAttribute);
4334         }
4335         g_free (names);
4336
4337         if (cfg->compile_aot) {
4338                 LLVMValueRef md_args [16];
4339                 LLVMValueRef md_node;
4340                 int method_index;
4341
4342                 method_index = mono_aot_get_method_index (cfg->orig_method);
4343                 md_args [0] = LLVMMDString (method_name, strlen (method_name));
4344                 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
4345                 md_node = LLVMMDNode (md_args, 2);
4346                 LLVMAddNamedMetadataOperand (module, "mono.function_indexes", md_node);
4347                 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
4348         }
4349
4350         max_block_num = 0;
4351         for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
4352                 max_block_num = MAX (max_block_num, bb->block_num);
4353         ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
4354
4355         /* Add branches between non-consecutive bblocks */
4356         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4357                 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
4358                         bb->next_bb != bb->last_ins->inst_false_bb) {
4359
4360                         MonoInst *inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
4361                         inst->opcode = OP_BR;
4362                         inst->inst_target_bb = bb->last_ins->inst_false_bb;
4363                         mono_bblock_add_inst (bb, inst);
4364                 }
4365         }
4366
4367         /*
4368          * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
4369          * was later optimized away, so clear these flags, and add them back for the still
4370          * present OP_LDADDR instructions.
4371          */
4372         for (i = 0; i < cfg->next_vreg; ++i) {
4373                 MonoInst *ins;
4374
4375                 ins = get_vreg_to_inst (cfg, i);
4376                 if (ins && ins != cfg->rgctx_var)
4377                         ins->flags &= ~MONO_INST_INDIRECT;
4378         }
4379
4380         /*
4381          * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
4382          */
4383         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4384                 MonoInst *ins;
4385                 LLVMBuilderRef builder;
4386                 char *dname;
4387                 char dname_buf[128];
4388
4389                 builder = create_builder (ctx);
4390
4391                 for (ins = bb->code; ins; ins = ins->next) {
4392                         switch (ins->opcode) {
4393                         case OP_PHI:
4394                         case OP_FPHI:
4395                         case OP_VPHI:
4396                         case OP_XPHI: {
4397                                 LLVMTypeRef phi_type = llvm_type_to_stack_type (type_to_llvm_type (ctx, &ins->klass->byval_arg));
4398
4399                                 CHECK_FAILURE (ctx);
4400
4401                                 if (ins->opcode == OP_VPHI) {
4402                                         /* Treat valuetype PHI nodes as operating on the address itself */
4403                                         g_assert (ins->klass);
4404                                         phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
4405                                 }
4406
4407                                 /*
4408                                  * Have to precreate these, as they can be referenced by
4409                                  * earlier instructions.
4410                                  */
4411                                 sprintf (dname_buf, "t%d", ins->dreg);
4412                                 dname = dname_buf;
4413                                 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
4414
4415                                 if (ins->opcode == OP_VPHI)
4416                                         ctx->addresses [ins->dreg] = values [ins->dreg];
4417
4418                                 g_ptr_array_add (phi_values, values [ins->dreg]);
4419
4420                                 /*
4421                                  * Set the expected type of the incoming arguments since these have
4422                                  * to have the same type.
4423                                  */
4424                                 for (i = 0; i < ins->inst_phi_args [0]; i++) {
4425                                         int sreg1 = ins->inst_phi_args [i + 1];
4426
4427                                         if (sreg1 != -1)
4428                                                 ctx->vreg_types [sreg1] = phi_type;
4429                                 }
4430                                 break;
4431                                 }
4432                         case OP_LDADDR:
4433                                 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
4434                                 break;
4435                         default:
4436                                 break;
4437                         }
4438                 }
4439         }
4440
4441         /*
4442          * Create an ordering for bblocks, use the depth first order first, then
4443          * put the exception handling bblocks last.
4444          */
4445         for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
4446                 bb = cfg->bblocks [bb_index];
4447                 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
4448                         g_ptr_array_add (bblock_list, bb);
4449                         bblocks [bb->block_num].added = TRUE;
4450                 }
4451         }
4452
4453         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4454                 if (!bblocks [bb->block_num].added)
4455                         g_ptr_array_add (bblock_list, bb);
4456         }
4457
4458         /*
4459          * Second pass: generate code.
4460          */
4461         for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
4462                 bb = g_ptr_array_index (bblock_list, bb_index);
4463
4464                 if (!(bb == cfg->bb_entry || bb->in_count > 0))
4465                         continue;
4466
4467                 process_bb (ctx, bb);
4468                 CHECK_FAILURE (ctx);
4469         }
4470
4471         /* Add incoming phi values */
4472         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4473                 GSList *l, *ins_list;
4474
4475                 ins_list = bblocks [bb->block_num].phi_nodes;
4476
4477                 for (l = ins_list; l; l = l->next) {
4478                         PhiNode *node = l->data;
4479                         MonoInst *phi = node->phi;
4480                         int sreg1 = node->sreg;
4481                         LLVMBasicBlockRef in_bb;
4482
4483                         if (sreg1 == -1)
4484                                 continue;
4485
4486                         in_bb = get_end_bb (ctx, node->in_bb);
4487
4488                         if (ctx->unreachable [node->in_bb->block_num])
4489                                 continue;
4490
4491                         if (!values [sreg1])
4492                                 /* Can happen with values in EH clauses */
4493                                 LLVM_FAILURE (ctx, "incoming phi sreg1");
4494
4495                         if (phi->opcode == OP_VPHI) {
4496                                 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4497                                 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
4498                         } else {
4499                                 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4500                                 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
4501                         }
4502                 }
4503         }
4504
4505         /* Create the SWITCH statements for ENDFINALLY instructions */
4506         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4507                 BBInfo *info = &bblocks [bb->block_num];
4508                 GSList *l;
4509                 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
4510                         LLVMValueRef switch_ins = l->data;
4511                         GSList *bb_list = info->call_handler_return_bbs;
4512
4513                         for (i = 0; i < g_slist_length (bb_list); ++i)
4514                                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), g_slist_nth (bb_list, i)->data);
4515                 }
4516         }
4517
4518         if (cfg->verbose_level > 1)
4519                 mono_llvm_dump_value (method);
4520
4521         mark_as_used (module, method);
4522
4523         if (cfg->compile_aot) {
4524                 /* Don't generate native code, keep the LLVM IR */
4525                 if (cfg->compile_aot && cfg->verbose_level)
4526                         printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), method_name);
4527
4528                 //LLVMVerifyFunction(method, 0);
4529         } else {
4530                 mono_llvm_optimize_method (method);
4531
4532                 if (cfg->verbose_level > 1)
4533                         mono_llvm_dump_value (method);
4534
4535                 cfg->native_code = LLVMGetPointerToGlobal (ee, method);
4536
4537                 /* Set by emit_cb */
4538                 g_assert (cfg->code_len);
4539
4540                 /* FIXME: Free the LLVM IL for the function */
4541         }
4542
4543         goto CLEANUP;
4544
4545  FAILURE:
4546
4547         if (method) {
4548                 /* Need to add unused phi nodes as they can be referenced by other values */
4549                 LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (method, "PHI_BB");
4550                 LLVMBuilderRef builder;
4551
4552                 builder = create_builder (ctx);
4553                 LLVMPositionBuilderAtEnd (builder, phi_bb);
4554
4555                 for (i = 0; i < phi_values->len; ++i) {
4556                         LLVMValueRef v = g_ptr_array_index (phi_values, i);
4557                         if (LLVMGetInstructionParent (v) == NULL)
4558                                 LLVMInsertIntoBuilder (builder, v);
4559                 }
4560
4561                 LLVMDeleteFunction (method);
4562         }
4563
4564  CLEANUP:
4565         g_free (values);
4566         g_free (ctx->addresses);
4567         g_free (ctx->vreg_types);
4568         g_free (ctx->vreg_cli_types);
4569         g_free (ctx->pindexes);
4570         g_free (ctx->is_dead);
4571         g_free (ctx->unreachable);
4572         g_ptr_array_free (phi_values, TRUE);
4573         g_free (ctx->bblocks);
4574         g_hash_table_destroy (ctx->region_to_handler);
4575         g_free (method_name);
4576         g_ptr_array_free (bblock_list, TRUE);
4577
4578         for (l = ctx->builders; l; l = l->next) {
4579                 LLVMBuilderRef builder = l->data;
4580                 LLVMDisposeBuilder (builder);
4581         }
4582
4583         g_free (ctx);
4584
4585         mono_native_tls_set_value (current_cfg_tls_id, NULL);
4586
4587         mono_loader_unlock ();
4588 }
4589
4590 /*
4591  * mono_llvm_emit_call:
4592  *
4593  *   Same as mono_arch_emit_call () for LLVM.
4594  */
4595 void
4596 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
4597 {
4598         MonoInst *in;
4599         MonoMethodSignature *sig;
4600         int i, n, stack_size;
4601         LLVMArgInfo *ainfo;
4602
4603         stack_size = 0;
4604
4605         sig = call->signature;
4606         n = sig->param_count + sig->hasthis;
4607
4608         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4609
4610         if (cfg->disable_llvm)
4611                 return;
4612
4613         if (sig->call_convention == MONO_CALL_VARARG) {
4614                 cfg->exception_message = g_strdup ("varargs");
4615                 cfg->disable_llvm = TRUE;
4616         }
4617
4618         for (i = 0; i < n; ++i) {
4619                 MonoInst *ins;
4620
4621                 ainfo = call->cinfo->args + i;
4622
4623                 in = call->args [i];
4624
4625                 /* Simply remember the arguments */
4626                 switch (ainfo->storage) {
4627                 case LLVMArgInIReg:
4628                 case LLVMArgInFPReg: {
4629                         MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : sig->params [i - sig->hasthis];
4630
4631                         if (!t->byref && (t->type == MONO_TYPE_R8 || t->type == MONO_TYPE_R4)) {
4632                                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
4633                                 ins->dreg = mono_alloc_freg (cfg);
4634                         } else {
4635                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
4636                                 ins->dreg = mono_alloc_ireg (cfg);
4637                         }
4638                         ins->sreg1 = in->dreg;
4639                         break;
4640                 }
4641                 case LLVMArgVtypeByVal:
4642                 case LLVMArgVtypeInReg:
4643                         MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
4644                         ins->dreg = mono_alloc_ireg (cfg);
4645                         ins->sreg1 = in->dreg;
4646                         ins->klass = mono_class_from_mono_type (sig->params [i - sig->hasthis]);
4647                         break;
4648                 default:
4649                         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4650                         cfg->exception_message = g_strdup ("ainfo->storage");
4651                         cfg->disable_llvm = TRUE;
4652                         return;
4653                 }
4654
4655                 if (!cfg->disable_llvm) {
4656                         MONO_ADD_INS (cfg->cbb, ins);
4657                         mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
4658                 }
4659         }
4660 }
4661
4662 static unsigned char*
4663 alloc_cb (LLVMValueRef function, int size)
4664 {
4665         MonoCompile *cfg;
4666
4667         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4668
4669         if (cfg) {
4670                 // FIXME: dynamic
4671                 return mono_domain_code_reserve (cfg->domain, size);
4672         } else {
4673                 return mono_domain_code_reserve (mono_domain_get (), size);
4674         }
4675 }
4676
4677 static void
4678 emitted_cb (LLVMValueRef function, void *start, void *end)
4679 {
4680         MonoCompile *cfg;
4681
4682         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4683         g_assert (cfg);
4684         cfg->code_len = (guint8*)end - (guint8*)start;
4685 }
4686
4687 static void
4688 exception_cb (void *data)
4689 {
4690         MonoCompile *cfg;
4691         MonoJitExceptionInfo *ei;
4692         guint32 ei_len, i, j, nested_len, nindex;
4693         gpointer *type_info;
4694         int this_reg, this_offset;
4695
4696         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4697         g_assert (cfg);
4698
4699         /*
4700          * data points to a DWARF FDE structure, convert it to our unwind format and
4701          * save it.
4702          * An alternative would be to save it directly, and modify our unwinder to work
4703          * with it.
4704          */
4705         cfg->encoded_unwind_ops = mono_unwind_decode_fde ((guint8*)data, &cfg->encoded_unwind_ops_len, NULL, &ei, &ei_len, &type_info, &this_reg, &this_offset);
4706
4707         /* Count nested clauses */
4708         nested_len = 0;
4709         for (i = 0; i < ei_len; ++i) {
4710                 for (j = 0; j < ei_len; ++j) {
4711                         gint32 cindex1 = *(gint32*)type_info [i];
4712                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4713                         gint32 cindex2 = *(gint32*)type_info [j];
4714                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4715
4716                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4717                                 nested_len ++;
4718                         }
4719                 }
4720         }
4721
4722         cfg->llvm_ex_info = mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
4723         cfg->llvm_ex_info_len = ei_len + nested_len;
4724         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
4725         /* Fill the rest of the information from the type info */
4726         for (i = 0; i < ei_len; ++i) {
4727                 gint32 clause_index = *(gint32*)type_info [i];
4728                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
4729
4730                 cfg->llvm_ex_info [i].flags = clause->flags;
4731                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
4732         }
4733
4734         /*
4735          * For nested clauses, the LLVM produced exception info associates the try interval with
4736          * the innermost handler, while mono expects it to be associated with all nesting clauses.
4737          */
4738         /* FIXME: These should be order with the normal clauses */
4739         nindex = ei_len;
4740         for (i = 0; i < ei_len; ++i) {
4741                 for (j = 0; j < ei_len; ++j) {
4742                         gint32 cindex1 = *(gint32*)type_info [i];
4743                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4744                         gint32 cindex2 = *(gint32*)type_info [j];
4745                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4746
4747                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4748                                 /*
4749                                  * The try interval comes from the nested clause, everything else from the
4750                                  * nesting clause.
4751                                  */
4752                                 memcpy (&cfg->llvm_ex_info [nindex], &cfg->llvm_ex_info [j], sizeof (MonoJitExceptionInfo));
4753                                 cfg->llvm_ex_info [nindex].try_start = cfg->llvm_ex_info [i].try_start;
4754                                 cfg->llvm_ex_info [nindex].try_end = cfg->llvm_ex_info [i].try_end;
4755                                 nindex ++;
4756                         }
4757                 }
4758         }
4759         g_assert (nindex == ei_len + nested_len);
4760         cfg->llvm_this_reg = this_reg;
4761         cfg->llvm_this_offset = this_offset;
4762
4763         /* type_info [i] is cfg mempool allocated, no need to free it */
4764
4765         g_free (ei);
4766         g_free (type_info);
4767 }
4768
4769 static char*
4770 dlsym_cb (const char *name, void **symbol)
4771 {
4772         MonoDl *current;
4773         char *err;
4774
4775         err = NULL;
4776         if (!strcmp (name, "__bzero")) {
4777                 *symbol = (void*)bzero;
4778         } else {
4779                 current = mono_dl_open (NULL, 0, NULL);
4780                 g_assert (current);
4781
4782                 err = mono_dl_symbol (current, name, symbol);
4783         }
4784 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
4785         *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
4786 #endif
4787         return err;
4788 }
4789
4790 static inline void
4791 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
4792 {
4793         LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
4794 }
4795
4796 static inline void
4797 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
4798 {
4799         LLVMTypeRef param_types [4];
4800
4801         param_types [0] = param_type1;
4802         param_types [1] = param_type2;
4803
4804         AddFunc (module, name, ret_type, param_types, 2);
4805 }
4806
4807 static void
4808 add_intrinsics (LLVMModuleRef module)
4809 {
4810         /* Emit declarations of instrinsics */
4811         /*
4812          * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
4813          * type doesn't seem to do any locking.
4814          */
4815         {
4816                 LLVMTypeRef memset_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4817
4818                 memset_param_count = 5;
4819                 memset_func_name = "llvm.memset.p0i8.i32";
4820
4821                 LLVMAddFunction (module, memset_func_name, LLVMFunctionType (LLVMVoidType (), memset_params, memset_param_count, FALSE));
4822         }
4823
4824         {
4825                 LLVMTypeRef memcpy_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4826
4827                 memcpy_param_count = 5;
4828                 memcpy_func_name = "llvm.memcpy.p0i8.p0i8.i32";
4829
4830                 LLVMAddFunction (module, memcpy_func_name, LLVMFunctionType (LLVMVoidType (), memcpy_params, memcpy_param_count, FALSE));
4831         }
4832
4833         {
4834                 LLVMTypeRef params [] = { LLVMDoubleType () };
4835
4836                 LLVMAddFunction (module, "llvm.sin.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4837                 LLVMAddFunction (module, "llvm.cos.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4838                 LLVMAddFunction (module, "llvm.sqrt.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4839
4840                 /* This isn't an intrinsic, instead llvm seems to special case it by name */
4841                 LLVMAddFunction (module, "fabs", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4842         }
4843
4844         {
4845                 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
4846                 LLVMTypeRef ovf_params_i32 [] = { LLVMInt32Type (), LLVMInt32Type () };
4847
4848                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4849                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4850                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4851                 LLVMAddFunction (module, "llvm.usub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4852                 LLVMAddFunction (module, "llvm.smul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4853                 LLVMAddFunction (module, "llvm.umul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4854         }
4855
4856         {
4857                 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
4858                 LLVMTypeRef ovf_params_i64 [] = { LLVMInt64Type (), LLVMInt64Type () };
4859
4860                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4861                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4862                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4863                 LLVMAddFunction (module, "llvm.usub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4864                 LLVMAddFunction (module, "llvm.smul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4865                 LLVMAddFunction (module, "llvm.umul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4866         }
4867
4868         {
4869                 LLVMTypeRef struct_ptr = LLVMPointerType (LLVMStructType (NULL, 0, FALSE), 0);
4870                 LLVMTypeRef invariant_start_params [] = { LLVMInt64Type (), LLVMPointerType (LLVMInt8Type (), 0) };
4871                 LLVMTypeRef invariant_end_params [] = { struct_ptr, LLVMInt64Type (), LLVMPointerType (LLVMInt8Type (), 0) };
4872
4873                 LLVMAddFunction (module, "llvm.invariant.start", LLVMFunctionType (struct_ptr, invariant_start_params, 2, FALSE));
4874
4875                 LLVMAddFunction (module, "llvm.invariant.end", LLVMFunctionType (LLVMVoidType (), invariant_end_params, 3, FALSE));
4876         }
4877
4878         /* EH intrinsics */
4879         {
4880                 LLVMTypeRef arg_types [2];
4881                 LLVMTypeRef ret_type;
4882
4883                 arg_types [0] = LLVMPointerType (LLVMInt8Type (), 0);
4884                 arg_types [1] = LLVMPointerType (LLVMInt8Type (), 0);
4885                 ret_type = LLVMInt32Type ();
4886
4887                 LLVMAddFunction (module, "mono_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4888
4889                 LLVMAddFunction (module, "llvm_resume_unwind_trampoline", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4890         }
4891
4892         /* SSE intrinsics */
4893         {
4894                 LLVMTypeRef ret_type, arg_types [16];
4895
4896                 /* Binary ops */
4897                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4898                 arg_types [0] = ret_type;
4899                 arg_types [1] = ret_type;
4900                 AddFunc (module, "llvm.x86.sse41.pminud", ret_type, arg_types, 2);
4901                 AddFunc (module, "llvm.x86.sse41.pmaxud", ret_type, arg_types, 2);
4902
4903                 ret_type = type_to_simd_type (MONO_TYPE_I2);
4904                 arg_types [0] = ret_type;
4905                 arg_types [1] = ret_type;
4906                 AddFunc (module, "llvm.x86.sse41.pminuw", ret_type, arg_types, 2);
4907                 AddFunc (module, "llvm.x86.sse2.pmins.w", ret_type, arg_types, 2);
4908                 AddFunc (module, "llvm.x86.sse41.pmaxuw", ret_type, arg_types, 2);
4909                 AddFunc (module, "llvm.x86.sse2.padds.w", ret_type, arg_types, 2);
4910                 AddFunc (module, "llvm.x86.sse2.psubs.w", ret_type, arg_types, 2);
4911                 AddFunc (module, "llvm.x86.sse2.paddus.w", ret_type, arg_types, 2);
4912                 AddFunc (module, "llvm.x86.sse2.psubus.w", ret_type, arg_types, 2);
4913                 AddFunc (module, "llvm.x86.sse2.pavg.w", ret_type, arg_types, 2);
4914                 AddFunc (module, "llvm.x86.sse2.pmulh.w", ret_type, arg_types, 2);
4915                 AddFunc (module, "llvm.x86.sse2.pmulhu.w", ret_type, arg_types, 2);
4916
4917                 ret_type = type_to_simd_type (MONO_TYPE_I1);
4918                 arg_types [0] = ret_type;
4919                 arg_types [1] = ret_type;
4920                 AddFunc (module, "llvm.x86.sse2.pminu.b", ret_type, arg_types, 2);
4921                 AddFunc (module, "llvm.x86.sse2.pmaxu.b", ret_type, arg_types, 2);
4922                 AddFunc (module, "llvm.x86.sse2.padds.b", ret_type, arg_types, 2);
4923                 AddFunc (module, "llvm.x86.sse2.psubs.b", ret_type, arg_types, 2);
4924                 AddFunc (module, "llvm.x86.sse2.paddus.b", ret_type, arg_types, 2);
4925                 AddFunc (module, "llvm.x86.sse2.psubus.b", ret_type, arg_types, 2);
4926                 AddFunc (module, "llvm.x86.sse2.pavg.b", ret_type, arg_types, 2);
4927
4928                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4929                 arg_types [0] = ret_type;
4930                 arg_types [1] = ret_type;
4931                 AddFunc (module, "llvm.x86.sse2.min.pd", ret_type, arg_types, 2);
4932                 AddFunc (module, "llvm.x86.sse2.max.pd", ret_type, arg_types, 2);
4933                 AddFunc (module, "llvm.x86.sse3.hadd.pd", ret_type, arg_types, 2);
4934                 AddFunc (module, "llvm.x86.sse3.hsub.pd", ret_type, arg_types, 2);
4935                 AddFunc (module, "llvm.x86.sse3.addsub.pd", ret_type, arg_types, 2);
4936
4937                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4938                 arg_types [0] = ret_type;
4939                 arg_types [1] = ret_type;
4940                 AddFunc (module, "llvm.x86.sse.min.ps", ret_type, arg_types, 2);
4941                 AddFunc (module, "llvm.x86.sse.max.ps", ret_type, arg_types, 2);
4942                 AddFunc (module, "llvm.x86.sse3.hadd.ps", ret_type, arg_types, 2);
4943                 AddFunc (module, "llvm.x86.sse3.hsub.ps", ret_type, arg_types, 2);
4944                 AddFunc (module, "llvm.x86.sse3.addsub.ps", ret_type, arg_types, 2);
4945
4946                 /* pack */
4947                 ret_type = type_to_simd_type (MONO_TYPE_I1);
4948                 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
4949                 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
4950                 AddFunc (module, "llvm.x86.sse2.packsswb.128", ret_type, arg_types, 2);
4951                 AddFunc (module, "llvm.x86.sse2.packuswb.128", ret_type, arg_types, 2);
4952                 ret_type = type_to_simd_type (MONO_TYPE_I2);
4953                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4954                 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
4955                 AddFunc (module, "llvm.x86.sse2.packssdw.128", ret_type, arg_types, 2);
4956                 AddFunc (module, "llvm.x86.sse41.packusdw", ret_type, arg_types, 2);
4957
4958                 /* cmp pd/ps */
4959                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4960                 arg_types [0] = ret_type;
4961                 arg_types [1] = ret_type;
4962                 arg_types [2] = LLVMInt8Type ();
4963                 AddFunc (module, "llvm.x86.sse2.cmp.pd", ret_type, arg_types, 3);
4964                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4965                 arg_types [0] = ret_type;
4966                 arg_types [1] = ret_type;
4967                 arg_types [2] = LLVMInt8Type ();
4968                 AddFunc (module, "llvm.x86.sse.cmp.ps", ret_type, arg_types, 3);
4969
4970                 /* Conversion ops */
4971                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4972                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4973                 AddFunc (module, "llvm.x86.sse2.cvtdq2pd", ret_type, arg_types, 1);
4974                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4975                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4976                 AddFunc (module, "llvm.x86.sse2.cvtdq2ps", ret_type, arg_types, 1);
4977                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4978                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4979                 AddFunc (module, "llvm.x86.sse2.cvtpd2dq", ret_type, arg_types, 1);
4980                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4981                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4982                 AddFunc (module, "llvm.x86.sse2.cvtps2dq", ret_type, arg_types, 1);
4983                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4984                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4985                 AddFunc (module, "llvm.x86.sse2.cvtpd2ps", ret_type, arg_types, 1);
4986                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4987                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4988                 AddFunc (module, "llvm.x86.sse2.cvtps2pd", ret_type, arg_types, 1);
4989
4990                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4991                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4992                 AddFunc (module, "llvm.x86.sse2.cvttpd2dq", ret_type, arg_types, 1);
4993                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4994                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4995                 AddFunc (module, "llvm.x86.sse2.cvttps2dq", ret_type, arg_types, 1);
4996
4997                 /* Unary ops */
4998                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4999                 arg_types [0] = ret_type;
5000                 AddFunc (module, "llvm.x86.sse2.sqrt.pd", ret_type, arg_types, 1);
5001                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5002                 arg_types [0] = ret_type;
5003                 AddFunc (module, "llvm.x86.sse.sqrt.ps", ret_type, arg_types, 1);
5004                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5005                 arg_types [0] = ret_type;
5006                 AddFunc (module, "llvm.x86.sse.rsqrt.ps", ret_type, arg_types, 1);
5007                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5008                 arg_types [0] = ret_type;
5009                 AddFunc (module, "llvm.x86.sse.rcp.ps", ret_type, arg_types, 1);
5010
5011                 /* shifts */
5012                 ret_type = type_to_simd_type (MONO_TYPE_I2);
5013                 arg_types [0] = ret_type;
5014                 arg_types [1] = LLVMInt32Type ();
5015                 AddFunc (module, "llvm.x86.sse2.psrli.w", ret_type, arg_types, 2);
5016                 AddFunc (module, "llvm.x86.sse2.psrai.w", ret_type, arg_types, 2);
5017                 AddFunc (module, "llvm.x86.sse2.pslli.w", ret_type, arg_types, 2);
5018                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5019                 arg_types [0] = ret_type;
5020                 arg_types [1] = LLVMInt32Type ();
5021                 AddFunc (module, "llvm.x86.sse2.psrli.d", ret_type, arg_types, 2);
5022                 AddFunc (module, "llvm.x86.sse2.psrai.d", ret_type, arg_types, 2);
5023                 AddFunc (module, "llvm.x86.sse2.pslli.d", ret_type, arg_types, 2);
5024                 ret_type = type_to_simd_type (MONO_TYPE_I8);
5025                 arg_types [0] = ret_type;
5026                 arg_types [1] = LLVMInt32Type ();
5027                 AddFunc (module, "llvm.x86.sse2.psrli.q", ret_type, arg_types, 2);
5028                 AddFunc (module, "llvm.x86.sse2.pslli.q", ret_type, arg_types, 2);
5029
5030                 /* pmovmskb */
5031                 ret_type = LLVMInt32Type ();
5032                 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
5033                 AddFunc (module, "llvm.x86.sse2.pmovmskb.128", ret_type, arg_types, 1);
5034         }
5035
5036         AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
5037
5038         /* Load/Store intrinsics */
5039         {
5040                 LLVMTypeRef arg_types [5];
5041                 int i;
5042                 char name [128];
5043
5044                 for (i = 1; i <= 8; i *= 2) {
5045                         arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
5046                         arg_types [1] = LLVMInt32Type ();
5047                         arg_types [2] = LLVMInt1Type ();
5048                         sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
5049                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMIntType (i * 8), arg_types, 3, FALSE));
5050
5051                         arg_types [0] = LLVMIntType (i * 8);
5052                         arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
5053                         arg_types [2] = LLVMInt32Type ();
5054                         arg_types [3] = LLVMInt1Type ();
5055                         sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
5056                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMVoidType (), arg_types, 4, FALSE));
5057                 }
5058         }
5059 }
5060
5061 void
5062 mono_llvm_init (void)
5063 {
5064         mono_native_tls_alloc (&current_cfg_tls_id, NULL);
5065 }
5066
5067 static void
5068 init_jit_module (void)
5069 {
5070         MonoJitICallInfo *info;
5071
5072         if (jit_module_inited)
5073                 return;
5074
5075         mono_loader_lock ();
5076
5077         if (jit_module_inited) {
5078                 mono_loader_unlock ();
5079                 return;
5080         }
5081
5082         jit_module.module = LLVMModuleCreateWithName ("mono");
5083
5084         ee = mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (jit_module.module), alloc_cb, emitted_cb, exception_cb, dlsym_cb);
5085
5086         add_intrinsics (jit_module.module);
5087
5088         jit_module.llvm_types = g_hash_table_new (NULL, NULL);
5089
5090         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
5091         g_assert (info);
5092         LLVMAddGlobalMapping (ee, LLVMGetNamedFunction (jit_module.module, "llvm_resume_unwind_trampoline"), (void*)info->func);
5093
5094         jit_module_inited = TRUE;
5095
5096         mono_loader_unlock ();
5097 }
5098
5099 void
5100 mono_llvm_cleanup (void)
5101 {
5102         if (ee)
5103                 mono_llvm_dispose_ee (ee);
5104
5105         if (jit_module.llvm_types)
5106                 g_hash_table_destroy (jit_module.llvm_types);
5107
5108         if (aot_module.module)
5109                 LLVMDisposeModule (aot_module.module);
5110
5111         LLVMContextDispose (LLVMGetGlobalContext ());
5112 }
5113
5114 void
5115 mono_llvm_create_aot_module (const char *got_symbol)
5116 {
5117         /* Delete previous module */
5118         if (aot_module.plt_entries)
5119                 g_hash_table_destroy (aot_module.plt_entries);
5120         if (aot_module.module)
5121                 LLVMDisposeModule (aot_module.module);
5122
5123         memset (&aot_module, 0, sizeof (aot_module));
5124
5125         aot_module.module = LLVMModuleCreateWithName ("aot");
5126         aot_module.got_symbol = got_symbol;
5127
5128         add_intrinsics (aot_module.module);
5129
5130         /* Add GOT */
5131         /*
5132          * We couldn't compute the type of the LLVM global representing the got because
5133          * its size is only known after all the methods have been emitted. So create
5134          * a dummy variable, and replace all uses it with the real got variable when
5135          * its size is known in mono_llvm_emit_aot_module ().
5136          */
5137         {
5138                 LLVMTypeRef got_type = LLVMArrayType (IntPtrType (), 0);
5139
5140                 aot_module.got_var = LLVMAddGlobal (aot_module.module, got_type, "mono_dummy_got");
5141                 LLVMSetInitializer (aot_module.got_var, LLVMConstNull (got_type));
5142         }
5143
5144         /* Add a dummy personality function */
5145         {
5146                 LLVMBasicBlockRef lbb;
5147                 LLVMBuilderRef lbuilder;
5148                 LLVMValueRef personality;
5149
5150                 personality = LLVMAddFunction (aot_module.module, "mono_aot_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
5151                 LLVMSetLinkage (personality, LLVMInternalLinkage);
5152                 lbb = LLVMAppendBasicBlock (personality, "BB0");
5153                 lbuilder = LLVMCreateBuilder ();
5154                 LLVMPositionBuilderAtEnd (lbuilder, lbb);
5155                 LLVMBuildRetVoid (lbuilder);
5156         }
5157
5158         aot_module.llvm_types = g_hash_table_new (NULL, NULL);
5159         aot_module.plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
5160 }
5161
5162 /*
5163  * Emit the aot module into the LLVM bitcode file FILENAME.
5164  */
5165 void
5166 mono_llvm_emit_aot_module (const char *filename, int got_size)
5167 {
5168         LLVMTypeRef got_type;
5169         LLVMValueRef real_got;
5170
5171         /*
5172          * Create the real got variable and replace all uses of the dummy variable with
5173          * the real one.
5174          */
5175         got_type = LLVMArrayType (IntPtrType (), got_size);
5176         real_got = LLVMAddGlobal (aot_module.module, got_type, aot_module.got_symbol);
5177         LLVMSetInitializer (real_got, LLVMConstNull (got_type));
5178         LLVMSetLinkage (real_got, LLVMInternalLinkage);
5179
5180         mono_llvm_replace_uses_of (aot_module.got_var, real_got);
5181
5182         mark_as_used (aot_module.module, real_got);
5183
5184         /* Delete the dummy got so it doesn't become a global */
5185         LLVMDeleteGlobal (aot_module.got_var);
5186
5187 #if 0
5188         {
5189                 char *verifier_err;
5190
5191                 if (LLVMVerifyModule (aot_module.module, LLVMReturnStatusAction, &verifier_err)) {
5192                         g_assert_not_reached ();
5193                 }
5194         }
5195 #endif
5196
5197         LLVMWriteBitcodeToFile (aot_module.module, filename);
5198 }
5199
5200 /*
5201   DESIGN:
5202   - Emit LLVM IR from the mono IR using the LLVM C API.
5203   - The original arch specific code remains, so we can fall back to it if we run
5204     into something we can't handle.
5205 */
5206
5207 /*
5208   A partial list of issues:
5209   - Handling of opcodes which can throw exceptions.
5210
5211       In the mono JIT, these are implemented using code like this:
5212           method:
5213       <compare>
5214           throw_pos:
5215           b<cond> ex_label
5216           <rest of code>
5217       ex_label:
5218           push throw_pos - method
5219           call <exception trampoline>
5220
5221           The problematic part is push throw_pos - method, which cannot be represented
5222       in the LLVM IR, since it does not support label values.
5223           -> this can be implemented in AOT mode using inline asm + labels, but cannot
5224           be implemented in JIT mode ?
5225           -> a possible but slower implementation would use the normal exception
5226       throwing code but it would need to control the placement of the throw code
5227       (it needs to be exactly after the compare+branch).
5228           -> perhaps add a PC offset intrinsics ?
5229
5230   - efficient implementation of .ovf opcodes.
5231
5232           These are currently implemented as:
5233           <ins which sets the condition codes>
5234           b<cond> ex_label
5235
5236           Some overflow opcodes are now supported by LLVM SVN.
5237
5238   - exception handling, unwinding.
5239     - SSA is disabled for methods with exception handlers
5240         - How to obtain unwind info for LLVM compiled methods ?
5241           -> this is now solved by converting the unwind info generated by LLVM
5242              into our format.
5243         - LLVM uses the c++ exception handling framework, while we use our home grown
5244       code, and couldn't use the c++ one:
5245       - its not supported under VC++, other exotic platforms.
5246           - it might be impossible to support filter clauses with it.
5247
5248   - trampolines.
5249
5250     The trampolines need a predictable call sequence, since they need to disasm
5251     the calling code to obtain register numbers / offsets.
5252
5253     LLVM currently generates this code in non-JIT mode:
5254            mov    -0x98(%rax),%eax
5255            callq  *%rax
5256     Here, the vtable pointer is lost.
5257     -> solution: use one vtable trampoline per class.
5258
5259   - passing/receiving the IMT pointer/RGCTX.
5260     -> solution: pass them as normal arguments ?
5261
5262   - argument passing.
5263
5264           LLVM does not allow the specification of argument registers etc. This means
5265       that all calls are made according to the platform ABI.
5266
5267   - passing/receiving vtypes.
5268
5269       Vtypes passed/received in registers are handled by the front end by using
5270           a signature with scalar arguments, and loading the parts of the vtype into those
5271           arguments.
5272
5273           Vtypes passed on the stack are handled using the 'byval' attribute.
5274
5275   - ldaddr.
5276
5277     Supported though alloca, we need to emit the load/store code.
5278
5279   - types.
5280
5281     The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
5282     typed registers, so we have to keep track of the precise LLVM type of each vreg.
5283     This is made easier because the IR is already in SSA form.
5284     An additional problem is that our IR is not consistent with types, i.e. i32/ia64
5285         types are frequently used incorrectly.
5286 */
5287
5288 /*
5289   AOT SUPPORT:
5290   Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then
5291   append the AOT data structures to that file. For methods which cannot be
5292   handled by LLVM, the normal JIT compiled versions are used.
5293 */
5294
5295 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
5296  *   - each bblock should end with a branch
5297  *   - setting the return value, making cfg->ret non-volatile
5298  * - avoid some transformations in the JIT which make it harder for us to generate
5299  *   code.
5300  * - use pointer types to help optimizations.
5301  */