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