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