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