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