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