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                         LLVMValueRef base, shifted_offset, offset;
3361
3362                         base = LLVMConstInt (LLVMInt32Type (), mono_amd64_get_tls_gs_offset (), TRUE);
3363                         shifted_offset = LLVMBuildMul (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), 8, TRUE), "");
3364                         offset = LLVMBuildAdd (builder, base, shifted_offset, "");
3365                         // 256 == GS segment register
3366                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3367                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, offset, ptrtype, ""), "");
3368 #else
3369                         LLVM_FAILURE (ctx, "opcode tls-get");
3370 #endif
3371                         break;
3372                 }
3373
3374                         /*
3375                          * Overflow opcodes.
3376                          */
3377                 case OP_IADD_OVF:
3378                 case OP_IADD_OVF_UN:
3379                 case OP_ISUB_OVF:
3380                 case OP_ISUB_OVF_UN:
3381                 case OP_IMUL_OVF:
3382                 case OP_IMUL_OVF_UN:
3383 #if SIZEOF_VOID_P == 8
3384                 case OP_LADD_OVF:
3385                 case OP_LADD_OVF_UN:
3386                 case OP_LSUB_OVF:
3387                 case OP_LSUB_OVF_UN:
3388                 case OP_LMUL_OVF:
3389                 case OP_LMUL_OVF_UN:
3390 #endif
3391                         {
3392                                 LLVMValueRef args [2], val, ovf, func;
3393
3394                                 args [0] = convert (ctx, lhs, op_to_llvm_type (ins->opcode));
3395                                 args [1] = convert (ctx, rhs, op_to_llvm_type (ins->opcode));
3396                                 func = LLVMGetNamedFunction (module, ovf_op_to_intrins (ins->opcode));
3397                                 g_assert (func);
3398                                 val = LLVMBuildCall (builder, func, args, 2, "");
3399                                 values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, dname);
3400                                 ovf = LLVMBuildExtractValue (builder, val, 1, "");
3401                                 emit_cond_system_exception (ctx, bb, "OverflowException", ovf);
3402                                 CHECK_FAILURE (ctx);
3403                                 builder = ctx->builder;
3404                                 break;
3405                         }
3406
3407                         /*
3408                          * Valuetypes.
3409                          *   We currently model them using arrays. Promotion to local vregs is
3410                          * disabled for them in mono_handle_global_vregs () in the LLVM case,
3411                          * so we always have an entry in cfg->varinfo for them.
3412                          * FIXME: Is this needed ?
3413                          */
3414                 case OP_VZERO: {
3415                         MonoClass *klass = ins->klass;
3416                         LLVMValueRef args [5];
3417
3418                         if (!klass) {
3419                                 // FIXME:
3420                                 LLVM_FAILURE (ctx, "!klass");
3421                                 break;
3422                         }
3423
3424                         if (!addresses [ins->dreg])
3425                                 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3426                         args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3427                         args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
3428                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3429                         // FIXME: Alignment
3430                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3431                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3432                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
3433                         break;
3434                 }
3435
3436                 case OP_STOREV_MEMBASE:
3437                 case OP_LOADV_MEMBASE:
3438                 case OP_VMOVE: {
3439                         MonoClass *klass = ins->klass;
3440                         LLVMValueRef src = NULL, dst, args [5];
3441                         gboolean done = FALSE;
3442
3443                         if (!klass) {
3444                                 // FIXME:
3445                                 LLVM_FAILURE (ctx, "!klass");
3446                                 break;
3447                         }
3448
3449                         if (mini_is_gsharedvt_klass (cfg, klass)) {
3450                                 // FIXME:
3451                                 LLVM_FAILURE (ctx, "gsharedvt");
3452                                 break;
3453                         }
3454
3455                         switch (ins->opcode) {
3456                         case OP_STOREV_MEMBASE:
3457                                 if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg &&
3458                                         LLVMGetInstructionOpcode (values [ins->inst_destbasereg]) != LLVMAlloca) {
3459                                         /* Decomposed earlier */
3460                                         g_assert_not_reached ();
3461                                         break;
3462                                 }
3463                                 if (!addresses [ins->sreg1]) {
3464                                         /* SIMD */
3465                                         g_assert (values [ins->sreg1]);
3466                                         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));
3467                                         LLVMBuildStore (builder, values [ins->sreg1], dst);
3468                                         done = TRUE;
3469                                 } else {
3470                                         src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3471                                         dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3472                                 }
3473                                 break;
3474                         case OP_LOADV_MEMBASE:
3475                                 if (!addresses [ins->dreg])
3476                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3477                                 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3478                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3479                                 break;
3480                         case OP_VMOVE:
3481                                 if (!addresses [ins->sreg1])
3482                                         addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
3483                                 if (!addresses [ins->dreg])
3484                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3485                                 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3486                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3487                                 break;
3488                         default:
3489                                 g_assert_not_reached ();
3490                         }
3491                         CHECK_FAILURE (ctx);
3492
3493                         if (done)
3494                                 break;
3495
3496                         args [0] = dst;
3497                         args [1] = src;
3498                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3499                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3500                         // FIXME: Alignment
3501                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3502                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3503                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memcpy_func_name), args, memcpy_param_count, "");
3504                         break;
3505                 }
3506                 case OP_LLVM_OUTARG_VT:
3507                         if (!addresses [ins->sreg1]) {
3508                                 addresses [ins->sreg1] = build_alloca (ctx, &ins->klass->byval_arg);
3509                                 g_assert (values [ins->sreg1]);
3510                                 LLVMBuildStore (builder, values [ins->sreg1], addresses [ins->sreg1]);
3511                         }
3512                         addresses [ins->dreg] = addresses [ins->sreg1];
3513                         break;
3514
3515                         /*
3516                          * SIMD
3517                          */
3518 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3519                 case OP_XZERO: {
3520                         values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
3521                         break;
3522                 }
3523                 case OP_LOADX_MEMBASE: {
3524                         LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
3525                         LLVMValueRef src;
3526
3527                         src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3528                         values [ins->dreg] = mono_llvm_build_aligned_load (builder, src, "", FALSE, 1);
3529                         break;
3530                 }
3531                 case OP_STOREX_MEMBASE: {
3532                         LLVMTypeRef t = LLVMTypeOf (values [ins->sreg1]);
3533                         LLVMValueRef dest;
3534
3535                         dest = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3536                         mono_llvm_build_aligned_store (builder, values [ins->sreg1], dest, FALSE, 1);
3537                         break;
3538                 }
3539                 case OP_PADDB:
3540                 case OP_PADDW:
3541                 case OP_PADDD:
3542                 case OP_PADDQ:
3543                         values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, "");
3544                         break;
3545                 case OP_ADDPD:
3546                 case OP_ADDPS:
3547                         values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, "");
3548                         break;
3549                 case OP_PSUBB:
3550                 case OP_PSUBW:
3551                 case OP_PSUBD:
3552                 case OP_PSUBQ:
3553                         values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, "");
3554                         break;
3555                 case OP_SUBPD:
3556                 case OP_SUBPS:
3557                         values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, "");
3558                         break;
3559                 case OP_MULPD:
3560                 case OP_MULPS:
3561                         values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, "");
3562                         break;
3563                 case OP_DIVPD:
3564                 case OP_DIVPS:
3565                         values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, "");
3566                         break;
3567                 case OP_PAND:
3568                         values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, "");
3569                         break;
3570                 case OP_POR:
3571                         values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, "");
3572                         break;
3573                 case OP_PXOR:
3574                         values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, "");
3575                         break;
3576                 case OP_PMULW:
3577                 case OP_PMULD:
3578                         values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, "");
3579                         break;
3580                 case OP_ANDPS:
3581                 case OP_ANDNPS:
3582                 case OP_ORPS:
3583                 case OP_XORPS:
3584                 case OP_ANDPD:
3585                 case OP_ANDNPD:
3586                 case OP_ORPD:
3587                 case OP_XORPD: {
3588                         LLVMTypeRef t, rt;
3589                         LLVMValueRef v = NULL;
3590
3591                         switch (ins->opcode) {
3592                         case OP_ANDPS:
3593                         case OP_ANDNPS:
3594                         case OP_ORPS:
3595                         case OP_XORPS:
3596                                 t = LLVMVectorType (LLVMInt32Type (), 4);
3597                                 rt = LLVMVectorType (LLVMFloatType (), 4);
3598                                 break;
3599                         case OP_ANDPD:
3600                         case OP_ANDNPD:
3601                         case OP_ORPD:
3602                         case OP_XORPD:
3603                                 t = LLVMVectorType (LLVMInt64Type (), 2);
3604                                 rt = LLVMVectorType (LLVMDoubleType (), 2);
3605                                 break;
3606                         default:
3607                                 t = LLVMInt32Type ();
3608                                 rt = LLVMInt32Type ();
3609                                 g_assert_not_reached ();
3610                         }
3611
3612                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3613                         rhs = LLVMBuildBitCast (builder, rhs, t, "");
3614                         switch (ins->opcode) {
3615                         case OP_ANDPS:
3616                         case OP_ANDPD:
3617                                 v = LLVMBuildAnd (builder, lhs, rhs, "");
3618                                 break;
3619                         case OP_ORPS:
3620                         case OP_ORPD:
3621                                 v = LLVMBuildOr (builder, lhs, rhs, "");
3622                                 break;
3623                         case OP_XORPS:
3624                         case OP_XORPD:
3625                                 v = LLVMBuildXor (builder, lhs, rhs, "");
3626                                 break;
3627                         case OP_ANDNPS:
3628                         case OP_ANDNPD:
3629                                 v = LLVMBuildAnd (builder, rhs, LLVMBuildNot (builder, lhs, ""), "");
3630                                 break;
3631                         }
3632                         values [ins->dreg] = LLVMBuildBitCast (builder, v, rt, "");
3633                         break;
3634                 }
3635                 case OP_MINPD:
3636                 case OP_MINPS:
3637                 case OP_MAXPD:
3638                 case OP_MAXPS:
3639                 case OP_ADDSUBPD:
3640                 case OP_ADDSUBPS:
3641                 case OP_PMIND_UN:
3642                 case OP_PMINW_UN:
3643                 case OP_PMINB_UN:
3644                 case OP_PMINW:
3645                 case OP_PMAXD_UN:
3646                 case OP_PMAXW_UN:
3647                 case OP_PMAXB_UN:
3648                 case OP_HADDPD:
3649                 case OP_HADDPS:
3650                 case OP_HSUBPD:
3651                 case OP_HSUBPS:
3652                 case OP_PADDB_SAT:
3653                 case OP_PADDW_SAT:
3654                 case OP_PSUBB_SAT:
3655                 case OP_PSUBW_SAT:
3656                 case OP_PADDB_SAT_UN:
3657                 case OP_PADDW_SAT_UN:
3658                 case OP_PSUBB_SAT_UN:
3659                 case OP_PSUBW_SAT_UN:
3660                 case OP_PAVGB_UN:
3661                 case OP_PAVGW_UN:
3662                 case OP_PACKW:
3663                 case OP_PACKD:
3664                 case OP_PACKW_UN:
3665                 case OP_PACKD_UN:
3666                 case OP_PMULW_HIGH:
3667                 case OP_PMULW_HIGH_UN: {
3668                         LLVMValueRef args [2];
3669
3670                         args [0] = lhs;
3671                         args [1] = rhs;
3672
3673                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3674                         break;
3675                 }
3676                 case OP_PCMPEQB:
3677                 case OP_PCMPEQW:
3678                 case OP_PCMPEQD:
3679                 case OP_PCMPEQQ: {
3680                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntEQ, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3681                         break;
3682                 }
3683                 case OP_PCMPGTB: {
3684                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntSGT, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3685                         break;
3686                 }
3687                 case OP_EXTRACT_R8:
3688                 case OP_EXTRACT_I8:
3689                 case OP_EXTRACT_I4:
3690                 case OP_EXTRACT_I2:
3691                 case OP_EXTRACT_U2:
3692                 case OP_EXTRACTX_U2:
3693                 case OP_EXTRACT_I1:
3694                 case OP_EXTRACT_U1: {
3695                         LLVMTypeRef t;
3696                         gboolean zext = FALSE;
3697
3698                         t = simd_op_to_llvm_type (ins->opcode);
3699
3700                         switch (ins->opcode) {
3701                         case OP_EXTRACT_R8:
3702                         case OP_EXTRACT_I8:
3703                         case OP_EXTRACT_I4:
3704                         case OP_EXTRACT_I2:
3705                         case OP_EXTRACT_I1:
3706                                 break;
3707                         case OP_EXTRACT_U2:
3708                         case OP_EXTRACTX_U2:
3709                         case OP_EXTRACT_U1:
3710                                 zext = TRUE;
3711                                 break;
3712                         default:
3713                                 t = LLVMInt32Type ();
3714                                 g_assert_not_reached ();
3715                         }
3716
3717                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3718                         values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
3719                         if (zext)
3720                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
3721                         break;
3722                 }
3723
3724                 case OP_EXPAND_I1:
3725                 case OP_EXPAND_I2:
3726                 case OP_EXPAND_I4:
3727                 case OP_EXPAND_I8:
3728                 case OP_EXPAND_R4:
3729                 case OP_EXPAND_R8: {
3730                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3731                         LLVMValueRef mask [16], v;
3732
3733                         for (i = 0; i < 16; ++i)
3734                                 mask [i] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3735
3736                         v = convert (ctx, values [ins->sreg1], LLVMGetElementType (t));
3737
3738                         values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (t), v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3739                         values [ins->dreg] = LLVMBuildShuffleVector (builder, values [ins->dreg], LLVMGetUndef (t), LLVMConstVector (mask, LLVMGetVectorSize (t)), "");
3740                         break;
3741                 }
3742
3743                 case OP_INSERT_I1:
3744                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3745                         break;
3746                 case OP_INSERT_I2:
3747                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3748                         break;
3749                 case OP_INSERT_I4:
3750                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3751                         break;
3752                 case OP_INSERT_I8:
3753                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3754                         break;
3755                 case OP_INSERT_R4:
3756                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3757                         break;
3758                 case OP_INSERT_R8:
3759                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3760                         break;
3761
3762                 case OP_CVTDQ2PD:
3763                 case OP_CVTDQ2PS:
3764                 case OP_CVTPD2DQ:
3765                 case OP_CVTPS2DQ:
3766                 case OP_CVTPD2PS:
3767                 case OP_CVTPS2PD:
3768                 case OP_CVTTPD2DQ:
3769                 case OP_CVTTPS2DQ:
3770                 case OP_EXTRACT_MASK:
3771                 case OP_SQRTPS:
3772                 case OP_SQRTPD:
3773                 case OP_RSQRTPS:
3774                 case OP_RCPPS: {
3775                         LLVMValueRef v;
3776
3777                         v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
3778
3779                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
3780                         break;
3781                 }
3782
3783                 case OP_ICONV_TO_R8_RAW:
3784                         /* Same as OP_ICONV_TO_R8 */
3785                         values [ins->dreg] = convert (ctx, LLVMBuildBitCast (builder, lhs, LLVMFloatType (), ""), LLVMDoubleType ());
3786                         break;
3787
3788                 case OP_COMPPS:
3789                 case OP_COMPPD: {
3790                         LLVMValueRef args [3];
3791
3792                         args [0] = lhs;
3793                         args [1] = rhs;
3794                         args [2] = LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE);
3795
3796                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 3, dname);
3797                         break;
3798                 }
3799
3800                 case OP_ICONV_TO_X:
3801                         /* This is only used for implementing shifts by non-immediate */
3802                         values [ins->dreg] = lhs;
3803                         break;
3804
3805                 case OP_PSHRW:
3806                 case OP_PSHRD:
3807                 case OP_PSHRQ:
3808                 case OP_PSARW:
3809                 case OP_PSARD:
3810                 case OP_PSHLW:
3811                 case OP_PSHLD:
3812                 case OP_PSHLQ: {
3813                         LLVMValueRef args [3];
3814
3815                         args [0] = lhs;
3816                         args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
3817
3818                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3819                         break;
3820                 }
3821
3822                 case OP_PSHRW_REG:
3823                 case OP_PSHRD_REG:
3824                 case OP_PSHRQ_REG:
3825                 case OP_PSARW_REG:
3826                 case OP_PSARD_REG:
3827                 case OP_PSHLW_REG:
3828                 case OP_PSHLD_REG:
3829                 case OP_PSHLQ_REG: {
3830                         LLVMValueRef args [3];
3831
3832                         args [0] = lhs;
3833                         args [1] = values [ins->sreg2];
3834
3835                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3836                         break;
3837                 }
3838
3839                 case OP_SHUFPS:
3840                 case OP_SHUFPD:
3841                 case OP_PSHUFLED:
3842                 case OP_PSHUFLEW_LOW:
3843                 case OP_PSHUFLEW_HIGH: {
3844                         int mask [16];
3845                         LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
3846                         int i, mask_size = 0;
3847                         int imask = ins->inst_c0;
3848
3849                         /* Convert the x86 shuffle mask to LLVM's */
3850                         switch (ins->opcode) {
3851                         case OP_SHUFPS:
3852                                 mask_size = 4;
3853                                 mask [0] = ((imask >> 0) & 3);
3854                                 mask [1] = ((imask >> 2) & 3);
3855                                 mask [2] = ((imask >> 4) & 3) + 4;
3856                                 mask [3] = ((imask >> 6) & 3) + 4;
3857                                 v1 = values [ins->sreg1];
3858                                 v2 = values [ins->sreg2];
3859                                 break;
3860                         case OP_SHUFPD:
3861                                 mask_size = 2;
3862                                 mask [0] = ((imask >> 0) & 1);
3863                                 mask [1] = ((imask >> 1) & 1) + 2;
3864                                 v1 = values [ins->sreg1];
3865                                 v2 = values [ins->sreg2];
3866                                 break;
3867                         case OP_PSHUFLEW_LOW:
3868                                 mask_size = 8;
3869                                 mask [0] = ((imask >> 0) & 3);
3870                                 mask [1] = ((imask >> 2) & 3);
3871                                 mask [2] = ((imask >> 4) & 3);
3872                                 mask [3] = ((imask >> 6) & 3);
3873                                 mask [4] = 4 + 0;
3874                                 mask [5] = 4 + 1;
3875                                 mask [6] = 4 + 2;
3876                                 mask [7] = 4 + 3;
3877                                 v1 = values [ins->sreg1];
3878                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3879                                 break;
3880                         case OP_PSHUFLEW_HIGH:
3881                                 mask_size = 8;
3882                                 mask [0] = 0;
3883                                 mask [1] = 1;
3884                                 mask [2] = 2;
3885                                 mask [3] = 3;
3886                                 mask [4] = 4 + ((imask >> 0) & 3);
3887                                 mask [5] = 4 + ((imask >> 2) & 3);
3888                                 mask [6] = 4 + ((imask >> 4) & 3);
3889                                 mask [7] = 4 + ((imask >> 6) & 3);
3890                                 v1 = values [ins->sreg1];
3891                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3892                                 break;
3893                         case OP_PSHUFLED:
3894                                 mask_size = 4;
3895                                 mask [0] = ((imask >> 0) & 3);
3896                                 mask [1] = ((imask >> 2) & 3);
3897                                 mask [2] = ((imask >> 4) & 3);
3898                                 mask [3] = ((imask >> 6) & 3);
3899                                 v1 = values [ins->sreg1];
3900                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3901                                 break;
3902                         default:
3903                                 g_assert_not_reached ();
3904                         }
3905                         for (i = 0; i < mask_size; ++i)
3906                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3907
3908                         values [ins->dreg] =
3909                                 LLVMBuildShuffleVector (builder, v1, v2,
3910                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3911                         break;
3912                 }
3913
3914                 case OP_UNPACK_LOWB:
3915                 case OP_UNPACK_LOWW:
3916                 case OP_UNPACK_LOWD:
3917                 case OP_UNPACK_LOWQ:
3918                 case OP_UNPACK_LOWPS:
3919                 case OP_UNPACK_LOWPD:
3920                 case OP_UNPACK_HIGHB:
3921                 case OP_UNPACK_HIGHW:
3922                 case OP_UNPACK_HIGHD:
3923                 case OP_UNPACK_HIGHQ:
3924                 case OP_UNPACK_HIGHPS:
3925                 case OP_UNPACK_HIGHPD: {
3926                         int mask [16];
3927                         LLVMValueRef mask_values [16];
3928                         int i, mask_size = 0;
3929                         gboolean low = FALSE;
3930
3931                         switch (ins->opcode) {
3932                         case OP_UNPACK_LOWB:
3933                                 mask_size = 16;
3934                                 low = TRUE;
3935                                 break;
3936                         case OP_UNPACK_LOWW:
3937                                 mask_size = 8;
3938                                 low = TRUE;
3939                                 break;
3940                         case OP_UNPACK_LOWD:
3941                         case OP_UNPACK_LOWPS:
3942                                 mask_size = 4;
3943                                 low = TRUE;
3944                                 break;
3945                         case OP_UNPACK_LOWQ:
3946                         case OP_UNPACK_LOWPD:
3947                                 mask_size = 2;
3948                                 low = TRUE;
3949                                 break;
3950                         case OP_UNPACK_HIGHB:
3951                                 mask_size = 16;
3952                                 break;
3953                         case OP_UNPACK_HIGHW:
3954                                 mask_size = 8;
3955                                 break;
3956                         case OP_UNPACK_HIGHD:
3957                         case OP_UNPACK_HIGHPS:
3958                                 mask_size = 4;
3959                                 break;
3960                         case OP_UNPACK_HIGHQ:
3961                         case OP_UNPACK_HIGHPD:
3962                                 mask_size = 2;
3963                                 break;
3964                         default:
3965                                 g_assert_not_reached ();
3966                         }
3967
3968                         if (low) {
3969                                 for (i = 0; i < (mask_size / 2); ++i) {
3970                                         mask [(i * 2)] = i;
3971                                         mask [(i * 2) + 1] = mask_size + i;
3972                                 }
3973                         } else {
3974                                 for (i = 0; i < (mask_size / 2); ++i) {
3975                                         mask [(i * 2)] = (mask_size / 2) + i;
3976                                         mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
3977                                 }
3978                         }
3979
3980                         for (i = 0; i < mask_size; ++i)
3981                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3982
3983                         values [ins->dreg] =
3984                                 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
3985                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3986                         break;
3987                 }
3988
3989                 case OP_DUPPD: {
3990                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3991                         LLVMValueRef v, val;
3992
3993                         v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3994                         val = LLVMConstNull (t);
3995                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3996                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
3997
3998                         values [ins->dreg] = val;
3999                         break;
4000                 }
4001                 case OP_DUPPS_LOW:
4002                 case OP_DUPPS_HIGH: {
4003                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
4004                         LLVMValueRef v1, v2, val;
4005
4006
4007                         if (ins->opcode == OP_DUPPS_LOW) {
4008                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
4009                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
4010                         } else {
4011                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
4012                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
4013                         }
4014                         val = LLVMConstNull (t);
4015                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
4016                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
4017                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
4018                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
4019
4020                         values [ins->dreg] = val;
4021                         break;
4022                 }
4023
4024 #endif /* SIMD */
4025
4026                 case OP_DUMMY_USE:
4027                         break;
4028
4029                         /*
4030                          * EXCEPTION HANDLING
4031                          */
4032                 case OP_IMPLICIT_EXCEPTION:
4033                         /* This marks a place where an implicit exception can happen */
4034                         if (bb->region != -1)
4035                                 LLVM_FAILURE (ctx, "implicit-exception");
4036                         break;
4037                 case OP_THROW:
4038                 case OP_RETHROW: {
4039                         MonoMethodSignature *throw_sig;
4040                         LLVMValueRef callee, arg;
4041                         gboolean rethrow = (ins->opcode == OP_RETHROW);
4042                         const char *icall_name;
4043
4044                         callee = rethrow ? ctx->lmodule->rethrow : ctx->lmodule->throw;
4045                         icall_name = rethrow ? "mono_arch_rethrow_exception" : "mono_arch_throw_exception";
4046
4047                         if (!callee) {
4048                                 throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
4049                                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
4050                                 throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
4051                                 if (cfg->compile_aot) {
4052                                         callee = get_plt_entry (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
4053                                 } else {
4054                                         callee = LLVMAddFunction (module, icall_name, sig_to_llvm_sig (ctx, throw_sig));
4055
4056 #ifdef TARGET_X86
4057                                         /*
4058                                          * LLVM doesn't push the exception argument, so we need a different
4059                                          * trampoline.
4060                                          */
4061                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, rethrow ? "llvm_rethrow_exception_trampoline" : "llvm_throw_exception_trampoline"));
4062 #else
4063                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
4064 #endif
4065                                 }
4066
4067                                 mono_memory_barrier ();
4068                                 if (rethrow)
4069                                         ctx->lmodule->rethrow = callee;
4070                                 else
4071                                         ctx->lmodule->throw = callee;
4072                         }
4073                         arg = convert (ctx, lhs, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
4074                         emit_call (ctx, bb, &builder, callee, &arg, 1);
4075                         break;
4076                 }
4077                 case OP_CALL_HANDLER: {
4078                         /*
4079                          * We don't 'call' handlers, but instead simply branch to them.
4080                          * The code generated by ENDFINALLY will branch back to us.
4081                          */
4082                         LLVMBasicBlockRef noex_bb;
4083                         GSList *bb_list;
4084                         BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
4085
4086                         bb_list = info->call_handler_return_bbs;
4087
4088                         /*
4089                          * Set the indicator variable for the finally clause.
4090                          */
4091                         lhs = info->finally_ind;
4092                         g_assert (lhs);
4093                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
4094
4095                         /* Branch to the finally clause */
4096                         LLVMBuildBr (builder, info->call_handler_target_bb);
4097
4098                         noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
4099                         info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
4100
4101                         builder = ctx->builder = create_builder (ctx);
4102                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
4103
4104                         bblocks [bb->block_num].end_bblock = noex_bb;
4105                         break;
4106                 }
4107                 case OP_START_HANDLER: {
4108                         break;
4109                 }
4110                 case OP_ENDFINALLY: {
4111                         LLVMBasicBlockRef resume_bb;
4112                         MonoBasicBlock *handler_bb;
4113                         LLVMValueRef val, switch_ins, callee;
4114                         GSList *bb_list;
4115                         BBInfo *info;
4116
4117                         handler_bb = g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
4118                         g_assert (handler_bb);
4119                         info = &bblocks [handler_bb->block_num];
4120                         lhs = info->finally_ind;
4121                         g_assert (lhs);
4122
4123                         bb_list = info->call_handler_return_bbs;
4124
4125                         resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
4126
4127                         /* Load the finally variable */
4128                         val = LLVMBuildLoad (builder, lhs, "");
4129
4130                         /* Reset the variable */
4131                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
4132
4133                         /* Branch to either resume_bb, or to the bblocks in bb_list */
4134                         switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
4135                         /*
4136                          * The other targets are added at the end to handle OP_CALL_HANDLER
4137                          * opcodes processed later.
4138                          */
4139                         info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
4140
4141                         builder = ctx->builder = create_builder (ctx);
4142                         LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
4143
4144                         if (ctx->cfg->compile_aot) {
4145                                 callee = get_plt_entry (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
4146                         } else {
4147                                 callee = LLVMGetNamedFunction (module, "llvm_resume_unwind_trampoline");
4148                         }
4149                         LLVMBuildCall (builder, callee, NULL, 0, "");
4150
4151                         LLVMBuildUnreachable (builder);
4152                         has_terminator = TRUE;
4153                         break;
4154                 }
4155                 default: {
4156                         char reason [128];
4157
4158                         sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
4159                         LLVM_FAILURE (ctx, reason);
4160                         break;
4161                 }
4162                 }
4163
4164                 /* Convert the value to the type required by phi nodes */
4165                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
4166                         if (!values [ins->dreg])
4167                                 /* vtypes */
4168                                 values [ins->dreg] = addresses [ins->dreg];
4169                         else
4170                                 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
4171                 }
4172
4173                 /* Add stores for volatile variables */
4174                 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
4175                         emit_volatile_store (ctx, ins->dreg);
4176         }
4177
4178         if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0))
4179                 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
4180
4181         if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID)
4182                 LLVMBuildRetVoid (builder);
4183
4184         if (bb == cfg->bb_entry)
4185                 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
4186
4187         return;
4188
4189  FAILURE:
4190         return;
4191 }
4192
4193 /*
4194  * mono_llvm_check_method_supported:
4195  *
4196  *   Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
4197  * compiling a method twice.
4198  */
4199 void
4200 mono_llvm_check_method_supported (MonoCompile *cfg)
4201 {
4202         MonoMethodHeader *header = cfg->header;
4203         MonoExceptionClause *clause;
4204         int i;
4205
4206         if (cfg->method->save_lmf) {
4207                 cfg->exception_message = g_strdup ("lmf");
4208                 cfg->disable_llvm = TRUE;
4209         }
4210
4211 #if 1
4212         for (i = 0; i < header->num_clauses; ++i) {
4213                 clause = &header->clauses [i];
4214
4215                 if (i > 0 && clause->try_offset <= header->clauses [i - 1].handler_offset + header->clauses [i - 1].handler_len) {
4216                         /*
4217                          * FIXME: Some tests still fail with nested clauses.
4218                          */
4219                         cfg->exception_message = g_strdup ("nested clauses");
4220                         cfg->disable_llvm = TRUE;
4221                 }
4222         }
4223 #endif
4224
4225         /* FIXME: */
4226         if (cfg->method->dynamic) {
4227                 cfg->exception_message = g_strdup ("dynamic.");
4228                 cfg->disable_llvm = TRUE;
4229         }
4230 }
4231
4232 /*
4233  * mono_llvm_emit_method:
4234  *
4235  *   Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
4236  */
4237 void
4238 mono_llvm_emit_method (MonoCompile *cfg)
4239 {
4240         EmitContext *ctx;
4241         MonoMethodSignature *sig;
4242         MonoBasicBlock *bb;
4243         LLVMTypeRef method_type;
4244         LLVMValueRef method = NULL;
4245         char *method_name;
4246         LLVMValueRef *values;
4247         int i, max_block_num, bb_index;
4248         gboolean last = FALSE;
4249         GPtrArray *phi_values;
4250         LLVMCallInfo *linfo;
4251         GSList *l;
4252         LLVMModuleRef module;
4253         BBInfo *bblocks;
4254         GPtrArray *bblock_list;
4255         MonoMethodHeader *header;
4256         MonoExceptionClause *clause;
4257         LLVMSigInfo sinfo;
4258         char **names;
4259
4260         /* The code below might acquire the loader lock, so use it for global locking */
4261         mono_loader_lock ();
4262
4263         /* Used to communicate with the callbacks */
4264         mono_native_tls_set_value (current_cfg_tls_id, cfg);
4265
4266         ctx = g_new0 (EmitContext, 1);
4267         ctx->cfg = cfg;
4268         ctx->mempool = cfg->mempool;
4269
4270         /*
4271          * This maps vregs to the LLVM instruction defining them
4272          */
4273         values = g_new0 (LLVMValueRef, cfg->next_vreg);
4274         /*
4275          * This maps vregs for volatile variables to the LLVM instruction defining their
4276          * address.
4277          */
4278         ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
4279         ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
4280         ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
4281         phi_values = g_ptr_array_sized_new (256);
4282         /*
4283          * This signals whenever the vreg was defined by a phi node with no input vars
4284          * (i.e. all its input bblocks end with NOT_REACHABLE).
4285          */
4286         ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
4287         /* Whenever the bblock is unreachable */
4288         ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
4289
4290         bblock_list = g_ptr_array_sized_new (256);
4291
4292         ctx->values = values;
4293         ctx->region_to_handler = g_hash_table_new (NULL, NULL);
4294
4295         if (cfg->compile_aot) {
4296                 ctx->lmodule = &aot_module;
4297                 method_name = mono_aot_get_method_name (cfg);
4298                 cfg->llvm_method_name = g_strdup (method_name);
4299         } else {
4300                 init_jit_module ();
4301                 ctx->lmodule = &jit_module;
4302                 method_name = mono_method_full_name (cfg->method, TRUE);
4303         }
4304
4305         module = ctx->module = ctx->lmodule->module;
4306
4307         if (cfg->gsharedvt)
4308                 LLVM_FAILURE (ctx, "gsharedvt");
4309
4310 #if 1
4311         {
4312                 static int count = 0;
4313                 count ++;
4314
4315                 if (g_getenv ("LLVM_COUNT")) {
4316                         if (count == atoi (g_getenv ("LLVM_COUNT"))) {
4317                                 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
4318                                 fflush (stdout);
4319                                 last = TRUE;
4320                         }
4321                         if (count > atoi (g_getenv ("LLVM_COUNT")))
4322                                 LLVM_FAILURE (ctx, "");
4323                 }
4324         }
4325 #endif
4326
4327         sig = mono_method_signature (cfg->method);
4328         ctx->sig = sig;
4329
4330         linfo = mono_arch_get_llvm_call_info (cfg, sig);
4331         ctx->linfo = linfo;
4332         CHECK_FAILURE (ctx);
4333
4334         if (cfg->rgctx_var)
4335                 linfo->rgctx_arg = TRUE;
4336         method_type = sig_to_llvm_sig_full (ctx, sig, linfo, &sinfo);
4337         CHECK_FAILURE (ctx);
4338
4339         /*
4340          * This maps parameter indexes in the original signature to the indexes in
4341          * the LLVM signature.
4342          */
4343         ctx->pindexes = sinfo.pindexes;
4344
4345         method = LLVMAddFunction (module, method_name, method_type);
4346         ctx->lmethod = method;
4347
4348         LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
4349         LLVMSetLinkage (method, LLVMPrivateLinkage);
4350
4351         LLVMAddFunctionAttr (method, LLVMUWTable);
4352
4353         if (cfg->compile_aot) {
4354                 LLVMSetLinkage (method, LLVMInternalLinkage);
4355                 LLVMSetVisibility (method, LLVMHiddenVisibility);
4356         } else {
4357                 LLVMSetLinkage (method, LLVMPrivateLinkage);
4358         }
4359
4360         if (cfg->method->save_lmf)
4361                 LLVM_FAILURE (ctx, "lmf");
4362
4363         if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
4364                 LLVM_FAILURE (ctx, "pinvoke signature");
4365
4366         header = cfg->header;
4367         for (i = 0; i < header->num_clauses; ++i) {
4368                 clause = &header->clauses [i];
4369                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
4370                         LLVM_FAILURE (ctx, "non-finally/catch clause.");
4371         }
4372
4373         if (linfo->rgctx_arg) {
4374                 ctx->rgctx_arg = LLVMGetParam (method, sinfo.rgctx_arg_pindex);
4375                 /*
4376                  * We mark the rgctx parameter with the inreg attribute, which is mapped to
4377                  * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
4378                  * CC_X86_64_Mono in X86CallingConv.td.
4379                  */
4380                 LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
4381                 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
4382         }
4383         if (cfg->vret_addr) {
4384                 values [cfg->vret_addr->dreg] = LLVMGetParam (method, sinfo.vret_arg_pindex);
4385                 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
4386         }
4387         if (sig->hasthis) {
4388                 values [cfg->args [0]->dreg] = LLVMGetParam (method, sinfo.this_arg_pindex);
4389                 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
4390         }
4391
4392         names = g_new (char *, sig->param_count);
4393         mono_method_get_param_names (cfg->method, (const char **) names);
4394
4395         for (i = 0; i < sig->param_count; ++i) {
4396                 char *name;
4397
4398                 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, sinfo.pindexes [i]);
4399                 if (names [i] && names [i][0] != '\0')
4400                         name = g_strdup_printf ("arg_%s", names [i]);
4401                 else
4402                         name = g_strdup_printf ("arg_%d", i);
4403                 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
4404                 g_free (name);
4405                 if (linfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal)
4406                         LLVMAddAttribute (LLVMGetParam (method, sinfo.pindexes [i]), LLVMByValAttribute);
4407         }
4408         g_free (names);
4409
4410         max_block_num = 0;
4411         for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
4412                 max_block_num = MAX (max_block_num, bb->block_num);
4413         ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
4414
4415         /* Add branches between non-consecutive bblocks */
4416         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4417                 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
4418                         bb->next_bb != bb->last_ins->inst_false_bb) {
4419
4420                         MonoInst *inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
4421                         inst->opcode = OP_BR;
4422                         inst->inst_target_bb = bb->last_ins->inst_false_bb;
4423                         mono_bblock_add_inst (bb, inst);
4424                 }
4425         }
4426
4427         /*
4428          * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
4429          * was later optimized away, so clear these flags, and add them back for the still
4430          * present OP_LDADDR instructions.
4431          */
4432         for (i = 0; i < cfg->next_vreg; ++i) {
4433                 MonoInst *ins;
4434
4435                 ins = get_vreg_to_inst (cfg, i);
4436                 if (ins && ins != cfg->rgctx_var)
4437                         ins->flags &= ~MONO_INST_INDIRECT;
4438         }
4439
4440         /*
4441          * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
4442          */
4443         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4444                 MonoInst *ins;
4445                 LLVMBuilderRef builder;
4446                 char *dname;
4447                 char dname_buf[128];
4448
4449                 builder = create_builder (ctx);
4450
4451                 for (ins = bb->code; ins; ins = ins->next) {
4452                         switch (ins->opcode) {
4453                         case OP_PHI:
4454                         case OP_FPHI:
4455                         case OP_VPHI:
4456                         case OP_XPHI: {
4457                                 LLVMTypeRef phi_type = llvm_type_to_stack_type (type_to_llvm_type (ctx, &ins->klass->byval_arg));
4458
4459                                 CHECK_FAILURE (ctx);
4460
4461                                 if (ins->opcode == OP_VPHI) {
4462                                         /* Treat valuetype PHI nodes as operating on the address itself */
4463                                         g_assert (ins->klass);
4464                                         phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
4465                                 }
4466
4467                                 /*
4468                                  * Have to precreate these, as they can be referenced by
4469                                  * earlier instructions.
4470                                  */
4471                                 sprintf (dname_buf, "t%d", ins->dreg);
4472                                 dname = dname_buf;
4473                                 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
4474
4475                                 if (ins->opcode == OP_VPHI)
4476                                         ctx->addresses [ins->dreg] = values [ins->dreg];
4477
4478                                 g_ptr_array_add (phi_values, values [ins->dreg]);
4479
4480                                 /*
4481                                  * Set the expected type of the incoming arguments since these have
4482                                  * to have the same type.
4483                                  */
4484                                 for (i = 0; i < ins->inst_phi_args [0]; i++) {
4485                                         int sreg1 = ins->inst_phi_args [i + 1];
4486
4487                                         if (sreg1 != -1)
4488                                                 ctx->vreg_types [sreg1] = phi_type;
4489                                 }
4490                                 break;
4491                                 }
4492                         case OP_LDADDR:
4493                                 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
4494                                 break;
4495                         default:
4496                                 break;
4497                         }
4498                 }
4499         }
4500
4501         /*
4502          * Create an ordering for bblocks, use the depth first order first, then
4503          * put the exception handling bblocks last.
4504          */
4505         for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
4506                 bb = cfg->bblocks [bb_index];
4507                 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
4508                         g_ptr_array_add (bblock_list, bb);
4509                         bblocks [bb->block_num].added = TRUE;
4510                 }
4511         }
4512
4513         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4514                 if (!bblocks [bb->block_num].added)
4515                         g_ptr_array_add (bblock_list, bb);
4516         }
4517
4518         /*
4519          * Second pass: generate code.
4520          */
4521         for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
4522                 bb = g_ptr_array_index (bblock_list, bb_index);
4523
4524                 if (!(bb == cfg->bb_entry || bb->in_count > 0))
4525                         continue;
4526
4527                 process_bb (ctx, bb);
4528                 CHECK_FAILURE (ctx);
4529         }
4530
4531         /* Add incoming phi values */
4532         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4533                 GSList *l, *ins_list;
4534
4535                 ins_list = bblocks [bb->block_num].phi_nodes;
4536
4537                 for (l = ins_list; l; l = l->next) {
4538                         PhiNode *node = l->data;
4539                         MonoInst *phi = node->phi;
4540                         int sreg1 = node->sreg;
4541                         LLVMBasicBlockRef in_bb;
4542
4543                         if (sreg1 == -1)
4544                                 continue;
4545
4546                         in_bb = get_end_bb (ctx, node->in_bb);
4547
4548                         if (ctx->unreachable [node->in_bb->block_num])
4549                                 continue;
4550
4551                         if (!values [sreg1])
4552                                 /* Can happen with values in EH clauses */
4553                                 LLVM_FAILURE (ctx, "incoming phi sreg1");
4554
4555                         if (phi->opcode == OP_VPHI) {
4556                                 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4557                                 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
4558                         } else {
4559                                 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4560                                 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
4561                         }
4562                 }
4563         }
4564
4565         /* Create the SWITCH statements for ENDFINALLY instructions */
4566         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4567                 BBInfo *info = &bblocks [bb->block_num];
4568                 GSList *l;
4569                 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
4570                         LLVMValueRef switch_ins = l->data;
4571                         GSList *bb_list = info->call_handler_return_bbs;
4572
4573                         for (i = 0; i < g_slist_length (bb_list); ++i)
4574                                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), g_slist_nth (bb_list, i)->data);
4575                 }
4576         }
4577
4578         if (cfg->verbose_level > 1)
4579                 mono_llvm_dump_value (method);
4580
4581         if (cfg->compile_aot)
4582                 mark_as_used (ctx->lmodule, method);
4583
4584         if (cfg->compile_aot) {
4585                 LLVMValueRef md_args [16];
4586                 LLVMValueRef md_node;
4587                 int method_index;
4588
4589                 method_index = mono_aot_get_method_index (cfg->orig_method);
4590                 md_args [0] = LLVMMDString (method_name, strlen (method_name));
4591                 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
4592                 md_node = LLVMMDNode (md_args, 2);
4593                 LLVMAddNamedMetadataOperand (module, "mono.function_indexes", md_node);
4594                 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
4595         }
4596
4597         if (cfg->compile_aot) {
4598                 /* Don't generate native code, keep the LLVM IR */
4599                 if (cfg->compile_aot && cfg->verbose_level)
4600                         printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), method_name);
4601
4602                 //LLVMVerifyFunction(method, 0);
4603         } else {
4604                 mono_llvm_optimize_method (method);
4605
4606                 if (cfg->verbose_level > 1)
4607                         mono_llvm_dump_value (method);
4608
4609                 cfg->native_code = LLVMGetPointerToGlobal (ee, method);
4610
4611                 /* Set by emit_cb */
4612                 g_assert (cfg->code_len);
4613
4614                 /* FIXME: Free the LLVM IL for the function */
4615         }
4616
4617         goto CLEANUP;
4618
4619  FAILURE:
4620
4621         if (method) {
4622                 /* Need to add unused phi nodes as they can be referenced by other values */
4623                 LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (method, "PHI_BB");
4624                 LLVMBuilderRef builder;
4625
4626                 builder = create_builder (ctx);
4627                 LLVMPositionBuilderAtEnd (builder, phi_bb);
4628
4629                 for (i = 0; i < phi_values->len; ++i) {
4630                         LLVMValueRef v = g_ptr_array_index (phi_values, i);
4631                         if (LLVMGetInstructionParent (v) == NULL)
4632                                 LLVMInsertIntoBuilder (builder, v);
4633                 }
4634
4635                 LLVMDeleteFunction (method);
4636         }
4637
4638  CLEANUP:
4639         g_free (values);
4640         g_free (ctx->addresses);
4641         g_free (ctx->vreg_types);
4642         g_free (ctx->vreg_cli_types);
4643         g_free (ctx->pindexes);
4644         g_free (ctx->is_dead);
4645         g_free (ctx->unreachable);
4646         g_ptr_array_free (phi_values, TRUE);
4647         g_free (ctx->bblocks);
4648         g_hash_table_destroy (ctx->region_to_handler);
4649         g_free (method_name);
4650         g_ptr_array_free (bblock_list, TRUE);
4651
4652         for (l = ctx->builders; l; l = l->next) {
4653                 LLVMBuilderRef builder = l->data;
4654                 LLVMDisposeBuilder (builder);
4655         }
4656
4657         g_free (ctx);
4658
4659         mono_native_tls_set_value (current_cfg_tls_id, NULL);
4660
4661         mono_loader_unlock ();
4662 }
4663
4664 /*
4665  * mono_llvm_emit_call:
4666  *
4667  *   Same as mono_arch_emit_call () for LLVM.
4668  */
4669 void
4670 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
4671 {
4672         MonoInst *in;
4673         MonoMethodSignature *sig;
4674         int i, n, stack_size;
4675         LLVMArgInfo *ainfo;
4676
4677         stack_size = 0;
4678
4679         sig = call->signature;
4680         n = sig->param_count + sig->hasthis;
4681
4682         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4683
4684         if (cfg->disable_llvm)
4685                 return;
4686
4687         if (sig->call_convention == MONO_CALL_VARARG) {
4688                 cfg->exception_message = g_strdup ("varargs");
4689                 cfg->disable_llvm = TRUE;
4690         }
4691
4692         for (i = 0; i < n; ++i) {
4693                 MonoInst *ins;
4694
4695                 ainfo = call->cinfo->args + i;
4696
4697                 in = call->args [i];
4698
4699                 /* Simply remember the arguments */
4700                 switch (ainfo->storage) {
4701                 case LLVMArgInIReg:
4702                 case LLVMArgInFPReg: {
4703                         MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : sig->params [i - sig->hasthis];
4704
4705                         if (!t->byref && (t->type == MONO_TYPE_R8 || t->type == MONO_TYPE_R4)) {
4706                                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
4707                                 ins->dreg = mono_alloc_freg (cfg);
4708                         } else {
4709                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
4710                                 ins->dreg = mono_alloc_ireg (cfg);
4711                         }
4712                         ins->sreg1 = in->dreg;
4713                         break;
4714                 }
4715                 case LLVMArgVtypeByVal:
4716                 case LLVMArgVtypeInReg:
4717                         MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
4718                         ins->dreg = mono_alloc_ireg (cfg);
4719                         ins->sreg1 = in->dreg;
4720                         ins->klass = mono_class_from_mono_type (sig->params [i - sig->hasthis]);
4721                         break;
4722                 default:
4723                         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4724                         cfg->exception_message = g_strdup ("ainfo->storage");
4725                         cfg->disable_llvm = TRUE;
4726                         return;
4727                 }
4728
4729                 if (!cfg->disable_llvm) {
4730                         MONO_ADD_INS (cfg->cbb, ins);
4731                         mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
4732                 }
4733         }
4734 }
4735
4736 static unsigned char*
4737 alloc_cb (LLVMValueRef function, int size)
4738 {
4739         MonoCompile *cfg;
4740
4741         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4742
4743         if (cfg) {
4744                 // FIXME: dynamic
4745                 return mono_domain_code_reserve (cfg->domain, size);
4746         } else {
4747                 return mono_domain_code_reserve (mono_domain_get (), size);
4748         }
4749 }
4750
4751 static void
4752 emitted_cb (LLVMValueRef function, void *start, void *end)
4753 {
4754         MonoCompile *cfg;
4755
4756         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4757         g_assert (cfg);
4758         cfg->code_len = (guint8*)end - (guint8*)start;
4759 }
4760
4761 static void
4762 exception_cb (void *data)
4763 {
4764         MonoCompile *cfg;
4765         MonoJitExceptionInfo *ei;
4766         guint32 ei_len, i, j, nested_len, nindex;
4767         gpointer *type_info;
4768         int this_reg, this_offset;
4769
4770         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4771         g_assert (cfg);
4772
4773         /*
4774          * data points to a DWARF FDE structure, convert it to our unwind format and
4775          * save it.
4776          * An alternative would be to save it directly, and modify our unwinder to work
4777          * with it.
4778          */
4779         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);
4780         if (cfg->verbose_level > 1)
4781                 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
4782
4783         /* Count nested clauses */
4784         nested_len = 0;
4785         for (i = 0; i < ei_len; ++i) {
4786                 for (j = 0; j < ei_len; ++j) {
4787                         gint32 cindex1 = *(gint32*)type_info [i];
4788                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4789                         gint32 cindex2 = *(gint32*)type_info [j];
4790                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4791
4792                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4793                                 nested_len ++;
4794                         }
4795                 }
4796         }
4797
4798         cfg->llvm_ex_info = mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
4799         cfg->llvm_ex_info_len = ei_len + nested_len;
4800         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
4801         /* Fill the rest of the information from the type info */
4802         for (i = 0; i < ei_len; ++i) {
4803                 gint32 clause_index = *(gint32*)type_info [i];
4804                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
4805
4806                 cfg->llvm_ex_info [i].flags = clause->flags;
4807                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
4808         }
4809
4810         /*
4811          * For nested clauses, the LLVM produced exception info associates the try interval with
4812          * the innermost handler, while mono expects it to be associated with all nesting clauses.
4813          */
4814         /* FIXME: These should be order with the normal clauses */
4815         nindex = ei_len;
4816         for (i = 0; i < ei_len; ++i) {
4817                 for (j = 0; j < ei_len; ++j) {
4818                         gint32 cindex1 = *(gint32*)type_info [i];
4819                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4820                         gint32 cindex2 = *(gint32*)type_info [j];
4821                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4822
4823                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4824                                 /*
4825                                  * The try interval comes from the nested clause, everything else from the
4826                                  * nesting clause.
4827                                  */
4828                                 memcpy (&cfg->llvm_ex_info [nindex], &cfg->llvm_ex_info [j], sizeof (MonoJitExceptionInfo));
4829                                 cfg->llvm_ex_info [nindex].try_start = cfg->llvm_ex_info [i].try_start;
4830                                 cfg->llvm_ex_info [nindex].try_end = cfg->llvm_ex_info [i].try_end;
4831                                 nindex ++;
4832                         }
4833                 }
4834         }
4835         g_assert (nindex == ei_len + nested_len);
4836         cfg->llvm_this_reg = this_reg;
4837         cfg->llvm_this_offset = this_offset;
4838
4839         /* type_info [i] is cfg mempool allocated, no need to free it */
4840
4841         g_free (ei);
4842         g_free (type_info);
4843 }
4844
4845 static char*
4846 dlsym_cb (const char *name, void **symbol)
4847 {
4848         MonoDl *current;
4849         char *err;
4850
4851         err = NULL;
4852         if (!strcmp (name, "__bzero")) {
4853                 *symbol = (void*)bzero;
4854         } else {
4855                 current = mono_dl_open (NULL, 0, NULL);
4856                 g_assert (current);
4857
4858                 err = mono_dl_symbol (current, name, symbol);
4859         }
4860 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
4861         *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
4862 #endif
4863         return err;
4864 }
4865
4866 static inline void
4867 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
4868 {
4869         LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
4870 }
4871
4872 static inline void
4873 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
4874 {
4875         LLVMTypeRef param_types [4];
4876
4877         param_types [0] = param_type1;
4878         param_types [1] = param_type2;
4879
4880         AddFunc (module, name, ret_type, param_types, 2);
4881 }
4882
4883 static void
4884 add_intrinsics (LLVMModuleRef module)
4885 {
4886         /* Emit declarations of instrinsics */
4887         /*
4888          * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
4889          * type doesn't seem to do any locking.
4890          */
4891         {
4892                 LLVMTypeRef memset_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4893
4894                 memset_param_count = 5;
4895                 memset_func_name = "llvm.memset.p0i8.i32";
4896
4897                 LLVMAddFunction (module, memset_func_name, LLVMFunctionType (LLVMVoidType (), memset_params, memset_param_count, FALSE));
4898         }
4899
4900         {
4901                 LLVMTypeRef memcpy_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4902
4903                 memcpy_param_count = 5;
4904                 memcpy_func_name = "llvm.memcpy.p0i8.p0i8.i32";
4905
4906                 LLVMAddFunction (module, memcpy_func_name, LLVMFunctionType (LLVMVoidType (), memcpy_params, memcpy_param_count, FALSE));
4907         }
4908
4909         {
4910                 LLVMTypeRef params [] = { LLVMDoubleType () };
4911
4912                 LLVMAddFunction (module, "llvm.sin.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4913                 LLVMAddFunction (module, "llvm.cos.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4914                 LLVMAddFunction (module, "llvm.sqrt.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4915
4916                 /* This isn't an intrinsic, instead llvm seems to special case it by name */
4917                 LLVMAddFunction (module, "fabs", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4918         }
4919
4920         {
4921                 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
4922                 LLVMTypeRef ovf_params_i32 [] = { LLVMInt32Type (), LLVMInt32Type () };
4923
4924                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4925                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4926                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4927                 LLVMAddFunction (module, "llvm.usub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4928                 LLVMAddFunction (module, "llvm.smul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4929                 LLVMAddFunction (module, "llvm.umul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4930         }
4931
4932         {
4933                 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
4934                 LLVMTypeRef ovf_params_i64 [] = { LLVMInt64Type (), LLVMInt64Type () };
4935
4936                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4937                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4938                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4939                 LLVMAddFunction (module, "llvm.usub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4940                 LLVMAddFunction (module, "llvm.smul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4941                 LLVMAddFunction (module, "llvm.umul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4942         }
4943
4944         /* EH intrinsics */
4945         {
4946                 LLVMTypeRef arg_types [2];
4947                 LLVMTypeRef ret_type;
4948
4949                 arg_types [0] = LLVMPointerType (LLVMInt8Type (), 0);
4950                 arg_types [1] = LLVMPointerType (LLVMInt8Type (), 0);
4951                 ret_type = LLVMInt32Type ();
4952
4953                 LLVMAddFunction (module, "mono_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4954
4955                 LLVMAddFunction (module, "llvm_resume_unwind_trampoline", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4956         }
4957
4958         /* SSE intrinsics */
4959 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4960         {
4961                 LLVMTypeRef ret_type, arg_types [16];
4962
4963                 /* Binary ops */
4964                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4965                 arg_types [0] = ret_type;
4966                 arg_types [1] = ret_type;
4967                 AddFunc (module, "llvm.x86.sse41.pminud", ret_type, arg_types, 2);
4968                 AddFunc (module, "llvm.x86.sse41.pmaxud", ret_type, arg_types, 2);
4969
4970                 ret_type = type_to_simd_type (MONO_TYPE_I2);
4971                 arg_types [0] = ret_type;
4972                 arg_types [1] = ret_type;
4973                 AddFunc (module, "llvm.x86.sse41.pminuw", ret_type, arg_types, 2);
4974                 AddFunc (module, "llvm.x86.sse2.pmins.w", ret_type, arg_types, 2);
4975                 AddFunc (module, "llvm.x86.sse41.pmaxuw", ret_type, arg_types, 2);
4976                 AddFunc (module, "llvm.x86.sse2.padds.w", ret_type, arg_types, 2);
4977                 AddFunc (module, "llvm.x86.sse2.psubs.w", ret_type, arg_types, 2);
4978                 AddFunc (module, "llvm.x86.sse2.paddus.w", ret_type, arg_types, 2);
4979                 AddFunc (module, "llvm.x86.sse2.psubus.w", ret_type, arg_types, 2);
4980                 AddFunc (module, "llvm.x86.sse2.pavg.w", ret_type, arg_types, 2);
4981                 AddFunc (module, "llvm.x86.sse2.pmulh.w", ret_type, arg_types, 2);
4982                 AddFunc (module, "llvm.x86.sse2.pmulhu.w", ret_type, arg_types, 2);
4983
4984                 ret_type = type_to_simd_type (MONO_TYPE_I1);
4985                 arg_types [0] = ret_type;
4986                 arg_types [1] = ret_type;
4987                 AddFunc (module, "llvm.x86.sse2.pminu.b", ret_type, arg_types, 2);
4988                 AddFunc (module, "llvm.x86.sse2.pmaxu.b", ret_type, arg_types, 2);
4989                 AddFunc (module, "llvm.x86.sse2.padds.b", ret_type, arg_types, 2);
4990                 AddFunc (module, "llvm.x86.sse2.psubs.b", ret_type, arg_types, 2);
4991                 AddFunc (module, "llvm.x86.sse2.paddus.b", ret_type, arg_types, 2);
4992                 AddFunc (module, "llvm.x86.sse2.psubus.b", ret_type, arg_types, 2);
4993                 AddFunc (module, "llvm.x86.sse2.pavg.b", ret_type, arg_types, 2);
4994
4995                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4996                 arg_types [0] = ret_type;
4997                 arg_types [1] = ret_type;
4998                 AddFunc (module, "llvm.x86.sse2.min.pd", ret_type, arg_types, 2);
4999                 AddFunc (module, "llvm.x86.sse2.max.pd", ret_type, arg_types, 2);
5000                 AddFunc (module, "llvm.x86.sse3.hadd.pd", ret_type, arg_types, 2);
5001                 AddFunc (module, "llvm.x86.sse3.hsub.pd", ret_type, arg_types, 2);
5002                 AddFunc (module, "llvm.x86.sse3.addsub.pd", ret_type, arg_types, 2);
5003
5004                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5005                 arg_types [0] = ret_type;
5006                 arg_types [1] = ret_type;
5007                 AddFunc (module, "llvm.x86.sse.min.ps", ret_type, arg_types, 2);
5008                 AddFunc (module, "llvm.x86.sse.max.ps", ret_type, arg_types, 2);
5009                 AddFunc (module, "llvm.x86.sse3.hadd.ps", ret_type, arg_types, 2);
5010                 AddFunc (module, "llvm.x86.sse3.hsub.ps", ret_type, arg_types, 2);
5011                 AddFunc (module, "llvm.x86.sse3.addsub.ps", ret_type, arg_types, 2);
5012
5013                 /* pack */
5014                 ret_type = type_to_simd_type (MONO_TYPE_I1);
5015                 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
5016                 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
5017                 AddFunc (module, "llvm.x86.sse2.packsswb.128", ret_type, arg_types, 2);
5018                 AddFunc (module, "llvm.x86.sse2.packuswb.128", ret_type, arg_types, 2);
5019                 ret_type = type_to_simd_type (MONO_TYPE_I2);
5020                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
5021                 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
5022                 AddFunc (module, "llvm.x86.sse2.packssdw.128", ret_type, arg_types, 2);
5023                 AddFunc (module, "llvm.x86.sse41.packusdw", ret_type, arg_types, 2);
5024
5025                 /* cmp pd/ps */
5026                 ret_type = type_to_simd_type (MONO_TYPE_R8);
5027                 arg_types [0] = ret_type;
5028                 arg_types [1] = ret_type;
5029                 arg_types [2] = LLVMInt8Type ();
5030                 AddFunc (module, "llvm.x86.sse2.cmp.pd", ret_type, arg_types, 3);
5031                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5032                 arg_types [0] = ret_type;
5033                 arg_types [1] = ret_type;
5034                 arg_types [2] = LLVMInt8Type ();
5035                 AddFunc (module, "llvm.x86.sse.cmp.ps", ret_type, arg_types, 3);
5036
5037                 /* Conversion ops */
5038                 ret_type = type_to_simd_type (MONO_TYPE_R8);
5039                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
5040                 AddFunc (module, "llvm.x86.sse2.cvtdq2pd", ret_type, arg_types, 1);
5041                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5042                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
5043                 AddFunc (module, "llvm.x86.sse2.cvtdq2ps", ret_type, arg_types, 1);
5044                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5045                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
5046                 AddFunc (module, "llvm.x86.sse2.cvtpd2dq", ret_type, arg_types, 1);
5047                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5048                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
5049                 AddFunc (module, "llvm.x86.sse2.cvtps2dq", ret_type, arg_types, 1);
5050                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5051                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
5052                 AddFunc (module, "llvm.x86.sse2.cvtpd2ps", ret_type, arg_types, 1);
5053                 ret_type = type_to_simd_type (MONO_TYPE_R8);
5054                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
5055                 AddFunc (module, "llvm.x86.sse2.cvtps2pd", ret_type, arg_types, 1);
5056
5057                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5058                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
5059                 AddFunc (module, "llvm.x86.sse2.cvttpd2dq", ret_type, arg_types, 1);
5060                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5061                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
5062                 AddFunc (module, "llvm.x86.sse2.cvttps2dq", ret_type, arg_types, 1);
5063
5064                 /* Unary ops */
5065                 ret_type = type_to_simd_type (MONO_TYPE_R8);
5066                 arg_types [0] = ret_type;
5067                 AddFunc (module, "llvm.x86.sse2.sqrt.pd", ret_type, arg_types, 1);
5068                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5069                 arg_types [0] = ret_type;
5070                 AddFunc (module, "llvm.x86.sse.sqrt.ps", ret_type, arg_types, 1);
5071                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5072                 arg_types [0] = ret_type;
5073                 AddFunc (module, "llvm.x86.sse.rsqrt.ps", ret_type, arg_types, 1);
5074                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5075                 arg_types [0] = ret_type;
5076                 AddFunc (module, "llvm.x86.sse.rcp.ps", ret_type, arg_types, 1);
5077
5078                 /* shifts */
5079                 ret_type = type_to_simd_type (MONO_TYPE_I2);
5080                 arg_types [0] = ret_type;
5081                 arg_types [1] = LLVMInt32Type ();
5082                 AddFunc (module, "llvm.x86.sse2.psrli.w", ret_type, arg_types, 2);
5083                 AddFunc (module, "llvm.x86.sse2.psrai.w", ret_type, arg_types, 2);
5084                 AddFunc (module, "llvm.x86.sse2.pslli.w", ret_type, arg_types, 2);
5085                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5086                 arg_types [0] = ret_type;
5087                 arg_types [1] = LLVMInt32Type ();
5088                 AddFunc (module, "llvm.x86.sse2.psrli.d", ret_type, arg_types, 2);
5089                 AddFunc (module, "llvm.x86.sse2.psrai.d", ret_type, arg_types, 2);
5090                 AddFunc (module, "llvm.x86.sse2.pslli.d", ret_type, arg_types, 2);
5091                 ret_type = type_to_simd_type (MONO_TYPE_I8);
5092                 arg_types [0] = ret_type;
5093                 arg_types [1] = LLVMInt32Type ();
5094                 AddFunc (module, "llvm.x86.sse2.psrli.q", ret_type, arg_types, 2);
5095                 AddFunc (module, "llvm.x86.sse2.pslli.q", ret_type, arg_types, 2);
5096
5097                 /* pmovmskb */
5098                 ret_type = LLVMInt32Type ();
5099                 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
5100                 AddFunc (module, "llvm.x86.sse2.pmovmskb.128", ret_type, arg_types, 1);
5101         }
5102
5103         AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
5104 #endif
5105
5106         /* Load/Store intrinsics */
5107         {
5108                 LLVMTypeRef arg_types [5];
5109                 int i;
5110                 char name [128];
5111
5112                 for (i = 1; i <= 8; i *= 2) {
5113                         arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
5114                         arg_types [1] = LLVMInt32Type ();
5115                         arg_types [2] = LLVMInt1Type ();
5116                         sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
5117                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMIntType (i * 8), arg_types, 3, FALSE));
5118
5119                         arg_types [0] = LLVMIntType (i * 8);
5120                         arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
5121                         arg_types [2] = LLVMInt32Type ();
5122                         arg_types [3] = LLVMInt1Type ();
5123                         sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
5124                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMVoidType (), arg_types, 4, FALSE));
5125                 }
5126         }
5127 }
5128
5129 static void
5130 add_types (MonoLLVMModule *lmodule)
5131 {
5132         lmodule->ptr_type = LLVMPointerType (sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type (), 0);
5133 }
5134
5135 void
5136 mono_llvm_init (void)
5137 {
5138         mono_native_tls_alloc (&current_cfg_tls_id, NULL);
5139 }
5140
5141 static void
5142 init_jit_module (void)
5143 {
5144         MonoJitICallInfo *info;
5145
5146         if (jit_module_inited)
5147                 return;
5148
5149         mono_loader_lock ();
5150
5151         if (jit_module_inited) {
5152                 mono_loader_unlock ();
5153                 return;
5154         }
5155
5156         jit_module.module = LLVMModuleCreateWithName ("mono");
5157
5158         ee = mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (jit_module.module), alloc_cb, emitted_cb, exception_cb, dlsym_cb);
5159
5160         add_intrinsics (jit_module.module);
5161         add_types (&jit_module);
5162
5163         jit_module.llvm_types = g_hash_table_new (NULL, NULL);
5164
5165         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
5166         g_assert (info);
5167         LLVMAddGlobalMapping (ee, LLVMGetNamedFunction (jit_module.module, "llvm_resume_unwind_trampoline"), (void*)info->func);
5168
5169         jit_module_inited = TRUE;
5170
5171         mono_loader_unlock ();
5172 }
5173
5174 void
5175 mono_llvm_cleanup (void)
5176 {
5177         if (ee)
5178                 mono_llvm_dispose_ee (ee);
5179
5180         if (jit_module.llvm_types)
5181                 g_hash_table_destroy (jit_module.llvm_types);
5182
5183         if (aot_module.module)
5184                 LLVMDisposeModule (aot_module.module);
5185
5186         LLVMContextDispose (LLVMGetGlobalContext ());
5187 }
5188
5189 void
5190 mono_llvm_create_aot_module (const char *got_symbol)
5191 {
5192         /* Delete previous module */
5193         if (aot_module.plt_entries)
5194                 g_hash_table_destroy (aot_module.plt_entries);
5195         if (aot_module.module)
5196                 LLVMDisposeModule (aot_module.module);
5197
5198         memset (&aot_module, 0, sizeof (aot_module));
5199
5200         aot_module.module = LLVMModuleCreateWithName ("aot");
5201         aot_module.got_symbol = got_symbol;
5202
5203         add_intrinsics (aot_module.module);
5204         add_types (&aot_module);
5205
5206         /* Add GOT */
5207         /*
5208          * We couldn't compute the type of the LLVM global representing the got because
5209          * its size is only known after all the methods have been emitted. So create
5210          * a dummy variable, and replace all uses it with the real got variable when
5211          * its size is known in mono_llvm_emit_aot_module ().
5212          */
5213         {
5214                 LLVMTypeRef got_type = LLVMArrayType (aot_module.ptr_type, 0);
5215
5216                 aot_module.got_var = LLVMAddGlobal (aot_module.module, got_type, "mono_dummy_got");
5217                 LLVMSetInitializer (aot_module.got_var, LLVMConstNull (got_type));
5218         }
5219
5220         /* Add a dummy personality function */
5221         {
5222                 LLVMBasicBlockRef lbb;
5223                 LLVMBuilderRef lbuilder;
5224                 LLVMValueRef personality;
5225
5226                 personality = LLVMAddFunction (aot_module.module, "mono_aot_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
5227                 LLVMSetLinkage (personality, LLVMInternalLinkage);
5228                 lbb = LLVMAppendBasicBlock (personality, "BB0");
5229                 lbuilder = LLVMCreateBuilder ();
5230                 LLVMPositionBuilderAtEnd (lbuilder, lbb);
5231                 LLVMBuildRetVoid (lbuilder);
5232         }
5233
5234         aot_module.llvm_types = g_hash_table_new (NULL, NULL);
5235         aot_module.plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
5236 }
5237
5238 /*
5239  * Emit the aot module into the LLVM bitcode file FILENAME.
5240  */
5241 void
5242 mono_llvm_emit_aot_module (const char *filename, int got_size)
5243 {
5244         LLVMTypeRef got_type;
5245         LLVMValueRef real_got;
5246
5247         /*
5248          * Create the real got variable and replace all uses of the dummy variable with
5249          * the real one.
5250          */
5251         got_type = LLVMArrayType (aot_module.ptr_type, got_size);
5252         real_got = LLVMAddGlobal (aot_module.module, got_type, aot_module.got_symbol);
5253         LLVMSetInitializer (real_got, LLVMConstNull (got_type));
5254         LLVMSetLinkage (real_got, LLVMInternalLinkage);
5255
5256         mono_llvm_replace_uses_of (aot_module.got_var, real_got);
5257
5258         mark_as_used (&aot_module, real_got);
5259
5260         /* Delete the dummy got so it doesn't become a global */
5261         LLVMDeleteGlobal (aot_module.got_var);
5262
5263         emit_llvm_used (&aot_module);
5264
5265 #if 0
5266         {
5267                 char *verifier_err;
5268
5269                 if (LLVMVerifyModule (aot_module.module, LLVMReturnStatusAction, &verifier_err)) {
5270                         g_assert_not_reached ();
5271                 }
5272         }
5273 #endif
5274
5275         LLVMWriteBitcodeToFile (aot_module.module, filename);
5276 }
5277
5278 /*
5279   DESIGN:
5280   - Emit LLVM IR from the mono IR using the LLVM C API.
5281   - The original arch specific code remains, so we can fall back to it if we run
5282     into something we can't handle.
5283 */
5284
5285 /*
5286   A partial list of issues:
5287   - Handling of opcodes which can throw exceptions.
5288
5289       In the mono JIT, these are implemented using code like this:
5290           method:
5291       <compare>
5292           throw_pos:
5293           b<cond> ex_label
5294           <rest of code>
5295       ex_label:
5296           push throw_pos - method
5297           call <exception trampoline>
5298
5299           The problematic part is push throw_pos - method, which cannot be represented
5300       in the LLVM IR, since it does not support label values.
5301           -> this can be implemented in AOT mode using inline asm + labels, but cannot
5302           be implemented in JIT mode ?
5303           -> a possible but slower implementation would use the normal exception
5304       throwing code but it would need to control the placement of the throw code
5305       (it needs to be exactly after the compare+branch).
5306           -> perhaps add a PC offset intrinsics ?
5307
5308   - efficient implementation of .ovf opcodes.
5309
5310           These are currently implemented as:
5311           <ins which sets the condition codes>
5312           b<cond> ex_label
5313
5314           Some overflow opcodes are now supported by LLVM SVN.
5315
5316   - exception handling, unwinding.
5317     - SSA is disabled for methods with exception handlers
5318         - How to obtain unwind info for LLVM compiled methods ?
5319           -> this is now solved by converting the unwind info generated by LLVM
5320              into our format.
5321         - LLVM uses the c++ exception handling framework, while we use our home grown
5322       code, and couldn't use the c++ one:
5323       - its not supported under VC++, other exotic platforms.
5324           - it might be impossible to support filter clauses with it.
5325
5326   - trampolines.
5327
5328     The trampolines need a predictable call sequence, since they need to disasm
5329     the calling code to obtain register numbers / offsets.
5330
5331     LLVM currently generates this code in non-JIT mode:
5332            mov    -0x98(%rax),%eax
5333            callq  *%rax
5334     Here, the vtable pointer is lost.
5335     -> solution: use one vtable trampoline per class.
5336
5337   - passing/receiving the IMT pointer/RGCTX.
5338     -> solution: pass them as normal arguments ?
5339
5340   - argument passing.
5341
5342           LLVM does not allow the specification of argument registers etc. This means
5343       that all calls are made according to the platform ABI.
5344
5345   - passing/receiving vtypes.
5346
5347       Vtypes passed/received in registers are handled by the front end by using
5348           a signature with scalar arguments, and loading the parts of the vtype into those
5349           arguments.
5350
5351           Vtypes passed on the stack are handled using the 'byval' attribute.
5352
5353   - ldaddr.
5354
5355     Supported though alloca, we need to emit the load/store code.
5356
5357   - types.
5358
5359     The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
5360     typed registers, so we have to keep track of the precise LLVM type of each vreg.
5361     This is made easier because the IR is already in SSA form.
5362     An additional problem is that our IR is not consistent with types, i.e. i32/ia64
5363         types are frequently used incorrectly.
5364 */
5365
5366 /*
5367   AOT SUPPORT:
5368   Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then
5369   append the AOT data structures to that file. For methods which cannot be
5370   handled by LLVM, the normal JIT compiled versions are used.
5371 */
5372
5373 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
5374  *   - each bblock should end with a branch
5375  *   - setting the return value, making cfg->ret non-volatile
5376  * - avoid some transformations in the JIT which make it harder for us to generate
5377  *   code.
5378  * - use pointer types to help optimizations.
5379  */