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