call.c (perform_overload_resolution, [...]): Use OVL_P; remove redundant TEMPLATE_DEC...

2019-05-15  Paolo Carlini  <paolo.carlini@oracle.com>

	* call.c (perform_overload_resolution, build_new_method_call_1):
	Use OVL_P; remove redundant TEMPLATE_DECL checks.
	* decl.c (grokfndecl): Likewise.
	* mangle.c (write_expression): Likewise.
	* parser.c (cp_parser_template_id): Likewise.
	* pt.c (resolve_overloaded_unification, type_dependent_expression_p):
	Likewise.
	* search.c (build_baselink): Likewise.
	* tree.c (is_overloaded_fn, dependent_name, maybe_get_fns): Likewise.

From-SVN: r271211

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index d896e5d572a6df859e1b8a312a5e121f6ffeb191..5888ce6b82cec6f890e388614767843b7b65dd37 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,15 @@
+2019-05-15  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * call.c (perform_overload_resolution, build_new_method_call_1):
+       Use OVL_P; remove redundant TEMPLATE_DECL checks.
+       * decl.c (grokfndecl): Likewise.
+       * mangle.c (write_expression): Likewise.
+       * parser.c (cp_parser_template_id): Likewise.
+       * pt.c (resolve_overloaded_unification, type_dependent_expression_p):
+       Likewise.
+       * search.c (build_baselink): Likewise.
+       * tree.c (is_overloaded_fn, dependent_name, maybe_get_fns): Likewise.
+
 2019-05-14  Paolo Carlini  <paolo.carlini@oracle.com>
 
        PR preprocessor/90382

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 00cb3993471efe72ee6bea0a38679f3294b3ebec..0a5147a1a2f4eef574fc90e98d34c4f9ede32cc7 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -4383,10 +4383,7 @@ perform_overload_resolution (tree fn,
   *any_viable_p = true;
 
   /* Check FN.  */
-  gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
-             || TREE_CODE (fn) == TEMPLATE_DECL
-             || TREE_CODE (fn) == OVERLOAD
-             || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
+  gcc_assert (OVL_P (fn) || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
 
   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
     {
@@ -9605,9 +9602,7 @@ build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args,
       fns = TREE_OPERAND (fns, 0);
       template_only = 1;
     }
-  gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
-             || TREE_CODE (fns) == TEMPLATE_DECL
-             || TREE_CODE (fns) == OVERLOAD);
+  gcc_assert (OVL_P (fns));
   fn = OVL_FIRST (fns);
   name = DECL_NAME (fn);
 

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 66dc4c4a2ce358bb6c41ce006754076780aaa1a8..6918c3bb79deeebd2142dee0a987d331e6bc04b3 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -8918,9 +8918,7 @@ grokfndecl (tree ctype,
             the information in the TEMPLATE_ID_EXPR.  */
          SET_DECL_IMPLICIT_INSTANTIATION (decl);
 
-         gcc_assert (identifier_p (fns)
-                     || TREE_CODE (fns) == OVERLOAD
-                     || TREE_CODE (fns) == FUNCTION_DECL);
+         gcc_assert (identifier_p (fns) || OVL_P (fns));
          DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
 
          for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))

diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index c13dacbd05e622739ce213a5453088bb66d05821..acb81d16b5359cdbe7e20a2c2977b33a93cf75ec 100644 (file)
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -3278,8 +3278,7 @@ write_expression (tree expr)
 
            /* Mangle a dependent name as the name, not whatever happens to
               be the first function in the overload set.  */
-           if ((TREE_CODE (fn) == FUNCTION_DECL
-                || TREE_CODE (fn) == OVERLOAD)
+           if (OVL_P (fn)
                && type_dependent_expression_p_push (expr))
              fn = OVL_NAME (fn);
 

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index c90782eafde4d915ee05f844444d36c21e48097b..ab3e672d3286e25d3d7ef12adb6fd9c8dd4eaea6 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -16479,10 +16479,7 @@ cp_parser_template_id (cp_parser *parser,
     {
       /* If it's not a class-template or a template-template, it should be
         a function-template.  */
-      gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
-                  || TREE_CODE (templ) == OVERLOAD
-                  || TREE_CODE (templ) == FUNCTION_DECL
-                  || BASELINK_P (templ)));
+      gcc_assert (OVL_P (templ) || BASELINK_P (templ));
 
       template_id = lookup_template_function (templ, arguments);
       if (TREE_CODE (template_id) == TEMPLATE_ID_EXPR)

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 42d128744ab5a16e588ee9c3b0f11c408366fc8b..edb0701760a9977ff76849429151905e92723cd7 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -21193,8 +21193,7 @@ resolve_overloaded_unification (tree tparms,
       if (good != 1)
        good = ok;
     }
-  else if (TREE_CODE (arg) != OVERLOAD
-          && TREE_CODE (arg) != FUNCTION_DECL)
+  else if (!OVL_P (arg))
     /* If ARG is, for example, "(0, &f)" then its type will be unknown
        -- but the deduction does not succeed because the expression is
        not just the function on its own.  */
@@ -25950,8 +25949,7 @@ type_dependent_expression_p (tree expression)
            return true;
        }
 
-      gcc_assert (TREE_CODE (expression) == OVERLOAD
-                 || TREE_CODE (expression) == FUNCTION_DECL);
+      gcc_assert (OVL_P (expression));
 
       for (lkp_iterator iter (expression); iter; ++iter)
        if (type_dependent_expression_p (*iter))

diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 4c3fffda717c21db0b6c6bae32330b2cd9238ddf..dac08d44d764c01d5d582a815884fc8f36e9d554 100644 (file)
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1058,10 +1058,7 @@ build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
 {
   tree baselink;
 
-  gcc_assert (TREE_CODE (functions) == FUNCTION_DECL
-             || TREE_CODE (functions) == TEMPLATE_DECL
-             || TREE_CODE (functions) == TEMPLATE_ID_EXPR
-             || TREE_CODE (functions) == OVERLOAD);
+  gcc_assert (OVL_P (functions) || TREE_CODE (functions) == TEMPLATE_ID_EXPR);
   gcc_assert (!optype || TYPE_P (optype));
   gcc_assert (TREE_TYPE (functions));
 

diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 7b8889ea7b2a8a8be9d302635f4a7dff93ffb64c..14d6aff1ccf6ca9bb2c91e842ce5963be80f0f55 100644 (file)
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -2381,8 +2381,7 @@ is_overloaded_fn (tree x)
       || (TREE_CODE (x) == OVERLOAD && !OVL_SINGLE_P (x)))
     return 2;
 
-  return (TREE_CODE (x) == FUNCTION_DECL
-         || TREE_CODE (x) == OVERLOAD);
+  return OVL_P (x);
 }
 
 /* X is the CALL_EXPR_FN of a CALL_EXPR.  If X represents a dependent name
@@ -2396,7 +2395,7 @@ dependent_name (tree x)
     return x;
   if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
     x = TREE_OPERAND (x, 0);
-  if (TREE_CODE (x) == OVERLOAD || TREE_CODE (x) == FUNCTION_DECL)
+  if (OVL_P (x))
     return OVL_NAME (x);
   return NULL_TREE;
 }
@@ -2428,8 +2427,7 @@ maybe_get_fns (tree from)
   if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
     from = TREE_OPERAND (from, 0);
 
-  if (TREE_CODE (from) == OVERLOAD
-      || TREE_CODE (from) == FUNCTION_DECL)
+  if (OVL_P (from))
     return from;
 
   return NULL;