On Fri, Mar 22, 2013 at 4:50 AM, Gabriel Dos Reis <g...@axiomatics.org> wrote:
>
> This patch introduces identified_p (t) in lieu of
>
> TREE_CODE (t) == IDENTIFIER_NODE
Generally we have macros like IDENTIFIER_P for this kind of checks.
> in the C++ front-end. identifier_p is effectively LANG_IDENTIFIER_CAST
> except that it returns a typed pointer instead of a boolean value.
Hm? So you are replacing TREE_CODE (t) == IDENTIFIER_NODE
with kind-of dynamic_cast<identifier> (t) (in C++ terms)? Then
naming it identifier_p is bad. We have is-a.h now, so please try to use
a single style of C++-style casting throughout GCC.
Thanks,
Richard.
> There is NO change in functionality. With this patch, I measured that
> bootsrapping takes slightly less time than without, and the object size
> of cc1plus decreases by more than 5K.
>
>
> Bootstrapped and texted on an x86_64-suse-linux.
> Applying to trunk. Follow up patches will exploit the typed pointer.
>
> -- Gaby
>
> 2013-03-21 Gabriel Dos Reis <g...@integrable-solutions.net>
>
> * cp-tree.h (identifier_p): New.
> * call.c: Throughout, call identifier_p insstead of direct
> comparaison of TREE_CODE against IDENTIFIER_NODE.
> * decl.c: Likewisse.
> * decl2.c: Likewise.
> * init.c: Likewise.
> * mangle.c: Likewise.
> * name-lookup.c: Likewise.
> * parser.c: Likewise.
> * pt.c: Likewise.
> * search.c: Likewise.
> * semantics.c: Likewise.
> * tree.c: Likewise.
> * typeck.c: Likewise.
> * typeck2.c: Likewise.
>
> Index: call.c
> ===================================================================
> --- call.c (revision 196891)
> +++ call.c (working copy)
> @@ -233,7 +233,7 @@
> name = TREE_TYPE (name);
> else if (TYPE_P (name))
> /* OK */;
> - else if (TREE_CODE (name) == IDENTIFIER_NODE)
> + else if (identifier_p (name))
> {
> if ((MAYBE_CLASS_TYPE_P (basetype)
> && name == constructor_name (basetype))
> @@ -3147,7 +3147,7 @@
> : ACONCAT ((msgstr, " ", NULL)));
> location_t cloc = location_of (candidate->fn);
>
> - if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
> + if (identifier_p (candidate->fn))
> {
> cloc = loc;
> if (candidate->num_convs == 3)
> @@ -8563,8 +8563,7 @@
> - do not have the same parameter type list as any non-template
> non-member candidate. */
>
> - if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
> - || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
> + if (identifier_p (cand1->fn) || identifier_p (cand2->fn))
> {
> for (i = 0; i < len; ++i)
> if (!same_type_p (cand1->convs[i]->type,
> @@ -8575,7 +8574,7 @@
> if (cand1->fn == cand2->fn)
> /* Two built-in candidates; arbitrarily pick one. */
> return 1;
> - else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
> + else if (identifier_p (cand1->fn))
> /* cand1 is built-in; prefer cand2. */
> return -1;
> else
> Index: cp-tree.h
> ===================================================================
> --- cp-tree.h (revision 196891)
> +++ cp-tree.h (working copy)
> @@ -241,6 +241,16 @@
> tree label_value;
> };
>
> +/* Return a typed pointer version of T if it designates a
> + C++ front-end identifier. */
> +inline lang_identifier*
> +identifier_p (tree t)
> +{
> + if (TREE_CODE (t) == IDENTIFIER_NODE)
> + return (lang_identifier*) t;
> + return NULL;
> +}
> +
> /* In an IDENTIFIER_NODE, nonzero if this identifier is actually a
> keyword. C_RID_CODE (node) is then the RID_* value of the keyword,
> and C_RID_YYCODE is the token number wanted by Yacc. */
> Index: decl.c
> ===================================================================
> --- decl.c (revision 196891)
> +++ decl.c (working copy)
> @@ -3296,7 +3296,7 @@
> error ("%qD used without template parameters", name);
> return error_mark_node;
> }
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
> gcc_assert (TYPE_P (context));
>
> if (!MAYBE_CLASS_TYPE_P (context))
> @@ -3402,7 +3402,7 @@
> name = TYPE_IDENTIFIER (name);
> else if (DECL_P (name))
> name = DECL_NAME (name);
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> if (!dependent_type_p (context)
> || currently_open_class (context))
> @@ -4781,7 +4781,7 @@
> }
> else
> {
> - gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (ce->index));
> error ("name %qD used in a GNU-style designated "
> "initializer for an array", ce->index);
> }
> @@ -7413,8 +7413,7 @@
> == current_class_type);
> fns = TREE_OPERAND (fns, 1);
> }
> - gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
> - || TREE_CODE (fns) == OVERLOAD);
> + gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD);
> DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
>
> for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
> @@ -7772,7 +7771,7 @@
> tree decl;
> tree explicit_scope;
>
> - gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (!name || identifier_p (name));
>
> /* Compute the scope in which to place the variable, but remember
> whether or not that scope was explicitly specified by the user. */
> @@ -8509,7 +8508,7 @@
> {
> if (!identifier)
> error ("unnamed variable or field declared void");
> - else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
> + else if (identifier_p (identifier))
> {
> gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
> error ("variable or field %qE declared void", identifier);
> @@ -8778,7 +8777,7 @@
> tree fns = TREE_OPERAND (decl, 0);
>
> dname = fns;
> - if (TREE_CODE (dname) != IDENTIFIER_NODE)
> + if (!identifier_p (dname))
> {
> gcc_assert (is_overloaded_fn (dname));
> dname = DECL_NAME (get_first_fn (dname));
> @@ -8787,7 +8786,7 @@
> /* Fall through. */
>
> case IDENTIFIER_NODE:
> - if (TREE_CODE (decl) == IDENTIFIER_NODE)
> + if (identifier_p (decl))
> dname = decl;
>
> if (C_IS_RESERVED_WORD (dname))
> @@ -8852,7 +8851,7 @@
> }
>
> if (dname
> - && TREE_CODE (dname) == IDENTIFIER_NODE
> + && identifier_p (dname)
> && UDLIT_OPER_P (dname)
> && innermost_code != cdk_function)
> {
> @@ -8977,7 +8976,7 @@
> common. With no options, it is allowed. With -Wreturn-type,
> it is a warning. It is only an error with -pedantic-errors. */
> is_main = (funcdef_flag
> - && dname && TREE_CODE (dname) == IDENTIFIER_NODE
> + && dname && identifier_p (dname)
> && MAIN_NAME_P (dname)
> && ctype == NULL_TREE
> && in_namespace == NULL_TREE
> @@ -11896,7 +11895,7 @@
> tree context = NULL_TREE;
> tag_scope scope;
>
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> switch (tag_code)
> {
> @@ -12323,7 +12322,7 @@
> bool scoped_enum_p, bool *is_new)
> {
> tree prevtype = NULL_TREE;
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> if (is_new)
> *is_new = false;
> Index: decl2.c
> ===================================================================
> --- decl2.c (revision 196891)
> +++ decl2.c (working copy)
> @@ -1121,7 +1121,7 @@
> second and following arguments. Attributes like mode, format,
> cleanup and several target specific attributes aren't late
> just because they have an IDENTIFIER_NODE as first argument. */
> - if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
> + if (arg == args && identifier_p (t))
> continue;
>
> if (value_dependent_expression_p (t)
> Index: init.c
> ===================================================================
> --- init.c (revision 196891)
> +++ init.c (working copy)
> @@ -1416,7 +1416,7 @@
> }
> else
> {
> - if (TREE_CODE (name) == IDENTIFIER_NODE)
> + if (identifier_p (name))
> field = lookup_field (current_class_type, name, 1, false);
> else
> field = name;
> Index: mangle.c
> ===================================================================
> --- mangle.c (revision 196891)
> +++ mangle.c (working copy)
> @@ -1189,7 +1189,7 @@
> {
> MANGLE_TRACE_TREE ("unqualified-name", decl);
>
> - if (TREE_CODE (decl) == IDENTIFIER_NODE)
> + if (identifier_p (decl))
> {
> write_unqualified_id (decl);
> return;
> @@ -2519,7 +2519,7 @@
> static void
> write_member_name (tree member)
> {
> - if (TREE_CODE (member) == IDENTIFIER_NODE)
> + if (identifier_p (member))
> write_unqualified_id (member);
> else if (DECL_P (member))
> write_unqualified_name (member);
> @@ -2697,7 +2697,7 @@
> {
> write_expression (TREE_OPERAND (expr, 0));
> }
> - else if (TREE_CODE (expr) == IDENTIFIER_NODE)
> + else if (identifier_p (expr))
> {
> /* An operator name appearing as a dependent name needs to be
> specially marked to disambiguate between a use of the operator
> Index: name-lookup.c
> ===================================================================
> --- name-lookup.c (revision 196891)
> +++ name-lookup.c (working copy)
> @@ -1959,7 +1959,7 @@
> if (!name)
> return false;
>
> - if (TREE_CODE (name) != IDENTIFIER_NODE)
> + if (!identifier_p (name))
> return false;
>
> /* These don't have names. */
> @@ -2073,7 +2073,7 @@
> gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
>
> name = DECL_NAME (function);
> - gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (name && identifier_p (name));
>
> for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
> iter;
> @@ -2136,7 +2136,7 @@
> tree decl;
>
> gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
> for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
> if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
> break;
> @@ -5724,7 +5724,7 @@
> || COMPLETE_TYPE_P (b->this_entity))))
> b = b->level_chain;
>
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> /* Do C++ gratuitous typedefing. */
> if (identifier_type_value_1 (name) != type)
> Index: parser.c
> ===================================================================
> --- parser.c (revision 196891)
> +++ parser.c (working copy)
> @@ -1110,7 +1110,7 @@
> case CPP_KEYWORD:
> /* Some keywords have a value that is not an IDENTIFIER_NODE.
> For example, `struct' is mapped to an INTEGER_CST. */
> - if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
> + if (!identifier_p (token->u.value))
> break;
> /* else fall through */
> case CPP_NAME:
> @@ -1259,7 +1259,7 @@
> if (qualifying_scope && TYPE_P (qualifying_scope))
> qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
>
> - gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
> + gcc_assert (identifier_p (unqualified_name)
> || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
> || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
>
> @@ -2587,7 +2587,7 @@
> {
> if (TYPE_P (type))
> error_at (location, "%qT is not a template", type);
> - else if (TREE_CODE (type) == IDENTIFIER_NODE)
> + else if (identifier_p (type))
> {
> if (tag_type != none_type)
> error_at (location, "%qE is not a class template", type);
> @@ -3193,7 +3193,7 @@
> tree id, location_t id_location)
> {
> tree result;
> - if (TREE_CODE (id) == IDENTIFIER_NODE)
> + if (identifier_p (id))
> {
> result = make_typename_type (scope, id, typename_type,
> /*complain=*/tf_none);
> @@ -5654,7 +5654,7 @@
> while (true)
> {
> if (idk == CP_ID_KIND_UNQUALIFIED
> - && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
> + && identifier_p (postfix_expression)
> && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
> /* It is not a Koenig lookup function call. */
> postfix_expression
> @@ -5741,7 +5741,7 @@
> if (idk == CP_ID_KIND_UNQUALIFIED
> || idk == CP_ID_KIND_TEMPLATE_ID)
> {
> - if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
> + if (identifier_p (postfix_expression))
> {
> if (!args->is_empty ())
> {
> @@ -11310,7 +11310,7 @@
> cp_id_kind idk;
> const char *error_msg;
>
> - if (TREE_CODE (expr) == IDENTIFIER_NODE)
> + if (identifier_p (expr))
> /* Lookup the name we got back from the id-expression. */
> expr = cp_parser_lookup_name (parser, expr,
> none_type,
> @@ -12759,7 +12759,7 @@
> }
>
> /* Build a representation of the specialization. */
> - if (TREE_CODE (templ) == IDENTIFIER_NODE)
> + if (identifier_p (templ))
> template_id = build_min_nt_loc (next_token->location,
> TEMPLATE_ID_EXPR,
> templ, arguments);
> @@ -13980,7 +13980,7 @@
> && !global_p
> && !qualified_p
> && TREE_CODE (type) == TYPE_DECL
> - && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
> + && identifier_p (DECL_NAME (type)))
> maybe_note_name_used_in_class (DECL_NAME (type), type);
> /* If it didn't work out, we don't have a TYPE. */
> if ((flags & CP_PARSER_FLAGS_OPTIONAL)
> @@ -15279,7 +15279,7 @@
> depending on what scope we are in. */
> if (qscope == error_mark_node || identifier == error_mark_node)
> ;
> - else if (TREE_CODE (identifier) != IDENTIFIER_NODE
> + else if (!identifier_p (identifier)
> && TREE_CODE (identifier) != BIT_NOT_EXPR)
> /* [namespace.udecl]
>
> @@ -16562,8 +16562,7 @@
> unqualified_name = error_mark_node;
> else if (unqualified_name
> && (qualifying_scope
> - || (TREE_CODE (unqualified_name)
> - != IDENTIFIER_NODE)))
> + || (!identifier_p (unqualified_name))))
> {
> cp_parser_error (parser, "expected unqualified-id");
> unqualified_name = error_mark_node;
> @@ -18226,7 +18225,7 @@
>
> /* Check to see that it is really the name of a class. */
> if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
> - && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
> + && identifier_p (TREE_OPERAND (decl, 0))
> && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
> /* Situations like this:
>
> @@ -21120,7 +21119,7 @@
> /* By this point, the NAME should be an ordinary identifier. If
> the id-expression was a qualified name, the qualifying scope is
> stored in PARSER->SCOPE at this point. */
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> /* Perform the lookup. */
> if (parser->scope)
> @@ -24290,7 +24289,7 @@
>
> node = token->u.value;
>
> - while (node && TREE_CODE (node) == IDENTIFIER_NODE
> + while (node && identifier_p (node)
> && (node == ridpointers [(int) RID_IN]
> || node == ridpointers [(int) RID_OUT]
> || node == ridpointers [(int) RID_INOUT]
> Index: pt.c
> ===================================================================
> --- pt.c (revision 196891)
> +++ pt.c (working copy)
> @@ -2467,7 +2467,7 @@
> {
> tree fns;
>
> - gcc_assert (TREE_CODE (declarator) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (declarator));
> if (ctype)
> fns = dname;
> else
> @@ -2528,8 +2528,7 @@
> return decl;
> }
> else if (ctype != NULL_TREE
> - && (TREE_CODE (TREE_OPERAND (declarator, 0)) ==
> - IDENTIFIER_NODE))
> + && (identifier_p (TREE_OPERAND (declarator, 0))))
> {
> /* Find the list of functions in ctype that have the same
> name as the declared function. */
> @@ -6955,7 +6954,7 @@
>
> gcc_assert (!arglist || TREE_CODE (arglist) == TREE_VEC);
>
> - if (!is_overloaded_fn (fns) && TREE_CODE (fns) != IDENTIFIER_NODE)
> + if (!is_overloaded_fn (fns) && !identifier_p (fns))
> {
> error ("%q#D is not a function template", fns);
> return error_mark_node;
> @@ -7058,7 +7057,7 @@
> spec_entry elt;
> hashval_t hash;
>
> - if (TREE_CODE (d1) == IDENTIFIER_NODE)
> + if (identifier_p (d1))
> {
> tree value = innermost_non_namespace_value (d1);
> if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
> @@ -7853,7 +7852,7 @@
> || TREE_CODE (t) == TEMPLATE_PARM_INDEX
> || TREE_CODE (t) == OVERLOAD
> || BASELINK_P (t)
> - || TREE_CODE (t) == IDENTIFIER_NODE
> + || identifier_p (t)
> || TREE_CODE (t) == TRAIT_EXPR
> || TREE_CODE (t) == CONSTRUCTOR
> || CONSTANT_CLASS_P (t))
> @@ -8482,8 +8481,7 @@
> if (TREE_VALUE (t)
> && TREE_CODE (TREE_VALUE (t)) == TREE_LIST
> && TREE_VALUE (TREE_VALUE (t))
> - && (TREE_CODE (TREE_VALUE (TREE_VALUE (t)))
> - == IDENTIFIER_NODE))
> + && (identifier_p (TREE_VALUE (TREE_VALUE (t)))))
> {
> tree chain
> = tsubst_expr (TREE_CHAIN (TREE_VALUE (t)), args,
> complain,
> @@ -13480,7 +13478,7 @@
> input_location);
> if (error_msg)
> error (error_msg);
> - if (!function_p && TREE_CODE (decl) == IDENTIFIER_NODE)
> + if (!function_p && identifier_p (decl))
> {
> if (complain & tf_error)
> unqualified_name_lookup_error (decl);
> @@ -13907,7 +13905,7 @@
> /*done=*/false,
> /*address_p=*/false);
> }
> - else if (koenig_p && TREE_CODE (function) == IDENTIFIER_NODE)
> + else if (koenig_p && identifier_p (function))
> {
> /* Do nothing; calling tsubst_copy_and_build on an identifier
> would incorrectly perform unqualified lookup again.
> @@ -13991,7 +13989,7 @@
> not appropriate, even if an unqualified-name was used
> to denote the function. */
> && !DECL_FUNCTION_MEMBER_P (get_first_fn (function)))
> - || TREE_CODE (function) == IDENTIFIER_NODE)
> + || identifier_p (function))
> /* Only do this when substitution turns a dependent call
> into a non-dependent call. */
> && type_dependent_expression_p_push (t)
> @@ -13999,7 +13997,7 @@
> function = perform_koenig_lookup (function, call_args, false,
> tf_none);
>
> - if (TREE_CODE (function) == IDENTIFIER_NODE
> + if (identifier_p (function)
> && !any_type_dependent_arguments_p (call_args))
> {
> if (koenig_p && (complain & tf_warning_or_error))
> @@ -14049,7 +14047,7 @@
> function = unq;
> }
> }
> - if (TREE_CODE (function) == IDENTIFIER_NODE)
> + if (identifier_p (function))
> {
> if (complain & tf_error)
> unqualified_name_lookup_error (function);
> @@ -19781,8 +19779,7 @@
> return false;
>
> /* An unresolved name is always dependent. */
> - if (TREE_CODE (expression) == IDENTIFIER_NODE
> - || TREE_CODE (expression) == USING_DECL)
> + if (identifier_p (expression) || TREE_CODE (expression) == USING_DECL)
> return true;
>
> /* Some expression forms are never type-dependent. */
> @@ -19887,7 +19884,7 @@
> if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
> return true;
> expression = TREE_OPERAND (expression, 1);
> - if (TREE_CODE (expression) == IDENTIFIER_NODE)
> + if (identifier_p (expression))
> return false;
> }
> /* SCOPE_REF with non-null TREE_TYPE is always non-dependent. */
> @@ -19978,7 +19975,7 @@
> return NULL_TREE;
>
> case COMPONENT_REF:
> - if (TREE_CODE (TREE_OPERAND (*tp, 1)) == IDENTIFIER_NODE)
> + if (identifier_p (TREE_OPERAND (*tp, 1)))
> /* In a template, finish_class_member_access_expr creates a
> COMPONENT_REF with an IDENTIFIER_NODE for op1 even if it isn't
> type-dependent, so that we can check access control at
> @@ -20222,8 +20219,7 @@
> || TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM)
> return true;
> /* So are names that have not been looked up. */
> - if (TREE_CODE (tmpl) == SCOPE_REF
> - || TREE_CODE (tmpl) == IDENTIFIER_NODE)
> + if (TREE_CODE (tmpl) == SCOPE_REF || identifier_p (tmpl))
> return true;
> /* So are member templates of dependent classes. */
> if (TYPE_P (CP_DECL_CONTEXT (tmpl)))
> @@ -20380,7 +20376,7 @@
> find a TEMPLATE_DECL. Otherwise, we want to find a TYPE_DECL. */
> if (!decl)
> /*nop*/;
> - else if (TREE_CODE (TYPENAME_TYPE_FULLNAME (type)) == IDENTIFIER_NODE
> + else if (identifier_p (TYPENAME_TYPE_FULLNAME (type))
> && TREE_CODE (decl) == TYPE_DECL)
> {
> result = TREE_TYPE (decl);
> Index: search.c
> ===================================================================
> --- search.c (revision 196891)
> +++ search.c (working copy)
> @@ -381,7 +381,7 @@
> {
> tree field;
>
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> if (TREE_CODE (type) == TEMPLATE_TYPE_PARM
> || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
> @@ -1190,7 +1190,7 @@
> || xbasetype == error_mark_node)
> return NULL_TREE;
>
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
> + gcc_assert (identifier_p (name));
>
> if (TREE_CODE (xbasetype) == TREE_BINFO)
> {
> Index: semantics.c
> ===================================================================
> --- semantics.c (revision 196891)
> +++ semantics.c (working copy)
> @@ -536,7 +536,7 @@
> tree
> finish_goto_stmt (tree destination)
> {
> - if (TREE_CODE (destination) == IDENTIFIER_NODE)
> + if (identifier_p (destination))
> destination = lookup_label (destination);
>
> /* We warn about unused labels with -Wunused. That means we have to
> @@ -1999,7 +1999,7 @@
> }
>
> /* Find the name of the overloaded function. */
> - if (TREE_CODE (fn) == IDENTIFIER_NODE)
> + if (identifier_p (fn))
> identifier = fn;
> else if (is_overloaded_fn (fn))
> {
> @@ -2966,7 +2966,7 @@
> if (scope
> && (!TYPE_P (scope)
> || (!dependent_type_p (scope)
> - && !(TREE_CODE (id_expression) == IDENTIFIER_NODE
> + && !(identifier_p (id_expression)
> && IDENTIFIER_TYPENAME_P (id_expression)
> && dependent_type_p (TREE_TYPE (id_expression))))))
> {
> @@ -2995,8 +2995,7 @@
> the current class so that we can check later to see if
> the meaning would have been different after the class
> was entirely defined. */
> - if (!scope && decl != error_mark_node
> - && TREE_CODE (id_expression) == IDENTIFIER_NODE)
> + if (!scope && decl != error_mark_node && identifier_p (id_expression))
> maybe_note_name_used_in_class (id_expression, decl);
>
> /* Disallow uses of local variables from containing functions, except
> @@ -3169,8 +3168,7 @@
> /* A template-id where the name of the template was not resolved
> is definitely dependent. */
> else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
> - && (TREE_CODE (TREE_OPERAND (decl, 0))
> - == IDENTIFIER_NODE))
> + && (identifier_p (TREE_OPERAND (decl, 0))))
> dependent_p = true;
> /* For anything except an overloaded function, just check its
> type. */
> @@ -5301,7 +5299,7 @@
> [expr.ref]), decltype(e) is defined as the type of the entity
> named by e. If there is no such entity, or e names a set of
> overloaded functions, the program is ill-formed. */
> - if (TREE_CODE (expr) == IDENTIFIER_NODE)
> + if (identifier_p (expr))
> expr = lookup_name (expr);
>
> if (TREE_CODE (expr) == INDIRECT_REF)
> Index: tree.c
> ===================================================================
> --- tree.c (revision 196891)
> +++ tree.c (working copy)
> @@ -1734,7 +1734,7 @@
> tree
> dependent_name (tree x)
> {
> - if (TREE_CODE (x) == IDENTIFIER_NODE)
> + if (identifier_p (x))
> return x;
> if (TREE_CODE (x) != COMPONENT_REF
> && TREE_CODE (x) != OFFSET_REF
> Index: typeck.c
> ===================================================================
> --- typeck.c (revision 196891)
> +++ typeck.c (working copy)
> @@ -2467,7 +2467,7 @@
> scope, dtor_type);
> return error_mark_node;
> }
> - if (TREE_CODE (dtor_type) == IDENTIFIER_NODE)
> + if (identifier_p (dtor_type))
> {
> /* In a template, names we can't find a match for are still accepted
> destructor names, and we check them here. */
> @@ -2588,7 +2588,7 @@
> dependent_type_p (object_type)
> /* If NAME is just an IDENTIFIER_NODE, then the expression
> is dependent. */
> - || TREE_CODE (object) == IDENTIFIER_NODE
> + || identifier_p (object)
> /* If NAME is "f<args>", where either 'f' or 'args' is
> dependent, then the expression is dependent. */
> || (TREE_CODE (name) == TEMPLATE_ID_EXPR
> @@ -2604,7 +2604,7 @@
> object = build_non_dependent_expr (object);
> }
> else if (c_dialect_objc ()
> - && TREE_CODE (name) == IDENTIFIER_NODE
> + && identifier_p (name)
> && (expr = objc_maybe_build_component_ref (object, name)))
> return expr;
>
> @@ -2671,8 +2671,7 @@
> }
>
> gcc_assert (CLASS_TYPE_P (scope));
> - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE
> - || TREE_CODE (name) == BIT_NOT_EXPR);
> + gcc_assert (identifier_p (name) || TREE_CODE (name) ==
> BIT_NOT_EXPR);
>
> if (constructor_name_p (name, scope))
> {
> @@ -5067,8 +5066,7 @@
> arg = mark_lvalue_use (arg);
> argtype = lvalue_type (arg);
>
> - gcc_assert (TREE_CODE (arg) != IDENTIFIER_NODE
> - || !IDENTIFIER_OPNAME_P (arg));
> + gcc_assert (!identifier_p (arg) || !IDENTIFIER_OPNAME_P (arg));
>
> if (TREE_CODE (arg) == COMPONENT_REF && type_unknown_p (arg)
> && !really_overloaded_fn (TREE_OPERAND (arg, 1)))
> Index: typeck2.c
> ===================================================================
> --- typeck2.c (revision 196891)
> +++ typeck2.c (working copy)
> @@ -278,8 +278,7 @@
> void **slot;
> struct pending_abstract_type *pat;
>
> - gcc_assert (!decl || DECL_P (decl)
> - || TREE_CODE (decl) == IDENTIFIER_NODE);
> + gcc_assert (!decl || DECL_P (decl) || identifier_p (decl));
>
> if (!abstract_pending_vars)
> abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
> @@ -336,7 +335,7 @@
> error ("invalid abstract return type for member function %q+#D",
> decl);
> else if (TREE_CODE (decl) == FUNCTION_DECL)
> error ("invalid abstract return type for function %q+#D", decl);
> - else if (TREE_CODE (decl) == IDENTIFIER_NODE)
> + else if (identifier_p (decl))
> /* Here we do not have location information. */
> error ("invalid abstract type %qT for %qE", type, decl);
> else
> @@ -1241,7 +1240,7 @@
> latter case can happen in templates where lookup has to be
> deferred. */
> gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
> - || TREE_CODE (ce->index) == IDENTIFIER_NODE);
> + || identifier_p (ce->index));
> if (ce->index != field
> && ce->index != DECL_NAME (field))
> {
> @@ -1367,7 +1366,7 @@
> {
> if (TREE_CODE (ce->index) == FIELD_DECL)
> ;
> - else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
> + else if (identifier_p (ce->index))
> {
> /* This can happen within a cast, see g++.dg/opt/cse2.C. */
> tree name = ce->index;
>
