mono/mini/mini-llvm.c

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