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/mempool-internals.h>
  11 #include <mono/utils/mono-tls.h>
  12 #include <mono/utils/mono-dl.h>
  13
  14 #ifndef __STDC_LIMIT_MACROS
  15 #define __STDC_LIMIT_MACROS
  16 #endif
  17 #ifndef __STDC_CONSTANT_MACROS
  18 #define __STDC_CONSTANT_MACROS
  19 #endif
  20
  21 #include "llvm-c/Core.h"
  22 #include "llvm-c/ExecutionEngine.h"
  23 #include "llvm-c/BitWriter.h"
  24 #include "llvm-c/Analysis.h"
  25
  26 #include "mini-llvm-cpp.h"
  27
  28  /*
  29   * Information associated by mono with LLVM modules.
  30   */
  31 typedef struct {
  32         LLVMModuleRef module;
  33         LLVMValueRef throw, rethrow, throw_corlib_exception;
  34         GHashTable *llvm_types;
  35         LLVMValueRef got_var;
  36         const char *got_symbol;
  37         GHashTable *plt_entries;
  38 } MonoLLVMModule;
  39
  40 /*
  41  * Information associated by the backend with mono basic blocks.
  42  */
  43 typedef struct {
  44         LLVMBasicBlockRef bblock, end_bblock;
  45         LLVMValueRef finally_ind;
  46         gboolean added, invoke_target;
  47         /*
  48          * If this bblock is the start of a finally clause, this is a list of bblocks it
  49          * needs to branch to in ENDFINALLY.
  50          */
  51         GSList *call_handler_return_bbs;
  52         /*
  53          * If this bblock is the start of a finally clause, this is the bblock that
  54          * CALL_HANDLER needs to branch to.
  55          */
  56         LLVMBasicBlockRef call_handler_target_bb;
  57         /* The list of switch statements generated by ENDFINALLY instructions */
  58         GSList *endfinally_switch_ins_list;
  59         GSList *phi_nodes;
  60 } BBInfo;
  61
  62 /*
  63  * Structure containing emit state
  64  */
  65 typedef struct {
  66         MonoMemPool *mempool;
  67
  68         /* Maps method names to the corresponding LLVMValueRef */
  69         GHashTable *emitted_method_decls;
  70
  71         MonoCompile *cfg;
  72         LLVMValueRef lmethod;
  73         MonoLLVMModule *lmodule;
  74         LLVMModuleRef module;
  75         BBInfo *bblocks;
  76         int sindex, default_index, ex_index;
  77         LLVMBuilderRef builder;
  78         LLVMValueRef *values, *addresses;
  79         MonoType **vreg_cli_types;
  80         LLVMCallInfo *linfo;
  81         MonoMethodSignature *sig;
  82         GSList *builders;
  83         GHashTable *region_to_handler;
  84         LLVMBuilderRef alloca_builder;
  85         LLVMValueRef last_alloca;
  86         LLVMValueRef rgctx_arg;
  87         LLVMTypeRef *vreg_types;
  88         gboolean *is_dead;
  89         gboolean *unreachable;
  90         int *pindexes;
  91
  92         char temp_name [32];
  93 } EmitContext;
  94
  95 typedef struct {
  96         MonoBasicBlock *bb;
  97         MonoInst *phi;
  98         MonoBasicBlock *in_bb;
  99         int sreg;
 100 } PhiNode;
 101
 102 /*
 103  * Instruction metadata
 104  * This is the same as ins_info, but LREG != IREG.
 105  */
 106 #ifdef MINI_OP
 107 #undef MINI_OP
 108 #endif
 109 #ifdef MINI_OP3
 110 #undef MINI_OP3
 111 #endif
 112 #define MINI_OP(a,b,dest,src1,src2) dest, src1, src2, ' ',
 113 #define MINI_OP3(a,b,dest,src1,src2,src3) dest, src1, src2, src3,
 114 #define NONE ' '
 115 #define IREG 'i'
 116 #define FREG 'f'
 117 #define VREG 'v'
 118 #define XREG 'x'
 119 #define LREG 'l'
 120 /* keep in sync with the enum in mini.h */
 121 const char
 122 llvm_ins_info[] = {
 123 #include "mini-ops.h"
 124 };
 125 #undef MINI_OP
 126 #undef MINI_OP3
 127
 128 #if SIZEOF_VOID_P == 4
 129 #define GET_LONG_IMM(ins) (((guint64)(ins)->inst_ms_word << 32) | (guint64)(guint32)(ins)->inst_ls_word)
 130 #else
 131 #define GET_LONG_IMM(ins) ((ins)->inst_imm)
 132 #endif
 133
 134 #define LLVM_INS_INFO(opcode) (&llvm_ins_info [((opcode) - OP_START - 1) * 4])
 135
 136 #if 0
 137 #define TRACE_FAILURE(msg) do { printf ("%s\n", msg); } while (0)
 138 #else
 139 #define TRACE_FAILURE(msg)
 140 #endif
 141
 142 #ifdef TARGET_X86
 143 #define IS_TARGET_X86 1
 144 #else
 145 #define IS_TARGET_X86 0
 146 #endif
 147
 148 #define LLVM_FAILURE(ctx, reason) do { \
 149         TRACE_FAILURE (reason); \
 150         (ctx)->cfg->exception_message = g_strdup (reason); \
 151         (ctx)->cfg->disable_llvm = TRUE; \
 152         goto FAILURE; \
 153 } while (0)
 154
 155 #define CHECK_FAILURE(ctx) do { \
 156     if ((ctx)->cfg->disable_llvm) \
 157                 goto FAILURE; \
 158 } while (0)
 159
 160 static LLVMIntPredicate cond_to_llvm_cond [] = {
 161         LLVMIntEQ,
 162         LLVMIntNE,
 163         LLVMIntSLE,
 164         LLVMIntSGE,
 165         LLVMIntSLT,
 166         LLVMIntSGT,
 167         LLVMIntULE,
 168         LLVMIntUGE,
 169         LLVMIntULT,
 170         LLVMIntUGT,
 171 };
 172
 173 static LLVMRealPredicate fpcond_to_llvm_cond [] = {
 174         LLVMRealOEQ,
 175         LLVMRealUNE,
 176         LLVMRealOLE,
 177         LLVMRealOGE,
 178         LLVMRealOLT,
 179         LLVMRealOGT,
 180         LLVMRealULE,
 181         LLVMRealUGE,
 182         LLVMRealULT,
 183         LLVMRealUGT,
 184 };
 185
 186 static LLVMExecutionEngineRef ee;
 187 static MonoNativeTlsKey current_cfg_tls_id;
 188
 189 static MonoLLVMModule jit_module, aot_module;
 190 static gboolean jit_module_inited;
 191 static int memset_param_count, memcpy_param_count;
 192 static const char *memset_func_name;
 193 static const char *memcpy_func_name;
 194
 195 static void init_jit_module (void);
 196
 197 /*
 198  * IntPtrType:
 199  *
 200  *   The LLVM type with width == sizeof (gpointer)
 201  */
 202 static LLVMTypeRef
 203 IntPtrType (void)
 204 {
 205         return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 206 }
 207
 208 static LLVMTypeRef
 209 ObjRefType (void)
 210 {
 211         return sizeof (gpointer) == 8 ? LLVMPointerType (LLVMInt64Type (), 0) : LLVMPointerType (LLVMInt32Type (), 0);
 212 }
 213
 214 /*
 215  * get_vtype_size:
 216  *
 217  *   Return the size of the LLVM representation of the vtype T.
 218  */
 219 static guint32
 220 get_vtype_size (MonoType *t)
 221 {
 222         int size;
 223
 224         size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
 225
 226         while (size < 2 * sizeof (gpointer) && mono_is_power_of_two (size) == -1)
 227                 size ++;
 228
 229         return size;
 230 }
 231
 232 /*
 233  * simd_class_to_llvm_type:
 234  *
 235  *   Return the LLVM type corresponding to the Mono.SIMD class KLASS
 236  */
 237 static LLVMTypeRef
 238 simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
 239 {
 240         if (!strcmp (klass->name, "Vector2d")) {
 241                 return LLVMVectorType (LLVMDoubleType (), 2);
 242         } else if (!strcmp (klass->name, "Vector2l")) {
 243                 return LLVMVectorType (LLVMInt64Type (), 2);
 244         } else if (!strcmp (klass->name, "Vector2ul")) {
 245                 return LLVMVectorType (LLVMInt64Type (), 2);
 246         } else if (!strcmp (klass->name, "Vector4i")) {
 247                 return LLVMVectorType (LLVMInt32Type (), 4);
 248         } else if (!strcmp (klass->name, "Vector4ui")) {
 249                 return LLVMVectorType (LLVMInt32Type (), 4);
 250         } else if (!strcmp (klass->name, "Vector4f")) {
 251                 return LLVMVectorType (LLVMFloatType (), 4);
 252         } else if (!strcmp (klass->name, "Vector8s")) {
 253                 return LLVMVectorType (LLVMInt16Type (), 8);
 254         } else if (!strcmp (klass->name, "Vector8us")) {
 255                 return LLVMVectorType (LLVMInt16Type (), 8);
 256         } else if (!strcmp (klass->name, "Vector16sb")) {
 257                 return LLVMVectorType (LLVMInt8Type (), 16);
 258         } else if (!strcmp (klass->name, "Vector16b")) {
 259                 return LLVMVectorType (LLVMInt8Type (), 16);
 260         } else {
 261                 printf ("%s\n", klass->name);
 262                 NOT_IMPLEMENTED;
 263                 return NULL;
 264         }
 265 }
 266
 267 /* Return the 128 bit SIMD type corresponding to the mono type TYPE */
 268 static inline G_GNUC_UNUSED LLVMTypeRef
 269 type_to_simd_type (int type)
 270 {
 271         switch (type) {
 272         case MONO_TYPE_I1:
 273                 return LLVMVectorType (LLVMInt8Type (), 16);
 274         case MONO_TYPE_I2:
 275                 return LLVMVectorType (LLVMInt16Type (), 8);
 276         case MONO_TYPE_I4:
 277                 return LLVMVectorType (LLVMInt32Type (), 4);
 278         case MONO_TYPE_I8:
 279                 return LLVMVectorType (LLVMInt64Type (), 2);
 280         case MONO_TYPE_R8:
 281                 return LLVMVectorType (LLVMDoubleType (), 2);
 282         case MONO_TYPE_R4:
 283                 return LLVMVectorType (LLVMFloatType (), 4);
 284         default:
 285                 g_assert_not_reached ();
 286                 return NULL;
 287         }
 288 }
 289
 290 /*
 291  * type_to_llvm_type:
 292  *
 293  *   Return the LLVM type corresponding to T.
 294  */
 295 static LLVMTypeRef
 296 type_to_llvm_type (EmitContext *ctx, MonoType *t)
 297 {
 298         if (t->byref)
 299                 return LLVMPointerType (LLVMInt8Type (), 0);
 300         switch (t->type) {
 301         case MONO_TYPE_VOID:
 302                 return LLVMVoidType ();
 303         case MONO_TYPE_I1:
 304                 return LLVMInt8Type ();
 305         case MONO_TYPE_I2:
 306                 return LLVMInt16Type ();
 307         case MONO_TYPE_I4:
 308                 return LLVMInt32Type ();
 309         case MONO_TYPE_U1:
 310                 return LLVMInt8Type ();
 311         case MONO_TYPE_U2:
 312                 return LLVMInt16Type ();
 313         case MONO_TYPE_U4:
 314                 return LLVMInt32Type ();
 315         case MONO_TYPE_BOOLEAN:
 316                 return LLVMInt8Type ();
 317         case MONO_TYPE_I8:
 318         case MONO_TYPE_U8:
 319                 return LLVMInt64Type ();
 320         case MONO_TYPE_CHAR:
 321                 return LLVMInt16Type ();
 322         case MONO_TYPE_R4:
 323                 return LLVMFloatType ();
 324         case MONO_TYPE_R8:
 325                 return LLVMDoubleType ();
 326         case MONO_TYPE_I:
 327         case MONO_TYPE_U:
 328                 return IntPtrType ();
 329         case MONO_TYPE_OBJECT:
 330         case MONO_TYPE_CLASS:
 331         case MONO_TYPE_ARRAY:
 332         case MONO_TYPE_SZARRAY:
 333         case MONO_TYPE_STRING:
 334         case MONO_TYPE_PTR:
 335                 return ObjRefType ();
 336         case MONO_TYPE_VAR:
 337         case MONO_TYPE_MVAR:
 338                 /* Because of generic sharing */
 339                 return ObjRefType ();
 340         case MONO_TYPE_GENERICINST:
 341                 if (!mono_type_generic_inst_is_valuetype (t))
 342                         return ObjRefType ();
 343                 /* Fall through */
 344         case MONO_TYPE_VALUETYPE:
 345         case MONO_TYPE_TYPEDBYREF: {
 346                 MonoClass *klass;
 347                 LLVMTypeRef ltype;
 348
 349                 klass = mono_class_from_mono_type (t);
 350
 351                 if (MONO_CLASS_IS_SIMD (ctx->cfg, klass))
 352                         return simd_class_to_llvm_type (ctx, klass);
 353
 354                 if (klass->enumtype)
 355                         return type_to_llvm_type (ctx, mono_class_enum_basetype (klass));
 356                 ltype = g_hash_table_lookup (ctx->lmodule->llvm_types, klass);
 357                 if (!ltype) {
 358                         int i, size;
 359                         LLVMTypeRef *eltypes;
 360                         char *name;
 361
 362                         size = get_vtype_size (t);
 363
 364                         eltypes = g_new (LLVMTypeRef, size);
 365                         for (i = 0; i < size; ++i)
 366                                 eltypes [i] = LLVMInt8Type ();
 367
 368                         name = mono_type_full_name (&klass->byval_arg);
 369                         ltype = LLVMStructCreateNamed (LLVMGetGlobalContext (), name);
 370                         LLVMStructSetBody (ltype, eltypes, size, FALSE);
 371                         g_hash_table_insert (ctx->lmodule->llvm_types, klass, ltype);
 372                         g_free (eltypes);
 373                 }
 374                 return ltype;
 375         }
 376
 377         default:
 378                 printf ("X: %d\n", t->type);
 379                 ctx->cfg->exception_message = g_strdup_printf ("type %s", mono_type_full_name (t));
 380                 ctx->cfg->disable_llvm = TRUE;
 381                 return NULL;
 382         }
 383 }
 384
 385 /*
 386  * type_is_unsigned:
 387  *
 388  *   Return whenever T is an unsigned int type.
 389  */
 390 static gboolean
 391 type_is_unsigned (EmitContext *ctx, MonoType *t)
 392 {
 393         if (t->byref)
 394                 return FALSE;
 395         switch (t->type) {
 396         case MONO_TYPE_U1:
 397         case MONO_TYPE_U2:
 398         case MONO_TYPE_U4:
 399         case MONO_TYPE_U8:
 400                 return TRUE;
 401         default:
 402                 return FALSE;
 403         }
 404 }
 405
 406 /*
 407  * type_to_llvm_arg_type:
 408  *
 409  *   Same as type_to_llvm_type, but treat i8/i16 as i32.
 410  */
 411 static LLVMTypeRef
 412 type_to_llvm_arg_type (EmitContext *ctx, MonoType *t)
 413 {
 414         LLVMTypeRef ptype = type_to_llvm_type (ctx, t);
 415
 416         if (ptype == LLVMInt8Type () || ptype == LLVMInt16Type ()) {
 417                 /*
 418                  * LLVM generates code which only sets the lower bits, while JITted
 419                  * code expects all the bits to be set.
 420                  */
 421                 ptype = LLVMInt32Type ();
 422         }
 423
 424         return ptype;
 425 }
 426
 427 /*
 428  * llvm_type_to_stack_type:
 429  *
 430  *   Return the LLVM type which needs to be used when a value of type TYPE is pushed
 431  * on the IL stack.
 432  */
 433 static G_GNUC_UNUSED LLVMTypeRef
 434 llvm_type_to_stack_type (LLVMTypeRef type)
 435 {
 436         if (type == NULL)
 437                 return NULL;
 438         if (type == LLVMInt8Type ())
 439                 return LLVMInt32Type ();
 440         else if (type == LLVMInt16Type ())
 441                 return LLVMInt32Type ();
 442         else if (type == LLVMFloatType ())
 443                 return LLVMDoubleType ();
 444         else
 445                 return type;
 446 }
 447
 448 /*
 449  * regtype_to_llvm_type:
 450  *
 451  *   Return the LLVM type corresponding to the regtype C used in instruction
 452  * descriptions.
 453  */
 454 static LLVMTypeRef
 455 regtype_to_llvm_type (char c)
 456 {
 457         switch (c) {
 458         case 'i':
 459                 return LLVMInt32Type ();
 460         case 'l':
 461                 return LLVMInt64Type ();
 462         case 'f':
 463                 return LLVMDoubleType ();
 464         default:
 465                 return NULL;
 466         }
 467 }
 468
 469 /*
 470  * op_to_llvm_type:
 471  *
 472  *   Return the LLVM type corresponding to the unary/binary opcode OPCODE.
 473  */
 474 static LLVMTypeRef
 475 op_to_llvm_type (int opcode)
 476 {
 477         switch (opcode) {
 478         case OP_ICONV_TO_I1:
 479         case OP_LCONV_TO_I1:
 480                 return LLVMInt8Type ();
 481         case OP_ICONV_TO_U1:
 482         case OP_LCONV_TO_U1:
 483                 return LLVMInt8Type ();
 484         case OP_ICONV_TO_I2:
 485         case OP_LCONV_TO_I2:
 486                 return LLVMInt16Type ();
 487         case OP_ICONV_TO_U2:
 488         case OP_LCONV_TO_U2:
 489                 return LLVMInt16Type ();
 490         case OP_ICONV_TO_I4:
 491         case OP_LCONV_TO_I4:
 492                 return LLVMInt32Type ();
 493         case OP_ICONV_TO_U4:
 494         case OP_LCONV_TO_U4:
 495                 return LLVMInt32Type ();
 496         case OP_ICONV_TO_I8:
 497                 return LLVMInt64Type ();
 498         case OP_ICONV_TO_R4:
 499                 return LLVMFloatType ();
 500         case OP_ICONV_TO_R8:
 501                 return LLVMDoubleType ();
 502         case OP_ICONV_TO_U8:
 503                 return LLVMInt64Type ();
 504         case OP_FCONV_TO_I4:
 505                 return LLVMInt32Type ();
 506         case OP_FCONV_TO_I8:
 507                 return LLVMInt64Type ();
 508         case OP_FCONV_TO_I1:
 509         case OP_FCONV_TO_U1:
 510                 return LLVMInt8Type ();
 511         case OP_FCONV_TO_I2:
 512         case OP_FCONV_TO_U2:
 513                 return LLVMInt16Type ();
 514         case OP_FCONV_TO_I:
 515         case OP_FCONV_TO_U:
 516                 return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
 517         case OP_IADD_OVF:
 518         case OP_IADD_OVF_UN:
 519         case OP_ISUB_OVF:
 520         case OP_ISUB_OVF_UN:
 521         case OP_IMUL_OVF:
 522         case OP_IMUL_OVF_UN:
 523                 return LLVMInt32Type ();
 524         case OP_LADD_OVF:
 525         case OP_LADD_OVF_UN:
 526         case OP_LSUB_OVF:
 527         case OP_LSUB_OVF_UN:
 528         case OP_LMUL_OVF:
 529         case OP_LMUL_OVF_UN:
 530                 return LLVMInt64Type ();
 531         default:
 532                 printf ("%s\n", mono_inst_name (opcode));
 533                 g_assert_not_reached ();
 534                 return NULL;
 535         }
 536 }
 537
 538 /*
 539  * load_store_to_llvm_type:
 540  *
 541  *   Return the size/sign/zero extension corresponding to the load/store opcode
 542  * OPCODE.
 543  */
 544 static LLVMTypeRef
 545 load_store_to_llvm_type (int opcode, int *size, gboolean *sext, gboolean *zext)
 546 {
 547         *sext = FALSE;
 548         *zext = FALSE;
 549
 550         switch (opcode) {
 551         case OP_LOADI1_MEMBASE:
 552         case OP_STOREI1_MEMBASE_REG:
 553         case OP_STOREI1_MEMBASE_IMM:
 554                 *size = 1;
 555                 *sext = TRUE;
 556                 return LLVMInt8Type ();
 557         case OP_LOADU1_MEMBASE:
 558         case OP_LOADU1_MEM:
 559                 *size = 1;
 560                 *zext = TRUE;
 561                 return LLVMInt8Type ();
 562         case OP_LOADI2_MEMBASE:
 563         case OP_STOREI2_MEMBASE_REG:
 564         case OP_STOREI2_MEMBASE_IMM:
 565                 *size = 2;
 566                 *sext = TRUE;
 567                 return LLVMInt16Type ();
 568         case OP_LOADU2_MEMBASE:
 569         case OP_LOADU2_MEM:
 570                 *size = 2;
 571                 *zext = TRUE;
 572                 return LLVMInt16Type ();
 573         case OP_LOADI4_MEMBASE:
 574         case OP_LOADU4_MEMBASE:
 575         case OP_LOADI4_MEM:
 576         case OP_LOADU4_MEM:
 577         case OP_STOREI4_MEMBASE_REG:
 578         case OP_STOREI4_MEMBASE_IMM:
 579                 *size = 4;
 580                 return LLVMInt32Type ();
 581         case OP_LOADI8_MEMBASE:
 582         case OP_LOADI8_MEM:
 583         case OP_STOREI8_MEMBASE_REG:
 584         case OP_STOREI8_MEMBASE_IMM:
 585                 *size = 8;
 586                 return LLVMInt64Type ();
 587         case OP_LOADR4_MEMBASE:
 588         case OP_STORER4_MEMBASE_REG:
 589                 *size = 4;
 590                 return LLVMFloatType ();
 591         case OP_LOADR8_MEMBASE:
 592         case OP_STORER8_MEMBASE_REG:
 593                 *size = 8;
 594                 return LLVMDoubleType ();
 595         case OP_LOAD_MEMBASE:
 596         case OP_LOAD_MEM:
 597         case OP_STORE_MEMBASE_REG:
 598         case OP_STORE_MEMBASE_IMM:
 599                 *size = sizeof (gpointer);
 600                 return IntPtrType ();
 601         default:
 602                 g_assert_not_reached ();
 603                 return NULL;
 604         }
 605 }
 606
 607 /*
 608  * ovf_op_to_intrins:
 609  *
 610  *   Return the LLVM intrinsics corresponding to the overflow opcode OPCODE.
 611  */
 612 static const char*
 613 ovf_op_to_intrins (int opcode)
 614 {
 615         switch (opcode) {
 616         case OP_IADD_OVF:
 617                 return "llvm.sadd.with.overflow.i32";
 618         case OP_IADD_OVF_UN:
 619                 return "llvm.uadd.with.overflow.i32";
 620         case OP_ISUB_OVF:
 621                 return "llvm.ssub.with.overflow.i32";
 622         case OP_ISUB_OVF_UN:
 623                 return "llvm.usub.with.overflow.i32";
 624         case OP_IMUL_OVF:
 625                 return "llvm.smul.with.overflow.i32";
 626         case OP_IMUL_OVF_UN:
 627                 return "llvm.umul.with.overflow.i32";
 628         case OP_LADD_OVF:
 629                 return "llvm.sadd.with.overflow.i64";
 630         case OP_LADD_OVF_UN:
 631                 return "llvm.uadd.with.overflow.i64";
 632         case OP_LSUB_OVF:
 633                 return "llvm.ssub.with.overflow.i64";
 634         case OP_LSUB_OVF_UN:
 635                 return "llvm.usub.with.overflow.i64";
 636         case OP_LMUL_OVF:
 637                 return "llvm.smul.with.overflow.i64";
 638         case OP_LMUL_OVF_UN:
 639                 return "llvm.umul.with.overflow.i64";
 640         default:
 641                 g_assert_not_reached ();
 642                 return NULL;
 643         }
 644 }
 645
 646 static const char*
 647 simd_op_to_intrins (int opcode)
 648 {
 649         switch (opcode) {
 650 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 651         case OP_MINPD:
 652                 return "llvm.x86.sse2.min.pd";
 653         case OP_MINPS:
 654                 return "llvm.x86.sse.min.ps";
 655         case OP_PMIND_UN:
 656                 return "llvm.x86.sse41.pminud";
 657         case OP_PMINW_UN:
 658                 return "llvm.x86.sse41.pminuw";
 659         case OP_PMINB_UN:
 660                 return "llvm.x86.sse2.pminu.b";
 661         case OP_PMINW:
 662                 return "llvm.x86.sse2.pmins.w";
 663         case OP_MAXPD:
 664                 return "llvm.x86.sse2.max.pd";
 665         case OP_MAXPS:
 666                 return "llvm.x86.sse.max.ps";
 667         case OP_HADDPD:
 668                 return "llvm.x86.sse3.hadd.pd";
 669         case OP_HADDPS:
 670                 return "llvm.x86.sse3.hadd.ps";
 671         case OP_HSUBPD:
 672                 return "llvm.x86.sse3.hsub.pd";
 673         case OP_HSUBPS:
 674                 return "llvm.x86.sse3.hsub.ps";
 675         case OP_PMAXD_UN:
 676                 return "llvm.x86.sse41.pmaxud";
 677         case OP_PMAXW_UN:
 678                 return "llvm.x86.sse41.pmaxuw";
 679         case OP_PMAXB_UN:
 680                 return "llvm.x86.sse2.pmaxu.b";
 681         case OP_ADDSUBPS:
 682                 return "llvm.x86.sse3.addsub.ps";
 683         case OP_ADDSUBPD:
 684                 return "llvm.x86.sse3.addsub.pd";
 685         case OP_EXTRACT_MASK:
 686                 return "llvm.x86.sse2.pmovmskb.128";
 687         case OP_PSHRW:
 688         case OP_PSHRW_REG:
 689                 return "llvm.x86.sse2.psrli.w";
 690         case OP_PSHRD:
 691         case OP_PSHRD_REG:
 692                 return "llvm.x86.sse2.psrli.d";
 693         case OP_PSHRQ:
 694         case OP_PSHRQ_REG:
 695                 return "llvm.x86.sse2.psrli.q";
 696         case OP_PSHLW:
 697         case OP_PSHLW_REG:
 698                 return "llvm.x86.sse2.pslli.w";
 699         case OP_PSHLD:
 700         case OP_PSHLD_REG:
 701                 return "llvm.x86.sse2.pslli.d";
 702         case OP_PSHLQ:
 703         case OP_PSHLQ_REG:
 704                 return "llvm.x86.sse2.pslli.q";
 705         case OP_PSARW:
 706         case OP_PSARW_REG:
 707                 return "llvm.x86.sse2.psrai.w";
 708         case OP_PSARD:
 709         case OP_PSARD_REG:
 710                 return "llvm.x86.sse2.psrai.d";
 711         case OP_PADDB_SAT:
 712                 return "llvm.x86.sse2.padds.b";
 713         case OP_PADDW_SAT:
 714                 return "llvm.x86.sse2.padds.w";
 715         case OP_PSUBB_SAT:
 716                 return "llvm.x86.sse2.psubs.b";
 717         case OP_PSUBW_SAT:
 718                 return "llvm.x86.sse2.psubs.w";
 719         case OP_PADDB_SAT_UN:
 720                 return "llvm.x86.sse2.paddus.b";
 721         case OP_PADDW_SAT_UN:
 722                 return "llvm.x86.sse2.paddus.w";
 723         case OP_PSUBB_SAT_UN:
 724                 return "llvm.x86.sse2.psubus.b";
 725         case OP_PSUBW_SAT_UN:
 726                 return "llvm.x86.sse2.psubus.w";
 727         case OP_PAVGB_UN:
 728                 return "llvm.x86.sse2.pavg.b";
 729         case OP_PAVGW_UN:
 730                 return "llvm.x86.sse2.pavg.w";
 731         case OP_SQRTPS:
 732                 return "llvm.x86.sse.sqrt.ps";
 733         case OP_SQRTPD:
 734                 return "llvm.x86.sse2.sqrt.pd";
 735         case OP_RSQRTPS:
 736                 return "llvm.x86.sse.rsqrt.ps";
 737         case OP_RCPPS:
 738                 return "llvm.x86.sse.rcp.ps";
 739         case OP_CVTDQ2PD:
 740                 return "llvm.x86.sse2.cvtdq2pd";
 741         case OP_CVTDQ2PS:
 742                 return "llvm.x86.sse2.cvtdq2ps";
 743         case OP_CVTPD2DQ:
 744                 return "llvm.x86.sse2.cvtpd2dq";
 745         case OP_CVTPS2DQ:
 746                 return "llvm.x86.sse2.cvtps2dq";
 747         case OP_CVTPD2PS:
 748                 return "llvm.x86.sse2.cvtpd2ps";
 749         case OP_CVTPS2PD:
 750                 return "llvm.x86.sse2.cvtps2pd";
 751         case OP_CVTTPD2DQ:
 752                 return "llvm.x86.sse2.cvttpd2dq";
 753         case OP_CVTTPS2DQ:
 754                 return "llvm.x86.sse2.cvttps2dq";
 755         case OP_COMPPS:
 756                 return "llvm.x86.sse.cmp.ps";
 757         case OP_COMPPD:
 758                 return "llvm.x86.sse2.cmp.pd";
 759         case OP_PACKW:
 760                 return "llvm.x86.sse2.packsswb.128";
 761         case OP_PACKD:
 762                 return "llvm.x86.sse2.packssdw.128";
 763         case OP_PACKW_UN:
 764                 return "llvm.x86.sse2.packuswb.128";
 765         case OP_PACKD_UN:
 766                 return "llvm.x86.sse41.packusdw";
 767         case OP_PMULW_HIGH:
 768                 return "llvm.x86.sse2.pmulh.w";
 769         case OP_PMULW_HIGH_UN:
 770                 return "llvm.x86.sse2.pmulhu.w";
 771 #endif
 772         default:
 773                 g_assert_not_reached ();
 774                 return NULL;
 775         }
 776 }
 777
 778 static LLVMTypeRef
 779 simd_op_to_llvm_type (int opcode)
 780 {
 781 #if defined(TARGET_X86) || defined(TARGET_AMD64)
 782         switch (opcode) {
 783         case OP_EXTRACT_R8:
 784         case OP_EXPAND_R8:
 785                 return type_to_simd_type (MONO_TYPE_R8);
 786         case OP_EXTRACT_I8:
 787         case OP_EXPAND_I8:
 788                 return type_to_simd_type (MONO_TYPE_I8);
 789         case OP_EXTRACT_I4:
 790         case OP_EXPAND_I4:
 791                 return type_to_simd_type (MONO_TYPE_I4);
 792         case OP_EXTRACT_I2:
 793         case OP_EXTRACT_U2:
 794         case OP_EXTRACTX_U2:
 795         case OP_EXPAND_I2:
 796                 return type_to_simd_type (MONO_TYPE_I2);
 797         case OP_EXTRACT_I1:
 798         case OP_EXTRACT_U1:
 799         case OP_EXPAND_I1:
 800                 return type_to_simd_type (MONO_TYPE_I1);
 801         case OP_EXPAND_R4:
 802                 return type_to_simd_type (MONO_TYPE_R4);
 803         case OP_CVTDQ2PD:
 804         case OP_CVTDQ2PS:
 805                 return type_to_simd_type (MONO_TYPE_I4);
 806         case OP_CVTPD2DQ:
 807         case OP_CVTPD2PS:
 808         case OP_CVTTPD2DQ:
 809                 return type_to_simd_type (MONO_TYPE_R8);
 810         case OP_CVTPS2DQ:
 811         case OP_CVTPS2PD:
 812         case OP_CVTTPS2DQ:
 813                 return type_to_simd_type (MONO_TYPE_R4);
 814         case OP_EXTRACT_MASK:
 815                 return type_to_simd_type (MONO_TYPE_I1);
 816         case OP_SQRTPS:
 817         case OP_RSQRTPS:
 818         case OP_RCPPS:
 819         case OP_DUPPS_LOW:
 820         case OP_DUPPS_HIGH:
 821                 return type_to_simd_type (MONO_TYPE_R4);
 822         case OP_SQRTPD:
 823         case OP_DUPPD:
 824                 return type_to_simd_type (MONO_TYPE_R8);
 825         default:
 826                 g_assert_not_reached ();
 827                 return NULL;
 828         }
 829 #else
 830         return NULL;
 831 #endif
 832 }
 833
 834 /*
 835  * get_bb:
 836  *
 837  *   Return the LLVM basic block corresponding to BB.
 838  */
 839 static LLVMBasicBlockRef
 840 get_bb (EmitContext *ctx, MonoBasicBlock *bb)
 841 {
 842         char bb_name [128];
 843
 844         if (ctx->bblocks [bb->block_num].bblock == NULL) {
 845                 if (bb->flags & BB_EXCEPTION_HANDLER) {
 846                         int clause_index = (mono_get_block_region_notry (ctx->cfg, bb->region) >> 8) - 1;
 847                         sprintf (bb_name, "EH_CLAUSE%d_BB%d", clause_index, bb->block_num);
 848                 } else {
 849                         sprintf (bb_name, "BB%d", bb->block_num);
 850                 }
 851
 852                 ctx->bblocks [bb->block_num].bblock = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
 853                 ctx->bblocks [bb->block_num].end_bblock = ctx->bblocks [bb->block_num].bblock;
 854         }
 855
 856         return ctx->bblocks [bb->block_num].bblock;
 857 }
 858
 859 /*
 860  * get_end_bb:
 861  *
 862  *   Return the last LLVM bblock corresponding to BB.
 863  * This might not be equal to the bb returned by get_bb () since we need to generate
 864  * multiple LLVM bblocks for a mono bblock to handle throwing exceptions.
 865  */
 866 static LLVMBasicBlockRef
 867 get_end_bb (EmitContext *ctx, MonoBasicBlock *bb)
 868 {
 869         get_bb (ctx, bb);
 870         return ctx->bblocks [bb->block_num].end_bblock;
 871 }
 872
 873 static LLVMBasicBlockRef
 874 gen_bb (EmitContext *ctx, const char *prefix)
 875 {
 876         char bb_name [128];
 877
 878         sprintf (bb_name, "%s%d", prefix, ++ ctx->ex_index);
 879         return LLVMAppendBasicBlock (ctx->lmethod, bb_name);
 880 }
 881
 882 /*
 883  * resolve_patch:
 884  *
 885  *   Return the target of the patch identified by TYPE and TARGET.
 886  */
 887 static gpointer
 888 resolve_patch (MonoCompile *cfg, MonoJumpInfoType type, gconstpointer target)
 889 {
 890         MonoJumpInfo ji;
 891
 892         memset (&ji, 0, sizeof (ji));
 893         ji.type = type;
 894         ji.data.target = target;
 895
 896         return mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
 897 }
 898
 899 /*
 900  * convert_full:
 901  *
 902  *   Emit code to convert the LLVM value V to DTYPE.
 903  */
 904 static LLVMValueRef
 905 convert_full (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype, gboolean is_unsigned)
 906 {
 907         LLVMTypeRef stype = LLVMTypeOf (v);
 908
 909         if (stype != dtype) {
 910                 gboolean ext = FALSE;
 911
 912                 /* Extend */
 913                 if (dtype == LLVMInt64Type () && (stype == LLVMInt32Type () || stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
 914                         ext = TRUE;
 915                 else if (dtype == LLVMInt32Type () && (stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
 916                         ext = TRUE;
 917                 else if (dtype == LLVMInt16Type () && (stype == LLVMInt8Type ()))
 918                         ext = TRUE;
 919
 920                 if (ext)
 921                         return is_unsigned ? LLVMBuildZExt (ctx->builder, v, dtype, "") : LLVMBuildSExt (ctx->builder, v, dtype, "");
 922
 923                 if (dtype == LLVMDoubleType () && stype == LLVMFloatType ())
 924                         return LLVMBuildFPExt (ctx->builder, v, dtype, "");
 925
 926                 /* Trunc */
 927                 if (stype == LLVMInt64Type () && (dtype == LLVMInt32Type () || dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
 928                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 929                 if (stype == LLVMInt32Type () && (dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
 930                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 931                 if (stype == LLVMInt16Type () && dtype == LLVMInt8Type ())
 932                         return LLVMBuildTrunc (ctx->builder, v, dtype, "");
 933                 if (stype == LLVMDoubleType () && dtype == LLVMFloatType ())
 934                         return LLVMBuildFPTrunc (ctx->builder, v, dtype, "");
 935
 936                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind && LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
 937                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 938                 if (LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
 939                         return LLVMBuildIntToPtr (ctx->builder, v, dtype, "");
 940                 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind)
 941                         return LLVMBuildPtrToInt (ctx->builder, v, dtype, "");
 942
 943                 if (mono_arch_is_soft_float ()) {
 944                         if (stype == LLVMInt32Type () && dtype == LLVMFloatType ())
 945                                 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 946                         if (stype == LLVMInt32Type () && dtype == LLVMDoubleType ())
 947                                 return LLVMBuildBitCast (ctx->builder, LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), ""), dtype, "");
 948                 }
 949
 950                 if (LLVMGetTypeKind (stype) == LLVMVectorTypeKind && LLVMGetTypeKind (dtype) == LLVMVectorTypeKind)
 951                         return LLVMBuildBitCast (ctx->builder, v, dtype, "");
 952
 953                 LLVMDumpValue (v);
 954                 LLVMDumpValue (LLVMConstNull (dtype));
 955                 g_assert_not_reached ();
 956                 return NULL;
 957         } else {
 958                 return v;
 959         }
 960 }
 961
 962 static LLVMValueRef
 963 convert (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype)
 964 {
 965         return convert_full (ctx, v, dtype, FALSE);
 966 }
 967
 968 /*
 969  * emit_volatile_load:
 970  *
 971  *   If vreg is volatile, emit a load from its address.
 972  */
 973 static LLVMValueRef
 974 emit_volatile_load (EmitContext *ctx, int vreg)
 975 {
 976         MonoType *t;
 977
 978         LLVMValueRef v = LLVMBuildLoad (ctx->builder, ctx->addresses [vreg], "");
 979         t = ctx->vreg_cli_types [vreg];
 980         if (t && !t->byref) {
 981                 /*
 982                  * Might have to zero extend since llvm doesn't have
 983                  * unsigned types.
 984                  */
 985                 if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_U2 || t->type == MONO_TYPE_CHAR || t->type == MONO_TYPE_BOOLEAN)
 986                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt32Type (), "");
 987                 else if (t->type == MONO_TYPE_U8)
 988                         v = LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), "");
 989         }
 990
 991         return v;
 992 }
 993
 994 /*
 995  * emit_volatile_store:
 996  *
 997  *   If VREG is volatile, emit a store from its value to its address.
 998  */
 999 static void
1000 emit_volatile_store (EmitContext *ctx, int vreg)
1001 {
1002         MonoInst *var = get_vreg_to_inst (ctx->cfg, vreg);
1003
1004         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
1005                 g_assert (ctx->addresses [vreg]);
1006                 LLVMBuildStore (ctx->builder, convert (ctx, ctx->values [vreg], type_to_llvm_type (ctx, var->inst_vtype)), ctx->addresses [vreg]);
1007         }
1008 }
1009
1010 typedef struct {
1011         /*
1012          * Maps parameter indexes in the original signature to parameter indexes
1013          * in the LLVM signature.
1014          */
1015         int *pindexes;
1016         /* The indexes of various special arguments in the LLVM signature */
1017         int vret_arg_pindex, this_arg_pindex, rgctx_arg_pindex, imt_arg_pindex;
1018 } LLVMSigInfo;
1019
1020 /*
1021  * sig_to_llvm_sig_full:
1022  *
1023  *   Return the LLVM signature corresponding to the mono signature SIG using the
1024  * calling convention information in CINFO. Return parameter mapping information in SINFO.
1025  */
1026 static LLVMTypeRef
1027 sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo *cinfo,
1028                                           LLVMSigInfo *sinfo)
1029 {
1030         LLVMTypeRef ret_type;
1031         LLVMTypeRef *param_types = NULL;
1032         LLVMTypeRef res;
1033         int i, j, pindex, vret_arg_pindex = 0;
1034         int *pindexes;
1035         gboolean vretaddr = FALSE;
1036
1037         if (sinfo)
1038                 memset (sinfo, 0, sizeof (LLVMSigInfo));
1039
1040         ret_type = type_to_llvm_type (ctx, sig->ret);
1041         CHECK_FAILURE (ctx);
1042
1043         if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
1044                 /* LLVM models this by returning an aggregate value */
1045                 if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgNone) {
1046                         LLVMTypeRef members [2];
1047
1048                         members [0] = IntPtrType ();
1049                         ret_type = LLVMStructType (members, 1, FALSE);
1050                 } else {
1051                         g_assert_not_reached ();
1052                 }
1053         } else if (cinfo && mini_type_is_vtype (ctx->cfg, sig->ret)) {
1054                 g_assert (cinfo->ret.storage == LLVMArgVtypeRetAddr);
1055                 vretaddr = TRUE;
1056                 ret_type = LLVMVoidType ();
1057         }
1058
1059         pindexes = g_new0 (int, sig->param_count);
1060         param_types = g_new0 (LLVMTypeRef, (sig->param_count * 2) + 3);
1061         pindex = 0;
1062         if (cinfo && cinfo->rgctx_arg) {
1063                 if (sinfo)
1064                         sinfo->rgctx_arg_pindex = pindex;
1065                 param_types [pindex] = IntPtrType ();
1066                 pindex ++;
1067         }
1068         if (cinfo && cinfo->imt_arg) {
1069                 if (sinfo)
1070                         sinfo->imt_arg_pindex = pindex;
1071                 param_types [pindex] = IntPtrType ();
1072                 pindex ++;
1073         }
1074         if (vretaddr) {
1075                 /* Compute the index in the LLVM signature where the vret arg needs to be passed */
1076                 vret_arg_pindex = pindex;
1077                 if (cinfo->vret_arg_index == 1) {
1078                         /* Add the slots consumed by the first argument */
1079                         LLVMArgInfo *ainfo = &cinfo->args [0];
1080                         switch (ainfo->storage) {
1081                         case LLVMArgVtypeInReg:
1082                                 for (j = 0; j < 2; ++j) {
1083                                         if (ainfo->pair_storage [j] == LLVMArgInIReg)
1084                                                 vret_arg_pindex ++;
1085                                 }
1086                                 break;
1087                         default:
1088                                 vret_arg_pindex ++;
1089                         }
1090                 }
1091
1092                 if (sinfo)
1093                         sinfo->vret_arg_pindex = vret_arg_pindex;
1094         }
1095
1096         if (vretaddr && vret_arg_pindex == pindex)
1097                 param_types [pindex ++] = IntPtrType ();
1098         if (sig->hasthis) {
1099                 if (sinfo)
1100                         sinfo->this_arg_pindex = pindex;
1101                 param_types [pindex ++] = IntPtrType ();
1102         }
1103         if (vretaddr && vret_arg_pindex == pindex)
1104                 param_types [pindex ++] = IntPtrType ();
1105         for (i = 0; i < sig->param_count; ++i) {
1106                 if (vretaddr && vret_arg_pindex == pindex)
1107                         param_types [pindex ++] = IntPtrType ();
1108                 pindexes [i] = pindex;
1109                 if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeInReg) {
1110                         for (j = 0; j < 2; ++j) {
1111                                 switch (cinfo->args [i + sig->hasthis].pair_storage [j]) {
1112                                 case LLVMArgInIReg:
1113                                         param_types [pindex ++] = LLVMIntType (sizeof (gpointer) * 8);
1114                                         break;
1115                                 case LLVMArgNone:
1116                                         break;
1117                                 default:
1118                                         g_assert_not_reached ();
1119                                 }
1120                         }
1121                 } else if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal) {
1122                         param_types [pindex] = type_to_llvm_arg_type (ctx, sig->params [i]);
1123                         CHECK_FAILURE (ctx);
1124                         param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1125                         pindex ++;
1126                 } else {
1127                         param_types [pindex ++] = type_to_llvm_arg_type (ctx, sig->params [i]);
1128                 }
1129         }
1130         if (vretaddr && vret_arg_pindex == pindex)
1131                 param_types [pindex ++] = IntPtrType ();
1132
1133         CHECK_FAILURE (ctx);
1134
1135         res = LLVMFunctionType (ret_type, param_types, pindex, FALSE);
1136         g_free (param_types);
1137
1138         if (sinfo) {
1139                 sinfo->pindexes = pindexes;
1140         } else {
1141                 g_free (pindexes);
1142         }
1143
1144         return res;
1145
1146  FAILURE:
1147         g_free (param_types);
1148
1149         return NULL;
1150 }
1151
1152 static LLVMTypeRef
1153 sig_to_llvm_sig (EmitContext *ctx, MonoMethodSignature *sig)
1154 {
1155         return sig_to_llvm_sig_full (ctx, sig, NULL, NULL);
1156 }
1157
1158 /*
1159  * LLVMFunctionType1:
1160  *
1161  *   Create an LLVM function type from the arguments.
1162  */
1163 static G_GNUC_UNUSED LLVMTypeRef
1164 LLVMFunctionType1(LLVMTypeRef ReturnType,
1165                                   LLVMTypeRef ParamType1,
1166                                   int IsVarArg)
1167 {
1168         LLVMTypeRef param_types [1];
1169
1170         param_types [0] = ParamType1;
1171
1172         return LLVMFunctionType (ReturnType, param_types, 1, IsVarArg);
1173 }
1174
1175 /*
1176  * LLVMFunctionType2:
1177  *
1178  *   Create an LLVM function type from the arguments.
1179  */
1180 static G_GNUC_UNUSED LLVMTypeRef
1181 LLVMFunctionType2(LLVMTypeRef ReturnType,
1182                                   LLVMTypeRef ParamType1,
1183                                   LLVMTypeRef ParamType2,
1184                                   int IsVarArg)
1185 {
1186         LLVMTypeRef param_types [2];
1187
1188         param_types [0] = ParamType1;
1189         param_types [1] = ParamType2;
1190
1191         return LLVMFunctionType (ReturnType, param_types, 2, IsVarArg);
1192 }
1193
1194 /*
1195  * LLVMFunctionType3:
1196  *
1197  *   Create an LLVM function type from the arguments.
1198  */
1199 static G_GNUC_UNUSED LLVMTypeRef
1200 LLVMFunctionType3(LLVMTypeRef ReturnType,
1201                                   LLVMTypeRef ParamType1,
1202                                   LLVMTypeRef ParamType2,
1203                                   LLVMTypeRef ParamType3,
1204                                   int IsVarArg)
1205 {
1206         LLVMTypeRef param_types [3];
1207
1208         param_types [0] = ParamType1;
1209         param_types [1] = ParamType2;
1210         param_types [2] = ParamType3;
1211
1212         return LLVMFunctionType (ReturnType, param_types, 3, IsVarArg);
1213 }
1214
1215 /*
1216  * create_builder:
1217  *
1218  *   Create an LLVM builder and remember it so it can be freed later.
1219  */
1220 static LLVMBuilderRef
1221 create_builder (EmitContext *ctx)
1222 {
1223         LLVMBuilderRef builder = LLVMCreateBuilder ();
1224
1225         ctx->builders = g_slist_prepend_mempool (ctx->cfg->mempool, ctx->builders, builder);
1226
1227         return builder;
1228 }
1229
1230 static LLVMValueRef
1231 get_plt_entry (EmitContext *ctx, LLVMTypeRef llvm_sig, MonoJumpInfoType type, gconstpointer data)
1232 {
1233         char *callee_name = mono_aot_get_plt_symbol (type, data);
1234         LLVMValueRef callee;
1235
1236         if (!callee_name)
1237                 return NULL;
1238
1239         if (ctx->cfg->compile_aot)
1240                 /* Add a patch so referenced wrappers can be compiled in full aot mode */
1241                 mono_add_patch_info (ctx->cfg, 0, type, data);
1242
1243         // FIXME: Locking
1244         callee = g_hash_table_lookup (ctx->lmodule->plt_entries, callee_name);
1245         if (!callee) {
1246                 callee = LLVMAddFunction (ctx->module, callee_name, llvm_sig);
1247
1248                 LLVMSetVisibility (callee, LLVMHiddenVisibility);
1249
1250                 g_hash_table_insert (ctx->lmodule->plt_entries, (char*)callee_name, callee);
1251         }
1252
1253         return callee;
1254 }
1255
1256 static int
1257 get_handler_clause (MonoCompile *cfg, MonoBasicBlock *bb)
1258 {
1259         MonoMethodHeader *header = cfg->header;
1260         MonoExceptionClause *clause;
1261         int i;
1262
1263         /* Directly */
1264         if (bb->region != -1 && MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))
1265                 return (bb->region >> 8) - 1;
1266
1267         /* Indirectly */
1268         for (i = 0; i < header->num_clauses; ++i) {
1269                 clause = &header->clauses [i];
1270
1271                 if (MONO_OFFSET_IN_CLAUSE (clause, bb->real_offset) && clause->flags == MONO_EXCEPTION_CLAUSE_NONE)
1272                         return i;
1273         }
1274
1275         return -1;
1276 }
1277
1278 static void
1279 set_metadata_flag (LLVMValueRef v, const char *flag_name)
1280 {
1281         LLVMValueRef md_arg;
1282         int md_kind;
1283
1284         md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1285         md_arg = LLVMMDString ("mono", 4);
1286         LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1287 }
1288
1289 static void
1290 set_invariant_load_flag (LLVMValueRef v)
1291 {
1292         LLVMValueRef md_arg;
1293         int md_kind;
1294         const char *flag_name;
1295
1296         // FIXME: Cache this
1297         flag_name = "invariant.load";
1298         md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1299         md_arg = LLVMMDString ("<index>", strlen ("<index>"));
1300         LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1301 }
1302
1303 /*
1304  * emit_call:
1305  *
1306  *   Emit an LLVM call or invoke instruction depending on whenever the call is inside
1307  * a try region.
1308  */
1309 static LLVMValueRef
1310 emit_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, LLVMValueRef callee, LLVMValueRef *args, int pindex)
1311 {
1312         MonoCompile *cfg = ctx->cfg;
1313         LLVMValueRef lcall;
1314         LLVMBuilderRef builder = *builder_ref;
1315         int clause_index;
1316
1317         clause_index = get_handler_clause (cfg, bb);
1318
1319         if (clause_index != -1) {
1320                 MonoMethodHeader *header = cfg->header;
1321                 MonoExceptionClause *ec = &header->clauses [clause_index];
1322                 MonoBasicBlock *tblock;
1323                 LLVMBasicBlockRef ex_bb, noex_bb;
1324
1325                 /*
1326                  * Have to use an invoke instead of a call, branching to the
1327                  * handler bblock of the clause containing this bblock.
1328                  */
1329
1330                 g_assert (ec->flags == MONO_EXCEPTION_CLAUSE_NONE || ec->flags == MONO_EXCEPTION_CLAUSE_FINALLY);
1331
1332                 tblock = cfg->cil_offset_to_bb [ec->handler_offset];
1333                 g_assert (tblock);
1334
1335                 ctx->bblocks [tblock->block_num].invoke_target = TRUE;
1336
1337                 ex_bb = get_bb (ctx, tblock);
1338
1339                 noex_bb = gen_bb (ctx, "NOEX_BB");
1340
1341                 /* Use an invoke */
1342                 lcall = LLVMBuildInvoke (builder, callee, args, pindex, noex_bb, ex_bb, "");
1343
1344                 builder = ctx->builder = create_builder (ctx);
1345                 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1346
1347                 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1348         } else {
1349                 lcall = LLVMBuildCall (builder, callee, args, pindex, "");
1350                 ctx->builder = builder;
1351         }
1352
1353         *builder_ref = ctx->builder;
1354
1355         return lcall;
1356 }
1357
1358 static LLVMValueRef
1359 emit_load (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef addr, const char *name, gboolean is_faulting)
1360 {
1361         const char *intrins_name;
1362         LLVMValueRef args [16], res;
1363         LLVMTypeRef addr_type;
1364
1365         if (is_faulting && bb->region != -1) {
1366                 /*
1367                  * We handle loads which can fault by calling a mono specific intrinsic
1368                  * using an invoke, so they are handled properly inside try blocks.
1369                  * We can't use this outside clauses, since LLVM optimizes intrinsics which
1370                  * are marked with IntrReadArgMem.
1371                  */
1372                 switch (size) {
1373                 case 1:
1374                         intrins_name = "llvm.mono.load.i8.p0i8";
1375                         break;
1376                 case 2:
1377                         intrins_name = "llvm.mono.load.i16.p0i16";
1378                         break;
1379                 case 4:
1380                         intrins_name = "llvm.mono.load.i32.p0i32";
1381                         break;
1382                 case 8:
1383                         intrins_name = "llvm.mono.load.i64.p0i64";
1384                         break;
1385                 default:
1386                         g_assert_not_reached ();
1387                 }
1388
1389                 addr_type = LLVMTypeOf (addr);
1390                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0) || addr_type == LLVMPointerType (LLVMFloatType (), 0))
1391                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1392
1393                 args [0] = addr;
1394                 args [1] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1395                 args [2] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1396                 res = emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 3);
1397
1398                 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0))
1399                         res = LLVMBuildBitCast (*builder_ref, res, LLVMDoubleType (), "");
1400                 else if (addr_type == LLVMPointerType (LLVMFloatType (), 0))
1401                         res = LLVMBuildBitCast (*builder_ref, res, LLVMFloatType (), "");
1402
1403                 return res;
1404         } else {
1405                 LLVMValueRef res;
1406
1407                 /*
1408                  * We emit volatile loads for loads which can fault, because otherwise
1409                  * LLVM will generate invalid code when encountering a load from a
1410                  * NULL address.
1411                  */
1412                  res = mono_llvm_build_load (*builder_ref, addr, name, is_faulting);
1413
1414                  /* Mark it with a custom metadata */
1415                  /*
1416                  if (is_faulting)
1417                          set_metadata_flag (res, "mono.faulting.load");
1418                  */
1419
1420                  return res;
1421         }
1422 }
1423
1424 static void
1425 emit_store (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef value, LLVMValueRef addr, gboolean is_faulting)
1426 {
1427         const char *intrins_name;
1428         LLVMValueRef args [16];
1429
1430         if (is_faulting && bb->region != -1) {
1431                 switch (size) {
1432                 case 1:
1433                         intrins_name = "llvm.mono.store.i8.p0i8";
1434                         break;
1435                 case 2:
1436                         intrins_name = "llvm.mono.store.i16.p0i16";
1437                         break;
1438                 case 4:
1439                         intrins_name = "llvm.mono.store.i32.p0i32";
1440                         break;
1441                 case 8:
1442                         intrins_name = "llvm.mono.store.i64.p0i64";
1443                         break;
1444                 default:
1445                         g_assert_not_reached ();
1446                 }
1447
1448                 if (LLVMTypeOf (value) == LLVMDoubleType () || LLVMTypeOf (value) == LLVMFloatType ()) {
1449                         value = LLVMBuildBitCast (*builder_ref, value, LLVMIntType (size * 8), "");
1450                         addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1451                 }
1452
1453                 args [0] = value;
1454                 args [1] = addr;
1455                 args [2] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1456                 args [3] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1457                 emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 4);
1458         } else {
1459                 LLVMBuildStore (*builder_ref, value, addr);
1460         }
1461 }
1462
1463 /*
1464  * emit_cond_system_exception:
1465  *
1466  *   Emit code to throw the exception EXC_TYPE if the condition CMP is false.
1467  * Might set the ctx exception.
1468  */
1469 static void
1470 emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *exc_type, LLVMValueRef cmp)
1471 {
1472         LLVMBasicBlockRef ex_bb, noex_bb;
1473         LLVMBuilderRef builder;
1474         MonoClass *exc_class;
1475         LLVMValueRef args [2];
1476
1477         ex_bb = gen_bb (ctx, "EX_BB");
1478         noex_bb = gen_bb (ctx, "NOEX_BB");
1479
1480         LLVMBuildCondBr (ctx->builder, cmp, ex_bb, noex_bb);
1481
1482         exc_class = mono_class_from_name (mono_get_corlib (), "System", exc_type);
1483         g_assert (exc_class);
1484
1485         /* Emit exception throwing code */
1486         builder = create_builder (ctx);
1487         LLVMPositionBuilderAtEnd (builder, ex_bb);
1488
1489         if (!ctx->lmodule->throw_corlib_exception) {
1490                 LLVMValueRef callee;
1491                 LLVMTypeRef sig;
1492                 const char *icall_name;
1493
1494                 MonoMethodSignature *throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 2);
1495                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
1496                 throw_sig->params [0] = &mono_get_int32_class ()->byval_arg;
1497                 icall_name = "llvm_throw_corlib_exception_abs_trampoline";
1498                 throw_sig->params [1] = &mono_get_intptr_class ()->byval_arg;
1499                 sig = sig_to_llvm_sig (ctx, throw_sig);
1500
1501                 if (ctx->cfg->compile_aot) {
1502                         callee = get_plt_entry (ctx, sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
1503                 } else {
1504                         callee = LLVMAddFunction (ctx->module, "llvm_throw_corlib_exception_trampoline", sig_to_llvm_sig (ctx, throw_sig));
1505
1506                         /*
1507                          * Differences between the LLVM/non-LLVM throw corlib exception trampoline:
1508                          * - On x86, LLVM generated code doesn't push the arguments
1509                          * - When using the LLVM mono branch, the trampoline takes the throw address as an
1510                          *   arguments, not a pc offset.
1511                          */
1512                         LLVMAddGlobalMapping (ee, callee, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
1513                 }
1514
1515                 mono_memory_barrier ();
1516                 ctx->lmodule->throw_corlib_exception = callee;
1517         }
1518
1519         if (IS_TARGET_X86)
1520                 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
1521         else
1522                 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token, FALSE);
1523
1524         /*
1525          * The LLVM mono branch contains changes so a block address can be passed as an
1526          * argument to a call.
1527          */
1528         args [1] = LLVMBuildPtrToInt (builder, LLVMBlockAddress (ctx->lmethod, ex_bb), IntPtrType (), "");
1529         emit_call (ctx, bb, &builder, ctx->lmodule->throw_corlib_exception, args, 2);
1530
1531         LLVMBuildUnreachable (builder);
1532
1533         ctx->builder = create_builder (ctx);
1534         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1535
1536         ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1537
1538         ctx->ex_index ++;
1539         return;
1540 }
1541
1542 /*
1543  * emit_reg_to_vtype:
1544  *
1545  *   Emit code to store the vtype in the registers REGS to the address ADDRESS.
1546  */
1547 static void
1548 emit_reg_to_vtype (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs)
1549 {
1550         int j, size;
1551
1552         size = get_vtype_size (t);
1553
1554         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1555                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1556         }
1557
1558         for (j = 0; j < 2; ++j) {
1559                 LLVMValueRef index [2], addr;
1560                 int part_size = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1561                 LLVMTypeRef part_type;
1562
1563                 if (ainfo->pair_storage [j] == LLVMArgNone)
1564                         continue;
1565
1566                 part_type = LLVMIntType (part_size * 8);
1567                 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1568                         index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1569                         addr = LLVMBuildGEP (builder, address, index, 1, "");
1570                 } else {
1571                         index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1572                         index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1573                         addr = LLVMBuildGEP (builder, address, index, 2, "");
1574                 }
1575                 switch (ainfo->pair_storage [j]) {
1576                 case LLVMArgInIReg:
1577                         LLVMBuildStore (builder, convert (ctx, regs [j], part_type), LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (part_type, 0), ""));
1578                         break;
1579                 case LLVMArgNone:
1580                         break;
1581                 default:
1582                         g_assert_not_reached ();
1583                 }
1584
1585                 size -= sizeof (gpointer);
1586         }
1587 }
1588
1589 /*
1590  * emit_vtype_to_reg:
1591  *
1592  *   Emit code to load a vtype at address ADDRESS into registers. Store the registers
1593  * into REGS, and the number of registers into NREGS.
1594  */
1595 static void
1596 emit_vtype_to_reg (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs, guint32 *nregs)
1597 {
1598         int pindex = 0;
1599         int j, size;
1600
1601         size = get_vtype_size (t);
1602
1603         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1604                 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1605         }
1606
1607         for (j = 0; j < 2; ++j) {
1608                 LLVMValueRef index [2], addr;
1609                 int partsize = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1610
1611                 if (ainfo->pair_storage [j] == LLVMArgNone)
1612                         continue;
1613
1614                 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1615                         index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1616                         addr = LLVMBuildGEP (builder, address, index, 1, "");
1617                 } else {
1618                         index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1619                         index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1620                         addr = LLVMBuildGEP (builder, address, index, 2, "");
1621                 }
1622                 switch (ainfo->pair_storage [j]) {
1623                 case LLVMArgInIReg:
1624                         regs [pindex ++] = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (LLVMIntType (partsize * 8), 0), ""), ""), IntPtrType ());
1625                         break;
1626                 case LLVMArgNone:
1627                         break;
1628                 default:
1629                         g_assert_not_reached ();
1630                 }
1631                 size -= sizeof (gpointer);
1632         }
1633
1634         *nregs = pindex;
1635 }
1636
1637 static LLVMValueRef
1638 build_alloca (EmitContext *ctx, MonoType *t)
1639 {
1640         MonoClass *k = mono_class_from_mono_type (t);
1641         int align;
1642
1643         if (MONO_CLASS_IS_SIMD (ctx->cfg, k))
1644                 align = 16;
1645         else
1646                 align = mono_class_min_align (k);
1647
1648         /* Sometimes align is not a power of 2 */
1649         while (mono_is_power_of_two (align) == -1)
1650                 align ++;
1651
1652         /*
1653          * Have to place all alloca's at the end of the entry bb, since otherwise they would
1654          * get executed every time control reaches them.
1655          */
1656         LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca);
1657
1658         ctx->last_alloca = mono_llvm_build_alloca (ctx->alloca_builder, type_to_llvm_type (ctx, t), NULL, align, "");
1659         return ctx->last_alloca;
1660 }
1661
1662 /*
1663  * Put the global into the 'llvm.used' array to prevent it from being optimized away.
1664  */
1665 static void
1666 mark_as_used (LLVMModuleRef module, LLVMValueRef global)
1667 {
1668         LLVMTypeRef used_type;
1669         LLVMValueRef used, used_elem;
1670
1671         used_type = LLVMArrayType (LLVMPointerType (LLVMInt8Type (), 0), 1);
1672         used = LLVMAddGlobal (module, used_type, "llvm.used");
1673         used_elem = LLVMConstBitCast (global, LLVMPointerType (LLVMInt8Type (), 0));
1674         LLVMSetInitializer (used, LLVMConstArray (LLVMPointerType (LLVMInt8Type (), 0), &used_elem, 1));
1675         LLVMSetLinkage (used, LLVMAppendingLinkage);
1676         LLVMSetSection (used, "llvm.metadata");
1677 }
1678
1679 /*
1680  * emit_entry_bb:
1681  *
1682  *   Emit code to load/convert arguments.
1683  */
1684 static void
1685 emit_entry_bb (EmitContext *ctx, LLVMBuilderRef builder)
1686 {
1687         int i, pindex;
1688         MonoCompile *cfg = ctx->cfg;
1689         MonoMethodSignature *sig = ctx->sig;
1690         LLVMCallInfo *linfo = ctx->linfo;
1691         MonoBasicBlock *bb;
1692
1693         ctx->alloca_builder = create_builder (ctx);
1694
1695         /*
1696          * Handle indirect/volatile variables by allocating memory for them
1697          * using 'alloca', and storing their address in a temporary.
1698          */
1699         for (i = 0; i < cfg->num_varinfo; ++i) {
1700                 MonoInst *var = cfg->varinfo [i];
1701                 LLVMTypeRef vtype;
1702
1703                 if (var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) || mini_type_is_vtype (cfg, var->inst_vtype)) {
1704                         vtype = type_to_llvm_type (ctx, var->inst_vtype);
1705                         CHECK_FAILURE (ctx);
1706                         /* Could be already created by an OP_VPHI */
1707                         if (!ctx->addresses [var->dreg])
1708                                 ctx->addresses [var->dreg] = build_alloca (ctx, var->inst_vtype);
1709                         ctx->vreg_cli_types [var->dreg] = var->inst_vtype;
1710                 }
1711         }
1712
1713         for (i = 0; i < sig->param_count; ++i) {
1714                 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
1715                 int reg = cfg->args [i + sig->hasthis]->dreg;
1716
1717                 if (ainfo->storage == LLVMArgVtypeInReg) {
1718                         LLVMValueRef regs [2];
1719
1720                         /*
1721                          * Emit code to save the argument from the registers to
1722                          * the real argument.
1723                          */
1724                         pindex = ctx->pindexes [i];
1725                         regs [0] = LLVMGetParam (ctx->lmethod, pindex);
1726                         if (ainfo->pair_storage [1] != LLVMArgNone)
1727                                 regs [1] = LLVMGetParam (ctx->lmethod, pindex + 1);
1728                         else
1729                                 regs [1] = NULL;
1730
1731                         ctx->addresses [reg] = build_alloca (ctx, sig->params [i]);
1732
1733                         emit_reg_to_vtype (ctx, builder, sig->params [i], ctx->addresses [reg], ainfo, regs);
1734
1735                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1736                                 /* Treat these as normal values */
1737                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1738                         }
1739                 } else if (ainfo->storage == LLVMArgVtypeByVal) {
1740                         ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, ctx->pindexes [i]);
1741
1742                         if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1743                                 /* Treat these as normal values */
1744                                 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1745                         }
1746                 } else {
1747                         ctx->values [reg] = convert (ctx, ctx->values [reg], llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->params [i])));
1748                 }
1749         }
1750
1751         if (cfg->vret_addr)
1752                 emit_volatile_store (ctx, cfg->vret_addr->dreg);
1753         if (sig->hasthis)
1754                 emit_volatile_store (ctx, cfg->args [0]->dreg);
1755         for (i = 0; i < sig->param_count; ++i)
1756                 if (!mini_type_is_vtype (cfg, sig->params [i]))
1757                         emit_volatile_store (ctx, cfg->args [i + sig->hasthis]->dreg);
1758
1759         if (sig->hasthis && !cfg->rgctx_var && cfg->generic_sharing_context) {
1760                 LLVMValueRef this_alloc;
1761
1762                 /*
1763                  * The exception handling code needs the location where the this argument was
1764                  * stored for gshared methods. We create a separate alloca to hold it, and mark it
1765                  * with the "mono.this" custom metadata to tell llvm that it needs to save its
1766                  * location into the LSDA.
1767                  */
1768                 this_alloc = mono_llvm_build_alloca (builder, IntPtrType (), LLVMConstInt (LLVMInt32Type (), 1, FALSE), 0, "");
1769                 /* This volatile store will keep the alloca alive */
1770                 mono_llvm_build_store (builder, ctx->values [cfg->args [0]->dreg], this_alloc, TRUE);
1771
1772                 set_metadata_flag (this_alloc, "mono.this");
1773         }
1774
1775         if (cfg->rgctx_var) {
1776                 LLVMValueRef rgctx_alloc, store;
1777
1778                 /*
1779                  * We handle the rgctx arg similarly to the this pointer.
1780                  */
1781                 g_assert (ctx->addresses [cfg->rgctx_var->dreg]);
1782                 rgctx_alloc = ctx->addresses [cfg->rgctx_var->dreg];
1783                 /* This volatile store will keep the alloca alive */
1784                 store = mono_llvm_build_store (builder, ctx->rgctx_arg, rgctx_alloc, TRUE);
1785
1786                 set_metadata_flag (rgctx_alloc, "mono.this");
1787         }
1788
1789         /*
1790          * For finally clauses, create an indicator variable telling OP_ENDFINALLY whenever
1791          * it needs to continue normally, or return back to the exception handling system.
1792          */
1793         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1794                 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER))
1795                         g_hash_table_insert (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)), bb);
1796                 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER) && bb->in_scount == 0) {
1797                         char name [128];
1798                         LLVMValueRef val;
1799
1800                         sprintf (name, "finally_ind_bb%d", bb->block_num);
1801                         val = LLVMBuildAlloca (builder, LLVMInt32Type (), name);
1802                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), val);
1803
1804                         ctx->bblocks [bb->block_num].finally_ind = val;
1805
1806                         /*
1807                          * Create a new bblock which CALL_HANDLER can branch to, because branching to the
1808                          * LLVM bblock containing the call to llvm.eh.selector causes problems for the
1809                          * LLVM optimizer passes.
1810                          */
1811                         sprintf (name, "BB_%d_CALL_HANDLER_TARGET", bb->block_num);
1812                         ctx->bblocks [bb->block_num].call_handler_target_bb = LLVMAppendBasicBlock (ctx->lmethod, name);
1813                 }
1814         }
1815
1816  FAILURE:
1817         ;
1818 }
1819
1820 /* Have to export this for AOT */
1821 void
1822 mono_personality (void);
1823
1824 void
1825 mono_personality (void)
1826 {
1827         /* Not used */
1828         g_assert_not_reached ();
1829 }
1830
1831 static void
1832 process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, MonoInst *ins)
1833 {
1834         MonoCompile *cfg = ctx->cfg;
1835         LLVMModuleRef module = ctx->module;
1836         LLVMValueRef *values = ctx->values;
1837         LLVMValueRef *addresses = ctx->addresses;
1838         MonoCallInst *call = (MonoCallInst*)ins;
1839         MonoMethodSignature *sig = call->signature;
1840         LLVMValueRef callee = NULL, lcall;
1841         LLVMValueRef *args;
1842         LLVMCallInfo *cinfo;
1843         GSList *l;
1844         int i, len, nargs;
1845         gboolean vretaddr;
1846         LLVMTypeRef llvm_sig;
1847         gpointer target;
1848         gboolean virtual, calli;
1849         LLVMBuilderRef builder = *builder_ref;
1850         LLVMSigInfo sinfo;
1851
1852         if (call->signature->call_convention != MONO_CALL_DEFAULT)
1853                 LLVM_FAILURE (ctx, "non-default callconv");
1854
1855         cinfo = call->cinfo;
1856         if (call->rgctx_arg_reg)
1857                 cinfo->rgctx_arg = TRUE;
1858         if (call->imt_arg_reg)
1859                 cinfo->imt_arg = TRUE;
1860
1861         vretaddr = cinfo && cinfo->ret.storage == LLVMArgVtypeRetAddr;
1862
1863         llvm_sig = sig_to_llvm_sig_full (ctx, sig, cinfo, &sinfo);
1864         CHECK_FAILURE (ctx);
1865
1866         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);
1867         calli = (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);
1868
1869         /* FIXME: Avoid creating duplicate methods */
1870
1871         if (ins->flags & MONO_INST_HAS_METHOD) {
1872                 if (virtual) {
1873                         callee = NULL;
1874                 } else {
1875                         if (cfg->compile_aot) {
1876                                 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_METHOD, call->method);
1877                                 if (!callee)
1878                                         LLVM_FAILURE (ctx, "can't encode patch");
1879                         } else {
1880                                 callee = LLVMAddFunction (module, "", llvm_sig);
1881
1882                                 target =
1883                                         mono_create_jit_trampoline_in_domain (mono_domain_get (),
1884                                                                                                                   call->method);
1885                                 LLVMAddGlobalMapping (ee, callee, target);
1886                         }
1887                 }
1888
1889                 if (call->method && strstr (call->method->klass->name, "AsyncVoidMethodBuilder"))
1890                         /* LLVM miscompiles async methods */
1891                         LLVM_FAILURE (ctx, "#13734");
1892         } else if (calli) {
1893         } else {
1894                 MonoJitICallInfo *info = mono_find_jit_icall_by_addr (call->fptr);
1895
1896                 if (info) {
1897                         /*
1898                           MonoJumpInfo ji;
1899
1900                           memset (&ji, 0, sizeof (ji));
1901                           ji.type = MONO_PATCH_INFO_JIT_ICALL_ADDR;
1902                           ji.data.target = info->name;
1903
1904                           target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
1905                         */
1906                         if (cfg->compile_aot) {
1907                                 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_INTERNAL_METHOD, (char*)info->name);
1908                                 if (!callee)
1909                                         LLVM_FAILURE (ctx, "can't encode patch");
1910                         } else {
1911                                 callee = LLVMAddFunction (module, "", llvm_sig);
1912                                 target = (gpointer)mono_icall_get_wrapper (info);
1913                                 LLVMAddGlobalMapping (ee, callee, target);
1914                         }
1915                 } else {
1916                         if (cfg->compile_aot) {
1917                                 callee = NULL;
1918                                 if (cfg->abs_patches) {
1919                                         MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1920                                         if (abs_ji) {
1921                                                 callee = get_plt_entry (ctx, llvm_sig, abs_ji->type, abs_ji->data.target);
1922                                                 if (!callee)
1923                                                         LLVM_FAILURE (ctx, "can't encode patch");
1924                                         }
1925                                 }
1926                                 if (!callee)
1927                                         LLVM_FAILURE (ctx, "aot");
1928                         } else {
1929                                 callee = LLVMAddFunction (module, "", llvm_sig);
1930                                 target = NULL;
1931                                 if (cfg->abs_patches) {
1932                                         MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1933                                         if (abs_ji) {
1934                                                 /*
1935                                                  * FIXME: Some trampolines might have
1936                                                  * their own calling convention on some platforms.
1937                                                  */
1938 #ifndef TARGET_AMD64
1939                                                 if (abs_ji->type == MONO_PATCH_INFO_MONITOR_ENTER || abs_ji->type == MONO_PATCH_INFO_MONITOR_EXIT || abs_ji->type == MONO_PATCH_INFO_GENERIC_CLASS_INIT)
1940                                                         LLVM_FAILURE (ctx, "trampoline with own cconv");
1941 #endif
1942                                                 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, abs_ji, FALSE);
1943                                                 LLVMAddGlobalMapping (ee, callee, target);
1944                                         }
1945                                 }
1946                                 if (!target)
1947                                         LLVMAddGlobalMapping (ee, callee, (gpointer)call->fptr);
1948                         }
1949                 }
1950         }
1951
1952         if (virtual) {
1953                 int size = sizeof (gpointer);
1954                 LLVMValueRef index;
1955
1956                 g_assert (ins->inst_offset % size == 0);
1957                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
1958
1959                 callee = convert (ctx, LLVMBuildLoad (builder, LLVMBuildGEP (builder, convert (ctx, values [ins->inst_basereg], LLVMPointerType (LLVMPointerType (IntPtrType (), 0), 0)), &index, 1, ""), ""), LLVMPointerType (llvm_sig, 0));
1960         } else if (calli) {
1961                 callee = convert (ctx, values [ins->sreg1], LLVMPointerType (llvm_sig, 0));
1962         } else {
1963                 if (ins->flags & MONO_INST_HAS_METHOD) {
1964                 }
1965         }
1966
1967         /*
1968          * Collect and convert arguments
1969          */
1970         nargs = (sig->param_count * 2) + sig->hasthis + vretaddr + call->rgctx_reg + call->imt_arg_reg;
1971         len = sizeof (LLVMValueRef) * nargs;
1972         args = alloca (len);
1973         memset (args, 0, len);
1974         l = call->out_ireg_args;
1975
1976         if (call->rgctx_arg_reg) {
1977                 g_assert (values [call->rgctx_arg_reg]);
1978                 g_assert (sinfo.rgctx_arg_pindex < nargs);
1979                 args [sinfo.rgctx_arg_pindex] = values [call->rgctx_arg_reg];
1980         }
1981         if (call->imt_arg_reg) {
1982                 g_assert (values [call->imt_arg_reg]);
1983                 g_assert (sinfo.imt_arg_pindex < nargs);
1984                 args [sinfo.imt_arg_pindex] = values [call->imt_arg_reg];
1985         }
1986
1987         if (vretaddr) {
1988                 if (!addresses [call->inst.dreg])
1989                         addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
1990                 g_assert (sinfo.vret_arg_pindex < nargs);
1991                 args [sinfo.vret_arg_pindex] = LLVMBuildPtrToInt (builder, addresses [call->inst.dreg], IntPtrType (), "");
1992         }
1993
1994         for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1995                 guint32 regpair;
1996                 int reg, pindex;
1997                 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i] : NULL;
1998
1999                 if (sig->hasthis) {
2000                         if (i == 0)
2001                                 pindex = sinfo.this_arg_pindex;
2002                         else
2003                                 pindex = sinfo.pindexes [i - 1];
2004                 } else {
2005                         pindex = sinfo.pindexes [i];
2006                 }
2007
2008                 regpair = (guint32)(gssize)(l->data);
2009                 reg = regpair & 0xffffff;
2010                 args [pindex] = values [reg];
2011                 if (ainfo->storage == LLVMArgVtypeInReg) {
2012                         int j;
2013                         LLVMValueRef regs [2];
2014                         guint32 nregs;
2015
2016                         g_assert (ainfo);
2017
2018                         g_assert (addresses [reg]);
2019
2020                         emit_vtype_to_reg (ctx, builder, sig->params [i - sig->hasthis], addresses [reg], ainfo, regs, &nregs);
2021                         for (j = 0; j < nregs; ++j)
2022                                 args [pindex ++] = regs [j];
2023
2024                         // FIXME: alignment
2025                         // FIXME: Get rid of the VMOVE
2026                 } else if (ainfo->storage == LLVMArgVtypeByVal) {
2027                         g_assert (addresses [reg]);
2028                         args [pindex] = addresses [reg];
2029                 } else {
2030                         g_assert (args [pindex]);
2031                         if (i == 0 && sig->hasthis)
2032                                 args [pindex] = convert (ctx, args [pindex], IntPtrType ());
2033                         else
2034                                 args [pindex] = convert (ctx, args [pindex], type_to_llvm_arg_type (ctx, sig->params [i - sig->hasthis]));
2035                 }
2036
2037                 l = l->next;
2038         }
2039
2040         // FIXME: Align call sites
2041
2042         /*
2043          * Emit the call
2044          */
2045
2046         lcall = emit_call (ctx, bb, &builder, callee, args, LLVMCountParamTypes (llvm_sig));
2047
2048         /*
2049          * Modify cconv and parameter attributes to pass rgctx/imt correctly.
2050          */
2051 #if defined(MONO_ARCH_IMT_REG) && defined(MONO_ARCH_RGCTX_REG)
2052         g_assert (MONO_ARCH_IMT_REG == MONO_ARCH_RGCTX_REG);
2053 #endif
2054         /* The two can't be used together, so use only one LLVM calling conv to pass them */
2055         g_assert (!(call->rgctx_arg_reg && call->imt_arg_reg));
2056         if (!sig->pinvoke)
2057                 LLVMSetInstructionCallConv (lcall, LLVMMono1CallConv);
2058
2059         if (call->rgctx_arg_reg)
2060                 LLVMAddInstrAttribute (lcall, 1 + sinfo.rgctx_arg_pindex, LLVMInRegAttribute);
2061         if (call->imt_arg_reg)
2062                 LLVMAddInstrAttribute (lcall, 1 + sinfo.imt_arg_pindex, LLVMInRegAttribute);
2063
2064         /* Add byval attributes if needed */
2065         for (i = 0; i < sig->param_count; ++i) {
2066                 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i + sig->hasthis] : NULL;
2067
2068                 if (ainfo && ainfo->storage == LLVMArgVtypeByVal) {
2069                         LLVMAddInstrAttribute (lcall, 1 + sinfo.pindexes [i], LLVMByValAttribute);
2070                 }
2071         }
2072
2073         /*
2074          * Convert the result
2075          */
2076         if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
2077                 LLVMValueRef regs [2];
2078
2079                 if (!addresses [ins->dreg])
2080                         addresses [ins->dreg] = build_alloca (ctx, sig->ret);
2081
2082                 regs [0] = LLVMBuildExtractValue (builder, lcall, 0, "");
2083                 if (cinfo->ret.pair_storage [1] != LLVMArgNone)
2084                         regs [1] = LLVMBuildExtractValue (builder, lcall, 1, "");
2085
2086                 emit_reg_to_vtype (ctx, builder, sig->ret, addresses [ins->dreg], &cinfo->ret, regs);
2087         } else if (sig->ret->type != MONO_TYPE_VOID && !vretaddr) {
2088                 /* If the method returns an unsigned value, need to zext it */
2089
2090                 values [ins->dreg] = convert_full (ctx, lcall, llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->ret)), type_is_unsigned (ctx, sig->ret));
2091         }
2092
2093         *builder_ref = ctx->builder;
2094
2095         g_free (sinfo.pindexes);
2096
2097         return;
2098  FAILURE:
2099         return;
2100 }
2101
2102 static void
2103 process_bb (EmitContext *ctx, MonoBasicBlock *bb)
2104 {
2105         MonoCompile *cfg = ctx->cfg;
2106         MonoMethodSignature *sig = ctx->sig;
2107         LLVMValueRef method = ctx->lmethod;
2108         LLVMValueRef *values = ctx->values;
2109         LLVMValueRef *addresses = ctx->addresses;
2110         int i;
2111         LLVMCallInfo *linfo = ctx->linfo;
2112         LLVMModuleRef module = ctx->module;
2113         BBInfo *bblocks = ctx->bblocks;
2114         MonoInst *ins;
2115         LLVMBasicBlockRef cbb;
2116         LLVMBuilderRef builder, starting_builder;
2117         gboolean has_terminator;
2118         LLVMValueRef v;
2119         LLVMValueRef lhs, rhs;
2120         int nins = 0;
2121
2122         cbb = get_bb (ctx, bb);
2123         builder = create_builder (ctx);
2124         ctx->builder = builder;
2125         LLVMPositionBuilderAtEnd (builder, cbb);
2126
2127         if (bb == cfg->bb_entry)
2128                 emit_entry_bb (ctx, builder);
2129         CHECK_FAILURE (ctx);
2130
2131         if (bb->flags & BB_EXCEPTION_HANDLER) {
2132                 LLVMTypeRef i8ptr;
2133                 LLVMValueRef personality;
2134                 LLVMBasicBlockRef target_bb;
2135                 MonoInst *exvar;
2136                 static gint32 mapping_inited;
2137                 static int ti_generator;
2138                 char ti_name [128];
2139                 MonoClass **ti;
2140                 LLVMValueRef type_info;
2141                 int clause_index;
2142
2143                 if (!bblocks [bb->block_num].invoke_target) {
2144                         /*
2145                          * LLVM asserts if llvm.eh.selector is called from a bblock which
2146                          * doesn't have an invoke pointing at it.
2147                          * Update: LLVM no longer asserts, but some tests in exceptions.exe now fail.
2148                          */
2149                         LLVM_FAILURE (ctx, "handler without invokes");
2150                 }
2151
2152                 // <resultval> = landingpad <somety> personality <type> <pers_fn> <clause>+
2153
2154                 if (cfg->compile_aot) {
2155                         /* Use a dummy personality function */
2156                         personality = LLVMGetNamedFunction (module, "mono_aot_personality");
2157                         g_assert (personality);
2158                 } else {
2159                         personality = LLVMGetNamedFunction (module, "mono_personality");
2160                         if (InterlockedCompareExchange (&mapping_inited, 1, 0) == 0)
2161                                 LLVMAddGlobalMapping (ee, personality, mono_personality);
2162                 }
2163
2164                 i8ptr = LLVMPointerType (LLVMInt8Type (), 0);
2165
2166                 clause_index = (mono_get_block_region_notry (cfg, bb->region) >> 8) - 1;
2167
2168                 /*
2169                  * Create the type info
2170                  */
2171                 sprintf (ti_name, "type_info_%d", ti_generator);
2172                 ti_generator ++;
2173
2174                 if (cfg->compile_aot) {
2175                         /* decode_eh_frame () in aot-runtime.c will decode this */
2176                         type_info = LLVMAddGlobal (module, LLVMInt32Type (), ti_name);
2177                         LLVMSetInitializer (type_info, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE));
2178
2179                         /*
2180                          * These symbols are not really used, the clause_index is embedded into the EH tables generated by DwarfMonoException in LLVM.
2181                          */
2182                         LLVMSetLinkage (type_info, LLVMInternalLinkage);
2183
2184                         /*
2185                          * Enabling this causes llc to crash:
2186                          * http://llvm.org/bugs/show_bug.cgi?id=6102
2187                          */
2188                         //LLVM_FAILURE (ctx, "aot+clauses");
2189 #ifdef TARGET_ARM
2190                         // test_0_invalid_unbox_arrays () fails
2191                         LLVM_FAILURE (ctx, "aot+clauses");
2192 #endif
2193                 } else {
2194                         /*
2195                          * After the cfg mempool is freed, the type info will point to stale memory,
2196                          * but this is not a problem, since we decode it once in exception_cb during
2197                          * compilation.
2198                          */
2199                         ti = mono_mempool_alloc (cfg->mempool, sizeof (gint32));
2200                         *(gint32*)ti = clause_index;
2201
2202                         type_info = LLVMAddGlobal (module, i8ptr, ti_name);
2203
2204                         LLVMAddGlobalMapping (ee, type_info, ti);
2205                 }
2206
2207                 {
2208                         LLVMTypeRef members [2], ret_type;
2209                         LLVMValueRef landing_pad;
2210
2211                         members [0] = i8ptr;
2212                         members [1] = LLVMInt32Type ();
2213                         ret_type = LLVMStructType (members, 2, FALSE);
2214
2215                         landing_pad = LLVMBuildLandingPad (builder, ret_type, personality, 1, "");
2216                         LLVMAddClause (landing_pad, type_info);
2217
2218                         /* Store the exception into the exvar */
2219                         if (bb->in_scount == 1) {
2220                                 g_assert (bb->in_scount == 1);
2221                                 exvar = bb->in_stack [0];
2222
2223                                 // FIXME: This is shared with filter clauses ?
2224                                 g_assert (!values [exvar->dreg]);
2225
2226                                 values [exvar->dreg] = LLVMBuildExtractValue (builder, landing_pad, 0, "ex_obj");
2227                                 emit_volatile_store (ctx, exvar->dreg);
2228                         }
2229                 }
2230
2231                 /* Start a new bblock which CALL_HANDLER can branch to */
2232                 target_bb = bblocks [bb->block_num].call_handler_target_bb;
2233                 if (target_bb) {
2234                         LLVMBuildBr (builder, target_bb);
2235
2236                         ctx->builder = builder = create_builder (ctx);
2237                         LLVMPositionBuilderAtEnd (ctx->builder, target_bb);
2238
2239                         ctx->bblocks [bb->block_num].end_bblock = target_bb;
2240                 }
2241         }
2242
2243         has_terminator = FALSE;
2244         starting_builder = builder;
2245         for (ins = bb->code; ins; ins = ins->next) {
2246                 const char *spec = LLVM_INS_INFO (ins->opcode);
2247                 char *dname = NULL;
2248                 char dname_buf [128];
2249
2250                 nins ++;
2251                 if (nins > 5000 && builder == starting_builder) {
2252                         /* some steps in llc are non-linear in the size of basic blocks, see #5714 */
2253                         LLVM_FAILURE (ctx, "basic block too long");
2254                 }
2255
2256                 if (has_terminator)
2257                         /* There could be instructions after a terminator, skip them */
2258                         break;
2259
2260                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins)) {
2261                         sprintf (dname_buf, "t%d", ins->dreg);
2262                         dname = dname_buf;
2263                 }
2264
2265                 if (spec [MONO_INST_SRC1] != ' ' && spec [MONO_INST_SRC1] != 'v') {
2266                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg1);
2267
2268                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2269                                 lhs = emit_volatile_load (ctx, ins->sreg1);
2270                         } else {
2271                                 /* It is ok for SETRET to have an uninitialized argument */
2272                                 if (!values [ins->sreg1] && ins->opcode != OP_SETRET)
2273                                         LLVM_FAILURE (ctx, "sreg1");
2274                                 lhs = values [ins->sreg1];
2275                         }
2276                 } else {
2277                         lhs = NULL;
2278                 }
2279
2280                 if (spec [MONO_INST_SRC2] != ' ' && spec [MONO_INST_SRC2] != ' ') {
2281                         MonoInst *var = get_vreg_to_inst (cfg, ins->sreg2);
2282                         if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2283                                 rhs = emit_volatile_load (ctx, ins->sreg2);
2284                         } else {
2285                                 if (!values [ins->sreg2])
2286                                         LLVM_FAILURE (ctx, "sreg2");
2287                                 rhs = values [ins->sreg2];
2288                         }
2289                 } else {
2290                         rhs = NULL;
2291                 }
2292
2293                 //mono_print_ins (ins);
2294                 switch (ins->opcode) {
2295                 case OP_NOP:
2296                 case OP_NOT_NULL:
2297                 case OP_LIVERANGE_START:
2298                 case OP_LIVERANGE_END:
2299                         break;
2300                 case OP_ICONST:
2301                         values [ins->dreg] = LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE);
2302                         break;
2303                 case OP_I8CONST:
2304 #if SIZEOF_VOID_P == 4
2305                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2306 #else
2307                         values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), (gint64)ins->inst_c0, FALSE);
2308 #endif
2309                         break;
2310                 case OP_R8CONST:
2311                         values [ins->dreg] = LLVMConstReal (LLVMDoubleType (), *(double*)ins->inst_p0);
2312                         break;
2313                 case OP_R4CONST:
2314                         values [ins->dreg] = LLVMConstFPExt (LLVMConstReal (LLVMFloatType (), *(float*)ins->inst_p0), LLVMDoubleType ());
2315                         break;
2316                 case OP_BR:
2317                         LLVMBuildBr (builder, get_bb (ctx, ins->inst_target_bb));
2318                         has_terminator = TRUE;
2319                         break;
2320                 case OP_SWITCH: {
2321                         int i;
2322                         LLVMValueRef v;
2323                         char bb_name [128];
2324                         LLVMBasicBlockRef new_bb;
2325                         LLVMBuilderRef new_builder;
2326
2327                         // The default branch is already handled
2328                         // FIXME: Handle it here
2329
2330                         /* Start new bblock */
2331                         sprintf (bb_name, "SWITCH_DEFAULT_BB%d", ctx->default_index ++);
2332                         new_bb = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
2333
2334                         lhs = convert (ctx, lhs, LLVMInt32Type ());
2335                         v = LLVMBuildSwitch (builder, lhs, new_bb, GPOINTER_TO_UINT (ins->klass));
2336                         for (i = 0; i < GPOINTER_TO_UINT (ins->klass); ++i) {
2337                                 MonoBasicBlock *target_bb = ins->inst_many_bb [i];
2338
2339                                 LLVMAddCase (v, LLVMConstInt (LLVMInt32Type (), i, FALSE), get_bb (ctx, target_bb));
2340                         }
2341
2342                         new_builder = create_builder (ctx);
2343                         LLVMPositionBuilderAtEnd (new_builder, new_bb);
2344                         LLVMBuildUnreachable (new_builder);
2345
2346                         has_terminator = TRUE;
2347                         g_assert (!ins->next);
2348
2349                         break;
2350                 }
2351
2352                 case OP_SETRET:
2353                         if (linfo->ret.storage == LLVMArgVtypeInReg) {
2354                                 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
2355                                 LLVMValueRef part1, retval;
2356                                 int size;
2357
2358                                 size = get_vtype_size (sig->ret);
2359
2360                                 g_assert (addresses [ins->sreg1]);
2361
2362                                 g_assert (linfo->ret.pair_storage [0] == LLVMArgInIReg);
2363                                 g_assert (linfo->ret.pair_storage [1] == LLVMArgNone);
2364
2365                                 part1 = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMIntType (size * 8), 0), ""), ""), IntPtrType ());
2366
2367                                 retval = LLVMBuildInsertValue (builder, LLVMGetUndef (ret_type), part1, 0, "");
2368
2369                                 LLVMBuildRet (builder, retval);
2370                                 break;
2371                         }
2372
2373                         if (linfo->ret.storage == LLVMArgVtypeRetAddr) {
2374                                 LLVMBuildRetVoid (builder);
2375                                 break;
2376                         }
2377
2378                         if (!lhs || ctx->is_dead [ins->sreg1]) {
2379                                 /*
2380                                  * The method did not set its return value, probably because it
2381                                  * ends with a throw.
2382                                  */
2383                                 if (cfg->vret_addr)
2384                                         LLVMBuildRetVoid (builder);
2385                                 else
2386                                         LLVMBuildRet (builder, LLVMConstNull (type_to_llvm_type (ctx, sig->ret)));
2387                         } else {
2388                                 LLVMBuildRet (builder, convert (ctx, lhs, type_to_llvm_type (ctx, sig->ret)));
2389                         }
2390                         has_terminator = TRUE;
2391                         break;
2392                 case OP_ICOMPARE:
2393                 case OP_FCOMPARE:
2394                 case OP_LCOMPARE:
2395                 case OP_COMPARE:
2396                 case OP_ICOMPARE_IMM:
2397                 case OP_LCOMPARE_IMM:
2398                 case OP_COMPARE_IMM: {
2399                         CompRelation rel;
2400                         LLVMValueRef cmp;
2401
2402                         if (ins->next->opcode == OP_NOP)
2403                                 break;
2404
2405                         if (ins->next->opcode == OP_BR)
2406                                 /* The comparison result is not needed */
2407                                 continue;
2408
2409                         rel = mono_opcode_to_cond (ins->next->opcode);
2410
2411                         if (ins->opcode == OP_ICOMPARE_IMM) {
2412                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2413                                 rhs = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2414                         }
2415                         if (ins->opcode == OP_LCOMPARE_IMM) {
2416                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
2417                                 rhs = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2418                         }
2419                         if (ins->opcode == OP_LCOMPARE) {
2420                                 lhs = convert (ctx, lhs, LLVMInt64Type ());
2421                                 rhs = convert (ctx, rhs, LLVMInt64Type ());
2422                         }
2423                         if (ins->opcode == OP_ICOMPARE) {
2424                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2425                                 rhs = convert (ctx, rhs, LLVMInt32Type ());
2426                         }
2427
2428                         if (lhs && rhs) {
2429                                 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2430                                         rhs = convert (ctx, rhs, LLVMTypeOf (lhs));
2431                                 else if (LLVMGetTypeKind (LLVMTypeOf (rhs)) == LLVMPointerTypeKind)
2432                                         lhs = convert (ctx, lhs, LLVMTypeOf (rhs));
2433                         }
2434
2435                         /* We use COMPARE+SETcc/Bcc, llvm uses SETcc+br cond */
2436                         if (ins->opcode == OP_FCOMPARE)
2437                                 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2438                         else if (ins->opcode == OP_COMPARE_IMM)
2439                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), "");
2440                         else if (ins->opcode == OP_LCOMPARE_IMM) {
2441                                 if (SIZEOF_REGISTER == 4 && COMPILE_LLVM (cfg))  {
2442                                         /* The immediate is encoded in two fields */
2443                                         guint64 l = ((guint64)(guint32)ins->inst_offset << 32) | ((guint32)ins->inst_imm);
2444                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), l, FALSE), "");
2445                                 } else {
2446                                         cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), ins->inst_imm, FALSE), "");
2447                                 }
2448                         }
2449                         else if (ins->opcode == OP_COMPARE)
2450                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), convert (ctx, rhs, IntPtrType ()), "");
2451                         else
2452                                 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, rhs, "");
2453
2454                         if (MONO_IS_COND_BRANCH_OP (ins->next)) {
2455                                 if (ins->next->inst_true_bb == ins->next->inst_false_bb) {
2456                                         /*
2457                                          * If the target bb contains PHI instructions, LLVM requires
2458                                          * two PHI entries for this bblock, while we only generate one.
2459                                          * So convert this to an unconditional bblock. (bxc #171).
2460                                          */
2461                                         LLVMBuildBr (builder, get_bb (ctx, ins->next->inst_true_bb));
2462                                 } else {
2463                                         LLVMBuildCondBr (builder, cmp, get_bb (ctx, ins->next->inst_true_bb), get_bb (ctx, ins->next->inst_false_bb));
2464                                 }
2465                                 has_terminator = TRUE;
2466                         } else if (MONO_IS_SETCC (ins->next)) {
2467                                 sprintf (dname_buf, "t%d", ins->next->dreg);
2468                                 dname = dname_buf;
2469                                 values [ins->next->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2470
2471                                 /* Add stores for volatile variables */
2472                                 emit_volatile_store (ctx, ins->next->dreg);
2473                         } else if (MONO_IS_COND_EXC (ins->next)) {
2474                                 emit_cond_system_exception (ctx, bb, ins->next->inst_p1, cmp);
2475                                 CHECK_FAILURE (ctx);
2476                                 builder = ctx->builder;
2477                         } else {
2478                                 LLVM_FAILURE (ctx, "next");
2479                         }
2480
2481                         ins = ins->next;
2482                         break;
2483                 }
2484                 case OP_FCEQ:
2485                 case OP_FCLT:
2486                 case OP_FCLT_UN:
2487                 case OP_FCGT:
2488                 case OP_FCGT_UN: {
2489                         CompRelation rel;
2490                         LLVMValueRef cmp;
2491
2492                         rel = mono_opcode_to_cond (ins->opcode);
2493
2494                         cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2495                         values [ins->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2496                         break;
2497                 }
2498                 case OP_PHI:
2499                 case OP_FPHI:
2500                 case OP_VPHI:
2501                 case OP_XPHI: {
2502                         int i;
2503                         gboolean empty = TRUE;
2504
2505                         /* Check that all input bblocks really branch to us */
2506                         for (i = 0; i < bb->in_count; ++i) {
2507                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_NOT_REACHED)
2508                                         ins->inst_phi_args [i + 1] = -1;
2509                                 else
2510                                         empty = FALSE;
2511                         }
2512
2513                         if (empty) {
2514                                 /* LLVM doesn't like phi instructions with zero operands */
2515                                 ctx->is_dead [ins->dreg] = TRUE;
2516                                 break;
2517                         }
2518
2519                         /* Created earlier, insert it now */
2520                         LLVMInsertIntoBuilder (builder, values [ins->dreg]);
2521
2522                         for (i = 0; i < ins->inst_phi_args [0]; i++) {
2523                                 int sreg1 = ins->inst_phi_args [i + 1];
2524                                 int count, j;
2525
2526                                 /*
2527                                  * Count the number of times the incoming bblock branches to us,
2528                                  * since llvm requires a separate entry for each.
2529                                  */
2530                                 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_SWITCH) {
2531                                         MonoInst *switch_ins = bb->in_bb [i]->last_ins;
2532
2533                                         count = 0;
2534                                         for (j = 0; j < GPOINTER_TO_UINT (switch_ins->klass); ++j) {
2535                                                 if (switch_ins->inst_many_bb [j] == bb)
2536                                                         count ++;
2537                                         }
2538                                 } else {
2539                                         count = 1;
2540                                 }
2541
2542                                 /* Remember for later */
2543                                 for (j = 0; j < count; ++j) {
2544                                         PhiNode *node = mono_mempool_alloc0 (ctx->mempool, sizeof (PhiNode));
2545                                         node->bb = bb;
2546                                         node->phi = ins;
2547                                         node->in_bb = bb->in_bb [i];
2548                                         node->sreg = sreg1;
2549                                         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);
2550                                 }
2551                         }
2552                         break;
2553                 }
2554                 case OP_MOVE:
2555                 case OP_LMOVE:
2556                 case OP_XMOVE:
2557                 case OP_SETFRET:
2558                         g_assert (lhs);
2559                         values [ins->dreg] = lhs;
2560                         break;
2561                 case OP_FMOVE: {
2562                         MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
2563
2564                         g_assert (lhs);
2565                         values [ins->dreg] = lhs;
2566
2567                         if (var && var->klass->byval_arg.type == MONO_TYPE_R4) {
2568                                 /*
2569                                  * This is added by the spilling pass in case of the JIT,
2570                                  * but we have to do it ourselves.
2571                                  */
2572                                 values [ins->dreg] = convert (ctx, values [ins->dreg], LLVMFloatType ());
2573                         }
2574                         break;
2575                 }
2576                 case OP_IADD:
2577                 case OP_ISUB:
2578                 case OP_IAND:
2579                 case OP_IMUL:
2580                 case OP_IDIV:
2581                 case OP_IDIV_UN:
2582                 case OP_IREM:
2583                 case OP_IREM_UN:
2584                 case OP_IOR:
2585                 case OP_IXOR:
2586                 case OP_ISHL:
2587                 case OP_ISHR:
2588                 case OP_ISHR_UN:
2589                 case OP_FADD:
2590                 case OP_FSUB:
2591                 case OP_FMUL:
2592                 case OP_FDIV:
2593                 case OP_LADD:
2594                 case OP_LSUB:
2595                 case OP_LMUL:
2596                 case OP_LDIV:
2597                 case OP_LDIV_UN:
2598                 case OP_LREM:
2599                 case OP_LREM_UN:
2600                 case OP_LAND:
2601                 case OP_LOR:
2602                 case OP_LXOR:
2603                 case OP_LSHL:
2604                 case OP_LSHR:
2605                 case OP_LSHR_UN:
2606                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2607                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2608
2609                         switch (ins->opcode) {
2610                         case OP_IADD:
2611                         case OP_LADD:
2612                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, dname);
2613                                 break;
2614                         case OP_ISUB:
2615                         case OP_LSUB:
2616                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, dname);
2617                                 break;
2618                         case OP_IMUL:
2619                         case OP_LMUL:
2620                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, dname);
2621                                 break;
2622                         case OP_IREM:
2623                         case OP_LREM:
2624                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, rhs, dname);
2625                                 break;
2626                         case OP_IREM_UN:
2627                         case OP_LREM_UN:
2628                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, rhs, dname);
2629                                 break;
2630                         case OP_IDIV:
2631                         case OP_LDIV:
2632                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, rhs, dname);
2633                                 break;
2634                         case OP_IDIV_UN:
2635                         case OP_LDIV_UN:
2636                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, rhs, dname);
2637                                 break;
2638                         case OP_FDIV:
2639                                 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, dname);
2640                                 break;
2641                         case OP_IAND:
2642                         case OP_LAND:
2643                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, dname);
2644                                 break;
2645                         case OP_IOR:
2646                         case OP_LOR:
2647                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, dname);
2648                                 break;
2649                         case OP_IXOR:
2650                         case OP_LXOR:
2651                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, dname);
2652                                 break;
2653                         case OP_ISHL:
2654                         case OP_LSHL:
2655                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, rhs, dname);
2656                                 break;
2657                         case OP_ISHR:
2658                         case OP_LSHR:
2659                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, rhs, dname);
2660                                 break;
2661                         case OP_ISHR_UN:
2662                         case OP_LSHR_UN:
2663                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, rhs, dname);
2664                                 break;
2665
2666                         case OP_FADD:
2667                                 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, dname);
2668                                 break;
2669                         case OP_FSUB:
2670                                 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, dname);
2671                                 break;
2672                         case OP_FMUL:
2673                                 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, dname);
2674                                 break;
2675
2676                         default:
2677                                 g_assert_not_reached ();
2678                         }
2679                         break;
2680                 case OP_IADD_IMM:
2681                 case OP_ISUB_IMM:
2682                 case OP_IMUL_IMM:
2683                 case OP_IREM_IMM:
2684                 case OP_IREM_UN_IMM:
2685                 case OP_IDIV_IMM:
2686                 case OP_IDIV_UN_IMM:
2687                 case OP_IAND_IMM:
2688                 case OP_IOR_IMM:
2689                 case OP_IXOR_IMM:
2690                 case OP_ISHL_IMM:
2691                 case OP_ISHR_IMM:
2692                 case OP_ISHR_UN_IMM:
2693                 case OP_LADD_IMM:
2694                 case OP_LSUB_IMM:
2695                 case OP_LREM_IMM:
2696                 case OP_LAND_IMM:
2697                 case OP_LOR_IMM:
2698                 case OP_LXOR_IMM:
2699                 case OP_LSHL_IMM:
2700                 case OP_LSHR_IMM:
2701                 case OP_LSHR_UN_IMM:
2702                 case OP_ADD_IMM:
2703                 case OP_AND_IMM:
2704                 case OP_MUL_IMM:
2705                 case OP_SHL_IMM:
2706                 case OP_SHR_IMM:
2707                 case OP_SHR_UN_IMM: {
2708                         LLVMValueRef imm;
2709
2710                         if (spec [MONO_INST_SRC1] == 'l') {
2711                                 imm = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2712                         } else {
2713                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2714                         }
2715
2716 #if SIZEOF_VOID_P == 4
2717                         if (ins->opcode == OP_LSHL_IMM || ins->opcode == OP_LSHR_IMM || ins->opcode == OP_LSHR_UN_IMM)
2718                                 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2719 #endif
2720
2721                         if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2722                                 lhs = convert (ctx, lhs, IntPtrType ());
2723                         imm = convert (ctx, imm, LLVMTypeOf (lhs));
2724                         switch (ins->opcode) {
2725                         case OP_IADD_IMM:
2726                         case OP_LADD_IMM:
2727                         case OP_ADD_IMM:
2728                                 values [ins->dreg] = LLVMBuildAdd (builder, lhs, imm, dname);
2729                                 break;
2730                         case OP_ISUB_IMM:
2731                         case OP_LSUB_IMM:
2732                                 values [ins->dreg] = LLVMBuildSub (builder, lhs, imm, dname);
2733                                 break;
2734                         case OP_IMUL_IMM:
2735                         case OP_MUL_IMM:
2736                                 values [ins->dreg] = LLVMBuildMul (builder, lhs, imm, dname);
2737                                 break;
2738                         case OP_IDIV_IMM:
2739                         case OP_LDIV_IMM:
2740                                 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, imm, dname);
2741                                 break;
2742                         case OP_IDIV_UN_IMM:
2743                         case OP_LDIV_UN_IMM:
2744                                 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, imm, dname);
2745                                 break;
2746                         case OP_IREM_IMM:
2747                         case OP_LREM_IMM:
2748                                 values [ins->dreg] = LLVMBuildSRem (builder, lhs, imm, dname);
2749                                 break;
2750                         case OP_IREM_UN_IMM:
2751                                 values [ins->dreg] = LLVMBuildURem (builder, lhs, imm, dname);
2752                                 break;
2753                         case OP_IAND_IMM:
2754                         case OP_LAND_IMM:
2755                         case OP_AND_IMM:
2756                                 values [ins->dreg] = LLVMBuildAnd (builder, lhs, imm, dname);
2757                                 break;
2758                         case OP_IOR_IMM:
2759                         case OP_LOR_IMM:
2760                                 values [ins->dreg] = LLVMBuildOr (builder, lhs, imm, dname);
2761                                 break;
2762                         case OP_IXOR_IMM:
2763                         case OP_LXOR_IMM:
2764                                 values [ins->dreg] = LLVMBuildXor (builder, lhs, imm, dname);
2765                                 break;
2766                         case OP_ISHL_IMM:
2767                         case OP_LSHL_IMM:
2768                         case OP_SHL_IMM:
2769                                 values [ins->dreg] = LLVMBuildShl (builder, lhs, imm, dname);
2770                                 break;
2771                         case OP_ISHR_IMM:
2772                         case OP_LSHR_IMM:
2773                         case OP_SHR_IMM:
2774                                 values [ins->dreg] = LLVMBuildAShr (builder, lhs, imm, dname);
2775                                 break;
2776                         case OP_ISHR_UN_IMM:
2777                                 /* This is used to implement conv.u4, so the lhs could be an i8 */
2778                                 lhs = convert (ctx, lhs, LLVMInt32Type ());
2779                                 imm = convert (ctx, imm, LLVMInt32Type ());
2780                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2781                                 break;
2782                         case OP_LSHR_UN_IMM:
2783                         case OP_SHR_UN_IMM:
2784                                 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2785                                 break;
2786                         default:
2787                                 g_assert_not_reached ();
2788                         }
2789                         break;
2790                 }
2791                 case OP_INEG:
2792                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2793                         break;
2794                 case OP_LNEG:
2795                         values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt64Type (), 0, FALSE), lhs, dname);
2796                         break;
2797                 case OP_FNEG:
2798                         lhs = convert (ctx, lhs, LLVMDoubleType ());
2799                         values [ins->dreg] = LLVMBuildFSub (builder, LLVMConstReal (LLVMDoubleType (), 0.0), lhs, dname);
2800                         break;
2801                 case OP_INOT: {
2802                         guint32 v = 0xffffffff;
2803                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt32Type (), v, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2804                         break;
2805                 }
2806                 case OP_LNOT: {
2807                         guint64 v = 0xffffffffffffffffLL;
2808                         values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt64Type (), v, FALSE), lhs, dname);
2809                         break;
2810                 }
2811 #if defined(TARGET_X86) || defined(TARGET_AMD64)
2812                 case OP_X86_LEA: {
2813                         LLVMValueRef v1, v2;
2814
2815                         v1 = LLVMBuildMul (builder, convert (ctx, rhs, IntPtrType ()), LLVMConstInt (IntPtrType (), (1 << ins->backend.shift_amount), FALSE), "");
2816                         v2 = LLVMBuildAdd (builder, convert (ctx, lhs, IntPtrType ()), v1, "");
2817                         values [ins->dreg] = LLVMBuildAdd (builder, v2, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), dname);
2818                         break;
2819                 }
2820 #endif
2821
2822                 case OP_ICONV_TO_I1:
2823                 case OP_ICONV_TO_I2:
2824                 case OP_ICONV_TO_I4:
2825                 case OP_ICONV_TO_U1:
2826                 case OP_ICONV_TO_U2:
2827                 case OP_ICONV_TO_U4:
2828                 case OP_LCONV_TO_I1:
2829                 case OP_LCONV_TO_I2:
2830                 case OP_LCONV_TO_U1:
2831                 case OP_LCONV_TO_U2:
2832                 case OP_LCONV_TO_U4: {
2833                         gboolean sign;
2834
2835                         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);
2836
2837                         /* Have to do two casts since our vregs have type int */
2838                         v = LLVMBuildTrunc (builder, lhs, op_to_llvm_type (ins->opcode), "");
2839                         if (sign)
2840                                 values [ins->dreg] = LLVMBuildSExt (builder, v, LLVMInt32Type (), dname);
2841                         else
2842                                 values [ins->dreg] = LLVMBuildZExt (builder, v, LLVMInt32Type (), dname);
2843                         break;
2844                 }
2845                 case OP_ICONV_TO_I8:
2846                         values [ins->dreg] = LLVMBuildSExt (builder, lhs, LLVMInt64Type (), dname);
2847                         break;
2848                 case OP_ICONV_TO_U8:
2849                         values [ins->dreg] = LLVMBuildZExt (builder, lhs, LLVMInt64Type (), dname);
2850                         break;
2851                 case OP_FCONV_TO_I4:
2852                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt32Type (), dname);
2853                         break;
2854                 case OP_FCONV_TO_I1:
2855                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2856                         break;
2857                 case OP_FCONV_TO_U1:
2858                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2859                         break;
2860                 case OP_FCONV_TO_I2:
2861                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2862                         break;
2863                 case OP_FCONV_TO_U2:
2864                         values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2865                         break;
2866                 case OP_FCONV_TO_I8:
2867                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt64Type (), dname);
2868                         break;
2869                 case OP_FCONV_TO_I:
2870                         values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, IntPtrType (), dname);
2871                         break;
2872                 case OP_ICONV_TO_R8:
2873                 case OP_LCONV_TO_R8:
2874                         values [ins->dreg] = LLVMBuildSIToFP (builder, lhs, LLVMDoubleType (), dname);
2875                         break;
2876                 case OP_LCONV_TO_R_UN:
2877                         values [ins->dreg] = LLVMBuildUIToFP (builder, lhs, LLVMDoubleType (), dname);
2878                         break;
2879 #if SIZEOF_VOID_P == 4
2880                 case OP_LCONV_TO_U:
2881 #endif
2882                 case OP_LCONV_TO_I4:
2883                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2884                         break;
2885                 case OP_ICONV_TO_R4:
2886                 case OP_LCONV_TO_R4:
2887                         v = LLVMBuildSIToFP (builder, lhs, LLVMFloatType (), "");
2888                         values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2889                         break;
2890                 case OP_FCONV_TO_R4:
2891                         v = LLVMBuildFPTrunc (builder, lhs, LLVMFloatType (), "");
2892                         values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2893                         break;
2894                 case OP_SEXT_I4:
2895                         values [ins->dreg] = LLVMBuildSExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2896                         break;
2897                 case OP_ZEXT_I4:
2898                         values [ins->dreg] = LLVMBuildZExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2899                         break;
2900                 case OP_TRUNC_I4:
2901                         values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2902                         break;
2903                 case OP_LOCALLOC_IMM: {
2904                         LLVMValueRef v;
2905
2906                         guint32 size = ins->inst_imm;
2907                         size = (size + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
2908
2909                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), LLVMConstInt (LLVMInt32Type (), size, FALSE), MONO_ARCH_FRAME_ALIGNMENT, "");
2910
2911                         if (ins->flags & MONO_INST_INIT) {
2912                                 LLVMValueRef args [5];
2913
2914                                 args [0] = v;
2915                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2916                                 args [2] = LLVMConstInt (LLVMInt32Type (), size, FALSE);
2917                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2918                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2919                                 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2920                         }
2921
2922                         values [ins->dreg] = v;
2923                         break;
2924                 }
2925                 case OP_LOCALLOC: {
2926                         LLVMValueRef v, size;
2927
2928                         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), "");
2929
2930                         v = mono_llvm_build_alloca (builder, LLVMInt8Type (), size, MONO_ARCH_FRAME_ALIGNMENT, "");
2931
2932                         if (ins->flags & MONO_INST_INIT) {
2933                                 LLVMValueRef args [5];
2934
2935                                 args [0] = v;
2936                                 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2937                                 args [2] = size;
2938                                 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2939                                 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2940                                 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2941                         }
2942                         values [ins->dreg] = v;
2943                         break;
2944                 }
2945
2946                 case OP_LOADI1_MEMBASE:
2947                 case OP_LOADU1_MEMBASE:
2948                 case OP_LOADI2_MEMBASE:
2949                 case OP_LOADU2_MEMBASE:
2950                 case OP_LOADI4_MEMBASE:
2951                 case OP_LOADU4_MEMBASE:
2952                 case OP_LOADI8_MEMBASE:
2953                 case OP_LOADR4_MEMBASE:
2954                 case OP_LOADR8_MEMBASE:
2955                 case OP_LOAD_MEMBASE:
2956                 case OP_LOADI8_MEM:
2957                 case OP_LOADU1_MEM:
2958                 case OP_LOADU2_MEM:
2959                 case OP_LOADI4_MEM:
2960                 case OP_LOADU4_MEM:
2961                 case OP_LOAD_MEM: {
2962                         int size = 8;
2963                         LLVMValueRef base, index, addr;
2964                         LLVMTypeRef t;
2965                         gboolean sext = FALSE, zext = FALSE;
2966                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
2967
2968                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
2969
2970                         if (sext || zext)
2971                                 dname = (char*)"";
2972
2973                         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)) {
2974                                 addr = LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE);
2975                         } else {
2976                                 /* _MEMBASE */
2977                                 base = lhs;
2978
2979                                 if (ins->inst_offset == 0) {
2980                                         addr = base;
2981                                 } else if (ins->inst_offset % size != 0) {
2982                                         /* Unaligned load */
2983                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
2984                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
2985                                 } else {
2986                                         index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
2987                                         addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
2988                                 }
2989                         }
2990
2991                         addr = convert (ctx, addr, LLVMPointerType (t, 0));
2992
2993                         values [ins->dreg] = emit_load (ctx, bb, &builder, size, addr, dname, is_volatile);
2994
2995                         if (!is_volatile && (ins->flags & MONO_INST_INVARIANT_LOAD)) {
2996                                 /*
2997                                  * These will signal LLVM that these loads do not alias any stores, and
2998                                  * they can't fail, allowing them to be hoisted out of loops.
2999                                  */
3000                                 set_invariant_load_flag (values [ins->dreg]);
3001                                 set_metadata_flag (values [ins->dreg], "mono.nofail.load");
3002                         }
3003
3004                         if (sext)
3005                                 values [ins->dreg] = LLVMBuildSExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
3006                         else if (zext)
3007                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
3008                         else if (ins->opcode == OP_LOADR4_MEMBASE)
3009                                 values [ins->dreg] = LLVMBuildFPExt (builder, values [ins->dreg], LLVMDoubleType (), dname);
3010                         break;
3011                 }
3012
3013                 case OP_STOREI1_MEMBASE_REG:
3014                 case OP_STOREI2_MEMBASE_REG:
3015                 case OP_STOREI4_MEMBASE_REG:
3016                 case OP_STOREI8_MEMBASE_REG:
3017                 case OP_STORER4_MEMBASE_REG:
3018                 case OP_STORER8_MEMBASE_REG:
3019                 case OP_STORE_MEMBASE_REG: {
3020                         int size = 8;
3021                         LLVMValueRef index, addr;
3022                         LLVMTypeRef t;
3023                         gboolean sext = FALSE, zext = FALSE;
3024                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3025
3026                         if (!values [ins->inst_destbasereg])
3027                                 LLVM_FAILURE (ctx, "inst_destbasereg");
3028
3029                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3030
3031                         if (ins->inst_offset % size != 0) {
3032                                 /* Unaligned store */
3033                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3034                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3035                         } else {
3036                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3037                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3038                         }
3039                         emit_store (ctx, bb, &builder, size, convert (ctx, values [ins->sreg1], t), convert (ctx, addr, LLVMPointerType (t, 0)), is_volatile);
3040                         break;
3041                 }
3042
3043                 case OP_STOREI1_MEMBASE_IMM:
3044                 case OP_STOREI2_MEMBASE_IMM:
3045                 case OP_STOREI4_MEMBASE_IMM:
3046                 case OP_STOREI8_MEMBASE_IMM:
3047                 case OP_STORE_MEMBASE_IMM: {
3048                         int size = 8;
3049                         LLVMValueRef index, addr;
3050                         LLVMTypeRef t;
3051                         gboolean sext = FALSE, zext = FALSE;
3052                         gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3053
3054                         t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3055
3056                         if (ins->inst_offset % size != 0) {
3057                                 /* Unaligned store */
3058                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3059                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3060                         } else {
3061                                 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3062                                 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3063                         }
3064                         emit_store (ctx, bb, &builder, size, convert (ctx, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), t), addr, is_volatile);
3065                         break;
3066                 }
3067
3068                 case OP_CHECK_THIS:
3069                         emit_load (ctx, bb, &builder, sizeof (gpointer), convert (ctx, lhs, LLVMPointerType (IntPtrType (), 0)), "", TRUE);
3070                         break;
3071                 case OP_OUTARG_VTRETADDR:
3072                         break;
3073                 case OP_VOIDCALL:
3074                 case OP_CALL:
3075                 case OP_LCALL:
3076                 case OP_FCALL:
3077                 case OP_VCALL:
3078                 case OP_VOIDCALL_MEMBASE:
3079                 case OP_CALL_MEMBASE:
3080                 case OP_LCALL_MEMBASE:
3081                 case OP_FCALL_MEMBASE:
3082                 case OP_VCALL_MEMBASE:
3083                 case OP_VOIDCALL_REG:
3084                 case OP_CALL_REG:
3085                 case OP_LCALL_REG:
3086                 case OP_FCALL_REG:
3087                 case OP_VCALL_REG: {
3088                         process_call (ctx, bb, &builder, ins);
3089                         CHECK_FAILURE (ctx);
3090                         break;
3091                 }
3092                 case OP_AOTCONST: {
3093                         guint32 got_offset;
3094                         LLVMValueRef indexes [2];
3095                         MonoJumpInfo *ji;
3096                         LLVMValueRef got_entry_addr;
3097
3098                         /*
3099                          * FIXME: Can't allocate from the cfg mempool since that is freed if
3100                          * the LLVM compile fails.
3101                          */
3102                         ji = g_new0 (MonoJumpInfo, 1);
3103                         ji->type = (MonoJumpInfoType)ins->inst_i1;
3104                         ji->data.target = ins->inst_p0;
3105
3106                         ji = mono_aot_patch_info_dup (ji);
3107
3108                         ji->next = cfg->patch_info;
3109                         cfg->patch_info = ji;
3110
3111                         //mono_add_patch_info (cfg, 0, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3112                         got_offset = mono_aot_get_got_offset (cfg->patch_info);
3113
3114                         indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3115                         indexes [1] = LLVMConstInt (LLVMInt32Type (), (gssize)got_offset, FALSE);
3116                         got_entry_addr = LLVMBuildGEP (builder, ctx->lmodule->got_var, indexes, 2, "");
3117
3118                         values [ins->dreg] = LLVMBuildLoad (builder, got_entry_addr, dname);
3119                         set_invariant_load_flag (values [ins->dreg]);
3120                         break;
3121                 }
3122                 case OP_NOT_REACHED:
3123                         LLVMBuildUnreachable (builder);
3124                         has_terminator = TRUE;
3125                         g_assert (bb->block_num < cfg->max_block_num);
3126                         ctx->unreachable [bb->block_num] = TRUE;
3127                         /* Might have instructions after this */
3128                         while (ins->next) {
3129                                 MonoInst *next = ins->next;
3130                                 /*
3131                                  * FIXME: If later code uses the regs defined by these instructions,
3132                                  * compilation will fail.
3133                                  */
3134                                 MONO_DELETE_INS (bb, next);
3135                         }
3136                         break;
3137                 case OP_LDADDR: {
3138                         MonoInst *var = ins->inst_p0;
3139
3140                         values [ins->dreg] = addresses [var->dreg];
3141                         break;
3142                 }
3143                 case OP_SIN: {
3144                         LLVMValueRef args [1];
3145
3146                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3147                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sin.f64"), args, 1, dname);
3148                         break;
3149                 }
3150                 case OP_COS: {
3151                         LLVMValueRef args [1];
3152
3153                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3154                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.cos.f64"), args, 1, dname);
3155                         break;
3156                 }
3157                 case OP_SQRT: {
3158                         LLVMValueRef args [1];
3159
3160 #if 0
3161                         /* This no longer seems to happen */
3162                         /*
3163                          * LLVM optimizes sqrt(nan) into undefined in
3164                          * lib/Analysis/ConstantFolding.cpp
3165                          * Also, sqrt(NegativeInfinity) is optimized into 0.
3166                          */
3167                         LLVM_FAILURE (ctx, "sqrt");
3168 #endif
3169                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3170                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sqrt.f64"), args, 1, dname);
3171                         break;
3172                 }
3173                 case OP_ABS: {
3174                         LLVMValueRef args [1];
3175
3176                         args [0] = convert (ctx, lhs, LLVMDoubleType ());
3177                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "fabs"), args, 1, dname);
3178                         break;
3179                 }
3180
3181                 case OP_IMIN:
3182                 case OP_LMIN:
3183                 case OP_IMAX:
3184                 case OP_LMAX:
3185                 case OP_IMIN_UN:
3186                 case OP_LMIN_UN:
3187                 case OP_IMAX_UN:
3188                 case OP_LMAX_UN: {
3189                         LLVMValueRef v;
3190
3191                         lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3192                         rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3193
3194                         switch (ins->opcode) {
3195                         case OP_IMIN:
3196                         case OP_LMIN:
3197                                 v = LLVMBuildICmp (builder, LLVMIntSLE, lhs, rhs, "");
3198                                 break;
3199                         case OP_IMAX:
3200                         case OP_LMAX:
3201                                 v = LLVMBuildICmp (builder, LLVMIntSGE, lhs, rhs, "");
3202                                 break;
3203                         case OP_IMIN_UN:
3204                         case OP_LMIN_UN:
3205                                 v = LLVMBuildICmp (builder, LLVMIntULE, lhs, rhs, "");
3206                                 break;
3207                         case OP_IMAX_UN:
3208                         case OP_LMAX_UN:
3209                                 v = LLVMBuildICmp (builder, LLVMIntUGE, lhs, rhs, "");
3210                                 break;
3211                         default:
3212                                 g_assert_not_reached ();
3213                                 break;
3214                         }
3215                         values [ins->dreg] = LLVMBuildSelect (builder, v, lhs, rhs, dname);
3216                         break;
3217                 }
3218                 case OP_ATOMIC_EXCHANGE_I4: {
3219                         LLVMValueRef args [2];
3220
3221                         g_assert (ins->inst_offset == 0);
3222
3223                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt32Type (), 0));
3224                         args [1] = rhs;
3225
3226                         values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
3227                         break;
3228                 }
3229                 case OP_ATOMIC_EXCHANGE_I8: {
3230                         LLVMValueRef args [2];
3231
3232                         g_assert (ins->inst_offset == 0);
3233
3234                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt64Type (), 0));
3235                         args [1] = convert (ctx, rhs, LLVMInt64Type ());
3236                         values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
3237                         break;
3238                 }
3239                 case OP_ATOMIC_ADD_NEW_I4: {
3240                         LLVMValueRef args [2];
3241
3242                         g_assert (ins->inst_offset == 0);
3243
3244                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt32Type (), 0));
3245                         args [1] = rhs;
3246                         values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
3247                         break;
3248                 }
3249                 case OP_ATOMIC_ADD_NEW_I8: {
3250                         LLVMValueRef args [2];
3251
3252                         g_assert (ins->inst_offset == 0);
3253
3254                         args [0] = convert (ctx, lhs, LLVMPointerType (LLVMInt64Type (), 0));
3255                         args [1] = convert (ctx, rhs, LLVMInt64Type ());
3256                         values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
3257                         break;
3258                 }
3259                 case OP_ATOMIC_CAS_I4:
3260                 case OP_ATOMIC_CAS_I8: {
3261                         LLVMValueRef args [3];
3262                         LLVMTypeRef t;
3263
3264                         if (ins->opcode == OP_ATOMIC_CAS_I4) {
3265                                 t = LLVMInt32Type ();
3266                         } else {
3267                                 t = LLVMInt64Type ();
3268                         }
3269
3270                         args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
3271                         /* comparand */
3272                         args [1] = convert (ctx, values [ins->sreg3], t);
3273                         /* new value */
3274                         args [2] = convert (ctx, values [ins->sreg2], t);
3275                         values [ins->dreg] = mono_llvm_build_cmpxchg (builder, args [0], args [1], args [2]);
3276                         break;
3277                 }
3278                 case OP_MEMORY_BARRIER: {
3279                         mono_llvm_build_fence (builder);
3280                         break;
3281                 }
3282                 case OP_RELAXED_NOP: {
3283 #if defined(TARGET_AMD64) || defined(TARGET_X86)
3284                         emit_call (ctx, bb, &builder, LLVMGetNamedFunction (ctx->module, "llvm.x86.sse2.pause"), NULL, 0);
3285                         break;
3286 #else
3287                         break;
3288 #endif
3289                 }
3290                 case OP_TLS_GET: {
3291 #if (defined(TARGET_AMD64) || defined(TARGET_X86)) && defined(__linux__)
3292 #ifdef TARGET_AMD64
3293                         // 257 == FS segment register
3294                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 257);
3295 #else
3296                         // 256 == GS segment register
3297                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3298 #endif
3299                         // FIXME: XEN
3300                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), ins->inst_offset, TRUE), ptrtype, ""), "");
3301 #elif defined(TARGET_AMD64) && defined(TARGET_OSX)
3302                         /* See mono_amd64_emit_tls_get () */
3303                         int offset = mono_amd64_get_tls_gs_offset () + (ins->inst_offset * 8);
3304
3305                         // 256 == GS segment register
3306                         LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3307                         values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), offset, TRUE), ptrtype, ""), "");
3308 #else
3309                         LLVM_FAILURE (ctx, "opcode tls-get");
3310 #endif
3311
3312                         break;
3313                 }
3314
3315                         /*
3316                          * Overflow opcodes.
3317                          */
3318                 case OP_IADD_OVF:
3319                 case OP_IADD_OVF_UN:
3320                 case OP_ISUB_OVF:
3321                 case OP_ISUB_OVF_UN:
3322                 case OP_IMUL_OVF:
3323                 case OP_IMUL_OVF_UN:
3324 #if SIZEOF_VOID_P == 8
3325                 case OP_LADD_OVF:
3326                 case OP_LADD_OVF_UN:
3327                 case OP_LSUB_OVF:
3328                 case OP_LSUB_OVF_UN:
3329                 case OP_LMUL_OVF:
3330                 case OP_LMUL_OVF_UN:
3331 #endif
3332                         {
3333                                 LLVMValueRef args [2], val, ovf, func;
3334
3335                                 args [0] = convert (ctx, lhs, op_to_llvm_type (ins->opcode));
3336                                 args [1] = convert (ctx, rhs, op_to_llvm_type (ins->opcode));
3337                                 func = LLVMGetNamedFunction (module, ovf_op_to_intrins (ins->opcode));
3338                                 g_assert (func);
3339                                 val = LLVMBuildCall (builder, func, args, 2, "");
3340                                 values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, dname);
3341                                 ovf = LLVMBuildExtractValue (builder, val, 1, "");
3342                                 emit_cond_system_exception (ctx, bb, "OverflowException", ovf);
3343                                 CHECK_FAILURE (ctx);
3344                                 builder = ctx->builder;
3345                                 break;
3346                         }
3347
3348                         /*
3349                          * Valuetypes.
3350                          *   We currently model them using arrays. Promotion to local vregs is
3351                          * disabled for them in mono_handle_global_vregs () in the LLVM case,
3352                          * so we always have an entry in cfg->varinfo for them.
3353                          * FIXME: Is this needed ?
3354                          */
3355                 case OP_VZERO: {
3356                         MonoClass *klass = ins->klass;
3357                         LLVMValueRef args [5];
3358
3359                         if (!klass) {
3360                                 // FIXME:
3361                                 LLVM_FAILURE (ctx, "!klass");
3362                                 break;
3363                         }
3364
3365                         if (!addresses [ins->dreg])
3366                                 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3367                         args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3368                         args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
3369                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3370                         // FIXME: Alignment
3371                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3372                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3373                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
3374                         break;
3375                 }
3376
3377                 case OP_STOREV_MEMBASE:
3378                 case OP_LOADV_MEMBASE:
3379                 case OP_VMOVE: {
3380                         MonoClass *klass = ins->klass;
3381                         LLVMValueRef src = NULL, dst, args [5];
3382                         gboolean done = FALSE;
3383
3384                         if (!klass) {
3385                                 // FIXME:
3386                                 LLVM_FAILURE (ctx, "!klass");
3387                                 break;
3388                         }
3389
3390                         if (mini_is_gsharedvt_klass (cfg, klass)) {
3391                                 // FIXME:
3392                                 LLVM_FAILURE (ctx, "gsharedvt");
3393                                 break;
3394                         }
3395
3396                         switch (ins->opcode) {
3397                         case OP_STOREV_MEMBASE:
3398                                 if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg) {
3399                                         /* FIXME: Emit write barriers like in mini_emit_stobj () */
3400                                         LLVM_FAILURE (ctx, "storev_membase + write barriers");
3401                                         break;
3402                                 }
3403                                 if (!addresses [ins->sreg1]) {
3404                                         /* SIMD */
3405                                         g_assert (values [ins->sreg1]);
3406                                         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));
3407                                         LLVMBuildStore (builder, values [ins->sreg1], dst);
3408                                         done = TRUE;
3409                                 } else {
3410                                         src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3411                                         dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3412                                 }
3413                                 break;
3414                         case OP_LOADV_MEMBASE:
3415                                 if (!addresses [ins->dreg])
3416                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3417                                 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3418                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3419                                 break;
3420                         case OP_VMOVE:
3421                                 if (!addresses [ins->sreg1])
3422                                         addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
3423                                 if (!addresses [ins->dreg])
3424                                         addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3425                                 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3426                                 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3427                                 break;
3428                         default:
3429                                 g_assert_not_reached ();
3430                         }
3431                         CHECK_FAILURE (ctx);
3432
3433                         if (done)
3434                                 break;
3435
3436                         args [0] = dst;
3437                         args [1] = src;
3438                         args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3439                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3440                         // FIXME: Alignment
3441                         args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3442                         args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3443                         LLVMBuildCall (builder, LLVMGetNamedFunction (module, memcpy_func_name), args, memcpy_param_count, "");
3444                         break;
3445                 }
3446                 case OP_LLVM_OUTARG_VT:
3447                         if (!addresses [ins->sreg1]) {
3448                                 addresses [ins->sreg1] = build_alloca (ctx, &ins->klass->byval_arg);
3449                                 g_assert (values [ins->sreg1]);
3450                                 LLVMBuildStore (builder, values [ins->sreg1], addresses [ins->sreg1]);
3451                         }
3452                         addresses [ins->dreg] = addresses [ins->sreg1];
3453                         break;
3454
3455                         /*
3456                          * SIMD
3457                          */
3458 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3459                 case OP_XZERO: {
3460                         values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
3461                         break;
3462                 }
3463                 case OP_LOADX_MEMBASE: {
3464                         LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
3465                         LLVMValueRef src;
3466
3467                         src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3468                         values [ins->dreg] = mono_llvm_build_aligned_load (builder, src, "", FALSE, 1);
3469                         break;
3470                 }
3471                 case OP_STOREX_MEMBASE: {
3472                         LLVMTypeRef t = LLVMTypeOf (values [ins->sreg1]);
3473                         LLVMValueRef dest;
3474
3475                         dest = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3476                         mono_llvm_build_aligned_store (builder, values [ins->sreg1], dest, FALSE, 1);
3477                         break;
3478                 }
3479                 case OP_PADDB:
3480                 case OP_PADDW:
3481                 case OP_PADDD:
3482                 case OP_PADDQ:
3483                         values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, "");
3484                         break;
3485                 case OP_ADDPD:
3486                 case OP_ADDPS:
3487                         values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, "");
3488                         break;
3489                 case OP_PSUBB:
3490                 case OP_PSUBW:
3491                 case OP_PSUBD:
3492                 case OP_PSUBQ:
3493                         values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, "");
3494                         break;
3495                 case OP_SUBPD:
3496                 case OP_SUBPS:
3497                         values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, "");
3498                         break;
3499                 case OP_MULPD:
3500                 case OP_MULPS:
3501                         values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, "");
3502                         break;
3503                 case OP_DIVPD:
3504                 case OP_DIVPS:
3505                         values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, "");
3506                         break;
3507                 case OP_PAND:
3508                         values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, "");
3509                         break;
3510                 case OP_POR:
3511                         values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, "");
3512                         break;
3513                 case OP_PXOR:
3514                         values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, "");
3515                         break;
3516                 case OP_PMULW:
3517                 case OP_PMULD:
3518                         values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, "");
3519                         break;
3520                 case OP_ANDPS:
3521                 case OP_ANDNPS:
3522                 case OP_ORPS:
3523                 case OP_XORPS:
3524                 case OP_ANDPD:
3525                 case OP_ANDNPD:
3526                 case OP_ORPD:
3527                 case OP_XORPD: {
3528                         LLVMTypeRef t, rt;
3529                         LLVMValueRef v = NULL;
3530
3531                         switch (ins->opcode) {
3532                         case OP_ANDPS:
3533                         case OP_ANDNPS:
3534                         case OP_ORPS:
3535                         case OP_XORPS:
3536                                 t = LLVMVectorType (LLVMInt32Type (), 4);
3537                                 rt = LLVMVectorType (LLVMFloatType (), 4);
3538                                 break;
3539                         case OP_ANDPD:
3540                         case OP_ANDNPD:
3541                         case OP_ORPD:
3542                         case OP_XORPD:
3543                                 t = LLVMVectorType (LLVMInt64Type (), 2);
3544                                 rt = LLVMVectorType (LLVMDoubleType (), 2);
3545                                 break;
3546                         default:
3547                                 t = LLVMInt32Type ();
3548                                 rt = LLVMInt32Type ();
3549                                 g_assert_not_reached ();
3550                         }
3551
3552                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3553                         rhs = LLVMBuildBitCast (builder, rhs, t, "");
3554                         switch (ins->opcode) {
3555                         case OP_ANDPS:
3556                         case OP_ANDPD:
3557                                 v = LLVMBuildAnd (builder, lhs, rhs, "");
3558                                 break;
3559                         case OP_ORPS:
3560                         case OP_ORPD:
3561                                 v = LLVMBuildOr (builder, lhs, rhs, "");
3562                                 break;
3563                         case OP_XORPS:
3564                         case OP_XORPD:
3565                                 v = LLVMBuildXor (builder, lhs, rhs, "");
3566                                 break;
3567                         case OP_ANDNPS:
3568                         case OP_ANDNPD:
3569                                 v = LLVMBuildAnd (builder, rhs, LLVMBuildNot (builder, lhs, ""), "");
3570                                 break;
3571                         }
3572                         values [ins->dreg] = LLVMBuildBitCast (builder, v, rt, "");
3573                         break;
3574                 }
3575                 case OP_MINPD:
3576                 case OP_MINPS:
3577                 case OP_MAXPD:
3578                 case OP_MAXPS:
3579                 case OP_ADDSUBPD:
3580                 case OP_ADDSUBPS:
3581                 case OP_PMIND_UN:
3582                 case OP_PMINW_UN:
3583                 case OP_PMINB_UN:
3584                 case OP_PMINW:
3585                 case OP_PMAXD_UN:
3586                 case OP_PMAXW_UN:
3587                 case OP_PMAXB_UN:
3588                 case OP_HADDPD:
3589                 case OP_HADDPS:
3590                 case OP_HSUBPD:
3591                 case OP_HSUBPS:
3592                 case OP_PADDB_SAT:
3593                 case OP_PADDW_SAT:
3594                 case OP_PSUBB_SAT:
3595                 case OP_PSUBW_SAT:
3596                 case OP_PADDB_SAT_UN:
3597                 case OP_PADDW_SAT_UN:
3598                 case OP_PSUBB_SAT_UN:
3599                 case OP_PSUBW_SAT_UN:
3600                 case OP_PAVGB_UN:
3601                 case OP_PAVGW_UN:
3602                 case OP_PACKW:
3603                 case OP_PACKD:
3604                 case OP_PACKW_UN:
3605                 case OP_PACKD_UN:
3606                 case OP_PMULW_HIGH:
3607                 case OP_PMULW_HIGH_UN: {
3608                         LLVMValueRef args [2];
3609
3610                         args [0] = lhs;
3611                         args [1] = rhs;
3612
3613                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3614                         break;
3615                 }
3616                 case OP_PCMPEQB:
3617                 case OP_PCMPEQW:
3618                 case OP_PCMPEQD:
3619                 case OP_PCMPEQQ: {
3620                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntEQ, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3621                         break;
3622                 }
3623                 case OP_PCMPGTB: {
3624                         values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntSGT, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3625                         break;
3626                 }
3627                 case OP_EXTRACT_R8:
3628                 case OP_EXTRACT_I8:
3629                 case OP_EXTRACT_I4:
3630                 case OP_EXTRACT_I2:
3631                 case OP_EXTRACT_U2:
3632                 case OP_EXTRACTX_U2:
3633                 case OP_EXTRACT_I1:
3634                 case OP_EXTRACT_U1: {
3635                         LLVMTypeRef t;
3636                         gboolean zext = FALSE;
3637
3638                         t = simd_op_to_llvm_type (ins->opcode);
3639
3640                         switch (ins->opcode) {
3641                         case OP_EXTRACT_R8:
3642                         case OP_EXTRACT_I8:
3643                         case OP_EXTRACT_I4:
3644                         case OP_EXTRACT_I2:
3645                         case OP_EXTRACT_I1:
3646                                 break;
3647                         case OP_EXTRACT_U2:
3648                         case OP_EXTRACTX_U2:
3649                         case OP_EXTRACT_U1:
3650                                 zext = TRUE;
3651                                 break;
3652                         default:
3653                                 t = LLVMInt32Type ();
3654                                 g_assert_not_reached ();
3655                         }
3656
3657                         lhs = LLVMBuildBitCast (builder, lhs, t, "");
3658                         values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
3659                         if (zext)
3660                                 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
3661                         break;
3662                 }
3663
3664                 case OP_EXPAND_I1:
3665                 case OP_EXPAND_I2:
3666                 case OP_EXPAND_I4:
3667                 case OP_EXPAND_I8:
3668                 case OP_EXPAND_R4:
3669                 case OP_EXPAND_R8: {
3670                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3671                         LLVMValueRef mask [16], v;
3672
3673                         for (i = 0; i < 16; ++i)
3674                                 mask [i] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3675
3676                         v = convert (ctx, values [ins->sreg1], LLVMGetElementType (t));
3677
3678                         values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (t), v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3679                         values [ins->dreg] = LLVMBuildShuffleVector (builder, values [ins->dreg], LLVMGetUndef (t), LLVMConstVector (mask, LLVMGetVectorSize (t)), "");
3680                         break;
3681                 }
3682
3683                 case OP_INSERT_I1:
3684                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3685                         break;
3686                 case OP_INSERT_I2:
3687                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3688                         break;
3689                 case OP_INSERT_I4:
3690                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3691                         break;
3692                 case OP_INSERT_I8:
3693                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3694                         break;
3695                 case OP_INSERT_R4:
3696                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3697                         break;
3698                 case OP_INSERT_R8:
3699                         values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3700                         break;
3701
3702                 case OP_CVTDQ2PD:
3703                 case OP_CVTDQ2PS:
3704                 case OP_CVTPD2DQ:
3705                 case OP_CVTPS2DQ:
3706                 case OP_CVTPD2PS:
3707                 case OP_CVTPS2PD:
3708                 case OP_CVTTPD2DQ:
3709                 case OP_CVTTPS2DQ:
3710                 case OP_EXTRACT_MASK:
3711                 case OP_SQRTPS:
3712                 case OP_SQRTPD:
3713                 case OP_RSQRTPS:
3714                 case OP_RCPPS: {
3715                         LLVMValueRef v;
3716
3717                         v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
3718
3719                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
3720                         break;
3721                 }
3722
3723                 case OP_ICONV_TO_R8_RAW:
3724                         /* Same as OP_ICONV_TO_R8 */
3725                         values [ins->dreg] = convert (ctx, LLVMBuildBitCast (builder, lhs, LLVMFloatType (), ""), LLVMDoubleType ());
3726                         break;
3727
3728                 case OP_COMPPS:
3729                 case OP_COMPPD: {
3730                         LLVMValueRef args [3];
3731
3732                         args [0] = lhs;
3733                         args [1] = rhs;
3734                         args [2] = LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE);
3735
3736                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 3, dname);
3737                         break;
3738                 }
3739
3740                 case OP_ICONV_TO_X:
3741                         /* This is only used for implementing shifts by non-immediate */
3742                         values [ins->dreg] = lhs;
3743                         break;
3744
3745                 case OP_PSHRW:
3746                 case OP_PSHRD:
3747                 case OP_PSHRQ:
3748                 case OP_PSARW:
3749                 case OP_PSARD:
3750                 case OP_PSHLW:
3751                 case OP_PSHLD:
3752                 case OP_PSHLQ: {
3753                         LLVMValueRef args [3];
3754
3755                         args [0] = lhs;
3756                         args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
3757
3758                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3759                         break;
3760                 }
3761
3762                 case OP_PSHRW_REG:
3763                 case OP_PSHRD_REG:
3764                 case OP_PSHRQ_REG:
3765                 case OP_PSARW_REG:
3766                 case OP_PSARD_REG:
3767                 case OP_PSHLW_REG:
3768                 case OP_PSHLD_REG:
3769                 case OP_PSHLQ_REG: {
3770                         LLVMValueRef args [3];
3771
3772                         args [0] = lhs;
3773                         args [1] = values [ins->sreg2];
3774
3775                         values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3776                         break;
3777                 }
3778
3779                 case OP_SHUFPS:
3780                 case OP_SHUFPD:
3781                 case OP_PSHUFLED:
3782                 case OP_PSHUFLEW_LOW:
3783                 case OP_PSHUFLEW_HIGH: {
3784                         int mask [16];
3785                         LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
3786                         int i, mask_size = 0;
3787                         int imask = ins->inst_c0;
3788
3789                         /* Convert the x86 shuffle mask to LLVM's */
3790                         switch (ins->opcode) {
3791                         case OP_SHUFPS:
3792                                 mask_size = 4;
3793                                 mask [0] = ((imask >> 0) & 3);
3794                                 mask [1] = ((imask >> 2) & 3);
3795                                 mask [2] = ((imask >> 4) & 3) + 4;
3796                                 mask [3] = ((imask >> 6) & 3) + 4;
3797                                 v1 = values [ins->sreg1];
3798                                 v2 = values [ins->sreg2];
3799                                 break;
3800                         case OP_SHUFPD:
3801                                 mask_size = 2;
3802                                 mask [0] = ((imask >> 0) & 1);
3803                                 mask [1] = ((imask >> 1) & 1) + 2;
3804                                 v1 = values [ins->sreg1];
3805                                 v2 = values [ins->sreg2];
3806                                 break;
3807                         case OP_PSHUFLEW_LOW:
3808                                 mask_size = 8;
3809                                 mask [0] = ((imask >> 0) & 3);
3810                                 mask [1] = ((imask >> 2) & 3);
3811                                 mask [2] = ((imask >> 4) & 3);
3812                                 mask [3] = ((imask >> 6) & 3);
3813                                 mask [4] = 4 + 0;
3814                                 mask [5] = 4 + 1;
3815                                 mask [6] = 4 + 2;
3816                                 mask [7] = 4 + 3;
3817                                 v1 = values [ins->sreg1];
3818                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3819                                 break;
3820                         case OP_PSHUFLEW_HIGH:
3821                                 mask_size = 8;
3822                                 mask [0] = 0;
3823                                 mask [1] = 1;
3824                                 mask [2] = 2;
3825                                 mask [3] = 3;
3826                                 mask [4] = 4 + ((imask >> 0) & 3);
3827                                 mask [5] = 4 + ((imask >> 2) & 3);
3828                                 mask [6] = 4 + ((imask >> 4) & 3);
3829                                 mask [7] = 4 + ((imask >> 6) & 3);
3830                                 v1 = values [ins->sreg1];
3831                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3832                                 break;
3833                         case OP_PSHUFLED:
3834                                 mask_size = 4;
3835                                 mask [0] = ((imask >> 0) & 3);
3836                                 mask [1] = ((imask >> 2) & 3);
3837                                 mask [2] = ((imask >> 4) & 3);
3838                                 mask [3] = ((imask >> 6) & 3);
3839                                 v1 = values [ins->sreg1];
3840                                 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3841                                 break;
3842                         default:
3843                                 g_assert_not_reached ();
3844                         }
3845                         for (i = 0; i < mask_size; ++i)
3846                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3847
3848                         values [ins->dreg] =
3849                                 LLVMBuildShuffleVector (builder, v1, v2,
3850                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3851                         break;
3852                 }
3853
3854                 case OP_UNPACK_LOWB:
3855                 case OP_UNPACK_LOWW:
3856                 case OP_UNPACK_LOWD:
3857                 case OP_UNPACK_LOWQ:
3858                 case OP_UNPACK_LOWPS:
3859                 case OP_UNPACK_LOWPD:
3860                 case OP_UNPACK_HIGHB:
3861                 case OP_UNPACK_HIGHW:
3862                 case OP_UNPACK_HIGHD:
3863                 case OP_UNPACK_HIGHQ:
3864                 case OP_UNPACK_HIGHPS:
3865                 case OP_UNPACK_HIGHPD: {
3866                         int mask [16];
3867                         LLVMValueRef mask_values [16];
3868                         int i, mask_size = 0;
3869                         gboolean low = FALSE;
3870
3871                         switch (ins->opcode) {
3872                         case OP_UNPACK_LOWB:
3873                                 mask_size = 16;
3874                                 low = TRUE;
3875                                 break;
3876                         case OP_UNPACK_LOWW:
3877                                 mask_size = 8;
3878                                 low = TRUE;
3879                                 break;
3880                         case OP_UNPACK_LOWD:
3881                         case OP_UNPACK_LOWPS:
3882                                 mask_size = 4;
3883                                 low = TRUE;
3884                                 break;
3885                         case OP_UNPACK_LOWQ:
3886                         case OP_UNPACK_LOWPD:
3887                                 mask_size = 2;
3888                                 low = TRUE;
3889                                 break;
3890                         case OP_UNPACK_HIGHB:
3891                                 mask_size = 16;
3892                                 break;
3893                         case OP_UNPACK_HIGHW:
3894                                 mask_size = 8;
3895                                 break;
3896                         case OP_UNPACK_HIGHD:
3897                         case OP_UNPACK_HIGHPS:
3898                                 mask_size = 4;
3899                                 break;
3900                         case OP_UNPACK_HIGHQ:
3901                         case OP_UNPACK_HIGHPD:
3902                                 mask_size = 2;
3903                                 break;
3904                         default:
3905                                 g_assert_not_reached ();
3906                         }
3907
3908                         if (low) {
3909                                 for (i = 0; i < (mask_size / 2); ++i) {
3910                                         mask [(i * 2)] = i;
3911                                         mask [(i * 2) + 1] = mask_size + i;
3912                                 }
3913                         } else {
3914                                 for (i = 0; i < (mask_size / 2); ++i) {
3915                                         mask [(i * 2)] = (mask_size / 2) + i;
3916                                         mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
3917                                 }
3918                         }
3919
3920                         for (i = 0; i < mask_size; ++i)
3921                                 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3922
3923                         values [ins->dreg] =
3924                                 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
3925                                                                                 LLVMConstVector (mask_values, mask_size), dname);
3926                         break;
3927                 }
3928
3929                 case OP_DUPPD: {
3930                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3931                         LLVMValueRef v, val;
3932
3933                         v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3934                         val = LLVMConstNull (t);
3935                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3936                         val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
3937
3938                         values [ins->dreg] = val;
3939                         break;
3940                 }
3941                 case OP_DUPPS_LOW:
3942                 case OP_DUPPS_HIGH: {
3943                         LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3944                         LLVMValueRef v1, v2, val;
3945
3946
3947                         if (ins->opcode == OP_DUPPS_LOW) {
3948                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3949                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3950                         } else {
3951                                 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3952                                 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3953                         }
3954                         val = LLVMConstNull (t);
3955                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3956                         val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3957                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3958                         val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3959
3960                         values [ins->dreg] = val;
3961                         break;
3962                 }
3963
3964 #endif /* SIMD */
3965
3966                 case OP_DUMMY_USE:
3967                         break;
3968
3969                         /*
3970                          * EXCEPTION HANDLING
3971                          */
3972                 case OP_IMPLICIT_EXCEPTION:
3973                         /* This marks a place where an implicit exception can happen */
3974                         if (bb->region != -1)
3975                                 LLVM_FAILURE (ctx, "implicit-exception");
3976                         break;
3977                 case OP_THROW:
3978                 case OP_RETHROW: {
3979                         MonoMethodSignature *throw_sig;
3980                         LLVMValueRef callee, arg;
3981                         gboolean rethrow = (ins->opcode == OP_RETHROW);
3982                         const char *icall_name;
3983
3984                         callee = rethrow ? ctx->lmodule->rethrow : ctx->lmodule->throw;
3985                         icall_name = rethrow ? "mono_arch_rethrow_exception" : "mono_arch_throw_exception";
3986
3987                         if (!callee) {
3988                                 throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
3989                                 throw_sig->ret = &mono_get_void_class ()->byval_arg;
3990                                 throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
3991                                 if (cfg->compile_aot) {
3992                                         callee = get_plt_entry (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3993                                 } else {
3994                                         callee = LLVMAddFunction (module, icall_name, sig_to_llvm_sig (ctx, throw_sig));
3995
3996 #ifdef TARGET_X86
3997                                         /*
3998                                          * LLVM doesn't push the exception argument, so we need a different
3999                                          * trampoline.
4000                                          */
4001                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, rethrow ? "llvm_rethrow_exception_trampoline" : "llvm_throw_exception_trampoline"));
4002 #else
4003                                         LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
4004 #endif
4005                                 }
4006
4007                                 mono_memory_barrier ();
4008                                 if (rethrow)
4009                                         ctx->lmodule->rethrow = callee;
4010                                 else
4011                                         ctx->lmodule->throw = callee;
4012                         }
4013                         arg = convert (ctx, lhs, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
4014                         emit_call (ctx, bb, &builder, callee, &arg, 1);
4015                         break;
4016                 }
4017                 case OP_CALL_HANDLER: {
4018                         /*
4019                          * We don't 'call' handlers, but instead simply branch to them.
4020                          * The code generated by ENDFINALLY will branch back to us.
4021                          */
4022                         LLVMBasicBlockRef noex_bb;
4023                         GSList *bb_list;
4024                         BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
4025
4026                         bb_list = info->call_handler_return_bbs;
4027
4028                         /*
4029                          * Set the indicator variable for the finally clause.
4030                          */
4031                         lhs = info->finally_ind;
4032                         g_assert (lhs);
4033                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
4034
4035                         /* Branch to the finally clause */
4036                         LLVMBuildBr (builder, info->call_handler_target_bb);
4037
4038                         noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
4039                         info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
4040
4041                         builder = ctx->builder = create_builder (ctx);
4042                         LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
4043
4044                         bblocks [bb->block_num].end_bblock = noex_bb;
4045                         break;
4046                 }
4047                 case OP_START_HANDLER: {
4048                         break;
4049                 }
4050                 case OP_ENDFINALLY: {
4051                         LLVMBasicBlockRef resume_bb;
4052                         MonoBasicBlock *handler_bb;
4053                         LLVMValueRef val, switch_ins, callee;
4054                         GSList *bb_list;
4055                         BBInfo *info;
4056
4057                         handler_bb = g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
4058                         g_assert (handler_bb);
4059                         info = &bblocks [handler_bb->block_num];
4060                         lhs = info->finally_ind;
4061                         g_assert (lhs);
4062
4063                         bb_list = info->call_handler_return_bbs;
4064
4065                         resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
4066
4067                         /* Load the finally variable */
4068                         val = LLVMBuildLoad (builder, lhs, "");
4069
4070                         /* Reset the variable */
4071                         LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
4072
4073                         /* Branch to either resume_bb, or to the bblocks in bb_list */
4074                         switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
4075                         /*
4076                          * The other targets are added at the end to handle OP_CALL_HANDLER
4077                          * opcodes processed later.
4078                          */
4079                         info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
4080
4081                         builder = ctx->builder = create_builder (ctx);
4082                         LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
4083
4084                         if (ctx->cfg->compile_aot) {
4085                                 callee = get_plt_entry (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
4086                         } else {
4087                                 callee = LLVMGetNamedFunction (module, "llvm_resume_unwind_trampoline");
4088                         }
4089                         LLVMBuildCall (builder, callee, NULL, 0, "");
4090
4091                         LLVMBuildUnreachable (builder);
4092                         has_terminator = TRUE;
4093                         break;
4094                 }
4095                 default: {
4096                         char reason [128];
4097
4098                         sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
4099                         LLVM_FAILURE (ctx, reason);
4100                         break;
4101                 }
4102                 }
4103
4104                 /* Convert the value to the type required by phi nodes */
4105                 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
4106                         if (!values [ins->dreg])
4107                                 /* vtypes */
4108                                 values [ins->dreg] = addresses [ins->dreg];
4109                         else
4110                                 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
4111                 }
4112
4113                 /* Add stores for volatile variables */
4114                 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
4115                         emit_volatile_store (ctx, ins->dreg);
4116         }
4117
4118         if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0))
4119                 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
4120
4121         if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID)
4122                 LLVMBuildRetVoid (builder);
4123
4124         if (bb == cfg->bb_entry)
4125                 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
4126
4127         return;
4128
4129  FAILURE:
4130         return;
4131 }
4132
4133 /*
4134  * mono_llvm_check_method_supported:
4135  *
4136  *   Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
4137  * compiling a method twice.
4138  */
4139 void
4140 mono_llvm_check_method_supported (MonoCompile *cfg)
4141 {
4142         MonoMethodHeader *header = cfg->header;
4143         MonoExceptionClause *clause;
4144         int i;
4145
4146         if (cfg->method->save_lmf) {
4147                 cfg->exception_message = g_strdup ("lmf");
4148                 cfg->disable_llvm = TRUE;
4149         }
4150
4151 #if 1
4152         for (i = 0; i < header->num_clauses; ++i) {
4153                 clause = &header->clauses [i];
4154
4155                 if (i > 0 && clause->try_offset <= header->clauses [i - 1].handler_offset + header->clauses [i - 1].handler_len) {
4156                         /*
4157                          * FIXME: Some tests still fail with nested clauses.
4158                          */
4159                         cfg->exception_message = g_strdup ("nested clauses");
4160                         cfg->disable_llvm = TRUE;
4161                 }
4162         }
4163 #endif
4164
4165         /* FIXME: */
4166         if (cfg->method->dynamic) {
4167                 cfg->exception_message = g_strdup ("dynamic.");
4168                 cfg->disable_llvm = TRUE;
4169         }
4170 }
4171
4172 /*
4173  * mono_llvm_emit_method:
4174  *
4175  *   Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
4176  */
4177 void
4178 mono_llvm_emit_method (MonoCompile *cfg)
4179 {
4180         EmitContext *ctx;
4181         MonoMethodSignature *sig;
4182         MonoBasicBlock *bb;
4183         LLVMTypeRef method_type;
4184         LLVMValueRef method = NULL;
4185         char *method_name;
4186         LLVMValueRef *values;
4187         int i, max_block_num, bb_index;
4188         gboolean last = FALSE;
4189         GPtrArray *phi_values;
4190         LLVMCallInfo *linfo;
4191         GSList *l;
4192         LLVMModuleRef module;
4193         BBInfo *bblocks;
4194         GPtrArray *bblock_list;
4195         MonoMethodHeader *header;
4196         MonoExceptionClause *clause;
4197         LLVMSigInfo sinfo;
4198         char **names;
4199
4200         /* The code below might acquire the loader lock, so use it for global locking */
4201         mono_loader_lock ();
4202
4203         /* Used to communicate with the callbacks */
4204         mono_native_tls_set_value (current_cfg_tls_id, cfg);
4205
4206         ctx = g_new0 (EmitContext, 1);
4207         ctx->cfg = cfg;
4208         ctx->mempool = cfg->mempool;
4209
4210         /*
4211          * This maps vregs to the LLVM instruction defining them
4212          */
4213         values = g_new0 (LLVMValueRef, cfg->next_vreg);
4214         /*
4215          * This maps vregs for volatile variables to the LLVM instruction defining their
4216          * address.
4217          */
4218         ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
4219         ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
4220         ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
4221         phi_values = g_ptr_array_new ();
4222         /*
4223          * This signals whenever the vreg was defined by a phi node with no input vars
4224          * (i.e. all its input bblocks end with NOT_REACHABLE).
4225          */
4226         ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
4227         /* Whenever the bblock is unreachable */
4228         ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
4229
4230         bblock_list = g_ptr_array_new ();
4231
4232         ctx->values = values;
4233         ctx->region_to_handler = g_hash_table_new (NULL, NULL);
4234
4235         if (cfg->compile_aot) {
4236                 ctx->lmodule = &aot_module;
4237                 method_name = mono_aot_get_method_name (cfg);
4238                 cfg->llvm_method_name = g_strdup (method_name);
4239         } else {
4240                 init_jit_module ();
4241                 ctx->lmodule = &jit_module;
4242                 method_name = mono_method_full_name (cfg->method, TRUE);
4243         }
4244
4245         module = ctx->module = ctx->lmodule->module;
4246
4247         if (cfg->gsharedvt)
4248                 LLVM_FAILURE (ctx, "gsharedvt");
4249
4250 #if 1
4251         {
4252                 static int count = 0;
4253                 count ++;
4254
4255                 if (g_getenv ("LLVM_COUNT")) {
4256                         if (count == atoi (g_getenv ("LLVM_COUNT"))) {
4257                                 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
4258                                 fflush (stdout);
4259                                 last = TRUE;
4260                         }
4261                         if (count > atoi (g_getenv ("LLVM_COUNT")))
4262                                 LLVM_FAILURE (ctx, "");
4263                 }
4264         }
4265 #endif
4266
4267         sig = mono_method_signature (cfg->method);
4268         ctx->sig = sig;
4269
4270         linfo = mono_arch_get_llvm_call_info (cfg, sig);
4271         ctx->linfo = linfo;
4272         CHECK_FAILURE (ctx);
4273
4274         if (cfg->rgctx_var)
4275                 linfo->rgctx_arg = TRUE;
4276         method_type = sig_to_llvm_sig_full (ctx, sig, linfo, &sinfo);
4277         CHECK_FAILURE (ctx);
4278
4279         /*
4280          * This maps parameter indexes in the original signature to the indexes in
4281          * the LLVM signature.
4282          */
4283         ctx->pindexes = sinfo.pindexes;
4284
4285         method = LLVMAddFunction (module, method_name, method_type);
4286         ctx->lmethod = method;
4287
4288         LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
4289         LLVMSetLinkage (method, LLVMPrivateLinkage);
4290
4291         LLVMAddFunctionAttr (method, LLVMUWTable);
4292
4293         if (cfg->compile_aot) {
4294                 LLVMSetLinkage (method, LLVMInternalLinkage);
4295                 LLVMSetVisibility (method, LLVMHiddenVisibility);
4296         } else {
4297                 LLVMSetLinkage (method, LLVMPrivateLinkage);
4298         }
4299
4300         if (cfg->method->save_lmf)
4301                 LLVM_FAILURE (ctx, "lmf");
4302
4303         if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
4304                 LLVM_FAILURE (ctx, "pinvoke signature");
4305
4306         header = cfg->header;
4307         for (i = 0; i < header->num_clauses; ++i) {
4308                 clause = &header->clauses [i];
4309                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
4310                         LLVM_FAILURE (ctx, "non-finally/catch clause.");
4311         }
4312
4313         if (linfo->rgctx_arg) {
4314                 ctx->rgctx_arg = LLVMGetParam (method, sinfo.rgctx_arg_pindex);
4315                 /*
4316                  * We mark the rgctx parameter with the inreg attribute, which is mapped to
4317                  * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
4318                  * CC_X86_64_Mono in X86CallingConv.td.
4319                  */
4320                 LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
4321                 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
4322         }
4323         if (cfg->vret_addr) {
4324                 values [cfg->vret_addr->dreg] = LLVMGetParam (method, sinfo.vret_arg_pindex);
4325                 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
4326         }
4327         if (sig->hasthis) {
4328                 values [cfg->args [0]->dreg] = LLVMGetParam (method, sinfo.this_arg_pindex);
4329                 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
4330         }
4331
4332         names = g_new (char *, sig->param_count);
4333         mono_method_get_param_names (cfg->method, (const char **) names);
4334
4335         for (i = 0; i < sig->param_count; ++i) {
4336                 char *name;
4337
4338                 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, sinfo.pindexes [i]);
4339                 if (names [i] && names [i][0] != '\0')
4340                         name = g_strdup_printf ("arg_%s", names [i]);
4341                 else
4342                         name = g_strdup_printf ("arg_%d", i);
4343                 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
4344                 g_free (name);
4345                 if (linfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal)
4346                         LLVMAddAttribute (LLVMGetParam (method, sinfo.pindexes [i]), LLVMByValAttribute);
4347         }
4348         g_free (names);
4349
4350         max_block_num = 0;
4351         for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
4352                 max_block_num = MAX (max_block_num, bb->block_num);
4353         ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
4354
4355         /* Add branches between non-consecutive bblocks */
4356         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4357                 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
4358                         bb->next_bb != bb->last_ins->inst_false_bb) {
4359
4360                         MonoInst *inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
4361                         inst->opcode = OP_BR;
4362                         inst->inst_target_bb = bb->last_ins->inst_false_bb;
4363                         mono_bblock_add_inst (bb, inst);
4364                 }
4365         }
4366
4367         /*
4368          * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
4369          * was later optimized away, so clear these flags, and add them back for the still
4370          * present OP_LDADDR instructions.
4371          */
4372         for (i = 0; i < cfg->next_vreg; ++i) {
4373                 MonoInst *ins;
4374
4375                 ins = get_vreg_to_inst (cfg, i);
4376                 if (ins && ins != cfg->rgctx_var)
4377                         ins->flags &= ~MONO_INST_INDIRECT;
4378         }
4379
4380         /*
4381          * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
4382          */
4383         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4384                 MonoInst *ins;
4385                 LLVMBuilderRef builder;
4386                 char *dname;
4387                 char dname_buf[128];
4388
4389                 builder = create_builder (ctx);
4390
4391                 for (ins = bb->code; ins; ins = ins->next) {
4392                         switch (ins->opcode) {
4393                         case OP_PHI:
4394                         case OP_FPHI:
4395                         case OP_VPHI:
4396                         case OP_XPHI: {
4397                                 LLVMTypeRef phi_type = llvm_type_to_stack_type (type_to_llvm_type (ctx, &ins->klass->byval_arg));
4398
4399                                 CHECK_FAILURE (ctx);
4400
4401                                 if (ins->opcode == OP_VPHI) {
4402                                         /* Treat valuetype PHI nodes as operating on the address itself */
4403                                         g_assert (ins->klass);
4404                                         phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
4405                                 }
4406
4407                                 /*
4408                                  * Have to precreate these, as they can be referenced by
4409                                  * earlier instructions.
4410                                  */
4411                                 sprintf (dname_buf, "t%d", ins->dreg);
4412                                 dname = dname_buf;
4413                                 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
4414
4415                                 if (ins->opcode == OP_VPHI)
4416                                         ctx->addresses [ins->dreg] = values [ins->dreg];
4417
4418                                 g_ptr_array_add (phi_values, values [ins->dreg]);
4419
4420                                 /*
4421                                  * Set the expected type of the incoming arguments since these have
4422                                  * to have the same type.
4423                                  */
4424                                 for (i = 0; i < ins->inst_phi_args [0]; i++) {
4425                                         int sreg1 = ins->inst_phi_args [i + 1];
4426
4427                                         if (sreg1 != -1)
4428                                                 ctx->vreg_types [sreg1] = phi_type;
4429                                 }
4430                                 break;
4431                                 }
4432                         case OP_LDADDR:
4433                                 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
4434                                 break;
4435                         default:
4436                                 break;
4437                         }
4438                 }
4439         }
4440
4441         /*
4442          * Create an ordering for bblocks, use the depth first order first, then
4443          * put the exception handling bblocks last.
4444          */
4445         for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
4446                 bb = cfg->bblocks [bb_index];
4447                 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
4448                         g_ptr_array_add (bblock_list, bb);
4449                         bblocks [bb->block_num].added = TRUE;
4450                 }
4451         }
4452
4453         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4454                 if (!bblocks [bb->block_num].added)
4455                         g_ptr_array_add (bblock_list, bb);
4456         }
4457
4458         /*
4459          * Second pass: generate code.
4460          */
4461         for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
4462                 bb = g_ptr_array_index (bblock_list, bb_index);
4463
4464                 if (!(bb == cfg->bb_entry || bb->in_count > 0))
4465                         continue;
4466
4467                 process_bb (ctx, bb);
4468                 CHECK_FAILURE (ctx);
4469         }
4470
4471         /* Add incoming phi values */
4472         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4473                 GSList *l, *ins_list;
4474
4475                 ins_list = bblocks [bb->block_num].phi_nodes;
4476
4477                 for (l = ins_list; l; l = l->next) {
4478                         PhiNode *node = l->data;
4479                         MonoInst *phi = node->phi;
4480                         int sreg1 = node->sreg;
4481                         LLVMBasicBlockRef in_bb;
4482
4483                         if (sreg1 == -1)
4484                                 continue;
4485
4486                         in_bb = get_end_bb (ctx, node->in_bb);
4487
4488                         if (ctx->unreachable [node->in_bb->block_num])
4489                                 continue;
4490
4491                         if (!values [sreg1])
4492                                 /* Can happen with values in EH clauses */
4493                                 LLVM_FAILURE (ctx, "incoming phi sreg1");
4494
4495                         if (phi->opcode == OP_VPHI) {
4496                                 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4497                                 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
4498                         } else {
4499                                 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4500                                 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
4501                         }
4502                 }
4503         }
4504
4505         /* Create the SWITCH statements for ENDFINALLY instructions */
4506         for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4507                 BBInfo *info = &bblocks [bb->block_num];
4508                 GSList *l;
4509                 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
4510                         LLVMValueRef switch_ins = l->data;
4511                         GSList *bb_list = info->call_handler_return_bbs;
4512
4513                         for (i = 0; i < g_slist_length (bb_list); ++i)
4514                                 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), g_slist_nth (bb_list, i)->data);
4515                 }
4516         }
4517
4518         if (cfg->verbose_level > 1)
4519                 mono_llvm_dump_value (method);
4520
4521         mark_as_used (module, method);
4522
4523         if (cfg->compile_aot) {
4524                 LLVMValueRef md_args [16];
4525                 LLVMValueRef md_node;
4526                 int method_index;
4527
4528                 method_index = mono_aot_get_method_index (cfg->orig_method);
4529                 md_args [0] = LLVMMDString (method_name, strlen (method_name));
4530                 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
4531                 md_node = LLVMMDNode (md_args, 2);
4532                 LLVMAddNamedMetadataOperand (module, "mono.function_indexes", md_node);
4533                 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
4534         }
4535
4536         if (cfg->compile_aot) {
4537                 /* Don't generate native code, keep the LLVM IR */
4538                 if (cfg->compile_aot && cfg->verbose_level)
4539                         printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), method_name);
4540
4541                 //LLVMVerifyFunction(method, 0);
4542         } else {
4543                 mono_llvm_optimize_method (method);
4544
4545                 if (cfg->verbose_level > 1)
4546                         mono_llvm_dump_value (method);
4547
4548                 cfg->native_code = LLVMGetPointerToGlobal (ee, method);
4549
4550                 /* Set by emit_cb */
4551                 g_assert (cfg->code_len);
4552
4553                 /* FIXME: Free the LLVM IL for the function */
4554         }
4555
4556         goto CLEANUP;
4557
4558  FAILURE:
4559
4560         if (method) {
4561                 /* Need to add unused phi nodes as they can be referenced by other values */
4562                 LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (method, "PHI_BB");
4563                 LLVMBuilderRef builder;
4564
4565                 builder = create_builder (ctx);
4566                 LLVMPositionBuilderAtEnd (builder, phi_bb);
4567
4568                 for (i = 0; i < phi_values->len; ++i) {
4569                         LLVMValueRef v = g_ptr_array_index (phi_values, i);
4570                         if (LLVMGetInstructionParent (v) == NULL)
4571                                 LLVMInsertIntoBuilder (builder, v);
4572                 }
4573
4574                 LLVMDeleteFunction (method);
4575         }
4576
4577  CLEANUP:
4578         g_free (values);
4579         g_free (ctx->addresses);
4580         g_free (ctx->vreg_types);
4581         g_free (ctx->vreg_cli_types);
4582         g_free (ctx->pindexes);
4583         g_free (ctx->is_dead);
4584         g_free (ctx->unreachable);
4585         g_ptr_array_free (phi_values, TRUE);
4586         g_free (ctx->bblocks);
4587         g_hash_table_destroy (ctx->region_to_handler);
4588         g_free (method_name);
4589         g_ptr_array_free (bblock_list, TRUE);
4590
4591         for (l = ctx->builders; l; l = l->next) {
4592                 LLVMBuilderRef builder = l->data;
4593                 LLVMDisposeBuilder (builder);
4594         }
4595
4596         g_free (ctx);
4597
4598         mono_native_tls_set_value (current_cfg_tls_id, NULL);
4599
4600         mono_loader_unlock ();
4601 }
4602
4603 /*
4604  * mono_llvm_emit_call:
4605  *
4606  *   Same as mono_arch_emit_call () for LLVM.
4607  */
4608 void
4609 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
4610 {
4611         MonoInst *in;
4612         MonoMethodSignature *sig;
4613         int i, n, stack_size;
4614         LLVMArgInfo *ainfo;
4615
4616         stack_size = 0;
4617
4618         sig = call->signature;
4619         n = sig->param_count + sig->hasthis;
4620
4621         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4622
4623         if (cfg->disable_llvm)
4624                 return;
4625
4626         if (sig->call_convention == MONO_CALL_VARARG) {
4627                 cfg->exception_message = g_strdup ("varargs");
4628                 cfg->disable_llvm = TRUE;
4629         }
4630
4631         for (i = 0; i < n; ++i) {
4632                 MonoInst *ins;
4633
4634                 ainfo = call->cinfo->args + i;
4635
4636                 in = call->args [i];
4637
4638                 /* Simply remember the arguments */
4639                 switch (ainfo->storage) {
4640                 case LLVMArgInIReg:
4641                 case LLVMArgInFPReg: {
4642                         MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : sig->params [i - sig->hasthis];
4643
4644                         if (!t->byref && (t->type == MONO_TYPE_R8 || t->type == MONO_TYPE_R4)) {
4645                                 MONO_INST_NEW (cfg, ins, OP_FMOVE);
4646                                 ins->dreg = mono_alloc_freg (cfg);
4647                         } else {
4648                                 MONO_INST_NEW (cfg, ins, OP_MOVE);
4649                                 ins->dreg = mono_alloc_ireg (cfg);
4650                         }
4651                         ins->sreg1 = in->dreg;
4652                         break;
4653                 }
4654                 case LLVMArgVtypeByVal:
4655                 case LLVMArgVtypeInReg:
4656                         MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
4657                         ins->dreg = mono_alloc_ireg (cfg);
4658                         ins->sreg1 = in->dreg;
4659                         ins->klass = mono_class_from_mono_type (sig->params [i - sig->hasthis]);
4660                         break;
4661                 default:
4662                         call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4663                         cfg->exception_message = g_strdup ("ainfo->storage");
4664                         cfg->disable_llvm = TRUE;
4665                         return;
4666                 }
4667
4668                 if (!cfg->disable_llvm) {
4669                         MONO_ADD_INS (cfg->cbb, ins);
4670                         mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
4671                 }
4672         }
4673 }
4674
4675 static unsigned char*
4676 alloc_cb (LLVMValueRef function, int size)
4677 {
4678         MonoCompile *cfg;
4679
4680         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4681
4682         if (cfg) {
4683                 // FIXME: dynamic
4684                 return mono_domain_code_reserve (cfg->domain, size);
4685         } else {
4686                 return mono_domain_code_reserve (mono_domain_get (), size);
4687         }
4688 }
4689
4690 static void
4691 emitted_cb (LLVMValueRef function, void *start, void *end)
4692 {
4693         MonoCompile *cfg;
4694
4695         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4696         g_assert (cfg);
4697         cfg->code_len = (guint8*)end - (guint8*)start;
4698 }
4699
4700 static void
4701 exception_cb (void *data)
4702 {
4703         MonoCompile *cfg;
4704         MonoJitExceptionInfo *ei;
4705         guint32 ei_len, i, j, nested_len, nindex;
4706         gpointer *type_info;
4707         int this_reg, this_offset;
4708
4709         cfg = mono_native_tls_get_value (current_cfg_tls_id);
4710         g_assert (cfg);
4711
4712         /*
4713          * data points to a DWARF FDE structure, convert it to our unwind format and
4714          * save it.
4715          * An alternative would be to save it directly, and modify our unwinder to work
4716          * with it.
4717          */
4718         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);
4719
4720         /* Count nested clauses */
4721         nested_len = 0;
4722         for (i = 0; i < ei_len; ++i) {
4723                 for (j = 0; j < ei_len; ++j) {
4724                         gint32 cindex1 = *(gint32*)type_info [i];
4725                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4726                         gint32 cindex2 = *(gint32*)type_info [j];
4727                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4728
4729                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4730                                 nested_len ++;
4731                         }
4732                 }
4733         }
4734
4735         cfg->llvm_ex_info = mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
4736         cfg->llvm_ex_info_len = ei_len + nested_len;
4737         memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
4738         /* Fill the rest of the information from the type info */
4739         for (i = 0; i < ei_len; ++i) {
4740                 gint32 clause_index = *(gint32*)type_info [i];
4741                 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
4742
4743                 cfg->llvm_ex_info [i].flags = clause->flags;
4744                 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
4745         }
4746
4747         /*
4748          * For nested clauses, the LLVM produced exception info associates the try interval with
4749          * the innermost handler, while mono expects it to be associated with all nesting clauses.
4750          */
4751         /* FIXME: These should be order with the normal clauses */
4752         nindex = ei_len;
4753         for (i = 0; i < ei_len; ++i) {
4754                 for (j = 0; j < ei_len; ++j) {
4755                         gint32 cindex1 = *(gint32*)type_info [i];
4756                         MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4757                         gint32 cindex2 = *(gint32*)type_info [j];
4758                         MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4759
4760                         if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4761                                 /*
4762                                  * The try interval comes from the nested clause, everything else from the
4763                                  * nesting clause.
4764                                  */
4765                                 memcpy (&cfg->llvm_ex_info [nindex], &cfg->llvm_ex_info [j], sizeof (MonoJitExceptionInfo));
4766                                 cfg->llvm_ex_info [nindex].try_start = cfg->llvm_ex_info [i].try_start;
4767                                 cfg->llvm_ex_info [nindex].try_end = cfg->llvm_ex_info [i].try_end;
4768                                 nindex ++;
4769                         }
4770                 }
4771         }
4772         g_assert (nindex == ei_len + nested_len);
4773         cfg->llvm_this_reg = this_reg;
4774         cfg->llvm_this_offset = this_offset;
4775
4776         /* type_info [i] is cfg mempool allocated, no need to free it */
4777
4778         g_free (ei);
4779         g_free (type_info);
4780 }
4781
4782 static char*
4783 dlsym_cb (const char *name, void **symbol)
4784 {
4785         MonoDl *current;
4786         char *err;
4787
4788         err = NULL;
4789         if (!strcmp (name, "__bzero")) {
4790                 *symbol = (void*)bzero;
4791         } else {
4792                 current = mono_dl_open (NULL, 0, NULL);
4793                 g_assert (current);
4794
4795                 err = mono_dl_symbol (current, name, symbol);
4796         }
4797 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
4798         *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
4799 #endif
4800         return err;
4801 }
4802
4803 static inline void
4804 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
4805 {
4806         LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
4807 }
4808
4809 static inline void
4810 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
4811 {
4812         LLVMTypeRef param_types [4];
4813
4814         param_types [0] = param_type1;
4815         param_types [1] = param_type2;
4816
4817         AddFunc (module, name, ret_type, param_types, 2);
4818 }
4819
4820 static void
4821 add_intrinsics (LLVMModuleRef module)
4822 {
4823         /* Emit declarations of instrinsics */
4824         /*
4825          * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
4826          * type doesn't seem to do any locking.
4827          */
4828         {
4829                 LLVMTypeRef memset_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4830
4831                 memset_param_count = 5;
4832                 memset_func_name = "llvm.memset.p0i8.i32";
4833
4834                 LLVMAddFunction (module, memset_func_name, LLVMFunctionType (LLVMVoidType (), memset_params, memset_param_count, FALSE));
4835         }
4836
4837         {
4838                 LLVMTypeRef memcpy_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4839
4840                 memcpy_param_count = 5;
4841                 memcpy_func_name = "llvm.memcpy.p0i8.p0i8.i32";
4842
4843                 LLVMAddFunction (module, memcpy_func_name, LLVMFunctionType (LLVMVoidType (), memcpy_params, memcpy_param_count, FALSE));
4844         }
4845
4846         {
4847                 LLVMTypeRef params [] = { LLVMDoubleType () };
4848
4849                 LLVMAddFunction (module, "llvm.sin.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4850                 LLVMAddFunction (module, "llvm.cos.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4851                 LLVMAddFunction (module, "llvm.sqrt.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4852
4853                 /* This isn't an intrinsic, instead llvm seems to special case it by name */
4854                 LLVMAddFunction (module, "fabs", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4855         }
4856
4857         {
4858                 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
4859                 LLVMTypeRef ovf_params_i32 [] = { LLVMInt32Type (), LLVMInt32Type () };
4860
4861                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4862                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4863                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4864                 LLVMAddFunction (module, "llvm.usub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4865                 LLVMAddFunction (module, "llvm.smul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4866                 LLVMAddFunction (module, "llvm.umul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4867         }
4868
4869         {
4870                 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
4871                 LLVMTypeRef ovf_params_i64 [] = { LLVMInt64Type (), LLVMInt64Type () };
4872
4873                 LLVMAddFunction (module, "llvm.sadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4874                 LLVMAddFunction (module, "llvm.uadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4875                 LLVMAddFunction (module, "llvm.ssub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4876                 LLVMAddFunction (module, "llvm.usub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4877                 LLVMAddFunction (module, "llvm.smul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4878                 LLVMAddFunction (module, "llvm.umul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4879         }
4880
4881         /* EH intrinsics */
4882         {
4883                 LLVMTypeRef arg_types [2];
4884                 LLVMTypeRef ret_type;
4885
4886                 arg_types [0] = LLVMPointerType (LLVMInt8Type (), 0);
4887                 arg_types [1] = LLVMPointerType (LLVMInt8Type (), 0);
4888                 ret_type = LLVMInt32Type ();
4889
4890                 LLVMAddFunction (module, "mono_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4891
4892                 LLVMAddFunction (module, "llvm_resume_unwind_trampoline", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4893         }
4894
4895         /* SSE intrinsics */
4896         {
4897                 LLVMTypeRef ret_type, arg_types [16];
4898
4899                 /* Binary ops */
4900                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4901                 arg_types [0] = ret_type;
4902                 arg_types [1] = ret_type;
4903                 AddFunc (module, "llvm.x86.sse41.pminud", ret_type, arg_types, 2);
4904                 AddFunc (module, "llvm.x86.sse41.pmaxud", ret_type, arg_types, 2);
4905
4906                 ret_type = type_to_simd_type (MONO_TYPE_I2);
4907                 arg_types [0] = ret_type;
4908                 arg_types [1] = ret_type;
4909                 AddFunc (module, "llvm.x86.sse41.pminuw", ret_type, arg_types, 2);
4910                 AddFunc (module, "llvm.x86.sse2.pmins.w", ret_type, arg_types, 2);
4911                 AddFunc (module, "llvm.x86.sse41.pmaxuw", ret_type, arg_types, 2);
4912                 AddFunc (module, "llvm.x86.sse2.padds.w", ret_type, arg_types, 2);
4913                 AddFunc (module, "llvm.x86.sse2.psubs.w", ret_type, arg_types, 2);
4914                 AddFunc (module, "llvm.x86.sse2.paddus.w", ret_type, arg_types, 2);
4915                 AddFunc (module, "llvm.x86.sse2.psubus.w", ret_type, arg_types, 2);
4916                 AddFunc (module, "llvm.x86.sse2.pavg.w", ret_type, arg_types, 2);
4917                 AddFunc (module, "llvm.x86.sse2.pmulh.w", ret_type, arg_types, 2);
4918                 AddFunc (module, "llvm.x86.sse2.pmulhu.w", ret_type, arg_types, 2);
4919
4920                 ret_type = type_to_simd_type (MONO_TYPE_I1);
4921                 arg_types [0] = ret_type;
4922                 arg_types [1] = ret_type;
4923                 AddFunc (module, "llvm.x86.sse2.pminu.b", ret_type, arg_types, 2);
4924                 AddFunc (module, "llvm.x86.sse2.pmaxu.b", ret_type, arg_types, 2);
4925                 AddFunc (module, "llvm.x86.sse2.padds.b", ret_type, arg_types, 2);
4926                 AddFunc (module, "llvm.x86.sse2.psubs.b", ret_type, arg_types, 2);
4927                 AddFunc (module, "llvm.x86.sse2.paddus.b", ret_type, arg_types, 2);
4928                 AddFunc (module, "llvm.x86.sse2.psubus.b", ret_type, arg_types, 2);
4929                 AddFunc (module, "llvm.x86.sse2.pavg.b", ret_type, arg_types, 2);
4930
4931                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4932                 arg_types [0] = ret_type;
4933                 arg_types [1] = ret_type;
4934                 AddFunc (module, "llvm.x86.sse2.min.pd", ret_type, arg_types, 2);
4935                 AddFunc (module, "llvm.x86.sse2.max.pd", ret_type, arg_types, 2);
4936                 AddFunc (module, "llvm.x86.sse3.hadd.pd", ret_type, arg_types, 2);
4937                 AddFunc (module, "llvm.x86.sse3.hsub.pd", ret_type, arg_types, 2);
4938                 AddFunc (module, "llvm.x86.sse3.addsub.pd", ret_type, arg_types, 2);
4939
4940                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4941                 arg_types [0] = ret_type;
4942                 arg_types [1] = ret_type;
4943                 AddFunc (module, "llvm.x86.sse.min.ps", ret_type, arg_types, 2);
4944                 AddFunc (module, "llvm.x86.sse.max.ps", ret_type, arg_types, 2);
4945                 AddFunc (module, "llvm.x86.sse3.hadd.ps", ret_type, arg_types, 2);
4946                 AddFunc (module, "llvm.x86.sse3.hsub.ps", ret_type, arg_types, 2);
4947                 AddFunc (module, "llvm.x86.sse3.addsub.ps", ret_type, arg_types, 2);
4948
4949                 /* pack */
4950                 ret_type = type_to_simd_type (MONO_TYPE_I1);
4951                 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
4952                 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
4953                 AddFunc (module, "llvm.x86.sse2.packsswb.128", ret_type, arg_types, 2);
4954                 AddFunc (module, "llvm.x86.sse2.packuswb.128", ret_type, arg_types, 2);
4955                 ret_type = type_to_simd_type (MONO_TYPE_I2);
4956                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4957                 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
4958                 AddFunc (module, "llvm.x86.sse2.packssdw.128", ret_type, arg_types, 2);
4959                 AddFunc (module, "llvm.x86.sse41.packusdw", ret_type, arg_types, 2);
4960
4961                 /* cmp pd/ps */
4962                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4963                 arg_types [0] = ret_type;
4964                 arg_types [1] = ret_type;
4965                 arg_types [2] = LLVMInt8Type ();
4966                 AddFunc (module, "llvm.x86.sse2.cmp.pd", ret_type, arg_types, 3);
4967                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4968                 arg_types [0] = ret_type;
4969                 arg_types [1] = ret_type;
4970                 arg_types [2] = LLVMInt8Type ();
4971                 AddFunc (module, "llvm.x86.sse.cmp.ps", ret_type, arg_types, 3);
4972
4973                 /* Conversion ops */
4974                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4975                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4976                 AddFunc (module, "llvm.x86.sse2.cvtdq2pd", ret_type, arg_types, 1);
4977                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4978                 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4979                 AddFunc (module, "llvm.x86.sse2.cvtdq2ps", ret_type, arg_types, 1);
4980                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4981                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4982                 AddFunc (module, "llvm.x86.sse2.cvtpd2dq", ret_type, arg_types, 1);
4983                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4984                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4985                 AddFunc (module, "llvm.x86.sse2.cvtps2dq", ret_type, arg_types, 1);
4986                 ret_type = type_to_simd_type (MONO_TYPE_R4);
4987                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4988                 AddFunc (module, "llvm.x86.sse2.cvtpd2ps", ret_type, arg_types, 1);
4989                 ret_type = type_to_simd_type (MONO_TYPE_R8);
4990                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4991                 AddFunc (module, "llvm.x86.sse2.cvtps2pd", ret_type, arg_types, 1);
4992
4993                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4994                 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4995                 AddFunc (module, "llvm.x86.sse2.cvttpd2dq", ret_type, arg_types, 1);
4996                 ret_type = type_to_simd_type (MONO_TYPE_I4);
4997                 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4998                 AddFunc (module, "llvm.x86.sse2.cvttps2dq", ret_type, arg_types, 1);
4999
5000                 /* Unary ops */
5001                 ret_type = type_to_simd_type (MONO_TYPE_R8);
5002                 arg_types [0] = ret_type;
5003                 AddFunc (module, "llvm.x86.sse2.sqrt.pd", ret_type, arg_types, 1);
5004                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5005                 arg_types [0] = ret_type;
5006                 AddFunc (module, "llvm.x86.sse.sqrt.ps", ret_type, arg_types, 1);
5007                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5008                 arg_types [0] = ret_type;
5009                 AddFunc (module, "llvm.x86.sse.rsqrt.ps", ret_type, arg_types, 1);
5010                 ret_type = type_to_simd_type (MONO_TYPE_R4);
5011                 arg_types [0] = ret_type;
5012                 AddFunc (module, "llvm.x86.sse.rcp.ps", ret_type, arg_types, 1);
5013
5014                 /* shifts */
5015                 ret_type = type_to_simd_type (MONO_TYPE_I2);
5016                 arg_types [0] = ret_type;
5017                 arg_types [1] = LLVMInt32Type ();
5018                 AddFunc (module, "llvm.x86.sse2.psrli.w", ret_type, arg_types, 2);
5019                 AddFunc (module, "llvm.x86.sse2.psrai.w", ret_type, arg_types, 2);
5020                 AddFunc (module, "llvm.x86.sse2.pslli.w", ret_type, arg_types, 2);
5021                 ret_type = type_to_simd_type (MONO_TYPE_I4);
5022                 arg_types [0] = ret_type;
5023                 arg_types [1] = LLVMInt32Type ();
5024                 AddFunc (module, "llvm.x86.sse2.psrli.d", ret_type, arg_types, 2);
5025                 AddFunc (module, "llvm.x86.sse2.psrai.d", ret_type, arg_types, 2);
5026                 AddFunc (module, "llvm.x86.sse2.pslli.d", ret_type, arg_types, 2);
5027                 ret_type = type_to_simd_type (MONO_TYPE_I8);
5028                 arg_types [0] = ret_type;
5029                 arg_types [1] = LLVMInt32Type ();
5030                 AddFunc (module, "llvm.x86.sse2.psrli.q", ret_type, arg_types, 2);
5031                 AddFunc (module, "llvm.x86.sse2.pslli.q", ret_type, arg_types, 2);
5032
5033                 /* pmovmskb */
5034                 ret_type = LLVMInt32Type ();
5035                 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
5036                 AddFunc (module, "llvm.x86.sse2.pmovmskb.128", ret_type, arg_types, 1);
5037         }
5038
5039         AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
5040
5041         /* Load/Store intrinsics */
5042         {
5043                 LLVMTypeRef arg_types [5];
5044                 int i;
5045                 char name [128];
5046
5047                 for (i = 1; i <= 8; i *= 2) {
5048                         arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
5049                         arg_types [1] = LLVMInt32Type ();
5050                         arg_types [2] = LLVMInt1Type ();
5051                         sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
5052                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMIntType (i * 8), arg_types, 3, FALSE));
5053
5054                         arg_types [0] = LLVMIntType (i * 8);
5055                         arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
5056                         arg_types [2] = LLVMInt32Type ();
5057                         arg_types [3] = LLVMInt1Type ();
5058                         sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
5059                         LLVMAddFunction (module, name, LLVMFunctionType (LLVMVoidType (), arg_types, 4, FALSE));
5060                 }
5061         }
5062 }
5063
5064 void
5065 mono_llvm_init (void)
5066 {
5067         mono_native_tls_alloc (&current_cfg_tls_id, NULL);
5068 }
5069
5070 static void
5071 init_jit_module (void)
5072 {
5073         MonoJitICallInfo *info;
5074
5075         if (jit_module_inited)
5076                 return;
5077
5078         mono_loader_lock ();
5079
5080         if (jit_module_inited) {
5081                 mono_loader_unlock ();
5082                 return;
5083         }
5084
5085         jit_module.module = LLVMModuleCreateWithName ("mono");
5086
5087         ee = mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (jit_module.module), alloc_cb, emitted_cb, exception_cb, dlsym_cb);
5088
5089         add_intrinsics (jit_module.module);
5090
5091         jit_module.llvm_types = g_hash_table_new (NULL, NULL);
5092
5093         info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
5094         g_assert (info);
5095         LLVMAddGlobalMapping (ee, LLVMGetNamedFunction (jit_module.module, "llvm_resume_unwind_trampoline"), (void*)info->func);
5096
5097         jit_module_inited = TRUE;
5098
5099         mono_loader_unlock ();
5100 }
5101
5102 void
5103 mono_llvm_cleanup (void)
5104 {
5105         if (ee)
5106                 mono_llvm_dispose_ee (ee);
5107
5108         if (jit_module.llvm_types)
5109                 g_hash_table_destroy (jit_module.llvm_types);
5110
5111         if (aot_module.module)
5112                 LLVMDisposeModule (aot_module.module);
5113
5114         LLVMContextDispose (LLVMGetGlobalContext ());
5115 }
5116
5117 void
5118 mono_llvm_create_aot_module (const char *got_symbol)
5119 {
5120         /* Delete previous module */
5121         if (aot_module.plt_entries)
5122                 g_hash_table_destroy (aot_module.plt_entries);
5123         if (aot_module.module)
5124                 LLVMDisposeModule (aot_module.module);
5125
5126         memset (&aot_module, 0, sizeof (aot_module));
5127
5128         aot_module.module = LLVMModuleCreateWithName ("aot");
5129         aot_module.got_symbol = got_symbol;
5130
5131         add_intrinsics (aot_module.module);
5132
5133         /* Add GOT */
5134         /*
5135          * We couldn't compute the type of the LLVM global representing the got because
5136          * its size is only known after all the methods have been emitted. So create
5137          * a dummy variable, and replace all uses it with the real got variable when
5138          * its size is known in mono_llvm_emit_aot_module ().
5139          */
5140         {
5141                 LLVMTypeRef got_type = LLVMArrayType (IntPtrType (), 0);
5142
5143                 aot_module.got_var = LLVMAddGlobal (aot_module.module, got_type, "mono_dummy_got");
5144                 LLVMSetInitializer (aot_module.got_var, LLVMConstNull (got_type));
5145         }
5146
5147         /* Add a dummy personality function */
5148         {
5149                 LLVMBasicBlockRef lbb;
5150                 LLVMBuilderRef lbuilder;
5151                 LLVMValueRef personality;
5152
5153                 personality = LLVMAddFunction (aot_module.module, "mono_aot_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
5154                 LLVMSetLinkage (personality, LLVMInternalLinkage);
5155                 lbb = LLVMAppendBasicBlock (personality, "BB0");
5156                 lbuilder = LLVMCreateBuilder ();
5157                 LLVMPositionBuilderAtEnd (lbuilder, lbb);
5158                 LLVMBuildRetVoid (lbuilder);
5159         }
5160
5161         aot_module.llvm_types = g_hash_table_new (NULL, NULL);
5162         aot_module.plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
5163 }
5164
5165 /*
5166  * Emit the aot module into the LLVM bitcode file FILENAME.
5167  */
5168 void
5169 mono_llvm_emit_aot_module (const char *filename, int got_size)
5170 {
5171         LLVMTypeRef got_type;
5172         LLVMValueRef real_got;
5173
5174         /*
5175          * Create the real got variable and replace all uses of the dummy variable with
5176          * the real one.
5177          */
5178         got_type = LLVMArrayType (IntPtrType (), got_size);
5179         real_got = LLVMAddGlobal (aot_module.module, got_type, aot_module.got_symbol);
5180         LLVMSetInitializer (real_got, LLVMConstNull (got_type));
5181         LLVMSetLinkage (real_got, LLVMInternalLinkage);
5182
5183         mono_llvm_replace_uses_of (aot_module.got_var, real_got);
5184
5185         mark_as_used (aot_module.module, real_got);
5186
5187         /* Delete the dummy got so it doesn't become a global */
5188         LLVMDeleteGlobal (aot_module.got_var);
5189
5190 #if 0
5191         {
5192                 char *verifier_err;
5193
5194                 if (LLVMVerifyModule (aot_module.module, LLVMReturnStatusAction, &verifier_err)) {
5195                         g_assert_not_reached ();
5196                 }
5197         }
5198 #endif
5199
5200         LLVMWriteBitcodeToFile (aot_module.module, filename);
5201 }
5202
5203 /*
5204   DESIGN:
5205   - Emit LLVM IR from the mono IR using the LLVM C API.
5206   - The original arch specific code remains, so we can fall back to it if we run
5207     into something we can't handle.
5208 */
5209
5210 /*
5211   A partial list of issues:
5212   - Handling of opcodes which can throw exceptions.
5213
5214       In the mono JIT, these are implemented using code like this:
5215           method:
5216       <compare>
5217           throw_pos:
5218           b<cond> ex_label
5219           <rest of code>
5220       ex_label:
5221           push throw_pos - method
5222           call <exception trampoline>
5223
5224           The problematic part is push throw_pos - method, which cannot be represented
5225       in the LLVM IR, since it does not support label values.
5226           -> this can be implemented in AOT mode using inline asm + labels, but cannot
5227           be implemented in JIT mode ?
5228           -> a possible but slower implementation would use the normal exception
5229       throwing code but it would need to control the placement of the throw code
5230       (it needs to be exactly after the compare+branch).
5231           -> perhaps add a PC offset intrinsics ?
5232
5233   - efficient implementation of .ovf opcodes.
5234
5235           These are currently implemented as:
5236           <ins which sets the condition codes>
5237           b<cond> ex_label
5238
5239           Some overflow opcodes are now supported by LLVM SVN.
5240
5241   - exception handling, unwinding.
5242     - SSA is disabled for methods with exception handlers
5243         - How to obtain unwind info for LLVM compiled methods ?
5244           -> this is now solved by converting the unwind info generated by LLVM
5245              into our format.
5246         - LLVM uses the c++ exception handling framework, while we use our home grown
5247       code, and couldn't use the c++ one:
5248       - its not supported under VC++, other exotic platforms.
5249           - it might be impossible to support filter clauses with it.
5250
5251   - trampolines.
5252
5253     The trampolines need a predictable call sequence, since they need to disasm
5254     the calling code to obtain register numbers / offsets.
5255
5256     LLVM currently generates this code in non-JIT mode:
5257            mov    -0x98(%rax),%eax
5258            callq  *%rax
5259     Here, the vtable pointer is lost.
5260     -> solution: use one vtable trampoline per class.
5261
5262   - passing/receiving the IMT pointer/RGCTX.
5263     -> solution: pass them as normal arguments ?
5264
5265   - argument passing.
5266
5267           LLVM does not allow the specification of argument registers etc. This means
5268       that all calls are made according to the platform ABI.
5269
5270   - passing/receiving vtypes.
5271
5272       Vtypes passed/received in registers are handled by the front end by using
5273           a signature with scalar arguments, and loading the parts of the vtype into those
5274           arguments.
5275
5276           Vtypes passed on the stack are handled using the 'byval' attribute.
5277
5278   - ldaddr.
5279
5280     Supported though alloca, we need to emit the load/store code.
5281
5282   - types.
5283
5284     The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
5285     typed registers, so we have to keep track of the precise LLVM type of each vreg.
5286     This is made easier because the IR is already in SSA form.
5287     An additional problem is that our IR is not consistent with types, i.e. i32/ia64
5288         types are frequently used incorrectly.
5289 */
5290
5291 /*
5292   AOT SUPPORT:
5293   Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then
5294   append the AOT data structures to that file. For methods which cannot be
5295   handled by LLVM, the normal JIT compiled versions are used.
5296 */
5297
5298 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
5299  *   - each bblock should end with a branch
5300  *   - setting the return value, making cfg->ret non-volatile
5301  * - avoid some transformations in the JIT which make it harder for us to generate
5302  *   code.
5303  * - use pointer types to help optimizations.
5304  */