CbC/CbC_gcc: gcc/symtab.c comparison

comparison gcc/symtab.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Symbol table.
-Copyright (C) 2012-2018 Free Software Foundation, Inc.
+Copyright (C) 2012-2020 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 {
 unlink_from_assembler_name_hash (node, false);
 insert_to_assembler_name_hash (node, false);
 }
-/* Initalize asm name hash unless.  */
+/* Initialize asm name hash unless.  */
 void
 symbol_table::symtab_initialize_asm_name_hash (void)
 {
 symtab_node *node;
 return;
 do
 {
 next = n->same_comdat_group;
 n->same_comdat_group = NULL;
+if (dyn_cast <cgraph_node *> (n))
+	dyn_cast <cgraph_node *> (n)->calls_comdat_local = false;
 /* Clear comdat_group for comdat locals, since
 make_decl_local doesn't.  */
 if (!TREE_PUBLIC (n->decl))
 	n->set_comdat_group (NULL);
 n = next;
 {
 return get_dump_name (true);
 }
 /* Return ipa reference from this symtab_node to
-REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
+REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
 of the use.  */
 ipa_ref *
 symtab_node::create_reference (symtab_node *referred_node,
 			       enum ipa_ref_use use_type)
 return create_reference (referred_node, use_type, NULL);
 }
 /* Return ipa reference from this symtab_node to
-REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
+REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
 of the use and STMT the statement (if it exists).  */
 ipa_ref *
 symtab_node::create_reference (symtab_node *referred_node,
 			       enum ipa_ref_use use_type, gimple *stmt)
 ref->referring = this;
 ref->referred = referred_node;
 ref->stmt = stmt;
 ref->lto_stmt_uid = 0;
+ref->speculative_id = 0;
 ref->use = use_type;
 ref->speculative = 0;
 /* If vector was moved in memory, update pointers.  */
 if (old_references != list->references->address ())
 unsigned int stmt_uid = ref->lto_stmt_uid;
 ref2 = create_reference (ref->referred, ref->use, ref->stmt);
 ref2->speculative = speculative;
 ref2->lto_stmt_uid = stmt_uid;
+ref2->speculative_id = ref->speculative_id;
 }
 }
 /* Clone all referring from symtab NODE to this symtab_node.  */
 unsigned int stmt_uid = ref->lto_stmt_uid;
 ref2 = ref->referring->create_reference (this, ref->use, ref->stmt);
 ref2->speculative = speculative;
 ref2->lto_stmt_uid = stmt_uid;
+ref2->speculative_id = ref->speculative_id;
 }
 }
 /* Clone reference REF to this symtab_node and set its stmt to STMT.  */
 ipa_ref *ref2;
 ref2 = create_reference (ref->referred, ref->use, stmt);
 ref2->speculative = speculative;
 ref2->lto_stmt_uid = stmt_uid;
+ref2->speculative_id = ref->speculative_id;
 return ref2;
 }
 /* Find the structure describing a reference to REFERRED_NODE
 and associated with statement STMT.  */
 else
 i++;
 }
 /* Remove all stmt references in non-speculative references.
-Those are not maintained during inlining & clonning.
+Those are not maintained during inlining & cloning.
 The exception are speculative references that are updated along
 with callgraph edges associated with them.  */
 void
 symtab_node::clear_stmts_in_references (void)
 for (i = 0; iterate_reference (i, r); i++)
 if (!r->speculative)
 {
 	r->stmt = NULL;
 	r->lto_stmt_uid = 0;
+	r->speculative_id = 0;
 }
 }
 /* Remove all references in ref list.  */
 }
 fprintf (file, "\n");
 }
 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
+/* Dump the visibility of the symbol.  */
+const char *
+symtab_node::get_visibility_string () const
+{
+static const char * const visibility_types[]
+= { "default", "protected", "hidden", "internal" };
+return visibility_types[DECL_VISIBILITY (decl)];
+}
+/* Dump the type_name of the symbol.  */
+const char *
+symtab_node::get_symtab_type_string () const
+{
+return symtab_type_names[type];
+}
 /* Dump base fields of symtab nodes to F.  Not to be used directly.  */
 void
 symtab_node::dump_base (FILE *f)
 fprintf (f, " alias");
 if (transparent_alias)
 fprintf (f, " transparent_alias");
 if (weakref)
 fprintf (f, " weakref");
+if (symver)
+fprintf (f, " symver");
 if (cpp_implicit_alias)
 fprintf (f, " cpp_implicit_alias");
 if (alias_target)
 fprintf (f, " target:%s",
 	     DECL_P (alias_target)
 if (DECL_STATIC_CONSTRUCTOR (decl))
 	fprintf (f, " constructor");
 if (DECL_STATIC_DESTRUCTOR (decl))
 	fprintf (f, " destructor");
 }
+if (ifunc_resolver)
+fprintf (f, " ifunc_resolver");
 fprintf (f, "\n");
 if (same_comdat_group)
 fprintf (f, "  Same comdat group as: %s\n",
 	     same_comdat_group->dump_asm_name ());
 if (next_sharing_asm_name)
 fprintf (f, "  next sharing asm name: %i\n",
 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
 vnode->dump (f);
 }
 void
+symtab_node::dump_graphviz (FILE *f)
+{
+if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
+cnode->dump_graphviz (f);
+}
+void
 symbol_table::dump (FILE *f)
 {
 symtab_node *node;
 fprintf (f, "Symbol table:\n\n");
 FOR_EACH_SYMBOL (node)
 node->dump (f);
+}
+void
+symbol_table::dump_graphviz (FILE *f)
+{
+symtab_node *node;
+fprintf (f, "digraph symtab {\n");
+FOR_EACH_SYMBOL (node)
+node->dump_graphviz (f);
+fprintf (f, "}\n");
 }
 DEBUG_FUNCTION void
 symbol_table::debug (void)
 {
 dump (stderr);
 }
 /* Verify common part of symtab nodes.  */
+#if __GNUC__ >= 10
+/* Disable warnings about missing quoting in GCC diagnostics for
+the verification errors.  Their format strings don't follow GCC
+diagnostic conventions and the calls are ultimately followed by
+one to internal_error.  */
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wformat-diag"
+#endif
 DEBUG_FUNCTION bool
 symtab_node::verify_base (void)
 {
 bool error_found = false;
 symtab_node *hashed_node;
 	}
 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))
 		!= NULL)
 	       != dyn_cast <cgraph_node *> (this)->ifunc_resolver)
 	{
-error ("inconsistent `ifunc' attribute");
+	  error ("inconsistent %<ifunc%> attribute");
 error_found = true;
 	}
 }
 else if (is_a <varpool_node *> (this))
 {
 	}
 }
 if (symtab->assembler_name_hash)
 {
 hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
-if (hashed_node && hashed_node->previous_sharing_asm_name)
+if (hashed_node)
 	{
-error ("assembler name hash list corrupted");
+	  if (hashed_node->previous_sharing_asm_name)
-error_found = true;
+	    {
-	}
+	      error ("assembler name hash list corrupted");
-while (hashed_node)
+	      error_found = true;
-	{
+	    }
-	  if (hashed_node == this)
+	  else if (previous_sharing_asm_name == NULL)
-	    break;
+	    {
-	  hashed_node = hashed_node->next_sharing_asm_name;
+	      if (hashed_node != this)
-	}
+		{
-if (!hashed_node
+		  error ("assembler name hash list corrupted");
-	  && !(is_a <varpool_node *> (this)
+		  error_found = true;
-	       && DECL_HARD_REGISTER (decl)))
+		}
-	{
+	    }
-error ("node not found in symtab assembler name hash");
+	  else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl)))
-error_found = true;
+	    {
+	      if (!asmname_hasher::equal (previous_sharing_asm_name,
+					  DECL_ASSEMBLER_NAME (decl)))
+		{
+		  error ("node not found in symtab assembler name hash");
+		  error_found = true;
+		}
+	    }
 	}
 }
 if (previous_sharing_asm_name
 && previous_sharing_asm_name->next_sharing_asm_name != this)
 {
 error_found = true;
 }
 if (transparent_alias && !alias)
 {
 error ("node is transparent_alias but not an alias");
+error_found = true;
+}
+if (symver && !alias)
+{
+error ("node is symver but not alias");
+error_found = true;
+}
+/* Limitation of gas requires us to output targets of symver aliases as
+global symbols.  This is binutils PR 25295.  */
+if (symver
+&& (!TREE_PUBLIC (get_alias_target ()->decl)
+	  || DECL_VISIBILITY (get_alias_target ()->decl) != VISIBILITY_DEFAULT))
+{
+error ("symver target is not exported with default visibility");
+error_found = true;
+}
+if (symver
+&& (!TREE_PUBLIC (decl)
+	  || DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT))
+{
+error ("symver is not exported with default visibility");
 error_found = true;
 }
 if (same_comdat_group)
 {
 symtab_node *n = same_comdat_group;
 	    }
 	}
 }
 if (implicit_section && !get_section ())
 {
-error ("implicit_section flag is set but section isn't");
+error ("implicit_section flag is set but section isn%'t");
 error_found = true;
 }
 if (get_section () && get_comdat_group ()
 && !implicit_section
 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl)))
 && (!get_section()
 	  || !get_alias_target ()->get_section ()
 	  || strcmp (get_section(),
 		     get_alias_target ()->get_section ())))
 {
-error ("Alias and target's section differs");
+error ("Alias and target%'s section differs");
 get_alias_target ()->dump (stderr);
 error_found = true;
 }
 if (alias && definition
 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
 {
-error ("Alias and target's comdat groups differs");
+error ("Alias and target%'s comdat groups differs");
 get_alias_target ()->dump (stderr);
 error_found = true;
 }
 if (transparent_alias && definition && !weakref)
 {
 const char *name2
 	= IDENTIFIER_POINTER (
 	    ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
 if (!symbol_table::assembler_names_equal_p (name1, name2))
 	{
-	  error ("Transparent alias and target's assembler names differs");
+	  error ("Transparent alias and target%'s assembler names differs");
 	  get_alias_target ()->dump (stderr);
 	  error_found = true;
 	}
 }
 if (transparent_alias && definition
 	    }
 	}
 }
 }
+#if __GNUC__ >= 10
+#  pragma GCC diagnostic pop
+#endif
 /* Make DECL local.  FIXME: We shouldn't need to mess with rtl this early,
 but other code such as notice_global_symbol generates rtl.  */
 void
 symtab_node::make_decl_local (void)
 /* To determine visibility of the target, we follow ELF semantic of aliases.
 Here alias is an alternative assembler name of a given definition. Its
 availability prevails the availability of its target (i.e. static alias of
 weak definition is available.
-Transaparent alias is just alternative anme of a given symbol used within
+Transparent alias is just alternative name of a given symbol used within
 one compilation unit and is translated prior hitting the object file.  It
 inherits the visibility of its target.
 Weakref is a different animal (and noweak definition is weak).
 If we ever get into supporting targets with different semantics, a target
 /* Set section of symbol and its aliases.  */
 void
 symtab_node::set_section (const char *section)
 {
-gcc_assert (!this->alias);
+gcc_assert (!this->alias || !this->analyzed);
 call_for_symbol_and_aliases
 (symtab_node::set_section, const_cast<char *>(section), true);
 }
 /* Return the initialization priority.  */
 }
 h = priority_info ();
 h->init = priority;
 }
-/* Set fialization priority to PRIORITY.  */
+/* Set finalization priority to PRIORITY.  */
 void
 cgraph_node::set_fini_priority (priority_type priority)
 {
 symbol_priority_map *h;
 	  alias_alias->remove_from_same_comdat_group ();
 	  alias_alias->set_comdat_group (NULL);
 	  if (target->get_comdat_group ())
 	    alias_alias->add_to_same_comdat_group (target);
 	}
-if (!alias_alias->transparent_alias || transparent)
+if ((!alias_alias->transparent_alias
+	   && !alias_alias->symver)
+	  || transparent)
 	{
 	  alias_alias->remove_all_references ();
 	  alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
 	}
 else i++;
 return true;
 }
 return false;
 }
-/* If node can not be overwriten by static or dynamic linker to point to
+/* If node cannot be overwriten by static or dynamic linker to point to
 different definition, return NODE. Otherwise look for alias with such
 property and if none exists, introduce new one.  */
 symtab_node *
 symtab_node::noninterposable_alias (void)
 /* First try to look up existing alias or base object
 (if that is already non-overwritable).  */
 symtab_node *node = ultimate_alias_target ();
 gcc_assert (!node->alias && !node->weakref);
 node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias,
-				   (void *)&new_node, true);
+				     (void *)&new_node, true);
 if (new_node)
 return new_node;
 /* If aliases aren't supported by the assembler, fail.  */
 if (!TARGET_SUPPORTS_ALIASES)
 return NULL;
 /* Otherwise create a new one.  */
 new_decl = copy_node (node->decl);
 DECL_DLLIMPORT_P (new_decl) = 0;
-DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias");
+tree name = clone_function_name (node->decl, "localalias");
+if (!flag_wpa)
+{
+unsigned long num = 0;
+/* In the rare case we already have a localalias, but the above
+	 node->call_for_symbol_and_aliases call didn't find any suitable,
+	 iterate until we find one not used yet.  */
+while (symtab_node::get_for_asmname (name))
+	name = clone_function_name (node->decl, "localalias", num++);
+}
+DECL_NAME (new_decl) = name;
 if (TREE_CODE (new_decl) == FUNCTION_DECL)
 DECL_STRUCT_FUNCTION (new_decl) = NULL;
 DECL_INITIAL (new_decl) = NULL;
 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
 SET_DECL_RTL (new_decl, NULL);
 if (TREE_CODE (new_decl) == FUNCTION_DECL)
 {
 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
 new_node = cgraph_node::create_alias (new_decl, node->decl);
+cgraph_node *new_cnode = dyn_cast <cgraph_node *> (new_node),
+		   *cnode = dyn_cast <cgraph_node *> (node);
+new_cnode->unit_id = cnode->unit_id;
+new_cnode->merged_comdat = cnode->merged_comdat;
+new_cnode->merged_extern_inline = cnode->merged_extern_inline;
 }
 else
 {
 TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
 DECL_INITIAL (new_decl) = error_mark_node;
 enum symbol_partitioning_class
 symtab_node::get_partitioning_class (void)
 {
 /* Inline clones are always duplicated.
-This include external delcarations.   */
+This include external declarations.   */
 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
 if (DECL_ABSTRACT_P (decl))
 return SYMBOL_EXTERNAL;
-if (cnode && cnode->global.inlined_to)
+if (cnode && cnode->inlined_to)
 return SYMBOL_DUPLICATE;
 /* Transparent aliases are always duplicated.  */
 if (transparent_alias)
 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
 /* External declarations are external.  */
 if (DECL_EXTERNAL (decl))
 return SYMBOL_EXTERNAL;
+/* Even static aliases of external functions as external.  Those can happen
+when COMDAT got resolved to non-IL implementation.  */
+if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
+return SYMBOL_EXTERNAL;
 if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
 {
 if (alias && definition && !ultimate_alias_target ()->definition)
 	return SYMBOL_EXTERNAL;
-/* Constant pool references use local symbol names that can not
+/* Constant pool references use local symbol names that cannot
 be promoted global.  We should never put into a constant pool
-objects that can not be duplicated across partitions.  */
+objects that cannot be duplicated across partitions.  */
 if (DECL_IN_CONSTANT_POOL (decl))
 	return SYMBOL_DUPLICATE;
 if (DECL_HARD_REGISTER (decl))
 	return SYMBOL_DUPLICATE;
 gcc_checking_assert (vnode->definition);
 	{
 	  symtab_node *target = ultimate_alias_target ();
 	  if (target->alias && target->weakref)
 	    return false;
-	  /* We can not recurse to target::nonzero.  It is possible that the
+	  /* We cannot recurse to target::nonzero.  It is possible that the
 	     target is used only via the alias.
 	     We may walk references and look for strong use, but we do not know
 	     if this strong use will survive to final binary, so be
 	     conservative here.
 	     ??? Maybe we could do the lookup during late optimization that
 /* With !flag_delete_null_pointer_checks we assume that symbols may
 bind to NULL. This is on by default on embedded targets only.
 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
-linking fails.  Important case of WEAK we want to do well are comdats.
+linking fails.  Important case of WEAK we want to do well are comdats,
-Those are handled by later check for definition.
+which also must be defined somewhere.
 When parsing, beware the cases when WEAK attribute is added later.  */
-if (!DECL_WEAK (decl)
+if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
 && flag_delete_null_pointer_checks)
 {
 refuse_visibility_changes = true;
 return true;
 }
-/* If target is defined and either comdat or not extern, we know it will be
+/* If target is defined and not extern, we know it will be
 output and thus it will bind to non-NULL.
 Play safe for flag_delete_null_pointer_checks where weak definition may
 be re-defined by NULL.  */
-if (definition && (!DECL_EXTERNAL (decl) || DECL_COMDAT (decl))
+if (definition && !DECL_EXTERNAL (decl)
 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
 {
 if (!DECL_WEAK (decl))
 refuse_visibility_changes = true;
 return true;
 Return 1 if symbol is known to have same address as S2,
 return -1 otherwise.
 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
 and S2 is going to be accessed.  This eliminates the situations when
-either THIS or S2 is NULL and is seful for comparing bases when deciding
+either THIS or S2 is NULL and is useful for comparing bases when deciding
 about memory aliasing.  */
 int
 symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
 {
 enum availability avail1, avail2;
 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
 bool really_binds_local1 = binds_local1;
 bool really_binds_local2 = binds_local2;
-/* Addresses of vtables and virtual functions can not be used by user
+/* Addresses of vtables and virtual functions cannot be used by user
 code and are used only within speculation.  In this case we may make
 symbol equivalent to its alias even if interposition may break this
 rule.  Doing so will allow us to turn speculative inlining into
-non-speculative more agressively.  */
+non-speculative more aggressively.  */
 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
 binds_local1 = true;
 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
 binds_local2 = true;
 if (rs2 != s2)
 s2->refuse_visibility_changes = true;
 return 1;
 }
-/* If both symbols may resolve to NULL, we can not really prove them
+/* If both symbols may resolve to NULL, we cannot really prove them
 different.  */
 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
 return -1;
 /* Except for NULL, functions and variables never overlap.  */
 /* If one of the symbols is unresolved alias, punt.  */
 if (rs1->alias || rs2->alias)
 return -1;
 /* If we have a non-interposale definition of at least one of the symbols
-and the other symbol is different, we know other unit can not interpose
+and the other symbol is different, we know other unit cannot interpose
 it to the first symbol; all aliases of the definition needs to be
 present in the current unit.  */
 if (((really_binds_local1 || really_binds_local2)
 /* If we have both definitions and they are different, we know they
 	 will be different even in units they binds to.  */
 return 0;
 }
 /* TODO: Alias oracle basically assume that addresses of global variables
 are different unless they are declared as alias of one to another while
-the code folding comparsions doesn't.
+the code folding comparisons doesn't.
 We probably should be consistent and use this fact here, too, but for
 the moment return false only when we are called from the alias oracle.  */
 return memory_accessed && rs1 != rs2 ? 0 : -1;
 }
 /* With -fno-toplevel-reorder we may have already output the constant.  */
 if (TREE_ASM_WRITTEN (target->decl))
 return false;
-/* If target is already placed in an anchor, we can not touch its
+/* If target is already placed in an anchor, we cannot touch its
 alignment.  */
 if (DECL_RTL_SET_P (target->decl)
 && MEM_P (DECL_RTL (target->decl))
 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
 return false;
 return false;
 if (decl_binds_to_current_def_p (decl))
 return true;
 /* Inline clones always binds locally.  */
-if (cnode && cnode->global.inlined_to)
+if (cnode && cnode->inlined_to)
 return true;
 if (DECL_EXTERNAL (decl))
 return false;
 if (ref)
 {
 cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
 if (cref)
-	ref = cref->global.inlined_to;
+	ref = cref->inlined_to;
 }
 /* If this is a reference from symbol itself and there are no aliases, we
 may be sure that the symbol was not interposed by something else because
 the symbol itself would be unreachable otherwise.  This is important
 return false;
 /* FIXME: variables probably should not be considered as real symbols at
 first place.  */
 if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
 return false;
-/* FIXME: Builtins corresponding to real functions probably should have
+if (TREE_CODE (decl) == FUNCTION_DECL && !definition
-symbol table entries.  */
+&& fndecl_built_in_p (decl))
-if (TREE_CODE (decl) == FUNCTION_DECL && fndecl_built_in_p (decl))
+{
-return false;
+/* Builtins like those for most math functions have actual implementations
+	 in libraries so make sure to output references into the symbol table to
+	 make those libraries referenced.  Note this is incomplete handling for
+	 now and only covers math functions.  */
+if (builtin_with_linkage_p (decl))
+	return true;
+else
+	return false;
+}
 /* We have real symbol that should be in symbol table.  However try to trim
-down the refernces to libraries bit more because linker will otherwise
+down the references to libraries bit more because linker will otherwise
-bring unnecesary object files into the final link.
+bring unnecessary object files into the final link.
 FIXME: The following checks can easily be confused i.e. by self recursive
 function or self-referring variable.  */
 /* We keep external functions in symtab for sake of inlining
 and devirtualization.  We do not want to see them in symbol table as
 && cnode->callers)
 return true;
 /* Ignore all references from external vars initializers - they are not really
 part of the compilation unit until they are used by folding.  Some symbols,
-like references to external construction vtables can not be referred to at
+like references to external construction vtables cannot be referred to at
 all.  We decide this at can_refer_decl_in_current_unit_p.  */
 if (!definition || DECL_EXTERNAL (decl))
 {
 int i;
 struct ipa_ref *ref;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/symtab.c @ 145:1830386684a0