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