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