From 0beb98b8260f5dbe0cefb85d10761458180dcea0 Mon Sep 17 00:00:00 2001 From: Hiroaki Etoh Date: Tue, 7 Jan 2003 15:22:32 +0000 Subject: prepare_stack_protection: add validate_insns_of_varrefs to validate insns of inline function for processors, which doesn't have long integer addition push_frame_of_insns: validate insns not to use long integer addition for powerpc --- gnu/egcs/gcc/protector.c | 248 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 239 insertions(+), 9 deletions(-) (limited to 'gnu/egcs/gcc/protector.c') diff --git a/gnu/egcs/gcc/protector.c b/gnu/egcs/gcc/protector.c index b42868ef38b..592ec04af40 100644 --- a/gnu/egcs/gcc/protector.c +++ b/gnu/egcs/gcc/protector.c @@ -73,7 +73,6 @@ static int current_function_defines_short_string; static int current_function_has_variable_string; static int current_function_defines_vsized_array; static int current_function_is_inlinable; -static int saved_optimize_size = -1; static rtx guard_area, _guard; static rtx function_first_insn, prologue_insert_point; @@ -105,6 +104,8 @@ static void change_arg_use_of_insns PARAMS ((rtx insn, rtx orig, rtx new, HOST_W static void change_arg_use_in_operand PARAMS ((rtx x, rtx orig, rtx new, HOST_WIDE_INT size)); static void expand_value_return PARAMS ((rtx val)); static int replace_return_reg PARAMS ((rtx insn, rtx return_save)); +static void validate_insns_of_varrefs PARAMS ((rtx insn)); +static void validate_operand_of_varrefs PARAMS ((rtx insn, rtx orig)); static void propagate_virtual_stack_vars_in_insns PARAMS ((rtx insn)); static void propagate_virtual_stack_vars_in_operand PARAMS ((rtx x, rtx orig)); @@ -131,13 +132,10 @@ prepare_stack_protection (inlinable) current_function_is_inlinable = inlinable && !flag_no_inline; push_frame_offset = push_allocated_offset = 0; - /* solve for ssp-ppc-20021125 */ - if (saved_optimize_size < 0) saved_optimize_size = optimize_size; - optimize_size = saved_optimize_size; - /* skip the protection if the function has no block or it is an inline function */ + if (current_function_is_inlinable) validate_insns_of_varrefs (get_insns ()); if (! blocks || current_function_is_inlinable) return; current_function_defines_vulnerable_string = search_string_from_argsandvars (0); @@ -1633,6 +1631,125 @@ expand_value_return (val) } +static void +validate_insns_of_varrefs (insn) + rtx insn; +{ + rtx next; + + /* Initialize recognition, indicating that volatile is OK. */ + init_recog (); + + for (; insn; insn = next) + { + next = NEXT_INSN (insn); + if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN + || GET_CODE (insn) == CALL_INSN) + { + /* excerpt from insn_invalid_p in recog.c */ + int icode = recog_memoized (insn); + + if (icode < 0 && asm_noperands (PATTERN (insn)) < 0) + validate_operand_of_varrefs (insn, PATTERN (insn)); + } + } + + init_recog_no_volatile (); +} + + +static void +validate_operand_of_varrefs (insn, x) + rtx insn, x; +{ + register enum rtx_code code; + int i, j; + const char *fmt; + + if (x == 0) + return; + + code = GET_CODE (x); + + switch (code) + { + case USE: + case CONST_INT: + case CONST_DOUBLE: + case CONST: + case SYMBOL_REF: + case CODE_LABEL: + case PC: + case CC0: + case ASM_INPUT: + case ADDR_VEC: + case ADDR_DIFF_VEC: + case RETURN: + case REG: + case ADDRESSOF: + return; + + case CALL_PLACEHOLDER: + validate_insns_of_varrefs (XEXP (x, 0)); + validate_insns_of_varrefs (XEXP (x, 1)); + validate_insns_of_varrefs (XEXP (x, 2)); + break; + + default: + break; + } + + /* Scan all subexpressions. */ + fmt = GET_RTX_FORMAT (code); + for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) + if (*fmt == 'e') + { + rtx temp, seq; + + /* validate insn of frame register plus constant. */ + if (GET_CODE (XEXP (x, i)) == PLUS + && XEXP (XEXP (x, i), 0) == virtual_stack_vars_rtx + && CONSTANT_P (XEXP (XEXP (x, i), 1))) + { + start_sequence (); + /* temp = force_operand (XEXP (x, i), NULL_RTX); */ + { /* excerpt from expand_binop in optabs.c */ + optab binoptab = add_optab; + enum machine_mode mode = GET_MODE (XEXP (x, i)); + int icode = (int) binoptab->handlers[(int) mode].insn_code; + enum machine_mode mode1 = insn_operand_mode[icode][2]; + rtx pat; + rtx xop0 = XEXP (XEXP (x, i), 0), xop1 = XEXP (XEXP (x, i), 1); + temp = gen_reg_rtx (mode); + + /* Now, if insn's predicates don't allow offset operands, put them into + pseudo regs. */ + + if (! (*insn_operand_predicate[icode][2]) (xop1, mode1) + && mode1 != VOIDmode) + xop1 = copy_to_mode_reg (mode1, xop1); + + pat = GEN_FCN (icode) (temp, xop0, xop1); + if (pat) + emit_insn (pat); + } + seq = get_insns (); + end_sequence (); + + emit_insns_before (seq, insn); + if (! validate_change (insn, &XEXP (x, i), temp, 0)) + abort (); + return; + } + + validate_operand_of_varrefs (insn, XEXP (x, i)); + } + else if (*fmt == 'E') + for (j = 0; j < XVECLEN (x, i); j++) + validate_operand_of_varrefs (insn, XVECEXP (x, i, j)); +} + + static void propagate_virtual_stack_vars_in_insns (insn) rtx insn; @@ -1745,6 +1862,7 @@ static void push_frame_of_reg_equiv_constant PARAMS ((HOST_WIDE_INT push_size, H static void reset_used_flags_for_push_frame PARAMS ((void)); static int check_out_of_frame_access PARAMS ((rtx insn, HOST_WIDE_INT boundary)); static int check_out_of_frame_access_in_operand PARAMS ((rtx, HOST_WIDE_INT boundary)); +static int change_plus_constant PARAMS ((rtx pattern, rtx base, HOST_WIDE_INT offset)); #endif rtx @@ -1768,7 +1886,6 @@ assign_stack_local_for_pseudo_reg (mode, size, align) || current_function_contains_functions) return assign_stack_local (mode, size, align); - optimize_size = 1; /* solve for ssp-ppc-20021125 */ units_per_push = MAX(BIGGEST_ALIGNMENT / BITS_PER_UNIT, GET_MODE_SIZE (mode)); @@ -1993,6 +2110,8 @@ push_frame_in_args (parms, push_size, boundary) } +static int insn_pushed; + static void push_frame_of_insns (insn, push_size, boundary) rtx insn; @@ -2002,9 +2121,58 @@ push_frame_of_insns (insn, push_size, boundary) if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CALL_INSN) { - debuginsn = insn; + insn_pushed = FALSE; debuginsn = insn; push_frame_in_operand (PATTERN (insn), push_size, boundary); + if (insn_pushed) + { + rtx after = insn; + rtx seq = split_insns (PATTERN (insn), insn); + + if (seq && GET_CODE (seq) == SEQUENCE) + { + register int i; + + /* replace the pattern of the insn */ + PATTERN (insn) = PATTERN (XVECEXP (seq, 0, 0)); + + if (XVECLEN (seq, 0) == 2) + { + rtx pattern = PATTERN (XVECEXP (seq, 0, 1)); + + if (GET_CODE (pattern) == SET + && GET_CODE (XEXP (pattern, 0)) == REG + && GET_CODE (XEXP (pattern, 1)) == PLUS + && XEXP (pattern, 0) == XEXP (XEXP (pattern, 1), 0) + && CONSTANT_P (XEXP (XEXP (pattern, 1), 1))) + { + rtx offset = XEXP (XEXP (pattern, 1), 1); + after = NEXT_INSN (insn); + if (change_plus_constant (after, + XEXP (pattern, 0), + INTVAL (offset))) + { + insn = try_split (PATTERN (after), after, 1); + goto next; + } + } + } + + for (i = 1; i < XVECLEN (seq, 0); i++) + { + rtx insn = XVECEXP (seq, 0, i); + add_insn_after (insn, after); + after = insn; + } + + /* Recursively call try_split for each new insn created */ + insn = NEXT_INSN (insn); + for (i = 1; i < XVECLEN (seq, 0); i++, insn = NEXT_INSN (insn)) + insn = try_split (PATTERN (insn), insn, 1); + } + } + + next: /* push frame in NOTE */ push_frame_in_operand (REG_NOTES (insn), push_size, boundary); @@ -2056,7 +2224,7 @@ push_frame_in_operand (orig, push_size, boundary) && boundary == 0) { XEXP (x, 0) = plus_constant (frame_pointer_rtx, push_size); - XEXP (x, 0)->used = 1; + XEXP (x, 0)->used = 1; insn_pushed = TRUE; return; } break; @@ -2078,7 +2246,7 @@ push_frame_in_operand (orig, push_size, boundary) /* XEXP (x, 0) is frame_pointer_rtx */ XEXP (x, 1) = gen_rtx_CONST_INT (VOIDmode, offset); - x->used = 1; + x->used = 1; insn_pushed = TRUE; return; } @@ -2278,4 +2446,66 @@ check_out_of_frame_access_in_operand (orig, boundary) return FALSE; } + + +static int +change_plus_constant (orig, reg, value) + rtx orig, reg; + HOST_WIDE_INT value; +{ + register rtx x = orig; + register enum rtx_code code; + int i, j, result = FALSE; + HOST_WIDE_INT offset; + const char *fmt; + + if (x == 0) + return FALSE; + + code = GET_CODE (x); + switch (code) + { + case CONST_INT: + case CONST_DOUBLE: + case CONST: + case SYMBOL_REF: + case CODE_LABEL: + case PC: + case CC0: + case ASM_INPUT: + case ADDR_VEC: + case ADDR_DIFF_VEC: + case RETURN: + case REG: + case ADDRESSOF: + return FALSE; + + case PLUS: + if (XEXP (x, 0) == reg && CONSTANT_P (XEXP (x, 1))) + { + offset = INTVAL (XEXP (x, 1)); + XEXP (x, 1) = gen_rtx_CONST_INT (VOIDmode, offset + value); + return TRUE; + } + break; + + default: + break; + } + + /* Scan all subexpressions. */ + fmt = GET_RTX_FORMAT (code); + for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) + if (*fmt == 'e') + { + if (change_plus_constant (XEXP (x, i), reg, value)) + result = TRUE; + } + else if (*fmt == 'E') + for (j = 0; j < XVECLEN (x, i); j++) + if (change_plus_constant (XVECEXP (x, i, j), reg, value)) + result = TRUE; + + return result; +} #endif -- cgit v1.2.3