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