procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

expr.c (do_preexpand_calls): Remove.

Browse source 
* expr.c (do_preexpand_calls): Remove.
	(same_from_p): Don't use CALL_EXPR_RTL.
	(expand_expr): Don't call preexpand_calls, or use CALL_EXPR_RTL.
	(preexpand_calls): Remove.
	* tree.c (first_rtl_op): Remove CALL_EXPR case.
	(unsave_expr_1): Likewise.
	* tree.def (CALL_EXPR): Give it only two slots.
	* tree.h (CALL_EXPR_RTL): Remove.

	* optimize.c (copy_body_r): Don't treat CALL_EXPRs specially.

From-SVN: r37012
This commit is contained in:
Mark Mitchell 2000-10-23 04:40:26 +00:00 • committed by Mark Mitchell
parent 0870bfd6d8
commit f9808f81c9
8 changed files with 60 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
gcc/ChangeLog
View file

@ -1,3 +1,14 @@
2000-10-22 Mark Mitchell <mark@codesourcery.com>
* expr.c (do_preexpand_calls): Remove.
(same_from_p): Don't use CALL_EXPR_RTL.
(expand_expr): Don't call preexpand_calls, or use CALL_EXPR_RTL.
(preexpand_calls): Remove.
* tree.c (first_rtl_op): Remove CALL_EXPR case.
(unsave_expr_1): Likewise.
* tree.def (CALL_EXPR): Give it only two slots.
* tree.h (CALL_EXPR_RTL): Remove.
2000-10-21 Chandrakala Chavva <cchavva@redhat.com>
* libgcc-std.ver (__addvsi3, __addvdi3, __subvsi3, __subvdi3,

2
gcc/cp/ChangeLog
View file

@ -1,5 +1,7 @@
2000-10-22 Mark Mitchell <mark@codesourcery.com>
* optimize.c (copy_body_r): Don't treat CALL_EXPRs specially.
* typeck.c (c_sizeof): Return an expression of `size_t' type,
not one with TYPE_IS_SIZETYPE set.
(dubious_conversion_warnings): Remove special-case code.

4
gcc/cp/optimize.c
View file

@ -336,10 +336,6 @@ copy_body_r (tp, walk_subtrees, data)
TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
TREE_OPERAND (*tp, 3) = NULL_TREE;
}
/* Similarly, if we're copying a CALL_EXPR, the RTL for the
result is no longer valid. */
else if (TREE_CODE (*tp) == CALL_EXPR)
CALL_EXPR_RTL (*tp) = NULL_RTX;
}
/* Keep iterating. */

119
gcc/expr.c
View file

@ -102,11 +102,6 @@ int (*lang_safe_from_p) PARAMS ((rtx, tree));
the same indirect address eventually. */
int cse_not_expected;
/* Nonzero to generate code for all the subroutines within an
expression before generating the upper levels of the expression.
Nowadays this is never zero. */
int do_preexpand_calls = 1;
/* Don't check memory usage, since code is being emitted to check a memory
usage. Used when current_function_check_memory_usage is true, to avoid
infinite recursion. */
@ -183,7 +178,6 @@ static rtx var_rtx PARAMS ((tree));
static int readonly_fields_p PARAMS ((tree));
static rtx expand_expr_unaligned PARAMS ((tree, unsigned int *));
static rtx expand_increment PARAMS ((tree, int, int));
static void preexpand_calls PARAMS ((tree));
static void do_jump_by_parts_greater PARAMS ((tree, int, rtx, rtx));
static void do_jump_by_parts_equality PARAMS ((tree, rtx, rtx));
static void do_compare_and_jump PARAMS ((tree, enum rtx_code, enum rtx_code,
@ -5533,16 +5527,11 @@ safe_from_p (x, exp, top_p)
break;
case CALL_EXPR:
exp_rtl = CALL_EXPR_RTL (exp);
if (exp_rtl == 0)
{
/* Assume that the call will clobber all hard registers and
all of memory. */
if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
|| GET_CODE (x) == MEM)
return 0;
}
/* Assume that the call will clobber all hard registers and
all of memory. */
if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
|| GET_CODE (x) == MEM)
return 0;
break;
case RTL_EXPR:
@ -7030,8 +7019,6 @@ expand_expr (exp, target, tmode, modifier)
rtx rlow;
rtx diff, quo, rem, addr, bit, result;
preexpand_calls (exp);
/* If domain is empty, answer is no. Likewise if index is constant
and out of bounds. */
if (((TREE_CODE (set_high_bound) == INTEGER_CST
@ -7154,11 +7141,6 @@ expand_expr (exp, target, tmode, modifier)
return expand_builtin (exp, target, subtarget, tmode, ignore);
}
/* If this call was expanded already by preexpand_calls,
just return the result we got. */
if (CALL_EXPR_RTL (exp) != 0)
return CALL_EXPR_RTL (exp);
return expand_call (exp, target, ignore);
case NON_LVALUE_EXPR:
@ -7354,7 +7336,6 @@ expand_expr (exp, target, tmode, modifier)
|| mode != ptr_mode)
goto binop;
preexpand_calls (exp);
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
subtarget = 0;
@ -7453,7 +7434,6 @@ expand_expr (exp, target, tmode, modifier)
goto binop;
case MULT_EXPR:
preexpand_calls (exp);
/* If first operand is constant, swap them.
Thus the following special case checks need only
check the second operand. */
@ -7580,7 +7560,6 @@ expand_expr (exp, target, tmode, modifier)
case CEIL_DIV_EXPR:
case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR:
preexpand_calls (exp);
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
subtarget = 0;
/* Possible optimization: compute the dividend with EXPAND_SUM
@ -7598,7 +7577,6 @@ expand_expr (exp, target, tmode, modifier)
case FLOOR_MOD_EXPR:
case CEIL_MOD_EXPR:
case ROUND_MOD_EXPR:
preexpand_calls (exp);
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
@ -7760,7 +7738,6 @@ expand_expr (exp, target, tmode, modifier)
case RSHIFT_EXPR:
case LROTATE_EXPR:
case RROTATE_EXPR:
preexpand_calls (exp);
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
@ -7782,7 +7759,6 @@ expand_expr (exp, target, tmode, modifier)
case UNGT_EXPR:
case UNGE_EXPR:
case UNEQ_EXPR:
preexpand_calls (exp);
temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
if (temp != 0)
return temp;
@ -8280,7 +8256,6 @@ expand_expr (exp, target, tmode, modifier)
&& TREE_CODE (lhs) != PARM_DECL
&& ! (TREE_CODE (lhs) == INDIRECT_REF
&& TYPE_READONLY (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
preexpand_calls (exp);
/* Check for |= or &= of a bitfield of size one into another bitfield
of size 1. In this case, (unless we need the result of the
@ -8608,7 +8583,6 @@ expand_expr (exp, target, tmode, modifier)
/* Here to do an ordinary binary operator, generating an instruction
from the optab already placed in `this_optab'. */
binop:
preexpand_calls (exp);
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
subtarget = 0;
op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
@ -9180,88 +9154,6 @@ expand_increment (exp, post, ignore)
return temp;
}
/* Expand all function calls contained within EXP, innermost ones first.
But don't look within expressions that have sequence points.
For each CALL_EXPR, record the rtx for its value
in the CALL_EXPR_RTL field. */
static void
preexpand_calls (exp)
tree exp;
{
register int nops, i;
int class = TREE_CODE_CLASS (TREE_CODE (exp));
if (! do_preexpand_calls)
return;
/* Only expressions and references can contain calls. */
if (! IS_EXPR_CODE_CLASS (class) && class != 'r')
return;
switch (TREE_CODE (exp))
{
case CALL_EXPR:
/* Do nothing if already expanded. */
if (CALL_EXPR_RTL (exp) != 0
/* Do nothing if the call returns a variable-sized object. */
|| (TREE_CODE (TREE_TYPE (exp)) != VOID_TYPE
&& TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)
/* Do nothing to built-in functions. */
|| (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
&& (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
== FUNCTION_DECL)
&& DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
return;
CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
return;
case COMPOUND_EXPR:
case COND_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
/* If we find one of these, then we can be sure
the adjust will be done for it (since it makes jumps).
Do it now, so that if this is inside an argument
of a function, we don't get the stack adjustment
after some other args have already been pushed. */
do_pending_stack_adjust ();
return;
case BLOCK:
case RTL_EXPR:
case WITH_CLEANUP_EXPR:
case CLEANUP_POINT_EXPR:
case TRY_CATCH_EXPR:
return;
case SAVE_EXPR:
if (SAVE_EXPR_RTL (exp) != 0)
return;
default:
break;
}
nops = TREE_CODE_LENGTH (TREE_CODE (exp));
for (i = 0; i < nops; i++)
if (TREE_OPERAND (exp, i) != 0)
{
if (TREE_CODE (exp) == TARGET_EXPR && i == 2)
/* We don't need to preexpand the cleanup for a TARGET_EXPR.
It doesn't happen before the call is made. */
;
else
{
class = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
if (IS_EXPR_CODE_CLASS (class) || class == 'r')
preexpand_calls (TREE_OPERAND (exp, i));
}
}
}
/* At the start of a function, record that we have no previously-pushed
arguments waiting to be popped. */
@ -10428,7 +10320,6 @@ do_store_flag (exp, target, mode, only_cheap)
return 0;
}
preexpand_calls (exp);
if (! get_subtarget (target)
|| GET_MODE (subtarget) != operand_mode
|| ! safe_from_p (subtarget, arg1, 1))

40
gcc/testsuite/g++.old-deja/g++.other/dtor10.C Normal file
View file

@ -0,0 +1,40 @@
// Origin: Mark Mitchell <mark@codesourcery.com>
extern "C" void abort ();
int j;
struct S {
static S* s[5];
S () { s[j++] = this; }
S (const S&) { s[j++] = this; }
~S () {
for (int k = 0; k < j; ++k)
if (s[k] == this)
return;
abort ();
}
};
S* S::s[5];
struct T {
int i;
S s;
};
T t;
T f () {
return t;
}
void g (S) {
};
int main ()
{
g (f ().s);
}

6
gcc/tree.c
View file

@ -1764,8 +1764,6 @@ first_rtl_op (code)
case GOTO_SUBROUTINE_EXPR:
case RTL_EXPR:
return 0;
case CALL_EXPR:
return 2;
case WITH_CLEANUP_EXPR:
/* Should be defined to be 2. */
return 1;
@ -1808,10 +1806,6 @@ unsave_expr_1 (expr)
abort ();
break;
case CALL_EXPR:
CALL_EXPR_RTL (expr) = 0;
break;
default:
if (lang_unsave_expr_now != 0)
(*lang_unsave_expr_now) (expr);

6
gcc/tree.def
View file

@ -454,10 +454,8 @@ DEFTREECODE (BIND_EXPR, "bind_expr", 'e', 3)
/* Function call. Operand 0 is the function.
Operand 1 is the argument list, a list of expressions
made out of a chain of TREE_LIST nodes.
There is no operand 2. That slot is used for the
CALL_EXPR_RTL macro (see preexpand_calls). */
DEFTREECODE (CALL_EXPR, "call_expr", 'e', 3)
made out of a chain of TREE_LIST nodes. */
DEFTREECODE (CALL_EXPR, "call_expr", 'e', 2)
/* Call a method. Operand 0 is the method, whose type is a METHOD_TYPE.
Operand 1 is the expression for "self".

3
gcc/tree.h
View file

@ -780,9 +780,6 @@ struct tree_vec
#define RTL_EXPR_SEQUENCE(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[0])
#define RTL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[1])
/* In a CALL_EXPR node. */
#define CALL_EXPR_RTL(NODE) (*(struct rtx_def **) &EXPR_CHECK (NODE)->exp.operands[2])
/* In a CONSTRUCTOR node. */
#define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND (NODE, 1)