mono/mini/mini-llvm.c

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