From: Bernhard Reutner-Fischer <al...@gcc.gnu.org>
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.
---
gcc/c-family/c-ada-spec.cc | 6 ++---
gcc/c-family/c-common.cc | 32 +++++++++++------------
gcc/c-family/c-common.h | 2 +-
gcc/c-family/c-omp.cc | 5 ++--
gcc/c-family/c-ubsan.cc | 2 +-
gcc/c-family/c-warn.cc | 6 ++---
gcc/c/c-convert.cc | 4 +--
gcc/c/c-decl.cc | 6 ++---
gcc/c/c-parser.cc | 4 +--
gcc/c/c-typeck.cc | 52 +++++++++++++++++++-------------------
gcc/c/gimple-parser.cc | 2 +-
libcc1/libcc1plugin.cc | 2 +-
libcc1/libcp1plugin.cc | 4 +--
13 files changed, 63 insertions(+), 64 deletions(-)
diff --git a/gcc/c-family/c-ada-spec.cc b/gcc/c-family/c-ada-spec.cc
index b50b3877564..050994d8416 100644
--- 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 2b4c82facf7..9c8eed5442a 100644
--- 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 f96350b64af..336a09f4a40 100644
--- 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 f72ca4c6acd..4faddb00bbc 100644
--- 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 cfb7cbf389c..51aa83a378d 100644
--- 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 9ac43a1af6e..d4d62c48b20 100644
--- 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 0f35dc4fe9a..5754d00b30a 100644
--- 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 1b53f2d0785..e378d461127 100644
--- 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 c9f06930e3a..11ac8653d5b 100644
--- 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 f619e2a67e7..191a90ff651 100644
--- 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 5423a790cc0..cc3a8899d97 100644
--- 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 7e0fecae145..283eaf20685 100644
--- 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 8d394c0cfdb..3c8e9e8b436 100644
--- 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);
--
2.30.2
