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