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