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