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

        * 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

gcc/ChangeLog

+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.

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.

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);
 

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
@@ -3571,41 +3561,6 @@ setjmp_args_warning (void)
 }
 
 
-/* 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.  */
 /* ??? Need an option to either create block fragments or to create

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);
 	}

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);
 }
 
 

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;
     }
 }
 

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)

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.  */

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;
+}
+

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'.  */

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;

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