mono/mini/mini-llvm.c

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