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  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   7  */
   8
   9 #include "mini.h"
  10 #include <mono/metadata/debug-helpers.h>
  11 #include <mono/metadata/debug-mono-symfile.h>
  12 #include <mono/metadata/mempool-internals.h>
  13 #include <mono/metadata/environment.h>
  14 #include <mono/metadata/object-internals.h>
  15 #include <mono/metadata/abi-details.h>
  16 #include <mono/utils/mono-tls.h>
  17 #include <mono/utils/mono-dl.h>
  18 #include <mono/utils/mono-time.h>
  19 #include <mono/utils/freebsd-dwarf.h>
  20
  21 #ifndef __STDC_LIMIT_MACROS
  22 #define __STDC_LIMIT_MACROS
  23 #endif
  24 #ifndef __STDC_CONSTANT_MACROS
  25 #define __STDC_CONSTANT_MACROS
  26 #endif
  27
  28 #include "llvm-c/BitWriter.h"
  29 #include "llvm-c/Analysis.h"
  30
  31 #include "mini-llvm-cpp.h"
  32 #include "llvm-jit.h"
  33 #include "aot-compiler.h"
  34 #include "mini-llvm.h"
  35
  36 #ifdef __MINGW32__
  37
  38 #include <stddef.h>
  39 extern void *memset(void *, int, size_t);
  40 void bzero (void *to, size_t count) { memset (to, 0, count); }
  41
  42 #endif
  43
  44 #if LLVM_API_VERSION < 4
  45 #error "The version of the mono llvm repository is too old."
  46 #endif
  47
  48 #define ALIGN_PTR_TO(ptr,align) (gpointer)((((gssize)(ptr)) + (align - 1)) & (~(align - 1)))
  49
  50  /*
  51   * Information associated by mono with LLVM modules.
  52   */
  53 typedef struct {
  54         LLVMModuleRef lmodule;
  55         LLVMValueRef throw_icall, rethrow, match_exc, throw_corlib_exception, resume_eh;
  56         GHashTable *llvm_types;
  57         LLVMValueRef got_var;
  58         const char *got_symbol;
  59         const char *get_method_symbol;
  60         const char *get_unbox_tramp_symbol;
  61         GHashTable *plt_entries;
  62         GHashTable *plt_entries_ji;
  63         GHashTable *method_to_lmethod;
  64         GHashTable *direct_callables;
  65         char **bb_names;
  66         int bb_names_len;
  67         GPtrArray *used;
  68         LLVMTypeRef ptr_type;
  69         GPtrArray *subprogram_mds;
  70         MonoEERef *mono_ee;
  71         LLVMExecutionEngineRef ee;
  72         gboolean external_symbols;
  73         gboolean emit_dwarf;
  74         int max_got_offset;
  75         LLVMValueRef personality;
  76
  77         /* For AOT */
  78         MonoAssembly *assembly;
  79         char *global_prefix;
  80         MonoAotFileInfo aot_info;
  81         const char *jit_got_symbol;
  82         const char *eh_frame_symbol;
  83         LLVMValueRef get_method, get_unbox_tramp;
  84         LLVMValueRef init_method, init_method_gshared_mrgctx, init_method_gshared_this, init_method_gshared_vtable;
  85         LLVMValueRef code_start, code_end;
  86         LLVMValueRef inited_var;
  87         int max_inited_idx, max_method_idx;
  88         gboolean has_jitted_code;
  89         gboolean static_link;
  90         gboolean llvm_only;
  91         GHashTable *idx_to_lmethod;
  92         GHashTable *idx_to_unbox_tramp;
  93         /* Maps a MonoMethod to LLVM instructions representing it */
  94         GHashTable *method_to_callers;
  95         LLVMContextRef context;
  96         LLVMValueRef sentinel_exception;
  97         void *di_builder, *cu;
  98         GHashTable *objc_selector_to_var;
  99 } MonoLLVMModule;
 100
 101 /*
 102  * Information associated by the backend with mono basic blocks.
 103  */
 104 typedef struct {
 105         LLVMBasicBlockRef bblock, end_bblock;
 106         LLVMValueRef finally_ind;
 107         gboolean added, invoke_target;
 108         /*
 109          * If this bblock is the start of a finally clause, this is a list of bblocks it
 110          * needs to branch to in ENDFINALLY.
 111          */
 112         GSList *call_handler_return_bbs;
 113         /*
 114          * If this bblock is the start of a finally clause, this is the bblock that
 115          * CALL_HANDLER needs to branch to.
 116          */
 117         LLVMBasicBlockRef call_handler_target_bb;
 118         /* The list of switch statements generated by ENDFINALLY instructions */
 119         GSList *endfinally_switch_ins_list;
 120         GSList *phi_nodes;
 121 } BBInfo;
 122
 123 /*
 124  * Structure containing emit state
 125  */
 126 typedef struct {
 127         MonoMemPool *mempool;
 128
 129         /* Maps method names to the corresponding LLVMValueRef */
 130         GHashTable *emitted_method_decls;
 131
 132         MonoCompile *cfg;
 133         LLVMValueRef lmethod;
 134         MonoLLVMModule *module;
 135         LLVMModuleRef lmodule;
 136         BBInfo *bblocks;
 137         int sindex, default_index, ex_index;
 138         LLVMBuilderRef builder;
 139         LLVMValueRef *values, *addresses;
 140         MonoType **vreg_cli_types;
 141         LLVMCallInfo *linfo;
 142         MonoMethodSignature *sig;
 143         GSList *builders;
 144         GHashTable *region_to_handler;
 145         GHashTable *clause_to_handler;
 146         LLVMBuilderRef alloca_builder;
 147         LLVMValueRef last_alloca;
 148         LLVMValueRef rgctx_arg;
 149         LLVMValueRef this_arg;
 150         LLVMTypeRef *vreg_types;
 151         gboolean *is_vphi;
 152         LLVMTypeRef method_type;
 153         LLVMBasicBlockRef init_bb, inited_bb;
 154         gboolean *is_dead;
 155         gboolean *unreachable;
 156         gboolean llvm_only;
 157         gboolean has_got_access;
 158         gboolean is_linkonce;
 159         int this_arg_pindex, rgctx_arg_pindex;
 160         LLVMValueRef imt_rgctx_loc;
 161         GHashTable *llvm_types;
 162         LLVMValueRef dbg_md;
 163         MonoDebugMethodInfo *minfo;
 164         char temp_name [32];
 165         /* For every clause, the clauses it is nested in */
 166         GSList **nested_in;
 167         LLVMValueRef ex_var;
 168         GHashTable *exc_meta;
 169         GHashTable *method_to_callers;
 170         GPtrArray *phi_values;
 171         GPtrArray *bblock_list;
 172         char *method_name;
 173         GHashTable *jit_callees;
 174         LLVMValueRef long_bb_break_var;
 175 } EmitContext;
 176
 177 typedef struct {
 178         MonoBasicBlock *bb;
 179         MonoInst *phi;
 180         MonoBasicBlock *in_bb;
 181         int sreg;
 182 } PhiNode;
 183
 184 /*
 185  * Instruction metadata
 186  * This is the same as ins_info, but LREG != IREG.
 187  */
 188 #ifdef MINI_OP
 189 #undef MINI_OP
 190 #endif
 191 #ifdef MINI_OP3
 192 #undef MINI_OP3
 193 #endif
 194 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2, ' ',
 195 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
 196 #define NONE ' '
 197 #define IREG 'i'
 198 #define FREG 'f'
 199 #define VREG 'v'
 200 #define XREG 'x'
 201 #define LREG 'l'
 202 /* keep in sync with the enum in mini.h */
 203 const char
 204 llvm_ins_info[] = {
 205 #include "mini-ops.h"
 206 };
 207 #undef MINI_OP
 208 #undef MINI_OP3
 209
 210 #if SIZEOF_VOID_P == 4
 211 #define GET_LONG_IMM(ins) (((guint64)(ins)->inst_ms_word << 32) | (guint64)(guint32)(ins)->inst_ls_word)
 212 #else
 213 #define GET_LONG_IMM(ins) ((ins)->inst_imm)
 214 #endif
 215
 216 #define LLVM_INS_INFO(opcode) (&llvm_ins_info [((opcode) - OP_START - 1) * 4])
 217
 218 #if 0
 219 #define TRACE_FAILURE(msg) do { printf ("%s\n", msg); } while (0)
 220 #else
 221 #define TRACE_FAILURE(msg)
 222 #endif
 223
 224 #ifdef TARGET_X86
 225 #define IS_TARGET_X86 1
 226 #else
 227 #define IS_TARGET_X86 0
 228 #endif
 229
 230 #ifdef TARGET_AMD64
 231 #define IS_TARGET_AMD64 1
 232 #else
 233 #define IS_TARGET_AMD64 0
 234 #endif
 235
 236 #define ctx_ok(ctx) (!(ctx)->cfg->disable_llvm)
 237
 238 static LLVMIntPredicate cond_to_llvm_cond [] = {
 239         LLVMIntEQ,
 240         LLVMIntNE,
 241         LLVMIntSLE,
 242         LLVMIntSGE,
 243         LLVMIntSLT,
 244         LLVMIntSGT,
 245         LLVMIntULE,
 246         LLVMIntUGE,
 247         LLVMIntULT,
 248         LLVMIntUGT,
 249 };
 250
 251 static LLVMRealPredicate fpcond_to_llvm_cond [] = {
 252         LLVMRealOEQ,
 253         LLVMRealUNE,
 254         LLVMRealOLE,
 255         LLVMRealOGE,
 256         LLVMRealOLT,
 257         LLVMRealOGT,
 258         LLVMRealULE,
 259         LLVMRealUGE,
 260         LLVMRealULT,
 261         LLVMRealUGT,
 262 };
 263
 264 static MonoNativeTlsKey current_cfg_tls_id;
 265
 266 static MonoLLVMModule aot_module;
 267
 268 static GHashTable *intrins_id_to_name;
 269 static GHashTable *intrins_name_to_id;
 270
 271 static void init_jit_module (MonoDomain *domain);
 272
 273 static void emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil_code);
 274 static LLVMValueRef emit_dbg_subprogram (EmitContext *ctx, MonoCompile *cfg, LLVMValueRef method, const char *name);
 275 static void emit_dbg_info (MonoLLVMModule *module, const char *filename, const char *cu_name);
 276 static void emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *exc_type, LLVMValueRef cmp);
 277 static LLVMValueRef get_intrinsic (EmitContext *ctx, const char *name);
 278 static void decode_llvm_eh_info (EmitContext *ctx, gpointer eh_frame);
 279
 280 static inline void
 281 set_failure (EmitContext *ctx, const char *message)
 282 {
 283         TRACE_FAILURE (reason);
 284         ctx->cfg->exception_message = g_strdup (message);
 285         ctx->cfg->disable_llvm = TRUE;
 286 }
 287
 288 /*
 289  * IntPtrType:
 290  *
 291  *   The LLVM type with width == sizeof (gpointer)
 292  */
 293 static LLVMTypeRef
 294 IntPtrType (void)
 295 {
 296         return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 297 }
 298
 299 static LLVMTypeRef
 300 ObjRefType (void)
 301 {
 302         return sizeof (gpointer) == 8 ? LLVMPointerType (LLVMInt64Type (), 0) : LLVMPointerType (LLVMInt32Type (), 0);
 303 }
 304
 305 static LLVMTypeRef
 306 ThisType (void)
 307 {
 308         return sizeof (gpointer) == 8 ? LLVMPointerType (LLVMInt64Type (), 0) : LLVMPointerType (LLVMInt32Type (), 0);
 309 }
 310
 311 /*
 312  * get_vtype_size:
 313  *
 314  *   Return the size of the LLVM representation of the vtype T.
 315  */
 316 static guint32
 317 get_vtype_size (MonoType *t)
 318 {
 319         int size;
 320
 321         size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
 322
 323         /* LLVMArgAsIArgs depends on this since it stores whole words */
 324         while (size < 2 * sizeof (gpointer) && mono_is_power_of_two (size) == -1)
 325                 size ++;
 326
 327         return size;
 328 }
 329
 330 /*
 331  * simd_class_to_llvm_type:
 332  *
 333  *   Return the LLVM type corresponding to the Mono.SIMD class KLASS
 334  */
 335 static LLVMTypeRef
 336 simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
 337 {
 338         if (!strcmp (klass->name, "Vector2d")) {
 339                 return LLVMVectorType (LLVMDoubleType (), 2);
 340         } else if (!strcmp (klass->name, "Vector2l")) {
 341                 return LLVMVectorType (LLVMInt64Type (), 2);
 342         } else if (!strcmp (klass->name, "Vector2ul")) {
 343                 return LLVMVectorType (LLVMInt64Type (), 2);
 344         } else if (!strcmp (klass->name, "Vector4i")) {
 345                 return LLVMVectorType (LLVMInt32Type (), 4);
 346         } else if (!strcmp (klass->name, "Vector4ui")) {
 347                 return LLVMVectorType (LLVMInt32Type (), 4);
 348         } else if (!strcmp (klass->name, "Vector4f")) {
 349                 return LLVMVectorType (LLVMFloatType (), 4);
 350         } else if (!strcmp (klass->name, "Vector8s")) {
 351                 return LLVMVectorType (LLVMInt16Type (), 8);
 352         } else if (!strcmp (klass->name, "Vector8us")) {
 353                 return LLVMVectorType (LLVMInt16Type (), 8);
 354         } else if (!strcmp (klass->name, "Vector16sb")) {
 355                 return LLVMVectorType (LLVMInt8Type (), 16);
 356         } else if (!strcmp (klass->name, "Vector16b")) {
 357                 return LLVMVectorType (LLVMInt8Type (), 16);
 358         } else {
 359                 printf ("%s\n", klass->name);
 360                 NOT_IMPLEMENTED;
 361                 return NULL;
 362         }
 363 }
 364
 365 /* Return the 128 bit SIMD type corresponding to the mono type TYPE */
 366 static inline G_GNUC_UNUSED LLVMTypeRef
 367 type_to_simd_type (int type)
 368 {
 369         switch (type) {
 370         case MONO_TYPE_I1:
 371                 return LLVMVectorType (LLVMInt8Type (), 16);
 372         case MONO_TYPE_I2:
 373                 return LLVMVectorType (LLVMInt16Type (), 8);
 374         case MONO_TYPE_I4:
 375                 return LLVMVectorType (LLVMInt32Type (), 4);
 376         case MONO_TYPE_I8:
 377                 return LLVMVectorType (LLVMInt64Type (), 2);
 378         case MONO_TYPE_R8:
 379                 return LLVMVectorType (LLVMDoubleType (), 2);
 380         case MONO_TYPE_R4:
 381                 return LLVMVectorType (LLVMFloatType (), 4);
 382         default:
 383                 g_assert_not_reached ();
 384                 return NULL;
 385         }
 386 }
 387
 388 static LLVMTypeRef
 389 create_llvm_type_for_type (MonoLLVMModule *module, MonoClass *klass)
 390 {
 391         int i, size, nfields, esize;
 392         LLVMTypeRef *eltypes;
 393         char *name;
 394         MonoType *t;
 395         LLVMTypeRef ltype;
 396
 397         t = &klass->byval_arg;
 398
 399         if (mini_type_is_hfa (t, &nfields, &esize)) {
 400                 /*
 401                  * This is needed on arm64 where HFAs are returned in
 402                  * registers.
 403                  */
 404                 size = nfields;
 405                 eltypes = g_new (LLVMTypeRef, size);
 406                 for (i = 0; i < size; ++i)
 407                         eltypes [i] = esize == 4 ? LLVMFloatType () : LLVMDoubleType ();
 408         } else {
 409                 size = get_vtype_size (t);
 410
 411                 eltypes = g_new (LLVMTypeRef, size);
 412                 for (i = 0; i < size; ++i)
 413                         eltypes [i] = LLVMInt8Type ();
 414         }
 415
 416         name = mono_type_full_name (&klass->byval_arg);
 417         ltype = LLVMStructCreateNamed (module->context, name);
 418         LLVMStructSetBody (ltype, eltypes, size, FALSE);
 419         g_free (eltypes);
 420         g_free (name);
 421
 422         return ltype;
 423 }
 424
 425 /*
 426  * type_to_llvm_type:
 427  *
 428  *   Return the LLVM type corresponding to T.
 429  */
 430 static LLVMTypeRef
 431 type_to_llvm_type (EmitContext *ctx, MonoType *t)
 432 {
 433         t = mini_get_underlying_type (t);
 434
 435         switch (t->type) {
 436         case MONO_TYPE_VOID:
 437                 return LLVMVoidType ();
 438         case MONO_TYPE_I1:
 439                 return LLVMInt8Type ();
 440         case MONO_TYPE_I2:
 441                 return LLVMInt16Type ();
 442         case MONO_TYPE_I4:
 443                 return LLVMInt32Type ();
 444         case MONO_TYPE_U1:
 445                 return LLVMInt8Type ();
 446         case MONO_TYPE_U2:
 447                 return LLVMInt16Type ();
 448         case MONO_TYPE_U4:
 449                 return LLVMInt32Type ();
 450         case MONO_TYPE_BOOLEAN:
 451                 return LLVMInt8Type ();
 452         case MONO_TYPE_I8:
 453         case MONO_TYPE_U8:
 454                 return LLVMInt64Type ();
 455         case MONO_TYPE_CHAR:
 456                 return LLVMInt16Type ();
 457         case MONO_TYPE_R4:
 458                 return LLVMFloatType ();
 459         case MONO_TYPE_R8:
 460                 return LLVMDoubleType ();
 461         case MONO_TYPE_I:
 462         case MONO_TYPE_U:
 463                 return IntPtrType ();
 464         case MONO_TYPE_OBJECT:
 465         case MONO_TYPE_CLASS:
 466         case MONO_TYPE_ARRAY:
 467         case MONO_TYPE_SZARRAY:
 468         case MONO_TYPE_STRING:
 469         case MONO_TYPE_PTR:
 470                 return ObjRefType ();
 471         case MONO_TYPE_VAR:
 472         case MONO_TYPE_MVAR:
 473                 /* Because of generic sharing */
 474                 return ObjRefType ();
 475         case MONO_TYPE_GENERICINST:
 476                 if (!mono_type_generic_inst_is_valuetype (t))
 477                         return ObjRefType ();
 478                 /* Fall through */
 479         case MONO_TYPE_VALUETYPE:
 480         case MONO_TYPE_TYPEDBYREF: {
 481                 MonoClass *klass;
 482                 LLVMTypeRef ltype;
 483
 484                 klass = mono_class_from_mono_type (t);
 485
 486                 if (MONO_CLASS_IS_SIMD (ctx->cfg, klass))
 487                         return simd_class_to_llvm_type (ctx, klass);
 488
 489                 if (klass->enumtype)
 490                         return type_to_llvm_type (ctx, mono_class_enum_basetype (klass));
 491
 492                 ltype = (LLVMTypeRef)g_hash_table_lookup (ctx->module->llvm_types, klass);
 493                 if (!ltype) {
 494                         ltype = create_llvm_type_for_type (ctx->module, klass);
 495                         g_hash_table_insert (ctx->module->llvm_types, klass, ltype);
 496                 }
 497                 return ltype;
 498         }
 499
 500         default:
 501                 printf ("X: %d\n", t->type);
 502                 ctx->cfg->exception_message = g_strdup_printf ("type %s", mono_type_full_name (t));
 503                 ctx->cfg->disable_llvm = TRUE;
 504                 return NULL;
 505         }
 506 }
 507
 508 /*
 509  * type_is_unsigned:
 510  *
 511  *   Return whenever T is an unsigned int type.
 512  */
 513 static gboolean
 514 type_is_unsigned (EmitContext *ctx, MonoType *t)
 515 {
 516         t = mini_get_underlying_type (t);
 517         if (t->byref)
 518                 return FALSE;
 519         switch (t->type) {
 520         case MONO_TYPE_U1:
 521         case MONO_TYPE_U2:
 522         case MONO_TYPE_CHAR:
 523         case MONO_TYPE_U4:
 524         case MONO_TYPE_U8:
 525                 return TRUE;
 526         default:
 527                 return FALSE;
 528         }
 529 }
 530
 531 /*
 532  * type_to_llvm_arg_type:
 533  *
 534  *   Same as type_to_llvm_type, but treat i8/i16 as i32.
 535  */
 536 static LLVMTypeRef
 537 type_to_llvm_arg_type (EmitContext *ctx, MonoType *t)
 538 {
 539         LLVMTypeRef ptype = type_to_llvm_type (ctx, t);
 540
 541         if (ctx->cfg->llvm_only)
 542                 return ptype;
 543
 544         /*
 545          * This works on all abis except arm64/ios which passes multiple
 546          * arguments in one stack slot.
 547          */
 548 #ifndef TARGET_ARM64
 549         if (ptype == LLVMInt8Type () || ptype == LLVMInt16Type ()) {
 550                 /*
 551                  * LLVM generates code which only sets the lower bits, while JITted
 552                  * code expects all the bits to be set.
 553                  */
 554                 ptype = LLVMInt32Type ();
 555         }
 556 #endif
 557
 558         return ptype;
 559 }
 560
 561 /*
 562  * llvm_type_to_stack_type:
 563  *
 564  *   Return the LLVM type which needs to be used when a value of type TYPE is pushed
 565  * on the IL stack.
 566  */
 567 static G_GNUC_UNUSED LLVMTypeRef
 568 llvm_type_to_stack_type (MonoCompile *cfg, LLVMTypeRef type)
 569 {
 570         if (type == NULL)
 571                 return NULL;
 572         if (type == LLVMInt8Type ())
 573                 return LLVMInt32Type ();
 574         else if (type == LLVMInt16Type ())
 575                 return LLVMInt32Type ();
 576         else if (!cfg->r4fp && type == LLVMFloatType ())
 577                 return LLVMDoubleType ();
 578         else
 579                 return type;
 580 }
 581
 582 /*
 583  * regtype_to_llvm_type:
 584  *
 585  *   Return the LLVM type corresponding to the regtype C used in instruction
 586  * descriptions.
 587  */
 588 static LLVMTypeRef
 589 regtype_to_llvm_type (char c)
 590 {
 591         switch (c) {
 592         case 'i':
 593                 return LLVMInt32Type ();
 594         case 'l':
 595                 return LLVMInt64Type ();
 596         case 'f':
 597                 return LLVMDoubleType ();
 598         default:
 599                 return NULL;
 600         }
 601 }
 602
 603 /*
 604  * op_to_llvm_type:
 605  *
 606  *   Return the LLVM type corresponding to the unary/binary opcode OPCODE.
 607  */
 608 static LLVMTypeRef
 609 op_to_llvm_type (int opcode)
 610 {
 611         switch (opcode) {
 612         case OP_ICONV_TO_I1:
 613         case OP_LCONV_TO_I1:
 614                 return LLVMInt8Type ();
 615         case OP_ICONV_TO_U1:
 616         case OP_LCONV_TO_U1:
 617                 return LLVMInt8Type ();
 618         case OP_ICONV_TO_I2:
 619         case OP_LCONV_TO_I2:
 620                 return LLVMInt16Type ();
 621         case OP_ICONV_TO_U2:
 622         case OP_LCONV_TO_U2:
 623                 return LLVMInt16Type ();
 624         case OP_ICONV_TO_I4:
 625         case OP_LCONV_TO_I4:
 626                 return LLVMInt32Type ();
 627         case OP_ICONV_TO_U4:
 628         case OP_LCONV_TO_U4:
 629                 return LLVMInt32Type ();
 630         case OP_ICONV_TO_I8:
 631                 return LLVMInt64Type ();
 632         case OP_ICONV_TO_R4:
 633                 return LLVMFloatType ();
 634         case OP_ICONV_TO_R8:
 635                 return LLVMDoubleType ();
 636         case OP_ICONV_TO_U8:
 637                 return LLVMInt64Type ();
 638         case OP_FCONV_TO_I4:
 639                 return LLVMInt32Type ();
 640         case OP_FCONV_TO_I8:
 641                 return LLVMInt64Type ();
 642         case OP_FCONV_TO_I1:
 643         case OP_FCONV_TO_U1:
 644         case OP_RCONV_TO_I1:
 645         case OP_RCONV_TO_U1:
 646                 return LLVMInt8Type ();
 647         case OP_FCONV_TO_I2:
 648         case OP_FCONV_TO_U2:
 649         case OP_RCONV_TO_I2:
 650         case OP_RCONV_TO_U2:
 651                 return LLVMInt16Type ();
 652         case OP_RCONV_TO_U4:
 653                 return LLVMInt32Type ();
 654         case OP_FCONV_TO_I:
 655         case OP_FCONV_TO_U:
 656                 return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 657         case OP_IADD_OVF:
 658         case OP_IADD_OVF_UN:
 659         case OP_ISUB_OVF:
 660         case OP_ISUB_OVF_UN:
 661         case OP_IMUL_OVF:
 662         case OP_IMUL_OVF_UN:
 663                 return LLVMInt32Type ();
 664         case OP_LADD_OVF:
 665         case OP_LADD_OVF_UN:
 666         case OP_LSUB_OVF:
 667         case OP_LSUB_OVF_UN:
 668         case OP_LMUL_OVF:
 669         case OP_LMUL_OVF_UN:
 670                 return LLVMInt64Type ();
 671         default:
 672                 printf ("%s\n", mono_inst_name (opcode));
 673                 g_assert_not_reached ();
 674                 return NULL;
 675         }
 676 }
 677
 678 #define CLAUSE_START(clause) ((clause)->try_offset)
 679 #define CLAUSE_END(clause) (((clause))->try_offset + ((clause))->try_len)
 680
 681 /*
 682  * load_store_to_llvm_type:
 683  *
 684  *   Return the size/sign/zero extension corresponding to the load/store opcode
 685  * OPCODE.
 686  */
 687 static LLVMTypeRef
 688 load_store_to_llvm_type (int opcode, int *size, gboolean *sext, gboolean *zext)
 689 {
 690         *sext = FALSE;
 691         *zext = FALSE;
 692
 693         switch (opcode) {
 694         case OP_LOADI1_MEMBASE:
 695         case OP_STOREI1_MEMBASE_REG:
 696         case OP_STOREI1_MEMBASE_IMM:
 697         case OP_ATOMIC_LOAD_I1:
 698         case OP_ATOMIC_STORE_I1:
 699                 *size = 1;
 700                 *sext = TRUE;
 701                 return LLVMInt8Type ();
 702         case OP_LOADU1_MEMBASE:
 703         case OP_LOADU1_MEM:
 704         case OP_ATOMIC_LOAD_U1:
 705         case OP_ATOMIC_STORE_U1:
 706                 *size = 1;
 707                 *zext = TRUE;
 708                 return LLVMInt8Type ();
 709         case OP_LOADI2_MEMBASE:
 710         case OP_STOREI2_MEMBASE_REG:
 711         case OP_STOREI2_MEMBASE_IMM:
 712         case OP_ATOMIC_LOAD_I2:
 713         case OP_ATOMIC_STORE_I2:
 714                 *size = 2;
 715                 *sext = TRUE;
 716                 return LLVMInt16Type ();
 717         case OP_LOADU2_MEMBASE:
 718         case OP_LOADU2_MEM:
 719         case OP_ATOMIC_LOAD_U2:
 720         case OP_ATOMIC_STORE_U2:
 721                 *size = 2;
 722                 *zext = TRUE;
 723                 return LLVMInt16Type ();
 724         case OP_LOADI4_MEMBASE:
 725         case OP_LOADU4_MEMBASE:
 726         case OP_LOADI4_MEM:
 727         case OP_LOADU4_MEM:
 728         case OP_STOREI4_MEMBASE_REG:
 729         case OP_STOREI4_MEMBASE_IMM:
 730         case OP_ATOMIC_LOAD_I4:
 731         case OP_ATOMIC_STORE_I4:
 732         case OP_ATOMIC_LOAD_U4:
 733         case OP_ATOMIC_STORE_U4:
 734                 *size = 4;
 735                 return LLVMInt32Type ();
 736         case OP_LOADI8_MEMBASE:
 737         case OP_LOADI8_MEM:
 738         case OP_STOREI8_MEMBASE_REG:
 739         case OP_STOREI8_MEMBASE_IMM:
 740         case OP_ATOMIC_LOAD_I8:
 741         case OP_ATOMIC_STORE_I8:
 742         case OP_ATOMIC_LOAD_U8:
 743         case OP_ATOMIC_STORE_U8:
 744                 *size = 8;
 745                 return LLVMInt64Type ();
 746         case OP_LOADR4_MEMBASE:
 747         case OP_STORER4_MEMBASE_REG:
 748         case OP_ATOMIC_LOAD_R4:
 749         case OP_ATOMIC_STORE_R4:
 750                 *size = 4;
 751                 return LLVMFloatType ();
 752         case OP_LOADR8_MEMBASE:
 753         case OP_STORER8_MEMBASE_REG:
 754         case OP_ATOMIC_LOAD_R8:
 755         case OP_ATOMIC_STORE_R8:
 756                 *size = 8;
 757                 return LLVMDoubleType ();
 758         case OP_LOAD_MEMBASE:
 759         case OP_LOAD_MEM:
 760         case OP_STORE_MEMBASE_REG:
 761         case OP_STORE_MEMBASE_IMM:
 762                 *size = sizeof (gpointer);
 763                 return IntPtrType ();
 764         default:
 765                 g_assert_not_reached ();
 766                 return NULL;
 767         }
 768 }
 769
 770 /*
 771  * ovf_op_to_intrins:
 772  *
 773  *   Return the LLVM intrinsics corresponding to the overflow opcode OPCODE.
 774  */
 775 static const char*
 776 ovf_op_to_intrins (int opcode)
 777 {
 778         switch (opcode) {
 779         case OP_IADD_OVF:
 780                 return "llvm.sadd.with.overflow.i32";
 781         case OP_IADD_OVF_UN:
 782                 return "llvm.uadd.with.overflow.i32";
 783         case OP_ISUB_OVF:
 784                 return "llvm.ssub.with.overflow.i32";
 785         case OP_ISUB_OVF_UN:
 786                 return "llvm.usub.with.overflow.i32";
 787         case OP_IMUL_OVF:
 788                 return "llvm.smul.with.overflow.i32";
 789         case OP_IMUL_OVF_UN:
 790                 return "llvm.umul.with.overflow.i32";
 791         case OP_LADD_OVF:
 792                 return "llvm.sadd.with.overflow.i64";
 793         case OP_LADD_OVF_UN:
 794                 return "llvm.uadd.with.overflow.i64";
 795         case OP_LSUB_OVF:
 796                 return "llvm.ssub.with.overflow.i64";
 797         case OP_LSUB_OVF_UN:
 798                 return "llvm.usub.with.overflow.i64";
 799         case OP_LMUL_OVF:
 800                 return "llvm.smul.with.overflow.i64";
 801         case OP_LMUL_OVF_UN:
 802                 return "llvm.umul.with.overflow.i64";
 803         default:
 804                 g_assert_not_reached ();
 805                 return NULL;
 806         }
 807 }
 808
 809 static const char*
 810 simd_op_to_intrins (int opcode)
 811 {
 812         switch (opcode) {
 813 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 814         case OP_MINPD:
 815                 return "llvm.x86.sse2.min.pd";
 816         case OP_MINPS:
 817                 return "llvm.x86.sse.min.ps";
 818         case OP_MAXPD:
 819                 return "llvm.x86.sse2.max.pd";
 820         case OP_MAXPS:
 821                 return "llvm.x86.sse.max.ps";
 822         case OP_HADDPD:
 823                 return "llvm.x86.sse3.hadd.pd";
 824         case OP_HADDPS:
 825                 return "llvm.x86.sse3.hadd.ps";
 826         case OP_HSUBPD:
 827                 return "llvm.x86.sse3.hsub.pd";
 828         case OP_HSUBPS:
 829                 return "llvm.x86.sse3.hsub.ps";
 830         case OP_ADDSUBPS:
 831                 return "llvm.x86.sse3.addsub.ps";
 832         case OP_ADDSUBPD:
 833                 return "llvm.x86.sse3.addsub.pd";
 834         case OP_EXTRACT_MASK:
 835                 return "llvm.x86.sse2.pmovmskb.128";
 836         case OP_PSHRW:
 837         case OP_PSHRW_REG:
 838                 return "llvm.x86.sse2.psrli.w";
 839         case OP_PSHRD:
 840         case OP_PSHRD_REG:
 841                 return "llvm.x86.sse2.psrli.d";
 842         case OP_PSHRQ:
 843         case OP_PSHRQ_REG:
 844                 return "llvm.x86.sse2.psrli.q";
 845         case OP_PSHLW:
 846         case OP_PSHLW_REG:
 847                 return "llvm.x86.sse2.pslli.w";
 848         case OP_PSHLD:
 849         case OP_PSHLD_REG:
 850                 return "llvm.x86.sse2.pslli.d";
 851         case OP_PSHLQ:
 852         case OP_PSHLQ_REG:
 853                 return "llvm.x86.sse2.pslli.q";
 854         case OP_PSARW:
 855         case OP_PSARW_REG:
 856                 return "llvm.x86.sse2.psrai.w";
 857         case OP_PSARD:
 858         case OP_PSARD_REG:
 859                 return "llvm.x86.sse2.psrai.d";
 860         case OP_PADDB_SAT:
 861                 return "llvm.x86.sse2.padds.b";
 862         case OP_PADDW_SAT:
 863                 return "llvm.x86.sse2.padds.w";
 864         case OP_PSUBB_SAT:
 865                 return "llvm.x86.sse2.psubs.b";
 866         case OP_PSUBW_SAT:
 867                 return "llvm.x86.sse2.psubs.w";
 868         case OP_PADDB_SAT_UN:
 869                 return "llvm.x86.sse2.paddus.b";
 870         case OP_PADDW_SAT_UN:
 871                 return "llvm.x86.sse2.paddus.w";
 872         case OP_PSUBB_SAT_UN:
 873                 return "llvm.x86.sse2.psubus.b";
 874         case OP_PSUBW_SAT_UN:
 875                 return "llvm.x86.sse2.psubus.w";
 876         case OP_PAVGB_UN:
 877                 return "llvm.x86.sse2.pavg.b";
 878         case OP_PAVGW_UN:
 879                 return "llvm.x86.sse2.pavg.w";
 880         case OP_SQRTPS:
 881                 return "llvm.x86.sse.sqrt.ps";
 882         case OP_SQRTPD:
 883                 return "llvm.x86.sse2.sqrt.pd";
 884         case OP_RSQRTPS:
 885                 return "llvm.x86.sse.rsqrt.ps";
 886         case OP_RCPPS:
 887                 return "llvm.x86.sse.rcp.ps";
 888         case OP_CVTDQ2PD:
 889                 return "llvm.x86.sse2.cvtdq2pd";
 890         case OP_CVTDQ2PS:
 891                 return "llvm.x86.sse2.cvtdq2ps";
 892         case OP_CVTPD2DQ:
 893                 return "llvm.x86.sse2.cvtpd2dq";
 894         case OP_CVTPS2DQ:
 895                 return "llvm.x86.sse2.cvtps2dq";
 896         case OP_CVTPD2PS:
 897                 return "llvm.x86.sse2.cvtpd2ps";
 898         case OP_CVTPS2PD:
 899                 return "llvm.x86.sse2.cvtps2pd";
 900         case OP_CVTTPD2DQ:
 901                 return "llvm.x86.sse2.cvttpd2dq";
 902         case OP_CVTTPS2DQ:
 903                 return "llvm.x86.sse2.cvttps2dq";
 904         case OP_PACKW:
 905                 return "llvm.x86.sse2.packsswb.128";
 906         case OP_PACKD:
 907                 return "llvm.x86.sse2.packssdw.128";
 908         case OP_PACKW_UN:
 909                 return "llvm.x86.sse2.packuswb.128";
 910         case OP_PACKD_UN:
 911                 return "llvm.x86.sse41.packusdw";
 912         case OP_PMULW_HIGH:
 913                 return "llvm.x86.sse2.pmulh.w";
 914         case OP_PMULW_HIGH_UN:
 915                 return "llvm.x86.sse2.pmulhu.w";
 916 #endif
 917         default:
 918                 g_assert_not_reached ();
 919                 return NULL;
 920         }
 921 }
 922
 923 static LLVMTypeRef
 924 simd_op_to_llvm_type (int opcode)
 925 {
 926 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 927         switch (opcode) {
 928         case OP_EXTRACT_R8:
 929         case OP_EXPAND_R8:
 930                 return type_to_simd_type (MONO_TYPE_R8);
 931         case OP_EXTRACT_I8:
 932         case OP_EXPAND_I8:
 933                 return type_to_simd_type (MONO_TYPE_I8);
 934         case OP_EXTRACT_I4:
 935         case OP_EXPAND_I4:
 936                 return type_to_simd_type (MONO_TYPE_I4);
 937         case OP_EXTRACT_I2:
 938         case OP_EXTRACT_U2:
 939         case OP_EXTRACTX_U2:
 940         case OP_EXPAND_I2:
 941                 return type_to_simd_type (MONO_TYPE_I2);
 942         case OP_EXTRACT_I1:
 943         case OP_EXTRACT_U1:
 944         case OP_EXPAND_I1:
 945                 return type_to_simd_type (MONO_TYPE_I1);
 946         case OP_EXPAND_R4:
 947                 return type_to_simd_type (MONO_TYPE_R4);
 948         case OP_CVTDQ2PD:
 949         case OP_CVTDQ2PS:
 950                 return type_to_simd_type (MONO_TYPE_I4);
 951         case OP_CVTPD2DQ:
 952         case OP_CVTPD2PS:
 953         case OP_CVTTPD2DQ:
 954                 return type_to_simd_type (MONO_TYPE_R8);
 955         case OP_CVTPS2DQ:
 956         case OP_CVTPS2PD:
 957         case OP_CVTTPS2DQ:
 958                 return type_to_simd_type (MONO_TYPE_R4);
 959         case OP_EXTRACT_MASK:
 960                 return type_to_simd_type (MONO_TYPE_I1);
 961         case OP_SQRTPS:
 962         case OP_RSQRTPS:
 963         case OP_RCPPS:
 964         case OP_DUPPS_LOW:
 965         case OP_DUPPS_HIGH:
 966                 return type_to_simd_type (MONO_TYPE_R4);
 967         case OP_SQRTPD:
 968         case OP_DUPPD:
 969                 return type_to_simd_type (MONO_TYPE_R8);
 970         default:
 971                 g_assert_not_reached ();
 972                 return NULL;
 973         }
 974 #else
 975         return NULL;
 976 #endif
 977 }
 978
 979 /*
 980  * get_bb:
 981  *
 982  *   Return the LLVM basic block corresponding to BB.
 983  */
 984 static LLVMBasicBlockRef
 985 get_bb (EmitContext *ctx, MonoBasicBlock *bb)
 986 {
 987         char bb_name_buf [128];
 988         char *bb_name;
 989
 990         if (ctx->bblocks [bb->block_num].bblock == NULL) {
 991                 if (bb->flags & BB_EXCEPTION_HANDLER) {
 992                         int clause_index = (mono_get_block_region_notry (ctx->cfg, bb->region) >> 8) - 1;
 993                         sprintf (bb_name_buf, "EH_CLAUSE%d_BB%d", clause_index, bb->block_num);
 994                         bb_name = bb_name_buf;
 995                 } else if (bb->block_num < 256) {
 996                         if (!ctx->module->bb_names) {
 997                                 ctx->module->bb_names_len = 256;
 998                                 ctx->module->bb_names = g_new0 (char*, ctx->module->bb_names_len);
 999                         }
1000                         if (!ctx->module->bb_names [bb->block_num]) {
1001                                 char *n;
1002
1003                                 n = g_strdup_printf ("BB%d", bb->block_num);
1004                                 mono_memory_barrier ();
1005                                 ctx->module->bb_names [bb->block_num] = n;
1006                         }
1007                         bb_name = ctx->module->bb_names [bb->block_num];
1008                 } else {
1009                         sprintf (bb_name_buf, "BB%d", bb->block_num);
1010                         bb_name = bb_name_buf;
1011                 }
1012
1013                 ctx->bblocks [bb->block_num].bblock = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
1014                 ctx->bblocks [bb->block_num].end_bblock = ctx->bblocks [bb->block_num].bblock;
1015         }
1016
1017         return ctx->bblocks [bb->block_num].bblock;
1018 }
1019
1020 /*
1021  * get_end_bb:
1022  *
1023  *   Return the last LLVM bblock corresponding to BB.
1024  * This might not be equal to the bb returned by get_bb () since we need to generate
1025  * multiple LLVM bblocks for a mono bblock to handle throwing exceptions.
1026  */
1027 static LLVMBasicBlockRef
1028 get_end_bb (EmitContext *ctx, MonoBasicBlock *bb)
1029 {
1030         get_bb (ctx, bb);
1031         return ctx->bblocks [bb->block_num].end_bblock;
1032 }
1033
1034 static LLVMBasicBlockRef
1035 gen_bb (EmitContext *ctx, const char *prefix)
1036 {
1037         char bb_name [128];
1038
1039         sprintf (bb_name, "%s%d", prefix, ++ ctx->ex_index);
1040         return LLVMAppendBasicBlock (ctx->lmethod, bb_name);
1041 }
1042
1043 /*
1044  * resolve_patch:
1045  *
1046  *   Return the target of the patch identified by TYPE and TARGET.
1047  */
1048 static gpointer
1049 resolve_patch (MonoCompile *cfg, MonoJumpInfoType type, gconstpointer target)
1050 {
1051         MonoJumpInfo ji;
1052         MonoError error;
1053         gpointer res;
1054
1055         memset (&ji, 0, sizeof (ji));
1056         ji.type = type;
1057         ji.data.target = target;
1058
1059         res = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE, &error);
1060         mono_error_assert_ok (&error);
1061
1062         return res;
1063 }
1064
1065 /*
1066  * convert_full:
1067  *
1068  *   Emit code to convert the LLVM value V to DTYPE.
1069  */
1070 static LLVMValueRef
1071 convert_full (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype, gboolean is_unsigned)
1072 {
1073         LLVMTypeRef stype = LLVMTypeOf (v);
1074
1075         if (stype != dtype) {
1076                 gboolean ext = FALSE;
1077
1078                 /* Extend */
1079                 if (dtype == LLVMInt64Type () && (stype == LLVMInt32Type () || stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
1080                         ext = TRUE;
1081                 else if (dtype == LLVMInt32Type () && (stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
1082                         ext = TRUE;
1083                 else if (dtype == LLVMInt16Type () && (stype == LLVMInt8Type ()))
1084                         ext = TRUE;
1085
1086                 if (ext)
1087                         return is_unsigned ? LLVMBuildZExt (ctx->builder, v, dtype, "") : LLVMBuildSExt (ctx->builder, v, dtype, "");
1088
1089                 if (dtype == LLVMDoubleType () && stype == LLVMFloatType ())
1090                         return LLVMBuildFPExt (ctx->builder, v, dtype, "");
1091
1092                 /* Trunc */
1093                 if (stype == LLVMInt64Type () && (dtype == LLVMInt32Type () || dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
1094                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
1095                 if (stype == LLVMInt32Type () && (dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
1096                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
1097                 if (stype == LLVMInt16Type () && dtype == LLVMInt8Type ())
1098                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
1099                 if (stype == LLVMDoubleType () && dtype == LLVMFloatType ())
1100                         return LLVMBuildFPTrunc (ctx->builder, v, dtype, "");
1101
1102                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind && LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
1103                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
1104                 if (LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
1105                         return LLVMBuildIntToPtr (ctx->builder, v, dtype, "");
1106                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind)
1107                         return LLVMBuildPtrToInt (ctx->builder, v, dtype, "");
1108
1109                 if (mono_arch_is_soft_float ()) {
1110                         if (stype == LLVMInt32Type () && dtype == LLVMFloatType ())
1111                                 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
1112                         if (stype == LLVMInt32Type () && dtype == LLVMDoubleType ())
1113                                 return LLVMBuildBitCast (ctx->builder, LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), ""), dtype, "");
1114                 }
1115
1116                 if (LLVMGetTypeKind (stype) == LLVMVectorTypeKind && LLVMGetTypeKind (dtype) == LLVMVectorTypeKind)
1117                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
1118
1119                 LLVMDumpValue (v);
1120                 LLVMDumpValue (LLVMConstNull (dtype));
1121                 g_assert_not_reached ();
1122                 return NULL;
1123         } else {
1124                 return v;
1125         }
1126 }
1127
1128 static LLVMValueRef
1129 convert (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype)
1130 {
1131         return convert_full (ctx, v, dtype, FALSE);
1132 }
1133
1134 /*
1135  * emit_volatile_load:
1136  *
1137  *   If vreg is volatile, emit a load from its address.
1138  */
1139 static LLVMValueRef
1140 emit_volatile_load (EmitContext *ctx, int vreg)
1141 {
1142         MonoType *t;
1143         LLVMValueRef v;
1144
1145 #ifdef TARGET_ARM64
1146         // FIXME: This hack is required because we pass the rgctx in a callee saved
1147         // register on arm64 (x15), and llvm might keep the value in that register
1148         // even through the register is marked as 'reserved' inside llvm.
1149         if (ctx->cfg->rgctx_var && ctx->cfg->rgctx_var->dreg == vreg)
1150                 v = mono_llvm_build_load (ctx->builder, ctx->addresses [vreg], "", TRUE);
1151         else
1152                 v = LLVMBuildLoad (ctx->builder, ctx->addresses [vreg], "");
1153 #else
1154         v = LLVMBuildLoad (ctx->builder, ctx->addresses [vreg], "");
1155 #endif
1156         t = ctx->vreg_cli_types [vreg];
1157         if (t && !t->byref) {
1158                 /*
1159                  * Might have to zero extend since llvm doesn't have
1160                  * unsigned types.
1161                  */
1162                 if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_U2 || t->type == MONO_TYPE_CHAR || t->type == MONO_TYPE_BOOLEAN)
1163                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt32Type (), "");
1164                 else if (t->type == MONO_TYPE_I1 || t->type == MONO_TYPE_I2)
1165                         v = LLVMBuildSExt (ctx->builder, v, LLVMInt32Type (), "");
1166                 else if (t->type == MONO_TYPE_U8)
1167                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), "");
1168         }
1169
1170         return v;
1171 }
1172
1173 /*
1174  * emit_volatile_store:
1175  *
1176  *   If VREG is volatile, emit a store from its value to its address.
1177  */
1178 static void
1179 emit_volatile_store (EmitContext *ctx, int vreg)
1180 {
1181         MonoInst *var = get_vreg_to_inst (ctx->cfg, vreg);
1182
1183         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
1184                 g_assert (ctx->addresses [vreg]);
1185                 LLVMBuildStore (ctx->builder, convert (ctx, ctx->values [vreg], type_to_llvm_type (ctx, var->inst_vtype)), ctx->addresses [vreg]);
1186         }
1187 }
1188
1189 static LLVMTypeRef
1190 sig_to_llvm_sig_no_cinfo (EmitContext *ctx, MonoMethodSignature *sig)
1191 {
1192         LLVMTypeRef ret_type;
1193         LLVMTypeRef *param_types = NULL;
1194         LLVMTypeRef res;
1195         int i, pindex;
1196         MonoType *rtype;
1197
1198         rtype = mini_get_underlying_type (sig->ret);
1199         ret_type = type_to_llvm_type (ctx, rtype);
1200         if (!ctx_ok (ctx))
1201                 return NULL;
1202
1203         param_types = g_new0 (LLVMTypeRef, (sig->param_count * 8) + 3);
1204         pindex = 0;
1205
1206         if (sig->hasthis)
1207                 param_types [pindex ++] = ThisType ();
1208         for (i = 0; i < sig->param_count; ++i)
1209                 param_types [pindex ++] = type_to_llvm_arg_type (ctx, sig->params [i]);
1210
1211         if (!ctx_ok (ctx)) {
1212                 g_free (param_types);
1213                 return NULL;
1214         }
1215
1216         res = LLVMFunctionType (ret_type, param_types, pindex, FALSE);
1217         g_free (param_types);
1218
1219         return res;
1220 }
1221
1222 /*
1223  * sig_to_llvm_sig_full:
1224  *
1225  *   Return the LLVM signature corresponding to the mono signature SIG using the
1226  * calling convention information in CINFO. Fill out the parameter mapping information in CINFO.
1227  */
1228 static LLVMTypeRef
1229 sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo *cinfo)
1230 {
1231         LLVMTypeRef ret_type;
1232         LLVMTypeRef *param_types = NULL;
1233         LLVMTypeRef res;
1234         int i, j, pindex, vret_arg_pindex = 0;
1235         gboolean vretaddr = FALSE;
1236         MonoType *rtype;
1237
1238         if (!cinfo)
1239                 return sig_to_llvm_sig_no_cinfo (ctx, sig);
1240
1241         rtype = mini_get_underlying_type (sig->ret);
1242         ret_type = type_to_llvm_type (ctx, rtype);
1243         if (!ctx_ok (ctx))
1244                 return NULL;
1245
1246         switch (cinfo->ret.storage) {
1247         case LLVMArgVtypeInReg:
1248                 /* LLVM models this by returning an aggregate value */
1249                 if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgNone) {
1250                         LLVMTypeRef members [2];
1251
1252                         members [0] = IntPtrType ();
1253                         ret_type = LLVMStructType (members, 1, FALSE);
1254                 } else if (cinfo->ret.pair_storage [0] == LLVMArgNone && cinfo->ret.pair_storage [1] == LLVMArgNone) {
1255                         /* Empty struct */
1256                         ret_type = LLVMVoidType ();
1257                 } else if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgInIReg) {
1258                         LLVMTypeRef members [2];
1259
1260                         members [0] = IntPtrType ();
1261                         members [1] = IntPtrType ();
1262                         ret_type = LLVMStructType (members, 2, FALSE);
1263                 } else {
1264                         g_assert_not_reached ();
1265                 }
1266                 break;
1267         case LLVMArgVtypeByVal:
1268                 /* Vtype returned normally by val */
1269                 break;
1270         case LLVMArgVtypeAsScalar: {
1271                 int size = mono_class_value_size (mono_class_from_mono_type (rtype), NULL);
1272                 /* LLVM models this by returning an int */
1273                 if (size < SIZEOF_VOID_P) {
1274                         g_assert (cinfo->ret.nslots == 1);
1275                         ret_type = LLVMIntType (size * 8);
1276                 } else {
1277                         g_assert (cinfo->ret.nslots == 1 || cinfo->ret.nslots == 2);
1278                         ret_type = LLVMIntType (cinfo->ret.nslots * sizeof (mgreg_t) * 8);
1279                 }
1280                 break;
1281         }
1282         case LLVMArgAsIArgs:
1283                 ret_type = LLVMArrayType (IntPtrType (), cinfo->ret.nslots);
1284                 break;
1285         case LLVMArgFpStruct: {
1286                 /* Vtype returned as a fp struct */
1287                 LLVMTypeRef members [16];
1288
1289                 /* Have to create our own structure since we don't map fp structures to LLVM fp structures yet */
1290                 for (i = 0; i < cinfo->ret.nslots; ++i)
1291                         members [i] = cinfo->ret.esize == 8 ? LLVMDoubleType () : LLVMFloatType ();
1292                 ret_type = LLVMStructType (members, cinfo->ret.nslots, FALSE);
1293                 break;
1294         }
1295         case LLVMArgVtypeByRef:
1296                 /* Vtype returned using a hidden argument */
1297                 ret_type = LLVMVoidType ();
1298                 break;
1299         case LLVMArgVtypeRetAddr:
1300         case LLVMArgGsharedvtFixed:
1301         case LLVMArgGsharedvtFixedVtype:
1302         case LLVMArgGsharedvtVariable:
1303                 vretaddr = TRUE;
1304                 ret_type = LLVMVoidType ();
1305                 break;
1306         default:
1307                 break;
1308         }
1309
1310         param_types = g_new0 (LLVMTypeRef, (sig->param_count * 8) + 3);
1311         pindex = 0;
1312         if (cinfo->ret.storage == LLVMArgVtypeByRef) {
1313                 /*
1314                  * Has to be the first argument because of the sret argument attribute
1315                  * FIXME: This might conflict with passing 'this' as the first argument, but
1316                  * this is only used on arm64 which has a dedicated struct return register.
1317                  */
1318                 cinfo->vret_arg_pindex = pindex;
1319                 param_types [pindex] = type_to_llvm_arg_type (ctx, sig->ret);
1320                 if (!ctx_ok (ctx)) {
1321                         g_free (param_types);
1322                         return NULL;
1323                 }
1324                 param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1325                 pindex ++;
1326         }
1327         if (!ctx->llvm_only && cinfo->rgctx_arg) {
1328                 cinfo->rgctx_arg_pindex = pindex;
1329                 param_types [pindex] = ctx->module->ptr_type;
1330                 pindex ++;
1331         }
1332         if (cinfo->imt_arg) {
1333                 cinfo->imt_arg_pindex = pindex;
1334                 param_types [pindex] = ctx->module->ptr_type;
1335                 pindex ++;
1336         }
1337         if (vretaddr) {
1338                 /* Compute the index in the LLVM signature where the vret arg needs to be passed */
1339                 vret_arg_pindex = pindex;
1340                 if (cinfo->vret_arg_index == 1) {
1341                         /* Add the slots consumed by the first argument */
1342                         LLVMArgInfo *ainfo = &cinfo->args [0];
1343                         switch (ainfo->storage) {
1344                         case LLVMArgVtypeInReg:
1345                                 for (j = 0; j < 2; ++j) {
1346                                         if (ainfo->pair_storage [j] == LLVMArgInIReg)
1347                                                 vret_arg_pindex ++;
1348                                 }
1349                                 break;
1350                         default:
1351                                 vret_arg_pindex ++;
1352                         }
1353                 }
1354
1355                 cinfo->vret_arg_pindex = vret_arg_pindex;
1356         }
1357
1358         if (vretaddr && vret_arg_pindex == pindex)
1359                 param_types [pindex ++] = IntPtrType ();
1360         if (sig->hasthis) {
1361                 cinfo->this_arg_pindex = pindex;
1362                 param_types [pindex ++] = ThisType ();
1363                 cinfo->args [0].pindex = cinfo->this_arg_pindex;
1364         }
1365         if (vretaddr && vret_arg_pindex == pindex)
1366                 param_types [pindex ++] = IntPtrType ();
1367         for (i = 0; i < sig->param_count; ++i) {
1368                 LLVMArgInfo *ainfo = &cinfo->args [i + sig->hasthis];
1369
1370                 if (vretaddr && vret_arg_pindex == pindex)
1371                         param_types [pindex ++] = IntPtrType ();
1372                 ainfo->pindex = pindex;
1373
1374                 switch (ainfo->storage) {
1375                 case LLVMArgVtypeInReg:
1376                         for (j = 0; j < 2; ++j) {
1377                                 switch (ainfo->pair_storage [j]) {
1378                                 case LLVMArgInIReg:
1379                                         param_types [pindex ++] = LLVMIntType (sizeof (gpointer) * 8);
1380                                         break;
1381                                 case LLVMArgNone:
1382                                         break;
1383                                 default:
1384                                         g_assert_not_reached ();
1385                                 }
1386                         }
1387                         break;
1388                 case LLVMArgVtypeByVal:
1389                         param_types [pindex] = type_to_llvm_arg_type (ctx, ainfo->type);
1390                         if (!ctx_ok (ctx))
1391                                 break;
1392                         param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1393                         pindex ++;
1394                         break;
1395                 case LLVMArgAsIArgs:
1396                         param_types [pindex] = LLVMArrayType (IntPtrType (), ainfo->nslots);
1397                         pindex ++;
1398                         break;
1399                 case LLVMArgVtypeByRef:
1400                         param_types [pindex] = type_to_llvm_arg_type (ctx, ainfo->type);
1401                         if (!ctx_ok (ctx))
1402                                 break;
1403                         param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1404                         pindex ++;
1405                         break;
1406                 case LLVMArgAsFpArgs: {
1407                         int j;
1408
1409                         /* Emit dummy fp arguments if needed so the rest is passed on the stack */
1410                         for (j = 0; j < ainfo->ndummy_fpargs; ++j)
1411                                 param_types [pindex ++] = LLVMDoubleType ();
1412                         for (j = 0; j < ainfo->nslots; ++j)
1413                                 param_types [pindex ++] = ainfo->esize == 8 ? LLVMDoubleType () : LLVMFloatType ();
1414                         break;
1415                 }
1416                 case LLVMArgVtypeAsScalar:
1417                         g_assert_not_reached ();
1418                         break;
1419                 case LLVMArgGsharedvtFixed:
1420                 case LLVMArgGsharedvtFixedVtype:
1421                         param_types [pindex ++] = LLVMPointerType (type_to_llvm_arg_type (ctx, ainfo->type), 0);
1422                         break;
1423                 case LLVMArgGsharedvtVariable:
1424                         param_types [pindex ++] = LLVMPointerType (IntPtrType (), 0);
1425                         break;
1426                 default:
1427                         param_types [pindex ++] = type_to_llvm_arg_type (ctx, ainfo->type);
1428                         break;
1429                 }
1430         }
1431         if (!ctx_ok (ctx)) {
1432                 g_free (param_types);
1433                 return NULL;
1434         }
1435         if (vretaddr && vret_arg_pindex == pindex)
1436                 param_types [pindex ++] = IntPtrType ();
1437         if (ctx->llvm_only && cinfo->rgctx_arg) {
1438                 /* Pass the rgctx as the last argument */
1439                 cinfo->rgctx_arg_pindex = pindex;
1440                 param_types [pindex] = ctx->module->ptr_type;
1441                 pindex ++;
1442         }
1443
1444         res = LLVMFunctionType (ret_type, param_types, pindex, FALSE);
1445         g_free (param_types);
1446
1447         return res;
1448 }
1449
1450 static LLVMTypeRef
1451 sig_to_llvm_sig (EmitContext *ctx, MonoMethodSignature *sig)
1452 {
1453         return sig_to_llvm_sig_full (ctx, sig, NULL);
1454 }
1455
1456 /*
1457  * LLVMFunctionType1:
1458  *
1459  *   Create an LLVM function type from the arguments.
1460  */
1461 static G_GNUC_UNUSED LLVMTypeRef
1462 LLVMFunctionType0 (LLVMTypeRef ReturnType,
1463                                    int IsVarArg)
1464 {
1465         return LLVMFunctionType (ReturnType, NULL, 0, IsVarArg);
1466 }
1467
1468 /*
1469  * LLVMFunctionType1:
1470  *
1471  *   Create an LLVM function type from the arguments.
1472  */
1473 static G_GNUC_UNUSED LLVMTypeRef
1474 LLVMFunctionType1 (LLVMTypeRef ReturnType,
1475                                    LLVMTypeRef ParamType1,
1476                                    int IsVarArg)
1477 {
1478         LLVMTypeRef param_types [1];
1479
1480         param_types [0] = ParamType1;
1481
1482         return LLVMFunctionType (ReturnType, param_types, 1, IsVarArg);
1483 }
1484
1485 /*
1486  * LLVMFunctionType2:
1487  *
1488  *   Create an LLVM function type from the arguments.
1489  */
1490 static G_GNUC_UNUSED LLVMTypeRef
1491 LLVMFunctionType2 (LLVMTypeRef ReturnType,
1492                                    LLVMTypeRef ParamType1,
1493                                    LLVMTypeRef ParamType2,
1494                                    int IsVarArg)
1495 {
1496         LLVMTypeRef param_types [2];
1497
1498         param_types [0] = ParamType1;
1499         param_types [1] = ParamType2;
1500
1501         return LLVMFunctionType (ReturnType, param_types, 2, IsVarArg);
1502 }
1503
1504 /*
1505  * LLVMFunctionType3:
1506  *
1507  *   Create an LLVM function type from the arguments.
1508  */
1509 static G_GNUC_UNUSED LLVMTypeRef
1510 LLVMFunctionType3 (LLVMTypeRef ReturnType,
1511                                    LLVMTypeRef ParamType1,
1512                                    LLVMTypeRef ParamType2,
1513                                    LLVMTypeRef ParamType3,
1514                                    int IsVarArg)
1515 {
1516         LLVMTypeRef param_types [3];
1517
1518         param_types [0] = ParamType1;
1519         param_types [1] = ParamType2;
1520         param_types [2] = ParamType3;
1521
1522         return LLVMFunctionType (ReturnType, param_types, 3, IsVarArg);
1523 }
1524
1525 static G_GNUC_UNUSED LLVMTypeRef
1526 LLVMFunctionType5 (LLVMTypeRef ReturnType,
1527                                    LLVMTypeRef ParamType1,
1528                                    LLVMTypeRef ParamType2,
1529                                    LLVMTypeRef ParamType3,
1530                                    LLVMTypeRef ParamType4,
1531                                    LLVMTypeRef ParamType5,
1532                                    int IsVarArg)
1533 {
1534         LLVMTypeRef param_types [5];
1535
1536         param_types [0] = ParamType1;
1537         param_types [1] = ParamType2;
1538         param_types [2] = ParamType3;
1539         param_types [3] = ParamType4;
1540         param_types [4] = ParamType5;
1541
1542         return LLVMFunctionType (ReturnType, param_types, 5, IsVarArg);
1543 }
1544
1545 /*
1546  * create_builder:
1547  *
1548  *   Create an LLVM builder and remember it so it can be freed later.
1549  */
1550 static LLVMBuilderRef
1551 create_builder (EmitContext *ctx)
1552 {
1553         LLVMBuilderRef builder = LLVMCreateBuilder ();
1554
1555         ctx->builders = g_slist_prepend_mempool (ctx->cfg->mempool, ctx->builders, builder);
1556
1557         return builder;
1558 }
1559
1560 static char*
1561 get_aotconst_name (MonoJumpInfoType type, gconstpointer data, int got_offset)
1562 {
1563         char *name;
1564
1565         switch (type) {
1566         case MONO_PATCH_INFO_INTERNAL_METHOD:
1567                 name = g_strdup_printf ("jit_icall_%s", data);
1568                 break;
1569         case MONO_PATCH_INFO_RGCTX_SLOT_INDEX: {
1570                 MonoJumpInfoRgctxEntry *entry = (MonoJumpInfoRgctxEntry*)data;
1571                 name = g_strdup_printf ("RGCTX_SLOT_INDEX_%s", mono_rgctx_info_type_to_str (entry->info_type));
1572                 break;
1573         }
1574         default:
1575                 name = g_strdup_printf ("%s_%d", mono_ji_type_to_string (type), got_offset);
1576                 break;
1577         }
1578
1579         return name;
1580 }
1581
1582 static LLVMValueRef
1583 get_aotconst_typed (EmitContext *ctx, MonoJumpInfoType type, gconstpointer data, LLVMTypeRef llvm_type)
1584 {
1585         MonoCompile *cfg;
1586         guint32 got_offset;
1587         LLVMValueRef indexes [2];
1588         LLVMValueRef got_entry_addr, load;
1589         LLVMBuilderRef builder = ctx->builder;
1590         char *name = NULL;
1591
1592         cfg = ctx->cfg;
1593
1594         MonoJumpInfo tmp_ji;
1595         tmp_ji.type = type;
1596         tmp_ji.data.target = data;
1597
1598         MonoJumpInfo *ji = mono_aot_patch_info_dup (&tmp_ji);
1599
1600         ji->next = cfg->patch_info;
1601         cfg->patch_info = ji;
1602
1603         got_offset = mono_aot_get_got_offset (cfg->patch_info);
1604         ctx->module->max_got_offset = MAX (ctx->module->max_got_offset, got_offset);
1605         /*
1606          * If the got slot is shared, it means its initialized when the aot image is loaded, so we don't need to
1607          * explicitly initialize it.
1608          */
1609         if (!mono_aot_is_shared_got_offset (got_offset)) {
1610                 //mono_print_ji (ji);
1611                 //printf ("\n");
1612                 ctx->has_got_access = TRUE;
1613         }
1614
1615         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1616         indexes [1] = LLVMConstInt (LLVMInt32Type (), (gssize)got_offset, FALSE);
1617         got_entry_addr = LLVMBuildGEP (builder, ctx->module->got_var, indexes, 2, "");
1618
1619         name = get_aotconst_name (type, data, got_offset);
1620         if (llvm_type) {
1621                 load = LLVMBuildLoad (builder, got_entry_addr, "");
1622                 load = convert (ctx, load, llvm_type);
1623                 LLVMSetValueName (load, name ? name : "");
1624         } else {
1625                 load = LLVMBuildLoad (builder, got_entry_addr, name ? name : "");
1626         }
1627         g_free (name);
1628         //set_invariant_load_flag (load);
1629
1630         return load;
1631 }
1632
1633 static LLVMValueRef
1634 get_aotconst (EmitContext *ctx, MonoJumpInfoType type, gconstpointer data)
1635 {
1636         return get_aotconst_typed (ctx, type, data, NULL);
1637 }
1638
1639 static LLVMValueRef
1640 get_callee (EmitContext *ctx, LLVMTypeRef llvm_sig, MonoJumpInfoType type, gconstpointer data)
1641 {
1642         LLVMValueRef callee;
1643         char *callee_name;
1644         if (ctx->llvm_only) {
1645                 callee_name = mono_aot_get_direct_call_symbol (type, data);
1646                 if (callee_name) {
1647                         /* Directly callable */
1648                         // FIXME: Locking
1649                         callee = (LLVMValueRef)g_hash_table_lookup (ctx->module->direct_callables, callee_name);
1650                         if (!callee) {
1651                                 callee = LLVMAddFunction (ctx->lmodule, callee_name, llvm_sig);
1652
1653                                 LLVMSetVisibility (callee, LLVMHiddenVisibility);
1654
1655                                 g_hash_table_insert (ctx->module->direct_callables, (char*)callee_name, callee);
1656                         } else {
1657                                 /* LLVMTypeRef's are uniqued */
1658                                 if (LLVMGetElementType (LLVMTypeOf (callee)) != llvm_sig)
1659                                         return LLVMConstBitCast (callee, LLVMPointerType (llvm_sig, 0));
1660
1661                                 g_free (callee_name);
1662                         }
1663                         return callee;
1664                 }
1665
1666                 /*
1667                  * Calls are made through the GOT.
1668                  */
1669                 return get_aotconst_typed (ctx, type, data, LLVMPointerType (llvm_sig, 0));
1670         } else {
1671                 MonoJumpInfo *ji = NULL;
1672
1673                 callee_name = mono_aot_get_plt_symbol (type, data);
1674                 if (!callee_name)
1675                         return NULL;
1676
1677                 if (ctx->cfg->compile_aot)
1678                         /* Add a patch so referenced wrappers can be compiled in full aot mode */
1679                         mono_add_patch_info (ctx->cfg, 0, type, data);
1680
1681                 // FIXME: Locking
1682                 callee = (LLVMValueRef)g_hash_table_lookup (ctx->module->plt_entries, callee_name);
1683                 if (!callee) {
1684                         callee = LLVMAddFunction (ctx->lmodule, callee_name, llvm_sig);
1685
1686                         LLVMSetVisibility (callee, LLVMHiddenVisibility);
1687
1688                         g_hash_table_insert (ctx->module->plt_entries, (char*)callee_name, callee);
1689                 }
1690
1691                 if (ctx->cfg->compile_aot) {
1692                         ji = g_new0 (MonoJumpInfo, 1);
1693                         ji->type = type;
1694                         ji->data.target = data;
1695
1696                         g_hash_table_insert (ctx->module->plt_entries_ji, ji, callee);
1697                 }
1698
1699                 return callee;
1700         }
1701 }
1702
1703 static LLVMValueRef
1704 emit_jit_callee (EmitContext *ctx, const char *name, LLVMTypeRef llvm_sig, gpointer target)
1705 {
1706 #if LLVM_API_VERSION > 100
1707         LLVMValueRef tramp_var = LLVMAddGlobal (ctx->lmodule, LLVMPointerType (llvm_sig, 0), name);
1708         LLVMSetInitializer (tramp_var, LLVMConstIntToPtr (LLVMConstInt (LLVMInt64Type (), (guint64)(size_t)target, FALSE), LLVMPointerType (llvm_sig, 0)));
1709         LLVMSetLinkage (tramp_var, LLVMExternalLinkage);
1710         LLVMValueRef callee = LLVMBuildLoad (ctx->builder, tramp_var, "");
1711         return callee;
1712 #else
1713         LLVMValueRef callee = LLVMAddFunction (ctx->lmodule, "", llvm_sig);
1714         LLVMAddGlobalMapping (ctx->module->ee, callee, target);
1715         return callee;
1716 #endif
1717 }
1718
1719 static int
1720 get_handler_clause (MonoCompile *cfg, MonoBasicBlock *bb)
1721 {
1722         MonoMethodHeader *header = cfg->header;
1723         MonoExceptionClause *clause;
1724         int i;
1725
1726         /* Directly */
1727         if (bb->region != -1 && MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))
1728                 return (bb->region >> 8) - 1;
1729
1730         /* Indirectly */
1731         for (i = 0; i < header->num_clauses; ++i) {
1732                 clause = &header->clauses [i];
1733
1734                 if (MONO_OFFSET_IN_CLAUSE (clause, bb->real_offset) && clause->flags == MONO_EXCEPTION_CLAUSE_NONE)
1735                         return i;
1736         }
1737
1738         return -1;
1739 }
1740
1741 static MonoExceptionClause *
1742 get_most_deep_clause (MonoCompile *cfg, EmitContext *ctx, MonoBasicBlock *bb)
1743 {
1744         if (bb == cfg->bb_init)
1745                 return NULL;
1746         // Since they're sorted by nesting we just need
1747         // the first one that the bb is a member of
1748         for (int i = 0; i < cfg->header->num_clauses; i++) {
1749                 MonoExceptionClause *curr = &cfg->header->clauses [i];
1750
1751                 if (MONO_OFFSET_IN_CLAUSE (curr, bb->real_offset))
1752                         return curr;
1753         }
1754
1755         return NULL;
1756 }
1757
1758 static void
1759 set_metadata_flag (LLVMValueRef v, const char *flag_name)
1760 {
1761         LLVMValueRef md_arg;
1762         int md_kind;
1763
1764         md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1765         md_arg = LLVMMDString ("mono", 4);
1766         LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1767 }
1768
1769 static void
1770 set_invariant_load_flag (LLVMValueRef v)
1771 {
1772         LLVMValueRef md_arg;
1773         int md_kind;
1774         const char *flag_name;
1775
1776         // FIXME: Cache this
1777         flag_name = "invariant.load";
1778         md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1779         md_arg = LLVMMDString ("<index>", strlen ("<index>"));
1780         LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1781 }
1782
1783 /*
1784  * emit_call:
1785  *
1786  *   Emit an LLVM call or invoke instruction depending on whenever the call is inside
1787  * a try region.
1788  */
1789 static LLVMValueRef
1790 emit_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, LLVMValueRef callee, LLVMValueRef *args, int pindex)
1791 {
1792         MonoCompile *cfg = ctx->cfg;
1793         LLVMValueRef lcall = NULL;
1794         LLVMBuilderRef builder = *builder_ref;
1795         MonoExceptionClause *clause;
1796
1797         if (ctx->llvm_only) {
1798                 clause = get_most_deep_clause (cfg, ctx, bb);
1799
1800                 if (clause) {
1801                         g_assert (clause->flags == MONO_EXCEPTION_CLAUSE_NONE || clause->flags == MONO_EXCEPTION_CLAUSE_FINALLY);
1802
1803                         /*
1804                          * Have to use an invoke instead of a call, branching to the
1805                          * handler bblock of the clause containing this bblock.
1806                          */
1807                         intptr_t key = CLAUSE_END(clause);
1808
1809                         LLVMBasicBlockRef lpad_bb = (LLVMBasicBlockRef)g_hash_table_lookup (ctx->exc_meta, (gconstpointer)key);
1810
1811                         // FIXME: Find the one that has the lowest end bound for the right start address
1812                         // FIXME: Finally + nesting
1813
1814                         if (lpad_bb) {
1815                                 LLVMBasicBlockRef noex_bb = gen_bb (ctx, "CALL_NOEX_BB");
1816
1817                                 /* Use an invoke */
1818                                 lcall = LLVMBuildInvoke (builder, callee, args, pindex, noex_bb, lpad_bb, "");
1819
1820                                 builder = ctx->builder = create_builder (ctx);
1821                                 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1822
1823                                 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1824                         }
1825                 }
1826         } else {
1827                 int clause_index = get_handler_clause (cfg, bb);
1828
1829                 if (clause_index != -1) {
1830                         MonoMethodHeader *header = cfg->header;
1831                         MonoExceptionClause *ec = &header->clauses [clause_index];
1832                         MonoBasicBlock *tblock;
1833                         LLVMBasicBlockRef ex_bb, noex_bb;
1834
1835                         /*
1836                          * Have to use an invoke instead of a call, branching to the
1837                          * handler bblock of the clause containing this bblock.
1838                          */
1839
1840                         g_assert (ec->flags == MONO_EXCEPTION_CLAUSE_NONE || ec->flags == MONO_EXCEPTION_CLAUSE_FINALLY);
1841
1842                         tblock = cfg->cil_offset_to_bb [ec->handler_offset];
1843                         g_assert (tblock);
1844
1845                         ctx->bblocks [tblock->block_num].invoke_target = TRUE;
1846
1847                         ex_bb = get_bb (ctx, tblock);
1848
1849                         noex_bb = gen_bb (ctx, "NOEX_BB");
1850
1851                         /* Use an invoke */
1852                         lcall = LLVMBuildInvoke (builder, callee, args, pindex, noex_bb, ex_bb, "");
1853
1854                         builder = ctx->builder = create_builder (ctx);
1855                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1856
1857                         ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1858                 }
1859         }
1860
1861         if (!lcall) {
1862                 lcall = LLVMBuildCall (builder, callee, args, pindex, "");
1863                 ctx->builder = builder;
1864         }
1865
1866         if (builder_ref)
1867                 *builder_ref = ctx->builder;
1868
1869         return lcall;
1870 }
1871
1872 static LLVMValueRef
1873 emit_load_general (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef addr, LLVMValueRef base, const char *name, gboolean is_faulting, BarrierKind barrier)
1874 {
1875         const char *intrins_name;
1876         LLVMValueRef args [16], res;
1877         LLVMTypeRef addr_type;
1878         gboolean use_intrinsics = TRUE;
1879
1880 #if LLVM_API_VERSION > 100
1881         if (is_faulting && bb->region != -1 && !ctx->cfg->llvm_only) {
1882                 /* The llvm.mono.load/store intrinsics are not supported by this llvm version, emit an explicit null check instead */
1883                 LLVMValueRef cmp;
1884
1885                 cmp = LLVMBuildICmp (*builder_ref, LLVMIntEQ, base, LLVMConstNull (LLVMTypeOf (base)), "");
1886                 emit_cond_system_exception (ctx, bb, "NullReferenceException", cmp);
1887                 *builder_ref = ctx->builder;
1888                 use_intrinsics = FALSE;
1889         }
1890 #endif
1891
1892         if (is_faulting && bb->region != -1 && !ctx->cfg->llvm_only && use_intrinsics) {
1893                 LLVMAtomicOrdering ordering;
1894
1895                 switch (barrier) {
1896                 case LLVM_BARRIER_NONE:
1897                         ordering = LLVMAtomicOrderingNotAtomic;
1898                         break;
1899                 case LLVM_BARRIER_ACQ:
1900                         ordering = LLVMAtomicOrderingAcquire;
1901                         break;
1902                 case LLVM_BARRIER_SEQ:
1903                         ordering = LLVMAtomicOrderingSequentiallyConsistent;
1904                         break;
1905                 default:
1906                         g_assert_not_reached ();
1907                         break;
1908                 }
1909
1910                 /*
1911                  * We handle loads which can fault by calling a mono specific intrinsic
1912                  * using an invoke, so they are handled properly inside try blocks.
1913                  * We can't use this outside clauses, since LLVM optimizes intrinsics which
1914                  * are marked with IntrReadArgMem.
1915                  */
1916                 switch (size) {
1917                 case 1:
1918                         intrins_name = "llvm.mono.load.i8.p0i8";
1919                         break;
1920                 case 2:
1921                         intrins_name = "llvm.mono.load.i16.p0i16";
1922                         break;
1923                 case 4:
1924                         intrins_name = "llvm.mono.load.i32.p0i32";
1925                         break;
1926                 case 8:
1927                         intrins_name = "llvm.mono.load.i64.p0i64";
1928                         break;
1929                 default:
1930                         g_assert_not_reached ();
1931                 }
1932
1933                 addr_type = LLVMTypeOf (addr);
1934                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0) || addr_type == LLVMPointerType (LLVMFloatType (), 0))
1935                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1936
1937                 args [0] = addr;
1938                 args [1] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1939                 args [2] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1940                 args [3] = LLVMConstInt (LLVMInt32Type (), ordering, FALSE);
1941                 res = emit_call (ctx, bb, builder_ref, get_intrinsic (ctx, intrins_name), args, 4);
1942
1943                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0))
1944                         res = LLVMBuildBitCast (*builder_ref, res, LLVMDoubleType (), "");
1945                 else if (addr_type == LLVMPointerType (LLVMFloatType (), 0))
1946                         res = LLVMBuildBitCast (*builder_ref, res, LLVMFloatType (), "");
1947
1948                 return res;
1949         } else {
1950                 LLVMValueRef res;
1951
1952                 /*
1953                  * We emit volatile loads for loads which can fault, because otherwise
1954                  * LLVM will generate invalid code when encountering a load from a
1955                  * NULL address.
1956                  */
1957                 if (barrier != LLVM_BARRIER_NONE)
1958                         res = mono_llvm_build_atomic_load (*builder_ref, addr, name, is_faulting, size, barrier);
1959                 else
1960                         res = mono_llvm_build_load (*builder_ref, addr, name, is_faulting);
1961
1962                 /* Mark it with a custom metadata */
1963                 /*
1964                   if (is_faulting)
1965                   set_metadata_flag (res, "mono.faulting.load");
1966                 */
1967
1968                 return res;
1969         }
1970 }
1971
1972 static LLVMValueRef
1973 emit_load (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef addr, const char *name, gboolean is_faulting)
1974 {
1975         return emit_load_general (ctx, bb, builder_ref, size, addr, addr, name, is_faulting, LLVM_BARRIER_NONE);
1976 }
1977
1978 static void
1979 emit_store_general (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef value, LLVMValueRef addr, LLVMValueRef base, gboolean is_faulting, BarrierKind barrier)
1980 {
1981         const char *intrins_name;
1982         LLVMValueRef args [16];
1983         gboolean use_intrinsics = TRUE;
1984
1985 #if LLVM_API_VERSION > 100
1986         if (is_faulting && bb->region != -1 && !ctx->cfg->llvm_only) {
1987                 /* The llvm.mono.load/store intrinsics are not supported by this llvm version, emit an explicit null check instead */
1988                 LLVMValueRef cmp = LLVMBuildICmp (*builder_ref, LLVMIntEQ, base, LLVMConstNull (LLVMTypeOf (base)), "");
1989                 emit_cond_system_exception (ctx, bb, "NullReferenceException", cmp);
1990                 *builder_ref = ctx->builder;
1991                 use_intrinsics = FALSE;
1992         }
1993 #endif
1994
1995         if (is_faulting && bb->region != -1 && !ctx->cfg->llvm_only && use_intrinsics) {
1996                 LLVMAtomicOrdering ordering;
1997
1998                 switch (barrier) {
1999                 case LLVM_BARRIER_NONE:
2000                         ordering = LLVMAtomicOrderingNotAtomic;
2001                         break;
2002                 case LLVM_BARRIER_REL:
2003                         ordering = LLVMAtomicOrderingRelease;
2004                         break;
2005                 case LLVM_BARRIER_SEQ:
2006                         ordering = LLVMAtomicOrderingSequentiallyConsistent;
2007                         break;
2008                 default:
2009                         g_assert_not_reached ();
2010                         break;
2011                 }
2012
2013                 switch (size) {
2014                 case 1:
2015                         intrins_name = "llvm.mono.store.i8.p0i8";
2016                         break;
2017                 case 2:
2018                         intrins_name = "llvm.mono.store.i16.p0i16";
2019                         break;
2020                 case 4:
2021                         intrins_name = "llvm.mono.store.i32.p0i32";
2022                         break;
2023                 case 8:
2024                         intrins_name = "llvm.mono.store.i64.p0i64";
2025                         break;
2026                 default:
2027                         g_assert_not_reached ();
2028                 }
2029
2030                 if (LLVMTypeOf (value) == LLVMDoubleType () || LLVMTypeOf (value) == LLVMFloatType ()) {
2031                         value = LLVMBuildBitCast (*builder_ref, value, LLVMIntType (size * 8), "");
2032                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
2033                 }
2034
2035                 args [0] = value;
2036                 args [1] = addr;
2037                 args [2] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
2038                 args [3] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
2039                 args [4] = LLVMConstInt (LLVMInt32Type (), ordering, FALSE);
2040                 emit_call (ctx, bb, builder_ref, get_intrinsic (ctx, intrins_name), args, 5);
2041         } else {
2042                 if (barrier != LLVM_BARRIER_NONE)
2043                         mono_llvm_build_aligned_store (*builder_ref, value, addr, barrier, size);
2044                 else
2045                         mono_llvm_build_store (*builder_ref, value, addr, is_faulting, barrier);
2046         }
2047 }
2048
2049 static void
2050 emit_store (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef value, LLVMValueRef addr, LLVMValueRef base, gboolean is_faulting)
2051 {
2052         emit_store_general (ctx, bb, builder_ref, size, value, addr, base, is_faulting, LLVM_BARRIER_NONE);
2053 }
2054
2055 /*
2056  * emit_cond_system_exception:
2057  *
2058  *   Emit code to throw the exception EXC_TYPE if the condition CMP is false.
2059  * Might set the ctx exception.
2060  */
2061 static void
2062 emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *exc_type, LLVMValueRef cmp)
2063 {
2064         LLVMBasicBlockRef ex_bb, ex2_bb = NULL, noex_bb;
2065         LLVMBuilderRef builder;
2066         MonoClass *exc_class;
2067         LLVMValueRef args [2];
2068         LLVMValueRef callee;
2069         gboolean no_pc = FALSE;
2070
2071         if (IS_TARGET_AMD64)
2072                 /* Some platforms don't require the pc argument */
2073                 no_pc = TRUE;
2074
2075         ex_bb = gen_bb (ctx, "EX_BB");
2076         if (ctx->llvm_only)
2077                 ex2_bb = gen_bb (ctx, "EX2_BB");
2078         noex_bb = gen_bb (ctx, "NOEX_BB");
2079
2080         LLVMBuildCondBr (ctx->builder, cmp, ex_bb, noex_bb);
2081
2082         exc_class = mono_class_load_from_name (mono_get_corlib (), "System", exc_type);
2083
2084         /* Emit exception throwing code */
2085         ctx->builder = builder = create_builder (ctx);
2086         LLVMPositionBuilderAtEnd (builder, ex_bb);
2087
2088         if (ctx->cfg->llvm_only) {
2089                 static LLVMTypeRef sig;
2090
2091                 if (!sig)
2092                         sig = LLVMFunctionType1 (LLVMVoidType (), LLVMInt32Type (), FALSE);
2093                 callee = get_callee (ctx, sig, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_llvm_throw_corlib_exception");
2094
2095                 LLVMBuildBr (builder, ex2_bb);
2096
2097                 ctx->builder = builder = create_builder (ctx);
2098                 LLVMPositionBuilderAtEnd (ctx->builder, ex2_bb);
2099
2100                 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
2101                 emit_call (ctx, bb, &builder, callee, args, 1);
2102                 LLVMBuildUnreachable (builder);
2103
2104                 ctx->builder = builder = create_builder (ctx);
2105                 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
2106
2107                 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
2108
2109                 ctx->ex_index ++;
2110                 return;
2111         }
2112
2113         callee = ctx->module->throw_corlib_exception;
2114         if (!callee) {
2115                 LLVMTypeRef sig;
2116                 const char *icall_name;
2117
2118                 if (no_pc)
2119                         sig = LLVMFunctionType1 (LLVMVoidType (), LLVMInt32Type (), FALSE);
2120                 else
2121                         sig = LLVMFunctionType2 (LLVMVoidType (), LLVMInt32Type (), LLVMPointerType (LLVMInt8Type (), 0), FALSE);
2122                 icall_name = "llvm_throw_corlib_exception_abs_trampoline";
2123
2124                 if (ctx->cfg->compile_aot) {
2125                         callee = get_callee (ctx, sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
2126                 } else {
2127                         /*
2128                          * Differences between the LLVM/non-LLVM throw corlib exception trampoline:
2129                          * - On x86, LLVM generated code doesn't push the arguments
2130                          * - The trampoline takes the throw address as an arguments, not a pc offset.
2131                          */
2132                         gpointer target = resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
2133                         callee = emit_jit_callee (ctx, "llvm_throw_corlib_exception_trampoline", sig, target);
2134
2135 #if LLVM_API_VERSION > 100
2136                         /*
2137                          * Make sure that ex_bb starts with the invoke, so the block address points to it, and not to the load
2138                          * added by emit_jit_callee ().
2139                          */
2140                         ex2_bb = gen_bb (ctx, "EX2_BB");
2141                         LLVMBuildBr (builder, ex2_bb);
2142                         ex_bb = ex2_bb;
2143
2144                         ctx->builder = builder = create_builder (ctx);
2145                         LLVMPositionBuilderAtEnd (ctx->builder, ex2_bb);
2146 #else
2147                         mono_memory_barrier ();
2148                         ctx->module->throw_corlib_exception = callee;
2149 #endif
2150                 }
2151         }
2152
2153         args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
2154
2155         /*
2156          * The LLVM mono branch contains changes so a block address can be passed as an
2157          * argument to a call.
2158          */
2159         if (no_pc) {
2160                 emit_call (ctx, bb, &builder, callee, args, 1);
2161         } else {
2162                 args [1] = LLVMBlockAddress (ctx->lmethod, ex_bb);
2163                 emit_call (ctx, bb, &builder, callee, args, 2);
2164         }
2165
2166         LLVMBuildUnreachable (builder);
2167
2168         ctx->builder = builder = create_builder (ctx);
2169         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
2170
2171         ctx->bblocks [bb->block_num].end_bblock = noex_bb;
2172
2173         ctx->ex_index ++;
2174         return;
2175 }
2176
2177 /*
2178  * emit_args_to_vtype:
2179  *
2180  *   Emit code to store the vtype in the arguments args to the address ADDRESS.
2181  */
2182 static void
2183 emit_args_to_vtype (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *args)
2184 {
2185         int j, size, nslots;
2186
2187         size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
2188
2189         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
2190                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
2191         }
2192
2193         if (ainfo->storage == LLVMArgAsFpArgs)
2194                 nslots = ainfo->nslots;
2195         else
2196                 nslots = 2;
2197
2198         for (j = 0; j < nslots; ++j) {
2199                 LLVMValueRef index [2], addr, daddr;
2200                 int part_size = size > sizeof (gpointer) ? sizeof (gpointer) : size;
2201                 LLVMTypeRef part_type;
2202
2203                 while (part_size != 1 && part_size != 2 && part_size != 4 && part_size < 8)
2204                         part_size ++;
2205
2206                 if (ainfo->pair_storage [j] == LLVMArgNone)
2207                         continue;
2208
2209                 switch (ainfo->pair_storage [j]) {
2210                 case LLVMArgInIReg: {
2211                         part_type = LLVMIntType (part_size * 8);
2212                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
2213                                 index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
2214                                 addr = LLVMBuildGEP (builder, address, index, 1, "");
2215                         } else {
2216                                 daddr = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (IntPtrType (), 0), "");
2217                                 index [0] = LLVMConstInt (LLVMInt32Type (), j, FALSE);
2218                                 addr = LLVMBuildGEP (builder, daddr, index, 1, "");
2219                         }
2220                         LLVMBuildStore (builder, convert (ctx, args [j], part_type), LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (part_type, 0), ""));
2221                         break;
2222                 }
2223                 case LLVMArgInFPReg: {
2224                         LLVMTypeRef arg_type;
2225
2226                         if (ainfo->esize == 8)
2227                                 arg_type = LLVMDoubleType ();
2228                         else
2229                                 arg_type = LLVMFloatType ();
2230
2231                         index [0] = LLVMConstInt (LLVMInt32Type (), j, FALSE);
2232                         daddr = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (arg_type, 0), "");
2233                         addr = LLVMBuildGEP (builder, daddr, index, 1, "");
2234                         LLVMBuildStore (builder, args [j], addr);
2235                         break;
2236                 }
2237                 case LLVMArgNone:
2238                         break;
2239                 default:
2240                         g_assert_not_reached ();
2241                 }
2242
2243                 size -= sizeof (gpointer);
2244         }
2245 }
2246
2247 /*
2248  * emit_vtype_to_args:
2249  *
2250  *   Emit code to load a vtype at address ADDRESS into scalar arguments. Store the arguments
2251  * into ARGS, and the number of arguments into NARGS.
2252  */
2253 static void
2254 emit_vtype_to_args (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *args, guint32 *nargs)
2255 {
2256         int pindex = 0;
2257         int j, size, nslots;
2258         LLVMTypeRef arg_type;
2259
2260         size = get_vtype_size (t);
2261
2262         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t)))
2263                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
2264
2265         if (ainfo->storage == LLVMArgAsFpArgs)
2266                 nslots = ainfo->nslots;
2267         else
2268                 nslots = 2;
2269         for (j = 0; j < nslots; ++j) {
2270                 LLVMValueRef index [2], addr, daddr;
2271                 int partsize = size > sizeof (gpointer) ? sizeof (gpointer) : size;
2272
2273                 if (ainfo->pair_storage [j] == LLVMArgNone)
2274                         continue;
2275
2276                 switch (ainfo->pair_storage [j]) {
2277                 case LLVMArgInIReg:
2278                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
2279                                 index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
2280                                 addr = LLVMBuildGEP (builder, address, index, 1, "");
2281                         } else {
2282                                 daddr = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (IntPtrType (), 0), "");
2283                                 index [0] = LLVMConstInt (LLVMInt32Type (), j, FALSE);
2284                                 addr = LLVMBuildGEP (builder, daddr, index, 1, "");
2285                         }
2286                         args [pindex ++] = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (LLVMIntType (partsize * 8), 0), ""), ""), IntPtrType ());
2287                         break;
2288                 case LLVMArgInFPReg:
2289                         if (ainfo->esize == 8)
2290                                 arg_type = LLVMDoubleType ();
2291                         else
2292                                 arg_type = LLVMFloatType ();
2293                         daddr = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (arg_type, 0), "");
2294                         index [0] = LLVMConstInt (LLVMInt32Type (), j, FALSE);
2295                         addr = LLVMBuildGEP (builder, daddr, index, 1, "");
2296                         args [pindex ++] = LLVMBuildLoad (builder, addr, "");
2297                         break;
2298                 case LLVMArgNone:
2299                         break;
2300                 default:
2301                         g_assert_not_reached ();
2302                 }
2303                 size -= sizeof (gpointer);
2304         }
2305
2306         *nargs = pindex;
2307 }
2308
2309 static LLVMValueRef
2310 build_alloca_llvm_type_name (EmitContext *ctx, LLVMTypeRef t, int align, const char *name)
2311 {
2312         /*
2313          * Have to place all alloca's at the end of the entry bb, since otherwise they would
2314          * get executed every time control reaches them.
2315          */
2316         LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca);
2317
2318         ctx->last_alloca = mono_llvm_build_alloca (ctx->alloca_builder, t, NULL, align, name);
2319         return ctx->last_alloca;
2320 }
2321
2322 static LLVMValueRef
2323 build_alloca_llvm_type (EmitContext *ctx, LLVMTypeRef t, int align)
2324 {
2325         return build_alloca_llvm_type_name (ctx, t, align, "");
2326 }
2327
2328 static LLVMValueRef
2329 build_alloca (EmitContext *ctx, MonoType *t)
2330 {
2331         MonoClass *k = mono_class_from_mono_type (t);
2332         int align;
2333
2334         g_assert (!mini_is_gsharedvt_variable_type (t));
2335
2336         if (MONO_CLASS_IS_SIMD (ctx->cfg, k))
2337                 align = 16;
2338         else
2339                 align = mono_class_min_align (k);
2340
2341         /* Sometimes align is not a power of 2 */
2342         while (mono_is_power_of_two (align) == -1)
2343                 align ++;
2344
2345         return build_alloca_llvm_type (ctx, type_to_llvm_type (ctx, t), align);
2346 }
2347
2348 static LLVMValueRef
2349 emit_gsharedvt_ldaddr (EmitContext *ctx, int vreg)
2350 {
2351         /*
2352          * gsharedvt local.
2353          * Compute the address of the local as gsharedvt_locals_var + gsharedvt_info_var->locals_offsets [idx].
2354          */
2355         MonoCompile *cfg = ctx->cfg;
2356         LLVMBuilderRef builder = ctx->builder;
2357         LLVMValueRef offset, offset_var;
2358         LLVMValueRef info_var = ctx->values [cfg->gsharedvt_info_var->dreg];
2359         LLVMValueRef locals_var = ctx->values [cfg->gsharedvt_locals_var->dreg];
2360         LLVMValueRef ptr;
2361         char *name;
2362
2363         g_assert (info_var);
2364         g_assert (locals_var);
2365
2366         int idx = cfg->gsharedvt_vreg_to_idx [vreg] - 1;
2367
2368         offset = LLVMConstInt (LLVMInt32Type (), MONO_STRUCT_OFFSET (MonoGSharedVtMethodRuntimeInfo, entries) + (idx * sizeof (gpointer)), FALSE);
2369         ptr = LLVMBuildAdd (builder, convert (ctx, info_var, IntPtrType ()), convert (ctx, offset, IntPtrType ()), "");
2370
2371         name = g_strdup_printf ("gsharedvt_local_%d_offset", vreg);
2372         offset_var = LLVMBuildLoad (builder, convert (ctx, ptr, LLVMPointerType (LLVMInt32Type (), 0)), name);
2373
2374         return LLVMBuildAdd (builder, convert (ctx, locals_var, IntPtrType ()), convert (ctx, offset_var, IntPtrType ()), "");
2375 }
2376
2377 /*
2378  * Put the global into the 'llvm.used' array to prevent it from being optimized away.
2379  */
2380 static void
2381 mark_as_used (MonoLLVMModule *module, LLVMValueRef global)
2382 {
2383         if (!module->used)
2384                 module->used = g_ptr_array_sized_new (16);
2385         g_ptr_array_add (module->used, global);
2386 }
2387
2388 static void
2389 emit_llvm_used (MonoLLVMModule *module)
2390 {
2391         LLVMModuleRef lmodule = module->lmodule;
2392         LLVMTypeRef used_type;
2393         LLVMValueRef used, *used_elem;
2394         int i;
2395
2396         if (!module->used)
2397                 return;
2398
2399         used_type = LLVMArrayType (LLVMPointerType (LLVMInt8Type (), 0), module->used->len);
2400         used = LLVMAddGlobal (lmodule, used_type, "llvm.used");
2401         used_elem = g_new0 (LLVMValueRef, module->used->len);
2402         for (i = 0; i < module->used->len; ++i)
2403                 used_elem [i] = LLVMConstBitCast ((LLVMValueRef)g_ptr_array_index (module->used, i), LLVMPointerType (LLVMInt8Type (), 0));
2404         LLVMSetInitializer (used, LLVMConstArray (LLVMPointerType (LLVMInt8Type (), 0), used_elem, module->used->len));
2405         LLVMSetLinkage (used, LLVMAppendingLinkage);
2406         LLVMSetSection (used, "llvm.metadata");
2407 }
2408
2409 /*
2410  * emit_get_method:
2411  *
2412  *   Emit a function mapping method indexes to their code
2413  */
2414 static void
2415 emit_get_method (MonoLLVMModule *module)
2416 {
2417         LLVMModuleRef lmodule = module->lmodule;
2418         LLVMValueRef func, switch_ins, m;
2419         LLVMBasicBlockRef entry_bb, fail_bb, bb, code_start_bb, code_end_bb;
2420         LLVMBasicBlockRef *bbs;
2421         LLVMTypeRef rtype;
2422         LLVMBuilderRef builder = LLVMCreateBuilder ();
2423         char *name;
2424         int i;
2425
2426         /*
2427          * Emit a switch statement. Emitting a table of function addresses is smaller/faster,
2428          * but generating code seems safer.
2429          */
2430         rtype = LLVMPointerType (LLVMInt8Type (), 0);
2431         func = LLVMAddFunction (lmodule, module->get_method_symbol, LLVMFunctionType1 (rtype, LLVMInt32Type (), FALSE));
2432         LLVMSetLinkage (func, LLVMExternalLinkage);
2433         LLVMSetVisibility (func, LLVMHiddenVisibility);
2434         LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute);
2435         module->get_method = func;
2436
2437         entry_bb = LLVMAppendBasicBlock (func, "ENTRY");
2438
2439         /*
2440          * Return llvm_code_start/llvm_code_end when called with -1/-2.
2441          * Hopefully, the toolchain doesn't reorder these functions. If it does,
2442          * then we will have to find another solution.
2443          */
2444
2445         name = g_strdup_printf ("BB_CODE_START");
2446         code_start_bb = LLVMAppendBasicBlock (func, name);
2447         g_free (name);
2448         LLVMPositionBuilderAtEnd (builder, code_start_bb);
2449         LLVMBuildRet (builder, LLVMBuildBitCast (builder, module->code_start, rtype, ""));
2450
2451         name = g_strdup_printf ("BB_CODE_END");
2452         code_end_bb = LLVMAppendBasicBlock (func, name);
2453         g_free (name);
2454         LLVMPositionBuilderAtEnd (builder, code_end_bb);
2455         LLVMBuildRet (builder, LLVMBuildBitCast (builder, module->code_end, rtype, ""));
2456
2457         bbs = g_new0 (LLVMBasicBlockRef, module->max_method_idx + 1);
2458         for (i = 0; i < module->max_method_idx + 1; ++i) {
2459                 name = g_strdup_printf ("BB_%d", i);
2460                 bb = LLVMAppendBasicBlock (func, name);
2461                 g_free (name);
2462                 bbs [i] = bb;
2463
2464                 LLVMPositionBuilderAtEnd (builder, bb);
2465
2466                 m = (LLVMValueRef)g_hash_table_lookup (module->idx_to_lmethod, GINT_TO_POINTER (i));
2467                 if (m)
2468                         LLVMBuildRet (builder, LLVMBuildBitCast (builder, m, rtype, ""));
2469                 else
2470                         LLVMBuildRet (builder, LLVMConstNull (rtype));
2471         }
2472
2473         fail_bb = LLVMAppendBasicBlock (func, "FAIL");
2474         LLVMPositionBuilderAtEnd (builder, fail_bb);
2475         LLVMBuildRet (builder, LLVMConstNull (rtype));
2476
2477         LLVMPositionBuilderAtEnd (builder, entry_bb);
2478
2479         switch_ins = LLVMBuildSwitch (builder, LLVMGetParam (func, 0), fail_bb, 0);
2480         LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), -1, FALSE), code_start_bb);
2481         LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), -2, FALSE), code_end_bb);
2482         for (i = 0; i < module->max_method_idx + 1; ++i) {
2483                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i, FALSE), bbs [i]);
2484         }
2485
2486         mark_as_used (module, func);
2487
2488         LLVMDisposeBuilder (builder);
2489 }
2490
2491 /*
2492  * emit_get_unbox_tramp:
2493  *
2494  *   Emit a function mapping method indexes to their unbox trampoline
2495  */
2496 static void
2497 emit_get_unbox_tramp (MonoLLVMModule *module)
2498 {
2499         LLVMModuleRef lmodule = module->lmodule;
2500         LLVMValueRef func, switch_ins, m;
2501         LLVMBasicBlockRef entry_bb, fail_bb, bb;
2502         LLVMBasicBlockRef *bbs;
2503         LLVMTypeRef rtype;
2504         LLVMBuilderRef builder = LLVMCreateBuilder ();
2505         char *name;
2506         int i;
2507
2508         /* Similar to emit_get_method () */
2509
2510         rtype = LLVMPointerType (LLVMInt8Type (), 0);
2511         func = LLVMAddFunction (lmodule, module->get_unbox_tramp_symbol, LLVMFunctionType1 (rtype, LLVMInt32Type (), FALSE));
2512         LLVMSetLinkage (func, LLVMExternalLinkage);
2513         LLVMSetVisibility (func, LLVMHiddenVisibility);
2514         LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute);
2515         module->get_unbox_tramp = func;
2516
2517         entry_bb = LLVMAppendBasicBlock (func, "ENTRY");
2518
2519         bbs = g_new0 (LLVMBasicBlockRef, module->max_method_idx + 1);
2520         for (i = 0; i < module->max_method_idx + 1; ++i) {
2521                 m = (LLVMValueRef)g_hash_table_lookup (module->idx_to_unbox_tramp, GINT_TO_POINTER (i));
2522                 if (!m)
2523                         continue;
2524
2525                 name = g_strdup_printf ("BB_%d", i);
2526                 bb = LLVMAppendBasicBlock (func, name);
2527                 g_free (name);
2528                 bbs [i] = bb;
2529
2530                 LLVMPositionBuilderAtEnd (builder, bb);
2531
2532                 LLVMBuildRet (builder, LLVMBuildBitCast (builder, m, rtype, ""));
2533         }
2534
2535         fail_bb = LLVMAppendBasicBlock (func, "FAIL");
2536         LLVMPositionBuilderAtEnd (builder, fail_bb);
2537         LLVMBuildRet (builder, LLVMConstNull (rtype));
2538
2539         LLVMPositionBuilderAtEnd (builder, entry_bb);
2540
2541         switch_ins = LLVMBuildSwitch (builder, LLVMGetParam (func, 0), fail_bb, 0);
2542         for (i = 0; i < module->max_method_idx + 1; ++i) {
2543                 m = (LLVMValueRef)g_hash_table_lookup (module->idx_to_unbox_tramp, GINT_TO_POINTER (i));
2544                 if (!m)
2545                         continue;
2546
2547                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i, FALSE), bbs [i]);
2548         }
2549
2550         mark_as_used (module, func);
2551         LLVMDisposeBuilder (builder);
2552 }
2553
2554 /* Add a function to mark the beginning of LLVM code */
2555 static void
2556 emit_llvm_code_start (MonoLLVMModule *module)
2557 {
2558         LLVMModuleRef lmodule = module->lmodule;
2559         LLVMValueRef func;
2560         LLVMBasicBlockRef entry_bb;
2561         LLVMBuilderRef builder;
2562
2563         func = LLVMAddFunction (lmodule, "llvm_code_start", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
2564         LLVMSetLinkage (func, LLVMInternalLinkage);
2565         LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute);
2566         module->code_start = func;
2567         entry_bb = LLVMAppendBasicBlock (func, "ENTRY");
2568         builder = LLVMCreateBuilder ();
2569         LLVMPositionBuilderAtEnd (builder, entry_bb);
2570         LLVMBuildRetVoid (builder);
2571         LLVMDisposeBuilder (builder);
2572 }
2573
2574 static LLVMValueRef
2575 emit_init_icall_wrapper (MonoLLVMModule *module, const char *name, const char *icall_name, int subtype)
2576 {
2577         LLVMModuleRef lmodule = module->lmodule;
2578         LLVMValueRef func, indexes [2], got_entry_addr, args [16], callee;
2579         LLVMBasicBlockRef entry_bb;
2580         LLVMBuilderRef builder;
2581         LLVMTypeRef sig;
2582         MonoJumpInfo *ji;
2583         int got_offset;
2584
2585         switch (subtype) {
2586         case 0:
2587                 func = LLVMAddFunction (lmodule, name, LLVMFunctionType1 (LLVMVoidType (), LLVMInt32Type (), FALSE));
2588                 sig = LLVMFunctionType2 (LLVMVoidType (), IntPtrType (), LLVMInt32Type (), FALSE);
2589                 break;
2590         case 1:
2591         case 3:
2592                 /* mrgctx/vtable */
2593                 func = LLVMAddFunction (lmodule, name, LLVMFunctionType2 (LLVMVoidType (), LLVMInt32Type (), IntPtrType (), FALSE));
2594                 sig = LLVMFunctionType3 (LLVMVoidType (), IntPtrType (), LLVMInt32Type (), IntPtrType (), FALSE);
2595                 break;
2596         case 2:
2597                 func = LLVMAddFunction (lmodule, name, LLVMFunctionType2 (LLVMVoidType (), LLVMInt32Type (), ObjRefType (), FALSE));
2598                 sig = LLVMFunctionType3 (LLVMVoidType (), IntPtrType (), LLVMInt32Type (), ObjRefType (), FALSE);
2599                 break;
2600         default:
2601                 g_assert_not_reached ();
2602         }
2603         LLVMSetLinkage (func, LLVMInternalLinkage);
2604         LLVMAddFunctionAttr (func, LLVMNoInlineAttribute);
2605         mono_llvm_set_preserveall_cc (func);
2606         entry_bb = LLVMAppendBasicBlock (func, "ENTRY");
2607         builder = LLVMCreateBuilder ();
2608         LLVMPositionBuilderAtEnd (builder, entry_bb);
2609
2610         /* get_aotconst */
2611         ji = g_new0 (MonoJumpInfo, 1);
2612         ji->type = MONO_PATCH_INFO_AOT_MODULE;
2613         ji = mono_aot_patch_info_dup (ji);
2614         got_offset = mono_aot_get_got_offset (ji);
2615         module->max_got_offset = MAX (module->max_got_offset, got_offset);
2616         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
2617         indexes [1] = LLVMConstInt (LLVMInt32Type (), got_offset, FALSE);
2618         got_entry_addr = LLVMBuildGEP (builder, module->got_var, indexes, 2, "");
2619         args [0] = LLVMBuildPtrToInt (builder, LLVMBuildLoad (builder, got_entry_addr, ""), IntPtrType (), "");
2620         args [1] = LLVMGetParam (func, 0);
2621         if (subtype)
2622                 args [2] = LLVMGetParam (func, 1);
2623
2624         ji = g_new0 (MonoJumpInfo, 1);
2625         ji->type = MONO_PATCH_INFO_INTERNAL_METHOD;
2626         ji->data.name = icall_name;
2627         ji = mono_aot_patch_info_dup (ji);
2628         got_offset = mono_aot_get_got_offset (ji);
2629         module->max_got_offset = MAX (module->max_got_offset, got_offset);
2630         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
2631         indexes [1] = LLVMConstInt (LLVMInt32Type (), got_offset, FALSE);
2632         got_entry_addr = LLVMBuildGEP (builder, module->got_var, indexes, 2, "");
2633         callee = LLVMBuildLoad (builder, got_entry_addr, "");
2634         callee = LLVMBuildBitCast (builder, callee, LLVMPointerType (sig, 0), "");
2635         LLVMBuildCall (builder, callee, args, LLVMCountParamTypes (sig), "");
2636
2637         // Set the inited flag
2638         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
2639         indexes [1] = LLVMGetParam (func, 0);
2640         LLVMBuildStore (builder, LLVMConstInt (LLVMInt8Type (), 1, FALSE), LLVMBuildGEP (builder, module->inited_var, indexes, 2, ""));
2641
2642         LLVMBuildRetVoid (builder);
2643
2644         LLVMVerifyFunction(func, LLVMAbortProcessAction);
2645         LLVMDisposeBuilder (builder);
2646         return func;
2647 }
2648
2649 /*
2650  * Emit wrappers around the C icalls used to initialize llvm methods, to
2651  * make the calling code smaller and to enable usage of the llvm
2652  * PreserveAll calling convention.
2653  */
2654 static void
2655 emit_init_icall_wrappers (MonoLLVMModule *module)
2656 {
2657         module->init_method = emit_init_icall_wrapper (module, "init_method", "mono_aot_init_llvm_method", 0);
2658         module->init_method_gshared_mrgctx = emit_init_icall_wrapper (module, "init_method_gshared_mrgctx", "mono_aot_init_gshared_method_mrgctx", 1);
2659         module->init_method_gshared_this = emit_init_icall_wrapper (module, "init_method_gshared_this", "mono_aot_init_gshared_method_this", 2);
2660         module->init_method_gshared_vtable = emit_init_icall_wrapper (module, "init_method_gshared_vtable", "mono_aot_init_gshared_method_vtable", 3);
2661 }
2662
2663 static void
2664 emit_llvm_code_end (MonoLLVMModule *module)
2665 {
2666         LLVMModuleRef lmodule = module->lmodule;
2667         LLVMValueRef func;
2668         LLVMBasicBlockRef entry_bb;
2669         LLVMBuilderRef builder;
2670
2671         func = LLVMAddFunction (lmodule, "llvm_code_end", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
2672         LLVMSetLinkage (func, LLVMInternalLinkage);
2673         LLVMAddFunctionAttr (func, LLVMNoUnwindAttribute);
2674         module->code_end = func;
2675         entry_bb = LLVMAppendBasicBlock (func, "ENTRY");
2676         builder = LLVMCreateBuilder ();
2677         LLVMPositionBuilderAtEnd (builder, entry_bb);
2678         LLVMBuildRetVoid (builder);
2679         LLVMDisposeBuilder (builder);
2680 }
2681
2682 static void
2683 emit_div_check (EmitContext *ctx, LLVMBuilderRef builder, MonoBasicBlock *bb, MonoInst *ins, LLVMValueRef lhs, LLVMValueRef rhs)
2684 {
2685         gboolean need_div_check = ctx->cfg->backend->need_div_check;
2686
2687         if (bb->region)
2688                 /* LLVM doesn't know that these can throw an exception since they are not called through an intrinsic */
2689                 need_div_check = TRUE;
2690
2691         if (!need_div_check)
2692                 return;
2693
2694         switch (ins->opcode) {
2695         case OP_IDIV:
2696         case OP_LDIV:
2697         case OP_IREM:
2698         case OP_LREM:
2699         case OP_IDIV_UN:
2700         case OP_LDIV_UN:
2701         case OP_IREM_UN:
2702         case OP_LREM_UN:
2703         case OP_IDIV_IMM:
2704         case OP_LDIV_IMM:
2705         case OP_IREM_IMM:
2706         case OP_LREM_IMM:
2707         case OP_IDIV_UN_IMM:
2708         case OP_LDIV_UN_IMM:
2709         case OP_IREM_UN_IMM:
2710         case OP_LREM_UN_IMM: {
2711                 LLVMValueRef cmp;
2712                 gboolean is_signed = (ins->opcode == OP_IDIV || ins->opcode == OP_LDIV || ins->opcode == OP_IREM || ins->opcode == OP_LREM ||
2713                                                           ins->opcode == OP_IDIV_IMM || ins->opcode == OP_LDIV_IMM || ins->opcode == OP_IREM_IMM || ins->opcode == OP_LREM_IMM);
2714
2715                 cmp = LLVMBuildICmp (builder, LLVMIntEQ, rhs, LLVMConstInt (LLVMTypeOf (rhs), 0, FALSE), "");
2716                 emit_cond_system_exception (ctx, bb, "DivideByZeroException", cmp);
2717                 if (!ctx_ok (ctx))
2718                         break;
2719                 builder = ctx->builder;
2720
2721                 /* b == -1 && a == 0x80000000 */
2722                 if (is_signed) {
2723                         LLVMValueRef c = (LLVMTypeOf (lhs) == LLVMInt32Type ()) ? LLVMConstInt (LLVMTypeOf (lhs), 0x80000000, FALSE) : LLVMConstInt (LLVMTypeOf (lhs), 0x8000000000000000LL, FALSE);
2724                         LLVMValueRef cond1 = LLVMBuildICmp (builder, LLVMIntEQ, rhs, LLVMConstInt (LLVMTypeOf (rhs), -1, FALSE), "");
2725                         LLVMValueRef cond2 = LLVMBuildICmp (builder, LLVMIntEQ, lhs, c, "");
2726
2727                         cmp = LLVMBuildICmp (builder, LLVMIntEQ, LLVMBuildAnd (builder, cond1, cond2, ""), LLVMConstInt (LLVMInt1Type (), 1, FALSE), "");
2728                         emit_cond_system_exception (ctx, bb, "OverflowException", cmp);
2729                         if (!ctx_ok (ctx))
2730                                 break;
2731                         builder = ctx->builder;
2732                 }
2733                 break;
2734         }
2735         default:
2736                 break;
2737         }
2738 }
2739
2740 /*
2741  * emit_init_method:
2742  *
2743  *   Emit code to initialize the GOT slots used by the method.
2744  */
2745 static void
2746 emit_init_method (EmitContext *ctx)
2747 {
2748         LLVMValueRef indexes [16], args [16], callee;
2749         LLVMValueRef inited_var, cmp, call;
2750         LLVMBasicBlockRef inited_bb, notinited_bb;
2751         LLVMBuilderRef builder = ctx->builder;
2752         MonoCompile *cfg = ctx->cfg;
2753
2754         ctx->module->max_inited_idx = MAX (ctx->module->max_inited_idx, cfg->method_index);
2755
2756         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
2757         indexes [1] = LLVMConstInt (LLVMInt32Type (), cfg->method_index, FALSE);
2758         inited_var = LLVMBuildLoad (builder, LLVMBuildGEP (builder, ctx->module->inited_var, indexes, 2, ""), "is_inited");
2759
2760         args [0] = inited_var;
2761         args [1] = LLVMConstInt (LLVMInt8Type (), 1, FALSE);
2762         inited_var = LLVMBuildCall (ctx->builder, get_intrinsic (ctx, "llvm.expect.i8"), args, 2, "");
2763
2764         cmp = LLVMBuildICmp (builder, LLVMIntEQ, inited_var, LLVMConstInt (LLVMTypeOf (inited_var), 0, FALSE), "");
2765
2766         inited_bb = ctx->inited_bb;
2767         notinited_bb = gen_bb (ctx, "NOTINITED_BB");
2768
2769         LLVMBuildCondBr (ctx->builder, cmp, notinited_bb, inited_bb);
2770
2771         builder = ctx->builder = create_builder (ctx);
2772         LLVMPositionBuilderAtEnd (ctx->builder, notinited_bb);
2773
2774         // FIXME: Cache
2775         if (ctx->rgctx_arg && cfg->method->is_inflated && mono_method_get_context (cfg->method)->method_inst) {
2776                 args [0] = LLVMConstInt (LLVMInt32Type (), cfg->method_index, 0);
2777                 args [1] = convert (ctx, ctx->rgctx_arg, IntPtrType ());
2778                 callee = ctx->module->init_method_gshared_mrgctx;
2779                 call = LLVMBuildCall (builder, callee, args, 2, "");
2780         } else if (ctx->rgctx_arg) {
2781                 /* A vtable is passed as the rgctx argument */
2782                 args [0] = LLVMConstInt (LLVMInt32Type (), cfg->method_index, 0);
2783                 args [1] = convert (ctx, ctx->rgctx_arg, IntPtrType ());
2784                 callee = ctx->module->init_method_gshared_vtable;
2785                 call = LLVMBuildCall (builder, callee, args, 2, "");
2786         } else if (cfg->gshared) {
2787                 args [0] = LLVMConstInt (LLVMInt32Type (), cfg->method_index, 0);
2788                 args [1] = convert (ctx, ctx->this_arg, ObjRefType ());
2789                 callee = ctx->module->init_method_gshared_this;
2790                 call = LLVMBuildCall (builder, callee, args, 2, "");
2791         } else {
2792                 args [0] = LLVMConstInt (LLVMInt32Type (), cfg->method_index, 0);
2793                 callee = ctx->module->init_method;
2794                 call = LLVMBuildCall (builder, callee, args, 1, "");
2795         }
2796
2797         /*
2798          * This enables llvm to keep arguments in their original registers/
2799          * scratch registers, since the call will not clobber them.
2800          */
2801         mono_llvm_set_call_preserveall_cc (call);
2802
2803         LLVMBuildBr (builder, inited_bb);
2804         ctx->bblocks [cfg->bb_entry->block_num].end_bblock = inited_bb;
2805
2806         builder = ctx->builder = create_builder (ctx);
2807         LLVMPositionBuilderAtEnd (ctx->builder, inited_bb);
2808 }
2809
2810 static void
2811 emit_unbox_tramp (EmitContext *ctx, const char *method_name, LLVMTypeRef method_type, LLVMValueRef method, int method_index)
2812 {
2813         /*
2814          * Emit unbox trampoline using a tail call
2815          */
2816         LLVMValueRef tramp, call, *args;
2817         LLVMBuilderRef builder;
2818         LLVMBasicBlockRef lbb;
2819         LLVMCallInfo *linfo;
2820         char *tramp_name;
2821         int i, nargs;
2822
2823         tramp_name = g_strdup_printf ("ut_%s", method_name);
2824         tramp = LLVMAddFunction (ctx->module->lmodule, tramp_name, method_type);
2825         LLVMSetLinkage (tramp, LLVMInternalLinkage);
2826         LLVMAddFunctionAttr (tramp, LLVMOptimizeForSizeAttribute);
2827         //LLVMAddFunctionAttr (tramp, LLVMNoUnwindAttribute);
2828         linfo = ctx->linfo;
2829         // FIXME: Reduce code duplication with mono_llvm_compile_method () etc.
2830         if (!ctx->llvm_only && ctx->rgctx_arg_pindex != -1)
2831                 LLVMAddAttribute (LLVMGetParam (tramp, ctx->rgctx_arg_pindex), LLVMInRegAttribute);
2832         if (ctx->cfg->vret_addr) {
2833                 LLVMSetValueName (LLVMGetParam (tramp, linfo->vret_arg_pindex), "vret");
2834                 if (linfo->ret.storage == LLVMArgVtypeByRef) {
2835                         LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMStructRetAttribute);
2836                         LLVMAddAttribute (LLVMGetParam (tramp, linfo->vret_arg_pindex), LLVMNoAliasAttribute);
2837                 }
2838         }
2839
2840         lbb = LLVMAppendBasicBlock (tramp, "");
2841         builder = LLVMCreateBuilder ();
2842         LLVMPositionBuilderAtEnd (builder, lbb);
2843
2844         nargs = LLVMCountParamTypes (method_type);
2845         args = g_new0 (LLVMValueRef, nargs);
2846         for (i = 0; i < nargs; ++i) {
2847                 args [i] = LLVMGetParam (tramp, i);
2848                 if (i == ctx->this_arg_pindex) {
2849                         LLVMTypeRef arg_type = LLVMTypeOf (args [i]);
2850
2851                         args [i] = LLVMBuildPtrToInt (builder, args [i], IntPtrType (), "");
2852                         args [i] = LLVMBuildAdd (builder, args [i], LLVMConstInt (IntPtrType (), sizeof (MonoObject), FALSE), "");
2853                         args [i] = LLVMBuildIntToPtr (builder, args [i], arg_type, "");
2854                 }
2855         }
2856         call = LLVMBuildCall (builder, method, args, nargs, "");
2857         if (!ctx->llvm_only && ctx->rgctx_arg_pindex != -1)
2858                 LLVMAddInstrAttribute (call, 1 + ctx->rgctx_arg_pindex, LLVMInRegAttribute);
2859         if (linfo->ret.storage == LLVMArgVtypeByRef)
2860                 LLVMAddInstrAttribute (call, 1 + linfo->vret_arg_pindex, LLVMStructRetAttribute);
2861
2862         // FIXME: This causes assertions in clang
2863         //mono_llvm_set_must_tail (call);
2864         if (LLVMGetReturnType (method_type) == LLVMVoidType ())
2865                 LLVMBuildRetVoid (builder);
2866         else
2867                 LLVMBuildRet (builder, call);
2868
2869         g_hash_table_insert (ctx->module->idx_to_unbox_tramp, GINT_TO_POINTER (method_index), tramp);
2870         LLVMDisposeBuilder (builder);
2871 }
2872
2873 /*
2874  * emit_entry_bb:
2875  *
2876  *   Emit code to load/convert arguments.
2877  */
2878 static void
2879 emit_entry_bb (EmitContext *ctx, LLVMBuilderRef builder)
2880 {
2881         int i, j, pindex;
2882         MonoCompile *cfg = ctx->cfg;
2883         MonoMethodSignature *sig = ctx->sig;
2884         LLVMCallInfo *linfo = ctx->linfo;
2885         MonoBasicBlock *bb;
2886         char **names;
2887
2888         LLVMBuilderRef old_builder = ctx->builder;
2889         ctx->builder = builder;
2890
2891         ctx->alloca_builder = create_builder (ctx);
2892
2893         /*
2894          * Handle indirect/volatile variables by allocating memory for them
2895          * using 'alloca', and storing their address in a temporary.
2896          */
2897         for (i = 0; i < cfg->num_varinfo; ++i) {
2898                 MonoInst *var = cfg->varinfo [i];
2899                 LLVMTypeRef vtype;
2900
2901                 if (var->opcode == OP_GSHAREDVT_LOCAL || var->opcode == OP_GSHAREDVT_ARG_REGOFFSET) {
2902                 } else if (var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) || (mini_type_is_vtype (var->inst_vtype) && !MONO_CLASS_IS_SIMD (ctx->cfg, var->klass))) {
2903                         vtype = type_to_llvm_type (ctx, var->inst_vtype);
2904                         if (!ctx_ok (ctx))
2905                                 return;
2906                         /* Could be already created by an OP_VPHI */
2907                         if (!ctx->addresses [var->dreg]) {
2908                                 ctx->addresses [var->dreg] = build_alloca (ctx, var->inst_vtype);
2909                                 //LLVMSetValueName (ctx->addresses [var->dreg], g_strdup_printf ("vreg_loc_%d", var->dreg));
2910                         }
2911                         ctx->vreg_cli_types [var->dreg] = var->inst_vtype;
2912                 }
2913         }
2914
2915         names = g_new (char *, sig->param_count);
2916         mono_method_get_param_names (cfg->method, (const char **) names);
2917
2918         for (i = 0; i < sig->param_count; ++i) {
2919                 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
2920                 int reg = cfg->args [i + sig->hasthis]->dreg;
2921                 char *name;
2922
2923                 pindex = ainfo->pindex;
2924
2925                 switch (ainfo->storage) {
2926                 case LLVMArgVtypeInReg:
2927                 case LLVMArgAsFpArgs: {
2928                         LLVMValueRef args [8];
2929                         int j;
2930
2931                         pindex += ainfo->ndummy_fpargs;
2932
2933                         /* The argument is received as a set of int/fp arguments, store them into the real argument */
2934                         memset (args, 0, sizeof (args));
2935                         if (ainfo->storage == LLVMArgVtypeInReg) {
2936                                 args [0] = LLVMGetParam (ctx->lmethod, pindex);
2937                                 if (ainfo->pair_storage [1] != LLVMArgNone)
2938                                         args [1] = LLVMGetParam (ctx->lmethod, pindex + 1);
2939                         } else {
2940                                 g_assert (ainfo->nslots <= 8);
2941                                 for (j = 0; j < ainfo->nslots; ++j)
2942                                         args [j] = LLVMGetParam (ctx->lmethod, pindex + j);
2943                         }
2944                         ctx->addresses [reg] = build_alloca (ctx, ainfo->type);
2945
2946                         emit_args_to_vtype (ctx, builder, ainfo->type, ctx->addresses [reg], ainfo, args);
2947
2948                         if (ainfo->storage == LLVMArgVtypeInReg && MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (ainfo->type))) {
2949                                 /* Treat these as normal values */
2950                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
2951                         }
2952                         break;
2953                 }
2954                 case LLVMArgVtypeByVal: {
2955                         ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, pindex);
2956
2957                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (ainfo->type))) {
2958                                 /* Treat these as normal values */
2959                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
2960                         }
2961                         break;
2962                 }
2963                 case LLVMArgVtypeByRef: {
2964                         /* The argument is passed by ref */
2965                         ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, pindex);
2966                         break;
2967                 }
2968                 case LLVMArgAsIArgs: {
2969                         LLVMValueRef arg = LLVMGetParam (ctx->lmethod, pindex);
2970                         int size;
2971
2972                         /* The argument is received as an array of ints, store it into the real argument */
2973                         ctx->addresses [reg] = build_alloca (ctx, ainfo->type);
2974
2975                         size = mono_class_value_size (mono_class_from_mono_type (ainfo->type), NULL);
2976                         if (size < SIZEOF_VOID_P) {
2977                                 /* The upper bits of the registers might not be valid */
2978                                 LLVMValueRef val = LLVMBuildExtractValue (builder, arg, 0, "");
2979                                 LLVMValueRef dest = convert (ctx, ctx->addresses [reg], LLVMPointerType (LLVMIntType (size * 8), 0));
2980                                 LLVMBuildStore (ctx->builder, LLVMBuildTrunc (builder, val, LLVMIntType (size * 8), ""), dest);
2981                         } else {
2982                                 LLVMBuildStore (ctx->builder, arg, convert (ctx, ctx->addresses [reg], LLVMPointerType (LLVMTypeOf (arg), 0)));
2983                         }
2984                         break;
2985                 }
2986                 case LLVMArgVtypeAsScalar:
2987                         g_assert_not_reached ();
2988                         break;
2989                 case LLVMArgGsharedvtFixed: {
2990                         /* These are non-gsharedvt arguments passed by ref, the rest of the IR treats them as scalars */
2991                         LLVMValueRef arg = LLVMGetParam (ctx->lmethod, pindex);
2992
2993                         if (names [i])
2994                                 name = g_strdup_printf ("arg_%s", names [i]);
2995                         else
2996                                 name = g_strdup_printf ("arg_%d", i);
2997
2998                         ctx->values [reg] = LLVMBuildLoad (builder, convert (ctx, arg, LLVMPointerType (type_to_llvm_type (ctx, ainfo->type), 0)), name);
2999                         break;
3000                 }
3001                 case LLVMArgGsharedvtFixedVtype: {
3002                         LLVMValueRef arg = LLVMGetParam (ctx->lmethod, pindex);
3003
3004                         if (names [i])
3005                                 name = g_strdup_printf ("vtype_arg_%s", names [i]);
3006                         else
3007                                 name = g_strdup_printf ("vtype_arg_%d", i);
3008
3009                         /* Non-gsharedvt vtype argument passed by ref, the rest of the IR treats it as a vtype */
3010                         g_assert (ctx->addresses [reg]);
3011                         LLVMSetValueName (ctx->addresses [reg], name);
3012                         LLVMBuildStore (builder, LLVMBuildLoad (builder, convert (ctx, arg, LLVMPointerType (type_to_llvm_type (ctx, ainfo->type), 0)), ""), ctx->addresses [reg]);
3013                         break;
3014                 }
3015                 case LLVMArgGsharedvtVariable:
3016                         /* The IR treats these as variables with addresses */
3017                         ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, pindex);
3018                         break;
3019                 default:
3020                         ctx->values [reg] = convert_full (ctx, ctx->values [reg], llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, ainfo->type)), type_is_unsigned (ctx, ainfo->type));
3021                         break;
3022                 }
3023         }
3024         g_free (names);
3025
3026         if (cfg->vret_addr)
3027                 emit_volatile_store (ctx, cfg->vret_addr->dreg);
3028         if (sig->hasthis)
3029                 emit_volatile_store (ctx, cfg->args [0]->dreg);
3030         for (i = 0; i < sig->param_count; ++i)
3031                 if (!mini_type_is_vtype (sig->params [i]))
3032                         emit_volatile_store (ctx, cfg->args [i + sig->hasthis]->dreg);
3033
3034         if (sig->hasthis && !cfg->rgctx_var && cfg->gshared) {
3035                 LLVMValueRef this_alloc;
3036
3037                 /*
3038                  * The exception handling code needs the location where the this argument was
3039                  * stored for gshared methods. We create a separate alloca to hold it, and mark it
3040                  * with the "mono.this" custom metadata to tell llvm that it needs to save its
3041                  * location into the LSDA.
3042                  */
3043                 this_alloc = mono_llvm_build_alloca (builder, ThisType (), LLVMConstInt (LLVMInt32Type (), 1, FALSE), 0, "");
3044                 /* This volatile store will keep the alloca alive */
3045                 mono_llvm_build_store (builder, ctx->values [cfg->args [0]->dreg], this_alloc, TRUE, LLVM_BARRIER_NONE);
3046
3047                 set_metadata_flag (this_alloc, "mono.this");
3048         }
3049
3050         if (cfg->rgctx_var) {
3051                 LLVMValueRef rgctx_alloc, store;
3052
3053                 /*
3054                  * We handle the rgctx arg similarly to the this pointer.
3055                  */
3056                 g_assert (ctx->addresses [cfg->rgctx_var->dreg]);
3057                 rgctx_alloc = ctx->addresses [cfg->rgctx_var->dreg];
3058                 /* This volatile store will keep the alloca alive */
3059                 store = mono_llvm_build_store (builder, convert (ctx, ctx->rgctx_arg, IntPtrType ()), rgctx_alloc, TRUE, LLVM_BARRIER_NONE);
3060
3061                 set_metadata_flag (rgctx_alloc, "mono.this");
3062         }
3063
3064         /* Initialize the method if needed */
3065         if (cfg->compile_aot && ctx->llvm_only) {
3066                 /* Emit a location for the initialization code */
3067                 ctx->init_bb = gen_bb (ctx, "INIT_BB");
3068                 ctx->inited_bb = gen_bb (ctx, "INITED_BB");
3069
3070                 LLVMBuildBr (ctx->builder, ctx->init_bb);
3071                 builder = ctx->builder = create_builder (ctx);
3072                 LLVMPositionBuilderAtEnd (ctx->builder, ctx->inited_bb);
3073                 ctx->bblocks [cfg->bb_entry->block_num].end_bblock = ctx->inited_bb;
3074         }
3075
3076         /* Compute nesting between clauses */
3077         ctx->nested_in = (GSList**)mono_mempool_alloc0 (cfg->mempool, sizeof (GSList*) * cfg->header->num_clauses);
3078         for (i = 0; i < cfg->header->num_clauses; ++i) {
3079                 for (j = 0; j < cfg->header->num_clauses; ++j) {
3080                         MonoExceptionClause *clause1 = &cfg->header->clauses [i];
3081                         MonoExceptionClause *clause2 = &cfg->header->clauses [j];
3082
3083                         if (i != j && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset)
3084                                 ctx->nested_in [i] = g_slist_prepend_mempool (cfg->mempool, ctx->nested_in [i], GINT_TO_POINTER (j));
3085                 }
3086         }
3087
3088         /*
3089          * For finally clauses, create an indicator variable telling OP_ENDFINALLY whenever
3090          * it needs to continue normally, or return back to the exception handling system.
3091          */
3092         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
3093                 int clause_index;
3094                 char name [128];
3095
3096                 if (!(bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER)))
3097                         continue;
3098
3099                 clause_index = MONO_REGION_CLAUSE_INDEX (bb->region);
3100                 g_hash_table_insert (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)), bb);
3101                 g_hash_table_insert (ctx->clause_to_handler, GINT_TO_POINTER (clause_index), bb);
3102
3103                 if (bb->in_scount == 0) {
3104                         LLVMValueRef val;
3105
3106                         sprintf (name, "finally_ind_bb%d", bb->block_num);
3107                         val = LLVMBuildAlloca (builder, LLVMInt32Type (), name);
3108                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), val);
3109
3110                         ctx->bblocks [bb->block_num].finally_ind = val;
3111                 } else {
3112                         /* Create a variable to hold the exception var */
3113                         if (!ctx->ex_var)
3114                                 ctx->ex_var = LLVMBuildAlloca (builder, ObjRefType (), "exvar");
3115                 }
3116
3117                 /*
3118                  * Create a new bblock which CALL_HANDLER/landing pads can branch to, because branching to the
3119                  * LLVM bblock containing a landing pad causes problems for the
3120                  * LLVM optimizer passes.
3121                  */
3122                 sprintf (name, "BB%d_CALL_HANDLER_TARGET", bb->block_num);
3123                 ctx->bblocks [bb->block_num].call_handler_target_bb = LLVMAppendBasicBlock (ctx->lmethod, name);
3124         }
3125         ctx->builder = old_builder;
3126 }
3127
3128 static void
3129 process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, MonoInst *ins)
3130 {
3131         MonoCompile *cfg = ctx->cfg;
3132         LLVMValueRef *values = ctx->values;
3133         LLVMValueRef *addresses = ctx->addresses;
3134         MonoCallInst *call = (MonoCallInst*)ins;
3135         MonoMethodSignature *sig = call->signature;
3136         LLVMValueRef callee = NULL, lcall;
3137         LLVMValueRef *args;
3138         LLVMCallInfo *cinfo;
3139         GSList *l;
3140         int i, len, nargs;
3141         gboolean vretaddr;
3142         LLVMTypeRef llvm_sig;
3143         gpointer target;
3144         gboolean is_virtual, calli, preserveall;
3145         LLVMBuilderRef builder = *builder_ref;
3146
3147         if ((call->signature->call_convention != MONO_CALL_DEFAULT) && !((call->signature->call_convention == MONO_CALL_C) && ctx->llvm_only)) {
3148                 set_failure (ctx, "non-default callconv");
3149                 return;
3150         }
3151
3152         cinfo = call->cinfo;
3153         g_assert (cinfo);
3154         if (call->rgctx_arg_reg)
3155                 cinfo->rgctx_arg = TRUE;
3156         if (call->imt_arg_reg)
3157                 cinfo->imt_arg = TRUE;
3158
3159         vretaddr = (cinfo->ret.storage == LLVMArgVtypeRetAddr || cinfo->ret.storage == LLVMArgVtypeByRef || cinfo->ret.storage == LLVMArgGsharedvtFixed || cinfo->ret.storage == LLVMArgGsharedvtVariable || cinfo->ret.storage == LLVMArgGsharedvtFixedVtype);
3160
3161         llvm_sig = sig_to_llvm_sig_full (ctx, sig, cinfo);
3162         if (!ctx_ok (ctx))
3163                 return;
3164
3165         is_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 || ins->opcode == OP_RCALL_MEMBASE);
3166         calli = !call->fptr_is_patch && (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 || ins->opcode == OP_RCALL_REG);
3167         /* Unused */
3168         preserveall = FALSE;
3169
3170         /* FIXME: Avoid creating duplicate methods */
3171
3172         if (ins->flags & MONO_INST_HAS_METHOD) {
3173                 if (is_virtual) {
3174                         callee = NULL;
3175                 } else {
3176                         if (cfg->compile_aot) {
3177                                 callee = get_callee (ctx, llvm_sig, MONO_PATCH_INFO_METHOD, call->method);
3178                                 if (!callee) {
3179                                         set_failure (ctx, "can't encode patch");
3180                                         return;
3181                                 }
3182                                 if (cfg->llvm_only && call->method->klass->image->assembly == ctx->module->assembly) {
3183                                         /*
3184                                          * Collect instructions representing the callee into a hash so they can be replaced
3185                                          * by the llvm method for the callee if the callee turns out to be direct
3186                                          * callable. Currently this only requires it to not fail llvm compilation.
3187                                          */
3188                                         GSList *l = (GSList*)g_hash_table_lookup (ctx->method_to_callers, call->method);
3189                                         l = g_slist_prepend (l, callee);
3190                                         g_hash_table_insert (ctx->method_to_callers, call->method, l);
3191                                 }
3192                         } else {
3193                                 MonoError error;
3194                                 static int tramp_index;
3195                                 char *name;
3196
3197                                 name = g_strdup_printf ("tramp_%d", tramp_index);
3198                                 tramp_index ++;
3199
3200 #if LLVM_API_VERSION > 100
3201                                 /*
3202                                  * Use our trampoline infrastructure for lazy compilation instead of llvm's.
3203                                  * Make all calls through a global. The address of the global will be saved in
3204                                  * MonoJitDomainInfo.llvm_jit_callees and updated when the method it refers to is
3205                                  * compiled.
3206                                  */
3207                                 LLVMValueRef tramp_var = g_hash_table_lookup (ctx->jit_callees, call->method);
3208                                 if (!tramp_var) {
3209                                         target =
3210                                                 mono_create_jit_trampoline (mono_domain_get (),
3211                                                                                                         call->method, &error);
3212                                         if (!is_ok (&error)) {
3213                                                 set_failure (ctx, mono_error_get_message (&error));
3214                                                 mono_error_cleanup (&error);
3215                                                 return;
3216                                         }
3217
3218                                         tramp_var = LLVMAddGlobal (ctx->lmodule, LLVMPointerType (llvm_sig, 0), name);
3219                                         LLVMSetInitializer (tramp_var, LLVMConstIntToPtr (LLVMConstInt (LLVMInt64Type (), (guint64)(size_t)target, FALSE), LLVMPointerType (llvm_sig, 0)));
3220                                         LLVMSetLinkage (tramp_var, LLVMExternalLinkage);
3221                                         g_hash_table_insert (ctx->jit_callees, call->method, tramp_var);
3222                                 }
3223                                 callee = LLVMBuildLoad (builder, tramp_var, "");
3224 #else
3225                                 target =
3226                                         mono_create_jit_trampoline (mono_domain_get (),
3227                                                                     call->method, &error);
3228                                 if (!is_ok (&error)) {
3229                                         g_free (name);
3230                                         set_failure (ctx, mono_error_get_message (&error));
3231                                         mono_error_cleanup (&error);
3232                                         return;
3233                                 }
3234
3235                                 callee = LLVMAddFunction (ctx->lmodule, name, llvm_sig);
3236                                 g_free (name);
3237
3238                                 LLVMAddGlobalMapping (ctx->module->ee, callee, target);
3239 #endif
3240                         }
3241                 }
3242
3243                 if (!cfg->llvm_only && call->method && strstr (call->method->klass->name, "AsyncVoidMethodBuilder")) {
3244                         /* LLVM miscompiles async methods */
3245                         set_failure (ctx, "#13734");
3246                         return;
3247                 }
3248         } else if (calli) {
3249         } else {
3250                 MonoJitICallInfo *info = mono_find_jit_icall_by_addr (call->fptr);
3251
3252                 if (info) {
3253                         /*
3254                           MonoJumpInfo ji;
3255
3256                           memset (&ji, 0, sizeof (ji));
3257                           ji.type = MONO_PATCH_INFO_JIT_ICALL_ADDR;
3258                           ji.data.target = info->name;
3259
3260                           target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
3261                         */
3262                         if (cfg->compile_aot) {
3263                                 callee = get_callee (ctx, llvm_sig, MONO_PATCH_INFO_INTERNAL_METHOD, (char*)info->name);
3264                                 if (!callee) {
3265                                         set_failure (ctx, "can't encode patch");
3266                                         return;
3267                                 }
3268                         } else {
3269                                 target = (gpointer)mono_icall_get_wrapper (info);
3270                                 callee = emit_jit_callee (ctx, "", llvm_sig, target);
3271                         }
3272                 } else {
3273                         if (cfg->compile_aot) {
3274                                 callee = NULL;
3275                                 if (cfg->abs_patches) {
3276                                         MonoJumpInfo *abs_ji = (MonoJumpInfo*)g_hash_table_lookup (cfg->abs_patches, call->fptr);
3277                                         if (abs_ji) {
3278                                                 callee = get_callee (ctx, llvm_sig, abs_ji->type, abs_ji->data.target);
3279                                                 if (!callee) {
3280                                                         set_failure (ctx, "can't encode patch");
3281                                                         return;
3282                                                 }
3283                                         }
3284                                 }
3285                                 if (!callee) {
3286                                         set_failure (ctx, "aot");
3287                                         return;
3288                                 }
3289                         } else {
3290 #if LLVM_API_VERSION > 100
3291                                 if (cfg->abs_patches) {
3292                                         MonoJumpInfo *abs_ji = (MonoJumpInfo*)g_hash_table_lookup (cfg->abs_patches, call->fptr);
3293                                         if (abs_ji) {
3294                                                 MonoError error;
3295
3296                                                 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, abs_ji, FALSE, &error);
3297                                                 mono_error_assert_ok (&error);
3298                                                 callee = emit_jit_callee (ctx, "", llvm_sig, target);
3299                                         } else {
3300                                                 g_assert_not_reached ();
3301                                         }
3302                                 } else {
3303                                         g_assert_not_reached ();
3304                                 }
3305 #else
3306                                 callee = LLVMAddFunction (ctx->lmodule, "", llvm_sig);
3307                                 target = NULL;
3308                                 if (cfg->abs_patches) {
3309                                         MonoJumpInfo *abs_ji = (MonoJumpInfo*)g_hash_table_lookup (cfg->abs_patches, call->fptr);
3310                                         if (abs_ji) {
3311                                                 MonoError error;
3312
3313                                                 /*
3314                                                  * FIXME: Some trampolines might have
3315                                                  * their own calling convention on some platforms.
3316                                                  */
3317                                                 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, abs_ji, FALSE, &error);
3318                                                 mono_error_assert_ok (&error);
3319                                                 LLVMAddGlobalMapping (ctx->module->ee, callee, target);
3320                                         }
3321                                 }
3322                                 if (!target)
3323                                         LLVMAddGlobalMapping (ctx->module->ee, callee, (gpointer)call->fptr);
3324 #endif
3325                         }
3326                 }
3327         }
3328
3329         if (is_virtual) {
3330                 int size = sizeof (gpointer);
3331                 LLVMValueRef index;
3332
3333                 g_assert (ins->inst_offset % size == 0);
3334                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3335
3336                 callee = convert (ctx, LLVMBuildLoad (builder, LLVMBuildGEP (builder, convert (ctx, values [ins->inst_basereg], LLVMPointerType (LLVMPointerType (IntPtrType (), 0), 0)), &index, 1, ""), ""), LLVMPointerType (llvm_sig, 0));
3337         } else if (calli) {
3338                 callee = convert (ctx, values [ins->sreg1], LLVMPointerType (llvm_sig, 0));
3339         } else {
3340                 if (ins->flags & MONO_INST_HAS_METHOD) {
3341                 }
3342         }
3343
3344         /*
3345          * Collect and convert arguments
3346          */
3347         nargs = (sig->param_count * 16) + sig->hasthis + vretaddr + call->rgctx_reg + call->imt_arg_reg;
3348         len = sizeof (LLVMValueRef) * nargs;
3349         args = (LLVMValueRef*)alloca (len);
3350         memset (args, 0, len);
3351         l = call->out_ireg_args;
3352
3353         if (call->rgctx_arg_reg) {
3354                 g_assert (values [call->rgctx_arg_reg]);
3355                 g_assert (cinfo->rgctx_arg_pindex < nargs);
3356                 /*
3357                  * On ARM, the imt/rgctx argument is passed in a caller save register, but some of our trampolines etc. clobber it, leading to
3358                  * problems is LLVM moves the arg assignment earlier. To work around this, save the argument into a stack slot and load
3359                  * it using a volatile load.
3360                  */
3361 #ifdef TARGET_ARM
3362                 if (!ctx->imt_rgctx_loc)
3363                         ctx->imt_rgctx_loc = build_alloca_llvm_type (ctx, ctx->module->ptr_type, sizeof (gpointer));
3364                 LLVMBuildStore (builder, convert (ctx, ctx->values [call->rgctx_arg_reg], ctx->module->ptr_type), ctx->imt_rgctx_loc);
3365                 args [cinfo->rgctx_arg_pindex] = mono_llvm_build_load (builder, ctx->imt_rgctx_loc, "", TRUE);
3366 #else
3367                 args [cinfo->rgctx_arg_pindex] = convert (ctx, values [call->rgctx_arg_reg], ctx->module->ptr_type);
3368 #endif
3369         }
3370         if (call->imt_arg_reg) {
3371                 g_assert (!ctx->llvm_only);
3372                 g_assert (values [call->imt_arg_reg]);
3373                 g_assert (cinfo->imt_arg_pindex < nargs);
3374 #ifdef TARGET_ARM
3375                 if (!ctx->imt_rgctx_loc)
3376                         ctx->imt_rgctx_loc = build_alloca_llvm_type (ctx, ctx->module->ptr_type, sizeof (gpointer));
3377                 LLVMBuildStore (builder, convert (ctx, ctx->values [call->imt_arg_reg], ctx->module->ptr_type), ctx->imt_rgctx_loc);
3378                 args [cinfo->imt_arg_pindex] = mono_llvm_build_load (builder, ctx->imt_rgctx_loc, "", TRUE);
3379 #else
3380                 args [cinfo->imt_arg_pindex] = convert (ctx, values [call->imt_arg_reg], ctx->module->ptr_type);
3381 #endif
3382         }
3383         switch (cinfo->ret.storage) {
3384         case LLVMArgGsharedvtVariable: {
3385                 MonoInst *var = get_vreg_to_inst (cfg, call->inst.dreg);
3386
3387                 if (var && var->opcode == OP_GSHAREDVT_LOCAL) {
3388                         args [cinfo->vret_arg_pindex] = convert (ctx, emit_gsharedvt_ldaddr (ctx, var->dreg), IntPtrType ());
3389                 } else {
3390                         g_assert (addresses [call->inst.dreg]);
3391                         args [cinfo->vret_arg_pindex] = addresses [call->inst.dreg];
3392                 }
3393                 break;
3394         }
3395         default:
3396                 if (vretaddr) {
3397                         if (!addresses [call->inst.dreg])
3398                                 addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
3399                         g_assert (cinfo->vret_arg_pindex < nargs);
3400                         if (cinfo->ret.storage == LLVMArgVtypeByRef)
3401                                 args [cinfo->vret_arg_pindex] = addresses [call->inst.dreg];
3402                         else
3403                                 args [cinfo->vret_arg_pindex] = LLVMBuildPtrToInt (builder, addresses [call->inst.dreg], IntPtrType (), "");
3404                 }
3405                 break;
3406         }
3407
3408         /*
3409          * Sometimes the same method is called with two different signatures (i.e. with and without 'this'), so
3410          * use the real callee for argument type conversion.
3411          */
3412         LLVMTypeRef callee_type = LLVMGetElementType (LLVMTypeOf (callee));
3413         LLVMTypeRef *param_types = (LLVMTypeRef*)g_alloca (sizeof (LLVMTypeRef) * LLVMCountParamTypes (callee_type));
3414         LLVMGetParamTypes (callee_type, param_types);
3415
3416         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
3417                 guint32 regpair;
3418                 int reg, pindex;
3419                 LLVMArgInfo *ainfo = &call->cinfo->args [i];
3420
3421                 pindex = ainfo->pindex;
3422
3423                 regpair = (guint32)(gssize)(l->data);
3424                 reg = regpair & 0xffffff;
3425                 args [pindex] = values [reg];
3426                 switch (ainfo->storage) {
3427                 case LLVMArgVtypeInReg:
3428                 case LLVMArgAsFpArgs: {
3429                         guint32 nargs;
3430                         int j;
3431
3432                         for (j = 0; j < ainfo->ndummy_fpargs; ++j)
3433                                 args [pindex + j] = LLVMConstNull (LLVMDoubleType ());
3434                         pindex += ainfo->ndummy_fpargs;
3435
3436                         g_assert (addresses [reg]);
3437                         emit_vtype_to_args (ctx, builder, ainfo->type, addresses [reg], ainfo, args + pindex, &nargs);
3438                         pindex += nargs;
3439
3440                         // FIXME: alignment
3441                         // FIXME: Get rid of the VMOVE
3442                         break;
3443                 }
3444                 case LLVMArgVtypeByVal:
3445                         g_assert (addresses [reg]);
3446                         args [pindex] = addresses [reg];
3447                         break;
3448                 case LLVMArgVtypeByRef: {
3449                         g_assert (addresses [reg]);
3450                         args [pindex] = convert (ctx, addresses [reg], LLVMPointerType (type_to_llvm_arg_type (ctx, ainfo->type), 0));
3451                         break;
3452                 }
3453                 case LLVMArgAsIArgs:
3454                         g_assert (addresses [reg]);
3455                         args [pindex] = LLVMBuildLoad (ctx->builder, convert (ctx, addresses [reg], LLVMPointerType (LLVMArrayType (IntPtrType (), ainfo->nslots), 0)), "");
3456                         break;
3457                 case LLVMArgVtypeAsScalar:
3458                         g_assert_not_reached ();
3459                         break;
3460                 case LLVMArgGsharedvtFixed:
3461                 case LLVMArgGsharedvtFixedVtype:
3462                         g_assert (addresses [reg]);
3463                         args [pindex] = convert (ctx, addresses [reg], LLVMPointerType (type_to_llvm_arg_type (ctx, ainfo->type), 0));
3464                         break;
3465                 case LLVMArgGsharedvtVariable:
3466                         g_assert (addresses [reg]);
3467                         args [pindex] = convert (ctx, addresses [reg], LLVMPointerType (IntPtrType (), 0));
3468                         break;
3469                 default:
3470                         g_assert (args [pindex]);
3471                         if (i == 0 && sig->hasthis)
3472                                 args [pindex] = convert (ctx, args [pindex], param_types [pindex]);
3473                         else
3474                                 args [pindex] = convert (ctx, args [pindex], type_to_llvm_arg_type (ctx, ainfo->type));
3475                         break;
3476                 }
3477                 g_assert (pindex <= nargs);
3478
3479                 l = l->next;
3480         }
3481
3482         // FIXME: Align call sites
3483
3484         /*
3485          * Emit the call
3486          */
3487
3488         lcall = emit_call (ctx, bb, &builder, callee, args, LLVMCountParamTypes (llvm_sig));
3489
3490         if (ins->opcode != OP_TAILCALL && LLVMGetInstructionOpcode (lcall) == LLVMCall)
3491                 mono_llvm_set_call_notail (lcall);
3492
3493         /*
3494          * Modify cconv and parameter attributes to pass rgctx/imt correctly.
3495          */
3496 #if defined(MONO_ARCH_IMT_REG) && defined(MONO_ARCH_RGCTX_REG)
3497         g_assert (MONO_ARCH_IMT_REG == MONO_ARCH_RGCTX_REG);
3498 #endif
3499         /* The two can't be used together, so use only one LLVM calling conv to pass them */
3500         g_assert (!(call->rgctx_arg_reg && call->imt_arg_reg));
3501         if (!sig->pinvoke && !cfg->llvm_only)
3502                 LLVMSetInstructionCallConv (lcall, LLVMMono1CallConv);
3503         if (preserveall)
3504                 mono_llvm_set_call_preserveall_cc (lcall);
3505
3506         if (cinfo->ret.storage == LLVMArgVtypeByRef)
3507                 LLVMAddInstrAttribute (lcall, 1 + cinfo->vret_arg_pindex, LLVMStructRetAttribute);
3508         if (!ctx->llvm_only && call->rgctx_arg_reg)
3509                 LLVMAddInstrAttribute (lcall, 1 + cinfo->rgctx_arg_pindex, LLVMInRegAttribute);
3510         if (call->imt_arg_reg)
3511                 LLVMAddInstrAttribute (lcall, 1 + cinfo->imt_arg_pindex, LLVMInRegAttribute);
3512
3513         /* Add byval attributes if needed */
3514         for (i = 0; i < sig->param_count; ++i) {
3515                 LLVMArgInfo *ainfo = &call->cinfo->args [i + sig->hasthis];
3516
3517                 if (ainfo && ainfo->storage == LLVMArgVtypeByVal)
3518                         LLVMAddInstrAttribute (lcall, 1 + ainfo->pindex, LLVMByValAttribute);
3519         }
3520
3521         /*
3522          * Convert the result
3523          */
3524         switch (cinfo->ret.storage) {
3525         case LLVMArgVtypeInReg: {
3526                 LLVMValueRef regs [2];
3527
3528                 if (LLVMTypeOf (lcall) == LLVMVoidType ())
3529                         /* Empty struct */
3530                         break;
3531
3532                 if (!addresses [ins->dreg])
3533                         addresses [ins->dreg] = build_alloca (ctx, sig->ret);
3534
3535                 regs [0] = LLVMBuildExtractValue (builder, lcall, 0, "");
3536                 if (cinfo->ret.pair_storage [1] != LLVMArgNone)
3537                         regs [1] = LLVMBuildExtractValue (builder, lcall, 1, "");
3538                 emit_args_to_vtype (ctx, builder, sig->ret, addresses [ins->dreg], &cinfo->ret, regs);
3539                 break;
3540         }
3541         case LLVMArgVtypeByVal:
3542                 if (!addresses [call->inst.dreg])
3543                         addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
3544                 LLVMBuildStore (builder, lcall, addresses [call->inst.dreg]);
3545                 break;
3546         case LLVMArgAsIArgs:
3547         case LLVMArgFpStruct:
3548                 if (!addresses [call->inst.dreg])
3549                         addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
3550                 LLVMBuildStore (builder, lcall, convert_full (ctx, addresses [call->inst.dreg], LLVMPointerType (LLVMTypeOf (lcall), 0), FALSE));
3551                 break;
3552         case LLVMArgVtypeAsScalar:
3553                 if (!addresses [call->inst.dreg])
3554                         addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
3555                 LLVMBuildStore (builder, lcall, convert_full (ctx, addresses [call->inst.dreg], LLVMPointerType (LLVMTypeOf (lcall), 0), FALSE));
3556                 break;
3557         case LLVMArgVtypeRetAddr:
3558         case LLVMArgVtypeByRef:
3559                 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->ret))) {
3560                         /* Some opcodes like STOREX_MEMBASE access these by value */
3561                         g_assert (addresses [call->inst.dreg]);
3562                         values [ins->dreg] = LLVMBuildLoad (builder, convert_full (ctx, addresses [call->inst.dreg], LLVMPointerType (type_to_llvm_type (ctx, sig->ret), 0), FALSE), "");
3563                 }
3564                 break;
3565         case LLVMArgGsharedvtVariable:
3566                 break;
3567         case LLVMArgGsharedvtFixed:
3568         case LLVMArgGsharedvtFixedVtype:
3569                 values [ins->dreg] = LLVMBuildLoad (builder, convert_full (ctx, addresses [call->inst.dreg], LLVMPointerType (type_to_llvm_type (ctx, sig->ret), 0), FALSE), "");
3570                 break;
3571         default:
3572                 if (sig->ret->type != MONO_TYPE_VOID)
3573                         /* If the method returns an unsigned value, need to zext it */
3574                         values [ins->dreg] = convert_full (ctx, lcall, llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, sig->ret)), type_is_unsigned (ctx, sig->ret));
3575                 break;
3576         }
3577
3578         *builder_ref = ctx->builder;
3579 }
3580
3581 static void
3582 emit_llvmonly_throw (EmitContext *ctx, MonoBasicBlock *bb, gboolean rethrow, LLVMValueRef exc)
3583 {
3584         const char *icall_name = rethrow ? "mono_llvm_rethrow_exception" : "mono_llvm_throw_exception";
3585         LLVMValueRef callee = rethrow ? ctx->module->rethrow : ctx->module->throw_icall;
3586
3587         LLVMTypeRef exc_type = type_to_llvm_type (ctx, &mono_get_exception_class ()->byval_arg);
3588
3589         if (!callee) {
3590                 LLVMTypeRef fun_sig = LLVMFunctionType1 (LLVMVoidType (), exc_type, FALSE);
3591
3592                 if (ctx->cfg->compile_aot) {
3593                         callee = get_callee (ctx, fun_sig, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
3594                 } else {
3595                         callee = LLVMAddFunction (ctx->lmodule, icall_name, fun_sig);
3596                         LLVMAddGlobalMapping (ctx->module->ee, callee, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
3597                         mono_memory_barrier ();
3598
3599                         if (rethrow)
3600                                 ctx->module->rethrow = callee;
3601                         else
3602                                 ctx->module->throw_icall = callee;
3603                 }
3604         }
3605
3606         LLVMValueRef args [2];
3607
3608         args [0] = convert (ctx, exc, exc_type);
3609         emit_call (ctx, bb, &ctx->builder, callee, args, 1);
3610
3611         LLVMBuildUnreachable (ctx->builder);
3612
3613         ctx->builder = create_builder (ctx);
3614 }
3615
3616 static void
3617 emit_throw (EmitContext *ctx, MonoBasicBlock *bb, gboolean rethrow, LLVMValueRef exc)
3618 {
3619         MonoMethodSignature *throw_sig;
3620         LLVMValueRef callee, arg;
3621         const char *icall_name;
3622
3623         callee = rethrow ? ctx->module->rethrow : ctx->module->throw_icall;
3624         icall_name = rethrow ? "mono_arch_rethrow_exception" : "mono_arch_throw_exception";
3625
3626         if (!callee) {
3627                 throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
3628                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
3629                 throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
3630                 if (ctx->cfg->compile_aot) {
3631                         callee = get_callee (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3632                 } else {
3633                         gpointer target;
3634 #ifdef TARGET_X86
3635                         /*
3636                          * LLVM doesn't push the exception argument, so we need a different
3637                          * trampoline.
3638                          */
3639                         target = resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, rethrow ? "llvm_rethrow_exception_trampoline" : "llvm_throw_exception_trampoline");
3640 #else
3641                         target = resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3642 #endif
3643                         callee = emit_jit_callee (ctx, icall_name, sig_to_llvm_sig (ctx, throw_sig), target);
3644                 }
3645
3646                 mono_memory_barrier ();
3647 #if LLVM_API_VERSION < 100
3648                 if (rethrow)
3649                         ctx->module->rethrow = callee;
3650                 else
3651                         ctx->module->throw_icall = callee;
3652 #endif
3653         }
3654         arg = convert (ctx, exc, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
3655         emit_call (ctx, bb, &ctx->builder, callee, &arg, 1);
3656 }
3657
3658 static void
3659 emit_resume_eh (EmitContext *ctx, MonoBasicBlock *bb)
3660 {
3661         const char *icall_name = "mono_llvm_resume_exception";
3662         LLVMValueRef callee = ctx->module->resume_eh;
3663
3664         LLVMTypeRef fun_sig = LLVMFunctionType0 (LLVMVoidType (), FALSE);
3665
3666         if (!callee) {
3667                 if (ctx->cfg->compile_aot) {
3668                         callee = get_callee (ctx, fun_sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3669                 } else {
3670                         callee = LLVMAddFunction (ctx->lmodule, icall_name, fun_sig);
3671                         LLVMAddGlobalMapping (ctx->module->ee, callee, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
3672                         mono_memory_barrier ();
3673
3674                         ctx->module->resume_eh = callee;
3675                 }
3676         }
3677
3678         emit_call (ctx, bb, &ctx->builder, callee, NULL, 0);
3679
3680         LLVMBuildUnreachable (ctx->builder);
3681
3682         ctx->builder = create_builder (ctx);
3683 }
3684
3685 static LLVMValueRef
3686 mono_llvm_emit_clear_exception_call (EmitContext *ctx, LLVMBuilderRef builder)
3687 {
3688         const char *icall_name = "mono_llvm_clear_exception";
3689
3690         LLVMTypeRef call_sig = LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE);
3691         LLVMValueRef callee = NULL;
3692
3693         if (!callee) {
3694                 if (ctx->cfg->compile_aot) {
3695                         callee = get_callee (ctx, call_sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3696                 } else {
3697                         // FIXME: This is broken.
3698                         callee = LLVMAddFunction (ctx->lmodule, icall_name, call_sig);
3699                 }
3700         }
3701
3702         g_assert (builder && callee);
3703
3704         return LLVMBuildCall (builder, callee, NULL, 0, "");
3705 }
3706
3707 static LLVMValueRef
3708 mono_llvm_emit_load_exception_call (EmitContext *ctx, LLVMBuilderRef builder)
3709 {
3710         const char *icall_name = "mono_llvm_load_exception";
3711
3712         LLVMTypeRef call_sig = LLVMFunctionType (ObjRefType (), NULL, 0, FALSE);
3713         LLVMValueRef callee = NULL;
3714
3715         if (!callee) {
3716                 if (ctx->cfg->compile_aot) {
3717                         callee = get_callee (ctx, call_sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3718                 } else {
3719                         // FIXME: This is broken.
3720                         callee = LLVMAddFunction (ctx->lmodule, icall_name, call_sig);
3721                 }
3722         }
3723
3724         g_assert (builder && callee);
3725
3726         return LLVMBuildCall (builder, callee, NULL, 0, icall_name);
3727 }
3728
3729
3730 static LLVMValueRef
3731 mono_llvm_emit_match_exception_call (EmitContext *ctx, LLVMBuilderRef builder, gint32 region_start, gint32 region_end)
3732 {
3733         const char *icall_name = "mono_llvm_match_exception";
3734
3735         ctx->builder = builder;
3736
3737         const int num_args = 5;
3738         LLVMValueRef args [num_args];
3739         args [0] = convert (ctx, get_aotconst (ctx, MONO_PATCH_INFO_AOT_JIT_INFO, GINT_TO_POINTER (ctx->cfg->method_index)), IntPtrType ());
3740         args [1] = LLVMConstInt (LLVMInt32Type (), region_start, 0);
3741         args [2] = LLVMConstInt (LLVMInt32Type (), region_end, 0);
3742         if (ctx->cfg->rgctx_var) {
3743                 LLVMValueRef rgctx_alloc = ctx->addresses [ctx->cfg->rgctx_var->dreg];
3744                 g_assert (rgctx_alloc);
3745                 args [3] = LLVMBuildLoad (builder, convert (ctx, rgctx_alloc, LLVMPointerType (IntPtrType (), 0)), "");
3746         } else {
3747                 args [3] = LLVMConstInt (IntPtrType (), 0, 0);
3748         }
3749         if (ctx->this_arg)
3750                 args [4] = convert (ctx, ctx->this_arg, IntPtrType ());
3751         else
3752                 args [4] = LLVMConstInt (IntPtrType (), 0, 0);
3753
3754         LLVMTypeRef match_sig = LLVMFunctionType5 (LLVMInt32Type (), IntPtrType (), LLVMInt32Type (), LLVMInt32Type (), IntPtrType (), IntPtrType (), FALSE);
3755         LLVMValueRef callee = ctx->module->match_exc;
3756
3757         if (!callee) {
3758                 if (ctx->cfg->compile_aot) {
3759                         ctx->builder = builder;
3760                         // get_callee expects ctx->builder to be the emitting builder
3761                         callee = get_callee (ctx, match_sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3762                 } else {
3763                         callee = ctx->module->match_exc = LLVMAddFunction (ctx->lmodule, icall_name, match_sig);
3764                         LLVMAddGlobalMapping (ctx->module->ee, ctx->module->match_exc, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
3765                         ctx->module->match_exc = callee;
3766                         mono_memory_barrier ();
3767                 }
3768         }
3769
3770         g_assert (builder && callee);
3771
3772         g_assert (ctx->ex_var);
3773
3774         return LLVMBuildCall (builder, callee, args, num_args, icall_name);
3775 }
3776
3777 // FIXME: This won't work because the code-finding makes this
3778 // not a constant.
3779 /*#define MONO_PERSONALITY_DEBUG*/
3780
3781 #ifdef MONO_PERSONALITY_DEBUG
3782 static const gboolean use_debug_personality = TRUE;
3783 static const char *default_personality_name = "mono_debug_personality";
3784 #else
3785 static const gboolean use_debug_personality = FALSE;
3786 static const char *default_personality_name = "__gxx_personality_v0";
3787 #endif
3788
3789 static LLVMTypeRef
3790 default_cpp_lpad_exc_signature (void)
3791 {
3792         static gboolean inited = FALSE;
3793         static LLVMTypeRef sig;
3794
3795         if (!sig) {
3796                 LLVMTypeRef signature [2];
3797                 signature [0] = LLVMPointerType (LLVMInt8Type (), 0);
3798                 signature [1] = LLVMInt32Type ();
3799                 sig = LLVMStructType (signature, 2, FALSE);
3800                 inited = TRUE;
3801         }
3802
3803         return sig;
3804 }
3805
3806 static LLVMValueRef
3807 get_mono_personality (EmitContext *ctx)
3808 {
3809         LLVMValueRef personality = NULL;
3810         static gint32 mapping_inited = FALSE;
3811         LLVMTypeRef personality_type = LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE);
3812
3813         if (!use_debug_personality) {
3814                 if (ctx->cfg->compile_aot) {
3815                                 personality = get_intrinsic (ctx, default_personality_name);
3816                 } else if (InterlockedCompareExchange (&mapping_inited, 1, 0) == 0) {
3817                                 personality = LLVMAddFunction (ctx->lmodule, default_personality_name, personality_type);
3818                                 LLVMAddGlobalMapping (ctx->module->ee, personality, personality);
3819                 }
3820         } else {
3821                 if (ctx->cfg->compile_aot) {
3822                         personality = get_callee (ctx, personality_type, MONO_PATCH_INFO_INTERNAL_METHOD, default_personality_name);
3823                 } else {
3824                         personality = LLVMAddFunction (ctx->lmodule, default_personality_name, personality_type);
3825                         LLVMAddGlobalMapping (ctx->module->ee, personality, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, default_personality_name));
3826                         mono_memory_barrier ();
3827                 }
3828         }
3829
3830         g_assert (personality);
3831         return personality;
3832 }
3833
3834 static LLVMBasicBlockRef
3835 emit_landing_pad (EmitContext *ctx, int group_index, int group_size)
3836 {
3837         MonoCompile *cfg = ctx->cfg;
3838         LLVMBuilderRef old_builder = ctx->builder;
3839         MonoExceptionClause *group_start = cfg->header->clauses + group_index;
3840
3841         LLVMBuilderRef lpadBuilder = create_builder (ctx);
3842         ctx->builder = lpadBuilder;
3843
3844         MonoBasicBlock *handler_bb = cfg->cil_offset_to_bb [CLAUSE_START (group_start)];
3845         g_assert (handler_bb);
3846
3847         // <resultval> = landingpad <somety> personality <type> <pers_fn> <clause>+
3848         LLVMValueRef personality = get_mono_personality (ctx);
3849         g_assert (personality);
3850
3851         char *bb_name = g_strdup_printf ("LPAD%d_BB", group_index);
3852         LLVMBasicBlockRef lpad_bb = gen_bb (ctx, bb_name);
3853         g_free (bb_name);
3854         LLVMPositionBuilderAtEnd (lpadBuilder, lpad_bb);
3855         LLVMValueRef landing_pad = LLVMBuildLandingPad (lpadBuilder, default_cpp_lpad_exc_signature (), personality, 0, "");
3856         g_assert (landing_pad);
3857
3858         LLVMValueRef cast = LLVMBuildBitCast (lpadBuilder, ctx->module->sentinel_exception, LLVMPointerType (LLVMInt8Type (), 0), "int8TypeInfo");
3859         LLVMAddClause (landing_pad, cast);
3860
3861         LLVMBasicBlockRef resume_bb = gen_bb (ctx, "RESUME_BB");
3862         LLVMBuilderRef resume_builder = create_builder (ctx);
3863         ctx->builder = resume_builder;
3864         LLVMPositionBuilderAtEnd (resume_builder, resume_bb);
3865
3866         emit_resume_eh (ctx, handler_bb);
3867
3868         // Build match
3869         ctx->builder = lpadBuilder;
3870         LLVMPositionBuilderAtEnd (lpadBuilder, lpad_bb);
3871
3872         gboolean finally_only = TRUE;
3873
3874         MonoExceptionClause *group_cursor = group_start;
3875
3876         for (int i = 0; i < group_size; i ++) {
3877                 if (!(group_cursor->flags & MONO_EXCEPTION_CLAUSE_FINALLY))
3878                         finally_only = FALSE;
3879
3880                 group_cursor++;
3881         }
3882
3883         // FIXME:
3884         // Handle landing pad inlining
3885
3886         if (!finally_only) {
3887                 // So at each level of the exception stack we will match the exception again.
3888                 // During that match, we need to compare against the handler types for the current
3889                 // protected region. We send the try start and end so that we can only check against
3890                 // handlers for this lexical protected region.
3891                 LLVMValueRef match = mono_llvm_emit_match_exception_call (ctx, lpadBuilder, group_start->try_offset, group_start->try_offset + group_start->try_len);
3892
3893                 // if returns -1, resume
3894                 LLVMValueRef switch_ins = LLVMBuildSwitch (lpadBuilder, match, resume_bb, group_size);
3895
3896                 // else move to that target bb
3897                 for (int i=0; i < group_size; i++) {
3898                         MonoExceptionClause *clause = group_start + i;
3899                         int clause_index = clause - cfg->header->clauses;
3900                         MonoBasicBlock *handler_bb = (MonoBasicBlock*)g_hash_table_lookup (ctx->clause_to_handler, GINT_TO_POINTER (clause_index));
3901                         g_assert (handler_bb);
3902                         g_assert (ctx->bblocks [handler_bb->block_num].call_handler_target_bb);
3903                         LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE), ctx->bblocks [handler_bb->block_num].call_handler_target_bb);
3904                 }
3905         } else {
3906                 int clause_index = group_start - cfg->header->clauses;
3907                 MonoBasicBlock *finally_bb = (MonoBasicBlock*)g_hash_table_lookup (ctx->clause_to_handler, GINT_TO_POINTER (clause_index));
3908                 g_assert (finally_bb);
3909
3910                 LLVMBuildBr (ctx->builder, ctx->bblocks [finally_bb->block_num].call_handler_target_bb);
3911         }
3912
3913         ctx->builder = old_builder;
3914
3915         return lpad_bb;
3916 }
3917
3918
3919 static void
3920 emit_llvmonly_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBasicBlockRef cbb)
3921 {
3922         int clause_index = MONO_REGION_CLAUSE_INDEX (bb->region);
3923         MonoExceptionClause *clause = &ctx->cfg->header->clauses [clause_index];
3924
3925         // Make exception available to catch blocks
3926         if (!(clause->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
3927                 LLVMValueRef mono_exc = mono_llvm_emit_load_exception_call (ctx, ctx->builder);
3928
3929                 g_assert (ctx->ex_var);
3930                 LLVMBuildStore (ctx->builder, LLVMBuildBitCast (ctx->builder, mono_exc, ObjRefType (), ""), ctx->ex_var);
3931
3932                 if (bb->in_scount == 1) {
3933                         MonoInst *exvar = bb->in_stack [0];
3934                         g_assert (!ctx->values [exvar->dreg]);
3935                         g_assert (ctx->ex_var);
3936                         ctx->values [exvar->dreg] = LLVMBuildLoad (ctx->builder, ctx->ex_var, "save_exception");
3937                         emit_volatile_store (ctx, exvar->dreg);
3938                 }
3939
3940                 mono_llvm_emit_clear_exception_call (ctx, ctx->builder);
3941         }
3942
3943         LLVMBuilderRef handler_builder = create_builder (ctx);
3944         LLVMBasicBlockRef target_bb = ctx->bblocks [bb->block_num].call_handler_target_bb;
3945         LLVMPositionBuilderAtEnd (handler_builder, target_bb);
3946
3947         // Make the handler code end with a jump to cbb
3948         LLVMBuildBr (handler_builder, cbb);
3949 }
3950
3951 static void
3952 emit_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef builder)
3953 {
3954         MonoCompile *cfg = ctx->cfg;
3955         LLVMValueRef *values = ctx->values;
3956         LLVMModuleRef lmodule = ctx->lmodule;
3957         BBInfo *bblocks = ctx->bblocks;
3958         LLVMTypeRef i8ptr;
3959         LLVMValueRef personality;
3960         LLVMValueRef landing_pad;
3961         LLVMBasicBlockRef target_bb;
3962         MonoInst *exvar;
3963         static int ti_generator;
3964         char ti_name [128];
3965         LLVMValueRef type_info;
3966         int clause_index;
3967         GSList *l;
3968
3969         // <resultval> = landingpad <somety> personality <type> <pers_fn> <clause>+
3970
3971         if (cfg->compile_aot) {
3972                 /* Use a dummy personality function */
3973                 personality = LLVMGetNamedFunction (lmodule, "mono_personality");
3974                 g_assert (personality);
3975         } else {
3976 #if LLVM_API_VERSION > 100
3977                 personality = ctx->module->personality;
3978                 if (!personality) {
3979                         LLVMTypeRef personality_type = LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE);
3980                         personality = LLVMAddFunction (ctx->lmodule, "mono_personality", personality_type);
3981                         LLVMAddFunctionAttr (personality, LLVMNoUnwindAttribute);
3982                         LLVMBasicBlockRef entry_bb = LLVMAppendBasicBlock (personality, "ENTRY");
3983                         LLVMBuilderRef builder2 = LLVMCreateBuilder ();
3984                         LLVMPositionBuilderAtEnd (builder2, entry_bb);
3985                         LLVMBuildRet (builder2, LLVMConstInt (LLVMInt32Type (), 0, FALSE));
3986                         ctx->module->personality = personality;
3987                         LLVMDisposeBuilder (builder2);
3988                 }
3989 #else
3990                 static gint32 mapping_inited;
3991
3992                 personality = LLVMGetNamedFunction (lmodule, "mono_personality");
3993
3994                 if (InterlockedCompareExchange (&mapping_inited, 1, 0) == 0)
3995                         LLVMAddGlobalMapping (ctx->module->ee, personality, (gpointer)mono_personality);
3996 #endif
3997         }
3998
3999         i8ptr = LLVMPointerType (LLVMInt8Type (), 0);
4000
4001         clause_index = (mono_get_block_region_notry (cfg, bb->region) >> 8) - 1;
4002
4003         /*
4004          * Create the type info
4005          */
4006         sprintf (ti_name, "type_info_%d", ti_generator);
4007         ti_generator ++;
4008
4009         if (cfg->compile_aot) {
4010                 /* decode_eh_frame () in aot-runtime.c will decode this */
4011                 type_info = LLVMAddGlobal (lmodule, LLVMInt32Type (), ti_name);
4012                 LLVMSetInitializer (type_info, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE));
4013
4014                 /*
4015                  * These symbols are not really used, the clause_index is embedded into the EH tables generated by DwarfMonoException in LLVM.
4016                  */
4017                 LLVMSetLinkage (type_info, LLVMInternalLinkage);
4018         } else {
4019 #if LLVM_API_VERSION > 100
4020                 type_info = LLVMAddGlobal (lmodule, LLVMInt32Type (), ti_name);
4021                 LLVMSetInitializer (type_info, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE));
4022 #else
4023                 gint32 *ti;
4024
4025                 /*
4026                  * After the cfg mempool is freed, the type info will point to stale memory,
4027                  * but this is not a problem, since we decode it once in exception_cb during
4028                  * compilation.
4029                  */
4030                 ti = (gint32*)mono_mempool_alloc (cfg->mempool, sizeof (gint32));
4031                 *(gint32*)ti = clause_index;
4032
4033                 type_info = LLVMAddGlobal (lmodule, i8ptr, ti_name);
4034
4035                 LLVMAddGlobalMapping (ctx->module->ee, type_info, ti);
4036 #endif
4037         }
4038
4039         {
4040                 LLVMTypeRef members [2], ret_type;
4041
4042                 members [0] = i8ptr;
4043                 members [1] = LLVMInt32Type ();
4044                 ret_type = LLVMStructType (members, 2, FALSE);
4045
4046                 landing_pad = LLVMBuildLandingPad (builder, ret_type, personality, 1, "");
4047                 LLVMAddClause (landing_pad, type_info);
4048
4049                 /* Store the exception into the exvar */
4050                 if (ctx->ex_var)
4051                         LLVMBuildStore (builder, convert (ctx, LLVMBuildExtractValue (builder, landing_pad, 0, "ex_obj"), ObjRefType ()), ctx->ex_var);
4052         }
4053
4054         /*
4055          * LLVM throw sites are associated with a one landing pad, and LLVM generated
4056          * code expects control to be transferred to this landing pad even in the
4057          * presence of nested clauses. The landing pad needs to branch to the landing
4058          * pads belonging to nested clauses based on the selector value returned by
4059          * the landing pad instruction, which is passed to the landing pad in a
4060          * register by the EH code.
4061          */
4062         target_bb = bblocks [bb->block_num].call_handler_target_bb;
4063         g_assert (target_bb);
4064
4065         /*
4066          * Branch to the correct landing pad
4067          */
4068         LLVMValueRef ex_selector = LLVMBuildExtractValue (builder, landing_pad, 1, "ex_selector");
4069         LLVMValueRef switch_ins = LLVMBuildSwitch (builder, ex_selector, target_bb, 0);
4070
4071         for (l = ctx->nested_in [clause_index]; l; l = l->next) {
4072                 int nesting_clause_index = GPOINTER_TO_INT (l->data);
4073                 MonoBasicBlock *handler_bb;
4074
4075                 handler_bb = (MonoBasicBlock*)g_hash_table_lookup (ctx->clause_to_handler, GINT_TO_POINTER (nesting_clause_index));
4076                 g_assert (handler_bb);
4077
4078                 g_assert (ctx->bblocks [handler_bb->block_num].call_handler_target_bb);
4079                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), nesting_clause_index, FALSE), ctx->bblocks [handler_bb->block_num].call_handler_target_bb);
4080         }
4081
4082         /* Start a new bblock which CALL_HANDLER can branch to */
4083         target_bb = bblocks [bb->block_num].call_handler_target_bb;
4084         if (target_bb) {
4085                 ctx->builder = builder = create_builder (ctx);
4086                 LLVMPositionBuilderAtEnd (ctx->builder, target_bb);
4087
4088                 ctx->bblocks [bb->block_num].end_bblock = target_bb;
4089
4090                 /* Store the exception into the IL level exvar */
4091                 if (bb->in_scount == 1) {
4092                         g_assert (bb->in_scount == 1);
4093                         exvar = bb->in_stack [0];
4094
4095                         // FIXME: This is shared with filter clauses ?
4096                         g_assert (!values [exvar->dreg]);
4097
4098                         g_assert (ctx->ex_var);
4099                         values [exvar->dreg] = LLVMBuildLoad (builder, ctx->ex_var, "");
4100                         emit_volatile_store (ctx, exvar->dreg);
4101                 }
4102         }
4103 }
4104
4105 static void
4106 process_bb (EmitContext *ctx, MonoBasicBlock *bb)
4107 {
4108         MonoCompile *cfg = ctx->cfg;
4109         MonoMethodSignature *sig = ctx->sig;
4110         LLVMValueRef method = ctx->lmethod;
4111         LLVMValueRef *values = ctx->values;
4112         LLVMValueRef *addresses = ctx->addresses;
4113         LLVMCallInfo *linfo = ctx->linfo;
4114         BBInfo *bblocks = ctx->bblocks;
4115         MonoInst *ins;
4116         LLVMBasicBlockRef cbb;
4117         LLVMBuilderRef builder, starting_builder;
4118         gboolean has_terminator;
4119         LLVMValueRef v;
4120         LLVMValueRef lhs, rhs;
4121         int nins = 0;
4122
4123         cbb = get_end_bb (ctx, bb);
4124
4125         builder = create_builder (ctx);
4126         ctx->builder = builder;
4127         LLVMPositionBuilderAtEnd (builder, cbb);
4128
4129         if (!ctx_ok (ctx))
4130                 return;
4131
4132         if (bb->flags & BB_EXCEPTION_HANDLER) {
4133                 if (!ctx->llvm_only && !bblocks [bb->block_num].invoke_target) {
4134                         set_failure (ctx, "handler without invokes");
4135                         return;
4136                 }
4137
4138                 if (ctx->llvm_only)
4139                         emit_llvmonly_handler_start (ctx, bb, cbb);
4140                 else
4141                         emit_handler_start (ctx, bb, builder);
4142                 if (!ctx_ok (ctx))
4143                         return;
4144                 builder = ctx->builder;
4145         }
4146
4147         has_terminator = FALSE;
4148         starting_builder = builder;
4149         for (ins = bb->code; ins; ins = ins->next) {
4150                 const char *spec = LLVM_INS_INFO (ins->opcode);
4151                 char *dname = NULL;
4152                 char dname_buf [128];
4153
4154                 emit_dbg_loc (ctx, builder, ins->cil_code);
4155
4156                 nins ++;
4157                 if (nins > 1000) {
4158                         /*
4159                          * Some steps in llc are non-linear in the size of basic blocks, see #5714.
4160                          * Start a new bblock.
4161                          * Prevent the bblocks to be merged by doing a volatile load + cond branch
4162                          * from localloc-ed memory.
4163                          */
4164                         if (!cfg->llvm_only)
4165                                 ;//set_failure (ctx, "basic block too long");
4166
4167                         if (!ctx->long_bb_break_var) {
4168                                 ctx->long_bb_break_var = build_alloca_llvm_type_name (ctx, LLVMInt32Type (), 0, "long_bb_break");
4169                                 mono_llvm_build_store (ctx->alloca_builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), ctx->long_bb_break_var, TRUE, LLVM_BARRIER_NONE);
4170                         }
4171
4172                         cbb = gen_bb (ctx, "CONT_LONG_BB");
4173                         LLVMBasicBlockRef dummy_bb = gen_bb (ctx, "CONT_LONG_BB_DUMMY");
4174
4175                         LLVMValueRef load = mono_llvm_build_load (builder, ctx->long_bb_break_var, "", TRUE);
4176                         /*
4177                          * The long_bb_break_var is initialized to 0 in the prolog, so this branch will always go to 'cbb'
4178                          * but llvm doesn't know that, so the branch is not going to be eliminated.
4179                          */
4180                         LLVMValueRef cmp = LLVMBuildICmp (builder, LLVMIntEQ, load, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
4181
4182                         LLVMBuildCondBr (builder, cmp, cbb, dummy_bb);
4183
4184                         /* Emit a dummy false bblock which does nothing but contains a volatile store so it cannot be eliminated */
4185                         ctx->builder = builder = create_builder (ctx);
4186                         LLVMPositionBuilderAtEnd (builder, dummy_bb);
4187                         mono_llvm_build_store (builder, LLVMConstInt (LLVMInt32Type (), 1, FALSE), ctx->long_bb_break_var, TRUE, LLVM_BARRIER_NONE);
4188                         LLVMBuildBr (builder, cbb);
4189
4190                         ctx->builder = builder = create_builder (ctx);
4191                         LLVMPositionBuilderAtEnd (builder, cbb);
4192                         ctx->bblocks [bb->block_num].end_bblock = cbb;
4193                         nins = 0;
4194                 }
4195
4196                 if (has_terminator)
4197                         /* There could be instructions after a terminator, skip them */
4198                         break;
4199
4200                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins)) {
4201                         sprintf (dname_buf, "t%d", ins->dreg);
4202                         dname = dname_buf;
4203                 }
4204
4205                 if (spec [MONO_INST_SRC1] != ' ' && spec [MONO_INST_SRC1] != 'v') {
4206                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg1);
4207
4208                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) && var->opcode != OP_GSHAREDVT_ARG_REGOFFSET) {
4209                                 lhs = emit_volatile_load (ctx, ins->sreg1);
4210                         } else {
4211                                 /* It is ok for SETRET to have an uninitialized argument */
4212                                 if (!values [ins->sreg1] && ins->opcode != OP_SETRET) {
4213                                         set_failure (ctx, "sreg1");
4214                                         return;
4215                                 }
4216                                 lhs = values [ins->sreg1];
4217                         }
4218                 } else {
4219                         lhs = NULL;
4220                 }
4221
4222                 if (spec [MONO_INST_SRC2] != ' ' && spec [MONO_INST_SRC2] != ' ') {
4223                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg2);
4224                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
4225                                 rhs = emit_volatile_load (ctx, ins->sreg2);
4226                         } else {
4227                                 if (!values [ins->sreg2]) {
4228                                         set_failure (ctx, "sreg2");
4229                                         return;
4230                                 }
4231                                 rhs = values [ins->sreg2];
4232                         }
4233                 } else {
4234                         rhs = NULL;
4235                 }
4236
4237                 //mono_print_ins (ins);
4238                 switch (ins->opcode) {
4239                 case OP_NOP:
4240                 case OP_NOT_NULL:
4241                 case OP_LIVERANGE_START:
4242                 case OP_LIVERANGE_END:
4243                         break;
4244                 case OP_ICONST:
4245                         values [ins->dreg] = LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE);
4246                         break;
4247                 case OP_I8CONST:
4248 #if SIZEOF_VOID_P == 4
4249                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
4250 #else
4251                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), (gint64)ins->inst_c0, FALSE);
4252 #endif
4253                         break;
4254                 case OP_R8CONST:
4255                         values [ins->dreg] = LLVMConstReal (LLVMDoubleType (), *(double*)ins->inst_p0);
4256                         break;
4257                 case OP_R4CONST:
4258                         if (cfg->r4fp)
4259                                 values [ins->dreg] = LLVMConstReal (LLVMFloatType (), *(float*)ins->inst_p0);
4260                         else
4261                                 values [ins->dreg] = LLVMConstFPExt (LLVMConstReal (LLVMFloatType (), *(float*)ins->inst_p0), LLVMDoubleType ());
4262                         break;
4263                 case OP_DUMMY_ICONST:
4264                         values [ins->dreg] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
4265                         break;
4266                 case OP_DUMMY_I8CONST:
4267                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
4268                         break;
4269                 case OP_DUMMY_R8CONST:
4270                         values [ins->dreg] = LLVMConstReal (LLVMDoubleType (), 0.0f);
4271                         break;
4272                 case OP_BR: {
4273                         LLVMBasicBlockRef target_bb = get_bb (ctx, ins->inst_target_bb);
4274                         LLVMBuildBr (builder, target_bb);
4275                         has_terminator = TRUE;
4276                         break;
4277                 }
4278                 case OP_SWITCH: {
4279                         int i;
4280                         LLVMValueRef v;
4281                         char bb_name [128];
4282                         LLVMBasicBlockRef new_bb;
4283                         LLVMBuilderRef new_builder;
4284
4285                         // The default branch is already handled
4286                         // FIXME: Handle it here
4287
4288                         /* Start new bblock */
4289                         sprintf (bb_name, "SWITCH_DEFAULT_BB%d", ctx->default_index ++);
4290                         new_bb = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
4291
4292                         lhs = convert (ctx, lhs, LLVMInt32Type ());
4293                         v = LLVMBuildSwitch (builder, lhs, new_bb, GPOINTER_TO_UINT (ins->klass));
4294                         for (i = 0; i < GPOINTER_TO_UINT (ins->klass); ++i) {
4295                                 MonoBasicBlock *target_bb = ins->inst_many_bb [i];
4296
4297                                 LLVMAddCase (v, LLVMConstInt (LLVMInt32Type (), i, FALSE), get_bb (ctx, target_bb));
4298                         }
4299
4300                         new_builder = create_builder (ctx);
4301                         LLVMPositionBuilderAtEnd (new_builder, new_bb);
4302                         LLVMBuildUnreachable (new_builder);
4303
4304                         has_terminator = TRUE;
4305                         g_assert (!ins->next);
4306
4307                         break;
4308                 }
4309
4310                 case OP_SETRET:
4311                         switch (linfo->ret.storage) {
4312                         case LLVMArgVtypeInReg: {
4313                                 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
4314                                 LLVMValueRef val, addr, retval;
4315                                 int i;
4316
4317                                 retval = LLVMGetUndef (ret_type);
4318
4319                                 if (!addresses [ins->sreg1]) {
4320                                         /*
4321                                          * The return type is an LLVM vector type, have to convert between it and the
4322                                          * real return type which is a struct type.
4323                                          */
4324                                         g_assert (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->ret)));
4325                                         /* Convert to 2xi64 first */
4326                                         val = LLVMBuildBitCast (builder, values [ins->sreg1], LLVMVectorType (IntPtrType (), 2), "");
4327
4328                                         for (i = 0; i < 2; ++i) {
4329                                                 if (linfo->ret.pair_storage [i] == LLVMArgInIReg) {
4330                                                         retval = LLVMBuildInsertValue (builder, retval, LLVMBuildExtractElement (builder, val, LLVMConstInt (LLVMInt32Type (), i, FALSE), ""), i, "");
4331                                                 } else {
4332                                                         g_assert (linfo->ret.pair_storage [i] == LLVMArgNone);
4333                                                 }
4334                                         }
4335                                 } else {
4336                                         addr = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (ret_type, 0), "");
4337                                         for (i = 0; i < 2; ++i) {
4338                                                 if (linfo->ret.pair_storage [i] == LLVMArgInIReg) {
4339                                                         LLVMValueRef indexes [2], part_addr;
4340
4341                                                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
4342                                                         indexes [1] = LLVMConstInt (LLVMInt32Type (), i, FALSE);
4343                                                         part_addr = LLVMBuildGEP (builder, addr, indexes, 2, "");
4344
4345                                                         retval = LLVMBuildInsertValue (builder, retval, LLVMBuildLoad (builder, part_addr, ""), i, "");
4346                                                 } else {
4347                                                         g_assert (linfo->ret.pair_storage [i] == LLVMArgNone);
4348                                                 }
4349                                         }
4350                                 }
4351                                 LLVMBuildRet (builder, retval);
4352                                 break;
4353                         }
4354                         case LLVMArgVtypeAsScalar: {
4355                                 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
4356                                 LLVMValueRef retval;
4357
4358                                 g_assert (addresses [ins->sreg1]);
4359
4360                                 retval = LLVMBuildLoad (builder, LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (ret_type, 0), ""), "");
4361                                 LLVMBuildRet (builder, retval);
4362                                 break;
4363                         }
4364                         case LLVMArgVtypeByVal: {
4365                                 LLVMValueRef retval;
4366
4367                                 g_assert (addresses [ins->sreg1]);
4368                                 retval = LLVMBuildLoad (builder, addresses [ins->sreg1], "");
4369                                 LLVMBuildRet (builder, retval);
4370                                 break;
4371                         }
4372                         case LLVMArgVtypeByRef: {
4373                                 LLVMBuildRetVoid (builder);
4374                                 break;
4375                         }
4376                         case LLVMArgGsharedvtFixed: {
4377                                 LLVMTypeRef ret_type = type_to_llvm_type (ctx, sig->ret);
4378                                 /* The return value is in lhs, need to store to the vret argument */
4379                                 /* sreg1 might not be set */
4380                                 if (lhs) {
4381                                         g_assert (cfg->vret_addr);
4382                                         g_assert (values [cfg->vret_addr->dreg]);
4383                                         LLVMBuildStore (builder, convert (ctx, lhs, ret_type), convert (ctx, values [cfg->vret_addr->dreg], LLVMPointerType (ret_type, 0)));
4384                                 }
4385                                 LLVMBuildRetVoid (builder);
4386                                 break;
4387                         }
4388                         case LLVMArgGsharedvtFixedVtype: {
4389                                 /* Already set */
4390                                 LLVMBuildRetVoid (builder);
4391                                 break;
4392                         }
4393                         case LLVMArgGsharedvtVariable: {
4394                                 /* Already set */
4395                                 LLVMBuildRetVoid (builder);
4396                                 break;
4397                         }
4398                         case LLVMArgVtypeRetAddr: {
4399                                 LLVMBuildRetVoid (builder);
4400                                 break;
4401                         }
4402                         case LLVMArgAsIArgs:
4403                         case LLVMArgFpStruct: {
4404                                 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
4405                                 LLVMValueRef retval;
4406
4407                                 g_assert (addresses [ins->sreg1]);
4408                                 retval = LLVMBuildLoad (builder, convert (ctx, addresses [ins->sreg1], LLVMPointerType (ret_type, 0)), "");
4409                                 LLVMBuildRet (builder, retval);
4410                                 break;
4411                         }
4412                         case LLVMArgNone:
4413                         case LLVMArgNormal: {
4414                                 if (!lhs || ctx->is_dead [ins->sreg1]) {
4415                                         /*
4416                                          * The method did not set its return value, probably because it
4417                                          * ends with a throw.
4418                                          */
4419                                         if (cfg->vret_addr)
4420                                                 LLVMBuildRetVoid (builder);
4421                                         else
4422                                                 LLVMBuildRet (builder, LLVMConstNull (type_to_llvm_type (ctx, sig->ret)));
4423                                 } else {
4424                                         LLVMBuildRet (builder, convert (ctx, lhs, type_to_llvm_type (ctx, sig->ret)));
4425                                 }
4426                                 has_terminator = TRUE;
4427                                 break;
4428                         }
4429                         default:
4430                                 g_assert_not_reached ();
4431                                 break;
4432                         }
4433                         break;
4434                 case OP_ICOMPARE:
4435                 case OP_FCOMPARE:
4436                 case OP_RCOMPARE:
4437                 case OP_LCOMPARE:
4438                 case OP_COMPARE:
4439                 case OP_ICOMPARE_IMM:
4440                 case OP_LCOMPARE_IMM:
4441                 case OP_COMPARE_IMM: {
4442                         CompRelation rel;
4443                         LLVMValueRef cmp, args [16];
4444                         gboolean likely = (ins->flags & MONO_INST_LIKELY) != 0;
4445
4446                         if (ins->next->opcode == OP_NOP)
4447                                 break;
4448
4449                         if (ins->next->opcode == OP_BR)
4450                                 /* The comparison result is not needed */
4451                                 continue;
4452
4453                         rel = mono_opcode_to_cond (ins->next->opcode);
4454
4455                         if (ins->opcode == OP_ICOMPARE_IMM) {
4456                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
4457                                 rhs = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
4458                         }
4459                         if (ins->opcode == OP_LCOMPARE_IMM) {
4460                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
4461                                 rhs = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
4462                         }
4463                         if (ins->opcode == OP_LCOMPARE) {
4464                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
4465                                 rhs = convert (ctx, rhs, LLVMInt64Type ());
4466                         }
4467                         if (ins->opcode == OP_ICOMPARE) {
4468                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
4469                                 rhs = convert (ctx, rhs, LLVMInt32Type ());
4470                         }
4471
4472                         if (lhs && rhs) {
4473                                 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
4474                                         rhs = convert (ctx, rhs, LLVMTypeOf (lhs));
4475                                 else if (LLVMGetTypeKind (LLVMTypeOf (rhs)) == LLVMPointerTypeKind)
4476                                         lhs = convert (ctx, lhs, LLVMTypeOf (rhs));
4477                         }
4478
4479                         /* We use COMPARE+SETcc/Bcc, llvm uses SETcc+br cond */
4480                         if (ins->opcode == OP_FCOMPARE) {
4481                                 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
4482                         } else if (ins->opcode == OP_RCOMPARE) {
4483                                 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMFloatType ()), convert (ctx, rhs, LLVMFloatType ()), "");
4484                         } else if (ins->opcode == OP_COMPARE_IMM) {
4485                                 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind && ins->inst_imm == 0)
4486                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, LLVMConstNull (LLVMTypeOf (lhs)), "");
4487                                 else
4488                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), "");
4489                         } else if (ins->opcode == OP_LCOMPARE_IMM) {
4490                                 if (SIZEOF_REGISTER == 4 && COMPILE_LLVM (cfg))  {
4491                                         /* The immediate is encoded in two fields */
4492                                         guint64 l = ((guint64)(guint32)ins->inst_offset << 32) | ((guint32)ins->inst_imm);
4493                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), l, FALSE), "");
4494                                 } else {
4495                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), ins->inst_imm, FALSE), "");
4496                                 }
4497                         }
4498                         else if (ins->opcode == OP_COMPARE) {
4499                                 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind && LLVMTypeOf (lhs) == LLVMTypeOf (rhs))
4500                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, rhs, "");
4501                                 else
4502                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), convert (ctx, rhs, IntPtrType ()), "");
4503                         } else
4504                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, rhs, "");
4505
4506                         if (likely) {
4507                                 args [0] = cmp;
4508                                 args [1] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
4509                                 cmp = LLVMBuildCall (ctx->builder, get_intrinsic (ctx, "llvm.expect.i1"), args, 2, "");
4510                         }
4511
4512                         if (MONO_IS_COND_BRANCH_OP (ins->next)) {
4513                                 if (ins->next->inst_true_bb == ins->next->inst_false_bb) {
4514                                         /*
4515                                          * If the target bb contains PHI instructions, LLVM requires
4516                                          * two PHI entries for this bblock, while we only generate one.
4517                                          * So convert this to an unconditional bblock. (bxc #171).
4518                                          */
4519                                         LLVMBuildBr (builder, get_bb (ctx, ins->next->inst_true_bb));
4520                                 } else {
4521                                         LLVMBuildCondBr (builder, cmp, get_bb (ctx, ins->next->inst_true_bb), get_bb (ctx, ins->next->inst_false_bb));
4522                                 }
4523                                 has_terminator = TRUE;
4524                         } else if (MONO_IS_SETCC (ins->next)) {
4525                                 sprintf (dname_buf, "t%d", ins->next->dreg);
4526                                 dname = dname_buf;
4527                                 values [ins->next->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
4528
4529                                 /* Add stores for volatile variables */
4530                                 emit_volatile_store (ctx, ins->next->dreg);
4531                         } else if (MONO_IS_COND_EXC (ins->next)) {
4532                                 emit_cond_system_exception (ctx, bb, (const char*)ins->next->inst_p1, cmp);
4533                                 if (!ctx_ok (ctx))
4534                                         break;
4535                                 builder = ctx->builder;
4536                         } else {
4537                                 set_failure (ctx, "next");
4538                                 break;
4539                         }
4540
4541                         ins = ins->next;
4542                         break;
4543                 }
4544                 case OP_FCEQ:
4545                 case OP_FCNEQ:
4546                 case OP_FCLT:
4547                 case OP_FCLT_UN:
4548                 case OP_FCGT:
4549                 case OP_FCGT_UN:
4550                 case OP_FCGE:
4551                 case OP_FCLE: {
4552                         CompRelation rel;
4553                         LLVMValueRef cmp;
4554
4555                         rel = mono_opcode_to_cond (ins->opcode);
4556
4557                         cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
4558                         values [ins->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
4559                         break;
4560                 }
4561                 case OP_RCEQ:
4562                 case OP_RCLT:
4563                 case OP_RCLT_UN:
4564                 case OP_RCGT:
4565                 case OP_RCGT_UN: {
4566                         CompRelation rel;
4567                         LLVMValueRef cmp;
4568
4569                         rel = mono_opcode_to_cond (ins->opcode);
4570
4571                         cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMFloatType ()), convert (ctx, rhs, LLVMFloatType ()), "");
4572                         values [ins->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
4573                         break;
4574                 }
4575                 case OP_PHI:
4576                 case OP_FPHI:
4577                 case OP_VPHI:
4578                 case OP_XPHI: {
4579                         int i;
4580                         gboolean empty = TRUE;
4581
4582                         /* Check that all input bblocks really branch to us */
4583                         for (i = 0; i < bb->in_count; ++i) {
4584                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_NOT_REACHED)
4585                                         ins->inst_phi_args [i + 1] = -1;
4586                                 else
4587                                         empty = FALSE;
4588                         }
4589
4590                         if (empty) {
4591                                 /* LLVM doesn't like phi instructions with zero operands */
4592                                 ctx->is_dead [ins->dreg] = TRUE;
4593                                 break;
4594                         }
4595
4596                         /* Created earlier, insert it now */
4597                         LLVMInsertIntoBuilder (builder, values [ins->dreg]);
4598
4599                         for (i = 0; i < ins->inst_phi_args [0]; i++) {
4600                                 int sreg1 = ins->inst_phi_args [i + 1];
4601                                 int count, j;
4602
4603                                 /*
4604                                  * Count the number of times the incoming bblock branches to us,
4605                                  * since llvm requires a separate entry for each.
4606                                  */
4607                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_SWITCH) {
4608                                         MonoInst *switch_ins = bb->in_bb [i]->last_ins;
4609
4610                                         count = 0;
4611                                         for (j = 0; j < GPOINTER_TO_UINT (switch_ins->klass); ++j) {
4612                                                 if (switch_ins->inst_many_bb [j] == bb)
4613                                                         count ++;
4614                                         }
4615                                 } else {
4616                                         count = 1;
4617                                 }
4618
4619                                 /* Remember for later */
4620                                 for (j = 0; j < count; ++j) {
4621                                         PhiNode *node = (PhiNode*)mono_mempool_alloc0 (ctx->mempool, sizeof (PhiNode));
4622                                         node->bb = bb;
4623                                         node->phi = ins;
4624                                         node->in_bb = bb->in_bb [i];
4625                                         node->sreg = sreg1;
4626                                         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);
4627                                 }
4628                         }
4629                         break;
4630                 }
4631                 case OP_MOVE:
4632                 case OP_LMOVE:
4633                 case OP_XMOVE:
4634                 case OP_SETFRET:
4635                         g_assert (lhs);
4636                         values [ins->dreg] = lhs;
4637                         break;
4638                 case OP_FMOVE:
4639                 case OP_RMOVE: {
4640                         MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
4641
4642                         g_assert (lhs);
4643                         values [ins->dreg] = lhs;
4644
4645                         if (var && var->klass->byval_arg.type == MONO_TYPE_R4) {
4646                                 /*
4647                                  * This is added by the spilling pass in case of the JIT,
4648                                  * but we have to do it ourselves.
4649                                  */
4650                                 values [ins->dreg] = convert (ctx, values [ins->dreg], LLVMFloatType ());
4651                         }
4652                         break;
4653                 }
4654                 case OP_MOVE_F_TO_I4: {
4655                         values [ins->dreg] = LLVMBuildBitCast (builder, LLVMBuildFPTrunc (builder, lhs, LLVMFloatType (), ""), LLVMInt32Type (), "");
4656                         break;
4657                 }
4658                 case OP_MOVE_I4_TO_F: {
4659                         values [ins->dreg] = LLVMBuildFPExt (builder, LLVMBuildBitCast (builder, lhs, LLVMFloatType (), ""), LLVMDoubleType (), "");
4660                         break;
4661                 }
4662                 case OP_MOVE_F_TO_I8: {
4663                         values [ins->dreg] = LLVMBuildBitCast (builder, lhs, LLVMInt64Type (), "");
4664                         break;
4665                 }
4666                 case OP_MOVE_I8_TO_F: {
4667                         values [ins->dreg] = LLVMBuildBitCast (builder, lhs, LLVMDoubleType (), "");
4668                         break;
4669                 }
4670                 case OP_IADD:
4671                 case OP_ISUB:
4672                 case OP_IAND:
4673                 case OP_IMUL:
4674                 case OP_IDIV:
4675                 case OP_IDIV_UN:
4676                 case OP_IREM:
4677                 case OP_IREM_UN:
4678                 case OP_IOR:
4679                 case OP_IXOR:
4680                 case OP_ISHL:
4681                 case OP_ISHR:
4682                 case OP_ISHR_UN:
4683                 case OP_FADD:
4684                 case OP_FSUB:
4685                 case OP_FMUL:
4686                 case OP_FDIV:
4687                 case OP_LADD:
4688                 case OP_LSUB:
4689                 case OP_LMUL:
4690                 case OP_LDIV:
4691                 case OP_LDIV_UN:
4692                 case OP_LREM:
4693                 case OP_LREM_UN:
4694                 case OP_LAND:
4695                 case OP_LOR:
4696                 case OP_LXOR:
4697                 case OP_LSHL:
4698                 case OP_LSHR:
4699                 case OP_LSHR_UN:
4700                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
4701                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
4702
4703                         emit_div_check (ctx, builder, bb, ins, lhs, rhs);
4704                         if (!ctx_ok (ctx))
4705                                 break;
4706                         builder = ctx->builder;
4707
4708                         switch (ins->opcode) {
4709                         case OP_IADD:
4710                         case OP_LADD:
4711                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, dname);
4712                                 break;
4713                         case OP_ISUB:
4714                         case OP_LSUB:
4715                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, dname);
4716                                 break;
4717                         case OP_IMUL:
4718                         case OP_LMUL:
4719                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, dname);
4720                                 break;
4721                         case OP_IREM:
4722                         case OP_LREM:
4723                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, rhs, dname);
4724                                 break;
4725                         case OP_IREM_UN:
4726                         case OP_LREM_UN:
4727                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, rhs, dname);
4728                                 break;
4729                         case OP_IDIV:
4730                         case OP_LDIV:
4731                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, rhs, dname);
4732                                 break;
4733                         case OP_IDIV_UN:
4734                         case OP_LDIV_UN:
4735                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, rhs, dname);
4736                                 break;
4737                         case OP_FDIV:
4738                         case OP_RDIV:
4739                                 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, dname);
4740                                 break;
4741                         case OP_IAND:
4742                         case OP_LAND:
4743                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, dname);
4744                                 break;
4745                         case OP_IOR:
4746                         case OP_LOR:
4747                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, dname);
4748                                 break;
4749                         case OP_IXOR:
4750                         case OP_LXOR:
4751                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, dname);
4752                                 break;
4753                         case OP_ISHL:
4754                         case OP_LSHL:
4755                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, rhs, dname);
4756                                 break;
4757                         case OP_ISHR:
4758                         case OP_LSHR:
4759                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, rhs, dname);
4760                                 break;
4761                         case OP_ISHR_UN:
4762                         case OP_LSHR_UN:
4763                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, rhs, dname);
4764                                 break;
4765
4766                         case OP_FADD:
4767                                 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, dname);
4768                                 break;
4769                         case OP_FSUB:
4770                                 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, dname);
4771                                 break;
4772                         case OP_FMUL:
4773                                 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, dname);
4774                                 break;
4775
4776                         default:
4777                                 g_assert_not_reached ();
4778                         }
4779                         break;
4780                 case OP_RADD:
4781                 case OP_RSUB:
4782                 case OP_RMUL:
4783                 case OP_RDIV: {
4784                         lhs = convert (ctx, lhs, LLVMFloatType ());
4785                         rhs = convert (ctx, rhs, LLVMFloatType ());
4786                         switch (ins->opcode) {
4787                         case OP_RADD:
4788                                 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, dname);
4789                                 break;
4790                         case OP_RSUB:
4791                                 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, dname);
4792                                 break;
4793                         case OP_RMUL:
4794                                 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, dname);
4795                                 break;
4796                         case OP_RDIV:
4797                                 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, dname);
4798                                 break;
4799                         default:
4800                                 g_assert_not_reached ();
4801                                 break;
4802                         }
4803                         break;
4804                 }
4805                 case OP_IADD_IMM:
4806                 case OP_ISUB_IMM:
4807                 case OP_IMUL_IMM:
4808                 case OP_IREM_IMM:
4809                 case OP_IREM_UN_IMM:
4810                 case OP_IDIV_IMM:
4811                 case OP_IDIV_UN_IMM:
4812                 case OP_IAND_IMM:
4813                 case OP_IOR_IMM:
4814                 case OP_IXOR_IMM:
4815                 case OP_ISHL_IMM:
4816                 case OP_ISHR_IMM:
4817                 case OP_ISHR_UN_IMM:
4818                 case OP_LADD_IMM:
4819                 case OP_LSUB_IMM:
4820                 case OP_LMUL_IMM:
4821                 case OP_LREM_IMM:
4822                 case OP_LAND_IMM:
4823                 case OP_LOR_IMM:
4824                 case OP_LXOR_IMM:
4825                 case OP_LSHL_IMM:
4826                 case OP_LSHR_IMM:
4827                 case OP_LSHR_UN_IMM:
4828                 case OP_ADD_IMM:
4829                 case OP_AND_IMM:
4830                 case OP_MUL_IMM:
4831                 case OP_SHL_IMM:
4832                 case OP_SHR_IMM:
4833                 case OP_SHR_UN_IMM: {
4834                         LLVMValueRef imm;
4835
4836                         if (spec [MONO_INST_SRC1] == 'l') {
4837                                 imm = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
4838                         } else {
4839                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
4840                         }
4841
4842                         emit_div_check (ctx, builder, bb, ins, lhs, imm);
4843                         if (!ctx_ok (ctx))
4844                                 break;
4845                         builder = ctx->builder;
4846
4847 #if SIZEOF_VOID_P == 4
4848                         if (ins->opcode == OP_LSHL_IMM || ins->opcode == OP_LSHR_IMM || ins->opcode == OP_LSHR_UN_IMM)
4849                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
4850 #endif
4851
4852                         if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
4853                                 lhs = convert (ctx, lhs, IntPtrType ());
4854                         imm = convert (ctx, imm, LLVMTypeOf (lhs));
4855                         switch (ins->opcode) {
4856                         case OP_IADD_IMM:
4857                         case OP_LADD_IMM:
4858                         case OP_ADD_IMM:
4859                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, imm, dname);
4860                                 break;
4861                         case OP_ISUB_IMM:
4862                         case OP_LSUB_IMM:
4863                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, imm, dname);
4864                                 break;
4865                         case OP_IMUL_IMM:
4866                         case OP_MUL_IMM:
4867                         case OP_LMUL_IMM:
4868                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, imm, dname);
4869                                 break;
4870                         case OP_IDIV_IMM:
4871                         case OP_LDIV_IMM:
4872                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, imm, dname);
4873                                 break;
4874                         case OP_IDIV_UN_IMM:
4875                         case OP_LDIV_UN_IMM:
4876                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, imm, dname);
4877                                 break;
4878                         case OP_IREM_IMM:
4879                         case OP_LREM_IMM:
4880                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, imm, dname);
4881                                 break;
4882                         case OP_IREM_UN_IMM:
4883                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, imm, dname);
4884                                 break;
4885                         case OP_IAND_IMM:
4886                         case OP_LAND_IMM:
4887                         case OP_AND_IMM:
4888                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, imm, dname);
4889                                 break;
4890                         case OP_IOR_IMM:
4891                         case OP_LOR_IMM:
4892                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, imm, dname);
4893                                 break;
4894                         case OP_IXOR_IMM:
4895                         case OP_LXOR_IMM:
4896                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, imm, dname);
4897                                 break;
4898                         case OP_ISHL_IMM:
4899                         case OP_LSHL_IMM:
4900                         case OP_SHL_IMM:
4901                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, imm, dname);
4902                                 break;
4903                         case OP_ISHR_IMM:
4904                         case OP_LSHR_IMM:
4905                         case OP_SHR_IMM:
4906                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, imm, dname);
4907                                 break;
4908                         case OP_ISHR_UN_IMM:
4909                                 /* This is used to implement conv.u4, so the lhs could be an i8 */
4910                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
4911                                 imm = convert (ctx, imm, LLVMInt32Type ());
4912                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
4913                                 break;
4914                         case OP_LSHR_UN_IMM:
4915                         case OP_SHR_UN_IMM:
4916                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
4917                                 break;
4918                         default:
4919                                 g_assert_not_reached ();
4920                         }
4921                         break;
4922                 }
4923                 case OP_INEG:
4924                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
4925                         break;
4926                 case OP_LNEG:
4927                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt64Type (), 0, FALSE), lhs, dname);
4928                         break;
4929                 case OP_FNEG:
4930                         lhs = convert (ctx, lhs, LLVMDoubleType ());
4931                         values [ins->dreg] = LLVMBuildFSub (builder, LLVMConstReal (LLVMDoubleType (), 0.0), lhs, dname);
4932                         break;
4933                 case OP_RNEG:
4934                         lhs = convert (ctx, lhs, LLVMFloatType ());
4935                         values [ins->dreg] = LLVMBuildFSub (builder, LLVMConstReal (LLVMFloatType (), 0.0), lhs, dname);
4936                         break;
4937                 case OP_INOT: {
4938                         guint32 v = 0xffffffff;
4939                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt32Type (), v, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
4940                         break;
4941                 }
4942                 case OP_LNOT: {
4943                         guint64 v = 0xffffffffffffffffLL;
4944                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt64Type (), v, FALSE), lhs, dname);
4945                         break;
4946                 }
4947 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4948                 case OP_X86_LEA: {
4949                         LLVMValueRef v1, v2;
4950
4951                         v1 = LLVMBuildMul (builder, convert (ctx, rhs, IntPtrType ()), LLVMConstInt (IntPtrType (), (1 << ins->backend.shift_amount), FALSE), "");
4952                         v2 = LLVMBuildAdd (builder, convert (ctx, lhs, IntPtrType ()), v1, "");
4953                         values [ins->dreg] = LLVMBuildAdd (builder, v2, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), dname);
4954                         break;
4955                 }
4956 #endif
4957
4958                 case OP_ICONV_TO_I1:
4959                 case OP_ICONV_TO_I2:
4960                 case OP_ICONV_TO_I4:
4961                 case OP_ICONV_TO_U1:
4962                 case OP_ICONV_TO_U2:
4963                 case OP_ICONV_TO_U4:
4964                 case OP_LCONV_TO_I1:
4965                 case OP_LCONV_TO_I2:
4966                 case OP_LCONV_TO_U1:
4967                 case OP_LCONV_TO_U2:
4968                 case OP_LCONV_TO_U4: {
4969                         gboolean sign;
4970
4971                         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);
4972
4973                         /* Have to do two casts since our vregs have type int */
4974                         v = LLVMBuildTrunc (builder, lhs, op_to_llvm_type (ins->opcode), "");
4975                         if (sign)
4976                                 values [ins->dreg] = LLVMBuildSExt (builder, v, LLVMInt32Type (), dname);
4977                         else
4978                                 values [ins->dreg] = LLVMBuildZExt (builder, v, LLVMInt32Type (), dname);
4979                         break;
4980                 }
4981                 case OP_ICONV_TO_I8:
4982                         values [ins->dreg] = LLVMBuildSExt (builder, lhs, LLVMInt64Type (), dname);
4983                         break;
4984                 case OP_ICONV_TO_U8:
4985                         values [ins->dreg] = LLVMBuildZExt (builder, lhs, LLVMInt64Type (), dname);
4986                         break;
4987                 case OP_FCONV_TO_I4:
4988                 case OP_RCONV_TO_I4:
4989                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt32Type (), dname);
4990                         break;
4991                 case OP_FCONV_TO_I1:
4992                 case OP_RCONV_TO_I1:
4993                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
4994                         break;
4995                 case OP_FCONV_TO_U1:
4996                 case OP_RCONV_TO_U1:
4997                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildTrunc (builder, LLVMBuildFPToUI (builder, lhs, IntPtrType (), dname), LLVMInt8Type (), ""), LLVMInt32Type (), "");
4998                         break;
4999                 case OP_FCONV_TO_I2:
5000                 case OP_RCONV_TO_I2:
5001                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
5002                         break;
5003                 case OP_FCONV_TO_U2:
5004                 case OP_RCONV_TO_U2:
5005                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
5006                         break;
5007                 case OP_RCONV_TO_U4:
5008                         values [ins->dreg] = LLVMBuildFPToUI (builder, lhs, LLVMInt32Type (), dname);
5009                         break;
5010                 case OP_FCONV_TO_I8:
5011                 case OP_RCONV_TO_I8:
5012                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt64Type (), dname);
5013                         break;
5014                 case OP_FCONV_TO_I:
5015                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, IntPtrType (), dname);
5016                         break;
5017                 case OP_ICONV_TO_R8:
5018                 case OP_LCONV_TO_R8:
5019                         values [ins->dreg] = LLVMBuildSIToFP (builder, lhs, LLVMDoubleType (), dname);
5020                         break;
5021                 case OP_ICONV_TO_R_UN:
5022                 case OP_LCONV_TO_R_UN:
5023                         values [ins->dreg] = LLVMBuildUIToFP (builder, lhs, LLVMDoubleType (), dname);
5024                         break;
5025 #if SIZEOF_VOID_P == 4
5026                 case OP_LCONV_TO_U:
5027 #endif
5028                 case OP_LCONV_TO_I4:
5029                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
5030                         break;
5031                 case OP_ICONV_TO_R4:
5032                 case OP_LCONV_TO_R4:
5033                         v = LLVMBuildSIToFP (builder, lhs, LLVMFloatType (), "");
5034                         if (cfg->r4fp)
5035                                 values [ins->dreg] = v;
5036                         else
5037                                 values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
5038                         break;
5039                 case OP_FCONV_TO_R4:
5040                         v = LLVMBuildFPTrunc (builder, lhs, LLVMFloatType (), "");
5041                         if (cfg->r4fp)
5042                                 values [ins->dreg] = v;
5043                         else
5044                                 values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
5045                         break;
5046                 case OP_RCONV_TO_R8:
5047                         values [ins->dreg] = LLVMBuildFPExt (builder, lhs, LLVMDoubleType (), dname);
5048                         break;
5049                 case OP_RCONV_TO_R4:
5050                         values [ins->dreg] = lhs;
5051                         break;
5052                 case OP_SEXT_I4:
5053                         values [ins->dreg] = LLVMBuildSExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
5054                         break;
5055                 case OP_ZEXT_I4:
5056                         values [ins->dreg] = LLVMBuildZExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
5057                         break;
5058                 case OP_TRUNC_I4:
5059                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
5060                         break;
5061                 case OP_LOCALLOC_IMM: {
5062                         LLVMValueRef v;
5063
5064                         guint32 size = ins->inst_imm;
5065                         size = (size + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
5066
5067                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), LLVMConstInt (LLVMInt32Type (), size, FALSE), MONO_ARCH_FRAME_ALIGNMENT, "");
5068
5069                         if (ins->flags & MONO_INST_INIT) {
5070                                 LLVMValueRef args [5];
5071
5072                                 args [0] = v;
5073                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
5074                                 args [2] = LLVMConstInt (LLVMInt32Type (), size, FALSE);
5075                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
5076                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
5077                                 LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.memset.p0i8.i32"), args, 5, "");
5078                         }
5079
5080                         values [ins->dreg] = v;
5081                         break;
5082                 }
5083                 case OP_LOCALLOC: {
5084                         LLVMValueRef v, size;
5085
5086                         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), "");
5087
5088                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), size, MONO_ARCH_FRAME_ALIGNMENT, "");
5089
5090                         if (ins->flags & MONO_INST_INIT) {
5091                                 LLVMValueRef args [5];
5092
5093                                 args [0] = v;
5094                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
5095                                 args [2] = size;
5096                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
5097                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
5098                                 LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.memset.p0i8.i32"), args, 5, "");
5099                         }
5100                         values [ins->dreg] = v;
5101                         break;
5102                 }
5103
5104                 case OP_LOADI1_MEMBASE:
5105                 case OP_LOADU1_MEMBASE:
5106                 case OP_LOADI2_MEMBASE:
5107                 case OP_LOADU2_MEMBASE:
5108                 case OP_LOADI4_MEMBASE:
5109                 case OP_LOADU4_MEMBASE:
5110                 case OP_LOADI8_MEMBASE:
5111                 case OP_LOADR4_MEMBASE:
5112                 case OP_LOADR8_MEMBASE:
5113                 case OP_LOAD_MEMBASE:
5114                 case OP_LOADI8_MEM:
5115                 case OP_LOADU1_MEM:
5116                 case OP_LOADU2_MEM:
5117                 case OP_LOADI4_MEM:
5118                 case OP_LOADU4_MEM:
5119                 case OP_LOAD_MEM: {
5120                         int size = 8;
5121                         LLVMValueRef base, index, addr;
5122                         LLVMTypeRef t;
5123                         gboolean sext = FALSE, zext = FALSE;
5124                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
5125
5126                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
5127
5128                         if (sext || zext)
5129                                 dname = (char*)"";
5130
5131                         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)) {
5132                                 addr = LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE);
5133                                 base = addr;
5134                         } else {
5135                                 /* _MEMBASE */
5136                                 base = lhs;
5137
5138                                 if (ins->inst_offset == 0) {
5139                                         addr = base;
5140                                 } else if (ins->inst_offset % size != 0) {
5141                                         /* Unaligned load */
5142                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
5143                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
5144                                 } else {
5145                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
5146                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
5147                                 }
5148                         }
5149
5150                         addr = convert (ctx, addr, LLVMPointerType (t, 0));
5151
5152                         values [ins->dreg] = emit_load_general (ctx, bb, &builder, size, addr, base, dname, is_volatile, LLVM_BARRIER_NONE);
5153
5154                         if (!is_volatile && (ins->flags & MONO_INST_INVARIANT_LOAD)) {
5155                                 /*
5156                                  * These will signal LLVM that these loads do not alias any stores, and
5157                                  * they can't fail, allowing them to be hoisted out of loops.
5158                                  */
5159                                 set_invariant_load_flag (values [ins->dreg]);
5160 #if LLVM_API_VERSION < 100
5161                                 set_metadata_flag (values [ins->dreg], "mono.nofail.load");
5162 #endif
5163                         }
5164
5165                         if (sext)
5166                                 values [ins->dreg] = LLVMBuildSExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
5167                         else if (zext)
5168                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
5169                         else if (!cfg->r4fp && ins->opcode == OP_LOADR4_MEMBASE)
5170                                 values [ins->dreg] = LLVMBuildFPExt (builder, values [ins->dreg], LLVMDoubleType (), dname);
5171                         break;
5172                 }
5173
5174                 case OP_STOREI1_MEMBASE_REG:
5175                 case OP_STOREI2_MEMBASE_REG:
5176                 case OP_STOREI4_MEMBASE_REG:
5177                 case OP_STOREI8_MEMBASE_REG:
5178                 case OP_STORER4_MEMBASE_REG:
5179                 case OP_STORER8_MEMBASE_REG:
5180                 case OP_STORE_MEMBASE_REG: {
5181                         int size = 8;
5182                         LLVMValueRef index, addr, base;
5183                         LLVMTypeRef t;
5184                         gboolean sext = FALSE, zext = FALSE;
5185                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
5186
5187                         if (!values [ins->inst_destbasereg]) {
5188                                 set_failure (ctx, "inst_destbasereg");
5189                                 break;
5190                         }
5191
5192                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
5193
5194                         base = values [ins->inst_destbasereg];
5195                         if (ins->inst_offset % size != 0) {
5196                                 /* Unaligned store */
5197                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
5198                                 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
5199                         } else {
5200                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
5201                                 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
5202                         }
5203                         emit_store (ctx, bb, &builder, size, convert (ctx, values [ins->sreg1], t), convert (ctx, addr, LLVMPointerType (t, 0)), base, is_volatile);
5204                         break;
5205                 }
5206
5207                 case OP_STOREI1_MEMBASE_IMM:
5208                 case OP_STOREI2_MEMBASE_IMM:
5209                 case OP_STOREI4_MEMBASE_IMM:
5210                 case OP_STOREI8_MEMBASE_IMM:
5211                 case OP_STORE_MEMBASE_IMM: {
5212                         int size = 8;
5213                         LLVMValueRef index, addr, base;
5214                         LLVMTypeRef t;
5215                         gboolean sext = FALSE, zext = FALSE;
5216                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
5217
5218                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
5219
5220                         base = values [ins->inst_destbasereg];
5221                         if (ins->inst_offset % size != 0) {
5222                                 /* Unaligned store */
5223                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
5224                                 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
5225                         } else {
5226                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
5227                                 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
5228                         }
5229                         emit_store (ctx, bb, &builder, size, convert (ctx, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), t), convert (ctx, addr, LLVMPointerType (t, 0)), base, is_volatile);
5230                         break;
5231                 }
5232
5233                 case OP_CHECK_THIS:
5234                         emit_load_general (ctx, bb, &builder, sizeof (gpointer), convert (ctx, lhs, LLVMPointerType (IntPtrType (), 0)), lhs, "", TRUE, LLVM_BARRIER_NONE);
5235                         break;
5236                 case OP_OUTARG_VTRETADDR:
5237                         break;
5238                 case OP_VOIDCALL:
5239                 case OP_CALL:
5240                 case OP_LCALL:
5241                 case OP_FCALL:
5242                 case OP_RCALL:
5243                 case OP_VCALL:
5244                 case OP_VOIDCALL_MEMBASE:
5245                 case OP_CALL_MEMBASE:
5246                 case OP_LCALL_MEMBASE:
5247                 case OP_FCALL_MEMBASE:
5248                 case OP_RCALL_MEMBASE:
5249                 case OP_VCALL_MEMBASE:
5250                 case OP_VOIDCALL_REG:
5251                 case OP_CALL_REG:
5252                 case OP_LCALL_REG:
5253                 case OP_FCALL_REG:
5254                 case OP_RCALL_REG:
5255                 case OP_VCALL_REG: {
5256                         process_call (ctx, bb, &builder, ins);
5257                         break;
5258                 }
5259                 case OP_AOTCONST: {
5260                         guint32 got_offset;
5261                         LLVMValueRef indexes [2];
5262                         MonoJumpInfo *tmp_ji, *ji;
5263                         LLVMValueRef got_entry_addr;
5264                         char *name;
5265
5266                         /*
5267                          * FIXME: Can't allocate from the cfg mempool since that is freed if
5268                          * the LLVM compile fails.
5269                          */
5270                         tmp_ji = g_new0 (MonoJumpInfo, 1);
5271                         tmp_ji->type = (MonoJumpInfoType)ins->inst_c1;
5272                         tmp_ji->data.target = ins->inst_p0;
5273
5274                         ji = mono_aot_patch_info_dup (tmp_ji);
5275                         g_free (tmp_ji);
5276
5277                         if (ji->type == MONO_PATCH_INFO_ICALL_ADDR) {
5278                                 char *symbol = mono_aot_get_direct_call_symbol (MONO_PATCH_INFO_ICALL_ADDR_CALL, ji->data.target);
5279                                 if (symbol) {
5280                                         /*
5281                                          * Avoid emitting a got entry for these since the method is directly called, and it might not be
5282                                          * resolvable at runtime using dlsym ().
5283                                          */
5284                                         g_free (symbol);
5285                                         values [ins->dreg] = LLVMConstInt (IntPtrType (), 0, FALSE);
5286                                         break;
5287                                 }
5288                         }
5289
5290                         ji->next = cfg->patch_info;
5291                         cfg->patch_info = ji;
5292
5293                         //mono_add_patch_info (cfg, 0, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
5294                         got_offset = mono_aot_get_got_offset (cfg->patch_info);
5295                         ctx->module->max_got_offset = MAX (ctx->module->max_got_offset, got_offset);
5296                         if (!mono_aot_is_shared_got_offset (got_offset)) {
5297                                 //mono_print_ji (ji);
5298                                 //printf ("\n");
5299                                 ctx->has_got_access = TRUE;
5300                         }
5301
5302                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
5303                         indexes [1] = LLVMConstInt (LLVMInt32Type (), (gssize)got_offset, FALSE);
5304                         got_entry_addr = LLVMBuildGEP (builder, ctx->module->got_var, indexes, 2, "");
5305
5306                         name = get_aotconst_name (ji->type, ji->data.target, got_offset);
5307                         values [ins->dreg] = LLVMBuildLoad (builder, got_entry_addr, name);
5308                         g_free (name);
5309                         /* Can't use this in llvmonly mode since the got slots are initialized by the methods themselves */
5310                         if (!cfg->llvm_only)
5311                                 set_invariant_load_flag (values [ins->dreg]);
5312                         break;
5313                 }
5314                 case OP_NOT_REACHED:
5315                         LLVMBuildUnreachable (builder);
5316                         has_terminator = TRUE;
5317                         g_assert (bb->block_num < cfg->max_block_num);
5318                         ctx->unreachable [bb->block_num] = TRUE;
5319                         /* Might have instructions after this */
5320                         while (ins->next) {
5321                                 MonoInst *next = ins->next;
5322                                 /*
5323                                  * FIXME: If later code uses the regs defined by these instructions,
5324                                  * compilation will fail.
5325                                  */
5326                                 MONO_DELETE_INS (bb, next);
5327                         }
5328                         break;
5329                 case OP_LDADDR: {
5330                         MonoInst *var = ins->inst_i0;
5331
5332                         if (var->opcode == OP_VTARG_ADDR) {
5333                                 /* The variable contains the vtype address */
5334                                 values [ins->dreg] = values [var->dreg];
5335                         } else if (var->opcode == OP_GSHAREDVT_LOCAL) {
5336                                 values [ins->dreg] = emit_gsharedvt_ldaddr (ctx, var->dreg);
5337                         } else {
5338                                 values [ins->dreg] = addresses [var->dreg];
5339                         }
5340                         break;
5341                 }
5342                 case OP_SIN: {
5343                         LLVMValueRef args [1];
5344
5345                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
5346                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.sin.f64"), args, 1, dname);
5347                         break;
5348                 }
5349                 case OP_COS: {
5350                         LLVMValueRef args [1];
5351
5352                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
5353                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.cos.f64"), args, 1, dname);
5354                         break;
5355                 }
5356                 case OP_SQRT: {
5357                         LLVMValueRef args [1];
5358
5359                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
5360                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.sqrt.f64"), args, 1, dname);
5361                         break;
5362                 }
5363                 case OP_ABS: {
5364                         LLVMValueRef args [1];
5365
5366                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
5367                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, "fabs"), args, 1, dname);
5368                         break;
5369                 }
5370
5371                 case OP_IMIN:
5372                 case OP_LMIN:
5373                 case OP_IMAX:
5374                 case OP_LMAX:
5375                 case OP_IMIN_UN:
5376                 case OP_LMIN_UN:
5377                 case OP_IMAX_UN:
5378                 case OP_LMAX_UN: {
5379                         LLVMValueRef v;
5380
5381                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
5382                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
5383
5384                         switch (ins->opcode) {
5385                         case OP_IMIN:
5386                         case OP_LMIN:
5387                                 v = LLVMBuildICmp (builder, LLVMIntSLE, lhs, rhs, "");
5388                                 break;
5389                         case OP_IMAX:
5390                         case OP_LMAX:
5391                                 v = LLVMBuildICmp (builder, LLVMIntSGE, lhs, rhs, "");
5392                                 break;
5393                         case OP_IMIN_UN:
5394                         case OP_LMIN_UN:
5395                                 v = LLVMBuildICmp (builder, LLVMIntULE, lhs, rhs, "");
5396                                 break;
5397                         case OP_IMAX_UN:
5398                         case OP_LMAX_UN:
5399                                 v = LLVMBuildICmp (builder, LLVMIntUGE, lhs, rhs, "");
5400                                 break;
5401                         default:
5402                                 g_assert_not_reached ();
5403                                 break;
5404                         }
5405                         values [ins->dreg] = LLVMBuildSelect (builder, v, lhs, rhs, dname);
5406                         break;
5407                 }
5408
5409 /*
5410  * See the ARM64 comment in mono/utils/atomic.h for an explanation of why this
5411  * hack is necessary (for now).
5412  */
5413 #ifdef TARGET_ARM64
5414 #define ARM64_ATOMIC_FENCE_FIX mono_llvm_build_fence (builder, LLVM_BARRIER_SEQ)
5415 #else
5416 #define ARM64_ATOMIC_FENCE_FIX
5417 #endif
5418
5419                 case OP_ATOMIC_EXCHANGE_I4:
5420                 case OP_ATOMIC_EXCHANGE_I8: {
5421                         LLVMValueRef args [2];
5422                         LLVMTypeRef t;
5423
5424                         if (ins->opcode == OP_ATOMIC_EXCHANGE_I4)
5425                                 t = LLVMInt32Type ();
5426                         else
5427                                 t = LLVMInt64Type ();
5428
5429                         g_assert (ins->inst_offset == 0);
5430
5431                         args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
5432                         args [1] = convert (ctx, rhs, t);
5433
5434                         ARM64_ATOMIC_FENCE_FIX;
5435                         values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
5436                         ARM64_ATOMIC_FENCE_FIX;
5437                         break;
5438                 }
5439                 case OP_ATOMIC_ADD_I4:
5440                 case OP_ATOMIC_ADD_I8: {
5441                         LLVMValueRef args [2];
5442                         LLVMTypeRef t;
5443
5444                         if (ins->opcode == OP_ATOMIC_ADD_I4)
5445                                 t = LLVMInt32Type ();
5446                         else
5447                                 t = LLVMInt64Type ();
5448
5449                         g_assert (ins->inst_offset == 0);
5450
5451                         args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
5452                         args [1] = convert (ctx, rhs, t);
5453                         ARM64_ATOMIC_FENCE_FIX;
5454                         values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
5455                         ARM64_ATOMIC_FENCE_FIX;
5456                         break;
5457                 }
5458                 case OP_ATOMIC_CAS_I4:
5459                 case OP_ATOMIC_CAS_I8: {
5460                         LLVMValueRef args [3], val;
5461                         LLVMTypeRef t;
5462
5463                         if (ins->opcode == OP_ATOMIC_CAS_I4)
5464                                 t = LLVMInt32Type ();
5465                         else
5466                                 t = LLVMInt64Type ();
5467
5468                         args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
5469                         /* comparand */
5470                         args [1] = convert (ctx, values [ins->sreg3], t);
5471                         /* new value */
5472                         args [2] = convert (ctx, values [ins->sreg2], t);
5473                         ARM64_ATOMIC_FENCE_FIX;
5474                         val = mono_llvm_build_cmpxchg (builder, args [0], args [1], args [2]);
5475                         ARM64_ATOMIC_FENCE_FIX;
5476                         /* cmpxchg returns a pair */
5477                         values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, "");
5478                         break;
5479                 }
5480                 case OP_MEMORY_BARRIER: {
5481                         mono_llvm_build_fence (builder, (BarrierKind) ins->backend.memory_barrier_kind);
5482                         break;
5483                 }
5484                 case OP_ATOMIC_LOAD_I1:
5485                 case OP_ATOMIC_LOAD_I2:
5486                 case OP_ATOMIC_LOAD_I4:
5487                 case OP_ATOMIC_LOAD_I8:
5488                 case OP_ATOMIC_LOAD_U1:
5489                 case OP_ATOMIC_LOAD_U2:
5490                 case OP_ATOMIC_LOAD_U4:
5491                 case OP_ATOMIC_LOAD_U8:
5492                 case OP_ATOMIC_LOAD_R4:
5493                 case OP_ATOMIC_LOAD_R8: {
5494 #if LLVM_API_VERSION > 100
5495                         int size;
5496                         gboolean sext, zext;
5497                         LLVMTypeRef t;
5498                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
5499                         BarrierKind barrier = (BarrierKind) ins->backend.memory_barrier_kind;
5500                         LLVMValueRef index, addr;
5501
5502                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
5503
5504                         if (sext || zext)
5505                                 dname = (char *)"";
5506
5507                         if (ins->inst_offset != 0) {
5508                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
5509                                 addr = LLVMBuildGEP (builder, convert (ctx, lhs, LLVMPointerType (t, 0)), &index, 1, "");
5510                         } else {
5511                                 addr = lhs;
5512                         }
5513
5514                         addr = convert (ctx, addr, LLVMPointerType (t, 0));
5515
5516                         ARM64_ATOMIC_FENCE_FIX;
5517                         values [ins->dreg] = emit_load_general (ctx, bb, &builder, size, addr, lhs, dname, is_volatile, barrier);
5518                         ARM64_ATOMIC_FENCE_FIX;
5519
5520                         if (sext)
5521                                 values [ins->dreg] = LLVMBuildSExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
5522                         else if (zext)
5523                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
5524                         break;
5525 #else
5526                         set_failure (ctx, "atomic mono.load intrinsic");
5527                         break;
5528 #endif
5529                 }
5530                 case OP_ATOMIC_STORE_I1:
5531                 case OP_ATOMIC_STORE_I2:
5532                 case OP_ATOMIC_STORE_I4:
5533                 case OP_ATOMIC_STORE_I8:
5534                 case OP_ATOMIC_STORE_U1:
5535                 case OP_ATOMIC_STORE_U2:
5536                 case OP_ATOMIC_STORE_U4:
5537                 case OP_ATOMIC_STORE_U8:
5538                 case OP_ATOMIC_STORE_R4:
5539                 case OP_ATOMIC_STORE_R8: {
5540                         int size;
5541                         gboolean sext, zext;
5542                         LLVMTypeRef t;
5543                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
5544                         BarrierKind barrier = (BarrierKind) ins->backend.memory_barrier_kind;
5545                         LLVMValueRef index, addr, value, base;
5546
5547 #if LLVM_API_VERSION < 100
5548                         if (!cfg->llvm_only) {
5549                                 set_failure (ctx, "atomic mono.store intrinsic");
5550                                 break;
5551                         }
5552 #endif
5553
5554                         if (!values [ins->inst_destbasereg]) {
5555                             set_failure (ctx, "inst_destbasereg");
5556                                 break;
5557                         }
5558
5559                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
5560
5561                         base = values [ins->inst_destbasereg];
5562                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
5563                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
5564                         value = convert (ctx, values [ins->sreg1], t);
5565
5566                         ARM64_ATOMIC_FENCE_FIX;
5567                         emit_store_general (ctx, bb, &builder, size, value, addr, base, is_volatile, barrier);
5568                         ARM64_ATOMIC_FENCE_FIX;
5569                         break;
5570                 }
5571                 case OP_RELAXED_NOP: {
5572 #if defined(TARGET_AMD64) || defined(TARGET_X86)
5573                         emit_call (ctx, bb, &builder, get_intrinsic (ctx, "llvm.x86.sse2.pause"), NULL, 0);
5574                         break;
5575 #else
5576                         break;
5577 #endif
5578                 }
5579                 case OP_TLS_GET: {
5580 #if (defined(TARGET_AMD64) || defined(TARGET_X86)) && defined(__linux__)
5581 #ifdef TARGET_AMD64
5582                         // 257 == FS segment register
5583                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 257);
5584 #else
5585                         // 256 == GS segment register
5586                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
5587 #endif
5588                         // FIXME: XEN
5589                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), ins->inst_offset, TRUE), ptrtype, ""), "");
5590 #elif defined(TARGET_AMD64) && defined(TARGET_OSX)
5591                         /* See mono_amd64_emit_tls_get () */
5592                         int offset = mono_amd64_get_tls_gs_offset () + (ins->inst_offset * 8);
5593
5594                         // 256 == GS segment register
5595                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
5596                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), offset, TRUE), ptrtype, ""), "");
5597 #else
5598                         set_failure (ctx, "opcode tls-get");
5599                         break;
5600 #endif
5601
5602                         break;
5603                 }
5604                 case OP_TLS_GET_REG: {
5605 #if defined(TARGET_AMD64) && defined(__linux__)
5606                         // 257 == FS segment register
5607                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 257);
5608                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, convert (ctx, lhs, LLVMInt64Type ()), ptrtype, ""), "");
5609 #elif defined(TARGET_AMD64) && defined(TARGET_OSX)
5610                         /* See emit_tls_get_reg () */
5611                         // 256 == GS segment register
5612                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
5613                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, convert (ctx, lhs, LLVMInt32Type ()), ptrtype, ""), "");
5614 #else
5615                         set_failure (ctx, "opcode tls-get");
5616                         break;
5617 #endif
5618                         break;
5619                 }
5620
5621                 case OP_TLS_SET_REG: {
5622 #if defined(TARGET_AMD64) && defined(TARGET_OSX)
5623                         /* See emit_tls_get_reg () */
5624                         // 256 == GS segment register
5625                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
5626                         LLVMBuildStore (builder, convert (ctx, lhs, IntPtrType ()), LLVMBuildIntToPtr (builder, convert (ctx, rhs, LLVMInt32Type ()), ptrtype, ""));
5627 #else
5628                         set_failure (ctx, "opcode tls-set-reg");
5629                         break;
5630 #endif
5631                         break;
5632                 }
5633                 case OP_GC_SAFE_POINT: {
5634                         LLVMValueRef val, cmp, callee;
5635                         LLVMBasicBlockRef poll_bb, cont_bb;
5636                         static LLVMTypeRef sig;
5637                         const char *icall_name = "mono_threads_state_poll";
5638
5639                         if (!sig)
5640                                 sig = LLVMFunctionType0 (LLVMVoidType (), FALSE);
5641
5642                         /*
5643                          * if (!*sreg1)
5644                          *   mono_threads_state_poll ();
5645                          * FIXME: Use a preserveall wrapper
5646                          */
5647                         val = mono_llvm_build_load (builder, convert (ctx, lhs, LLVMPointerType (IntPtrType (), 0)), "", TRUE);
5648                         cmp = LLVMBuildICmp (builder, LLVMIntEQ, val, LLVMConstNull (LLVMTypeOf (val)), "");
5649                         poll_bb = gen_bb (ctx, "POLL_BB");
5650                         cont_bb = gen_bb (ctx, "CONT_BB");
5651                         LLVMBuildCondBr (builder, cmp, cont_bb, poll_bb);
5652
5653                         ctx->builder = builder = create_builder (ctx);
5654                         LLVMPositionBuilderAtEnd (builder, poll_bb);
5655
5656                         if (ctx->cfg->compile_aot) {
5657                                 callee = get_callee (ctx, sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
5658                         } else {
5659                                 gpointer target = resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
5660                                 callee = emit_jit_callee (ctx, icall_name, sig, target);
5661                         }
5662                         LLVMBuildCall (builder, callee, NULL, 0, "");
5663                         LLVMBuildBr (builder, cont_bb);
5664
5665                         ctx->builder = builder = create_builder (ctx);
5666                         LLVMPositionBuilderAtEnd (builder, cont_bb);
5667                         ctx->bblocks [bb->block_num].end_bblock = cont_bb;
5668                         break;
5669                 }
5670
5671                         /*
5672                          * Overflow opcodes.
5673                          */
5674                 case OP_IADD_OVF:
5675                 case OP_IADD_OVF_UN:
5676                 case OP_ISUB_OVF:
5677                 case OP_ISUB_OVF_UN:
5678                 case OP_IMUL_OVF:
5679                 case OP_IMUL_OVF_UN:
5680                 case OP_LADD_OVF:
5681                 case OP_LADD_OVF_UN:
5682                 case OP_LSUB_OVF:
5683                 case OP_LSUB_OVF_UN:
5684                 case OP_LMUL_OVF:
5685                 case OP_LMUL_OVF_UN:
5686                         {
5687                                 LLVMValueRef args [2], val, ovf, func;
5688
5689                                 args [0] = convert (ctx, lhs, op_to_llvm_type (ins->opcode));
5690                                 args [1] = convert (ctx, rhs, op_to_llvm_type (ins->opcode));
5691                                 func = get_intrinsic (ctx, ovf_op_to_intrins (ins->opcode));
5692                                 g_assert (func);
5693                                 val = LLVMBuildCall (builder, func, args, 2, "");
5694                                 values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, dname);
5695                                 ovf = LLVMBuildExtractValue (builder, val, 1, "");
5696                                 emit_cond_system_exception (ctx, bb, "OverflowException", ovf);
5697                                 if (!ctx_ok (ctx))
5698                                         break;
5699                                 builder = ctx->builder;
5700                                 break;
5701                         }
5702
5703                         /*
5704                          * Valuetypes.
5705                          *   We currently model them using arrays. Promotion to local vregs is
5706                          * disabled for them in mono_handle_global_vregs () in the LLVM case,
5707                          * so we always have an entry in cfg->varinfo for them.
5708                          * FIXME: Is this needed ?
5709                          */
5710                 case OP_VZERO: {
5711                         MonoClass *klass = ins->klass;
5712                         LLVMValueRef args [5];
5713
5714                         if (!klass) {
5715                                 // FIXME:
5716                                 set_failure (ctx, "!klass");
5717                                 break;
5718                         }
5719
5720                         if (!addresses [ins->dreg])
5721                                 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
5722                         args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
5723                         args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
5724                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
5725                         // FIXME: Alignment
5726                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
5727                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
5728                         LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.memset.p0i8.i32"), args, 5, "");
5729                         break;
5730                 }
5731                 case OP_DUMMY_VZERO:
5732                         break;
5733
5734                 case OP_STOREV_MEMBASE:
5735                 case OP_LOADV_MEMBASE:
5736                 case OP_VMOVE: {
5737                         MonoClass *klass = ins->klass;
5738                         LLVMValueRef src = NULL, dst, args [5];
5739                         gboolean done = FALSE;
5740
5741                         if (!klass) {
5742                                 // FIXME:
5743                                 set_failure (ctx, "!klass");
5744                                 break;
5745                         }
5746
5747                         if (mini_is_gsharedvt_klass (klass)) {
5748                                 // FIXME:
5749                                 set_failure (ctx, "gsharedvt");
5750                                 break;
5751                         }
5752
5753                         switch (ins->opcode) {
5754                         case OP_STOREV_MEMBASE:
5755                                 if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg &&
5756                                         LLVMGetInstructionOpcode (values [ins->inst_destbasereg]) != LLVMAlloca) {
5757                                         /* Decomposed earlier */
5758                                         g_assert_not_reached ();
5759                                         break;
5760                                 }
5761                                 if (!addresses [ins->sreg1]) {
5762                                         /* SIMD */
5763                                         g_assert (values [ins->sreg1]);
5764                                         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));
5765                                         LLVMBuildStore (builder, values [ins->sreg1], dst);
5766                                         done = TRUE;
5767                                 } else {
5768                                         src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
5769                                         dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
5770                                 }
5771                                 break;
5772                         case OP_LOADV_MEMBASE:
5773                                 if (!addresses [ins->dreg])
5774                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
5775                                 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
5776                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
5777                                 break;
5778                         case OP_VMOVE:
5779                                 if (!addresses [ins->sreg1])
5780                                         addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
5781                                 if (!addresses [ins->dreg])
5782                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
5783                                 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
5784                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
5785                                 break;
5786                         default:
5787                                 g_assert_not_reached ();
5788                         }
5789                         if (!ctx_ok (ctx))
5790                                 break;
5791
5792                         if (done)
5793                                 break;
5794
5795                         args [0] = dst;
5796                         args [1] = src;
5797                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
5798                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
5799                         // FIXME: Alignment
5800                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
5801                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
5802                         LLVMBuildCall (builder, get_intrinsic (ctx, "llvm.memcpy.p0i8.p0i8.i32"), args, 5, "");
5803                         break;
5804                 }
5805                 case OP_LLVM_OUTARG_VT: {
5806                         LLVMArgInfo *ainfo = (LLVMArgInfo*)ins->inst_p0;
5807                         MonoType *t = mini_get_underlying_type (ins->inst_vtype);
5808
5809                         if (ainfo->storage == LLVMArgGsharedvtVariable) {
5810                                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg1);
5811
5812                                         if (var && var->opcode == OP_GSHAREDVT_LOCAL) {
5813                                                 addresses [ins->dreg] = convert (ctx, emit_gsharedvt_ldaddr (ctx, var->dreg), LLVMPointerType (IntPtrType (), 0));
5814                                         } else {
5815                                                 g_assert (addresses [ins->sreg1]);
5816                                                 addresses [ins->dreg] = addresses [ins->sreg1];
5817                                         }
5818                         } else if (ainfo->storage == LLVMArgGsharedvtFixed) {
5819                                 if (!addresses [ins->sreg1]) {
5820                                         addresses [ins->sreg1] = build_alloca (ctx, t);
5821                                         g_assert (values [ins->sreg1]);
5822                                 }
5823                                 LLVMBuildStore (builder, convert (ctx, values [ins->sreg1], LLVMGetElementType (LLVMTypeOf (addresses [ins->sreg1]))), addresses [ins->sreg1]);
5824                                 addresses [ins->dreg] = addresses [ins->sreg1];
5825                         } else {
5826                                 if (!addresses [ins->sreg1]) {
5827                                         addresses [ins->sreg1] = build_alloca (ctx, t);
5828                                         g_assert (values [ins->sreg1]);
5829                                         LLVMBuildStore (builder, convert (ctx, values [ins->sreg1], type_to_llvm_type (ctx, t)), addresses [ins->sreg1]);
5830                                 }
5831                                 addresses [ins->dreg] = addresses [ins->sreg1];
5832                         }
5833                         break;
5834                 }
5835                 case OP_OBJC_GET_SELECTOR: {
5836                         const char *name = (const char*)ins->inst_p0;
5837                         LLVMValueRef var;
5838
5839                         if (!ctx->module->objc_selector_to_var)
5840                                 ctx->module->objc_selector_to_var = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
5841                         var = g_hash_table_lookup (ctx->module->objc_selector_to_var, name);
5842                         if (!var) {
5843                                 LLVMValueRef indexes [16];
5844
5845                                 LLVMValueRef name_var = LLVMAddGlobal (ctx->lmodule, LLVMArrayType (LLVMInt8Type (), strlen (name) + 1), "@OBJC_METH_VAR_NAME_");
5846                                 LLVMSetInitializer (name_var, mono_llvm_create_constant_data_array ((const uint8_t*)name, strlen (name) + 1));
5847                                 LLVMSetLinkage (name_var, LLVMPrivateLinkage);
5848                                 LLVMSetSection (name_var, "__TEXT,__objc_methname,cstring_literals");
5849                                 mark_as_used (ctx->module, name_var);
5850
5851                                 LLVMValueRef ref_var = LLVMAddGlobal (ctx->lmodule, LLVMPointerType (LLVMInt8Type (), 0), "@OBJC_SELECTOR_REFERENCES_");
5852
5853                                 indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, 0);
5854                                 indexes [1] = LLVMConstInt (LLVMInt32Type (), 0, 0);
5855                                 LLVMSetInitializer (ref_var, LLVMConstGEP (name_var, indexes, 2));
5856                                 LLVMSetLinkage (ref_var, LLVMPrivateLinkage);
5857                                 LLVMSetExternallyInitialized (ref_var, TRUE);
5858                                 LLVMSetSection (ref_var, "__DATA, __objc_selrefs, literal_pointers, no_dead_strip");
5859                                 LLVMSetAlignment (ref_var, sizeof (mgreg_t));
5860                                 mark_as_used (ctx->module, ref_var);
5861
5862                                 g_hash_table_insert (ctx->module->objc_selector_to_var, g_strdup (name), ref_var);
5863                                 var = ref_var;
5864                         }
5865
5866                         values [ins->dreg] = LLVMBuildLoad (builder, var, "");
5867                         break;
5868                 }
5869
5870                         /*
5871                          * SIMD
5872                          */
5873 #if defined(TARGET_X86) || defined(TARGET_AMD64)
5874                 case OP_XZERO: {
5875                         values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
5876                         break;
5877                 }
5878                 case OP_LOADX_MEMBASE: {
5879                         LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
5880                         LLVMValueRef src;
5881
5882                         src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
5883                         values [ins->dreg] = mono_llvm_build_aligned_load (builder, src, "", FALSE, 1);
5884                         break;
5885                 }
5886                 case OP_STOREX_MEMBASE: {
5887                         LLVMTypeRef t = LLVMTypeOf (values [ins->sreg1]);
5888                         LLVMValueRef dest;
5889
5890                         dest = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
5891                         mono_llvm_build_aligned_store (builder, values [ins->sreg1], dest, FALSE, 1);
5892                         break;
5893                 }
5894                 case OP_PADDB:
5895                 case OP_PADDW:
5896                 case OP_PADDD:
5897                 case OP_PADDQ:
5898                         values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, "");
5899                         break;
5900                 case OP_ADDPD:
5901                 case OP_ADDPS:
5902                         values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, "");
5903                         break;
5904                 case OP_PSUBB:
5905                 case OP_PSUBW:
5906                 case OP_PSUBD:
5907                 case OP_PSUBQ:
5908                         values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, "");
5909                         break;
5910                 case OP_SUBPD:
5911                 case OP_SUBPS:
5912                         values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, "");
5913                         break;
5914                 case OP_MULPD:
5915                 case OP_MULPS:
5916                         values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, "");
5917                         break;
5918                 case OP_DIVPD:
5919                 case OP_DIVPS:
5920                         values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, "");
5921                         break;
5922                 case OP_PAND:
5923                         values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, "");
5924                         break;
5925                 case OP_POR:
5926                         values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, "");
5927                         break;
5928                 case OP_PXOR:
5929                         values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, "");
5930                         break;
5931                 case OP_PMULW:
5932                 case OP_PMULD:
5933                         values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, "");
5934                         break;
5935                 case OP_ANDPS:
5936                 case OP_ANDNPS:
5937                 case OP_ORPS:
5938                 case OP_XORPS:
5939                 case OP_ANDPD:
5940                 case OP_ANDNPD:
5941                 case OP_ORPD:
5942                 case OP_XORPD: {
5943                         LLVMTypeRef t, rt;
5944                         LLVMValueRef v = NULL;
5945
5946                         switch (ins->opcode) {
5947                         case OP_ANDPS:
5948                         case OP_ANDNPS:
5949                         case OP_ORPS:
5950                         case OP_XORPS:
5951                                 t = LLVMVectorType (LLVMInt32Type (), 4);
5952                                 rt = LLVMVectorType (LLVMFloatType (), 4);
5953                                 break;
5954                         case OP_ANDPD:
5955                         case OP_ANDNPD:
5956                         case OP_ORPD:
5957                         case OP_XORPD:
5958                                 t = LLVMVectorType (LLVMInt64Type (), 2);
5959                                 rt = LLVMVectorType (LLVMDoubleType (), 2);
5960                                 break;
5961                         default:
5962                                 t = LLVMInt32Type ();
5963                                 rt = LLVMInt32Type ();
5964                                 g_assert_not_reached ();
5965                         }
5966
5967                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
5968                         rhs = LLVMBuildBitCast (builder, rhs, t, "");
5969                         switch (ins->opcode) {
5970                         case OP_ANDPS:
5971                         case OP_ANDPD:
5972                                 v = LLVMBuildAnd (builder, lhs, rhs, "");
5973                                 break;
5974                         case OP_ORPS:
5975                         case OP_ORPD:
5976                                 v = LLVMBuildOr (builder, lhs, rhs, "");
5977                                 break;
5978                         case OP_XORPS:
5979                         case OP_XORPD:
5980                                 v = LLVMBuildXor (builder, lhs, rhs, "");
5981                                 break;
5982                         case OP_ANDNPS:
5983                         case OP_ANDNPD:
5984                                 v = LLVMBuildAnd (builder, rhs, LLVMBuildNot (builder, lhs, ""), "");
5985                                 break;
5986                         }
5987                         values [ins->dreg] = LLVMBuildBitCast (builder, v, rt, "");
5988                         break;
5989                 }
5990                 case OP_PMIND_UN:
5991                 case OP_PMINW_UN:
5992                 case OP_PMINB_UN: {
5993                         LLVMValueRef cmp = LLVMBuildICmp (builder, LLVMIntULT, lhs, rhs, "");
5994                         values [ins->dreg] = LLVMBuildSelect (builder, cmp, lhs, rhs, "");
5995                         break;
5996                 }
5997                 case OP_PMAXD_UN:
5998                 case OP_PMAXW_UN:
5999                 case OP_PMAXB_UN: {
6000                         LLVMValueRef cmp = LLVMBuildICmp (builder, LLVMIntUGT, lhs, rhs, "");
6001                         values [ins->dreg] = LLVMBuildSelect (builder, cmp, lhs, rhs, "");
6002                         break;
6003                 }
6004                 case OP_PMINW: {
6005                         LLVMValueRef cmp = LLVMBuildICmp (builder, LLVMIntSLT, lhs, rhs, "");
6006                         values [ins->dreg] = LLVMBuildSelect (builder, cmp, lhs, rhs, "");
6007                         break;
6008                 }
6009                 case OP_MINPD:
6010                 case OP_MINPS:
6011                 case OP_MAXPD:
6012                 case OP_MAXPS:
6013                 case OP_ADDSUBPD:
6014                 case OP_ADDSUBPS:
6015                 case OP_HADDPD:
6016                 case OP_HADDPS:
6017                 case OP_HSUBPD:
6018                 case OP_HSUBPS:
6019                 case OP_PADDB_SAT:
6020                 case OP_PADDW_SAT:
6021                 case OP_PSUBB_SAT:
6022                 case OP_PSUBW_SAT:
6023                 case OP_PADDB_SAT_UN:
6024                 case OP_PADDW_SAT_UN:
6025                 case OP_PSUBB_SAT_UN:
6026                 case OP_PSUBW_SAT_UN:
6027                 case OP_PAVGB_UN:
6028                 case OP_PAVGW_UN:
6029                 case OP_PACKW:
6030                 case OP_PACKD:
6031                 case OP_PACKW_UN:
6032                 case OP_PACKD_UN:
6033                 case OP_PMULW_HIGH:
6034                 case OP_PMULW_HIGH_UN: {
6035                         LLVMValueRef args [2];
6036
6037                         args [0] = lhs;
6038                         args [1] = rhs;
6039
6040                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 2, dname);
6041                         break;
6042                 }
6043                 case OP_PCMPEQB:
6044                 case OP_PCMPEQW:
6045                 case OP_PCMPEQD:
6046                 case OP_PCMPEQQ: {
6047                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntEQ, lhs, rhs, ""), LLVMTypeOf (lhs), "");
6048                         break;
6049                 }
6050                 case OP_PCMPGTB: {
6051                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntSGT, lhs, rhs, ""), LLVMTypeOf (lhs), "");
6052                         break;
6053                 }
6054                 case OP_EXTRACT_R8:
6055                 case OP_EXTRACT_I8:
6056                 case OP_EXTRACT_I4:
6057                 case OP_EXTRACT_I2:
6058                 case OP_EXTRACT_U2:
6059                 case OP_EXTRACTX_U2:
6060                 case OP_EXTRACT_I1:
6061                 case OP_EXTRACT_U1: {
6062                         LLVMTypeRef t;
6063                         gboolean zext = FALSE;
6064
6065                         t = simd_op_to_llvm_type (ins->opcode);
6066
6067                         switch (ins->opcode) {
6068                         case OP_EXTRACT_R8:
6069                         case OP_EXTRACT_I8:
6070                         case OP_EXTRACT_I4:
6071                         case OP_EXTRACT_I2:
6072                         case OP_EXTRACT_I1:
6073                                 break;
6074                         case OP_EXTRACT_U2:
6075                         case OP_EXTRACTX_U2:
6076                         case OP_EXTRACT_U1:
6077                                 zext = TRUE;
6078                                 break;
6079                         default:
6080                                 t = LLVMInt32Type ();
6081                                 g_assert_not_reached ();
6082                         }
6083
6084                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
6085                         values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
6086                         if (zext)
6087                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
6088                         break;
6089                 }
6090
6091                 case OP_EXPAND_I1:
6092                 case OP_EXPAND_I2:
6093                 case OP_EXPAND_I4:
6094                 case OP_EXPAND_I8:
6095                 case OP_EXPAND_R4:
6096                 case OP_EXPAND_R8: {
6097                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
6098                         LLVMValueRef mask [16], v;
6099                         int i;
6100
6101                         for (i = 0; i < 16; ++i)
6102                                 mask [i] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
6103
6104                         v = convert (ctx, values [ins->sreg1], LLVMGetElementType (t));
6105
6106                         values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (t), v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6107                         values [ins->dreg] = LLVMBuildShuffleVector (builder, values [ins->dreg], LLVMGetUndef (t), LLVMConstVector (mask, LLVMGetVectorSize (t)), "");
6108                         break;
6109                 }
6110
6111                 case OP_INSERT_I1:
6112                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6113                         break;
6114                 case OP_INSERT_I2:
6115                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6116                         break;
6117                 case OP_INSERT_I4:
6118                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6119                         break;
6120                 case OP_INSERT_I8:
6121                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6122                         break;
6123                 case OP_INSERT_R4:
6124                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6125                         break;
6126                 case OP_INSERT_R8:
6127                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
6128                         break;
6129
6130 #if 0
6131                         // Requires a later llvm version
6132                 case OP_CVTDQ2PD: {
6133                         LLVMValueRef indexes [16];
6134
6135                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
6136                         indexes [1] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
6137                         LLVMValueRef mask = LLVMConstVector (indexes, 2);
6138                         LLVMValueRef shuffle = LLVMBuildShuffleVector (builder, lhs, LLVMConstNull (LLVMTypeOf (lhs)), mask, "");
6139                         values [ins->dreg] = LLVMBuildSIToFP (builder, shuffle, LLVMVectorType (LLVMDoubleType (), 2), dname);
6140                         break;
6141                 }
6142                 case OP_CVTPS2PD: {
6143                         LLVMValueRef indexes [16];
6144
6145                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
6146                         indexes [1] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
6147                         LLVMValueRef mask = LLVMConstVector (indexes, 2);
6148                         LLVMValueRef shuffle = LLVMBuildShuffleVector (builder, lhs, LLVMConstNull (LLVMTypeOf (lhs)), mask, "");
6149                         values [ins->dreg] = LLVMBuildFPExt (builder, shuffle, LLVMVectorType (LLVMDoubleType (), 2), dname);
6150                         break;
6151                 }
6152                 case OP_CVTTPS2DQ:
6153                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMVectorType (LLVMInt32Type (), 4), dname);
6154                         break;
6155 #endif
6156
6157                 case OP_CVTDQ2PD:
6158                 case OP_CVTDQ2PS:
6159                 case OP_CVTPD2DQ:
6160                 case OP_CVTPS2DQ:
6161                 case OP_CVTPD2PS:
6162                 case OP_CVTPS2PD:
6163                 case OP_CVTTPD2DQ:
6164                 case OP_CVTTPS2DQ:
6165                 case OP_EXTRACT_MASK:
6166                 case OP_SQRTPS:
6167                 case OP_SQRTPD:
6168                 case OP_RSQRTPS:
6169                 case OP_RCPPS: {
6170                         LLVMValueRef v;
6171
6172                         v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
6173
6174                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
6175                         break;
6176                 }
6177                 case OP_COMPPS:
6178                 case OP_COMPPD: {
6179                         LLVMRealPredicate op;
6180
6181                         switch (ins->inst_c0) {
6182                         case SIMD_COMP_EQ:
6183                                 op = LLVMRealOEQ;
6184                                 break;
6185                         case SIMD_COMP_LT:
6186                                 op = LLVMRealOLT;
6187                                 break;
6188                         case SIMD_COMP_LE:
6189                                 op = LLVMRealOLE;
6190                                 break;
6191                         case SIMD_COMP_UNORD:
6192                                 op = LLVMRealUNO;
6193                                 break;
6194                         case SIMD_COMP_NEQ:
6195                                 op = LLVMRealUNE;
6196                                 break;
6197                         case SIMD_COMP_NLT:
6198                                 op = LLVMRealUGE;
6199                                 break;
6200                         case SIMD_COMP_NLE:
6201                                 op = LLVMRealUGT;
6202                                 break;
6203                         case SIMD_COMP_ORD:
6204                                 op = LLVMRealORD;
6205                                 break;
6206                         default:
6207                                 g_assert_not_reached ();
6208                         }
6209
6210                         LLVMValueRef cmp = LLVMBuildFCmp (builder, op, lhs, rhs, "");
6211                         if (ins->opcode == OP_COMPPD)
6212                                 values [ins->dreg] = LLVMBuildBitCast (builder, LLVMBuildSExt (builder, cmp, LLVMVectorType (LLVMInt64Type (), 2), ""), LLVMTypeOf (lhs), "");
6213                         else
6214                                 values [ins->dreg] = LLVMBuildBitCast (builder, LLVMBuildSExt (builder, cmp, LLVMVectorType (LLVMInt32Type (), 4), ""), LLVMTypeOf (lhs), "");
6215                         break;
6216                 }
6217                 case OP_ICONV_TO_X:
6218                         /* This is only used for implementing shifts by non-immediate */
6219                         values [ins->dreg] = lhs;
6220                         break;
6221
6222                 case OP_PSHRW:
6223                 case OP_PSHRD:
6224                 case OP_PSHRQ:
6225                 case OP_PSARW:
6226                 case OP_PSARD:
6227                 case OP_PSHLW:
6228                 case OP_PSHLD:
6229                 case OP_PSHLQ: {
6230                         LLVMValueRef args [3];
6231
6232                         args [0] = lhs;
6233                         args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
6234
6235                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 2, dname);
6236                         break;
6237                 }
6238
6239                 case OP_PSHRW_REG:
6240                 case OP_PSHRD_REG:
6241                 case OP_PSHRQ_REG:
6242                 case OP_PSARW_REG:
6243                 case OP_PSARD_REG:
6244                 case OP_PSHLW_REG:
6245                 case OP_PSHLD_REG:
6246                 case OP_PSHLQ_REG: {
6247                         LLVMValueRef args [3];
6248
6249                         args [0] = lhs;
6250                         args [1] = values [ins->sreg2];
6251
6252                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 2, dname);
6253                         break;
6254                 }
6255
6256                 case OP_SHUFPS:
6257                 case OP_SHUFPD:
6258                 case OP_PSHUFLED:
6259                 case OP_PSHUFLEW_LOW:
6260                 case OP_PSHUFLEW_HIGH: {
6261                         int mask [16];
6262                         LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
6263                         int i, mask_size = 0;
6264                         int imask = ins->inst_c0;
6265
6266                         /* Convert the x86 shuffle mask to LLVM's */
6267                         switch (ins->opcode) {
6268                         case OP_SHUFPS:
6269                                 mask_size = 4;
6270                                 mask [0] = ((imask >> 0) & 3);
6271                                 mask [1] = ((imask >> 2) & 3);
6272                                 mask [2] = ((imask >> 4) & 3) + 4;
6273                                 mask [3] = ((imask >> 6) & 3) + 4;
6274                                 v1 = values [ins->sreg1];
6275                                 v2 = values [ins->sreg2];
6276                                 break;
6277                         case OP_SHUFPD:
6278                                 mask_size = 2;
6279                                 mask [0] = ((imask >> 0) & 1);
6280                                 mask [1] = ((imask >> 1) & 1) + 2;
6281                                 v1 = values [ins->sreg1];
6282                                 v2 = values [ins->sreg2];
6283                                 break;
6284                         case OP_PSHUFLEW_LOW:
6285                                 mask_size = 8;
6286                                 mask [0] = ((imask >> 0) & 3);
6287                                 mask [1] = ((imask >> 2) & 3);
6288                                 mask [2] = ((imask >> 4) & 3);
6289                                 mask [3] = ((imask >> 6) & 3);
6290                                 mask [4] = 4 + 0;
6291                                 mask [5] = 4 + 1;
6292                                 mask [6] = 4 + 2;
6293                                 mask [7] = 4 + 3;
6294                                 v1 = values [ins->sreg1];
6295                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6296                                 break;
6297                         case OP_PSHUFLEW_HIGH:
6298                                 mask_size = 8;
6299                                 mask [0] = 0;
6300                                 mask [1] = 1;
6301                                 mask [2] = 2;
6302                                 mask [3] = 3;
6303                                 mask [4] = 4 + ((imask >> 0) & 3);
6304                                 mask [5] = 4 + ((imask >> 2) & 3);
6305                                 mask [6] = 4 + ((imask >> 4) & 3);
6306                                 mask [7] = 4 + ((imask >> 6) & 3);
6307                                 v1 = values [ins->sreg1];
6308                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6309                                 break;
6310                         case OP_PSHUFLED:
6311                                 mask_size = 4;
6312                                 mask [0] = ((imask >> 0) & 3);
6313                                 mask [1] = ((imask >> 2) & 3);
6314                                 mask [2] = ((imask >> 4) & 3);
6315                                 mask [3] = ((imask >> 6) & 3);
6316                                 v1 = values [ins->sreg1];
6317                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6318                                 break;
6319                         default:
6320                                 g_assert_not_reached ();
6321                         }
6322                         for (i = 0; i < mask_size; ++i)
6323                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
6324
6325                         values [ins->dreg] =
6326                                 LLVMBuildShuffleVector (builder, v1, v2,
6327                                                                                 LLVMConstVector (mask_values, mask_size), dname);
6328                         break;
6329                 }
6330
6331                 case OP_UNPACK_LOWB:
6332                 case OP_UNPACK_LOWW:
6333                 case OP_UNPACK_LOWD:
6334                 case OP_UNPACK_LOWQ:
6335                 case OP_UNPACK_LOWPS:
6336                 case OP_UNPACK_LOWPD:
6337                 case OP_UNPACK_HIGHB:
6338                 case OP_UNPACK_HIGHW:
6339                 case OP_UNPACK_HIGHD:
6340                 case OP_UNPACK_HIGHQ:
6341                 case OP_UNPACK_HIGHPS:
6342                 case OP_UNPACK_HIGHPD: {
6343                         int mask [16];
6344                         LLVMValueRef mask_values [16];
6345                         int i, mask_size = 0;
6346                         gboolean low = FALSE;
6347
6348                         switch (ins->opcode) {
6349                         case OP_UNPACK_LOWB:
6350                                 mask_size = 16;
6351                                 low = TRUE;
6352                                 break;
6353                         case OP_UNPACK_LOWW:
6354                                 mask_size = 8;
6355                                 low = TRUE;
6356                                 break;
6357                         case OP_UNPACK_LOWD:
6358                         case OP_UNPACK_LOWPS:
6359                                 mask_size = 4;
6360                                 low = TRUE;
6361                                 break;
6362                         case OP_UNPACK_LOWQ:
6363                         case OP_UNPACK_LOWPD:
6364                                 mask_size = 2;
6365                                 low = TRUE;
6366                                 break;
6367                         case OP_UNPACK_HIGHB:
6368                                 mask_size = 16;
6369                                 break;
6370                         case OP_UNPACK_HIGHW:
6371                                 mask_size = 8;
6372                                 break;
6373                         case OP_UNPACK_HIGHD:
6374                         case OP_UNPACK_HIGHPS:
6375                                 mask_size = 4;
6376                                 break;
6377                         case OP_UNPACK_HIGHQ:
6378                         case OP_UNPACK_HIGHPD:
6379                                 mask_size = 2;
6380                                 break;
6381                         default:
6382                                 g_assert_not_reached ();
6383                         }
6384
6385                         if (low) {
6386                                 for (i = 0; i < (mask_size / 2); ++i) {
6387                                         mask [(i * 2)] = i;
6388                                         mask [(i * 2) + 1] = mask_size + i;
6389                                 }
6390                         } else {
6391                                 for (i = 0; i < (mask_size / 2); ++i) {
6392                                         mask [(i * 2)] = (mask_size / 2) + i;
6393                                         mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
6394                                 }
6395                         }
6396
6397                         for (i = 0; i < mask_size; ++i)
6398                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
6399
6400                         values [ins->dreg] =
6401                                 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
6402                                                                                 LLVMConstVector (mask_values, mask_size), dname);
6403                         break;
6404                 }
6405
6406                 case OP_DUPPD: {
6407                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
6408                         LLVMValueRef v, val;
6409
6410                         v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6411                         val = LLVMConstNull (t);
6412                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6413                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
6414
6415                         values [ins->dreg] = val;
6416                         break;
6417                 }
6418                 case OP_DUPPS_LOW:
6419                 case OP_DUPPS_HIGH: {
6420                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
6421                         LLVMValueRef v1, v2, val;
6422
6423
6424                         if (ins->opcode == OP_DUPPS_LOW) {
6425                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6426                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
6427                         } else {
6428                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
6429                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
6430                         }
6431                         val = LLVMConstNull (t);
6432                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6433                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
6434                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
6435                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
6436
6437                         values [ins->dreg] = val;
6438                         break;
6439                 }
6440
6441 #endif /* SIMD */
6442
6443                 case OP_DUMMY_USE:
6444                         break;
6445
6446                         /*
6447                          * EXCEPTION HANDLING
6448                          */
6449                 case OP_IMPLICIT_EXCEPTION:
6450                         /* This marks a place where an implicit exception can happen */
6451                         if (bb->region != -1)
6452                                 set_failure (ctx, "implicit-exception");
6453                         break;
6454                 case OP_THROW:
6455                 case OP_RETHROW: {
6456                         gboolean rethrow = (ins->opcode == OP_RETHROW);
6457                         if (ctx->llvm_only) {
6458                                 emit_llvmonly_throw (ctx, bb, rethrow, lhs);
6459                                 has_terminator = TRUE;
6460                                 ctx->unreachable [bb->block_num] = TRUE;
6461                         } else {
6462                                 emit_throw (ctx, bb, rethrow, lhs);
6463                                 builder = ctx->builder;
6464                         }
6465                         break;
6466                 }
6467                 case OP_CALL_HANDLER: {
6468                         /*
6469                          * We don't 'call' handlers, but instead simply branch to them.
6470                          * The code generated by ENDFINALLY will branch back to us.
6471                          */
6472                         LLVMBasicBlockRef noex_bb;
6473                         GSList *bb_list;
6474                         BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
6475
6476                         bb_list = info->call_handler_return_bbs;
6477
6478                         /*
6479                          * Set the indicator variable for the finally clause.
6480                          */
6481                         lhs = info->finally_ind;
6482                         g_assert (lhs);
6483                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
6484
6485                         /* Branch to the finally clause */
6486                         LLVMBuildBr (builder, info->call_handler_target_bb);
6487
6488                         noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
6489                         info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
6490
6491                         builder = ctx->builder = create_builder (ctx);
6492                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
6493
6494                         bblocks [bb->block_num].end_bblock = noex_bb;
6495                         break;
6496                 }
6497                 case OP_START_HANDLER: {
6498                         break;
6499                 }
6500                 case OP_ENDFINALLY: {
6501                         LLVMBasicBlockRef resume_bb;
6502                         MonoBasicBlock *handler_bb;
6503                         LLVMValueRef val, switch_ins, callee;
6504                         GSList *bb_list;
6505                         BBInfo *info;
6506
6507                         handler_bb = (MonoBasicBlock*)g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
6508                         g_assert (handler_bb);
6509                         info = &bblocks [handler_bb->block_num];
6510                         lhs = info->finally_ind;
6511                         g_assert (lhs);
6512
6513                         bb_list = info->call_handler_return_bbs;
6514
6515                         resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
6516
6517                         /* Load the finally variable */
6518                         val = LLVMBuildLoad (builder, lhs, "");
6519
6520                         /* Reset the variable */
6521                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
6522
6523                         /* Branch to either resume_bb, or to the bblocks in bb_list */
6524                         switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
6525                         /*
6526                          * The other targets are added at the end to handle OP_CALL_HANDLER
6527                          * opcodes processed later.
6528                          */
6529                         info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
6530
6531                         builder = ctx->builder = create_builder (ctx);
6532                         LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
6533
6534                         if (ctx->llvm_only) {
6535                                 emit_resume_eh (ctx, bb);
6536                         } else {
6537                                 if (ctx->cfg->compile_aot) {
6538                                         callee = get_callee (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
6539                                 } else {
6540 #if LLVM_API_VERSION > 100
6541                                         MonoJitICallInfo *info;
6542
6543                                         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
6544                                         g_assert (info);
6545                                         gpointer target = (void*)info->func;
6546                                         LLVMTypeRef icall_sig = LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE);
6547                                         callee = emit_jit_callee (ctx, "llvm_resume_unwind_trampoline", icall_sig, target);
6548 #else
6549                                         callee = LLVMGetNamedFunction (ctx->lmodule, "llvm_resume_unwind_trampoline");
6550 #endif
6551                                 }
6552                                 LLVMBuildCall (builder, callee, NULL, 0, "");
6553                                 LLVMBuildUnreachable (builder);
6554                         }
6555
6556                         has_terminator = TRUE;
6557                         break;
6558                 }
6559                 case OP_IL_SEQ_POINT:
6560                         break;
6561                 default: {
6562                         char reason [128];
6563
6564                         sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
6565                         set_failure (ctx, reason);
6566                         break;
6567                 }
6568                 }
6569
6570                 if (!ctx_ok (ctx))
6571                         break;
6572
6573                 /* Convert the value to the type required by phi nodes */
6574                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
6575                         if (ctx->is_vphi [ins->dreg])
6576                                 /* vtypes */
6577                                 values [ins->dreg] = addresses [ins->dreg];
6578                         else
6579                                 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
6580                 }
6581
6582                 /* Add stores for volatile variables */
6583                 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
6584                         emit_volatile_store (ctx, ins->dreg);
6585         }
6586
6587         if (!ctx_ok (ctx))
6588                 return;
6589
6590         if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0)) {
6591                 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
6592         }
6593
6594         if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID) {
6595                 emit_dbg_loc (ctx, builder, cfg->header->code + cfg->header->code_size - 1);
6596                 LLVMBuildRetVoid (builder);
6597         }
6598
6599         if (bb == cfg->bb_entry)
6600                 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
6601 }
6602
6603 /*
6604  * mono_llvm_check_method_supported:
6605  *
6606  *   Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
6607  * compiling a method twice.
6608  */
6609 void
6610 mono_llvm_check_method_supported (MonoCompile *cfg)
6611 {
6612         int i, j;
6613
6614         if (cfg->llvm_only)
6615                 return;
6616
6617         if (cfg->method->save_lmf) {
6618                 cfg->exception_message = g_strdup ("lmf");
6619                 cfg->disable_llvm = TRUE;
6620         }
6621         if (cfg->disable_llvm)
6622                 return;
6623
6624         /*
6625          * Nested clauses where one of the clauses is a finally clause is
6626          * not supported, because LLVM can't figure out the control flow,
6627          * probably because we resume exception handling by calling our
6628          * own function instead of using the 'resume' llvm instruction.
6629          */
6630         for (i = 0; i < cfg->header->num_clauses; ++i) {
6631                 for (j = 0; j < cfg->header->num_clauses; ++j) {
6632                         MonoExceptionClause *clause1 = &cfg->header->clauses [i];
6633                         MonoExceptionClause *clause2 = &cfg->header->clauses [j];
6634
6635                         // FIXME: Nested try clauses fail in some cases too, i.e. #37273
6636                         if (i != j && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
6637                                 //(clause1->flags == MONO_EXCEPTION_CLAUSE_FINALLY || clause2->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
6638                                 cfg->exception_message = g_strdup ("nested clauses");
6639                                 cfg->disable_llvm = TRUE;
6640                                 break;
6641                         }
6642                 }
6643         }
6644         if (cfg->disable_llvm)
6645                 return;
6646
6647         /* FIXME: */
6648         if (cfg->method->dynamic) {
6649                 cfg->exception_message = g_strdup ("dynamic.");
6650                 cfg->disable_llvm = TRUE;
6651         }
6652         if (cfg->disable_llvm)
6653                 return;
6654 }
6655
6656 static LLVMCallInfo*
6657 get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
6658 {
6659         LLVMCallInfo *linfo;
6660         int i;
6661
6662         if (cfg->gsharedvt && cfg->llvm_only && mini_is_gsharedvt_variable_signature (sig)) {
6663                 int i, n, pindex;
6664
6665                 /*
6666                  * Gsharedvt methods have the following calling convention:
6667                  * - all arguments are passed by ref, even non generic ones
6668                  * - the return value is returned by ref too, using a vret
6669                  *   argument passed after 'this'.
6670                  */
6671                 n = sig->param_count + sig->hasthis;
6672                 linfo = (LLVMCallInfo*)mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMCallInfo) + (sizeof (LLVMArgInfo) * n));
6673
6674                 pindex = 0;
6675                 if (sig->hasthis)
6676                         linfo->args [pindex ++].storage = LLVMArgNormal;
6677
6678                 if (sig->ret->type != MONO_TYPE_VOID) {
6679                         if (mini_is_gsharedvt_variable_type (sig->ret))
6680                                 linfo->ret.storage = LLVMArgGsharedvtVariable;
6681                         else if (mini_type_is_vtype (sig->ret))
6682                                 linfo->ret.storage = LLVMArgGsharedvtFixedVtype;
6683                         else
6684                                 linfo->ret.storage = LLVMArgGsharedvtFixed;
6685                         linfo->vret_arg_index = pindex;
6686                 } else {
6687                         linfo->ret.storage = LLVMArgNone;
6688                 }
6689
6690                 for (i = 0; i < sig->param_count; ++i) {
6691                         if (sig->params [i]->byref)
6692                                 linfo->args [pindex].storage = LLVMArgNormal;
6693                         else if (mini_is_gsharedvt_variable_type (sig->params [i]))
6694                                 linfo->args [pindex].storage = LLVMArgGsharedvtVariable;
6695                         else if (mini_type_is_vtype (sig->params [i]))
6696                                 linfo->args [pindex].storage = LLVMArgGsharedvtFixedVtype;
6697                         else
6698                                 linfo->args [pindex].storage = LLVMArgGsharedvtFixed;
6699                         linfo->args [pindex].type = sig->params [i];
6700                         pindex ++;
6701                 }
6702                 return linfo;
6703         }
6704
6705
6706         linfo = mono_arch_get_llvm_call_info (cfg, sig);
6707         for (i = 0; i < sig->param_count; ++i)
6708                 linfo->args [i + sig->hasthis].type = sig->params [i];
6709
6710         return linfo;
6711 }
6712
6713 static void
6714 emit_method_inner (EmitContext *ctx);
6715
6716 static void
6717 free_ctx (EmitContext *ctx)
6718 {
6719         GSList *l;
6720
6721         g_free (ctx->values);
6722         g_free (ctx->addresses);
6723         g_free (ctx->vreg_types);
6724         g_free (ctx->is_vphi);
6725         g_free (ctx->vreg_cli_types);
6726         g_free (ctx->is_dead);
6727         g_free (ctx->unreachable);
6728         g_ptr_array_free (ctx->phi_values, TRUE);
6729         g_free (ctx->bblocks);
6730         g_hash_table_destroy (ctx->region_to_handler);
6731         g_hash_table_destroy (ctx->clause_to_handler);
6732         g_hash_table_destroy (ctx->jit_callees);
6733
6734         GHashTableIter iter;
6735         g_hash_table_iter_init (&iter, ctx->method_to_callers);
6736         while (g_hash_table_iter_next (&iter, NULL, (gpointer)&l))
6737                 g_slist_free (l);
6738
6739         g_hash_table_destroy (ctx->method_to_callers);
6740
6741         g_free (ctx->method_name);
6742         g_ptr_array_free (ctx->bblock_list, TRUE);
6743
6744         for (l = ctx->builders; l; l = l->next) {
6745                 LLVMBuilderRef builder = (LLVMBuilderRef)l->data;
6746                 LLVMDisposeBuilder (builder);
6747         }
6748
6749         g_free (ctx);
6750 }
6751
6752 /*
6753  * mono_llvm_emit_method:
6754  *
6755  *   Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
6756  */
6757 void
6758 mono_llvm_emit_method (MonoCompile *cfg)
6759 {
6760         EmitContext *ctx;
6761         char *method_name;
6762         gboolean is_linkonce = FALSE;
6763         int i;
6764
6765         /* The code below might acquire the loader lock, so use it for global locking */
6766         mono_loader_lock ();
6767
6768         /* Used to communicate with the callbacks */
6769         mono_native_tls_set_value (current_cfg_tls_id, cfg);
6770
6771         ctx = g_new0 (EmitContext, 1);
6772         ctx->cfg = cfg;
6773         ctx->mempool = cfg->mempool;
6774
6775         /*
6776          * This maps vregs to the LLVM instruction defining them
6777          */
6778         ctx->values = g_new0 (LLVMValueRef, cfg->next_vreg);
6779         /*
6780          * This maps vregs for volatile variables to the LLVM instruction defining their
6781          * address.
6782          */
6783         ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
6784         ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
6785         ctx->is_vphi = g_new0 (gboolean, cfg->next_vreg);
6786         ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
6787         ctx->phi_values = g_ptr_array_sized_new (256);
6788         /*
6789          * This signals whenever the vreg was defined by a phi node with no input vars
6790          * (i.e. all its input bblocks end with NOT_REACHABLE).
6791          */
6792         ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
6793         /* Whenever the bblock is unreachable */
6794         ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
6795         ctx->bblock_list = g_ptr_array_sized_new (256);
6796
6797         ctx->region_to_handler = g_hash_table_new (NULL, NULL);
6798         ctx->clause_to_handler = g_hash_table_new (NULL, NULL);
6799         ctx->method_to_callers = g_hash_table_new (NULL, NULL);
6800         ctx->jit_callees = g_hash_table_new (NULL, NULL);
6801         if (cfg->compile_aot) {
6802                 ctx->module = &aot_module;
6803
6804                 method_name = NULL;
6805                 /*
6806                  * Allow the linker to discard duplicate copies of wrappers, generic instances etc. by using the 'linkonce'
6807                  * linkage for them. This requires the following:
6808                  * - the method needs to have a unique mangled name
6809                  * - llvmonly mode, since the code in aot-runtime.c would initialize got slots in the wrong aot image etc.
6810                  */
6811                 is_linkonce = ctx->module->llvm_only && ctx->module->static_link && mono_aot_is_linkonce_method (cfg->method);
6812                 if (is_linkonce) {
6813                         method_name = mono_aot_get_mangled_method_name (cfg->method);
6814                         if (!method_name)
6815                                 is_linkonce = FALSE;
6816                         /*
6817                         if (method_name)
6818                                 printf ("%s %s\n", mono_method_full_name (cfg->method, 1), method_name);
6819                         else
6820                                 printf ("%s\n", mono_method_full_name (cfg->method, 1));
6821                         */
6822                 }
6823                 if (!method_name)
6824                         method_name = mono_aot_get_method_name (cfg);
6825                 cfg->llvm_method_name = g_strdup (method_name);
6826         } else {
6827                 init_jit_module (cfg->domain);
6828                 ctx->module = (MonoLLVMModule*)domain_jit_info (cfg->domain)->llvm_module;
6829                 method_name = mono_method_full_name (cfg->method, TRUE);
6830         }
6831         ctx->method_name = method_name;
6832         ctx->is_linkonce = is_linkonce;
6833
6834 #if LLVM_API_VERSION > 100
6835         if (cfg->compile_aot)
6836                 ctx->lmodule = ctx->module->lmodule;
6837         else
6838                 ctx->lmodule = LLVMModuleCreateWithName ("jit-module");
6839 #else
6840         ctx->lmodule = ctx->module->lmodule;
6841 #endif
6842         ctx->llvm_only = ctx->module->llvm_only;
6843
6844         emit_method_inner (ctx);
6845
6846         if (!ctx_ok (ctx)) {
6847                 if (ctx->lmethod) {
6848                         /* Need to add unused phi nodes as they can be referenced by other values */
6849                         LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (ctx->lmethod, "PHI_BB");
6850                         LLVMBuilderRef builder;
6851
6852                         builder = create_builder (ctx);
6853                         LLVMPositionBuilderAtEnd (builder, phi_bb);
6854
6855                         for (i = 0; i < ctx->phi_values->len; ++i) {
6856                                 LLVMValueRef v = (LLVMValueRef)g_ptr_array_index (ctx->phi_values, i);
6857                                 if (LLVMGetInstructionParent (v) == NULL)
6858                                         LLVMInsertIntoBuilder (builder, v);
6859                         }
6860
6861                         LLVMDeleteFunction (ctx->lmethod);
6862                 }
6863         }
6864
6865         free_ctx (ctx);
6866
6867         mono_native_tls_set_value (current_cfg_tls_id, NULL);
6868
6869         mono_loader_unlock ();
6870 }
6871
6872 static void
6873 emit_method_inner (EmitContext *ctx)
6874 {
6875         MonoCompile *cfg = ctx->cfg;
6876         MonoMethodSignature *sig;
6877         MonoBasicBlock *bb;
6878         LLVMTypeRef method_type;
6879         LLVMValueRef method = NULL;
6880         LLVMValueRef *values = ctx->values;
6881         int i, max_block_num, bb_index;
6882         gboolean last = FALSE;
6883         LLVMCallInfo *linfo;
6884         LLVMModuleRef lmodule = ctx->lmodule;
6885         BBInfo *bblocks;
6886         GPtrArray *bblock_list = ctx->bblock_list;
6887         MonoMethodHeader *header;
6888         MonoExceptionClause *clause;
6889         char **names;
6890
6891         if (cfg->gsharedvt && !cfg->llvm_only) {
6892                 set_failure (ctx, "gsharedvt");
6893                 return;
6894         }
6895
6896 #if 1
6897         {
6898                 static int count = 0;
6899                 count ++;
6900
6901                 if (g_getenv ("LLVM_COUNT")) {
6902                         if (count == atoi (g_getenv ("LLVM_COUNT"))) {
6903                                 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
6904                                 fflush (stdout);
6905                                 last = TRUE;
6906                         }
6907                         if (count > atoi (g_getenv ("LLVM_COUNT"))) {
6908                                 set_failure (ctx, "count");
6909                                 return;
6910                         }
6911                 }
6912         }
6913 #endif
6914
6915         sig = mono_method_signature (cfg->method);
6916         ctx->sig = sig;
6917
6918         linfo = get_llvm_call_info (cfg, sig);
6919         ctx->linfo = linfo;
6920         if (!ctx_ok (ctx))
6921                 return;
6922
6923         if (cfg->rgctx_var)
6924                 linfo->rgctx_arg = TRUE;
6925         ctx->method_type = method_type = sig_to_llvm_sig_full (ctx, sig, linfo);
6926         if (!ctx_ok (ctx))
6927                 return;
6928
6929         method = LLVMAddFunction (lmodule, ctx->method_name, method_type);
6930         ctx->lmethod = method;
6931
6932         if (!cfg->llvm_only)
6933                 LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
6934         LLVMSetLinkage (method, LLVMPrivateLinkage);
6935
6936         LLVMAddFunctionAttr (method, LLVMUWTable);
6937
6938         if (cfg->compile_aot) {
6939                 LLVMSetLinkage (method, LLVMInternalLinkage);
6940                 if (ctx->module->external_symbols) {
6941                         LLVMSetLinkage (method, LLVMExternalLinkage);
6942                         LLVMSetVisibility (method, LLVMHiddenVisibility);
6943                 }
6944                 if (ctx->is_linkonce) {
6945                         LLVMSetLinkage (method, LLVMLinkOnceAnyLinkage);
6946                         LLVMSetVisibility (method, LLVMDefaultVisibility);
6947                 }
6948         } else {
6949 #if LLVM_API_VERSION > 100
6950                 LLVMSetLinkage (method, LLVMExternalLinkage);
6951 #else
6952                 LLVMSetLinkage (method, LLVMPrivateLinkage);
6953 #endif
6954         }
6955
6956         if (cfg->method->save_lmf && !cfg->llvm_only) {
6957                 set_failure (ctx, "lmf");
6958                 return;
6959         }
6960
6961         if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && !cfg->llvm_only) {
6962                 set_failure (ctx, "pinvoke signature");
6963                 return;
6964         }
6965
6966         header = cfg->header;
6967         for (i = 0; i < header->num_clauses; ++i) {
6968                 clause = &header->clauses [i];
6969                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE) {
6970                     set_failure (ctx, "non-finally/catch clause.");
6971                         return;
6972                 }
6973         }
6974         if (header->num_clauses || (cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_NOINLINING) || cfg->no_inline)
6975                 /* We can't handle inlined methods with clauses */
6976                 LLVMAddFunctionAttr (method, LLVMNoInlineAttribute);
6977
6978         if (linfo->rgctx_arg) {
6979                 ctx->rgctx_arg = LLVMGetParam (method, linfo->rgctx_arg_pindex);
6980                 ctx->rgctx_arg_pindex = linfo->rgctx_arg_pindex;
6981                 /*
6982                  * We mark the rgctx parameter with the inreg attribute, which is mapped to
6983                  * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
6984                  * CC_X86_64_Mono in X86CallingConv.td.
6985                  */
6986                 if (!ctx->llvm_only)
6987                         LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
6988                 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
6989         } else {
6990                 ctx->rgctx_arg_pindex = -1;
6991         }
6992         if (cfg->vret_addr) {
6993                 values [cfg->vret_addr->dreg] = LLVMGetParam (method, linfo->vret_arg_pindex);
6994                 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
6995                 if (linfo->ret.storage == LLVMArgVtypeByRef) {
6996                         LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMStructRetAttribute);
6997                         LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMNoAliasAttribute);
6998                 }
6999         }
7000
7001         if (sig->hasthis) {
7002                 ctx->this_arg_pindex = linfo->this_arg_pindex;
7003                 ctx->this_arg = LLVMGetParam (method, linfo->this_arg_pindex);
7004                 values [cfg->args [0]->dreg] = ctx->this_arg;
7005                 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
7006         }
7007
7008         names = g_new (char *, sig->param_count);
7009         mono_method_get_param_names (cfg->method, (const char **) names);
7010
7011         /* Set parameter names/attributes */
7012         for (i = 0; i < sig->param_count; ++i) {
7013                 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
7014                 char *name;
7015                 int pindex = ainfo->pindex + ainfo->ndummy_fpargs;
7016                 int j;
7017
7018                 for (j = 0; j < ainfo->ndummy_fpargs; ++j) {
7019                         name = g_strdup_printf ("dummy_%d_%d", i, j);
7020                         LLVMSetValueName (LLVMGetParam (method, ainfo->pindex + j), name);
7021                         g_free (name);
7022                 }
7023
7024                 if (ainfo->storage == LLVMArgVtypeInReg && ainfo->pair_storage [0] == LLVMArgNone && ainfo->pair_storage [1] == LLVMArgNone)
7025                         continue;
7026
7027                 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, pindex);
7028                 if (ainfo->storage == LLVMArgGsharedvtFixed || ainfo->storage == LLVMArgGsharedvtFixedVtype) {
7029                         if (names [i] && names [i][0] != '\0')
7030                                 name = g_strdup_printf ("p_arg_%s", names [i]);
7031                         else
7032                                 name = g_strdup_printf ("p_arg_%d", i);
7033                 } else {
7034                         if (names [i] && names [i][0] != '\0')
7035                                 name = g_strdup_printf ("arg_%s", names [i]);
7036                         else
7037                                 name = g_strdup_printf ("arg_%d", i);
7038                 }
7039                 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
7040                 g_free (name);
7041                 if (ainfo->storage == LLVMArgVtypeByVal)
7042                         LLVMAddAttribute (LLVMGetParam (method, pindex), LLVMByValAttribute);
7043
7044                 if (ainfo->storage == LLVMArgVtypeByRef) {
7045                         /* For OP_LDADDR */
7046                         cfg->args [i + sig->hasthis]->opcode = OP_VTARG_ADDR;
7047                 }
7048         }
7049         g_free (names);
7050
7051         if (ctx->module->emit_dwarf && cfg->compile_aot && mono_debug_enabled ()) {
7052                 ctx->minfo = mono_debug_lookup_method (cfg->method);
7053                 ctx->dbg_md = emit_dbg_subprogram (ctx, cfg, method, ctx->method_name);
7054         }
7055
7056         max_block_num = 0;
7057         for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
7058                 max_block_num = MAX (max_block_num, bb->block_num);
7059         ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
7060
7061         /* Add branches between non-consecutive bblocks */
7062         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7063                 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
7064                         bb->next_bb != bb->last_ins->inst_false_bb) {
7065
7066                         MonoInst *inst = (MonoInst*)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
7067                         inst->opcode = OP_BR;
7068                         inst->inst_target_bb = bb->last_ins->inst_false_bb;
7069                         mono_bblock_add_inst (bb, inst);
7070                 }
7071         }
7072
7073         /*
7074          * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
7075          * was later optimized away, so clear these flags, and add them back for the still
7076          * present OP_LDADDR instructions.
7077          */
7078         for (i = 0; i < cfg->next_vreg; ++i) {
7079                 MonoInst *ins;
7080
7081                 ins = get_vreg_to_inst (cfg, i);
7082                 if (ins && ins != cfg->rgctx_var)
7083                         ins->flags &= ~MONO_INST_INDIRECT;
7084         }
7085
7086         /*
7087          * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
7088          */
7089         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7090                 MonoInst *ins;
7091                 LLVMBuilderRef builder;
7092                 char *dname;
7093                 char dname_buf[128];
7094
7095                 builder = create_builder (ctx);
7096
7097                 for (ins = bb->code; ins; ins = ins->next) {
7098                         switch (ins->opcode) {
7099                         case OP_PHI:
7100                         case OP_FPHI:
7101                         case OP_VPHI:
7102                         case OP_XPHI: {
7103                                 LLVMTypeRef phi_type = llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, &ins->klass->byval_arg));
7104
7105                                 if (!ctx_ok (ctx))
7106                                         return;
7107
7108                                 if (ins->opcode == OP_VPHI) {
7109                                         /* Treat valuetype PHI nodes as operating on the address itself */
7110                                         g_assert (ins->klass);
7111                                         phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
7112                                 }
7113
7114                                 /*
7115                                  * Have to precreate these, as they can be referenced by
7116                                  * earlier instructions.
7117                                  */
7118                                 sprintf (dname_buf, "t%d", ins->dreg);
7119                                 dname = dname_buf;
7120                                 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
7121
7122                                 if (ins->opcode == OP_VPHI)
7123                                         ctx->addresses [ins->dreg] = values [ins->dreg];
7124
7125                                 g_ptr_array_add (ctx->phi_values, values [ins->dreg]);
7126
7127                                 /*
7128                                  * Set the expected type of the incoming arguments since these have
7129                                  * to have the same type.
7130                                  */
7131                                 for (i = 0; i < ins->inst_phi_args [0]; i++) {
7132                                         int sreg1 = ins->inst_phi_args [i + 1];
7133
7134                                         if (sreg1 != -1) {
7135                                                 if (ins->opcode == OP_VPHI)
7136                                                         ctx->is_vphi [sreg1] = TRUE;
7137                                                 ctx->vreg_types [sreg1] = phi_type;
7138                                         }
7139                                 }
7140                                 break;
7141                                 }
7142                         case OP_LDADDR:
7143                                 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
7144                                 break;
7145                         default:
7146                                 break;
7147                         }
7148                 }
7149         }
7150
7151         /*
7152          * Create an ordering for bblocks, use the depth first order first, then
7153          * put the exception handling bblocks last.
7154          */
7155         for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
7156                 bb = cfg->bblocks [bb_index];
7157                 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
7158                         g_ptr_array_add (bblock_list, bb);
7159                         bblocks [bb->block_num].added = TRUE;
7160                 }
7161         }
7162
7163         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7164                 if (!bblocks [bb->block_num].added)
7165                         g_ptr_array_add (bblock_list, bb);
7166         }
7167
7168         /*
7169          * Second pass: generate code.
7170          */
7171         // Emit entry point
7172         LLVMBuilderRef entry_builder = create_builder (ctx);
7173         LLVMBasicBlockRef entry_bb = get_bb (ctx, cfg->bb_entry);
7174         LLVMPositionBuilderAtEnd (entry_builder, entry_bb);
7175         emit_entry_bb (ctx, entry_builder);
7176
7177         // Make landing pads first
7178         ctx->exc_meta = g_hash_table_new_full (NULL, NULL, NULL, NULL);
7179
7180         if (ctx->llvm_only) {
7181                 size_t group_index = 0;
7182                 while (group_index < cfg->header->num_clauses) {
7183                         int count = 0;
7184                         size_t cursor = group_index;
7185                         while (cursor < cfg->header->num_clauses &&
7186                                    CLAUSE_START (&cfg->header->clauses [cursor]) == CLAUSE_START (&cfg->header->clauses [group_index]) &&
7187                                    CLAUSE_END (&cfg->header->clauses [cursor]) == CLAUSE_END (&cfg->header->clauses [group_index])) {
7188                                 count++;
7189                                 cursor++;
7190                         }
7191
7192                         LLVMBasicBlockRef lpad_bb = emit_landing_pad (ctx, group_index, count);
7193                         intptr_t key = CLAUSE_END (&cfg->header->clauses [group_index]);
7194                         g_hash_table_insert (ctx->exc_meta, (gpointer)key, lpad_bb);
7195
7196                         group_index = cursor;
7197                 }
7198         }
7199
7200         for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
7201                 bb = (MonoBasicBlock*)g_ptr_array_index (bblock_list, bb_index);
7202
7203                 // Prune unreachable mono BBs.
7204                 if (!(bb == cfg->bb_entry || bb->in_count > 0))
7205                         continue;
7206
7207                 process_bb (ctx, bb);
7208                 if (!ctx_ok (ctx))
7209                         return;
7210         }
7211         g_hash_table_destroy (ctx->exc_meta);
7212
7213         mono_memory_barrier ();
7214
7215         /* Add incoming phi values */
7216         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7217                 GSList *l, *ins_list;
7218
7219                 ins_list = bblocks [bb->block_num].phi_nodes;
7220
7221                 for (l = ins_list; l; l = l->next) {
7222                         PhiNode *node = (PhiNode*)l->data;
7223                         MonoInst *phi = node->phi;
7224                         int sreg1 = node->sreg;
7225                         LLVMBasicBlockRef in_bb;
7226
7227                         if (sreg1 == -1)
7228                                 continue;
7229
7230                         in_bb = get_end_bb (ctx, node->in_bb);
7231
7232                         if (ctx->unreachable [node->in_bb->block_num])
7233                                 continue;
7234
7235                         if (!values [sreg1]) {
7236                                 /* Can happen with values in EH clauses */
7237                                 set_failure (ctx, "incoming phi sreg1");
7238                                 return;
7239                         }
7240
7241                         if (phi->opcode == OP_VPHI) {
7242                                 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
7243                                 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
7244                         } else {
7245                                 if (LLVMTypeOf (values [sreg1]) != LLVMTypeOf (values [phi->dreg])) {
7246                                         set_failure (ctx, "incoming phi arg type mismatch");
7247                                         return;
7248                                 }
7249                                 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
7250                                 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
7251                         }
7252                 }
7253         }
7254
7255         /* Nullify empty phi instructions */
7256         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7257                 GSList *l, *ins_list;
7258
7259                 ins_list = bblocks [bb->block_num].phi_nodes;
7260
7261                 for (l = ins_list; l; l = l->next) {
7262                         PhiNode *node = (PhiNode*)l->data;
7263                         MonoInst *phi = node->phi;
7264                         LLVMValueRef phi_ins = values [phi->dreg];
7265
7266                         if (!phi_ins)
7267                                 /* Already removed */
7268                                 continue;
7269
7270                         if (LLVMCountIncoming (phi_ins) == 0) {
7271                                 mono_llvm_replace_uses_of (phi_ins, LLVMConstNull (LLVMTypeOf (phi_ins)));
7272                                 LLVMInstructionEraseFromParent (phi_ins);
7273                                 values [phi->dreg] = NULL;
7274                         }
7275                 }
7276         }
7277
7278         /* Create the SWITCH statements for ENDFINALLY instructions */
7279         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7280                 BBInfo *info = &bblocks [bb->block_num];
7281                 GSList *l;
7282                 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
7283                         LLVMValueRef switch_ins = (LLVMValueRef)l->data;
7284                         GSList *bb_list = info->call_handler_return_bbs;
7285
7286                         for (i = 0; i < g_slist_length (bb_list); ++i)
7287                                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), (LLVMBasicBlockRef)(g_slist_nth (bb_list, i)->data));
7288                 }
7289         }
7290
7291         /* Initialize the method if needed */
7292         if (cfg->compile_aot && ctx->llvm_only) {
7293                 // FIXME: Add more shared got entries
7294                 ctx->builder = create_builder (ctx);
7295                 LLVMPositionBuilderAtEnd (ctx->builder, ctx->init_bb);
7296
7297                 ctx->module->max_method_idx = MAX (ctx->module->max_method_idx, cfg->method_index);
7298
7299                 // FIXME: beforefieldinit
7300                 /*
7301                  * NATIVE_TO_MANAGED methods might be called on a thread not attached to the runtime, so they are initialized when loaded
7302                  * in load_method ().
7303                  */
7304                 if ((ctx->has_got_access || mono_class_get_cctor (cfg->method->klass)) && !(cfg->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)) {
7305                         /*
7306                          * linkonce methods shouldn't have initialization,
7307                          * because they might belong to assemblies which
7308                          * haven't been loaded yet.
7309                          */
7310                         g_assert (!ctx->is_linkonce);
7311                         emit_init_method (ctx);
7312                 } else {
7313                         LLVMBuildBr (ctx->builder, ctx->inited_bb);
7314                 }
7315         }
7316
7317         if (cfg->llvm_only) {
7318                 GHashTableIter iter;
7319                 MonoMethod *method;
7320                 GSList *callers, *l, *l2;
7321
7322                 /*
7323                  * Add the contents of ctx->method_to_callers to module->method_to_callers.
7324                  * We can't do this earlier, as it contains llvm instructions which can be
7325                  * freed if compilation fails.
7326                  * FIXME: Get rid of this when all methods can be llvm compiled.
7327                  */
7328                 g_hash_table_iter_init (&iter, ctx->method_to_callers);
7329                 while (g_hash_table_iter_next (&iter, (void**)&method, (void**)&callers)) {
7330                         for (l = callers; l; l = l->next) {
7331                                 l2 = (GSList*)g_hash_table_lookup (ctx->module->method_to_callers, method);
7332                                 l2 = g_slist_prepend (l2, l->data);
7333                                 g_hash_table_insert (ctx->module->method_to_callers, method, l2);
7334                         }
7335                 }
7336         }
7337
7338         if (cfg->verbose_level > 1)
7339                 mono_llvm_dump_value (method);
7340
7341         if (cfg->compile_aot && !cfg->llvm_only)
7342                 mark_as_used (ctx->module, method);
7343
7344         if (!cfg->llvm_only) {
7345                 LLVMValueRef md_args [16];
7346                 LLVMValueRef md_node;
7347                 int method_index;
7348
7349                 if (cfg->compile_aot)
7350                         method_index = mono_aot_get_method_index (cfg->orig_method);
7351                 else
7352                         method_index = 1;
7353                 md_args [0] = LLVMMDString (ctx->method_name, strlen (ctx->method_name));
7354                 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
7355                 md_node = LLVMMDNode (md_args, 2);
7356                 LLVMAddNamedMetadataOperand (lmodule, "mono.function_indexes", md_node);
7357                 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
7358         }
7359
7360         if (cfg->compile_aot) {
7361                 /* Don't generate native code, keep the LLVM IR */
7362                 if (cfg->verbose_level)
7363                         printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), ctx->method_name);
7364
7365 #if LLVM_API_VERSION < 100
7366                 /* VerifyFunction can't handle some of the debug info created by DIBuilder in llvm 3.9 */
7367                 int err = LLVMVerifyFunction(ctx->lmethod, LLVMPrintMessageAction);
7368                 g_assert (err == 0);
7369 #endif
7370         } else {
7371                 //LLVMVerifyFunction(method, 0);
7372 #if LLVM_API_VERSION > 100
7373                 MonoDomain *domain = mono_domain_get ();
7374                 MonoJitDomainInfo *domain_info;
7375                 int nvars = g_hash_table_size (ctx->jit_callees);
7376                 LLVMValueRef *callee_vars = g_new0 (LLVMValueRef, nvars);
7377                 gpointer *callee_addrs = g_new0 (gpointer, nvars);
7378                 GHashTableIter iter;
7379                 LLVMValueRef var;
7380                 MonoMethod *callee;
7381                 gpointer eh_frame;
7382
7383                 /*
7384                  * Compute the addresses of the LLVM globals pointing to the
7385                  * methods called by the current method. Pass it to the trampoline
7386                  * code so it can update them after their corresponding method was
7387                  * compiled.
7388                  */
7389                 g_hash_table_iter_init (&iter, ctx->jit_callees);
7390                 i = 0;
7391                 while (g_hash_table_iter_next (&iter, NULL, (void**)&var))
7392                         callee_vars [i ++] = var;
7393
7394                 cfg->native_code = mono_llvm_compile_method (ctx->module->mono_ee, ctx->lmethod, nvars, callee_vars, callee_addrs, &eh_frame);
7395
7396                 decode_llvm_eh_info (ctx, eh_frame);
7397
7398                 mono_domain_lock (domain);
7399                 domain_info = domain_jit_info (domain);
7400                 if (!domain_info->llvm_jit_callees)
7401                         domain_info->llvm_jit_callees = g_hash_table_new (NULL, NULL);
7402                 g_hash_table_iter_init (&iter, ctx->jit_callees);
7403                 i = 0;
7404                 while (g_hash_table_iter_next (&iter, (void**)&callee, (void**)&var)) {
7405                         GSList *addrs = g_hash_table_lookup (domain_info->llvm_jit_callees, callee);
7406                         addrs = g_slist_prepend (addrs, callee_addrs [i]);
7407                         g_hash_table_insert (domain_info->llvm_jit_callees, callee, addrs);
7408                         i ++;
7409                 }
7410                 mono_domain_unlock (domain);
7411 #else
7412                 mono_llvm_optimize_method (ctx->module->mono_ee, ctx->lmethod);
7413
7414                 if (cfg->verbose_level > 1)
7415                         mono_llvm_dump_value (ctx->lmethod);
7416
7417                 cfg->native_code = (unsigned char*)LLVMGetPointerToGlobal (ctx->module->ee, ctx->lmethod);
7418
7419                 /* Set by emit_cb */
7420                 g_assert (cfg->code_len);
7421 #endif
7422         }
7423
7424         if (ctx->module->method_to_lmethod)
7425                 g_hash_table_insert (ctx->module->method_to_lmethod, cfg->method, ctx->lmethod);
7426         if (ctx->module->idx_to_lmethod)
7427                 g_hash_table_insert (ctx->module->idx_to_lmethod, GINT_TO_POINTER (cfg->method_index), ctx->lmethod);
7428
7429         if (ctx->llvm_only && cfg->orig_method->klass->valuetype && !(cfg->orig_method->flags & METHOD_ATTRIBUTE_STATIC))
7430                 emit_unbox_tramp (ctx, ctx->method_name, ctx->method_type, ctx->lmethod, cfg->method_index);
7431 }
7432
7433 /*
7434  * mono_llvm_create_vars:
7435  *
7436  *   Same as mono_arch_create_vars () for LLVM.
7437  */
7438 void
7439 mono_llvm_create_vars (MonoCompile *cfg)
7440 {
7441         MonoMethodSignature *sig;
7442
7443         sig = mono_method_signature (cfg->method);
7444         if (cfg->gsharedvt && cfg->llvm_only) {
7445                 if (mini_is_gsharedvt_variable_signature (sig) && sig->ret->type != MONO_TYPE_VOID) {
7446                         cfg->vret_addr = mono_compile_create_var (cfg, &mono_get_intptr_class ()->byval_arg, OP_ARG);
7447                         if (G_UNLIKELY (cfg->verbose_level > 1)) {
7448                                 printf ("vret_addr = ");
7449                                 mono_print_ins (cfg->vret_addr);
7450                         }
7451                 }
7452         } else {
7453                 mono_arch_create_vars (cfg);
7454         }
7455 }
7456
7457 /*
7458  * mono_llvm_emit_call:
7459  *
7460  *   Same as mono_arch_emit_call () for LLVM.
7461  */
7462 void
7463 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
7464 {
7465         MonoInst *in;
7466         MonoMethodSignature *sig;
7467         int i, n, stack_size;
7468         LLVMArgInfo *ainfo;
7469
7470         stack_size = 0;
7471
7472         sig = call->signature;
7473         n = sig->param_count + sig->hasthis;
7474
7475         call->cinfo = get_llvm_call_info (cfg, sig);
7476
7477         if (cfg->disable_llvm)
7478                 return;
7479
7480         if (sig->call_convention == MONO_CALL_VARARG) {
7481                 cfg->exception_message = g_strdup ("varargs");
7482                 cfg->disable_llvm = TRUE;
7483         }
7484
7485         for (i = 0; i < n; ++i) {
7486                 MonoInst *ins;
7487
7488                 ainfo = call->cinfo->args + i;
7489
7490                 in = call->args [i];
7491
7492                 /* Simply remember the arguments */
7493                 switch (ainfo->storage) {
7494                 case LLVMArgNormal: {
7495                         MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : ainfo->type;
7496                         int opcode;
7497
7498                         opcode = mono_type_to_regmove (cfg, t);
7499                         if (opcode == OP_FMOVE) {
7500                                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
7501                                 ins->dreg = mono_alloc_freg (cfg);
7502                         } else if (opcode == OP_LMOVE) {
7503                                 MONO_INST_NEW (cfg, ins, OP_LMOVE);
7504                                 ins->dreg = mono_alloc_lreg (cfg);
7505                         } else if (opcode == OP_RMOVE) {
7506                                 MONO_INST_NEW (cfg, ins, OP_RMOVE);
7507                                 ins->dreg = mono_alloc_freg (cfg);
7508                         } else {
7509                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
7510                                 ins->dreg = mono_alloc_ireg (cfg);
7511                         }
7512                         ins->sreg1 = in->dreg;
7513                         break;
7514                 }
7515                 case LLVMArgVtypeByVal:
7516                 case LLVMArgVtypeByRef:
7517                 case LLVMArgVtypeInReg:
7518                 case LLVMArgVtypeAsScalar:
7519                 case LLVMArgAsIArgs:
7520                 case LLVMArgAsFpArgs:
7521                 case LLVMArgGsharedvtVariable:
7522                 case LLVMArgGsharedvtFixed:
7523                 case LLVMArgGsharedvtFixedVtype:
7524                         MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
7525                         ins->dreg = mono_alloc_ireg (cfg);
7526                         ins->sreg1 = in->dreg;
7527                         ins->inst_p0 = mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMArgInfo));
7528                         memcpy (ins->inst_p0, ainfo, sizeof (LLVMArgInfo));
7529                         ins->inst_vtype = ainfo->type;
7530                         ins->klass = mono_class_from_mono_type (ainfo->type);
7531                         break;
7532                 default:
7533                         cfg->exception_message = g_strdup ("ainfo->storage");
7534                         cfg->disable_llvm = TRUE;
7535                         return;
7536                 }
7537
7538                 if (!cfg->disable_llvm) {
7539                         MONO_ADD_INS (cfg->cbb, ins);
7540                         mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
7541                 }
7542         }
7543 }
7544
7545 static unsigned char*
7546 alloc_cb (LLVMValueRef function, int size)
7547 {
7548         MonoCompile *cfg;
7549
7550         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7551
7552         if (cfg) {
7553                 // FIXME: dynamic
7554                 return (unsigned char*)mono_domain_code_reserve (cfg->domain, size);
7555         } else {
7556                 return (unsigned char*)mono_domain_code_reserve (mono_domain_get (), size);
7557         }
7558 }
7559
7560 static void
7561 emitted_cb (LLVMValueRef function, void *start, void *end)
7562 {
7563         MonoCompile *cfg;
7564
7565         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7566         g_assert (cfg);
7567         cfg->code_len = (guint8*)end - (guint8*)start;
7568 }
7569
7570 static void
7571 exception_cb (void *data)
7572 {
7573         MonoCompile *cfg;
7574         MonoJitExceptionInfo *ei;
7575         guint32 ei_len, i, j, nested_len, nindex;
7576         gpointer *type_info;
7577         int this_reg, this_offset;
7578
7579         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7580         g_assert (cfg);
7581
7582         /*
7583          * data points to a DWARF FDE structure, convert it to our unwind format and
7584          * save it.
7585          * An alternative would be to save it directly, and modify our unwinder to work
7586          * with it.
7587          */
7588         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);
7589         if (cfg->verbose_level > 1)
7590                 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
7591
7592         /* Count nested clauses */
7593         nested_len = 0;
7594         for (i = 0; i < ei_len; ++i) {
7595                 gint32 cindex1 = *(gint32*)type_info [i];
7596                 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
7597
7598                 for (j = 0; j < cfg->header->num_clauses; ++j) {
7599                         int cindex2 = j;
7600                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
7601
7602                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
7603                                 nested_len ++;
7604                         }
7605                 }
7606         }
7607
7608         cfg->llvm_ex_info = (MonoJitExceptionInfo*)mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
7609         cfg->llvm_ex_info_len = ei_len + nested_len;
7610         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
7611         /* Fill the rest of the information from the type info */
7612         for (i = 0; i < ei_len; ++i) {
7613                 gint32 clause_index = *(gint32*)type_info [i];
7614                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
7615
7616                 cfg->llvm_ex_info [i].flags = clause->flags;
7617                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
7618                 cfg->llvm_ex_info [i].clause_index = clause_index;
7619         }
7620
7621         /*
7622          * For nested clauses, the LLVM produced exception info associates the try interval with
7623          * the innermost handler, while mono expects it to be associated with all nesting clauses.
7624          * So add new clauses which use the IL info (catch class etc.) from the nesting clause,
7625          * and everything else from the nested clause.
7626          */
7627         nindex = ei_len;
7628         for (i = 0; i < ei_len; ++i) {
7629                 gint32 cindex1 = *(gint32*)type_info [i];
7630                 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
7631
7632                 for (j = 0; j < cfg->header->num_clauses; ++j) {
7633                         int cindex2 = j;
7634                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
7635                         MonoJitExceptionInfo *nesting_ei, *nested_ei;
7636
7637                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
7638                                 /* clause1 is the nested clause */
7639                                 nested_ei = &cfg->llvm_ex_info [i];
7640                                 nesting_ei = &cfg->llvm_ex_info [nindex];
7641                                 nindex ++;
7642
7643                                 memcpy (nesting_ei, nested_ei, sizeof (MonoJitExceptionInfo));
7644
7645                                 nesting_ei->flags = clause2->flags;
7646                                 nesting_ei->data.catch_class = clause2->data.catch_class;
7647                                 nesting_ei->clause_index = cindex2;
7648                         }
7649                 }
7650         }
7651         g_assert (nindex == ei_len + nested_len);
7652         cfg->llvm_this_reg = this_reg;
7653         cfg->llvm_this_offset = this_offset;
7654
7655         /* type_info [i] is cfg mempool allocated, no need to free it */
7656
7657         g_free (ei);
7658         g_free (type_info);
7659 }
7660
7661 #if LLVM_API_VERSION > 100
7662 /*
7663  * decode_llvm_eh_info:
7664  *
7665  *   Decode the EH table emitted by llvm in jit mode, and store
7666  * the result into cfg.
7667  */
7668 static void
7669 decode_llvm_eh_info (EmitContext *ctx, gpointer eh_frame)
7670 {
7671         MonoCompile *cfg = ctx->cfg;
7672         guint8 *cie, *fde;
7673         int fde_len;
7674         MonoLLVMFDEInfo info;
7675         MonoJitExceptionInfo *ei;
7676         guint8 *p = eh_frame;
7677         int version, fde_count, fde_offset;
7678         guint32 ei_len, i, nested_len;
7679         gpointer *type_info;
7680         gint32 *table;
7681
7682         /*
7683          * Decode the one element EH table emitted by the MonoException class
7684          * in llvm.
7685          */
7686
7687         /* Similar to decode_llvm_mono_eh_frame () in aot-runtime.c */
7688
7689         version = *p;
7690         g_assert (version == 3);
7691         p ++;
7692         p ++;
7693         p = (guint8 *)ALIGN_PTR_TO (p, 4);
7694
7695         fde_count = *(guint32*)p;
7696         p += 4;
7697         table = (gint32*)p;
7698
7699         g_assert (fde_count <= 2);
7700
7701         /* The first entry is the real method */
7702         g_assert (table [0] == 1);
7703         fde_offset = table [1];
7704         table += fde_count * 2;
7705         /* Extra entry */
7706         cfg->code_len = table [0];
7707         fde_len = table [1] - fde_offset;
7708         table += 2;
7709
7710         fde = (guint8*)eh_frame + fde_offset;
7711         cie = (guint8*)table;
7712
7713         mono_unwind_decode_llvm_mono_fde (fde, fde_len, cie, cfg->native_code, &info);
7714
7715         cfg->encoded_unwind_ops = info.unw_info;
7716         cfg->encoded_unwind_ops_len = info.unw_info_len;
7717         if (cfg->verbose_level > 1)
7718                 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
7719         if (info.this_reg != -1) {
7720                 cfg->llvm_this_reg = info.this_reg;
7721                 cfg->llvm_this_offset = info.this_offset;
7722         }
7723
7724         ei = info.ex_info;
7725         ei_len = info.ex_info_len;
7726         type_info = info.type_info;
7727
7728         // Nested clauses are currently disabled
7729         nested_len = 0;
7730
7731         cfg->llvm_ex_info = (MonoJitExceptionInfo*)mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
7732         cfg->llvm_ex_info_len = ei_len + nested_len;
7733         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
7734         /* Fill the rest of the information from the type info */
7735         for (i = 0; i < ei_len; ++i) {
7736                 gint32 clause_index = *(gint32*)type_info [i];
7737                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
7738
7739                 cfg->llvm_ex_info [i].flags = clause->flags;
7740                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
7741                 cfg->llvm_ex_info [i].clause_index = clause_index;
7742         }
7743 }
7744 #endif
7745
7746 static char*
7747 dlsym_cb (const char *name, void **symbol)
7748 {
7749         MonoDl *current;
7750         char *err;
7751
7752         err = NULL;
7753         if (!strcmp (name, "__bzero")) {
7754                 *symbol = (void*)bzero;
7755         } else {
7756                 current = mono_dl_open (NULL, 0, NULL);
7757                 g_assert (current);
7758
7759                 err = mono_dl_symbol (current, name, symbol);
7760
7761                 mono_dl_close (current);
7762         }
7763 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
7764         *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
7765 #endif
7766         return err;
7767 }
7768
7769 static inline void
7770 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
7771 {
7772         LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
7773 }
7774
7775 static inline void
7776 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
7777 {
7778         LLVMTypeRef param_types [4];
7779
7780         param_types [0] = param_type1;
7781         param_types [1] = param_type2;
7782
7783         AddFunc (module, name, ret_type, param_types, 2);
7784 }
7785
7786 typedef enum {
7787         INTRINS_MEMSET,
7788         INTRINS_MEMCPY,
7789         INTRINS_SADD_OVF_I32,
7790         INTRINS_UADD_OVF_I32,
7791         INTRINS_SSUB_OVF_I32,
7792         INTRINS_USUB_OVF_I32,
7793         INTRINS_SMUL_OVF_I32,
7794         INTRINS_UMUL_OVF_I32,
7795         INTRINS_SADD_OVF_I64,
7796         INTRINS_UADD_OVF_I64,
7797         INTRINS_SSUB_OVF_I64,
7798         INTRINS_USUB_OVF_I64,
7799         INTRINS_SMUL_OVF_I64,
7800         INTRINS_UMUL_OVF_I64,
7801         INTRINS_SIN,
7802         INTRINS_COS,
7803         INTRINS_SQRT,
7804         INTRINS_FABS,
7805         INTRINS_EXPECT_I8,
7806         INTRINS_EXPECT_I1,
7807 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7808         INTRINS_SSE_PMOVMSKB,
7809         INTRINS_SSE_PSRLI_W,
7810         INTRINS_SSE_PSRAI_W,
7811         INTRINS_SSE_PSLLI_W,
7812         INTRINS_SSE_PSRLI_D,
7813         INTRINS_SSE_PSRAI_D,
7814         INTRINS_SSE_PSLLI_D,
7815         INTRINS_SSE_PSRLI_Q,
7816         INTRINS_SSE_PSLLI_Q,
7817         INTRINS_SSE_SQRT_PD,
7818         INTRINS_SSE_SQRT_PS,
7819         INTRINS_SSE_RSQRT_PS,
7820         INTRINS_SSE_RCP_PS,
7821         INTRINS_SSE_CVTTPD2DQ,
7822         INTRINS_SSE_CVTTPS2DQ,
7823         INTRINS_SSE_CVTDQ2PD,
7824         INTRINS_SSE_CVTDQ2PS,
7825         INTRINS_SSE_CVTPD2DQ,
7826         INTRINS_SSE_CVTPS2DQ,
7827         INTRINS_SSE_CVTPD2PS,
7828         INTRINS_SSE_CVTPS2PD,
7829         INTRINS_SSE_CMPPD,
7830         INTRINS_SSE_CMPPS,
7831         INTRINS_SSE_PACKSSWB,
7832         INTRINS_SSE_PACKUSWB,
7833         INTRINS_SSE_PACKSSDW,
7834         INTRINS_SSE_PACKUSDW,
7835         INTRINS_SSE_MINPS,
7836         INTRINS_SSE_MAXPS,
7837         INTRINS_SSE_HADDPS,
7838         INTRINS_SSE_HSUBPS,
7839         INTRINS_SSE_ADDSUBPS,
7840         INTRINS_SSE_MINPD,
7841         INTRINS_SSE_MAXPD,
7842         INTRINS_SSE_HADDPD,
7843         INTRINS_SSE_HSUBPD,
7844         INTRINS_SSE_ADDSUBPD,
7845         INTRINS_SSE_PADDSW,
7846         INTRINS_SSE_PSUBSW,
7847         INTRINS_SSE_PADDUSW,
7848         INTRINS_SSE_PSUBUSW,
7849         INTRINS_SSE_PAVGW,
7850         INTRINS_SSE_PMULHW,
7851         INTRINS_SSE_PMULHU,
7852         INTRINS_SE_PADDSB,
7853         INTRINS_SSE_PSUBSB,
7854         INTRINS_SSE_PADDUSB,
7855         INTRINS_SSE_PSUBUSB,
7856         INTRINS_SSE_PAVGB,
7857         INTRINS_SSE_PAUSE,
7858 #endif
7859         INTRINS_NUM
7860 } IntrinsicId;
7861
7862 typedef struct {
7863         IntrinsicId id;
7864         const char *name;
7865 } IntrinsicDesc;
7866
7867 static IntrinsicDesc intrinsics[] = {
7868         {INTRINS_MEMSET, "llvm.memset.p0i8.i32"},
7869         {INTRINS_MEMCPY, "llvm.memcpy.p0i8.p0i8.i32"},
7870         {INTRINS_SADD_OVF_I32, "llvm.sadd.with.overflow.i32"},
7871         {INTRINS_UADD_OVF_I32, "llvm.uadd.with.overflow.i32"},
7872         {INTRINS_SSUB_OVF_I32, "llvm.ssub.with.overflow.i32"},
7873         {INTRINS_USUB_OVF_I32, "llvm.usub.with.overflow.i32"},
7874         {INTRINS_SMUL_OVF_I32, "llvm.smul.with.overflow.i32"},
7875         {INTRINS_UMUL_OVF_I32, "llvm.umul.with.overflow.i32"},
7876         {INTRINS_SADD_OVF_I64, "llvm.sadd.with.overflow.i64"},
7877         {INTRINS_UADD_OVF_I64, "llvm.uadd.with.overflow.i64"},
7878         {INTRINS_SSUB_OVF_I64, "llvm.ssub.with.overflow.i64"},
7879         {INTRINS_USUB_OVF_I64, "llvm.usub.with.overflow.i64"},
7880         {INTRINS_SMUL_OVF_I64, "llvm.smul.with.overflow.i64"},
7881         {INTRINS_UMUL_OVF_I64, "llvm.umul.with.overflow.i64"},
7882         {INTRINS_SIN, "llvm.sin.f64"},
7883         {INTRINS_COS, "llvm.cos.f64"},
7884         {INTRINS_SQRT, "llvm.sqrt.f64"},
7885         /* This isn't an intrinsic, instead llvm seems to special case it by name */
7886         {INTRINS_FABS, "fabs"},
7887         {INTRINS_EXPECT_I8, "llvm.expect.i8"},
7888         {INTRINS_EXPECT_I1, "llvm.expect.i1"},
7889 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7890         {INTRINS_SSE_PMOVMSKB, "llvm.x86.sse2.pmovmskb.128"},
7891         {INTRINS_SSE_PSRLI_W, "llvm.x86.sse2.psrli.w"},
7892         {INTRINS_SSE_PSRAI_W, "llvm.x86.sse2.psrai.w"},
7893         {INTRINS_SSE_PSLLI_W, "llvm.x86.sse2.pslli.w"},
7894         {INTRINS_SSE_PSRLI_D, "llvm.x86.sse2.psrli.d"},
7895         {INTRINS_SSE_PSRAI_D, "llvm.x86.sse2.psrai.d"},
7896         {INTRINS_SSE_PSLLI_D, "llvm.x86.sse2.pslli.d"},
7897         {INTRINS_SSE_PSRLI_Q, "llvm.x86.sse2.psrli.q"},
7898         {INTRINS_SSE_PSLLI_Q, "llvm.x86.sse2.pslli.q"},
7899         {INTRINS_SSE_SQRT_PD, "llvm.x86.sse2.sqrt.pd"},
7900         {INTRINS_SSE_SQRT_PS, "llvm.x86.sse.sqrt.ps"},
7901         {INTRINS_SSE_RSQRT_PS, "llvm.x86.sse.rsqrt.ps"},
7902         {INTRINS_SSE_RCP_PS, "llvm.x86.sse.rcp.ps"},
7903         {INTRINS_SSE_CVTTPD2DQ, "llvm.x86.sse2.cvttpd2dq"},
7904         {INTRINS_SSE_CVTTPS2DQ, "llvm.x86.sse2.cvttps2dq"},
7905         {INTRINS_SSE_CVTDQ2PD, "llvm.x86.sse2.cvtdq2pd"},
7906         {INTRINS_SSE_CVTDQ2PS, "llvm.x86.sse2.cvtdq2ps"},
7907         {INTRINS_SSE_CVTPD2DQ, "llvm.x86.sse2.cvtpd2dq"},
7908         {INTRINS_SSE_CVTPS2DQ, "llvm.x86.sse2.cvtps2dq"},
7909         {INTRINS_SSE_CVTPD2PS, "llvm.x86.sse2.cvtpd2ps"},
7910         {INTRINS_SSE_CVTPS2PD, "llvm.x86.sse2.cvtps2pd"},
7911         {INTRINS_SSE_CMPPD, "llvm.x86.sse2.cmp.pd"},
7912         {INTRINS_SSE_CMPPS, "llvm.x86.sse.cmp.ps"},
7913         {INTRINS_SSE_PACKSSWB, "llvm.x86.sse2.packsswb.128"},
7914         {INTRINS_SSE_PACKUSWB, "llvm.x86.sse2.packuswb.128"},
7915         {INTRINS_SSE_PACKSSDW, "llvm.x86.sse2.packssdw.128"},
7916         {INTRINS_SSE_PACKUSDW, "llvm.x86.sse41.packusdw"},
7917         {INTRINS_SSE_MINPS, "llvm.x86.sse.min.ps"},
7918         {INTRINS_SSE_MAXPS, "llvm.x86.sse.max.ps"},
7919         {INTRINS_SSE_HADDPS, "llvm.x86.sse3.hadd.ps"},
7920         {INTRINS_SSE_HSUBPS, "llvm.x86.sse3.hsub.ps"},
7921         {INTRINS_SSE_ADDSUBPS, "llvm.x86.sse3.addsub.ps"},
7922         {INTRINS_SSE_MINPD, "llvm.x86.sse2.min.pd"},
7923         {INTRINS_SSE_MAXPD, "llvm.x86.sse2.max.pd"},
7924         {INTRINS_SSE_HADDPD, "llvm.x86.sse3.hadd.pd"},
7925         {INTRINS_SSE_HSUBPD, "llvm.x86.sse3.hsub.pd"},
7926         {INTRINS_SSE_ADDSUBPD, "llvm.x86.sse3.addsub.pd"},
7927         {INTRINS_SSE_PADDSW, "llvm.x86.sse2.padds.w"},
7928         {INTRINS_SSE_PSUBSW, "llvm.x86.sse2.psubs.w"},
7929         {INTRINS_SSE_PADDUSW, "llvm.x86.sse2.paddus.w"},
7930         {INTRINS_SSE_PSUBUSW, "llvm.x86.sse2.psubus.w"},
7931         {INTRINS_SSE_PAVGW, "llvm.x86.sse2.pavg.w"},
7932         {INTRINS_SSE_PMULHW, "llvm.x86.sse2.pmulh.w"},
7933         {INTRINS_SSE_PMULHU, "llvm.x86.sse2.pmulhu.w"},
7934         {INTRINS_SE_PADDSB, "llvm.x86.sse2.padds.b"},
7935         {INTRINS_SSE_PSUBSB, "llvm.x86.sse2.psubs.b"},
7936         {INTRINS_SSE_PADDUSB, "llvm.x86.sse2.paddus.b"},
7937         {INTRINS_SSE_PSUBUSB, "llvm.x86.sse2.psubus.b"},
7938         {INTRINS_SSE_PAVGB, "llvm.x86.sse2.pavg.b"},
7939         {INTRINS_SSE_PAUSE, "llvm.x86.sse2.pause"}
7940 #endif
7941 };
7942
7943 static void
7944 add_sse_binary (LLVMModuleRef module, const char *name, int type)
7945 {
7946         LLVMTypeRef ret_type = type_to_simd_type (type);
7947         AddFunc2 (module, name, ret_type, ret_type, ret_type);
7948 }
7949
7950 static void
7951 add_intrinsic (LLVMModuleRef module, int id)
7952 {
7953         const char *name;
7954 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7955         LLVMTypeRef ret_type, arg_types [16];
7956 #endif
7957
7958         name = g_hash_table_lookup (intrins_id_to_name, GINT_TO_POINTER (id));
7959         g_assert (name);
7960
7961         switch (id) {
7962         case INTRINS_MEMSET: {
7963                 LLVMTypeRef params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
7964
7965                 AddFunc (module, name, LLVMVoidType (), params, 5);
7966                 break;
7967         }
7968         case INTRINS_MEMCPY: {
7969                 LLVMTypeRef params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
7970
7971                 AddFunc (module, name, LLVMVoidType (), params, 5);
7972                 break;
7973         }
7974         case INTRINS_SADD_OVF_I32:
7975         case INTRINS_UADD_OVF_I32:
7976         case INTRINS_SSUB_OVF_I32:
7977         case INTRINS_USUB_OVF_I32:
7978         case INTRINS_SMUL_OVF_I32:
7979         case INTRINS_UMUL_OVF_I32: {
7980                 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
7981                 LLVMTypeRef params [] = { LLVMInt32Type (), LLVMInt32Type () };
7982                 LLVMTypeRef ret_type = LLVMStructType (ovf_res_i32, 2, FALSE);
7983
7984                 AddFunc (module, name, ret_type, params, 2);
7985                 break;
7986         }
7987         case INTRINS_SADD_OVF_I64:
7988         case INTRINS_UADD_OVF_I64:
7989         case INTRINS_SSUB_OVF_I64:
7990         case INTRINS_USUB_OVF_I64:
7991         case INTRINS_SMUL_OVF_I64:
7992         case INTRINS_UMUL_OVF_I64: {
7993                 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
7994                 LLVMTypeRef params [] = { LLVMInt64Type (), LLVMInt64Type () };
7995                 LLVMTypeRef ret_type = LLVMStructType (ovf_res_i64, 2, FALSE);
7996
7997                 AddFunc (module, name, ret_type, params, 2);
7998                 break;
7999         }
8000         case INTRINS_SIN:
8001         case INTRINS_COS:
8002         case INTRINS_SQRT:
8003         case INTRINS_FABS: {
8004                 LLVMTypeRef params [] = { LLVMDoubleType () };
8005
8006                 AddFunc (module, name, LLVMDoubleType (), params, 1);
8007                 break;
8008         }
8009         case INTRINS_EXPECT_I8:
8010                 AddFunc2 (module, name, LLVMInt8Type (), LLVMInt8Type (), LLVMInt8Type ());
8011                 break;
8012         case INTRINS_EXPECT_I1:
8013                 AddFunc2 (module, name, LLVMInt1Type (), LLVMInt1Type (), LLVMInt1Type ());
8014                 break;
8015 #if defined(TARGET_AMD64) || defined(TARGET_X86)
8016         case INTRINS_SSE_PMOVMSKB:
8017                 /* pmovmskb */
8018                 ret_type = LLVMInt32Type ();
8019                 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
8020                 AddFunc (module, name, ret_type, arg_types, 1);
8021                 break;
8022         case INTRINS_SSE_PSRLI_W:
8023         case INTRINS_SSE_PSRAI_W:
8024         case INTRINS_SSE_PSLLI_W:
8025                 /* shifts */
8026                 ret_type = type_to_simd_type (MONO_TYPE_I2);
8027                 arg_types [0] = ret_type;
8028                 arg_types [1] = LLVMInt32Type ();
8029                 AddFunc (module, name, ret_type, arg_types, 2);
8030                 break;
8031         case INTRINS_SSE_PSRLI_D:
8032         case INTRINS_SSE_PSRAI_D:
8033         case INTRINS_SSE_PSLLI_D:
8034                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8035                 arg_types [0] = ret_type;
8036                 arg_types [1] = LLVMInt32Type ();
8037                 AddFunc (module, name, ret_type, arg_types, 2);
8038                 break;
8039         case INTRINS_SSE_PSRLI_Q:
8040         case INTRINS_SSE_PSLLI_Q:
8041                 ret_type = type_to_simd_type (MONO_TYPE_I8);
8042                 arg_types [0] = ret_type;
8043                 arg_types [1] = LLVMInt32Type ();
8044                 AddFunc (module, name, ret_type, arg_types, 2);
8045                 break;
8046         case INTRINS_SSE_SQRT_PD:
8047                 /* Unary ops */
8048                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8049                 arg_types [0] = ret_type;
8050                 AddFunc (module, name, ret_type, arg_types, 1);
8051                 break;
8052         case INTRINS_SSE_SQRT_PS:
8053                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8054                 arg_types [0] = ret_type;
8055                 AddFunc (module, name, ret_type, arg_types, 1);
8056                 break;
8057         case INTRINS_SSE_RSQRT_PS:
8058                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8059                 arg_types [0] = ret_type;
8060                 AddFunc (module, name, ret_type, arg_types, 1);
8061                 break;
8062         case INTRINS_SSE_RCP_PS:
8063                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8064                 arg_types [0] = ret_type;
8065                 AddFunc (module, name, ret_type, arg_types, 1);
8066                 break;
8067         case INTRINS_SSE_CVTTPD2DQ:
8068                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8069                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8070                 AddFunc (module, name, ret_type, arg_types, 1);
8071                 break;
8072         case INTRINS_SSE_CVTTPS2DQ:
8073                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8074                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8075                 AddFunc (module, name, ret_type, arg_types, 1);
8076                 break;
8077         case INTRINS_SSE_CVTDQ2PD:
8078                 /* Conversion ops */
8079                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8080                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8081                 AddFunc (module, name, ret_type, arg_types, 1);
8082                 break;
8083         case INTRINS_SSE_CVTDQ2PS:
8084                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8085                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8086                 AddFunc (module, name, ret_type, arg_types, 1);
8087                 break;
8088         case INTRINS_SSE_CVTPD2DQ:
8089                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8090                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8091                 AddFunc (module, name, ret_type, arg_types, 1);
8092                 break;
8093         case INTRINS_SSE_CVTPS2DQ:
8094                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8095                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8096                 AddFunc (module, name, ret_type, arg_types, 1);
8097                 break;
8098         case INTRINS_SSE_CVTPD2PS:
8099                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8100                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8101                 AddFunc (module, name, ret_type, arg_types, 1);
8102                 break;
8103         case INTRINS_SSE_CVTPS2PD:
8104                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8105                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8106                 AddFunc (module, name, ret_type, arg_types, 1);
8107                 break;
8108         case INTRINS_SSE_CMPPD:
8109                 /* cmp pd/ps */
8110                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8111                 arg_types [0] = ret_type;
8112                 arg_types [1] = ret_type;
8113                 arg_types [2] = LLVMInt8Type ();
8114                 AddFunc (module, name, ret_type, arg_types, 3);
8115                 break;
8116         case INTRINS_SSE_CMPPS:
8117                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8118                 arg_types [0] = ret_type;
8119                 arg_types [1] = ret_type;
8120                 arg_types [2] = LLVMInt8Type ();
8121                 AddFunc (module, name, ret_type, arg_types, 3);
8122                 break;
8123         case INTRINS_SSE_PACKSSWB:
8124         case INTRINS_SSE_PACKUSWB:
8125         case INTRINS_SSE_PACKSSDW:
8126                 /* pack */
8127                 ret_type = type_to_simd_type (MONO_TYPE_I1);
8128                 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
8129                 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
8130                 AddFunc (module, name, ret_type, arg_types, 2);
8131                 break;
8132         case INTRINS_SSE_PACKUSDW:
8133                 ret_type = type_to_simd_type (MONO_TYPE_I2);
8134                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8135                 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
8136                 AddFunc (module, name, ret_type, arg_types, 2);
8137                 break;
8138                 /* SSE Binary ops */
8139         case INTRINS_SSE_PADDSW:
8140         case INTRINS_SSE_PSUBSW:
8141         case INTRINS_SSE_PADDUSW:
8142         case INTRINS_SSE_PSUBUSW:
8143         case INTRINS_SSE_PAVGW:
8144         case INTRINS_SSE_PMULHW:
8145         case INTRINS_SSE_PMULHU:
8146                 add_sse_binary (module, name, MONO_TYPE_I2);
8147                 break;
8148         case INTRINS_SSE_MINPS:
8149         case INTRINS_SSE_MAXPS:
8150         case INTRINS_SSE_HADDPS:
8151         case INTRINS_SSE_HSUBPS:
8152         case INTRINS_SSE_ADDSUBPS:
8153                 add_sse_binary (module, name, MONO_TYPE_R4);
8154                 break;
8155         case INTRINS_SSE_MINPD:
8156         case INTRINS_SSE_MAXPD:
8157         case INTRINS_SSE_HADDPD:
8158         case INTRINS_SSE_HSUBPD:
8159         case INTRINS_SSE_ADDSUBPD:
8160                 add_sse_binary (module, name, MONO_TYPE_R8);
8161                 break;
8162         case INTRINS_SE_PADDSB:
8163         case INTRINS_SSE_PSUBSB:
8164         case INTRINS_SSE_PADDUSB:
8165         case INTRINS_SSE_PSUBUSB:
8166         case INTRINS_SSE_PAVGB:
8167                 add_sse_binary (module, name, MONO_TYPE_I1);
8168                 break;
8169         case INTRINS_SSE_PAUSE:
8170                 AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
8171                 break;
8172 #endif
8173         default:
8174                 g_assert_not_reached ();
8175                 break;
8176         }
8177 }
8178
8179 static LLVMValueRef
8180 get_intrinsic (EmitContext *ctx, const char *name)
8181 {
8182 #if LLVM_API_VERSION > 100
8183         LLVMValueRef res;
8184
8185         /*
8186          * Every method is emitted into its own module so
8187          * we can add intrinsics on demand.
8188          */
8189         res = LLVMGetNamedFunction (ctx->lmodule, name);
8190         if (!res) {
8191                 int id = -1;
8192
8193                 /* No locking needed */
8194                 id = GPOINTER_TO_INT (g_hash_table_lookup (intrins_name_to_id, name));
8195                 id --;
8196                 if (id == -1)
8197                         printf ("%s\n", name);
8198                 g_assert (id != -1);
8199                 add_intrinsic (ctx->lmodule, id);
8200                 res = LLVMGetNamedFunction (ctx->lmodule, name);
8201                 g_assert (res);
8202         }
8203
8204         return res;
8205 #else
8206         LLVMValueRef res;
8207
8208         res = LLVMGetNamedFunction (ctx->lmodule, name);
8209         g_assert (res);
8210         return res;
8211 #endif
8212 }
8213
8214 static void
8215 add_intrinsics (LLVMModuleRef module)
8216 {
8217         int i;
8218
8219         /* Emit declarations of instrinsics */
8220         /*
8221          * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
8222          * type doesn't seem to do any locking.
8223          */
8224         for (i = 0; i < INTRINS_NUM; ++i)
8225                 add_intrinsic (module, i);
8226
8227         /* EH intrinsics */
8228         {
8229                 AddFunc (module, "mono_personality", LLVMVoidType (), NULL, 0);
8230
8231                 AddFunc (module, "llvm_resume_unwind_trampoline", LLVMVoidType (), NULL, 0);
8232         }
8233
8234         /* Load/Store intrinsics */
8235         {
8236                 LLVMTypeRef arg_types [5];
8237                 int i;
8238                 char name [128];
8239
8240                 for (i = 1; i <= 8; i *= 2) {
8241                         arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
8242                         arg_types [1] = LLVMInt32Type ();
8243                         arg_types [2] = LLVMInt1Type ();
8244                         arg_types [3] = LLVMInt32Type ();
8245                         sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
8246                         AddFunc (module, name, LLVMIntType (i * 8), arg_types, 4);
8247
8248                         arg_types [0] = LLVMIntType (i * 8);
8249                         arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
8250                         arg_types [2] = LLVMInt32Type ();
8251                         arg_types [3] = LLVMInt1Type ();
8252                         arg_types [4] = LLVMInt32Type ();
8253                         sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
8254                         AddFunc (module, name, LLVMVoidType (), arg_types, 5);
8255                 }
8256         }
8257 }
8258
8259 static void
8260 add_types (MonoLLVMModule *module)
8261 {
8262         module->ptr_type = LLVMPointerType (sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type (), 0);
8263 }
8264
8265 void
8266 mono_llvm_init (void)
8267 {
8268         GHashTable *h;
8269         int i;
8270
8271         mono_native_tls_alloc (&current_cfg_tls_id, NULL);
8272
8273         h = g_hash_table_new (NULL, NULL);
8274         for (i = 0; i < INTRINS_NUM; ++i)
8275                 g_hash_table_insert (h, GINT_TO_POINTER (intrinsics [i].id), (gpointer)intrinsics [i].name);
8276         intrins_id_to_name = h;
8277
8278         h = g_hash_table_new (g_str_hash, g_str_equal);
8279         for (i = 0; i < INTRINS_NUM; ++i)
8280                 g_hash_table_insert (h, (gpointer)intrinsics [i].name, GINT_TO_POINTER (intrinsics [i].id + 1));
8281         intrins_name_to_id = h;
8282 }
8283
8284 static void
8285 init_jit_module (MonoDomain *domain)
8286 {
8287         MonoJitDomainInfo *dinfo;
8288         MonoLLVMModule *module;
8289         char *name;
8290
8291         dinfo = domain_jit_info (domain);
8292         if (dinfo->llvm_module)
8293                 return;
8294
8295         mono_loader_lock ();
8296
8297         if (dinfo->llvm_module) {
8298                 mono_loader_unlock ();
8299                 return;
8300         }
8301
8302         module = g_new0 (MonoLLVMModule, 1);
8303
8304         name = g_strdup_printf ("mono-%s", domain->friendly_name);
8305         module->lmodule = LLVMModuleCreateWithName (name);
8306         module->context = LLVMGetGlobalContext ();
8307
8308         module->mono_ee = (MonoEERef*)mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (module->lmodule), alloc_cb, emitted_cb, exception_cb, dlsym_cb, &module->ee);
8309
8310         add_intrinsics (module->lmodule);
8311         add_types (module);
8312
8313         module->llvm_types = g_hash_table_new (NULL, NULL);
8314
8315 #if LLVM_API_VERSION < 100
8316         MonoJitICallInfo *info;
8317
8318         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
8319         g_assert (info);
8320         LLVMAddGlobalMapping (module->ee, LLVMGetNamedFunction (module->lmodule, "llvm_resume_unwind_trampoline"), (void*)info->func);
8321 #endif
8322
8323         mono_memory_barrier ();
8324
8325         dinfo->llvm_module = module;
8326
8327         mono_loader_unlock ();
8328 }
8329
8330 void
8331 mono_llvm_cleanup (void)
8332 {
8333         MonoLLVMModule *module = &aot_module;
8334
8335         if (module->lmodule)
8336                 LLVMDisposeModule (module->lmodule);
8337
8338         if (module->context)
8339                 LLVMContextDispose (module->context);
8340 }
8341
8342 void
8343 mono_llvm_free_domain_info (MonoDomain *domain)
8344 {
8345         MonoJitDomainInfo *info = domain_jit_info (domain);
8346         MonoLLVMModule *module = (MonoLLVMModule*)info->llvm_module;
8347         int i;
8348
8349         if (!module)
8350                 return;
8351
8352         if (module->llvm_types)
8353                 g_hash_table_destroy (module->llvm_types);
8354
8355         mono_llvm_dispose_ee (module->mono_ee);
8356
8357         if (module->bb_names) {
8358                 for (i = 0; i < module->bb_names_len; ++i)
8359                         g_free (module->bb_names [i]);
8360                 g_free (module->bb_names);
8361         }
8362         //LLVMDisposeModule (module->module);
8363
8364         g_free (module);
8365
8366         info->llvm_module = NULL;
8367 }
8368
8369 void
8370 mono_llvm_create_aot_module (MonoAssembly *assembly, const char *global_prefix, gboolean emit_dwarf, gboolean static_link, gboolean llvm_only)
8371 {
8372         MonoLLVMModule *module = &aot_module;
8373
8374         /* Delete previous module */
8375         if (module->plt_entries)
8376                 g_hash_table_destroy (module->plt_entries);
8377         if (module->lmodule)
8378                 LLVMDisposeModule (module->lmodule);
8379
8380         memset (module, 0, sizeof (aot_module));
8381
8382         module->lmodule = LLVMModuleCreateWithName ("aot");
8383         module->assembly = assembly;
8384         module->global_prefix = g_strdup (global_prefix);
8385         module->got_symbol = g_strdup_printf ("%s_llvm_got", global_prefix);
8386         module->eh_frame_symbol = g_strdup_printf ("%s_eh_frame", global_prefix);
8387         module->get_method_symbol = g_strdup_printf ("%s_get_method", global_prefix);
8388         module->get_unbox_tramp_symbol = g_strdup_printf ("%s_get_unbox_tramp", global_prefix);
8389         module->external_symbols = TRUE;
8390         module->emit_dwarf = emit_dwarf;
8391         module->static_link = static_link;
8392         module->llvm_only = llvm_only;
8393         /* The first few entries are reserved */
8394         module->max_got_offset = 16;
8395         module->context = LLVMGetGlobalContext ();
8396
8397         if (llvm_only)
8398                 /* clang ignores our debug info because it has an invalid version */
8399                 module->emit_dwarf = FALSE;
8400
8401         add_intrinsics (module->lmodule);
8402         add_types (module);
8403
8404 #if LLVM_API_VERSION > 100
8405         if (module->emit_dwarf) {
8406                 char *dir, *build_info, *s, *cu_name;
8407
8408                 module->di_builder = mono_llvm_create_di_builder (module->lmodule);
8409
8410                 // FIXME:
8411                 dir = g_strdup (".");
8412                 build_info = mono_get_runtime_build_info ();
8413                 s = g_strdup_printf ("Mono AOT Compiler %s (LLVM)", build_info);
8414                 cu_name = g_path_get_basename (assembly->image->name);
8415                 module->cu = mono_llvm_di_create_compile_unit (module->di_builder, cu_name, dir, s);
8416                 g_free (dir);
8417                 g_free (build_info);
8418                 g_free (s);
8419         }
8420 #endif
8421
8422         /* Add GOT */
8423         /*
8424          * We couldn't compute the type of the LLVM global representing the got because
8425          * its size is only known after all the methods have been emitted. So create
8426          * a dummy variable, and replace all uses it with the real got variable when
8427          * its size is known in mono_llvm_emit_aot_module ().
8428          */
8429         {
8430                 LLVMTypeRef got_type = LLVMArrayType (module->ptr_type, 0);
8431
8432                 module->got_var = LLVMAddGlobal (module->lmodule, got_type, "mono_dummy_got");
8433                 LLVMSetInitializer (module->got_var, LLVMConstNull (got_type));
8434         }
8435
8436         /* Add initialization array */
8437         if (llvm_only) {
8438                 LLVMTypeRef inited_type = LLVMArrayType (LLVMInt8Type (), 0);
8439
8440                 module->inited_var = LLVMAddGlobal (aot_module.lmodule, inited_type, "mono_inited_tmp");
8441                 LLVMSetInitializer (module->inited_var, LLVMConstNull (inited_type));
8442         }
8443
8444         if (llvm_only)
8445                 emit_init_icall_wrappers (module);
8446
8447         emit_llvm_code_start (module);
8448
8449         /* Add a dummy personality function */
8450         if (!use_debug_personality) {
8451                 LLVMValueRef personality = LLVMAddFunction (module->lmodule, default_personality_name, LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE));
8452                 LLVMSetLinkage (personality, LLVMExternalLinkage);
8453                 mark_as_used (module, personality);
8454         }
8455
8456         /* Add a reference to the c++ exception we throw/catch */
8457         {
8458                 LLVMTypeRef exc = LLVMPointerType (LLVMInt8Type (), 0);
8459                 module->sentinel_exception = LLVMAddGlobal (module->lmodule, exc, "_ZTIPi");
8460                 LLVMSetLinkage (module->sentinel_exception, LLVMExternalLinkage);
8461                 mono_llvm_set_is_constant (module->sentinel_exception);
8462         }
8463
8464         module->llvm_types = g_hash_table_new (NULL, NULL);
8465         module->plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
8466         module->plt_entries_ji = g_hash_table_new (NULL, NULL);
8467         module->direct_callables = g_hash_table_new (g_str_hash, g_str_equal);
8468         module->method_to_lmethod = g_hash_table_new (NULL, NULL);
8469         module->idx_to_lmethod = g_hash_table_new (NULL, NULL);
8470         module->idx_to_unbox_tramp = g_hash_table_new (NULL, NULL);
8471         module->method_to_callers = g_hash_table_new (NULL, NULL);
8472 }
8473
8474 static LLVMValueRef
8475 llvm_array_from_uints (LLVMTypeRef el_type, guint32 *values, int nvalues)
8476 {
8477         int i;
8478         LLVMValueRef res, *vals;
8479
8480         vals = g_new0 (LLVMValueRef, nvalues);
8481         for (i = 0; i < nvalues; ++i)
8482                 vals [i] = LLVMConstInt (LLVMInt32Type (), values [i], FALSE);
8483         res = LLVMConstArray (LLVMInt32Type (), vals, nvalues);
8484         g_free (vals);
8485         return res;
8486 }
8487
8488 static LLVMValueRef
8489 llvm_array_from_bytes (guint8 *values, int nvalues)
8490 {
8491         int i;
8492         LLVMValueRef res, *vals;
8493
8494         vals = g_new0 (LLVMValueRef, nvalues);
8495         for (i = 0; i < nvalues; ++i)
8496                 vals [i] = LLVMConstInt (LLVMInt8Type (), values [i], FALSE);
8497         res = LLVMConstArray (LLVMInt8Type (), vals, nvalues);
8498         g_free (vals);
8499         return res;
8500 }
8501 /*
8502  * mono_llvm_emit_aot_file_info:
8503  *
8504  *   Emit the MonoAotFileInfo structure.
8505  * Same as emit_aot_file_info () in aot-compiler.c.
8506  */
8507 void
8508 mono_llvm_emit_aot_file_info (MonoAotFileInfo *info, gboolean has_jitted_code)
8509 {
8510         MonoLLVMModule *module = &aot_module;
8511
8512         /* Save these for later */
8513         memcpy (&module->aot_info, info, sizeof (MonoAotFileInfo));
8514         module->has_jitted_code = has_jitted_code;
8515 }
8516
8517 /*
8518  * mono_llvm_emit_aot_data:
8519  *
8520  *   Emit the binary data DATA pointed to by symbol SYMBOL.
8521  */
8522 void
8523 mono_llvm_emit_aot_data (const char *symbol, guint8 *data, int data_len)
8524 {
8525         MonoLLVMModule *module = &aot_module;
8526         LLVMTypeRef type;
8527         LLVMValueRef d;
8528
8529         type = LLVMArrayType (LLVMInt8Type (), data_len);
8530         d = LLVMAddGlobal (module->lmodule, type, symbol);
8531         LLVMSetVisibility (d, LLVMHiddenVisibility);
8532         LLVMSetLinkage (d, LLVMInternalLinkage);
8533         LLVMSetInitializer (d, mono_llvm_create_constant_data_array (data, data_len));
8534         mono_llvm_set_is_constant (d);
8535 }
8536
8537 /* Add a reference to a global defined in JITted code */
8538 static LLVMValueRef
8539 AddJitGlobal (MonoLLVMModule *module, LLVMTypeRef type, const char *name)
8540 {
8541         char *s;
8542         LLVMValueRef v;
8543
8544         s = g_strdup_printf ("%s%s", module->global_prefix, name);
8545         v = LLVMAddGlobal (module->lmodule, LLVMInt8Type (), s);
8546         g_free (s);
8547         return v;
8548 }
8549
8550 static void
8551 emit_aot_file_info (MonoLLVMModule *module)
8552 {
8553         LLVMTypeRef file_info_type;
8554         LLVMTypeRef *eltypes, eltype;
8555         LLVMValueRef info_var;
8556         LLVMValueRef *fields;
8557         int i, nfields, tindex;
8558         MonoAotFileInfo *info;
8559         LLVMModuleRef lmodule = module->lmodule;
8560
8561         info = &module->aot_info;
8562
8563         /* Create an LLVM type to represent MonoAotFileInfo */
8564         nfields = 2 + MONO_AOT_FILE_INFO_NUM_SYMBOLS + 16 + 5;
8565         eltypes = g_new (LLVMTypeRef, nfields);
8566         tindex = 0;
8567         eltypes [tindex ++] = LLVMInt32Type ();
8568         eltypes [tindex ++] = LLVMInt32Type ();
8569         /* Symbols */
8570         for (i = 0; i < MONO_AOT_FILE_INFO_NUM_SYMBOLS; ++i)
8571                 eltypes [tindex ++] = LLVMPointerType (LLVMInt8Type (), 0);
8572         /* Scalars */
8573         for (i = 0; i < 15; ++i)
8574                 eltypes [tindex ++] = LLVMInt32Type ();
8575         /* Arrays */
8576         eltypes [tindex ++] = LLVMArrayType (LLVMInt32Type (), MONO_AOT_TABLE_NUM);
8577         for (i = 0; i < 4; ++i)
8578                 eltypes [tindex ++] = LLVMArrayType (LLVMInt32Type (), MONO_AOT_TRAMP_NUM);
8579         eltypes [tindex ++] = LLVMArrayType (LLVMInt8Type (), 16);
8580         g_assert (tindex == nfields);
8581         file_info_type = LLVMStructCreateNamed (module->context, "MonoAotFileInfo");
8582         LLVMStructSetBody (file_info_type, eltypes, nfields, FALSE);
8583
8584         info_var = LLVMAddGlobal (lmodule, file_info_type, "mono_aot_file_info");
8585         if (module->static_link) {
8586                 LLVMSetVisibility (info_var, LLVMHiddenVisibility);
8587                 LLVMSetLinkage (info_var, LLVMInternalLinkage);
8588         }
8589         fields = g_new (LLVMValueRef, nfields);
8590         tindex = 0;
8591         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->version, FALSE);
8592         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->dummy, FALSE);
8593
8594         /* Symbols */
8595         /*
8596          * We use LLVMGetNamedGlobal () for symbol which are defined in LLVM code, and LLVMAddGlobal ()
8597          * for symbols defined in the .s file emitted by the aot compiler.
8598          */
8599         eltype = eltypes [tindex];
8600         if (module->llvm_only)
8601                 fields [tindex ++] = LLVMConstNull (eltype);
8602         else
8603                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_got");
8604         fields [tindex ++] = module->got_var;
8605         /* llc defines this directly */
8606         if (!module->llvm_only) {
8607                 fields [tindex ++] = LLVMAddGlobal (lmodule, eltype, module->eh_frame_symbol);
8608                 fields [tindex ++] = LLVMConstNull (eltype);
8609                 fields [tindex ++] = LLVMConstNull (eltype);
8610         } else {
8611                 fields [tindex ++] = LLVMConstNull (eltype);
8612                 fields [tindex ++] = module->get_method;
8613                 fields [tindex ++] = module->get_unbox_tramp;
8614         }
8615         if (module->has_jitted_code) {
8616                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_code_start");
8617                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_code_end");
8618         } else {
8619                 fields [tindex ++] = LLVMConstNull (eltype);
8620                 fields [tindex ++] = LLVMConstNull (eltype);
8621         }
8622         if (!module->llvm_only)
8623                 fields [tindex ++] = AddJitGlobal (module, eltype, "method_addresses");
8624         else
8625                 fields [tindex ++] = LLVMConstNull (eltype);
8626         if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA) {
8627                 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
8628                         fields [tindex ++] = LLVMConstNull (eltype);
8629         } else {
8630                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "blob");
8631                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "class_name_table");
8632                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "class_info_offsets");
8633                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "method_info_offsets");
8634                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "ex_info_offsets");
8635                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "extra_method_info_offsets");
8636                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "extra_method_table");
8637                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "got_info_offsets");
8638                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "llvm_got_info_offsets");
8639                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "image_table");
8640         }
8641         /* Not needed (mem_end) */
8642         fields [tindex ++] = LLVMConstNull (eltype);
8643         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "assembly_guid");
8644         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "runtime_version");
8645         if (info->trampoline_size [0]) {
8646                 fields [tindex ++] = AddJitGlobal (module, eltype, "specific_trampolines");
8647                 fields [tindex ++] = AddJitGlobal (module, eltype, "static_rgctx_trampolines");
8648                 fields [tindex ++] = AddJitGlobal (module, eltype, "imt_trampolines");
8649                 fields [tindex ++] = AddJitGlobal (module, eltype, "gsharedvt_arg_trampolines");
8650         } else {
8651                 fields [tindex ++] = LLVMConstNull (eltype);
8652                 fields [tindex ++] = LLVMConstNull (eltype);
8653                 fields [tindex ++] = LLVMConstNull (eltype);
8654                 fields [tindex ++] = LLVMConstNull (eltype);
8655         }
8656         if (module->static_link && !module->llvm_only)
8657                 fields [tindex ++] = AddJitGlobal (module, eltype, "globals");
8658         else
8659                 fields [tindex ++] = LLVMConstNull (eltype);
8660         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "assembly_name");
8661         if (!module->llvm_only) {
8662                 fields [tindex ++] = AddJitGlobal (module, eltype, "plt");
8663                 fields [tindex ++] = AddJitGlobal (module, eltype, "plt_end");
8664                 fields [tindex ++] = AddJitGlobal (module, eltype, "unwind_info");
8665                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampolines");
8666                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampolines_end");
8667                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampoline_addresses");
8668         } else {
8669                 fields [tindex ++] = LLVMConstNull (eltype);
8670                 fields [tindex ++] = LLVMConstNull (eltype);
8671                 fields [tindex ++] = LLVMConstNull (eltype);
8672                 fields [tindex ++] = LLVMConstNull (eltype);
8673                 fields [tindex ++] = LLVMConstNull (eltype);
8674                 fields [tindex ++] = LLVMConstNull (eltype);
8675         }
8676
8677         for (i = 0; i < MONO_AOT_FILE_INFO_NUM_SYMBOLS; ++i)
8678                 fields [2 + i] = LLVMConstBitCast (fields [2 + i], eltype);
8679
8680         /* Scalars */
8681         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->plt_got_offset_base, FALSE);
8682         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->got_size, FALSE);
8683         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->plt_size, FALSE);
8684         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->nmethods, FALSE);
8685         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->flags, FALSE);
8686         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->opts, FALSE);
8687         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->simd_opts, FALSE);
8688         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->gc_name_index, FALSE);
8689         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->num_rgctx_fetch_trampolines, FALSE);
8690         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->double_align, FALSE);
8691         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->long_align, FALSE);
8692         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->generic_tramp_num, FALSE);
8693         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->tramp_page_size, FALSE);
8694         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->nshared_got_entries, FALSE);
8695         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->datafile_size, FALSE);
8696         /* Arrays */
8697         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->table_offsets, MONO_AOT_TABLE_NUM);
8698         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->num_trampolines, MONO_AOT_TRAMP_NUM);
8699         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->trampoline_got_offset_base, MONO_AOT_TRAMP_NUM);
8700         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->trampoline_size, MONO_AOT_TRAMP_NUM);
8701         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->tramp_page_code_offsets, MONO_AOT_TRAMP_NUM);
8702
8703         fields [tindex ++] = llvm_array_from_bytes (info->aotid, 16);
8704         g_assert (tindex == nfields);
8705
8706         LLVMSetInitializer (info_var, LLVMConstNamedStruct (file_info_type, fields, nfields));
8707
8708         if (module->static_link) {
8709                 char *s, *p;
8710                 LLVMValueRef var;
8711
8712                 s = g_strdup_printf ("mono_aot_module_%s_info", module->assembly->aname.name);
8713                 /* Get rid of characters which cannot occur in symbols */
8714                 p = s;
8715                 for (p = s; *p; ++p) {
8716                         if (!(isalnum (*p) || *p == '_'))
8717                                 *p = '_';
8718                 }
8719                 var = LLVMAddGlobal (module->lmodule, LLVMPointerType (LLVMInt8Type (), 0), s);
8720                 g_free (s);
8721                 LLVMSetInitializer (var, LLVMConstBitCast (LLVMGetNamedGlobal (module->lmodule, "mono_aot_file_info"), LLVMPointerType (LLVMInt8Type (), 0)));
8722                 LLVMSetLinkage (var, LLVMExternalLinkage);
8723         }
8724 }
8725
8726 /*
8727  * Emit the aot module into the LLVM bitcode file FILENAME.
8728  */
8729 void
8730 mono_llvm_emit_aot_module (const char *filename, const char *cu_name)
8731 {
8732         LLVMTypeRef got_type, inited_type;
8733         LLVMValueRef real_got, real_inited;
8734         MonoLLVMModule *module = &aot_module;
8735
8736         emit_llvm_code_end (module);
8737
8738         /*
8739          * Create the real got variable and replace all uses of the dummy variable with
8740          * the real one.
8741          */
8742         got_type = LLVMArrayType (module->ptr_type, module->max_got_offset + 1);
8743         real_got = LLVMAddGlobal (module->lmodule, got_type, module->got_symbol);
8744         LLVMSetInitializer (real_got, LLVMConstNull (got_type));
8745         if (module->external_symbols) {
8746                 LLVMSetLinkage (real_got, LLVMExternalLinkage);
8747                 LLVMSetVisibility (real_got, LLVMHiddenVisibility);
8748         } else {
8749                 LLVMSetLinkage (real_got, LLVMInternalLinkage);
8750         }
8751         mono_llvm_replace_uses_of (module->got_var, real_got);
8752
8753         mark_as_used (&aot_module, real_got);
8754
8755         /* Delete the dummy got so it doesn't become a global */
8756         LLVMDeleteGlobal (module->got_var);
8757         module->got_var = real_got;
8758
8759         /*
8760          * Same for the init_var
8761          */
8762         if (module->llvm_only) {
8763                 inited_type = LLVMArrayType (LLVMInt8Type (), module->max_inited_idx + 1);
8764                 real_inited = LLVMAddGlobal (module->lmodule, inited_type, "mono_inited");
8765                 LLVMSetInitializer (real_inited, LLVMConstNull (inited_type));
8766                 LLVMSetLinkage (real_inited, LLVMInternalLinkage);
8767                 mono_llvm_replace_uses_of (module->inited_var, real_inited);
8768                 LLVMDeleteGlobal (module->inited_var);
8769         }
8770
8771         if (module->llvm_only) {
8772                 emit_get_method (&aot_module);
8773                 emit_get_unbox_tramp (&aot_module);
8774         }
8775
8776         emit_llvm_used (&aot_module);
8777         emit_dbg_info (&aot_module, filename, cu_name);
8778         emit_aot_file_info (&aot_module);
8779
8780         /*
8781          * Replace GOT entries for directly callable methods with the methods themselves.
8782          * It would be easier to implement this by predefining all methods before compiling
8783          * their bodies, but that couldn't handle the case when a method fails to compile
8784          * with llvm.
8785          */
8786         if (module->llvm_only) {
8787                 GHashTableIter iter;
8788                 MonoMethod *method;
8789                 GSList *callers, *l;
8790
8791                 g_hash_table_iter_init (&iter, module->method_to_callers);
8792                 while (g_hash_table_iter_next (&iter, (void**)&method, (void**)&callers)) {
8793                         LLVMValueRef lmethod;
8794
8795                         if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
8796                                 continue;
8797
8798                         lmethod = (LLVMValueRef)g_hash_table_lookup (module->method_to_lmethod, method);
8799                         if (lmethod) {
8800                                 for (l = callers; l; l = l->next) {
8801                                         LLVMValueRef caller = (LLVMValueRef)l->data;
8802
8803                                         mono_llvm_replace_uses_of (caller, lmethod);
8804                                 }
8805                         }
8806                 }
8807         }
8808
8809         /* Replace PLT entries for directly callable methods with the methods themselves */
8810         {
8811                 GHashTableIter iter;
8812                 MonoJumpInfo *ji;
8813                 LLVMValueRef callee;
8814
8815                 g_hash_table_iter_init (&iter, module->plt_entries_ji);
8816                 while (g_hash_table_iter_next (&iter, (void**)&ji, (void**)&callee)) {
8817                         if (mono_aot_is_direct_callable (ji)) {
8818                                 LLVMValueRef lmethod;
8819
8820                                 lmethod = (LLVMValueRef)g_hash_table_lookup (module->method_to_lmethod, ji->data.method);
8821                                 /* The types might not match because the caller might pass an rgctx */
8822                                 if (lmethod && LLVMTypeOf (callee) == LLVMTypeOf (lmethod)) {
8823                                         mono_llvm_replace_uses_of (callee, lmethod);
8824                                         mono_aot_mark_unused_llvm_plt_entry (ji);
8825                                 }
8826                         }
8827                 }
8828         }
8829
8830 #if 1
8831         {
8832                 char *verifier_err;
8833
8834                 if (LLVMVerifyModule (module->lmodule, LLVMReturnStatusAction, &verifier_err)) {
8835                         printf ("%s\n", verifier_err);
8836                         g_assert_not_reached ();
8837                 }
8838         }
8839 #endif
8840
8841         LLVMWriteBitcodeToFile (module->lmodule, filename);
8842 }
8843
8844
8845 static LLVMValueRef
8846 md_string (const char *s)
8847 {
8848         return LLVMMDString (s, strlen (s));
8849 }
8850
8851 /* Debugging support */
8852
8853 static void
8854 emit_dbg_info (MonoLLVMModule *module, const char *filename, const char *cu_name)
8855 {
8856         LLVMModuleRef lmodule = module->lmodule;
8857         LLVMValueRef args [16], ver;
8858
8859         /*
8860          * This can only be enabled when LLVM code is emitted into a separate object
8861          * file, since the AOT compiler also emits dwarf info,
8862          * and the abbrev indexes will not be correct since llvm has added its own
8863          * abbrevs.
8864          */
8865         if (!module->emit_dwarf)
8866                 return;
8867
8868 #if LLVM_API_VERSION > 100
8869         mono_llvm_di_builder_finalize (module->di_builder);
8870 #else
8871         LLVMValueRef cu_args [16], cu;
8872         int n_cuargs;
8873         char *build_info, *s, *dir;
8874
8875         /*
8876          * Emit dwarf info in the form of LLVM metadata. There is some
8877          * out-of-date documentation at:
8878          * http://llvm.org/docs/SourceLevelDebugging.html
8879          * but most of this was gathered from the llvm and
8880          * clang sources.
8881          */
8882
8883         n_cuargs = 0;
8884         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), DW_TAG_compile_unit, FALSE);
8885         /* CU name/compilation dir */
8886         dir = g_path_get_dirname (filename);
8887         args [0] = LLVMMDString (cu_name, strlen (cu_name));
8888         args [1] = LLVMMDString (dir, strlen (dir));
8889         cu_args [n_cuargs ++] = LLVMMDNode (args, 2);
8890         g_free (dir);
8891         /* Language */
8892         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), DW_LANG_C99, FALSE);
8893         /* Producer */
8894         build_info = mono_get_runtime_build_info ();
8895         s = g_strdup_printf ("Mono AOT Compiler %s (LLVM)", build_info);
8896         cu_args [n_cuargs ++] = LLVMMDString (s, strlen (s));
8897         g_free (build_info);
8898         /* Optimized */
8899         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8900         /* Flags */
8901         cu_args [n_cuargs ++] = LLVMMDString ("", strlen (""));
8902         /* Runtime version */
8903         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
8904         /* Enums */
8905         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8906         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8907         /* Subprograms */
8908         if (module->subprogram_mds) {
8909                 LLVMValueRef *mds;
8910                 int i;
8911
8912                 mds = g_new0 (LLVMValueRef, module->subprogram_mds->len);
8913                 for (i = 0; i < module->subprogram_mds->len; ++i)
8914                         mds [i] = (LLVMValueRef)g_ptr_array_index (module->subprogram_mds, i);
8915                 cu_args [n_cuargs ++] = LLVMMDNode (mds, module->subprogram_mds->len);
8916         } else {
8917                 cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8918         }
8919         /* GVs */
8920         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8921         /* Imported modules */
8922         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8923         /* SplitName */
8924         cu_args [n_cuargs ++] = LLVMMDString ("", strlen (""));
8925         /* DebugEmissionKind = FullDebug */
8926         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8927         cu = LLVMMDNode (cu_args, n_cuargs);
8928         LLVMAddNamedMetadataOperand (lmodule, "llvm.dbg.cu", cu);
8929 #endif
8930
8931 #if LLVM_API_VERSION > 100
8932         args [0] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8933         args [1] = LLVMMDString ("Dwarf Version", strlen ("Dwarf Version"));
8934         args [2] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8935         ver = LLVMMDNode (args, 3);
8936         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8937
8938         args [0] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8939         args [1] = LLVMMDString ("Debug Info Version", strlen ("Debug Info Version"));
8940         args [2] = LLVMConstInt (LLVMInt64Type (), 3, FALSE);
8941         ver = LLVMMDNode (args, 3);
8942         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8943 #else
8944         args [0] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8945         args [1] = LLVMMDString ("Dwarf Version", strlen ("Dwarf Version"));
8946         args [2] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8947         ver = LLVMMDNode (args, 3);
8948         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8949
8950         args [0] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8951         args [1] = LLVMMDString ("Debug Info Version", strlen ("Debug Info Version"));
8952         args [2] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8953         ver = LLVMMDNode (args, 3);
8954         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8955 #endif
8956 }
8957
8958 static LLVMValueRef
8959 emit_dbg_subprogram (EmitContext *ctx, MonoCompile *cfg, LLVMValueRef method, const char *name)
8960 {
8961         MonoLLVMModule *module = ctx->module;
8962         MonoDebugMethodInfo *minfo = ctx->minfo;
8963         char *source_file, *dir, *filename;
8964         LLVMValueRef md, args [16], ctx_args [16], md_args [64], type_args [16], ctx_md, type_md;
8965         MonoSymSeqPoint *sym_seq_points;
8966         int n_seq_points;
8967
8968         if (!minfo)
8969                 return NULL;
8970
8971         mono_debug_symfile_get_seq_points (minfo, &source_file, NULL, NULL, &sym_seq_points, &n_seq_points);
8972         if (!source_file)
8973                 source_file = g_strdup ("<unknown>");
8974         dir = g_path_get_dirname (source_file);
8975         filename = g_path_get_basename (source_file);
8976
8977 #if LLVM_API_VERSION > 100
8978         return mono_llvm_di_create_function (module->di_builder, module->cu, method, cfg->method->name, name, dir, filename, n_seq_points ? sym_seq_points [0].line : 1);
8979 #endif
8980
8981         ctx_args [0] = LLVMConstInt (LLVMInt32Type (), 0x29, FALSE);
8982         args [0] = md_string (filename);
8983         args [1] = md_string (dir);
8984         ctx_args [1] = LLVMMDNode (args, 2);
8985         ctx_md = LLVMMDNode (ctx_args, 2);
8986
8987         type_args [0] = LLVMConstInt (LLVMInt32Type (), DW_TAG_subroutine_type, FALSE);
8988         type_args [1] = NULL;
8989         type_args [2] = NULL;
8990         type_args [3] = LLVMMDString ("", 0);
8991         type_args [4] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
8992         type_args [5] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
8993         type_args [6] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
8994         type_args [7] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
8995         type_args [8] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
8996         type_args [9] = NULL;
8997         type_args [10] = NULL;
8998         type_args [11] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
8999         type_args [12] = NULL;
9000         type_args [13] = NULL;
9001         type_args [14] = NULL;
9002         type_md = LLVMMDNode (type_args, 14);
9003
9004         /* http://llvm.org/docs/SourceLevelDebugging.html#subprogram-descriptors */
9005         md_args [0] = LLVMConstInt (LLVMInt32Type (), DW_TAG_subprogram, FALSE);
9006         /* Source directory + file pair */
9007         args [0] = md_string (filename);
9008         args [1] = md_string (dir);
9009         md_args [1] = LLVMMDNode (args ,2);
9010         md_args [2] = ctx_md;
9011         md_args [3] = md_string (cfg->method->name);
9012         md_args [4] = md_string (name);
9013         md_args [5] = md_string (name);
9014         /* Line number */
9015         if (n_seq_points)
9016                 md_args [6] = LLVMConstInt (LLVMInt32Type (), sym_seq_points [0].line, FALSE);
9017         else
9018                 md_args [6] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
9019         /* Type */
9020         md_args [7] = type_md;
9021         /* static */
9022         md_args [8] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
9023         /* not extern */
9024         md_args [9] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
9025         /* Virtuality */
9026         md_args [10] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
9027         /* Index into a virtual function */
9028         md_args [11] = NULL;
9029         md_args [12] = NULL;
9030         /* Flags */
9031         md_args [13] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
9032         /* isOptimized */
9033         md_args [14] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
9034         /* Pointer to LLVM function */
9035         md_args [15] = method;
9036         /* Function template parameter */
9037         md_args [16] = NULL;
9038         /* Function declaration descriptor */
9039         md_args [17] = NULL;
9040         /* List of function variables */
9041         md_args [18] = LLVMMDNode (args, 0);
9042         /* Line number */
9043         md_args [19] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
9044         md = LLVMMDNode (md_args, 20);
9045
9046         if (!module->subprogram_mds)
9047                 module->subprogram_mds = g_ptr_array_new ();
9048         g_ptr_array_add (module->subprogram_mds, md);
9049
9050         g_free (dir);
9051         g_free (filename);
9052         g_free (source_file);
9053         g_free (sym_seq_points);
9054
9055         return md;
9056 }
9057
9058 static void
9059 emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil_code)
9060 {
9061         MonoCompile *cfg = ctx->cfg;
9062
9063         if (ctx->minfo && cil_code && cil_code >= cfg->header->code && cil_code < cfg->header->code + cfg->header->code_size) {
9064                 MonoDebugSourceLocation *loc;
9065                 LLVMValueRef loc_md;
9066
9067                 loc = mono_debug_symfile_lookup_location (ctx->minfo, cil_code - cfg->header->code);
9068
9069                 if (loc) {
9070 #if LLVM_API_VERSION > 100
9071                         loc_md = mono_llvm_di_create_location (ctx->module->di_builder, ctx->dbg_md, loc->row, loc->column);
9072                         mono_llvm_di_set_location (builder, loc_md);
9073 #else
9074                         LLVMValueRef md_args [16];
9075                         int nmd_args;
9076
9077                         nmd_args = 0;
9078                         md_args [nmd_args ++] = LLVMConstInt (LLVMInt32Type (), loc->row, FALSE);
9079                         md_args [nmd_args ++] = LLVMConstInt (LLVMInt32Type (), loc->column, FALSE);
9080                         md_args [nmd_args ++] = ctx->dbg_md;
9081                         md_args [nmd_args ++] = NULL;
9082                         loc_md = LLVMMDNode (md_args, nmd_args);
9083                         LLVMSetCurrentDebugLocation (builder, loc_md);
9084 #endif
9085                         mono_debug_symfile_free_location (loc);
9086                 }
9087         }
9088 }
9089
9090 void
9091 default_mono_llvm_unhandled_exception (void)
9092 {
9093         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
9094         MonoObject *target = mono_gchandle_get_target (jit_tls->thrown_exc);
9095
9096         mono_unhandled_exception (target);
9097         mono_invoke_unhandled_exception_hook (target);
9098         g_assert_not_reached ();
9099 }
9100
9101 /*
9102   DESIGN:
9103   - Emit LLVM IR from the mono IR using the LLVM C API.
9104   - The original arch specific code remains, so we can fall back to it if we run
9105     into something we can't handle.
9106 */
9107
9108 /*
9109   A partial list of issues:
9110   - Handling of opcodes which can throw exceptions.
9111
9112       In the mono JIT, these are implemented using code like this:
9113           method:
9114       <compare>
9115           throw_pos:
9116           b<cond> ex_label
9117           <rest of code>
9118       ex_label:
9119           push throw_pos - method
9120           call <exception trampoline>
9121
9122           The problematic part is push throw_pos - method, which cannot be represented
9123       in the LLVM IR, since it does not support label values.
9124           -> this can be implemented in AOT mode using inline asm + labels, but cannot
9125           be implemented in JIT mode ?
9126           -> a possible but slower implementation would use the normal exception
9127       throwing code but it would need to control the placement of the throw code
9128       (it needs to be exactly after the compare+branch).
9129           -> perhaps add a PC offset intrinsics ?
9130
9131   - efficient implementation of .ovf opcodes.
9132
9133           These are currently implemented as:
9134           <ins which sets the condition codes>
9135           b<cond> ex_label
9136
9137           Some overflow opcodes are now supported by LLVM SVN.
9138
9139   - exception handling, unwinding.
9140     - SSA is disabled for methods with exception handlers
9141         - How to obtain unwind info for LLVM compiled methods ?
9142           -> this is now solved by converting the unwind info generated by LLVM
9143              into our format.
9144         - LLVM uses the c++ exception handling framework, while we use our home grown
9145       code, and couldn't use the c++ one:
9146       - its not supported under VC++, other exotic platforms.
9147           - it might be impossible to support filter clauses with it.
9148
9149   - trampolines.
9150
9151     The trampolines need a predictable call sequence, since they need to disasm
9152     the calling code to obtain register numbers / offsets.
9153
9154     LLVM currently generates this code in non-JIT mode:
9155            mov    -0x98(%rax),%eax
9156            callq  *%rax
9157     Here, the vtable pointer is lost.
9158     -> solution: use one vtable trampoline per class.
9159
9160   - passing/receiving the IMT pointer/RGCTX.
9161     -> solution: pass them as normal arguments ?
9162
9163   - argument passing.
9164
9165           LLVM does not allow the specification of argument registers etc. This means
9166       that all calls are made according to the platform ABI.
9167
9168   - passing/receiving vtypes.
9169
9170       Vtypes passed/received in registers are handled by the front end by using
9171           a signature with scalar arguments, and loading the parts of the vtype into those
9172           arguments.
9173
9174           Vtypes passed on the stack are handled using the 'byval' attribute.
9175
9176   - ldaddr.
9177
9178     Supported though alloca, we need to emit the load/store code.
9179
9180   - types.
9181
9182     The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
9183     typed registers, so we have to keep track of the precise LLVM type of each vreg.
9184     This is made easier because the IR is already in SSA form.
9185     An additional problem is that our IR is not consistent with types, i.e. i32/ia64
9186         types are frequently used incorrectly.
9187 */
9188
9189 /*
9190   AOT SUPPORT:
9191   Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then link
9192   it with the file containing the methods emitted by the JIT and the AOT data
9193   structures.
9194 */
9195
9196 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
9197  *   - each bblock should end with a branch
9198  *   - setting the return value, making cfg->ret non-volatile
9199  * - avoid some transformations in the JIT which make it harder for us to generate
9200  *   code.
9201  * - use pointer types to help optimizations.
9202  */