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 0
6151                         // Requires a later llvm version
6152                 case OP_CVTDQ2PD: {
6153                         LLVMValueRef indexes [16];
6154
6155                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
6156                         indexes [1] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
6157                         LLVMValueRef mask = LLVMConstVector (indexes, 2);
6158                         LLVMValueRef shuffle = LLVMBuildShuffleVector (builder, lhs, LLVMConstNull (LLVMTypeOf (lhs)), mask, "");
6159                         values [ins->dreg] = LLVMBuildSIToFP (builder, shuffle, LLVMVectorType (LLVMDoubleType (), 2), dname);
6160                         break;
6161                 }
6162                 case OP_CVTPS2PD: {
6163                         LLVMValueRef indexes [16];
6164
6165                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
6166                         indexes [1] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
6167                         LLVMValueRef mask = LLVMConstVector (indexes, 2);
6168                         LLVMValueRef shuffle = LLVMBuildShuffleVector (builder, lhs, LLVMConstNull (LLVMTypeOf (lhs)), mask, "");
6169                         values [ins->dreg] = LLVMBuildFPExt (builder, shuffle, LLVMVectorType (LLVMDoubleType (), 2), dname);
6170                         break;
6171                 }
6172                 case OP_CVTTPS2DQ:
6173                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMVectorType (LLVMInt32Type (), 4), dname);
6174                         break;
6175 #endif
6176
6177                 case OP_CVTDQ2PD:
6178                 case OP_CVTDQ2PS:
6179                 case OP_CVTPD2DQ:
6180                 case OP_CVTPS2DQ:
6181                 case OP_CVTPD2PS:
6182                 case OP_CVTPS2PD:
6183                 case OP_CVTTPD2DQ:
6184                 case OP_CVTTPS2DQ:
6185                 case OP_EXTRACT_MASK:
6186                 case OP_SQRTPS:
6187                 case OP_SQRTPD:
6188                 case OP_RSQRTPS:
6189                 case OP_RCPPS: {
6190                         LLVMValueRef v;
6191
6192                         v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
6193
6194                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
6195                         break;
6196                 }
6197                 case OP_COMPPS:
6198                 case OP_COMPPD: {
6199                         LLVMRealPredicate op;
6200
6201                         switch (ins->inst_c0) {
6202                         case SIMD_COMP_EQ:
6203                                 op = LLVMRealOEQ;
6204                                 break;
6205                         case SIMD_COMP_LT:
6206                                 op = LLVMRealOLT;
6207                                 break;
6208                         case SIMD_COMP_LE:
6209                                 op = LLVMRealOLE;
6210                                 break;
6211                         case SIMD_COMP_UNORD:
6212                                 op = LLVMRealUNO;
6213                                 break;
6214                         case SIMD_COMP_NEQ:
6215                                 op = LLVMRealUNE;
6216                                 break;
6217                         case SIMD_COMP_NLT:
6218                                 op = LLVMRealUGE;
6219                                 break;
6220                         case SIMD_COMP_NLE:
6221                                 op = LLVMRealUGT;
6222                                 break;
6223                         case SIMD_COMP_ORD:
6224                                 op = LLVMRealORD;
6225                                 break;
6226                         default:
6227                                 g_assert_not_reached ();
6228                         }
6229
6230                         LLVMValueRef cmp = LLVMBuildFCmp (builder, op, lhs, rhs, "");
6231                         if (ins->opcode == OP_COMPPD)
6232                                 values [ins->dreg] = LLVMBuildBitCast (builder, LLVMBuildSExt (builder, cmp, LLVMVectorType (LLVMInt64Type (), 2), ""), LLVMTypeOf (lhs), "");
6233                         else
6234                                 values [ins->dreg] = LLVMBuildBitCast (builder, LLVMBuildSExt (builder, cmp, LLVMVectorType (LLVMInt32Type (), 4), ""), LLVMTypeOf (lhs), "");
6235                         break;
6236                 }
6237                 case OP_ICONV_TO_X:
6238                         /* This is only used for implementing shifts by non-immediate */
6239                         values [ins->dreg] = lhs;
6240                         break;
6241
6242                 case OP_PSHRW:
6243                 case OP_PSHRD:
6244                 case OP_PSHRQ:
6245                 case OP_PSARW:
6246                 case OP_PSARD:
6247                 case OP_PSHLW:
6248                 case OP_PSHLD:
6249                 case OP_PSHLQ: {
6250                         LLVMValueRef args [3];
6251
6252                         args [0] = lhs;
6253                         args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
6254
6255                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 2, dname);
6256                         break;
6257                 }
6258
6259                 case OP_PSHRW_REG:
6260                 case OP_PSHRD_REG:
6261                 case OP_PSHRQ_REG:
6262                 case OP_PSARW_REG:
6263                 case OP_PSARD_REG:
6264                 case OP_PSHLW_REG:
6265                 case OP_PSHLD_REG:
6266                 case OP_PSHLQ_REG: {
6267                         LLVMValueRef args [3];
6268
6269                         args [0] = lhs;
6270                         args [1] = values [ins->sreg2];
6271
6272                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 2, dname);
6273                         break;
6274                 }
6275
6276                 case OP_SHUFPS:
6277                 case OP_SHUFPD:
6278                 case OP_PSHUFLED:
6279                 case OP_PSHUFLEW_LOW:
6280                 case OP_PSHUFLEW_HIGH: {
6281                         int mask [16];
6282                         LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
6283                         int i, mask_size = 0;
6284                         int imask = ins->inst_c0;
6285
6286                         /* Convert the x86 shuffle mask to LLVM's */
6287                         switch (ins->opcode) {
6288                         case OP_SHUFPS:
6289                                 mask_size = 4;
6290                                 mask [0] = ((imask >> 0) & 3);
6291                                 mask [1] = ((imask >> 2) & 3);
6292                                 mask [2] = ((imask >> 4) & 3) + 4;
6293                                 mask [3] = ((imask >> 6) & 3) + 4;
6294                                 v1 = values [ins->sreg1];
6295                                 v2 = values [ins->sreg2];
6296                                 break;
6297                         case OP_SHUFPD:
6298                                 mask_size = 2;
6299                                 mask [0] = ((imask >> 0) & 1);
6300                                 mask [1] = ((imask >> 1) & 1) + 2;
6301                                 v1 = values [ins->sreg1];
6302                                 v2 = values [ins->sreg2];
6303                                 break;
6304                         case OP_PSHUFLEW_LOW:
6305                                 mask_size = 8;
6306                                 mask [0] = ((imask >> 0) & 3);
6307                                 mask [1] = ((imask >> 2) & 3);
6308                                 mask [2] = ((imask >> 4) & 3);
6309                                 mask [3] = ((imask >> 6) & 3);
6310                                 mask [4] = 4 + 0;
6311                                 mask [5] = 4 + 1;
6312                                 mask [6] = 4 + 2;
6313                                 mask [7] = 4 + 3;
6314                                 v1 = values [ins->sreg1];
6315                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6316                                 break;
6317                         case OP_PSHUFLEW_HIGH:
6318                                 mask_size = 8;
6319                                 mask [0] = 0;
6320                                 mask [1] = 1;
6321                                 mask [2] = 2;
6322                                 mask [3] = 3;
6323                                 mask [4] = 4 + ((imask >> 0) & 3);
6324                                 mask [5] = 4 + ((imask >> 2) & 3);
6325                                 mask [6] = 4 + ((imask >> 4) & 3);
6326                                 mask [7] = 4 + ((imask >> 6) & 3);
6327                                 v1 = values [ins->sreg1];
6328                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6329                                 break;
6330                         case OP_PSHUFLED:
6331                                 mask_size = 4;
6332                                 mask [0] = ((imask >> 0) & 3);
6333                                 mask [1] = ((imask >> 2) & 3);
6334                                 mask [2] = ((imask >> 4) & 3);
6335                                 mask [3] = ((imask >> 6) & 3);
6336                                 v1 = values [ins->sreg1];
6337                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
6338                                 break;
6339                         default:
6340                                 g_assert_not_reached ();
6341                         }
6342                         for (i = 0; i < mask_size; ++i)
6343                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
6344
6345                         values [ins->dreg] =
6346                                 LLVMBuildShuffleVector (builder, v1, v2,
6347                                                                                 LLVMConstVector (mask_values, mask_size), dname);
6348                         break;
6349                 }
6350
6351                 case OP_UNPACK_LOWB:
6352                 case OP_UNPACK_LOWW:
6353                 case OP_UNPACK_LOWD:
6354                 case OP_UNPACK_LOWQ:
6355                 case OP_UNPACK_LOWPS:
6356                 case OP_UNPACK_LOWPD:
6357                 case OP_UNPACK_HIGHB:
6358                 case OP_UNPACK_HIGHW:
6359                 case OP_UNPACK_HIGHD:
6360                 case OP_UNPACK_HIGHQ:
6361                 case OP_UNPACK_HIGHPS:
6362                 case OP_UNPACK_HIGHPD: {
6363                         int mask [16];
6364                         LLVMValueRef mask_values [16];
6365                         int i, mask_size = 0;
6366                         gboolean low = FALSE;
6367
6368                         switch (ins->opcode) {
6369                         case OP_UNPACK_LOWB:
6370                                 mask_size = 16;
6371                                 low = TRUE;
6372                                 break;
6373                         case OP_UNPACK_LOWW:
6374                                 mask_size = 8;
6375                                 low = TRUE;
6376                                 break;
6377                         case OP_UNPACK_LOWD:
6378                         case OP_UNPACK_LOWPS:
6379                                 mask_size = 4;
6380                                 low = TRUE;
6381                                 break;
6382                         case OP_UNPACK_LOWQ:
6383                         case OP_UNPACK_LOWPD:
6384                                 mask_size = 2;
6385                                 low = TRUE;
6386                                 break;
6387                         case OP_UNPACK_HIGHB:
6388                                 mask_size = 16;
6389                                 break;
6390                         case OP_UNPACK_HIGHW:
6391                                 mask_size = 8;
6392                                 break;
6393                         case OP_UNPACK_HIGHD:
6394                         case OP_UNPACK_HIGHPS:
6395                                 mask_size = 4;
6396                                 break;
6397                         case OP_UNPACK_HIGHQ:
6398                         case OP_UNPACK_HIGHPD:
6399                                 mask_size = 2;
6400                                 break;
6401                         default:
6402                                 g_assert_not_reached ();
6403                         }
6404
6405                         if (low) {
6406                                 for (i = 0; i < (mask_size / 2); ++i) {
6407                                         mask [(i * 2)] = i;
6408                                         mask [(i * 2) + 1] = mask_size + i;
6409                                 }
6410                         } else {
6411                                 for (i = 0; i < (mask_size / 2); ++i) {
6412                                         mask [(i * 2)] = (mask_size / 2) + i;
6413                                         mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
6414                                 }
6415                         }
6416
6417                         for (i = 0; i < mask_size; ++i)
6418                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
6419
6420                         values [ins->dreg] =
6421                                 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
6422                                                                                 LLVMConstVector (mask_values, mask_size), dname);
6423                         break;
6424                 }
6425
6426                 case OP_DUPPD: {
6427                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
6428                         LLVMValueRef v, val;
6429
6430                         v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6431                         val = LLVMConstNull (t);
6432                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6433                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
6434
6435                         values [ins->dreg] = val;
6436                         break;
6437                 }
6438                 case OP_DUPPS_LOW:
6439                 case OP_DUPPS_HIGH: {
6440                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
6441                         LLVMValueRef v1, v2, val;
6442
6443
6444                         if (ins->opcode == OP_DUPPS_LOW) {
6445                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6446                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
6447                         } else {
6448                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
6449                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
6450                         }
6451                         val = LLVMConstNull (t);
6452                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
6453                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
6454                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
6455                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
6456
6457                         values [ins->dreg] = val;
6458                         break;
6459                 }
6460
6461                 case OP_DPPS: {
6462                         LLVMValueRef args [3];
6463
6464                         args [0] = lhs;
6465                         args [1] = rhs;
6466                         /* 0xf1 == multiply all 4 elements, add them together, and store the result to the lowest element */
6467                         args [2] = LLVMConstInt (LLVMInt32Type (), 0xf1, FALSE);
6468
6469                         values [ins->dreg] = LLVMBuildCall (builder, get_intrinsic (ctx, simd_op_to_intrins (ins->opcode)), args, 3, dname);
6470                         break;
6471                 }
6472
6473 #endif /* SIMD */
6474
6475                 case OP_DUMMY_USE:
6476                         break;
6477
6478                         /*
6479                          * EXCEPTION HANDLING
6480                          */
6481                 case OP_IMPLICIT_EXCEPTION:
6482                         /* This marks a place where an implicit exception can happen */
6483                         if (bb->region != -1)
6484                                 set_failure (ctx, "implicit-exception");
6485                         break;
6486                 case OP_THROW:
6487                 case OP_RETHROW: {
6488                         gboolean rethrow = (ins->opcode == OP_RETHROW);
6489                         if (ctx->llvm_only) {
6490                                 emit_llvmonly_throw (ctx, bb, rethrow, lhs);
6491                                 has_terminator = TRUE;
6492                                 ctx->unreachable [bb->block_num] = TRUE;
6493                         } else {
6494                                 emit_throw (ctx, bb, rethrow, lhs);
6495                                 builder = ctx->builder;
6496                         }
6497                         break;
6498                 }
6499                 case OP_CALL_HANDLER: {
6500                         /*
6501                          * We don't 'call' handlers, but instead simply branch to them.
6502                          * The code generated by ENDFINALLY will branch back to us.
6503                          */
6504                         LLVMBasicBlockRef noex_bb;
6505                         GSList *bb_list;
6506                         BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
6507
6508                         bb_list = info->call_handler_return_bbs;
6509
6510                         /*
6511                          * Set the indicator variable for the finally clause.
6512                          */
6513                         lhs = info->finally_ind;
6514                         g_assert (lhs);
6515                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
6516
6517                         /* Branch to the finally clause */
6518                         LLVMBuildBr (builder, info->call_handler_target_bb);
6519
6520                         noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
6521                         info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
6522
6523                         builder = ctx->builder = create_builder (ctx);
6524                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
6525
6526                         bblocks [bb->block_num].end_bblock = noex_bb;
6527                         break;
6528                 }
6529                 case OP_START_HANDLER: {
6530                         break;
6531                 }
6532                 case OP_ENDFINALLY: {
6533                         LLVMBasicBlockRef resume_bb;
6534                         MonoBasicBlock *handler_bb;
6535                         LLVMValueRef val, switch_ins, callee;
6536                         GSList *bb_list;
6537                         BBInfo *info;
6538
6539                         handler_bb = (MonoBasicBlock*)g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
6540                         g_assert (handler_bb);
6541                         info = &bblocks [handler_bb->block_num];
6542                         lhs = info->finally_ind;
6543                         g_assert (lhs);
6544
6545                         bb_list = info->call_handler_return_bbs;
6546
6547                         resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
6548
6549                         /* Load the finally variable */
6550                         val = LLVMBuildLoad (builder, lhs, "");
6551
6552                         /* Reset the variable */
6553                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
6554
6555                         /* Branch to either resume_bb, or to the bblocks in bb_list */
6556                         switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
6557                         /*
6558                          * The other targets are added at the end to handle OP_CALL_HANDLER
6559                          * opcodes processed later.
6560                          */
6561                         info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
6562
6563                         builder = ctx->builder = create_builder (ctx);
6564                         LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
6565
6566                         if (ctx->llvm_only) {
6567                                 emit_resume_eh (ctx, bb);
6568                         } else {
6569                                 if (ctx->cfg->compile_aot) {
6570                                         callee = get_callee (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
6571                                 } else {
6572 #if LLVM_API_VERSION > 100
6573                                         MonoJitICallInfo *info;
6574
6575                                         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
6576                                         g_assert (info);
6577                                         gpointer target = (void*)info->func;
6578                                         LLVMTypeRef icall_sig = LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE);
6579                                         callee = emit_jit_callee (ctx, "llvm_resume_unwind_trampoline", icall_sig, target);
6580 #else
6581                                         callee = LLVMGetNamedFunction (ctx->lmodule, "llvm_resume_unwind_trampoline");
6582 #endif
6583                                 }
6584                                 LLVMBuildCall (builder, callee, NULL, 0, "");
6585                                 LLVMBuildUnreachable (builder);
6586                         }
6587
6588                         has_terminator = TRUE;
6589                         break;
6590                 }
6591                 case OP_IL_SEQ_POINT:
6592                         break;
6593                 default: {
6594                         char reason [128];
6595
6596                         sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
6597                         set_failure (ctx, reason);
6598                         break;
6599                 }
6600                 }
6601
6602                 if (!ctx_ok (ctx))
6603                         break;
6604
6605                 /* Convert the value to the type required by phi nodes */
6606                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
6607                         if (ctx->is_vphi [ins->dreg])
6608                                 /* vtypes */
6609                                 values [ins->dreg] = addresses [ins->dreg];
6610                         else
6611                                 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
6612                 }
6613
6614                 /* Add stores for volatile variables */
6615                 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
6616                         emit_volatile_store (ctx, ins->dreg);
6617         }
6618
6619         if (!ctx_ok (ctx))
6620                 return;
6621
6622         if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0)) {
6623                 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
6624         }
6625
6626         if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID) {
6627                 emit_dbg_loc (ctx, builder, cfg->header->code + cfg->header->code_size - 1);
6628                 LLVMBuildRetVoid (builder);
6629         }
6630
6631         if (bb == cfg->bb_entry)
6632                 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
6633 }
6634
6635 /*
6636  * mono_llvm_check_method_supported:
6637  *
6638  *   Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
6639  * compiling a method twice.
6640  */
6641 void
6642 mono_llvm_check_method_supported (MonoCompile *cfg)
6643 {
6644         int i, j;
6645
6646         if (cfg->llvm_only)
6647                 return;
6648
6649         if (cfg->method->save_lmf) {
6650                 cfg->exception_message = g_strdup ("lmf");
6651                 cfg->disable_llvm = TRUE;
6652         }
6653         if (cfg->disable_llvm)
6654                 return;
6655
6656         /*
6657          * Nested clauses where one of the clauses is a finally clause is
6658          * not supported, because LLVM can't figure out the control flow,
6659          * probably because we resume exception handling by calling our
6660          * own function instead of using the 'resume' llvm instruction.
6661          */
6662         for (i = 0; i < cfg->header->num_clauses; ++i) {
6663                 for (j = 0; j < cfg->header->num_clauses; ++j) {
6664                         MonoExceptionClause *clause1 = &cfg->header->clauses [i];
6665                         MonoExceptionClause *clause2 = &cfg->header->clauses [j];
6666
6667                         // FIXME: Nested try clauses fail in some cases too, i.e. #37273
6668                         if (i != j && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
6669                                 //(clause1->flags == MONO_EXCEPTION_CLAUSE_FINALLY || clause2->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
6670                                 cfg->exception_message = g_strdup ("nested clauses");
6671                                 cfg->disable_llvm = TRUE;
6672                                 break;
6673                         }
6674                 }
6675         }
6676         if (cfg->disable_llvm)
6677                 return;
6678
6679         /* FIXME: */
6680         if (cfg->method->dynamic) {
6681                 cfg->exception_message = g_strdup ("dynamic.");
6682                 cfg->disable_llvm = TRUE;
6683         }
6684         if (cfg->disable_llvm)
6685                 return;
6686 }
6687
6688 static LLVMCallInfo*
6689 get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
6690 {
6691         LLVMCallInfo *linfo;
6692         int i;
6693
6694         if (cfg->gsharedvt && cfg->llvm_only && mini_is_gsharedvt_variable_signature (sig)) {
6695                 int i, n, pindex;
6696
6697                 /*
6698                  * Gsharedvt methods have the following calling convention:
6699                  * - all arguments are passed by ref, even non generic ones
6700                  * - the return value is returned by ref too, using a vret
6701                  *   argument passed after 'this'.
6702                  */
6703                 n = sig->param_count + sig->hasthis;
6704                 linfo = (LLVMCallInfo*)mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMCallInfo) + (sizeof (LLVMArgInfo) * n));
6705
6706                 pindex = 0;
6707                 if (sig->hasthis)
6708                         linfo->args [pindex ++].storage = LLVMArgNormal;
6709
6710                 if (sig->ret->type != MONO_TYPE_VOID) {
6711                         if (mini_is_gsharedvt_variable_type (sig->ret))
6712                                 linfo->ret.storage = LLVMArgGsharedvtVariable;
6713                         else if (mini_type_is_vtype (sig->ret))
6714                                 linfo->ret.storage = LLVMArgGsharedvtFixedVtype;
6715                         else
6716                                 linfo->ret.storage = LLVMArgGsharedvtFixed;
6717                         linfo->vret_arg_index = pindex;
6718                 } else {
6719                         linfo->ret.storage = LLVMArgNone;
6720                 }
6721
6722                 for (i = 0; i < sig->param_count; ++i) {
6723                         if (sig->params [i]->byref)
6724                                 linfo->args [pindex].storage = LLVMArgNormal;
6725                         else if (mini_is_gsharedvt_variable_type (sig->params [i]))
6726                                 linfo->args [pindex].storage = LLVMArgGsharedvtVariable;
6727                         else if (mini_type_is_vtype (sig->params [i]))
6728                                 linfo->args [pindex].storage = LLVMArgGsharedvtFixedVtype;
6729                         else
6730                                 linfo->args [pindex].storage = LLVMArgGsharedvtFixed;
6731                         linfo->args [pindex].type = sig->params [i];
6732                         pindex ++;
6733                 }
6734                 return linfo;
6735         }
6736
6737
6738         linfo = mono_arch_get_llvm_call_info (cfg, sig);
6739         for (i = 0; i < sig->param_count; ++i)
6740                 linfo->args [i + sig->hasthis].type = sig->params [i];
6741
6742         return linfo;
6743 }
6744
6745 static void
6746 emit_method_inner (EmitContext *ctx);
6747
6748 static void
6749 free_ctx (EmitContext *ctx)
6750 {
6751         GSList *l;
6752
6753         g_free (ctx->values);
6754         g_free (ctx->addresses);
6755         g_free (ctx->vreg_types);
6756         g_free (ctx->is_vphi);
6757         g_free (ctx->vreg_cli_types);
6758         g_free (ctx->is_dead);
6759         g_free (ctx->unreachable);
6760         g_ptr_array_free (ctx->phi_values, TRUE);
6761         g_free (ctx->bblocks);
6762         g_hash_table_destroy (ctx->region_to_handler);
6763         g_hash_table_destroy (ctx->clause_to_handler);
6764         g_hash_table_destroy (ctx->jit_callees);
6765
6766         GHashTableIter iter;
6767         g_hash_table_iter_init (&iter, ctx->method_to_callers);
6768         while (g_hash_table_iter_next (&iter, NULL, (gpointer)&l))
6769                 g_slist_free (l);
6770
6771         g_hash_table_destroy (ctx->method_to_callers);
6772
6773         g_free (ctx->method_name);
6774         g_ptr_array_free (ctx->bblock_list, TRUE);
6775
6776         for (l = ctx->builders; l; l = l->next) {
6777                 LLVMBuilderRef builder = (LLVMBuilderRef)l->data;
6778                 LLVMDisposeBuilder (builder);
6779         }
6780
6781         g_free (ctx);
6782 }
6783
6784 /*
6785  * mono_llvm_emit_method:
6786  *
6787  *   Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
6788  */
6789 void
6790 mono_llvm_emit_method (MonoCompile *cfg)
6791 {
6792         EmitContext *ctx;
6793         char *method_name;
6794         gboolean is_linkonce = FALSE;
6795         int i;
6796
6797         /* The code below might acquire the loader lock, so use it for global locking */
6798         mono_loader_lock ();
6799
6800         /* Used to communicate with the callbacks */
6801         mono_native_tls_set_value (current_cfg_tls_id, cfg);
6802
6803         ctx = g_new0 (EmitContext, 1);
6804         ctx->cfg = cfg;
6805         ctx->mempool = cfg->mempool;
6806
6807         /*
6808          * This maps vregs to the LLVM instruction defining them
6809          */
6810         ctx->values = g_new0 (LLVMValueRef, cfg->next_vreg);
6811         /*
6812          * This maps vregs for volatile variables to the LLVM instruction defining their
6813          * address.
6814          */
6815         ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
6816         ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
6817         ctx->is_vphi = g_new0 (gboolean, cfg->next_vreg);
6818         ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
6819         ctx->phi_values = g_ptr_array_sized_new (256);
6820         /*
6821          * This signals whenever the vreg was defined by a phi node with no input vars
6822          * (i.e. all its input bblocks end with NOT_REACHABLE).
6823          */
6824         ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
6825         /* Whenever the bblock is unreachable */
6826         ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
6827         ctx->bblock_list = g_ptr_array_sized_new (256);
6828
6829         ctx->region_to_handler = g_hash_table_new (NULL, NULL);
6830         ctx->clause_to_handler = g_hash_table_new (NULL, NULL);
6831         ctx->method_to_callers = g_hash_table_new (NULL, NULL);
6832         ctx->jit_callees = g_hash_table_new (NULL, NULL);
6833         if (cfg->compile_aot) {
6834                 ctx->module = &aot_module;
6835
6836                 method_name = NULL;
6837                 /*
6838                  * Allow the linker to discard duplicate copies of wrappers, generic instances etc. by using the 'linkonce'
6839                  * linkage for them. This requires the following:
6840                  * - the method needs to have a unique mangled name
6841                  * - llvmonly mode, since the code in aot-runtime.c would initialize got slots in the wrong aot image etc.
6842                  */
6843                 is_linkonce = ctx->module->llvm_only && ctx->module->static_link && mono_aot_is_linkonce_method (cfg->method);
6844                 if (is_linkonce) {
6845                         method_name = mono_aot_get_mangled_method_name (cfg->method);
6846                         if (!method_name)
6847                                 is_linkonce = FALSE;
6848                         /*
6849                         if (method_name)
6850                                 printf ("%s %s\n", mono_method_full_name (cfg->method, 1), method_name);
6851                         else
6852                                 printf ("%s\n", mono_method_full_name (cfg->method, 1));
6853                         */
6854                 }
6855                 if (!method_name)
6856                         method_name = mono_aot_get_method_name (cfg);
6857                 cfg->llvm_method_name = g_strdup (method_name);
6858         } else {
6859                 init_jit_module (cfg->domain);
6860                 ctx->module = (MonoLLVMModule*)domain_jit_info (cfg->domain)->llvm_module;
6861                 method_name = mono_method_full_name (cfg->method, TRUE);
6862         }
6863         ctx->method_name = method_name;
6864         ctx->is_linkonce = is_linkonce;
6865
6866 #if LLVM_API_VERSION > 100
6867         if (cfg->compile_aot)
6868                 ctx->lmodule = ctx->module->lmodule;
6869         else
6870                 ctx->lmodule = LLVMModuleCreateWithName ("jit-module");
6871 #else
6872         ctx->lmodule = ctx->module->lmodule;
6873 #endif
6874         ctx->llvm_only = ctx->module->llvm_only;
6875
6876         emit_method_inner (ctx);
6877
6878         if (!ctx_ok (ctx)) {
6879                 if (ctx->lmethod) {
6880                         /* Need to add unused phi nodes as they can be referenced by other values */
6881                         LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (ctx->lmethod, "PHI_BB");
6882                         LLVMBuilderRef builder;
6883
6884                         builder = create_builder (ctx);
6885                         LLVMPositionBuilderAtEnd (builder, phi_bb);
6886
6887                         for (i = 0; i < ctx->phi_values->len; ++i) {
6888                                 LLVMValueRef v = (LLVMValueRef)g_ptr_array_index (ctx->phi_values, i);
6889                                 if (LLVMGetInstructionParent (v) == NULL)
6890                                         LLVMInsertIntoBuilder (builder, v);
6891                         }
6892
6893                         LLVMDeleteFunction (ctx->lmethod);
6894                 }
6895         }
6896
6897         free_ctx (ctx);
6898
6899         mono_native_tls_set_value (current_cfg_tls_id, NULL);
6900
6901         mono_loader_unlock ();
6902 }
6903
6904 static void
6905 emit_method_inner (EmitContext *ctx)
6906 {
6907         MonoCompile *cfg = ctx->cfg;
6908         MonoMethodSignature *sig;
6909         MonoBasicBlock *bb;
6910         LLVMTypeRef method_type;
6911         LLVMValueRef method = NULL;
6912         LLVMValueRef *values = ctx->values;
6913         int i, max_block_num, bb_index;
6914         gboolean last = FALSE;
6915         LLVMCallInfo *linfo;
6916         LLVMModuleRef lmodule = ctx->lmodule;
6917         BBInfo *bblocks;
6918         GPtrArray *bblock_list = ctx->bblock_list;
6919         MonoMethodHeader *header;
6920         MonoExceptionClause *clause;
6921         char **names;
6922
6923         if (cfg->gsharedvt && !cfg->llvm_only) {
6924                 set_failure (ctx, "gsharedvt");
6925                 return;
6926         }
6927
6928 #if 1
6929         {
6930                 static int count = 0;
6931                 count ++;
6932
6933                 if (g_getenv ("LLVM_COUNT")) {
6934                         if (count == atoi (g_getenv ("LLVM_COUNT"))) {
6935                                 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
6936                                 fflush (stdout);
6937                                 last = TRUE;
6938                         }
6939                         if (count > atoi (g_getenv ("LLVM_COUNT"))) {
6940                                 set_failure (ctx, "count");
6941                                 return;
6942                         }
6943                 }
6944         }
6945 #endif
6946
6947         sig = mono_method_signature (cfg->method);
6948         ctx->sig = sig;
6949
6950         linfo = get_llvm_call_info (cfg, sig);
6951         ctx->linfo = linfo;
6952         if (!ctx_ok (ctx))
6953                 return;
6954
6955         if (cfg->rgctx_var)
6956                 linfo->rgctx_arg = TRUE;
6957         ctx->method_type = method_type = sig_to_llvm_sig_full (ctx, sig, linfo);
6958         if (!ctx_ok (ctx))
6959                 return;
6960
6961         method = LLVMAddFunction (lmodule, ctx->method_name, method_type);
6962         ctx->lmethod = method;
6963
6964         if (!cfg->llvm_only)
6965                 LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
6966         LLVMSetLinkage (method, LLVMPrivateLinkage);
6967
6968         LLVMAddFunctionAttr (method, LLVMUWTable);
6969
6970         if (cfg->compile_aot) {
6971                 LLVMSetLinkage (method, LLVMInternalLinkage);
6972                 if (ctx->module->external_symbols) {
6973                         LLVMSetLinkage (method, LLVMExternalLinkage);
6974                         LLVMSetVisibility (method, LLVMHiddenVisibility);
6975                 }
6976                 if (ctx->is_linkonce) {
6977                         LLVMSetLinkage (method, LLVMLinkOnceAnyLinkage);
6978                         LLVMSetVisibility (method, LLVMDefaultVisibility);
6979                 }
6980         } else {
6981 #if LLVM_API_VERSION > 100
6982                 LLVMSetLinkage (method, LLVMExternalLinkage);
6983 #else
6984                 LLVMSetLinkage (method, LLVMPrivateLinkage);
6985 #endif
6986         }
6987
6988         if (cfg->method->save_lmf && !cfg->llvm_only) {
6989                 set_failure (ctx, "lmf");
6990                 return;
6991         }
6992
6993         if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && !cfg->llvm_only) {
6994                 set_failure (ctx, "pinvoke signature");
6995                 return;
6996         }
6997
6998         header = cfg->header;
6999         for (i = 0; i < header->num_clauses; ++i) {
7000                 clause = &header->clauses [i];
7001                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE) {
7002                     set_failure (ctx, "non-finally/catch clause.");
7003                         return;
7004                 }
7005         }
7006         if (header->num_clauses || (cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_NOINLINING) || cfg->no_inline)
7007                 /* We can't handle inlined methods with clauses */
7008                 LLVMAddFunctionAttr (method, LLVMNoInlineAttribute);
7009
7010         if (linfo->rgctx_arg) {
7011                 ctx->rgctx_arg = LLVMGetParam (method, linfo->rgctx_arg_pindex);
7012                 ctx->rgctx_arg_pindex = linfo->rgctx_arg_pindex;
7013                 /*
7014                  * We mark the rgctx parameter with the inreg attribute, which is mapped to
7015                  * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
7016                  * CC_X86_64_Mono in X86CallingConv.td.
7017                  */
7018                 if (!ctx->llvm_only)
7019                         LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
7020                 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
7021         } else {
7022                 ctx->rgctx_arg_pindex = -1;
7023         }
7024         if (cfg->vret_addr) {
7025                 values [cfg->vret_addr->dreg] = LLVMGetParam (method, linfo->vret_arg_pindex);
7026                 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
7027                 if (linfo->ret.storage == LLVMArgVtypeByRef) {
7028                         LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMStructRetAttribute);
7029                         LLVMAddAttribute (LLVMGetParam (method, linfo->vret_arg_pindex), LLVMNoAliasAttribute);
7030                 }
7031         }
7032
7033         if (sig->hasthis) {
7034                 ctx->this_arg_pindex = linfo->this_arg_pindex;
7035                 ctx->this_arg = LLVMGetParam (method, linfo->this_arg_pindex);
7036                 values [cfg->args [0]->dreg] = ctx->this_arg;
7037                 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
7038         }
7039
7040         names = g_new (char *, sig->param_count);
7041         mono_method_get_param_names (cfg->method, (const char **) names);
7042
7043         /* Set parameter names/attributes */
7044         for (i = 0; i < sig->param_count; ++i) {
7045                 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
7046                 char *name;
7047                 int pindex = ainfo->pindex + ainfo->ndummy_fpargs;
7048                 int j;
7049
7050                 for (j = 0; j < ainfo->ndummy_fpargs; ++j) {
7051                         name = g_strdup_printf ("dummy_%d_%d", i, j);
7052                         LLVMSetValueName (LLVMGetParam (method, ainfo->pindex + j), name);
7053                         g_free (name);
7054                 }
7055
7056                 if (ainfo->storage == LLVMArgVtypeInReg && ainfo->pair_storage [0] == LLVMArgNone && ainfo->pair_storage [1] == LLVMArgNone)
7057                         continue;
7058
7059                 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, pindex);
7060                 if (ainfo->storage == LLVMArgGsharedvtFixed || ainfo->storage == LLVMArgGsharedvtFixedVtype) {
7061                         if (names [i] && names [i][0] != '\0')
7062                                 name = g_strdup_printf ("p_arg_%s", names [i]);
7063                         else
7064                                 name = g_strdup_printf ("p_arg_%d", i);
7065                 } else {
7066                         if (names [i] && names [i][0] != '\0')
7067                                 name = g_strdup_printf ("arg_%s", names [i]);
7068                         else
7069                                 name = g_strdup_printf ("arg_%d", i);
7070                 }
7071                 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
7072                 g_free (name);
7073                 if (ainfo->storage == LLVMArgVtypeByVal)
7074                         LLVMAddAttribute (LLVMGetParam (method, pindex), LLVMByValAttribute);
7075
7076                 if (ainfo->storage == LLVMArgVtypeByRef) {
7077                         /* For OP_LDADDR */
7078                         cfg->args [i + sig->hasthis]->opcode = OP_VTARG_ADDR;
7079                 }
7080         }
7081         g_free (names);
7082
7083         if (ctx->module->emit_dwarf && cfg->compile_aot && mono_debug_enabled ()) {
7084                 ctx->minfo = mono_debug_lookup_method (cfg->method);
7085                 ctx->dbg_md = emit_dbg_subprogram (ctx, cfg, method, ctx->method_name);
7086         }
7087
7088         max_block_num = 0;
7089         for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
7090                 max_block_num = MAX (max_block_num, bb->block_num);
7091         ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
7092
7093         /* Add branches between non-consecutive bblocks */
7094         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7095                 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
7096                         bb->next_bb != bb->last_ins->inst_false_bb) {
7097
7098                         MonoInst *inst = (MonoInst*)mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
7099                         inst->opcode = OP_BR;
7100                         inst->inst_target_bb = bb->last_ins->inst_false_bb;
7101                         mono_bblock_add_inst (bb, inst);
7102                 }
7103         }
7104
7105         /*
7106          * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
7107          * was later optimized away, so clear these flags, and add them back for the still
7108          * present OP_LDADDR instructions.
7109          */
7110         for (i = 0; i < cfg->next_vreg; ++i) {
7111                 MonoInst *ins;
7112
7113                 ins = get_vreg_to_inst (cfg, i);
7114                 if (ins && ins != cfg->rgctx_var)
7115                         ins->flags &= ~MONO_INST_INDIRECT;
7116         }
7117
7118         /*
7119          * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
7120          */
7121         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7122                 MonoInst *ins;
7123                 LLVMBuilderRef builder;
7124                 char *dname;
7125                 char dname_buf[128];
7126
7127                 builder = create_builder (ctx);
7128
7129                 for (ins = bb->code; ins; ins = ins->next) {
7130                         switch (ins->opcode) {
7131                         case OP_PHI:
7132                         case OP_FPHI:
7133                         case OP_VPHI:
7134                         case OP_XPHI: {
7135                                 LLVMTypeRef phi_type = llvm_type_to_stack_type (cfg, type_to_llvm_type (ctx, &ins->klass->byval_arg));
7136
7137                                 if (!ctx_ok (ctx))
7138                                         return;
7139
7140                                 if (ins->opcode == OP_VPHI) {
7141                                         /* Treat valuetype PHI nodes as operating on the address itself */
7142                                         g_assert (ins->klass);
7143                                         phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
7144                                 }
7145
7146                                 /*
7147                                  * Have to precreate these, as they can be referenced by
7148                                  * earlier instructions.
7149                                  */
7150                                 sprintf (dname_buf, "t%d", ins->dreg);
7151                                 dname = dname_buf;
7152                                 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
7153
7154                                 if (ins->opcode == OP_VPHI)
7155                                         ctx->addresses [ins->dreg] = values [ins->dreg];
7156
7157                                 g_ptr_array_add (ctx->phi_values, values [ins->dreg]);
7158
7159                                 /*
7160                                  * Set the expected type of the incoming arguments since these have
7161                                  * to have the same type.
7162                                  */
7163                                 for (i = 0; i < ins->inst_phi_args [0]; i++) {
7164                                         int sreg1 = ins->inst_phi_args [i + 1];
7165
7166                                         if (sreg1 != -1) {
7167                                                 if (ins->opcode == OP_VPHI)
7168                                                         ctx->is_vphi [sreg1] = TRUE;
7169                                                 ctx->vreg_types [sreg1] = phi_type;
7170                                         }
7171                                 }
7172                                 break;
7173                                 }
7174                         case OP_LDADDR:
7175                                 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
7176                                 break;
7177                         default:
7178                                 break;
7179                         }
7180                 }
7181         }
7182
7183         /*
7184          * Create an ordering for bblocks, use the depth first order first, then
7185          * put the exception handling bblocks last.
7186          */
7187         for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
7188                 bb = cfg->bblocks [bb_index];
7189                 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
7190                         g_ptr_array_add (bblock_list, bb);
7191                         bblocks [bb->block_num].added = TRUE;
7192                 }
7193         }
7194
7195         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7196                 if (!bblocks [bb->block_num].added)
7197                         g_ptr_array_add (bblock_list, bb);
7198         }
7199
7200         /*
7201          * Second pass: generate code.
7202          */
7203         // Emit entry point
7204         LLVMBuilderRef entry_builder = create_builder (ctx);
7205         LLVMBasicBlockRef entry_bb = get_bb (ctx, cfg->bb_entry);
7206         LLVMPositionBuilderAtEnd (entry_builder, entry_bb);
7207         emit_entry_bb (ctx, entry_builder);
7208
7209         // Make landing pads first
7210         ctx->exc_meta = g_hash_table_new_full (NULL, NULL, NULL, NULL);
7211
7212         if (ctx->llvm_only) {
7213                 size_t group_index = 0;
7214                 while (group_index < cfg->header->num_clauses) {
7215                         int count = 0;
7216                         size_t cursor = group_index;
7217                         while (cursor < cfg->header->num_clauses &&
7218                                    CLAUSE_START (&cfg->header->clauses [cursor]) == CLAUSE_START (&cfg->header->clauses [group_index]) &&
7219                                    CLAUSE_END (&cfg->header->clauses [cursor]) == CLAUSE_END (&cfg->header->clauses [group_index])) {
7220                                 count++;
7221                                 cursor++;
7222                         }
7223
7224                         LLVMBasicBlockRef lpad_bb = emit_landing_pad (ctx, group_index, count);
7225                         intptr_t key = CLAUSE_END (&cfg->header->clauses [group_index]);
7226                         g_hash_table_insert (ctx->exc_meta, (gpointer)key, lpad_bb);
7227
7228                         group_index = cursor;
7229                 }
7230         }
7231
7232         for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
7233                 bb = (MonoBasicBlock*)g_ptr_array_index (bblock_list, bb_index);
7234
7235                 // Prune unreachable mono BBs.
7236                 if (!(bb == cfg->bb_entry || bb->in_count > 0))
7237                         continue;
7238
7239                 process_bb (ctx, bb);
7240                 if (!ctx_ok (ctx))
7241                         return;
7242         }
7243         g_hash_table_destroy (ctx->exc_meta);
7244
7245         mono_memory_barrier ();
7246
7247         /* Add incoming phi values */
7248         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7249                 GSList *l, *ins_list;
7250
7251                 ins_list = bblocks [bb->block_num].phi_nodes;
7252
7253                 for (l = ins_list; l; l = l->next) {
7254                         PhiNode *node = (PhiNode*)l->data;
7255                         MonoInst *phi = node->phi;
7256                         int sreg1 = node->sreg;
7257                         LLVMBasicBlockRef in_bb;
7258
7259                         if (sreg1 == -1)
7260                                 continue;
7261
7262                         in_bb = get_end_bb (ctx, node->in_bb);
7263
7264                         if (ctx->unreachable [node->in_bb->block_num])
7265                                 continue;
7266
7267                         if (!values [sreg1]) {
7268                                 /* Can happen with values in EH clauses */
7269                                 set_failure (ctx, "incoming phi sreg1");
7270                                 return;
7271                         }
7272
7273                         if (phi->opcode == OP_VPHI) {
7274                                 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
7275                                 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
7276                         } else {
7277                                 if (LLVMTypeOf (values [sreg1]) != LLVMTypeOf (values [phi->dreg])) {
7278                                         set_failure (ctx, "incoming phi arg type mismatch");
7279                                         return;
7280                                 }
7281                                 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
7282                                 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
7283                         }
7284                 }
7285         }
7286
7287         /* Nullify empty phi instructions */
7288         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7289                 GSList *l, *ins_list;
7290
7291                 ins_list = bblocks [bb->block_num].phi_nodes;
7292
7293                 for (l = ins_list; l; l = l->next) {
7294                         PhiNode *node = (PhiNode*)l->data;
7295                         MonoInst *phi = node->phi;
7296                         LLVMValueRef phi_ins = values [phi->dreg];
7297
7298                         if (!phi_ins)
7299                                 /* Already removed */
7300                                 continue;
7301
7302                         if (LLVMCountIncoming (phi_ins) == 0) {
7303                                 mono_llvm_replace_uses_of (phi_ins, LLVMConstNull (LLVMTypeOf (phi_ins)));
7304                                 LLVMInstructionEraseFromParent (phi_ins);
7305                                 values [phi->dreg] = NULL;
7306                         }
7307                 }
7308         }
7309
7310         /* Create the SWITCH statements for ENDFINALLY instructions */
7311         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
7312                 BBInfo *info = &bblocks [bb->block_num];
7313                 GSList *l;
7314                 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
7315                         LLVMValueRef switch_ins = (LLVMValueRef)l->data;
7316                         GSList *bb_list = info->call_handler_return_bbs;
7317
7318                         GSList *bb_list_iter;
7319                         i = 0;
7320                         for (bb_list_iter = bb_list; bb_list_iter; bb_list_iter = g_slist_next (bb_list_iter)) {
7321                                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), (LLVMBasicBlockRef)bb_list_iter->data);
7322                                 i ++;
7323                         }
7324                 }
7325         }
7326
7327         /* Initialize the method if needed */
7328         if (cfg->compile_aot && ctx->llvm_only) {
7329                 // FIXME: Add more shared got entries
7330                 ctx->builder = create_builder (ctx);
7331                 LLVMPositionBuilderAtEnd (ctx->builder, ctx->init_bb);
7332
7333                 ctx->module->max_method_idx = MAX (ctx->module->max_method_idx, cfg->method_index);
7334
7335                 // FIXME: beforefieldinit
7336                 /*
7337                  * NATIVE_TO_MANAGED methods might be called on a thread not attached to the runtime, so they are initialized when loaded
7338                  * in load_method ().
7339                  */
7340                 if ((ctx->has_got_access || mono_class_get_cctor (cfg->method->klass)) && !(cfg->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)) {
7341                         /*
7342                          * linkonce methods shouldn't have initialization,
7343                          * because they might belong to assemblies which
7344                          * haven't been loaded yet.
7345                          */
7346                         g_assert (!ctx->is_linkonce);
7347                         emit_init_method (ctx);
7348                 } else {
7349                         LLVMBuildBr (ctx->builder, ctx->inited_bb);
7350                 }
7351         }
7352
7353         if (cfg->llvm_only) {
7354                 GHashTableIter iter;
7355                 MonoMethod *method;
7356                 GSList *callers, *l, *l2;
7357
7358                 /*
7359                  * Add the contents of ctx->method_to_callers to module->method_to_callers.
7360                  * We can't do this earlier, as it contains llvm instructions which can be
7361                  * freed if compilation fails.
7362                  * FIXME: Get rid of this when all methods can be llvm compiled.
7363                  */
7364                 g_hash_table_iter_init (&iter, ctx->method_to_callers);
7365                 while (g_hash_table_iter_next (&iter, (void**)&method, (void**)&callers)) {
7366                         for (l = callers; l; l = l->next) {
7367                                 l2 = (GSList*)g_hash_table_lookup (ctx->module->method_to_callers, method);
7368                                 l2 = g_slist_prepend (l2, l->data);
7369                                 g_hash_table_insert (ctx->module->method_to_callers, method, l2);
7370                         }
7371                 }
7372         }
7373
7374         if (cfg->verbose_level > 1)
7375                 mono_llvm_dump_value (method);
7376
7377         if (cfg->compile_aot && !cfg->llvm_only)
7378                 mark_as_used (ctx->module, method);
7379
7380         if (!cfg->llvm_only) {
7381                 LLVMValueRef md_args [16];
7382                 LLVMValueRef md_node;
7383                 int method_index;
7384
7385                 if (cfg->compile_aot)
7386                         method_index = mono_aot_get_method_index (cfg->orig_method);
7387                 else
7388                         method_index = 1;
7389                 md_args [0] = LLVMMDString (ctx->method_name, strlen (ctx->method_name));
7390                 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
7391                 md_node = LLVMMDNode (md_args, 2);
7392                 LLVMAddNamedMetadataOperand (lmodule, "mono.function_indexes", md_node);
7393                 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
7394         }
7395
7396         if (cfg->compile_aot) {
7397                 /* Don't generate native code, keep the LLVM IR */
7398                 if (cfg->verbose_level)
7399                         printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), ctx->method_name);
7400
7401 #if LLVM_API_VERSION < 100
7402                 /* VerifyFunction can't handle some of the debug info created by DIBuilder in llvm 3.9 */
7403                 int err = LLVMVerifyFunction(ctx->lmethod, LLVMPrintMessageAction);
7404                 g_assert (err == 0);
7405 #endif
7406         } else {
7407                 //LLVMVerifyFunction(method, 0);
7408 #if LLVM_API_VERSION > 100
7409                 MonoDomain *domain = mono_domain_get ();
7410                 MonoJitDomainInfo *domain_info;
7411                 int nvars = g_hash_table_size (ctx->jit_callees);
7412                 LLVMValueRef *callee_vars = g_new0 (LLVMValueRef, nvars);
7413                 gpointer *callee_addrs = g_new0 (gpointer, nvars);
7414                 GHashTableIter iter;
7415                 LLVMValueRef var;
7416                 MonoMethod *callee;
7417                 gpointer eh_frame;
7418
7419                 /*
7420                  * Compute the addresses of the LLVM globals pointing to the
7421                  * methods called by the current method. Pass it to the trampoline
7422                  * code so it can update them after their corresponding method was
7423                  * compiled.
7424                  */
7425                 g_hash_table_iter_init (&iter, ctx->jit_callees);
7426                 i = 0;
7427                 while (g_hash_table_iter_next (&iter, NULL, (void**)&var))
7428                         callee_vars [i ++] = var;
7429
7430                 cfg->native_code = mono_llvm_compile_method (ctx->module->mono_ee, ctx->lmethod, nvars, callee_vars, callee_addrs, &eh_frame);
7431
7432                 decode_llvm_eh_info (ctx, eh_frame);
7433
7434                 mono_domain_lock (domain);
7435                 domain_info = domain_jit_info (domain);
7436                 if (!domain_info->llvm_jit_callees)
7437                         domain_info->llvm_jit_callees = g_hash_table_new (NULL, NULL);
7438                 g_hash_table_iter_init (&iter, ctx->jit_callees);
7439                 i = 0;
7440                 while (g_hash_table_iter_next (&iter, (void**)&callee, (void**)&var)) {
7441                         GSList *addrs = g_hash_table_lookup (domain_info->llvm_jit_callees, callee);
7442                         addrs = g_slist_prepend (addrs, callee_addrs [i]);
7443                         g_hash_table_insert (domain_info->llvm_jit_callees, callee, addrs);
7444                         i ++;
7445                 }
7446                 mono_domain_unlock (domain);
7447 #else
7448                 mono_llvm_optimize_method (ctx->module->mono_ee, ctx->lmethod);
7449
7450                 if (cfg->verbose_level > 1)
7451                         mono_llvm_dump_value (ctx->lmethod);
7452
7453                 cfg->native_code = (unsigned char*)LLVMGetPointerToGlobal (ctx->module->ee, ctx->lmethod);
7454
7455                 /* Set by emit_cb */
7456                 g_assert (cfg->code_len);
7457 #endif
7458         }
7459
7460         if (ctx->module->method_to_lmethod)
7461                 g_hash_table_insert (ctx->module->method_to_lmethod, cfg->method, ctx->lmethod);
7462         if (ctx->module->idx_to_lmethod)
7463                 g_hash_table_insert (ctx->module->idx_to_lmethod, GINT_TO_POINTER (cfg->method_index), ctx->lmethod);
7464
7465         if (ctx->llvm_only && cfg->orig_method->klass->valuetype && !(cfg->orig_method->flags & METHOD_ATTRIBUTE_STATIC))
7466                 emit_unbox_tramp (ctx, ctx->method_name, ctx->method_type, ctx->lmethod, cfg->method_index);
7467 }
7468
7469 /*
7470  * mono_llvm_create_vars:
7471  *
7472  *   Same as mono_arch_create_vars () for LLVM.
7473  */
7474 void
7475 mono_llvm_create_vars (MonoCompile *cfg)
7476 {
7477         MonoMethodSignature *sig;
7478
7479         sig = mono_method_signature (cfg->method);
7480         if (cfg->gsharedvt && cfg->llvm_only) {
7481                 if (mini_is_gsharedvt_variable_signature (sig) && sig->ret->type != MONO_TYPE_VOID) {
7482                         cfg->vret_addr = mono_compile_create_var (cfg, &mono_get_intptr_class ()->byval_arg, OP_ARG);
7483                         if (G_UNLIKELY (cfg->verbose_level > 1)) {
7484                                 printf ("vret_addr = ");
7485                                 mono_print_ins (cfg->vret_addr);
7486                         }
7487                 }
7488         } else {
7489                 mono_arch_create_vars (cfg);
7490         }
7491 }
7492
7493 /*
7494  * mono_llvm_emit_call:
7495  *
7496  *   Same as mono_arch_emit_call () for LLVM.
7497  */
7498 void
7499 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
7500 {
7501         MonoInst *in;
7502         MonoMethodSignature *sig;
7503         int i, n, stack_size;
7504         LLVMArgInfo *ainfo;
7505
7506         stack_size = 0;
7507
7508         sig = call->signature;
7509         n = sig->param_count + sig->hasthis;
7510
7511         call->cinfo = get_llvm_call_info (cfg, sig);
7512
7513         if (cfg->disable_llvm)
7514                 return;
7515
7516         if (sig->call_convention == MONO_CALL_VARARG) {
7517                 cfg->exception_message = g_strdup ("varargs");
7518                 cfg->disable_llvm = TRUE;
7519         }
7520
7521         for (i = 0; i < n; ++i) {
7522                 MonoInst *ins;
7523
7524                 ainfo = call->cinfo->args + i;
7525
7526                 in = call->args [i];
7527
7528                 /* Simply remember the arguments */
7529                 switch (ainfo->storage) {
7530                 case LLVMArgNormal: {
7531                         MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : ainfo->type;
7532                         int opcode;
7533
7534                         opcode = mono_type_to_regmove (cfg, t);
7535                         if (opcode == OP_FMOVE) {
7536                                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
7537                                 ins->dreg = mono_alloc_freg (cfg);
7538                         } else if (opcode == OP_LMOVE) {
7539                                 MONO_INST_NEW (cfg, ins, OP_LMOVE);
7540                                 ins->dreg = mono_alloc_lreg (cfg);
7541                         } else if (opcode == OP_RMOVE) {
7542                                 MONO_INST_NEW (cfg, ins, OP_RMOVE);
7543                                 ins->dreg = mono_alloc_freg (cfg);
7544                         } else {
7545                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
7546                                 ins->dreg = mono_alloc_ireg (cfg);
7547                         }
7548                         ins->sreg1 = in->dreg;
7549                         break;
7550                 }
7551                 case LLVMArgVtypeByVal:
7552                 case LLVMArgVtypeByRef:
7553                 case LLVMArgVtypeInReg:
7554                 case LLVMArgVtypeAsScalar:
7555                 case LLVMArgAsIArgs:
7556                 case LLVMArgAsFpArgs:
7557                 case LLVMArgGsharedvtVariable:
7558                 case LLVMArgGsharedvtFixed:
7559                 case LLVMArgGsharedvtFixedVtype:
7560                         MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
7561                         ins->dreg = mono_alloc_ireg (cfg);
7562                         ins->sreg1 = in->dreg;
7563                         ins->inst_p0 = mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMArgInfo));
7564                         memcpy (ins->inst_p0, ainfo, sizeof (LLVMArgInfo));
7565                         ins->inst_vtype = ainfo->type;
7566                         ins->klass = mono_class_from_mono_type (ainfo->type);
7567                         break;
7568                 default:
7569                         cfg->exception_message = g_strdup ("ainfo->storage");
7570                         cfg->disable_llvm = TRUE;
7571                         return;
7572                 }
7573
7574                 if (!cfg->disable_llvm) {
7575                         MONO_ADD_INS (cfg->cbb, ins);
7576                         mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
7577                 }
7578         }
7579 }
7580
7581 static unsigned char*
7582 alloc_cb (LLVMValueRef function, int size)
7583 {
7584         MonoCompile *cfg;
7585
7586         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7587
7588         if (cfg) {
7589                 // FIXME: dynamic
7590                 return (unsigned char*)mono_domain_code_reserve (cfg->domain, size);
7591         } else {
7592                 return (unsigned char*)mono_domain_code_reserve (mono_domain_get (), size);
7593         }
7594 }
7595
7596 static void
7597 emitted_cb (LLVMValueRef function, void *start, void *end)
7598 {
7599         MonoCompile *cfg;
7600
7601         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7602         g_assert (cfg);
7603         cfg->code_len = (guint8*)end - (guint8*)start;
7604 }
7605
7606 static void
7607 exception_cb (void *data)
7608 {
7609         MonoCompile *cfg;
7610         MonoJitExceptionInfo *ei;
7611         guint32 ei_len, i, j, nested_len, nindex;
7612         gpointer *type_info;
7613         int this_reg, this_offset;
7614
7615         cfg = (MonoCompile*)mono_native_tls_get_value (current_cfg_tls_id);
7616         g_assert (cfg);
7617
7618         /*
7619          * data points to a DWARF FDE structure, convert it to our unwind format and
7620          * save it.
7621          * An alternative would be to save it directly, and modify our unwinder to work
7622          * with it.
7623          */
7624         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);
7625         if (cfg->verbose_level > 1)
7626                 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
7627
7628         /* Count nested clauses */
7629         nested_len = 0;
7630         for (i = 0; i < ei_len; ++i) {
7631                 gint32 cindex1 = *(gint32*)type_info [i];
7632                 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
7633
7634                 for (j = 0; j < cfg->header->num_clauses; ++j) {
7635                         int cindex2 = j;
7636                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
7637
7638                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
7639                                 nested_len ++;
7640                         }
7641                 }
7642         }
7643
7644         cfg->llvm_ex_info = (MonoJitExceptionInfo*)mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
7645         cfg->llvm_ex_info_len = ei_len + nested_len;
7646         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
7647         /* Fill the rest of the information from the type info */
7648         for (i = 0; i < ei_len; ++i) {
7649                 gint32 clause_index = *(gint32*)type_info [i];
7650                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
7651
7652                 cfg->llvm_ex_info [i].flags = clause->flags;
7653                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
7654                 cfg->llvm_ex_info [i].clause_index = clause_index;
7655         }
7656
7657         /*
7658          * For nested clauses, the LLVM produced exception info associates the try interval with
7659          * the innermost handler, while mono expects it to be associated with all nesting clauses.
7660          * So add new clauses which use the IL info (catch class etc.) from the nesting clause,
7661          * and everything else from the nested clause.
7662          */
7663         nindex = ei_len;
7664         for (i = 0; i < ei_len; ++i) {
7665                 gint32 cindex1 = *(gint32*)type_info [i];
7666                 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
7667
7668                 for (j = 0; j < cfg->header->num_clauses; ++j) {
7669                         int cindex2 = j;
7670                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
7671                         MonoJitExceptionInfo *nesting_ei, *nested_ei;
7672
7673                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
7674                                 /* clause1 is the nested clause */
7675                                 nested_ei = &cfg->llvm_ex_info [i];
7676                                 nesting_ei = &cfg->llvm_ex_info [nindex];
7677                                 nindex ++;
7678
7679                                 memcpy (nesting_ei, nested_ei, sizeof (MonoJitExceptionInfo));
7680
7681                                 nesting_ei->flags = clause2->flags;
7682                                 nesting_ei->data.catch_class = clause2->data.catch_class;
7683                                 nesting_ei->clause_index = cindex2;
7684                         }
7685                 }
7686         }
7687         g_assert (nindex == ei_len + nested_len);
7688         cfg->llvm_this_reg = this_reg;
7689         cfg->llvm_this_offset = this_offset;
7690
7691         /* type_info [i] is cfg mempool allocated, no need to free it */
7692
7693         g_free (ei);
7694         g_free (type_info);
7695 }
7696
7697 #if LLVM_API_VERSION > 100
7698 /*
7699  * decode_llvm_eh_info:
7700  *
7701  *   Decode the EH table emitted by llvm in jit mode, and store
7702  * the result into cfg.
7703  */
7704 static void
7705 decode_llvm_eh_info (EmitContext *ctx, gpointer eh_frame)
7706 {
7707         MonoCompile *cfg = ctx->cfg;
7708         guint8 *cie, *fde;
7709         int fde_len;
7710         MonoLLVMFDEInfo info;
7711         MonoJitExceptionInfo *ei;
7712         guint8 *p = eh_frame;
7713         int version, fde_count, fde_offset;
7714         guint32 ei_len, i, nested_len;
7715         gpointer *type_info;
7716         gint32 *table;
7717
7718         /*
7719          * Decode the one element EH table emitted by the MonoException class
7720          * in llvm.
7721          */
7722
7723         /* Similar to decode_llvm_mono_eh_frame () in aot-runtime.c */
7724
7725         version = *p;
7726         g_assert (version == 3);
7727         p ++;
7728         p ++;
7729         p = (guint8 *)ALIGN_PTR_TO (p, 4);
7730
7731         fde_count = *(guint32*)p;
7732         p += 4;
7733         table = (gint32*)p;
7734
7735         g_assert (fde_count <= 2);
7736
7737         /* The first entry is the real method */
7738         g_assert (table [0] == 1);
7739         fde_offset = table [1];
7740         table += fde_count * 2;
7741         /* Extra entry */
7742         cfg->code_len = table [0];
7743         fde_len = table [1] - fde_offset;
7744         table += 2;
7745
7746         fde = (guint8*)eh_frame + fde_offset;
7747         cie = (guint8*)table;
7748
7749         mono_unwind_decode_llvm_mono_fde (fde, fde_len, cie, cfg->native_code, &info);
7750
7751         cfg->encoded_unwind_ops = info.unw_info;
7752         cfg->encoded_unwind_ops_len = info.unw_info_len;
7753         if (cfg->verbose_level > 1)
7754                 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
7755         if (info.this_reg != -1) {
7756                 cfg->llvm_this_reg = info.this_reg;
7757                 cfg->llvm_this_offset = info.this_offset;
7758         }
7759
7760         ei = info.ex_info;
7761         ei_len = info.ex_info_len;
7762         type_info = info.type_info;
7763
7764         // Nested clauses are currently disabled
7765         nested_len = 0;
7766
7767         cfg->llvm_ex_info = (MonoJitExceptionInfo*)mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
7768         cfg->llvm_ex_info_len = ei_len + nested_len;
7769         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
7770         /* Fill the rest of the information from the type info */
7771         for (i = 0; i < ei_len; ++i) {
7772                 gint32 clause_index = *(gint32*)type_info [i];
7773                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
7774
7775                 cfg->llvm_ex_info [i].flags = clause->flags;
7776                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
7777                 cfg->llvm_ex_info [i].clause_index = clause_index;
7778         }
7779 }
7780 #endif
7781
7782 static char*
7783 dlsym_cb (const char *name, void **symbol)
7784 {
7785         MonoDl *current;
7786         char *err;
7787
7788         err = NULL;
7789         if (!strcmp (name, "__bzero")) {
7790                 *symbol = (void*)bzero;
7791         } else {
7792                 current = mono_dl_open (NULL, 0, NULL);
7793                 g_assert (current);
7794
7795                 err = mono_dl_symbol (current, name, symbol);
7796
7797                 mono_dl_close (current);
7798         }
7799 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
7800         *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
7801 #endif
7802         return err;
7803 }
7804
7805 static inline void
7806 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
7807 {
7808         LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
7809 }
7810
7811 static inline void
7812 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
7813 {
7814         LLVMTypeRef param_types [4];
7815
7816         param_types [0] = param_type1;
7817         param_types [1] = param_type2;
7818
7819         AddFunc (module, name, ret_type, param_types, 2);
7820 }
7821
7822 typedef enum {
7823         INTRINS_MEMSET,
7824         INTRINS_MEMCPY,
7825         INTRINS_SADD_OVF_I32,
7826         INTRINS_UADD_OVF_I32,
7827         INTRINS_SSUB_OVF_I32,
7828         INTRINS_USUB_OVF_I32,
7829         INTRINS_SMUL_OVF_I32,
7830         INTRINS_UMUL_OVF_I32,
7831         INTRINS_SADD_OVF_I64,
7832         INTRINS_UADD_OVF_I64,
7833         INTRINS_SSUB_OVF_I64,
7834         INTRINS_USUB_OVF_I64,
7835         INTRINS_SMUL_OVF_I64,
7836         INTRINS_UMUL_OVF_I64,
7837         INTRINS_SIN,
7838         INTRINS_COS,
7839         INTRINS_SQRT,
7840         INTRINS_FABS,
7841         INTRINS_EXPECT_I8,
7842         INTRINS_EXPECT_I1,
7843 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7844         INTRINS_SSE_PMOVMSKB,
7845         INTRINS_SSE_PSRLI_W,
7846         INTRINS_SSE_PSRAI_W,
7847         INTRINS_SSE_PSLLI_W,
7848         INTRINS_SSE_PSRLI_D,
7849         INTRINS_SSE_PSRAI_D,
7850         INTRINS_SSE_PSLLI_D,
7851         INTRINS_SSE_PSRLI_Q,
7852         INTRINS_SSE_PSLLI_Q,
7853         INTRINS_SSE_SQRT_PD,
7854         INTRINS_SSE_SQRT_PS,
7855         INTRINS_SSE_RSQRT_PS,
7856         INTRINS_SSE_RCP_PS,
7857         INTRINS_SSE_CVTTPD2DQ,
7858         INTRINS_SSE_CVTTPS2DQ,
7859         INTRINS_SSE_CVTDQ2PD,
7860         INTRINS_SSE_CVTDQ2PS,
7861         INTRINS_SSE_CVTPD2DQ,
7862         INTRINS_SSE_CVTPS2DQ,
7863         INTRINS_SSE_CVTPD2PS,
7864         INTRINS_SSE_CVTPS2PD,
7865         INTRINS_SSE_CMPPD,
7866         INTRINS_SSE_CMPPS,
7867         INTRINS_SSE_PACKSSWB,
7868         INTRINS_SSE_PACKUSWB,
7869         INTRINS_SSE_PACKSSDW,
7870         INTRINS_SSE_PACKUSDW,
7871         INTRINS_SSE_MINPS,
7872         INTRINS_SSE_MAXPS,
7873         INTRINS_SSE_HADDPS,
7874         INTRINS_SSE_HSUBPS,
7875         INTRINS_SSE_ADDSUBPS,
7876         INTRINS_SSE_MINPD,
7877         INTRINS_SSE_MAXPD,
7878         INTRINS_SSE_HADDPD,
7879         INTRINS_SSE_HSUBPD,
7880         INTRINS_SSE_ADDSUBPD,
7881         INTRINS_SSE_PADDSW,
7882         INTRINS_SSE_PSUBSW,
7883         INTRINS_SSE_PADDUSW,
7884         INTRINS_SSE_PSUBUSW,
7885         INTRINS_SSE_PAVGW,
7886         INTRINS_SSE_PMULHW,
7887         INTRINS_SSE_PMULHU,
7888         INTRINS_SE_PADDSB,
7889         INTRINS_SSE_PSUBSB,
7890         INTRINS_SSE_PADDUSB,
7891         INTRINS_SSE_PSUBUSB,
7892         INTRINS_SSE_PAVGB,
7893         INTRINS_SSE_PAUSE,
7894         INTRINS_SSE_DPPS,
7895 #endif
7896         INTRINS_NUM
7897 } IntrinsicId;
7898
7899 typedef struct {
7900         IntrinsicId id;
7901         const char *name;
7902 } IntrinsicDesc;
7903
7904 static IntrinsicDesc intrinsics[] = {
7905         {INTRINS_MEMSET, "llvm.memset.p0i8.i32"},
7906         {INTRINS_MEMCPY, "llvm.memcpy.p0i8.p0i8.i32"},
7907         {INTRINS_SADD_OVF_I32, "llvm.sadd.with.overflow.i32"},
7908         {INTRINS_UADD_OVF_I32, "llvm.uadd.with.overflow.i32"},
7909         {INTRINS_SSUB_OVF_I32, "llvm.ssub.with.overflow.i32"},
7910         {INTRINS_USUB_OVF_I32, "llvm.usub.with.overflow.i32"},
7911         {INTRINS_SMUL_OVF_I32, "llvm.smul.with.overflow.i32"},
7912         {INTRINS_UMUL_OVF_I32, "llvm.umul.with.overflow.i32"},
7913         {INTRINS_SADD_OVF_I64, "llvm.sadd.with.overflow.i64"},
7914         {INTRINS_UADD_OVF_I64, "llvm.uadd.with.overflow.i64"},
7915         {INTRINS_SSUB_OVF_I64, "llvm.ssub.with.overflow.i64"},
7916         {INTRINS_USUB_OVF_I64, "llvm.usub.with.overflow.i64"},
7917         {INTRINS_SMUL_OVF_I64, "llvm.smul.with.overflow.i64"},
7918         {INTRINS_UMUL_OVF_I64, "llvm.umul.with.overflow.i64"},
7919         {INTRINS_SIN, "llvm.sin.f64"},
7920         {INTRINS_COS, "llvm.cos.f64"},
7921         {INTRINS_SQRT, "llvm.sqrt.f64"},
7922         /* This isn't an intrinsic, instead llvm seems to special case it by name */
7923         {INTRINS_FABS, "fabs"},
7924         {INTRINS_EXPECT_I8, "llvm.expect.i8"},
7925         {INTRINS_EXPECT_I1, "llvm.expect.i1"},
7926 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7927         {INTRINS_SSE_PMOVMSKB, "llvm.x86.sse2.pmovmskb.128"},
7928         {INTRINS_SSE_PSRLI_W, "llvm.x86.sse2.psrli.w"},
7929         {INTRINS_SSE_PSRAI_W, "llvm.x86.sse2.psrai.w"},
7930         {INTRINS_SSE_PSLLI_W, "llvm.x86.sse2.pslli.w"},
7931         {INTRINS_SSE_PSRLI_D, "llvm.x86.sse2.psrli.d"},
7932         {INTRINS_SSE_PSRAI_D, "llvm.x86.sse2.psrai.d"},
7933         {INTRINS_SSE_PSLLI_D, "llvm.x86.sse2.pslli.d"},
7934         {INTRINS_SSE_PSRLI_Q, "llvm.x86.sse2.psrli.q"},
7935         {INTRINS_SSE_PSLLI_Q, "llvm.x86.sse2.pslli.q"},
7936         {INTRINS_SSE_SQRT_PD, "llvm.x86.sse2.sqrt.pd"},
7937         {INTRINS_SSE_SQRT_PS, "llvm.x86.sse.sqrt.ps"},
7938         {INTRINS_SSE_RSQRT_PS, "llvm.x86.sse.rsqrt.ps"},
7939         {INTRINS_SSE_RCP_PS, "llvm.x86.sse.rcp.ps"},
7940         {INTRINS_SSE_CVTTPD2DQ, "llvm.x86.sse2.cvttpd2dq"},
7941         {INTRINS_SSE_CVTTPS2DQ, "llvm.x86.sse2.cvttps2dq"},
7942         {INTRINS_SSE_CVTDQ2PD, "llvm.x86.sse2.cvtdq2pd"},
7943         {INTRINS_SSE_CVTDQ2PS, "llvm.x86.sse2.cvtdq2ps"},
7944         {INTRINS_SSE_CVTPD2DQ, "llvm.x86.sse2.cvtpd2dq"},
7945         {INTRINS_SSE_CVTPS2DQ, "llvm.x86.sse2.cvtps2dq"},
7946         {INTRINS_SSE_CVTPD2PS, "llvm.x86.sse2.cvtpd2ps"},
7947         {INTRINS_SSE_CVTPS2PD, "llvm.x86.sse2.cvtps2pd"},
7948         {INTRINS_SSE_CMPPD, "llvm.x86.sse2.cmp.pd"},
7949         {INTRINS_SSE_CMPPS, "llvm.x86.sse.cmp.ps"},
7950         {INTRINS_SSE_PACKSSWB, "llvm.x86.sse2.packsswb.128"},
7951         {INTRINS_SSE_PACKUSWB, "llvm.x86.sse2.packuswb.128"},
7952         {INTRINS_SSE_PACKSSDW, "llvm.x86.sse2.packssdw.128"},
7953         {INTRINS_SSE_PACKUSDW, "llvm.x86.sse41.packusdw"},
7954         {INTRINS_SSE_MINPS, "llvm.x86.sse.min.ps"},
7955         {INTRINS_SSE_MAXPS, "llvm.x86.sse.max.ps"},
7956         {INTRINS_SSE_HADDPS, "llvm.x86.sse3.hadd.ps"},
7957         {INTRINS_SSE_HSUBPS, "llvm.x86.sse3.hsub.ps"},
7958         {INTRINS_SSE_ADDSUBPS, "llvm.x86.sse3.addsub.ps"},
7959         {INTRINS_SSE_MINPD, "llvm.x86.sse2.min.pd"},
7960         {INTRINS_SSE_MAXPD, "llvm.x86.sse2.max.pd"},
7961         {INTRINS_SSE_HADDPD, "llvm.x86.sse3.hadd.pd"},
7962         {INTRINS_SSE_HSUBPD, "llvm.x86.sse3.hsub.pd"},
7963         {INTRINS_SSE_ADDSUBPD, "llvm.x86.sse3.addsub.pd"},
7964         {INTRINS_SSE_PADDSW, "llvm.x86.sse2.padds.w"},
7965         {INTRINS_SSE_PSUBSW, "llvm.x86.sse2.psubs.w"},
7966         {INTRINS_SSE_PADDUSW, "llvm.x86.sse2.paddus.w"},
7967         {INTRINS_SSE_PSUBUSW, "llvm.x86.sse2.psubus.w"},
7968         {INTRINS_SSE_PAVGW, "llvm.x86.sse2.pavg.w"},
7969         {INTRINS_SSE_PMULHW, "llvm.x86.sse2.pmulh.w"},
7970         {INTRINS_SSE_PMULHU, "llvm.x86.sse2.pmulhu.w"},
7971         {INTRINS_SE_PADDSB, "llvm.x86.sse2.padds.b"},
7972         {INTRINS_SSE_PSUBSB, "llvm.x86.sse2.psubs.b"},
7973         {INTRINS_SSE_PADDUSB, "llvm.x86.sse2.paddus.b"},
7974         {INTRINS_SSE_PSUBUSB, "llvm.x86.sse2.psubus.b"},
7975         {INTRINS_SSE_PAVGB, "llvm.x86.sse2.pavg.b"},
7976         {INTRINS_SSE_PAUSE, "llvm.x86.sse2.pause"},
7977         {INTRINS_SSE_DPPS, "llvm.x86.sse41.dpps"}
7978 #endif
7979 };
7980
7981 static void
7982 add_sse_binary (LLVMModuleRef module, const char *name, int type)
7983 {
7984         LLVMTypeRef ret_type = type_to_simd_type (type);
7985         AddFunc2 (module, name, ret_type, ret_type, ret_type);
7986 }
7987
7988 static void
7989 add_intrinsic (LLVMModuleRef module, int id)
7990 {
7991         const char *name;
7992 #if defined(TARGET_AMD64) || defined(TARGET_X86)
7993         LLVMTypeRef ret_type, arg_types [16];
7994 #endif
7995
7996         name = g_hash_table_lookup (intrins_id_to_name, GINT_TO_POINTER (id));
7997         g_assert (name);
7998
7999         switch (id) {
8000         case INTRINS_MEMSET: {
8001                 LLVMTypeRef params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
8002
8003                 AddFunc (module, name, LLVMVoidType (), params, 5);
8004                 break;
8005         }
8006         case INTRINS_MEMCPY: {
8007                 LLVMTypeRef params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
8008
8009                 AddFunc (module, name, LLVMVoidType (), params, 5);
8010                 break;
8011         }
8012         case INTRINS_SADD_OVF_I32:
8013         case INTRINS_UADD_OVF_I32:
8014         case INTRINS_SSUB_OVF_I32:
8015         case INTRINS_USUB_OVF_I32:
8016         case INTRINS_SMUL_OVF_I32:
8017         case INTRINS_UMUL_OVF_I32: {
8018                 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
8019                 LLVMTypeRef params [] = { LLVMInt32Type (), LLVMInt32Type () };
8020                 LLVMTypeRef ret_type = LLVMStructType (ovf_res_i32, 2, FALSE);
8021
8022                 AddFunc (module, name, ret_type, params, 2);
8023                 break;
8024         }
8025         case INTRINS_SADD_OVF_I64:
8026         case INTRINS_UADD_OVF_I64:
8027         case INTRINS_SSUB_OVF_I64:
8028         case INTRINS_USUB_OVF_I64:
8029         case INTRINS_SMUL_OVF_I64:
8030         case INTRINS_UMUL_OVF_I64: {
8031                 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
8032                 LLVMTypeRef params [] = { LLVMInt64Type (), LLVMInt64Type () };
8033                 LLVMTypeRef ret_type = LLVMStructType (ovf_res_i64, 2, FALSE);
8034
8035                 AddFunc (module, name, ret_type, params, 2);
8036                 break;
8037         }
8038         case INTRINS_SIN:
8039         case INTRINS_COS:
8040         case INTRINS_SQRT:
8041         case INTRINS_FABS: {
8042                 LLVMTypeRef params [] = { LLVMDoubleType () };
8043
8044                 AddFunc (module, name, LLVMDoubleType (), params, 1);
8045                 break;
8046         }
8047         case INTRINS_EXPECT_I8:
8048                 AddFunc2 (module, name, LLVMInt8Type (), LLVMInt8Type (), LLVMInt8Type ());
8049                 break;
8050         case INTRINS_EXPECT_I1:
8051                 AddFunc2 (module, name, LLVMInt1Type (), LLVMInt1Type (), LLVMInt1Type ());
8052                 break;
8053 #if defined(TARGET_AMD64) || defined(TARGET_X86)
8054         case INTRINS_SSE_PMOVMSKB:
8055                 /* pmovmskb */
8056                 ret_type = LLVMInt32Type ();
8057                 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
8058                 AddFunc (module, name, ret_type, arg_types, 1);
8059                 break;
8060         case INTRINS_SSE_PSRLI_W:
8061         case INTRINS_SSE_PSRAI_W:
8062         case INTRINS_SSE_PSLLI_W:
8063                 /* shifts */
8064                 ret_type = type_to_simd_type (MONO_TYPE_I2);
8065                 arg_types [0] = ret_type;
8066                 arg_types [1] = LLVMInt32Type ();
8067                 AddFunc (module, name, ret_type, arg_types, 2);
8068                 break;
8069         case INTRINS_SSE_PSRLI_D:
8070         case INTRINS_SSE_PSRAI_D:
8071         case INTRINS_SSE_PSLLI_D:
8072                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8073                 arg_types [0] = ret_type;
8074                 arg_types [1] = LLVMInt32Type ();
8075                 AddFunc (module, name, ret_type, arg_types, 2);
8076                 break;
8077         case INTRINS_SSE_PSRLI_Q:
8078         case INTRINS_SSE_PSLLI_Q:
8079                 ret_type = type_to_simd_type (MONO_TYPE_I8);
8080                 arg_types [0] = ret_type;
8081                 arg_types [1] = LLVMInt32Type ();
8082                 AddFunc (module, name, ret_type, arg_types, 2);
8083                 break;
8084         case INTRINS_SSE_SQRT_PD:
8085                 /* Unary ops */
8086                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8087                 arg_types [0] = ret_type;
8088                 AddFunc (module, name, ret_type, arg_types, 1);
8089                 break;
8090         case INTRINS_SSE_SQRT_PS:
8091                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8092                 arg_types [0] = ret_type;
8093                 AddFunc (module, name, ret_type, arg_types, 1);
8094                 break;
8095         case INTRINS_SSE_RSQRT_PS:
8096                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8097                 arg_types [0] = ret_type;
8098                 AddFunc (module, name, ret_type, arg_types, 1);
8099                 break;
8100         case INTRINS_SSE_RCP_PS:
8101                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8102                 arg_types [0] = ret_type;
8103                 AddFunc (module, name, ret_type, arg_types, 1);
8104                 break;
8105         case INTRINS_SSE_CVTTPD2DQ:
8106                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8107                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8108                 AddFunc (module, name, ret_type, arg_types, 1);
8109                 break;
8110         case INTRINS_SSE_CVTTPS2DQ:
8111                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8112                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8113                 AddFunc (module, name, ret_type, arg_types, 1);
8114                 break;
8115         case INTRINS_SSE_CVTDQ2PD:
8116                 /* Conversion ops */
8117                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8118                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8119                 AddFunc (module, name, ret_type, arg_types, 1);
8120                 break;
8121         case INTRINS_SSE_CVTDQ2PS:
8122                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8123                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8124                 AddFunc (module, name, ret_type, arg_types, 1);
8125                 break;
8126         case INTRINS_SSE_CVTPD2DQ:
8127                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8128                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8129                 AddFunc (module, name, ret_type, arg_types, 1);
8130                 break;
8131         case INTRINS_SSE_CVTPS2DQ:
8132                 ret_type = type_to_simd_type (MONO_TYPE_I4);
8133                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8134                 AddFunc (module, name, ret_type, arg_types, 1);
8135                 break;
8136         case INTRINS_SSE_CVTPD2PS:
8137                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8138                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
8139                 AddFunc (module, name, ret_type, arg_types, 1);
8140                 break;
8141         case INTRINS_SSE_CVTPS2PD:
8142                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8143                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8144                 AddFunc (module, name, ret_type, arg_types, 1);
8145                 break;
8146         case INTRINS_SSE_CMPPD:
8147                 /* cmp pd/ps */
8148                 ret_type = type_to_simd_type (MONO_TYPE_R8);
8149                 arg_types [0] = ret_type;
8150                 arg_types [1] = ret_type;
8151                 arg_types [2] = LLVMInt8Type ();
8152                 AddFunc (module, name, ret_type, arg_types, 3);
8153                 break;
8154         case INTRINS_SSE_CMPPS:
8155                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8156                 arg_types [0] = ret_type;
8157                 arg_types [1] = ret_type;
8158                 arg_types [2] = LLVMInt8Type ();
8159                 AddFunc (module, name, ret_type, arg_types, 3);
8160                 break;
8161         case INTRINS_SSE_PACKSSWB:
8162         case INTRINS_SSE_PACKUSWB:
8163         case INTRINS_SSE_PACKSSDW:
8164                 /* pack */
8165                 ret_type = type_to_simd_type (MONO_TYPE_I1);
8166                 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
8167                 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
8168                 AddFunc (module, name, ret_type, arg_types, 2);
8169                 break;
8170         case INTRINS_SSE_PACKUSDW:
8171                 ret_type = type_to_simd_type (MONO_TYPE_I2);
8172                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
8173                 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
8174                 AddFunc (module, name, ret_type, arg_types, 2);
8175                 break;
8176                 /* SSE Binary ops */
8177         case INTRINS_SSE_PADDSW:
8178         case INTRINS_SSE_PSUBSW:
8179         case INTRINS_SSE_PADDUSW:
8180         case INTRINS_SSE_PSUBUSW:
8181         case INTRINS_SSE_PAVGW:
8182         case INTRINS_SSE_PMULHW:
8183         case INTRINS_SSE_PMULHU:
8184                 add_sse_binary (module, name, MONO_TYPE_I2);
8185                 break;
8186         case INTRINS_SSE_MINPS:
8187         case INTRINS_SSE_MAXPS:
8188         case INTRINS_SSE_HADDPS:
8189         case INTRINS_SSE_HSUBPS:
8190         case INTRINS_SSE_ADDSUBPS:
8191                 add_sse_binary (module, name, MONO_TYPE_R4);
8192                 break;
8193         case INTRINS_SSE_MINPD:
8194         case INTRINS_SSE_MAXPD:
8195         case INTRINS_SSE_HADDPD:
8196         case INTRINS_SSE_HSUBPD:
8197         case INTRINS_SSE_ADDSUBPD:
8198                 add_sse_binary (module, name, MONO_TYPE_R8);
8199                 break;
8200         case INTRINS_SE_PADDSB:
8201         case INTRINS_SSE_PSUBSB:
8202         case INTRINS_SSE_PADDUSB:
8203         case INTRINS_SSE_PSUBUSB:
8204         case INTRINS_SSE_PAVGB:
8205                 add_sse_binary (module, name, MONO_TYPE_I1);
8206                 break;
8207         case INTRINS_SSE_PAUSE:
8208                 AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
8209                 break;
8210         case INTRINS_SSE_DPPS:
8211                 ret_type = type_to_simd_type (MONO_TYPE_R4);
8212                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
8213                 arg_types [1] = type_to_simd_type (MONO_TYPE_R4);
8214                 arg_types [2] = LLVMInt32Type ();
8215                 AddFunc (module, name, ret_type, arg_types, 3);
8216                 break;
8217 #endif
8218         default:
8219                 g_assert_not_reached ();
8220                 break;
8221         }
8222 }
8223
8224 static LLVMValueRef
8225 get_intrinsic (EmitContext *ctx, const char *name)
8226 {
8227 #if LLVM_API_VERSION > 100
8228         LLVMValueRef res;
8229
8230         /*
8231          * Every method is emitted into its own module so
8232          * we can add intrinsics on demand.
8233          */
8234         res = LLVMGetNamedFunction (ctx->lmodule, name);
8235         if (!res) {
8236                 int id = -1;
8237
8238                 /* No locking needed */
8239                 id = GPOINTER_TO_INT (g_hash_table_lookup (intrins_name_to_id, name));
8240                 id --;
8241                 if (id == -1)
8242                         printf ("%s\n", name);
8243                 g_assert (id != -1);
8244                 add_intrinsic (ctx->lmodule, id);
8245                 res = LLVMGetNamedFunction (ctx->lmodule, name);
8246                 g_assert (res);
8247         }
8248
8249         return res;
8250 #else
8251         LLVMValueRef res;
8252
8253         res = LLVMGetNamedFunction (ctx->lmodule, name);
8254         g_assert (res);
8255         return res;
8256 #endif
8257 }
8258
8259 static void
8260 add_intrinsics (LLVMModuleRef module)
8261 {
8262         int i;
8263
8264         /* Emit declarations of instrinsics */
8265         /*
8266          * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
8267          * type doesn't seem to do any locking.
8268          */
8269         for (i = 0; i < INTRINS_NUM; ++i)
8270                 add_intrinsic (module, i);
8271
8272         /* EH intrinsics */
8273         {
8274                 AddFunc (module, "mono_personality", LLVMVoidType (), NULL, 0);
8275
8276                 AddFunc (module, "llvm_resume_unwind_trampoline", LLVMVoidType (), NULL, 0);
8277         }
8278
8279         /* Load/Store intrinsics */
8280         {
8281                 LLVMTypeRef arg_types [5];
8282                 int i;
8283                 char name [128];
8284
8285                 for (i = 1; i <= 8; i *= 2) {
8286                         arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
8287                         arg_types [1] = LLVMInt32Type ();
8288                         arg_types [2] = LLVMInt1Type ();
8289                         arg_types [3] = LLVMInt32Type ();
8290                         sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
8291                         AddFunc (module, name, LLVMIntType (i * 8), arg_types, 4);
8292
8293                         arg_types [0] = LLVMIntType (i * 8);
8294                         arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
8295                         arg_types [2] = LLVMInt32Type ();
8296                         arg_types [3] = LLVMInt1Type ();
8297                         arg_types [4] = LLVMInt32Type ();
8298                         sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
8299                         AddFunc (module, name, LLVMVoidType (), arg_types, 5);
8300                 }
8301         }
8302 }
8303
8304 static void
8305 add_types (MonoLLVMModule *module)
8306 {
8307         module->ptr_type = LLVMPointerType (sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type (), 0);
8308 }
8309
8310 void
8311 mono_llvm_init (void)
8312 {
8313         GHashTable *h;
8314         int i;
8315
8316         mono_native_tls_alloc (&current_cfg_tls_id, NULL);
8317
8318         h = g_hash_table_new (NULL, NULL);
8319         for (i = 0; i < INTRINS_NUM; ++i)
8320                 g_hash_table_insert (h, GINT_TO_POINTER (intrinsics [i].id), (gpointer)intrinsics [i].name);
8321         intrins_id_to_name = h;
8322
8323         h = g_hash_table_new (g_str_hash, g_str_equal);
8324         for (i = 0; i < INTRINS_NUM; ++i)
8325                 g_hash_table_insert (h, (gpointer)intrinsics [i].name, GINT_TO_POINTER (intrinsics [i].id + 1));
8326         intrins_name_to_id = h;
8327 }
8328
8329 static void
8330 init_jit_module (MonoDomain *domain)
8331 {
8332         MonoJitDomainInfo *dinfo;
8333         MonoLLVMModule *module;
8334         char *name;
8335
8336         dinfo = domain_jit_info (domain);
8337         if (dinfo->llvm_module)
8338                 return;
8339
8340         mono_loader_lock ();
8341
8342         if (dinfo->llvm_module) {
8343                 mono_loader_unlock ();
8344                 return;
8345         }
8346
8347         module = g_new0 (MonoLLVMModule, 1);
8348
8349         name = g_strdup_printf ("mono-%s", domain->friendly_name);
8350         module->lmodule = LLVMModuleCreateWithName (name);
8351         module->context = LLVMGetGlobalContext ();
8352
8353         module->mono_ee = (MonoEERef*)mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (module->lmodule), alloc_cb, emitted_cb, exception_cb, dlsym_cb, &module->ee);
8354
8355         add_intrinsics (module->lmodule);
8356         add_types (module);
8357
8358         module->llvm_types = g_hash_table_new (NULL, NULL);
8359
8360 #if LLVM_API_VERSION < 100
8361         MonoJitICallInfo *info;
8362
8363         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
8364         g_assert (info);
8365         LLVMAddGlobalMapping (module->ee, LLVMGetNamedFunction (module->lmodule, "llvm_resume_unwind_trampoline"), (void*)info->func);
8366 #endif
8367
8368         mono_memory_barrier ();
8369
8370         dinfo->llvm_module = module;
8371
8372         mono_loader_unlock ();
8373 }
8374
8375 void
8376 mono_llvm_cleanup (void)
8377 {
8378         MonoLLVMModule *module = &aot_module;
8379
8380         if (module->lmodule)
8381                 LLVMDisposeModule (module->lmodule);
8382
8383         if (module->context)
8384                 LLVMContextDispose (module->context);
8385 }
8386
8387 void
8388 mono_llvm_free_domain_info (MonoDomain *domain)
8389 {
8390         MonoJitDomainInfo *info = domain_jit_info (domain);
8391         MonoLLVMModule *module = (MonoLLVMModule*)info->llvm_module;
8392         int i;
8393
8394         if (!module)
8395                 return;
8396
8397         if (module->llvm_types)
8398                 g_hash_table_destroy (module->llvm_types);
8399
8400         mono_llvm_dispose_ee (module->mono_ee);
8401
8402         if (module->bb_names) {
8403                 for (i = 0; i < module->bb_names_len; ++i)
8404                         g_free (module->bb_names [i]);
8405                 g_free (module->bb_names);
8406         }
8407         //LLVMDisposeModule (module->module);
8408
8409         g_free (module);
8410
8411         info->llvm_module = NULL;
8412 }
8413
8414 void
8415 mono_llvm_create_aot_module (MonoAssembly *assembly, const char *global_prefix, gboolean emit_dwarf, gboolean static_link, gboolean llvm_only)
8416 {
8417         MonoLLVMModule *module = &aot_module;
8418
8419         /* Delete previous module */
8420         if (module->plt_entries)
8421                 g_hash_table_destroy (module->plt_entries);
8422         if (module->lmodule)
8423                 LLVMDisposeModule (module->lmodule);
8424
8425         memset (module, 0, sizeof (aot_module));
8426
8427         module->lmodule = LLVMModuleCreateWithName ("aot");
8428         module->assembly = assembly;
8429         module->global_prefix = g_strdup (global_prefix);
8430         module->got_symbol = g_strdup_printf ("%s_llvm_got", global_prefix);
8431         module->eh_frame_symbol = g_strdup_printf ("%s_eh_frame", global_prefix);
8432         module->get_method_symbol = g_strdup_printf ("%s_get_method", global_prefix);
8433         module->get_unbox_tramp_symbol = g_strdup_printf ("%s_get_unbox_tramp", global_prefix);
8434         module->external_symbols = TRUE;
8435         module->emit_dwarf = emit_dwarf;
8436         module->static_link = static_link;
8437         module->llvm_only = llvm_only;
8438         /* The first few entries are reserved */
8439         module->max_got_offset = 16;
8440         module->context = LLVMGetGlobalContext ();
8441
8442         if (llvm_only)
8443                 /* clang ignores our debug info because it has an invalid version */
8444                 module->emit_dwarf = FALSE;
8445
8446         add_intrinsics (module->lmodule);
8447         add_types (module);
8448
8449 #if LLVM_API_VERSION > 100
8450         if (module->emit_dwarf) {
8451                 char *dir, *build_info, *s, *cu_name;
8452
8453                 module->di_builder = mono_llvm_create_di_builder (module->lmodule);
8454
8455                 // FIXME:
8456                 dir = g_strdup (".");
8457                 build_info = mono_get_runtime_build_info ();
8458                 s = g_strdup_printf ("Mono AOT Compiler %s (LLVM)", build_info);
8459                 cu_name = g_path_get_basename (assembly->image->name);
8460                 module->cu = mono_llvm_di_create_compile_unit (module->di_builder, cu_name, dir, s);
8461                 g_free (dir);
8462                 g_free (build_info);
8463                 g_free (s);
8464         }
8465 #endif
8466
8467         /* Add GOT */
8468         /*
8469          * We couldn't compute the type of the LLVM global representing the got because
8470          * its size is only known after all the methods have been emitted. So create
8471          * a dummy variable, and replace all uses it with the real got variable when
8472          * its size is known in mono_llvm_emit_aot_module ().
8473          */
8474         {
8475                 LLVMTypeRef got_type = LLVMArrayType (module->ptr_type, 0);
8476
8477                 module->got_var = LLVMAddGlobal (module->lmodule, got_type, "mono_dummy_got");
8478                 LLVMSetInitializer (module->got_var, LLVMConstNull (got_type));
8479         }
8480
8481         /* Add initialization array */
8482         if (llvm_only) {
8483                 LLVMTypeRef inited_type = LLVMArrayType (LLVMInt8Type (), 0);
8484
8485                 module->inited_var = LLVMAddGlobal (aot_module.lmodule, inited_type, "mono_inited_tmp");
8486                 LLVMSetInitializer (module->inited_var, LLVMConstNull (inited_type));
8487         }
8488
8489         if (llvm_only)
8490                 emit_init_icall_wrappers (module);
8491
8492         emit_llvm_code_start (module);
8493
8494         /* Add a dummy personality function */
8495         if (!use_debug_personality) {
8496                 LLVMValueRef personality = LLVMAddFunction (module->lmodule, default_personality_name, LLVMFunctionType (LLVMInt32Type (), NULL, 0, TRUE));
8497                 LLVMSetLinkage (personality, LLVMExternalLinkage);
8498                 mark_as_used (module, personality);
8499         }
8500
8501         /* Add a reference to the c++ exception we throw/catch */
8502         {
8503                 LLVMTypeRef exc = LLVMPointerType (LLVMInt8Type (), 0);
8504                 module->sentinel_exception = LLVMAddGlobal (module->lmodule, exc, "_ZTIPi");
8505                 LLVMSetLinkage (module->sentinel_exception, LLVMExternalLinkage);
8506                 mono_llvm_set_is_constant (module->sentinel_exception);
8507         }
8508
8509         module->llvm_types = g_hash_table_new (NULL, NULL);
8510         module->plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
8511         module->plt_entries_ji = g_hash_table_new (NULL, NULL);
8512         module->direct_callables = g_hash_table_new (g_str_hash, g_str_equal);
8513         module->method_to_lmethod = g_hash_table_new (NULL, NULL);
8514         module->idx_to_lmethod = g_hash_table_new (NULL, NULL);
8515         module->idx_to_unbox_tramp = g_hash_table_new (NULL, NULL);
8516         module->method_to_callers = g_hash_table_new (NULL, NULL);
8517 }
8518
8519 static LLVMValueRef
8520 llvm_array_from_uints (LLVMTypeRef el_type, guint32 *values, int nvalues)
8521 {
8522         int i;
8523         LLVMValueRef res, *vals;
8524
8525         vals = g_new0 (LLVMValueRef, nvalues);
8526         for (i = 0; i < nvalues; ++i)
8527                 vals [i] = LLVMConstInt (LLVMInt32Type (), values [i], FALSE);
8528         res = LLVMConstArray (LLVMInt32Type (), vals, nvalues);
8529         g_free (vals);
8530         return res;
8531 }
8532
8533 static LLVMValueRef
8534 llvm_array_from_bytes (guint8 *values, int nvalues)
8535 {
8536         int i;
8537         LLVMValueRef res, *vals;
8538
8539         vals = g_new0 (LLVMValueRef, nvalues);
8540         for (i = 0; i < nvalues; ++i)
8541                 vals [i] = LLVMConstInt (LLVMInt8Type (), values [i], FALSE);
8542         res = LLVMConstArray (LLVMInt8Type (), vals, nvalues);
8543         g_free (vals);
8544         return res;
8545 }
8546 /*
8547  * mono_llvm_emit_aot_file_info:
8548  *
8549  *   Emit the MonoAotFileInfo structure.
8550  * Same as emit_aot_file_info () in aot-compiler.c.
8551  */
8552 void
8553 mono_llvm_emit_aot_file_info (MonoAotFileInfo *info, gboolean has_jitted_code)
8554 {
8555         MonoLLVMModule *module = &aot_module;
8556
8557         /* Save these for later */
8558         memcpy (&module->aot_info, info, sizeof (MonoAotFileInfo));
8559         module->has_jitted_code = has_jitted_code;
8560 }
8561
8562 /*
8563  * mono_llvm_emit_aot_data:
8564  *
8565  *   Emit the binary data DATA pointed to by symbol SYMBOL.
8566  */
8567 void
8568 mono_llvm_emit_aot_data (const char *symbol, guint8 *data, int data_len)
8569 {
8570         MonoLLVMModule *module = &aot_module;
8571         LLVMTypeRef type;
8572         LLVMValueRef d;
8573
8574         type = LLVMArrayType (LLVMInt8Type (), data_len);
8575         d = LLVMAddGlobal (module->lmodule, type, symbol);
8576         LLVMSetVisibility (d, LLVMHiddenVisibility);
8577         LLVMSetLinkage (d, LLVMInternalLinkage);
8578         LLVMSetInitializer (d, mono_llvm_create_constant_data_array (data, data_len));
8579         mono_llvm_set_is_constant (d);
8580 }
8581
8582 /* Add a reference to a global defined in JITted code */
8583 static LLVMValueRef
8584 AddJitGlobal (MonoLLVMModule *module, LLVMTypeRef type, const char *name)
8585 {
8586         char *s;
8587         LLVMValueRef v;
8588
8589         s = g_strdup_printf ("%s%s", module->global_prefix, name);
8590         v = LLVMAddGlobal (module->lmodule, LLVMInt8Type (), s);
8591         g_free (s);
8592         return v;
8593 }
8594
8595 static void
8596 emit_aot_file_info (MonoLLVMModule *module)
8597 {
8598         LLVMTypeRef file_info_type;
8599         LLVMTypeRef *eltypes, eltype;
8600         LLVMValueRef info_var;
8601         LLVMValueRef *fields;
8602         int i, nfields, tindex;
8603         MonoAotFileInfo *info;
8604         LLVMModuleRef lmodule = module->lmodule;
8605
8606         info = &module->aot_info;
8607
8608         /* Create an LLVM type to represent MonoAotFileInfo */
8609         nfields = 2 + MONO_AOT_FILE_INFO_NUM_SYMBOLS + 16 + 5;
8610         eltypes = g_new (LLVMTypeRef, nfields);
8611         tindex = 0;
8612         eltypes [tindex ++] = LLVMInt32Type ();
8613         eltypes [tindex ++] = LLVMInt32Type ();
8614         /* Symbols */
8615         for (i = 0; i < MONO_AOT_FILE_INFO_NUM_SYMBOLS; ++i)
8616                 eltypes [tindex ++] = LLVMPointerType (LLVMInt8Type (), 0);
8617         /* Scalars */
8618         for (i = 0; i < 15; ++i)
8619                 eltypes [tindex ++] = LLVMInt32Type ();
8620         /* Arrays */
8621         eltypes [tindex ++] = LLVMArrayType (LLVMInt32Type (), MONO_AOT_TABLE_NUM);
8622         for (i = 0; i < 4; ++i)
8623                 eltypes [tindex ++] = LLVMArrayType (LLVMInt32Type (), MONO_AOT_TRAMP_NUM);
8624         eltypes [tindex ++] = LLVMArrayType (LLVMInt8Type (), 16);
8625         g_assert (tindex == nfields);
8626         file_info_type = LLVMStructCreateNamed (module->context, "MonoAotFileInfo");
8627         LLVMStructSetBody (file_info_type, eltypes, nfields, FALSE);
8628
8629         info_var = LLVMAddGlobal (lmodule, file_info_type, "mono_aot_file_info");
8630         if (module->static_link) {
8631                 LLVMSetVisibility (info_var, LLVMHiddenVisibility);
8632                 LLVMSetLinkage (info_var, LLVMInternalLinkage);
8633         }
8634         fields = g_new (LLVMValueRef, nfields);
8635         tindex = 0;
8636         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->version, FALSE);
8637         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->dummy, FALSE);
8638
8639         /* Symbols */
8640         /*
8641          * We use LLVMGetNamedGlobal () for symbol which are defined in LLVM code, and LLVMAddGlobal ()
8642          * for symbols defined in the .s file emitted by the aot compiler.
8643          */
8644         eltype = eltypes [tindex];
8645         if (module->llvm_only)
8646                 fields [tindex ++] = LLVMConstNull (eltype);
8647         else
8648                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_got");
8649         fields [tindex ++] = module->got_var;
8650         /* llc defines this directly */
8651         if (!module->llvm_only) {
8652                 fields [tindex ++] = LLVMAddGlobal (lmodule, eltype, module->eh_frame_symbol);
8653                 fields [tindex ++] = LLVMConstNull (eltype);
8654                 fields [tindex ++] = LLVMConstNull (eltype);
8655         } else {
8656                 fields [tindex ++] = LLVMConstNull (eltype);
8657                 fields [tindex ++] = module->get_method;
8658                 fields [tindex ++] = module->get_unbox_tramp;
8659         }
8660         if (module->has_jitted_code) {
8661                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_code_start");
8662                 fields [tindex ++] = AddJitGlobal (module, eltype, "jit_code_end");
8663         } else {
8664                 fields [tindex ++] = LLVMConstNull (eltype);
8665                 fields [tindex ++] = LLVMConstNull (eltype);
8666         }
8667         if (!module->llvm_only)
8668                 fields [tindex ++] = AddJitGlobal (module, eltype, "method_addresses");
8669         else
8670                 fields [tindex ++] = LLVMConstNull (eltype);
8671         if (info->flags & MONO_AOT_FILE_FLAG_SEPARATE_DATA) {
8672                 for (i = 0; i < MONO_AOT_TABLE_NUM; ++i)
8673                         fields [tindex ++] = LLVMConstNull (eltype);
8674         } else {
8675                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "blob");
8676                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "class_name_table");
8677                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "class_info_offsets");
8678                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "method_info_offsets");
8679                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "ex_info_offsets");
8680                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "extra_method_info_offsets");
8681                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "extra_method_table");
8682                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "got_info_offsets");
8683                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "llvm_got_info_offsets");
8684                 fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "image_table");
8685         }
8686         /* Not needed (mem_end) */
8687         fields [tindex ++] = LLVMConstNull (eltype);
8688         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "assembly_guid");
8689         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "runtime_version");
8690         if (info->trampoline_size [0]) {
8691                 fields [tindex ++] = AddJitGlobal (module, eltype, "specific_trampolines");
8692                 fields [tindex ++] = AddJitGlobal (module, eltype, "static_rgctx_trampolines");
8693                 fields [tindex ++] = AddJitGlobal (module, eltype, "imt_trampolines");
8694                 fields [tindex ++] = AddJitGlobal (module, eltype, "gsharedvt_arg_trampolines");
8695         } else {
8696                 fields [tindex ++] = LLVMConstNull (eltype);
8697                 fields [tindex ++] = LLVMConstNull (eltype);
8698                 fields [tindex ++] = LLVMConstNull (eltype);
8699                 fields [tindex ++] = LLVMConstNull (eltype);
8700         }
8701         if (module->static_link && !module->llvm_only)
8702                 fields [tindex ++] = AddJitGlobal (module, eltype, "globals");
8703         else
8704                 fields [tindex ++] = LLVMConstNull (eltype);
8705         fields [tindex ++] = LLVMGetNamedGlobal (lmodule, "assembly_name");
8706         if (!module->llvm_only) {
8707                 fields [tindex ++] = AddJitGlobal (module, eltype, "plt");
8708                 fields [tindex ++] = AddJitGlobal (module, eltype, "plt_end");
8709                 fields [tindex ++] = AddJitGlobal (module, eltype, "unwind_info");
8710                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampolines");
8711                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampolines_end");
8712                 fields [tindex ++] = AddJitGlobal (module, eltype, "unbox_trampoline_addresses");
8713         } else {
8714                 fields [tindex ++] = LLVMConstNull (eltype);
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         }
8721
8722         for (i = 0; i < MONO_AOT_FILE_INFO_NUM_SYMBOLS; ++i)
8723                 fields [2 + i] = LLVMConstBitCast (fields [2 + i], eltype);
8724
8725         /* Scalars */
8726         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->plt_got_offset_base, FALSE);
8727         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->got_size, FALSE);
8728         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->plt_size, FALSE);
8729         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->nmethods, FALSE);
8730         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->flags, FALSE);
8731         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->opts, FALSE);
8732         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->simd_opts, FALSE);
8733         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->gc_name_index, FALSE);
8734         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->num_rgctx_fetch_trampolines, FALSE);
8735         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->double_align, FALSE);
8736         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->long_align, FALSE);
8737         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->generic_tramp_num, FALSE);
8738         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->tramp_page_size, FALSE);
8739         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->nshared_got_entries, FALSE);
8740         fields [tindex ++] = LLVMConstInt (LLVMInt32Type (), info->datafile_size, FALSE);
8741         /* Arrays */
8742         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->table_offsets, MONO_AOT_TABLE_NUM);
8743         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->num_trampolines, MONO_AOT_TRAMP_NUM);
8744         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->trampoline_got_offset_base, MONO_AOT_TRAMP_NUM);
8745         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->trampoline_size, MONO_AOT_TRAMP_NUM);
8746         fields [tindex ++] = llvm_array_from_uints (LLVMInt32Type (), info->tramp_page_code_offsets, MONO_AOT_TRAMP_NUM);
8747
8748         fields [tindex ++] = llvm_array_from_bytes (info->aotid, 16);
8749         g_assert (tindex == nfields);
8750
8751         LLVMSetInitializer (info_var, LLVMConstNamedStruct (file_info_type, fields, nfields));
8752
8753         if (module->static_link) {
8754                 char *s, *p;
8755                 LLVMValueRef var;
8756
8757                 s = g_strdup_printf ("mono_aot_module_%s_info", module->assembly->aname.name);
8758                 /* Get rid of characters which cannot occur in symbols */
8759                 p = s;
8760                 for (p = s; *p; ++p) {
8761                         if (!(isalnum (*p) || *p == '_'))
8762                                 *p = '_';
8763                 }
8764                 var = LLVMAddGlobal (module->lmodule, LLVMPointerType (LLVMInt8Type (), 0), s);
8765                 g_free (s);
8766                 LLVMSetInitializer (var, LLVMConstBitCast (LLVMGetNamedGlobal (module->lmodule, "mono_aot_file_info"), LLVMPointerType (LLVMInt8Type (), 0)));
8767                 LLVMSetLinkage (var, LLVMExternalLinkage);
8768         }
8769 }
8770
8771 /*
8772  * Emit the aot module into the LLVM bitcode file FILENAME.
8773  */
8774 void
8775 mono_llvm_emit_aot_module (const char *filename, const char *cu_name)
8776 {
8777         LLVMTypeRef got_type, inited_type;
8778         LLVMValueRef real_got, real_inited;
8779         MonoLLVMModule *module = &aot_module;
8780
8781         emit_llvm_code_end (module);
8782
8783         /*
8784          * Create the real got variable and replace all uses of the dummy variable with
8785          * the real one.
8786          */
8787         got_type = LLVMArrayType (module->ptr_type, module->max_got_offset + 1);
8788         real_got = LLVMAddGlobal (module->lmodule, got_type, module->got_symbol);
8789         LLVMSetInitializer (real_got, LLVMConstNull (got_type));
8790         if (module->external_symbols) {
8791                 LLVMSetLinkage (real_got, LLVMExternalLinkage);
8792                 LLVMSetVisibility (real_got, LLVMHiddenVisibility);
8793         } else {
8794                 LLVMSetLinkage (real_got, LLVMInternalLinkage);
8795         }
8796         mono_llvm_replace_uses_of (module->got_var, real_got);
8797
8798         mark_as_used (&aot_module, real_got);
8799
8800         /* Delete the dummy got so it doesn't become a global */
8801         LLVMDeleteGlobal (module->got_var);
8802         module->got_var = real_got;
8803
8804         /*
8805          * Same for the init_var
8806          */
8807         if (module->llvm_only) {
8808                 inited_type = LLVMArrayType (LLVMInt8Type (), module->max_inited_idx + 1);
8809                 real_inited = LLVMAddGlobal (module->lmodule, inited_type, "mono_inited");
8810                 LLVMSetInitializer (real_inited, LLVMConstNull (inited_type));
8811                 LLVMSetLinkage (real_inited, LLVMInternalLinkage);
8812                 mono_llvm_replace_uses_of (module->inited_var, real_inited);
8813                 LLVMDeleteGlobal (module->inited_var);
8814         }
8815
8816         if (module->llvm_only) {
8817                 emit_get_method (&aot_module);
8818                 emit_get_unbox_tramp (&aot_module);
8819         }
8820
8821         emit_llvm_used (&aot_module);
8822         emit_dbg_info (&aot_module, filename, cu_name);
8823         emit_aot_file_info (&aot_module);
8824
8825         /*
8826          * Replace GOT entries for directly callable methods with the methods themselves.
8827          * It would be easier to implement this by predefining all methods before compiling
8828          * their bodies, but that couldn't handle the case when a method fails to compile
8829          * with llvm.
8830          */
8831         if (module->llvm_only) {
8832                 GHashTableIter iter;
8833                 MonoMethod *method;
8834                 GSList *callers, *l;
8835
8836                 g_hash_table_iter_init (&iter, module->method_to_callers);
8837                 while (g_hash_table_iter_next (&iter, (void**)&method, (void**)&callers)) {
8838                         LLVMValueRef lmethod;
8839
8840                         if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
8841                                 continue;
8842
8843                         lmethod = (LLVMValueRef)g_hash_table_lookup (module->method_to_lmethod, method);
8844                         if (lmethod) {
8845                                 for (l = callers; l; l = l->next) {
8846                                         LLVMValueRef caller = (LLVMValueRef)l->data;
8847
8848                                         mono_llvm_replace_uses_of (caller, lmethod);
8849                                 }
8850                         }
8851                 }
8852         }
8853
8854         /* Replace PLT entries for directly callable methods with the methods themselves */
8855         {
8856                 GHashTableIter iter;
8857                 MonoJumpInfo *ji;
8858                 LLVMValueRef callee;
8859
8860                 g_hash_table_iter_init (&iter, module->plt_entries_ji);
8861                 while (g_hash_table_iter_next (&iter, (void**)&ji, (void**)&callee)) {
8862                         if (mono_aot_is_direct_callable (ji)) {
8863                                 LLVMValueRef lmethod;
8864
8865                                 lmethod = (LLVMValueRef)g_hash_table_lookup (module->method_to_lmethod, ji->data.method);
8866                                 /* The types might not match because the caller might pass an rgctx */
8867                                 if (lmethod && LLVMTypeOf (callee) == LLVMTypeOf (lmethod)) {
8868                                         mono_llvm_replace_uses_of (callee, lmethod);
8869                                         mono_aot_mark_unused_llvm_plt_entry (ji);
8870                                 }
8871                         }
8872                 }
8873         }
8874
8875 #if 1
8876         {
8877                 char *verifier_err;
8878
8879                 if (LLVMVerifyModule (module->lmodule, LLVMReturnStatusAction, &verifier_err)) {
8880                         printf ("%s\n", verifier_err);
8881                         g_assert_not_reached ();
8882                 }
8883         }
8884 #endif
8885
8886         LLVMWriteBitcodeToFile (module->lmodule, filename);
8887 }
8888
8889
8890 static LLVMValueRef
8891 md_string (const char *s)
8892 {
8893         return LLVMMDString (s, strlen (s));
8894 }
8895
8896 /* Debugging support */
8897
8898 static void
8899 emit_dbg_info (MonoLLVMModule *module, const char *filename, const char *cu_name)
8900 {
8901         LLVMModuleRef lmodule = module->lmodule;
8902         LLVMValueRef args [16], ver;
8903
8904         /*
8905          * This can only be enabled when LLVM code is emitted into a separate object
8906          * file, since the AOT compiler also emits dwarf info,
8907          * and the abbrev indexes will not be correct since llvm has added its own
8908          * abbrevs.
8909          */
8910         if (!module->emit_dwarf)
8911                 return;
8912
8913 #if LLVM_API_VERSION > 100
8914         mono_llvm_di_builder_finalize (module->di_builder);
8915 #else
8916         LLVMValueRef cu_args [16], cu;
8917         int n_cuargs;
8918         char *build_info, *s, *dir;
8919
8920         /*
8921          * Emit dwarf info in the form of LLVM metadata. There is some
8922          * out-of-date documentation at:
8923          * http://llvm.org/docs/SourceLevelDebugging.html
8924          * but most of this was gathered from the llvm and
8925          * clang sources.
8926          */
8927
8928         n_cuargs = 0;
8929         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), DW_TAG_compile_unit, FALSE);
8930         /* CU name/compilation dir */
8931         dir = g_path_get_dirname (filename);
8932         args [0] = LLVMMDString (cu_name, strlen (cu_name));
8933         args [1] = LLVMMDString (dir, strlen (dir));
8934         cu_args [n_cuargs ++] = LLVMMDNode (args, 2);
8935         g_free (dir);
8936         /* Language */
8937         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), DW_LANG_C99, FALSE);
8938         /* Producer */
8939         build_info = mono_get_runtime_build_info ();
8940         s = g_strdup_printf ("Mono AOT Compiler %s (LLVM)", build_info);
8941         cu_args [n_cuargs ++] = LLVMMDString (s, strlen (s));
8942         g_free (build_info);
8943         /* Optimized */
8944         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8945         /* Flags */
8946         cu_args [n_cuargs ++] = LLVMMDString ("", strlen (""));
8947         /* Runtime version */
8948         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
8949         /* Enums */
8950         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8951         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8952         /* Subprograms */
8953         if (module->subprogram_mds) {
8954                 LLVMValueRef *mds;
8955                 int i;
8956
8957                 mds = g_new0 (LLVMValueRef, module->subprogram_mds->len);
8958                 for (i = 0; i < module->subprogram_mds->len; ++i)
8959                         mds [i] = (LLVMValueRef)g_ptr_array_index (module->subprogram_mds, i);
8960                 cu_args [n_cuargs ++] = LLVMMDNode (mds, module->subprogram_mds->len);
8961         } else {
8962                 cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8963         }
8964         /* GVs */
8965         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8966         /* Imported modules */
8967         cu_args [n_cuargs ++] = LLVMMDNode (args, 0);
8968         /* SplitName */
8969         cu_args [n_cuargs ++] = LLVMMDString ("", strlen (""));
8970         /* DebugEmissionKind = FullDebug */
8971         cu_args [n_cuargs ++] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8972         cu = LLVMMDNode (cu_args, n_cuargs);
8973         LLVMAddNamedMetadataOperand (lmodule, "llvm.dbg.cu", cu);
8974 #endif
8975
8976 #if LLVM_API_VERSION > 100
8977         args [0] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8978         args [1] = LLVMMDString ("Dwarf Version", strlen ("Dwarf Version"));
8979         args [2] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8980         ver = LLVMMDNode (args, 3);
8981         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8982
8983         args [0] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8984         args [1] = LLVMMDString ("Debug Info Version", strlen ("Debug Info Version"));
8985         args [2] = LLVMConstInt (LLVMInt64Type (), 3, FALSE);
8986         ver = LLVMMDNode (args, 3);
8987         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8988 #else
8989         args [0] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8990         args [1] = LLVMMDString ("Dwarf Version", strlen ("Dwarf Version"));
8991         args [2] = LLVMConstInt (LLVMInt32Type (), 2, FALSE);
8992         ver = LLVMMDNode (args, 3);
8993         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
8994
8995         args [0] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8996         args [1] = LLVMMDString ("Debug Info Version", strlen ("Debug Info Version"));
8997         args [2] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
8998         ver = LLVMMDNode (args, 3);
8999         LLVMAddNamedMetadataOperand (lmodule, "llvm.module.flags", ver);
9000 #endif
9001 }
9002
9003 static LLVMValueRef
9004 emit_dbg_subprogram (EmitContext *ctx, MonoCompile *cfg, LLVMValueRef method, const char *name)
9005 {
9006         MonoLLVMModule *module = ctx->module;
9007         MonoDebugMethodInfo *minfo = ctx->minfo;
9008         char *source_file, *dir, *filename;
9009         LLVMValueRef md, args [16], ctx_args [16], md_args [64], type_args [16], ctx_md, type_md;
9010         MonoSymSeqPoint *sym_seq_points;
9011         int n_seq_points;
9012
9013         if (!minfo)
9014                 return NULL;
9015
9016         mono_debug_symfile_get_seq_points (minfo, &source_file, NULL, NULL, &sym_seq_points, &n_seq_points);
9017         if (!source_file)
9018                 source_file = g_strdup ("<unknown>");
9019         dir = g_path_get_dirname (source_file);
9020         filename = g_path_get_basename (source_file);
9021
9022 #if LLVM_API_VERSION > 100
9023         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);
9024 #endif
9025
9026         ctx_args [0] = LLVMConstInt (LLVMInt32Type (), 0x29, FALSE);
9027         args [0] = md_string (filename);
9028         args [1] = md_string (dir);
9029         ctx_args [1] = LLVMMDNode (args, 2);
9030         ctx_md = LLVMMDNode (ctx_args, 2);
9031
9032         type_args [0] = LLVMConstInt (LLVMInt32Type (), DW_TAG_subroutine_type, FALSE);
9033         type_args [1] = NULL;
9034         type_args [2] = NULL;
9035         type_args [3] = LLVMMDString ("", 0);
9036         type_args [4] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
9037         type_args [5] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
9038         type_args [6] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
9039         type_args [7] = LLVMConstInt (LLVMInt64Type (), 0, FALSE);
9040         type_args [8] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
9041         type_args [9] = NULL;
9042         type_args [10] = NULL;
9043         type_args [11] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
9044         type_args [12] = NULL;
9045         type_args [13] = NULL;
9046         type_args [14] = NULL;
9047         type_md = LLVMMDNode (type_args, 14);
9048
9049         /* http://llvm.org/docs/SourceLevelDebugging.html#subprogram-descriptors */
9050         md_args [0] = LLVMConstInt (LLVMInt32Type (), DW_TAG_subprogram, FALSE);
9051         /* Source directory + file pair */
9052         args [0] = md_string (filename);
9053         args [1] = md_string (dir);
9054         md_args [1] = LLVMMDNode (args ,2);
9055         md_args [2] = ctx_md;
9056         md_args [3] = md_string (cfg->method->name);
9057         md_args [4] = md_string (name);
9058         md_args [5] = md_string (name);
9059         /* Line number */
9060         if (n_seq_points)
9061                 md_args [6] = LLVMConstInt (LLVMInt32Type (), sym_seq_points [0].line, FALSE);
9062         else
9063                 md_args [6] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
9064         /* Type */
9065         md_args [7] = type_md;
9066         /* static */
9067         md_args [8] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
9068         /* not extern */
9069         md_args [9] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
9070         /* Virtuality */
9071         md_args [10] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
9072         /* Index into a virtual function */
9073         md_args [11] = NULL;
9074         md_args [12] = NULL;
9075         /* Flags */
9076         md_args [13] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
9077         /* isOptimized */
9078         md_args [14] = LLVMConstInt (LLVMInt1Type (), 1, FALSE);
9079         /* Pointer to LLVM function */
9080         md_args [15] = method;
9081         /* Function template parameter */
9082         md_args [16] = NULL;
9083         /* Function declaration descriptor */
9084         md_args [17] = NULL;
9085         /* List of function variables */
9086         md_args [18] = LLVMMDNode (args, 0);
9087         /* Line number */
9088         md_args [19] = LLVMConstInt (LLVMInt32Type (), 1, FALSE);
9089         md = LLVMMDNode (md_args, 20);
9090
9091         if (!module->subprogram_mds)
9092                 module->subprogram_mds = g_ptr_array_new ();
9093         g_ptr_array_add (module->subprogram_mds, md);
9094
9095         g_free (dir);
9096         g_free (filename);
9097         g_free (source_file);
9098         g_free (sym_seq_points);
9099
9100         return md;
9101 }
9102
9103 static void
9104 emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil_code)
9105 {
9106         MonoCompile *cfg = ctx->cfg;
9107
9108         if (ctx->minfo && cil_code && cil_code >= cfg->header->code && cil_code < cfg->header->code + cfg->header->code_size) {
9109                 MonoDebugSourceLocation *loc;
9110                 LLVMValueRef loc_md;
9111
9112                 loc = mono_debug_symfile_lookup_location (ctx->minfo, cil_code - cfg->header->code);
9113
9114                 if (loc) {
9115 #if LLVM_API_VERSION > 100
9116                         loc_md = mono_llvm_di_create_location (ctx->module->di_builder, ctx->dbg_md, loc->row, loc->column);
9117                         mono_llvm_di_set_location (builder, loc_md);
9118 #else
9119                         LLVMValueRef md_args [16];
9120                         int nmd_args;
9121
9122                         nmd_args = 0;
9123                         md_args [nmd_args ++] = LLVMConstInt (LLVMInt32Type (), loc->row, FALSE);
9124                         md_args [nmd_args ++] = LLVMConstInt (LLVMInt32Type (), loc->column, FALSE);
9125                         md_args [nmd_args ++] = ctx->dbg_md;
9126                         md_args [nmd_args ++] = NULL;
9127                         loc_md = LLVMMDNode (md_args, nmd_args);
9128                         LLVMSetCurrentDebugLocation (builder, loc_md);
9129 #endif
9130                         mono_debug_symfile_free_location (loc);
9131                 }
9132         }
9133 }
9134
9135 void
9136 default_mono_llvm_unhandled_exception (void)
9137 {
9138         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
9139         MonoObject *target = mono_gchandle_get_target (jit_tls->thrown_exc);
9140
9141         mono_unhandled_exception (target);
9142         mono_invoke_unhandled_exception_hook (target);
9143         g_assert_not_reached ();
9144 }
9145
9146 /*
9147   DESIGN:
9148   - Emit LLVM IR from the mono IR using the LLVM C API.
9149   - The original arch specific code remains, so we can fall back to it if we run
9150     into something we can't handle.
9151 */
9152
9153 /*
9154   A partial list of issues:
9155   - Handling of opcodes which can throw exceptions.
9156
9157       In the mono JIT, these are implemented using code like this:
9158           method:
9159       <compare>
9160           throw_pos:
9161           b<cond> ex_label
9162           <rest of code>
9163       ex_label:
9164           push throw_pos - method
9165           call <exception trampoline>
9166
9167           The problematic part is push throw_pos - method, which cannot be represented
9168       in the LLVM IR, since it does not support label values.
9169           -> this can be implemented in AOT mode using inline asm + labels, but cannot
9170           be implemented in JIT mode ?
9171           -> a possible but slower implementation would use the normal exception
9172       throwing code but it would need to control the placement of the throw code
9173       (it needs to be exactly after the compare+branch).
9174           -> perhaps add a PC offset intrinsics ?
9175
9176   - efficient implementation of .ovf opcodes.
9177
9178           These are currently implemented as:
9179           <ins which sets the condition codes>
9180           b<cond> ex_label
9181
9182           Some overflow opcodes are now supported by LLVM SVN.
9183
9184   - exception handling, unwinding.
9185     - SSA is disabled for methods with exception handlers
9186         - How to obtain unwind info for LLVM compiled methods ?
9187           -> this is now solved by converting the unwind info generated by LLVM
9188              into our format.
9189         - LLVM uses the c++ exception handling framework, while we use our home grown
9190       code, and couldn't use the c++ one:
9191       - its not supported under VC++, other exotic platforms.
9192           - it might be impossible to support filter clauses with it.
9193
9194   - trampolines.
9195
9196     The trampolines need a predictable call sequence, since they need to disasm
9197     the calling code to obtain register numbers / offsets.
9198
9199     LLVM currently generates this code in non-JIT mode:
9200            mov    -0x98(%rax),%eax
9201            callq  *%rax
9202     Here, the vtable pointer is lost.
9203     -> solution: use one vtable trampoline per class.
9204
9205   - passing/receiving the IMT pointer/RGCTX.
9206     -> solution: pass them as normal arguments ?
9207
9208   - argument passing.
9209
9210           LLVM does not allow the specification of argument registers etc. This means
9211       that all calls are made according to the platform ABI.
9212
9213   - passing/receiving vtypes.
9214
9215       Vtypes passed/received in registers are handled by the front end by using
9216           a signature with scalar arguments, and loading the parts of the vtype into those
9217           arguments.
9218
9219           Vtypes passed on the stack are handled using the 'byval' attribute.
9220
9221   - ldaddr.
9222
9223     Supported though alloca, we need to emit the load/store code.
9224
9225   - types.
9226
9227     The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
9228     typed registers, so we have to keep track of the precise LLVM type of each vreg.
9229     This is made easier because the IR is already in SSA form.
9230     An additional problem is that our IR is not consistent with types, i.e. i32/ia64
9231         types are frequently used incorrectly.
9232 */
9233
9234 /*
9235   AOT SUPPORT:
9236   Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then link
9237   it with the file containing the methods emitted by the JIT and the AOT data
9238   structures.
9239 */
9240
9241 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
9242  *   - each bblock should end with a branch
9243  *   - setting the return value, making cfg->ret non-volatile
9244  * - avoid some transformations in the JIT which make it harder for us to generate
9245  *   code.
9246  * - use pointer types to help optimizations.
9247  */
9248
9249 #else /* DISABLE_JIT */
9250
9251 void
9252 mono_llvm_cleanup (void)
9253 {
9254 }
9255
9256 void
9257 mono_llvm_free_domain_info (MonoDomain *domain)
9258 {
9259 }
9260
9261 void
9262 mono_llvm_init (void)
9263 {
9264 }
9265
9266 void
9267 default_mono_llvm_unhandled_exception (void)
9268 {
9269 }
9270
9271 #endif /* DISABLE_JIT */