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