diff --git a/src/mono/CMakeLists.txt b/src/mono/CMakeLists.txt index 05766210ea6be5..a57cc52b0b110b 100644 --- a/src/mono/CMakeLists.txt +++ b/src/mono/CMakeLists.txt @@ -15,9 +15,6 @@ if (MSVC) if(EXISTS ${CLR_SOURCELINK_FILE_PATH}) add_link_options("/sourcelink:${CLR_SOURCELINK_FILE_PATH}") endif() - - # FIXME: Remove the line below when https://github.com/dotnet/runtime/issues/91249 is fixed. - add_compile_options($<$:/wd4244>) # conversion from 'type1' to 'type2', possible loss of data endif(MSVC) set(CROSS_ROOTFS $ENV{ROOTFS_DIR}) diff --git a/src/mono/mono/arch/arm64/arm64-codegen.h b/src/mono/mono/arch/arm64/arm64-codegen.h index 3042132bcc1cec..05b13c627e08de 100644 --- a/src/mono/mono/arch/arm64/arm64-codegen.h +++ b/src/mono/mono/arch/arm64/arm64-codegen.h @@ -179,7 +179,7 @@ arm_is_bl_disp (void *code, void *target) static G_GNUC_UNUSED inline unsigned int arm_get_disp (void *p, void *target) { - unsigned int disp = ((char*)target - (char*)p) / 4; + unsigned int disp = GINT64_TO_UINT (((char*)target - (char*)p) / 4); if (target) g_assert (arm_is_bl_disp (p, target)); @@ -205,7 +205,7 @@ arm_is_disp19 (void *code, void *target) static G_GNUC_UNUSED inline unsigned int arm_get_disp19 (void *p, void *target) { - unsigned int disp = ((char*)target - (char*)p) / 4; + unsigned int disp = GINT64_TO_UINT (((char*)target - (char*)p) / 4); if (target) g_assert (arm_is_disp19 (p, target)); @@ -233,7 +233,7 @@ arm_get_disp19 (void *p, void *target) static G_GNUC_UNUSED inline unsigned int arm_get_disp15 (void *p, void *target) { - unsigned int disp = ((char*)target - (char*)p) / 4; + unsigned int disp = GINT64_TO_UINT (((char*)target - (char*)p) / 4); return (disp & 0x7fff); } @@ -545,7 +545,7 @@ arm_encode_arith_imm (int imm, guint32 *shift) #define arm_movkw(p, rd, imm, shift) do { g_assert ((shift) % 16 == 0); arm_format_mov ((p), 0x0, 0x3, (shift) / 16, (rd), (imm)); } while (0) /* PC-relative address calculation */ -#define arm_format_adrp(p, op, rd, target) do { guint64 imm1 = (guint64)(target); guint64 imm2 = (guint64)(p); int _imm = imm1 - imm2; arm_emit ((p), ((op) << 31) | (((_imm) & 0x3) << 29) | (0x10 << 24) | (((_imm >> 2) & 0x7ffff) << 5) | ((rd) << 0)); } while (0) +#define arm_format_adrp(p, op, rd, target) do { guint64 imm1 = (guint64)(target); guint64 imm2 = (guint64)(p); int _imm = GUINT64_TO_INT (imm1 - imm2); arm_emit ((p), ((op) << 31) | (((_imm) & 0x3) << 29) | (0x10 << 24) | (((_imm >> 2) & 0x7ffff) << 5) | ((rd) << 0)); } while (0) #define arm_adrpx(p, rd, target) arm_format_adrp ((p), 0x1, (rd), (target)) #define arm_adrx(p, rd, target) arm_format_adrp ((p), 0x0, (rd), (target)) diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index a210242c1eb691..c840e1b7ae2613 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -8855,7 +8855,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint buffer_add_objid (buf, obj); if (CHECK_ICORDBG (TRUE)) { - buffer_add_byte(buf, m_class_is_valuetype (klass)); + buffer_add_byte(buf, GINT_TO_UINT8(m_class_is_valuetype (klass))); if (m_class_is_valuetype (klass)) { int nfields = 0; @@ -8950,7 +8950,7 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint case MDBGPROT_CMD_TYPE_ELEMENT_TYPE: { buffer_add_int (buf, m_class_get_byval_arg (klass)->type); - buffer_add_byte (buf, MONO_TYPE_ISSTRUCT (m_class_get_byval_arg (klass))); + buffer_add_byte (buf, GINT_TO_UINT8 (MONO_TYPE_ISSTRUCT (m_class_get_byval_arg (klass)))); break; } case MDBGPROT_CMD_TYPE_RANK: @@ -10141,7 +10141,7 @@ array_commands (int command, guint8 *p, guint8 *end, Buffer *buf) { buffer_add_typeid (buf, arr->obj.vtable->domain, m_class_get_element_class (arr->obj.vtable->klass)); if (CHECK_ICORDBG (TRUE)) - buffer_add_byte (buf, MONO_TYPE_ISSTRUCT (m_class_get_byval_arg (m_class_get_element_class (arr->obj.vtable->klass)))); + buffer_add_byte (buf, GINT_TO_UINT8 (MONO_TYPE_ISSTRUCT (m_class_get_byval_arg (m_class_get_element_class (arr->obj.vtable->klass))))); } } break; diff --git a/src/mono/mono/eglib/giconv.c b/src/mono/mono/eglib/giconv.c index 8ae955c303fe25..d311cc93d8c2bc 100644 --- a/src/mono/mono/eglib/giconv.c +++ b/src/mono/mono/eglib/giconv.c @@ -237,8 +237,6 @@ g_unichar_to_utf8 (gunichar c, gchar *outbuf) static FORCE_INLINE (int) g_unichar_to_utf16_endian (gunichar c, gunichar2 *outbuf, unsigned endian) { - gunichar c2; - if (c < 0xd800) { if (outbuf) *outbuf = (gunichar2) (endian == G_BIG_ENDIAN ? GUINT16_TO_BE(c) : GUINT16_TO_LE(c)); @@ -253,7 +251,7 @@ g_unichar_to_utf16_endian (gunichar c, gunichar2 *outbuf, unsigned endian) return 1; } else if (c < 0x110000) { if (outbuf) { - c2 = c - 0x10000; + gunichar2 c2 = (gunichar2)(c - 0x10000); gunichar2 part1 = (c2 >> 10) + 0xd800; gunichar2 part2 = (c2 & 0x3ff) + 0xdc00; diff --git a/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c b/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c index fe3b3c09db18a9..81d46bdf14a1e9 100644 --- a/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c +++ b/src/mono/mono/eventpipe/ep-rt-mono-runtime-provider.c @@ -3729,7 +3729,7 @@ buffer_gc_event_object_reference_callback ( sizeof (object_size) + sizeof (object_type) + sizeof (edge_count) + - (edge_count * sizeof (uintptr_t)); + GUINT64_TO_UINT32 (edge_count * sizeof (uintptr_t)); EP_ASSERT (context->buffer); EP_ASSERT (context->buffer->context); @@ -3775,7 +3775,7 @@ flush_gc_event_bulk_root_static_vars (GCHeapDumpContext *context) context->bulk_root_static_vars.count, (uint64_t)mono_get_root_domain (), clr_instance_get_id (), - context->bulk_root_static_vars.data_current - context->bulk_root_static_vars.data_start, + GPTRDIFF_TO_INT (context->bulk_root_static_vars.data_current - context->bulk_root_static_vars.data_start), context->bulk_root_static_vars.data_start, NULL, NULL); diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c index f3ef9b74f26c65..b3a88ecf03c49c 100644 --- a/src/mono/mono/metadata/icall.c +++ b/src/mono/mono/metadata/icall.c @@ -2827,7 +2827,7 @@ ves_icall_RuntimeType_GetCallingConventionFromFunctionPointerInternal (MonoQCall MonoType *type = type_handle.type; g_assert (type->type == MONO_TYPE_FNPTR); // FIXME: Once we address: https://github.com/dotnet/runtime/issues/90308 this should not be needed anymore - return type->data.method->suppress_gc_transition ? MONO_CALL_UNMANAGED_MD : type->data.method->call_convention; + return GUINT_TO_INT8 (type->data.method->suppress_gc_transition ? MONO_CALL_UNMANAGED_MD : type->data.method->call_convention); } MonoBoolean diff --git a/src/mono/mono/metadata/sgen-client-mono.h b/src/mono/mono/metadata/sgen-client-mono.h index 8bdae1b9fec8fe..f20831112ec2e7 100644 --- a/src/mono/mono/metadata/sgen-client-mono.h +++ b/src/mono/mono/metadata/sgen-client-mono.h @@ -90,7 +90,7 @@ enum { }; static inline mword -sgen_mono_array_size (GCVTable vtable, MonoArray *array, mword *bounds_size, mword descr) +sgen_mono_array_size (GCVTable vtable, MonoArray *array, mword *bounds_size, SgenDescriptor descr) { mword size, size_without_bounds; int element_size; diff --git a/src/mono/mono/metadata/sgen-mono.c b/src/mono/mono/metadata/sgen-mono.c index 4d008a7468a916..c98dcf7c0cd464 100644 --- a/src/mono/mono/metadata/sgen-mono.c +++ b/src/mono/mono/metadata/sgen-mono.c @@ -98,7 +98,7 @@ ptr_on_stack (void *ptr) } while (0) static void -scan_object_for_binary_protocol_copy_wbarrier (gpointer dest, char *start, mword desc) +scan_object_for_binary_protocol_copy_wbarrier (gpointer dest, char *start, SgenDescriptor desc) { #define SCAN_OBJECT_NOVTABLE #include "sgen/sgen-scan-object.h" @@ -127,7 +127,7 @@ mono_gc_wbarrier_value_copy_internal (gpointer dest, gconstpointer src, int coun for (i = 0; i < count; ++i) { scan_object_for_binary_protocol_copy_wbarrier ((char*)dest + i * element_size, (char*)src + i * element_size - MONO_ABI_SIZEOF (MonoObject), - (mword) m_class_get_gc_descr (klass)); + m_class_get_gc_descr (klass)); } } #endif @@ -157,7 +157,7 @@ mono_gc_wbarrier_object_copy_internal (MonoObject* obj, MonoObject *src) #ifdef SGEN_HEAVY_BINARY_PROTOCOL if (sgen_binary_protocol_is_heavy_enabled ()) - scan_object_for_binary_protocol_copy_wbarrier (obj, (char*)src, (mword) src->vtable->gc_descr); + scan_object_for_binary_protocol_copy_wbarrier (obj, (char*)src, src->vtable->gc_descr); #endif sgen_get_remset ()->wbarrier_object_copy (obj, src); @@ -982,7 +982,7 @@ sgen_client_cardtable_scan_object (GCObject *obj, guint8 *cards, ScanCopyContext size_t card_count; size_t extra_idx = 0; - mword desc = (mword)m_class_get_gc_descr (m_class_get_element_class (klass)); + SgenDescriptor desc = m_class_get_gc_descr (m_class_get_element_class (klass)); int elem_size = mono_array_element_size (klass); #ifdef SGEN_OBJECT_LAYOUT_STATISTICS @@ -1297,7 +1297,7 @@ two_args_report_root (void *address, MonoObject *obj, void *gc_data) } static void -precisely_report_roots_from (GCRootReport *report, void** start_root, void** end_root, mword desc) +precisely_report_roots_from (GCRootReport *report, void** start_root, void** end_root, SgenDescriptor desc) { switch (desc & ROOT_DESC_TYPE_MASK) { case ROOT_DESC_BITMAP: @@ -1850,7 +1850,7 @@ static void collect_references (HeapWalkInfo *hwi, GCObject *obj, size_t size) { char *start = (char*)obj; - mword desc = sgen_obj_get_descriptor (obj); + SgenDescriptor desc = sgen_obj_get_descriptor (obj); #include "sgen/sgen-scan-object.h" } diff --git a/src/mono/mono/metadata/sgen-new-bridge.c b/src/mono/mono/metadata/sgen-new-bridge.c index e618783bcb4086..cddaee8bff7594 100644 --- a/src/mono/mono/metadata/sgen-new-bridge.c +++ b/src/mono/mono/metadata/sgen-new-bridge.c @@ -373,7 +373,7 @@ dfs1 (HashEntry *obj_entry) if (!obj_entry->v.dfs1.is_visited) { int num_links = 0; - mword desc = sgen_obj_get_descriptor_safe (obj); + SgenDescriptor desc = sgen_obj_get_descriptor_safe (obj); obj_entry->v.dfs1.is_visited = 1; diff --git a/src/mono/mono/metadata/sgen-tarjan-bridge.c b/src/mono/mono/metadata/sgen-tarjan-bridge.c index f22b188a3ed25a..6f1fb1ec10bd94 100644 --- a/src/mono/mono/metadata/sgen-tarjan-bridge.c +++ b/src/mono/mono/metadata/sgen-tarjan-bridge.c @@ -681,7 +681,7 @@ push_all (ScanData *data) { GCObject *obj = data->obj; char *start = (char*)obj; - mword desc = sgen_obj_get_descriptor_safe (obj); + SgenDescriptor desc = sgen_obj_get_descriptor_safe (obj); #if DUMP_GRAPH printf ("+scanning %s (%p) index %d color %p\n", safe_name_bridge (data->obj), data->obj, data->index, data->color); @@ -741,7 +741,7 @@ compute_low (ScanData *data) { GCObject *obj = data->obj; char *start = (char*)obj; - mword desc = sgen_obj_get_descriptor_safe (obj); + SgenDescriptor desc = sgen_obj_get_descriptor_safe (obj); #include "sgen/sgen-scan-object.h" } diff --git a/src/mono/mono/metadata/weak-hash.c b/src/mono/mono/metadata/weak-hash.c index c4d43a977c1098..9aed30b1bc1ed2 100644 --- a/src/mono/mono/metadata/weak-hash.c +++ b/src/mono/mono/metadata/weak-hash.c @@ -235,7 +235,7 @@ rehash (MonoWeakHashTable *hash) * Rehash to a size that can fit the current elements. Rehash relative to in_use * to allow also for compaction. */ - data.new_size = g_spaced_primes_closest (hash->in_use / HASH_TABLE_MAX_LOAD_FACTOR * HASH_TABLE_RESIZE_RATIO); + data.new_size = g_spaced_primes_closest (GFLOAT_TO_UINT (hash->in_use / HASH_TABLE_MAX_LOAD_FACTOR * HASH_TABLE_RESIZE_RATIO)); MonoArray *holder = (MonoArray*)mono_gchandle_get_target_internal (hash->key_value_handle); g_assert (holder); diff --git a/src/mono/mono/mini/CMakeLists.txt b/src/mono/mono/mini/CMakeLists.txt index 6b300ab2b74cfa..7f58d60a00a6b6 100644 --- a/src/mono/mono/mini/CMakeLists.txt +++ b/src/mono/mono/mini/CMakeLists.txt @@ -364,9 +364,8 @@ elseif(NOT HOST_BROWSER AND NOT HOST_WASI) set(mini_sources "${mini_sources};${VERSION_FILE_PATH}") # this is generated by GenerateNativeVersionFile in Arcade endif() -if(HOST_WIN32) -set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_OPTIONS "/wd4005;/wd4127;/wd4131;/wd4244") -endif() +set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_DEFINITIONS "${ZLIB_COMPILE_DEFINITIONS}") +set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_OPTIONS "${ZLIB_COMPILE_OPTIONS}") set(monosgen-sources "${mini_sources};${ZLIB_SOURCES}") diff --git a/src/mono/mono/mini/aot-compiler.c b/src/mono/mono/mini/aot-compiler.c index 023cd6ce42b0b5..d72e9db2309c9d 100644 --- a/src/mono/mono/mini/aot-compiler.c +++ b/src/mono/mono/mini/aot-compiler.c @@ -1426,9 +1426,9 @@ arm64_emit_tramp_page_common_code (MonoAotCompile *acfg, int pagesize, int arg_r code = mono_arm_emit_brx (code, ARMREG_IP0); /* Emit it */ - emit_code_bytes (acfg, buf, code - buf); + emit_code_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); - *size = code - buf; + *size = GPTRDIFF_TO_INT (code - buf); } static void @@ -1450,7 +1450,7 @@ arm64_emit_tramp_page_specific_code (MonoAotCompile *acfg, int pagesize, int com arm_nop (code); #endif g_assert (code - buf == specific_tramp_size); - emit_code_bytes (acfg, buf, code - buf); + emit_code_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } } @@ -1535,9 +1535,9 @@ arm64_emit_specific_trampoline_pages (MonoAotCompile *acfg) code = mono_arm_emit_brx (code, ARMREG_IP0); /* Emit it */ - emit_code_bytes (acfg, buf, code - buf); + emit_code_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); - common_tramp_size = code - buf; + common_tramp_size = GPTRDIFF_TO_INT (code - buf); acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_UNBOX_ARBITRARY] = common_tramp_size; arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size); @@ -1587,9 +1587,9 @@ arm64_emit_specific_trampoline_pages (MonoAotCompile *acfg) arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P); code = mono_arm_emit_brx (code, ARMREG_IP0); - emit_code_bytes (acfg, buf, code - buf); + emit_code_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); - common_tramp_size = code - buf; + common_tramp_size = GPTRDIFF_TO_INT (code - buf); acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_IMT] = common_tramp_size; arm64_emit_tramp_page_specific_code (acfg, pagesize, common_tramp_size, specific_tramp_size); @@ -1673,9 +1673,9 @@ arm64_emit_imt_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size) arm_ldrp (code, ARMREG_IP0, ARMREG_IP1, TARGET_SIZEOF_VOID_P); code = mono_arm_emit_brx (code, ARMREG_IP0); - emit_code_bytes (acfg, buf, code - buf); + emit_code_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); - *tramp_size = code - buf + (3 * 4); + *tramp_size = GPTRDIFF_TO_INT (code - buf + (3 * 4)); } static void @@ -1986,7 +1986,7 @@ arch_emit_plt_entry (MonoAotCompile *acfg, const char *got_symbol, guint32 plt_i code = buf; ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_IP); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, got_symbol, ".", offset - 4); /* Used by mono_aot_get_plt_info_offset */ emit_int32 (acfg, info_offset); @@ -2111,7 +2111,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) g_assert (code - buf == COMMON_TRAMP_SIZE); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); for (i = 0; i < count; ++i) { code = buf; @@ -2119,7 +2119,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_BL (code, 0); arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1)); g_assert (code - buf == 8); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } /* now the rgctx trampolines: each specific trampolines puts in the ip register @@ -2139,7 +2139,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) g_assert (code - buf == COMMON_TRAMP_SIZE); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); for (i = 0; i < count; ++i) { code = buf; @@ -2147,7 +2147,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_B (code, 0); arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1)); g_assert (code - buf == 8); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } /* @@ -2164,7 +2164,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_LDR_IMM (code, ARMREG_PC, ARMREG_IP, -4); g_assert (code - buf == COMMON_TRAMP_SIZE); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); for (i = 0; i < count; ++i) { code = buf; @@ -2172,7 +2172,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_B (code, 0); arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1)); g_assert (code - buf == 8); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } /* now the unbox arbitrary trampolines: each specific trampolines puts in the ip register @@ -2193,7 +2193,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) g_assert (code - buf == COMMON_TRAMP_SIZE); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); for (i = 0; i < count; ++i) { code = buf; @@ -2201,7 +2201,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_B (code, 0); arm_patch (code - 4, code - COMMON_TRAMP_SIZE - 8 * (i + 1)); g_assert (code - buf == 8); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } /* now the imt trampolines: each specific trampolines puts in the ip register @@ -2257,7 +2257,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) /* Emit it */ g_assert (code - buf == IMT_TRAMP_SIZE); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); for (i = 0; i < count; ++i) { code = buf; @@ -2265,7 +2265,7 @@ arch_emit_specific_trampoline_pages (MonoAotCompile *acfg) ARM_B (code, 0); arm_patch (code - 4, code - IMT_TRAMP_SIZE - 8 * (i + 1)); g_assert (code - buf == 8); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); } acfg->tramp_page_code_offsets [MONO_AOT_TRAMP_SPECIFIC] = 16; @@ -2389,7 +2389,7 @@ arch_emit_specific_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size g_assert (code - buf == 16); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); /* * Only one offset is needed, since the second one would be equal to the * first one. @@ -2453,7 +2453,7 @@ arch_emit_specific_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size /* Branch to generic trampoline */ x86_jump_reg (code, X86_ECX); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); *tramp_size = 17; g_assert (code - buf == *tramp_size); @@ -2500,7 +2500,7 @@ arch_emit_unbox_trampoline (MonoAotCompile *acfg, MonoCompile *cfg, MonoMethod * x86_alu_membase_imm (code, X86_ADD, X86_ESP, this_pos, MONO_ABI_SIZEOF (MonoObject)); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); /* jump */ emit_byte (acfg, '\xe9'); @@ -2521,7 +2521,7 @@ arch_emit_unbox_trampoline (MonoAotCompile *acfg, MonoCompile *cfg, MonoMethod * ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, MONO_ABI_SIZEOF (MonoObject)); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); /* jump to method */ if (acfg->thumb_mixed && cfg->compile_llvm) fprintf (acfg->fp, "\n\tbx %s\n", call_target); @@ -2589,7 +2589,7 @@ arch_emit_static_rgctx_trampoline (MonoAotCompile *acfg, int offset, int *tramp_ g_assert (code - buf == 16); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) - 4 + 8); emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) - 4 + 4); #elif defined(TARGET_ARM64) @@ -2648,7 +2648,7 @@ arch_emit_static_rgctx_trampoline (MonoAotCompile *acfg, int offset, int *tramp_ /* Branch to the target address */ x86_jump_membase (code, X86_ECX, (offset + 1) * sizeof (target_mgreg_t)); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); *tramp_size = 15; g_assert (code - buf == *tramp_size); @@ -2796,9 +2796,9 @@ arch_emit_imt_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size) mono_x86_patch (labels [3], code); x86_breakpoint (code); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); - *tramp_size = code - buf; + *tramp_size = GPTRDIFF_TO_INT (code - buf); g_free (buf); @@ -2853,10 +2853,10 @@ arch_emit_imt_trampoline (MonoAotCompile *acfg, int offset, int *tramp_size) code2 = labels [0]; ARM_LDR_IMM (code2, ARMREG_R0, ARMREG_PC, (code - (labels [0] + 8))); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, acfg->got_symbol, ".", (int)((offset * sizeof (target_mgreg_t)) + (code - (labels [0] + 8)) - 4)); - *tramp_size = code - buf + 4; + *tramp_size = GPTRDIFF_TO_INT (code - buf + 4); #elif defined(TARGET_ARM64) arm64_emit_imt_trampoline (acfg, offset, tramp_size); #elif defined(TARGET_POWERPC) @@ -2955,7 +2955,7 @@ arch_emit_gsharedvt_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp /* Branch to the target address */ x86_jump_membase (code, X86_ECX, (offset + 1) * sizeof (target_mgreg_t)); - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); *tramp_size = 15; g_assert (code - buf == *tramp_size); @@ -2979,7 +2979,7 @@ arch_emit_gsharedvt_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp g_assert (code - buf == 20); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + 4); #elif defined(TARGET_ARM64) arm64_emit_gsharedvt_arg_trampoline (acfg, offset, tramp_size); @@ -3019,7 +3019,7 @@ arch_emit_ftnptr_arg_trampoline (MonoAotCompile *acfg, int offset, int *tramp_si g_assert (code - buf == 24); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, acfg->got_symbol, ".", ((offset + 1) * sizeof (target_mgreg_t)) + 12); // offset from ldr pc to addr emit_symbol_diff (acfg, acfg->got_symbol, ".", (offset * sizeof (target_mgreg_t)) + 4); // offset from ldr pc to arg #else @@ -3067,7 +3067,7 @@ arch_emit_unbox_arbitrary_trampoline (MonoAotCompile *acfg, int offset, int *tra g_assert (code - buf == 12); /* Emit it */ - emit_bytes (acfg, buf, code - buf); + emit_bytes (acfg, buf, GPTRDIFF_TO_INT (code - buf)); emit_symbol_diff (acfg, acfg->got_symbol, ".", (int)((offset * sizeof (target_mgreg_t)) + (code - (label + 8)) - 4)); *tramp_size = 4 * 4; #else @@ -11400,7 +11400,7 @@ encode_uint_len (guint32 val, int len, guint8 *buf, guint8 **endbuf) { if (len == 2) { g_assert (val < 65536); - encode_int16 (val, buf, endbuf); + encode_int16 (GUINT32_TO_UINT16 (val), buf, endbuf); } else { encode_int ((gint32)val, buf, endbuf); } @@ -11454,7 +11454,7 @@ emit_extra_methods (MonoAotCompile *acfg) * Construct a chained hash table for mapping indexes in extra_method_info to * method indexes. */ - guint table_size = g_spaced_primes_closest ((guint)(nmethods * 1.5)); + guint table_size = g_spaced_primes_closest (GFLOAT_TO_UINT (nmethods * 1.5)); table = g_ptr_array_sized_new (table_size); for (guint i = 0; i < table_size; ++i) g_ptr_array_add (table, NULL); @@ -11732,7 +11732,7 @@ emit_class_name_table (MonoAotCompile *acfg) * Construct a chained hash table for mapping class names to typedef tokens. */ guint32 rows = table_info_get_rows (&acfg->image->tables [MONO_TABLE_TYPEDEF]); - guint table_size = g_spaced_primes_closest (rows * 1.5); + guint table_size = g_spaced_primes_closest (GFLOAT_TO_UINT (rows * 1.5)); table = g_ptr_array_sized_new (table_size); for (guint i = 0; i < table_size; ++i) g_ptr_array_add (table, NULL); @@ -12091,7 +12091,7 @@ emit_globals (MonoAotCompile *acfg) * Construct a chained hash table for mapping global names to their index in * the globals table. */ - guint table_size = g_spaced_primes_closest (acfg->globals->len * 1.5); + guint table_size = g_spaced_primes_closest (GFLOAT_TO_UINT (acfg->globals->len * 1.5)); table = g_ptr_array_sized_new (table_size); for (guint i = 0; i < table_size; ++i) g_ptr_array_add (table, NULL); diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c index 86c70dba388621..ccc9c93d4af166 100644 --- a/src/mono/mono/mini/aot-runtime.c +++ b/src/mono/mono/mini/aot-runtime.c @@ -2269,17 +2269,15 @@ load_aot_module (MonoAssemblyLoadContext *alc, MonoAssembly *assembly, gpointer if (make_unreadable) { #ifndef TARGET_WIN32 - guint8 *addr; guint8 *page_start, *page_end; - int err, len; + int err; - addr = amodule->mem_begin; - g_assert (addr); - len = amodule->mem_end - amodule->mem_begin; + g_assert (amodule->mem_begin); + g_assert (amodule->mem_end); /* Round down in both directions to avoid modifying data which is not ours */ - page_start = (guint8 *) (((gssize) (addr)) & ~ (mono_pagesize () - 1)) + mono_pagesize (); - page_end = (guint8 *) (((gssize) (addr + len)) & ~ (mono_pagesize () - 1)); + page_start = (guint8 *) (((gssize) (amodule->mem_begin)) & ~ (mono_pagesize () - 1)) + mono_pagesize (); + page_end = (guint8 *) (((gssize) (amodule->mem_end)) & ~ (mono_pagesize () - 1)); if (page_end > page_start) { err = mono_mprotect (page_start, (page_end - page_start), MONO_MMAP_NONE); g_assert (err == 0); @@ -3736,7 +3734,7 @@ mono_aot_find_jit_info (MonoImage *image, gpointer addr) /* Unused */ int len = mono_jit_info_size (0, 0, 0); jinfo = (MonoJitInfo *)alloc0_jit_info_data (mem_manager, len, async); - mono_jit_info_init (jinfo, method, code, code_len, 0, 0, 0); + mono_jit_info_init (jinfo, method, code, GPTRDIFF_TO_INT (code_len), 0, 0, 0); } else { jinfo = decode_exception_debug_info (amodule, method, ex_info, code, GPTRDIFF_TO_UINT32 (code_len)); } diff --git a/src/mono/mono/mini/exceptions-arm.c b/src/mono/mono/mini/exceptions-arm.c index 3af1e4dbf5fcb6..5edd89d69c227b 100644 --- a/src/mono/mono/mini/exceptions-arm.c +++ b/src/mono/mono/mini/exceptions-arm.c @@ -86,11 +86,11 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) g_assert ((code - start) < 128); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); if (info) - *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("restore_context", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; } @@ -137,11 +137,11 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) g_assert ((code - start) < 320); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); if (info) - *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("call_filter", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; } @@ -309,7 +309,7 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm else icall_id = MONO_JIT_ICALL_mono_arm_throw_exception; - ji = mono_patch_info_list_prepend (ji, code - start, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (icall_id)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - start), MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (icall_id)); ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)(gpointer)code = NULL; @@ -323,11 +323,11 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm /* we should never reach this breakpoint */ ARM_DBRK (code); g_assert ((code - start) < size); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); if (info) - *info = mono_tramp_info_create (tramp_name, start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; } diff --git a/src/mono/mono/mini/exceptions-arm64.c b/src/mono/mono/mini/exceptions-arm64.c index b55825583cca8a..28ce79cd01c575 100644 --- a/src/mono/mono/mini/exceptions-arm64.c +++ b/src/mono/mono/mini/exceptions-arm64.c @@ -67,10 +67,10 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) g_assert ((code - start) < size); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); if (info) - *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("restore_context", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return MINI_ADDR_TO_FTNPTR (start); } @@ -158,10 +158,10 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) g_assert ((code - start) < size); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); if (info) - *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("call_filter", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return MINI_ADDR_TO_FTNPTR (start); } @@ -262,10 +262,10 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm g_assert ((code - start) < size); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); if (info) - *info = mono_tramp_info_create (tramp_name, start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return MINI_ADDR_TO_FTNPTR (start); } @@ -372,7 +372,7 @@ mono_arm_throw_exception (gpointer arg, host_mgreg_t pc, host_mgreg_t *int_regs, if (!corlib) exc = (MonoObject*)arg; else { - ex_token_index = (guint64)arg; + ex_token_index = GPOINTER_TO_UINT32 (arg); ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index; exc = (MonoObject*)mono_exception_from_token (mono_defaults.corlib, ex_token); } diff --git a/src/mono/mono/mini/exceptions-x86.c b/src/mono/mono/mini/exceptions-x86.c index c51181d9480366..47ba88dcf92923 100644 --- a/src/mono/mono/mini/exceptions-x86.c +++ b/src/mono/mono/mini/exceptions-x86.c @@ -352,7 +352,7 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) x86_ret (code); if (info) - *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("restore_context", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); else { GSList *l; @@ -363,7 +363,7 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) g_assertf ((code - start) <= size, "%d %d", (int)(code - start), size); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); return start; @@ -432,7 +432,7 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) x86_ret (code); if (info) - *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("call_filter", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); else { GSList *l; @@ -441,7 +441,7 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) g_slist_free (unwind_ops); } - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); g_assertf ((code - start) <= kMaxCodeSize, "%d %d", (int)(code - start), kMaxCodeSize); @@ -676,7 +676,7 @@ get_throw_trampoline (const char *name, gboolean rethrow, gboolean llvm, gboolea g_assertf ((code - start) <= kMaxCodeSize, "%d %d", (int)(code - start), kMaxCodeSize); if (info) - *info = mono_tramp_info_create (name, start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create (name, start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); else { GSList *l; @@ -685,7 +685,7 @@ get_throw_trampoline (const char *name, gboolean rethrow, gboolean llvm, gboolea g_slist_free (unwind_ops); } - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); return start; @@ -982,7 +982,7 @@ mono_x86_get_signal_exception_trampoline (MonoTrampInfo **info, gboolean aot) g_assertf ((code - start) <= size, "%d %d", (int)(code - start), size); if (info) - *info = mono_tramp_info_create ("x86_signal_exception_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("x86_signal_exception_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); else { GSList *l; @@ -993,7 +993,7 @@ mono_x86_get_signal_exception_trampoline (MonoTrampInfo **info, gboolean aot) g_assertf ((code - start) <= size, "%d %d", (int)(code - start), size); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); return start; diff --git a/src/mono/mono/mini/graph.c b/src/mono/mono/mini/graph.c index 025664e6cbe6c1..1fffe4c833b7d4 100644 --- a/src/mono/mono/mini/graph.c +++ b/src/mono/mono/mini/graph.c @@ -203,7 +203,6 @@ mono_draw_graph (MonoCompile *cfg, MonoGraphOptions draw_options) #endif const char *fn; FILE *fp; - int _i G_GNUC_UNUSED; fn = "/tmp/minidtree.graph"; fp = fopen (fn, "w+"); @@ -228,6 +227,7 @@ mono_draw_graph (MonoCompile *cfg, MonoGraphOptions draw_options) #ifdef HAVE_SYSTEM //com = g_strdup_printf ("dot %s -Tpng -o %s.png; eog %s.png", fn, fn, fn); com = g_strdup_printf ("dot %s -Tps -o %s.ps;gv %s.ps", fn, fn, fn); + int _i G_GNUC_UNUSED; _i = system (com); g_free (com); #else diff --git a/src/mono/mono/mini/helpers.c b/src/mono/mono/mini/helpers.c index 130210cf21be9b..9d903fdbc24a50 100644 --- a/src/mono/mono/mini/helpers.c +++ b/src/mono/mono/mini/helpers.c @@ -130,7 +130,6 @@ mono_disassemble_code (MonoCompile *cfg, guint8 *code, int size, char *id) #endif char *as_file; char *o_file; - int unused G_GNUC_UNUSED; #ifdef HOST_WIN32 as_file = g_strdup_printf ("%s/test.s", tmp); @@ -255,6 +254,7 @@ MONO_RESTORE_WARNING #endif #ifdef HAVE_SYSTEM + int unused G_GNUC_UNUSED; char *cmd = g_strdup_printf (ARCH_PREFIX AS_CMD " %s -o %s", as_file, o_file); unused = system (cmd); g_free (cmd); diff --git a/src/mono/mono/mini/interp/transform.c b/src/mono/mono/mini/interp/transform.c index d4b7a94d8a4d98..17b44ae5007561 100644 --- a/src/mono/mono/mini/interp/transform.c +++ b/src/mono/mono/mini/interp/transform.c @@ -728,7 +728,7 @@ get_mov_for_type (int mt, gboolean needs_sext) g_assert_not_reached (); } -static int +static guint16 get_mint_type_size (int mt) { switch (mt) { @@ -3323,9 +3323,9 @@ interp_realign_simd_params (TransformData *td, StackInfo *sp_params, int num_arg interp_add_ins (td, MINT_MOV_STACK_UNOPT); // After previous alignment, this arg will be offset by MINT_STACK_SLOT_SIZE - td->last_ins->data [0] = sp_params [i].offset + prev_offset; + td->last_ins->data [0] = GINT_TO_UINT16 (sp_params [i].offset + prev_offset); td->last_ins->data [1] = offset_amount; - td->last_ins->data [2] = get_stack_size (td, sp_params + i, num_args - i); + td->last_ins->data [2] = GINT_TO_UINT16 (get_stack_size (td, sp_params + i, num_args - i)); } } } @@ -3711,9 +3711,9 @@ interp_transform_call (TransformData *td, MonoMethod *method, MonoMethod *target // Mov all params to the new_param_offset interp_add_ins (td, MINT_MOV_STACK_UNOPT); - td->last_ins->data [0] = param_offset; + td->last_ins->data [0] = GINT_TO_UINT16 (param_offset); td->last_ins->data [1] = MINT_STACK_SLOT_SIZE; - td->last_ins->data [2] = param_end_offset - param_offset; + td->last_ins->data [2] = GINT_TO_UINT16 (param_end_offset - param_offset); // If we have any simd arguments, we broke their alignment. We need to find the first simd arg and realign it // together with the following params. First argument can't be simd type otherwise we would have been aligned @@ -4032,7 +4032,7 @@ get_basic_blocks (TransformData *td, MonoMethodHeader *header, gboolean make_lis get_bb (td, target, make_list); ip += 2; get_bb (td, ip, make_list); - mono_bitset_set (il_targets, target - start); + mono_bitset_set (il_targets, GPTRDIFF_TO_UINT32 (target - start)); break; case MonoInlineBrTarget: target = start + cli_addr + 5 + (gint32)read32 (ip + 1); @@ -4041,7 +4041,7 @@ get_basic_blocks (TransformData *td, MonoMethodHeader *header, gboolean make_lis get_bb (td, target, make_list); ip += 5; get_bb (td, ip, make_list); - mono_bitset_set (il_targets, target - start); + mono_bitset_set (il_targets, GPTRDIFF_TO_UINT32 (target - start)); break; case MonoInlineSwitch: { guint32 n = read32 (ip + 1); @@ -4052,14 +4052,14 @@ get_basic_blocks (TransformData *td, MonoMethodHeader *header, gboolean make_lis if (target > end) return FALSE; get_bb (td, target, make_list); - mono_bitset_set (il_targets, target - start); + mono_bitset_set (il_targets, GPTRDIFF_TO_UINT32 (target - start)); for (j = 0; j < n; ++j) { target = start + cli_addr + (gint32)read32 (ip); if (target > end) return FALSE; get_bb (td, target, make_list); ip += 4; - mono_bitset_set (il_targets, target - start); + mono_bitset_set (il_targets, GPTRDIFF_TO_UINT32 (target - start)); } get_bb (td, ip, make_list); break; @@ -6212,7 +6212,7 @@ generate_code (TransformData *td, MonoMethod *method, MonoMethodHeader *header, td->cbb->contains_call_instruction = TRUE; interp_add_ins (td, MINT_NEWOBJ_STRING_UNOPT); td->last_ins->data [0] = get_data_item_index (td, mono_interp_get_imethod (m)); - td->last_ins->data [1] = params_stack_size; + td->last_ins->data [1] = GUINT32_TO_UINT16 (params_stack_size); push_type (td, stack_type [ret_mt], klass); interp_ins_set_dreg (td->last_ins, td->sp [-1].local); } else { @@ -6293,16 +6293,16 @@ generate_code (TransformData *td, MonoMethod *method, MonoMethodHeader *header, if (td->locals [sp_params [0].local].flags & INTERP_LOCAL_FLAG_SIMD) { // if first arg is simd, move all args at next aligned offset after this ptr interp_add_ins (td, MINT_MOV_STACK_UNOPT); - td->last_ins->data [0] = param_offset; - td->last_ins->data [1] = call_offset + MINT_SIMD_ALIGNMENT - param_offset; - td->last_ins->data [2] = param_size; + td->last_ins->data [0] = GINT_TO_UINT16 (param_offset); + td->last_ins->data [1] = GINT_TO_UINT16 (call_offset + MINT_SIMD_ALIGNMENT - param_offset); + td->last_ins->data [2] = GINT_TO_UINT16 (param_size); } else { int realign_offset = call_offset + MINT_STACK_SLOT_SIZE - param_offset; // otherwise we move all args immediately after this ptr interp_add_ins (td, MINT_MOV_STACK_UNOPT); - td->last_ins->data [0] = param_offset; - td->last_ins->data [1] = realign_offset; - td->last_ins->data [2] = param_size; + td->last_ins->data [0] = GINT_TO_UINT16 (param_offset); + td->last_ins->data [1] = GINT_TO_UINT16 (realign_offset); + td->last_ins->data [2] = GINT_TO_UINT16 (param_size); if ((realign_offset % MINT_SIMD_ALIGNMENT) != 0) { // the argument move broke the alignment of any potential simd arguments, realign @@ -9811,8 +9811,8 @@ interp_cprop (TransformData *td) ins = interp_insert_ins (td, ins, MINT_MOV_SRC_OFF); interp_ins_set_dreg (ins, ins->prev->dreg); interp_ins_set_sreg (ins, local); - ins->data [0] = foffset; - ins->data [1] = mt; + ins->data [0] = GINT_TO_UINT16 (foffset); + ins->data [1] = GINT_TO_UINT16 (mt); if (mt == MINT_TYPE_VT) ins->data [2] = ldsize; @@ -9945,8 +9945,8 @@ interp_cprop (TransformData *td) ins = interp_insert_ins (td, ins, MINT_MOV_DST_OFF); interp_ins_set_dreg (ins, local); interp_ins_set_sreg (ins, sregs [1]); - ins->data [0] = foffset; - ins->data [1] = mt; + ins->data [0] = GINT_TO_UINT16 (foffset); + ins->data [1] = GINT_TO_UINT16 (mt); ins->data [2] = vtsize; interp_clear_ins (ins->prev); @@ -10301,7 +10301,7 @@ interp_super_instructions (TransformData *td) new_inst = interp_insert_ins (td, ins, MINT_SHR_UN_I8_IMM); new_inst->dreg = ins->dreg; new_inst->sregs [0] = ins->sregs [0]; - new_inst->data [0] = power2; + new_inst->data [0] = GINT_TO_UINT16 (power2); interp_clear_ins (def); interp_clear_ins (ins); @@ -10495,7 +10495,7 @@ interp_super_instructions (TransformData *td) break; } if (replace_opcode != -1) { - ins->opcode = replace_opcode; + ins->opcode = GINT_TO_UINT16 (replace_opcode); ins->sregs [0] = def->sregs [0]; if (def->opcode != MINT_CEQ0_I4) ins->sregs [1] = def->sregs [1]; diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c index ef77b7dc89f2ee..48f72b46bb987c 100644 --- a/src/mono/mono/mini/intrinsics.c +++ b/src/mono/mono/mini/intrinsics.c @@ -906,7 +906,7 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign int sizes_reg = alloc_ireg (cfg); MONO_EMIT_NEW_LOAD_MEMBASE_FAULT (cfg, vt_reg, args [0]->dreg, MONO_STRUCT_OFFSET (MonoObject, vtable)); EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, class_reg, vt_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, sizes_reg, class_reg, m_class_offsetof_sizes ()); + EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADI4_MEMBASE, sizes_reg, class_reg, GINTPTR_TO_TMREG (m_class_offsetof_sizes ())); return ins; } @@ -1044,7 +1044,7 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign MonoInst* ptr_inst; if (cfg->compile_aot) { - NEW_RVACONST (cfg, ptr_inst, mono_class_get_image (mono_field_get_parent (field)), args [0]->inst_c0); + NEW_RVACONST (cfg, ptr_inst, mono_class_get_image (mono_field_get_parent (field)), GTMREG_TO_UINT32 (args [0]->inst_c0)); MONO_ADD_INS (cfg->cbb, ptr_inst); } else { #if G_BYTE_ORDER == G_LITTLE_ENDIAN diff --git a/src/mono/mono/mini/jit-icalls.c b/src/mono/mono/mini/jit-icalls.c index 628d18abe35cfd..90eb332a00bf0e 100644 --- a/src/mono/mono/mini/jit-icalls.c +++ b/src/mono/mono/mini/jit-icalls.c @@ -544,7 +544,7 @@ mono_imul_ovf (gint32 a, gint32 b) return 0; } - return res; + return GINT64_TO_INT32 (res); } gint32 @@ -559,7 +559,7 @@ mono_imul_ovf_un (guint32 a, guint32 b) return 0; } - return res; + return GUINT64_TO_INT32 (res); } gint32 @@ -574,7 +574,7 @@ mono_imul_ovf_un_oom (guint32 a, guint32 b) return 0; } - return res; + return GUINT64_TO_INT32 (res); } #endif diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c index dedc6804c3cbd8..39fb9f7dd1cfa6 100644 --- a/src/mono/mono/mini/method-to-ir.c +++ b/src/mono/mono/mini/method-to-ir.c @@ -3045,7 +3045,7 @@ emit_seq_point (MonoCompile *cfg, MonoMethod *method, guint8* ip, gboolean intr_ MonoInst *ins; if (cfg->gen_seq_points && cfg->method == method) { - NEW_SEQ_POINT (cfg, ins, ip - cfg->header->code, intr_loc); + NEW_SEQ_POINT (cfg, ins, GPTRDIFF_TO_TMREG (ip - cfg->header->code), intr_loc); if (nonempty_stack) ins->flags |= MONO_INST_NONEMPTY_STACK; MONO_ADD_INS (cfg->cbb, ins); @@ -3212,7 +3212,7 @@ mini_handle_unbox (MonoCompile *cfg, MonoClass *klass, MonoInst *val, int contex MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException"); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, m_class_offsetof_element_class ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_element_class ())); if (context_used) { MonoInst *element_class; @@ -7014,7 +7014,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b /* Avoid sequence points on empty IL like .volatile */ // FIXME: Enable this //if (!(cfg->cbb->last_ins && cfg->cbb->last_ins->opcode == OP_SEQ_POINT)) { - NEW_SEQ_POINT (cfg, ins, ip - header->code, intr_loc); + NEW_SEQ_POINT (cfg, ins, GPTRDIFF_TO_TMREG (ip - header->code), intr_loc); if ((sp != stack_start) && !sym_seq_point) ins->flags |= MONO_INST_NONEMPTY_STACK; MONO_ADD_INS (cfg->cbb, ins); @@ -7101,7 +7101,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b * The C# compiler uses these nops to notify the JIT that it should * insert seq points. */ - NEW_SEQ_POINT (cfg, ins, ip - header->code, FALSE); + NEW_SEQ_POINT (cfg, ins, GPTRDIFF_TO_TMREG (ip - header->code), FALSE); MONO_ADD_INS (cfg->cbb, ins); } if (cfg->keep_cil_nops) @@ -8520,7 +8520,7 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b * ret * will work correctly. */ - NEW_SEQ_POINT (cfg, ins, ip - header->code, TRUE); + NEW_SEQ_POINT (cfg, ins, GPTRDIFF_TO_TMREG (ip - header->code), TRUE); MONO_ADD_INS (cfg->cbb, ins); } diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c index e03b142feef1f3..2a87c1bf4bbb5a 100644 --- a/src/mono/mono/mini/mini-amd64.c +++ b/src/mono/mono/mini/mini-amd64.c @@ -7305,7 +7305,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (ins->inst_c0 == 0) { amd64_sse_movss_reg_reg (code, ins->dreg, ins->sreg1); } else { - int imm = ins->inst_c0; + int imm = GTMREG_TO_INT (ins->inst_c0); amd64_sse_movaps_reg_reg (code, SIMD_TEMP_REG, ins->sreg1); amd64_sse_shufps_reg_reg_imm (code, SIMD_TEMP_REG, ins->sreg1, imm); amd64_sse_pxor_reg_reg (code, ins->dreg, ins->dreg); @@ -7326,7 +7326,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) amd64_sse_pinsrq_reg_reg_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0); break; case OP_INSERT_R4: { - guint8 imm = (0 << 6) | (ins->inst_c0 << 4); + guint8 imm = (0 << 6) | (GTMREG_TO_UINT8 (ins->inst_c0 << 4)); amd64_sse_insertps_reg_reg (code, ins->sreg1, ins->sreg2, imm); break; } diff --git a/src/mono/mono/mini/mini-arm.c b/src/mono/mono/mini/mini-arm.c index ebd56c20584c3c..29546e1c231991 100644 --- a/src/mono/mono/mini/mini-arm.c +++ b/src/mono/mono/mini/mini-arm.c @@ -430,7 +430,7 @@ emit_save_lmf (MonoCompile *cfg, guint8 *code, gint32 lmf_offset) if (mono_arch_have_fast_tls () && mono_tls_get_tls_offset (TLS_KEY_LMF_ADDR) != -1) { code = emit_tls_get (code, ARMREG_R0, mono_tls_get_tls_offset (TLS_KEY_LMF_ADDR)); } else { - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_tls_get_lmf_addr_extern)); code = emit_call_seq (cfg, code); } @@ -495,7 +495,7 @@ emit_float_args (MonoCompile *cfg, MonoCallInst *inst, guint8 *code, int *max_le ARM_FLDS (code, fad->hreg, var->inst_basereg, var->inst_offset); set_code_cursor (cfg, code); - *offset = code - cfg->native_code; + *offset = GPTRDIFF_TO_UINT (code - cfg->native_code); } return code; @@ -669,10 +669,10 @@ get_delegate_invoke_impl (MonoTrampInfo **info, gboolean has_target, gboolean pa } if (has_target) { - *info = mono_tramp_info_create ("delegate_invoke_impl_has_target", start, code - start, NULL, unwind_ops); + *info = mono_tramp_info_create ("delegate_invoke_impl_has_target", start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); } else { char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", param_count); - *info = mono_tramp_info_create (name, start, code - start, NULL, unwind_ops); + *info = mono_tramp_info_create (name, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); g_free (name); } @@ -3090,28 +3090,28 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) *(gpointer*)ret = (gpointer)(gsize)res; break; case MONO_TYPE_I1: - *(gint8*)ret = GINT32_TO_INT8 (res); + *(gint8*)ret = GHMREG_TO_INT8 (res); break; case MONO_TYPE_U1: - *(guint8*)ret = GINT32_TO_UINT8 (res); + *(guint8*)ret = GHMREG_TO_UINT8 (res); break; case MONO_TYPE_I2: - *(gint16*)ret = GINT32_TO_INT16 (res); + *(gint16*)ret = GHMREG_TO_INT16 (res); break; case MONO_TYPE_U2: - *(guint16*)ret = GINT32_TO_UINT16 (res); + *(guint16*)ret = GHMREG_TO_UINT16 (res); break; case MONO_TYPE_I4: - *(gint32*)ret = res; + *(gint32*)ret = GHMREG_TO_INT32 (res); break; case MONO_TYPE_U4: - *(guint32*)ret = res; + *(guint32*)ret = GHMREG_TO_UINT32 (res); break; case MONO_TYPE_I8: case MONO_TYPE_U8: /* This handles endianness as well */ - ((gint32*)ret) [0] = res; - ((gint32*)ret) [1] = res2; + ((gint32*)ret) [0] = GHMREG_TO_INT32 (res); + ((gint32*)ret) [1] = GHMREG_TO_INT32 (res2); break; case MONO_TYPE_GENERICINST: if (MONO_TYPE_IS_REFERENCE (ptype)) { @@ -3159,7 +3159,7 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) if (0 && ins->inst_true_bb->native_offset) { \ ARM_B_COND (code, (condcode), (code - cfg->native_code + ins->inst_true_bb->native_offset) & 0xffffff); \ } else { \ - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \ + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, ins->inst_true_bb); \ ARM_B_COND (code, (condcode), 0); \ } @@ -3172,7 +3172,7 @@ if (0 && ins->inst_true_bb->native_offset) { \ */ #define EMIT_COND_SYSTEM_EXCEPTION_FLAGS(condcode,exc_name) \ do { \ - mono_add_patch_info (cfg, code - cfg->native_code, \ + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), \ MONO_PATCH_INFO_EXC, exc_name); \ ARM_BL_COND (code, (condcode), 0); \ } while (0); @@ -3762,7 +3762,7 @@ emit_thunk (guint8 *code, gconstpointer target) ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP); *(guint32*)code = (guint32)(gsize)target; code += 4; - mono_arch_flush_icache (p, code - p); + mono_arch_flush_icache (p, GPTRDIFF_TO_INT (code - p)); } static void @@ -3856,11 +3856,11 @@ arm_patch_general (MonoCompile *cfg, guchar *code, const guchar *target) //g_print ("patching 0x%08x (0x%08x) to point to 0x%08x\n", code, ins, target); if (prim == 5) { /* 101b */ /* the diff starts 8 bytes from the branch opcode */ - gint diff = target - code - 8; + gint diff = GPTRDIFF_TO_INT (target - code - 8); gint tbits; gint tmask = 0xffffffff; if (tval & 1) { /* entering thumb mode */ - diff = target - 1 - code - 8; + diff = GPTRDIFF_TO_INT (target - 1 - code - 8); g_assert (thumb_supported); tbits = 0xf << 28; /* bl->blx bit pattern */ g_assert ((ins & (1 << 24))); /* it must be a bl, not b instruction */ @@ -4229,13 +4229,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset); if (mono_break_at_bb_method && mono_method_desc_full_match (mono_break_at_bb_method, cfg->method) && bb->block_num == mono_break_at_bb_bb_num) { - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_break)); code = emit_call_seq (cfg, code); } MONO_BB_FOR_EACH_INS (bb, ins) { - guint offset = code - cfg->native_code; + guint offset = GPTRDIFF_TO_UINT (code - cfg->native_code); set_code_cursor (cfg, code); max_len = ins_get_size (ins->opcode); code = realloc_code (cfg, max_len); @@ -4539,7 +4539,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) //*(int*)code = 0xef9f0001; //code += 4; //ARM_DBRK (code); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_break)); code = emit_call_seq (cfg, code); break; @@ -4555,7 +4555,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_NOT_NULL: break; case OP_IL_SEQ_POINT: - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); break; case OP_SEQ_POINT: { int i; @@ -4622,11 +4622,11 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } } - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); /* Breakpoint check */ if (cfg->compile_aot) { - const guint32 bp_offset = code - cfg->native_code; + const guint32 bp_offset = GPTRDIFF_TO_UINT32 (code - cfg->native_code); guint32 val; var = info_var; @@ -5059,7 +5059,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (tailcall_reg || tailcall_membase) { code = emit_jmp_reg (code, ARMREG_IP); } else { - mono_add_patch_info (cfg, (guint8*) code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, call_ins->method); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_METHOD_JUMP, call_ins->method); if (cfg->compile_aot) { ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); @@ -5096,11 +5096,11 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (IS_HARD_FLOAT) code = emit_float_args (cfg, call, code, &max_len, &offset); - mono_call_add_patch_info (cfg, call, code - cfg->native_code); + mono_call_add_patch_info (cfg, call, GPTRDIFF_TO_INT (code - cfg->native_code)); code = emit_call_seq (cfg, code); ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); code = emit_move_return_value (cfg, ins, code); break; case OP_FCALL_REG: @@ -5115,7 +5115,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = emit_call_reg (code, ins->sreg1); ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); code = emit_move_return_value (cfg, ins, code); break; case OP_FCALL_MEMBASE: @@ -5142,7 +5142,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) ARM_LDR_IMM (code, ARMREG_PC, ins->sreg1, ins->inst_offset); } ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); code = emit_move_return_value (cfg, ins, code); break; } @@ -5161,7 +5161,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) /* Uninitialized case */ g_assert (ins->sreg1 == ARMREG_R0); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_generic_class_init)); code = emit_call_seq (cfg, code); @@ -5269,7 +5269,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_THROW: { if (ins->sreg1 != ARMREG_R0) ARM_MOV_REG_REG (code, ARMREG_R0, ins->sreg1); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arch_throw_exception)); code = emit_call_seq (cfg, code); break; @@ -5277,7 +5277,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_RETHROW: { if (ins->sreg1 != ARMREG_R0) ARM_MOV_REG_REG (code, ARMREG_R0, ins->sreg1); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arch_rethrow_exception)); code = emit_call_seq (cfg, code); break; @@ -5358,7 +5358,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_CALL_HANDLER: - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_target_bb); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, ins->inst_target_bb); code = mono_arm_patchable_bl (code, ARMCOND_AL); cfg->thunk_area += THUNK_SIZE; for (GList *tmp = ins->inst_eh_blocks; tmp != bb->clause_holes; tmp = tmp->prev) @@ -5370,7 +5370,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; case OP_LABEL: - ins->inst_c0 = code - cfg->native_code; + ins->inst_c0 = GPTRDIFF_TO_TMREG (code - cfg->native_code); break; case OP_BR: /*if (ins->inst_target_bb->native_offset) { @@ -5920,22 +5920,22 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_GC_LIVENESS_DEF: case OP_GC_LIVENESS_USE: case OP_GC_PARAM_SLOT_LIVENESS_DEF: - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); break; case OP_GC_SPILL_SLOT_LIVENESS_DEF: - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); bb->spill_slot_defs = g_slist_prepend_mempool (cfg->mempool, bb->spill_slot_defs, ins); break; case OP_LIVERANGE_START: { if (cfg->verbose_level > 1) printf ("R%d START=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = code - cfg->native_code; + MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_LIVERANGE_END: { if (cfg->verbose_level > 1) printf ("R%d END=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = code - cfg->native_code; + MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_GC_SAFE_POINT: { @@ -5945,7 +5945,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) ARM_CMP_REG_IMM (code, ARMREG_IP, 0, 0); buf [0] = code; ARM_B_COND (code, ARMCOND_EQ, 0); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_threads_state_poll)); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_threads_state_poll)); code = emit_call_seq (cfg, code); arm_patch (buf [0], code); break; @@ -6223,8 +6223,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) ARM_STR_REG_REG (code, MONO_ARCH_RGCTX_REG, ins->inst_basereg, ARMREG_LR); } - mono_add_var_location (cfg, cfg->rgctx_var, TRUE, MONO_ARCH_RGCTX_REG, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, cfg->rgctx_var, FALSE, ins->inst_basereg, ins->inst_offset, code - cfg->native_code, 0); + mono_add_var_location (cfg, cfg->rgctx_var, TRUE, MONO_ARCH_RGCTX_REG, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, cfg->rgctx_var, FALSE, ins->inst_basereg, ins->inst_offset, GPTRDIFF_TO_INT (code - cfg->native_code), 0); } /* load arguments allocated to register from the stack */ @@ -6277,8 +6277,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (i == 0 && sig->hasthis) { g_assert (ainfo->storage == RegTypeGeneral); - mono_add_var_location (cfg, inst, TRUE, ainfo->reg, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, inst, TRUE, inst->dreg, 0, code - cfg->native_code, 0); + mono_add_var_location (cfg, inst, TRUE, ainfo->reg, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, inst, TRUE, inst->dreg, 0, GPTRDIFF_TO_INT (code - cfg->native_code), 0); } if (cfg->verbose_level > 2) @@ -6339,8 +6339,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) } if (i == 0 && sig->hasthis) { g_assert (ainfo->storage == RegTypeGeneral); - mono_add_var_location (cfg, inst, TRUE, ainfo->reg, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, inst, FALSE, inst->inst_basereg, inst->inst_offset, code - cfg->native_code, 0); + mono_add_var_location (cfg, inst, TRUE, ainfo->reg, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, inst, FALSE, inst->inst_basereg, inst->inst_offset, GPTRDIFF_TO_INT (code - cfg->native_code), 0); } break; case RegTypeBaseGen: @@ -6467,7 +6467,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) MonoInst *ins = cfg->arch.seq_point_info_var; /* Initialize the variable from a GOT slot */ - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_SEQ_POINT_INFO, cfg->method); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_SEQ_POINT_INFO, cfg->method); ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -6743,7 +6743,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg) ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0); patch_info->type = MONO_PATCH_INFO_JIT_ICALL_ID; patch_info->data.jit_icall_id = MONO_JIT_ICALL_mono_arch_throw_corlib_exception; - patch_info->ip.i = code - cfg->native_code; + patch_info->ip.i = GPTRDIFF_TO_INT (code - cfg->native_code); ARM_BL (code, 0); cfg->thunk_area += THUNK_SIZE; *(guint32*)(gpointer)code = m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF; @@ -7069,7 +7069,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoIMTCheckItem **imt_entri mono_arch_flush_icache ((guint8*)start, size); MONO_PROFILER_RAISE (jit_code_buffer, ((guint8*)start, code - start, MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL)); - UnlockedAdd (&mono_stats.imt_trampolines_size, code - start); + UnlockedAdd (&mono_stats.imt_trampolines_size, GPTRDIFF_TO_INT32 (code - start)); g_assert (DISTANCE (start, code) <= size); @@ -7419,7 +7419,7 @@ static G_GNUC_UNUSED guint8* emit_aotconst (MonoCompile *cfg, guint8 *code, int dreg, int patch_type, gpointer data) { /* OP_AOTCONST */ - mono_add_patch_info (cfg, code - cfg->native_code, (MonoJumpInfoType)patch_type, data); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), (MonoJumpInfoType)patch_type, data); ARM_LDR_IMM (code, dreg, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -7434,7 +7434,7 @@ mono_arm_emit_aotconst (gpointer ji_list, guint8 *code, guint8 *buf, int dreg, i { MonoJumpInfo **ji = (MonoJumpInfo**)ji_list; - *ji = mono_patch_info_list_prepend (*ji, code - buf, (MonoJumpInfoType)patch_type, data); + *ji = mono_patch_info_list_prepend (*ji, GPTRDIFF_TO_INT (code - buf), (MonoJumpInfoType)patch_type, data); ARM_LDR_IMM (code, dreg, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; diff --git a/src/mono/mono/mini/mini-arm64.c b/src/mono/mono/mini/mini-arm64.c index ffd35a36c67a53..3d5c548812b871 100644 --- a/src/mono/mono/mini/mini-arm64.c +++ b/src/mono/mono/mini/mini-arm64.c @@ -199,10 +199,10 @@ get_delegate_invoke_impl (gboolean has_target, gboolean param_count, guint32 *co g_assert ((code - start) <= size); } - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL); if (code_size) - *code_size = code - start; + *code_size = GPTRDIFF_TO_UINT32 (code - start); return MINI_ADDR_TO_FTNPTR (start); } @@ -241,7 +241,7 @@ get_delegate_virtual_invoke_impl (MonoTrampInfo **info, gboolean load_imt_reg, i g_assert ((code - start) <= size); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL); tramp_name = mono_get_delegate_virtual_invoke_impl_name (load_imt_reg, offset); *info = mono_tramp_info_create (tramp_name, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); @@ -1054,11 +1054,11 @@ static guint8* emit_call (MonoCompile *cfg, guint8* code, MonoJumpInfoType patch_type, gconstpointer data) { /* - mono_add_patch_info_rel (cfg, code - cfg->native_code, patch_type, data, MONO_R_ARM64_IMM); + mono_add_patch_info_rel (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), patch_type, data, MONO_R_ARM64_IMM); code = emit_imm64_template (code, ARMREG_LR); arm_blrx (code, ARMREG_LR); */ - mono_add_patch_info_rel (cfg, code - cfg->native_code, patch_type, data, MONO_R_ARM64_BL); + mono_add_patch_info_rel (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), patch_type, data, MONO_R_ARM64_BL); arm_bl (code, code); cfg->thunk_area += THUNK_SIZE; return code; @@ -1068,9 +1068,9 @@ static guint8* emit_aotconst_full (MonoCompile *cfg, MonoJumpInfo **ji, guint8 *code, guint8 *start, int dreg, guint32 patch_type, gconstpointer data) { if (cfg) - mono_add_patch_info (cfg, code - cfg->native_code, (MonoJumpInfoType)patch_type, data); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), (MonoJumpInfoType)patch_type, data); else - *ji = mono_patch_info_list_prepend (*ji, code - start, (MonoJumpInfoType)patch_type, data); + *ji = mono_patch_info_list_prepend (*ji, GPTRDIFF_TO_INT (code - start), (MonoJumpInfoType)patch_type, data); /* See arch_emit_got_access () in aot-compiler.c */ arm_ldrx_lit (code, dreg, 0); arm_nop (code); @@ -1185,7 +1185,7 @@ emit_thunk (guint8 *code, gconstpointer target) *(guint64*)code = (guint64)target; code += sizeof (guint64); - mono_arch_flush_icache (p, code - p); + mono_arch_flush_icache (p, GPTRDIFF_TO_INT (code - p)); return code; } @@ -2329,10 +2329,10 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) *(guint16*)ret = GHMREG_TO_UINT16 (res); break; case MONO_TYPE_I4: - *(gint32*)ret = res; + *(gint32*)ret = GHMREG_TO_INT32 (res); break; case MONO_TYPE_U4: - *(guint32*)ret = res; + *(guint32*)ret = GHMREG_TO_UINT32 (res); break; case MONO_TYPE_I8: case MONO_TYPE_U8: @@ -3508,7 +3508,7 @@ emit_cond_exc (MonoCompile *cfg, guint8 *code, int opcode, const char *exc_name) cond = opcode_to_armcond (opcode); /* Capture PC */ arm_adrx (code, ARMREG_IP1, code); - mono_add_patch_info_rel (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC, exc_name, MONO_R_ARM64_BCC); + mono_add_patch_info_rel (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_EXC, exc_name, MONO_R_ARM64_BCC); arm_bcc (code, cond, 0); return code; } @@ -3545,7 +3545,7 @@ emit_move_return_value (MonoCompile *cfg, guint8 * code, MonoInst *ins) /* Load the destination address */ g_assert (loc && loc->opcode == OP_REGOFFSET); - code = emit_ldrx (code, ARMREG_LR, loc->inst_basereg, loc->inst_offset); + code = emit_ldrx (code, ARMREG_LR, loc->inst_basereg, GTMREG_TO_INT (loc->inst_offset)); for (i = 0; i < cinfo->ret.nregs; ++i) arm_strx (code, cinfo->ret.reg + i, ARMREG_LR, i * 8); break; @@ -3556,7 +3556,7 @@ emit_move_return_value (MonoCompile *cfg, guint8 * code, MonoInst *ins) /* Load the destination address */ g_assert (loc && loc->opcode == OP_REGOFFSET); - code = emit_ldrx (code, ARMREG_LR, loc->inst_basereg, loc->inst_offset); + code = emit_ldrx (code, ARMREG_LR, loc->inst_basereg, GTMREG_TO_INT (loc->inst_offset)); for (i = 0; i < cinfo->ret.nregs; ++i) { if (cinfo->ret.esize == 4) arm_strfpw (code, cinfo->ret.reg + i, ARMREG_LR, cinfo->ret.foffsets [i]); @@ -3628,7 +3628,7 @@ emit_branch_island (MonoCompile *cfg, guint8 *code, int start_offset) /* Rewrite the cond branch so it branches to an unconditional branch in the branch island */ arm_patch_rel (cfg->native_code + ji->ip.i, code, ji->relocation); /* Rewrite the patch so it points to the unconditional branch */ - ji->ip.i = code - cfg->native_code; + ji->ip.i = GPTRDIFF_TO_INT (code - cfg->native_code); ji->relocation = MONO_R_ARM64_B; arm_b (code, code); } @@ -3650,11 +3650,11 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (cfg->verbose_level > 2) g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset); - start_offset = code - cfg->native_code; + start_offset = GPTRDIFF_TO_INT (code - cfg->native_code); g_assert (GINT_TO_UINT(start_offset) <= cfg->code_size); MONO_BB_FOR_EACH_INS (bb, ins) { - guint offset = code - cfg->native_code; + guint offset = GPTRDIFF_TO_UINT (code - cfg->native_code); set_code_cursor (cfg, code); max_len = ins_get_size (ins->opcode); code = realloc_code (cfg, max_len); @@ -3662,7 +3662,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (G_UNLIKELY (cfg->arch.cond_branch_islands && offset - start_offset > 4 * 0x1ffff)) { /* Emit a branch island for large basic blocks */ code = emit_branch_island (cfg, code, start_offset); - offset = code - cfg->native_code; + offset = GPTRDIFF_TO_UINT (code - cfg->native_code); start_offset = offset; } @@ -3699,7 +3699,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) manual_instruction_emit: switch (ins->opcode) { case OP_ICONST: - code = emit_imm (code, dreg, ins->inst_c0); + code = emit_imm (code, dreg, GTMREG_TO_INT (ins->inst_c0)); break; case OP_I8CONST: code = emit_imm64 (code, dreg, ins->inst_c0); @@ -3801,7 +3801,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) g_assert (var->opcode == OP_REGOFFSET); /* Load ss_tramp_var */ /* This is equal to &ss_trampoline */ - arm_ldrx (code, ARMREG_IP1, var->inst_basereg, var->inst_offset); + arm_ldrx (code, ARMREG_IP1, var->inst_basereg, GTMREG_TO_INT (var->inst_offset)); /* Load the trampoline address */ arm_ldrx (code, ARMREG_IP1, ARMREG_IP1, 0); /* Call it if it is non-null */ @@ -3809,13 +3809,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = mono_arm_emit_blrx (code, ARMREG_IP1); } - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); if (cfg->compile_aot) { - const guint32 bp_tramp_offset = code - cfg->native_code; + const guint32 bp_tramp_offset = GPTRDIFF_TO_UINT32 (code - cfg->native_code); guint32 val; - arm_ldrx (code, ARMREG_IP1, info_var->inst_basereg, info_var->inst_offset); + arm_ldrx (code, ARMREG_IP1, info_var->inst_basereg, GTMREG_TO_INT (info_var->inst_offset)); /* Add the bp_tramp_offset */ val = ((bp_tramp_offset / 4) * sizeof (target_mgreg_t)) + MONO_STRUCT_OFFSET (SeqPointInfo, bp_addrs); /* Load the info->bp_addrs [bp_tramp_offset], which is either 0 or the address of the bp trampoline */ @@ -3830,7 +3830,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) g_assert (var); g_assert (var->opcode == OP_REGOFFSET); /* Load the address of the bp trampoline into IP0 */ - arm_ldrx (code, ARMREG_IP0, var->inst_basereg, var->inst_offset); + arm_ldrx (code, ARMREG_IP0, var->inst_basereg, GTMREG_TO_INT (var->inst_offset)); /* * A placeholder for a possible breakpoint inserted by * mono_arch_set_breakpoint (). @@ -3912,7 +3912,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ARM64_BROADCAST_ELEM: - arm_neon_smov (code, TYPE_I32, ARMREG_IP0, sreg1, ins->inst_c0); + arm_neon_smov (code, TYPE_I32, ARMREG_IP0, sreg1, GTMREG_TO_UINT32 (ins->inst_c0)); arm_neon_dup_g_4s (code, dreg, ARMREG_IP0); break; @@ -3924,19 +3924,19 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_neon_not_16b (code, dreg, dreg); break; case OP_XEXTRACT: - code = emit_xextract (code, VREG_FULL, ins->inst_c0, dreg, sreg1); + code = emit_xextract (code, VREG_FULL, GTMREG_TO_INT (ins->inst_c0), dreg, sreg1); break; case OP_STOREX_MEMBASE: if (ins->klass && mono_class_value_size (ins->klass, NULL) == 8) - code = emit_strfpx (code, sreg1, dreg, ins->inst_offset); + code = emit_strfpx (code, sreg1, dreg, GTMREG_TO_INT (ins->inst_offset)); else - code = emit_strfpq (code, sreg1, dreg, ins->inst_offset); + code = emit_strfpq (code, sreg1, dreg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADX_MEMBASE: if (ins->klass && mono_class_value_size (ins->klass, NULL) == 8) - code = emit_ldrfpx (code, dreg, sreg1, ins->inst_offset); + code = emit_ldrfpx (code, dreg, sreg1, GTMREG_TO_INT (ins->inst_offset)); else - code = emit_ldrfpq (code, dreg, sreg1, ins->inst_offset); + code = emit_ldrfpq (code, dreg, sreg1, GTMREG_TO_INT (ins->inst_offset)); break; case OP_XMOVE: if(dreg != sreg1) @@ -3976,9 +3976,9 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) const int t = get_type_size_macro (ins->inst_c1); // smov is not defined for i64 if (is_type_unsigned_macro (ins->inst_c1) || t == TYPE_I64) { - arm_neon_umov (code, t, dreg, sreg1, ins->inst_c0); + arm_neon_umov (code, t, dreg, sreg1, GTMREG_TO_UINT32 (ins->inst_c0)); } else { - arm_neon_smov (code, t, dreg, sreg1, ins->inst_c0); + arm_neon_smov (code, t, dreg, sreg1, GTMREG_TO_UINT32 (ins->inst_c0)); } break; } @@ -3989,7 +3989,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) // Technically, this broadcasts element #inst_c0 to all dest XREG elements; whereas it should // set the FREG to the said element. Since FREG and XREG pool is the same on arm64 and the rest // of the F/XREG is ignored in FREG mode, this operation remains valid. - arm_neon_fdup_e (code, VREG_FULL, t, dreg, sreg1, ins->inst_c0); + arm_neon_fdup_e (code, VREG_FULL, t, dreg, sreg1, GTMREG_TO_UINT32 (ins->inst_c0)); } break; @@ -4028,7 +4028,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (dreg != sreg1) arm_neon_mov (code, dreg, sreg1); - arm_neon_ins_g(code, t, dreg, sreg2, ins->inst_c0); + arm_neon_ins_g(code, t, dreg, sreg2, GTMREG_TO_UINT32 (ins->inst_c0)); break; } case OP_INSERT_R4: @@ -4046,15 +4046,15 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (dreg != sreg1) { if (dreg != sreg2) { arm_neon_mov (code, dreg, sreg1); - arm_neon_ins_e(code, t, dreg, sreg2, ins->inst_c0, 0); + arm_neon_ins_e(code, t, dreg, sreg2, GTMREG_TO_UINT32 (ins->inst_c0), 0); } else { arm_neon_mov (code, NEON_TMP_REG, sreg1); - arm_neon_ins_e(code, t, NEON_TMP_REG, sreg2, ins->inst_c0, 0); + arm_neon_ins_e(code, t, NEON_TMP_REG, sreg2, GTMREG_TO_UINT32 (ins->inst_c0), 0); arm_neon_mov (code, dreg, NEON_TMP_REG); } } else { g_assert (dreg != sreg2); - arm_neon_ins_e(code, t, dreg, sreg2, ins->inst_c0, 0); + arm_neon_ins_e(code, t, dreg, sreg2, GTMREG_TO_UINT32 (ins->inst_c0), 0); } break; } @@ -4234,7 +4234,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_FBLE_UN: mono_add_patch_info_rel (cfg, offset, MONO_PATCH_INFO_BB, ins->inst_true_bb, MONO_R_ARM64_BCC); arm_bcc (code, ARMCOND_EQ, 0); - mono_add_patch_info_rel (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb, MONO_R_ARM64_BCC); + mono_add_patch_info_rel (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, ins->inst_true_bb, MONO_R_ARM64_BCC); /* For fp compares, ARMCOND_LT is lt or unordered */ arm_bcc (code, ARMCOND_LT, 0); break; @@ -4320,39 +4320,39 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_cmpx (code, sreg1, sreg2); break; case OP_IADD_IMM: - code = emit_addw_imm (code, dreg, sreg1, imm); + code = emit_addw_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_LADD_IMM: case OP_ADD_IMM: - code = emit_addx_imm (code, dreg, sreg1, imm); + code = emit_addx_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_ISUB_IMM: - code = emit_subw_imm (code, dreg, sreg1, imm); + code = emit_subw_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_LSUB_IMM: - code = emit_subx_imm (code, dreg, sreg1, imm); + code = emit_subx_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_IAND_IMM: - code = emit_andw_imm (code, dreg, sreg1, imm); + code = emit_andw_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_LAND_IMM: case OP_AND_IMM: - code = emit_andx_imm (code, dreg, sreg1, imm); + code = emit_andx_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_IOR_IMM: - code = emit_orrw_imm (code, dreg, sreg1, imm); + code = emit_orrw_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_LOR_IMM: - code = emit_orrx_imm (code, dreg, sreg1, imm); + code = emit_orrx_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_IXOR_IMM: - code = emit_eorw_imm (code, dreg, sreg1, imm); + code = emit_eorw_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_LXOR_IMM: - code = emit_eorx_imm (code, dreg, sreg1, imm); + code = emit_eorx_imm (code, dreg, sreg1, GTMREG_TO_INT (imm)); break; case OP_ICOMPARE_IMM: - code = emit_cmpw_imm (code, sreg1, imm); + code = emit_cmpw_imm (code, sreg1, GTMREG_TO_INT (imm)); break; case OP_LCOMPARE_IMM: case OP_COMPARE_IMM: @@ -4399,27 +4399,27 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) if (imm == 0) arm_movx (code, dreg, sreg1); else - arm_asrw (code, dreg, sreg1, imm); + arm_asrw (code, dreg, sreg1, GTMREG_TO_UINT32 (imm)); break; case OP_LSHR_IMM: case OP_SHR_IMM: if (imm == 0) arm_movx (code, dreg, sreg1); else - arm_asrx (code, dreg, sreg1, imm); + arm_asrx (code, dreg, sreg1, GTMREG_TO_UINT32 (imm)); break; case OP_ISHR_UN_IMM: if (imm == 0) arm_movx (code, dreg, sreg1); else - arm_lsrw (code, dreg, sreg1, imm); + arm_lsrw (code, dreg, sreg1, GTMREG_TO_UINT32 (imm)); break; case OP_SHR_UN_IMM: case OP_LSHR_UN_IMM: if (imm == 0) arm_movx (code, dreg, sreg1); else - arm_lsrx (code, dreg, sreg1, imm); + arm_lsrx (code, dreg, sreg1, GTMREG_TO_UINT32 (imm)); break; /* 64BIT ALU */ @@ -4508,12 +4508,12 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_mulx (code, dreg, sreg1, sreg2); break; case OP_IMUL_IMM: - code = emit_imm (code, ARMREG_LR, imm); + code = emit_imm (code, ARMREG_LR, GTMREG_TO_INT (imm)); arm_mulw (code, dreg, sreg1, ARMREG_LR); break; case OP_MUL_IMM: case OP_LMUL_IMM: - code = emit_imm (code, ARMREG_LR, imm); + code = emit_imm (code, ARMREG_LR, GTMREG_TO_INT (imm)); arm_mulx (code, dreg, sreg1, ARMREG_LR); break; @@ -4580,26 +4580,26 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) /* MEMORY */ case OP_LOADI1_MEMBASE: - code = emit_ldrsbx (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrsbx (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADU1_MEMBASE: - code = emit_ldrb (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrb (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADI2_MEMBASE: - code = emit_ldrshx (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrshx (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADU2_MEMBASE: - code = emit_ldrh (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrh (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADI4_MEMBASE: - code = emit_ldrswx (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrswx (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADU4_MEMBASE: - code = emit_ldrw (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrw (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOAD_MEMBASE: case OP_LOADI8_MEMBASE: - code = emit_ldrx (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrx (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STOREI1_MEMBASE_IMM: case OP_STOREI2_MEMBASE_IMM: @@ -4609,7 +4609,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) int immreg; if (imm != 0) { - code = emit_imm (code, ARMREG_LR, imm); + code = emit_imm (code, ARMREG_LR, GTMREG_TO_INT (imm)); immreg = ARMREG_LR; } else { immreg = ARMREG_RZR; @@ -4617,17 +4617,17 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) switch (ins->opcode) { case OP_STOREI1_MEMBASE_IMM: - code = emit_strb (code, immreg, ins->inst_destbasereg, ins->inst_offset); + code = emit_strb (code, immreg, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STOREI2_MEMBASE_IMM: - code = emit_strh (code, immreg, ins->inst_destbasereg, ins->inst_offset); + code = emit_strh (code, immreg, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STOREI4_MEMBASE_IMM: - code = emit_strw (code, immreg, ins->inst_destbasereg, ins->inst_offset); + code = emit_strw (code, immreg, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STORE_MEMBASE_IMM: case OP_STOREI8_MEMBASE_IMM: - code = emit_strx (code, immreg, ins->inst_destbasereg, ins->inst_offset); + code = emit_strx (code, immreg, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; default: g_assert_not_reached (); @@ -4636,23 +4636,23 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_STOREI1_MEMBASE_REG: - code = emit_strb (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strb (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STOREI2_MEMBASE_REG: - code = emit_strh (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strh (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STOREI4_MEMBASE_REG: - code = emit_strw (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strw (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STORE_MEMBASE_REG: case OP_STOREI8_MEMBASE_REG: - code = emit_strx (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strx (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_TLS_GET: - code = emit_tls_get (code, dreg, ins->inst_offset); + code = emit_tls_get (code, dreg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_TLS_SET: - code = emit_tls_set (code, sreg1, ins->inst_offset); + code = emit_tls_set (code, sreg1, GTMREG_TO_INT (ins->inst_offset)); break; /* Atomic */ case OP_MEMORY_BARRIER: @@ -4742,7 +4742,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_I1: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarb (code, ins->dreg, ARMREG_LR); @@ -4750,7 +4750,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_U1: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarb (code, ins->dreg, ARMREG_LR); @@ -4758,7 +4758,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_I2: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarh (code, ins->dreg, ARMREG_LR); @@ -4766,7 +4766,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_U2: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarh (code, ins->dreg, ARMREG_LR); @@ -4774,7 +4774,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_I4: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarw (code, ins->dreg, ARMREG_LR); @@ -4782,7 +4782,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_U4: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarw (code, ins->dreg, ARMREG_LR); @@ -4791,14 +4791,14 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ATOMIC_LOAD_I8: case OP_ATOMIC_LOAD_U8: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarx (code, ins->dreg, ARMREG_LR); break; } case OP_ATOMIC_LOAD_R4: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarw (code, ARMREG_LR, ARMREG_LR); @@ -4806,7 +4806,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_LOAD_R8: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); arm_ldarx (code, ARMREG_LR, ARMREG_LR); @@ -4815,7 +4815,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ATOMIC_STORE_I1: case OP_ATOMIC_STORE_U1: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_stlrb (code, ARMREG_LR, ins->sreg1); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); @@ -4823,7 +4823,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ATOMIC_STORE_I2: case OP_ATOMIC_STORE_U2: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_stlrh (code, ARMREG_LR, ins->sreg1); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); @@ -4831,7 +4831,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ATOMIC_STORE_I4: case OP_ATOMIC_STORE_U4: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_stlrw (code, ARMREG_LR, ins->sreg1); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); @@ -4839,14 +4839,14 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ATOMIC_STORE_I8: case OP_ATOMIC_STORE_U8: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_stlrx (code, ARMREG_LR, ins->sreg1); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) arm_dmb (code, ARM_DMB_ISH); break; } case OP_ATOMIC_STORE_R4: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_fmov_double_to_rx (code, ARMREG_IP0, ins->sreg1); arm_stlrw (code, ARMREG_LR, ARMREG_IP0); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) @@ -4854,7 +4854,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_ATOMIC_STORE_R8: { - code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, ins->inst_offset); + code = emit_addx_imm (code, ARMREG_LR, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); arm_fmov_double_to_rx (code, ARMREG_IP0, ins->sreg1); arm_stlrx (code, ARMREG_LR, ARMREG_IP0); if (ins->backend.memory_barrier_kind == MONO_MEMORY_BARRIER_SEQ) @@ -4911,16 +4911,16 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_LOADR8_MEMBASE: - code = emit_ldrfpx (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrfpx (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_LOADR4_MEMBASE: - code = emit_ldrfpw (code, dreg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrfpw (code, dreg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STORER8_MEMBASE_REG: - code = emit_strfpx (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strfpx (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_STORER4_MEMBASE_REG: - code = emit_strfpw (code, sreg1, ins->inst_destbasereg, ins->inst_offset); + code = emit_strfpw (code, sreg1, ins->inst_destbasereg, GTMREG_TO_INT (ins->inst_offset)); break; case OP_FMOVE: if (dreg != sreg1) @@ -5128,7 +5128,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_FCALL_MEMBASE: case OP_RCALL_MEMBASE: case OP_VCALL2_MEMBASE: - code = emit_ldrx (code, ARMREG_IP0, ins->inst_basereg, ins->inst_offset); + code = emit_ldrx (code, ARMREG_IP0, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); code = mono_arm_emit_blrx (code, ARMREG_IP0); code = emit_move_return_value (cfg, code, ins); break; @@ -5183,7 +5183,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) g_assert (ins->inst_basereg != ARMREG_LR); g_assert (ins->inst_basereg != ARMREG_SP); g_assert (ins->inst_basereg != ARMREG_R28); - code = emit_ldrx (code, branch_reg, ins->inst_basereg, ins->inst_offset); + code = emit_ldrx (code, branch_reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; default: @@ -5214,7 +5214,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) /* This is not a PLT patch */ code = emit_aotconst (cfg, code, branch_reg, MONO_PATCH_INFO_METHOD_JUMP, call->method); } else { - mono_add_patch_info_rel (cfg, code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, call->method, MONO_R_ARM64_B); + mono_add_patch_info_rel (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_METHOD_JUMP, call->method, MONO_R_ARM64_B); arm_b (code, code); cfg->thunk_area += THUNK_SIZE; break; @@ -5230,7 +5230,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); break; } case OP_ARGLIST: @@ -5254,7 +5254,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_movx (code, ARMREG_IP1, sreg2); /* Save args buffer */ - code = emit_strx (code, ARMREG_LR, var->inst_basereg, var->inst_offset); + code = emit_strx (code, ARMREG_LR, var->inst_basereg, GTMREG_TO_INT (var->inst_offset)); /* Set fp argument regs */ code = emit_ldrw (code, ARMREG_R0, ARMREG_LR, MONO_STRUCT_OFFSET (DynCallArgs, n_fpargs)); @@ -5299,7 +5299,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = mono_arm_emit_blrx (code, ARMREG_IP1); /* Save result */ - code = emit_ldrx (code, ARMREG_LR, var->inst_basereg, var->inst_offset); + code = emit_ldrx (code, ARMREG_LR, var->inst_basereg, GTMREG_TO_INT (var->inst_offset)); arm_strx (code, ARMREG_R0, ARMREG_LR, MONO_STRUCT_OFFSET (DynCallArgs, res)); arm_strx (code, ARMREG_R1, ARMREG_LR, MONO_STRUCT_OFFSET (DynCallArgs, res2)); /* Save fp result */ @@ -5366,7 +5366,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_DUMMY_R4CONST: break; case OP_IL_SEQ_POINT: - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); break; /* EH */ @@ -5423,7 +5423,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) MonoInst *spvar = mono_find_spvar_for_region (cfg, bb->region); /* Save caller address */ - code = emit_strx (code, ARMREG_LR, spvar->inst_basereg, spvar->inst_offset); + code = emit_strx (code, ARMREG_LR, spvar->inst_basereg, GTMREG_TO_INT (spvar->inst_offset)); /* * Reserve a param area, see test_0_finally_param_area (). @@ -5445,7 +5445,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_movx (code, ARMREG_R0, sreg1); /* Return to either after the branch in OP_CALL_HANDLER, or to the EH code */ - code = emit_ldrx (code, ARMREG_LR, spvar->inst_basereg, spvar->inst_offset); + code = emit_ldrx (code, ARMREG_LR, spvar->inst_basereg, GTMREG_TO_INT (spvar->inst_offset)); arm_brx (code, ARMREG_LR); break; } @@ -5455,14 +5455,14 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; case OP_LIVERANGE_START: { if (cfg->verbose_level > 1) - printf ("R%d START=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = code - cfg->native_code; + printf ("R%d START=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, GPTRDIFF_TO_INT (code - cfg->native_code)); + MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_LIVERANGE_END: { if (cfg->verbose_level > 1) - printf ("R%d END=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = code - cfg->native_code; + printf ("R%d END=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, GPTRDIFF_TO_INT (code - cfg->native_code)); + MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_GC_SAFE_POINT: { @@ -5558,7 +5558,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } case OP_ARM64_HINT: g_assert (ins->inst_c0 <= ARMHINT_SEVL); - arm_hint (code, ins->inst_c0); + arm_hint (code, GTMREG_TO_UINT32 (ins->inst_c0)); break; default: @@ -5604,8 +5604,8 @@ emit_move_args (MonoCompile *cfg, guint8 *code) case ArgInIReg: arm_movx (code, ins->dreg, ainfo->reg); if (i == 0 && sig->hasthis) { - mono_add_var_location (cfg, ins, TRUE, ainfo->reg, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, ins, TRUE, ins->dreg, 0, code - cfg->native_code, 0); + mono_add_var_location (cfg, ins, TRUE, ainfo->reg, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, ins, TRUE, ins->dreg, 0, GPTRDIFF_TO_INT (code - cfg->native_code), 0); } break; case ArgOnStack: @@ -5644,17 +5644,17 @@ emit_move_args (MonoCompile *cfg, guint8 *code) switch (ainfo->storage) { case ArgInIReg: /* Stack slots for arguments have size 8 */ - code = emit_strx (code, ainfo->reg, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ainfo->reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); if (i == 0 && sig->hasthis) { - mono_add_var_location (cfg, ins, TRUE, ainfo->reg, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, ins, FALSE, ins->inst_basereg, ins->inst_offset, code - cfg->native_code, 0); + mono_add_var_location (cfg, ins, TRUE, ainfo->reg, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, ins, FALSE, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset), GPTRDIFF_TO_INT (code - cfg->native_code), 0); } break; case ArgInFReg: - code = emit_strfpx (code, ainfo->reg, ins->inst_basereg, ins->inst_offset); + code = emit_strfpx (code, ainfo->reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case ArgInFRegR4: - code = emit_strfpw (code, ainfo->reg, ins->inst_basereg, ins->inst_offset); + code = emit_strfpw (code, ainfo->reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; case ArgOnStack: case ArgOnStackR4: @@ -5667,29 +5667,29 @@ emit_move_args (MonoCompile *cfg, guint8 *code) if (ainfo->gsharedvt) { g_assert (ins->opcode == OP_GSHAREDVT_ARG_REGOFFSET); - arm_strx (code, ainfo->reg, ins->inst_basereg, ins->inst_offset); + arm_strx (code, ainfo->reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); } else { g_assert (ins->opcode == OP_VTARG_ADDR); g_assert (addr_arg->opcode == OP_REGOFFSET); - arm_strx (code, ainfo->reg, addr_arg->inst_basereg, addr_arg->inst_offset); + arm_strx (code, ainfo->reg, addr_arg->inst_basereg, GTMREG_TO_INT (addr_arg->inst_offset)); } break; } case ArgVtypeInIRegs: for (part = 0; part < ainfo->nregs; part ++) { - code = emit_strx (code, ainfo->reg + part, ins->inst_basereg, ins->inst_offset + (part * 8)); + code = emit_strx (code, ainfo->reg + part, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + (part * 8))); } break; case ArgHFA: for (part = 0; part < ainfo->nregs; part ++) { if (ainfo->esize == 4) - code = emit_strfpw (code, ainfo->reg + part, ins->inst_basereg, ins->inst_offset + ainfo->foffsets [part]); + code = emit_strfpw (code, ainfo->reg + part, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + ainfo->foffsets [part])); else - code = emit_strfpx (code, ainfo->reg + part, ins->inst_basereg, ins->inst_offset + ainfo->foffsets [part]); + code = emit_strfpx (code, ainfo->reg + part, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + ainfo->foffsets [part])); } break; case ArgInSIMDReg: - code = emit_strfpq (code, ainfo->reg, ins->inst_basereg, ins->inst_offset); + code = emit_strfpq (code, ainfo->reg, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); break; default: g_assert_not_reached (); @@ -5842,7 +5842,7 @@ static WARN_UNUSED_RESULT guint8* emit_store_regset_cfa (MonoCompile *cfg, guint8 *code, guint64 regs, int basereg, int offset, int cfa_offset, guint64 no_cfa_regset) { int i, j, pos, nregs; - guint32 cfa_regset = regs & ~no_cfa_regset; + guint32 cfa_regset = GUINT64_TO_UINT32 (regs & ~no_cfa_regset); pos = 0; for (i = 0; i < 32; ++i) { @@ -5948,7 +5948,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } if (cfg->method->save_lmf) { - code = emit_setup_lmf (cfg, code, cfg->lmf_var->inst_offset, cfa_offset); + code = emit_setup_lmf (cfg, code, GTMREG_TO_INT32 (cfg->lmf_var->inst_offset), cfa_offset); } else { /* Save gregs */ code = emit_store_regset_cfa (cfg, code, MONO_ARCH_CALLEE_SAVED_REGS & cfg->used_int_regs, ARMREG_FP, cfg->arch.saved_gregs_offset, cfa_offset, 0); @@ -5965,7 +5965,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) MonoInst *ins = cfg->vret_addr; g_assert (ins->opcode == OP_REGOFFSET); - code = emit_strx (code, ARMREG_R8, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ARMREG_R8, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); } /* Save mrgctx received in MONO_ARCH_RGCTX_REG */ @@ -5974,10 +5974,10 @@ mono_arch_emit_prolog (MonoCompile *cfg) g_assert (ins->opcode == OP_REGOFFSET); - code = emit_strx (code, MONO_ARCH_RGCTX_REG, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, MONO_ARCH_RGCTX_REG, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); - mono_add_var_location (cfg, cfg->rgctx_var, TRUE, MONO_ARCH_RGCTX_REG, 0, 0, code - cfg->native_code); - mono_add_var_location (cfg, cfg->rgctx_var, FALSE, ins->inst_basereg, ins->inst_offset, code - cfg->native_code, 0); + mono_add_var_location (cfg, cfg->rgctx_var, TRUE, MONO_ARCH_RGCTX_REG, 0, 0, GPTRDIFF_TO_INT (code - cfg->native_code)); + mono_add_var_location (cfg, cfg->rgctx_var, FALSE, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset), GPTRDIFF_TO_INT (code - cfg->native_code), 0); } /* @@ -5992,14 +5992,14 @@ mono_arch_emit_prolog (MonoCompile *cfg) /* Initialize the variable from a GOT slot */ code = emit_aotconst (cfg, code, ARMREG_IP0, MONO_PATCH_INFO_SEQ_POINT_INFO, cfg->method); g_assert (ins->opcode == OP_REGOFFSET); - code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); /* Initialize ss_tramp_var */ ins = cfg->arch.ss_tramp_var; g_assert (ins->opcode == OP_REGOFFSET); code = emit_ldrx (code, ARMREG_IP1, ARMREG_IP0, MONO_STRUCT_OFFSET (SeqPointInfo, ss_tramp_addr)); - code = emit_strx (code, ARMREG_IP1, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ARMREG_IP1, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); } else { MonoInst *ins; @@ -6009,7 +6009,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) g_assert (ins->opcode == OP_REGOFFSET); code = emit_imm64 (code, ARMREG_IP0, (guint64)&ss_trampoline); - code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); } if (cfg->arch.bp_tramp_var) { @@ -6018,7 +6018,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) g_assert (ins->opcode == OP_REGOFFSET); code = emit_imm64 (code, ARMREG_IP0, (guint64)bp_trampoline); - code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, ins->inst_offset); + code = emit_strx (code, ARMREG_IP0, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset)); } } @@ -6051,7 +6051,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) code = realloc_code (cfg, max_epilog_size); if (cfg->method->save_lmf) { - code = mono_arm_emit_load_regarray (code, MONO_ARCH_CALLEE_SAVED_REGS & cfg->used_int_regs, ARMREG_FP, cfg->lmf_var->inst_offset + MONO_STRUCT_OFFSET (MonoLMF, gregs) - (MONO_ARCH_FIRST_LMF_REG * 8)); + code = mono_arm_emit_load_regarray (code, MONO_ARCH_CALLEE_SAVED_REGS & cfg->used_int_regs, ARMREG_FP, GTMREG_TO_INT (cfg->lmf_var->inst_offset + MONO_STRUCT_OFFSET (MonoLMF, gregs) - (MONO_ARCH_FIRST_LMF_REG * 8))); } else { /* Restore gregs */ code = emit_load_regset (code, MONO_ARCH_CALLEE_SAVED_REGS & cfg->used_int_regs, ARMREG_FP, cfg->arch.saved_gregs_offset); @@ -6064,7 +6064,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) MonoInst *ins = cfg->ret; for (i = 0; i < cinfo->ret.nregs; ++i) - code = emit_ldrx (code, cinfo->ret.reg + i, ins->inst_basereg, ins->inst_offset + (i * 8)); + code = emit_ldrx (code, cinfo->ret.reg + i, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + (i * 8))); break; } case ArgHFA: { @@ -6072,9 +6072,9 @@ mono_arch_emit_epilog (MonoCompile *cfg) for (i = 0; i < cinfo->ret.nregs; ++i) { if (cinfo->ret.esize == 4) - code = emit_ldrfpw (code, cinfo->ret.reg + i, ins->inst_basereg, ins->inst_offset + cinfo->ret.foffsets [i]); + code = emit_ldrfpw (code, cinfo->ret.reg + i, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + cinfo->ret.foffsets [i])); else - code = emit_ldrfpx (code, cinfo->ret.reg + i, ins->inst_basereg, ins->inst_offset + cinfo->ret.foffsets [i]); + code = emit_ldrfpx (code, cinfo->ret.reg + i, ins->inst_basereg, GTMREG_TO_INT (ins->inst_offset + cinfo->ret.foffsets [i])); } break; } @@ -6151,7 +6151,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg) /* r1 = throw ip */ arm_movx (code, ARMREG_R1, ARMREG_IP1); /* Branch to the corlib exception throwing trampoline */ - ji->ip.i = code - cfg->native_code; + ji->ip.i = GPTRDIFF_TO_INT (code - cfg->native_code); ji->type = MONO_PATCH_INFO_JIT_ICALL_ID; ji->data.jit_icall_id = MONO_JIT_ICALL_mono_arch_throw_corlib_exception; ji->relocation = MONO_R_ARM64_BL; @@ -6326,7 +6326,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoIMTCheckItem **imt_entri g_assert ((code - buf) <= buf_len); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL); return MINI_ADDR_TO_FTNPTR (buf); } @@ -6355,7 +6355,7 @@ void mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip) { guint8 *code = MINI_FTNPTR_TO_ADDR (ip); - guint32 native_offset = ip - (guint8*)ji->code_start; + guint32 native_offset = GPTRDIFF_TO_UINT32 (ip - (guint8*)ji->code_start); if (ji->from_aot) { SeqPointInfo *info = mono_arch_get_seq_point_info ((guint8*)ji->code_start); @@ -6371,7 +6371,7 @@ mono_arch_set_breakpoint (MonoJitInfo *ji, guint8 *ip) mono_codeman_enable_write (); code = mono_arm_emit_blrx (code, ARMREG_IP0); mono_codeman_disable_write (); - mono_arch_flush_icache (ip, code - ip); + mono_arch_flush_icache (ip, GPTRDIFF_TO_INT (code - ip)); } } @@ -6381,7 +6381,7 @@ mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip) guint8 *code = MINI_FTNPTR_TO_ADDR (ip); if (ji->from_aot) { - guint32 native_offset = ip - (guint8*)ji->code_start; + guint32 native_offset = GPTRDIFF_TO_UINT32 (ip - (guint8*)ji->code_start); SeqPointInfo *info = mono_arch_get_seq_point_info ((guint8*)ji->code_start); if (enable_ptrauth) @@ -6395,7 +6395,7 @@ mono_arch_clear_breakpoint (MonoJitInfo *ji, guint8 *ip) mono_codeman_enable_write (); arm_nop (code); mono_codeman_disable_write (); - mono_arch_flush_icache (ip, code - ip); + mono_arch_flush_icache (ip,GPTRDIFF_TO_INT ( code - ip)); } } diff --git a/src/mono/mono/mini/mini-llvm-cpp.cpp b/src/mono/mono/mini/mini-llvm-cpp.cpp index 453ba959e06200..ce5473be3a7ed6 100644 --- a/src/mono/mono/mini/mini-llvm-cpp.cpp +++ b/src/mono/mono/mini/mini-llvm-cpp.cpp @@ -779,7 +779,7 @@ mono_llvm_register_overloaded_intrinsic (LLVMModuleRef module, IntrinsicId id, L unsigned int mono_llvm_get_prim_size_bits (LLVMTypeRef type) { - return unwrap (type)->getPrimitiveSizeInBits (); + return GUINT64_TO_INT (unwrap (type)->getPrimitiveSizeInBits ()); } /* diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index a6c23aa59b67a2..bbd8b38da1c4ef 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -4537,7 +4537,7 @@ process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, LLVMValueRef index; g_assert (ins->inst_offset % size == 0); - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); LLVMTypeRef etype = pointer_type (llvm_sig); callee = LLVMBuildLoad2 (builder, etype, LLVMBuildGEP2 (builder, etype, convert (ctx, values [ins->inst_basereg], pointer_type (etype)), &index, 1, ""), ""); @@ -5866,7 +5866,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) case OP_TAILCALL_PARAMETER: break; case OP_ICONST: - values [ins->dreg] = const_int32 (ins->inst_c0); + values [ins->dreg] = const_int32 (GTMREG_TO_INT (ins->inst_c0)); break; case OP_I8CONST: #if TARGET_SIZEOF_VOID_P == 4 @@ -6093,7 +6093,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) if (ins->opcode == OP_ICOMPARE_IMM) { lhs = convert (ctx, lhs, LLVMInt32Type ()); - rhs = const_int32 (ins->inst_imm); + rhs = const_int32 (GTMREG_TO_INT (ins->inst_imm)); } if (ins->opcode == OP_LCOMPARE_IMM) { lhs = convert (ctx, lhs, LLVMInt64Type ()); @@ -6466,7 +6466,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) if (spec [MONO_INST_SRC1] == 'l') { imm = const_int64 (GET_LONG_IMM (ins)); } else { - imm = const_int32 (ins->inst_imm); + imm = const_int32 (GTMREG_TO_INT (ins->inst_imm)); } emit_div_check (ctx, builder, bb, ins, lhs, imm); @@ -6476,7 +6476,7 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) #if TARGET_SIZEOF_VOID_P == 4 if (shift_i8) - imm = const_int32 (ins->inst_imm); + imm = const_int32 (GTMREG_TO_INT (ins->inst_imm)); #endif if (shift_i8) /* The IL might not be regular */ @@ -6741,7 +6741,7 @@ MONO_RESTORE_WARNING case OP_LOCALLOC_IMM: { LLVMValueRef v; - guint32 size = ins->inst_imm; + guint32 size = GTMREG_TO_UINT32 (ins->inst_imm); size = (size + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1); v = mono_llvm_build_alloca (builder, LLVMInt8Type (), const_int32 (size), MONO_ARCH_FRAME_ALIGNMENT, ""); @@ -6810,10 +6810,10 @@ MONO_RESTORE_WARNING } } else if (ins->inst_offset % size != 0) { /* Unaligned load */ - index = const_int32 (ins->inst_offset); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset)); addr = LLVMBuildGEP2 (builder, i1_t, convert (ctx, base, pointer_type (LLVMInt8Type ())), &index, 1, ""); } else { - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); addr = LLVMBuildGEP2 (builder, t, convert (ctx, base, pointer_type (t)), &index, 1, ""); } } @@ -6867,10 +6867,10 @@ MONO_RESTORE_WARNING addr = LLVMBuildGEP2 (builder, i1_t, convert (ctx, gep_base, pointer_type (LLVMInt8Type ())), &gep_offset, 1, ""); } else if (ins->inst_offset % size != 0) { /* Unaligned store */ - index = const_int32 (ins->inst_offset); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset)); addr = LLVMBuildGEP2 (builder, i1_t, convert (ctx, base, pointer_type (LLVMInt8Type ())), &index, 1, ""); } else { - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); addr = LLVMBuildGEP2 (builder, t, convert (ctx, base, pointer_type (t)), &index, 1, ""); } if (is_volatile && LLVMGetInstructionOpcode (base) == LLVMAlloca && !(ins->flags & MONO_INST_VOLATILE)) @@ -6906,10 +6906,10 @@ MONO_RESTORE_WARNING addr = LLVMBuildGEP2 (builder, i1_t, convert (ctx, gep_base, pointer_type (LLVMInt8Type ())), &gep_offset, 1, ""); } else if (ins->inst_offset % size != 0) { /* Unaligned store */ - index = const_int32 (ins->inst_offset); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset)); addr = LLVMBuildGEP2 (builder, i1_t, convert (ctx, base, pointer_type (LLVMInt8Type ())), &index, 1, ""); } else { - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); addr = LLVMBuildGEP2 (builder, t, convert (ctx, base, pointer_type (t)), &index, 1, ""); } LLVMValueRef srcval = convert (ctx, LLVMConstInt (IntPtrType (), ins->inst_imm, FALSE), t); @@ -7377,7 +7377,7 @@ MONO_RESTORE_WARNING dname = (char *)""; if (ins->inst_offset != 0) { - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); addr = LLVMBuildGEP2 (builder, t, convert (ctx, lhs, pointer_type (t)), &index, 1, ""); } else { addr = lhs; @@ -7419,7 +7419,7 @@ MONO_RESTORE_WARNING t = load_store_to_llvm_type (ins->opcode, &size, &sext, &zext); base = values [ins->inst_destbasereg]; - index = const_int32 (ins->inst_offset / size); + index = const_int32 (GTMREG_TO_INT (ins->inst_offset / size)); addr = LLVMBuildGEP2 (builder, t, convert (ctx, base, pointer_type (t)), &index, 1, ""); value = convert (ctx, values [ins->sreg1], t); @@ -7946,7 +7946,7 @@ MONO_RESTORE_WARNING element_ix = rhs; break; default: - element_ix = const_int32 (ins->inst_c0); + element_ix = const_int32 (GTMREG_TO_INT (ins->inst_c0)); } #ifdef TARGET_WASM @@ -8296,22 +8296,22 @@ MONO_RESTORE_WARNING break; } case OP_INSERT_I1: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt8Type ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_INSERT_I2: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt16Type ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_INSERT_I4: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt32Type ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_INSERT_I8: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMInt64Type ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_INSERT_R4: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMFloatType ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_INSERT_R8: - values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), const_int32 (ins->inst_c0), dname); + values [ins->dreg] = LLVMBuildInsertElement (builder, values [ins->sreg1], convert (ctx, values [ins->sreg2], LLVMDoubleType ()), const_int32 (GTMREG_TO_INT (ins->inst_c0)), dname); break; case OP_XCAST: { LLVMTypeRef t = simd_class_to_llvm_type (ctx, ins->klass); @@ -8366,7 +8366,7 @@ MONO_RESTORE_WARNING #if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_WASM) case OP_SIMD_STORE: { LLVMValueRef dst_vec = convert (ctx, lhs, pointer_type (LLVMTypeOf (rhs))); - mono_llvm_build_aligned_store (builder, rhs, dst_vec, FALSE, ins->inst_c0); + mono_llvm_build_aligned_store (builder, rhs, dst_vec, FALSE, GTMREG_TO_INT (ins->inst_c0)); break; } case OP_PADDB: @@ -8639,7 +8639,7 @@ MONO_RESTORE_WARNING int mask [16]; LLVMValueRef v1 = NULL, v2 = NULL, mask_values [16]; int i, mask_size = 0; - int imask = ins->inst_c0; + int imask = GTMREG_TO_INT (ins->inst_c0); /* Convert the x86 shuffle mask to LLVM's */ switch (ins->opcode) { @@ -8916,14 +8916,14 @@ MONO_RESTORE_WARNING convert (ctx, lhs, sse_i2_t), convert (ctx, rhs, sse_i2_t), create_const_vector_i32 (mask_values, 8), ""); - values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (ins->inst_c1)); + values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); } else if (ins->inst_c1 == MONO_TYPE_I1 || ins->inst_c1 == MONO_TYPE_U1) { const int mask_values [] = { 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23 }; LLVMValueRef shuffled = LLVMBuildShuffleVector (builder, convert (ctx, lhs, sse_i1_t), convert (ctx, rhs, sse_i1_t), create_const_vector_i32 (mask_values, 16), ""); - values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (ins->inst_c1)); + values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); } else { g_assert_not_reached (); } @@ -8941,14 +8941,14 @@ MONO_RESTORE_WARNING convert (ctx, lhs, sse_i2_t), convert (ctx, rhs, sse_i2_t), create_const_vector_i32 (mask_values, 8), ""); - values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (ins->inst_c1)); + values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); } else if (ins->inst_c1 == MONO_TYPE_I1 || ins->inst_c1 == MONO_TYPE_U1) { const int mask_values [] = { 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31 }; LLVMValueRef shuffled = LLVMBuildShuffleVector (builder, convert (ctx, lhs, sse_i1_t), convert (ctx, rhs, sse_i1_t), create_const_vector_i32 (mask_values, 16), ""); - values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (ins->inst_c1)); + values [ins->dreg] = convert (ctx, shuffled, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); } else { g_assert_not_reached (); } @@ -8957,15 +8957,15 @@ MONO_RESTORE_WARNING case OP_SSE_LOADU: { LLVMValueRef dst_ptr = convert (ctx, lhs, pointer_type (primitive_type_to_llvm_type (inst_c1_type (ins)))); - LLVMTypeRef etype = type_to_sse_type (ins->inst_c1); + LLVMTypeRef etype = type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)); LLVMValueRef dst_vec = LLVMBuildBitCast (builder, dst_ptr, pointer_type (etype), ""); - values [ins->dreg] = mono_llvm_build_aligned_load (builder, etype, dst_vec, "", FALSE, ins->inst_c0); // inst_c0 is alignment + values [ins->dreg] = mono_llvm_build_aligned_load (builder, etype, dst_vec, "", FALSE, GTMREG_TO_INT (ins->inst_c0)); // inst_c0 is alignment break; } case OP_SSE_MOVSS: { LLVMValueRef addr = convert (ctx, lhs, pointer_type (LLVMFloatType ())); LLVMValueRef val = LLVMBuildLoad2 (builder, LLVMFloatType (), addr, ""); - values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (type_to_sse_type (ins->inst_c1)), val, const_int32 (0), ""); + values [ins->dreg] = LLVMBuildInsertElement (builder, LLVMConstNull (type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))), val, const_int32 (0), ""); break; } case OP_SSE_MOVSS_STORE: { @@ -9037,7 +9037,7 @@ MONO_RESTORE_WARNING } case OP_SSE_MOVNTPS: { LLVMValueRef addr = convert (ctx, lhs, pointer_type (LLVMTypeOf (rhs))); - LLVMValueRef store = mono_llvm_build_aligned_store (builder, rhs, addr, FALSE, ins->inst_c0); + LLVMValueRef store = mono_llvm_build_aligned_store (builder, rhs, addr, FALSE, GTMREG_TO_INT (ins->inst_c0)); set_nontemporal_flag (store); break; } @@ -9070,7 +9070,7 @@ MONO_RESTORE_WARNING LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, sse_i8_t); LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, sse_i8_t); LLVMValueRef vec_and = LLVMBuildOr (builder, vec_lhs_i64, vec_rhs_i64, ""); - values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (ins->inst_c1), ""); + values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)), ""); break; } @@ -9078,7 +9078,7 @@ MONO_RESTORE_WARNING LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, sse_i8_t); LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, sse_i8_t); LLVMValueRef vec_and = LLVMBuildXor (builder, vec_lhs_i64, vec_rhs_i64, ""); - values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (ins->inst_c1), ""); + values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)), ""); break; } @@ -9086,7 +9086,7 @@ MONO_RESTORE_WARNING LLVMValueRef vec_lhs_i64 = convert (ctx, lhs, sse_i8_t); LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, sse_i8_t); LLVMValueRef vec_and = LLVMBuildAnd (builder, vec_lhs_i64, vec_rhs_i64, ""); - values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (ins->inst_c1), ""); + values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)), ""); break; } @@ -9339,8 +9339,8 @@ MONO_RESTORE_WARNING case OP_PADDW_SAT_UN: type = MONO_TYPE_U2; break; case OP_PSUBB_SAT_UN: type = MONO_TYPE_U1; is_add = FALSE; break; case OP_PSUBW_SAT_UN: type = MONO_TYPE_U2; is_add = FALSE; break; - case OP_SSE2_ADDS: type = ins->inst_c1; break; - case OP_SSE2_SUBS: type = ins->inst_c1; is_add = FALSE; break; + case OP_SSE2_ADDS: type = GTMREG_TO_INT (ins->inst_c1); break; + case OP_SSE2_SUBS: type = GTMREG_TO_INT (ins->inst_c1); is_add = FALSE; break; default: g_assert_not_reached (); } if (is_add) { @@ -9373,7 +9373,7 @@ MONO_RESTORE_WARNING args [1] = convert (ctx, rhs, sse_i2_t); values [ins->dreg] = convert (ctx, call_intrins (ctx, INTRINS_SSE_PACKUSWB, args, dname), - type_to_sse_type (ins->inst_c1)); + type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); break; } @@ -9381,7 +9381,7 @@ MONO_RESTORE_WARNING LLVMValueRef args [] = { lhs, rhs }; values [ins->dreg] = convert (ctx, call_intrins (ctx, INTRINS_SSE_PSRLI_W, args, dname), - type_to_sse_type (ins->inst_c1)); + type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); break; } @@ -9435,7 +9435,7 @@ MONO_RESTORE_WARNING LLVMPositionBuilderAtEnd (builder, cbb); values [ins->dreg] = LLVMBuildPhi (builder, LLVMTypeOf (phi_values [0]), ""); LLVMAddIncoming (values [ins->dreg], phi_values, bbs, nelems + 1); - values [ins->dreg] = convert (ctx, values [ins->dreg], type_to_sse_type (ins->inst_c1)); + values [ins->dreg] = convert (ctx, values [ins->dreg], type_to_sse_type (GTMREG_TO_INT (ins->inst_c1))); ctx->bblocks [bb->block_num].end_bblock = cbb; break; @@ -9626,7 +9626,7 @@ MONO_RESTORE_WARNING } case OP_SSE41_ROUNDP: { - LLVMValueRef args [] = { lhs, const_int32 (ins->inst_c0) }; + LLVMValueRef args [] = { lhs, const_int32 (GTMREG_TO_INT (ins->inst_c0)) }; values [ins->dreg] = call_intrins (ctx, ins->inst_c1 == MONO_TYPE_R4 ? INTRINS_SSE_ROUNDPS : INTRINS_SSE_ROUNDPD, args, dname); break; } @@ -9634,7 +9634,7 @@ MONO_RESTORE_WARNING LLVMValueRef args [3]; args [0] = lhs; args [1] = rhs; - args [2] = const_int32 (ins->inst_c0); + args [2] = const_int32 (GTMREG_TO_INT (ins->inst_c0)); values [ins->dreg] = call_intrins (ctx, ins->inst_c1 == MONO_TYPE_R4 ? INTRINS_SSE_ROUNDSS : INTRINS_SSE_ROUNDSD, args, dname); break; } @@ -9815,7 +9815,7 @@ MONO_RESTORE_WARNING case OP_SSE41_LOADANT: { LLVMValueRef dst_ptr = convert (ctx, lhs, pointer_type (primitive_type_to_llvm_type (inst_c1_type (ins)))); - LLVMTypeRef etype = type_to_sse_type (ins->inst_c1); + LLVMTypeRef etype = type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)); LLVMValueRef dst_vec = LLVMBuildBitCast (builder, dst_ptr, pointer_type (etype), ""); LLVMValueRef load = mono_llvm_build_aligned_load (builder, etype, dst_vec, "", FALSE, 16); set_nontemporal_flag (load); @@ -9905,7 +9905,7 @@ MONO_RESTORE_WARNING LLVMValueRef vec_xor = LLVMBuildXor (builder, vec_lhs_i64, LLVMConstVector (minus_one, 2), ""); LLVMValueRef vec_rhs_i64 = convert (ctx, rhs, sse_i8_t); LLVMValueRef vec_and = LLVMBuildAnd (builder, vec_rhs_i64, vec_xor, ""); - values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (ins->inst_c1), ""); + values [ins->dreg] = LLVMBuildBitCast (builder, vec_and, type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)), ""); break; } @@ -9913,7 +9913,7 @@ MONO_RESTORE_WARNING // %sub = sub <16 x i8> zeroinitializer, %arg // %cmp = icmp sgt <16 x i8> %arg, zeroinitializer // %abs = select <16 x i1> %cmp, <16 x i8> %arg, <16 x i8> %sub - LLVMTypeRef typ = type_to_sse_type (ins->inst_c1); + LLVMTypeRef typ = type_to_sse_type (GTMREG_TO_INT (ins->inst_c1)); LLVMValueRef sub = LLVMBuildSub(builder, LLVMConstNull(typ), lhs, ""); LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntSGT, lhs, LLVMConstNull(typ), ""); LLVMValueRef abs = LLVMBuildSelect (builder, cmp, lhs, sub, ""); @@ -10469,7 +10469,7 @@ MONO_RESTORE_WARNING case INTRINS_AARCH64_PMULL64: getElement = TRUE; bitcast_result = TRUE; - element_idx = ins->inst_c1; + element_idx = GTMREG_TO_INT (ins->inst_c1); break; case INTRINS_AARCH64_CRC32B: case INTRINS_AARCH64_CRC32H: @@ -10742,7 +10742,7 @@ MONO_RESTORE_WARNING llvm_ovr_tag_t ovr_tag = ovr_tag_from_llvm_type (ret_t); LLVMTypeRef elem_t = LLVMGetElementType (ret_t); LLVMValueRef result = NULL; - int iid = ins->inst_c0; + int iid = GTMREG_TO_INT (ins->inst_c0); int scalar_iid = 0; switch (iid) { case INTRINS_AARCH64_ADV_SIMD_SQXTUN: scalar_iid = INTRINS_AARCH64_ADV_SIMD_SCALAR_SQXTUN; break; @@ -11106,7 +11106,7 @@ MONO_RESTORE_WARNING LLVMTypeRef elem_t = LLVMGetElementType (t); unsigned int group_bits = mono_llvm_get_prim_size_bits (elem_t); unsigned int vec_bits = mono_llvm_get_prim_size_bits (t); - unsigned int tmp_bits = ins->inst_c0; + unsigned int tmp_bits = GTMREG_TO_UINT (ins->inst_c0); unsigned int tmp_elements = vec_bits / tmp_bits; const int cycle8 [] = { 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8 }; const int cycle4 [] = { 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12 }; @@ -11190,7 +11190,7 @@ MONO_RESTORE_WARNING LLVMValueRef shift_amount = rhs; gboolean high = FALSE; gboolean scalar = FALSE; - int iid = ins->inst_c0; + int iid = GTMREG_TO_INT (ins->inst_c0); switch (ins->opcode) { case OP_ARM64_XNSHIFT_SCALAR: scalar = TRUE; break; case OP_ARM64_XNSHIFT2: high = TRUE; break; @@ -11559,7 +11559,7 @@ MONO_RESTORE_WARNING llvm_ovr_tag_t ovr_tag = ovr_tag_from_llvm_type (arg_t); if (elem_t == i1_t || elem_t == i2_t) truncate = TRUE; - LLVMValueRef result = call_overloaded_intrins (ctx, ins->inst_c0, ovr_tag, &lhs, ""); + LLVMValueRef result = call_overloaded_intrins (ctx, GTMREG_TO_INT (ins->inst_c0), ovr_tag, &lhs, ""); if (truncate) { // @llvm.aarch64.neon.saddv.i32.v8i16 ought to return an i16, but doesn't in LLVM 9. result = LLVMBuildTrunc (builder, result, elem_t, ""); @@ -11692,7 +11692,7 @@ MONO_RESTORE_WARNING } case OP_ARM64_ABSCOMPARE: { IntrinsicId iid = (IntrinsicId) ins->inst_c0; - gboolean scalar = ins->inst_c1; + gboolean scalar = ins->inst_c1 != 0; LLVMTypeRef ret_t = simd_class_to_llvm_type (ctx, ins->klass); LLVMTypeRef elem_t = LLVMGetElementType (ret_t); llvm_ovr_tag_t ovr_tag = ovr_tag_from_mono_vector_class (ins->klass); @@ -11714,7 +11714,7 @@ MONO_RESTORE_WARNING } case OP_ARM64_TBL_INDIRECT: case OP_ARM64_TBX_INDIRECT: { - int nvectors = ins->inst_c0; + int nvectors = GTMREG_TO_INT (ins->inst_c0); guint32 *offsets = (guint32*)ins->inst_p1; LLVMValueRef args [16]; @@ -14387,7 +14387,7 @@ emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil MonoDebugSourceLocation *loc; LLVMValueRef loc_md; - loc = mono_debug_method_lookup_location (ctx->minfo, cil_code - cfg->header->code); + loc = mono_debug_method_lookup_location (ctx->minfo, GPTRDIFF_TO_INT (cil_code - cfg->header->code)); if (loc) { loc_md = (LLVMValueRef)mono_llvm_di_create_location (ctx->module->di_builder, ctx->dbg_md, loc->row, loc->column); diff --git a/src/mono/mono/mini/mini-x86.c b/src/mono/mono/mini/mini-x86.c index 65dea3f7086198..d71ae67fa9d92f 100644 --- a/src/mono/mono/mini/mini-x86.c +++ b/src/mono/mono/mini/mini-x86.c @@ -951,22 +951,22 @@ mono_arch_is_int_overflow (void *sigctx, void *info) /* idiv REG */ switch (x86_modrm_rm (ip [1])) { case X86_EAX: - reg = ctx.eax; + reg = GHMREG_TO_INT32 (ctx.eax); break; case X86_ECX: - reg = ctx.ecx; + reg = GHMREG_TO_INT32 (ctx.ecx); break; case X86_EDX: - reg = ctx.edx; + reg = GHMREG_TO_INT32 (ctx.edx); break; case X86_EBX: - reg = ctx.ebx; + reg = GHMREG_TO_INT32 (ctx.ebx); break; case X86_ESI: - reg = ctx.esi; + reg = GHMREG_TO_INT32 (ctx.esi); break; case X86_EDI: - reg = ctx.edi; + reg = GHMREG_TO_INT32 (ctx.edi); break; default: g_assert_not_reached (); @@ -1828,7 +1828,7 @@ mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) if (ins->inst_true_bb->native_offset) { \ x86_branch (code, cond, cfg->native_code + ins->inst_true_bb->native_offset, sign); \ } else { \ - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_true_bb); \ + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, ins->inst_true_bb); \ if ((cfg->opt & MONO_OPT_BRANCH) && x86_is_imm8 (ins->inst_true_bb->max_offset - cpos)) \ x86_branch8 (code, cond, 0, sign); \ else \ @@ -1843,7 +1843,7 @@ if (ins->inst_true_bb->native_offset) { \ do { \ MonoInst *tins = mono_branch_optimize_exception_target (cfg, bb, exc_name); \ if (tins == NULL) { \ - mono_add_patch_info (cfg, code - cfg->native_code, \ + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), \ MONO_PATCH_INFO_EXC, exc_name); \ x86_branch32 (code, cond, 0, signed); \ } else { \ @@ -1879,7 +1879,7 @@ x86_align_and_patch (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstp if (needs_paddings && pad_size) x86_padding (code, 4 - pad_size); - mono_add_patch_info (cfg, code - cfg->native_code, (MonoJumpInfoType)patch_type, data); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), (MonoJumpInfoType)patch_type, data); return code; } @@ -1909,7 +1909,7 @@ emit_r8const (MonoCompile *cfg, guint8* code, int dreg, double *p) x86_sse_movsd_reg_membase (code, dreg, X86_ESP, 0); x86_alu_reg_imm (code, X86_ADD, X86_ESP, 8); } else { - mono_add_patch_info (cfg, code - cfg->native_code + X86_SSE_REG_MEM_OFFSET, MONO_PATCH_INFO_R8, p); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code + X86_SSE_REG_MEM_OFFSET), MONO_PATCH_INFO_R8, p); x86_sse_movsd_reg_mem (code, dreg, (gsize)NULL); } } @@ -1930,7 +1930,7 @@ emit_r4const (MonoCompile *cfg, guint8* code, int dreg, float *p) x86_sse_movss_reg_membase (code, dreg, X86_ESP, 0); x86_alu_reg_imm (code, X86_ADD, X86_ESP, 4); } else { - mono_add_patch_info (cfg, code - cfg->native_code + X86_SSE_REG_MEM_OFFSET, MONO_PATCH_INFO_R4, p); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code + X86_SSE_REG_MEM_OFFSET), MONO_PATCH_INFO_R4, p); x86_sse_movss_reg_mem (code, dreg, (gsize)NULL); } } @@ -2437,7 +2437,7 @@ emit_setup_lmf (MonoCompile *cfg, guint8 *code, gint32 lmf_offset, int cfa_offse x86_call_imm (code, 0); x86_pop_reg (code, X86_EAX); } else { - mono_add_patch_info (cfg, code + 1 - cfg->native_code, MONO_PATCH_INFO_IP, NULL); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code + 1 - cfg->native_code), MONO_PATCH_INFO_IP, NULL); x86_mov_reg_imm (code, X86_EAX, 0); } x86_mov_membase_reg (code, cfg->frame_reg, lmf_offset + MONO_STRUCT_OFFSET (MonoLMF, eip), X86_EAX, sizeof (target_mgreg_t)); @@ -2509,13 +2509,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) set_code_cursor (cfg, code); - mono_debug_open_block (cfg, bb, code - cfg->native_code); + mono_debug_open_block (cfg, bb, GPTRDIFF_TO_UINT32 (code - cfg->native_code)); if (mono_break_at_bb_method && mono_method_desc_full_match (mono_break_at_bb_method, cfg->method) && bb->block_num == mono_break_at_bb_bb_num) x86_breakpoint (code); MONO_BB_FOR_EACH_INS (bb, ins) { - const guint offset = code - cfg->native_code; + const guint offset = GPTRDIFF_TO_UINT (code - cfg->native_code); set_code_cursor (cfg, code); int max_len = ins_get_size (ins->opcode); code = realloc_code (cfg, max_len); @@ -2705,7 +2705,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_NOT_NULL: break; case OP_IL_SEQ_POINT: - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); break; case OP_SEQ_POINT: { int i; @@ -2740,7 +2740,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) * This means we have to put the loading of bp_tramp_var after the offset. */ - mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); + mono_add_seq_point (cfg, bb, ins, GPTRDIFF_TO_INT (code - cfg->native_code)); MonoInst *var = cfg->arch.bp_tramp_var; @@ -2751,7 +2751,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) guint8 *start = code; x86_mov_reg_membase (code, X86_ECX, var->inst_basereg, var->inst_offset, 4); if (code < start + OP_SEQ_POINT_BP_OFFSET) { - int size = start + OP_SEQ_POINT_BP_OFFSET - code; + int size = GPTRDIFF_TO_INT (start + OP_SEQ_POINT_BP_OFFSET - code); x86_padding (code, size); } /* @@ -3155,7 +3155,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = realloc_code (cfg, max_len); ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); g_assert (!cfg->method->save_lmf); @@ -3292,7 +3292,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); if (cinfo->callee_stack_pop) { /* Have to compensate for the stack space popped by the callee */ x86_alu_reg_imm (code, X86_SUB, X86_ESP, cinfo->callee_stack_pop); @@ -3343,7 +3343,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = emit_call (cfg, code, MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arch_throw_exception)); ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); break; } case OP_RETHROW: { @@ -3352,12 +3352,12 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) code = emit_call (cfg, code, MONO_PATCH_INFO_JIT_ICALL_ID, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arch_rethrow_exception)); ins->flags |= MONO_INST_GC_CALLSITE; - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); break; } case OP_CALL_HANDLER: x86_alu_reg_imm (code, X86_SUB, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - 4); - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, ins->inst_target_bb); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, ins->inst_target_bb); x86_call_imm (code, 0); for (GList *tmp = ins->inst_eh_blocks; tmp != bb->clause_holes; tmp = tmp->prev) mono_cfg_add_try_hole (cfg, ((MonoLeaveClause *) tmp->data)->clause, code, bb); @@ -3388,7 +3388,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; case OP_LABEL: - ins->inst_c0 = code - cfg->native_code; + ins->inst_c0 = GPTRDIFF_TO_TMREG (code - cfg->native_code); break; case OP_BR: if (ins->inst_target_bb->native_offset) { @@ -3676,13 +3676,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) /* throw exception */ tins = mono_branch_optimize_exception_target (cfg, bb, "OverflowException"); if (tins) { - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_BB, tins->inst_true_bb); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_BB, tins->inst_true_bb); if ((cfg->opt & MONO_OPT_BRANCH) && x86_is_imm8 (tins->inst_true_bb->max_offset - cpos)) x86_jump8 (code, 0); else x86_jump32 (code, 0); } else { - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC, "OverflowException"); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_EXC, "OverflowException"); x86_jump32 (code, 0); } @@ -4848,13 +4848,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_LIVERANGE_START: { if (cfg->verbose_level > 1) printf ("R%d START=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = code - cfg->native_code; + MONO_VARINFO (cfg, ins->inst_c0)->live_range_start = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_LIVERANGE_END: { if (cfg->verbose_level > 1) printf ("R%d END=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code)); - MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = code - cfg->native_code; + MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = GPTRDIFF_TO_INT32 (code - cfg->native_code); break; } case OP_GC_SAFE_POINT: { @@ -4870,10 +4870,10 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) case OP_GC_LIVENESS_DEF: case OP_GC_LIVENESS_USE: case OP_GC_PARAM_SLOT_LIVENESS_DEF: - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); break; case OP_GC_SPILL_SLOT_LIVENESS_DEF: - ins->backend.pc_offset = code - cfg->native_code; + ins->backend.pc_offset = GPTRDIFF_TO_INT (code - cfg->native_code); bb->spill_slot_defs = g_slist_prepend_mempool (cfg->mempool, bb->spill_slot_defs, ins); break; case OP_GET_SP: @@ -5373,7 +5373,7 @@ mono_arch_emit_exceptions (MonoCompile *cfg) x86_push_imm (code, m_class_get_type_token (exc_class) - MONO_TOKEN_TYPE_DEF); patch_info->data.jit_icall_id = MONO_JIT_ICALL_mono_arch_throw_corlib_exception; patch_info->type = MONO_PATCH_INFO_JIT_ICALL_ID; - patch_info->ip.i = code - cfg->native_code; + patch_info->ip.i = GPTRDIFF_TO_INT (code - cfg->native_code); x86_call_code (code, 0); x86_push_imm (buf, (code - cfg->native_code) - throw_ip); while (buf < buf2) @@ -5548,7 +5548,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoIMTCheckItem **imt_entri } if (!fail_tramp) - UnlockedAdd (&mono_stats.imt_trampolines_size, code - start); + UnlockedAdd (&mono_stats.imt_trampolines_size, GPTRDIFF_TO_INT32 (code - start)); g_assertf (code - start <= size, "%d %d", (int)(code - start), size); #if DEBUG_IMT @@ -5570,7 +5570,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoIMTCheckItem **imt_entri MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -5692,7 +5692,7 @@ mono_breakpoint_clean_code (guint8 *method_start, guint8 *code, int offset, guin if (!method_start || code - offset >= method_start) { memcpy (buf, code - offset, size); } else { - int diff = code - method_start; + int diff = GPTRDIFF_TO_INT (code - method_start); memset (buf, 0, size); memcpy (buf + offset - diff, method_start, diff + size - offset); } @@ -5787,10 +5787,10 @@ get_delegate_invoke_impl (MonoTrampInfo **info, gboolean has_target, guint32 par g_assertf ((code - start) <= code_reserve, "%d %d", (int)(code - start), code_reserve); if (has_target) { - *info = mono_tramp_info_create ("delegate_invoke_impl_has_target", start, code - start, NULL, unwind_ops); + *info = mono_tramp_info_create ("delegate_invoke_impl_has_target", start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); } else { char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", param_count); - *info = mono_tramp_info_create (name, start, code - start, NULL, unwind_ops); + *info = mono_tramp_info_create (name, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); g_free (name); } @@ -5850,7 +5850,7 @@ get_delegate_virtual_invoke_impl (MonoTrampInfo **info, gboolean load_imt_reg, i MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE, NULL)); tramp_name = mono_get_delegate_virtual_invoke_impl_name (load_imt_reg, offset); - *info = mono_tramp_info_create (tramp_name, start, code - start, NULL, unwind_ops); + *info = mono_tramp_info_create (tramp_name, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops); g_free (tramp_name); @@ -6165,9 +6165,9 @@ mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, Mon * to be added to that address. */ if (cfg) - mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_GOT_OFFSET, NULL); + mono_add_patch_info (cfg, GPTRDIFF_TO_INT (code - cfg->native_code), MONO_PATCH_INFO_GOT_OFFSET, NULL); else - *ji = mono_patch_info_list_prepend (*ji, code - start, MONO_PATCH_INFO_GOT_OFFSET, NULL); + *ji = mono_patch_info_list_prepend (*ji, GPTRDIFF_TO_INT (code - start), MONO_PATCH_INFO_GOT_OFFSET, NULL); x86_pop_reg (code, MONO_ARCH_GOT_REG); x86_alu_reg_imm (code, X86_ADD, MONO_ARCH_GOT_REG, 0xf0f0f0f0); if (cfg) @@ -6188,7 +6188,7 @@ mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, Mo { /* Load the mscorlib got address */ x86_mov_reg_membase (code, X86_EAX, MONO_ARCH_GOT_REG, sizeof (target_mgreg_t), 4); - *ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target); + *ji = mono_patch_info_list_prepend (*ji, GPTRDIFF_TO_INT (code - start), tramp_type, target); /* arch_emit_got_access () patches this */ x86_mov_reg_membase (code, X86_EAX, X86_EAX, 0xf0f0f0f0, 4); diff --git a/src/mono/mono/mini/simd-intrinsics.c b/src/mono/mono/mini/simd-intrinsics.c index 1b6fe4d2447b5f..833f475cc2d1e4 100644 --- a/src/mono/mono/mini/simd-intrinsics.c +++ b/src/mono/mono/mini/simd-intrinsics.c @@ -1929,7 +1929,7 @@ emit_sri_vector (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi if (args [1]->opcode == OP_ICONST) { // If the index is provably a constant, we can generate vastly better code. - int index = args[1]->inst_c0; + int index = GTMREG_TO_INT (args[1]->inst_c0); if (index < 0 || index >= elems) { MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, args [1]->dreg, elems); @@ -2259,7 +2259,7 @@ emit_sri_vector (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi if (args [1]->opcode == OP_ICONST) { // If the index is provably a constant, we can generate vastly better code. - int index = args[1]->inst_c0; + int index = GTMREG_TO_INT (args[1]->inst_c0); if (index < 0 || index >= elems) { MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, args [1]->dreg, elems); @@ -2724,7 +2724,7 @@ emit_vector_2_3_4 (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *f if (args [1]->opcode == OP_ICONST) { // If the index is provably a constant, we can generate vastly better code. - int index = args[1]->inst_c0; + int index = GTMREG_TO_INT (args[1]->inst_c0); if (index < 0 || index >= elems) { MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, args [1]->dreg, elems); @@ -2806,7 +2806,7 @@ emit_vector_2_3_4 (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *f g_assert (fsig->hasthis && fsig->param_count == 2 && fsig->params [0]->type == MONO_TYPE_I4 && fsig->params [1]->type == MONO_TYPE_R4); gboolean indirect = FALSE; - int elems = 4, index = args [1]->inst_c0; + int elems = 4, index = GTMREG_TO_INT (args [1]->inst_c0); int dreg = load_simd_vreg (cfg, cmethod, args [0], &indirect); if (args [1]->opcode == OP_ICONST) { @@ -5714,7 +5714,7 @@ emit_wasm_supported_intrinsics ( break; } case SN_ExtractScalar: { - op = type_to_xextract_op (arg0_type); + op = GINT_TO_UINT16 (type_to_xextract_op (arg0_type)); break; } case SN_LoadScalarVector128: { diff --git a/src/mono/mono/mini/tramp-arm-gsharedvt.c b/src/mono/mono/mini/tramp-arm-gsharedvt.c index 2ccd8a7b8a5145..90a47ed369c71d 100644 --- a/src/mono/mono/mini/tramp-arm-gsharedvt.c +++ b/src/mono/mono/mini/tramp-arm-gsharedvt.c @@ -283,7 +283,7 @@ MONO_RESTORE_WARNING ARM_STR_IMM (code, ARMREG_IP, ARMREG_SP, 4); /* Make the call */ if (aot) { - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arm_start_gsharedvt_call)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_arm_start_gsharedvt_call)); ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -543,9 +543,9 @@ MONO_RESTORE_WARNING g_assert ((code - buf) < buf_len); if (info) - *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); return buf; } diff --git a/src/mono/mono/mini/tramp-arm.c b/src/mono/mono/mini/tramp-arm.c index 1f5c8900d87169..88f505c1bae4ca 100644 --- a/src/mono/mono/mini/tramp-arm.c +++ b/src/mono/mono/mini/tramp-arm.c @@ -100,7 +100,7 @@ mono_arch_patch_plt_entry (guint8 *code, gpointer *got, host_mgreg_t *regs, guin static guint32 branch_for_target_reachable (guint8 *branch, guint8 *target) { - gint diff = target - branch - 8; + gint diff = GPTRDIFF_TO_INT (target - branch - 8); g_assert ((diff & 3) == 0); if (diff >= 0) { if (diff <= 33554431) @@ -214,7 +214,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf * This is a synthetized call to mono_get_lmf_addr () */ if (aot) { - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_get_lmf_addr)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_get_lmf_addr)); ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -292,7 +292,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_V2); if (aot) { - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, GINT_TO_POINTER (mono_trampoline_type_to_jit_icall_id (tramp_type))); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_JIT_ICALL_ADDR, GINT_TO_POINTER (mono_trampoline_type_to_jit_icall_id (tramp_type))); ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -429,7 +429,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf code = emit_bx (code, ARMREG_IP); /* Flush instruction cache, since we've generated code */ - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); /* Sanity check */ @@ -437,7 +437,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf g_assert (info); tramp_name = mono_get_generic_trampoline_name (tramp_type); - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -496,13 +496,13 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty } /* Flush instruction cache, since we've generated code */ - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type))); g_assert ((code - buf) <= size); if (code_len) - *code_len = code - buf; + *code_len = GPTRDIFF_TO_UINT32 (code - buf); return buf; } @@ -533,13 +533,13 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) code = emit_bx (code, ARMREG_IP); *(guint32*)code = (guint32)(gsize)addr; code += 4; - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m)); g_assert ((code - start) <= size); /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name); g_print ("unbox code is at %p for method at %p\n", start, addr);*/ - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -564,10 +564,10 @@ mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer g_assert ((code - start) <= buf_len); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -593,10 +593,10 @@ mono_arch_get_ftnptr_arg_trampoline (MonoMemoryManager *mem_manager, gpointer ar g_assert ((code - start) <= buf_len); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -691,7 +691,7 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info /* The vtable/mrgctx is still in R0 */ if (aot) { - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot)); ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -708,13 +708,13 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info code += 4; } - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); g_assert (code - buf <= tramp_size); char *name = mono_get_rgctx_fetch_trampoline_name (slot); - *info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); g_free (name); return buf; @@ -743,12 +743,12 @@ mono_arch_create_general_rgctx_lazy_fetch_trampoline (MonoTrampInfo **info, gboo g_assert (MONO_ARCH_VTABLE_REG == ARMREG_R0); code = emit_bx (code, ARMREG_R1); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); g_assert (code - buf <= tramp_size); - *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -798,9 +798,9 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo /* call */ if (aot) { if (single_step) - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_single_step_from_context)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_single_step_from_context)); else - ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context)); + ji = mono_patch_info_list_prepend (ji, GPTRDIFF_TO_INT (code - buf), MONO_PATCH_INFO_JIT_ICALL_ADDR, GUINT_TO_POINTER (MONO_JIT_ICALL_mono_debugger_agent_breakpoint_from_context)); ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); ARM_B (code, 0); *(gpointer*)code = NULL; @@ -827,11 +827,11 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo ARM_ADD_REG_IMM8 (code, ARMREG_IP, ARMREG_FP, MONO_STRUCT_OFFSET (MonoContext, regs)); ARM_LDM (code, ARMREG_IP, 0xffff); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); const char *tramp_name = single_step ? "sdb_single_step_trampoline" : "sdb_breakpoint_trampoline"; - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -930,11 +930,11 @@ mono_arch_get_interp_to_native_trampoline (MonoTrampInfo **info) g_assert (code - start < buf_len); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); if (info) - *info = mono_tramp_info_create ("interp_to_native_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("interp_to_native_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; #else @@ -1003,11 +1003,11 @@ mono_arch_get_native_to_interp_trampoline (MonoTrampInfo **info) g_assert (code - start < buf_len); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL)); if (info) - *info = mono_tramp_info_create ("native_to_interp_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("native_to_interp_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; #else @@ -1186,10 +1186,10 @@ mono_arch_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr) g_assert ((code - buf) <= buf_len); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, buf, code - buf, NULL, NULL), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, buf, GPTRDIFF_TO_UINT32 (code - buf), NULL, NULL), mem_manager); return buf; } diff --git a/src/mono/mono/mini/tramp-arm64-gsharedvt.c b/src/mono/mono/mini/tramp-arm64-gsharedvt.c index e04cfd33805eaa..f7942c8eb3d5a6 100644 --- a/src/mono/mono/mini/tramp-arm64-gsharedvt.c +++ b/src/mono/mono/mini/tramp-arm64-gsharedvt.c @@ -46,7 +46,7 @@ mono_arch_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr) g_assert ((code - buf) < buf_len); - MINI_END_CODEGEN (buf, code - buf, -1, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), -1, NULL); return buf; } @@ -557,9 +557,9 @@ mono_arch_get_gsharedvt_trampoline (MonoTrampInfo **info, gboolean aot) g_assert ((code - buf) < buf_len); if (info) - *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); - MINI_END_CODEGEN (buf, code - buf, -1, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), -1, NULL); return buf; } diff --git a/src/mono/mono/mini/tramp-arm64.c b/src/mono/mono/mini/tramp-arm64.c index 3528edee8f43a6..af394802ecd98a 100644 --- a/src/mono/mono/mini/tramp-arm64.c +++ b/src/mono/mono/mini/tramp-arm64.c @@ -308,11 +308,11 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf g_assert ((code - buf) < buf_len); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_HELPER, NULL); if (info) { tramp_name = mono_get_generic_trampoline_name (tramp_type); - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); } return (guchar*)MINI_ADDR_TO_FTNPTR (buf); @@ -341,10 +341,10 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty g_assert ((code - buf) < buf_len); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type)); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type)); if (code_len) - *code_len = code - buf; + *code_len = GPTRDIFF_TO_UINT32 (code - buf); return (gpointer)MINI_ADDR_TO_FTNPTR (buf); } @@ -368,7 +368,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) g_assert ((code - start) <= size); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m); return (gpointer)MINI_ADDR_TO_FTNPTR (start); } @@ -387,7 +387,7 @@ mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer code = mono_arm_emit_imm64 (code, ARMREG_IP0, (guint64)addr); code = mono_arm_emit_brx (code, ARMREG_IP0); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); g_assert ((code - start) <= buf_len); @@ -486,11 +486,11 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info g_assert (code - buf <= buf_size); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); if (info) { char *name = mono_get_rgctx_fetch_trampoline_name (slot); - *info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); g_free (name); } @@ -524,10 +524,10 @@ mono_arch_create_general_rgctx_lazy_fetch_trampoline (MonoTrampInfo **info, gboo g_assert (code - buf <= tramp_size); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL); if (info) - *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return (gpointer)MINI_ADDR_TO_FTNPTR (buf); } @@ -625,10 +625,10 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo g_assert (code - buf <= tramp_size); - MINI_END_CODEGEN (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL); + MINI_END_CODEGEN (buf, GPTRDIFF_TO_INT (code - buf), MONO_PROFILER_CODE_BUFFER_HELPER, NULL); const char *tramp_name = single_step ? "sdb_single_step_trampoline" : "sdb_breakpoint_trampoline"; - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return (guint8*)MINI_ADDR_TO_FTNPTR (buf); } @@ -732,10 +732,10 @@ mono_arch_get_interp_to_native_trampoline (MonoTrampInfo **info) g_assert (code - start < buf_len); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_HELPER, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_HELPER, NULL); if (info) - *info = mono_tramp_info_create ("interp_to_native_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("interp_to_native_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return (guint8*)MINI_ADDR_TO_FTNPTR (start); #else @@ -809,10 +809,10 @@ mono_arch_get_native_to_interp_trampoline (MonoTrampInfo **info) g_assert (code - start < buf_len); - MINI_END_CODEGEN (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); + MINI_END_CODEGEN (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL); if (info) - *info = mono_tramp_info_create ("native_to_interp_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("native_to_interp_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return (guint8*)MINI_ADDR_TO_FTNPTR (start); #else diff --git a/src/mono/mono/mini/tramp-x86-gsharedvt.c b/src/mono/mono/mini/tramp-x86-gsharedvt.c index ded0b1c2c16568..e1bcd351a25e7b 100644 --- a/src/mono/mono/mini/tramp-x86-gsharedvt.c +++ b/src/mono/mono/mini/tramp-x86-gsharedvt.c @@ -354,9 +354,9 @@ mono_arch_get_gsharedvt_trampoline (MonoTrampInfo **info, gboolean aot) g_assertf (code - buf <= buf_len, "%d %d", (int)(code - buf), buf_len); if (info) - *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("gsharedvt_trampoline", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); return buf; } diff --git a/src/mono/mono/mini/tramp-x86.c b/src/mono/mono/mini/tramp-x86.c index af10b329a0dd0f..c03f5f6ef91b50 100644 --- a/src/mono/mono/mini/tramp-x86.c +++ b/src/mono/mono/mini/tramp-x86.c @@ -58,7 +58,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -79,10 +79,10 @@ mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer x86_jump_code (code, addr); g_assertf ((code - start) <= buf_len, "%d %d", (int)(code - start), buf_len); - mono_arch_flush_icache (start, code - start); - MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); + MONO_PROFILER_RAISE (jit_code_buffer, (start, GPTRDIFF_TO_INT (code - start), MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -388,7 +388,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); tramp_name = mono_get_generic_trampoline_name (tramp_type); - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -410,11 +410,11 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty x86_jump_code (buf, tramp); g_assertf ((code - buf) <= size, "%d %d", (int)(code - buf), size); - mono_arch_flush_icache (code, buf - code); - MONO_PROFILER_RAISE (jit_code_buffer, (code, buf - code, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type))); + mono_arch_flush_icache (code, GPTRDIFF_TO_INT (buf - code)); + MONO_PROFILER_RAISE (jit_code_buffer, (code, GPTRDIFF_TO_INT (buf - code), MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type))); if (code_len) - *code_len = buf - code; + *code_len = GPTRDIFF_TO_UINT32 (buf - code); return code; } @@ -505,13 +505,13 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info x86_jump_code (code, tramp); } - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); g_assertf (code - buf <= tramp_size, "%d %d", (int)(code - buf), tramp_size); char *name = mono_get_rgctx_fetch_trampoline_name (slot); - *info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); g_free (name); return buf; @@ -548,12 +548,12 @@ mono_arch_create_general_rgctx_lazy_fetch_trampoline (MonoTrampInfo **info, gboo x86_jump_reg (code, X86_EAX); - mono_arch_flush_icache (buf, code - buf); + mono_arch_flush_icache (buf, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); g_assertf (code - buf <= tramp_size, "%d %d", (int)(code - buf), tramp_size); - *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create ("rgctx_fetch_trampoline_general", buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -609,10 +609,10 @@ mono_arch_get_gsharedvt_arg_trampoline (gpointer arg, gpointer addr) x86_jump_code (code, addr); g_assertf ((code - start) <= buf_len, "%d %d", (int)(code - start), buf_len); - mono_arch_flush_icache (start, code - start); + mono_arch_flush_icache (start, GPTRDIFF_TO_INT (code - start)); MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL)); - mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), mem_manager); + mono_tramp_info_register (mono_tramp_info_create (NULL, start, GPTRDIFF_TO_UINT32 (code - start), NULL, unwind_ops), mem_manager); return start; } @@ -709,12 +709,12 @@ mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gbo mono_add_unwind_op_def_cfa (unwind_ops, code, buf, X86_ESP, cfa_offset); x86_ret (code); - mono_arch_flush_icache (code, code - buf); + mono_arch_flush_icache (code, GPTRDIFF_TO_INT (code - buf)); MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); g_assertf (code - buf <= tramp_size, "%d %d", (int)(code - buf), tramp_size); const char *tramp_name = single_step ? "sdb_single_step_trampoline" : "sdb_breakpoint_trampoline"; - *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops); + *info = mono_tramp_info_create (tramp_name, buf, GPTRDIFF_TO_UINT32 (code - buf), ji, unwind_ops); return buf; } @@ -799,7 +799,7 @@ mono_arch_get_interp_to_native_trampoline (MonoTrampInfo **info) MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_HELPER, NULL)); if (info) - *info = mono_tramp_info_create ("interp_to_native_trampoline", start, code - start, ji, unwind_ops); + *info = mono_tramp_info_create ("interp_to_native_trampoline", start, GPTRDIFF_TO_UINT32 (code - start), ji, unwind_ops); return start; #else diff --git a/src/mono/mono/mini/type-checking.c b/src/mono/mono/mini/type-checking.c index 7fc2cf394c998e..a847cb8e720d27 100644 --- a/src/mono/mono/mini/type-checking.c +++ b/src/mono/mono/mini/type-checking.c @@ -110,11 +110,11 @@ mini_emit_isninst_cast_inst (MonoCompile *cfg, int klass_reg, MonoClass *klass, mono_class_setup_supertypes (klass); if (m_class_get_idepth (klass) > MONO_DEFAULT_SUPERTABLE_SIZE) { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, m_class_offsetof_idepth ()); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_idepth ())); MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, m_class_get_idepth (klass)); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBLT_UN, false_target); } - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, m_class_offsetof_supertypes ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_supertypes ())); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((m_class_get_idepth (klass) - 1) * TARGET_SIZEOF_VOID_P)); if (klass_ins) { MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, stype, klass_ins->dreg); @@ -145,7 +145,7 @@ mini_emit_interface_bitmap_check (MonoCompile *cfg, int intf_bit_reg, int base_r #else int ibitmap_byte_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, base_reg, offset); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, ibitmap_reg, base_reg, GINTPTR_TO_TMREG (offset)); if (cfg->compile_aot) { int iid_reg = alloc_preg (cfg); @@ -228,7 +228,7 @@ mini_emit_max_iid_check_class (MonoCompile *cfg, int klass_reg, MonoClass *klass { int max_iid_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, klass_reg, m_class_offsetof_max_interface_id ()); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU4_MEMBASE, max_iid_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_max_interface_id ())); mini_emit_max_iid_check (cfg, max_iid_reg, klass, false_target); } @@ -296,12 +296,12 @@ mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClas g_assert (!klass_inst); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, m_class_offsetof_rank ()); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, rank_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_rank ())); MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, m_class_get_rank (klass)); MONO_EMIT_NEW_COND_EXC (cfg, NE_UN, "InvalidCastException"); // MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, m_class_offsetof_cast_class ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_cast_class ())); if (m_class_is_array_special_interface (m_class_get_cast_class (klass))) { MonoInst *src; @@ -310,7 +310,7 @@ mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClas emit_castclass_with_cache_no_details (cfg, src, klass, 0); } else if (m_class_get_cast_class (klass) == mono_defaults.object_class) { int parent_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, m_class_offsetof_parent ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, GINTPTR_TO_TMREG (m_class_offsetof_parent ())); mini_emit_class_check_branch (cfg, parent_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBNE_UN, object_is_null); mini_emit_class_check (cfg, eclass_reg, mono_defaults.enum_class); } else if (m_class_get_cast_class (klass) == m_class_get_parent (mono_defaults.enum_class)) { @@ -340,11 +340,11 @@ mini_emit_castclass_inst (MonoCompile *cfg, int obj_reg, int klass_reg, MonoClas mono_class_setup_supertypes (klass); if (m_class_get_idepth (klass) > MONO_DEFAULT_SUPERTABLE_SIZE) { - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, m_class_offsetof_idepth ()); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_idepth ())); MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, idepth_reg, m_class_get_idepth (klass)); MONO_EMIT_NEW_COND_EXC (cfg, LT_UN, "InvalidCastException"); } - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, m_class_offsetof_supertypes ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stypes_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_supertypes ())); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, stype, stypes_reg, ((m_class_get_idepth (klass) - 1) * TARGET_SIZEOF_VOID_P)); mini_emit_class_check_inst (cfg, stype, klass, klass_inst); } @@ -532,7 +532,7 @@ handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_us MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, rank_reg, m_class_get_rank (klass)); MONO_EMIT_NEW_BRANCH_BLOCK (cfg, OP_PBNE_UN, false_bb); MONO_EMIT_NEW_LOAD_MEMBASE (cfg, klass_reg, vtable_reg, MONO_STRUCT_OFFSET (MonoVTable, klass)); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, m_class_offsetof_cast_class ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, eclass_reg, klass_reg, GINTPTR_TO_TMREG (m_class_offsetof_cast_class ())); if (m_class_is_array_special_interface (m_class_get_cast_class (klass))) { MonoInst *move, *res_inst; @@ -547,8 +547,8 @@ handle_isinst (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_us parent_reg = alloc_preg (cfg); class_kind_reg = alloc_preg (cfg); - MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, m_class_offsetof_parent ()); - MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, class_kind_reg, eclass_reg, m_class_offsetof_class_kind ()); + MONO_EMIT_NEW_LOAD_MEMBASE (cfg, parent_reg, eclass_reg, GINTPTR_TO_TMREG (m_class_offsetof_parent ())); + MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADU1_MEMBASE, class_kind_reg, eclass_reg, GINTPTR_TO_TMREG (m_class_offsetof_class_kind ())); // Check if the parent class of the element is not System.ValueType mini_emit_class_check_branch (cfg, parent_reg, m_class_get_parent (mono_defaults.enum_class), OP_PBNE_UN, pointer_check_bb); diff --git a/src/mono/mono/profiler/CMakeLists.txt b/src/mono/mono/profiler/CMakeLists.txt index 6bca00983686fc..511c19dbe5a322 100644 --- a/src/mono/mono/profiler/CMakeLists.txt +++ b/src/mono/mono/profiler/CMakeLists.txt @@ -12,6 +12,8 @@ include_directories( if(NOT DISABLE_LIBS) if(HOST_ANDROID OR HOST_IOS OR HOST_TVOS OR HOST_S390X) # Build the logging profiler only for certain platforms + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_DEFINITIONS "${ZLIB_COMPILE_DEFINITIONS}") + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_OPTIONS "${ZLIB_COMPILE_OPTIONS}") add_library(mono-profiler-log SHARED helper.c log.c log-args.c ${ZLIB_SOURCES}) target_compile_definitions(mono-profiler-log PRIVATE -DMONO_DLL_EXPORT) target_link_libraries(mono-profiler-log PRIVATE monosgen-shared monoapi eglib_objects) diff --git a/src/mono/mono/sgen/sgen-scan-object.h b/src/mono/mono/sgen/sgen-scan-object.h index 565d25446cef31..4932ca36917850 100644 --- a/src/mono/mono/sgen/sgen-scan-object.h +++ b/src/mono/mono/sgen/sgen-scan-object.h @@ -14,7 +14,7 @@ * "start" will point to the start of the next object, if the scanned * object contained references. If not, the value of "start" should * be considered undefined after executing this code. The object's - * GC descriptor must be in the variable "mword desc". + * GC descriptor must be in the variable "SgenDescriptor desc". * * The macro `HANDLE_PTR` will be invoked for every reference encountered while scanning the * object. It is called with two parameters: The pointer to the reference (not the diff --git a/src/mono/mono/utils/mono-machine.h b/src/mono/mono/utils/mono-machine.h index b6bef8db9c7780..7a559d83c6fca0 100644 --- a/src/mono/mono/utils/mono-machine.h +++ b/src/mono/mono/utils/mono-machine.h @@ -96,6 +96,9 @@ __CAST_UTYPE_TO_STYPE(guint64, target_mgreg_t, PTRDIFF_MIN, PTRDIFF_MAX) #define GINT64_TO_TMREG(v) G_CAST_TYPE_TO_TYPE(gint64, target_mgreg_t, v) #define GUINT64_TO_TMREG(v) G_CAST_TYPE_TO_TYPE(guint64, target_mgreg_t, v) +#define GINTPTR_TO_TMREG(v) G_CAST_TYPE_TO_TYPE(gintptr, target_mgreg_t, v) +#define GPTRDIFF_TO_TMREG(v) G_CAST_TYPE_TO_TYPE(gptrdiff, target_mgreg_t, v) + /* Alignment for MonoArray.vector */ #if defined(_AIX) /* diff --git a/src/native/external/brotli.cmake b/src/native/external/brotli.cmake index 6e4d3f7ee0b489..bf72e767cc659b 100644 --- a/src/native/external/brotli.cmake +++ b/src/native/external/brotli.cmake @@ -1,3 +1,5 @@ +# IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects + include_directories(BEFORE "${CMAKE_CURRENT_LIST_DIR}/brotli/include") set (BROTLI_SOURCES_BASE diff --git a/src/native/external/libunwind.cmake b/src/native/external/libunwind.cmake index 3854f9b85a2b36..c4456cf93b71ba 100644 --- a/src/native/external/libunwind.cmake +++ b/src/native/external/libunwind.cmake @@ -1,3 +1,5 @@ +# IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects + include_directories(${CMAKE_CURRENT_LIST_DIR}/libunwind/include/tdep) include_directories(${CMAKE_CURRENT_LIST_DIR}/libunwind/include) include_directories(${CMAKE_CURRENT_LIST_DIR}/libunwind/src) @@ -491,8 +493,6 @@ else(CLR_CMAKE_HOST_UNIX) set(libunwind_elf_la_SOURCES ${libunwind_elf64_la_SOURCES}) endif() - set_source_files_properties(${CLR_DIR}/pal/src/exception/remote-unwind.cpp PROPERTIES COMPILE_FLAGS /TP INCLUDE_DIRECTORIES ${CLR_DIR}/inc) - set(LIBUNWIND_SOURCES_BASE remote/win/missing-functions.c # ${libunwind_la_SOURCES} Local... @@ -506,8 +506,4 @@ else(CLR_CMAKE_HOST_UNIX) ) endif(CLR_CMAKE_HOST_UNIX) -if(CMAKE_C_COMPILER_ID MATCHES "Clang") - add_compile_options($<$:-Wno-implicit-int-conversion>) -endif() - addprefix(LIBUNWIND_SOURCES "${CMAKE_CURRENT_LIST_DIR}/libunwind/src" "${LIBUNWIND_SOURCES_BASE}") diff --git a/src/native/external/libunwind_extras/CMakeLists.txt b/src/native/external/libunwind_extras/CMakeLists.txt index 245bd3823169e5..962196c7893a9c 100644 --- a/src/native/external/libunwind_extras/CMakeLists.txt +++ b/src/native/external/libunwind_extras/CMakeLists.txt @@ -169,6 +169,8 @@ if(CLR_CMAKE_HOST_UNIX) add_library(libunwind OBJECT ${LIBUNWIND_SOURCES}) endif(CLR_CMAKE_HOST_OSX) else(CLR_CMAKE_HOST_UNIX) + set_source_files_properties(${CLR_DIR}/pal/src/exception/remote-unwind.cpp PROPERTIES COMPILE_FLAGS /TP INCLUDE_DIRECTORIES ${CLR_DIR}/inc) + add_library(libunwind_xdac OBJECT ${CLR_DIR}/pal/src/exception/remote-unwind.cpp ${LIBUNWIND_SOURCES}) diff --git a/src/native/external/llvm-libunwind.cmake b/src/native/external/llvm-libunwind.cmake index a6f7ddf8cb5ba6..72cecd2a149806 100644 --- a/src/native/external/llvm-libunwind.cmake +++ b/src/native/external/llvm-libunwind.cmake @@ -1,3 +1,5 @@ +# IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects + if(NOT CLR_CMAKE_TARGET_ARCH_WASM) include_directories(BEFORE "${CMAKE_CURRENT_LIST_DIR}/llvm-libunwind/include") endif() diff --git a/src/native/external/zlib-intel.cmake b/src/native/external/zlib-intel.cmake index e8f198271d865b..a664f154dbef09 100644 --- a/src/native/external/zlib-intel.cmake +++ b/src/native/external/zlib-intel.cmake @@ -1,3 +1,5 @@ +# IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects + set(ZLIB_SOURCES_BASE adler32.c compress.c @@ -17,7 +19,11 @@ set(ZLIB_SOURCES_BASE ../../libs/System.IO.Compression.Native/zlib_allocator_win.c ) +addprefix(ZLIB_SOURCES "${CMAKE_CURRENT_LIST_DIR}/zlib-intel" "${ZLIB_SOURCES_BASE}") + # enable custom zlib allocator -add_definitions(-DMY_ZCALLOC) +set(ZLIB_COMPILE_DEFINITIONS "MY_ZCALLOC") -addprefix(ZLIB_SOURCES "${CMAKE_CURRENT_LIST_DIR}/zlib-intel" "${ZLIB_SOURCES_BASE}") +if(HOST_WIN32 OR CLR_CMAKE_TARGET_WIN32) + set(ZLIB_COMPILE_OPTIONS "/wd4127;/wd4131") +endif() diff --git a/src/native/external/zlib.cmake b/src/native/external/zlib.cmake index 730bfc4bd14020..498ec977960e01 100644 --- a/src/native/external/zlib.cmake +++ b/src/native/external/zlib.cmake @@ -1,3 +1,5 @@ +# IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects + set(ZLIB_SOURCES_BASE adler32.c compress.c @@ -23,8 +25,6 @@ set(ZLIB_SOURCES_BASE zutil.h ) -# enable custom zlib allocator -add_definitions(-DMY_ZCALLOC) if(HOST_WIN32 OR CLR_CMAKE_TARGET_WIN32) set(ZLIB_SOURCES_BASE ${ZLIB_SOURCES_BASE} ../../libs/System.IO.Compression.Native/zlib_allocator_win.c) else() @@ -32,3 +32,10 @@ else() endif() addprefix(ZLIB_SOURCES "${CMAKE_CURRENT_LIST_DIR}/zlib" "${ZLIB_SOURCES_BASE}") + +# enable custom zlib allocator +set(ZLIB_COMPILE_DEFINITIONS "MY_ZCALLOC") + +if(HOST_WIN32 OR CLR_CMAKE_TARGET_WIN32) + set(ZLIB_COMPILE_OPTIONS "/wd4127;/wd4131") +endif() diff --git a/src/native/libs/System.IO.Compression.Native/CMakeLists.txt b/src/native/libs/System.IO.Compression.Native/CMakeLists.txt index b8a726542ce3ad..80458a5ebd241d 100644 --- a/src/native/libs/System.IO.Compression.Native/CMakeLists.txt +++ b/src/native/libs/System.IO.Compression.Native/CMakeLists.txt @@ -32,6 +32,8 @@ if (CLR_CMAKE_TARGET_UNIX OR CLR_CMAKE_TARGET_BROWSER OR CLR_CMAKE_TARGET_WASI) if (CLR_CMAKE_TARGET_BROWSER OR CLR_CMAKE_TARGET_WASI) include(${CLR_SRC_NATIVE_DIR}/external/zlib.cmake) add_definitions(-DINTERNAL_ZLIB) + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_DEFINITIONS "${ZLIB_COMPILE_DEFINITIONS}") + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_OPTIONS "${ZLIB_COMPILE_OPTIONS}") set(NATIVECOMPRESSION_SOURCES ${ZLIB_SOURCES} ${NATIVECOMPRESSION_SOURCES}) endif() @@ -110,6 +112,8 @@ else () endif () add_definitions(-DINTERNAL_ZLIB) + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_DEFINITIONS "${ZLIB_COMPILE_DEFINITIONS}") + set_source_files_properties(${ZLIB_SOURCES} PROPERTIES COMPILE_OPTIONS "${ZLIB_COMPILE_OPTIONS}") set(NATIVECOMPRESSION_SOURCES ${ZLIB_SOURCES} ${NATIVECOMPRESSION_SOURCES}) if (GEN_SHARED_LIB)