mono/mini/mini-llvm.c

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