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