mono/mini/mini-llvm.c

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