mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-22 18:50:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

expr.c (expand_expr_real_1): Don't handle non-local variables.

Browse Source 
* expr.c (expand_expr_real_1): Don't handle non-local variables.
        * expr.h (fix_lexical_addr): Remove.
        * function.c (NEED_SEPARATE_AP): Remove.
        (fix_lexical_addr): Remove.
        * tree-alias-common.c (get_alias_var_decl): Check TREE_STATIC,
        not null decl_function_context.
        (create_alias_vars): Likewise.
        * tree-cfg.c (make_ctrl_stmt_edges): Don't check for non-local labels.
        (simple_goto_p): Likewise.
        * tree-dfa.c (add_referenced_var): Don't check for non-local variables.
        * tree-ssa-ccp.c (get_default_value): Likewise.
        * tree-tailcall.c (suitable_for_tail_opt_p): Likewise.
        * tree.c (needs_to_live_in_memory): Likewise.
        * tree-flow-inline.h (may_be_aliased): Move...
        * tree-ssa-alias.c (may_be_aliased): ... here.  Enhance check for
        when TREE_STATIC variables may be addressable.

From-SVN: r85099
This commit is contained in:
Richard Henderson 2004-07-23 15:37:23 -07:00 committed by Richard Henderson
parent 5aa33bdb4f
commit ab8907ef75
13 changed files with 66 additions and 111 deletions

19
gcc/ChangeLog

@ -1,3 +1,22 @@
2004-07-23 Richard Henderson <rth@redhat.com>
* expr.c (expand_expr_real_1): Don't handle non-local variables.
* expr.h (fix_lexical_addr): Remove.
* function.c (NEED_SEPARATE_AP): Remove.
(fix_lexical_addr): Remove.
* tree-alias-common.c (get_alias_var_decl): Check TREE_STATIC,
not null decl_function_context.
(create_alias_vars): Likewise.
* tree-cfg.c (make_ctrl_stmt_edges): Don't check for non-local labels.
(simple_goto_p): Likewise.
* tree-dfa.c (add_referenced_var): Don't check for non-local variables.
* tree-ssa-ccp.c (get_default_value): Likewise.
* tree-tailcall.c (suitable_for_tail_opt_p): Likewise.
* tree.c (needs_to_live_in_memory): Likewise.
* tree-flow-inline.h (may_be_aliased): Move...
* tree-ssa-alias.c (may_be_aliased): ... here. Enhance check for
when TREE_STATIC variables may be addressable.
2004-07-24 Jakub Jelinek <jakub@redhat.com>
* Makefile.in (site.exp): Add HOSTCC and HOSTCFLAGS to site.exp.

34
gcc/expr.c

@ -6368,33 +6368,15 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
/* Show we haven't gotten RTL for this yet. */
temp = 0;
/* Handle variables inherited from containing functions. */
/* Variables inherited from containing functions should have
been lowered by this point. */
context = decl_function_context (exp);
if (context != 0 && context != current_function_decl
/* If var is static, we don't need a static chain to access it. */
&& ! (MEM_P (DECL_RTL (exp))
&& CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
{
rtx addr;
/* Mark as non-local and addressable. */
DECL_NONLOCAL (exp) = 1;
if (DECL_NO_STATIC_CHAIN (current_function_decl))
abort ();
lang_hooks.mark_addressable (exp);
if (!MEM_P (DECL_RTL (exp)))
abort ();
addr = XEXP (DECL_RTL (exp), 0);
if (MEM_P (addr))
addr
= replace_equiv_address (addr,
fix_lexical_addr (XEXP (addr, 0), exp));
else
addr = fix_lexical_addr (addr, exp);
temp = replace_equiv_address (DECL_RTL (exp), addr);
}
if (context != 0
&& context != current_function_decl
&& !TREE_STATIC (exp)
/* ??? C++ creates functions that are not TREE_STATIC. */
&& TREE_CODE (exp) != FUNCTION_DECL)
abort ();
/* This is the case of an array whose size is to be determined
from its initializer, while the initializer is still being parsed.

4
gcc/expr.h

@ -556,10 +556,6 @@ extern rtx expr_size (tree);
if the size can vary or is larger than an integer. */
extern HOST_WIDE_INT int_expr_size (tree);
/* Convert a stack slot address ADDR valid in function FNDECL
into an address valid in this function (using a static chain). */
extern rtx fix_lexical_addr (rtx, tree);
/* Return the address of the trampoline for entering nested fn FUNCTION. */
extern rtx trampoline_address (tree);

45
gcc/function.c

@ -87,16 +87,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
alignment. */
#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
/* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
during rtl generation. If they are different register numbers, this is
always true. It may also be true if
FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
generation. See fix_lexical_addr for details. */
#if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
#define NEED_SEPARATE_AP
#endif
/* Nonzero if function being compiled doesn't contain any calls
(ignoring the prologue and epilogue). This is set prior to
local register allocation and is valid for the remaining
@ -3570,41 +3560,6 @@ setjmp_args_warning (void)
decl, decl);
}
/* Convert a stack slot address ADDR for variable VAR
(from a containing function)
into an address valid in this function (using a static chain). */
rtx
fix_lexical_addr (rtx addr, tree var)
{
rtx basereg;
HOST_WIDE_INT displacement;
tree context = decl_function_context (var);
struct function *fp;
rtx base = 0;
/* If this is the present function, we need not do anything. */
if (context == current_function_decl)
return addr;
fp = find_function_data (context);
/* Decode given address as base reg plus displacement. */
if (REG_P (addr))
basereg = addr, displacement = 0;
else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
else
abort ();
if (base == 0)
abort ();
/* Use same offset, relative to appropriate static chain or argument
pointer. */
return plus_constant (base, displacement);
}
/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
and create duplicate blocks. */

8
gcc/tree-alias-common.c

@ -154,11 +154,7 @@ get_alias_var_decl (tree decl)
newvar = create_alias_var (decl);
/* Assign globals to global var for purposes of intraprocedural
analysis. */
if ((DECL_CONTEXT (decl) == NULL
|| TREE_PUBLIC (decl)
|| TREE_STATIC (decl)
|| decl_function_context (decl) == NULL)
&& decl != pta_global_var)
if (TREE_STATIC (decl) && decl != pta_global_var)
{
current_alias_ops->addr_assign (current_alias_ops,
get_alias_var (pta_global_var),
@ -1016,7 +1012,7 @@ create_alias_vars (void)
{
var = TREE_VALUE (vars);
if (TREE_CODE (var) != LABEL_DECL
&& decl_function_context (var) == NULL
&& TREE_STATIC (var)
&& DECL_INITIAL (var))
find_func_aliases (var);
}

11
gcc/tree-cfg.c

@ -459,17 +459,12 @@ static void
make_ctrl_stmt_edges (basic_block bb)
{
tree last = last_stmt (bb);
tree first = first_stmt (bb);
#if defined ENABLE_CHECKING
if (last == NULL_TREE)
abort();
#endif
if (TREE_CODE (first) == LABEL_EXPR
&& DECL_NONLOCAL (LABEL_EXPR_LABEL (first)))
make_edge (ENTRY_BLOCK_PTR, bb, EDGE_ABNORMAL);
switch (TREE_CODE (last))
{
case GOTO_EXPR:
@ -2541,10 +2536,8 @@ computed_goto_p (tree t)
bool
simple_goto_p (tree expr)
{
return (TREE_CODE (expr) == GOTO_EXPR
&& TREE_CODE (GOTO_DESTINATION (expr)) == LABEL_DECL
&& (decl_function_context (GOTO_DESTINATION (expr))
== current_function_decl));
return (TREE_CODE (expr) == GOTO_EXPR
&& TREE_CODE (GOTO_DESTINATION (expr)) == LABEL_DECL);
}

5
gcc/tree-dfa.c

@ -903,11 +903,6 @@ add_referenced_var (tree var, struct walk_state *walk_state)
/* Global and static variables are call-clobbered, always. */
if (needs_to_live_in_memory (var))
mark_call_clobbered (var);
/* DECL_NONLOCAL variables should not be removed, as they are needed
to emit nested functions. */
if (DECL_NONLOCAL (var))
v_ann->used = 1;
}
}

8
gcc/tree-flow-inline.h

@ -635,14 +635,6 @@ loop_containing_stmt (tree stmt)
return bb->loop_father;
}
/* Return true if VAR may be aliased. */
static inline bool
may_be_aliased (tree var)
{
return (TREE_ADDRESSABLE (var)
|| decl_function_context (var) != current_function_decl);
}
/* Return true if VAR is a clobbered by function calls. */
static inline bool
is_call_clobbered (tree var)

2
gcc/tree-flow.h

@ -325,7 +325,6 @@ static inline tree immediate_use (dataflow_t, int);
static inline dataflow_t get_immediate_uses (tree);
static inline void set_default_def (tree, tree);
static inline tree default_def (tree);
static inline bool may_be_aliased (tree);
/*---------------------------------------------------------------------------
Structure representing predictions in tree level.
@ -554,6 +553,7 @@ extern void dump_points_to_info (FILE *);
extern void debug_points_to_info (void);
extern void dump_points_to_info_for (FILE *, tree);
extern void debug_points_to_info_for (tree);
extern bool may_be_aliased (tree);
/* Call-back function for walk_use_def_chains(). At each reaching
definition, a function with this prototype is called. */

31
gcc/tree-ssa-alias.c

@ -2473,3 +2473,34 @@ debug_may_aliases_for (tree var)
{
dump_may_aliases_for (stderr, var);
}
/* Return true if VAR may be aliased. */
bool
may_be_aliased (tree var)
{
/* Obviously. */
if (TREE_ADDRESSABLE (var))
return true;
/* Automatic variables can't have their addresses escape any other way. */
if (!TREE_STATIC (var))
return false;
/* Globally visible variables can have their addresses taken by other
translation units. */
if (DECL_EXTERNAL (var) || TREE_PUBLIC (var))
return true;
/* If we're in unit-at-a-time mode, then we must have seen all occurrences
of address-of operators, and so we can trust TREE_ADDRESSABLE. Otherwise
we can only be sure the variable isn't addressable if it's local to the
current function. */
if (flag_unit_at_a_time)
return false;
if (decl_function_context (var) == current_function_decl)
return false;
return true;
}

3
gcc/tree-ssa-ccp.c

@ -2390,8 +2390,7 @@ get_default_value (tree var)
/* Function arguments and volatile variables are considered VARYING. */
val.lattice_val = VARYING;
}
else if (decl_function_context (sym) != current_function_decl
|| TREE_STATIC (sym))
else if (TREE_STATIC (sym))
{
/* Globals and static variables are considered UNKNOWN_VAL,
unless they are declared 'const'. */

3
gcc/tree-tailcall.c

@ -143,8 +143,7 @@ suitable_for_tail_opt_p (void)
{
tree var = VARRAY_TREE (referenced_vars, i);
if (decl_function_context (var) == current_function_decl
&& !TREE_STATIC (var)
if (!TREE_STATIC (var)
&& var_ann (var)->mem_tag_kind == NOT_A_TAG
&& is_call_clobbered (var))
return false;

4
gcc/tree.c

@ -5671,10 +5671,8 @@ needs_to_live_in_memory (tree t)
return (DECL_NEEDS_TO_LIVE_IN_MEMORY_INTERNAL (t)
|| TREE_STATIC (t)
|| DECL_EXTERNAL (t)
|| DECL_NONLOCAL (t)
|| (TREE_CODE (t) == RESULT_DECL
&& aggregate_value_p (t, current_function_decl))
|| decl_function_context (t) != current_function_decl);
&& aggregate_value_p (t, current_function_decl)));
}
/* There are situations in which a language considers record types