From: Bernhard Reutner-Fischer <al...@gcc.gnu.org>
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.
---
gcc/cp/call.cc | 42 +++++++++++++++++++-------------------
gcc/cp/class.cc | 2 +-
gcc/cp/coroutines.cc | 2 +-
gcc/cp/cp-tree.h | 4 ++--
gcc/cp/cvt.cc | 2 +-
gcc/cp/cxx-pretty-print.cc | 2 +-
gcc/cp/decl.cc | 4 ++--
gcc/cp/error.cc | 2 +-
gcc/cp/lambda.cc | 2 +-
gcc/cp/mangle.cc | 2 +-
gcc/cp/method.cc | 2 +-
gcc/cp/module.cc | 12 +++++------
gcc/cp/name-lookup.cc | 6 +++---
gcc/cp/pt.cc | 2 +-
gcc/cp/semantics.cc | 24 +++++++++++-----------
gcc/cp/tree.cc | 4 ++--
gcc/cp/typeck.cc | 4 ++--
gcc/cp/typeck2.cc | 10 ++++-----
18 files changed, 64 insertions(+), 64 deletions(-)
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 2a06520c0c1..6e13d17f6b8 100644
--- 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),
@@ -8976,7 +8976,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))
@@ -9798,7 +9798,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);
@@ -10462,7 +10462,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);
@@ -12199,7 +12199,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.
@@ -12207,15 +12207,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
@@ -12242,7 +12242,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 68b62086340..bc84f4f731a 100644
--- 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 59a240ebd40..3493d3c6ed3 100644
--- 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 714b6d55f4f..a1b882f11fe 100644
--- 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 17827d06a4a..c6b52f07050 100644
--- 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 4b547c77ef4..909a9dc917f 100644
--- 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 23a2b2fef0b..a672e4844f1 100644
--- 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 9b967ce409d..31319aa9e87 100644
--- 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 9925209b2ed..a359bc6ee8d 100644
--- 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 a235f23459d..826c5e76c1d 100644
--- 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 00eae56eb5b..cbcc7948b37 100644
--- 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 ac2fe66b080..ecde98d69b4 100644
--- 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 ad03141df43..eb5c333b5ea 100644
--- 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 696df2bdd9f..16d658e3c6a 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -7487,7 +7487,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 13c6582b628..05df6282302 100644
--- 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 131b212ff73..19dfb3ed782 100644
--- 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 53ac925a092..a4ceb8a1703 100644
--- 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 bf03967a71f..6affdc73fb1 100644
--- a/gcc/cp/typeck2.cc
+++ b/gcc/cp/typeck2.cc
@@ -907,7 +907,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
@@ -974,7 +974,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))
@@ -992,8 +992,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
@@ -1030,7 +1030,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)
--
2.30.2
