c: use _P() defines from tree.h

gcc/c-family/ChangeLog:

	* c-ada-spec.cc (has_static_fields): Use _P() defines from tree.h.
	(dump_ada_declaration): Ditto.
	(dump_ada_structure): Ditto.
	* c-common.cc (unsafe_conversion_p): Ditto.
	(shorten_compare): Ditto.
	(pointer_int_sum): Ditto.
	(c_common_truthvalue_conversion): Ditto.
	(scalar_to_vector): Ditto.
	* c-common.h (gnu_vector_type_p): Ditto.
	* c-omp.cc (c_omp_depend_t_p): Ditto.
	(c_omp_split_clauses): Ditto.
	* c-ubsan.cc (ubsan_instrument_division): Ditto.
	* c-warn.cc (conversion_warning): Ditto.
	(warnings_for_convert_and_check): Ditto.

gcc/c/ChangeLog:

	* c-convert.cc (c_convert): Ditto.
	* c-decl.cc (merge_decls): Ditto.
	* c-parser.cc (c_parser_omp_clause_reduction): Ditto.
	(c_parser_omp_declare_reduction): Ditto.
	* c-typeck.cc (build_component_ref): Ditto.
	(convert_argument): Ditto.
	(pointer_diff): Ditto.
	(build_unary_op): Ditto.
	(build_c_cast): Ditto.
	(build_modify_expr): Ditto.
	(store_init_value): Ditto.
	(constexpr_init_fits_real_type): Ditto.
	(check_constexpr_init): Ditto.
	(c_finish_return): Ditto.
	(handle_omp_array_sections_1): Ditto.
	(c_finish_omp_clauses): Ditto.
	* gimple-parser.cc (c_finish_gimple_return): Ditto.

libcc1/ChangeLog:

	* libcc1plugin.cc (plugin_float_type): Ditto.
	* libcp1plugin.cc (plugin_reactivate_decl): Ditto.
	(plugin_get_float_type): Ditto.

diff --git a/gcc/c-family/c-ada-spec.cc b/gcc/c-family/c-ada-spec.cc
index b50b387756450f4abc89696cc4284704576fd906..050994d8416654e3074fc3e69f532fa86a94d558 100644 (file)
--- a/gcc/c-family/c-ada-spec.cc
+++ b/gcc/c-family/c-ada-spec.cc
@@ -1051,7 +1051,7 @@ has_static_fields (const_tree type)
     return false;
 
   for (tree fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
-    if (TREE_CODE (fld) == VAR_DECL && DECL_NAME (fld))
+    if (VAR_P (fld) && DECL_NAME (fld))
       return true;
 
   return false;
@@ -3244,7 +3244,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc)
       if (need_indent)
        INDENT (spc);
 
-      if ((TREE_CODE (t) == FIELD_DECL || TREE_CODE (t) == VAR_DECL)
+      if ((TREE_CODE (t) == FIELD_DECL || VAR_P (t))
          && DECL_NAME (t))
        check_type_name_conflict (buffer, t);
 
@@ -3462,7 +3462,7 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested,
   /* Print the static fields of the structure, if any.  */
   for (tree tmp = TYPE_FIELDS (node); tmp; tmp = TREE_CHAIN (tmp))
     {
-      if (TREE_CODE (tmp) == VAR_DECL && DECL_NAME (tmp))
+      if (VAR_P (tmp) && DECL_NAME (tmp))
        {
          if (need_semicolon)
            {

diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index 2b4c82facf7f95560f2d3b0aa50e8412f5809c5b..9c8eed5442a453c709527f7e114318b63591e748 100644 (file)
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -1483,7 +1483,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
 
       /* Warn for real constant that is not an exact integer converted
         to integer type.  */
-      if (TREE_CODE (expr_type) == REAL_TYPE
+      if (SCALAR_FLOAT_TYPE_P (expr_type)
          && TREE_CODE (type) == INTEGER_TYPE)
        {
          if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
@@ -1508,7 +1508,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
          else
            give_warning = UNSAFE_OTHER;
        }
-      else if (TREE_CODE (type) == REAL_TYPE)
+      else if (SCALAR_FLOAT_TYPE_P (type))
        {
          /* Warn for an integer constant that does not fit into real type.  */
          if (TREE_CODE (expr_type) == INTEGER_TYPE)
@@ -1519,7 +1519,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
            }
          /* Warn for a real constant that does not fit into a smaller
             real type.  */
-         else if (TREE_CODE (expr_type) == REAL_TYPE
+         else if (SCALAR_FLOAT_TYPE_P (expr_type)
                   && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
            {
              REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
@@ -1579,7 +1579,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
   else
     {
       /* Warn for real types converted to integer types.  */
-      if (TREE_CODE (expr_type) == REAL_TYPE
+      if (SCALAR_FLOAT_TYPE_P (expr_type)
          && TREE_CODE (type) == INTEGER_TYPE)
        give_warning = UNSAFE_REAL;
 
@@ -1651,7 +1651,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
         all the range of values of the integer type cannot be
         represented by the real type.  */
       else if (TREE_CODE (expr_type) == INTEGER_TYPE
-              && TREE_CODE (type) == REAL_TYPE)
+              && SCALAR_FLOAT_TYPE_P (type))
        {
          /* Don't warn about char y = 0xff; float x = (int) y;  */
          expr = get_unwidened (expr, 0);
@@ -1662,8 +1662,8 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
        }
 
       /* Warn for real types converted to smaller real types.  */
-      else if (TREE_CODE (expr_type) == REAL_TYPE
-              && TREE_CODE (type) == REAL_TYPE
+      else if (SCALAR_FLOAT_TYPE_P (expr_type)
+              && SCALAR_FLOAT_TYPE_P (type)
               && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
        give_warning = UNSAFE_REAL;
 
@@ -1677,13 +1677,13 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
          tree to_type = TREE_TYPE (type);
 
          /* Warn for real types converted to integer types.  */
-         if (TREE_CODE (from_type) == REAL_TYPE
+         if (SCALAR_FLOAT_TYPE_P (from_type)
              && TREE_CODE (to_type) == INTEGER_TYPE)
            give_warning = UNSAFE_REAL;
 
          /* Warn for real types converted to smaller real types.  */
-         else if (TREE_CODE (from_type) == REAL_TYPE
-                  && TREE_CODE (to_type) == REAL_TYPE
+         else if (SCALAR_FLOAT_TYPE_P (from_type)
+                  && SCALAR_FLOAT_TYPE_P (to_type)
                   && TYPE_PRECISION (to_type) < TYPE_PRECISION (from_type))
            give_warning = UNSAFE_REAL;
 
@@ -1706,7 +1706,7 @@ unsafe_conversion_p (tree type, tree expr, tree result, bool check_sign)
                give_warning = UNSAFE_SIGN;
            }
          else if (TREE_CODE (from_type) == INTEGER_TYPE
-                  && TREE_CODE (to_type) == REAL_TYPE
+                  && SCALAR_FLOAT_TYPE_P (to_type)
                   && !int_safely_convertible_to_real_p (from_type, to_type))
            give_warning = UNSAFE_OTHER;
        }
@@ -2951,8 +2951,8 @@ shorten_compare (location_t loc, tree *op0_ptr, tree *op1_ptr,
     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
 
   /* If one of the operands must be floated, we cannot optimize.  */
-  real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
-  real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
+  real1 = SCALAR_FLOAT_TYPE_P (TREE_TYPE (primop0));
+  real2 = SCALAR_FLOAT_TYPE_P (TREE_TYPE (primop1));
 
   /* If first arg is constant, swap the args (changing operation
      so value is preserved), for canonicalization.  Don't do this if
@@ -3283,7 +3283,7 @@ pointer_int_sum (location_t loc, enum tree_code resultcode,
   /* The result is a pointer of the same type that is being added.  */
   tree result_type = TREE_TYPE (ptrop);
 
-  if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
+  if (VOID_TYPE_P (TREE_TYPE (result_type)))
     {
       if (complain && warn_pointer_arith)
        pedwarn (loc, OPT_Wpointer_arith,
@@ -3730,7 +3730,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
       goto ret;
     }
 
-  if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
+  if (FIXED_POINT_TYPE_P (TREE_TYPE (expr)))
     {
       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
                                          FCONST0 (TYPE_MODE
@@ -8649,7 +8649,7 @@ scalar_to_vector (location_t loc, enum tree_code code, tree op0, tree op1,
          }
        else if (!integer_only_op
                    /* Allow integer --> real conversion if safe.  */
-                && (TREE_CODE (type0) == REAL_TYPE
+                && (SCALAR_FLOAT_TYPE_P (type0)
                     || TREE_CODE (type0) == INTEGER_TYPE)
                 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1)))
          {

diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index f96350b64af0ca59d1a125534a5b909e761c213c..336a09f4a407df949f89734dadcaf0ad0f5f6487 100644 (file)
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -790,7 +790,7 @@ extern bool override_libcpp_locations;
 inline bool
 gnu_vector_type_p (const_tree type)
 {
-  return TREE_CODE (type) == VECTOR_TYPE && !TYPE_INDIVISIBLE_P (type);
+  return VECTOR_TYPE_P (type) && !TYPE_INDIVISIBLE_P (type);
 }
 
 struct visibility_flags

diff --git a/gcc/c-family/c-omp.cc b/gcc/c-family/c-omp.cc
index f72ca4c6acd909bf964ce1c95ad89368d5ffd619..4faddb00bbcbea909ab4986214eb9aaec1212573 100644 (file)
--- a/gcc/c-family/c-omp.cc
+++ b/gcc/c-family/c-omp.cc
@@ -674,8 +674,7 @@ c_omp_depend_t_p (tree type)
          && ((TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
               ? DECL_NAME (TYPE_NAME (type)) : TYPE_NAME (type))
              == get_identifier ("omp_depend_t"))
-         && (!TYPE_CONTEXT (type)
-             || TREE_CODE (TYPE_CONTEXT (type)) == TRANSLATION_UNIT_DECL)
+         && TYPE_FILE_SCOPE_P (type)
          && COMPLETE_TYPE_P (type)
          && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
          && !compare_tree_int (TYPE_SIZE (type),
@@ -2672,7 +2671,7 @@ c_omp_split_clauses (location_t loc, enum tree_code code,
                      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 (&allocate_head, DECL_UID (t));

diff --git a/gcc/c-family/c-ubsan.cc b/gcc/c-family/c-ubsan.cc
index cfb7cbf389cac3c51a4811ee139a51079530aa62..51aa83a378d2b23e18e979f27201a22256ce7a04 100644 (file)
--- a/gcc/c-family/c-ubsan.cc
+++ b/gcc/c-family/c-ubsan.cc
@@ -57,7 +57,7 @@ ubsan_instrument_division (location_t loc, tree op0, tree op1)
       && sanitize_flags_p (SANITIZE_DIVIDE))
     t = fold_build2 (EQ_EXPR, boolean_type_node,
                     op1, build_int_cst (type, 0));
-  else if (TREE_CODE (type) == REAL_TYPE
+  else if (SCALAR_FLOAT_TYPE_P (type)
           && sanitize_flags_p (SANITIZE_FLOAT_DIVIDE))
     {
       t = fold_build2 (EQ_EXPR, boolean_type_node,

diff --git a/gcc/c-family/c-warn.cc b/gcc/c-family/c-warn.cc
index 9ac43a1af6ef5f9bc9c5bc2368a16a72588bed2c..d4d62c48b206fd7d7a5cdec1559768b6c4445fc9 100644 (file)
--- a/gcc/c-family/c-warn.cc
+++ b/gcc/c-family/c-warn.cc
@@ -1227,7 +1227,7 @@ conversion_warning (location_t loc, tree type, tree expr, tree result)
          {
            bool cstresult
              = (result
-                && TREE_CODE_CLASS (TREE_CODE (result)) == tcc_constant);
+                && CONSTANT_CLASS_P (result));
            if (TYPE_UNSIGNED (type))
              {
                if (cstresult)
@@ -1255,7 +1255,7 @@ conversion_warning (location_t loc, tree type, tree expr, tree result)
                              expr_type, type, expr);
              }
          }
-       else if (TREE_CODE_CLASS (TREE_CODE (result)) == tcc_constant)
+       else if (CONSTANT_CLASS_P (result))
          warning_at (loc, warnopt,
                      "conversion from %qT to %qT changes value from %qE to %qE",
                      expr_type, type, expr, result);
@@ -1404,7 +1404,7 @@ warnings_for_convert_and_check (location_t loc, tree type, tree expr,
   while (TREE_CODE (result) == COMPOUND_EXPR)
     result = TREE_OPERAND (result, 1);
 
-  bool cst = TREE_CODE_CLASS (TREE_CODE (result)) == tcc_constant;
+  bool cst = CONSTANT_CLASS_P (result);
   tree exprtype = TREE_TYPE (expr);
   tree result_diag;
   /* We're interested in the actual numerical value here, not its ASCII

diff --git a/gcc/c/c-convert.cc b/gcc/c/c-convert.cc
index 0f35dc4fe9a93bc14a5ba368c80de8f8e7e8d837..5754d00b30a67167ea6f65872fbaf7f135950778 100644 (file)
--- a/gcc/c/c-convert.cc
+++ b/gcc/c/c-convert.cc
@@ -99,7 +99,7 @@ c_convert (tree type, tree expr, bool init_const)
     return fold_convert_loc (loc, type, expr);
   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
     return error_mark_node;
-  if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
+  if (VOID_TYPE_P (TREE_TYPE (expr)))
     {
       error ("void value not ignored as it ought to be");
       return error_mark_node;
@@ -119,7 +119,7 @@ c_convert (tree type, tree expr, bool init_const)
     case INTEGER_TYPE:
       if (sanitize_flags_p (SANITIZE_FLOAT_CAST)
          && current_function_decl != NULL_TREE
-         && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
+         && SCALAR_FLOAT_TYPE_P (TREE_TYPE (expr))
          && COMPLETE_TYPE_P (type))
        {
          expr = save_expr (expr);

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index f8ede362bfd70324fd49a2fbdf70e42e5e6b1c84..945e45bff89ca9bc163d411f6b5da91e240af814 100644 (file)
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -2746,11 +2746,11 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
      system header. Otherwise, keep source location of definition rather than
      declaration and of prototype rather than non-prototype unless that
      prototype is built-in.  */
-  if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
+  if (HAS_DECL_ASSEMBLER_NAME_P (olddecl)
       && DECL_IN_SYSTEM_HEADER (olddecl)
       && !DECL_IN_SYSTEM_HEADER (newdecl) )
     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
-  else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
+  else if (HAS_DECL_ASSEMBLER_NAME_P (olddecl)
           && DECL_IN_SYSTEM_HEADER (newdecl)
           && !DECL_IN_SYSTEM_HEADER (olddecl))
     DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
@@ -2777,7 +2777,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
   if (VAR_P (olddecl) && C_DECL_THREADPRIVATE_P (olddecl))
     C_DECL_THREADPRIVATE_P (newdecl) = 1;
 
-  if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
+  if (HAS_DECL_ASSEMBLER_NAME_P (olddecl))
     {
       /* Copy the assembler name.
         Currently, it can only be defined in the prototype.  */

diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index c9f06930e3a0d8c8a9139782539a412c94a15842..11ac8653d5b9a2e49abed9b31b5a167a30972b7c 100644 (file)
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -15730,7 +15730,7 @@ c_parser_omp_clause_reduction (c_parser *parser, enum omp_clause_code kind,
                OMP_CLAUSE_REDUCTION_INSCAN (c) = 1;
              if (code == ERROR_MARK
                  || !(INTEGRAL_TYPE_P (type)
-                      || TREE_CODE (type) == REAL_TYPE
+                      || SCALAR_FLOAT_TYPE_P (type)
                       || TREE_CODE (type) == COMPLEX_TYPE))
                OMP_CLAUSE_REDUCTION_PLACEHOLDER (c)
                  = c_omp_reduction_lookup (reduc_id,
@@ -23293,7 +23293,7 @@ c_parser_omp_declare_reduction (c_parser *parser, enum pragma_context context)
          if (type == error_mark_node)
            ;
          else if ((INTEGRAL_TYPE_P (type)
-                   || TREE_CODE (type) == REAL_TYPE
+                   || SCALAR_FLOAT_TYPE_P (type)
                    || TREE_CODE (type) == COMPLEX_TYPE)
                   && orig_reduc_id == NULL_TREE)
            error_at (loc, "predeclared arithmetic type in "

diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index f619e2a67e7aec8cfd093b59acfc79b692b1b2c7..191a90ff65151c9d2aeaf902a305321e17a95fdd 100644 (file)
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -2662,7 +2662,7 @@ build_component_ref (location_t loc, tree datum, tree component,
       /* Special-case the error message for "ptr.field" for the case
         where the user has confused "." vs "->".  */
       rich_location richloc (line_table, loc);
-      if (TREE_CODE (datum) == INDIRECT_REF && arrow_loc != UNKNOWN_LOCATION)
+      if (INDIRECT_REF_P (datum) && arrow_loc != UNKNOWN_LOCATION)
        {
          richloc.add_fixit_insert_before (arrow_loc, "(*");
          richloc.add_fixit_insert_after (arrow_loc, ")");
@@ -3414,7 +3414,7 @@ convert_argument (location_t ploc, tree function, tree fundecl,
       unsigned int formal_prec = TYPE_PRECISION (type);
 
       if (INTEGRAL_TYPE_P (type)
-         && TREE_CODE (valtype) == REAL_TYPE)
+         && SCALAR_FLOAT_TYPE_P (valtype))
        warning_at (ploc, OPT_Wtraditional_conversion,
                    "passing argument %d of %qE as integer rather "
                    "than floating due to prototype",
@@ -3426,12 +3426,12 @@ convert_argument (location_t ploc, tree function, tree fundecl,
                    "than complex due to prototype",
                    argnum, rname);
       else if (TREE_CODE (type) == COMPLEX_TYPE
-              && TREE_CODE (valtype) == REAL_TYPE)
+              && SCALAR_FLOAT_TYPE_P (valtype))
        warning_at (ploc, OPT_Wtraditional_conversion,
                    "passing argument %d of %qE as complex rather "
                    "than floating due to prototype",
                    argnum, rname);
-      else if (TREE_CODE (type) == REAL_TYPE
+      else if (SCALAR_FLOAT_TYPE_P (type)
               && INTEGRAL_TYPE_P (valtype))
        warning_at (ploc, OPT_Wtraditional_conversion,
                    "passing argument %d of %qE as floating rather "
@@ -3443,7 +3443,7 @@ convert_argument (location_t ploc, tree function, tree fundecl,
                    "passing argument %d of %qE as complex rather "
                    "than integer due to prototype",
                    argnum, rname);
-      else if (TREE_CODE (type) == REAL_TYPE
+      else if (SCALAR_FLOAT_TYPE_P (type)
               && TREE_CODE (valtype) == COMPLEX_TYPE)
        warning_at (ploc, OPT_Wtraditional_conversion,
                    "passing argument %d of %qE as floating rather "
@@ -3452,8 +3452,8 @@ convert_argument (location_t ploc, tree function, tree fundecl,
       /* ??? At some point, messages should be written about
         conversions between complex types, but that's too messy
         to do now.  */
-      else if (TREE_CODE (type) == REAL_TYPE
-              && TREE_CODE (valtype) == REAL_TYPE)
+      else if (SCALAR_FLOAT_TYPE_P (type)
+              && SCALAR_FLOAT_TYPE_P (valtype))
        {
          /* Warn if any argument is passed as `float',
             since without a prototype it would be `double'.  */
@@ -4131,7 +4131,7 @@ pointer_diff (location_t loc, tree op0, tree op1, tree *instrument_expr)
   else
     inttype = restype;
 
-  if (TREE_CODE (target_type) == VOID_TYPE)
+  if (VOID_TYPE_P (target_type))
     pedwarn (loc, OPT_Wpointer_arith,
             "pointer of type %<void *%> used in subtraction");
   if (TREE_CODE (target_type) == FUNCTION_TYPE)
@@ -4828,7 +4828,7 @@ build_unary_op (location_t location, enum tree_code code, tree xarg,
                            TREE_TYPE (argtype));
              }
            else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
-                    || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
+                    || VOID_TYPE_P (TREE_TYPE (argtype)))
              {
                if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
                  pedwarn (location, OPT_Wpointer_arith,
@@ -6251,7 +6251,7 @@ build_c_cast (location_t loc, tree type, tree expr)
       /* Ignore any integer overflow caused by the cast.  */
       if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
        {
-         if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
+         if (TREE_OVERFLOW_P (ovalue))
            {
              if (!TREE_OVERFLOW (value))
                {
@@ -6477,7 +6477,7 @@ build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
   if (TREE_CODE (lhs) == COMPONENT_REF
       && (TREE_CODE (lhstype) == INTEGER_TYPE
          || TREE_CODE (lhstype) == BOOLEAN_TYPE
-         || TREE_CODE (lhstype) == REAL_TYPE
+         || SCALAR_FLOAT_TYPE_P (lhstype)
          || TREE_CODE (lhstype) == ENUMERAL_TYPE))
     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
 
@@ -7938,7 +7938,7 @@ store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
       /* Not fully determined before folding.  */
       arith_const_expr = true;
     }
-  bool constexpr_p = (TREE_CODE (decl) == VAR_DECL
+  bool constexpr_p = (VAR_P (decl)
                      && C_DECL_DECLARED_CONSTEXPR (decl));
   value = digest_init (init_loc, type, init, origtype, npc, int_const_expr,
                       arith_const_expr, true,
@@ -8119,7 +8119,7 @@ print_spelling (char *buffer)
 static bool
 constexpr_init_fits_real_type (tree type, tree init)
 {
-  gcc_assert (TREE_CODE (type) == REAL_TYPE);
+  gcc_assert (SCALAR_FLOAT_TYPE_P (type));
   gcc_assert (TREE_CODE (init) == INTEGER_CST || TREE_CODE (init) == REAL_CST);
   if (TREE_CODE (init) == REAL_CST
       && TYPE_MODE (TREE_TYPE (init)) == TYPE_MODE (type))
@@ -8226,14 +8226,14 @@ check_constexpr_init (location_t loc, tree type, tree init,
      compatible (not just the same mode); all quiet NaN and infinity
      initializations are considered to preserve the value.  */
   if (TREE_CODE (TREE_TYPE (init)) == COMPLEX_TYPE
-      && TREE_CODE (type) == REAL_TYPE)
+      && SCALAR_FLOAT_TYPE_P (type))
     {
       error_at (loc, "%<constexpr%> initializer for a real type is of "
                "complex type");
       return;
     }
-  if (TREE_CODE (type) == REAL_TYPE
-      && TREE_CODE (TREE_TYPE (init)) == REAL_TYPE
+  if (SCALAR_FLOAT_TYPE_P (type)
+      && SCALAR_FLOAT_TYPE_P (TREE_TYPE (init))
       && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (init))
       && !DECIMAL_FLOAT_TYPE_P (type))
     {
@@ -11313,7 +11313,7 @@ c_finish_return (location_t loc, tree retval, tree origtype)
                    "declared here");
        }
     }
-  else if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
+  else if (valtype == NULL_TREE || VOID_TYPE_P (valtype))
     {
       current_function_returns_null = 1;
       bool warned_here;
@@ -11345,7 +11345,7 @@ c_finish_return (location_t loc, tree retval, tree origtype)
       save = in_late_binary_op;
       if (C_BOOLEAN_TYPE_P (TREE_TYPE (res))
          || TREE_CODE (TREE_TYPE (res)) == COMPLEX_TYPE
-         || (TREE_CODE (TREE_TYPE (t)) == REAL_TYPE
+         || (SCALAR_FLOAT_TYPE_P (TREE_TYPE (t))
              && (TREE_CODE (TREE_TYPE (res)) == INTEGER_TYPE
                  || TREE_CODE (TREE_TYPE (res)) == ENUMERAL_TYPE)
              && sanitize_flags_p (SANITIZE_FLOAT_CAST)))
@@ -13668,7 +13668,7 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
                    t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
          return error_mark_node;
        }
-      while (TREE_CODE (t) == INDIRECT_REF)
+      while (INDIRECT_REF_P (t))
        {
          t = TREE_OPERAND (t, 0);
          STRIP_NOPS (t);
@@ -13702,7 +13702,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);
@@ -15402,7 +15402,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
                        {
                          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);
@@ -15479,7 +15479,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
               bias) to zero here, so it is not set erroneously to the pointer
               size later on in gimplify.cc.  */
            OMP_CLAUSE_SIZE (c) = size_zero_node;
-         while (TREE_CODE (t) == INDIRECT_REF
+         while (INDIRECT_REF_P (t)
                 || TREE_CODE (t) == ARRAY_REF)
            {
              t = TREE_OPERAND (t, 0);
@@ -15495,7 +15495,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
          indir_component_ref_p = false;
          if (TREE_CODE (t) == COMPONENT_REF
              && (TREE_CODE (TREE_OPERAND (t, 0)) == MEM_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);
@@ -15550,7 +15550,7 @@ c_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);
@@ -16094,7 +16094,7 @@ c_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));
@@ -16131,7 +16131,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
          {
            tree 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)

diff --git a/gcc/c/gimple-parser.cc b/gcc/c/gimple-parser.cc
index 5423a790cc00601935fe3f3eece854eb296ae33c..cc3a8899d97ed6b50fd605a5ad16913d0a28b458 100644 (file)
--- a/gcc/c/gimple-parser.cc
+++ b/gcc/c/gimple-parser.cc
@@ -2472,7 +2472,7 @@ c_finish_gimple_return (location_t loc, tree retval)
 
   if (! retval)
     current_function_returns_null = 1;
-  else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
+  else if (valtype == 0 || VOID_TYPE_P (valtype))
     {
       current_function_returns_null = 1;
       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)

diff --git a/libcc1/libcc1plugin.cc b/libcc1/libcc1plugin.cc
index 7e0fecae14562d1ffdc9b68d5ffda16f7c215ad9..283eaf206850c6505127a92a1138092d1e320ab0 100644 (file)
--- a/libcc1/libcc1plugin.cc
+++ b/libcc1/libcc1plugin.cc
@@ -632,7 +632,7 @@ plugin_float_type (cc1_plugin::connection *self,
   if (!result)
     return convert_out (error_mark_node);
 
-  gcc_assert (TREE_CODE (result) == REAL_TYPE);
+  gcc_assert (SCALAR_FLOAT_TYPE_P (result));
   gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result));
 
   return convert_out (result);

diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc
index 8d394c0cfdb804ae81619d91f42b9be6b5a97648..3c8e9e8b436713ea3bf0151f9acb742123d7c0d7 100644 (file)
--- a/libcc1/libcp1plugin.cc
+++ b/libcc1/libcp1plugin.cc
@@ -713,7 +713,7 @@ plugin_reactivate_decl (cc1_plugin::connection *,
 {
   tree decl = convert_in (decl_in);
   tree scope = convert_in (scope_in);
-  gcc_assert (TREE_CODE (decl) == VAR_DECL
+  gcc_assert (VAR_P (decl)
              || TREE_CODE (decl) == FUNCTION_DECL
              || TREE_CODE (decl) == TYPE_DECL);
   cp_binding_level *b;
@@ -3296,7 +3296,7 @@ plugin_get_float_type (cc1_plugin::connection *,
       if (!result)
        return convert_out (error_mark_node);
 
-      gcc_assert (TREE_CODE (result) == REAL_TYPE);
+      gcc_assert (SCALAR_FLOAT_TYPE_P (result));
       gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result));
 
       return convert_out (result);