From 38caaf67b1048273326139b2200f69ad45229638 Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Wed, 24 Oct 2018 18:18:47 +0200 Subject: [PATCH] [jit] Remove unused mono_arch_instrument_prolog ()/epilog () functions. (#11304) --- mono/mini/mini-amd64.c | 154 ---------- mono/mini/mini-arm.c | 159 ---------- mono/mini/mini-arm64.c | 14 - mono/mini/mini-mips.c | 199 ------------- mono/mini/mini-s390x.c | 766 +------------------------------------------------ mono/mini/mini-x86.c | 212 -------------- mono/mini/mini.h | 2 - 7 files changed, 2 insertions(+), 1504 deletions(-) diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c index 2bd3dd05638..0846fef65f2 100644 --- a/mono/mini/mini-amd64.c +++ b/mono/mini/mini-amd64.c @@ -7663,160 +7663,6 @@ mono_arch_emit_exceptions (MonoCompile *cfg) #endif /* DISABLE_JIT */ -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar *)p; - MonoMethodSignature *sig; - MonoInst *inst; - int i, n, stack_area = 0; - - /* Keep this in sync with mono_arch_get_argument_info */ - - if (enable_arguments) { - /* Allocate a new area on the stack and save arguments there */ - sig = mono_method_signature_internal (cfg->method); - - n = sig->param_count + sig->hasthis; - - stack_area = ALIGN_TO (n * 8, 16); - - amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, stack_area); - - for (i = 0; i < n; ++i) { - inst = cfg->args [i]; - - if (inst->opcode == OP_REGVAR) - amd64_mov_membase_reg (code, AMD64_RSP, (i * 8), inst->dreg, 8); - else { - if (inst->opcode == OP_VTARG_ADDR) - inst = inst->inst_left; - amd64_mov_reg_membase (code, AMD64_R11, inst->inst_basereg, inst->inst_offset, 8); - amd64_mov_membase_reg (code, AMD64_RSP, (i * 8), AMD64_R11, 8); - } - } - } - - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_METHODCONST, cfg->method); - amd64_set_reg_template (code, AMD64_ARG_REG1); - amd64_mov_reg_reg (code, AMD64_ARG_REG2, AMD64_RSP, 8); - code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)func, TRUE); - - if (enable_arguments) - amd64_alu_reg_imm (code, X86_ADD, AMD64_RSP, stack_area); - - set_code_cursor (cfg, code); - - return code; -} - -enum { - SAVE_NONE, - SAVE_STRUCT, - SAVE_EAX, - SAVE_EAX_EDX, - SAVE_XMM -}; - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar *)p; - int save_mode = SAVE_NONE; - MonoMethod *method = cfg->method; - MonoType *ret_type = mini_get_underlying_type (mono_method_signature_internal (method)->ret); - - switch (ret_type->type) { - case MONO_TYPE_VOID: - /* special case string .ctor icall */ - if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) - save_mode = SAVE_EAX; - else - save_mode = SAVE_NONE; - break; - case MONO_TYPE_I8: - case MONO_TYPE_U8: - save_mode = SAVE_EAX; - break; - case MONO_TYPE_R4: - case MONO_TYPE_R8: - save_mode = SAVE_XMM; - break; - case MONO_TYPE_GENERICINST: - if (!mono_type_generic_inst_is_valuetype (ret_type)) { - save_mode = SAVE_EAX; - break; - } - /* Fall through */ - case MONO_TYPE_VALUETYPE: - save_mode = SAVE_STRUCT; - break; - default: - save_mode = SAVE_EAX; - break; - } - - /* Save the result and copy it into the proper argument register */ - switch (save_mode) { - case SAVE_EAX: - amd64_push_reg (code, AMD64_RAX); - /* Align stack */ - amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, 8); - if (enable_arguments) - amd64_mov_reg_reg (code, AMD64_ARG_REG2, AMD64_RAX, 8); - break; - case SAVE_STRUCT: - /* FIXME: */ - if (enable_arguments) - amd64_mov_reg_imm (code, AMD64_ARG_REG2, 0); - break; - case SAVE_XMM: - amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, 8); - amd64_movsd_membase_reg (code, AMD64_RSP, 0, AMD64_XMM0); - /* Align stack */ - amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, 8); - /* - * The result is already in the proper argument register so no copying - * needed. - */ - break; - case SAVE_NONE: - break; - default: - g_assert_not_reached (); - } - - /* Set %al since this is a varargs call */ - code = amd64_handle_varargs_nregs (code, save_mode == SAVE_XMM); - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_METHODCONST, method); - amd64_set_reg_template (code, AMD64_ARG_REG1); - code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)func, TRUE); - - /* Restore result */ - switch (save_mode) { - case SAVE_EAX: - amd64_alu_reg_imm (code, X86_ADD, AMD64_RSP, 8); - amd64_pop_reg (code, AMD64_RAX); - break; - case SAVE_STRUCT: - /* FIXME: */ - break; - case SAVE_XMM: - amd64_alu_reg_imm (code, X86_ADD, AMD64_RSP, 8); - amd64_movsd_reg_membase (code, AMD64_XMM0, AMD64_RSP, 0); - amd64_alu_reg_imm (code, X86_ADD, AMD64_RSP, 8); - break; - case SAVE_NONE: - break; - default: - g_assert_not_reached (); - } - - set_code_cursor (cfg, code); - - return code; -} - MONO_NEVER_INLINE void mono_arch_flush_icache (guint8 *code, gint size) diff --git a/mono/mini/mini-arm.c b/mono/mini/mini-arm.c index 855e3e0041a..b44ecd7aa26 100644 --- a/mono/mini/mini-arm.c +++ b/mono/mini/mini-arm.c @@ -28,7 +28,6 @@ #include "mini-arm.h" #include "cpu-arm.h" -#include "trace.h" #include "ir-emit.h" #include "debugger-agent.h" #include "mini-gc.h" @@ -3170,149 +3169,6 @@ mono_arch_finish_dyn_call (MonoDynCallInfo *info, guint8 *buf) #ifndef DISABLE_JIT /* - * Allow tracing to work with this interface (with an optional argument) - */ - -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar*)p; - - code = mono_arm_emit_load_imm (code, ARMREG_R0, (guint32)(gsize)cfg->method); - ARM_MOV_REG_IMM8 (code, ARMREG_R1, 0); /* NULL ebp for now */ - code = mono_arm_emit_load_imm (code, ARMREG_R2, (guint32)(gsize)func); - code = emit_call_reg (code, ARMREG_R2); - return code; -} - -enum { - SAVE_NONE, - SAVE_STRUCT, - SAVE_ONE, - SAVE_TWO, - SAVE_ONE_FP, - SAVE_TWO_FP -}; - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar*)p; - int save_mode = SAVE_NONE; - MonoMethod *method = cfg->method; - MonoType *ret_type = mini_get_underlying_type (mono_method_signature_internal (method)->ret); - int rtype = ret_type->type; - int save_offset = cfg->param_area; - save_offset += 7; - save_offset &= ~7; - - set_code_cursor (cfg, code); - /* we need about 16 instructions */ - code = realloc_code (cfg, 16 * 4); - - switch (rtype) { - case MONO_TYPE_VOID: - /* special case string .ctor icall */ - if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) - save_mode = SAVE_ONE; - else - save_mode = SAVE_NONE; - break; - case MONO_TYPE_I8: - case MONO_TYPE_U8: - save_mode = SAVE_TWO; - break; - case MONO_TYPE_R4: - if (IS_HARD_FLOAT) - save_mode = SAVE_ONE_FP; - else - save_mode = SAVE_ONE; - break; - case MONO_TYPE_R8: - if (IS_HARD_FLOAT) - save_mode = SAVE_TWO_FP; - else - save_mode = SAVE_TWO; - break; - case MONO_TYPE_GENERICINST: - if (!mono_type_generic_inst_is_valuetype (ret_type)) { - save_mode = SAVE_ONE; - break; - } - /* Fall through */ - case MONO_TYPE_VALUETYPE: - save_mode = SAVE_STRUCT; - break; - default: - save_mode = SAVE_ONE; - break; - } - - switch (save_mode) { - case SAVE_TWO: - ARM_STR_IMM (code, ARMREG_R0, cfg->frame_reg, save_offset); - ARM_STR_IMM (code, ARMREG_R1, cfg->frame_reg, save_offset + 4); - if (enable_arguments) { - ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_R1); - ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_R0); - } - break; - case SAVE_ONE: - ARM_STR_IMM (code, ARMREG_R0, cfg->frame_reg, save_offset); - if (enable_arguments) { - ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_R0); - } - break; - case SAVE_ONE_FP: - ARM_FSTS (code, ARM_VFP_F0, cfg->frame_reg, save_offset); - if (enable_arguments) { - ARM_FMRS (code, ARMREG_R1, ARM_VFP_F0); - } - break; - case SAVE_TWO_FP: - ARM_FSTD (code, ARM_VFP_D0, cfg->frame_reg, save_offset); - if (enable_arguments) { - ARM_FMDRR (code, ARMREG_R1, ARMREG_R2, ARM_VFP_D0); - } - break; - case SAVE_STRUCT: - if (enable_arguments) { - /* FIXME: get the actual address */ - ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_R0); - } - break; - case SAVE_NONE: - default: - break; - } - - code = mono_arm_emit_load_imm (code, ARMREG_R0, (guint32)(gsize)cfg->method); - code = mono_arm_emit_load_imm (code, ARMREG_IP, (guint32)(gsize)func); - code = emit_call_reg (code, ARMREG_IP); - - switch (save_mode) { - case SAVE_TWO: - ARM_LDR_IMM (code, ARMREG_R0, cfg->frame_reg, save_offset); - ARM_LDR_IMM (code, ARMREG_R1, cfg->frame_reg, save_offset + 4); - break; - case SAVE_ONE: - ARM_LDR_IMM (code, ARMREG_R0, cfg->frame_reg, save_offset); - break; - case SAVE_ONE_FP: - ARM_FLDS (code, ARM_VFP_F0, cfg->frame_reg, save_offset); - break; - case SAVE_TWO_FP: - ARM_FLDD (code, ARM_VFP_D0, cfg->frame_reg, save_offset); - break; - case SAVE_NONE: - default: - break; - } - - return code; -} - -/* * The immediate field for cond branches is big enough for all reasonable methods */ #define EMIT_COND_BRANCH_FLAGS(ins,condcode) \ @@ -6280,8 +6136,6 @@ mono_arm_unaligned_stack (MonoMethod *method) * ------------------- * spilled regs * ------------------- - * optional 8 bytes for tracing - * ------------------- * param area size is cfg->param_area * ------------------- sp */ @@ -6295,13 +6149,9 @@ mono_arch_emit_prolog (MonoCompile *cfg) int alloc_size, orig_alloc_size, pos, max_offset, i, rot_amount, part; guint8 *code; CallInfo *cinfo; - int tracing = 0; int lmf_offset = 0; int prev_sp_offset, reg_offset; - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) - tracing = 1; - sig = mono_method_signature_internal (method); cfg->code_size = 256 + sig->param_count * 64; code = cfg->native_code = g_malloc (cfg->code_size); @@ -6675,9 +6525,6 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (method->save_lmf) code = emit_save_lmf (cfg, code, alloc_size - lmf_offset); - if (tracing) - code = (guint8*)mono_arch_instrument_prolog (cfg, (void*)mono_trace_enter_method, code, TRUE); - if (cfg->arch.seq_point_info_var) { MonoInst *ins = cfg->arch.seq_point_info_var; @@ -6767,18 +6614,12 @@ mono_arch_emit_epilog (MonoCompile *cfg) if (cfg->method->save_lmf) max_epilog_size += 128; - - if (mono_jit_trace_calls != NULL) - max_epilog_size += 50; code = realloc_code (cfg, max_epilog_size); /* Save the uwind state which is needed by the out-of-line code */ mono_emit_unwind_op_remember_state (cfg, code); - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) { - code = (guint8*)mono_arch_instrument_epilog (cfg, (void*)mono_trace_leave_method, code, TRUE); - } pos = 0; /* Load returned vtypes into registers if needed */ diff --git a/mono/mini/mini-arm64.c b/mono/mini/mini-arm64.c index 5c24a51db4a..b417a69f93c 100644 --- a/mono/mini/mini-arm64.c +++ b/mono/mini/mini-arm64.c @@ -2826,20 +2826,6 @@ mono_arch_is_inst_imm (int opcode, int imm_opcode, gint64 imm) return (imm >= -((gint64)1<<31) && imm <= (((gint64)1<<31)-1)); } -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - NOT_IMPLEMENTED; - return NULL; -} - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - NOT_IMPLEMENTED; - return NULL; -} - void mono_arch_peephole_pass_1 (MonoCompile *cfg, MonoBasicBlock *bb) { diff --git a/mono/mini/mini-mips.c b/mono/mini/mini-mips.c index f945f743d10..da901136c92 100644 --- a/mono/mini/mini-mips.c +++ b/mono/mini/mini-mips.c @@ -27,7 +27,6 @@ #include "mini-mips.h" #include "cpu-mips.h" -#include "trace.h" #include "ir-emit.h" #include "aot-runtime.h" #include "mini-runtime.h" @@ -1355,8 +1354,6 @@ mono_arch_compute_omit_fp (MonoCompile *cfg) cfg->arch.omit_fp = FALSE; if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG)) cfg->arch.omit_fp = FALSE; - if ((mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method))) - cfg->arch.omit_fp = FALSE; /* * On MIPS, fp points to the bottom of the frame, so it can be eliminated even if * there are stack arguments. @@ -1406,10 +1403,6 @@ mono_arch_allocate_vars (MonoCompile *cfg) /* spill down, we'll fix it in a separate pass */ // cfg->flags |= MONO_CFG_HAS_SPILLUP; - /* allow room for the vararg method args: void* and long/double */ - if (mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method)) - cfg->param_area = MAX (cfg->param_area, sizeof (gpointer)*8); - /* this is bug #60332: remove when #59509 is fixed, so no weird vararg * call convs needs to be handled this way. */ @@ -1458,10 +1451,6 @@ mono_arch_allocate_vars (MonoCompile *cfg) /* Space for outgoing parameters, including a0-a3 */ offset += cfg->param_area; - /* allow room to save the return value (if it's a struct) */ - if (mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method)) - offset += 8; - /* Now handle the local variables */ curinst = cfg->locals_start; @@ -4563,63 +4552,6 @@ mono_arch_patch_code (MonoCompile *cfg, MonoMethod *method, MonoDomain *domain, } } -/* - * Allow tracing to work with this interface (with an optional argument) - * - * This code is expected to be inserted just after the 'real' prolog code, - * and before the first basic block. We need to allocate a 2nd, temporary - * stack frame so that we can preserve f12-f15 as well as a0-a3. - */ - -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = p; - int offset = cfg->arch.tracing_offset; - - mips_nop (code); - mips_nop (code); - mips_nop (code); - - MIPS_SW (code, mips_a0, mips_sp, offset + 0*SIZEOF_REGISTER); - MIPS_SW (code, mips_a1, mips_sp, offset + 1*SIZEOF_REGISTER); - MIPS_SW (code, mips_a2, mips_sp, offset + 2*SIZEOF_REGISTER); - MIPS_SW (code, mips_a3, mips_sp, offset + 3*SIZEOF_REGISTER); -#if _MIPS_SIM == _ABIN32 - NOT_IMPLEMENTED; - /* FIXME: Need a separate region for these */ - MIPS_SW (code, mips_a4, mips_sp, offset + 4*SIZEOF_REGISTER); - MIPS_SW (code, mips_a5, mips_sp, offset + 5*SIZEOF_REGISTER); - MIPS_SW (code, mips_a6, mips_sp, offset + 6*SIZEOF_REGISTER); - MIPS_SW (code, mips_a7, mips_sp, offset + 7*SIZEOF_REGISTER); - */ -#endif - - mips_load_const (code, mips_a0, cfg->method); - mips_addiu (code, mips_a1, mips_sp, offset); - mips_call (code, mips_t9, func); - mips_nop (code); - - MIPS_LW (code, mips_a0, mips_sp, offset + 0*SIZEOF_REGISTER); - MIPS_LW (code, mips_a1, mips_sp, offset + 1*SIZEOF_REGISTER); - MIPS_LW (code, mips_a2, mips_sp, offset + 2*SIZEOF_REGISTER); - MIPS_LW (code, mips_a3, mips_sp, offset + 3*SIZEOF_REGISTER); -#if _MIPS_SIM == _ABIN32 - NOT_IMPLEMENTED; - /* - MIPS_LW (code, mips_a4, mips_sp, offset + 4*SIZEOF_REGISTER); - MIPS_LW (code, mips_a5, mips_sp, offset + 5*SIZEOF_REGISTER); - MIPS_LW (code, mips_a6, mips_sp, offset + 6*SIZEOF_REGISTER); - MIPS_LW (code, mips_a7, mips_sp, offset + 7*SIZEOF_REGISTER); - */ -#endif - - mips_nop (code); - mips_nop (code); - mips_nop (code); - return code; -} - void mips_adjust_stackframe(MonoCompile *cfg) { @@ -4782,7 +4714,6 @@ mono_arch_emit_prolog (MonoCompile *cfg) int alloc2_size = 0; guint8 *code; CallInfo *cinfo; - int tracing = 0; guint32 iregs_to_save = 0; #if SAVE_FP_REGS guint32 fregs_to_save = 0; @@ -4791,12 +4722,6 @@ mono_arch_emit_prolog (MonoCompile *cfg) guint32 lmf_offset = cfg->arch.lmf_offset; int cfa_offset = 0; MonoBasicBlock *bb; - - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) - tracing = 1; - - if (tracing) - cfg->flags |= MONO_CFG_HAS_CALLS; sig = mono_method_signature_internal (method); cfg->code_size = 768 + sig->param_count * 20; @@ -5138,129 +5063,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) mono_emit_unwind_op_def_cfa_offset (cfg, code, cfa_offset); } - if (tracing) { -#if _MIPS_SIM == _ABIO32 - cfg->arch.tracing_offset = cfg->stack_offset; -#elif _MIPS_SIM == _ABIN32 - /* no stack slots by default for argument regs, reserve a special block */ - g_assert_not_reached (); -#endif - code = (guint8*)mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE); - } - set_code_cursor (cfg, code); return code; } -enum { - SAVE_NONE, - SAVE_STRUCT, - SAVE_ONE, - SAVE_TWO, - SAVE_FP -}; - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = p; - int save_mode = SAVE_NONE; - MonoMethod *method = cfg->method; - int rtype = mini_get_underlying_type (mono_method_signature_internal (method)->ret)->type; - int save_offset = MIPS_STACK_PARAM_OFFSET; - - g_assert ((save_offset & (MIPS_STACK_ALIGNMENT-1)) == 0); - - set_code_cursor (cfg, code); - /* we need about 16 instructions */ - code = realloc_code (cfg, 16 * 4); - mips_nop (code); - mips_nop (code); - switch (rtype) { - case MONO_TYPE_VOID: - /* special case string .ctor icall */ - if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) - save_mode = SAVE_ONE; - else - save_mode = SAVE_NONE; - break; - case MONO_TYPE_R4: - case MONO_TYPE_R8: - save_mode = SAVE_FP; - break; - case MONO_TYPE_VALUETYPE: - save_mode = SAVE_STRUCT; - break; - case MONO_TYPE_I8: - case MONO_TYPE_U8: -#if SIZEOF_REGISTER == 4 - save_mode = SAVE_TWO; -#elif SIZEOF_REGISTER == 8 - save_mode = SAVE_ONE; -#endif - break; - default: - save_mode = SAVE_ONE; - break; - } - - mips_addiu (code, mips_sp, mips_sp, -32); - g_assert (mips_is_imm16(save_offset)); - switch (save_mode) { - case SAVE_TWO: - mips_sw (code, mips_v0, mips_sp, save_offset); - g_assert (mips_is_imm16(save_offset + SIZEOF_REGISTER)); - mips_sw (code, mips_v1, mips_sp, save_offset + SIZEOF_REGISTER); - if (enable_arguments) { - MIPS_MOVE (code, mips_a1, mips_v0); - MIPS_MOVE (code, mips_a2, mips_v1); - } - break; - case SAVE_ONE: - MIPS_SW (code, mips_v0, mips_sp, save_offset); - if (enable_arguments) { - MIPS_MOVE (code, mips_a1, mips_v0); - } - break; - case SAVE_FP: - mips_sdc1 (code, mips_f0, mips_sp, save_offset); - mips_ldc1 (code, mips_f12, mips_sp, save_offset); - mips_lw (code, mips_a0, mips_sp, save_offset); - g_assert (mips_is_imm16(save_offset + SIZEOF_REGISTER)); - mips_lw (code, mips_a1, mips_sp, save_offset + SIZEOF_REGISTER); - break; - case SAVE_STRUCT: - case SAVE_NONE: - default: - break; - } - mips_load_const (code, mips_a0, cfg->method); - mips_call (code, mips_t9, func); - - switch (save_mode) { - case SAVE_TWO: - mips_lw (code, mips_v0, mips_sp, save_offset); - g_assert (mips_is_imm16(save_offset + SIZEOF_REGISTER)); - mips_lw (code, mips_v1, mips_sp, save_offset + SIZEOF_REGISTER); - break; - case SAVE_ONE: - MIPS_LW (code, mips_v0, mips_sp, save_offset); - break; - case SAVE_FP: - mips_ldc1 (code, mips_f0, mips_sp, save_offset); - break; - case SAVE_STRUCT: - case SAVE_NONE: - default: - break; - } - mips_addiu (code, mips_sp, mips_sp, 32); - mips_nop (code); - mips_nop (code); - return code; -} - guint8 * mono_arch_emit_epilog_sub (MonoCompile *cfg) { @@ -5276,17 +5083,11 @@ mono_arch_emit_epilog_sub (MonoCompile *cfg) if (cfg->method->save_lmf) max_epilog_size += 128; - - if (mono_jit_trace_calls != NULL) - max_epilog_size += 50; realloc_code (cfg, max_epilog_size); code = cfg->native_code + cfg->code_len; - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) { - code = (guint8*)mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE); - } if (cfg->frame_reg != mips_sp) { MIPS_MOVE (code, mips_sp, cfg->frame_reg); } diff --git a/mono/mini/mini-s390x.c b/mono/mini/mini-s390x.c index dcbdb52a9a0..ab4a0dbe483 100644 --- a/mono/mini/mini-s390x.c +++ b/mono/mini/mini-s390x.c @@ -338,7 +338,6 @@ if (ins->inst_true_bb->native_offset) { \ #include "support-s390x.h" #include "jit-icalls.h" #include "ir-emit.h" -#include "trace.h" #include "mini-gc.h" #include "aot-runtime.h" #include "mini-runtime.h" @@ -359,19 +358,6 @@ typedef struct { retStruct; } size_data; -/*------------------------------------------------------------------*/ -/* Used by the instrument_emit_epilog */ -/*------------------------------------------------------------------*/ - -enum { - SAVE_NONE, - SAVE_STRUCT, - SAVE_ONE, - SAVE_TWO, - SAVE_R4, - SAVE_R8 -}; - typedef struct InstList InstList; struct InstList { @@ -435,9 +421,6 @@ typedef struct { static void indent (int); static guint8 * backUpStackPtr(MonoCompile *, guint8 *); -static void decodeParm (MonoType *, void *, int); -static void enter_method (MonoMethod *, RegParm *, char *); -static void leave_method (MonoMethod *, ...); static inline void add_general (guint *, size_data *, ArgInfo *); static inline void add_stackParm (guint *, size_data *, ArgInfo *, gint); static inline void add_float (guint *, size_data *, ArgInfo *, gboolean); @@ -820,563 +803,6 @@ cvtMonoType(MonoTypeEnum t) /*------------------------------------------------------------------*/ /* */ -/* Name - decodeParmString */ -/* */ -/* Function - Decode a parameter string for the trace. */ -/* */ -/*------------------------------------------------------------------*/ - -static void -decodeParmString (MonoString *s) -{ - ERROR_DECL (error); - char *str = mono_string_to_utf8_checked(s, error); - if (is_ok (error)) { - fprintf (trFd, "[STRING:%p:%s], ", s, str); - g_free (str); - } else { - mono_error_cleanup (error); - fprintf (trFd, "[STRING:%p:], ", s); - } -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ -/* Name - decodeParm */ -/* */ -/* Function - Decode a parameter for the trace. */ -/* */ -/*------------------------------------------------------------------*/ - - -static void -decodeParm(MonoType *type, void *curParm, int size) -{ - guint32 simpleType; - - if (type->byref) { - fprintf (trFd, "[BYREF:%p], ", *((char **) curParm)); - } else { - simpleType = mini_get_underlying_type(type)->type; -enum_parmtype: - switch (simpleType) { - case MONO_TYPE_I : - fprintf (trFd, "[INTPTR:%p], ", *((int **) curParm)); - break; - case MONO_TYPE_U : - fprintf (trFd, "[UINTPTR:%p], ", *((int **) curParm)); - break; - case MONO_TYPE_BOOLEAN : - fprintf (trFd, "[BOOL:%ld], ", *((gint64 *) curParm)); - break; - case MONO_TYPE_CHAR : - fprintf (trFd, "[CHAR:%c], ", *((int *) curParm)); - break; - case MONO_TYPE_I1 : - fprintf (trFd, "[INT1:%ld], ", *((gint64 *) curParm)); - break; - case MONO_TYPE_I2 : - fprintf (trFd, "[INT2:%ld], ", *((gint64 *) curParm)); - break; - case MONO_TYPE_I4 : - fprintf (trFd, "[INT4:%ld], ", *((gint64 *) curParm)); - break; - case MONO_TYPE_U1 : - fprintf (trFd, "[UINT1:%lu], ", *((guint64 *) curParm)); - break; - case MONO_TYPE_U2 : - fprintf (trFd, "[UINT2:%lu], ", *((guint64 *) curParm)); - break; - case MONO_TYPE_U4 : - fprintf (trFd, "[UINT4:%lu], ", *((guint64 *) curParm)); - break; - case MONO_TYPE_U8 : - fprintf (trFd, "[UINT8:%lu], ", *((guint64 *) curParm)); - break; - case MONO_TYPE_STRING : { - MonoString *s = *((MonoString **) curParm); - if (s) { - g_assert (((MonoObject *) s)->vtable->klass == mono_defaults.string_class); - decodeParmString (s); - } else { - fprintf (trFd, "[STRING:null], "); - } - break; - } - case MONO_TYPE_CLASS : - case MONO_TYPE_OBJECT : { - MonoObject *obj = *((MonoObject **) curParm); - MonoClass *klass; - if ((obj) && (obj->vtable)) { - fprintf (trFd, "[CLASS/OBJ:"); - klass = obj->vtable->klass; - fprintf (trFd, "%p [%p] ",obj,curParm); - if (klass == mono_defaults.string_class) { - decodeParmString ((MonoString *)obj); - } else if (klass == mono_defaults.int32_class) { - fprintf (trFd, "[INT32:%p:%d]", - obj, *(gint32 *)((char *)obj + MONO_ABI_SIZEOF (MonoObject))); - } else - fprintf (trFd, "[%s.%s:%p]", - m_class_get_name_space (klass), m_class_get_name (klass), obj); - fprintf (trFd, "], "); - } else { - fprintf (trFd, "[OBJECT:null], "); - } - break; - } - case MONO_TYPE_PTR : - fprintf (trFd, "[PTR:%p], ", *((gpointer **) (curParm))); - break; - case MONO_TYPE_FNPTR : - fprintf (trFd, "[FNPTR:%p], ", *((gpointer **) (curParm))); - break; - case MONO_TYPE_ARRAY : - fprintf (trFd, "[ARRAY:%p], ", *((gpointer **) (curParm))); - break; - case MONO_TYPE_SZARRAY : - fprintf (trFd, "[SZARRAY:%p], ", *((gpointer **) (curParm))); - break; - case MONO_TYPE_I8 : - fprintf (trFd, "[INT8:%ld], ", *((gint64 *) (curParm))); - break; - case MONO_TYPE_R4 : - fprintf (trFd, "[FLOAT4:%g], ", *((float *) (curParm))); - break; - case MONO_TYPE_R8 : - fprintf (trFd, "[FLOAT8:%g], ", *((double *) (curParm))); - break; - case MONO_TYPE_VALUETYPE : { - int i; - MonoMarshalType *info; - - if (m_class_is_enumtype (type->data.klass)) { - simpleType = mono_class_enum_basetype_internal (type->data.klass)->type; - fprintf (trFd, "{VALUETYPE} - "); - goto enum_parmtype; - } - - info = mono_marshal_load_type_info (type->data.klass); - - if ((info->native_size == sizeof(float)) && - (info->num_fields == 1) && - (info->fields[0].field->type->type == MONO_TYPE_R4)) { - fprintf (trFd, "[FLOAT4:%f], ", *((float *) (curParm))); - break; - } - - if ((info->native_size == sizeof(double)) && - (info->num_fields == 1) && - (info->fields[0].field->type->type == MONO_TYPE_R8)) { - fprintf (trFd, "[FLOAT8:%g], ", *((double *) (curParm))); - break; - } - - fprintf (trFd, "[VALUETYPE:"); - for (i = 0; i < size; i++) - fprintf (trFd, "%02x,", *((guint8 *)curParm+i)); - fprintf (trFd, "], "); - break; - } - case MONO_TYPE_TYPEDBYREF: { - int i; - fprintf (trFd, "[TYPEDBYREF:"); - for (i = 0; i < size; i++) - fprintf (trFd, "%02x,", *((guint8 *)curParm+i)); - fprintf (trFd, "]"); - break; - } - default : - fprintf (trFd, "[%s], ",cvtMonoType(simpleType)); - } - } -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ -/* Name - enter_method */ -/* */ -/* Function - Perform tracing of the entry to the current */ -/* method. */ -/* */ -/*------------------------------------------------------------------*/ - -static void -enter_method (MonoMethod *method, RegParm *rParm, char *sp) -{ - int i, oParm = 0, iParm = 0; - MonoClass *klass; - MonoObject *obj; - MonoMethodSignature *sig; - char *fname; - guint64 ip; - CallInfo *cinfo; - ArgInfo *ainfo; - void *curParm; - - if (trFd == NULL) { - char buf[32]; - sprintf(buf, "/tmp/mono.%d.trc.%d", getpid(), curThreadNo++); - trFd = fopen(buf, "w"); - } - fname = mono_method_full_name (method, TRUE); - indent (1); - fprintf (trFd, "ENTER: %s ", fname); - g_free (fname); - - ip = (*(guint64 *) (sp+S390_RET_ADDR_OFFSET)); - fprintf (trFd, "ip: %p sp: %p - ", (gpointer) ip, sp); - - if (rParm == NULL) - return; - - sig = mono_method_signature_internal (method); - - cinfo = get_call_info (NULL, sig); - - if (cinfo->struct_ret) { - fprintf (trFd, "[STRUCTRET:%p], ", (gpointer) rParm->gr[0]); - iParm = 1; - } - - if (sig->hasthis) { - gpointer *this_arg = (gpointer *) rParm->gr[iParm]; - obj = (MonoObject *) this_arg; - switch(m_class_get_this_arg (method->klass)->type) { - case MONO_TYPE_VALUETYPE: - if (obj) { - guint64 *value = (guint64 *) ((uintptr_t)this_arg + MONO_ABI_SIZEOF (MonoObject)); - fprintf (trFd, "this:[value:%p:%016lx], ", this_arg, *value); - } else - fprintf (trFd, "this:[NULL], "); - break; - case MONO_TYPE_STRING: - if (obj) { - if (obj->vtable) { - klass = obj->vtable->klass; - if (klass == mono_defaults.string_class) { - fprintf (trFd, "this:"); - decodeParmString((MonoString *)obj); - } else { - fprintf (trFd, "this:%p[%s.%s], ", - obj, m_class_get_name_space (klass), m_class_get_name (klass)); - } - } else - fprintf (trFd, "vtable:[NULL], "); - } else - fprintf (trFd, "this:[NULL], "); - break; - default : - fprintf (trFd, "this[%s]: %p, ",cvtMonoType(m_class_get_this_arg (method->klass)->type),this_arg); - } - oParm++; - } - - for (i = 0; i < sig->param_count; ++i) { - ainfo = &cinfo->args[i + oParm]; - switch (ainfo->regtype) { - case RegTypeGeneral : - decodeParm(sig->params[i], &(rParm->gr[ainfo->reg-2]), ainfo->size); - break; - case RegTypeFP : - case RegTypeFPR4 : - decodeParm(sig->params[i], &(rParm->fp[ainfo->reg]), ainfo->size); - break; - case RegTypeBase : - decodeParm(sig->params[i], sp+ainfo->offset, ainfo->size); - break; - case RegTypeStructByVal : - if (ainfo->reg != STK_BASE) { - int offset = sizeof(glong) - ainfo->size; - curParm = &(rParm->gr[ainfo->reg-2])+offset; - } - else - curParm = sp+ainfo->offset; - - if (retFitsInReg (ainfo->vtsize)) - decodeParm(sig->params[i], - curParm, - ainfo->size); - else - decodeParm(sig->params[i], - *((char **) curParm), - ainfo->vtsize); - break; - case RegTypeStructByAddr : - if (ainfo->reg != STK_BASE) - curParm = &(rParm->gr[ainfo->reg-2]); - else - curParm = sp+ainfo->offset; - - decodeParm(sig->params[i], - *((char **) curParm), - ainfo->vtsize); - break; - - default : - fprintf (trFd, "???, "); - } - } - fprintf (trFd, "\n"); - g_free(cinfo); -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ -/* Name - leave_method */ -/* */ -/* Function - */ -/* */ -/*------------------------------------------------------------------*/ - -static void -leave_method (MonoMethod *method, ...) -{ - MonoType *type; - char *fname; - guint64 ip; - va_list ap; - - va_start(ap, method); - - fname = mono_method_full_name (method, TRUE); - indent (-1); - fprintf (trFd, "LEAVE: %s", fname); - g_free (fname); - - type = mono_method_signature_internal (method)->ret; - -handle_enum: - switch (type->type) { - case MONO_TYPE_VOID: - break; - case MONO_TYPE_BOOLEAN: { - int val = va_arg (ap, int); - if (val) - fprintf (trFd, "[TRUE:%d]", val); - else - fprintf (trFd, "[FALSE]"); - - break; - } - case MONO_TYPE_CHAR: { - int val = va_arg (ap, int); - fprintf (trFd, "[CHAR:%d]", val); - break; - } - case MONO_TYPE_I1: { - int val = va_arg (ap, int); - fprintf (trFd, "[INT1:%d]", val); - break; - } - case MONO_TYPE_U1: { - int val = va_arg (ap, int); - fprintf (trFd, "[UINT1:%d]", val); - break; - } - case MONO_TYPE_I2: { - int val = va_arg (ap, int); - fprintf (trFd, "[INT2:%d]", val); - break; - } - case MONO_TYPE_U2: { - int val = va_arg (ap, int); - fprintf (trFd, "[UINT2:%d]", val); - break; - } - case MONO_TYPE_I4: { - int val = va_arg (ap, int); - fprintf (trFd, "[INT4:%d]", val); - break; - } - case MONO_TYPE_U4: { - int val = va_arg (ap, int); - fprintf (trFd, "[UINT4:%d]", val); - break; - } - case MONO_TYPE_I: { - gint64 val = va_arg (ap, gint64); - fprintf (trFd, "[INT:%ld]", val); - fprintf (trFd, "]"); - break; - } - case MONO_TYPE_U: { - gint64 val = va_arg (ap, gint64); - fprintf (trFd, "[UINT:%lu]", val); - fprintf (trFd, "]"); - break; - } - case MONO_TYPE_STRING: { - MonoString *s = va_arg (ap, MonoString *); -; - if (s) { - g_assert (((MonoObject *)s)->vtable->klass == mono_defaults.string_class); - decodeParmString (s); - } else - fprintf (trFd, "[STRING:null], "); - break; - } - case MONO_TYPE_CLASS: - case MONO_TYPE_OBJECT: { - MonoObject *o = va_arg (ap, MonoObject *); - - if ((o) && (o->vtable)) { - if (o->vtable->klass == mono_defaults.boolean_class) { - fprintf (trFd, "[BOOLEAN:%p:%d]", o, *((guint8 *)o + MONO_ABI_SIZEOF (MonoObject))); - } else if (o->vtable->klass == mono_defaults.int32_class) { - fprintf (trFd, "[INT32:%p:%d]", o, *((gint32 *)((char *)o + MONO_ABI_SIZEOF (MonoObject)))); - } else if (o->vtable->klass == mono_defaults.int64_class) { - fprintf (trFd, "[INT64:%p:%ld]", o, *((gint64 *)((char *)o + MONO_ABI_SIZEOF (MonoObject)))); - } else - fprintf (trFd, "[%s.%s:%p]", m_class_get_name_space (o->vtable->klass), m_class_get_name (o->vtable->klass), o); - } else - fprintf (trFd, "[OBJECT:%p]", o); - - break; - } - case MONO_TYPE_PTR: - case MONO_TYPE_FNPTR: - case MONO_TYPE_ARRAY: - case MONO_TYPE_SZARRAY: { - gpointer p = va_arg (ap, gpointer); - fprintf (trFd, "[result=%p]", p); - break; - } - case MONO_TYPE_I8: { - gint64 l = va_arg (ap, gint64); - fprintf (trFd, "[LONG:%ld]", l); - break; - } - case MONO_TYPE_U8: { - guint64 l = va_arg (ap, guint64); - fprintf (trFd, "[ULONG:%lu]", l); - break; - } - case MONO_TYPE_R4: { - double f = va_arg (ap, double); - fprintf (trFd, "[FLOAT4:%g]\n", f); - break; - } - case MONO_TYPE_R8: { - double f = va_arg (ap, double); - fprintf (trFd, "[FLOAT8:%g]\n", f); - break; - } - case MONO_TYPE_VALUETYPE: { - MonoMarshalType *info; - if (m_class_is_enumtype (type->data.klass)) { - type = mono_class_enum_basetype_internal (type->data.klass); - goto handle_enum; - } else { - int size, align; - - info = mono_marshal_load_type_info (type->data.klass); - - if ((info->native_size == sizeof(float)) && - (info->num_fields == 1) && - (info->fields[0].field->type->type == MONO_TYPE_R4)) { - double f = va_arg (ap, double); - fprintf (trFd, "[FLOAT4:%g]\n", (double) f); - break; - } - - if ((info->native_size == sizeof(double)) && - (info->num_fields == 1) && - (info->fields[0].field->type->type == MONO_TYPE_R8)) { - double f = va_arg (ap, double); - fprintf (trFd, "[FLOAT8:%g]\n", f); - break; - } - - size = mono_type_size (type, &align); - switch (size) { - case 1: { - guint32 p = va_arg (ap, guint32); - fprintf (trFd, "[%02x]\n",p); - break; - } - case 2: { - guint32 p = va_arg (ap, guint32); - fprintf (trFd, "[%04x]\n",p); - break; - } - case 4: { - guint32 p = va_arg (ap, guint32); - fprintf (trFd, "[%08x]\n",p); - break; - } - case 8: { - guint64 p = va_arg (ap, guint64); - fprintf (trFd, "[%016lx]\n",p); - break; - } - default: { - gpointer p = va_arg (ap, gpointer); - fprintf (trFd, "[VALUETYPE] %p\n",p); - } - } - } - break; - } - case MONO_TYPE_TYPEDBYREF: { - guint8 *p = va_arg (ap, gpointer); - int j, size, align; - size = mono_type_size (type, &align); - switch (size) { - case 1: - case 2: - case 4: - case 8: - fprintf (trFd, "["); - for (j = 0; p && j < size; j++) - fprintf (trFd, "%02x,", p [j]); - fprintf (trFd, "]\n"); - break; - default: - fprintf (trFd, "[TYPEDBYREF]\n"); - } - } - break; - case MONO_TYPE_GENERICINST: { - fprintf (trFd, "[GENERICINST]\n"); - } - break; - case MONO_TYPE_MVAR: { - fprintf (trFd, "[MVAR]\n"); - } - break; - case MONO_TYPE_CMOD_REQD: { - fprintf (trFd, "[CMOD_REQD]\n"); - } - break; - case MONO_TYPE_CMOD_OPT: { - fprintf (trFd, "[CMOD_OPT]\n"); - } - break; - case MONO_TYPE_INTERNAL: { - fprintf (trFd, "[INTERNAL]\n"); - } - break; - default: - fprintf (trFd, "(unknown return type %x)", - mono_method_signature_internal (method)->ret->type); - } - - ip = ((gint64) __builtin_extract_return_addr (__builtin_return_address (0))); - fprintf (trFd, " ip: %p\n", (gpointer) ip); - va_end (ap); -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ /* Name - mono_arch_cpu_init */ /* */ /* Function - Perform CPU specific initialization to execute */ @@ -2263,12 +1689,6 @@ mono_arch_allocate_vars (MonoCompile *cfg) cfg->locals_max_stack_offset = offset; /*------------------------------------------------------*/ - /* Allow space for the trace method stack area if needed*/ - /*------------------------------------------------------*/ - if ((mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method))) - offset += S390_TRACE_STACK_SIZE; - - /*------------------------------------------------------*/ /* Reserve space to save LMF and caller saved registers */ /*------------------------------------------------------*/ if (cfg->method->save_lmf) @@ -2670,163 +2090,6 @@ mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) /*------------------------------------------------------------------*/ /* */ -/* Name - mono_arch_instrument_prolog */ -/* */ -/* Function - Create an "instrumented" prolog. */ -/* */ -/*------------------------------------------------------------------*/ - -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, - gboolean enable_arguments) -{ - guchar *code = p; - int parmOffset, - fpOffset, - baseReg; - - parmOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE - cfg->arch.fpSize; - if (cfg->method->save_lmf) - parmOffset -= sizeof(MonoLMF); - fpOffset = parmOffset + (5*sizeof(gpointer)); - baseReg = STK_BASE; - - s390_stmg (code, s390_r2, s390_r6, STK_BASE, parmOffset); - s390_stdy (code, s390_f0, 0, STK_BASE, fpOffset); - s390_stdy (code, s390_f2, 0, STK_BASE, fpOffset+sizeof(gdouble)); - s390_stdy (code, s390_f4, 0, STK_BASE, fpOffset+2*sizeof(gdouble)); - s390_stdy (code, s390_f6, 0, STK_BASE, fpOffset+3*sizeof(gdouble)); - S390_SET (code, s390_r1, func); - S390_SET (code, s390_r2, cfg->method); - s390_lay (code, s390_r3, 0, STK_BASE, parmOffset); - s390_lgr (code, s390_r4, STK_BASE); - s390_aghi (code, s390_r4, cfg->stack_usage); - s390_basr (code, s390_r14, s390_r1); - s390_ldy (code, s390_f6, 0, STK_BASE, fpOffset+3*sizeof(gdouble)); - s390_ldy (code, s390_f4, 0, STK_BASE, fpOffset+2*sizeof(gdouble)); - s390_ldy (code, s390_f2, 0, STK_BASE, fpOffset+sizeof(gdouble)); - s390_ldy (code, s390_f0, 0, STK_BASE, fpOffset); - s390_lmg (code, s390_r2, s390_r6, STK_BASE, parmOffset); - - return code; -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ -/* Name - mono_arch_instrument_epilog */ -/* */ -/* Function - Create an epilog that will handle the returned */ -/* values used in instrumentation. */ -/* */ -/*------------------------------------------------------------------*/ - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = p; - int save_mode = SAVE_NONE, - saveOffset; - MonoMethod *method = cfg->method; - int rtype = mini_get_underlying_type (mono_method_signature_internal (method)->ret)->type; - - set_code_cursor (cfg, code); - /*-----------------------------------------*/ - /* We need about 128 bytes of instructions */ - /*-----------------------------------------*/ - code = realloc_code (cfg, 128); - - saveOffset = cfg->stack_usage - S390_TRACE_STACK_SIZE - cfg->arch.fpSize; - if (method->save_lmf) - saveOffset -= sizeof(MonoLMF); - -handle_enum: - switch (rtype) { - case MONO_TYPE_VOID: - /* special case string .ctor icall */ - if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) - save_mode = SAVE_ONE; - else - save_mode = SAVE_NONE; - break; - case MONO_TYPE_I8: - case MONO_TYPE_U8: - save_mode = SAVE_ONE; - break; - case MONO_TYPE_R4: - save_mode = SAVE_R4; - break; - case MONO_TYPE_R8: - save_mode = SAVE_R8; - break; - case MONO_TYPE_VALUETYPE: - if (m_class_is_enumtype (mono_method_signature_internal (method)->ret->data.klass)) { - rtype = mono_class_enum_basetype_internal (mono_method_signature_internal (method)->ret->data.klass)->type; - goto handle_enum; - } - save_mode = SAVE_STRUCT; - break; - default: - save_mode = SAVE_ONE; - break; - } - - switch (save_mode) { - case SAVE_ONE: - s390_stg (code, s390_r2, 0, cfg->frame_reg, saveOffset); - if (enable_arguments) { - s390_lgr (code, s390_r3, s390_r2); - } - break; - case SAVE_R4: - s390_std (code, s390_f0, 0, cfg->frame_reg, saveOffset); - if (enable_arguments) { - s390_ldebr (code, s390_f0, s390_f0); - } - break; - case SAVE_R8: - s390_std (code, s390_f0, 0, cfg->frame_reg, saveOffset); - break; - case SAVE_STRUCT: - s390_stg (code, s390_r2, 0, cfg->frame_reg, saveOffset); - if (enable_arguments) { - s390_lg (code, s390_r3, 0, cfg->frame_reg, - S390_MINIMAL_STACK_SIZE+cfg->param_area); - } - break; - case SAVE_NONE: - default: - break; - } - - S390_SET (code, s390_r1, func); - S390_SET (code, s390_r2, cfg->method); - s390_basr (code, s390_r14, s390_r1); - - switch (save_mode) { - case SAVE_ONE: - s390_lg (code, s390_r2, 0, cfg->frame_reg, saveOffset); - break; - case SAVE_R4: - case SAVE_R8: - s390_ld (code, s390_f0, 0, cfg->frame_reg, saveOffset); - break; - case SAVE_STRUCT: - s390_lg (code, s390_r2, 0, cfg->frame_reg, saveOffset); - break; - case SAVE_NONE: - default: - break; - } - - return code; -} - -/*========================= End of Function ========================*/ - -/*------------------------------------------------------------------*/ -/* */ /* Name - compare_and_branch */ /* */ /* Function - Form a peephole pass at the code looking for */ @@ -4324,9 +3587,6 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) s390_jcl (code, S390_CC_UN, 0); } - if (mono_jit_trace_calls != NULL && mono_trace_eval(cfg->method)) - indent_level--; - g_free (cinfo); } break; @@ -6147,20 +5407,12 @@ mono_arch_emit_prolog (MonoCompile *cfg) guint8 *code; guint32 size; CallInfo *cinfo; - int tracing = 0, - argsClobbered = 0, + int argsClobbered = 0, lmfOffset, fpOffset = 0, - traceSize = 0; cfg->code_size = 512; - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) { - tracing = 1; - traceSize = S390_TRACE_STACK_SIZE; - cfg->code_size += 256; - } - if (method->save_lmf) cfg->code_size += 200; @@ -6187,7 +5439,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) } cfg->arch.fpSize = fpOffset; - alloc_size = cfg->stack_offset + fpOffset + traceSize; + alloc_size = cfg->stack_offset + fpOffset; cfg->stack_usage = cfa_offset = alloc_size; s390_lgr (code, s390_r11, STK_BASE); @@ -6462,11 +5714,6 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (cfg->method->save_lmf) argsClobbered = TRUE; - if (tracing) { - argsClobbered = TRUE; - code = (guint8*)mono_arch_instrument_prolog (cfg, enter_method, code, TRUE); - } - /* * Optimize the common case of the first bblock making a call with the same * arguments as the method. This works because the arguments are still in their @@ -6557,7 +5804,6 @@ void mono_arch_emit_epilog (MonoCompile *cfg) { MonoMethod *method = cfg->method; - int tracing = 0; guint8 *code; int max_epilog_size = 96; int fpOffset = 0; @@ -6565,16 +5811,8 @@ mono_arch_emit_epilog (MonoCompile *cfg) if (cfg->method->save_lmf) max_epilog_size += 128; - if (mono_jit_trace_calls != NULL) - max_epilog_size += 128; - code = realloc_code (cfg, max_epilog_size); - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) { - code = (guint8*)mono_arch_instrument_epilog (cfg, leave_method, code, TRUE); - tracing = 1; - } - if (method->save_lmf) restoreLMF(code, cfg->frame_reg, cfg->stack_usage); diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c index 93900337352..72233c23bcc 100644 --- a/mono/mini/mini-x86.c +++ b/mono/mini/mini-x86.c @@ -34,7 +34,6 @@ #include #include -#include "trace.h" #include "mini-x86.h" #include "cpu-x86.h" #include "ir-emit.h" @@ -1010,8 +1009,6 @@ needs_stack_frame (MonoCompile *cfg) result = TRUE; else if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG)) result = TRUE; - else if ((mono_jit_trace_calls != NULL && mono_trace_eval (cfg->method))) - result = TRUE; set_needs_stack_frame (cfg, result); @@ -1693,209 +1690,6 @@ mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val) MONO_EMIT_NEW_UNALU (cfg, OP_MOVE, cfg->ret->dreg, val->dreg); } -/* - * Allow tracing to work with this interface (with an optional argument) - */ -void* -mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar*)p; - MonoMethodSignature *sig = mono_method_signature_internal (cfg->method); - int argument_copy_size = 0; - const guint32* param_regs; - int stack_size; - - param_regs = callconv_param_regs (sig); - if (param_regs != NULL) { - /* Need to copy the stack arguments and then store the registers. */ - MonoJitArgumentInfo* arg_info; - int i; - - arg_info = g_newa (MonoJitArgumentInfo, sig->param_count + 1); - - stack_size = mono_arch_get_argument_info (sig, sig->param_count, arg_info); - - argument_copy_size = stack_size; - for (i=0; param_regs[i] != X86_NREG; i++) - argument_copy_size += 4; - - argument_copy_size = ALIGN_TO (argument_copy_size, MONO_ARCH_FRAME_ALIGNMENT); - - x86_alu_reg_imm (code, X86_SUB, X86_ESP, argument_copy_size); - - /* memcpy(esp, ebp, stack_size) */ - for (i=0; i < stack_size; i+=4) { - x86_mov_reg_membase (code, X86_EAX, X86_EBP, i, 4); - x86_mov_membase_reg (code, X86_ESP, i, X86_EAX, 4); - } - - for (i=0; param_regs[i] != X86_NREG; i++) { - x86_mov_membase_reg (code, X86_ESP, stack_size + i*4, param_regs[i], 4); - } - } - - if (argument_copy_size) { - x86_mov_reg_reg (code, X86_EAX, X86_ESP); - } - - g_assert (MONO_ARCH_FRAME_ALIGNMENT >= 8); - x86_alu_reg_imm (code, X86_SUB, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - 8); - - if (argument_copy_size) { - x86_push_reg (code, X86_EAX); - } else { - x86_push_reg (code, X86_EBP); - } - - if (cfg->compile_aot) { - x86_push_imm (code, cfg->method); - x86_mov_reg_imm (code, X86_EAX, func); - x86_call_reg (code, X86_EAX); - } else { - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_METHODCONST, cfg->method); - x86_push_imm (code, cfg->method); - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_ABS, func); - x86_call_code (code, 0); - } - if (param_regs != NULL) { - int i; - - for (i=0; param_regs[i] != X86_NREG; i++) { - x86_mov_reg_membase (code, param_regs[i], X86_ESP, MONO_ARCH_FRAME_ALIGNMENT + stack_size + i*4, 4); - } - } - x86_alu_reg_imm (code, X86_ADD, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT + argument_copy_size); - - return code; -} - -enum { - SAVE_NONE, - SAVE_STRUCT, - SAVE_EAX, - SAVE_EAX_EDX, - SAVE_FP -}; - -void* -mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments) -{ - guchar *code = (guchar*)p; - int arg_size = 0, stack_usage = 0, save_mode = SAVE_NONE; - MonoMethod *method = cfg->method; - MonoType *ret_type = mini_get_underlying_type (mono_method_signature_internal (method)->ret); - - switch (ret_type->type) { - case MONO_TYPE_VOID: - /* special case string .ctor icall */ - if (strcmp (".ctor", method->name) && method->klass == mono_defaults.string_class) { - save_mode = SAVE_EAX; - stack_usage = enable_arguments ? 8 : 4; - } else - save_mode = SAVE_NONE; - break; - case MONO_TYPE_I8: - case MONO_TYPE_U8: - save_mode = SAVE_EAX_EDX; - stack_usage = enable_arguments ? 16 : 8; - break; - case MONO_TYPE_R4: - case MONO_TYPE_R8: - save_mode = SAVE_FP; - stack_usage = enable_arguments ? 16 : 8; - break; - case MONO_TYPE_GENERICINST: - if (!mono_type_generic_inst_is_valuetype (ret_type)) { - save_mode = SAVE_EAX; - stack_usage = enable_arguments ? 8 : 4; - break; - } - /* Fall through */ - case MONO_TYPE_VALUETYPE: - // FIXME: Handle SMALL_STRUCT_IN_REG here for proper alignment on darwin-x86 - save_mode = SAVE_STRUCT; - stack_usage = enable_arguments ? 4 : 0; - break; - default: - save_mode = SAVE_EAX; - stack_usage = enable_arguments ? 8 : 4; - break; - } - - x86_alu_reg_imm (code, X86_SUB, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - stack_usage - 4); - - switch (save_mode) { - case SAVE_EAX_EDX: - x86_push_reg (code, X86_EDX); - x86_push_reg (code, X86_EAX); - if (enable_arguments) { - x86_push_reg (code, X86_EDX); - x86_push_reg (code, X86_EAX); - arg_size = 8; - } - break; - case SAVE_EAX: - x86_push_reg (code, X86_EAX); - if (enable_arguments) { - x86_push_reg (code, X86_EAX); - arg_size = 4; - } - break; - case SAVE_FP: - x86_alu_reg_imm (code, X86_SUB, X86_ESP, 8); - x86_fst_membase (code, X86_ESP, 0, TRUE, TRUE); - if (enable_arguments) { - x86_alu_reg_imm (code, X86_SUB, X86_ESP, 8); - x86_fst_membase (code, X86_ESP, 0, TRUE, TRUE); - arg_size = 8; - } - break; - case SAVE_STRUCT: - if (enable_arguments) { - x86_push_membase (code, X86_EBP, 8); - arg_size = 4; - } - break; - case SAVE_NONE: - default: - break; - } - - if (cfg->compile_aot) { - x86_push_imm (code, method); - x86_mov_reg_imm (code, X86_EAX, func); - x86_call_reg (code, X86_EAX); - } else { - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_METHODCONST, method); - x86_push_imm (code, method); - mono_add_patch_info (cfg, code-cfg->native_code, MONO_PATCH_INFO_ABS, func); - x86_call_code (code, 0); - } - - x86_alu_reg_imm (code, X86_ADD, X86_ESP, arg_size + 4); - - switch (save_mode) { - case SAVE_EAX_EDX: - x86_pop_reg (code, X86_EAX); - x86_pop_reg (code, X86_EDX); - break; - case SAVE_EAX: - x86_pop_reg (code, X86_EAX); - break; - case SAVE_FP: - x86_fld_membase (code, X86_ESP, 0, TRUE); - x86_alu_reg_imm (code, X86_ADD, X86_ESP, 8); - break; - case SAVE_NONE: - default: - break; - } - - x86_alu_reg_imm (code, X86_ADD, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - stack_usage); - - return code; -} - #define EMIT_COND_BRANCH(ins,cond,sign) \ if (ins->inst_true_bb->native_offset) { \ x86_branch (code, cond, cfg->native_code + ins->inst_true_bb->native_offset, sign); \ @@ -5313,9 +5107,6 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (method->save_lmf) code = emit_setup_lmf (cfg, code, cfg->lmf_var->inst_offset, cfa_offset); - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) - code = (guint8*)mono_arch_instrument_prolog (cfg, (gpointer)mono_trace_enter_method, code, TRUE); - { MonoInst *ins; @@ -5386,9 +5177,6 @@ mono_arch_emit_epilog (MonoCompile *cfg) code = realloc_code (cfg, max_epilog_size); - if (mono_jit_trace_calls != NULL && mono_trace_eval (method)) - code = (guint8*)mono_arch_instrument_epilog (cfg, (gpointer)mono_trace_leave_method, code, TRUE); - /* the code restoring the registers must be kept in sync with OP_TAILCALL */ pos = 0; diff --git a/mono/mini/mini.h b/mono/mini/mini.h index f6a9defbee4..b8a7dcb1c96 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -2254,8 +2254,6 @@ void mono_arch_finish_init (void); void mono_arch_cleanup (void); void mono_arch_cpu_init (void); guint32 mono_arch_cpu_optimizations (guint32 *exclude_mask); -void *mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments); -void *mono_arch_instrument_epilog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments); const char *mono_arch_regname (int reg); const char *mono_arch_fregname (int reg); void mono_arch_exceptions_init (void); -- 2.11.4.GIT