mono/mini/mini-llvm.c

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