2 * mini-llvm.c: llvm "Backend" for the mono JIT
4 * Copyright 2009-2011 Novell Inc (http://www.novell.com)
5 * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
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>
14 #ifndef __STDC_LIMIT_MACROS
15 #define __STDC_LIMIT_MACROS
17 #ifndef __STDC_CONSTANT_MACROS
18 #define __STDC_CONSTANT_MACROS
21 #include "llvm-c/Core.h"
22 #include "llvm-c/ExecutionEngine.h"
23 #include "llvm-c/BitWriter.h"
24 #include "llvm-c/Analysis.h"
26 #include "mini-llvm-cpp.h"
29 * Information associated by mono with LLVM modules.
33 LLVMValueRef throw, rethrow, throw_corlib_exception;
34 GHashTable *llvm_types;
36 const char *got_symbol;
37 GHashTable *plt_entries;
41 * Information associated by the backend with mono basic blocks.
44 LLVMBasicBlockRef bblock, end_bblock;
45 LLVMValueRef finally_ind;
46 gboolean added, invoke_target;
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.
51 GSList *call_handler_return_bbs;
53 * If this bblock is the start of a finally clause, this is the bblock that
54 * CALL_HANDLER needs to branch to.
56 LLVMBasicBlockRef call_handler_target_bb;
57 /* The list of switch statements generated by ENDFINALLY instructions */
58 GSList *endfinally_switch_ins_list;
63 * Structure containing emit state
68 /* Maps method names to the corresponding LLVMValueRef */
69 GHashTable *emitted_method_decls;
73 MonoLLVMModule *lmodule;
76 int sindex, default_index, ex_index;
77 LLVMBuilderRef builder;
78 LLVMValueRef *values, *addresses;
79 MonoType **vreg_cli_types;
81 MonoMethodSignature *sig;
83 GHashTable *region_to_handler;
84 LLVMBuilderRef alloca_builder;
85 LLVMValueRef last_alloca;
86 LLVMValueRef rgctx_arg;
87 LLVMTypeRef *vreg_types;
89 gboolean *unreachable;
98 MonoBasicBlock *in_bb;
103 * Instruction metadata
104 * This is the same as ins_info, but LREG != IREG.
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,
120 /* keep in sync with the enum in mini.h */
123 #include "mini-ops.h"
128 #if SIZEOF_VOID_P == 4
129 #define GET_LONG_IMM(ins) (((guint64)(ins)->inst_ms_word << 32) | (guint64)(guint32)(ins)->inst_ls_word)
131 #define GET_LONG_IMM(ins) ((ins)->inst_imm)
134 #define LLVM_INS_INFO(opcode) (&llvm_ins_info [((opcode) - OP_START - 1) * 4])
137 #define TRACE_FAILURE(msg) do { printf ("%s\n", msg); } while (0)
139 #define TRACE_FAILURE(msg)
143 #define IS_TARGET_X86 1
145 #define IS_TARGET_X86 0
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; \
155 #define CHECK_FAILURE(ctx) do { \
156 if ((ctx)->cfg->disable_llvm) \
160 static LLVMIntPredicate cond_to_llvm_cond [] = {
173 static LLVMRealPredicate fpcond_to_llvm_cond [] = {
186 static LLVMExecutionEngineRef ee;
187 static MonoNativeTlsKey current_cfg_tls_id;
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;
195 static void init_jit_module (void);
200 * The LLVM type with width == sizeof (gpointer)
205 return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
211 return sizeof (gpointer) == 8 ? LLVMPointerType (LLVMInt64Type (), 0) : LLVMPointerType (LLVMInt32Type (), 0);
217 * Return the size of the LLVM representation of the vtype T.
220 get_vtype_size (MonoType *t)
224 size = mono_class_value_size (mono_class_from_mono_type (t), NULL);
226 while (size < 2 * sizeof (gpointer) && mono_is_power_of_two (size) == -1)
233 * simd_class_to_llvm_type:
235 * Return the LLVM type corresponding to the Mono.SIMD class KLASS
238 simd_class_to_llvm_type (EmitContext *ctx, MonoClass *klass)
240 if (!strcmp (klass->name, "Vector2d")) {
241 return LLVMVectorType (LLVMDoubleType (), 2);
242 } else if (!strcmp (klass->name, "Vector2l")) {
243 return LLVMVectorType (LLVMInt64Type (), 2);
244 } else if (!strcmp (klass->name, "Vector2ul")) {
245 return LLVMVectorType (LLVMInt64Type (), 2);
246 } else if (!strcmp (klass->name, "Vector4i")) {
247 return LLVMVectorType (LLVMInt32Type (), 4);
248 } else if (!strcmp (klass->name, "Vector4ui")) {
249 return LLVMVectorType (LLVMInt32Type (), 4);
250 } else if (!strcmp (klass->name, "Vector4f")) {
251 return LLVMVectorType (LLVMFloatType (), 4);
252 } else if (!strcmp (klass->name, "Vector8s")) {
253 return LLVMVectorType (LLVMInt16Type (), 8);
254 } else if (!strcmp (klass->name, "Vector8us")) {
255 return LLVMVectorType (LLVMInt16Type (), 8);
256 } else if (!strcmp (klass->name, "Vector16sb")) {
257 return LLVMVectorType (LLVMInt8Type (), 16);
258 } else if (!strcmp (klass->name, "Vector16b")) {
259 return LLVMVectorType (LLVMInt8Type (), 16);
261 printf ("%s\n", klass->name);
267 /* Return the 128 bit SIMD type corresponding to the mono type TYPE */
268 static inline G_GNUC_UNUSED LLVMTypeRef
269 type_to_simd_type (int type)
273 return LLVMVectorType (LLVMInt8Type (), 16);
275 return LLVMVectorType (LLVMInt16Type (), 8);
277 return LLVMVectorType (LLVMInt32Type (), 4);
279 return LLVMVectorType (LLVMInt64Type (), 2);
281 return LLVMVectorType (LLVMDoubleType (), 2);
283 return LLVMVectorType (LLVMFloatType (), 4);
285 g_assert_not_reached ();
293 * Return the LLVM type corresponding to T.
296 type_to_llvm_type (EmitContext *ctx, MonoType *t)
299 return LLVMPointerType (LLVMInt8Type (), 0);
302 return LLVMVoidType ();
304 return LLVMInt8Type ();
306 return LLVMInt16Type ();
308 return LLVMInt32Type ();
310 return LLVMInt8Type ();
312 return LLVMInt16Type ();
314 return LLVMInt32Type ();
315 case MONO_TYPE_BOOLEAN:
316 return LLVMInt8Type ();
319 return LLVMInt64Type ();
321 return LLVMInt16Type ();
323 return LLVMFloatType ();
325 return LLVMDoubleType ();
328 return IntPtrType ();
329 case MONO_TYPE_OBJECT:
330 case MONO_TYPE_CLASS:
331 case MONO_TYPE_ARRAY:
332 case MONO_TYPE_SZARRAY:
333 case MONO_TYPE_STRING:
335 return ObjRefType ();
338 /* Because of generic sharing */
339 return ObjRefType ();
340 case MONO_TYPE_GENERICINST:
341 if (!mono_type_generic_inst_is_valuetype (t))
342 return ObjRefType ();
344 case MONO_TYPE_VALUETYPE:
345 case MONO_TYPE_TYPEDBYREF: {
349 klass = mono_class_from_mono_type (t);
351 if (MONO_CLASS_IS_SIMD (ctx->cfg, klass))
352 return simd_class_to_llvm_type (ctx, klass);
355 return type_to_llvm_type (ctx, mono_class_enum_basetype (klass));
356 ltype = g_hash_table_lookup (ctx->lmodule->llvm_types, klass);
359 LLVMTypeRef *eltypes;
362 size = get_vtype_size (t);
364 eltypes = g_new (LLVMTypeRef, size);
365 for (i = 0; i < size; ++i)
366 eltypes [i] = LLVMInt8Type ();
368 name = mono_type_full_name (&klass->byval_arg);
369 ltype = LLVMStructCreateNamed (LLVMGetGlobalContext (), name);
370 LLVMStructSetBody (ltype, eltypes, size, FALSE);
371 g_hash_table_insert (ctx->lmodule->llvm_types, klass, ltype);
378 printf ("X: %d\n", t->type);
379 ctx->cfg->exception_message = g_strdup_printf ("type %s", mono_type_full_name (t));
380 ctx->cfg->disable_llvm = TRUE;
388 * Return whenever T is an unsigned int type.
391 type_is_unsigned (EmitContext *ctx, MonoType *t)
407 * type_to_llvm_arg_type:
409 * Same as type_to_llvm_type, but treat i8/i16 as i32.
412 type_to_llvm_arg_type (EmitContext *ctx, MonoType *t)
414 LLVMTypeRef ptype = type_to_llvm_type (ctx, t);
416 if (ptype == LLVMInt8Type () || ptype == LLVMInt16Type ()) {
418 * LLVM generates code which only sets the lower bits, while JITted
419 * code expects all the bits to be set.
421 ptype = LLVMInt32Type ();
428 * llvm_type_to_stack_type:
430 * Return the LLVM type which needs to be used when a value of type TYPE is pushed
433 static G_GNUC_UNUSED LLVMTypeRef
434 llvm_type_to_stack_type (LLVMTypeRef type)
438 if (type == LLVMInt8Type ())
439 return LLVMInt32Type ();
440 else if (type == LLVMInt16Type ())
441 return LLVMInt32Type ();
442 else if (type == LLVMFloatType ())
443 return LLVMDoubleType ();
449 * regtype_to_llvm_type:
451 * Return the LLVM type corresponding to the regtype C used in instruction
455 regtype_to_llvm_type (char c)
459 return LLVMInt32Type ();
461 return LLVMInt64Type ();
463 return LLVMDoubleType ();
472 * Return the LLVM type corresponding to the unary/binary opcode OPCODE.
475 op_to_llvm_type (int opcode)
480 return LLVMInt8Type ();
483 return LLVMInt8Type ();
486 return LLVMInt16Type ();
489 return LLVMInt16Type ();
492 return LLVMInt32Type ();
495 return LLVMInt32Type ();
497 return LLVMInt64Type ();
499 return LLVMFloatType ();
501 return LLVMDoubleType ();
503 return LLVMInt64Type ();
505 return LLVMInt32Type ();
507 return LLVMInt64Type ();
510 return LLVMInt8Type ();
513 return LLVMInt16Type ();
516 return sizeof (gpointer) == 8 ? LLVMInt64Type () : LLVMInt32Type ();
523 return LLVMInt32Type ();
530 return LLVMInt64Type ();
532 printf ("%s\n", mono_inst_name (opcode));
533 g_assert_not_reached ();
539 * load_store_to_llvm_type:
541 * Return the size/sign/zero extension corresponding to the load/store opcode
545 load_store_to_llvm_type (int opcode, int *size, gboolean *sext, gboolean *zext)
551 case OP_LOADI1_MEMBASE:
552 case OP_STOREI1_MEMBASE_REG:
553 case OP_STOREI1_MEMBASE_IMM:
556 return LLVMInt8Type ();
557 case OP_LOADU1_MEMBASE:
561 return LLVMInt8Type ();
562 case OP_LOADI2_MEMBASE:
563 case OP_STOREI2_MEMBASE_REG:
564 case OP_STOREI2_MEMBASE_IMM:
567 return LLVMInt16Type ();
568 case OP_LOADU2_MEMBASE:
572 return LLVMInt16Type ();
573 case OP_LOADI4_MEMBASE:
574 case OP_LOADU4_MEMBASE:
577 case OP_STOREI4_MEMBASE_REG:
578 case OP_STOREI4_MEMBASE_IMM:
580 return LLVMInt32Type ();
581 case OP_LOADI8_MEMBASE:
583 case OP_STOREI8_MEMBASE_REG:
584 case OP_STOREI8_MEMBASE_IMM:
586 return LLVMInt64Type ();
587 case OP_LOADR4_MEMBASE:
588 case OP_STORER4_MEMBASE_REG:
590 return LLVMFloatType ();
591 case OP_LOADR8_MEMBASE:
592 case OP_STORER8_MEMBASE_REG:
594 return LLVMDoubleType ();
595 case OP_LOAD_MEMBASE:
597 case OP_STORE_MEMBASE_REG:
598 case OP_STORE_MEMBASE_IMM:
599 *size = sizeof (gpointer);
600 return IntPtrType ();
602 g_assert_not_reached ();
610 * Return the LLVM intrinsics corresponding to the overflow opcode OPCODE.
613 ovf_op_to_intrins (int opcode)
617 return "llvm.sadd.with.overflow.i32";
619 return "llvm.uadd.with.overflow.i32";
621 return "llvm.ssub.with.overflow.i32";
623 return "llvm.usub.with.overflow.i32";
625 return "llvm.smul.with.overflow.i32";
627 return "llvm.umul.with.overflow.i32";
629 return "llvm.sadd.with.overflow.i64";
631 return "llvm.uadd.with.overflow.i64";
633 return "llvm.ssub.with.overflow.i64";
635 return "llvm.usub.with.overflow.i64";
637 return "llvm.smul.with.overflow.i64";
639 return "llvm.umul.with.overflow.i64";
641 g_assert_not_reached ();
647 simd_op_to_intrins (int opcode)
650 #if defined(TARGET_X86) || defined(TARGET_AMD64)
652 return "llvm.x86.sse2.min.pd";
654 return "llvm.x86.sse.min.ps";
656 return "llvm.x86.sse41.pminud";
658 return "llvm.x86.sse41.pminuw";
660 return "llvm.x86.sse2.pminu.b";
662 return "llvm.x86.sse2.pmins.w";
664 return "llvm.x86.sse2.max.pd";
666 return "llvm.x86.sse.max.ps";
668 return "llvm.x86.sse3.hadd.pd";
670 return "llvm.x86.sse3.hadd.ps";
672 return "llvm.x86.sse3.hsub.pd";
674 return "llvm.x86.sse3.hsub.ps";
676 return "llvm.x86.sse41.pmaxud";
678 return "llvm.x86.sse41.pmaxuw";
680 return "llvm.x86.sse2.pmaxu.b";
682 return "llvm.x86.sse3.addsub.ps";
684 return "llvm.x86.sse3.addsub.pd";
685 case OP_EXTRACT_MASK:
686 return "llvm.x86.sse2.pmovmskb.128";
689 return "llvm.x86.sse2.psrli.w";
692 return "llvm.x86.sse2.psrli.d";
695 return "llvm.x86.sse2.psrli.q";
698 return "llvm.x86.sse2.pslli.w";
701 return "llvm.x86.sse2.pslli.d";
704 return "llvm.x86.sse2.pslli.q";
707 return "llvm.x86.sse2.psrai.w";
710 return "llvm.x86.sse2.psrai.d";
712 return "llvm.x86.sse2.padds.b";
714 return "llvm.x86.sse2.padds.w";
716 return "llvm.x86.sse2.psubs.b";
718 return "llvm.x86.sse2.psubs.w";
719 case OP_PADDB_SAT_UN:
720 return "llvm.x86.sse2.paddus.b";
721 case OP_PADDW_SAT_UN:
722 return "llvm.x86.sse2.paddus.w";
723 case OP_PSUBB_SAT_UN:
724 return "llvm.x86.sse2.psubus.b";
725 case OP_PSUBW_SAT_UN:
726 return "llvm.x86.sse2.psubus.w";
728 return "llvm.x86.sse2.pavg.b";
730 return "llvm.x86.sse2.pavg.w";
732 return "llvm.x86.sse.sqrt.ps";
734 return "llvm.x86.sse2.sqrt.pd";
736 return "llvm.x86.sse.rsqrt.ps";
738 return "llvm.x86.sse.rcp.ps";
740 return "llvm.x86.sse2.cvtdq2pd";
742 return "llvm.x86.sse2.cvtdq2ps";
744 return "llvm.x86.sse2.cvtpd2dq";
746 return "llvm.x86.sse2.cvtps2dq";
748 return "llvm.x86.sse2.cvtpd2ps";
750 return "llvm.x86.sse2.cvtps2pd";
752 return "llvm.x86.sse2.cvttpd2dq";
754 return "llvm.x86.sse2.cvttps2dq";
756 return "llvm.x86.sse.cmp.ps";
758 return "llvm.x86.sse2.cmp.pd";
760 return "llvm.x86.sse2.packsswb.128";
762 return "llvm.x86.sse2.packssdw.128";
764 return "llvm.x86.sse2.packuswb.128";
766 return "llvm.x86.sse41.packusdw";
768 return "llvm.x86.sse2.pmulh.w";
769 case OP_PMULW_HIGH_UN:
770 return "llvm.x86.sse2.pmulhu.w";
773 g_assert_not_reached ();
779 simd_op_to_llvm_type (int opcode)
781 #if defined(TARGET_X86) || defined(TARGET_AMD64)
785 return type_to_simd_type (MONO_TYPE_R8);
788 return type_to_simd_type (MONO_TYPE_I8);
791 return type_to_simd_type (MONO_TYPE_I4);
796 return type_to_simd_type (MONO_TYPE_I2);
800 return type_to_simd_type (MONO_TYPE_I1);
802 return type_to_simd_type (MONO_TYPE_R4);
805 return type_to_simd_type (MONO_TYPE_I4);
809 return type_to_simd_type (MONO_TYPE_R8);
813 return type_to_simd_type (MONO_TYPE_R4);
814 case OP_EXTRACT_MASK:
815 return type_to_simd_type (MONO_TYPE_I1);
821 return type_to_simd_type (MONO_TYPE_R4);
824 return type_to_simd_type (MONO_TYPE_R8);
826 g_assert_not_reached ();
837 * Return the LLVM basic block corresponding to BB.
839 static LLVMBasicBlockRef
840 get_bb (EmitContext *ctx, MonoBasicBlock *bb)
844 if (ctx->bblocks [bb->block_num].bblock == NULL) {
845 if (bb->flags & BB_EXCEPTION_HANDLER) {
846 int clause_index = (mono_get_block_region_notry (ctx->cfg, bb->region) >> 8) - 1;
847 sprintf (bb_name, "EH_CLAUSE%d_BB%d", clause_index, bb->block_num);
849 sprintf (bb_name, "BB%d", bb->block_num);
852 ctx->bblocks [bb->block_num].bblock = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
853 ctx->bblocks [bb->block_num].end_bblock = ctx->bblocks [bb->block_num].bblock;
856 return ctx->bblocks [bb->block_num].bblock;
862 * Return the last LLVM bblock corresponding to BB.
863 * This might not be equal to the bb returned by get_bb () since we need to generate
864 * multiple LLVM bblocks for a mono bblock to handle throwing exceptions.
866 static LLVMBasicBlockRef
867 get_end_bb (EmitContext *ctx, MonoBasicBlock *bb)
870 return ctx->bblocks [bb->block_num].end_bblock;
873 static LLVMBasicBlockRef
874 gen_bb (EmitContext *ctx, const char *prefix)
878 sprintf (bb_name, "%s%d", prefix, ++ ctx->ex_index);
879 return LLVMAppendBasicBlock (ctx->lmethod, bb_name);
885 * Return the target of the patch identified by TYPE and TARGET.
888 resolve_patch (MonoCompile *cfg, MonoJumpInfoType type, gconstpointer target)
892 memset (&ji, 0, sizeof (ji));
894 ji.data.target = target;
896 return mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
902 * Emit code to convert the LLVM value V to DTYPE.
905 convert_full (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype, gboolean is_unsigned)
907 LLVMTypeRef stype = LLVMTypeOf (v);
909 if (stype != dtype) {
910 gboolean ext = FALSE;
913 if (dtype == LLVMInt64Type () && (stype == LLVMInt32Type () || stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
915 else if (dtype == LLVMInt32Type () && (stype == LLVMInt16Type () || stype == LLVMInt8Type ()))
917 else if (dtype == LLVMInt16Type () && (stype == LLVMInt8Type ()))
921 return is_unsigned ? LLVMBuildZExt (ctx->builder, v, dtype, "") : LLVMBuildSExt (ctx->builder, v, dtype, "");
923 if (dtype == LLVMDoubleType () && stype == LLVMFloatType ())
924 return LLVMBuildFPExt (ctx->builder, v, dtype, "");
927 if (stype == LLVMInt64Type () && (dtype == LLVMInt32Type () || dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
928 return LLVMBuildTrunc (ctx->builder, v, dtype, "");
929 if (stype == LLVMInt32Type () && (dtype == LLVMInt16Type () || dtype == LLVMInt8Type ()))
930 return LLVMBuildTrunc (ctx->builder, v, dtype, "");
931 if (stype == LLVMInt16Type () && dtype == LLVMInt8Type ())
932 return LLVMBuildTrunc (ctx->builder, v, dtype, "");
933 if (stype == LLVMDoubleType () && dtype == LLVMFloatType ())
934 return LLVMBuildFPTrunc (ctx->builder, v, dtype, "");
936 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind && LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
937 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
938 if (LLVMGetTypeKind (dtype) == LLVMPointerTypeKind)
939 return LLVMBuildIntToPtr (ctx->builder, v, dtype, "");
940 if (LLVMGetTypeKind (stype) == LLVMPointerTypeKind)
941 return LLVMBuildPtrToInt (ctx->builder, v, dtype, "");
943 if (mono_arch_is_soft_float ()) {
944 if (stype == LLVMInt32Type () && dtype == LLVMFloatType ())
945 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
946 if (stype == LLVMInt32Type () && dtype == LLVMDoubleType ())
947 return LLVMBuildBitCast (ctx->builder, LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), ""), dtype, "");
950 if (LLVMGetTypeKind (stype) == LLVMVectorTypeKind && LLVMGetTypeKind (dtype) == LLVMVectorTypeKind)
951 return LLVMBuildBitCast (ctx->builder, v, dtype, "");
954 LLVMDumpValue (LLVMConstNull (dtype));
955 g_assert_not_reached ();
963 convert (EmitContext *ctx, LLVMValueRef v, LLVMTypeRef dtype)
965 return convert_full (ctx, v, dtype, FALSE);
969 * emit_volatile_load:
971 * If vreg is volatile, emit a load from its address.
974 emit_volatile_load (EmitContext *ctx, int vreg)
978 LLVMValueRef v = LLVMBuildLoad (ctx->builder, ctx->addresses [vreg], "");
979 t = ctx->vreg_cli_types [vreg];
980 if (t && !t->byref) {
982 * Might have to zero extend since llvm doesn't have
985 if (t->type == MONO_TYPE_U1 || t->type == MONO_TYPE_U2 || t->type == MONO_TYPE_CHAR || t->type == MONO_TYPE_BOOLEAN)
986 v = LLVMBuildZExt (ctx->builder, v, LLVMInt32Type (), "");
987 else if (t->type == MONO_TYPE_U8)
988 v = LLVMBuildZExt (ctx->builder, v, LLVMInt64Type (), "");
995 * emit_volatile_store:
997 * If VREG is volatile, emit a store from its value to its address.
1000 emit_volatile_store (EmitContext *ctx, int vreg)
1002 MonoInst *var = get_vreg_to_inst (ctx->cfg, vreg);
1004 if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
1005 g_assert (ctx->addresses [vreg]);
1006 LLVMBuildStore (ctx->builder, convert (ctx, ctx->values [vreg], type_to_llvm_type (ctx, var->inst_vtype)), ctx->addresses [vreg]);
1012 * Maps parameter indexes in the original signature to parameter indexes
1013 * in the LLVM signature.
1016 /* The indexes of various special arguments in the LLVM signature */
1017 int vret_arg_pindex, this_arg_pindex, rgctx_arg_pindex, imt_arg_pindex;
1021 * sig_to_llvm_sig_full:
1023 * Return the LLVM signature corresponding to the mono signature SIG using the
1024 * calling convention information in CINFO. Return parameter mapping information in SINFO.
1027 sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo *cinfo,
1030 LLVMTypeRef ret_type;
1031 LLVMTypeRef *param_types = NULL;
1033 int i, j, pindex, vret_arg_pindex = 0;
1035 gboolean vretaddr = FALSE;
1038 memset (sinfo, 0, sizeof (LLVMSigInfo));
1040 ret_type = type_to_llvm_type (ctx, sig->ret);
1041 CHECK_FAILURE (ctx);
1043 if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
1044 /* LLVM models this by returning an aggregate value */
1045 if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgNone) {
1046 LLVMTypeRef members [2];
1048 members [0] = IntPtrType ();
1049 ret_type = LLVMStructType (members, 1, FALSE);
1051 g_assert_not_reached ();
1053 } else if (cinfo && mini_type_is_vtype (ctx->cfg, sig->ret)) {
1054 g_assert (cinfo->ret.storage == LLVMArgVtypeRetAddr);
1056 ret_type = LLVMVoidType ();
1059 pindexes = g_new0 (int, sig->param_count);
1060 param_types = g_new0 (LLVMTypeRef, (sig->param_count * 2) + 3);
1062 if (cinfo && cinfo->rgctx_arg) {
1064 sinfo->rgctx_arg_pindex = pindex;
1065 param_types [pindex] = IntPtrType ();
1068 if (cinfo && cinfo->imt_arg) {
1070 sinfo->imt_arg_pindex = pindex;
1071 param_types [pindex] = IntPtrType ();
1075 /* Compute the index in the LLVM signature where the vret arg needs to be passed */
1076 vret_arg_pindex = pindex;
1077 if (cinfo->vret_arg_index == 1) {
1078 /* Add the slots consumed by the first argument */
1079 LLVMArgInfo *ainfo = &cinfo->args [0];
1080 switch (ainfo->storage) {
1081 case LLVMArgVtypeInReg:
1082 for (j = 0; j < 2; ++j) {
1083 if (ainfo->pair_storage [j] == LLVMArgInIReg)
1093 sinfo->vret_arg_pindex = vret_arg_pindex;
1096 if (vretaddr && vret_arg_pindex == pindex)
1097 param_types [pindex ++] = IntPtrType ();
1100 sinfo->this_arg_pindex = pindex;
1101 param_types [pindex ++] = IntPtrType ();
1103 if (vretaddr && vret_arg_pindex == pindex)
1104 param_types [pindex ++] = IntPtrType ();
1105 for (i = 0; i < sig->param_count; ++i) {
1106 if (vretaddr && vret_arg_pindex == pindex)
1107 param_types [pindex ++] = IntPtrType ();
1108 pindexes [i] = pindex;
1109 if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeInReg) {
1110 for (j = 0; j < 2; ++j) {
1111 switch (cinfo->args [i + sig->hasthis].pair_storage [j]) {
1113 param_types [pindex ++] = LLVMIntType (sizeof (gpointer) * 8);
1118 g_assert_not_reached ();
1121 } else if (cinfo && cinfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal) {
1122 param_types [pindex] = type_to_llvm_arg_type (ctx, sig->params [i]);
1123 CHECK_FAILURE (ctx);
1124 param_types [pindex] = LLVMPointerType (param_types [pindex], 0);
1127 param_types [pindex ++] = type_to_llvm_arg_type (ctx, sig->params [i]);
1130 if (vretaddr && vret_arg_pindex == pindex)
1131 param_types [pindex ++] = IntPtrType ();
1133 CHECK_FAILURE (ctx);
1135 res = LLVMFunctionType (ret_type, param_types, pindex, FALSE);
1136 g_free (param_types);
1139 sinfo->pindexes = pindexes;
1147 g_free (param_types);
1153 sig_to_llvm_sig (EmitContext *ctx, MonoMethodSignature *sig)
1155 return sig_to_llvm_sig_full (ctx, sig, NULL, NULL);
1159 * LLVMFunctionType1:
1161 * Create an LLVM function type from the arguments.
1163 static G_GNUC_UNUSED LLVMTypeRef
1164 LLVMFunctionType1(LLVMTypeRef ReturnType,
1165 LLVMTypeRef ParamType1,
1168 LLVMTypeRef param_types [1];
1170 param_types [0] = ParamType1;
1172 return LLVMFunctionType (ReturnType, param_types, 1, IsVarArg);
1176 * LLVMFunctionType2:
1178 * Create an LLVM function type from the arguments.
1180 static G_GNUC_UNUSED LLVMTypeRef
1181 LLVMFunctionType2(LLVMTypeRef ReturnType,
1182 LLVMTypeRef ParamType1,
1183 LLVMTypeRef ParamType2,
1186 LLVMTypeRef param_types [2];
1188 param_types [0] = ParamType1;
1189 param_types [1] = ParamType2;
1191 return LLVMFunctionType (ReturnType, param_types, 2, IsVarArg);
1195 * LLVMFunctionType3:
1197 * Create an LLVM function type from the arguments.
1199 static G_GNUC_UNUSED LLVMTypeRef
1200 LLVMFunctionType3(LLVMTypeRef ReturnType,
1201 LLVMTypeRef ParamType1,
1202 LLVMTypeRef ParamType2,
1203 LLVMTypeRef ParamType3,
1206 LLVMTypeRef param_types [3];
1208 param_types [0] = ParamType1;
1209 param_types [1] = ParamType2;
1210 param_types [2] = ParamType3;
1212 return LLVMFunctionType (ReturnType, param_types, 3, IsVarArg);
1218 * Create an LLVM builder and remember it so it can be freed later.
1220 static LLVMBuilderRef
1221 create_builder (EmitContext *ctx)
1223 LLVMBuilderRef builder = LLVMCreateBuilder ();
1225 ctx->builders = g_slist_prepend_mempool (ctx->cfg->mempool, ctx->builders, builder);
1231 get_plt_entry (EmitContext *ctx, LLVMTypeRef llvm_sig, MonoJumpInfoType type, gconstpointer data)
1233 char *callee_name = mono_aot_get_plt_symbol (type, data);
1234 LLVMValueRef callee;
1239 if (ctx->cfg->compile_aot)
1240 /* Add a patch so referenced wrappers can be compiled in full aot mode */
1241 mono_add_patch_info (ctx->cfg, 0, type, data);
1244 callee = g_hash_table_lookup (ctx->lmodule->plt_entries, callee_name);
1246 callee = LLVMAddFunction (ctx->module, callee_name, llvm_sig);
1248 LLVMSetVisibility (callee, LLVMHiddenVisibility);
1250 g_hash_table_insert (ctx->lmodule->plt_entries, (char*)callee_name, callee);
1257 get_handler_clause (MonoCompile *cfg, MonoBasicBlock *bb)
1259 MonoMethodHeader *header = cfg->header;
1260 MonoExceptionClause *clause;
1264 if (bb->region != -1 && MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))
1265 return (bb->region >> 8) - 1;
1268 for (i = 0; i < header->num_clauses; ++i) {
1269 clause = &header->clauses [i];
1271 if (MONO_OFFSET_IN_CLAUSE (clause, bb->real_offset) && clause->flags == MONO_EXCEPTION_CLAUSE_NONE)
1279 set_metadata_flag (LLVMValueRef v, const char *flag_name)
1281 LLVMValueRef md_arg;
1284 md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1285 md_arg = LLVMMDString ("mono", 4);
1286 LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1290 set_invariant_load_flag (LLVMValueRef v)
1292 LLVMValueRef md_arg;
1294 const char *flag_name;
1296 // FIXME: Cache this
1297 flag_name = "invariant.load";
1298 md_kind = LLVMGetMDKindID (flag_name, strlen (flag_name));
1299 md_arg = LLVMMDString ("<index>", strlen ("<index>"));
1300 LLVMSetMetadata (v, md_kind, LLVMMDNode (&md_arg, 1));
1306 * Emit an LLVM call or invoke instruction depending on whenever the call is inside
1310 emit_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, LLVMValueRef callee, LLVMValueRef *args, int pindex)
1312 MonoCompile *cfg = ctx->cfg;
1314 LLVMBuilderRef builder = *builder_ref;
1317 clause_index = get_handler_clause (cfg, bb);
1319 if (clause_index != -1) {
1320 MonoMethodHeader *header = cfg->header;
1321 MonoExceptionClause *ec = &header->clauses [clause_index];
1322 MonoBasicBlock *tblock;
1323 LLVMBasicBlockRef ex_bb, noex_bb;
1326 * Have to use an invoke instead of a call, branching to the
1327 * handler bblock of the clause containing this bblock.
1330 g_assert (ec->flags == MONO_EXCEPTION_CLAUSE_NONE || ec->flags == MONO_EXCEPTION_CLAUSE_FINALLY);
1332 tblock = cfg->cil_offset_to_bb [ec->handler_offset];
1335 ctx->bblocks [tblock->block_num].invoke_target = TRUE;
1337 ex_bb = get_bb (ctx, tblock);
1339 noex_bb = gen_bb (ctx, "NOEX_BB");
1342 lcall = LLVMBuildInvoke (builder, callee, args, pindex, noex_bb, ex_bb, "");
1344 builder = ctx->builder = create_builder (ctx);
1345 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1347 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1349 lcall = LLVMBuildCall (builder, callee, args, pindex, "");
1350 ctx->builder = builder;
1353 *builder_ref = ctx->builder;
1359 emit_load (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef addr, const char *name, gboolean is_faulting)
1361 const char *intrins_name;
1362 LLVMValueRef args [16], res;
1363 LLVMTypeRef addr_type;
1365 if (is_faulting && bb->region != -1) {
1367 * We handle loads which can fault by calling a mono specific intrinsic
1368 * using an invoke, so they are handled properly inside try blocks.
1369 * We can't use this outside clauses, since LLVM optimizes intrinsics which
1370 * are marked with IntrReadArgMem.
1374 intrins_name = "llvm.mono.load.i8.p0i8";
1377 intrins_name = "llvm.mono.load.i16.p0i16";
1380 intrins_name = "llvm.mono.load.i32.p0i32";
1383 intrins_name = "llvm.mono.load.i64.p0i64";
1386 g_assert_not_reached ();
1389 addr_type = LLVMTypeOf (addr);
1390 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0) || addr_type == LLVMPointerType (LLVMFloatType (), 0))
1391 addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1394 args [1] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1395 args [2] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1396 res = emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 3);
1398 if (addr_type == LLVMPointerType (LLVMDoubleType (), 0))
1399 res = LLVMBuildBitCast (*builder_ref, res, LLVMDoubleType (), "");
1400 else if (addr_type == LLVMPointerType (LLVMFloatType (), 0))
1401 res = LLVMBuildBitCast (*builder_ref, res, LLVMFloatType (), "");
1408 * We emit volatile loads for loads which can fault, because otherwise
1409 * LLVM will generate invalid code when encountering a load from a
1412 res = mono_llvm_build_load (*builder_ref, addr, name, is_faulting);
1414 /* Mark it with a custom metadata */
1417 set_metadata_flag (res, "mono.faulting.load");
1425 emit_store (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, int size, LLVMValueRef value, LLVMValueRef addr, gboolean is_faulting)
1427 const char *intrins_name;
1428 LLVMValueRef args [16];
1430 if (is_faulting && bb->region != -1) {
1433 intrins_name = "llvm.mono.store.i8.p0i8";
1436 intrins_name = "llvm.mono.store.i16.p0i16";
1439 intrins_name = "llvm.mono.store.i32.p0i32";
1442 intrins_name = "llvm.mono.store.i64.p0i64";
1445 g_assert_not_reached ();
1448 if (LLVMTypeOf (value) == LLVMDoubleType () || LLVMTypeOf (value) == LLVMFloatType ()) {
1449 value = LLVMBuildBitCast (*builder_ref, value, LLVMIntType (size * 8), "");
1450 addr = LLVMBuildBitCast (*builder_ref, addr, LLVMPointerType (LLVMIntType (size * 8), 0), "");
1455 args [2] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1456 args [3] = LLVMConstInt (LLVMInt1Type (), TRUE, FALSE);
1457 emit_call (ctx, bb, builder_ref, LLVMGetNamedFunction (ctx->module, intrins_name), args, 4);
1459 LLVMBuildStore (*builder_ref, value, addr);
1464 * emit_cond_system_exception:
1466 * Emit code to throw the exception EXC_TYPE if the condition CMP is false.
1467 * Might set the ctx exception.
1470 emit_cond_system_exception (EmitContext *ctx, MonoBasicBlock *bb, const char *exc_type, LLVMValueRef cmp)
1472 LLVMBasicBlockRef ex_bb, noex_bb;
1473 LLVMBuilderRef builder;
1474 MonoClass *exc_class;
1475 LLVMValueRef args [2];
1477 ex_bb = gen_bb (ctx, "EX_BB");
1478 noex_bb = gen_bb (ctx, "NOEX_BB");
1480 LLVMBuildCondBr (ctx->builder, cmp, ex_bb, noex_bb);
1482 exc_class = mono_class_from_name (mono_get_corlib (), "System", exc_type);
1483 g_assert (exc_class);
1485 /* Emit exception throwing code */
1486 builder = create_builder (ctx);
1487 LLVMPositionBuilderAtEnd (builder, ex_bb);
1489 if (!ctx->lmodule->throw_corlib_exception) {
1490 LLVMValueRef callee;
1492 const char *icall_name;
1494 MonoMethodSignature *throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 2);
1495 throw_sig->ret = &mono_get_void_class ()->byval_arg;
1496 throw_sig->params [0] = &mono_get_int32_class ()->byval_arg;
1497 icall_name = "llvm_throw_corlib_exception_abs_trampoline";
1498 throw_sig->params [1] = &mono_get_intptr_class ()->byval_arg;
1499 sig = sig_to_llvm_sig (ctx, throw_sig);
1501 if (ctx->cfg->compile_aot) {
1502 callee = get_plt_entry (ctx, sig, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
1504 callee = LLVMAddFunction (ctx->module, "llvm_throw_corlib_exception_trampoline", sig_to_llvm_sig (ctx, throw_sig));
1507 * Differences between the LLVM/non-LLVM throw corlib exception trampoline:
1508 * - On x86, LLVM generated code doesn't push the arguments
1509 * - When using the LLVM mono branch, the trampoline takes the throw address as an
1510 * arguments, not a pc offset.
1512 LLVMAddGlobalMapping (ee, callee, resolve_patch (ctx->cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
1515 mono_memory_barrier ();
1516 ctx->lmodule->throw_corlib_exception = callee;
1520 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token - MONO_TOKEN_TYPE_DEF, FALSE);
1522 args [0] = LLVMConstInt (LLVMInt32Type (), exc_class->type_token, FALSE);
1525 * The LLVM mono branch contains changes so a block address can be passed as an
1526 * argument to a call.
1528 args [1] = LLVMBuildPtrToInt (builder, LLVMBlockAddress (ctx->lmethod, ex_bb), IntPtrType (), "");
1529 emit_call (ctx, bb, &builder, ctx->lmodule->throw_corlib_exception, args, 2);
1531 LLVMBuildUnreachable (builder);
1533 ctx->builder = create_builder (ctx);
1534 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
1536 ctx->bblocks [bb->block_num].end_bblock = noex_bb;
1543 * emit_reg_to_vtype:
1545 * Emit code to store the vtype in the registers REGS to the address ADDRESS.
1548 emit_reg_to_vtype (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs)
1552 size = get_vtype_size (t);
1554 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1555 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1558 for (j = 0; j < 2; ++j) {
1559 LLVMValueRef index [2], addr;
1560 int part_size = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1561 LLVMTypeRef part_type;
1563 if (ainfo->pair_storage [j] == LLVMArgNone)
1566 part_type = LLVMIntType (part_size * 8);
1567 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1568 index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1569 addr = LLVMBuildGEP (builder, address, index, 1, "");
1571 index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1572 index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1573 addr = LLVMBuildGEP (builder, address, index, 2, "");
1575 switch (ainfo->pair_storage [j]) {
1577 LLVMBuildStore (builder, convert (ctx, regs [j], part_type), LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (part_type, 0), ""));
1582 g_assert_not_reached ();
1585 size -= sizeof (gpointer);
1590 * emit_vtype_to_reg:
1592 * Emit code to load a vtype at address ADDRESS into registers. Store the registers
1593 * into REGS, and the number of registers into NREGS.
1596 emit_vtype_to_reg (EmitContext *ctx, LLVMBuilderRef builder, MonoType *t, LLVMValueRef address, LLVMArgInfo *ainfo, LLVMValueRef *regs, guint32 *nregs)
1601 size = get_vtype_size (t);
1603 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1604 address = LLVMBuildBitCast (ctx->builder, address, LLVMPointerType (LLVMInt8Type (), 0), "");
1607 for (j = 0; j < 2; ++j) {
1608 LLVMValueRef index [2], addr;
1609 int partsize = size > sizeof (gpointer) ? sizeof (gpointer) : size;
1611 if (ainfo->pair_storage [j] == LLVMArgNone)
1614 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (t))) {
1615 index [0] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1616 addr = LLVMBuildGEP (builder, address, index, 1, "");
1618 index [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
1619 index [1] = LLVMConstInt (LLVMInt32Type (), j * sizeof (gpointer), FALSE);
1620 addr = LLVMBuildGEP (builder, address, index, 2, "");
1622 switch (ainfo->pair_storage [j]) {
1624 regs [pindex ++] = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (ctx->builder, addr, LLVMPointerType (LLVMIntType (partsize * 8), 0), ""), ""), IntPtrType ());
1629 g_assert_not_reached ();
1631 size -= sizeof (gpointer);
1638 build_alloca (EmitContext *ctx, MonoType *t)
1640 MonoClass *k = mono_class_from_mono_type (t);
1643 if (MONO_CLASS_IS_SIMD (ctx->cfg, k))
1646 align = mono_class_min_align (k);
1648 /* Sometimes align is not a power of 2 */
1649 while (mono_is_power_of_two (align) == -1)
1653 * Have to place all alloca's at the end of the entry bb, since otherwise they would
1654 * get executed every time control reaches them.
1656 LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca);
1658 ctx->last_alloca = mono_llvm_build_alloca (ctx->alloca_builder, type_to_llvm_type (ctx, t), NULL, align, "");
1659 return ctx->last_alloca;
1663 * Put the global into the 'llvm.used' array to prevent it from being optimized away.
1666 mark_as_used (LLVMModuleRef module, LLVMValueRef global)
1668 LLVMTypeRef used_type;
1669 LLVMValueRef used, used_elem;
1671 used_type = LLVMArrayType (LLVMPointerType (LLVMInt8Type (), 0), 1);
1672 used = LLVMAddGlobal (module, used_type, "llvm.used");
1673 used_elem = LLVMConstBitCast (global, LLVMPointerType (LLVMInt8Type (), 0));
1674 LLVMSetInitializer (used, LLVMConstArray (LLVMPointerType (LLVMInt8Type (), 0), &used_elem, 1));
1675 LLVMSetLinkage (used, LLVMAppendingLinkage);
1676 LLVMSetSection (used, "llvm.metadata");
1682 * Emit code to load/convert arguments.
1685 emit_entry_bb (EmitContext *ctx, LLVMBuilderRef builder)
1688 MonoCompile *cfg = ctx->cfg;
1689 MonoMethodSignature *sig = ctx->sig;
1690 LLVMCallInfo *linfo = ctx->linfo;
1693 ctx->alloca_builder = create_builder (ctx);
1696 * Handle indirect/volatile variables by allocating memory for them
1697 * using 'alloca', and storing their address in a temporary.
1699 for (i = 0; i < cfg->num_varinfo; ++i) {
1700 MonoInst *var = cfg->varinfo [i];
1703 if (var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT) || mini_type_is_vtype (cfg, var->inst_vtype)) {
1704 vtype = type_to_llvm_type (ctx, var->inst_vtype);
1705 CHECK_FAILURE (ctx);
1706 /* Could be already created by an OP_VPHI */
1707 if (!ctx->addresses [var->dreg])
1708 ctx->addresses [var->dreg] = build_alloca (ctx, var->inst_vtype);
1709 ctx->vreg_cli_types [var->dreg] = var->inst_vtype;
1713 for (i = 0; i < sig->param_count; ++i) {
1714 LLVMArgInfo *ainfo = &linfo->args [i + sig->hasthis];
1715 int reg = cfg->args [i + sig->hasthis]->dreg;
1717 if (ainfo->storage == LLVMArgVtypeInReg) {
1718 LLVMValueRef regs [2];
1721 * Emit code to save the argument from the registers to
1722 * the real argument.
1724 pindex = ctx->pindexes [i];
1725 regs [0] = LLVMGetParam (ctx->lmethod, pindex);
1726 if (ainfo->pair_storage [1] != LLVMArgNone)
1727 regs [1] = LLVMGetParam (ctx->lmethod, pindex + 1);
1731 ctx->addresses [reg] = build_alloca (ctx, sig->params [i]);
1733 emit_reg_to_vtype (ctx, builder, sig->params [i], ctx->addresses [reg], ainfo, regs);
1735 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1736 /* Treat these as normal values */
1737 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1739 } else if (ainfo->storage == LLVMArgVtypeByVal) {
1740 ctx->addresses [reg] = LLVMGetParam (ctx->lmethod, ctx->pindexes [i]);
1742 if (MONO_CLASS_IS_SIMD (ctx->cfg, mono_class_from_mono_type (sig->params [i]))) {
1743 /* Treat these as normal values */
1744 ctx->values [reg] = LLVMBuildLoad (builder, ctx->addresses [reg], "");
1747 ctx->values [reg] = convert (ctx, ctx->values [reg], llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->params [i])));
1752 emit_volatile_store (ctx, cfg->vret_addr->dreg);
1754 emit_volatile_store (ctx, cfg->args [0]->dreg);
1755 for (i = 0; i < sig->param_count; ++i)
1756 if (!mini_type_is_vtype (cfg, sig->params [i]))
1757 emit_volatile_store (ctx, cfg->args [i + sig->hasthis]->dreg);
1759 if (sig->hasthis && !cfg->rgctx_var && cfg->generic_sharing_context) {
1760 LLVMValueRef this_alloc;
1763 * The exception handling code needs the location where the this argument was
1764 * stored for gshared methods. We create a separate alloca to hold it, and mark it
1765 * with the "mono.this" custom metadata to tell llvm that it needs to save its
1766 * location into the LSDA.
1768 this_alloc = mono_llvm_build_alloca (builder, IntPtrType (), LLVMConstInt (LLVMInt32Type (), 1, FALSE), 0, "");
1769 /* This volatile store will keep the alloca alive */
1770 mono_llvm_build_store (builder, ctx->values [cfg->args [0]->dreg], this_alloc, TRUE);
1772 set_metadata_flag (this_alloc, "mono.this");
1775 if (cfg->rgctx_var) {
1776 LLVMValueRef rgctx_alloc, store;
1779 * We handle the rgctx arg similarly to the this pointer.
1781 g_assert (ctx->addresses [cfg->rgctx_var->dreg]);
1782 rgctx_alloc = ctx->addresses [cfg->rgctx_var->dreg];
1783 /* This volatile store will keep the alloca alive */
1784 store = mono_llvm_build_store (builder, ctx->rgctx_arg, rgctx_alloc, TRUE);
1786 set_metadata_flag (rgctx_alloc, "mono.this");
1790 * For finally clauses, create an indicator variable telling OP_ENDFINALLY whenever
1791 * it needs to continue normally, or return back to the exception handling system.
1793 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
1794 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER))
1795 g_hash_table_insert (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)), bb);
1796 if (bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER) && bb->in_scount == 0) {
1800 sprintf (name, "finally_ind_bb%d", bb->block_num);
1801 val = LLVMBuildAlloca (builder, LLVMInt32Type (), name);
1802 LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), val);
1804 ctx->bblocks [bb->block_num].finally_ind = val;
1807 * Create a new bblock which CALL_HANDLER can branch to, because branching to the
1808 * LLVM bblock containing the call to llvm.eh.selector causes problems for the
1809 * LLVM optimizer passes.
1811 sprintf (name, "BB_%d_CALL_HANDLER_TARGET", bb->block_num);
1812 ctx->bblocks [bb->block_num].call_handler_target_bb = LLVMAppendBasicBlock (ctx->lmethod, name);
1820 /* Have to export this for AOT */
1822 mono_personality (void);
1825 mono_personality (void)
1828 g_assert_not_reached ();
1832 process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, MonoInst *ins)
1834 MonoCompile *cfg = ctx->cfg;
1835 LLVMModuleRef module = ctx->module;
1836 LLVMValueRef *values = ctx->values;
1837 LLVMValueRef *addresses = ctx->addresses;
1838 MonoCallInst *call = (MonoCallInst*)ins;
1839 MonoMethodSignature *sig = call->signature;
1840 LLVMValueRef callee = NULL, lcall;
1842 LLVMCallInfo *cinfo;
1846 LLVMTypeRef llvm_sig;
1848 gboolean virtual, calli;
1849 LLVMBuilderRef builder = *builder_ref;
1852 if (call->signature->call_convention != MONO_CALL_DEFAULT)
1853 LLVM_FAILURE (ctx, "non-default callconv");
1855 cinfo = call->cinfo;
1856 if (call->rgctx_arg_reg)
1857 cinfo->rgctx_arg = TRUE;
1858 if (call->imt_arg_reg)
1859 cinfo->imt_arg = TRUE;
1861 vretaddr = cinfo && cinfo->ret.storage == LLVMArgVtypeRetAddr;
1863 llvm_sig = sig_to_llvm_sig_full (ctx, sig, cinfo, &sinfo);
1864 CHECK_FAILURE (ctx);
1866 virtual = (ins->opcode == OP_VOIDCALL_MEMBASE || ins->opcode == OP_CALL_MEMBASE || ins->opcode == OP_VCALL_MEMBASE || ins->opcode == OP_LCALL_MEMBASE || ins->opcode == OP_FCALL_MEMBASE);
1867 calli = (ins->opcode == OP_VOIDCALL_REG || ins->opcode == OP_CALL_REG || ins->opcode == OP_VCALL_REG || ins->opcode == OP_LCALL_REG || ins->opcode == OP_FCALL_REG);
1869 /* FIXME: Avoid creating duplicate methods */
1871 if (ins->flags & MONO_INST_HAS_METHOD) {
1875 if (cfg->compile_aot) {
1876 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_METHOD, call->method);
1878 LLVM_FAILURE (ctx, "can't encode patch");
1880 callee = LLVMAddFunction (module, "", llvm_sig);
1883 mono_create_jit_trampoline_in_domain (mono_domain_get (),
1885 LLVMAddGlobalMapping (ee, callee, target);
1889 if (call->method && strstr (call->method->klass->name, "AsyncVoidMethodBuilder"))
1890 /* LLVM miscompiles async methods */
1891 LLVM_FAILURE (ctx, "#13734");
1894 MonoJitICallInfo *info = mono_find_jit_icall_by_addr (call->fptr);
1900 memset (&ji, 0, sizeof (ji));
1901 ji.type = MONO_PATCH_INFO_JIT_ICALL_ADDR;
1902 ji.data.target = info->name;
1904 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, &ji, FALSE);
1906 if (cfg->compile_aot) {
1907 callee = get_plt_entry (ctx, llvm_sig, MONO_PATCH_INFO_INTERNAL_METHOD, (char*)info->name);
1909 LLVM_FAILURE (ctx, "can't encode patch");
1911 callee = LLVMAddFunction (module, "", llvm_sig);
1912 target = (gpointer)mono_icall_get_wrapper (info);
1913 LLVMAddGlobalMapping (ee, callee, target);
1916 if (cfg->compile_aot) {
1918 if (cfg->abs_patches) {
1919 MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1921 callee = get_plt_entry (ctx, llvm_sig, abs_ji->type, abs_ji->data.target);
1923 LLVM_FAILURE (ctx, "can't encode patch");
1927 LLVM_FAILURE (ctx, "aot");
1929 callee = LLVMAddFunction (module, "", llvm_sig);
1931 if (cfg->abs_patches) {
1932 MonoJumpInfo *abs_ji = g_hash_table_lookup (cfg->abs_patches, call->fptr);
1935 * FIXME: Some trampolines might have
1936 * their own calling convention on some platforms.
1938 #ifndef TARGET_AMD64
1939 if (abs_ji->type == MONO_PATCH_INFO_MONITOR_ENTER || abs_ji->type == MONO_PATCH_INFO_MONITOR_EXIT || abs_ji->type == MONO_PATCH_INFO_GENERIC_CLASS_INIT)
1940 LLVM_FAILURE (ctx, "trampoline with own cconv");
1942 target = mono_resolve_patch_target (cfg->method, cfg->domain, NULL, abs_ji, FALSE);
1943 LLVMAddGlobalMapping (ee, callee, target);
1947 LLVMAddGlobalMapping (ee, callee, (gpointer)call->fptr);
1953 int size = sizeof (gpointer);
1956 g_assert (ins->inst_offset % size == 0);
1957 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
1959 callee = convert (ctx, LLVMBuildLoad (builder, LLVMBuildGEP (builder, convert (ctx, values [ins->inst_basereg], LLVMPointerType (LLVMPointerType (IntPtrType (), 0), 0)), &index, 1, ""), ""), LLVMPointerType (llvm_sig, 0));
1961 callee = convert (ctx, values [ins->sreg1], LLVMPointerType (llvm_sig, 0));
1963 if (ins->flags & MONO_INST_HAS_METHOD) {
1968 * Collect and convert arguments
1970 nargs = (sig->param_count * 2) + sig->hasthis + vretaddr + call->rgctx_reg + call->imt_arg_reg;
1971 len = sizeof (LLVMValueRef) * nargs;
1972 args = alloca (len);
1973 memset (args, 0, len);
1974 l = call->out_ireg_args;
1976 if (call->rgctx_arg_reg) {
1977 g_assert (values [call->rgctx_arg_reg]);
1978 g_assert (sinfo.rgctx_arg_pindex < nargs);
1979 args [sinfo.rgctx_arg_pindex] = values [call->rgctx_arg_reg];
1981 if (call->imt_arg_reg) {
1982 g_assert (values [call->imt_arg_reg]);
1983 g_assert (sinfo.imt_arg_pindex < nargs);
1984 args [sinfo.imt_arg_pindex] = values [call->imt_arg_reg];
1988 if (!addresses [call->inst.dreg])
1989 addresses [call->inst.dreg] = build_alloca (ctx, sig->ret);
1990 g_assert (sinfo.vret_arg_pindex < nargs);
1991 args [sinfo.vret_arg_pindex] = LLVMBuildPtrToInt (builder, addresses [call->inst.dreg], IntPtrType (), "");
1994 for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
1997 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i] : NULL;
2001 pindex = sinfo.this_arg_pindex;
2003 pindex = sinfo.pindexes [i - 1];
2005 pindex = sinfo.pindexes [i];
2008 regpair = (guint32)(gssize)(l->data);
2009 reg = regpair & 0xffffff;
2010 args [pindex] = values [reg];
2011 if (ainfo->storage == LLVMArgVtypeInReg) {
2013 LLVMValueRef regs [2];
2018 g_assert (addresses [reg]);
2020 emit_vtype_to_reg (ctx, builder, sig->params [i - sig->hasthis], addresses [reg], ainfo, regs, &nregs);
2021 for (j = 0; j < nregs; ++j)
2022 args [pindex ++] = regs [j];
2025 // FIXME: Get rid of the VMOVE
2026 } else if (ainfo->storage == LLVMArgVtypeByVal) {
2027 g_assert (addresses [reg]);
2028 args [pindex] = addresses [reg];
2030 g_assert (args [pindex]);
2031 if (i == 0 && sig->hasthis)
2032 args [pindex] = convert (ctx, args [pindex], IntPtrType ());
2034 args [pindex] = convert (ctx, args [pindex], type_to_llvm_arg_type (ctx, sig->params [i - sig->hasthis]));
2040 // FIXME: Align call sites
2046 lcall = emit_call (ctx, bb, &builder, callee, args, LLVMCountParamTypes (llvm_sig));
2049 * Modify cconv and parameter attributes to pass rgctx/imt correctly.
2051 #if defined(MONO_ARCH_IMT_REG) && defined(MONO_ARCH_RGCTX_REG)
2052 g_assert (MONO_ARCH_IMT_REG == MONO_ARCH_RGCTX_REG);
2054 /* The two can't be used together, so use only one LLVM calling conv to pass them */
2055 g_assert (!(call->rgctx_arg_reg && call->imt_arg_reg));
2057 LLVMSetInstructionCallConv (lcall, LLVMMono1CallConv);
2059 if (call->rgctx_arg_reg)
2060 LLVMAddInstrAttribute (lcall, 1 + sinfo.rgctx_arg_pindex, LLVMInRegAttribute);
2061 if (call->imt_arg_reg)
2062 LLVMAddInstrAttribute (lcall, 1 + sinfo.imt_arg_pindex, LLVMInRegAttribute);
2064 /* Add byval attributes if needed */
2065 for (i = 0; i < sig->param_count; ++i) {
2066 LLVMArgInfo *ainfo = call->cinfo ? &call->cinfo->args [i + sig->hasthis] : NULL;
2068 if (ainfo && ainfo->storage == LLVMArgVtypeByVal) {
2069 LLVMAddInstrAttribute (lcall, 1 + sinfo.pindexes [i], LLVMByValAttribute);
2074 * Convert the result
2076 if (cinfo && cinfo->ret.storage == LLVMArgVtypeInReg) {
2077 LLVMValueRef regs [2];
2079 if (!addresses [ins->dreg])
2080 addresses [ins->dreg] = build_alloca (ctx, sig->ret);
2082 regs [0] = LLVMBuildExtractValue (builder, lcall, 0, "");
2083 if (cinfo->ret.pair_storage [1] != LLVMArgNone)
2084 regs [1] = LLVMBuildExtractValue (builder, lcall, 1, "");
2086 emit_reg_to_vtype (ctx, builder, sig->ret, addresses [ins->dreg], &cinfo->ret, regs);
2087 } else if (sig->ret->type != MONO_TYPE_VOID && !vretaddr) {
2088 /* If the method returns an unsigned value, need to zext it */
2090 values [ins->dreg] = convert_full (ctx, lcall, llvm_type_to_stack_type (type_to_llvm_type (ctx, sig->ret)), type_is_unsigned (ctx, sig->ret));
2093 *builder_ref = ctx->builder;
2095 g_free (sinfo.pindexes);
2103 process_bb (EmitContext *ctx, MonoBasicBlock *bb)
2105 MonoCompile *cfg = ctx->cfg;
2106 MonoMethodSignature *sig = ctx->sig;
2107 LLVMValueRef method = ctx->lmethod;
2108 LLVMValueRef *values = ctx->values;
2109 LLVMValueRef *addresses = ctx->addresses;
2111 LLVMCallInfo *linfo = ctx->linfo;
2112 LLVMModuleRef module = ctx->module;
2113 BBInfo *bblocks = ctx->bblocks;
2115 LLVMBasicBlockRef cbb;
2116 LLVMBuilderRef builder, starting_builder;
2117 gboolean has_terminator;
2119 LLVMValueRef lhs, rhs;
2122 cbb = get_bb (ctx, bb);
2123 builder = create_builder (ctx);
2124 ctx->builder = builder;
2125 LLVMPositionBuilderAtEnd (builder, cbb);
2127 if (bb == cfg->bb_entry)
2128 emit_entry_bb (ctx, builder);
2129 CHECK_FAILURE (ctx);
2131 if (bb->flags & BB_EXCEPTION_HANDLER) {
2133 LLVMValueRef personality;
2134 LLVMBasicBlockRef target_bb;
2136 static gint32 mapping_inited;
2137 static int ti_generator;
2140 LLVMValueRef type_info;
2143 if (!bblocks [bb->block_num].invoke_target) {
2145 * LLVM asserts if llvm.eh.selector is called from a bblock which
2146 * doesn't have an invoke pointing at it.
2147 * Update: LLVM no longer asserts, but some tests in exceptions.exe now fail.
2149 LLVM_FAILURE (ctx, "handler without invokes");
2152 // <resultval> = landingpad <somety> personality <type> <pers_fn> <clause>+
2154 if (cfg->compile_aot) {
2155 /* Use a dummy personality function */
2156 personality = LLVMGetNamedFunction (module, "mono_aot_personality");
2157 g_assert (personality);
2159 personality = LLVMGetNamedFunction (module, "mono_personality");
2160 if (InterlockedCompareExchange (&mapping_inited, 1, 0) == 0)
2161 LLVMAddGlobalMapping (ee, personality, mono_personality);
2164 i8ptr = LLVMPointerType (LLVMInt8Type (), 0);
2166 clause_index = (mono_get_block_region_notry (cfg, bb->region) >> 8) - 1;
2169 * Create the type info
2171 sprintf (ti_name, "type_info_%d", ti_generator);
2174 if (cfg->compile_aot) {
2175 /* decode_eh_frame () in aot-runtime.c will decode this */
2176 type_info = LLVMAddGlobal (module, LLVMInt32Type (), ti_name);
2177 LLVMSetInitializer (type_info, LLVMConstInt (LLVMInt32Type (), clause_index, FALSE));
2180 * These symbols are not really used, the clause_index is embedded into the EH tables generated by DwarfMonoException in LLVM.
2182 LLVMSetLinkage (type_info, LLVMInternalLinkage);
2185 * Enabling this causes llc to crash:
2186 * http://llvm.org/bugs/show_bug.cgi?id=6102
2188 //LLVM_FAILURE (ctx, "aot+clauses");
2190 // test_0_invalid_unbox_arrays () fails
2191 LLVM_FAILURE (ctx, "aot+clauses");
2195 * After the cfg mempool is freed, the type info will point to stale memory,
2196 * but this is not a problem, since we decode it once in exception_cb during
2199 ti = mono_mempool_alloc (cfg->mempool, sizeof (gint32));
2200 *(gint32*)ti = clause_index;
2202 type_info = LLVMAddGlobal (module, i8ptr, ti_name);
2204 LLVMAddGlobalMapping (ee, type_info, ti);
2208 LLVMTypeRef members [2], ret_type;
2209 LLVMValueRef landing_pad;
2211 members [0] = i8ptr;
2212 members [1] = LLVMInt32Type ();
2213 ret_type = LLVMStructType (members, 2, FALSE);
2215 landing_pad = LLVMBuildLandingPad (builder, ret_type, personality, 1, "");
2216 LLVMAddClause (landing_pad, type_info);
2218 /* Store the exception into the exvar */
2219 if (bb->in_scount == 1) {
2220 g_assert (bb->in_scount == 1);
2221 exvar = bb->in_stack [0];
2223 // FIXME: This is shared with filter clauses ?
2224 g_assert (!values [exvar->dreg]);
2226 values [exvar->dreg] = LLVMBuildExtractValue (builder, landing_pad, 0, "ex_obj");
2227 emit_volatile_store (ctx, exvar->dreg);
2231 /* Start a new bblock which CALL_HANDLER can branch to */
2232 target_bb = bblocks [bb->block_num].call_handler_target_bb;
2234 LLVMBuildBr (builder, target_bb);
2236 ctx->builder = builder = create_builder (ctx);
2237 LLVMPositionBuilderAtEnd (ctx->builder, target_bb);
2239 ctx->bblocks [bb->block_num].end_bblock = target_bb;
2243 has_terminator = FALSE;
2244 starting_builder = builder;
2245 for (ins = bb->code; ins; ins = ins->next) {
2246 const char *spec = LLVM_INS_INFO (ins->opcode);
2248 char dname_buf [128];
2251 if (nins > 5000 && builder == starting_builder) {
2252 /* some steps in llc are non-linear in the size of basic blocks, see #5714 */
2253 LLVM_FAILURE (ctx, "basic block too long");
2257 /* There could be instructions after a terminator, skip them */
2260 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins)) {
2261 sprintf (dname_buf, "t%d", ins->dreg);
2265 if (spec [MONO_INST_SRC1] != ' ' && spec [MONO_INST_SRC1] != 'v') {
2266 MonoInst *var = get_vreg_to_inst (cfg, ins->sreg1);
2268 if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2269 lhs = emit_volatile_load (ctx, ins->sreg1);
2271 /* It is ok for SETRET to have an uninitialized argument */
2272 if (!values [ins->sreg1] && ins->opcode != OP_SETRET)
2273 LLVM_FAILURE (ctx, "sreg1");
2274 lhs = values [ins->sreg1];
2280 if (spec [MONO_INST_SRC2] != ' ' && spec [MONO_INST_SRC2] != ' ') {
2281 MonoInst *var = get_vreg_to_inst (cfg, ins->sreg2);
2282 if (var && var->flags & (MONO_INST_VOLATILE|MONO_INST_INDIRECT)) {
2283 rhs = emit_volatile_load (ctx, ins->sreg2);
2285 if (!values [ins->sreg2])
2286 LLVM_FAILURE (ctx, "sreg2");
2287 rhs = values [ins->sreg2];
2293 //mono_print_ins (ins);
2294 switch (ins->opcode) {
2297 case OP_LIVERANGE_START:
2298 case OP_LIVERANGE_END:
2301 values [ins->dreg] = LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE);
2304 #if SIZEOF_VOID_P == 4
2305 values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2307 values [ins->dreg] = LLVMConstInt (LLVMInt64Type (), (gint64)ins->inst_c0, FALSE);
2311 values [ins->dreg] = LLVMConstReal (LLVMDoubleType (), *(double*)ins->inst_p0);
2314 values [ins->dreg] = LLVMConstFPExt (LLVMConstReal (LLVMFloatType (), *(float*)ins->inst_p0), LLVMDoubleType ());
2317 LLVMBuildBr (builder, get_bb (ctx, ins->inst_target_bb));
2318 has_terminator = TRUE;
2324 LLVMBasicBlockRef new_bb;
2325 LLVMBuilderRef new_builder;
2327 // The default branch is already handled
2328 // FIXME: Handle it here
2330 /* Start new bblock */
2331 sprintf (bb_name, "SWITCH_DEFAULT_BB%d", ctx->default_index ++);
2332 new_bb = LLVMAppendBasicBlock (ctx->lmethod, bb_name);
2334 lhs = convert (ctx, lhs, LLVMInt32Type ());
2335 v = LLVMBuildSwitch (builder, lhs, new_bb, GPOINTER_TO_UINT (ins->klass));
2336 for (i = 0; i < GPOINTER_TO_UINT (ins->klass); ++i) {
2337 MonoBasicBlock *target_bb = ins->inst_many_bb [i];
2339 LLVMAddCase (v, LLVMConstInt (LLVMInt32Type (), i, FALSE), get_bb (ctx, target_bb));
2342 new_builder = create_builder (ctx);
2343 LLVMPositionBuilderAtEnd (new_builder, new_bb);
2344 LLVMBuildUnreachable (new_builder);
2346 has_terminator = TRUE;
2347 g_assert (!ins->next);
2353 if (linfo->ret.storage == LLVMArgVtypeInReg) {
2354 LLVMTypeRef ret_type = LLVMGetReturnType (LLVMGetElementType (LLVMTypeOf (method)));
2355 LLVMValueRef part1, retval;
2358 size = get_vtype_size (sig->ret);
2360 g_assert (addresses [ins->sreg1]);
2362 g_assert (linfo->ret.pair_storage [0] == LLVMArgInIReg);
2363 g_assert (linfo->ret.pair_storage [1] == LLVMArgNone);
2365 part1 = convert (ctx, LLVMBuildLoad (builder, LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMIntType (size * 8), 0), ""), ""), IntPtrType ());
2367 retval = LLVMBuildInsertValue (builder, LLVMGetUndef (ret_type), part1, 0, "");
2369 LLVMBuildRet (builder, retval);
2373 if (linfo->ret.storage == LLVMArgVtypeRetAddr) {
2374 LLVMBuildRetVoid (builder);
2378 if (!lhs || ctx->is_dead [ins->sreg1]) {
2380 * The method did not set its return value, probably because it
2381 * ends with a throw.
2384 LLVMBuildRetVoid (builder);
2386 LLVMBuildRet (builder, LLVMConstNull (type_to_llvm_type (ctx, sig->ret)));
2388 LLVMBuildRet (builder, convert (ctx, lhs, type_to_llvm_type (ctx, sig->ret)));
2390 has_terminator = TRUE;
2396 case OP_ICOMPARE_IMM:
2397 case OP_LCOMPARE_IMM:
2398 case OP_COMPARE_IMM: {
2402 if (ins->next->opcode == OP_NOP)
2405 if (ins->next->opcode == OP_BR)
2406 /* The comparison result is not needed */
2409 rel = mono_opcode_to_cond (ins->next->opcode);
2411 if (ins->opcode == OP_ICOMPARE_IMM) {
2412 lhs = convert (ctx, lhs, LLVMInt32Type ());
2413 rhs = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2415 if (ins->opcode == OP_LCOMPARE_IMM) {
2416 lhs = convert (ctx, lhs, LLVMInt64Type ());
2417 rhs = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2419 if (ins->opcode == OP_LCOMPARE) {
2420 lhs = convert (ctx, lhs, LLVMInt64Type ());
2421 rhs = convert (ctx, rhs, LLVMInt64Type ());
2423 if (ins->opcode == OP_ICOMPARE) {
2424 lhs = convert (ctx, lhs, LLVMInt32Type ());
2425 rhs = convert (ctx, rhs, LLVMInt32Type ());
2429 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2430 rhs = convert (ctx, rhs, LLVMTypeOf (lhs));
2431 else if (LLVMGetTypeKind (LLVMTypeOf (rhs)) == LLVMPointerTypeKind)
2432 lhs = convert (ctx, lhs, LLVMTypeOf (rhs));
2435 /* We use COMPARE+SETcc/Bcc, llvm uses SETcc+br cond */
2436 if (ins->opcode == OP_FCOMPARE)
2437 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2438 else if (ins->opcode == OP_COMPARE_IMM)
2439 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), "");
2440 else if (ins->opcode == OP_LCOMPARE_IMM) {
2441 if (SIZEOF_REGISTER == 4 && COMPILE_LLVM (cfg)) {
2442 /* The immediate is encoded in two fields */
2443 guint64 l = ((guint64)(guint32)ins->inst_offset << 32) | ((guint32)ins->inst_imm);
2444 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), l, FALSE), "");
2446 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, LLVMInt64Type ()), LLVMConstInt (LLVMInt64Type (), ins->inst_imm, FALSE), "");
2449 else if (ins->opcode == OP_COMPARE)
2450 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], convert (ctx, lhs, IntPtrType ()), convert (ctx, rhs, IntPtrType ()), "");
2452 cmp = LLVMBuildICmp (builder, cond_to_llvm_cond [rel], lhs, rhs, "");
2454 if (MONO_IS_COND_BRANCH_OP (ins->next)) {
2455 if (ins->next->inst_true_bb == ins->next->inst_false_bb) {
2457 * If the target bb contains PHI instructions, LLVM requires
2458 * two PHI entries for this bblock, while we only generate one.
2459 * So convert this to an unconditional bblock. (bxc #171).
2461 LLVMBuildBr (builder, get_bb (ctx, ins->next->inst_true_bb));
2463 LLVMBuildCondBr (builder, cmp, get_bb (ctx, ins->next->inst_true_bb), get_bb (ctx, ins->next->inst_false_bb));
2465 has_terminator = TRUE;
2466 } else if (MONO_IS_SETCC (ins->next)) {
2467 sprintf (dname_buf, "t%d", ins->next->dreg);
2469 values [ins->next->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2471 /* Add stores for volatile variables */
2472 emit_volatile_store (ctx, ins->next->dreg);
2473 } else if (MONO_IS_COND_EXC (ins->next)) {
2474 emit_cond_system_exception (ctx, bb, ins->next->inst_p1, cmp);
2475 CHECK_FAILURE (ctx);
2476 builder = ctx->builder;
2478 LLVM_FAILURE (ctx, "next");
2492 rel = mono_opcode_to_cond (ins->opcode);
2494 cmp = LLVMBuildFCmp (builder, fpcond_to_llvm_cond [rel], convert (ctx, lhs, LLVMDoubleType ()), convert (ctx, rhs, LLVMDoubleType ()), "");
2495 values [ins->dreg] = LLVMBuildZExt (builder, cmp, LLVMInt32Type (), dname);
2503 gboolean empty = TRUE;
2505 /* Check that all input bblocks really branch to us */
2506 for (i = 0; i < bb->in_count; ++i) {
2507 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_NOT_REACHED)
2508 ins->inst_phi_args [i + 1] = -1;
2514 /* LLVM doesn't like phi instructions with zero operands */
2515 ctx->is_dead [ins->dreg] = TRUE;
2519 /* Created earlier, insert it now */
2520 LLVMInsertIntoBuilder (builder, values [ins->dreg]);
2522 for (i = 0; i < ins->inst_phi_args [0]; i++) {
2523 int sreg1 = ins->inst_phi_args [i + 1];
2527 * Count the number of times the incoming bblock branches to us,
2528 * since llvm requires a separate entry for each.
2530 if (bb->in_bb [i]->last_ins && bb->in_bb [i]->last_ins->opcode == OP_SWITCH) {
2531 MonoInst *switch_ins = bb->in_bb [i]->last_ins;
2534 for (j = 0; j < GPOINTER_TO_UINT (switch_ins->klass); ++j) {
2535 if (switch_ins->inst_many_bb [j] == bb)
2542 /* Remember for later */
2543 for (j = 0; j < count; ++j) {
2544 PhiNode *node = mono_mempool_alloc0 (ctx->mempool, sizeof (PhiNode));
2547 node->in_bb = bb->in_bb [i];
2549 bblocks [bb->in_bb [i]->block_num].phi_nodes = g_slist_prepend_mempool (ctx->mempool, bblocks [bb->in_bb [i]->block_num].phi_nodes, node);
2559 values [ins->dreg] = lhs;
2562 MonoInst *var = get_vreg_to_inst (cfg, ins->dreg);
2565 values [ins->dreg] = lhs;
2567 if (var && var->klass->byval_arg.type == MONO_TYPE_R4) {
2569 * This is added by the spilling pass in case of the JIT,
2570 * but we have to do it ourselves.
2572 values [ins->dreg] = convert (ctx, values [ins->dreg], LLVMFloatType ());
2606 lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2607 rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
2609 switch (ins->opcode) {
2612 values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, dname);
2616 values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, dname);
2620 values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, dname);
2624 values [ins->dreg] = LLVMBuildSRem (builder, lhs, rhs, dname);
2628 values [ins->dreg] = LLVMBuildURem (builder, lhs, rhs, dname);
2632 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, rhs, dname);
2636 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, rhs, dname);
2639 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, dname);
2643 values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, dname);
2647 values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, dname);
2651 values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, dname);
2655 values [ins->dreg] = LLVMBuildShl (builder, lhs, rhs, dname);
2659 values [ins->dreg] = LLVMBuildAShr (builder, lhs, rhs, dname);
2663 values [ins->dreg] = LLVMBuildLShr (builder, lhs, rhs, dname);
2667 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, dname);
2670 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, dname);
2673 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, dname);
2677 g_assert_not_reached ();
2684 case OP_IREM_UN_IMM:
2686 case OP_IDIV_UN_IMM:
2692 case OP_ISHR_UN_IMM:
2701 case OP_LSHR_UN_IMM:
2707 case OP_SHR_UN_IMM: {
2710 if (spec [MONO_INST_SRC1] == 'l') {
2711 imm = LLVMConstInt (LLVMInt64Type (), GET_LONG_IMM (ins), FALSE);
2713 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2716 #if SIZEOF_VOID_P == 4
2717 if (ins->opcode == OP_LSHL_IMM || ins->opcode == OP_LSHR_IMM || ins->opcode == OP_LSHR_UN_IMM)
2718 imm = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
2721 if (LLVMGetTypeKind (LLVMTypeOf (lhs)) == LLVMPointerTypeKind)
2722 lhs = convert (ctx, lhs, IntPtrType ());
2723 imm = convert (ctx, imm, LLVMTypeOf (lhs));
2724 switch (ins->opcode) {
2728 values [ins->dreg] = LLVMBuildAdd (builder, lhs, imm, dname);
2732 values [ins->dreg] = LLVMBuildSub (builder, lhs, imm, dname);
2736 values [ins->dreg] = LLVMBuildMul (builder, lhs, imm, dname);
2740 values [ins->dreg] = LLVMBuildSDiv (builder, lhs, imm, dname);
2742 case OP_IDIV_UN_IMM:
2743 case OP_LDIV_UN_IMM:
2744 values [ins->dreg] = LLVMBuildUDiv (builder, lhs, imm, dname);
2748 values [ins->dreg] = LLVMBuildSRem (builder, lhs, imm, dname);
2750 case OP_IREM_UN_IMM:
2751 values [ins->dreg] = LLVMBuildURem (builder, lhs, imm, dname);
2756 values [ins->dreg] = LLVMBuildAnd (builder, lhs, imm, dname);
2760 values [ins->dreg] = LLVMBuildOr (builder, lhs, imm, dname);
2764 values [ins->dreg] = LLVMBuildXor (builder, lhs, imm, dname);
2769 values [ins->dreg] = LLVMBuildShl (builder, lhs, imm, dname);
2774 values [ins->dreg] = LLVMBuildAShr (builder, lhs, imm, dname);
2776 case OP_ISHR_UN_IMM:
2777 /* This is used to implement conv.u4, so the lhs could be an i8 */
2778 lhs = convert (ctx, lhs, LLVMInt32Type ());
2779 imm = convert (ctx, imm, LLVMInt32Type ());
2780 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2782 case OP_LSHR_UN_IMM:
2784 values [ins->dreg] = LLVMBuildLShr (builder, lhs, imm, dname);
2787 g_assert_not_reached ();
2792 values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2795 values [ins->dreg] = LLVMBuildSub (builder, LLVMConstInt (LLVMInt64Type (), 0, FALSE), lhs, dname);
2798 lhs = convert (ctx, lhs, LLVMDoubleType ());
2799 values [ins->dreg] = LLVMBuildFSub (builder, LLVMConstReal (LLVMDoubleType (), 0.0), lhs, dname);
2802 guint32 v = 0xffffffff;
2803 values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt32Type (), v, FALSE), convert (ctx, lhs, LLVMInt32Type ()), dname);
2807 guint64 v = 0xffffffffffffffffLL;
2808 values [ins->dreg] = LLVMBuildXor (builder, LLVMConstInt (LLVMInt64Type (), v, FALSE), lhs, dname);
2811 #if defined(TARGET_X86) || defined(TARGET_AMD64)
2813 LLVMValueRef v1, v2;
2815 v1 = LLVMBuildMul (builder, convert (ctx, rhs, IntPtrType ()), LLVMConstInt (IntPtrType (), (1 << ins->backend.shift_amount), FALSE), "");
2816 v2 = LLVMBuildAdd (builder, convert (ctx, lhs, IntPtrType ()), v1, "");
2817 values [ins->dreg] = LLVMBuildAdd (builder, v2, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), dname);
2822 case OP_ICONV_TO_I1:
2823 case OP_ICONV_TO_I2:
2824 case OP_ICONV_TO_I4:
2825 case OP_ICONV_TO_U1:
2826 case OP_ICONV_TO_U2:
2827 case OP_ICONV_TO_U4:
2828 case OP_LCONV_TO_I1:
2829 case OP_LCONV_TO_I2:
2830 case OP_LCONV_TO_U1:
2831 case OP_LCONV_TO_U2:
2832 case OP_LCONV_TO_U4: {
2835 sign = (ins->opcode == OP_ICONV_TO_I1) || (ins->opcode == OP_ICONV_TO_I2) || (ins->opcode == OP_ICONV_TO_I4) || (ins->opcode == OP_LCONV_TO_I1) || (ins->opcode == OP_LCONV_TO_I2);
2837 /* Have to do two casts since our vregs have type int */
2838 v = LLVMBuildTrunc (builder, lhs, op_to_llvm_type (ins->opcode), "");
2840 values [ins->dreg] = LLVMBuildSExt (builder, v, LLVMInt32Type (), dname);
2842 values [ins->dreg] = LLVMBuildZExt (builder, v, LLVMInt32Type (), dname);
2845 case OP_ICONV_TO_I8:
2846 values [ins->dreg] = LLVMBuildSExt (builder, lhs, LLVMInt64Type (), dname);
2848 case OP_ICONV_TO_U8:
2849 values [ins->dreg] = LLVMBuildZExt (builder, lhs, LLVMInt64Type (), dname);
2851 case OP_FCONV_TO_I4:
2852 values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt32Type (), dname);
2854 case OP_FCONV_TO_I1:
2855 values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2857 case OP_FCONV_TO_U1:
2858 values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt8Type (), dname), LLVMInt32Type (), "");
2860 case OP_FCONV_TO_I2:
2861 values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildFPToSI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2863 case OP_FCONV_TO_U2:
2864 values [ins->dreg] = LLVMBuildZExt (builder, LLVMBuildFPToUI (builder, lhs, LLVMInt16Type (), dname), LLVMInt32Type (), "");
2866 case OP_FCONV_TO_I8:
2867 values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, LLVMInt64Type (), dname);
2870 values [ins->dreg] = LLVMBuildFPToSI (builder, lhs, IntPtrType (), dname);
2872 case OP_ICONV_TO_R8:
2873 case OP_LCONV_TO_R8:
2874 values [ins->dreg] = LLVMBuildSIToFP (builder, lhs, LLVMDoubleType (), dname);
2876 case OP_LCONV_TO_R_UN:
2877 values [ins->dreg] = LLVMBuildUIToFP (builder, lhs, LLVMDoubleType (), dname);
2879 #if SIZEOF_VOID_P == 4
2882 case OP_LCONV_TO_I4:
2883 values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2885 case OP_ICONV_TO_R4:
2886 case OP_LCONV_TO_R4:
2887 v = LLVMBuildSIToFP (builder, lhs, LLVMFloatType (), "");
2888 values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2890 case OP_FCONV_TO_R4:
2891 v = LLVMBuildFPTrunc (builder, lhs, LLVMFloatType (), "");
2892 values [ins->dreg] = LLVMBuildFPExt (builder, v, LLVMDoubleType (), dname);
2895 values [ins->dreg] = LLVMBuildSExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2898 values [ins->dreg] = LLVMBuildZExt (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMInt64Type (), dname);
2901 values [ins->dreg] = LLVMBuildTrunc (builder, lhs, LLVMInt32Type (), dname);
2903 case OP_LOCALLOC_IMM: {
2906 guint32 size = ins->inst_imm;
2907 size = (size + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
2909 v = mono_llvm_build_alloca (builder, LLVMInt8Type (), LLVMConstInt (LLVMInt32Type (), size, FALSE), MONO_ARCH_FRAME_ALIGNMENT, "");
2911 if (ins->flags & MONO_INST_INIT) {
2912 LLVMValueRef args [5];
2915 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2916 args [2] = LLVMConstInt (LLVMInt32Type (), size, FALSE);
2917 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2918 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2919 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2922 values [ins->dreg] = v;
2926 LLVMValueRef v, size;
2928 size = LLVMBuildAnd (builder, LLVMBuildAdd (builder, convert (ctx, lhs, LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT - 1, FALSE), ""), LLVMConstInt (LLVMInt32Type (), ~ (MONO_ARCH_FRAME_ALIGNMENT - 1), FALSE), "");
2930 v = mono_llvm_build_alloca (builder, LLVMInt8Type (), size, MONO_ARCH_FRAME_ALIGNMENT, "");
2932 if (ins->flags & MONO_INST_INIT) {
2933 LLVMValueRef args [5];
2936 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
2938 args [3] = LLVMConstInt (LLVMInt32Type (), MONO_ARCH_FRAME_ALIGNMENT, FALSE);
2939 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
2940 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
2942 values [ins->dreg] = v;
2946 case OP_LOADI1_MEMBASE:
2947 case OP_LOADU1_MEMBASE:
2948 case OP_LOADI2_MEMBASE:
2949 case OP_LOADU2_MEMBASE:
2950 case OP_LOADI4_MEMBASE:
2951 case OP_LOADU4_MEMBASE:
2952 case OP_LOADI8_MEMBASE:
2953 case OP_LOADR4_MEMBASE:
2954 case OP_LOADR8_MEMBASE:
2955 case OP_LOAD_MEMBASE:
2963 LLVMValueRef base, index, addr;
2965 gboolean sext = FALSE, zext = FALSE;
2966 gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
2968 t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
2973 if ((ins->opcode == OP_LOADI8_MEM) || (ins->opcode == OP_LOAD_MEM) || (ins->opcode == OP_LOADI4_MEM) || (ins->opcode == OP_LOADU4_MEM) || (ins->opcode == OP_LOADU1_MEM) || (ins->opcode == OP_LOADU2_MEM)) {
2974 addr = LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE);
2979 if (ins->inst_offset == 0) {
2981 } else if (ins->inst_offset % size != 0) {
2982 /* Unaligned load */
2983 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
2984 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
2986 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
2987 addr = LLVMBuildGEP (builder, convert (ctx, base, LLVMPointerType (t, 0)), &index, 1, "");
2991 addr = convert (ctx, addr, LLVMPointerType (t, 0));
2993 values [ins->dreg] = emit_load (ctx, bb, &builder, size, addr, dname, is_volatile);
2995 if (!is_volatile && (ins->flags & MONO_INST_INVARIANT_LOAD)) {
2997 * These will signal LLVM that these loads do not alias any stores, and
2998 * they can't fail, allowing them to be hoisted out of loops.
3000 set_invariant_load_flag (values [ins->dreg]);
3001 set_metadata_flag (values [ins->dreg], "mono.nofail.load");
3005 values [ins->dreg] = LLVMBuildSExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
3007 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), dname);
3008 else if (ins->opcode == OP_LOADR4_MEMBASE)
3009 values [ins->dreg] = LLVMBuildFPExt (builder, values [ins->dreg], LLVMDoubleType (), dname);
3013 case OP_STOREI1_MEMBASE_REG:
3014 case OP_STOREI2_MEMBASE_REG:
3015 case OP_STOREI4_MEMBASE_REG:
3016 case OP_STOREI8_MEMBASE_REG:
3017 case OP_STORER4_MEMBASE_REG:
3018 case OP_STORER8_MEMBASE_REG:
3019 case OP_STORE_MEMBASE_REG: {
3021 LLVMValueRef index, addr;
3023 gboolean sext = FALSE, zext = FALSE;
3024 gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3026 if (!values [ins->inst_destbasereg])
3027 LLVM_FAILURE (ctx, "inst_destbasereg");
3029 t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3031 if (ins->inst_offset % size != 0) {
3032 /* Unaligned store */
3033 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3034 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3036 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3037 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3039 emit_store (ctx, bb, &builder, size, convert (ctx, values [ins->sreg1], t), convert (ctx, addr, LLVMPointerType (t, 0)), is_volatile);
3043 case OP_STOREI1_MEMBASE_IMM:
3044 case OP_STOREI2_MEMBASE_IMM:
3045 case OP_STOREI4_MEMBASE_IMM:
3046 case OP_STOREI8_MEMBASE_IMM:
3047 case OP_STORE_MEMBASE_IMM: {
3049 LLVMValueRef index, addr;
3051 gboolean sext = FALSE, zext = FALSE;
3052 gboolean is_volatile = (ins->flags & MONO_INST_FAULT);
3054 t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext);
3056 if (ins->inst_offset % size != 0) {
3057 /* Unaligned store */
3058 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset, FALSE);
3059 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (LLVMInt8Type (), 0)), &index, 1, "");
3061 index = LLVMConstInt (LLVMInt32Type (), ins->inst_offset / size, FALSE);
3062 addr = LLVMBuildGEP (builder, convert (ctx, values [ins->inst_destbasereg], LLVMPointerType (t, 0)), &index, 1, "");
3064 emit_store (ctx, bb, &builder, size, convert (ctx, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), t), addr, is_volatile);
3069 emit_load (ctx, bb, &builder, sizeof (gpointer), convert (ctx, lhs, LLVMPointerType (IntPtrType (), 0)), "", TRUE);
3071 case OP_OUTARG_VTRETADDR:
3078 case OP_VOIDCALL_MEMBASE:
3079 case OP_CALL_MEMBASE:
3080 case OP_LCALL_MEMBASE:
3081 case OP_FCALL_MEMBASE:
3082 case OP_VCALL_MEMBASE:
3083 case OP_VOIDCALL_REG:
3087 case OP_VCALL_REG: {
3088 process_call (ctx, bb, &builder, ins);
3089 CHECK_FAILURE (ctx);
3094 LLVMValueRef indexes [2];
3096 LLVMValueRef got_entry_addr;
3099 * FIXME: Can't allocate from the cfg mempool since that is freed if
3100 * the LLVM compile fails.
3102 ji = g_new0 (MonoJumpInfo, 1);
3103 ji->type = (MonoJumpInfoType)ins->inst_i1;
3104 ji->data.target = ins->inst_p0;
3106 ji = mono_aot_patch_info_dup (ji);
3108 ji->next = cfg->patch_info;
3109 cfg->patch_info = ji;
3111 //mono_add_patch_info (cfg, 0, (MonoJumpInfoType)ins->inst_i1, ins->inst_p0);
3112 got_offset = mono_aot_get_got_offset (cfg->patch_info);
3114 indexes [0] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3115 indexes [1] = LLVMConstInt (LLVMInt32Type (), (gssize)got_offset, FALSE);
3116 got_entry_addr = LLVMBuildGEP (builder, ctx->lmodule->got_var, indexes, 2, "");
3118 values [ins->dreg] = LLVMBuildLoad (builder, got_entry_addr, dname);
3119 set_invariant_load_flag (values [ins->dreg]);
3122 case OP_NOT_REACHED:
3123 LLVMBuildUnreachable (builder);
3124 has_terminator = TRUE;
3125 g_assert (bb->block_num < cfg->max_block_num);
3126 ctx->unreachable [bb->block_num] = TRUE;
3127 /* Might have instructions after this */
3129 MonoInst *next = ins->next;
3131 * FIXME: If later code uses the regs defined by these instructions,
3132 * compilation will fail.
3134 MONO_DELETE_INS (bb, next);
3138 MonoInst *var = ins->inst_p0;
3140 values [ins->dreg] = addresses [var->dreg];
3144 LLVMValueRef args [1];
3146 args [0] = convert (ctx, lhs, LLVMDoubleType ());
3147 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sin.f64"), args, 1, dname);
3151 LLVMValueRef args [1];
3153 args [0] = convert (ctx, lhs, LLVMDoubleType ());
3154 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.cos.f64"), args, 1, dname);
3158 LLVMValueRef args [1];
3161 /* This no longer seems to happen */
3163 * LLVM optimizes sqrt(nan) into undefined in
3164 * lib/Analysis/ConstantFolding.cpp
3165 * Also, sqrt(NegativeInfinity) is optimized into 0.
3167 LLVM_FAILURE (ctx, "sqrt");
3169 args [0] = convert (ctx, lhs, LLVMDoubleType ());
3170 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "llvm.sqrt.f64"), args, 1, dname);
3174 LLVMValueRef args [1];
3176 args [0] = convert (ctx, lhs, LLVMDoubleType ());
3177 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, "fabs"), args, 1, dname);
3191 lhs = convert (ctx, lhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3192 rhs = convert (ctx, rhs, regtype_to_llvm_type (spec [MONO_INST_DEST]));
3194 switch (ins->opcode) {
3197 v = LLVMBuildICmp (builder, LLVMIntSLE, lhs, rhs, "");
3201 v = LLVMBuildICmp (builder, LLVMIntSGE, lhs, rhs, "");
3205 v = LLVMBuildICmp (builder, LLVMIntULE, lhs, rhs, "");
3209 v = LLVMBuildICmp (builder, LLVMIntUGE, lhs, rhs, "");
3212 g_assert_not_reached ();
3215 values [ins->dreg] = LLVMBuildSelect (builder, v, lhs, rhs, dname);
3218 case OP_ATOMIC_EXCHANGE_I4:
3219 case OP_ATOMIC_EXCHANGE_I8: {
3220 LLVMValueRef args [2];
3223 if (ins->opcode == OP_ATOMIC_EXCHANGE_I4)
3224 t = LLVMInt32Type ();
3226 t = LLVMInt64Type ();
3228 g_assert (ins->inst_offset == 0);
3230 args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
3231 args [1] = convert (ctx, rhs, t);
3233 values [ins->dreg] = mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_XCHG, args [0], args [1]);
3236 case OP_ATOMIC_ADD_NEW_I4:
3237 case OP_ATOMIC_ADD_NEW_I8: {
3238 LLVMValueRef args [2];
3241 if (ins->opcode == OP_ATOMIC_ADD_NEW_I4)
3242 t = LLVMInt32Type ();
3244 t = LLVMInt64Type ();
3246 g_assert (ins->inst_offset == 0);
3248 args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
3249 args [1] = convert (ctx, rhs, t);
3250 values [ins->dreg] = LLVMBuildAdd (builder, mono_llvm_build_atomic_rmw (builder, LLVM_ATOMICRMW_OP_ADD, args [0], args [1]), args [1], dname);
3253 case OP_ATOMIC_CAS_I4:
3254 case OP_ATOMIC_CAS_I8: {
3255 LLVMValueRef args [3];
3258 if (ins->opcode == OP_ATOMIC_CAS_I4)
3259 t = LLVMInt32Type ();
3261 t = LLVMInt64Type ();
3263 args [0] = convert (ctx, lhs, LLVMPointerType (t, 0));
3265 args [1] = convert (ctx, values [ins->sreg3], t);
3267 args [2] = convert (ctx, values [ins->sreg2], t);
3268 values [ins->dreg] = mono_llvm_build_cmpxchg (builder, args [0], args [1], args [2]);
3271 case OP_MEMORY_BARRIER: {
3272 mono_llvm_build_fence (builder);
3275 case OP_RELAXED_NOP: {
3276 #if defined(TARGET_AMD64) || defined(TARGET_X86)
3277 emit_call (ctx, bb, &builder, LLVMGetNamedFunction (ctx->module, "llvm.x86.sse2.pause"), NULL, 0);
3284 #if (defined(TARGET_AMD64) || defined(TARGET_X86)) && defined(__linux__)
3286 // 257 == FS segment register
3287 LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 257);
3289 // 256 == GS segment register
3290 LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3293 values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), ins->inst_offset, TRUE), ptrtype, ""), "");
3294 #elif defined(TARGET_AMD64) && defined(TARGET_OSX)
3295 /* See mono_amd64_emit_tls_get () */
3296 int offset = mono_amd64_get_tls_gs_offset () + (ins->inst_offset * 8);
3298 // 256 == GS segment register
3299 LLVMTypeRef ptrtype = LLVMPointerType (IntPtrType (), 256);
3300 values [ins->dreg] = LLVMBuildLoad (builder, LLVMBuildIntToPtr (builder, LLVMConstInt (IntPtrType (), offset, TRUE), ptrtype, ""), "");
3302 LLVM_FAILURE (ctx, "opcode tls-get");
3312 case OP_IADD_OVF_UN:
3314 case OP_ISUB_OVF_UN:
3316 case OP_IMUL_OVF_UN:
3317 #if SIZEOF_VOID_P == 8
3319 case OP_LADD_OVF_UN:
3321 case OP_LSUB_OVF_UN:
3323 case OP_LMUL_OVF_UN:
3326 LLVMValueRef args [2], val, ovf, func;
3328 args [0] = convert (ctx, lhs, op_to_llvm_type (ins->opcode));
3329 args [1] = convert (ctx, rhs, op_to_llvm_type (ins->opcode));
3330 func = LLVMGetNamedFunction (module, ovf_op_to_intrins (ins->opcode));
3332 val = LLVMBuildCall (builder, func, args, 2, "");
3333 values [ins->dreg] = LLVMBuildExtractValue (builder, val, 0, dname);
3334 ovf = LLVMBuildExtractValue (builder, val, 1, "");
3335 emit_cond_system_exception (ctx, bb, "OverflowException", ovf);
3336 CHECK_FAILURE (ctx);
3337 builder = ctx->builder;
3343 * We currently model them using arrays. Promotion to local vregs is
3344 * disabled for them in mono_handle_global_vregs () in the LLVM case,
3345 * so we always have an entry in cfg->varinfo for them.
3346 * FIXME: Is this needed ?
3349 MonoClass *klass = ins->klass;
3350 LLVMValueRef args [5];
3354 LLVM_FAILURE (ctx, "!klass");
3358 if (!addresses [ins->dreg])
3359 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3360 args [0] = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3361 args [1] = LLVMConstInt (LLVMInt8Type (), 0, FALSE);
3362 args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3364 args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3365 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3366 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memset_func_name), args, memset_param_count, "");
3370 case OP_STOREV_MEMBASE:
3371 case OP_LOADV_MEMBASE:
3373 MonoClass *klass = ins->klass;
3374 LLVMValueRef src = NULL, dst, args [5];
3375 gboolean done = FALSE;
3379 LLVM_FAILURE (ctx, "!klass");
3383 if (mini_is_gsharedvt_klass (cfg, klass)) {
3385 LLVM_FAILURE (ctx, "gsharedvt");
3389 switch (ins->opcode) {
3390 case OP_STOREV_MEMBASE:
3391 if (cfg->gen_write_barriers && klass->has_references && ins->inst_destbasereg != cfg->frame_reg) {
3392 /* FIXME: Emit write barriers like in mini_emit_stobj () */
3393 LLVM_FAILURE (ctx, "storev_membase + write barriers");
3396 if (!addresses [ins->sreg1]) {
3398 g_assert (values [ins->sreg1]);
3399 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));
3400 LLVMBuildStore (builder, values [ins->sreg1], dst);
3403 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3404 dst = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3407 case OP_LOADV_MEMBASE:
3408 if (!addresses [ins->dreg])
3409 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3410 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (LLVMInt8Type (), 0));
3411 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3414 if (!addresses [ins->sreg1])
3415 addresses [ins->sreg1] = build_alloca (ctx, &klass->byval_arg);
3416 if (!addresses [ins->dreg])
3417 addresses [ins->dreg] = build_alloca (ctx, &klass->byval_arg);
3418 src = LLVMBuildBitCast (builder, addresses [ins->sreg1], LLVMPointerType (LLVMInt8Type (), 0), "");
3419 dst = LLVMBuildBitCast (builder, addresses [ins->dreg], LLVMPointerType (LLVMInt8Type (), 0), "");
3422 g_assert_not_reached ();
3424 CHECK_FAILURE (ctx);
3431 args [2] = LLVMConstInt (LLVMInt32Type (), mono_class_value_size (klass, NULL), FALSE);
3432 args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3434 args [3] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3435 args [4] = LLVMConstInt (LLVMInt1Type (), 0, FALSE);
3436 LLVMBuildCall (builder, LLVMGetNamedFunction (module, memcpy_func_name), args, memcpy_param_count, "");
3439 case OP_LLVM_OUTARG_VT:
3440 if (!addresses [ins->sreg1]) {
3441 addresses [ins->sreg1] = build_alloca (ctx, &ins->klass->byval_arg);
3442 g_assert (values [ins->sreg1]);
3443 LLVMBuildStore (builder, values [ins->sreg1], addresses [ins->sreg1]);
3445 addresses [ins->dreg] = addresses [ins->sreg1];
3451 #if defined(TARGET_X86) || defined(TARGET_AMD64)
3453 values [ins->dreg] = LLVMConstNull (type_to_llvm_type (ctx, &ins->klass->byval_arg));
3456 case OP_LOADX_MEMBASE: {
3457 LLVMTypeRef t = type_to_llvm_type (ctx, &ins->klass->byval_arg);
3460 src = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_basereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3461 values [ins->dreg] = mono_llvm_build_aligned_load (builder, src, "", FALSE, 1);
3464 case OP_STOREX_MEMBASE: {
3465 LLVMTypeRef t = LLVMTypeOf (values [ins->sreg1]);
3468 dest = convert (ctx, LLVMBuildAdd (builder, convert (ctx, values [ins->inst_destbasereg], IntPtrType ()), LLVMConstInt (IntPtrType (), ins->inst_offset, FALSE), ""), LLVMPointerType (t, 0));
3469 mono_llvm_build_aligned_store (builder, values [ins->sreg1], dest, FALSE, 1);
3476 values [ins->dreg] = LLVMBuildAdd (builder, lhs, rhs, "");
3480 values [ins->dreg] = LLVMBuildFAdd (builder, lhs, rhs, "");
3486 values [ins->dreg] = LLVMBuildSub (builder, lhs, rhs, "");
3490 values [ins->dreg] = LLVMBuildFSub (builder, lhs, rhs, "");
3494 values [ins->dreg] = LLVMBuildFMul (builder, lhs, rhs, "");
3498 values [ins->dreg] = LLVMBuildFDiv (builder, lhs, rhs, "");
3501 values [ins->dreg] = LLVMBuildAnd (builder, lhs, rhs, "");
3504 values [ins->dreg] = LLVMBuildOr (builder, lhs, rhs, "");
3507 values [ins->dreg] = LLVMBuildXor (builder, lhs, rhs, "");
3511 values [ins->dreg] = LLVMBuildMul (builder, lhs, rhs, "");
3522 LLVMValueRef v = NULL;
3524 switch (ins->opcode) {
3529 t = LLVMVectorType (LLVMInt32Type (), 4);
3530 rt = LLVMVectorType (LLVMFloatType (), 4);
3536 t = LLVMVectorType (LLVMInt64Type (), 2);
3537 rt = LLVMVectorType (LLVMDoubleType (), 2);
3540 t = LLVMInt32Type ();
3541 rt = LLVMInt32Type ();
3542 g_assert_not_reached ();
3545 lhs = LLVMBuildBitCast (builder, lhs, t, "");
3546 rhs = LLVMBuildBitCast (builder, rhs, t, "");
3547 switch (ins->opcode) {
3550 v = LLVMBuildAnd (builder, lhs, rhs, "");
3554 v = LLVMBuildOr (builder, lhs, rhs, "");
3558 v = LLVMBuildXor (builder, lhs, rhs, "");
3562 v = LLVMBuildAnd (builder, rhs, LLVMBuildNot (builder, lhs, ""), "");
3565 values [ins->dreg] = LLVMBuildBitCast (builder, v, rt, "");
3589 case OP_PADDB_SAT_UN:
3590 case OP_PADDW_SAT_UN:
3591 case OP_PSUBB_SAT_UN:
3592 case OP_PSUBW_SAT_UN:
3600 case OP_PMULW_HIGH_UN: {
3601 LLVMValueRef args [2];
3606 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3613 values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntEQ, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3617 values [ins->dreg] = LLVMBuildSExt (builder, LLVMBuildICmp (builder, LLVMIntSGT, lhs, rhs, ""), LLVMTypeOf (lhs), "");
3625 case OP_EXTRACTX_U2:
3627 case OP_EXTRACT_U1: {
3629 gboolean zext = FALSE;
3631 t = simd_op_to_llvm_type (ins->opcode);
3633 switch (ins->opcode) {
3641 case OP_EXTRACTX_U2:
3646 t = LLVMInt32Type ();
3647 g_assert_not_reached ();
3650 lhs = LLVMBuildBitCast (builder, lhs, t, "");
3651 values [ins->dreg] = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), "");
3653 values [ins->dreg] = LLVMBuildZExt (builder, values [ins->dreg], LLVMInt32Type (), "");
3662 case OP_EXPAND_R8: {
3663 LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3664 LLVMValueRef mask [16], v;
3666 for (i = 0; i < 16; ++i)
3667 mask [i] = LLVMConstInt (LLVMInt32Type (), 0, FALSE);
3669 v = convert (ctx, values [ins->sreg1], LLVMGetElementType (t));
3671 values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (t), v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3672 values [ins->dreg] = LLVMBuildShuffleVector (builder, values [ins->dreg], LLVMGetUndef (t), LLVMConstVector (mask, LLVMGetVectorSize (t)), "");
3677 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3680 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3683 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3686 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3689 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3692 values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), LLVMConstInt (LLVMInt32Type (), ins->inst_c0, FALSE), dname);
3703 case OP_EXTRACT_MASK:
3710 v = convert (ctx, values [ins->sreg1], simd_op_to_llvm_type (ins->opcode));
3712 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), &v, 1, dname);
3716 case OP_ICONV_TO_R8_RAW:
3717 /* Same as OP_ICONV_TO_R8 */
3718 values [ins->dreg] = convert (ctx, LLVMBuildBitCast (builder, lhs, LLVMFloatType (), ""), LLVMDoubleType ());
3723 LLVMValueRef args [3];
3727 args [2] = LLVMConstInt (LLVMInt8Type (), ins->inst_c0, FALSE);
3729 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 3, dname);
3734 /* This is only used for implementing shifts by non-immediate */
3735 values [ins->dreg] = lhs;
3746 LLVMValueRef args [3];
3749 args [1] = LLVMConstInt (LLVMInt32Type (), ins->inst_imm, FALSE);
3751 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3762 case OP_PSHLQ_REG: {
3763 LLVMValueRef args [3];
3766 args [1] = values [ins->sreg2];
3768 values [ins->dreg] = LLVMBuildCall (builder, LLVMGetNamedFunction (module, simd_op_to_intrins (ins->opcode)), args, 2, dname);
3775 case OP_PSHUFLEW_LOW:
3776 case OP_PSHUFLEW_HIGH: {
3778 LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16];
3779 int i, mask_size = 0;
3780 int imask = ins->inst_c0;
3782 /* Convert the x86 shuffle mask to LLVM's */
3783 switch (ins->opcode) {
3786 mask [0] = ((imask >> 0) & 3);
3787 mask [1] = ((imask >> 2) & 3);
3788 mask [2] = ((imask >> 4) & 3) + 4;
3789 mask [3] = ((imask >> 6) & 3) + 4;
3790 v1 = values [ins->sreg1];
3791 v2 = values [ins->sreg2];
3795 mask [0] = ((imask >> 0) & 1);
3796 mask [1] = ((imask >> 1) & 1) + 2;
3797 v1 = values [ins->sreg1];
3798 v2 = values [ins->sreg2];
3800 case OP_PSHUFLEW_LOW:
3802 mask [0] = ((imask >> 0) & 3);
3803 mask [1] = ((imask >> 2) & 3);
3804 mask [2] = ((imask >> 4) & 3);
3805 mask [3] = ((imask >> 6) & 3);
3810 v1 = values [ins->sreg1];
3811 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3813 case OP_PSHUFLEW_HIGH:
3819 mask [4] = 4 + ((imask >> 0) & 3);
3820 mask [5] = 4 + ((imask >> 2) & 3);
3821 mask [6] = 4 + ((imask >> 4) & 3);
3822 mask [7] = 4 + ((imask >> 6) & 3);
3823 v1 = values [ins->sreg1];
3824 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3828 mask [0] = ((imask >> 0) & 3);
3829 mask [1] = ((imask >> 2) & 3);
3830 mask [2] = ((imask >> 4) & 3);
3831 mask [3] = ((imask >> 6) & 3);
3832 v1 = values [ins->sreg1];
3833 v2 = LLVMGetUndef (LLVMTypeOf (v1));
3836 g_assert_not_reached ();
3838 for (i = 0; i < mask_size; ++i)
3839 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3841 values [ins->dreg] =
3842 LLVMBuildShuffleVector (builder, v1, v2,
3843 LLVMConstVector (mask_values, mask_size), dname);
3847 case OP_UNPACK_LOWB:
3848 case OP_UNPACK_LOWW:
3849 case OP_UNPACK_LOWD:
3850 case OP_UNPACK_LOWQ:
3851 case OP_UNPACK_LOWPS:
3852 case OP_UNPACK_LOWPD:
3853 case OP_UNPACK_HIGHB:
3854 case OP_UNPACK_HIGHW:
3855 case OP_UNPACK_HIGHD:
3856 case OP_UNPACK_HIGHQ:
3857 case OP_UNPACK_HIGHPS:
3858 case OP_UNPACK_HIGHPD: {
3860 LLVMValueRef mask_values [16];
3861 int i, mask_size = 0;
3862 gboolean low = FALSE;
3864 switch (ins->opcode) {
3865 case OP_UNPACK_LOWB:
3869 case OP_UNPACK_LOWW:
3873 case OP_UNPACK_LOWD:
3874 case OP_UNPACK_LOWPS:
3878 case OP_UNPACK_LOWQ:
3879 case OP_UNPACK_LOWPD:
3883 case OP_UNPACK_HIGHB:
3886 case OP_UNPACK_HIGHW:
3889 case OP_UNPACK_HIGHD:
3890 case OP_UNPACK_HIGHPS:
3893 case OP_UNPACK_HIGHQ:
3894 case OP_UNPACK_HIGHPD:
3898 g_assert_not_reached ();
3902 for (i = 0; i < (mask_size / 2); ++i) {
3904 mask [(i * 2) + 1] = mask_size + i;
3907 for (i = 0; i < (mask_size / 2); ++i) {
3908 mask [(i * 2)] = (mask_size / 2) + i;
3909 mask [(i * 2) + 1] = mask_size + (mask_size / 2) + i;
3913 for (i = 0; i < mask_size; ++i)
3914 mask_values [i] = LLVMConstInt (LLVMInt32Type (), mask [i], FALSE);
3916 values [ins->dreg] =
3917 LLVMBuildShuffleVector (builder, values [ins->sreg1], values [ins->sreg2],
3918 LLVMConstVector (mask_values, mask_size), dname);
3923 LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3924 LLVMValueRef v, val;
3926 v = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3927 val = LLVMConstNull (t);
3928 val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3929 val = LLVMBuildInsertElement (builder, val, v, LLVMConstInt (LLVMInt32Type (), 1, FALSE), dname);
3931 values [ins->dreg] = val;
3935 case OP_DUPPS_HIGH: {
3936 LLVMTypeRef t = simd_op_to_llvm_type (ins->opcode);
3937 LLVMValueRef v1, v2, val;
3940 if (ins->opcode == OP_DUPPS_LOW) {
3941 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3942 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3944 v1 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3945 v2 = LLVMBuildExtractElement (builder, lhs, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3947 val = LLVMConstNull (t);
3948 val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 0, FALSE), "");
3949 val = LLVMBuildInsertElement (builder, val, v1, LLVMConstInt (LLVMInt32Type (), 1, FALSE), "");
3950 val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 2, FALSE), "");
3951 val = LLVMBuildInsertElement (builder, val, v2, LLVMConstInt (LLVMInt32Type (), 3, FALSE), "");
3953 values [ins->dreg] = val;
3963 * EXCEPTION HANDLING
3965 case OP_IMPLICIT_EXCEPTION:
3966 /* This marks a place where an implicit exception can happen */
3967 if (bb->region != -1)
3968 LLVM_FAILURE (ctx, "implicit-exception");
3972 MonoMethodSignature *throw_sig;
3973 LLVMValueRef callee, arg;
3974 gboolean rethrow = (ins->opcode == OP_RETHROW);
3975 const char *icall_name;
3977 callee = rethrow ? ctx->lmodule->rethrow : ctx->lmodule->throw;
3978 icall_name = rethrow ? "mono_arch_rethrow_exception" : "mono_arch_throw_exception";
3981 throw_sig = mono_metadata_signature_alloc (mono_get_corlib (), 1);
3982 throw_sig->ret = &mono_get_void_class ()->byval_arg;
3983 throw_sig->params [0] = &mono_get_object_class ()->byval_arg;
3984 if (cfg->compile_aot) {
3985 callee = get_plt_entry (ctx, sig_to_llvm_sig (ctx, throw_sig), MONO_PATCH_INFO_INTERNAL_METHOD, icall_name);
3987 callee = LLVMAddFunction (module, icall_name, sig_to_llvm_sig (ctx, throw_sig));
3991 * LLVM doesn't push the exception argument, so we need a different
3994 LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, rethrow ? "llvm_rethrow_exception_trampoline" : "llvm_throw_exception_trampoline"));
3996 LLVMAddGlobalMapping (ee, callee, resolve_patch (cfg, MONO_PATCH_INFO_INTERNAL_METHOD, icall_name));
4000 mono_memory_barrier ();
4002 ctx->lmodule->rethrow = callee;
4004 ctx->lmodule->throw = callee;
4006 arg = convert (ctx, lhs, type_to_llvm_type (ctx, &mono_get_object_class ()->byval_arg));
4007 emit_call (ctx, bb, &builder, callee, &arg, 1);
4010 case OP_CALL_HANDLER: {
4012 * We don't 'call' handlers, but instead simply branch to them.
4013 * The code generated by ENDFINALLY will branch back to us.
4015 LLVMBasicBlockRef noex_bb;
4017 BBInfo *info = &bblocks [ins->inst_target_bb->block_num];
4019 bb_list = info->call_handler_return_bbs;
4022 * Set the indicator variable for the finally clause.
4024 lhs = info->finally_ind;
4026 LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), g_slist_length (bb_list) + 1, FALSE), lhs);
4028 /* Branch to the finally clause */
4029 LLVMBuildBr (builder, info->call_handler_target_bb);
4031 noex_bb = gen_bb (ctx, "CALL_HANDLER_CONT_BB");
4032 info->call_handler_return_bbs = g_slist_append_mempool (cfg->mempool, info->call_handler_return_bbs, noex_bb);
4034 builder = ctx->builder = create_builder (ctx);
4035 LLVMPositionBuilderAtEnd (ctx->builder, noex_bb);
4037 bblocks [bb->block_num].end_bblock = noex_bb;
4040 case OP_START_HANDLER: {
4043 case OP_ENDFINALLY: {
4044 LLVMBasicBlockRef resume_bb;
4045 MonoBasicBlock *handler_bb;
4046 LLVMValueRef val, switch_ins, callee;
4050 handler_bb = g_hash_table_lookup (ctx->region_to_handler, GUINT_TO_POINTER (mono_get_block_region_notry (cfg, bb->region)));
4051 g_assert (handler_bb);
4052 info = &bblocks [handler_bb->block_num];
4053 lhs = info->finally_ind;
4056 bb_list = info->call_handler_return_bbs;
4058 resume_bb = gen_bb (ctx, "ENDFINALLY_RESUME_BB");
4060 /* Load the finally variable */
4061 val = LLVMBuildLoad (builder, lhs, "");
4063 /* Reset the variable */
4064 LLVMBuildStore (builder, LLVMConstInt (LLVMInt32Type (), 0, FALSE), lhs);
4066 /* Branch to either resume_bb, or to the bblocks in bb_list */
4067 switch_ins = LLVMBuildSwitch (builder, val, resume_bb, g_slist_length (bb_list));
4069 * The other targets are added at the end to handle OP_CALL_HANDLER
4070 * opcodes processed later.
4072 info->endfinally_switch_ins_list = g_slist_append_mempool (cfg->mempool, info->endfinally_switch_ins_list, switch_ins);
4074 builder = ctx->builder = create_builder (ctx);
4075 LLVMPositionBuilderAtEnd (ctx->builder, resume_bb);
4077 if (ctx->cfg->compile_aot) {
4078 callee = get_plt_entry (ctx, LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE), MONO_PATCH_INFO_INTERNAL_METHOD, "llvm_resume_unwind_trampoline");
4080 callee = LLVMGetNamedFunction (module, "llvm_resume_unwind_trampoline");
4082 LLVMBuildCall (builder, callee, NULL, 0, "");
4084 LLVMBuildUnreachable (builder);
4085 has_terminator = TRUE;
4091 sprintf (reason, "opcode %s", mono_inst_name (ins->opcode));
4092 LLVM_FAILURE (ctx, reason);
4097 /* Convert the value to the type required by phi nodes */
4098 if (spec [MONO_INST_DEST] != ' ' && !MONO_IS_STORE_MEMBASE (ins) && ctx->vreg_types [ins->dreg]) {
4099 if (!values [ins->dreg])
4101 values [ins->dreg] = addresses [ins->dreg];
4103 values [ins->dreg] = convert (ctx, values [ins->dreg], ctx->vreg_types [ins->dreg]);
4106 /* Add stores for volatile variables */
4107 if (spec [MONO_INST_DEST] != ' ' && spec [MONO_INST_DEST] != 'v' && !MONO_IS_STORE_MEMBASE (ins))
4108 emit_volatile_store (ctx, ins->dreg);
4111 if (!has_terminator && bb->next_bb && (bb == cfg->bb_entry || bb->in_count > 0))
4112 LLVMBuildBr (builder, get_bb (ctx, bb->next_bb));
4114 if (bb == cfg->bb_exit && sig->ret->type == MONO_TYPE_VOID)
4115 LLVMBuildRetVoid (builder);
4117 if (bb == cfg->bb_entry)
4118 ctx->last_alloca = LLVMGetLastInstruction (get_bb (ctx, cfg->bb_entry));
4127 * mono_llvm_check_method_supported:
4129 * Do some quick checks to decide whenever cfg->method can be compiled by LLVM, to avoid
4130 * compiling a method twice.
4133 mono_llvm_check_method_supported (MonoCompile *cfg)
4135 MonoMethodHeader *header = cfg->header;
4136 MonoExceptionClause *clause;
4139 if (cfg->method->save_lmf) {
4140 cfg->exception_message = g_strdup ("lmf");
4141 cfg->disable_llvm = TRUE;
4145 for (i = 0; i < header->num_clauses; ++i) {
4146 clause = &header->clauses [i];
4148 if (i > 0 && clause->try_offset <= header->clauses [i - 1].handler_offset + header->clauses [i - 1].handler_len) {
4150 * FIXME: Some tests still fail with nested clauses.
4152 cfg->exception_message = g_strdup ("nested clauses");
4153 cfg->disable_llvm = TRUE;
4159 if (cfg->method->dynamic) {
4160 cfg->exception_message = g_strdup ("dynamic.");
4161 cfg->disable_llvm = TRUE;
4166 * mono_llvm_emit_method:
4168 * Emit LLVM IL from the mono IL, and compile it to native code using LLVM.
4171 mono_llvm_emit_method (MonoCompile *cfg)
4174 MonoMethodSignature *sig;
4176 LLVMTypeRef method_type;
4177 LLVMValueRef method = NULL;
4179 LLVMValueRef *values;
4180 int i, max_block_num, bb_index;
4181 gboolean last = FALSE;
4182 GPtrArray *phi_values;
4183 LLVMCallInfo *linfo;
4185 LLVMModuleRef module;
4187 GPtrArray *bblock_list;
4188 MonoMethodHeader *header;
4189 MonoExceptionClause *clause;
4193 /* The code below might acquire the loader lock, so use it for global locking */
4194 mono_loader_lock ();
4196 /* Used to communicate with the callbacks */
4197 mono_native_tls_set_value (current_cfg_tls_id, cfg);
4199 ctx = g_new0 (EmitContext, 1);
4201 ctx->mempool = cfg->mempool;
4204 * This maps vregs to the LLVM instruction defining them
4206 values = g_new0 (LLVMValueRef, cfg->next_vreg);
4208 * This maps vregs for volatile variables to the LLVM instruction defining their
4211 ctx->addresses = g_new0 (LLVMValueRef, cfg->next_vreg);
4212 ctx->vreg_types = g_new0 (LLVMTypeRef, cfg->next_vreg);
4213 ctx->vreg_cli_types = g_new0 (MonoType*, cfg->next_vreg);
4214 phi_values = g_ptr_array_new ();
4216 * This signals whenever the vreg was defined by a phi node with no input vars
4217 * (i.e. all its input bblocks end with NOT_REACHABLE).
4219 ctx->is_dead = g_new0 (gboolean, cfg->next_vreg);
4220 /* Whenever the bblock is unreachable */
4221 ctx->unreachable = g_new0 (gboolean, cfg->max_block_num);
4223 bblock_list = g_ptr_array_new ();
4225 ctx->values = values;
4226 ctx->region_to_handler = g_hash_table_new (NULL, NULL);
4228 if (cfg->compile_aot) {
4229 ctx->lmodule = &aot_module;
4230 method_name = mono_aot_get_method_name (cfg);
4231 cfg->llvm_method_name = g_strdup (method_name);
4234 ctx->lmodule = &jit_module;
4235 method_name = mono_method_full_name (cfg->method, TRUE);
4238 module = ctx->module = ctx->lmodule->module;
4241 LLVM_FAILURE (ctx, "gsharedvt");
4245 static int count = 0;
4248 if (g_getenv ("LLVM_COUNT")) {
4249 if (count == atoi (g_getenv ("LLVM_COUNT"))) {
4250 printf ("LAST: %s\n", mono_method_full_name (cfg->method, TRUE));
4254 if (count > atoi (g_getenv ("LLVM_COUNT")))
4255 LLVM_FAILURE (ctx, "");
4260 sig = mono_method_signature (cfg->method);
4263 linfo = mono_arch_get_llvm_call_info (cfg, sig);
4265 CHECK_FAILURE (ctx);
4268 linfo->rgctx_arg = TRUE;
4269 method_type = sig_to_llvm_sig_full (ctx, sig, linfo, &sinfo);
4270 CHECK_FAILURE (ctx);
4273 * This maps parameter indexes in the original signature to the indexes in
4274 * the LLVM signature.
4276 ctx->pindexes = sinfo.pindexes;
4278 method = LLVMAddFunction (module, method_name, method_type);
4279 ctx->lmethod = method;
4281 LLVMSetFunctionCallConv (method, LLVMMono1CallConv);
4282 LLVMSetLinkage (method, LLVMPrivateLinkage);
4284 LLVMAddFunctionAttr (method, LLVMUWTable);
4286 if (cfg->compile_aot) {
4287 LLVMSetLinkage (method, LLVMInternalLinkage);
4288 LLVMSetVisibility (method, LLVMHiddenVisibility);
4290 LLVMSetLinkage (method, LLVMPrivateLinkage);
4293 if (cfg->method->save_lmf)
4294 LLVM_FAILURE (ctx, "lmf");
4296 if (sig->pinvoke && cfg->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE)
4297 LLVM_FAILURE (ctx, "pinvoke signature");
4299 header = cfg->header;
4300 for (i = 0; i < header->num_clauses; ++i) {
4301 clause = &header->clauses [i];
4302 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY && clause->flags != MONO_EXCEPTION_CLAUSE_NONE)
4303 LLVM_FAILURE (ctx, "non-finally/catch clause.");
4306 if (linfo->rgctx_arg) {
4307 ctx->rgctx_arg = LLVMGetParam (method, sinfo.rgctx_arg_pindex);
4309 * We mark the rgctx parameter with the inreg attribute, which is mapped to
4310 * MONO_ARCH_RGCTX_REG in the Mono calling convention in llvm, i.e.
4311 * CC_X86_64_Mono in X86CallingConv.td.
4313 LLVMAddAttribute (ctx->rgctx_arg, LLVMInRegAttribute);
4314 LLVMSetValueName (ctx->rgctx_arg, "rgctx");
4316 if (cfg->vret_addr) {
4317 values [cfg->vret_addr->dreg] = LLVMGetParam (method, sinfo.vret_arg_pindex);
4318 LLVMSetValueName (values [cfg->vret_addr->dreg], "vret");
4321 values [cfg->args [0]->dreg] = LLVMGetParam (method, sinfo.this_arg_pindex);
4322 LLVMSetValueName (values [cfg->args [0]->dreg], "this");
4325 names = g_new (char *, sig->param_count);
4326 mono_method_get_param_names (cfg->method, (const char **) names);
4328 for (i = 0; i < sig->param_count; ++i) {
4331 values [cfg->args [i + sig->hasthis]->dreg] = LLVMGetParam (method, sinfo.pindexes [i]);
4332 if (names [i] && names [i][0] != '\0')
4333 name = g_strdup_printf ("arg_%s", names [i]);
4335 name = g_strdup_printf ("arg_%d", i);
4336 LLVMSetValueName (values [cfg->args [i + sig->hasthis]->dreg], name);
4338 if (linfo->args [i + sig->hasthis].storage == LLVMArgVtypeByVal)
4339 LLVMAddAttribute (LLVMGetParam (method, sinfo.pindexes [i]), LLVMByValAttribute);
4344 for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
4345 max_block_num = MAX (max_block_num, bb->block_num);
4346 ctx->bblocks = bblocks = g_new0 (BBInfo, max_block_num + 1);
4348 /* Add branches between non-consecutive bblocks */
4349 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4350 if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins) &&
4351 bb->next_bb != bb->last_ins->inst_false_bb) {
4353 MonoInst *inst = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
4354 inst->opcode = OP_BR;
4355 inst->inst_target_bb = bb->last_ins->inst_false_bb;
4356 mono_bblock_add_inst (bb, inst);
4361 * The INDIRECT flag added by OP_LDADDR inhibits optimizations, even if the LDADDR
4362 * was later optimized away, so clear these flags, and add them back for the still
4363 * present OP_LDADDR instructions.
4365 for (i = 0; i < cfg->next_vreg; ++i) {
4368 ins = get_vreg_to_inst (cfg, i);
4369 if (ins && ins != cfg->rgctx_var)
4370 ins->flags &= ~MONO_INST_INDIRECT;
4374 * Make a first pass over the code to precreate PHI nodes/set INDIRECT flags.
4376 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4378 LLVMBuilderRef builder;
4380 char dname_buf[128];
4382 builder = create_builder (ctx);
4384 for (ins = bb->code; ins; ins = ins->next) {
4385 switch (ins->opcode) {
4390 LLVMTypeRef phi_type = llvm_type_to_stack_type (type_to_llvm_type (ctx, &ins->klass->byval_arg));
4392 CHECK_FAILURE (ctx);
4394 if (ins->opcode == OP_VPHI) {
4395 /* Treat valuetype PHI nodes as operating on the address itself */
4396 g_assert (ins->klass);
4397 phi_type = LLVMPointerType (type_to_llvm_type (ctx, &ins->klass->byval_arg), 0);
4401 * Have to precreate these, as they can be referenced by
4402 * earlier instructions.
4404 sprintf (dname_buf, "t%d", ins->dreg);
4406 values [ins->dreg] = LLVMBuildPhi (builder, phi_type, dname);
4408 if (ins->opcode == OP_VPHI)
4409 ctx->addresses [ins->dreg] = values [ins->dreg];
4411 g_ptr_array_add (phi_values, values [ins->dreg]);
4414 * Set the expected type of the incoming arguments since these have
4415 * to have the same type.
4417 for (i = 0; i < ins->inst_phi_args [0]; i++) {
4418 int sreg1 = ins->inst_phi_args [i + 1];
4421 ctx->vreg_types [sreg1] = phi_type;
4426 ((MonoInst*)ins->inst_p0)->flags |= MONO_INST_INDIRECT;
4435 * Create an ordering for bblocks, use the depth first order first, then
4436 * put the exception handling bblocks last.
4438 for (bb_index = 0; bb_index < cfg->num_bblocks; ++bb_index) {
4439 bb = cfg->bblocks [bb_index];
4440 if (!(bb->region != -1 && !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))) {
4441 g_ptr_array_add (bblock_list, bb);
4442 bblocks [bb->block_num].added = TRUE;
4446 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4447 if (!bblocks [bb->block_num].added)
4448 g_ptr_array_add (bblock_list, bb);
4452 * Second pass: generate code.
4454 for (bb_index = 0; bb_index < bblock_list->len; ++bb_index) {
4455 bb = g_ptr_array_index (bblock_list, bb_index);
4457 if (!(bb == cfg->bb_entry || bb->in_count > 0))
4460 process_bb (ctx, bb);
4461 CHECK_FAILURE (ctx);
4464 /* Add incoming phi values */
4465 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4466 GSList *l, *ins_list;
4468 ins_list = bblocks [bb->block_num].phi_nodes;
4470 for (l = ins_list; l; l = l->next) {
4471 PhiNode *node = l->data;
4472 MonoInst *phi = node->phi;
4473 int sreg1 = node->sreg;
4474 LLVMBasicBlockRef in_bb;
4479 in_bb = get_end_bb (ctx, node->in_bb);
4481 if (ctx->unreachable [node->in_bb->block_num])
4484 if (!values [sreg1])
4485 /* Can happen with values in EH clauses */
4486 LLVM_FAILURE (ctx, "incoming phi sreg1");
4488 if (phi->opcode == OP_VPHI) {
4489 g_assert (LLVMTypeOf (ctx->addresses [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4490 LLVMAddIncoming (values [phi->dreg], &ctx->addresses [sreg1], &in_bb, 1);
4492 g_assert (LLVMTypeOf (values [sreg1]) == LLVMTypeOf (values [phi->dreg]));
4493 LLVMAddIncoming (values [phi->dreg], &values [sreg1], &in_bb, 1);
4498 /* Create the SWITCH statements for ENDFINALLY instructions */
4499 for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
4500 BBInfo *info = &bblocks [bb->block_num];
4502 for (l = info->endfinally_switch_ins_list; l; l = l->next) {
4503 LLVMValueRef switch_ins = l->data;
4504 GSList *bb_list = info->call_handler_return_bbs;
4506 for (i = 0; i < g_slist_length (bb_list); ++i)
4507 LLVMAddCase (switch_ins, LLVMConstInt (LLVMInt32Type (), i + 1, FALSE), g_slist_nth (bb_list, i)->data);
4511 if (cfg->verbose_level > 1)
4512 mono_llvm_dump_value (method);
4514 mark_as_used (module, method);
4516 if (cfg->compile_aot) {
4517 LLVMValueRef md_args [16];
4518 LLVMValueRef md_node;
4521 method_index = mono_aot_get_method_index (cfg->orig_method);
4522 md_args [0] = LLVMMDString (method_name, strlen (method_name));
4523 md_args [1] = LLVMConstInt (LLVMInt32Type (), method_index, FALSE);
4524 md_node = LLVMMDNode (md_args, 2);
4525 LLVMAddNamedMetadataOperand (module, "mono.function_indexes", md_node);
4526 //LLVMSetMetadata (method, md_kind, LLVMMDNode (&md_arg, 1));
4529 if (cfg->compile_aot) {
4530 /* Don't generate native code, keep the LLVM IR */
4531 if (cfg->compile_aot && cfg->verbose_level)
4532 printf ("%s emitted as %s\n", mono_method_full_name (cfg->method, TRUE), method_name);
4534 //LLVMVerifyFunction(method, 0);
4536 mono_llvm_optimize_method (method);
4538 if (cfg->verbose_level > 1)
4539 mono_llvm_dump_value (method);
4541 cfg->native_code = LLVMGetPointerToGlobal (ee, method);
4543 /* Set by emit_cb */
4544 g_assert (cfg->code_len);
4546 /* FIXME: Free the LLVM IL for the function */
4554 /* Need to add unused phi nodes as they can be referenced by other values */
4555 LLVMBasicBlockRef phi_bb = LLVMAppendBasicBlock (method, "PHI_BB");
4556 LLVMBuilderRef builder;
4558 builder = create_builder (ctx);
4559 LLVMPositionBuilderAtEnd (builder, phi_bb);
4561 for (i = 0; i < phi_values->len; ++i) {
4562 LLVMValueRef v = g_ptr_array_index (phi_values, i);
4563 if (LLVMGetInstructionParent (v) == NULL)
4564 LLVMInsertIntoBuilder (builder, v);
4567 LLVMDeleteFunction (method);
4572 g_free (ctx->addresses);
4573 g_free (ctx->vreg_types);
4574 g_free (ctx->vreg_cli_types);
4575 g_free (ctx->pindexes);
4576 g_free (ctx->is_dead);
4577 g_free (ctx->unreachable);
4578 g_ptr_array_free (phi_values, TRUE);
4579 g_free (ctx->bblocks);
4580 g_hash_table_destroy (ctx->region_to_handler);
4581 g_free (method_name);
4582 g_ptr_array_free (bblock_list, TRUE);
4584 for (l = ctx->builders; l; l = l->next) {
4585 LLVMBuilderRef builder = l->data;
4586 LLVMDisposeBuilder (builder);
4591 mono_native_tls_set_value (current_cfg_tls_id, NULL);
4593 mono_loader_unlock ();
4597 * mono_llvm_emit_call:
4599 * Same as mono_arch_emit_call () for LLVM.
4602 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
4605 MonoMethodSignature *sig;
4606 int i, n, stack_size;
4611 sig = call->signature;
4612 n = sig->param_count + sig->hasthis;
4614 call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4616 if (cfg->disable_llvm)
4619 if (sig->call_convention == MONO_CALL_VARARG) {
4620 cfg->exception_message = g_strdup ("varargs");
4621 cfg->disable_llvm = TRUE;
4624 for (i = 0; i < n; ++i) {
4627 ainfo = call->cinfo->args + i;
4629 in = call->args [i];
4631 /* Simply remember the arguments */
4632 switch (ainfo->storage) {
4634 case LLVMArgInFPReg: {
4635 MonoType *t = (sig->hasthis && i == 0) ? &mono_get_intptr_class ()->byval_arg : sig->params [i - sig->hasthis];
4637 if (!t->byref && (t->type == MONO_TYPE_R8 || t->type == MONO_TYPE_R4)) {
4638 MONO_INST_NEW (cfg, ins, OP_FMOVE);
4639 ins->dreg = mono_alloc_freg (cfg);
4641 MONO_INST_NEW (cfg, ins, OP_MOVE);
4642 ins->dreg = mono_alloc_ireg (cfg);
4644 ins->sreg1 = in->dreg;
4647 case LLVMArgVtypeByVal:
4648 case LLVMArgVtypeInReg:
4649 MONO_INST_NEW (cfg, ins, OP_LLVM_OUTARG_VT);
4650 ins->dreg = mono_alloc_ireg (cfg);
4651 ins->sreg1 = in->dreg;
4652 ins->klass = mono_class_from_mono_type (sig->params [i - sig->hasthis]);
4655 call->cinfo = mono_arch_get_llvm_call_info (cfg, sig);
4656 cfg->exception_message = g_strdup ("ainfo->storage");
4657 cfg->disable_llvm = TRUE;
4661 if (!cfg->disable_llvm) {
4662 MONO_ADD_INS (cfg->cbb, ins);
4663 mono_call_inst_add_outarg_reg (cfg, call, ins->dreg, 0, FALSE);
4668 static unsigned char*
4669 alloc_cb (LLVMValueRef function, int size)
4673 cfg = mono_native_tls_get_value (current_cfg_tls_id);
4677 return mono_domain_code_reserve (cfg->domain, size);
4679 return mono_domain_code_reserve (mono_domain_get (), size);
4684 emitted_cb (LLVMValueRef function, void *start, void *end)
4688 cfg = mono_native_tls_get_value (current_cfg_tls_id);
4690 cfg->code_len = (guint8*)end - (guint8*)start;
4694 exception_cb (void *data)
4697 MonoJitExceptionInfo *ei;
4698 guint32 ei_len, i, j, nested_len, nindex;
4699 gpointer *type_info;
4700 int this_reg, this_offset;
4702 cfg = mono_native_tls_get_value (current_cfg_tls_id);
4706 * data points to a DWARF FDE structure, convert it to our unwind format and
4708 * An alternative would be to save it directly, and modify our unwinder to work
4711 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);
4712 if (cfg->verbose_level > 1)
4713 mono_print_unwind_info (cfg->encoded_unwind_ops, cfg->encoded_unwind_ops_len);
4715 /* Count nested clauses */
4717 for (i = 0; i < ei_len; ++i) {
4718 for (j = 0; j < ei_len; ++j) {
4719 gint32 cindex1 = *(gint32*)type_info [i];
4720 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4721 gint32 cindex2 = *(gint32*)type_info [j];
4722 MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4724 if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4730 cfg->llvm_ex_info = mono_mempool_alloc0 (cfg->mempool, (ei_len + nested_len) * sizeof (MonoJitExceptionInfo));
4731 cfg->llvm_ex_info_len = ei_len + nested_len;
4732 memcpy (cfg->llvm_ex_info, ei, ei_len * sizeof (MonoJitExceptionInfo));
4733 /* Fill the rest of the information from the type info */
4734 for (i = 0; i < ei_len; ++i) {
4735 gint32 clause_index = *(gint32*)type_info [i];
4736 MonoExceptionClause *clause = &cfg->header->clauses [clause_index];
4738 cfg->llvm_ex_info [i].flags = clause->flags;
4739 cfg->llvm_ex_info [i].data.catch_class = clause->data.catch_class;
4743 * For nested clauses, the LLVM produced exception info associates the try interval with
4744 * the innermost handler, while mono expects it to be associated with all nesting clauses.
4746 /* FIXME: These should be order with the normal clauses */
4748 for (i = 0; i < ei_len; ++i) {
4749 for (j = 0; j < ei_len; ++j) {
4750 gint32 cindex1 = *(gint32*)type_info [i];
4751 MonoExceptionClause *clause1 = &cfg->header->clauses [cindex1];
4752 gint32 cindex2 = *(gint32*)type_info [j];
4753 MonoExceptionClause *clause2 = &cfg->header->clauses [cindex2];
4755 if (cindex1 != cindex2 && clause1->try_offset >= clause2->try_offset && clause1->handler_offset <= clause2->handler_offset) {
4757 * The try interval comes from the nested clause, everything else from the
4760 memcpy (&cfg->llvm_ex_info [nindex], &cfg->llvm_ex_info [j], sizeof (MonoJitExceptionInfo));
4761 cfg->llvm_ex_info [nindex].try_start = cfg->llvm_ex_info [i].try_start;
4762 cfg->llvm_ex_info [nindex].try_end = cfg->llvm_ex_info [i].try_end;
4767 g_assert (nindex == ei_len + nested_len);
4768 cfg->llvm_this_reg = this_reg;
4769 cfg->llvm_this_offset = this_offset;
4771 /* type_info [i] is cfg mempool allocated, no need to free it */
4778 dlsym_cb (const char *name, void **symbol)
4784 if (!strcmp (name, "__bzero")) {
4785 *symbol = (void*)bzero;
4787 current = mono_dl_open (NULL, 0, NULL);
4790 err = mono_dl_symbol (current, name, symbol);
4792 #ifdef MONO_ARCH_HAVE_CREATE_LLVM_NATIVE_THUNK
4793 *symbol = (char*)mono_arch_create_llvm_native_thunk (mono_domain_get (), (guint8*)(*symbol));
4799 AddFunc (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef *param_types, int nparams)
4801 LLVMAddFunction (module, name, LLVMFunctionType (ret_type, param_types, nparams, FALSE));
4805 AddFunc2 (LLVMModuleRef module, const char *name, LLVMTypeRef ret_type, LLVMTypeRef param_type1, LLVMTypeRef param_type2)
4807 LLVMTypeRef param_types [4];
4809 param_types [0] = param_type1;
4810 param_types [1] = param_type2;
4812 AddFunc (module, name, ret_type, param_types, 2);
4816 add_intrinsics (LLVMModuleRef module)
4818 /* Emit declarations of instrinsics */
4820 * It would be nicer to emit only the intrinsics actually used, but LLVM's Module
4821 * type doesn't seem to do any locking.
4824 LLVMTypeRef memset_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMInt8Type (), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4826 memset_param_count = 5;
4827 memset_func_name = "llvm.memset.p0i8.i32";
4829 LLVMAddFunction (module, memset_func_name, LLVMFunctionType (LLVMVoidType (), memset_params, memset_param_count, FALSE));
4833 LLVMTypeRef memcpy_params [] = { LLVMPointerType (LLVMInt8Type (), 0), LLVMPointerType (LLVMInt8Type (), 0), LLVMInt32Type (), LLVMInt32Type (), LLVMInt1Type () };
4835 memcpy_param_count = 5;
4836 memcpy_func_name = "llvm.memcpy.p0i8.p0i8.i32";
4838 LLVMAddFunction (module, memcpy_func_name, LLVMFunctionType (LLVMVoidType (), memcpy_params, memcpy_param_count, FALSE));
4842 LLVMTypeRef params [] = { LLVMDoubleType () };
4844 LLVMAddFunction (module, "llvm.sin.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4845 LLVMAddFunction (module, "llvm.cos.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4846 LLVMAddFunction (module, "llvm.sqrt.f64", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4848 /* This isn't an intrinsic, instead llvm seems to special case it by name */
4849 LLVMAddFunction (module, "fabs", LLVMFunctionType (LLVMDoubleType (), params, 1, FALSE));
4853 LLVMTypeRef ovf_res_i32 [] = { LLVMInt32Type (), LLVMInt1Type () };
4854 LLVMTypeRef ovf_params_i32 [] = { LLVMInt32Type (), LLVMInt32Type () };
4856 LLVMAddFunction (module, "llvm.sadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4857 LLVMAddFunction (module, "llvm.uadd.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4858 LLVMAddFunction (module, "llvm.ssub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4859 LLVMAddFunction (module, "llvm.usub.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4860 LLVMAddFunction (module, "llvm.smul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4861 LLVMAddFunction (module, "llvm.umul.with.overflow.i32", LLVMFunctionType (LLVMStructType (ovf_res_i32, 2, FALSE), ovf_params_i32, 2, FALSE));
4865 LLVMTypeRef ovf_res_i64 [] = { LLVMInt64Type (), LLVMInt1Type () };
4866 LLVMTypeRef ovf_params_i64 [] = { LLVMInt64Type (), LLVMInt64Type () };
4868 LLVMAddFunction (module, "llvm.sadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4869 LLVMAddFunction (module, "llvm.uadd.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4870 LLVMAddFunction (module, "llvm.ssub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4871 LLVMAddFunction (module, "llvm.usub.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4872 LLVMAddFunction (module, "llvm.smul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4873 LLVMAddFunction (module, "llvm.umul.with.overflow.i64", LLVMFunctionType (LLVMStructType (ovf_res_i64, 2, FALSE), ovf_params_i64, 2, FALSE));
4878 LLVMTypeRef arg_types [2];
4879 LLVMTypeRef ret_type;
4881 arg_types [0] = LLVMPointerType (LLVMInt8Type (), 0);
4882 arg_types [1] = LLVMPointerType (LLVMInt8Type (), 0);
4883 ret_type = LLVMInt32Type ();
4885 LLVMAddFunction (module, "mono_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4887 LLVMAddFunction (module, "llvm_resume_unwind_trampoline", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
4890 /* SSE intrinsics */
4891 #if defined(TARGET_X86) || defined(TARGET_AMD64)
4893 LLVMTypeRef ret_type, arg_types [16];
4896 ret_type = type_to_simd_type (MONO_TYPE_I4);
4897 arg_types [0] = ret_type;
4898 arg_types [1] = ret_type;
4899 AddFunc (module, "llvm.x86.sse41.pminud", ret_type, arg_types, 2);
4900 AddFunc (module, "llvm.x86.sse41.pmaxud", ret_type, arg_types, 2);
4902 ret_type = type_to_simd_type (MONO_TYPE_I2);
4903 arg_types [0] = ret_type;
4904 arg_types [1] = ret_type;
4905 AddFunc (module, "llvm.x86.sse41.pminuw", ret_type, arg_types, 2);
4906 AddFunc (module, "llvm.x86.sse2.pmins.w", ret_type, arg_types, 2);
4907 AddFunc (module, "llvm.x86.sse41.pmaxuw", ret_type, arg_types, 2);
4908 AddFunc (module, "llvm.x86.sse2.padds.w", ret_type, arg_types, 2);
4909 AddFunc (module, "llvm.x86.sse2.psubs.w", ret_type, arg_types, 2);
4910 AddFunc (module, "llvm.x86.sse2.paddus.w", ret_type, arg_types, 2);
4911 AddFunc (module, "llvm.x86.sse2.psubus.w", ret_type, arg_types, 2);
4912 AddFunc (module, "llvm.x86.sse2.pavg.w", ret_type, arg_types, 2);
4913 AddFunc (module, "llvm.x86.sse2.pmulh.w", ret_type, arg_types, 2);
4914 AddFunc (module, "llvm.x86.sse2.pmulhu.w", ret_type, arg_types, 2);
4916 ret_type = type_to_simd_type (MONO_TYPE_I1);
4917 arg_types [0] = ret_type;
4918 arg_types [1] = ret_type;
4919 AddFunc (module, "llvm.x86.sse2.pminu.b", ret_type, arg_types, 2);
4920 AddFunc (module, "llvm.x86.sse2.pmaxu.b", ret_type, arg_types, 2);
4921 AddFunc (module, "llvm.x86.sse2.padds.b", ret_type, arg_types, 2);
4922 AddFunc (module, "llvm.x86.sse2.psubs.b", ret_type, arg_types, 2);
4923 AddFunc (module, "llvm.x86.sse2.paddus.b", ret_type, arg_types, 2);
4924 AddFunc (module, "llvm.x86.sse2.psubus.b", ret_type, arg_types, 2);
4925 AddFunc (module, "llvm.x86.sse2.pavg.b", ret_type, arg_types, 2);
4927 ret_type = type_to_simd_type (MONO_TYPE_R8);
4928 arg_types [0] = ret_type;
4929 arg_types [1] = ret_type;
4930 AddFunc (module, "llvm.x86.sse2.min.pd", ret_type, arg_types, 2);
4931 AddFunc (module, "llvm.x86.sse2.max.pd", ret_type, arg_types, 2);
4932 AddFunc (module, "llvm.x86.sse3.hadd.pd", ret_type, arg_types, 2);
4933 AddFunc (module, "llvm.x86.sse3.hsub.pd", ret_type, arg_types, 2);
4934 AddFunc (module, "llvm.x86.sse3.addsub.pd", ret_type, arg_types, 2);
4936 ret_type = type_to_simd_type (MONO_TYPE_R4);
4937 arg_types [0] = ret_type;
4938 arg_types [1] = ret_type;
4939 AddFunc (module, "llvm.x86.sse.min.ps", ret_type, arg_types, 2);
4940 AddFunc (module, "llvm.x86.sse.max.ps", ret_type, arg_types, 2);
4941 AddFunc (module, "llvm.x86.sse3.hadd.ps", ret_type, arg_types, 2);
4942 AddFunc (module, "llvm.x86.sse3.hsub.ps", ret_type, arg_types, 2);
4943 AddFunc (module, "llvm.x86.sse3.addsub.ps", ret_type, arg_types, 2);
4946 ret_type = type_to_simd_type (MONO_TYPE_I1);
4947 arg_types [0] = type_to_simd_type (MONO_TYPE_I2);
4948 arg_types [1] = type_to_simd_type (MONO_TYPE_I2);
4949 AddFunc (module, "llvm.x86.sse2.packsswb.128", ret_type, arg_types, 2);
4950 AddFunc (module, "llvm.x86.sse2.packuswb.128", ret_type, arg_types, 2);
4951 ret_type = type_to_simd_type (MONO_TYPE_I2);
4952 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4953 arg_types [1] = type_to_simd_type (MONO_TYPE_I4);
4954 AddFunc (module, "llvm.x86.sse2.packssdw.128", ret_type, arg_types, 2);
4955 AddFunc (module, "llvm.x86.sse41.packusdw", ret_type, arg_types, 2);
4958 ret_type = type_to_simd_type (MONO_TYPE_R8);
4959 arg_types [0] = ret_type;
4960 arg_types [1] = ret_type;
4961 arg_types [2] = LLVMInt8Type ();
4962 AddFunc (module, "llvm.x86.sse2.cmp.pd", ret_type, arg_types, 3);
4963 ret_type = type_to_simd_type (MONO_TYPE_R4);
4964 arg_types [0] = ret_type;
4965 arg_types [1] = ret_type;
4966 arg_types [2] = LLVMInt8Type ();
4967 AddFunc (module, "llvm.x86.sse.cmp.ps", ret_type, arg_types, 3);
4969 /* Conversion ops */
4970 ret_type = type_to_simd_type (MONO_TYPE_R8);
4971 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4972 AddFunc (module, "llvm.x86.sse2.cvtdq2pd", ret_type, arg_types, 1);
4973 ret_type = type_to_simd_type (MONO_TYPE_R4);
4974 arg_types [0] = type_to_simd_type (MONO_TYPE_I4);
4975 AddFunc (module, "llvm.x86.sse2.cvtdq2ps", ret_type, arg_types, 1);
4976 ret_type = type_to_simd_type (MONO_TYPE_I4);
4977 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4978 AddFunc (module, "llvm.x86.sse2.cvtpd2dq", ret_type, arg_types, 1);
4979 ret_type = type_to_simd_type (MONO_TYPE_I4);
4980 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4981 AddFunc (module, "llvm.x86.sse2.cvtps2dq", ret_type, arg_types, 1);
4982 ret_type = type_to_simd_type (MONO_TYPE_R4);
4983 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4984 AddFunc (module, "llvm.x86.sse2.cvtpd2ps", ret_type, arg_types, 1);
4985 ret_type = type_to_simd_type (MONO_TYPE_R8);
4986 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4987 AddFunc (module, "llvm.x86.sse2.cvtps2pd", ret_type, arg_types, 1);
4989 ret_type = type_to_simd_type (MONO_TYPE_I4);
4990 arg_types [0] = type_to_simd_type (MONO_TYPE_R8);
4991 AddFunc (module, "llvm.x86.sse2.cvttpd2dq", ret_type, arg_types, 1);
4992 ret_type = type_to_simd_type (MONO_TYPE_I4);
4993 arg_types [0] = type_to_simd_type (MONO_TYPE_R4);
4994 AddFunc (module, "llvm.x86.sse2.cvttps2dq", ret_type, arg_types, 1);
4997 ret_type = type_to_simd_type (MONO_TYPE_R8);
4998 arg_types [0] = ret_type;
4999 AddFunc (module, "llvm.x86.sse2.sqrt.pd", ret_type, arg_types, 1);
5000 ret_type = type_to_simd_type (MONO_TYPE_R4);
5001 arg_types [0] = ret_type;
5002 AddFunc (module, "llvm.x86.sse.sqrt.ps", ret_type, arg_types, 1);
5003 ret_type = type_to_simd_type (MONO_TYPE_R4);
5004 arg_types [0] = ret_type;
5005 AddFunc (module, "llvm.x86.sse.rsqrt.ps", ret_type, arg_types, 1);
5006 ret_type = type_to_simd_type (MONO_TYPE_R4);
5007 arg_types [0] = ret_type;
5008 AddFunc (module, "llvm.x86.sse.rcp.ps", ret_type, arg_types, 1);
5011 ret_type = type_to_simd_type (MONO_TYPE_I2);
5012 arg_types [0] = ret_type;
5013 arg_types [1] = LLVMInt32Type ();
5014 AddFunc (module, "llvm.x86.sse2.psrli.w", ret_type, arg_types, 2);
5015 AddFunc (module, "llvm.x86.sse2.psrai.w", ret_type, arg_types, 2);
5016 AddFunc (module, "llvm.x86.sse2.pslli.w", ret_type, arg_types, 2);
5017 ret_type = type_to_simd_type (MONO_TYPE_I4);
5018 arg_types [0] = ret_type;
5019 arg_types [1] = LLVMInt32Type ();
5020 AddFunc (module, "llvm.x86.sse2.psrli.d", ret_type, arg_types, 2);
5021 AddFunc (module, "llvm.x86.sse2.psrai.d", ret_type, arg_types, 2);
5022 AddFunc (module, "llvm.x86.sse2.pslli.d", ret_type, arg_types, 2);
5023 ret_type = type_to_simd_type (MONO_TYPE_I8);
5024 arg_types [0] = ret_type;
5025 arg_types [1] = LLVMInt32Type ();
5026 AddFunc (module, "llvm.x86.sse2.psrli.q", ret_type, arg_types, 2);
5027 AddFunc (module, "llvm.x86.sse2.pslli.q", ret_type, arg_types, 2);
5030 ret_type = LLVMInt32Type ();
5031 arg_types [0] = type_to_simd_type (MONO_TYPE_I1);
5032 AddFunc (module, "llvm.x86.sse2.pmovmskb.128", ret_type, arg_types, 1);
5035 AddFunc (module, "llvm.x86.sse2.pause", LLVMVoidType (), NULL, 0);
5038 /* Load/Store intrinsics */
5040 LLVMTypeRef arg_types [5];
5044 for (i = 1; i <= 8; i *= 2) {
5045 arg_types [0] = LLVMPointerType (LLVMIntType (i * 8), 0);
5046 arg_types [1] = LLVMInt32Type ();
5047 arg_types [2] = LLVMInt1Type ();
5048 sprintf (name, "llvm.mono.load.i%d.p0i%d", i * 8, i * 8);
5049 LLVMAddFunction (module, name, LLVMFunctionType (LLVMIntType (i * 8), arg_types, 3, FALSE));
5051 arg_types [0] = LLVMIntType (i * 8);
5052 arg_types [1] = LLVMPointerType (LLVMIntType (i * 8), 0);
5053 arg_types [2] = LLVMInt32Type ();
5054 arg_types [3] = LLVMInt1Type ();
5055 sprintf (name, "llvm.mono.store.i%d.p0i%d", i * 8, i * 8);
5056 LLVMAddFunction (module, name, LLVMFunctionType (LLVMVoidType (), arg_types, 4, FALSE));
5062 mono_llvm_init (void)
5064 mono_native_tls_alloc (¤t_cfg_tls_id, NULL);
5068 init_jit_module (void)
5070 MonoJitICallInfo *info;
5072 if (jit_module_inited)
5075 mono_loader_lock ();
5077 if (jit_module_inited) {
5078 mono_loader_unlock ();
5082 jit_module.module = LLVMModuleCreateWithName ("mono");
5084 ee = mono_llvm_create_ee (LLVMCreateModuleProviderForExistingModule (jit_module.module), alloc_cb, emitted_cb, exception_cb, dlsym_cb);
5086 add_intrinsics (jit_module.module);
5088 jit_module.llvm_types = g_hash_table_new (NULL, NULL);
5090 info = mono_find_jit_icall_by_name ("llvm_resume_unwind_trampoline");
5092 LLVMAddGlobalMapping (ee, LLVMGetNamedFunction (jit_module.module, "llvm_resume_unwind_trampoline"), (void*)info->func);
5094 jit_module_inited = TRUE;
5096 mono_loader_unlock ();
5100 mono_llvm_cleanup (void)
5103 mono_llvm_dispose_ee (ee);
5105 if (jit_module.llvm_types)
5106 g_hash_table_destroy (jit_module.llvm_types);
5108 if (aot_module.module)
5109 LLVMDisposeModule (aot_module.module);
5111 LLVMContextDispose (LLVMGetGlobalContext ());
5115 mono_llvm_create_aot_module (const char *got_symbol)
5117 /* Delete previous module */
5118 if (aot_module.plt_entries)
5119 g_hash_table_destroy (aot_module.plt_entries);
5120 if (aot_module.module)
5121 LLVMDisposeModule (aot_module.module);
5123 memset (&aot_module, 0, sizeof (aot_module));
5125 aot_module.module = LLVMModuleCreateWithName ("aot");
5126 aot_module.got_symbol = got_symbol;
5128 add_intrinsics (aot_module.module);
5132 * We couldn't compute the type of the LLVM global representing the got because
5133 * its size is only known after all the methods have been emitted. So create
5134 * a dummy variable, and replace all uses it with the real got variable when
5135 * its size is known in mono_llvm_emit_aot_module ().
5138 LLVMTypeRef got_type = LLVMArrayType (IntPtrType (), 0);
5140 aot_module.got_var = LLVMAddGlobal (aot_module.module, got_type, "mono_dummy_got");
5141 LLVMSetInitializer (aot_module.got_var, LLVMConstNull (got_type));
5144 /* Add a dummy personality function */
5146 LLVMBasicBlockRef lbb;
5147 LLVMBuilderRef lbuilder;
5148 LLVMValueRef personality;
5150 personality = LLVMAddFunction (aot_module.module, "mono_aot_personality", LLVMFunctionType (LLVMVoidType (), NULL, 0, FALSE));
5151 LLVMSetLinkage (personality, LLVMInternalLinkage);
5152 lbb = LLVMAppendBasicBlock (personality, "BB0");
5153 lbuilder = LLVMCreateBuilder ();
5154 LLVMPositionBuilderAtEnd (lbuilder, lbb);
5155 LLVMBuildRetVoid (lbuilder);
5158 aot_module.llvm_types = g_hash_table_new (NULL, NULL);
5159 aot_module.plt_entries = g_hash_table_new (g_str_hash, g_str_equal);
5163 * Emit the aot module into the LLVM bitcode file FILENAME.
5166 mono_llvm_emit_aot_module (const char *filename, int got_size)
5168 LLVMTypeRef got_type;
5169 LLVMValueRef real_got;
5172 * Create the real got variable and replace all uses of the dummy variable with
5175 got_type = LLVMArrayType (IntPtrType (), got_size);
5176 real_got = LLVMAddGlobal (aot_module.module, got_type, aot_module.got_symbol);
5177 LLVMSetInitializer (real_got, LLVMConstNull (got_type));
5178 LLVMSetLinkage (real_got, LLVMInternalLinkage);
5180 mono_llvm_replace_uses_of (aot_module.got_var, real_got);
5182 mark_as_used (aot_module.module, real_got);
5184 /* Delete the dummy got so it doesn't become a global */
5185 LLVMDeleteGlobal (aot_module.got_var);
5191 if (LLVMVerifyModule (aot_module.module, LLVMReturnStatusAction, &verifier_err)) {
5192 g_assert_not_reached ();
5197 LLVMWriteBitcodeToFile (aot_module.module, filename);
5202 - Emit LLVM IR from the mono IR using the LLVM C API.
5203 - The original arch specific code remains, so we can fall back to it if we run
5204 into something we can't handle.
5208 A partial list of issues:
5209 - Handling of opcodes which can throw exceptions.
5211 In the mono JIT, these are implemented using code like this:
5218 push throw_pos - method
5219 call <exception trampoline>
5221 The problematic part is push throw_pos - method, which cannot be represented
5222 in the LLVM IR, since it does not support label values.
5223 -> this can be implemented in AOT mode using inline asm + labels, but cannot
5224 be implemented in JIT mode ?
5225 -> a possible but slower implementation would use the normal exception
5226 throwing code but it would need to control the placement of the throw code
5227 (it needs to be exactly after the compare+branch).
5228 -> perhaps add a PC offset intrinsics ?
5230 - efficient implementation of .ovf opcodes.
5232 These are currently implemented as:
5233 <ins which sets the condition codes>
5236 Some overflow opcodes are now supported by LLVM SVN.
5238 - exception handling, unwinding.
5239 - SSA is disabled for methods with exception handlers
5240 - How to obtain unwind info for LLVM compiled methods ?
5241 -> this is now solved by converting the unwind info generated by LLVM
5243 - LLVM uses the c++ exception handling framework, while we use our home grown
5244 code, and couldn't use the c++ one:
5245 - its not supported under VC++, other exotic platforms.
5246 - it might be impossible to support filter clauses with it.
5250 The trampolines need a predictable call sequence, since they need to disasm
5251 the calling code to obtain register numbers / offsets.
5253 LLVM currently generates this code in non-JIT mode:
5254 mov -0x98(%rax),%eax
5256 Here, the vtable pointer is lost.
5257 -> solution: use one vtable trampoline per class.
5259 - passing/receiving the IMT pointer/RGCTX.
5260 -> solution: pass them as normal arguments ?
5264 LLVM does not allow the specification of argument registers etc. This means
5265 that all calls are made according to the platform ABI.
5267 - passing/receiving vtypes.
5269 Vtypes passed/received in registers are handled by the front end by using
5270 a signature with scalar arguments, and loading the parts of the vtype into those
5273 Vtypes passed on the stack are handled using the 'byval' attribute.
5277 Supported though alloca, we need to emit the load/store code.
5281 The mono JIT uses pointer sized iregs/double fregs, while LLVM uses precisely
5282 typed registers, so we have to keep track of the precise LLVM type of each vreg.
5283 This is made easier because the IR is already in SSA form.
5284 An additional problem is that our IR is not consistent with types, i.e. i32/ia64
5285 types are frequently used incorrectly.
5290 Emit LLVM bytecode into a .bc file, compile it using llc into a .s file, then
5291 append the AOT data structures to that file. For methods which cannot be
5292 handled by LLVM, the normal JIT compiled versions are used.
5295 /* FIXME: Normalize some aspects of the mono IR to allow easier translation, like:
5296 * - each bblock should end with a branch
5297 * - setting the return value, making cfg->ret non-volatile
5298 * - avoid some transformations in the JIT which make it harder for us to generate
5300 * - use pointer types to help optimizations.