===================================================================
*************** compile_file (void)
{
/* Initialize yet another pass. */
+ timevar_start (TV_PHASE_PARSING);
+
ggc_protect_identifiers = true;
init_cgraph ();
*************** compile_file (void)
statistics_init ();
invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
! timevar_push (TV_PARSE);
/* Call the parser, which parses the entire file (calling
rest_of_compilation for each function). */
statistics_init ();
invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
! timevar_push (TV_PARSE_GLOBAL);
/* Call the parser, which parses the entire file (calling
rest_of_compilation for each function). */
*************** compile_file (void)
/* Compilation is now finished except for writing
what's left of the symbol table output. */
! timevar_pop (TV_PARSE);
if (flag_syntax_only || flag_wpa)
return;
/* Compilation is now finished except for writing
what's left of the symbol table output. */
! timevar_pop (TV_PARSE_GLOBAL);
!
! timevar_stop (TV_PHASE_PARSING);
if (flag_syntax_only || flag_wpa)
return;
*************** compile_file (void)
if (seen_error ())
return;
+ timevar_start (TV_PHASE_GENERATE);
+
varpool_assemble_pending_decls ();
finish_aliases_2 ();
*************** compile_file (void)
into the assembly file here, and hence we can not output anything to the
assembly file after this point. */
targetm.asm_out.file_end ();
+
+ timevar_stop (TV_PHASE_GENERATE);
}
/* Indexed by enum debug_info_type. */
*************** do_compile (void)
/* Don't do any more if an error has already occurred. */
if (!seen_error ())
{
+ timevar_start (TV_PHASE_SETUP);
+
/* This must be run always, because it is needed to compute the FP
predefined macros, such as __LDBL_MAX__, for targets using non
default FP formats. */
*************** do_compile (void)
if (!no_backend)
backend_init ();
+ timevar_stop (TV_PHASE_SETUP);
+
/* Language-dependent initialization. Returns true on success. */
if (lang_dependent_init (main_input_filename))
compile_file ();
+ timevar_start (TV_PHASE_FINALIZE);
+
finalize (no_backend);
+
+ timevar_stop (TV_PHASE_FINALIZE);
}
/* Stop timing and print the times. */
===================================================================
*************** poplevel (int keep, int reverse, int fun
unsigned ix;
cp_label_binding *label_bind;
! timevar_push (TV_NAME_LOOKUP);
restart:
block = NULL_TREE;
unsigned ix;
cp_label_binding *label_bind;
! timevar_start (TV_NAME_LOOKUP);
restart:
block = NULL_TREE;
*************** poplevel (int keep, int reverse, int fun
if (kind == sk_cleanup)
goto restart;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
}
/* Walk all the namespaces contained NAMESPACE, including NAMESPACE
if (kind == sk_cleanup)
goto restart;
! timevar_stop (TV_NAME_LOOKUP);
! return block;
}
/* Walk all the namespaces contained NAMESPACE, including NAMESPACE
*************** push_local_name (tree decl)
size_t i, nelts;
tree t, name;
! timevar_push (TV_NAME_LOOKUP);
name = DECL_NAME (decl);
size_t i, nelts;
tree t, name;
! timevar_start (TV_NAME_LOOKUP);
name = DECL_NAME (decl);
*************** push_local_name (tree decl)
DECL_DISCRIMINATOR (decl) = 1;
VEC_replace (tree, local_names, i, decl);
! timevar_pop (TV_NAME_LOOKUP);
return;
}
}
VEC_safe_push (tree, gc, local_names, decl);
! timevar_pop (TV_NAME_LOOKUP);
}
/* Subroutine of duplicate_decls: return truthvalue of whether
DECL_DISCRIMINATOR (decl) = 1;
VEC_replace (tree, local_names, i, decl);
! timevar_stop (TV_NAME_LOOKUP);
return;
}
}
VEC_safe_push (tree, gc, local_names, decl);
! timevar_stop (TV_NAME_LOOKUP);
}
/* Subroutine of duplicate_decls: return truthvalue of whether
*************** make_label_decl (tree id, int local_p)
be found, create one. (We keep track of used, but undefined,
labels, and complain about them at the end of a function.) */
! tree
! lookup_label (tree id)
{
tree decl;
- timevar_push (TV_NAME_LOOKUP);
/* You can't use labels at global scope. */
if (current_function_decl == NULL_TREE)
{
error ("label %qE referenced outside of any function", id);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}
/* See if we've already got this label. */
decl = IDENTIFIER_LABEL_VALUE (id);
if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
decl = make_label_decl (id, /*local_p=*/0);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
/* Declare a local label named ID. */
be found, create one. (We keep track of used, but undefined,
labels, and complain about them at the end of a function.) */
! static tree
! lookup_label_1 (tree id)
{
tree decl;
/* You can't use labels at global scope. */
if (current_function_decl == NULL_TREE)
{
error ("label %qE referenced outside of any function", id);
! return NULL_TREE;
}
/* See if we've already got this label. */
decl = IDENTIFIER_LABEL_VALUE (id);
if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
! return decl;
decl = make_label_decl (id, /*local_p=*/0);
! return decl;
! }
!
! /* Wrapper for lookup_label_1. */
!
! tree
! lookup_label (tree id)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = lookup_label_1 (id);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Declare a local label named ID. */
*************** check_omp_return (void)
/* Define a label, specifying the location in the source file.
Return the LABEL_DECL node for the label. */
! tree
! define_label (location_t location, tree name)
{
struct named_label_entry *ent, dummy;
struct cp_binding_level *p;
tree decl;
- timevar_push (TV_NAME_LOOKUP);
-
decl = lookup_label (name);
dummy.label_decl = decl;
/* Define a label, specifying the location in the source file.
Return the LABEL_DECL node for the label. */
! static tree
! define_label_1 (location_t location, tree name)
{
struct named_label_entry *ent, dummy;
struct cp_binding_level *p;
tree decl;
decl = lookup_label (name);
dummy.label_decl = decl;
*************** define_label (location_t location, tree
if (DECL_INITIAL (decl) != NULL_TREE)
{
error ("duplicate label %qD", decl);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
else
{
if (DECL_INITIAL (decl) != NULL_TREE)
{
error ("duplicate label %qD", decl);
! return error_mark_node;
}
else
{
*************** define_label (location_t location, tree
ent->uses = NULL;
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
struct cp_switch
{
struct cp_binding_level *level;
ent->uses = NULL;
}
! return decl;
}
+ /* Wrapper for define_label_1. */
+
+ tree
+ define_label (location_t location, tree name)
+ {
+ tree ret;
+ timevar_start (TV_NAME_LOOKUP);
+ ret = define_label_1 (location, name);
+ timevar_stop (TV_NAME_LOOKUP);
+ return ret;
+ }
+
+
struct cp_switch
{
struct cp_binding_level *level;
*************** lookup_and_check_tag (enum tag_types tag
TEMPLATE_HEADER_P is true when this declaration is preceded by
a set of template parameters. */
! tree
! xref_tag (enum tag_types tag_code, tree name,
! tag_scope scope, bool template_header_p)
{
enum tree_code code;
tree t;
tree context = NULL_TREE;
- timevar_push (TV_NAME_LOOKUP);
-
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
switch (tag_code)
TEMPLATE_HEADER_P is true when this declaration is preceded by
a set of template parameters. */
! static tree
! xref_tag_1 (enum tag_types tag_code, tree name,
! tag_scope scope, bool template_header_p)
{
enum tree_code code;
tree t;
tree context = NULL_TREE;
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
switch (tag_code)
*************** xref_tag (enum tag_types tag_code, tree
scope, template_header_p);
if (t == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
if (scope != ts_current && t && current_class_type
&& template_class_depth (current_class_type)
scope, template_header_p);
if (t == error_mark_node)
! return error_mark_node;
if (scope != ts_current && t && current_class_type
&& template_class_depth (current_class_type)
*************** xref_tag (enum tag_types tag_code, tree
if (code == ENUMERAL_TYPE)
{
error ("use of enum %q#D without previous declaration", name);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
else
{
if (code == ENUMERAL_TYPE)
{
error ("use of enum %q#D without previous declaration", name);
! return error_mark_node;
}
else
{
*************** xref_tag (enum tag_types tag_code, tree
if (template_header_p && MAYBE_CLASS_TYPE_P (t))
{
if (!redeclare_class_template (t, current_template_parms))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
else if (!processing_template_decl
&& CLASS_TYPE_P (t)
if (template_header_p && MAYBE_CLASS_TYPE_P (t))
{
if (!redeclare_class_template (t, current_template_parms))
! return error_mark_node;
}
else if (!processing_template_decl
&& CLASS_TYPE_P (t)
*************** xref_tag (enum tag_types tag_code, tree
{
error ("redeclaration of %qT as a non-template", t);
error ("previous declaration %q+D", t);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
/* Make injected friend class visible. */
{
error ("redeclaration of %qT as a non-template", t);
error ("previous declaration %q+D", t);
! return error_mark_node;
}
/* Make injected friend class visible. */
*************** xref_tag (enum tag_types tag_code, tree
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
tree
xref_tag_from_type (tree old, tree id, tag_scope scope)
{
}
}
! return t;
! }
!
! /* Wrapper for xref_tag_1. */
!
! tree
! xref_tag (enum tag_types tag_code, tree name,
! tag_scope scope, bool template_header_p)
! {
! tree ret;
! timevar_start (TV_NAME_LOOKUP);
! ret = xref_tag_1 (tag_code, name, scope, template_header_p);
! timevar_stop (TV_NAME_LOOKUP);
! return ret;
}
+
tree
xref_tag_from_type (tree old, tree id, tag_scope scope)
{
===================================================================
*************** cp/class.o: cp/class.c $(CXX_TREE_H) $(T
$(SPLAY_TREE_H)
cp/call.o: cp/call.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h \
$(DIAGNOSTIC_CORE_H) intl.h gt-cp-call.h convert.h $(TARGET_H) langhooks.h \
! c-family/c-objc.h
cp/friend.o: cp/friend.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H)
cp/init.o: cp/init.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) \
$(EXCEPT_H) $(TARGET_H)
$(SPLAY_TREE_H)
cp/call.o: cp/call.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h \
$(DIAGNOSTIC_CORE_H) intl.h gt-cp-call.h convert.h $(TARGET_H) langhooks.h \
! $(TIMEVAR_H) c-family/c-objc.h
cp/friend.o: cp/friend.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H)
cp/init.o: cp/init.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) \
$(EXCEPT_H) $(TARGET_H)
*************** cp/mangle.o: cp/mangle.c $(CXX_TREE_H) $
gt-cp-mangle.h $(TARGET_H) $(TM_P_H) $(CGRAPH_H)
cp/parser.o: cp/parser.c $(CXX_TREE_H) $(TM_H) $(DIAGNOSTIC_CORE_H) \
gt-cp-parser.h output.h $(TARGET_H) $(PLUGIN_H) intl.h \
! c-family/c-objc.h
cp/cp-gimplify.o: cp/cp-gimplify.c $(CXX_TREE_H) $(C_COMMON_H) \
$(TM_H) coretypes.h pointer-set.h tree-iterator.h
gt-cp-mangle.h $(TARGET_H) $(TM_P_H) $(CGRAPH_H)
cp/parser.o: cp/parser.c $(CXX_TREE_H) $(TM_H) $(DIAGNOSTIC_CORE_H) \
gt-cp-parser.h output.h $(TARGET_H) $(PLUGIN_H) intl.h \
! $(TIMEVAR_H) c-family/c-objc.h
cp/cp-gimplify.o: cp/cp-gimplify.c $(CXX_TREE_H) $(C_COMMON_H) \
$(TM_H) coretypes.h pointer-set.h tree-iterator.h
===================================================================
*************** maybe_get_template_decl_from_type_decl (
that we want to avoid. It also causes some problems with argument
coercion (see convert_nontype_argument for more information on this). */
! tree
! lookup_template_class (tree d1,
! tree arglist,
! tree in_decl,
! tree context,
! int entering_scope,
! tsubst_flags_t complain)
{
tree templ = NULL_TREE, parmlist;
tree t;
that we want to avoid. It also causes some problems with argument
coercion (see convert_nontype_argument for more information on this). */
! static tree
! lookup_template_class_1 (tree d1, tree arglist, tree in_decl, tree context,
! int entering_scope, tsubst_flags_t complain)
{
tree templ = NULL_TREE, parmlist;
tree t;
*************** lookup_template_class (tree d1,
spec_entry elt;
hashval_t hash;
- timevar_push (TV_NAME_LOOKUP);
-
if (TREE_CODE (d1) == IDENTIFIER_NODE)
{
tree value = innermost_non_namespace_value (d1);
*************** lookup_template_class (tree d1,
{
if (complain & tf_error)
error ("%qT is not a template", d1);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
if (TREE_CODE (templ) != TEMPLATE_DECL
{
if (complain & tf_error)
error ("%qT is not a template", d1);
! return error_mark_node;
}
if (TREE_CODE (templ) != TEMPLATE_DECL
*************** lookup_template_class (tree d1,
if (in_decl)
error ("for template declaration %q+D", in_decl);
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
complain &= ~tf_user;
if (in_decl)
error ("for template declaration %q+D", in_decl);
}
! return error_mark_node;
}
complain &= ~tf_user;
*************** lookup_template_class (tree d1,
if (arglist2 == error_mark_node
|| (!uses_template_parms (arglist2)
&& check_instantiated_args (templ, arglist2, complain)))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
}
else
{
if (arglist2 == error_mark_node
|| (!uses_template_parms (arglist2)
&& check_instantiated_args (templ, arglist2, complain)))
! return error_mark_node;
parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
! return parm;
}
else
{
*************** lookup_template_class (tree d1,
{
/* Restore the ARGLIST to its full size. */
TREE_VEC_LENGTH (arglist) = saved_depth;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
SET_TMPL_ARGS_LEVEL (bound_args, i, a);
{
/* Restore the ARGLIST to its full size. */
TREE_VEC_LENGTH (arglist) = saved_depth;
! return error_mark_node;
}
SET_TMPL_ARGS_LEVEL (bound_args, i, a);
*************** lookup_template_class (tree d1,
if (arglist == error_mark_node)
/* We were unable to bind the arguments. */
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
/* In the scope of a template class, explicit references to the
template class refer to the type of the template, not any
if (arglist == error_mark_node)
/* We were unable to bind the arguments. */
! return error_mark_node;
/* In the scope of a template class, explicit references to the
template class refer to the type of the template, not any
*************** lookup_template_class (tree d1,
/* comp_template_args is expensive, check it last. */
&& comp_template_args (TYPE_TI_ARGS (template_type),
arglist))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, template_type);
/* If we already have this specialization, return it. */
elt.tmpl = gen_tmpl;
/* comp_template_args is expensive, check it last. */
&& comp_template_args (TYPE_TI_ARGS (template_type),
arglist))
! return template_type;
/* If we already have this specialization, return it. */
elt.tmpl = gen_tmpl;
*************** lookup_template_class (tree d1,
&elt, hash);
if (entry)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->spec);
is_dependent_type = uses_template_parms (arglist);
&elt, hash);
if (entry)
! return entry->spec;
is_dependent_type = uses_template_parms (arglist);
*************** lookup_template_class (tree d1,
&& check_instantiated_args (gen_tmpl,
INNERMOST_TEMPLATE_ARGS (arglist),
complain))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
if (!is_dependent_type
&& !PRIMARY_TEMPLATE_P (gen_tmpl)
&& check_instantiated_args (gen_tmpl,
INNERMOST_TEMPLATE_ARGS (arglist),
complain))
! return error_mark_node;
if (!is_dependent_type
&& !PRIMARY_TEMPLATE_P (gen_tmpl)
*************** lookup_template_class (tree d1,
found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
DECL_NAME (gen_tmpl),
/*tag_scope=*/ts_global);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
}
context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
found = xref_tag_from_type (TREE_TYPE (gen_tmpl),
DECL_NAME (gen_tmpl),
/*tag_scope=*/ts_global);
! return found;
}
context = tsubst (DECL_CONTEXT (gen_tmpl), arglist,
*************** lookup_template_class (tree d1,
TREE_PUBLIC (type_decl) = 1;
determine_visibility (type_decl);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
! timevar_pop (TV_NAME_LOOKUP);
}
struct pair_fn_data
TREE_PUBLIC (type_decl) = 1;
determine_visibility (type_decl);
! return t;
}
! }
!
! /* Wrapper for lookup_template_class_1. */
!
! tree
! lookup_template_class (tree d1, tree arglist, tree in_decl, tree context,
! int entering_scope, tsubst_flags_t complain)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = lookup_template_class_1 (d1, arglist, in_decl, context,
! entering_scope, complain);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
struct pair_fn_data
*************** perform_typedefs_access_check (tree tmpl
input_location = saved_location;
}
! tree
! instantiate_class_template (tree type)
{
tree templ, args, pattern, t, member;
tree typedecl;
input_location = saved_location;
}
! static tree
! instantiate_class_template_1 (tree type)
{
tree templ, args, pattern, t, member;
tree typedecl;
*************** instantiate_class_template (tree type)
return type;
}
+ /* Wrapper for instantiate_class_template_1. */
+
+ tree
+ instantiate_class_template (tree type)
+ {
+ tree ret;
+ timevar_push (TV_INSTANTIATE_TEMPLATE);
+ ret = instantiate_class_template_1 (type);
+ timevar_pop (TV_INSTANTIATE_TEMPLATE);
+ return ret;
+ }
+
static tree
tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
{
*************** check_instantiated_args (tree tmpl, tree
/* Instantiate the indicated variable or function template TMPL with
the template arguments in TARG_PTR. */
! tree
! instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
{
tree targ_ptr = orig_args;
tree fndecl;
/* Instantiate the indicated variable or function template TMPL with
the template arguments in TARG_PTR. */
! static tree
! instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
{
tree targ_ptr = orig_args;
tree fndecl;
*************** instantiate_template (tree tmpl, tree or
return fndecl;
}
+ /* Wrapper for instantiate_template_1. */
+
+ tree
+ instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
+ {
+ tree ret;
+ timevar_push (TV_INSTANTIATE_TEMPLATE);
+ ret = instantiate_template_1 (tmpl, orig_args, complain);
+ timevar_pop (TV_INSTANTIATE_TEMPLATE);
+ return ret;
+ }
+
/* The FN is a TEMPLATE_DECL for a function. ARGS is an array with
NARGS elements of the arguments that are being used when calling
it. TARGS is a vector into which the deduced template arguments
*************** instantiate_decl (tree d, int defer_ok,
if (! push_tinst_level (d))
return d;
! timevar_push (TV_PARSE);
/* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
for the instantiation. */
if (! push_tinst_level (d))
return d;
! timevar_push (TV_PARSE_GLOBAL);
/* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
for the instantiation. */
*************** out:
pop_deferring_access_checks ();
pop_tinst_level ();
! timevar_pop (TV_PARSE);
return d;
}
pop_deferring_access_checks ();
pop_tinst_level ();
! timevar_pop (TV_PARSE_GLOBAL);
return d;
}
===================================================================
*************** 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:
*************** cp_write_global_declarations (void)
generating the initializer for an object may cause templates to be
instantiated, etc., etc. */
- timevar_push (TV_VARCONST);
-
emit_support_tinfos ();
do
*************** cp_write_global_declarations (void)
/* Collect candidates for Java hidden aliases. */
candidates = collect_candidates_for_java_method_aliases ();
+ timevar_stop (TV_PHASE_DEFERRED);
+ timevar_start (TV_PHASE_CGRAPH);
+
cgraph_finalize_compilation_unit ();
+ timevar_stop (TV_PHASE_CGRAPH);
+ timevar_start (TV_PHASE_CHECK_AND_GEN_DEBUG);
+
/* Now, issue warnings about static, but not defined, functions,
etc., and emit debugging information. */
walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
*************** cp_write_global_declarations (void)
}
}
- timevar_pop (TV_VARCONST);
-
if (flag_detailed_statistics)
{
dump_tree_statistics ();
*************** cp_write_global_declarations (void)
#ifdef ENABLE_CHECKING
validate_conversion_obstack ();
#endif /* ENABLE_CHECKING */
+
+ timevar_stop (TV_PHASE_CHECK_DBG);
}
/* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
===================================================================
*************** along with GCC; see the file COPYING3.
#include "system.h"
#include "coretypes.h"
#include "tm.h"
+ #include "timevar.h"
#include "cpplib.h"
#include "tree.h"
#include "cp-tree.h"
*************** cp_parser_explicit_instantiation (cp_par
cp_decl_specifier_seq decl_specifiers;
tree extension_specifier = NULL_TREE;
+ timevar_push (TV_INSTANTIATE_TEMPLATE);
+
/* Look for an (optional) storage-class-specifier or
function-specifier. */
if (cp_parser_allow_gnu_extensions_p (parser))
*************** cp_parser_explicit_instantiation (cp_par
end_explicit_instantiation ();
cp_parser_consume_semicolon_at_end_of_statement (parser);
+
+ timevar_pop (TV_INSTANTIATE_TEMPLATE);
}
/* Parse an explicit-specialization.
*************** cp_parser_enum_specifier (cp_parser* par
elaborated-type-specifier. */
if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
{
+ timevar_push (TV_PARSE_ENUM);
if (nested_name_specifier)
{
/* The following catches invalid code such as:
*************** cp_parser_enum_specifier (cp_parser* par
if (scoped_enum_p)
finish_scope ();
+ timevar_pop (TV_PARSE_ENUM);
}
else
{
*************** cp_parser_class_specifier (cp_parser* pa
tree scope = NULL_TREE;
tree bases;
+ timevar_push (TV_PARSE_STRUCT);
push_deferring_access_checks (dk_no_deferred);
/* Parse the class-head. */
*************** cp_parser_class_specifier (cp_parser* pa
{
cp_parser_skip_to_end_of_block_or_statement (parser);
pop_deferring_access_checks ();
+ timevar_pop (TV_PARSE_STRUCT);
return error_mark_node;
}
*************** cp_parser_class_specifier (cp_parser* pa
if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
{
pop_deferring_access_checks ();
+ timevar_pop (TV_PARSE_STRUCT);
return error_mark_node;
}
*************** cp_parser_class_specifier (cp_parser* pa
if (cp_parser_skip_to_closing_brace (parser))
cp_lexer_consume_token (parser->lexer);
pop_deferring_access_checks ();
+ timevar_pop (TV_PARSE_STRUCT);
return error_mark_node;
}
*************** cp_parser_class_specifier (cp_parser* pa
parser->in_unbraced_linkage_specification_p
= saved_in_unbraced_linkage_specification_p;
+ timevar_pop (TV_PARSE_STRUCT);
return type;
}
*************** cp_parser_function_definition_from_speci
{
tree fn;
bool success_p;
+ timevar_push (TV_PARSE_FUNC);
/* Begin the function-definition. */
success_p = start_function (decl_specifiers, declarator, attributes);
*************** cp_parser_function_definition_from_speci
fn = cp_parser_function_definition_after_declarator (parser,
/*inline_p=*/false);
+ timevar_pop (TV_PARSE_FUNC);
return fn;
}
*************** cp_parser_enclosed_template_argument_lis
static void
cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
{
+ timevar_push (TV_PARSE_INMETH);
/* If this member is a template, get the underlying
FUNCTION_DECL. */
if (DECL_FUNCTION_TEMPLATE_P (member_function))
*************** cp_parser_late_parsing_for_member (cp_pa
/* Restore the queue. */
pop_unparsed_function_queues (parser);
+ timevar_pop (TV_PARSE_INMETH);
}
/* If DECL contains any default args, remember it on the unparsed
===================================================================
*************** along with GCC; see the file COPYING3.
#include "convert.h"
#include "langhooks.h"
#include "c-family/c-objc.h"
+ #include "timevar.h"
/* The various kinds of conversion. */
*************** perform_overload_resolution (tree fn,
bool *any_viable_p)
{
struct z_candidate *cand;
! tree explicit_targs = NULL_TREE;
! int template_only = 0;
*candidates = NULL;
*any_viable_p = true;
bool *any_viable_p)
{
struct z_candidate *cand;
! tree explicit_targs;
! int template_only;
!
! timevar_start (TV_RESOLVE_OVERLOAD);
!
! explicit_targs = NULL_TREE;
! template_only = 0;
*candidates = NULL;
*any_viable_p = true;
*************** perform_overload_resolution (tree fn,
candidates);
*candidates = splice_viable (*candidates, pedantic, any_viable_p);
! if (!*any_viable_p)
! return NULL;
! cand = tourney (*candidates);
return cand;
}
candidates);
*candidates = splice_viable (*candidates, pedantic, any_viable_p);
! if (*any_viable_p)
! cand = tourney (*candidates);
! else
! cand = NULL;
! timevar_stop (TV_RESOLVE_OVERLOAD);
return cand;
}
===================================================================
*************** pop_binding (tree id, tree decl)
was successful. */
static bool
! supplement_binding (cxx_binding *binding, tree decl)
{
tree bval = binding->value;
bool ok = true;
- timevar_push (TV_NAME_LOOKUP);
if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
/* The new name is the type name. */
binding->type = decl;
was successful. */
static bool
! supplement_binding_1 (cxx_binding *binding, tree decl)
{
tree bval = binding->value;
bool ok = true;
if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
/* The new name is the type name. */
binding->type = decl;
*************** supplement_binding (cxx_binding *binding
ok = false;
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
}
/* Add DECL to the list of things declared in B. */
ok = false;
}
! return ok;
! }
!
! /* Wrapper for supplement_binding_1. */
!
! static bool
! supplement_binding (cxx_binding *binding, tree decl)
! {
! bool ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = supplement_binding_1 (binding, decl);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Add DECL to the list of things declared in B. */
*************** add_decl_to_level (tree decl, cxx_scope
If an old decl is returned, it may have been smashed
to agree with what X says. */
! tree
! pushdecl_maybe_friend (tree x, bool is_friend)
{
tree t;
tree name;
int need_new_binding;
- timevar_push (TV_NAME_LOOKUP);
-
if (x == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
need_new_binding = 1;
If an old decl is returned, it may have been smashed
to agree with what X says. */
! static tree
! pushdecl_maybe_friend_1 (tree x, bool is_friend)
{
tree t;
tree name;
int need_new_binding;
if (x == error_mark_node)
! return error_mark_node;
need_new_binding = 1;
*************** pushdecl_maybe_friend (tree x, bool is_f
/* Check for duplicate params. */
tree d = duplicate_decls (x, t, is_friend);
if (d)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
}
else if ((DECL_EXTERN_C_FUNCTION_P (x)
|| DECL_FUNCTION_TEMPLATE_P (x))
/* Check for duplicate params. */
tree d = duplicate_decls (x, t, is_friend);
if (d)
! return d;
}
else if ((DECL_EXTERN_C_FUNCTION_P (x)
|| DECL_FUNCTION_TEMPLATE_P (x))
*************** pushdecl_maybe_friend (tree x, bool is_f
TREE_TYPE (x));
/* Throw away the redeclaration. */
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
else
{
TREE_TYPE (x));
/* Throw away the redeclaration. */
! return t;
}
else
{
*************** pushdecl_maybe_friend (tree x, bool is_f
/* If the redeclaration failed, we can stop at this
point. */
if (olddecl == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
if (olddecl)
{
if (TREE_CODE (t) == TYPE_DECL)
SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
{
/* If the redeclaration failed, we can stop at this
point. */
if (olddecl == error_mark_node)
! return error_mark_node;
if (olddecl)
{
if (TREE_CODE (t) == TYPE_DECL)
SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
! return t;
}
else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
{
*************** pushdecl_maybe_friend (tree x, bool is_f
error ("as %qD", x);
/* We don't try to push this declaration since that
causes a crash. */
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}
}
}
error ("as %qD", x);
/* We don't try to push this declaration since that
causes a crash. */
! return x;
}
}
}
*************** pushdecl_maybe_friend (tree x, bool is_f
x_exception_spec,
ce_normal))
{
! pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
x);
! pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
previous);
! pedwarn (input_location, 0, "due to different exception specifications");
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
}
}
else
x_exception_spec,
ce_normal))
{
! pedwarn (input_location, 0,
! "declaration of %q#D with C language linkage",
x);
! pedwarn (input_location, 0,
! "conflicts with previous declaration %q+#D",
previous);
! pedwarn (input_location, 0,
! "due to different exception specifications");
! return error_mark_node;
}
}
else
*************** pushdecl_maybe_friend (tree x, bool is_f
check_default_args (t);
if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
/* If declaring a type as a typedef, copy the type (unless we're
at line 0), and install this TYPE_DECL as the new type's typedef
check_default_args (t);
if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
! return t;
/* If declaring a type as a typedef, copy the type (unless we're
at line 0), and install this TYPE_DECL as the new type's typedef
*************** pushdecl_maybe_friend (tree x, bool is_f
? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
: current_binding_level);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}
/* Record a decl-node X as belonging to the current lexical scope. */
? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
: current_binding_level);
! return x;
! }
!
! /* Wrapper for pushdecl_maybe_friend_1. */
!
! tree
! pushdecl_maybe_friend (tree x, bool is_friend)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = pushdecl_maybe_friend_1 (x, is_friend);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Record a decl-node X as belonging to the current lexical scope. */
*************** print_binding_stack (void)
print_binding_level (NAMESPACE_LEVEL (global_namespace));
}
! /* Return the type associated with id. */
! tree
! identifier_type_value (tree id)
{
- timevar_push (TV_NAME_LOOKUP);
/* There is no type with that name, anywhere. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
/* This is not the type marker, but the real thing. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
/* Have to search for it. It must be on the global level, now.
Ask lookup_name not to return non-types. */
id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
if (id)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}
/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
print_binding_level (NAMESPACE_LEVEL (global_namespace));
}
! /* Return the type associated with ID. */
! static tree
! identifier_type_value_1 (tree id)
{
/* There is no type with that name, anywhere. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
! return NULL_TREE;
/* This is not the type marker, but the real thing. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
! return REAL_IDENTIFIER_TYPE_VALUE (id);
/* Have to search for it. It must be on the global level, now.
Ask lookup_name not to return non-types. */
id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
if (id)
! return TREE_TYPE (id);
! return NULL_TREE;
}
+ /* Wrapper for identifier_type_value_1. */
+
+ tree
+ identifier_type_value (tree id)
+ {
+ tree ret;
+ timevar_start (TV_NAME_LOOKUP);
+ ret = identifier_type_value_1 (id);
+ timevar_stop (TV_NAME_LOOKUP);
+ return ret;
+ }
+
+
/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
*************** make_lambda_name (void)
static inline cxx_binding *
find_binding (cxx_scope *scope, cxx_binding *binding)
{
- timevar_push (TV_NAME_LOOKUP);
-
for (; binding != NULL; binding = binding->previous)
if (binding->scope == scope)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
}
/* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
static inline cxx_binding *
find_binding (cxx_scope *scope, cxx_binding *binding)
{
for (; binding != NULL; binding = binding->previous)
if (binding->scope == scope)
! return binding;
! return (cxx_binding *)0;
}
/* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
*************** lookup_extern_c_fun_binding_in_all_ns (t
scope, a using decl might extend any previous bindings). */
static tree
! push_using_decl (tree scope, tree name)
{
tree decl;
- timevar_push (TV_NAME_LOOKUP);
gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
break;
if (decl)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
! namespace_bindings_p () ? decl : NULL_TREE);
decl = build_lang_decl (USING_DECL, name, NULL_TREE);
USING_DECL_SCOPE (decl) = scope;
DECL_CHAIN (decl) = current_binding_level->usings;
current_binding_level->usings = decl;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
caller to set DECL_CONTEXT properly. */
! tree
! pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
{
struct cp_binding_level *b;
tree function_decl = current_function_decl;
- timevar_push (TV_NAME_LOOKUP);
current_function_decl = NULL_TREE;
if (level->kind == sk_class)
{
scope, a using decl might extend any previous bindings). */
static tree
! push_using_decl_1 (tree scope, tree name)
{
tree decl;
gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
break;
if (decl)
! return namespace_bindings_p () ? decl : NULL_TREE;
decl = build_lang_decl (USING_DECL, name, NULL_TREE);
USING_DECL_SCOPE (decl) = scope;
DECL_CHAIN (decl) = current_binding_level->usings;
current_binding_level->usings = decl;
! return decl;
! }
!
! /* Wrapper for push_using_decl_1. */
!
! static tree
! push_using_decl (tree scope, tree name)
! {
! tree ret;
! timevar_start (TV_NAME_LOOKUP);
! ret = push_using_decl_1 (scope, name);
! timevar_stop (TV_NAME_LOOKUP);
! return ret;
}
/* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
caller to set DECL_CONTEXT properly. */
! static tree
! pushdecl_with_scope_1 (tree x, cxx_scope *level, bool is_friend)
{
struct cp_binding_level *b;
tree function_decl = current_function_decl;
current_function_decl = NULL_TREE;
if (level->kind == sk_class)
{
*************** pushdecl_with_scope (tree x, cxx_scope *
current_binding_level = b;
}
current_function_decl = function_decl;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}
/* DECL is a FUNCTION_DECL for a non-member function, which may have
other definitions already in place. We get around this by making
current_binding_level = b;
}
current_function_decl = function_decl;
! return x;
}
+
+ /* Wrapper for pushdecl_with_scope_1. */
+
+ tree
+ pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
+ {
+ tree ret;
+ bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
+ ret = pushdecl_with_scope_1 (x, level, is_friend);
+ timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+ return ret;
+ }
+
/* DECL is a FUNCTION_DECL for a non-member function, which may have
other definitions already in place. We get around this by making
*************** pushdecl_with_scope (tree x, cxx_scope *
it's always DECL (and never something that's not a _DECL). */
static tree
! push_overloaded_decl (tree decl, int flags, bool is_friend)
{
tree name = DECL_NAME (decl);
tree old;
tree new_binding;
int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
- timevar_push (TV_NAME_LOOKUP);
if (doing_global)
old = namespace_binding (name, DECL_CONTEXT (decl));
else
it's always DECL (and never something that's not a _DECL). */
static tree
! push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
{
tree name = DECL_NAME (decl);
tree old;
tree new_binding;
int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
if (doing_global)
old = namespace_binding (name, DECL_CONTEXT (decl));
else
*************** push_overloaded_decl (tree decl, int fla
/* If DECL was a redeclaration of FN -- even an invalid
one -- pass that information along to our caller. */
if (dup == fn || dup == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
}
/* We don't overload implicit built-ins. duplicate_decls()
/* If DECL was a redeclaration of FN -- even an invalid
one -- pass that information along to our caller. */
if (dup == fn || dup == error_mark_node)
! return dup;
}
/* We don't overload implicit built-ins. duplicate_decls()
*************** push_overloaded_decl (tree decl, int fla
{
error ("previous non-function declaration %q+#D", old);
error ("conflicts with function declaration %q#D", decl);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
}
{
error ("previous non-function declaration %q+#D", old);
error ("conflicts with function declaration %q#D", decl);
! return decl;
}
}
*************** push_overloaded_decl (tree decl, int fla
/* And update the cxx_binding node. */
IDENTIFIER_BINDING (name)->value = new_binding;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
/* We should always find a previous binding in this case. */
/* And update the cxx_binding node. */
IDENTIFIER_BINDING (name)->value = new_binding;
! return decl;
}
/* We should always find a previous binding in this case. */
*************** push_overloaded_decl (tree decl, int fla
push_local_binding (name, new_binding, flags);
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
/* Check a non-member using-declaration. Return the name and scope
push_local_binding (name, new_binding, flags);
}
! return decl;
! }
!
! /* Wrapper for push_overloaded_decl_1. */
!
! static tree
! push_overloaded_decl (tree decl, int flags, bool is_friend)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = push_overloaded_decl_1 (decl, flags, is_friend);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Check a non-member using-declaration. Return the name and scope
*************** poplevel_class (void)
size_t i;
tree shadowed;
! timevar_push (TV_NAME_LOOKUP);
gcc_assert (level != 0);
/* If we're leaving a toplevel class, cache its binding level. */
size_t i;
tree shadowed;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
gcc_assert (level != 0);
/* If we're leaving a toplevel class, cache its binding level. */
*************** poplevel_class (void)
`pushlevel_class' routine. */
gcc_assert (current_binding_level == level);
leave_scope ();
! timevar_pop (TV_NAME_LOOKUP);
}
/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
`pushlevel_class' routine. */
gcc_assert (current_binding_level == level);
leave_scope ();
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
*************** pushdecl_class_level (tree x)
{
tree name;
bool is_valid = true;
/* Do nothing if we're adding to an outer lambda closure type,
outer_binding will add it later if it's needed. */
if (current_class_type != class_binding_level->this_entity)
return true;
! timevar_push (TV_NAME_LOOKUP);
/* Get the name of X. */
if (TREE_CODE (x) == OVERLOAD)
name = DECL_NAME (get_first_fn (x));
{
tree name;
bool is_valid = true;
+ bool subtime;
/* Do nothing if we're adding to an outer lambda closure type,
outer_binding will add it later if it's needed. */
if (current_class_type != class_binding_level->this_entity)
return true;
! subtime = timevar_cond_start (TV_NAME_LOOKUP);
/* Get the name of X. */
if (TREE_CODE (x) == OVERLOAD)
name = DECL_NAME (get_first_fn (x));
*************** pushdecl_class_level (tree x)
input_location = save_location;
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
}
/* Return the BINDING (if any) for NAME in SCOPE, which is a class
input_location = save_location;
}
}
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return is_valid;
}
/* Return the BINDING (if any) for NAME in SCOPE, which is a class
*************** get_class_binding (tree name, cxx_scope
/* Make the declaration(s) of X appear in CLASS scope under the name
NAME. Returns true if the binding is valid. */
! bool
! push_class_level_binding (tree name, tree x)
{
cxx_binding *binding;
tree decl = x;
bool ok;
- timevar_push (TV_NAME_LOOKUP);
/* The class_binding_level will be NULL if x is a template
parameter name in a member template. */
if (!class_binding_level)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
if (name == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
/* Check for invalid member names. */
gcc_assert (TYPE_BEING_DEFINED (current_class_type));
/* Make the declaration(s) of X appear in CLASS scope under the name
NAME. Returns true if the binding is valid. */
! static bool
! push_class_level_binding_1 (tree name, tree x)
{
cxx_binding *binding;
tree decl = x;
bool ok;
/* The class_binding_level will be NULL if x is a template
parameter name in a member template. */
if (!class_binding_level)
! return true;
if (name == error_mark_node)
! return false;
/* Check for invalid member names. */
gcc_assert (TYPE_BEING_DEFINED (current_class_type));
*************** push_class_level_binding (tree name, tre
decl = TREE_VALUE (decl);
if (!check_template_shadow (decl))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
/* [class.mem]
decl = TREE_VALUE (decl);
if (!check_template_shadow (decl))
! return false;
/* [class.mem]
*************** push_class_level_binding (tree name, tre
error ("%qD has the same name as the class in which it is "
"declared",
x);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
}
}
error ("%qD has the same name as the class in which it is "
"declared",
x);
! return false;
}
}
*************** push_class_level_binding (tree name, tre
else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
old_decl = bval;
else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
old_decl = bval;
else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
if (old_decl && binding->scope == class_binding_level)
{
else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
old_decl = bval;
else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
! return true;
else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
old_decl = bval;
else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
! return true;
if (old_decl && binding->scope == class_binding_level)
{
*************** push_class_level_binding (tree name, tre
here. This function is only used to register bindings
from with the class definition itself. */
INHERITED_VALUE_BINDING_P (binding) = 0;
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
}
}
here. This function is only used to register bindings
from with the class definition itself. */
INHERITED_VALUE_BINDING_P (binding) = 0;
! return true;
}
}
*************** push_class_level_binding (tree name, tre
ok = true;
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
}
/* Process "using SCOPE::NAME" in a class scope. Return the
ok = true;
}
! return ok;
! }
!
! /* Wrapper for push_class_level_binding_1. */
!
! bool
! push_class_level_binding (tree name, tree x)
! {
! bool ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = push_class_level_binding_1 (name, x);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Process "using SCOPE::NAME" in a class scope. Return the
*************** do_class_using_decl (tree scope, tree na
/* Return the binding value for name in scope. */
! tree
! namespace_binding (tree name, tree scope)
{
cxx_binding *binding;
/* Return the binding value for name in scope. */
!
! static tree
! namespace_binding_1 (tree name, tree scope)
{
cxx_binding *binding;
*************** namespace_binding (tree name, tree scope
return binding ? binding->value : NULL_TREE;
}
/* Set the binding value for name in scope. */
! void
! set_namespace_binding (tree name, tree scope, tree val)
{
cxx_binding *b;
- timevar_push (TV_NAME_LOOKUP);
if (scope == NULL_TREE)
scope = global_namespace;
b = binding_for_name (NAMESPACE_LEVEL (scope), name);
return binding ? binding->value : NULL_TREE;
}
+ tree
+ namespace_binding (tree name, tree scope)
+ {
+ tree ret;
+ bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
+ ret = namespace_binding_1 (name, scope);
+ timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+ return ret;
+ }
+
/* Set the binding value for name in scope. */
! static void
! set_namespace_binding_1 (tree name, tree scope, tree val)
{
cxx_binding *b;
if (scope == NULL_TREE)
scope = global_namespace;
b = binding_for_name (NAMESPACE_LEVEL (scope), name);
*************** set_namespace_binding (tree name, tree s
b->value = val;
else
supplement_binding (b, val);
! timevar_pop (TV_NAME_LOOKUP);
}
/* Set the context of a declaration to scope. Complain if we are not
b->value = val;
else
supplement_binding (b, val);
! }
!
! /* Wrapper for set_namespace_binding_1. */
!
! void
! set_namespace_binding (tree name, tree scope, tree val)
! {
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! set_namespace_binding_1 (name, scope, val);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Set the context of a declaration to scope. Complain if we are not
*************** push_namespace (tree name)
int implicit_use = 0;
bool anon = !name;
! timevar_push (TV_NAME_LOOKUP);
/* We should not get here if the global_namespace is not yet constructed
nor if NAME designates the global namespace: The global scope is
int implicit_use = 0;
bool anon = !name;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
/* We should not get here if the global_namespace is not yet constructed
nor if NAME designates the global namespace: The global scope is
*************** push_namespace (tree name)
/* Enter the name space. */
current_namespace = d;
! timevar_pop (TV_NAME_LOOKUP);
}
/* Pop from the scope of the current namespace. */
/* Enter the name space. */
current_namespace = d;
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Pop from the scope of the current namespace. */
*************** push_nested_namespace (tree ns)
void
pop_nested_namespace (tree ns)
{
! timevar_push (TV_NAME_LOOKUP);
gcc_assert (current_namespace == ns);
while (ns != global_namespace)
{
void
pop_nested_namespace (tree ns)
{
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
gcc_assert (current_namespace == ns);
while (ns != global_namespace)
{
*************** pop_nested_namespace (tree ns)
}
pop_from_top_level ();
! timevar_pop (TV_NAME_LOOKUP);
}
/* Temporarily set the namespace for the current declaration. */
}
pop_from_top_level ();
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Temporarily set the namespace for the current declaration. */
*************** pop_decl_namespace (void)
of two given namespaces. */
static tree
! namespace_ancestor (tree ns1, tree ns2)
{
! timevar_push (TV_NAME_LOOKUP);
if (is_ancestor (ns1, ns2))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
! namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
}
/* Process a namespace-alias declaration. */
of two given namespaces. */
static tree
! namespace_ancestor_1 (tree ns1, tree ns2)
{
! tree nsr;
if (is_ancestor (ns1, ns2))
! nsr = ns1;
! else
! nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
! return nsr;
! }
!
! /* Wrapper for namespace_ancestor_1. */
!
! static tree
! namespace_ancestor (tree ns1, tree ns2)
! {
! tree nsr;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! nsr = namespace_ancestor_1 (ns1, ns2);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return nsr;
}
/* Process a namespace-alias declaration. */
*************** pushdecl_namespace_level (tree x, bool i
struct cp_binding_level *b = current_binding_level;
tree t;
! timevar_push (TV_NAME_LOOKUP);
t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
/* Now, the type_shadowed stack may screw us. Munge it so it does
struct cp_binding_level *b = current_binding_level;
tree t;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
/* Now, the type_shadowed stack may screw us. Munge it so it does
*************** pushdecl_namespace_level (tree x, bool i
*ptr = newval;
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
/* Insert USED into the using list of USER. Set INDIRECT_flag if this
directive is not directly from the source. Also find the common
ancestor and let our users know about the new namespace */
static void
! add_using_namespace (tree user, tree used, bool indirect)
{
tree t;
- timevar_push (TV_NAME_LOOKUP);
/* Using oneself is a no-op. */
if (user == used)
! {
! timevar_pop (TV_NAME_LOOKUP);
! return;
! }
gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
/* Check if we already have this. */
*ptr = newval;
}
}
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return t;
}
/* Insert USED into the using list of USER. Set INDIRECT_flag if this
directive is not directly from the source. Also find the common
ancestor and let our users know about the new namespace */
+
static void
! add_using_namespace_1 (tree user, tree used, bool indirect)
{
tree t;
/* Using oneself is a no-op. */
if (user == used)
! return;
gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
/* Check if we already have this. */
*************** add_using_namespace (tree user, tree use
if (!indirect)
/* Promote to direct usage. */
TREE_INDIRECT_USING (t) = 0;
- timevar_pop (TV_NAME_LOOKUP);
return;
}
*************** add_using_namespace (tree user, tree use
/* Recursively add all namespaces used. */
for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
/* indirect usage */
! add_using_namespace (user, TREE_PURPOSE (t), 1);
/* Tell everyone using us about the new used namespaces. */
for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
! add_using_namespace (TREE_PURPOSE (t), used, 1);
! timevar_pop (TV_NAME_LOOKUP);
}
/* Process a using-declaration not appearing in class or local scope. */
/* Recursively add all namespaces used. */
for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
/* indirect usage */
! add_using_namespace_1 (user, TREE_PURPOSE (t), 1);
/* Tell everyone using us about the new used namespaces. */
for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
! add_using_namespace_1 (TREE_PURPOSE (t), used, 1);
! }
!
! /* Wrapper for add_using_namespace_1. */
!
! static void
! add_using_namespace (tree user, tree used, bool indirect)
! {
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! add_using_namespace_1 (user, used, indirect);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Process a using-declaration not appearing in class or local scope. */
*************** parse_using_directive (tree name_space,
static tree
pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
{
! timevar_push (TV_NAME_LOOKUP);
push_to_top_level ();
x = pushdecl_namespace_level (x, is_friend);
if (init)
cp_finish_decl (x, *init, false, NULL_TREE, 0);
pop_from_top_level ();
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
}
/* Like pushdecl, only it places X in the global scope if appropriate. */
static tree
pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
{
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
push_to_top_level ();
x = pushdecl_namespace_level (x, is_friend);
if (init)
cp_finish_decl (x, *init, false, NULL_TREE, 0);
pop_from_top_level ();
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return x;
}
/* Like pushdecl, only it places X in the global scope if appropriate. */
*************** suggest_alternatives_for (location_t loc
considering using-directives. */
static tree
! unqualified_namespace_lookup (tree name, int flags)
{
tree initial = current_decl_namespace ();
tree scope = initial;
considering using-directives. */
static tree
! unqualified_namespace_lookup_1 (tree name, int flags)
{
tree initial = current_decl_namespace ();
tree scope = initial;
*************** unqualified_namespace_lookup (tree name,
struct cp_binding_level *level;
tree val = NULL_TREE;
- timevar_push (TV_NAME_LOOKUP);
-
for (; !val; scope = CP_DECL_CONTEXT (scope))
{
struct scope_binding binding = EMPTY_SCOPE_BINDING;
*************** unqualified_namespace_lookup (tree name,
if (!lookup_using_namespace (name, &binding, level->using_directives,
scope, flags))
/* Give up because of error. */
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
/* Add all _DECLs seen through global using-directives. */
/* XXX local and global using lists should work equally. */
if (!lookup_using_namespace (name, &binding, level->using_directives,
scope, flags))
/* Give up because of error. */
! return error_mark_node;
/* Add all _DECLs seen through global using-directives. */
/* XXX local and global using lists should work equally. */
*************** unqualified_namespace_lookup (tree name,
DECL_NAMESPACE_USING (siter),
scope, flags))
/* Give up because of error. */
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
if (siter == scope) break;
siter = CP_DECL_CONTEXT (siter);
}
DECL_NAMESPACE_USING (siter),
scope, flags))
/* Give up because of error. */
! return error_mark_node;
if (siter == scope) break;
siter = CP_DECL_CONTEXT (siter);
}
*************** unqualified_namespace_lookup (tree name,
if (scope == global_namespace)
break;
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
}
/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
if (scope == global_namespace)
break;
}
! return val;
! }
!
! /* Wrapper for unqualified_namespace_lookup_1. */
!
! static tree
! unqualified_namespace_lookup (tree name, int flags)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = unqualified_namespace_lookup_1 (name, flags);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
*************** lookup_using_namespace (tree name, struc
tree usings, tree scope, int flags)
{
tree iter;
! timevar_push (TV_NAME_LOOKUP);
/* Iterate over all used namespaces in current, searching for using
directives of scope. */
for (iter = usings; iter; iter = TREE_CHAIN (iter))
tree usings, tree scope, int flags)
{
tree iter;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
/* Iterate over all used namespaces in current, searching for using
directives of scope. */
for (iter = usings; iter; iter = TREE_CHAIN (iter))
*************** lookup_using_namespace (tree name, struc
if (val1)
ambiguous_decl (val, val1, flags);
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
}
/* Returns true iff VEC contains TARGET. */
if (val1)
ambiguous_decl (val, val1, flags);
}
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return val->value != error_mark_node;
}
/* Returns true iff VEC contains TARGET. */
*************** qualified_lookup_using_namespace (tree n
VEC(tree,gc) *todo_maybe = NULL;
VEC(tree,gc) *todo_inline = NULL;
tree usings;
! timevar_push (TV_NAME_LOOKUP);
/* Look through namespace aliases. */
scope = ORIGINAL_NAMESPACE (scope);
VEC(tree,gc) *todo_maybe = NULL;
VEC(tree,gc) *todo_inline = NULL;
tree usings;
! timevar_start (TV_NAME_LOOKUP);
/* Look through namespace aliases. */
scope = ORIGINAL_NAMESPACE (scope);
*************** qualified_lookup_using_namespace (tree n
VEC_free (tree,gc,todo_inline);
VEC_free (tree,gc,seen);
VEC_free (tree,gc,seen_inline);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
}
/* Subroutine of outer_binding.
VEC_free (tree,gc,todo_inline);
VEC_free (tree,gc,seen);
VEC_free (tree,gc,seen_inline);
! timevar_stop (TV_NAME_LOOKUP);
! return result->value != error_mark_node;
}
/* Subroutine of outer_binding.
*************** innermost_non_namespace_value (tree name
If NONCLASS is nonzero, bindings in class scopes are ignored. If
BLOCK_P is false, bindings in block scopes are ignored. */
! tree
! lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
! int namespaces_only, int flags)
{
cxx_binding *iter;
tree val = NULL_TREE;
- timevar_push (TV_NAME_LOOKUP);
/* Conversion operators are handled specially because ordinary
unqualified name lookup will not find template conversion
operators. */
If NONCLASS is nonzero, bindings in class scopes are ignored. If
BLOCK_P is false, bindings in block scopes are ignored. */
! static tree
! lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
! int namespaces_only, int flags)
{
cxx_binding *iter;
tree val = NULL_TREE;
/* Conversion operators are handled specially because ordinary
unqualified name lookup will not find template conversion
operators. */
*************** lookup_name_real (tree name, int prefer_
class_type = level->this_entity;
operators = lookup_fnfields (class_type, name, /*protect=*/0);
if (operators)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}
flags |= lookup_flags (prefer_type, namespaces_only);
class_type = level->this_entity;
operators = lookup_fnfields (class_type, name, /*protect=*/0);
if (operators)
! return operators;
}
! return NULL_TREE;
}
flags |= lookup_flags (prefer_type, namespaces_only);
*************** lookup_name_real (tree name, int prefer_
if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
val = OVL_FUNCTION (val);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
}
tree
if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
val = OVL_FUNCTION (val);
! return val;
! }
!
! /* Wrapper for lookup_name_real_1. */
!
! tree
! lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
! int namespaces_only, int flags)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
! namespaces_only, flags);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
tree
*************** lookup_name_prefer_type (tree name, int
A TYPE_DECL best matching the NAME is returned. Catching error
and issuing diagnostics are caller's responsibility. */
! tree
! lookup_type_scope (tree name, tag_scope scope)
{
cxx_binding *iter = NULL;
tree val = NULL_TREE;
- timevar_push (TV_NAME_LOOKUP);
-
/* Look in non-namespace scope first. */
if (current_binding_level->kind != sk_namespace)
iter = outer_binding (name, NULL, /*class_p=*/ true);
A TYPE_DECL best matching the NAME is returned. Catching error
and issuing diagnostics are caller's responsibility. */
! static tree
! lookup_type_scope_1 (tree name, tag_scope scope)
{
cxx_binding *iter = NULL;
tree val = NULL_TREE;
/* Look in non-namespace scope first. */
if (current_binding_level->kind != sk_namespace)
iter = outer_binding (name, NULL, /*class_p=*/ true);
*************** lookup_type_scope (tree name, tag_scope
while (b)
{
if (iter->scope == b)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
if (b->kind == sk_cleanup || b->kind == sk_template_parms
|| b->kind == sk_function_parms)
while (b)
{
if (iter->scope == b)
! return val;
if (b->kind == sk_cleanup || b->kind == sk_template_parms
|| b->kind == sk_function_parms)
*************** lookup_type_scope (tree name, tag_scope
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
}
/* Similar to `lookup_name' but look only in the innermost non-class
binding level. */
! tree
! lookup_name_innermost_nonclass_level (tree name)
{
struct cp_binding_level *b;
tree t = NULL_TREE;
- timevar_push (TV_NAME_LOOKUP);
b = innermost_nonclass_level ();
if (b->kind == sk_namespace)
}
}
! return NULL_TREE;
}
+
+ /* Wrapper for lookup_type_scope_1. */
+
+ tree
+ lookup_type_scope (tree name, tag_scope scope)
+ {
+ tree ret;
+ bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
+ ret = lookup_type_scope_1 (name, scope);
+ timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+ return ret;
+ }
+
/* Similar to `lookup_name' but look only in the innermost non-class
binding level. */
! static tree
! lookup_name_innermost_nonclass_level_1 (tree name)
{
struct cp_binding_level *b;
tree t = NULL_TREE;
b = innermost_nonclass_level ();
if (b->kind == sk_namespace)
*************** lookup_name_innermost_nonclass_level (tr
if (binding->scope == b
&& !(TREE_CODE (binding->value) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (binding->value)))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
if (b->kind == sk_cleanup)
b = b->level_chain;
if (binding->scope == b
&& !(TREE_CODE (binding->value) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (binding->value)))
! return binding->value;
if (b->kind == sk_cleanup)
b = b->level_chain;
*************** lookup_name_innermost_nonclass_level (tr
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
/* Returns true iff DECL is a block-scope extern declaration of a function
or variable. */
}
}
! return t;
}
+ /* Wrapper for lookup_name_innermost_nonclass_level_1. */
+
+ tree
+ lookup_name_innermost_nonclass_level (tree name)
+ {
+ tree ret;
+ bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
+ ret = lookup_name_innermost_nonclass_level_1 (name);
+ timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+ return ret;
+ }
+
+
/* Returns true iff DECL is a block-scope extern declaration of a function
or variable. */
*************** lookup_type_current_level (tree name)
{
tree t = NULL_TREE;
! timevar_push (TV_NAME_LOOKUP);
gcc_assert (current_binding_level->kind != sk_namespace);
if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
{
tree t = NULL_TREE;
! timevar_start (TV_NAME_LOOKUP);
gcc_assert (current_binding_level->kind != sk_namespace);
if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
*************** lookup_type_current_level (tree name)
while (1)
{
if (purpose_member (name, b->type_shadowed))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
! REAL_IDENTIFIER_TYPE_VALUE (name));
if (b->kind == sk_cleanup)
b = b->level_chain;
else
while (1)
{
if (purpose_member (name, b->type_shadowed))
! {
! t = REAL_IDENTIFIER_TYPE_VALUE (name);
! break;
! }
if (b->kind == sk_cleanup)
b = b->level_chain;
else
*************** lookup_type_current_level (tree name)
}
}
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
}
/* [basic.lookup.koenig] */
}
}
! timevar_stop (TV_NAME_LOOKUP);
! return t;
}
/* [basic.lookup.koenig] */
*************** arg_assoc (struct arg_lookup *k, tree n)
/* Performs Koenig lookup depending on arguments, where fns
are the functions found in normal lookup. */
! tree
! lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
! bool include_std)
{
struct arg_lookup k;
- timevar_push (TV_NAME_LOOKUP);
-
/* Remove any hidden friend functions from the list of functions
found so far. They will be added back by arg_assoc_class as
appropriate. */
/* Performs Koenig lookup depending on arguments, where fns
are the functions found in normal lookup. */
! static tree
! lookup_arg_dependent_1 (tree name, tree fns, VEC(tree,gc) *args,
! bool include_std)
{
struct arg_lookup k;
/* Remove any hidden friend functions from the list of functions
found so far. They will be added back by arg_assoc_class as
appropriate. */
*************** lookup_arg_dependent (tree name, tree fn
release_tree_vector (k.classes);
release_tree_vector (k.namespaces);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
}
/* Add namespace to using_directives. Return NULL_TREE if nothing was
changed (i.e. there was already a directive), or the fresh
TREE_LIST otherwise. */
static tree
! push_using_directive (tree used)
{
tree ud = current_binding_level->using_directives;
tree iter, ancestor;
- timevar_push (TV_NAME_LOOKUP);
/* Check if we already have this. */
if (purpose_member (used, ud) != NULL_TREE)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
ancestor = namespace_ancestor (current_decl_namespace (), used);
ud = current_binding_level->using_directives;
release_tree_vector (k.classes);
release_tree_vector (k.namespaces);
! return fns;
}
+ /* Wrapper for lookup_arg_dependent_1. */
+
+ tree
+ lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
+ bool include_std)
+ {
+ tree ret;
+ timevar_start (TV_NAME_LOOKUP);
+ ret = lookup_arg_dependent_1 (name, fns, args, include_std);
+ timevar_stop (TV_NAME_LOOKUP);
+ return ret;
+ }
+
+
/* Add namespace to using_directives. Return NULL_TREE if nothing was
changed (i.e. there was already a directive), or the fresh
TREE_LIST otherwise. */
static tree
! push_using_directive_1 (tree used)
{
tree ud = current_binding_level->using_directives;
tree iter, ancestor;
/* Check if we already have this. */
if (purpose_member (used, ud) != NULL_TREE)
! return NULL_TREE;
ancestor = namespace_ancestor (current_decl_namespace (), used);
ud = current_binding_level->using_directives;
*************** push_using_directive (tree used)
for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
push_using_directive (TREE_PURPOSE (iter));
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
}
/* The type TYPE is being declared. If it is a class template, or a
for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
push_using_directive (TREE_PURPOSE (iter));
! return ud;
! }
!
! /* Wrapper for push_using_directive_1. */
!
! static tree
! push_using_directive (tree used)
! {
! tree ret;
! timevar_start (TV_NAME_LOOKUP);
! ret = push_using_directive_1 (used);
! timevar_stop (TV_NAME_LOOKUP);
! return ret;
}
/* The type TYPE is being declared. If it is a class template, or a
*************** maybe_process_template_type_declaration
Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
! tree
! pushtag (tree name, tree type, tag_scope scope)
{
struct cp_binding_level *b;
tree decl;
- timevar_push (TV_NAME_LOOKUP);
b = current_binding_level;
while (/* Cleanup scopes are not scopes from the point of view of
the language. */
Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
! static tree
! pushtag_1 (tree name, tree type, tag_scope scope)
{
struct cp_binding_level *b;
tree decl;
b = current_binding_level;
while (/* Cleanup scopes are not scopes from the point of view of
the language. */
*************** pushtag (tree name, tree type, tag_scope
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
/* Do C++ gratuitous typedefing. */
! if (IDENTIFIER_TYPE_VALUE (name) != type)
{
tree tdef;
int in_class = 0;
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
/* Do C++ gratuitous typedefing. */
! if (identifier_type_value_1 (name) != type)
{
tree tdef;
int in_class = 0;
*************** pushtag (tree name, tree type, tag_scope
decl = maybe_process_template_type_declaration
(type, scope == ts_within_enclosing_non_class, b);
if (decl == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
if (b->kind == sk_class)
{
if (!TYPE_BEING_DEFINED (current_class_type))
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
/* Put this TYPE_DECL on the TYPE_FIELDS list for the
decl = maybe_process_template_type_declaration
(type, scope == ts_within_enclosing_non_class, b);
if (decl == error_mark_node)
! return decl;
if (b->kind == sk_class)
{
if (!TYPE_BEING_DEFINED (current_class_type))
! return error_mark_node;
if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
/* Put this TYPE_DECL on the TYPE_FIELDS list for the
*************** pushtag (tree name, tree type, tag_scope
}
else if (b->kind != sk_template_parms)
{
! decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
if (decl == error_mark_node)
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
if (! in_class)
}
else if (b->kind != sk_template_parms)
{
! decl = pushdecl_with_scope_1 (decl, b, /*is_friend=*/false);
if (decl == error_mark_node)
! return decl;
}
if (! in_class)
*************** pushtag (tree name, tree type, tag_scope
TREE_PUBLIC (decl) = 1;
determine_visibility (decl);
! POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
}
/* Subroutines for reverting temporarily to top-level for instantiation
TREE_PUBLIC (decl) = 1;
determine_visibility (decl);
! return type;
! }
!
! /* Wrapper for pushtag_1. */
!
! tree
! pushtag (tree name, tree type, tag_scope scope)
! {
! tree ret;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
! ret = pushtag_1 (name, type, scope);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
! return ret;
}
/* Subroutines for reverting temporarily to top-level for instantiation
*************** store_bindings (tree names, VEC(cxx_save
{
tree t;
! timevar_push (TV_NAME_LOOKUP);
for (t = names; t; t = TREE_CHAIN (t))
{
tree id;
{
tree t;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
for (t = names; t; t = TREE_CHAIN (t))
{
tree id;
*************** store_bindings (tree names, VEC(cxx_save
store_binding (id, old_bindings);
}
! timevar_pop (TV_NAME_LOOKUP);
}
/* Like store_bindings, but NAMES is a vector of cp_class_binding
store_binding (id, old_bindings);
}
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
/* Like store_bindings, but NAMES is a vector of cp_class_binding
*************** store_class_bindings (VEC(cp_class_bindi
size_t i;
cp_class_binding *cb;
! timevar_push (TV_NAME_LOOKUP);
for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
store_binding (cb->identifier, old_bindings);
! timevar_pop (TV_NAME_LOOKUP);
}
void
size_t i;
cp_class_binding *cb;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
store_binding (cb->identifier, old_bindings);
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
void
*************** push_to_top_level (void)
size_t i;
bool need_pop;
! timevar_push (TV_NAME_LOOKUP);
s = ggc_alloc_cleared_saved_scope ();
b = scope_chain ? current_binding_level : 0;
size_t i;
bool need_pop;
! bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
s = ggc_alloc_cleared_saved_scope ();
b = scope_chain ? current_binding_level : 0;
*************** push_to_top_level (void)
push_class_stack ();
cp_unevaluated_operand = 0;
c_inhibit_evaluation_warnings = 0;
! timevar_pop (TV_NAME_LOOKUP);
}
! void
! pop_from_top_level (void)
{
struct saved_scope *s = scope_chain;
cxx_saved_binding *saved;
size_t i;
- timevar_push (TV_NAME_LOOKUP);
/* Clear out class-level bindings cache. */
if (previous_class_level)
invalidate_class_lookup_cache ();
push_class_stack ();
cp_unevaluated_operand = 0;
c_inhibit_evaluation_warnings = 0;
! timevar_cond_stop (TV_NAME_LOOKUP, subtime);
}
! static void
! pop_from_top_level_1 (void)
{
struct saved_scope *s = scope_chain;
cxx_saved_binding *saved;
size_t i;
/* Clear out class-level bindings cache. */
if (previous_class_level)
invalidate_class_lookup_cache ();
*************** pop_from_top_level (void)
current_function_decl = s->function_decl;
cp_unevaluated_operand = s->unevaluated_operand;
c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
- timevar_pop (TV_NAME_LOOKUP);
}
/* Pop off extraneous binding levels left over due to syntax errors.
We don't pop past namespaces, as they might be valid. */
current_function_decl = s->function_decl;
cp_unevaluated_operand = s->unevaluated_operand;
c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
}
+ /* Wrapper for pop_from_top_level_1. */
+
+ void
+ pop_from_top_level (void)
+ {
+ bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
+ pop_from_top_level_1 ();
+ timevar_cond_stop (TV_NAME_LOOKUP, subtime);
+ }
+
+
/* Pop off extraneous binding levels left over due to syntax errors.
We don't pop past namespaces, as they might be valid. */
===================================================================
***************
/* The total execution time. */
DEFTIMEVAR (TV_TOTAL , "total time")
/* Time spent garbage-collecting. */
! DEFTIMEVAR (TV_GC , "garbage collection")
/* Time spent generating dump files. */
DEFTIMEVAR (TV_DUMP , "dump files")
/* The total execution time. */
DEFTIMEVAR (TV_TOTAL , "total time")
+ DEFTIMEVAR (TV_PHASE_SETUP , "phase setup")
+ DEFTIMEVAR (TV_PHASE_PARSING , "phase parsing")
+ DEFTIMEVAR (TV_PHASE_C_WRAPUP_CHECK , "phase C wrapup & check")
+ DEFTIMEVAR (TV_PHASE_CP_DEFERRED , "phase C++ deferred")
+ DEFTIMEVAR (TV_PHASE_CGRAPH , "phase cgraph")
+ DEFTIMEVAR (TV_PHASE_DBGINFO , "phase debug info")
+ DEFTIMEVAR (TV_PHASE_CHECK_DBGINFO , "phase check & debug info")
+ DEFTIMEVAR (TV_PHASE_GENERATE , "phase generate")
+ DEFTIMEVAR (TV_PHASE_FINALIZE , "phase finalize")
/* Time spent garbage-collecting. */
! DEFTIMEVAR (TV_GC , "|garbage collection")
/* Time spent generating dump files. */
DEFTIMEVAR (TV_DUMP , "dump files")
*************** DEFTIMEVAR (TV_REBUILD_JUMP , "rebu
/* Timing in various stages of the compiler. */
DEFTIMEVAR (TV_CPP , "preprocessing")
DEFTIMEVAR (TV_LEX , "lexical analysis")
! DEFTIMEVAR (TV_PARSE , "parser")
! DEFTIMEVAR (TV_NAME_LOOKUP , "name lookup")
DEFTIMEVAR (TV_INLINE_HEURISTICS , "inline heuristics")
DEFTIMEVAR (TV_INTEGRATION , "integration")
DEFTIMEVAR (TV_TREE_GIMPLIFY , "tree gimplify")
/* Timing in various stages of the compiler. */
DEFTIMEVAR (TV_CPP , "preprocessing")
DEFTIMEVAR (TV_LEX , "lexical analysis")
! DEFTIMEVAR (TV_PARSE_GLOBAL , "parser (global)")
! DEFTIMEVAR (TV_PARSE_STRUCT , "parser struct body")
! DEFTIMEVAR (TV_PARSE_ENUM , "parser enumerator list")
! DEFTIMEVAR (TV_PARSE_FUNC , "parser function body")
! DEFTIMEVAR (TV_PARSE_INMETH , "parser inl. meth. body")
! DEFTIMEVAR (TV_INSTANTIATE_TEMPLATE , "instantiate template")
! DEFTIMEVAR (TV_NAME_LOOKUP , "|name lookup")
! DEFTIMEVAR (TV_RESOLVE_OVERLOAD , "|overload resolution")
DEFTIMEVAR (TV_INLINE_HEURISTICS , "inline heuristics")
DEFTIMEVAR (TV_INTEGRATION , "integration")
DEFTIMEVAR (TV_TREE_GIMPLIFY , "tree gimplify")
*************** DEFTIMEVAR (TV_CGRAPH_VERIFY , "
DEFTIMEVAR (TV_DOM_FRONTIERS , "dominance frontiers")
DEFTIMEVAR (TV_DOMINANCE , "dominance computation")
DEFTIMEVAR (TV_CONTROL_DEPENDENCES , "control dependences")
- DEFTIMEVAR (TV_OVERLOAD , "overload resolution")
- DEFTIMEVAR (TV_TEMPLATE_INSTANTIATION, "template instantiation")
DEFTIMEVAR (TV_OUT_OF_SSA , "out of ssa")
DEFTIMEVAR (TV_VAR_EXPAND , "expand vars")
DEFTIMEVAR (TV_EXPAND , "expand")
===================================================================
*************** timevar_stop (timevar_id_t timevar)
/* TIMEVAR must have been started via timevar_start. */
gcc_assert (tv->standalone);
+ tv->standalone = 0; /* Enable a restart. */
+
+ get_time (&now);
+ timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
+ }
+
+ /* Conditionally start timing TIMEVAR independently of the timing stack.
+ If the timer is already running, leave it running and return true.
+ Otherwise, start the timer and return false.
+ Elapsed time until the corresponding timevar_cond_stop
+ is called for the same timing variable is attributed to TIMEVAR. */
+
+ bool
+ timevar_cond_start (timevar_id_t timevar)
+ {
+ struct timevar_def *tv = &timevars[timevar];
+
+ if (!timevar_enable)
+ return false;
+
+ /* Mark this timing variable as used. */
+ tv->used = 1;
+
+ if (tv->standalone)
+ return true; /* The timevar is already running. */
+
+ /* Don't allow the same timing variable
+ to be unconditionally started more than once. */
+ tv->standalone = 1;
+
+ get_time (&tv->start_time);
+ return false; /* The timevar was not already running. */
+ }
+
+ /* Conditionally stop timing TIMEVAR. The RUNNING parameter must come
+ from the return value of a dynamically matching timevar_cond_start.
+ If the timer had already been RUNNING, do nothing. Otherwise, time
+ elapsed since timevar_cond_start was called is attributed to it. */
+
+ void
+ timevar_cond_stop (timevar_id_t timevar, bool running)
+ {
+ struct timevar_def *tv;
+ struct timevar_time_def now;
+
+ if (!timevar_enable || running)
+ return;
+
+ tv = &timevars[timevar];
+
+ /* TIMEVAR must have been started via timevar_cond_start. */
+ gcc_assert (tv->standalone);
+ tv->standalone = 0; /* Enable a restart. */
get_time (&now);
timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
===================================================================
*************** extern bool timevar_enable;
/* Total amount of memory allocated by garbage collector. */
extern size_t timevar_ggc_mem_total;
- /* Execute the sequence: timevar_pop (TV), return (E); */
- #define POP_TIMEVAR_AND_RETURN(TV, E) do { timevar_pop (TV); return (E); }while(0)
-
extern void timevar_init (void);
extern void timevar_push_1 (timevar_id_t);
extern void timevar_pop_1 (timevar_id_t);
extern void timevar_start (timevar_id_t);
extern void timevar_stop (timevar_id_t);
extern void timevar_print (FILE *);
/* Provided for backward compatibility. */
/* Total amount of memory allocated by garbage collector. */
extern size_t timevar_ggc_mem_total;
extern void timevar_init (void);
extern void timevar_push_1 (timevar_id_t);
extern void timevar_pop_1 (timevar_id_t);
extern void timevar_start (timevar_id_t);
extern void timevar_stop (timevar_id_t);
+ extern bool timevar_cond_start (timevar_id_t);
+ extern void timevar_cond_stop (timevar_id_t, bool);
extern void timevar_print (FILE *);
/* Provided for backward compatibility. */
===================================================================
*************** c_write_global_declarations (void)
if (pch_file)
return;
+ timevar_start (TV_PHASE_C_WRAPUP_CHECK);
+
/* Do the Objective-C stuff. This is where all the Objective-C
module stuff gets generated (symtab, class/protocol/selector
lists etc). */
*************** c_write_global_declarations (void)
c_write_global_declarations_1 (BLOCK_VARS (DECL_INITIAL (t)));
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
+ timevar_stop (TV_PHASE_C_WRAPUP_CHECK);
+ timevar_start (TV_PHASE_CGRAPH);
+
/* We're done parsing; proceed to optimize and emit assembly.
FIXME: shouldn't be the front end's responsibility to call this. */
cgraph_finalize_compilation_unit ();
+ timevar_stop (TV_PHASE_CGRAPH);
+ 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 ())
*************** c_write_global_declarations (void)
}
ext_block = NULL;
+ timevar_stop (TV_PHASE_DBGINFO);
}
/* Register reserved keyword WORD as qualifier for address space AS. */
===================================================================
*************** ggc_collect (void)
struct alloc_zone *zone;
bool marked = false;
! timevar_push (TV_GC);
if (!ggc_force_collect)
{
struct alloc_zone *zone;
bool marked = false;
! timevar_start (TV_GC);
if (!ggc_force_collect)
{
*************** ggc_collect (void)
if (allocated < allocated_last_gc + min_expand)
{
! timevar_pop (TV_GC);
return;
}
}
if (allocated < allocated_last_gc + min_expand)
{
! timevar_stop (TV_GC);
return;
}
}
*************** ggc_collect (void)
invoke_plugin_callbacks (PLUGIN_GGC_END, NULL);
! timevar_pop (TV_GC);
}
/* Print allocation statistics. */
invoke_plugin_callbacks (PLUGIN_GGC_END, NULL);
! timevar_stop (TV_GC);
}
/* Print allocation statistics. */
===================================================================
*************** ggc_collect (void)
if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect)
return;
! timevar_push (TV_GC);
if (!quiet_flag)
fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated / 1024);
if (GGC_DEBUG_LEVEL >= 2)
if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect)
return;
! timevar_start (TV_GC);
if (!quiet_flag)
fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated / 1024);
if (GGC_DEBUG_LEVEL >= 2)
*************** ggc_collect (void)
invoke_plugin_callbacks (PLUGIN_GGC_END, NULL);
! timevar_pop (TV_GC);
if (!quiet_flag)
fprintf (stderr, "%luk}", (unsigned long) G.allocated / 1024);
invoke_plugin_callbacks (PLUGIN_GGC_END, NULL);
! timevar_stop (TV_GC);
if (!quiet_flag)
fprintf (stderr, "%luk}", (unsigned long) G.allocated / 1024);
===================================================================
*************** c_parser_declaration_or_fndef (c_parser
return;
}
/* Function definition (nested or otherwise). */
+ timevar_push (TV_PARSE_FUNC);
if (nested)
{
pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
*************** c_parser_declaration_or_fndef (c_parser
add_stmt (fnbody);
finish_function ();
}
+ timevar_pop (TV_PARSE_FUNC);
break;
}
}
*************** c_parser_enum_specifier (c_parser *parse
{
/* Parse an enum definition. */
struct c_enum_contents the_enum;
! tree type = start_enum (enum_loc, &the_enum, ident);
tree postfix_attrs;
/* We chain the enumerators in reverse order, then put them in
forward order at the end. */
! tree values = NULL_TREE;
c_parser_consume_token (parser);
while (true)
{
{
/* Parse an enum definition. */
struct c_enum_contents the_enum;
! tree type;
tree postfix_attrs;
/* We chain the enumerators in reverse order, then put them in
forward order at the end. */
! tree values;
! timevar_push (TV_PARSE_ENUM);
! type = start_enum (enum_loc, &the_enum, ident);
! values = NULL_TREE;
c_parser_consume_token (parser);
while (true)
{
*************** c_parser_enum_specifier (c_parser *parse
ret.kind = ctsk_tagdef;
ret.expr = NULL_TREE;
ret.expr_const_operands = true;
+ timevar_pop (TV_PARSE_ENUM);
return ret;
}
else if (!ident)
*************** c_parser_struct_or_union_specifier (c_pa
semicolon separated fields than comma separated fields, and
so we'll be minimizing the number of node traversals required
by chainon. */
! tree contents = NULL_TREE;
c_parser_consume_token (parser);
/* Handle the Objective-C @defs construct,
e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
semicolon separated fields than comma separated fields, and
so we'll be minimizing the number of node traversals required
by chainon. */
! tree contents;
! timevar_push (TV_PARSE_STRUCT);
! contents = NULL_TREE;
c_parser_consume_token (parser);
/* Handle the Objective-C @defs construct,
e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
*************** c_parser_struct_or_union_specifier (c_pa
ret.kind = ctsk_tagdef;
ret.expr = NULL_TREE;
ret.expr_const_operands = true;
+ timevar_pop (TV_PARSE_STRUCT);
return ret;
}
else if (!ident)