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