mono/mini/mini-llvm.c

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