OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge debug-early branch into mainline. 

* dwarf2out.c: Remove deferred_locations*.
	(dwarf2_debug_hooks): Add early_finish hook.
	Remove global_decl hook.
	Add early_global_decl and late_global_decl hook.
	New global early_dwarf.
	New structure set_early_dwarf.
	(output_die): Indicate whether a DIE was generated early
	when generating assembly with -dA.
	(struct limbo_die_struct): Document created_for field.
	Remove file_table_last_lookup.
	(remove_AT): Return TRUE if successful.
	(remove_child_TAG): Clear die_parent.
	(reparent_child): New function abstracted from...
	(splice_child_die): ...here.
	(new_die): ICE if a DIE ends up in limbo too late.
	(check_die): New.
	(defer_location): Remove.
	(add_subscript_info): Reuse DW_TAG_subrange_type if available.
	(fill_variable_array_bounds): New.
	(decl_start_label): Call fill_variable_array_bounds.
	(gen_formal_parameter_die): Rewrite to reuse previously generated
	DIEs.
	(gen_subprogram_die): Same.
	(gen_variable_die): Same.
	(gen_const_die): Same.
	(gen_label_die): Same.
	(gen_lexical_block_die): Same.
	(decl_will_get_specification_p): New.
	(local_function_static): New.
	(gen_struct_or_union_type_die): Fill in variable-length fields.
	(gen_typedef_die): Fill in variable-length typedefs.
	(gen_tagged_type_die): Gracefully return on error_mark_node.
	Handle re-entrancy.
	(gen_type_die_with_usage): Handle variable-length types.
	Remove duplicate code for ARRAY_TYPE case.
	(process_scope_var): Only process imported modules during early
	dwarf.
	(dwarf2out_early_global_decl): New.
	(dwarf2out_late_global_decl): Rename from dwarf2out_global_decl.
	(dwarf2out_type_decl): Set early_dwarf while calling
	dwarf2out_decl.
	(dwarf2out_decl): Verify that we did not recreate a previously
	generated DIE.
	Do not return on DECL_EXTERNALs in VAR_DECLs.
	Abstract some code to local_function_static.
	(lookup_filename): Remove use of file_table_last_lookup.
	Gracefully exit on missing file_name.
	(dwarf2out_finish): Verify limbo list.
	Remove deferred_locations_list use.
	Move deferred_asm_name and limbo flushing to...
	(dwarf2out_early_finish): ...here.  New.
	(dwarf2out_c_finalize): Remove set of deferred_location_list,
	deferred_asm_name, and file_table_last_lookup.
	* cgraph.h (referred_to_p): Add default argument.
	* cgraphunit.c (referred_to_p): Add and handle include_self
	argument.
	(analyze_functions): Add first_time argument.
	Call check_global_declaration for all symbols.
	Call late_global_decl for nodes for moribund nodes.
	(finalize_compilation_unit): Add new argument to
	analyze_functions.
	Call early_global_decl for functions.
	Call early_finish debug hook.
	* dbxout.c (dbxout_early_global_decl): New.
	(dbxout_late_global_decl): New.  Adapted from dbxout_global_decl.
	(dbx_debug_hooks): Add new hooks.
	(xcoff_debug_hooks): Same.
	* debug.c (do_nothing_debug_hooks): Add early_finish field.
	Add early and late debug hooks.
	Remove global_decl hook.
	* debug.h (struct gcc_debug_hooks): Add early_finish,
	early_global_decl, and late_global_decl fields.
	Remove global_decl field.
	Document gcc_debug_hooks.
	* gengtype.c (output_typename): Remove.
	* godump.c (go_early_global_decl): New.
	(go_late_global_decl): New.
	(go_global_decl): Remove.
	(dump_go_spec_init): Remove global_decl.  Add
	{early,late}_global_decl.
	* langhooks-def.h (LANG_HOOKS_WRITE_GLOBALS): Remove.
	(LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS): New.
	* langhooks.c (lhd_warn_unused_global_decl): Adjust comment.
	(write_global_declarations): Remove.
	(global_decl_processing): New.
	* langhooks.h (struct lang_hooks_for_decls): Remove
	final_write_globals field.
	Add post_compilation_parsing_cleanups field.
	* passes.c (rest_of_decl_compilation): Call early_global_decl.
	* sdbout.c: Add early and late_global_decl hooks.  Remove
	sdbout_global_decl hook.
	Add early_finish field for sdb_debug_hooks.
	(sdbout_global_decl): Remove.
	(sdbout_early_global_decl): New.
	(sdbout_late_global_decl): New.
	* timevar.def (TV_PHASE_LATE_PARSING_CLEANUPS): New.
	* toplev.c (check_global_declaration): Rename from
	check_global_declaration_1.
	Adapt to use symtab infrastructure.
	(check_global_declarations): Remove.
	(emit_debug_global_declarations): Remove.
	(compile_file): Remove call to final_write_globals langhook.
	Run the actual compilation process.
	Perform any post compilation parser cleanups.
	Generate late debug info.
	* toplev.h (check_global_declaration): New.
	(check_global_declaration_1): Remove.
	(check_global_declarations): Remove.
	(write_global_declarations): Remove.
	(emit_debug_global_declarations): Remove.
	(global_decl_processing): New.
	* tree-core.h (struct tree_block): Add DIE field.
	* tree.h (BLOCK_DIE): New.
	* vmsdbgout.c (vmsdbgout_global_decl): Remove function and its use
	throughout.
	(vmsdbgout_early_global_decl): New.
	(vmsdbgout_late_global_decl): New.
	Add early_finish debug hook field to vmsdbg_debug_hooks.
	Remove vmsdbgout_decl to vmsdbgout_function_decl.
	Add early and late_global_decl debug hooks.

From-SVN: r224161
This commit is contained in:
Aldy Hernandez 2015-06-05 18:44:53 +00:00 committed by Aldy Hernandez
parent 46ba128114
commit d7438551ff
70 changed files with 1415 additions and 657 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
gcc/ChangeLog
View File

@ -1,3 +1,126 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* dwarf2out.c: Remove deferred_locations*.
(dwarf2_debug_hooks): Add early_finish hook.
Remove global_decl hook.
Add early_global_decl and late_global_decl hook.
New global early_dwarf.
New structure set_early_dwarf.
(output_die): Indicate whether a DIE was generated early
when generating assembly with -dA.
(struct limbo_die_struct): Document created_for field.
Remove file_table_last_lookup.
(remove_AT): Return TRUE if successful.
(remove_child_TAG): Clear die_parent.
(reparent_child): New function abstracted from...
(splice_child_die): ...here.
(new_die): ICE if a DIE ends up in limbo too late.
(check_die): New.
(defer_location): Remove.
(add_subscript_info): Reuse DW_TAG_subrange_type if available.
(fill_variable_array_bounds): New.
(decl_start_label): Call fill_variable_array_bounds.
(gen_formal_parameter_die): Rewrite to reuse previously generated
DIEs.
(gen_subprogram_die): Same.
(gen_variable_die): Same.
(gen_const_die): Same.
(gen_label_die): Same.
(gen_lexical_block_die): Same.
(decl_will_get_specification_p): New.
(local_function_static): New.
(gen_struct_or_union_type_die): Fill in variable-length fields.
(gen_typedef_die): Fill in variable-length typedefs.
(gen_tagged_type_die): Gracefully return on error_mark_node.
Handle re-entrancy.
(gen_type_die_with_usage): Handle variable-length types.
Remove duplicate code for ARRAY_TYPE case.
(process_scope_var): Only process imported modules during early
dwarf.
(dwarf2out_early_global_decl): New.
(dwarf2out_late_global_decl): Rename from dwarf2out_global_decl.
(dwarf2out_type_decl): Set early_dwarf while calling
dwarf2out_decl.
(dwarf2out_decl): Verify that we did not recreate a previously
generated DIE.
Do not return on DECL_EXTERNALs in VAR_DECLs.
Abstract some code to local_function_static.
(lookup_filename): Remove use of file_table_last_lookup.
Gracefully exit on missing file_name.
(dwarf2out_finish): Verify limbo list.
Remove deferred_locations_list use.
Move deferred_asm_name and limbo flushing to...
(dwarf2out_early_finish): ...here. New.
(dwarf2out_c_finalize): Remove set of deferred_location_list,
deferred_asm_name, and file_table_last_lookup.
* cgraph.h (referred_to_p): Add default argument.
* cgraphunit.c (referred_to_p): Add and handle include_self
argument.
(analyze_functions): Add first_time argument.
Call check_global_declaration for all symbols.
Call late_global_decl for nodes for moribund nodes.
(finalize_compilation_unit): Add new argument to
analyze_functions.
Call early_global_decl for functions.
Call early_finish debug hook.
* dbxout.c (dbxout_early_global_decl): New.
(dbxout_late_global_decl): New. Adapted from dbxout_global_decl.
(dbx_debug_hooks): Add new hooks.
(xcoff_debug_hooks): Same.
* debug.c (do_nothing_debug_hooks): Add early_finish field.
Add early and late debug hooks.
Remove global_decl hook.
* debug.h (struct gcc_debug_hooks): Add early_finish,
early_global_decl, and late_global_decl fields.
Remove global_decl field.
Document gcc_debug_hooks.
* gengtype.c (output_typename): Remove.
* godump.c (go_early_global_decl): New.
(go_late_global_decl): New.
(go_global_decl): Remove.
(dump_go_spec_init): Remove global_decl. Add
{early,late}_global_decl.
* langhooks-def.h (LANG_HOOKS_WRITE_GLOBALS): Remove.
(LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS): New.
* langhooks.c (lhd_warn_unused_global_decl): Adjust comment.
(write_global_declarations): Remove.
(global_decl_processing): New.
* langhooks.h (struct lang_hooks_for_decls): Remove
final_write_globals field.
Add post_compilation_parsing_cleanups field.
* passes.c (rest_of_decl_compilation): Call early_global_decl.
* sdbout.c: Add early and late_global_decl hooks. Remove
sdbout_global_decl hook.
Add early_finish field for sdb_debug_hooks.
(sdbout_global_decl): Remove.
(sdbout_early_global_decl): New.
(sdbout_late_global_decl): New.
* timevar.def (TV_PHASE_LATE_PARSING_CLEANUPS): New.
* toplev.c (check_global_declaration): Rename from
check_global_declaration_1.
Adapt to use symtab infrastructure.
(check_global_declarations): Remove.
(emit_debug_global_declarations): Remove.
(compile_file): Remove call to final_write_globals langhook.
Run the actual compilation process.
Perform any post compilation parser cleanups.
Generate late debug info.
* toplev.h (check_global_declaration): New.
(check_global_declaration_1): Remove.
(check_global_declarations): Remove.
(write_global_declarations): Remove.
(emit_debug_global_declarations): Remove.
(global_decl_processing): New.
* tree-core.h (struct tree_block): Add DIE field.
* tree.h (BLOCK_DIE): New.
* vmsdbgout.c (vmsdbgout_global_decl): Remove function and its use
throughout.
(vmsdbgout_early_global_decl): New.
(vmsdbgout_late_global_decl): New.
Add early_finish debug hook field to vmsdbg_debug_hooks.
Remove vmsdbgout_decl to vmsdbgout_function_decl.
Add early and late_global_decl debug hooks.
2015-06-05 Julian Brown <julian@codesourcery.com>
Sandra Loosemore <sandra@codesourcery.com>

14
gcc/ada/ChangeLog
View File

@ -1,3 +1,17 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* gcc-interface/gigi.h (note_types_used_by_globals): Rename from
gnat_write_global_declarations.
* gcc-interface/misc.c (gnat_parse_file): Call
note_types_used_by_globals.
Remove LANG_HOOKS_WRITE_GLOBALS.
* gcc-interface/utils.c: Rename global_decls to type_decls.
(gnat_write_global_declarations): Rename
to note_types_used_by_globals.
Remove call to finalize_compilation_unit.
Remove debug_hooks->global_decl() call for globals.
(gnat_pushdecls): Only insert into type_decls if TYPE_DECL.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* gcc-interface/cuintp.c: Adjust includes for restructured coretypes.h.

7
gcc/ada/gcc-interface/decl.c
View File

@ -5185,6 +5185,13 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
&& !Present (Alias (gnat_entity))
&& !(Present (Renamed_Object (gnat_entity)) && saved))
{
/* ?? DECL_ARTIFICIAL, and possibly DECL_IGNORED_P below, should
be set before calling rest_of_decl_compilation above (through
create_var_decl_1). This is because rest_of_decl_compilation
calls the debugging backend and will create a DIE without
DW_AT_artificial.
This is currently causing gnat.dg/specs/debug1.ads to FAIL. */
if (!Comes_From_Source (gnat_entity))
DECL_ARTIFICIAL (gnu_decl) = 1;

5
gcc/ada/gcc-interface/gigi.h
View File

@ -531,8 +531,9 @@ extern tree gnat_type_for_size (unsigned precision, int unsignedp);
an unsigned type; otherwise a signed type is returned. */
extern tree gnat_type_for_mode (machine_mode mode, int unsignedp);
/* Emit debug info for all global variable declarations. */
extern void gnat_write_global_declarations (void);
/* Keep track of types used at the global level and emit debug info
for all global types. */
extern void note_types_used_by_globals (void);
/* Return the unsigned version of a TYPE_NODE, a scalar type. */
extern tree gnat_unsigned_type (tree type_node);

4
gcc/ada/gcc-interface/misc.c
View File

@ -117,6 +117,8 @@ gnat_parse_file (void)
/* Call the front end. */
_ada_gnat1drv ();
note_types_used_by_globals ();
}
/* Return language mask for option processing. */
@ -969,8 +971,6 @@ gnat_init_ts (void)
#define LANG_HOOKS_GETDECLS lhd_return_null_tree_v
#undef LANG_HOOKS_PUSHDECL
#define LANG_HOOKS_PUSHDECL gnat_return_tree
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS gnat_write_global_declarations
#undef LANG_HOOKS_GET_ALIAS_SET
#define LANG_HOOKS_GET_ALIAS_SET gnat_get_alias_set
#undef LANG_HOOKS_PRINT_DECL

34
gcc/ada/gcc-interface/utils.c
View File

@ -224,8 +224,8 @@ static GTY((deletable)) struct gnat_binding_level *free_binding_level;
/* The context to be used for global declarations. */
static GTY(()) tree global_context;
/* An array of global declarations. */
static GTY(()) vec<tree, va_gc> *global_decls;
/* An array of global type declarations. */
static GTY(()) vec<tree, va_gc> *type_decls;
/* An array of builtin function declarations. */
static GTY(()) vec<tree, va_gc> *builtin_decls;
@ -756,7 +756,10 @@ gnat_pushdecl (tree decl, Node_Id gnat_node)
vec_safe_push (builtin_decls, decl);
}
else if (global_bindings_p ())
vec_safe_push (global_decls, decl);
{
if (TREE_CODE (decl) == TYPE_DECL)
vec_safe_push (type_decls, decl);
}
else
{
DECL_CHAIN (decl) = BLOCK_VARS (current_binding_level->block);
@ -5183,8 +5186,11 @@ smaller_form_type_p (tree type, tree orig_type)
static GTY (()) tree dummy_global;
/* Keep track of types used at the global level and emit debug info
for all global types. */
void
gnat_write_global_declarations (void)
note_types_used_by_globals (void)
{
unsigned int i;
tree iter;
@ -5214,26 +5220,12 @@ gnat_write_global_declarations (void)
}
/* Output debug information for all global type declarations first. This
ensures that global types whose compilation hasn't been finalized yet,
ensures that global types whose compilation haven't been finalized yet,
for example pointers to Taft amendment types, have their compilation
finalized in the right context. */
FOR_EACH_VEC_SAFE_ELT (global_decls, i, iter)
if (TREE_CODE (iter) == TYPE_DECL && !DECL_IGNORED_P (iter))
FOR_EACH_VEC_SAFE_ELT (type_decls, i, iter)
if (!DECL_IGNORED_P (iter))
debug_hooks->type_decl (iter, false);
/* Proceed to optimize and emit assembly. */
symtab->finalize_compilation_unit ();
/* After cgraph has had a chance to emit everything that's going to
be emitted, output debug information for the rest of globals. */
if (!seen_error ())
{
timevar_push (TV_SYMOUT);
FOR_EACH_VEC_SAFE_ELT (global_decls, i, iter)
if (TREE_CODE (iter) != TYPE_DECL && !DECL_IGNORED_P (iter))
debug_hooks->global_decl (iter);
timevar_pop (TV_SYMOUT);
}
}
/* ************************************************************************

5
gcc/c-family/ChangeLog
View File

@ -1,3 +1,8 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* c-common.h (c_parse_final_cleanups): New prototype.
* c-opts.c (c_common_parse_file): Call c_parse_final_cleanups.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* array-notation-common.c: Adjust includes for restructured coretypes.h.

2
gcc/c-family/c-common.h
View File

@ -887,6 +887,8 @@ extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
/* This is the basic parsing function. */
extern void c_parse_file (void);
extern void c_parse_final_cleanups (void);
extern void warn_for_omitted_condop (location_t, tree);
/* These macros provide convenient access to the various _STMT nodes. */

2
gcc/c-family/c-opts.c
View File

@ -1087,6 +1087,8 @@ c_common_parse_file (void)
if (!this_input_filename)
break;
}
c_parse_final_cleanups ();
}
/* Returns the appropriate dump file for PHASE to dump with FLAGS. */

14
gcc/c/ChangeLog
View File

@ -1,3 +1,17 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* c-decl.c (finish_struct): Save C_TYPE_INCOMPLETE_VARS and
immediately clobber it.
(c_write_global_declarations_1): Remove call to
check_global_declaration_1.
(c_write_global_declarations_2): Remove.
(c_write_final_cleanups): Rename from c_write_global_declarations.
Remove call to finalize_compilation_unit.
Remove calls to debugging hooks.
* c-objc-common.c: Adjust comment for c_warn_unused_global_decl.
* c-objc-common.h: Remove LANG_HOOKS_WRITE_GLOBALS.
* c-tree.h: Remove c_write_global_declarations.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* c-array-notation.c: Adjust includes for restructured coretypes.h.

68
gcc/c/c-decl.c
View File

@ -7837,10 +7837,18 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
}
/* If this structure or union completes the type of any previous
variable declaration, lay it out and output its rtl. */
for (x = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
x;
x = TREE_CHAIN (x))
variable declaration, lay it out and output its rtl.
Note: C_TYPE_INCOMPLETE_VARS overloads TYPE_VFIELD which is used
in dwarf2out via rest_of_decl_compilation below and means
something totally different. Since we will be clearing
C_TYPE_INCOMPLETE_VARS shortly after we iterate through them,
clear it ahead of time and avoid problems in dwarf2out. Ideally,
C_TYPE_INCOMPLETE_VARS should use some language specific
node. */
tree incomplete_vars = C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t));
C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
for (x = incomplete_vars; x; x = TREE_CHAIN (x))
{
tree decl = TREE_VALUE (x);
if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
@ -7853,7 +7861,6 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
rest_of_decl_compilation (decl, toplevel, 0);
}
}
C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
/* Update type location to the one of the definition, instead of e.g.
a forward declaration. */
@ -10679,9 +10686,8 @@ finish_declspecs (struct c_declspecs *specs)
return specs;
}
/* A subroutine of c_write_global_declarations. Perform final processing
on one file scope's declarations (or the external scope's declarations),
GLOBALS. */
/* Perform final processing on one file scope's declarations (or the
external scope's declarations), GLOBALS. */
static void
c_write_global_declarations_1 (tree globals)
@ -10694,7 +10700,7 @@ c_write_global_declarations_1 (tree globals)
{
/* Check for used but undefined static functions using the C
standard's definition of "used", and set TREE_NO_WARNING so
that check_global_declarations doesn't repeat the check. */
that check_global_declaration doesn't repeat the check. */
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) == 0
&& DECL_EXTERNAL (decl)
@ -10715,21 +10721,6 @@ c_write_global_declarations_1 (tree globals)
reconsider |= wrapup_global_declaration_2 (decl);
}
while (reconsider);
for (decl = globals; decl; decl = DECL_CHAIN (decl))
check_global_declaration_1 (decl);
}
/* A subroutine of c_write_global_declarations Emit debug information for each
of the declarations in GLOBALS. */
static void
c_write_global_declarations_2 (tree globals)
{
tree decl;
for (decl = globals; decl ; decl = DECL_CHAIN (decl))
debug_hooks->global_decl (decl);
}
/* Callback to collect a source_ref from a DECL. */
@ -10779,8 +10770,11 @@ for_each_global_decl (void (*callback) (tree decl))
callback (decl);
}
/* Perform any final parser cleanups and generate initial debugging
information. */
void
c_write_global_declarations (void)
c_parse_final_cleanups (void)
{
tree t;
unsigned i;
@ -10789,6 +10783,7 @@ c_write_global_declarations (void)
if (pch_file)
return;
timevar_stop (TV_PHASE_PARSING);
timevar_start (TV_PHASE_DEFERRED);
/* Do the Objective-C stuff. This is where all the Objective-C
@ -10827,34 +10822,15 @@ c_write_global_declarations (void)
}
/* Process all file scopes in this compilation, and the external_scope,
through wrapup_global_declarations and check_global_declarations. */
through wrapup_global_declarations. */
FOR_EACH_VEC_ELT (*all_translation_units, i, t)
c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
timevar_stop (TV_PHASE_DEFERRED);
timevar_start (TV_PHASE_OPT_GEN);
/* We're done parsing; proceed to optimize and emit assembly.
FIXME: shouldn't be the front end's responsibility to call this. */
symtab->finalize_compilation_unit ();
timevar_stop (TV_PHASE_OPT_GEN);
timevar_start (TV_PHASE_DBGINFO);
/* After cgraph has had a chance to emit everything that's going to
be emitted, output debug information for globals. */
if (!seen_error ())
{
timevar_push (TV_SYMOUT);
FOR_EACH_VEC_ELT (*all_translation_units, i, t)
c_write_global_declarations_2 (BLOCK_VARS (DECL_INITIAL (t)));
c_write_global_declarations_2 (BLOCK_VARS (ext_block));
timevar_pop (TV_SYMOUT);
}
timevar_start (TV_PHASE_PARSING);
ext_block = NULL;
timevar_stop (TV_PHASE_DBGINFO);
}
/* Register reserved keyword WORD as qualifier for address space AS. */

2
gcc/c/c-objc-common.c
View File

@ -49,7 +49,7 @@ c_missing_noreturn_ok_p (tree decl)
return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
}
/* Called from check_global_declarations. */
/* Called from check_global_declaration. */
bool
c_warn_unused_global_decl (const_tree decl)

2
gcc/c/c-objc-common.h
View File

@ -92,8 +92,6 @@ along with GCC; see the file COPYING3. If not see
#undef LANG_HOOKS_GETDECLS
#define LANG_HOOKS_GETDECLS lhd_return_null_tree_v
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS c_write_global_declarations
/* Hooks for tree gimplification. */
#undef LANG_HOOKS_GIMPLIFY_EXPR

1
gcc/c/c-tree.h
View File

@ -695,7 +695,6 @@ typedef void c_binding_oracle_function (enum c_oracle_request, tree identifier);
extern c_binding_oracle_function *c_binding_oracle;
extern void c_finish_incomplete_decl (tree);
extern void c_write_global_declarations (void);
extern tree c_omp_reduction_id (enum tree_code, tree);
extern tree c_omp_reduction_decl (tree);
extern tree c_omp_reduction_lookup (tree, tree);

2
gcc/cgraph.h
View File

@ -314,7 +314,7 @@ public:
bool needed_p (void);
/* Return true when there are references to the node. */
bool referred_to_p (void);
bool referred_to_p (bool include_self = true);
/* Return true if NODE can be discarded by linker from the binary. */
inline bool

53
gcc/cgraphunit.c
View File

@ -403,10 +403,11 @@ cgraph_node::reset (void)
remove_all_references ();
}
/* Return true when there are references to the node. */
/* Return true when there are references to the node. INCLUDE_SELF is
true if a self reference counts as a reference. */
bool
symtab_node::referred_to_p (void)
symtab_node::referred_to_p (bool include_self)
{
ipa_ref *ref = NULL;
@ -416,7 +417,13 @@ symtab_node::referred_to_p (void)
/* For functions check also calls. */
cgraph_node *cn = dyn_cast <cgraph_node *> (this);
if (cn && cn->callers)
return true;
{
if (include_self)
return true;
for (cgraph_edge *e = cn->callers; e; e = e->next_caller)
if (e->caller != this)
return true;
}
return false;
}
@ -924,8 +931,12 @@ walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
static cgraph_node *first_analyzed;
static varpool_node *first_analyzed_var;
/* FIRST_TIME is set to TRUE for the first time we are called for a
translation unit from finalize_compilation_unit() or false
otherwise. */
static void
analyze_functions (void)
analyze_functions (bool first_time)
{
/* Keep track of already processed nodes when called multiple times for
intermodule optimization. */
@ -1097,6 +1108,13 @@ analyze_functions (void)
symtab_node::dump_table (symtab->dump_file);
}
if (first_time)
{
symtab_node *snode;
FOR_EACH_SYMBOL (snode)
check_global_declaration (snode->decl);
}
if (symtab->dump_file)
fprintf (symtab->dump_file, "\nRemoving unused symbols:");
@ -1109,6 +1127,19 @@ analyze_functions (void)
{
if (symtab->dump_file)
fprintf (symtab->dump_file, " %s", node->name ());
/* See if the debugger can use anything before the DECL
passes away. Perhaps it can notice a DECL that is now a
constant and can tag the early DIE with an appropriate
attribute.
Otherwise, this is the last chance the debug_hooks have
at looking at optimized away DECLs, since
late_global_decl will subsequently be called from the
contents of the now pruned symbol table. */
if (!decl_function_context (node->decl))
(*debug_hooks->late_global_decl) (node->decl);
node->remove ();
continue;
}
@ -2445,13 +2476,23 @@ symbol_table::finalize_compilation_unit (void)
/* Gimplify and lower all functions, compute reachability and
remove unreachable nodes. */
analyze_functions ();
analyze_functions (/*first_time=*/true);
/* Mark alias targets necessary and emit diagnostics. */
handle_alias_pairs ();
/* Gimplify and lower thunks. */
analyze_functions ();
analyze_functions (/*first_time=*/false);
/* Emit early debug for reachable functions, and by consequence,
locally scoped symbols. */
struct cgraph_node *cnode;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (cnode)
(*debug_hooks->early_global_decl) (cnode->decl);
/* Clean up anything that needs cleaning up after initial debug
generation. */
(*debug_hooks->early_finish) ();
/* Finally drive the pass manager. */
compile ();

33
gcc/cp/ChangeLog
View File

@ -1,3 +1,36 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* cp-objcp-common.c: Adjust comment for
cxx_warn_unused_global_decl.
* cp-objcp-common.h (LANG_HOOKS_WRITE_GLOBALS): Remove
(LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS): New.
* cp-tree.h (note_mangling_alias): Protoize.
(cp_write_global_declarations): Remove.
(cxx_post_compilation_parsing_cleanups): Protoize.
* decl.c (wrapup_globals_for_namespace): Remove use of DATA
argument.
* decl2.c (mangling_aliases): New global.
(build_java_method_aliases): New. Adapted from
collect_candidates_for_java_method_aliases.
(collect_candidates_for_java_method_aliases): Remove.
(build_java_method_aliases): Remove.
(generate_mangling_aliases): New.
(note_mangling_alias): New. Moved from mangle_decl.
(locus_at_end_of_parsing): New global.
(c_parse_final_cleanups): Rename from
cp_write_global_declarations.
Use locus_at_end_of_parsing.
Call generate_mangling_aliases.
Rename call to collect_candidates_for_java_method_aliases into
build_java_method_aliases.
Remove call to finalize_compilation_unit.
Move vtable handling into cxx_post_compilation_parsing_cleanups.
Do not call check_global_declarations or
emit_debug_global_declarations.
(cxx_post_compilation_parsing_cleanups): New.
* mangle.c (mangle_decl): Move code to note_mangling_alias.
* name-lookup.c (do_namespace_alias): Call early_global_decl.
2015-06-05 Nathan Sidwell <nathan@acm.org>
PR c++/52595

2
gcc/cp/cp-objcp-common.c
View File

@ -57,7 +57,7 @@ cxx_get_alias_set (tree t)
return c_common_get_alias_set (t);
}
/* Called from check_global_declarations. */
/* Called from check_global_declaration. */
bool
cxx_warn_unused_global_decl (const_tree decl)

4
gcc/cp/cp-objcp-common.h
View File

@ -84,8 +84,8 @@ extern void cp_common_init_ts (void);
#define LANG_HOOKS_PRINT_ERROR_FUNCTION cxx_print_error_function
#undef LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL
#define LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL cxx_warn_unused_global_decl
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS cp_write_global_declarations
#undef LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS
#define LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS cxx_post_compilation_parsing_cleanups
#undef LANG_HOOKS_BUILTIN_FUNCTION
#define LANG_HOOKS_BUILTIN_FUNCTION cxx_builtin_function
#undef LANG_HOOKS_BUILTIN_FUNCTION_EXT_SCOPE

2
gcc/cp/cp-tree.h
View File

@ -5469,7 +5469,7 @@ extern tree cp_reconstruct_complex_type (tree, tree);
extern bool attributes_naming_typedef_ok (tree);
extern void cplus_decl_attributes (tree *, tree, int);
extern void finish_anon_union (tree);
extern void cp_write_global_declarations (void);
extern void cxx_post_compilation_parsing_cleanups (void);
extern tree coerce_new_type (tree);
extern tree coerce_delete_type (tree);
extern void comdat_linkage (tree);

15
gcc/cp/decl.c
View File

@ -888,30 +888,19 @@ walk_namespaces (walk_namespaces_fn f, void* data)
return walk_namespaces_r (global_namespace, f, data);
}
/* Call wrapup_globals_declarations for the globals in NAMESPACE. If
DATA is non-NULL, this is the last time we will call
wrapup_global_declarations for this NAMESPACE. */
/* Call wrapup_globals_declarations for the globals in NAMESPACE. */
int
wrapup_globals_for_namespace (tree name_space, void* data)
wrapup_globals_for_namespace (tree name_space, void* data ATTRIBUTE_UNUSED)
{
cp_binding_level *level = NAMESPACE_LEVEL (name_space);
vec<tree, va_gc> *statics = level->static_decls;
tree *vec = statics->address ();
int len = statics->length ();
int last_time = (data != 0);
if (last_time)
{
check_global_declarations (vec, len);
emit_debug_global_declarations (vec, len);
return 0;
}
/* Write out any globals that need to be output. */
return wrapup_global_declarations (vec, len);
}
/* In C++, you don't have to write `struct S' to refer to `S'; you
can just use `S'. We accomplish this by creating a TYPE_DECL as

82
gcc/cp/decl2.c
View File

@ -4389,6 +4389,8 @@ dump_tu (void)
}
}
static location_t locus_at_end_of_parsing;
/* Check the deallocation functions for CODE to see if we want to warn that
only one was defined. */
@ -4436,17 +4438,16 @@ maybe_warn_sized_delete ()
first, since that way we only need to reverse the decls once. */
void
cp_write_global_declarations (void)
c_parse_final_cleanups (void)
{
tree vars;
bool reconsider;
size_t i;
location_t locus;
unsigned ssdf_count = 0;
int retries = 0;
tree decl;
locus = input_location;
locus_at_end_of_parsing = input_location;
at_eof = 1;
/* Bad parse errors. Just forget about it. */
@ -4463,6 +4464,9 @@ cp_write_global_declarations (void)
return;
}
timevar_stop (TV_PHASE_PARSING);
timevar_start (TV_PHASE_DEFERRED);
symtab->process_same_body_aliases ();
/* Handle -fdump-ada-spec[-slim] */
@ -4478,8 +4482,6 @@ cp_write_global_declarations (void)
/* FIXME - huh? was input_line -= 1;*/
timevar_start (TV_PHASE_DEFERRED);
/* We now have to write out all the stuff we put off writing out.
These include:
@ -4575,7 +4577,7 @@ cp_write_global_declarations (void)
/* Set the line and file, so that it is obviously not from
the source file. */
input_location = locus;
input_location = locus_at_end_of_parsing;
ssdf_body = start_static_storage_duration_function (ssdf_count);
/* Make sure the back end knows about all the variables. */
@ -4601,7 +4603,7 @@ cp_write_global_declarations (void)
/* Finish up the static storage duration function for this
round. */
input_location = locus;
input_location = locus_at_end_of_parsing;
finish_static_storage_duration_function (ssdf_body);
/* All those initializations and finalizations might cause
@ -4609,7 +4611,7 @@ cp_write_global_declarations (void)
instantiations, etc. */
reconsider = true;
ssdf_count++;
/* ??? was: locus.line++; */
/* ??? was: locus_at_end_of_parsing.line++; */
}
/* Now do the same for thread_local variables. */
@ -4752,7 +4754,7 @@ cp_write_global_declarations (void)
(template_for_substitution (decl)))))
{
warning (0, "inline function %q+D used but never defined", decl);
/* Avoid a duplicate warning from check_global_declaration_1. */
/* Avoid a duplicate warning from check_global_declaration. */
TREE_NO_WARNING (decl) = 1;
}
}
@ -4779,12 +4781,13 @@ cp_write_global_declarations (void)
if (priority_info_map)
splay_tree_foreach (priority_info_map,
generate_ctor_and_dtor_functions_for_priority,
/*data=*/&locus);
/*data=*/&locus_at_end_of_parsing);
else if (c_dialect_objc () && objc_static_init_needed_p ())
/* If this is obj-c++ and we need a static init, call
generate_ctor_or_dtor_function. */
generate_ctor_or_dtor_function (/*constructor_p=*/true,
DEFAULT_INIT_PRIORITY, &locus);
DEFAULT_INIT_PRIORITY,
&locus_at_end_of_parsing);
/* We're done with the splay-tree now. */
if (priority_info_map)
@ -4800,9 +4803,6 @@ cp_write_global_declarations (void)
/* Generate Java hidden aliases. */
build_java_method_aliases ();
timevar_stop (TV_PHASE_DEFERRED);
timevar_start (TV_PHASE_OPT_GEN);
if (flag_vtable_verify)
{
vtv_recover_class_info ();
@ -4810,32 +4810,6 @@ cp_write_global_declarations (void)
vtv_build_vtable_verify_fndecl ();
}
symtab->finalize_compilation_unit ();
if (flag_vtable_verify)
{
/* Generate the special constructor initialization function that
calls __VLTRegisterPairs, and give it a very high
initialization priority. This must be done after
finalize_compilation_unit so that we have accurate
information about which vtable will actually be emitted. */
vtv_generate_init_routine ();
}
timevar_stop (TV_PHASE_OPT_GEN);
timevar_start (TV_PHASE_CHECK_DBGINFO);
/* Now, issue warnings about static, but not defined, functions,
etc., and emit debugging information. */
walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
if (vec_safe_length (pending_statics) != 0)
{
check_global_declarations (pending_statics->address (),
pending_statics->length ());
emit_debug_global_declarations (pending_statics->address (),
pending_statics->length ());
}
perform_deferred_noexcept_checks ();
finish_repo ();
@ -4849,13 +4823,37 @@ cp_write_global_declarations (void)
dump_tree_statistics ();
dump_time_statistics ();
}
input_location = locus;
timevar_stop (TV_PHASE_DEFERRED);
timevar_start (TV_PHASE_PARSING);
}
/* Perform any post compilation-proper cleanups for the C++ front-end.
This should really go away. No front-end should need to do
anything past the compilation process. */
void
cxx_post_compilation_parsing_cleanups (void)
{
timevar_start (TV_PHASE_LATE_PARSING_CLEANUPS);
if (flag_vtable_verify)
{
/* Generate the special constructor initialization function that
calls __VLTRegisterPairs, and give it a very high
initialization priority. This must be done after
finalize_compilation_unit so that we have accurate
information about which vtable will actually be emitted. */
vtv_generate_init_routine ();
}
input_location = locus_at_end_of_parsing;
#ifdef ENABLE_CHECKING
validate_conversion_obstack ();
#endif /* ENABLE_CHECKING */
timevar_stop (TV_PHASE_CHECK_DBGINFO);
timevar_stop (TV_PHASE_LATE_PARSING_CLEANUPS);
}
/* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the

2
gcc/cp/name-lookup.c
View File

@ -3896,7 +3896,7 @@ do_namespace_alias (tree alias, tree name_space)
/* Emit debug info for namespace alias. */
if (!building_stmt_list_p ())
(*debug_hooks->global_decl) (alias);
(*debug_hooks->early_global_decl) (alias);
}
/* Like pushdecl, only it places X in the current namespace,

19
gcc/dbxout.c
View File

@ -345,7 +345,8 @@ static int dbxout_symbol_location (tree, tree, const char *, rtx);
static void dbxout_symbol_name (tree, const char *, int);
static void dbxout_common_name (tree, const char *, stab_code_type);
static const char *dbxout_common_check (tree, int *);
static void dbxout_global_decl (tree);
static void dbxout_early_global_decl (tree);
static void dbxout_late_global_decl (tree);
static void dbxout_type_decl (tree, int);
static void dbxout_handle_pch (unsigned);
static void debug_free_queue (void);
@ -367,6 +368,7 @@ const struct gcc_debug_hooks dbx_debug_hooks =
dbxout_init,
dbxout_finish,
debug_nothing_void,
debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
@ -386,7 +388,8 @@ const struct gcc_debug_hooks dbx_debug_hooks =
#endif
debug_nothing_int, /* end_function */
dbxout_function_decl,
dbxout_global_decl, /* global_decl */
dbxout_early_global_decl, /* early_global_decl */
dbxout_late_global_decl, /* late_global_decl */
dbxout_type_decl, /* type_decl */
debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
debug_nothing_tree, /* deferred_inline_function */
@ -407,6 +410,7 @@ const struct gcc_debug_hooks xcoff_debug_hooks =
dbxout_init,
dbxout_finish,
debug_nothing_void,
debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
@ -422,7 +426,8 @@ const struct gcc_debug_hooks xcoff_debug_hooks =
debug_nothing_tree, /* begin_function */
xcoffout_end_function,
debug_nothing_tree, /* function_decl */
dbxout_global_decl, /* global_decl */
dbxout_early_global_decl, /* early_global_decl */
dbxout_late_global_decl, /* late_global_decl */
dbxout_type_decl, /* type_decl */
debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
debug_nothing_tree, /* deferred_inline_function */
@ -1336,10 +1341,16 @@ dbxout_function_decl (tree decl)
#endif /* DBX_DEBUGGING_INFO */
static void
dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED)
{
/* NYI for non-dwarf. */
}
/* Debug information for a global DECL. Called from toplev.c after
compilation proper has finished. */
static void
dbxout_global_decl (tree decl)
dbxout_late_global_decl (tree decl)
{
if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
{

4
gcc/debug.c
View File

@ -33,6 +33,7 @@ const struct gcc_debug_hooks do_nothing_debug_hooks =
{
debug_nothing_charstar,
debug_nothing_charstar,
debug_nothing_void, /* early_finish */
debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
@ -49,7 +50,8 @@ const struct gcc_debug_hooks do_nothing_debug_hooks =
debug_nothing_tree, /* begin_function */
debug_nothing_int, /* end_function */
debug_nothing_tree, /* function_decl */
debug_nothing_tree, /* global_decl */
debug_nothing_tree, /* early_global_decl */
debug_nothing_tree, /* late_global_decl */
debug_nothing_tree_int, /* type_decl */
debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
debug_nothing_tree, /* deferred_inline_function */

42
gcc/debug.h
View File

@ -30,6 +30,9 @@ struct gcc_debug_hooks
/* Output debug symbols. */
void (* finish) (const char *main_filename);
/* Run cleanups necessary after early debug generation. */
void (* early_finish) (void);
/* Called from cgraph_optimize before starting to assemble
functions/variables/toplevel asms. */
void (* assembly_start) (void);
@ -89,12 +92,43 @@ struct gcc_debug_hooks
/* Debug information for a function DECL. This might include the
function name (a symbol), its parameters, and the block that
makes up the function's body, and the local variables of the
function. */
function.
This is only called for FUNCTION_DECLs. It is part of the late
debug pass and is called from rest_of_handle_final.
Location information is available at this point.
See the documentation for early_global_decl and late_global_decl
for other entry points into the debugging back-ends for DECLs. */
void (* function_decl) (tree decl);
/* Debug information for a global DECL. Called from toplev.c after
compilation proper has finished. */
void (* global_decl) (tree decl);
/* Debug information for a global DECL. Called from the parser
after the parsing process has finished.
This gets called for both variables and functions.
Location information is not available at this point, but it is a
good probe point to get access to symbols before they get
optimized away.
This hook may be called on VAR_DECLs or FUNCTION_DECLs. It is up
to the hook to use what it needs. */
void (* early_global_decl) (tree decl);
/* Augment debug information generated by early_global_decl with
more complete debug info (if applicable). Called from toplev.c
after the compilation proper has finished and cgraph information
is available.
This gets called for both variables and functions.
Location information is usually available at this point, unless
the hook is being called for a decl that has been optimized away.
This hook may be called on VAR_DECLs or FUNCTION_DECLs. It is up
to the hook to use what it needs. */
void (* late_global_decl) (tree decl);
/* Debug information for a type DECL. Called from toplev.c after
compilation proper, also from various language front ends to

1031
gcc/dwarf2out.c
View File

File diff suppressed because it is too large Load Diff

10
gcc/fortran/ChangeLog
View File

@ -1,3 +1,13 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* f95-lang.c (gfc_write_global_declarations): Remove.
(LANG_HOOKS_WRITE_GLOBALS): Remove.
(gfc_write_global_declarations): Move code from here to...
(gfc_be_parse_file): ...here.
Call global_decl_processing.
* trans-decl.c (gfc_emit_parameter_debug_info): Rename global_decl
to early_global_decl.
2015-06-05 Russell Whitesides <russelldub@gmail.com>
Steven G. Kargl <kargl@gcc.gnu.org>

41
gcc/fortran/f95-lang.c
View File

@ -94,7 +94,6 @@ static bool global_bindings_p (void);
/* Each front end provides its own. */
static bool gfc_init (void);
static void gfc_finish (void);
static void gfc_write_global_declarations (void);
static void gfc_be_parse_file (void);
static alias_set_type gfc_get_alias_set (tree);
static void gfc_init_ts (void);
@ -121,7 +120,6 @@ static const struct attribute_spec gfc_attribute_table[] =
#undef LANG_HOOKS_NAME
#undef LANG_HOOKS_INIT
#undef LANG_HOOKS_FINISH
#undef LANG_HOOKS_WRITE_GLOBALS
#undef LANG_HOOKS_OPTION_LANG_MASK
#undef LANG_HOOKS_INIT_OPTIONS_STRUCT
#undef LANG_HOOKS_INIT_OPTIONS
@ -155,7 +153,6 @@ static const struct attribute_spec gfc_attribute_table[] =
#define LANG_HOOKS_NAME "GNU Fortran"
#define LANG_HOOKS_INIT gfc_init
#define LANG_HOOKS_FINISH gfc_finish
#define LANG_HOOKS_WRITE_GLOBALS gfc_write_global_declarations
#define LANG_HOOKS_OPTION_LANG_MASK gfc_option_lang_mask
#define LANG_HOOKS_INIT_OPTIONS_STRUCT gfc_init_options_struct
#define LANG_HOOKS_INIT_OPTIONS gfc_init_options
@ -226,9 +223,21 @@ gfc_be_parse_file (void)
while (!global_bindings_p ())
poplevel (0, 0);
/* Finalize all of the globals.
Emulated tls lowering needs to see all TLS variables before we
call finalize_compilation_unit. The C/C++ front ends manage this
by calling decl_rest_of_compilation on each global and static
variable as they are seen. The Fortran front end waits until
here. */
for (tree decl = getdecls (); decl ; decl = DECL_CHAIN (decl))
rest_of_decl_compilation (decl, true, true);
/* Switch to the default tree diagnostics here, because there may be
diagnostics before gfc_finish(). */
gfc_diagnostics_finish ();
global_decl_processing ();
}
@ -272,32 +281,6 @@ gfc_finish (void)
return;
}
/* ??? This is something of a hack.
Emulated tls lowering needs to see all TLS variables before we call
finalize_compilation_unit. The C/C++ front ends manage this
by calling decl_rest_of_compilation on each global and static variable
as they are seen. The Fortran front end waits until this hook.
A Correct solution is for finalize_compilation_unit not to be
called during the WRITE_GLOBALS langhook, and have that hook only do what
its name suggests and write out globals. But the C++ and Java front ends
have (unspecified) problems with aliases that gets in the way. It has
been suggested that these problems would be solved by completing the
conversion to cgraph-based aliases. */
static void
gfc_write_global_declarations (void)
{
tree decl;
/* Finalize all of the globals. */
for (decl = getdecls(); decl ; decl = DECL_CHAIN (decl))
rest_of_decl_compilation (decl, true, true);
write_global_declarations ();
}
/* These functions and variables deal with binding contours. We only
need these functions for the list of PARM_DECLs, but we leave the
functions more general; these are a simplified version of the

2
gcc/fortran/trans-decl.c
View File

@ -4828,7 +4828,7 @@ gfc_emit_parameter_debug_info (gfc_symbol *sym)
TREE_TYPE (decl),
sym->attr.dimension,
false, false);
debug_hooks->global_decl (decl);
debug_hooks->early_global_decl (decl);
}

27
gcc/gengtype.c
View File

@ -4720,33 +4720,6 @@ write_roots (pair_p variables, bool emit_pch)
this funcion will have to be adjusted to be more like
output_mangled_typename. */
static void
output_typename (outf_p of, const_type_p t)
{
switch (t->kind)
{
case TYPE_STRING:
oprintf (of, "str");
break;
case TYPE_SCALAR:
oprintf (of, "scalar");
break;
case TYPE_POINTER:
output_typename (of, t->u.p);
break;
case TYPE_STRUCT:
case TYPE_USER_STRUCT:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
oprintf (of, "%s", t->u.s.tag);
break;
case TYPE_NONE:
case TYPE_UNDEFINED:
case TYPE_ARRAY:
gcc_unreachable ();
}
}
#define INDENT 2
/* Dumps the value of typekind KIND. */

9
gcc/go/ChangeLog
View File

@ -1,3 +1,12 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* go-gcc.cc (write_global_definitions): Remove call to
finalize_compilation_unit.
Remove Go specific debug generation.
* go-lang.c (go_langhook_parse_file): Call go_write_globals.
(go_langhook_write_globals): Remove.
Remove LANG_HOOKS_WRITE_GLOBALS everywhere.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* go-backend.c: Adjust includes for restructured coretypes.h.

8
gcc/go/go-gcc.cc
View File

@ -3020,7 +3020,8 @@ Gcc_backend::lookup_builtin(const std::string& name)
}
// Write the definitions for all TYPE_DECLS, CONSTANT_DECLS,
// FUNCTION_DECLS, and VARIABLE_DECLS declared globally.
// FUNCTION_DECLS, and VARIABLE_DECLS declared globally, as well as
// emit early debugging information.
void
Gcc_backend::write_global_definitions(
@ -3093,11 +3094,6 @@ Gcc_backend::write_global_definitions(
wrapup_global_declarations(defs, i);
symtab->finalize_compilation_unit();
check_global_declarations(defs, i);
emit_debug_global_declarations(defs, i);
delete[] defs;
}

13
gcc/go/go-lang.c
View File

@ -307,6 +307,9 @@ go_langhook_parse_file (void)
{
go_parse_input_files (in_fnames, num_in_fnames, flag_syntax_only,
go_require_return_statement);
/* Final processing of globals and early debug info generation. */
go_write_globals ();
}
static tree
@ -452,14 +455,6 @@ go_langhook_getdecls (void)
return NULL;
}
/* Write out globals. */
static void
go_langhook_write_globals (void)
{
go_write_globals ();
}
/* Go specific gimplification. We need to gimplify
CALL_EXPR_STATIC_CHAIN, because the gimplifier doesn't handle
it. */
@ -557,7 +552,6 @@ go_localize_identifier (const char *ident)
#undef LANG_HOOKS_GLOBAL_BINDINGS_P
#undef LANG_HOOKS_PUSHDECL
#undef LANG_HOOKS_GETDECLS
#undef LANG_HOOKS_WRITE_GLOBALS
#undef LANG_HOOKS_GIMPLIFY_EXPR
#undef LANG_HOOKS_EH_PERSONALITY
@ -574,7 +568,6 @@ go_localize_identifier (const char *ident)
#define LANG_HOOKS_GLOBAL_BINDINGS_P go_langhook_global_bindings_p
#define LANG_HOOKS_PUSHDECL go_langhook_pushdecl
#define LANG_HOOKS_GETDECLS go_langhook_getdecls
#define LANG_HOOKS_WRITE_GLOBALS go_langhook_write_globals
#define LANG_HOOKS_GIMPLIFY_EXPR go_langhook_gimplify_expr
#define LANG_HOOKS_EH_PERSONALITY go_langhook_eh_personality

15
gcc/godump.c
View File

@ -511,13 +511,19 @@ go_function_decl (tree decl)
go_decl (decl);
}
static void
go_early_global_decl (tree decl)
{
go_decl (decl);
real_debug_hooks->early_global_decl (decl);
}
/* A global variable decl. */
static void
go_global_decl (tree decl)
go_late_global_decl (tree decl)
{
real_debug_hooks->global_decl (decl);
go_decl (decl);
real_debug_hooks->late_global_decl (decl);
}
/* A type declaration. */
@ -1457,7 +1463,8 @@ dump_go_spec_init (const char *filename, const struct gcc_debug_hooks *hooks)
go_debug_hooks.define = go_define;
go_debug_hooks.undef = go_undef;
go_debug_hooks.function_decl = go_function_decl;
go_debug_hooks.global_decl = go_global_decl;
go_debug_hooks.early_global_decl = go_early_global_decl;
go_debug_hooks.late_global_decl = go_late_global_decl;
go_debug_hooks.type_decl = go_type_decl;
macro_hash = htab_create (100, macro_hash_hashval, macro_hash_eq,

12
gcc/java/ChangeLog
View File

@ -1,3 +1,15 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* class.c: Remove pending_static_fields.
(add_field): Remove use of pending_static_fields.
(java_write_globals): Remove.
* decl.c (java_mark_class_local): Remove use of
pending_static_fields.
* java-tree.h: Remove pending_static_fields and
java_write_globals.
* jcf-parse.c (java_parse_file): Call global_decl_processing.
* lang.c (LANG_HOOKS_WRITE_GLOBALS): Remove.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* boehm.c: Adjust includes for restructured coretypes.h.

19
gcc/java/class.c
View File

@ -120,10 +120,6 @@ static GTY(()) vec<tree, va_gc> *registered_class;
currently being compiled. */
static GTY(()) tree this_classdollar;
/* A list of static class fields. This is to emit proper debug
info for them. */
vec<tree, va_gc> *pending_static_fields;
/* Return the node that most closely represents the class whose name
is IDENT. Start the search from NODE (followed by its siblings).
Return NULL if an appropriate node does not exist. */
@ -892,8 +888,6 @@ add_field (tree klass, tree name, tree field_type, int flags)
/* Considered external unless we are compiling it into this
object file. */
DECL_EXTERNAL (field) = (is_compiled_class (klass) != 2);
if (!DECL_EXTERNAL (field))
vec_safe_push (pending_static_fields, field);
}
return field;
@ -3270,17 +3264,4 @@ in_same_package (tree name1, tree name2)
return (pkg1 == pkg2);
}
/* lang_hooks.decls.final_write_globals: perform final processing on
global variables. */
void
java_write_globals (void)
{
tree *vec = vec_safe_address (pending_static_fields);
int len = vec_safe_length (pending_static_fields);
write_global_declarations ();
emit_debug_global_declarations (vec, len);
vec_free (pending_static_fields);
}
#include "gt-java-class.h"

6
gcc/java/decl.c
View File

@ -1967,11 +1967,7 @@ java_mark_class_local (tree klass)
for (t = TYPE_FIELDS (klass); t ; t = DECL_CHAIN (t))
if (FIELD_STATIC (t))
{
if (DECL_EXTERNAL (t))
vec_safe_push (pending_static_fields, t);
java_mark_decl_local (t);
}
java_mark_decl_local (t);
for (t = TYPE_METHODS (klass); t ; t = DECL_CHAIN (t))
if (!METHOD_ABSTRACT (t))

4
gcc/java/java-tree.h
View File

@ -1194,10 +1194,6 @@ extern void rewrite_reflection_indexes (void *);
int cxx_keyword_p (const char *name, int length);
extern GTY(()) vec<tree, va_gc> *pending_static_fields;
extern void java_write_globals (void);
#define DECL_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
/* Access flags etc for a method (a FUNCTION_DECL): */

3
gcc/java/jcf-parse.c
View File

@ -1996,6 +1996,9 @@ java_parse_file (void)
/* Arrange for any necessary initialization to happen. */
java_emit_static_constructor ();
gcc_assert (global_bindings_p ());
/* Do final processing on globals. */
global_decl_processing ();
}

2
gcc/java/lang.c
View File

@ -146,8 +146,6 @@ struct GTY(()) language_function {
#define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name
#undef LANG_HOOKS_PRINT_ERROR_FUNCTION
#define LANG_HOOKS_PRINT_ERROR_FUNCTION java_print_error_function
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS java_write_globals
#undef LANG_HOOKS_TYPE_FOR_MODE
#define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode

4
gcc/langhooks-def.h
View File

@ -205,7 +205,7 @@ extern tree lhd_make_node (enum tree_code);
#define LANG_HOOKS_FUNCTION_DECL_EXPLICIT_P hook_bool_tree_false
#define LANG_HOOKS_FUNCTION_DECL_DELETED_P hook_bool_tree_false
#define LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL lhd_warn_unused_global_decl
#define LANG_HOOKS_WRITE_GLOBALS write_global_declarations
#define LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS NULL
#define LANG_HOOKS_DECL_OK_FOR_SIBCALL lhd_decl_ok_for_sibcall
#define LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE hook_bool_const_tree_false
#define LANG_HOOKS_OMP_PREDETERMINED_SHARING lhd_omp_predetermined_sharing
@ -230,7 +230,7 @@ extern tree lhd_make_node (enum tree_code);
LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P, \
LANG_HOOKS_GET_GENERIC_FUNCTION_DECL, \
LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL, \
LANG_HOOKS_WRITE_GLOBALS, \
LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS, \
LANG_HOOKS_DECL_OK_FOR_SIBCALL, \
LANG_HOOKS_OMP_PRIVATIZE_BY_REFERENCE, \
LANG_HOOKS_OMP_PREDETERMINED_SHARING, \

26
gcc/langhooks.c
View File

@ -136,12 +136,12 @@ lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
{
}
/* Called from check_global_declarations. */
/* Called from check_global_declaration. */
bool
lhd_warn_unused_global_decl (const_tree decl)
{
/* This is what used to exist in check_global_declarations. Probably
/* This is what used to exist in check_global_declaration. Probably
not many of these actually apply to non-C languages. */
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
@ -308,14 +308,17 @@ lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
return true;
}
/* lang_hooks.decls.final_write_globals: perform final processing on
global variables. */
/* Generic global declaration processing. This is meant to be called
by the front-ends at the end of parsing. C/C++ do their own thing,
but other front-ends may call this. */
void
write_global_declarations (void)
global_decl_processing (void)
{
tree globals, decl, *vec;
int len, i;
timevar_stop (TV_PHASE_PARSING);
timevar_start (TV_PHASE_DEFERRED);
/* Really define vars that have had only a tentative definition.
Really output inline functions that must actually be callable
@ -332,20 +335,9 @@ write_global_declarations (void)
vec[len - i - 1] = decl;
wrapup_global_declarations (vec, len);
check_global_declarations (vec, len);
timevar_stop (TV_PHASE_DEFERRED);
timevar_start (TV_PHASE_OPT_GEN);
/* This lang hook is dual-purposed, and also finalizes the
compilation unit. */
symtab->finalize_compilation_unit ();
timevar_stop (TV_PHASE_OPT_GEN);
timevar_start (TV_PHASE_DBGINFO);
emit_debug_global_declarations (vec, len);
timevar_stop (TV_PHASE_DBGINFO);
/* Clean up. */
timevar_start (TV_PHASE_PARSING);
free (vec);
}

8
gcc/langhooks.h
View File

@ -184,9 +184,11 @@ struct lang_hooks_for_decls
We will already have checked that it has static binding. */
bool (*warn_unused_global) (const_tree);
/* Obtain a list of globals and do final output on them at end
of compilation */
void (*final_write_globals) (void);
/* Perform any post compilation-proper parser cleanups and
processing. This is currently only needed for the C++ parser,
which hopefully can be cleaned up so this hook is no longer
necessary. */
void (*post_compilation_parsing_cleanups) (void);
/* True if this decl may be called via a sibcall. */
bool (*ok_for_sibcall) (const_tree);

5
gcc/lto/ChangeLog
View File

@ -1,3 +1,8 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* lto-lang.c (lto_write_globals): Remove.
(LANG_HOOKS_WRITE_GLOBALS): Same.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* lto-lang.c: Adjust includes for restructured coretypes.h.

15
gcc/lto/lto-lang.c
View File

@ -1113,19 +1113,6 @@ lto_getdecls (void)
return NULL_TREE;
}
static void
lto_write_globals (void)
{
if (flag_wpa)
return;
/* Output debug info for global variables. */
varpool_node *vnode;
FOR_EACH_DEFINED_VARIABLE (vnode)
if (!decl_function_context (vnode->decl))
debug_hooks->global_decl (vnode->decl);
}
static tree
lto_builtin_function (tree decl)
{
@ -1331,8 +1318,6 @@ static void lto_init_ts (void)
#define LANG_HOOKS_PUSHDECL lto_pushdecl
#undef LANG_HOOKS_GETDECLS
#define LANG_HOOKS_GETDECLS lto_getdecls
#undef LANG_HOOKS_WRITE_GLOBALS
#define LANG_HOOKS_WRITE_GLOBALS lto_write_globals
#undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
#define LANG_HOOKS_REGISTER_BUILTIN_TYPE lto_register_builtin_type
#undef LANG_HOOKS_BUILTIN_FUNCTION

6
gcc/objc/ChangeLog
View File

@ -1,3 +1,9 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* objc-act.c (objc_write_global_declarations): Adjust comment.
* objc-gnu-runtime-abi-01.c (build_selector_table_decl): Set
TREE_USED bit.
2015-06-04 Andrew MacLeod <amacleod@redhat.com>
* objc-act.c: Adjust includes for restructured coretypes.h.

3
gcc/objc/objc-act.c
View File

@ -435,8 +435,7 @@ objc_init (void)
return true;
}
/* This is called automatically (at the very end of compilation) by
c_write_global_declarations and cp_write_global_declarations. */
/* This is called at the end of parsing by the C/C++ parsers. */
void
objc_write_global_declarations (void)
{

2
gcc/objc/objc-gnu-runtime-abi-01.c
View File

@ -497,6 +497,8 @@ build_selector_table_decl (void)
temp = build_array_type (objc_selector_template, NULL_TREE);
UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
/* Squash `defined but not used' warning check_global_declaration. */
TREE_USED (UOBJC_SELECTOR_TABLE_decl) = 1;
OBJCMETA (UOBJC_SELECTOR_TABLE_decl, objc_meta, meta_base);
}

50
gcc/passes.c
View File

@ -288,6 +288,56 @@ rest_of_decl_compilation (tree decl,
else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
&& TREE_STATIC (decl))
varpool_node::get_create (decl);
/* Generate early debug for global variables. Any local variables will
be handled by either handling reachable functions from
finalize_compilation_unit (and by consequence, locally scoped
symbols), or by rest_of_type_compilation below.
Also, pick up function prototypes, which will be mostly ignored
by the different early_global_decl() hooks, but will at least be
used by Go's hijack of the debug_hooks to implement
-fdump-go-spec. */
if (!in_lto_p
&& (TREE_CODE (decl) != FUNCTION_DECL
/* This will pick up function prototypes with no bodies,
which are not visible in finalize_compilation_unit()
while iterating with FOR_EACH_*_FUNCTION through the
symbol table. */
|| !DECL_SAVED_TREE (decl))
/* We need to check both decl_function_context and
current_function_decl here to make sure local extern
declarations end up with the correct context.
For local extern declarations, decl_function_context is
empty, but current_function_decl is set to the function where
the extern was declared . Without the check for
!current_function_decl below, the local extern ends up
incorrectly with a top-level context.
For example:
namespace S
{
int
f()
{
{
int i = 42;
{
extern int i; // Local extern declaration.
return i;
}
}
}
}
*/
&& !decl_function_context (decl)
&& !current_function_decl
&& !decl_type_context (decl))
(*debug_hooks->early_global_decl) (decl);
}
/* Called after finishing a record, union or enumeral type. */

23
gcc/sdbout.c
View File

@ -125,7 +125,8 @@ static void sdbout_begin_block (unsigned int, unsigned int);
static void sdbout_end_block (unsigned int, unsigned int);
static void sdbout_source_line (unsigned int, const char *, int, bool);
static void sdbout_end_epilogue (unsigned int, const char *);
static void sdbout_global_decl (tree);
static void sdbout_early_global_decl (tree);
static void sdbout_late_global_decl (tree);
static void sdbout_begin_prologue (unsigned int, const char *);
static void sdbout_end_prologue (unsigned int, const char *);
static void sdbout_begin_function (tree);
@ -148,7 +149,6 @@ static void sdbout_field_types (tree);
static void sdbout_one_type (tree);
static void sdbout_parms (tree);
static void sdbout_reg_parms (tree);
static void sdbout_global_decl (tree);
/* Random macros describing parts of SDB data. */
@ -285,6 +285,7 @@ const struct gcc_debug_hooks sdb_debug_hooks =
{
sdbout_init, /* init */
sdbout_finish, /* finish */
debug_nothing_void, /* early_finish */
debug_nothing_void, /* assembly_start */
debug_nothing_int_charstar, /* define */
debug_nothing_int_charstar, /* undef */
@ -301,7 +302,8 @@ const struct gcc_debug_hooks sdb_debug_hooks =
sdbout_begin_function, /* begin_function */
sdbout_end_function, /* end_function */
debug_nothing_tree, /* function_decl */
sdbout_global_decl, /* global_decl */
sdbout_early_global_decl, /* early_global_decl */
sdbout_late_global_decl, /* late_global_decl */
sdbout_symbol, /* type_decl */
debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
debug_nothing_tree, /* deferred_inline_function */
@ -1427,11 +1429,20 @@ sdbout_reg_parms (tree parms)
}
}
/* Output debug information for a global DECL. Called from toplev.c
after compilation proper has finished. */
/* Output early debug information for a global DECL. Called from
rest_of_decl_compilation during parsing. */
static void
sdbout_global_decl (tree decl)
sdbout_early_global_decl (tree decl ATTRIBUTE_UNUSED)
{
/* NYI for non-dwarf. */
}
/* Output late debug information for a global DECL after location
information is available. */
static void
sdbout_late_global_decl (tree decl)
{
if (TREE_CODE (decl) == VAR_DECL
&& !DECL_EXTERNAL (decl)

17
gcc/testsuite/ChangeLog
View File

@ -1,3 +1,20 @@
2015-06-05 Aldy Hernandez <aldyh@redhat.com>
* g++.dg/cpp0x/pr57101.C: Add warning.
* g++.dg/debug/dwarf2/dwarf4-typedef.C: Same.
* g++.dg/ext/visibility/anon7.C: Same.
* g++.dg/ipa/pr63587-2.C: Same.
* g++.dg/opt/dump1.C: Same.
* g++.dg/opt/pr59622-3.C: Same.
* g++.dg/opt/pr59622.C: Same.
* g++.dg/torture/pr46383.C: Same.
* gcc.dg/dfp/pragma-float-const-decimal64-8.c: Same.
* g++.dg/debug/dwarf2/auto1.C: Adjust for early dwarf.
* g++.dg/lto/pr65549_0.C: Add { } to used but never defined
functions.
* gfortran.dg/intent_out_8.f90: Same.
* gfortran.dg/warn_target_lifetime_3.f90: Same.
2015-06-05 Steven G. Kargl <kargl@gcc.gnu.org>
PR fortran/66377

2
gcc/testsuite/g++.dg/cpp0x/pr57101.C
View File

@ -160,7 +160,7 @@ namespace std
typedef _Alloc allocator_type;
template < typename _Key_compare > struct _Rb_tree_impl
{
_Rb_tree_impl (_Key_compare, _Node_allocator);
_Rb_tree_impl (_Key_compare, _Node_allocator); // { dg-warning "used but never defined" }
};
_Rb_tree_impl < _Compare > _M_impl;
_Rb_tree (_Compare __comp, allocator_type __a):

8
gcc/testsuite/g++.dg/debug/dwarf2/auto1.C
View File

@ -10,14 +10,14 @@
// .uleb128 0x5 # (DIE (0x4c) DW_TAG_unspecified_type)
// .long .LASF6 # DW_AT_name: "auto"
//...
// .uleb128 0x9 # (DIE (0x87) DW_TAG_base_type)
// .ascii "int\0" # DW_AT_name
//...
// .uleb128 0x7 # (DIE (0x57) DW_TAG_subprogram)
// .long 0x33 # DW_AT_specification
// .long 0x87 # DW_AT_type
//...
// .uleb128 0x9 # (DIE (0x87) DW_TAG_base_type)
// .ascii "int\0" # DW_AT_name
// { dg-final { scan-assembler "a1.*(0x\[0-9a-f]+)\[^\n\r]*DW_AT_type.*\\1. DW_TAG_unspecified_type.*DW_AT_specification\[\n\r]{1,2}\[^\n\r]*(0x\[0-9a-f]+)\[^\n\r]*DW_AT_type.*\\2. DW_TAG_base_type" } }
// { dg-final { scan-assembler "a1.*(0x\[0-9a-f]+)\[^\n\r]*DW_AT_type.*\\1. DW_TAG_unspecified_type.*(0x\[0-9a-f]+). DW_TAG_base_type.*DW_AT_specification\[\n\r]{1,2}\[^\n\r]*\\2\[^\n\r]*DW_AT_type" } }
struct A
{

2
gcc/testsuite/g++.dg/debug/dwarf2/dwarf4-typedef.C
View File

@ -6,7 +6,7 @@
namespace {
struct A {
virtual ~A();
virtual ~A(); // { dg-warning "used but never defined" }
};
struct B : public A {

2
gcc/testsuite/g++.dg/ext/visibility/anon7.C
View File

@ -4,7 +4,7 @@
namespace
{
struct A {
static int bar ();
static int bar (); // { dg-error "used but never defined" "" }
static int i; // { dg-error "used, but not defined" "" { xfail *-*-* } }
static int j;
static int k;

2
gcc/testsuite/g++.dg/ipa/pr63587-2.C
View File

@ -178,7 +178,7 @@ public:
}
};
template <typename AttributeValueT>
attribute_actor<AttributeValueT> attr (attribute_name);
attribute_actor<AttributeValueT> attr (attribute_name); // { dg-warning "used but never defined" }
terminal<>::type stream;
template <typename LeftT, typename ImplT> class attribute_output_terminal
{

4
gcc/testsuite/g++.dg/lto/pr65549_0.C
View File

@ -25,7 +25,7 @@ struct C<_Functor(_ArgTypes...)>
typename remove_reference<_Functor>::type>::value,
_Functor> {};
template <typename _Tp> using result_of_t = typename C<_Tp>::type;
template <typename> void forward();
template <typename> void forward() { }
template <typename _Tp> _Tp move(_Tp) {}
namespace __cxx11 {
class basic_string typedef string;
@ -119,7 +119,7 @@ class H {
template <typename Func> void schedule(Func func) {
G __trans_tmp_1;
struct task_with_ready_state {
task_with_ready_state(Func, G);
task_with_ready_state(Func, G) { };
};
std::make_unique<task_with_ready_state>(std::move(func), __trans_tmp_1);
_promise->schedule(std::move(func));

8
gcc/testsuite/g++.dg/opt/dump1.C
View File

@ -311,7 +311,7 @@ namespace std __attribute__ ((__visibility__ ("default")))
typename __add_ref<
typename tuple_element<__i, tuple<_Elements...>>::type
>::type
get(tuple<_Elements...>& __t) noexcept;
get(tuple<_Elements...>& __t) noexcept; // { dg-warning "used but never defined" }
template<std::size_t... _Indexes>
struct _Index_tuple
{};
@ -386,7 +386,7 @@ namespace std __attribute__ ((__visibility__ ("default")))
};
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
__bind_simple(_Callable&& __callable, _Args&&... __args) // { dg-warning "used but never defined" }
;
union _Any_data
;
@ -403,7 +403,7 @@ namespace std __attribute__ ((__visibility__ ("default")))
{
protected:
static _Functor*
_M_get_pointer(const _Any_data& __source)
_M_get_pointer(const _Any_data& __source) // { dg-warning "used but never defined" }
;
};
};
@ -510,7 +510,7 @@ namespace std __attribute__ ((__visibility__ ("default")))
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
{ ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
static pointer
allocate(_Alloc& __a, size_type __n)
allocate(_Alloc& __a, size_type __n) // { dg-warning "used but never defined" }
;
template<typename _Tp, typename... _Args>
static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)

2
gcc/testsuite/g++.dg/opt/pr59622-3.C
View File

@ -8,7 +8,7 @@ namespace
{
struct A
{
virtual C foo ();
virtual C foo (); // { dg-warning "used but never defined" }
C bar () { return foo (); }
};
}

2
gcc/testsuite/g++.dg/opt/pr59622.C
View File

@ -6,7 +6,7 @@ namespace
{
struct A
{
virtual int foo ();
virtual int foo (); // { dg-warning "used but never defined" }
int bar () { return foo (); }
};
}

8
gcc/testsuite/g++.dg/torture/pr46383.C
View File

@ -69,9 +69,9 @@ template < class Tr, class Derived, class Element, class Previous, class Triangu
Mesher_level(Previous_level& previous)
: previous_level(previous)
{ }
Vertex_handle insert(Point p, Zone& z) ;
Zone conflicts_zone(const Point& p, Element e) ;
Element get_next_element() ;
Vertex_handle insert(Point p, Zone& z) ; // { dg-warning "used but never defined" }
Zone conflicts_zone(const Point& p, Element e) ; // { dg-warning "used but never defined" }
Element get_next_element() ; // { dg-warning "used but never defined" }
template <class Mesh_visitor> void before_insertion(Element& e, const Point& p, Zone& zone, Mesh_visitor visitor) {
visitor.before_insertion(e, p, zone);
}
@ -171,7 +171,7 @@ template <typename Tr> struct Triangulation_mesher_level_traits_3
tr.is_infinite(f) ;
new_facet<false>(f);
}
template <bool remove_from_complex_if_not_in_restricted_Delaunay> void new_facet (const Facet& f) ;
template <bool remove_from_complex_if_not_in_restricted_Delaunay> void new_facet (const Facet& f) ; // { dg-warning "used but never defined" }
void after_insertion_handle_opposite_facet (const Facet& f) {
after_insertion_handle_incident_facet (f);
}

2
gcc/testsuite/gcc.dg/dfp/pragma-float-const-decimal64-8.c
View File

@ -145,7 +145,7 @@ here:
double
f10 (void)
{
void foo10 (void)
void foo10 (void) /* { dg-warning "defined but not used" } */
{
a = 1.0;
}

2
gcc/testsuite/gfortran.dg/intent_out_8.f90
View File

@ -10,7 +10,7 @@ end type t
contains
subroutine foo(x)
subroutine foo(x) ! { dg-warning "defined but not used" }
type(t), intent(out) :: x
end subroutine

4
gcc/testsuite/gfortran.dg/warn_target_lifetime_3.f90
View File

@ -10,7 +10,7 @@ subroutine test
integer, target :: t
p => t
contains
subroutine sub()
subroutine sub() ! { dg-warning "defined but not used" }
if (p /= 0) return
end subroutine
end subroutine
@ -22,7 +22,7 @@ contains
integer, target :: t2
p2 => t2 ! { dg-warning "Pointer at .1. in pointer assignment might outlive the pointer target" }
contains
subroutine sub()
subroutine sub() ! { dg-warning "defined but not used" }
if (p2 /= 0) return
end subroutine
end subroutine

10
gcc/timevar.def
View File

@ -31,11 +31,17 @@
/* The total execution time. */
DEFTIMEVAR (TV_TOTAL , "total time")
/* The compiler phases. These must be mutually exclusive.
Ideally, they would sum to near the total time. */
/* The compiler phases.
These must be mutually exclusive, and the NAME field must begin
with "phase".
Also, their sum must be within a millionth of the total time (see
validate_phases). */
DEFTIMEVAR (TV_PHASE_SETUP , "phase setup")
DEFTIMEVAR (TV_PHASE_PARSING , "phase parsing")
DEFTIMEVAR (TV_PHASE_DEFERRED , "phase lang. deferred")
DEFTIMEVAR (TV_PHASE_LATE_PARSING_CLEANUPS, "phase late parsing cleanups")
DEFTIMEVAR (TV_PHASE_OPT_GEN , "phase opt and generate")
DEFTIMEVAR (TV_PHASE_DBGINFO , "phase debug info")
DEFTIMEVAR (TV_PHASE_CHECK_DBGINFO , "phase check & debug info")

78
gcc/toplev.c
View File

@ -492,15 +492,15 @@ wrapup_global_declarations (tree *vec, int len)
return output_something;
}
/* A subroutine of check_global_declarations. Issue appropriate warnings
for the global declaration DECL. */
/* Issue appropriate warnings for the global declaration DECL. */
void
check_global_declaration_1 (tree decl)
check_global_declaration (tree decl)
{
/* Warn about any function declared static but not defined. We don't
warn about variables, because many programs have static variables
that exist only to get some text into the object file. */
symtab_node *snode = symtab_node::get (decl);
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) == 0
&& DECL_EXTERNAL (decl)
@ -508,9 +508,9 @@ check_global_declaration_1 (tree decl)
&& ! TREE_NO_WARNING (decl)
&& ! TREE_PUBLIC (decl)
&& (warn_unused_function
|| TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
|| snode->referred_to_p (/*include_self=*/false)))
{
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
if (snode->referred_to_p (/*include_self=*/false))
pedwarn (input_location, 0, "%q+F used but never defined", decl);
else
warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl);
@ -525,6 +525,10 @@ check_global_declaration_1 (tree decl)
|| (warn_unused_variable
&& TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl)))
&& ! DECL_IN_SYSTEM_HEADER (decl)
&& ! snode->referred_to_p (/*include_self=*/false)
/* This TREE_USED check is needed in addition to referred_to_p
above, because the `__unused__' attribute is not being
considered for referred_to_p. */
&& ! TREE_USED (decl)
/* The TREE_USED bit for file-scope decls is kept in the identifier,
to handle multiple external decls in different scopes. */
@ -535,6 +539,10 @@ check_global_declaration_1 (tree decl)
&& ! TREE_THIS_VOLATILE (decl)
/* Global register variables must be declared to reserve them. */
&& ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
/* Global ctors and dtors are called by the runtime. */
&& (TREE_CODE (decl) != FUNCTION_DECL
|| (!DECL_STATIC_CONSTRUCTOR (decl)
&& !DECL_STATIC_DESTRUCTOR (decl)))
/* Otherwise, ask the language. */
&& lang_hooks.decls.warn_unused_global (decl))
warning ((TREE_CODE (decl) == FUNCTION_DECL)
@ -543,38 +551,6 @@ check_global_declaration_1 (tree decl)
"%q+D defined but not used", decl);
}
/* Issue appropriate warnings for the global declarations in V (of
which there are LEN). */
void
check_global_declarations (tree *v, int len)
{
int i;
for (i = 0; i < len; i++)
check_global_declaration_1 (v[i]);
}
/* Emit debugging information for all global declarations in VEC. */
void
emit_debug_global_declarations (tree *vec, int len)
{
int i;
/* Avoid confusing the debug information machinery when there are errors. */
if (seen_error ())
return;
/* No need for debug info in object files when producing slimLTO. */
if (!in_lto_p && flag_lto && !flag_fat_lto_objects)
return;
timevar_push (TV_SYMOUT);
for (i = 0; i < len; i++)
debug_hooks->global_decl (vec[i]);
timevar_pop (TV_SYMOUT);
}
/* Compile an entire translation unit. Write a file of assembly
output and various debugging dumps. */
@ -584,8 +560,7 @@ compile_file (void)
timevar_start (TV_PHASE_PARSING);
timevar_push (TV_PARSE_GLOBAL);
/* Call the parser, which parses the entire file (calling
rest_of_compilation for each function). */
/* Parse entire file and generate initial debug information. */
lang_hooks.parse_file ();
timevar_pop (TV_PARSE_GLOBAL);
@ -602,12 +577,33 @@ compile_file (void)
ggc_protect_identifiers = false;
/* This must also call finalize_compilation_unit. */
lang_hooks.decls.final_write_globals ();
/* Run the actual compilation process. */
if (!in_lto_p)
{
timevar_start (TV_PHASE_OPT_GEN);
symtab->finalize_compilation_unit ();
timevar_stop (TV_PHASE_OPT_GEN);
}
/* Perform any post compilation-proper parser cleanups and
processing. This is currently only needed for the C++ parser,
which can be hopefully cleaned up so this hook is no longer
necessary. */
if (lang_hooks.decls.post_compilation_parsing_cleanups)
lang_hooks.decls.post_compilation_parsing_cleanups ();
if (seen_error ())
return;
/* After the parser has generated debugging information, augment
this information with any new location/etc information that may
have become available after the compilation proper. */
timevar_start (TV_PHASE_DBGINFO);
symtab_node *node;
FOR_EACH_DEFINED_SYMBOL (node)
debug_hooks->late_global_decl (node->decl);
timevar_stop (TV_PHASE_DBGINFO);
timevar_start (TV_PHASE_LATE_ASM);
/* Compilation unit is finalized. When producing non-fat LTO object, we are

7
gcc/toplev.h
View File

@ -59,10 +59,9 @@ extern void announce_function (tree);
extern void wrapup_global_declaration_1 (tree);
extern bool wrapup_global_declaration_2 (tree);
extern bool wrapup_global_declarations (tree *, int);
extern void check_global_declaration_1 (tree);
extern void check_global_declarations (tree *, int);
extern void emit_debug_global_declarations (tree *, int);
extern void write_global_declarations (void);
extern void check_global_declaration (tree);
extern void global_decl_processing (void);
extern void dump_memory_report (bool);
extern void dump_profile_report (void);

1
gcc/tree-switch-conversion.c
View File

@ -1093,6 +1093,7 @@ build_one_array (gswitch *swtch, int num, tree arr_index_type,
DECL_IGNORED_P (decl) = 1;
TREE_CONSTANT (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_IGNORED_P (decl) = 1;
varpool_node::finalize_decl (decl);
fetch = build4 (ARRAY_REF, value_type, decl, tidx, NULL_TREE,

24
gcc/vmsdbgout.c
View File

@ -171,7 +171,8 @@ static void vmsdbgout_begin_epilogue (unsigned int, const char *);
static void vmsdbgout_end_epilogue (unsigned int, const char *);
static void vmsdbgout_begin_function (tree);
static void vmsdbgout_decl (tree);
static void vmsdbgout_global_decl (tree);
static void vmsdbgout_early_global_decl (tree);
static void vmsdbgout_late_global_decl (tree);
static void vmsdbgout_type_decl (tree, int);
static void vmsdbgout_abstract_function (tree);
@ -180,6 +181,7 @@ static void vmsdbgout_abstract_function (tree);
const struct gcc_debug_hooks vmsdbg_debug_hooks
= {vmsdbgout_init,
vmsdbgout_finish,
debug_nothing_void,
vmsdbgout_assembly_start,
vmsdbgout_define,
vmsdbgout_undef,
@ -195,8 +197,9 @@ const struct gcc_debug_hooks vmsdbg_debug_hooks
vmsdbgout_end_epilogue,
vmsdbgout_begin_function,
vmsdbgout_end_function,
vmsdbgout_decl,
vmsdbgout_global_decl,
vmsdbgout_function_decl,
vmsdbgout_early_global_decl,
vmsdbgout_late_global_decl,
vmsdbgout_type_decl, /* type_decl */
debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
debug_nothing_tree, /* deferred_inline_function */
@ -1509,7 +1512,7 @@ vmsdbgout_undef (unsigned int lineno, const char *buffer)
/* Not implemented in VMS Debug. */
static void
vmsdbgout_decl (tree decl)
vmsdbgout_function_decl (tree decl)
{
if (write_symbols == VMS_AND_DWARF2_DEBUG)
(*dwarf2_debug_hooks.function_decl) (decl);
@ -1518,10 +1521,19 @@ vmsdbgout_decl (tree decl)
/* Not implemented in VMS Debug. */
static void
vmsdbgout_global_decl (tree decl)
vmsdbgout_early_global_decl (tree decl)
{
if (write_symbols == VMS_AND_DWARF2_DEBUG)
(*dwarf2_debug_hooks.global_decl) (decl);
(*dwarf2_debug_hooks.early_global_decl) (decl);
}
/* Not implemented in VMS Debug. */
static void
vmsdbgout_late_global_decl (tree decl)
{
if (write_symbols == VMS_AND_DWARF2_DEBUG)
(*dwarf2_debug_hooks.late_global_decl) (decl);
}
/* Not implemented in VMS Debug. */