mono/mini/mini-llvm.c

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