CbC/CbC_gcc: gcc/varpool.c comparison

comparison gcc/varpool.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 /* Callgraph handling code.
-Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2010
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
 #include "cgraph.h"
 #include "langhooks.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
 #include "hashtab.h"
 #include "ggc.h"
 #include "timevar.h"
 #include "debug.h"
 #include "target.h"
 return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 }
 /* Return varpool node assigned to DECL without creating new one.  */
 struct varpool_node *
-varpool_get_node (tree decl)
+varpool_get_node (const_tree decl)
 {
 struct varpool_node key, **slot;
-gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
+gcc_assert (TREE_CODE (decl) == VAR_DECL
+	      && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)));
 if (!varpool_hash)
 return NULL;
-key.decl = decl;
+key.decl = CONST_CAST2 (tree, const_tree, decl);
 slot = (struct varpool_node **)
-htab_find_slot (varpool_hash, &key, INSERT);
+htab_find_slot (varpool_hash, &key, NO_INSERT);
+if (!slot)
+return NULL;
 return *slot;
 }
 /* Return varpool node assigned to DECL.  Create new one when needed.  */
 struct varpool_node *
 varpool_node (tree decl)
 {
 struct varpool_node key, *node, **slot;
-gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
+gcc_assert (TREE_CODE (decl) == VAR_DECL
+	      && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)));
 if (!varpool_hash)
 varpool_hash = htab_create_ggc (10, hash_varpool_node,
 					   eq_varpool_node, NULL);
 key.decl = decl;
 slot = (struct varpool_node **)
 htab_find_slot (varpool_hash, &key, INSERT);
 if (*slot)
 return *slot;
-node = GGC_CNEW (struct varpool_node);
+node = ggc_alloc_cleared_varpool_node ();
 node->decl = decl;
 node->order = cgraph_order++;
 node->next = varpool_nodes;
 ipa_empty_ref_list (&node->ref_list);
 if (varpool_nodes)
 fprintf (f, " finalized");
 if (node->output)
 fprintf (f, " output");
 if (node->externally_visible)
 fprintf (f, " externally_visible");
+if (node->resolution != LDPR_UNKNOWN)
+fprintf (f, " %s",
+	     ld_plugin_symbol_resolution_names[(int)node->resolution]);
 if (node->in_other_partition)
 fprintf (f, " in_other_partition");
 else if (node->used_from_other_partition)
 fprintf (f, " used_from_other_partition");
 fprintf (f, "\n");
 dump_varpool_node (f, node);
 }
 /* Dump the variable pool to stderr.  */
-void
+DEBUG_FUNCTION void
 debug_varpool (void)
 {
 dump_varpool (stderr);
 }
 either outside this translation unit, something magic in the system
 configury */
 bool
 decide_is_variable_needed (struct varpool_node *node, tree decl)
 {
-if (node->used_from_other_partition)
+/* If the user told us it is used, then it must be so.  */
+if (node->force_output)
 return true;
-/* If the user told us it is used, then it must be so.  */
-if ((node->externally_visible && !DECL_COMDAT (decl))
+gcc_assert (!DECL_EXTERNAL (decl));
-|| node->force_output)
-return true;
 /* Externally visible variables must be output.  The exception is
 COMDAT variables that must be output only when they are needed.  */
 if (TREE_PUBLIC (decl)
-&& !flag_whole_program
-&& !flag_lto
-&& !flag_whopr
 && !DECL_COMDAT (decl)
 && !DECL_EXTERNAL (decl))
 return true;
-/* When emulating tls, we actually see references to the control
-variable, rather than the user-level variable.  */
-if (!targetm.have_tls
-&& TREE_CODE (decl) == VAR_DECL
-&& DECL_THREAD_LOCAL_P (decl))
-{
-tree control = emutls_decl (decl);
-if (decide_is_variable_needed (varpool_node (control), control))
-	return true;
-}
 /* When not reordering top level variables, we have to assume that
 we are going to keep everything.  */
-if (flag_toplevel_reorder)
+if (!flag_toplevel_reorder)
+return true;
+return false;
+}
+/* Return if DECL is constant and its initial value is known (so we can do
+constant folding using DECL_INITIAL (decl)).  */
+bool
+const_value_known_p (tree decl)
+{
+if (TREE_CODE (decl) != VAR_DECL
+&&TREE_CODE (decl) != CONST_DECL)
 return false;
-/* We want to emit COMDAT variables only when absolutely necessary.  */
+if (TREE_CODE (decl) == CONST_DECL
-if (DECL_COMDAT (decl))
+|| DECL_IN_CONSTANT_POOL (decl))
+return true;
+gcc_assert (TREE_CODE (decl) == VAR_DECL);
+if (!TREE_READONLY (decl) || TREE_THIS_VOLATILE (decl))
 return false;
+/* Gimplifier takes away constructors of local vars  */
+if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
+return DECL_INITIAL (decl) != NULL;
+gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
+/* Variables declared 'const' without an initializer
+have zero as the initializer if they may not be
+overridden at link or run time.  */
+if (!DECL_INITIAL (decl)
+&& (DECL_EXTERNAL (decl)
+	  || decl_replaceable_p (decl)))
+return false;
+/* Variables declared `const' with an initializer are considered
+to not be overwritable with different initializer by default.
+??? Previously we behaved so for scalar variables but not for array
+accesses.  */
 return true;
 }
 /* Mark DECL as finalized.  By finalizing the declaration, frontend instruct the
 middle end to output the variable to asm file, if needed or externally
 visible.  */
 void
 varpool_finalize_decl (tree decl)
 {
 struct varpool_node *node = varpool_node (decl);
+gcc_assert (TREE_STATIC (decl));
 /* The first declaration of a variable that comes through this function
 decides whether it is global (in C, has external linkage)
 or local (in C, has internal linkage).  So do nothing more
 if this function has already run.  */
 node->finalized = true;
 if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl))
 node->force_output = true;
 if (decide_is_variable_needed (node, decl))
-varpool_mark_needed_node (node);
-/* Since we reclaim unreachable nodes at the end of every language
-level unit, we need to be conservative about possible entry points
-there.  */
-else if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
 varpool_mark_needed_node (node);
 if (cgraph_global_info_ready)
 varpool_assemble_pending_decls ();
 }
 if (!TREE_PUBLIC (node->decl))
 return AVAIL_AVAILABLE;
 /* If the variable can be overwritten, return OVERWRITABLE.  Takes
 care of at least two notable extensions - the COMDAT variables
 used to share template instantiations in C++.  */
-if (!(*targetm.binds_local_p) (node->decl) && !DECL_COMDAT (node->decl))
+if (!decl_replaceable_p (node->decl))
 return AVAIL_OVERWRITABLE;
 return AVAIL_AVAILABLE;
 }
 /* Walk the decls we marked as necessary and see if they reference new
 {
 struct varpool_node *next, *node = varpool_nodes_queue;
 varpool_reset_queue ();
-if (errorcount || sorrycount)
+if (seen_error ())
 return;
 while (node)
 {
-tree decl = node->decl;
 next = node->next_needed;
 node->needed = 0;
-if (node->finalized
+if (node->analyzed
-	  && (decide_is_variable_needed (node, decl)
+	  && (!varpool_can_remove_if_no_refs (node)
-	      /* ??? Cgraph does not yet rule the world with an iron hand,
+	      /* We just expanded all function bodies.  See if any of
-		 and does not control the emission of debug information.
+		 them needed the variable.  */
-		 After a variable has its DECL_RTL set, we must assume that
+	      || DECL_RTL_SET_P (node->decl)))
-		 it may be referenced by the debug information, and we can
-		 no longer elide it.  */
-	      || DECL_RTL_SET_P (decl)))
 	varpool_mark_needed_node (node);
 node = next;
 }
 /* Make sure we mark alias targets as used targets.  */
 finish_aliases_1 ();
 varpool_analyze_pending_decls ();
 }
+/* For variables in named sections make sure get_variable_section
+is called before we switch to those sections.  Then section
+conflicts between read-only and read-only requiring relocations
+sections can be resolved.  */
+void
+varpool_finalize_named_section_flags (struct varpool_node *node)
+{
+if (!TREE_ASM_WRITTEN (node->decl)
+&& !node->alias
+&& !node->in_other_partition
+&& !DECL_EXTERNAL (node->decl)
+&& TREE_CODE (node->decl) == VAR_DECL
+&& !DECL_HAS_VALUE_EXPR_P (node->decl)
+&& DECL_SECTION_NAME (node->decl))
+get_variable_section (node->decl, false);
+}
 /* Output all variables enqueued to be assembled.  */
 bool
 varpool_assemble_pending_decls (void)
 {
 bool changed = false;
+struct varpool_node *node;
-if (errorcount || sorrycount)
+if (seen_error ())
 return false;
 timevar_push (TV_VAROUT);
 /* EH might mark decls as needed during expansion.  This should be safe since
 we don't create references to new function, but it should not be used
 elsewhere.  */
 varpool_analyze_pending_decls ();
+for (node = varpool_nodes_queue; node; node = node->next_needed)
+varpool_finalize_named_section_flags (node);
 while (varpool_nodes_queue)
 {
 struct varpool_node *node = varpool_nodes_queue;
 }
 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
 Extra name aliases are output whenever DECL is output.  */
-bool
+struct varpool_node *
 varpool_extra_name_alias (tree alias, tree decl)
 {
 struct varpool_node key, *alias_node, *decl_node, **slot;
 #ifndef ASM_OUTPUT_DEF
 slot = (struct varpool_node **) htab_find_slot (varpool_hash, &key, INSERT);
 /* If the varpool_node has been already created, fail.  */
 if (*slot)
-return false;
+return NULL;
-alias_node = GGC_CNEW (struct varpool_node);
+alias_node = ggc_alloc_cleared_varpool_node ();
 alias_node->decl = alias;
 alias_node->alias = 1;
 alias_node->extra_name = decl_node;
 alias_node->next = decl_node->extra_name;
 ipa_empty_ref_list (&alias_node->ref_list);
 if (decl_node->extra_name)
 decl_node->extra_name->prev = alias_node;
 decl_node->extra_name = alias_node;
 *slot = alias_node;
-return true;
+return alias_node;
+}
+/* Return true when NODE is known to be used from other (non-LTO) object file.
+Known only when doing LTO via linker plugin.  */
+bool
+varpool_used_from_object_file_p (struct varpool_node *node)
+{
+struct varpool_node *alias;
+if (!TREE_PUBLIC (node->decl))
+return false;
+if (resolution_used_from_other_file_p (node->resolution))
+return true;
+for (alias = node->extra_name; alias; alias = alias->next)
+if (TREE_PUBLIC (alias->decl)
+	&& resolution_used_from_other_file_p (alias->resolution))
+return true;
+return false;
 }
 #include "gt-varpool.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/varpool.c @ 67:f6334be47118