c++: use _P() defines from tree.h

gcc/cp/ChangeLog:

	* call.cc (promoted_arithmetic_type_p): Use _P defines from tree.h.
	(build_conditional_expr): Ditto.
	(convert_like_internal): Ditto.
	(convert_arg_to_ellipsis): Ditto.
	(build_over_call): Ditto.
	(compare_ics): Ditto.
	* class.cc (is_empty_base_ref): Ditto.
	* coroutines.cc (rewrite_param_uses): Ditto.
	* cp-tree.h (DECL_DISCRIMINATOR_P): Ditto.
	(ARITHMETIC_TYPE_P): Ditto.
	* cvt.cc (ocp_convert): Ditto.
	* cxx-pretty-print.cc (pp_cxx_template_argument_list): Ditto.
	* decl.cc (layout_var_decl): Ditto.
	(get_tuple_size): Ditto.
	* error.cc (dump_simple_decl): Ditto.
	* lambda.cc (start_lambda_scope): Ditto.
	* mangle.cc (write_template_arg): Ditto.
	* method.cc (spaceship_comp_cat): Ditto.
	* module.cc (node_template_info): Ditto.
	(trees_out::start): Ditto.
	(trees_out::decl_node): Ditto.
	(trees_in::read_var_def): Ditto.
	(set_instantiating_module): Ditto.
	* name-lookup.cc (maybe_record_mergeable_decl): Ditto.
	(consider_decl): Ditto.
	(maybe_add_fuzzy_decl): Ditto.
	* pt.cc (convert_nontype_argument): Ditto.
	* semantics.cc (handle_omp_array_sections_1): Ditto.
	(finish_omp_clauses): Ditto.
	(finish_omp_target_clauses_r): Ditto.
	(is_this_parameter): Ditto.
	* tree.cc (build_cplus_array_type): Ditto.
	(is_this_expression): Ditto.
	* typeck.cc (do_warn_enum_conversions): Ditto.
	* typeck2.cc (store_init_value): Ditto.
	(check_narrowing): Ditto.

diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 908374a43c989b10e81d9706952080f1e06e3f8c..2736f55f229f7a411e984d0ebd90f4cd14caa043 100644 (file)
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -2746,7 +2746,7 @@ promoted_arithmetic_type_p (tree type)
      integral types plus floating types.  */
   return ((CP_INTEGRAL_TYPE_P (type)
           && same_type_p (type_promotes_to (type), type))
-         || TREE_CODE (type) == REAL_TYPE);
+         || SCALAR_FLOAT_TYPE_P (type));
 }
 
 /* Create any builtin operator overload candidates for the operator in
@@ -5759,10 +5759,10 @@ build_conditional_expr (const op_location_t &loc,
   if ((TREE_CODE (arg2) == EXCESS_PRECISION_EXPR
        || TREE_CODE (arg3) == EXCESS_PRECISION_EXPR)
       && (TREE_CODE (arg2_type) == INTEGER_TYPE
-         || TREE_CODE (arg2_type) == REAL_TYPE
+         || SCALAR_FLOAT_TYPE_P (arg2_type)
          || TREE_CODE (arg2_type) == COMPLEX_TYPE)
       && (TREE_CODE (arg3_type) == INTEGER_TYPE
-         || TREE_CODE (arg3_type) == REAL_TYPE
+         || SCALAR_FLOAT_TYPE_P (arg3_type)
          || TREE_CODE (arg3_type) == COMPLEX_TYPE))
     {
       semantic_result_type
@@ -5775,8 +5775,8 @@ build_conditional_expr (const op_location_t &loc,
            t1 = TREE_TYPE (t1);
          if (TREE_CODE (t2) == COMPLEX_TYPE)
            t2 = TREE_TYPE (t2);
-         gcc_checking_assert (TREE_CODE (t1) == REAL_TYPE
-                              && TREE_CODE (t2) == REAL_TYPE
+         gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1)
+                              && SCALAR_FLOAT_TYPE_P (t2)
                               && (extended_float_type_p (t1)
                                   || extended_float_type_p (t2))
                               && cp_compare_floating_point_conversion_ranks
@@ -6127,8 +6127,8 @@ build_conditional_expr (const op_location_t &loc,
            t1 = TREE_TYPE (t1);
          if (TREE_CODE (t2) == COMPLEX_TYPE)
            t2 = TREE_TYPE (t2);
-         gcc_checking_assert (TREE_CODE (t1) == REAL_TYPE
-                              && TREE_CODE (t2) == REAL_TYPE
+         gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1)
+                              && SCALAR_FLOAT_TYPE_P (t2)
                               && (extended_float_type_p (t1)
                                   || extended_float_type_p (t2))
                               && cp_compare_floating_point_conversion_ranks
@@ -6147,8 +6147,8 @@ build_conditional_expr (const op_location_t &loc,
            t1 = TREE_TYPE (t1);
          if (TREE_CODE (t2) == COMPLEX_TYPE)
            t2 = TREE_TYPE (t2);
-         gcc_checking_assert (TREE_CODE (t1) == REAL_TYPE
-                              && TREE_CODE (t2) == REAL_TYPE
+         gcc_checking_assert (SCALAR_FLOAT_TYPE_P (t1)
+                              && SCALAR_FLOAT_TYPE_P (t2)
                               && (extended_float_type_p (t1)
                                   || extended_float_type_p (t2))
                               && cp_compare_floating_point_conversion_ranks
@@ -6185,8 +6185,8 @@ build_conditional_expr (const op_location_t &loc,
       else if ((complain & tf_warning)
               && warn_deprecated_enum_float_conv
               && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
-                   && TREE_CODE (arg3_type) == REAL_TYPE)
-                  || (TREE_CODE (arg2_type) == REAL_TYPE
+                   && SCALAR_FLOAT_TYPE_P (arg3_type))
+                  || (SCALAR_FLOAT_TYPE_P (arg2_type)
                       && TREE_CODE (arg3_type) == ENUMERAL_TYPE)))
        {
          if (TREE_CODE (arg2_type) == ENUMERAL_TYPE)
@@ -8321,8 +8321,8 @@ convert_like_internal (conversion *convs, tree expr, tree fn, int argnum,
                                "direct-initialization",
                                totype, TREE_TYPE (expr));
 
-      if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
-         && TREE_CODE (totype) == REAL_TYPE
+      if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (expr))
+         && SCALAR_FLOAT_TYPE_P (totype)
          && (extended_float_type_p (TREE_TYPE (expr))
              || extended_float_type_p (totype)))
        switch (cp_compare_floating_point_conversion_ranks (TREE_TYPE (expr),
@@ -8974,7 +8974,7 @@ convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain)
      type that is subject to the floating-point promotion
      (_conv.fpprom_), the value of the argument is converted to the
      promoted type before the call.  */
-  if (TREE_CODE (arg_type) == REAL_TYPE
+  if (SCALAR_FLOAT_TYPE_P (arg_type)
       && (TYPE_PRECISION (arg_type)
          < TYPE_PRECISION (double_type_node))
       && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type))
@@ -9796,7 +9796,7 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
              obj_arg = NULL_TREE;
            }
          /* Look through *(const T *)&obj.  */
-         else if (obj_arg && TREE_CODE (obj_arg) == INDIRECT_REF)
+         else if (obj_arg && INDIRECT_REF_P (obj_arg))
            {
              tree addr = TREE_OPERAND (obj_arg, 0);
              STRIP_NOPS (addr);
@@ -10460,7 +10460,7 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
              obj_arg = NULL_TREE;
            }
          /* Look through *(const T *)&obj.  */
-         else if (obj_arg && TREE_CODE (obj_arg) == INDIRECT_REF)
+         else if (obj_arg && INDIRECT_REF_P (obj_arg))
            {
              tree addr = TREE_OPERAND (obj_arg, 0);
              STRIP_NOPS (addr);
@@ -12197,7 +12197,7 @@ compare_ics (conversion *ics1, conversion *ics2)
        std::swap (fp3, t3);
       }
     if (TYPE_MAIN_VARIANT (fp1) == TYPE_MAIN_VARIANT (fp3)
-       && TREE_CODE (fp1) == REAL_TYPE
+       && SCALAR_FLOAT_TYPE_P (fp1)
        /* Only apply this rule if at least one of the 3 types is
           extended floating-point type, otherwise keep them as
           before for compatibility reasons with types like __float128.
@@ -12205,15 +12205,15 @@ compare_ics (conversion *ics1, conversion *ics2)
           ranks and so when just those 3 types are involved, this
           rule doesn't trigger.  */
        && (extended_float_type_p (fp1)
-           || (TREE_CODE (fp2) == REAL_TYPE && extended_float_type_p (fp2))
-           || (TREE_CODE (t3) == REAL_TYPE && extended_float_type_p (t3))))
+           || (SCALAR_FLOAT_TYPE_P (fp2) && extended_float_type_p (fp2))
+           || (SCALAR_FLOAT_TYPE_P (t3) && extended_float_type_p (t3))))
       {
        if (TREE_CODE (fp2) != REAL_TYPE)
          {
            ret = -ret;
            std::swap (fp2, t3);
          }
-       if (TREE_CODE (fp2) == REAL_TYPE)
+       if (SCALAR_FLOAT_TYPE_P (fp2))
          {
            /* cp_compare_floating_point_conversion_ranks returns -1, 0 or 1
               if the conversion rank is equal (-1 or 1 if the subrank is
@@ -12240,7 +12240,7 @@ compare_ics (conversion *ics1, conversion *ics2)
                     FP1 <-> T3 conversion is better.  */
                  return -ret;
              }
-           else if (TREE_CODE (t3) == REAL_TYPE
+           else if (SCALAR_FLOAT_TYPE_P (t3)
                     && IN_RANGE (cp_compare_floating_point_conversion_ranks
                                                                (fp1, t3),
                                  -1, 1))

diff --git a/gcc/cp/class.cc b/gcc/cp/class.cc
index 68b62086340bcd1ab357907308b52b64c680b994..bc84f4f731ac6dbf17becb0131f56ab7a03d28e8 100644 (file)
--- a/gcc/cp/class.cc
+++ b/gcc/cp/class.cc
@@ -673,7 +673,7 @@ convert_to_base_statically (tree expr, tree base)
 bool
 is_empty_base_ref (tree expr)
 {
-  if (TREE_CODE (expr) == INDIRECT_REF)
+  if (INDIRECT_REF_P (expr))
     expr = TREE_OPERAND (expr, 0);
   if (TREE_CODE (expr) != NOP_EXPR)
     return false;

diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index 59a240ebd403996494dd8004c1e41a667b9d6cf7..3493d3c6ed33101eaf6d2e0cac4a653896d23941 100644 (file)
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -3780,7 +3780,7 @@ rewrite_param_uses (tree *stmt, int *do_subtree ATTRIBUTE_UNUSED, void *d)
   param_frame_data *data = (param_frame_data *) d;
 
   /* For lambda closure content, we have to look specifically.  */
-  if (TREE_CODE (*stmt) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (*stmt))
+  if (VAR_P (*stmt) && DECL_HAS_VALUE_EXPR_P (*stmt))
     {
       tree t = DECL_VALUE_EXPR (*stmt);
       return cp_walk_tree (&t, rewrite_param_uses, d, NULL);

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 714b6d55f4f66a84486cc5adc9c2bbb08d0a63e7..a1b882f11fed4fc967c7a94f7a32fc43ac19f899 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3189,7 +3189,7 @@ struct GTY(()) lang_decl {
 
 /* Nonzero if NODE has DECL_DISCRIMINATOR and not DECL_ACCESS.  */
 #define DECL_DISCRIMINATOR_P(NODE)                             \
-  (((TREE_CODE (NODE) == VAR_DECL && TREE_STATIC (NODE))       \
+  (((VAR_P (NODE) && TREE_STATIC (NODE))       \
     || DECL_IMPLICIT_TYPEDEF_P (NODE))                         \
    && DECL_FUNCTION_SCOPE_P (NODE))
 
@@ -4453,7 +4453,7 @@ get_vec_init_expr (tree t)
    Keep these checks in ascending code order.  */
 #define ARITHMETIC_TYPE_P(TYPE) \
   (CP_INTEGRAL_TYPE_P (TYPE) \
-   || TREE_CODE (TYPE) == REAL_TYPE \
+   || SCALAR_FLOAT_TYPE_P (TYPE) \
    || TREE_CODE (TYPE) == COMPLEX_TYPE)
 
 /* [basic.types]

diff --git a/gcc/cp/cvt.cc b/gcc/cp/cvt.cc
index 17827d06a4a6693e27710394c889756e8765a288..c6b52f07050854f185d86e0d52221a888c9e09e1 100644 (file)
--- a/gcc/cp/cvt.cc
+++ b/gcc/cp/cvt.cc
@@ -810,7 +810,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags,
          /* enum = enum, enum = int, enum = float, (enum)pointer are all
             errors.  */
          if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
-               || TREE_CODE (intype) == REAL_TYPE)
+               || SCALAR_FLOAT_TYPE_P (intype))
               && ! (convtype & CONV_STATIC))
              || TYPE_PTR_P (intype))
            {

diff --git a/gcc/cp/cxx-pretty-print.cc b/gcc/cp/cxx-pretty-print.cc
index 4b547c77ef4aa8443f21c6bacc3f40d8a26f7274..909a9dc917f20b70b2c4bdb55e68b880320592b5 100644 (file)
--- a/gcc/cp/cxx-pretty-print.cc
+++ b/gcc/cp/cxx-pretty-print.cc
@@ -1966,7 +1966,7 @@ pp_cxx_template_argument_list (cxx_pretty_printer *pp, tree t)
          if (TYPE_P (arg) || (TREE_CODE (arg) == TEMPLATE_DECL
                               && TYPE_P (DECL_TEMPLATE_RESULT (arg))))
            pp->type_id (arg);
-         else if (TREE_CODE (arg) == VAR_DECL && DECL_NTTP_OBJECT_P (arg))
+         else if (VAR_P (arg) && DECL_NTTP_OBJECT_P (arg))
            pp->expression (DECL_INITIAL (arg));
          else
            pp->expression (arg);

diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 23a2b2fef0bc88ed127214c5a911138fc82860d7..a672e4844f1a598e8d596ac289bc91a289a737eb 100644 (file)
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -6349,7 +6349,7 @@ layout_var_decl (tree decl)
       && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)))
       && DECL_SIZE (decl) != NULL_TREE
       && TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST
-      && TYPE_SIZE (type) != NULL_TREE
+      && COMPLETE_TYPE_P (type)
       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
       && tree_int_cst_equal (DECL_SIZE (decl), TYPE_SIZE (type)))
     {
@@ -8927,7 +8927,7 @@ get_tuple_size (tree type)
     return NULL_TREE;
   tree val = lookup_qualified_name (inst, value_identifier,
                                    LOOK_want::NORMAL, /*complain*/false);
-  if (TREE_CODE (val) == VAR_DECL || TREE_CODE (val) == CONST_DECL)
+  if (VAR_P (val) || TREE_CODE (val) == CONST_DECL)
     val = maybe_constant_value (val);
   if (TREE_CODE (val) == INTEGER_CST)
     return val;

diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
index 9b967ce409db5c3d387a9eb6aa31a90a28fc6479..31319aa9e87dcb0559520707d463f7ad051eff38 100644 (file)
--- a/gcc/cp/error.cc
+++ b/gcc/cp/error.cc
@@ -1140,7 +1140,7 @@ dump_global_iord (cxx_pretty_printer *pp, tree t)
 static void
 dump_simple_decl (cxx_pretty_printer *pp, tree t, tree type, int flags)
 {
-  if (TREE_CODE (t) == VAR_DECL && DECL_NTTP_OBJECT_P (t))
+  if (VAR_P (t) && DECL_NTTP_OBJECT_P (t))
     return dump_expr (pp, DECL_INITIAL (t), flags);
 
   if (flags & TFF_DECL_SPECIFIERS)

diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc
index 9925209b2ed07901ec847c32c6e85445f71305ca..a359bc6ee8dc3570fd33c3ac45392f4598338aac 100644 (file)
--- a/gcc/cp/lambda.cc
+++ b/gcc/cp/lambda.cc
@@ -1474,7 +1474,7 @@ void
 start_lambda_scope (tree decl)
 {
   gcc_checking_assert (decl);
-  if (current_function_decl && TREE_CODE (decl) == VAR_DECL)
+  if (current_function_decl && VAR_P (decl))
     // If we're inside a function, we ignore variable scope.  Don't push.
     lambda_scope.nesting++;
   else

diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index a235f23459d2ca6a12ba2eecb0611c81c3d3e2e1..826c5e76c1dfb95869c323036f555753b61b3c7f 100644 (file)
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -3793,7 +3793,7 @@ write_template_arg (tree node)
        }
     }
 
-  if (TREE_CODE (node) == VAR_DECL && DECL_NTTP_OBJECT_P (node))
+  if (VAR_P (node) && DECL_NTTP_OBJECT_P (node))
     /* We want to mangle the argument, not the var we stored it in.  */
     node = tparm_object_argument (node);
 

diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc
index 7ec7bfe8387594dea61512a3f9dd10c510811f6d..0c2ca9e4f4165693e9def002225ef6a1b1c77dd0 100644 (file)
--- a/gcc/cp/method.cc
+++ b/gcc/cp/method.cc
@@ -1048,7 +1048,7 @@ spaceship_comp_cat (tree optype)
 {
   if (INTEGRAL_OR_ENUMERATION_TYPE_P (optype) || TYPE_PTROBV_P (optype))
     return cc_strong_ordering;
-  else if (TREE_CODE (optype) == REAL_TYPE)
+  else if (SCALAR_FLOAT_TYPE_P (optype))
     return cc_partial_ordering;
 
   /* ??? should vector <=> produce a vector of one of the above?  */

diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc
index ac2fe66b080c9a51a591475ff584465f2ce9f0df..ecde98d69b41daf79a610399a9b7b928185acc73 100644 (file)
--- a/gcc/cp/module.cc
+++ b/gcc/cp/module.cc
@@ -4042,7 +4042,7 @@ node_template_info (tree decl, int &use)
        }
     }
   else if (DECL_LANG_SPECIFIC (decl)
-          && (TREE_CODE (decl) == VAR_DECL
+          && (VAR_P (decl)
               || TREE_CODE (decl) == TYPE_DECL
               || TREE_CODE (decl) == FUNCTION_DECL
               || TREE_CODE (decl) == FIELD_DECL
@@ -5151,7 +5151,7 @@ trees_out::start (tree t, bool code_streamed)
   switch (TREE_CODE (t))
     {
     default:
-      if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_vl_exp)
+      if (VL_EXP_CLASS_P (t))
        u (VL_EXP_OPERAND_LENGTH (t));
       break;
 
@@ -8551,7 +8551,7 @@ trees_out::decl_node (tree decl, walk_kind ref)
        {
        tinfo:
          /* A typeinfo, tt_tinfo_typedef or tt_tinfo_var.  */
-         bool is_var = TREE_CODE (decl) == VAR_DECL;
+         bool is_var = VAR_P (decl);
          tree type = TREE_TYPE (decl);
          unsigned ix = get_pseudo_tinfo_index (type);
          if (streaming_p ())
@@ -8651,7 +8651,7 @@ trees_out::decl_node (tree decl, walk_kind ref)
      Mostly things that can be defined outside of their (original
      declaration) context.  */
   gcc_checking_assert (TREE_CODE (decl) == TEMPLATE_DECL
-                      || TREE_CODE (decl) == VAR_DECL
+                      || VAR_P (decl)
                       || TREE_CODE (decl) == FUNCTION_DECL
                       || TREE_CODE (decl) == TYPE_DECL
                       || TREE_CODE (decl) == USING_DECL
@@ -11702,7 +11702,7 @@ bool
 trees_in::read_var_def (tree decl, tree maybe_template)
 {
   /* Do not mark the virtual table entries as used.  */
-  bool vtable = TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl);
+  bool vtable = VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl);
   unused += vtable;
   tree init = tree_node ();
   tree dyn_init = init ? NULL_TREE : tree_node ();
@@ -18776,7 +18776,7 @@ void
 set_instantiating_module (tree decl)
 {
   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
-             || TREE_CODE (decl) == VAR_DECL
+             || VAR_P (decl)
              || TREE_CODE (decl) == TYPE_DECL
              || TREE_CODE (decl) == CONCEPT_DECL
              || TREE_CODE (decl) == TEMPLATE_DECL

diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc
index ad03141df430f90d4cdc59675afcd5f4feffaa5d..eb5c333b5ead8a97a34c25f0ce198a45cba66009 100644 (file)
--- a/gcc/cp/name-lookup.cc
+++ b/gcc/cp/name-lookup.cc
@@ -3488,7 +3488,7 @@ maybe_record_mergeable_decl (tree *slot, tree name, tree decl)
 
   tree not_tmpl = STRIP_TEMPLATE (decl);
   if ((TREE_CODE (not_tmpl) == FUNCTION_DECL
-       || TREE_CODE (not_tmpl) == VAR_DECL)
+       || VAR_P (not_tmpl))
       && DECL_THIS_STATIC (not_tmpl))
     /* Internal linkage.  */
     return;
@@ -6932,7 +6932,7 @@ consider_decl (tree decl,  best_match <tree, const char *> &bm,
 {
   /* Skip compiler-generated variables (e.g. __for_begin/__for_end
      within range for).  */
-  if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl))
+  if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
     return;
 
   tree suggestion = DECL_NAME (decl);
@@ -6967,7 +6967,7 @@ maybe_add_fuzzy_decl (auto_vec<tree> &vec, tree decl)
 {
   /* Skip compiler-generated variables (e.g. __for_begin/__for_end
      within range for).  */
-  if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl))
+  if (VAR_P (decl) && DECL_ARTIFICIAL (decl))
     return false;
 
   tree suggestion = DECL_NAME (decl);

diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 351fc18b600b53ea028b24107fd6ef4f9dcbe8a0..696233e9f07e622bbc1fe872fb2214f17f193def 100644 (file)
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -7488,7 +7488,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
      integral promotions (_conv.prom_) and integral conversions
      (_conv.integral_) are applied.  */
   if (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
-      || TREE_CODE (type) == REAL_TYPE)
+      || SCALAR_FLOAT_TYPE_P (type))
     {
       if (cxx_dialect < cxx11)
        {

diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 13c6582b62899204e6715a866b12d35eda19d875..05df62823021acef1011758facf577338f49926f 100644 (file)
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -5169,7 +5169,7 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
          && TREE_CODE (TREE_OPERAND (t, 0)) == COMPONENT_REF)
        t = TREE_OPERAND (t, 0);
       ret = t;
-      while (TREE_CODE (t) == INDIRECT_REF)
+      while (INDIRECT_REF_P (t))
        {
          t = TREE_OPERAND (t, 0);
          STRIP_NOPS (t);
@@ -5206,7 +5206,7 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
                }
              t = TREE_OPERAND (t, 0);
              while (TREE_CODE (t) == MEM_REF
-                    || TREE_CODE (t) == INDIRECT_REF
+                    || INDIRECT_REF_P (t)
                     || TREE_CODE (t) == ARRAY_REF)
                {
                  t = TREE_OPERAND (t, 0);
@@ -8097,7 +8097,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                          if (REFERENCE_REF_P (t))
                            t = TREE_OPERAND (t, 0);
                          if (TREE_CODE (t) == MEM_REF
-                             || TREE_CODE (t) == INDIRECT_REF)
+                             || INDIRECT_REF_P (t))
                            {
                              t = TREE_OPERAND (t, 0);
                              STRIP_NOPS (t);
@@ -8182,7 +8182,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                  && OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_ATTACH_DETACH)
                OMP_CLAUSE_DECL (c) = t;
            }
-         while (TREE_CODE (t) == INDIRECT_REF
+         while (INDIRECT_REF_P (t)
                 || TREE_CODE (t) == ARRAY_REF)
            {
              t = TREE_OPERAND (t, 0);
@@ -8201,7 +8201,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
            remove = true;
          indir_component_ref_p = false;
          if (TREE_CODE (t) == COMPONENT_REF
-             && (TREE_CODE (TREE_OPERAND (t, 0)) == INDIRECT_REF
+             && (INDIRECT_REF_P (TREE_OPERAND (t, 0))
                  || TREE_CODE (TREE_OPERAND (t, 0)) == ARRAY_REF))
            {
              t = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
@@ -8255,7 +8255,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                        t = TREE_OPERAND (t, 0);
                    }
                  while (TREE_CODE (t) == MEM_REF
-                        || TREE_CODE (t) == INDIRECT_REF
+                        || INDIRECT_REF_P (t)
                         || TREE_CODE (t) == ARRAY_REF)
                    {
                      t = TREE_OPERAND (t, 0);
@@ -8706,7 +8706,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                  t = OMP_CLAUSE_DECL (c);
                  while (TREE_CODE (t) == TREE_LIST)
                    t = TREE_CHAIN (t);
-                 while (TREE_CODE (t) == INDIRECT_REF
+                 while (INDIRECT_REF_P (t)
                         || TREE_CODE (t) == ARRAY_REF)
                    t = TREE_OPERAND (t, 0);
                }
@@ -9021,7 +9021,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
            {
              t = OMP_CLAUSE_DECL (c);
              while (handled_component_p (t)
-                    || TREE_CODE (t) == INDIRECT_REF
+                    || INDIRECT_REF_P (t)
                     || TREE_CODE (t) == ADDR_EXPR
                     || TREE_CODE (t) == MEM_REF
                     || TREE_CODE (t) == NON_LVALUE_EXPR)
@@ -9070,7 +9070,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                  if (TREE_CODE (t) == POINTER_PLUS_EXPR)
                    t = TREE_OPERAND (t, 0);
                  if (TREE_CODE (t) == ADDR_EXPR
-                     || TREE_CODE (t) == INDIRECT_REF)
+                     || INDIRECT_REF_P (t))
                    t = TREE_OPERAND (t, 0);
                  if (DECL_P (t))
                    bitmap_clear_bit (&aligned_head, DECL_UID (t));
@@ -9609,7 +9609,7 @@ finish_omp_target_clauses_r (tree *tp, int *walk_subtrees, void *ptr)
      of DECL_VALUE_EXPRs during the target body walk seems the only way to
      find them.  */
   if (current_closure
-      && (TREE_CODE (t) == VAR_DECL
+      && (VAR_P (t)
          || TREE_CODE (t) == PARM_DECL
          || TREE_CODE (t) == RESULT_DECL)
       && DECL_HAS_VALUE_EXPR_P (t)
@@ -12362,8 +12362,8 @@ is_this_parameter (tree t)
   if (!DECL_P (t) || DECL_NAME (t) != this_identifier)
     return false;
   gcc_assert (TREE_CODE (t) == PARM_DECL
-             || (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
-             || (cp_binding_oracle && TREE_CODE (t) == VAR_DECL));
+             || (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
+             || (cp_binding_oracle && VAR_P (t)));
   return true;
 }
 

diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index 131b212ff73e2e5d4a2a154d33c55f4237dfcb8a..19dfb3ed782f5d721005cf14325aa77fe7d5c7a5 100644 (file)
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -1173,7 +1173,7 @@ build_cplus_array_type (tree elt_type, tree index_type, int dependent)
     }
 
   /* Avoid spurious warnings with VLAs (c++/54583).  */
-  if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t)))
+  if (CAN_HAVE_LOCATION_P (TYPE_SIZE (t)))
     suppress_warning (TYPE_SIZE (t), OPT_Wunused);
 
   /* Push these needs up to the ARRAY_TYPE so that initialization takes
@@ -3911,7 +3911,7 @@ is_this_expression (tree t)
 {
   t = get_innermost_component (t);
   /* See through deferences and no-op conversions.  */
-  if (TREE_CODE (t) == INDIRECT_REF)
+  if (INDIRECT_REF_P (t))
     t = TREE_OPERAND (t, 0);
   if (TREE_CODE (t) == NOP_EXPR)
     t = TREE_OPERAND (t, 0);

diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index c225c4e242325a4334d8b54dbd9484145e69d4c1..11fcc7fcd3b35df92906e0bd72811dac43ae9e9c 100644 (file)
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -4996,8 +4996,8 @@ do_warn_enum_conversions (location_t loc, enum tree_code code, tree type0,
        }
     }
   else if ((TREE_CODE (type0) == ENUMERAL_TYPE
-           && TREE_CODE (type1) == REAL_TYPE)
-          || (TREE_CODE (type0) == REAL_TYPE
+           && SCALAR_FLOAT_TYPE_P (type1))
+          || (SCALAR_FLOAT_TYPE_P (type0)
               && TREE_CODE (type1) == ENUMERAL_TYPE))
     {
       const bool enum_first_p = TREE_CODE (type0) == ENUMERAL_TYPE;

diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc
index 72b38317090861f71ae2d6d94d3cd11dafcdc418..8724877058fbcf805810c6681954ac5f47977c3d 100644 (file)
--- a/gcc/cp/typeck2.cc
+++ b/gcc/cp/typeck2.cc
@@ -932,7 +932,7 @@ store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
      here it should have been digested into an actual value for the type.  */
   gcc_checking_assert (TREE_CODE (value) != CONSTRUCTOR
                       || processing_template_decl
-                      || TREE_CODE (type) == VECTOR_TYPE
+                      || VECTOR_TYPE_P (type)
                       || !TREE_HAS_CONSTRUCTOR (value));
 
   /* If the initializer is not a constant, fill in DECL_INITIAL with
@@ -999,7 +999,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain,
     return ok;
 
   if (CP_INTEGRAL_TYPE_P (type)
-      && TREE_CODE (ftype) == REAL_TYPE)
+      && SCALAR_FLOAT_TYPE_P (ftype))
     ok = false;
   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
           && CP_INTEGRAL_TYPE_P (type))
@@ -1017,8 +1017,8 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain,
     }
   /* [dcl.init.list]#7.2: "from long double to double or float, or from
       double to float".  */
-  else if (TREE_CODE (ftype) == REAL_TYPE
-          && TREE_CODE (type) == REAL_TYPE)
+  else if (SCALAR_FLOAT_TYPE_P (ftype)
+          && SCALAR_FLOAT_TYPE_P (type))
     {
       if ((extended_float_type_p (ftype) || extended_float_type_p (type))
          ? /* "from a floating-point type T to another floating-point type
@@ -1055,7 +1055,7 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain,
        }
     }
   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
-          && TREE_CODE (type) == REAL_TYPE)
+          && SCALAR_FLOAT_TYPE_P (type))
     {
       ok = false;
       if (TREE_CODE (init) == INTEGER_CST)