gcc: use _P() defines from tree.h

gcc/ChangeLog:

	* alias.cc (ref_all_alias_ptr_type_p): Use _P() defines from tree.h.
	* attribs.cc (diag_attr_exclusions): Ditto.
	(decl_attributes): Ditto.
	(build_type_attribute_qual_variant): Ditto.
	* builtins.cc (fold_builtin_carg): Ditto.
	(fold_builtin_next_arg): Ditto.
	(do_mpc_arg2): Ditto.
	* cfgexpand.cc (expand_return): Ditto.
	* cgraph.h (decl_in_symtab_p): Ditto.
	(symtab_node::get_create): Ditto.
	* dwarf2out.cc (base_type_die): Ditto.
	(implicit_ptr_descriptor): Ditto.
	(gen_array_type_die): Ditto.
	(gen_type_die_with_usage): Ditto.
	(optimize_location_into_implicit_ptr): Ditto.
	* expr.cc (do_store_flag): Ditto.
	* fold-const.cc (negate_expr_p): Ditto.
	(fold_negate_expr_1): Ditto.
	(fold_convert_const): Ditto.
	(fold_convert_loc): Ditto.
	(constant_boolean_node): Ditto.
	(fold_binary_op_with_conditional_arg): Ditto.
	(build_fold_addr_expr_with_type_loc): Ditto.
	(fold_comparison): Ditto.
	(fold_checksum_tree): Ditto.
	(tree_unary_nonnegative_warnv_p): Ditto.
	(integer_valued_real_unary_p): Ditto.
	(fold_read_from_constant_string): Ditto.
	* gcc-rich-location.cc (maybe_range_label_for_tree_type_mismatch::get_text): Ditto.
	* gimple-expr.cc (useless_type_conversion_p): Ditto.
	(is_gimple_reg): Ditto.
	(is_gimple_asm_val): Ditto.
	(mark_addressable): Ditto.
	* gimple-expr.h (is_gimple_variable): Ditto.
	(virtual_operand_p): Ditto.
	* gimple-ssa-warn-access.cc (pass_waccess::check_dangling_stores): Ditto.
	* gimplify.cc (gimplify_bind_expr): Ditto.
	(gimplify_return_expr): Ditto.
	(gimple_add_padding_init_for_auto_var): Ditto.
	(gimplify_addr_expr): Ditto.
	(omp_add_variable): Ditto.
	(omp_notice_variable): Ditto.
	(omp_get_base_pointer): Ditto.
	(omp_strip_components_and_deref): Ditto.
	(omp_strip_indirections): Ditto.
	(omp_accumulate_sibling_list): Ditto.
	(omp_build_struct_sibling_lists): Ditto.
	(gimplify_adjust_omp_clauses_1): Ditto.
	(gimplify_adjust_omp_clauses): Ditto.
	(gimplify_omp_for): Ditto.
	(goa_lhs_expr_p): Ditto.
	(gimplify_one_sizepos): Ditto.
	* graphite-scop-detection.cc (scop_detection::graphite_can_represent_scev): Ditto.
	* ipa-devirt.cc (odr_types_equivalent_p): Ditto.
	* ipa-prop.cc (ipa_set_jf_constant): Ditto.
	(propagate_controlled_uses): Ditto.
	* ipa-sra.cc (type_prevails_p): Ditto.
	(scan_expr_access): Ditto.
	* optabs-tree.cc (optab_for_tree_code): Ditto.
	* toplev.cc (wrapup_global_declaration_1): Ditto.
	* trans-mem.cc (transaction_invariant_address_p): Ditto.
	* tree-cfg.cc (verify_types_in_gimple_reference): Ditto.
	(verify_gimple_comparison): Ditto.
	(verify_gimple_assign_binary): Ditto.
	(verify_gimple_assign_single): Ditto.
	* tree-complex.cc (get_component_ssa_name): Ditto.
	* tree-emutls.cc (lower_emutls_2): Ditto.
	* tree-inline.cc (copy_tree_body_r): Ditto.
	(estimate_move_cost): Ditto.
	(copy_decl_for_dup_finish): Ditto.
	* tree-nested.cc (convert_nonlocal_omp_clauses): Ditto.
	(note_nonlocal_vla_type): Ditto.
	(convert_local_omp_clauses): Ditto.
	(remap_vla_decls): Ditto.
	(fixup_vla_decls): Ditto.
	* tree-parloops.cc (loop_has_vector_phi_nodes): Ditto.
	* tree-pretty-print.cc (print_declaration): Ditto.
	(print_call_name): Ditto.
	* tree-sra.cc (compare_access_positions): Ditto.
	* tree-ssa-alias.cc (compare_type_sizes): Ditto.
	* tree-ssa-ccp.cc (get_default_value): Ditto.
	* tree-ssa-coalesce.cc (populate_coalesce_list_for_outofssa): Ditto.
	* tree-ssa-dom.cc (reduce_vector_comparison_to_scalar_comparison): Ditto.
	* tree-ssa-forwprop.cc (can_propagate_from): Ditto.
	* tree-ssa-propagate.cc (may_propagate_copy): Ditto.
	* tree-ssa-sccvn.cc (fully_constant_vn_reference_p): Ditto.
	* tree-ssa-sink.cc (statement_sink_location): Ditto.
	* tree-ssa-structalias.cc (type_must_have_pointers): Ditto.
	* tree-ssa-ter.cc (find_replaceable_in_bb): Ditto.
	* tree-ssa-uninit.cc (warn_uninit): Ditto.
	* tree-ssa.cc (maybe_rewrite_mem_ref_base): Ditto.
	(non_rewritable_mem_ref_base): Ditto.
	* tree-streamer-in.cc (lto_input_ts_type_non_common_tree_pointers): Ditto.
	* tree-streamer-out.cc (write_ts_type_non_common_tree_pointers): Ditto.
	* tree-vect-generic.cc (do_binop): Ditto.
	(do_cond): Ditto.
	* tree-vect-stmts.cc (vect_init_vector): Ditto.
	* tree-vector-builder.h (tree_vector_builder::note_representative): Ditto.
	* tree.cc (sign_mask_for): Ditto.
	(verify_type_variant): Ditto.
	(gimple_canonical_types_compatible_p): Ditto.
	(verify_type): Ditto.
	* ubsan.cc (get_ubsan_type_info_for_type): Ditto.
	* var-tracking.cc (prepare_call_arguments): Ditto.
	(vt_add_function_parameters): Ditto.
	* varasm.cc (decode_addr_const): Ditto.

49 files changed, 167 insertions, 183 deletions

diff --git a/gcc/alias.cc b/gcc/alias.cc
index 3672bf2..7dc7e06 100644
--- a/gcc/alias.cc
+++ b/gcc/alias.cc
@@ -699,7 +699,7 @@ component_uses_parent_alias_set_from (const_tree t)
 static bool
 ref_all_alias_ptr_type_p (const_tree t)
 {
-  return (TREE_CODE (TREE_TYPE (t)) == VOID_TYPE
+  return (VOID_TYPE_P (TREE_TYPE (t))
 	  || TYPE_REF_CAN_ALIAS_ALL (t));
 }
 
diff --git a/gcc/attribs.cc b/gcc/attribs.cc
index b130001..b8cb55b 100644
--- a/gcc/attribs.cc
+++ b/gcc/attribs.cc
@@ -526,7 +526,7 @@ diag_attr_exclusions (tree last_decl, tree node, tree attrname,
 	    continue;
 
 	  if ((TREE_CODE (node) == FIELD_DECL
-	       || TREE_CODE (node) == VAR_DECL)
+	       || VAR_P (node))
 	      && !excl->variable)
 	    continue;
 
@@ -783,8 +783,7 @@ decl_attributes (tree *node, tree attributes, int flags,
 	  && TREE_CODE (*anode) != METHOD_TYPE)
 	{
 	  if (TREE_CODE (*anode) == POINTER_TYPE
-	      && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
-		  || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
+	      && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (*anode)))
 	    {
 	      /* OK, this is a bit convoluted.  We can't just make a copy
 		 of the pointer type and modify its TREE_TYPE, because if
@@ -820,7 +819,7 @@ decl_attributes (tree *node, tree attributes, int flags,
 
       if (TYPE_P (*anode)
 	  && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
-	  && TYPE_SIZE (*anode) != NULL_TREE)
+	  && COMPLETE_TYPE_P (*anode))
 	{
 	  warning (OPT_Wattributes, "type attributes ignored after type is already defined");
 	  continue;
@@ -1278,9 +1277,7 @@ build_type_attribute_qual_variant (tree otype, tree attribute, int quals)
 	 build_duplicate_type is another solution (as used in
 	 handle_transparent_union_attribute), but that doesn't play well
 	 with the stronger C++ type identity model.  */
-      if (TREE_CODE (ttype) == RECORD_TYPE
-	  || TREE_CODE (ttype) == UNION_TYPE
-	  || TREE_CODE (ttype) == QUAL_UNION_TYPE
+      if (RECORD_OR_UNION_TYPE_P (ttype)
 	  || TREE_CODE (ttype) == ENUMERAL_TYPE)
 	{
 	  warning (OPT_Wattributes,
diff --git a/gcc/builtins.cc b/gcc/builtins.cc
index c21c468..8400ada 100644
--- a/gcc/builtins.cc
+++ b/gcc/builtins.cc
@@ -8937,7 +8937,7 @@ static tree
 fold_builtin_carg (location_t loc, tree arg, tree type)
 {
   if (validate_arg (arg, COMPLEX_TYPE)
-      && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
+      && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg))))
     {
       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
 
@@ -10445,7 +10445,7 @@ fold_builtin_next_arg (tree exp, bool va_start_p)
 	 We must also strip off INDIRECT_EXPR for C++ reference
 	 parameters.  */
       while (CONVERT_EXPR_P (arg)
-	     || TREE_CODE (arg) == INDIRECT_REF)
+	     || INDIRECT_REF_P (arg))
 	arg = TREE_OPERAND (arg, 0);
       if (arg != last_parm)
 	{
@@ -11133,9 +11133,9 @@ do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
   /* To proceed, MPFR must exactly represent the target floating point
      format, which only happens when the target base equals two.  */
   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
-      && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
+      && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg0)))
       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
-      && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
+      && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TREE_TYPE (arg1)))
       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
     {
       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc
index 1a1b26b..85a93a5 100644
--- a/gcc/cfgexpand.cc
+++ b/gcc/cfgexpand.cc
@@ -3753,7 +3753,7 @@ expand_return (tree retval)
   tree retval_rhs;
 
   /* If function wants no value, give it none.  */
-  if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
+  if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
     {
       expand_normal (retval);
       expand_null_return ();
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index f5f5476..cedaaac 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -2650,7 +2650,7 @@ inline bool
 decl_in_symtab_p (const_tree decl)
 {
   return (TREE_CODE (decl) == FUNCTION_DECL
-          || (TREE_CODE (decl) == VAR_DECL
+	  || (VAR_P (decl)
 	      && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
 }
 
@@ -3359,7 +3359,7 @@ cgraph_node::optimize_for_size_p (void)
 inline symtab_node *
 symtab_node::get_create (tree node)
 {
-  if (TREE_CODE (node) == VAR_DECL)
+  if (VAR_P (node))
     return varpool_node::get_create (node);
   else
     return cgraph_node::get_create (node);
diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc
index 1a0015c..d89ffa6 100644
--- a/gcc/dwarf2out.cc
+++ b/gcc/dwarf2out.cc
@@ -13287,7 +13287,7 @@ base_type_die (tree type, bool reverse)
       /* Dwarf2 doesn't know anything about complex ints, so use
 	 a user defined type for it.  */
     case COMPLEX_TYPE:
-      if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
+      if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (type)))
 	encoding = DW_ATE_complex_float;
       else
 	encoding = DW_ATE_lo_user;
@@ -17079,7 +17079,7 @@ implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
 
   if (dwarf_strict && dwarf_version < 5)
     return NULL;
-  gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
+  gcc_assert (VAR_P (DEBUG_IMPLICIT_PTR_DECL (rtl))
 	      || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
 	      || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
   ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
@@ -22499,7 +22499,7 @@ gen_array_type_die (tree type, dw_die_ref context_die)
 	  size = int_size_in_bytes (TREE_TYPE (szdecl));
 	  if (!DECL_P (szdecl))
 	    {
-	      if (TREE_CODE (szdecl) == INDIRECT_REF
+	      if (INDIRECT_REF_P (szdecl)
 		  && DECL_P (TREE_OPERAND (szdecl, 0)))
 		{
 		  rszdecl = TREE_OPERAND (szdecl, 0);
@@ -22533,7 +22533,7 @@ gen_array_type_die (tree type, dw_die_ref context_die)
   add_name_attribute (array_die, type_tag (type));
   equate_type_number_to_die (type, array_die);
 
-  if (TREE_CODE (type) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (type))
     add_AT_flag (array_die, DW_AT_GNU_vector, 1);
 
   /* For Fortran multidimensional arrays use DW_ORD_col_major ordering.  */
@@ -22554,7 +22554,7 @@ gen_array_type_die (tree type, dw_die_ref context_die)
   add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
 #endif
 
-  if (TREE_CODE (type) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (type))
     {
       /* For VECTOR_TYPEs we use an array DIE with appropriate bounds.  */
       dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
@@ -26238,8 +26238,7 @@ gen_type_die_with_usage (tree type, dw_die_ref context_die,
      now.  (Vectors and arrays are special because the debugging info is in the
      cloned type itself.  Similarly function/method types can contain extra
      ref-qualification).  */
-  if (TREE_CODE (type) == FUNCTION_TYPE
-      || TREE_CODE (type) == METHOD_TYPE)
+  if (FUNC_OR_METHOD_TYPE_P (type))
     {
       /* For function/method types, can't use type_main_variant here,
 	 because that can have different ref-qualifiers for C++,
@@ -30976,7 +30975,7 @@ optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
     return;
   if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST
        && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0)))
-      || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL
+      || (VAR_P (TREE_OPERAND (init, 0))
 	  && !DECL_EXTERNAL (TREE_OPERAND (init, 0))
 	  && TREE_OPERAND (init, 0) != decl))
     {
diff --git a/gcc/expr.cc b/gcc/expr.cc
index 758dda9..5ede094 100644
--- a/gcc/expr.cc
+++ b/gcc/expr.cc
@@ -12956,7 +12956,7 @@ do_store_flag (sepops ops, rtx target, machine_mode mode)
 
   /* For vector typed comparisons emit code to generate the desired
      all-ones or all-zeros mask.  */
-  if (TREE_CODE (ops->type) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (ops->type))
     {
       tree ifexp = build2 (ops->code, ops->type, arg0, arg1);
       if (VECTOR_BOOLEAN_TYPE_P (ops->type)
diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
index db54bfc..a73b972 100644
--- a/gcc/fold-const.cc
+++ b/gcc/fold-const.cc
@@ -573,7 +573,7 @@ negate_expr_p (tree t)
 
     case NOP_EXPR:
       /* Negate -((double)float) as (double)(-float).  */
-      if (TREE_CODE (type) == REAL_TYPE)
+      if (SCALAR_FLOAT_TYPE_P (type))
 	{
 	  tree tem = strip_float_extensions (t);
 	  if (tem != t)
@@ -759,7 +759,7 @@ fold_negate_expr_1 (location_t loc, tree t)
 
     case NOP_EXPR:
       /* Convert -((double)float) into (double)(-float).  */
-      if (TREE_CODE (type) == REAL_TYPE)
+      if (SCALAR_FLOAT_TYPE_P (type))
 	{
 	  tem = strip_float_extensions (t);
 	  if (tem != t && negate_expr_p (tem))
@@ -2385,7 +2385,7 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
       else if (TREE_CODE (arg1) == FIXED_CST)
 	return fold_convert_const_int_from_fixed (type, arg1);
     }
-  else if (TREE_CODE (type) == REAL_TYPE)
+  else if (SCALAR_FLOAT_TYPE_P (type))
     {
       if (TREE_CODE (arg1) == INTEGER_CST)
 	{
@@ -2407,7 +2407,7 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
       else if (TREE_CODE (arg1) == FIXED_CST)
 	return fold_convert_const_real_from_fixed (type, arg1);
     }
-  else if (TREE_CODE (type) == FIXED_POINT_TYPE)
+  else if (FIXED_POINT_TYPE_P (type))
     {
       if (TREE_CODE (arg1) == FIXED_CST)
 	return fold_convert_const_fixed_from_fixed (type, arg1);
@@ -2416,7 +2416,7 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
       else if (TREE_CODE (arg1) == REAL_CST)
 	return fold_convert_const_fixed_from_real (type, arg1);
     }
-  else if (TREE_CODE (type) == VECTOR_TYPE)
+  else if (VECTOR_TYPE_P (type))
     {
       if (TREE_CODE (arg1) == VECTOR_CST
 	  && known_eq (TYPE_VECTOR_SUBPARTS (type), VECTOR_CST_NELTS (arg1)))
@@ -2545,7 +2545,7 @@ fold_convert_loc (location_t loc, tree type, tree arg)
 	return fold_convert_loc (loc, type,
 				 fold_build1_loc (loc, REALPART_EXPR,
 						  TREE_TYPE (orig), arg));
-      gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
+      gcc_assert (VECTOR_TYPE_P (orig)
 		  && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
       return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
 
@@ -2658,7 +2658,7 @@ fold_convert_loc (location_t loc, tree type, tree arg)
 	return build_zero_vector (type);
       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
-		  || TREE_CODE (orig) == VECTOR_TYPE);
+		  || VECTOR_TYPE_P (orig));
       return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
 
     case VOID_TYPE:
@@ -7184,7 +7184,7 @@ constant_boolean_node (bool value, tree type)
     return value ? integer_one_node : integer_zero_node;
   else if (type == boolean_type_node)
     return value ? boolean_true_node : boolean_false_node;
-  else if (TREE_CODE (type) == VECTOR_TYPE)
+  else if (VECTOR_TYPE_P (type))
     return build_vector_from_val (type,
 				  build_int_cst (TREE_TYPE (type),
 						 value ? -1 : 0));
@@ -7237,7 +7237,7 @@ fold_binary_op_with_conditional_arg (location_t loc,
 	rhs = false_value;
     }
   else if (!(TREE_CODE (type) != VECTOR_TYPE
-	     && TREE_CODE (TREE_TYPE (cond)) == VECTOR_TYPE))
+	     && VECTOR_TYPE_P (TREE_TYPE (cond))))
     {
       tree testtype = TREE_TYPE (cond);
       test = cond;
@@ -7248,7 +7248,7 @@ fold_binary_op_with_conditional_arg (location_t loc,
     /* Detect the case of mixing vector and scalar types - bail out.  */
     return NULL_TREE;
 
-  if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (TREE_TYPE (test)))
     cond_code = VEC_COND_EXPR;
 
   /* This transformation is only worthwhile if we don't have to wrap ARG
@@ -9289,7 +9289,7 @@ build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
   if (TREE_CODE (t) == WITH_SIZE_EXPR)
     t = TREE_OPERAND (t, 0);
 
-  if (TREE_CODE (t) == INDIRECT_REF)
+  if (INDIRECT_REF_P (t))
     {
       t = TREE_OPERAND (t, 0);
 
@@ -10137,7 +10137,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
 	    = get_inner_reference (TREE_OPERAND (arg0, 0),
 				   &bitsize, &bitpos0, &offset0, &mode,
 				   &unsignedp, &reversep, &volatilep);
-	  if (TREE_CODE (base0) == INDIRECT_REF)
+	  if (INDIRECT_REF_P (base0))
 	    base0 = TREE_OPERAND (base0, 0);
 	  else
 	    indirect_base0 = true;
@@ -10152,7 +10152,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
 		= get_inner_reference (TREE_OPERAND (base0, 0),
 				       &bitsize, &bitpos0, &offset0, &mode,
 				       &unsignedp, &reversep, &volatilep);
-	      if (TREE_CODE (base0) == INDIRECT_REF)
+	      if (INDIRECT_REF_P (base0))
 		base0 = TREE_OPERAND (base0, 0);
 	      else
 		indirect_base0 = true;
@@ -10180,7 +10180,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
 	    = get_inner_reference (TREE_OPERAND (arg1, 0),
 				   &bitsize, &bitpos1, &offset1, &mode,
 				   &unsignedp, &reversep, &volatilep);
-	  if (TREE_CODE (base1) == INDIRECT_REF)
+	  if (INDIRECT_REF_P (base1))
 	    base1 = TREE_OPERAND (base1, 0);
 	  else
 	    indirect_base1 = true;
@@ -10195,7 +10195,7 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
 		= get_inner_reference (TREE_OPERAND (base1, 0),
 				       &bitsize, &bitpos1, &offset1, &mode,
 				       &unsignedp, &reversep, &volatilep);
-	      if (TREE_CODE (base1) == INDIRECT_REF)
+	      if (INDIRECT_REF_P (base1))
 		base1 = TREE_OPERAND (base1, 0);
 	      else
 		indirect_base1 = true;
@@ -13763,9 +13763,7 @@ fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
 	  fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
 	}
       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
-      if (TREE_CODE (expr) == RECORD_TYPE
-	  || TREE_CODE (expr) == UNION_TYPE
-	  || TREE_CODE (expr) == QUAL_UNION_TYPE)
+      if (RECORD_OR_UNION_TYPE_P (expr))
 	fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
       break;
@@ -14665,9 +14663,9 @@ tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
 	tree inner_type = TREE_TYPE (op0);
 	tree outer_type = type;
 
-	if (TREE_CODE (outer_type) == REAL_TYPE)
+	if (SCALAR_FLOAT_TYPE_P (outer_type))
 	  {
-	    if (TREE_CODE (inner_type) == REAL_TYPE)
+	    if (SCALAR_FLOAT_TYPE_P (inner_type))
 	      return RECURSE (op0);
 	    if (INTEGRAL_TYPE_P (inner_type))
 	      {
@@ -14678,7 +14676,7 @@ tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
 	  }
 	else if (INTEGRAL_TYPE_P (outer_type))
 	  {
-	    if (TREE_CODE (inner_type) == REAL_TYPE)
+	    if (SCALAR_FLOAT_TYPE_P (inner_type))
 	      return RECURSE (op0);
 	    if (INTEGRAL_TYPE_P (inner_type))
 	      return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
@@ -15442,7 +15440,7 @@ integer_valued_real_unary_p (tree_code code, tree op0, int depth)
 	tree type = TREE_TYPE (op0);
 	if (TREE_CODE (type) == INTEGER_TYPE)
 	  return true;
-	if (TREE_CODE (type) == REAL_TYPE)
+	if (SCALAR_FLOAT_TYPE_P (type))
 	  return RECURSE (op0);
 	break;
       }
@@ -15673,7 +15671,7 @@ fold_unary_to_constant (enum tree_code code, tree type, tree op0)
 tree
 fold_read_from_constant_string (tree exp)
 {
-  if ((TREE_CODE (exp) == INDIRECT_REF
+  if ((INDIRECT_REF_P (exp)
        || TREE_CODE (exp) == ARRAY_REF)
       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
     {
@@ -15682,7 +15680,7 @@ fold_read_from_constant_string (tree exp)
       tree string;
       location_t loc = EXPR_LOCATION (exp);
 
-      if (TREE_CODE (exp) == INDIRECT_REF)
+      if (INDIRECT_REF_P (exp))
 	string = string_constant (exp1, &index, NULL, NULL);
       else
 	{
diff --git a/gcc/gcc-rich-location.cc b/gcc/gcc-rich-location.cc
index d02a514..edecf07 100644
--- a/gcc/gcc-rich-location.cc
+++ b/gcc/gcc-rich-location.cc
@@ -200,7 +200,7 @@ maybe_range_label_for_tree_type_mismatch::get_text (unsigned range_idx) const
   tree expr_type = TREE_TYPE (m_expr);
 
   tree other_type = NULL_TREE;
-  if (m_other_expr && EXPR_P (m_other_expr))
+  if (CAN_HAVE_LOCATION_P (m_other_expr))
     other_type = TREE_TYPE (m_other_expr);
 
   range_label_for_type_mismatch inner (expr_type, other_type);
diff --git a/gcc/gimple-expr.cc b/gcc/gimple-expr.cc
index 83dc340..f15cc0ba 100644
--- a/gcc/gimple-expr.cc
+++ b/gcc/gimple-expr.cc
@@ -76,10 +76,8 @@ useless_type_conversion_p (tree outer_type, tree inner_type)
 	  != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
 	return false;
       /* Do not lose casts to function pointer types.  */
-      if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
-	   || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
-	  && !(TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE
-	       || TREE_CODE (TREE_TYPE (inner_type)) == METHOD_TYPE))
+      if (FUNC_OR_METHOD_TYPE_P (TREE_TYPE (outer_type))
+	  && !FUNC_OR_METHOD_TYPE_P (TREE_TYPE (inner_type)))
 	return false;
     }
 
@@ -147,8 +145,8 @@ useless_type_conversion_p (tree outer_type, tree inner_type)
 				      TREE_TYPE (inner_type));
 
   /* Recurse for vector types with the same number of subparts.  */
-  else if (TREE_CODE (inner_type) == VECTOR_TYPE
-	   && TREE_CODE (outer_type) == VECTOR_TYPE)
+  else if (VECTOR_TYPE_P (inner_type)
+	   && VECTOR_TYPE_P (outer_type))
     return (known_eq (TYPE_VECTOR_SUBPARTS (inner_type),
 		      TYPE_VECTOR_SUBPARTS (outer_type))
 	    && useless_type_conversion_p (TREE_TYPE (outer_type),
@@ -223,8 +221,7 @@ useless_type_conversion_p (tree outer_type, tree inner_type)
 					TREE_TYPE (inner_type));
     }
 
-  else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
-	    || TREE_CODE (inner_type) == METHOD_TYPE)
+  else if (FUNC_OR_METHOD_TYPE_P (inner_type)
 	   && TREE_CODE (inner_type) == TREE_CODE (outer_type))
     {
       tree outer_parm, inner_parm;
@@ -819,7 +816,7 @@ is_gimple_reg (tree t)
      it seems safest to not do too much optimization with these at the
      tree level at all.  We'll have to rely on the rtl optimizers to
      clean this up, as there we've got all the appropriate bits exposed.  */
-  if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
+  if (VAR_P (t) && DECL_HARD_REGISTER (t))
     return false;
 
   /* Variables can be marked as having partial definitions, avoid
@@ -847,7 +844,7 @@ is_gimple_val (tree t)
 bool
 is_gimple_asm_val (tree t)
 {
-  if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
+  if (VAR_P (t) && DECL_HARD_REGISTER (t))
     return true;
 
   return is_gimple_val (t);
@@ -955,7 +952,7 @@ mark_addressable (tree x)
   mark_addressable_1 (x);
 
   /* Also mark the artificial SSA_NAME that points to the partition of X.  */
-  if (TREE_CODE (x) == VAR_DECL
+  if (VAR_P (x)
       && !DECL_EXTERNAL (x)
       && !TREE_STATIC (x)
       && cfun->gimple_df != NULL
diff --git a/gcc/gimple-expr.h b/gcc/gimple-expr.h
index e89f7e2..39f4b2f 100644
--- a/gcc/gimple-expr.h
+++ b/gcc/gimple-expr.h
@@ -81,7 +81,7 @@ is_gimple_reg_type (tree type)
 inline bool
 is_gimple_variable (tree t)
 {
-  return (TREE_CODE (t) == VAR_DECL
+  return (VAR_P (t)
 	  || TREE_CODE (t) == PARM_DECL
 	  || TREE_CODE (t) == RESULT_DECL
 	  || TREE_CODE (t) == SSA_NAME);
@@ -108,7 +108,7 @@ virtual_operand_p (tree op)
   if (TREE_CODE (op) == SSA_NAME)
     return SSA_NAME_IS_VIRTUAL_OPERAND (op);
 
-  if (TREE_CODE (op) == VAR_DECL)
+  if (VAR_P (op))
     return VAR_DECL_IS_VIRTUAL_OPERAND (op);
 
   return false;
diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc
index 33bc4a8..ac07a6f 100644
--- a/gcc/gimple-ssa-warn-access.cc
+++ b/gcc/gimple-ssa-warn-access.cc
@@ -4584,7 +4584,7 @@ pass_waccess::check_dangling_stores (basic_block bb,
       if (TREE_CODE (lhs_ref.ref) == PARM_DECL
 	  && (lhs_ref.deref - DECL_BY_REFERENCE (lhs_ref.ref)) > 0)
 	/* Assignment through a (real) pointer/reference parameter.  */;
-      else if (TREE_CODE (lhs_ref.ref) == VAR_DECL
+      else if (VAR_P (lhs_ref.ref)
 	       && !auto_var_p (lhs_ref.ref))
 	/* Assignment to/through a non-local variable.  */;
       else
diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc
index 7afa4c3..d0d16a2 100644
--- a/gcc/gimplify.cc
+++ b/gcc/gimplify.cc
@@ -1491,7 +1491,7 @@ gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
 	      if (DECL_HAS_VALUE_EXPR_P (key))
 		{
 		  key = DECL_VALUE_EXPR (key);
-		  if (TREE_CODE (key) == INDIRECT_REF)
+		  if (INDIRECT_REF_P (key))
 		    key = TREE_OPERAND (key, 0);
 		}
 	      tree *c = oacc_declare_returns->get (key);
@@ -1625,7 +1625,7 @@ gimplify_return_expr (tree stmt, gimple_seq *pre_p)
       result_decl = TREE_OPERAND (ret_expr, 0);
 
       /* See through a return by reference.  */
-      if (TREE_CODE (result_decl) == INDIRECT_REF)
+      if (INDIRECT_REF_P (result_decl))
 	result_decl = TREE_OPERAND (result_decl, 0);
 
       gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
@@ -1812,7 +1812,7 @@ gimple_add_padding_init_for_auto_var (tree decl, bool is_vla,
       /* The temporary address variable for this vla should be
 	 created in gimplify_vla_decl.  */
       gcc_assert (DECL_HAS_VALUE_EXPR_P (decl));
-      gcc_assert (TREE_CODE (DECL_VALUE_EXPR (decl)) == INDIRECT_REF);
+      gcc_assert (INDIRECT_REF_P (DECL_VALUE_EXPR (decl)));
       addr_of_decl = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
     }
   else
@@ -6590,7 +6590,7 @@ gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 
       /* For various reasons, the gimplification of the expression
 	 may have made a new INDIRECT_REF.  */
-      if (TREE_CODE (op0) == INDIRECT_REF
+      if (INDIRECT_REF_P (op0)
 	  || (TREE_CODE (op0) == MEM_REF
 	      && integer_zerop (TREE_OPERAND (op0, 1))))
 	goto do_indirect_ref;
@@ -7400,7 +7400,7 @@ omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
 	    nflags = GOVD_FIRSTPRIVATE;
 	  nflags |= flags & GOVD_SEEN;
 	  t = DECL_VALUE_EXPR (decl);
-	  gcc_assert (TREE_CODE (t) == INDIRECT_REF);
+	  gcc_assert (INDIRECT_REF_P (t));
 	  t = TREE_OPERAND (t, 0);
 	  gcc_assert (DECL_P (t));
 	  omp_add_variable (ctx, t, nflags);
@@ -8033,7 +8033,7 @@ omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
 	{
 	  splay_tree_node n2;
 	  tree t = DECL_VALUE_EXPR (decl);
-	  gcc_assert (TREE_CODE (t) == INDIRECT_REF);
+	  gcc_assert (INDIRECT_REF_P (t));
 	  t = TREE_OPERAND (t, 0);
 	  gcc_assert (DECL_P (t));
 	  n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
@@ -9026,7 +9026,7 @@ omp_get_base_pointer (tree expr)
 	 || TREE_CODE (expr) == COMPONENT_REF)
     expr = TREE_OPERAND (expr, 0);
 
-  if (TREE_CODE (expr) == INDIRECT_REF
+  if (INDIRECT_REF_P (expr)
       || (TREE_CODE (expr) == MEM_REF
 	  && integer_zerop (TREE_OPERAND (expr, 1))))
     {
@@ -9050,7 +9050,7 @@ static tree
 omp_strip_components_and_deref (tree expr)
 {
   while (TREE_CODE (expr) == COMPONENT_REF
-	 || TREE_CODE (expr) == INDIRECT_REF
+	 || INDIRECT_REF_P (expr)
 	 || (TREE_CODE (expr) == MEM_REF
 	     && integer_zerop (TREE_OPERAND (expr, 1)))
 	 || TREE_CODE (expr) == POINTER_PLUS_EXPR
@@ -9068,7 +9068,7 @@ omp_strip_components_and_deref (tree expr)
 static tree
 omp_strip_indirections (tree expr)
 {
-  while (TREE_CODE (expr) == INDIRECT_REF
+  while (INDIRECT_REF_P (expr)
 	 || (TREE_CODE (expr) == MEM_REF
 	     && integer_zerop (TREE_OPERAND (expr, 1))))
     expr = TREE_OPERAND (expr, 0);
@@ -10283,7 +10283,7 @@ omp_accumulate_sibling_list (enum omp_region_type region_type,
   while (TREE_CODE (ocd) == ARRAY_REF)
     ocd = TREE_OPERAND (ocd, 0);
 
-  if (TREE_CODE (ocd) == INDIRECT_REF)
+  if (INDIRECT_REF_P (ocd))
     ocd = TREE_OPERAND (ocd, 0);
 
   tree base = extract_base_bit_offset (ocd, &cbitpos, &coffset);
@@ -10375,11 +10375,10 @@ omp_accumulate_sibling_list (enum omp_region_type region_type,
 	  tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (grp_end),
 				      OMP_CLAUSE_MAP);
 	  bool base_ref
-	    = (TREE_CODE (base) == INDIRECT_REF
+	    = (INDIRECT_REF_P (base)
 	       && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (base, 0)))
 		    == REFERENCE_TYPE)
-		   || ((TREE_CODE (TREE_OPERAND (base, 0))
-			== INDIRECT_REF)
+		   || (INDIRECT_REF_P (TREE_OPERAND (base, 0))
 		       && (TREE_CODE (TREE_TYPE (TREE_OPERAND
 						  (TREE_OPERAND (base, 0), 0)))
 			   == REFERENCE_TYPE))));
@@ -10441,7 +10440,7 @@ omp_accumulate_sibling_list (enum omp_region_type region_type,
 		    || TREE_CODE (TREE_TYPE (sc_decl)) != ARRAY_TYPE)
 		  break;
 	      }
-	    else if (TREE_CODE (sc_decl) == INDIRECT_REF
+	    else if (INDIRECT_REF_P (sc_decl)
 		     && TREE_CODE (TREE_OPERAND (sc_decl, 0)) == COMPONENT_REF
 		     && (TREE_CODE (TREE_TYPE (TREE_OPERAND (sc_decl, 0)))
 			 == REFERENCE_TYPE))
@@ -10611,7 +10610,7 @@ omp_build_struct_sibling_lists (enum tree_code code,
 	    decl = d;
 	}
       if (d == decl
-	  && TREE_CODE (decl) == INDIRECT_REF
+	  && INDIRECT_REF_P (decl)
 	  && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
 	  && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
 	      == REFERENCE_TYPE)
@@ -12422,7 +12421,7 @@ gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
 	  && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
 	{
 	  tree decl2 = DECL_VALUE_EXPR (decl);
-	  gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
+	  gcc_assert (INDIRECT_REF_P (decl2));
 	  decl2 = TREE_OPERAND (decl2, 0);
 	  gcc_assert (DECL_P (decl2));
 	  tree mem = build_simple_mem_ref (decl2);
@@ -12711,7 +12710,7 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
 
 	case OMP_CLAUSE_HAS_DEVICE_ADDR:
 	  decl = OMP_CLAUSE_DECL (c);
-	  while (TREE_CODE (decl) == INDIRECT_REF
+	  while (INDIRECT_REF_P (decl)
 		 || TREE_CODE (decl) == ARRAY_REF)
 	    decl = TREE_OPERAND (decl, 0);
 	  n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
@@ -12786,7 +12785,7 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
 	      if ((ctx->region_type & ORT_TARGET) != 0
 		  && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
 		{
-		  if (TREE_CODE (decl) == INDIRECT_REF
+		  if (INDIRECT_REF_P (decl)
 		      && TREE_CODE (TREE_OPERAND (decl, 0)) == COMPONENT_REF
 		      && (TREE_CODE (TREE_TYPE (TREE_OPERAND (decl, 0)))
 			  == REFERENCE_TYPE))
@@ -12840,7 +12839,7 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
 	      gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
 
 	      tree decl2 = DECL_VALUE_EXPR (decl);
-	      gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
+	      gcc_assert (INDIRECT_REF_P (decl2));
 	      decl2 = TREE_OPERAND (decl2, 0);
 	      gcc_assert (DECL_P (decl2));
 	      tree mem = build_simple_mem_ref (decl2);
@@ -12891,7 +12890,7 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
 	      && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
 	    {
 	      tree decl2 = DECL_VALUE_EXPR (decl);
-	      gcc_assert (TREE_CODE (decl2) == INDIRECT_REF);
+	      gcc_assert (INDIRECT_REF_P (decl2));
 	      decl2 = TREE_OPERAND (decl2, 0);
 	      gcc_assert (DECL_P (decl2));
 	      tree mem = build_simple_mem_ref (decl2);
@@ -13812,8 +13811,7 @@ gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
     {
       has_decl_expr = BITMAP_ALLOC (NULL);
       if (TREE_CODE (OMP_FOR_PRE_BODY (for_stmt)) == DECL_EXPR
-	  && TREE_CODE (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt)))
-	     == VAR_DECL)
+	  && VAR_P (DECL_EXPR_DECL (OMP_FOR_PRE_BODY (for_stmt))))
 	{
 	  t = OMP_FOR_PRE_BODY (for_stmt);
 	  bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
@@ -13826,7 +13824,7 @@ gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
 	    {
 	      t = tsi_stmt (si);
 	      if (TREE_CODE (t) == DECL_EXPR
-		  && TREE_CODE (DECL_EXPR_DECL (t)) == VAR_DECL)
+		  && VAR_P (DECL_EXPR_DECL (t)))
 		bitmap_set_bit (has_decl_expr, DECL_UID (DECL_EXPR_DECL (t)));
 	    }
 	}
@@ -15623,7 +15621,7 @@ goa_lhs_expr_p (tree expr, tree addr)
      STRIP_TYPE_NOPS but includes the main variant lookup.  */
   STRIP_USELESS_TYPE_CONVERSION (expr);
 
-  if (TREE_CODE (expr) == INDIRECT_REF)
+  if (INDIRECT_REF_P (expr))
     {
       expr = TREE_OPERAND (expr, 0);
       while (expr != addr
@@ -17551,7 +17549,7 @@ gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
      if this type is from outside the function.  It's OK to have that here.  */
   if (expr == NULL_TREE
       || is_gimple_constant (expr)
-      || TREE_CODE (expr) == VAR_DECL
+      || VAR_P (expr)
       || CONTAINS_PLACEHOLDER_P (expr))
     return;
 
diff --git a/gcc/graphite-scop-detection.cc b/gcc/graphite-scop-detection.cc
index 48b3d62..e1112035 100644
--- a/gcc/graphite-scop-detection.cc
+++ b/gcc/graphite-scop-detection.cc
@@ -980,8 +980,8 @@ scop_detection::graphite_can_represent_scev (sese_l scop, tree scev)
 	&& graphite_can_represent_scev (scop, TREE_OPERAND (scev, 1));
 
     case MULT_EXPR:
-      return !CONVERT_EXPR_CODE_P (TREE_CODE (TREE_OPERAND (scev, 0)))
-	&& !CONVERT_EXPR_CODE_P (TREE_CODE (TREE_OPERAND (scev, 1)))
+      return !CONVERT_EXPR_P (TREE_OPERAND (scev, 0))
+	&& !CONVERT_EXPR_P (TREE_OPERAND (scev, 1))
 	&& !(chrec_contains_symbols (TREE_OPERAND (scev, 0))
 	     && chrec_contains_symbols (TREE_OPERAND (scev, 1)))
 	&& graphite_can_represent_init (scev)
diff --git a/gcc/ipa-devirt.cc b/gcc/ipa-devirt.cc
index 8198602..2c61a49 100644
--- a/gcc/ipa-devirt.cc
+++ b/gcc/ipa-devirt.cc
@@ -1252,7 +1252,7 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
   if (INTEGRAL_TYPE_P (t1)
       || SCALAR_FLOAT_TYPE_P (t1)
       || FIXED_POINT_TYPE_P (t1)
-      || TREE_CODE (t1) == VECTOR_TYPE
+      || VECTOR_TYPE_P (t1)
       || TREE_CODE (t1) == COMPLEX_TYPE
       || TREE_CODE (t1) == OFFSET_TYPE
       || POINTER_TYPE_P (t1))
@@ -1310,7 +1310,7 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
 	    }
 	}
 
-      if ((TREE_CODE (t1) == VECTOR_TYPE || TREE_CODE (t1) == COMPLEX_TYPE)
+      if ((VECTOR_TYPE_P (t1) || TREE_CODE (t1) == COMPLEX_TYPE)
 	  && !odr_subtypes_equivalent_p (TREE_TYPE (t1), TREE_TYPE (t2),
 					 visited, loc1, loc2))
 	{
diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc
index d7d70e5..60b7f09 100644
--- a/gcc/ipa-prop.cc
+++ b/gcc/ipa-prop.cc
@@ -546,7 +546,7 @@ ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant,
 
   if (TREE_CODE (constant) == ADDR_EXPR
       && (TREE_CODE (TREE_OPERAND (constant, 0)) == FUNCTION_DECL
-	  || (TREE_CODE (TREE_OPERAND (constant, 0)) == VAR_DECL
+	  || (VAR_P (TREE_OPERAND (constant, 0))
 	      && TREE_STATIC (TREE_OPERAND (constant, 0)))))
     {
       struct ipa_cst_ref_desc *rdesc;
@@ -4188,7 +4188,7 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 	  if (rdesc->refcount != IPA_UNDESCRIBED_USE
 	      && ipa_get_param_load_dereferenced (old_root_info, i)
 	      && TREE_CODE (cst) == ADDR_EXPR
-	      && TREE_CODE (TREE_OPERAND (cst, 0)) == VAR_DECL)
+	      && VAR_P (TREE_OPERAND (cst, 0)))
 	    {
 	      symtab_node *n = symtab_node::get (TREE_OPERAND (cst, 0));
 	      new_root->create_reference (n, IPA_REF_LOAD, NULL);
@@ -4202,8 +4202,7 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 	      gcc_checking_assert (TREE_CODE (cst) == ADDR_EXPR
 				   && ((TREE_CODE (TREE_OPERAND (cst, 0))
 					== FUNCTION_DECL)
-				       || (TREE_CODE (TREE_OPERAND (cst, 0))
-					   == VAR_DECL)));
+				       || VAR_P (TREE_OPERAND (cst, 0))));
 
 	      symtab_node *n = symtab_node::get (TREE_OPERAND (cst, 0));
 	      if (n)
diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc
index 7b8260b..7230522 100644
--- a/gcc/ipa-sra.cc
+++ b/gcc/ipa-sra.cc
@@ -1664,10 +1664,10 @@ type_prevails_p (tree old_type, tree new_type)
   if (TREE_CODE (old_type) != COMPLEX_TYPE
       && TREE_CODE (old_type) != VECTOR_TYPE
       && (TREE_CODE (new_type) == COMPLEX_TYPE
-	  || TREE_CODE (new_type) == VECTOR_TYPE))
+	  || VECTOR_TYPE_P (new_type)))
     return true;
   if ((TREE_CODE (old_type) == COMPLEX_TYPE
-       || TREE_CODE (old_type) == VECTOR_TYPE)
+       || VECTOR_TYPE_P (old_type))
       && TREE_CODE (new_type) != COMPLEX_TYPE
       && TREE_CODE (new_type) != VECTOR_TYPE)
     return false;
@@ -1754,7 +1754,7 @@ scan_expr_access (tree expr, gimple *stmt, isra_scan_context ctx,
       if (ctx == ISRA_CTX_ARG)
 	return;
       tree t = get_base_address (TREE_OPERAND (expr, 0));
-      if (TREE_CODE (t) == VAR_DECL && !TREE_STATIC (t))
+      if (VAR_P (t) && !TREE_STATIC (t))
 	loaded_decls->add (t);
       return;
     }
@@ -1780,7 +1780,7 @@ scan_expr_access (tree expr, gimple *stmt, isra_scan_context ctx,
 	return;
       deref = true;
     }
-  else if (TREE_CODE (base) == VAR_DECL
+  else if (VAR_P (base)
 	   && !TREE_STATIC (base)
 	   && (ctx == ISRA_CTX_ARG
 	       || ctx == ISRA_CTX_LOAD))
diff --git a/gcc/optabs-tree.cc b/gcc/optabs-tree.cc
index 8010046..cd7b45f 100644
--- a/gcc/optabs-tree.cc
+++ b/gcc/optabs-tree.cc
@@ -63,7 +63,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
 	 expansion has code to adjust TRUNC_MOD_EXPR into the desired other
 	 modes, but for vector modes it does not.  The adjustment code
 	 should be instead emitted in tree-vect-patterns.cc.  */
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	return unknown_optab;
       /* FALLTHRU */
     case TRUNC_MOD_EXPR:
@@ -77,7 +77,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
 	 into the desired other modes, but for vector modes it does not.
 	 The adjustment code should be instead emitted in
 	 tree-vect-patterns.cc.  */
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	return unknown_optab;
       /* FALLTHRU */
     case RDIV_EXPR:
@@ -88,7 +88,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
       return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
 
     case LSHIFT_EXPR:
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	{
 	  if (subtype == optab_vector)
 	    return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
@@ -100,7 +100,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
       return ashl_optab;
 
     case RSHIFT_EXPR:
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	{
 	  if (subtype == optab_vector)
 	    return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
@@ -110,7 +110,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
       return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
 
     case LROTATE_EXPR:
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	{
 	  if (subtype == optab_vector)
 	    return vrotl_optab;
@@ -120,7 +120,7 @@ optab_for_tree_code (enum tree_code code, const_tree type,
       return rotl_optab;
 
     case RROTATE_EXPR:
-      if (TREE_CODE (type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (type))
 	{
 	  if (subtype == optab_vector)
 	    return vrotr_optab;
diff --git a/gcc/toplev.cc b/gcc/toplev.cc
index d53b5e7..8aec9a2 100644
--- a/gcc/toplev.cc
+++ b/gcc/toplev.cc
@@ -323,7 +323,7 @@ wrapup_global_declaration_1 (tree decl)
 {
   /* We're not deferring this any longer.  Assignment is conditional to
      avoid needlessly dirtying PCH pages.  */
-  if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
+  if (HAS_DECL_ASSEMBLER_NAME_P (decl)
       && DECL_DEFER_OUTPUT (decl) != 0)
     DECL_DEFER_OUTPUT (decl) = 0;
 
diff --git a/gcc/trans-mem.cc b/gcc/trans-mem.cc
index 4b12966..d036e43 100644
--- a/gcc/trans-mem.cc
+++ b/gcc/trans-mem.cc
@@ -1062,7 +1062,7 @@ tm_log_delete (void)
 static bool
 transaction_invariant_address_p (const_tree mem, basic_block region_entry_block)
 {
-  if ((TREE_CODE (mem) == INDIRECT_REF || TREE_CODE (mem) == MEM_REF)
+  if ((INDIRECT_REF_P (mem) || TREE_CODE (mem) == MEM_REF)
       && TREE_CODE (TREE_OPERAND (mem, 0)) == SSA_NAME)
     {
       basic_block def_bb;
diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
index 0aeebb6..a1a6076 100644
--- a/gcc/tree-cfg.cc
+++ b/gcc/tree-cfg.cc
@@ -3328,7 +3328,7 @@ verify_types_in_gimple_reference (tree expr, bool require_lvalue)
 	  return true;
 	}
     }
-  else if (TREE_CODE (expr) == INDIRECT_REF)
+  else if (INDIRECT_REF_P (expr))
     {
       error ("%qs in gimple IL", code_name);
       debug_generic_stmt (expr);
@@ -3615,8 +3615,8 @@ verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
       && (TREE_CODE (type) == BOOLEAN_TYPE
 	  || TYPE_PRECISION (type) == 1))
     {
-      if ((TREE_CODE (op0_type) == VECTOR_TYPE
-	   || TREE_CODE (op1_type) == VECTOR_TYPE)
+      if ((VECTOR_TYPE_P (op0_type)
+	   || VECTOR_TYPE_P (op1_type))
 	  && code != EQ_EXPR && code != NE_EXPR
 	  && !VECTOR_BOOLEAN_TYPE_P (op0_type)
 	  && !VECTOR_INTEGER_TYPE_P (op0_type))
@@ -3630,7 +3630,7 @@ verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
     }
   /* Or a boolean vector type with the same element count
      as the comparison operand types.  */
-  else if (TREE_CODE (type) == VECTOR_TYPE
+  else if (VECTOR_TYPE_P (type)
 	   && TREE_CODE (TREE_TYPE (type)) == BOOLEAN_TYPE)
     {
       if (TREE_CODE (op0_type) != VECTOR_TYPE
@@ -3963,13 +3963,13 @@ verify_gimple_assign_binary (gassign *stmt)
 	   types and integer vector types.  */
 	if ((!INTEGRAL_TYPE_P (rhs1_type)
 	     && !FIXED_POINT_TYPE_P (rhs1_type)
-	     && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
+	     && ! (VECTOR_TYPE_P (rhs1_type)
 		  && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
 	    || (!INTEGRAL_TYPE_P (rhs2_type)
 		/* Vector shifts of vectors are also ok.  */
-		&& !(TREE_CODE (rhs1_type) == VECTOR_TYPE
+		&& ! (VECTOR_TYPE_P (rhs1_type)
 		     && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
-		     && TREE_CODE (rhs2_type) == VECTOR_TYPE
+		     && VECTOR_TYPE_P (rhs2_type)
 		     && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
 	    || !useless_type_conversion_p (lhs_type, rhs1_type))
 	  {
@@ -4029,7 +4029,7 @@ verify_gimple_assign_binary (gassign *stmt)
 	tree lhs_etype = lhs_type;
 	tree rhs1_etype = rhs1_type;
 	tree rhs2_etype = rhs2_type;
-	if (TREE_CODE (lhs_type) == VECTOR_TYPE)
+	if (VECTOR_TYPE_P (lhs_type))
 	  {
 	    if (TREE_CODE (rhs1_type) != VECTOR_TYPE
 		|| TREE_CODE (rhs2_type) != VECTOR_TYPE)
@@ -4709,7 +4709,7 @@ verify_gimple_assign_single (gassign *stmt)
       return res;
 
     case CONSTRUCTOR:
-      if (TREE_CODE (rhs1_type) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (rhs1_type))
 	{
 	  unsigned int i;
 	  tree elt_i, elt_v, elt_t = NULL_TREE;
@@ -4729,7 +4729,7 @@ verify_gimple_assign_single (gassign *stmt)
 	      if (elt_t == NULL_TREE)
 		{
 		  elt_t = TREE_TYPE (elt_v);
-		  if (TREE_CODE (elt_t) == VECTOR_TYPE)
+		  if (VECTOR_TYPE_P (elt_t))
 		    {
 		      tree elt_t = TREE_TYPE (elt_v);
 		      if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
@@ -4774,7 +4774,7 @@ verify_gimple_assign_single (gassign *stmt)
 		  return true;
 		}
 	      if (elt_i != NULL_TREE
-		  && (TREE_CODE (elt_t) == VECTOR_TYPE
+		  && (VECTOR_TYPE_P (elt_t)
 		      || TREE_CODE (elt_i) != INTEGER_CST
 		      || compare_tree_int (elt_i, i) != 0))
 		{
diff --git a/gcc/tree-complex.cc b/gcc/tree-complex.cc
index ef40511..688fe13 100644
--- a/gcc/tree-complex.cc
+++ b/gcc/tree-complex.cc
@@ -526,7 +526,7 @@ get_component_ssa_name (tree ssa_name, bool imag_p)
       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ret)
 	= SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name);
       if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
-	  && TREE_CODE (SSA_NAME_VAR (ssa_name)) == VAR_DECL)
+	  && VAR_P (SSA_NAME_VAR (ssa_name)))
 	{
 	  SSA_NAME_DEF_STMT (ret) = SSA_NAME_DEF_STMT (ssa_name);
 	  set_ssa_default_def (cfun, SSA_NAME_VAR (ret), ret);
diff --git a/gcc/tree-emutls.cc b/gcc/tree-emutls.cc
index eb3ac9b..5dca5a8 100644
--- a/gcc/tree-emutls.cc
+++ b/gcc/tree-emutls.cc
@@ -439,7 +439,7 @@ static tree
 lower_emutls_2 (tree *ptr, int *walk_subtrees, void *)
 {
   tree t = *ptr;
-  if (TREE_CODE (t) == VAR_DECL)
+  if (VAR_P (t))
     return DECL_THREAD_LOCAL_P (t) ? t : NULL_TREE;
   else if (!EXPR_P (t))
     *walk_subtrees = 0;
diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc
index 63a19f8..47e2f58 100644
--- a/gcc/tree-inline.cc
+++ b/gcc/tree-inline.cc
@@ -1307,7 +1307,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
 		}
 	    }
 	}
-      else if (TREE_CODE (*tp) == INDIRECT_REF)
+      else if (INDIRECT_REF_P (*tp))
 	{
 	  /* Get rid of *& from inline substitutions that can happen when a
 	     pointer argument is an ADDR_EXPR.  */
@@ -1429,7 +1429,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
 
 	  /* Handle the case where we substituted an INDIRECT_REF
 	     into the operand of the ADDR_EXPR.  */
-	  if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF
+	  if (INDIRECT_REF_P (TREE_OPERAND (*tp, 0))
 	      && !id->do_not_fold)
 	    {
 	      tree t = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0);
@@ -4170,7 +4170,7 @@ estimate_move_cost (tree type, bool ARG_UNUSED (speed_p))
 
   gcc_assert (!VOID_TYPE_P (type));
 
-  if (TREE_CODE (type) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (type))
     {
       scalar_mode inner = SCALAR_TYPE_MODE (TREE_TYPE (type));
       machine_mode simd = targetm.vectorize.preferred_simd_mode (inner);
@@ -5918,7 +5918,7 @@ copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy)
   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
 
   /* The new variable/label has no RTL, yet.  */
-  if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL)
+  if (HAS_RTL_P (copy)
       && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
     SET_DECL_RTL (copy, 0);
   /* For vector typed decls make sure to update DECL_MODE according
diff --git a/gcc/tree-nested.cc b/gcc/tree-nested.cc
index 1418e1f..ae7d1f1 100644
--- a/gcc/tree-nested.cc
+++ b/gcc/tree-nested.cc
@@ -1311,7 +1311,7 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
 	      pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
 	      if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
 		pdecl = &TREE_OPERAND (*pdecl, 0);
-	      if (TREE_CODE (*pdecl) == INDIRECT_REF
+	      if (INDIRECT_REF_P (*pdecl)
 		  || TREE_CODE (*pdecl) == ADDR_EXPR)
 		pdecl = &TREE_OPERAND (*pdecl, 0);
 	    }
@@ -1614,7 +1614,7 @@ note_nonlocal_vla_type (struct nesting_info *info, tree type)
     type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
 
   while (POINTER_TYPE_P (type)
-	 || TREE_CODE (type) == VECTOR_TYPE
+	 || VECTOR_TYPE_P (type)
 	 || TREE_CODE (type) == FUNCTION_TYPE
 	 || TREE_CODE (type) == METHOD_TYPE)
     type = TREE_TYPE (type);
@@ -2097,7 +2097,7 @@ convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
 	      pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
 	      if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
 		pdecl = &TREE_OPERAND (*pdecl, 0);
-	      if (TREE_CODE (*pdecl) == INDIRECT_REF
+	      if (INDIRECT_REF_P (*pdecl)
 		  || TREE_CODE (*pdecl) == ADDR_EXPR)
 		pdecl = &TREE_OPERAND (*pdecl, 0);
 	    }
@@ -3234,8 +3234,8 @@ remap_vla_decls (tree block, struct nesting_info *root)
 	val = DECL_VALUE_EXPR (var);
 	type = TREE_TYPE (var);
 
-	if (!(TREE_CODE (val) == INDIRECT_REF
-	      && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
+	if (! (INDIRECT_REF_P (val)
+	      && VAR_P (TREE_OPERAND (val, 0))
 	      && variably_modified_type_p (type, NULL)))
 	  continue;
 
@@ -3261,8 +3261,8 @@ remap_vla_decls (tree block, struct nesting_info *root)
 	val = DECL_VALUE_EXPR (var);
 	type = TREE_TYPE (var);
 
-	if (!(TREE_CODE (val) == INDIRECT_REF
-	      && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
+	if (! (INDIRECT_REF_P (val)
+	      && VAR_P (TREE_OPERAND (val, 0))
 	      && variably_modified_type_p (type, NULL)))
 	  continue;
 
@@ -3323,7 +3323,7 @@ fixup_vla_decls (tree block)
       {
 	tree val = DECL_VALUE_EXPR (var);
 
-	if (!(TREE_CODE (val) == INDIRECT_REF
+	if (! (INDIRECT_REF_P (val)
 	      && VAR_P (TREE_OPERAND (val, 0))
 	      && DECL_HAS_VALUE_EXPR_P (TREE_OPERAND (val, 0))))
 	  continue;
diff --git a/gcc/tree-parloops.cc b/gcc/tree-parloops.cc
index 0abec54..e495bbd 100644
--- a/gcc/tree-parloops.cc
+++ b/gcc/tree-parloops.cc
@@ -3195,7 +3195,7 @@ loop_has_vector_phi_nodes (class loop *loop ATTRIBUTE_UNUSED)
 
   for (i = 0; i < loop->num_nodes; i++)
     for (gsi = gsi_start_phis (bbs[i]); !gsi_end_p (gsi); gsi_next (&gsi))
-      if (TREE_CODE (TREE_TYPE (PHI_RESULT (gsi.phi ()))) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (TREE_TYPE (PHI_RESULT (gsi.phi ()))))
 	goto end;
 
   res = false;
diff --git a/gcc/tree-pretty-print.cc b/gcc/tree-pretty-print.cc
index 7947f96..3d1c983 100644
--- a/gcc/tree-pretty-print.cc
+++ b/gcc/tree-pretty-print.cc
@@ -3962,7 +3962,7 @@ print_declaration (pretty_printer *pp, tree t, int spc, dump_flags_t flags)
   if (TREE_CODE (t) == TYPE_DECL)
     pp_string (pp, "typedef ");
 
-  if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
+  if (HAS_RTL_P (t) && DECL_REGISTER (t))
     pp_string (pp, "register ");
 
   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
@@ -4484,7 +4484,7 @@ print_call_name (pretty_printer *pp, tree node, dump_flags_t flags)
       break;
 
     case ARRAY_REF:
-      if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
+      if (VAR_P (TREE_OPERAND (op0, 0)))
 	dump_function_name (pp, TREE_OPERAND (op0, 0), flags);
       else
 	dump_generic_node (pp, op0, 0, flags, false);
diff --git a/gcc/tree-sra.cc b/gcc/tree-sra.cc
index ad0c738..56a8ba2 100644
--- a/gcc/tree-sra.cc
+++ b/gcc/tree-sra.cc
@@ -1465,10 +1465,10 @@ compare_access_positions (const void *a, const void *b)
       else if (TREE_CODE (f1->type) != COMPLEX_TYPE
 	       && TREE_CODE (f1->type) != VECTOR_TYPE
 	       && (TREE_CODE (f2->type) == COMPLEX_TYPE
-		   || TREE_CODE (f2->type) == VECTOR_TYPE))
+		   || VECTOR_TYPE_P (f2->type)))
 	return 1;
       else if ((TREE_CODE (f1->type) == COMPLEX_TYPE
-		|| TREE_CODE (f1->type) == VECTOR_TYPE)
+		|| VECTOR_TYPE_P (f1->type))
 	       && TREE_CODE (f2->type) != COMPLEX_TYPE
 	       && TREE_CODE (f2->type) != VECTOR_TYPE)
 	return -1;
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index e0693e1..79ed956 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -945,10 +945,10 @@ compare_type_sizes (tree type1, tree type2)
   /* Be conservative for arrays and vectors.  We want to support partial
      overlap on int[3] and int[3] as tested in gcc.dg/torture/alias-2.c.  */
   while (TREE_CODE (type1) == ARRAY_TYPE
-	 || TREE_CODE (type1) == VECTOR_TYPE)
+	 || VECTOR_TYPE_P (type1))
     type1 = TREE_TYPE (type1);
   while (TREE_CODE (type2) == ARRAY_TYPE
-	 || TREE_CODE (type2) == VECTOR_TYPE)
+	 || VECTOR_TYPE_P (type2))
     type2 = TREE_TYPE (type2);
   return compare_sizes (TYPE_SIZE (type1), TYPE_SIZE (type2));
 }
diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
index 2e552b3..6fb371c 100644
--- a/gcc/tree-ssa-ccp.cc
+++ b/gcc/tree-ssa-ccp.cc
@@ -289,7 +289,7 @@ get_default_value (tree var)
 	 consider it VARYING.  */
       if (!virtual_operand_p (var)
 	  && SSA_NAME_VAR (var)
-	  && TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
+	  && VAR_P (SSA_NAME_VAR (var)))
 	val.lattice_val = UNDEFINED;
       else
 	{
diff --git a/gcc/tree-ssa-coalesce.cc b/gcc/tree-ssa-coalesce.cc
index 6e8c390..e9de9d4d 100644
--- a/gcc/tree-ssa-coalesce.cc
+++ b/gcc/tree-ssa-coalesce.cc
@@ -1298,7 +1298,7 @@ populate_coalesce_list_for_outofssa (coalesce_list *cl, bitmap used_in_copy)
 		     originally with optimizations and only the link
 		     performed at -O0, so we can't actually require it.  */
 		  const int cost
-		    = (TREE_CODE (SSA_NAME_VAR (a)) == VAR_DECL || in_lto_p)
+		    = (VAR_P (SSA_NAME_VAR (a)) || in_lto_p)
 		      ? MUST_COALESCE_COST - 1 : MUST_COALESCE_COST;
 		  add_coalesce (cl, SSA_NAME_VERSION (a),
 				SSA_NAME_VERSION (*slot), cost);
diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index ab31d2e..9f534b5 100644
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -2162,8 +2162,8 @@ reduce_vector_comparison_to_scalar_comparison (gimple *stmt)
       /* We may have a vector comparison where both arms are uniform
 	 vectors.  If so, we can simplify the vector comparison down
 	 to a scalar comparison.  */
-      if (TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE
-	  && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE)
+      if (VECTOR_TYPE_P (TREE_TYPE (lhs))
+	  && VECTOR_TYPE_P (TREE_TYPE (rhs)))
 	{
 	  /* If either operand is an SSA_NAME, then look back to its
 	     defining statement to try and get at a suitable source.  */
diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
index 0326e67..047f923 100644
--- a/gcc/tree-ssa-forwprop.cc
+++ b/gcc/tree-ssa-forwprop.cc
@@ -291,8 +291,7 @@ can_propagate_from (gimple *def_stmt)
   if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
     {
       tree rhs = gimple_assign_rhs1 (def_stmt);
-      if (POINTER_TYPE_P (TREE_TYPE (rhs))
-          && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs))) == FUNCTION_TYPE)
+      if (FUNCTION_POINTER_TYPE_P (TREE_TYPE (rhs)))
         return false;
     }
 
diff --git a/gcc/tree-ssa-propagate.cc b/gcc/tree-ssa-propagate.cc
index 5573d36..174d198 100644
--- a/gcc/tree-ssa-propagate.cc
+++ b/gcc/tree-ssa-propagate.cc
@@ -1020,7 +1020,7 @@ may_propagate_copy (tree dest, tree orig, bool dest_not_phi_arg_p)
       && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig)
       && SSA_NAME_IS_DEFAULT_DEF (orig)
       && (SSA_NAME_VAR (orig) == NULL_TREE
-	  || TREE_CODE (SSA_NAME_VAR (orig)) == VAR_DECL))
+	  || VAR_P (SSA_NAME_VAR (orig))))
     ;
   /* Otherwise if ORIG just flows in from an abnormal edge then the copy cannot
      be propagated.  */
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index 94d6163..27c84e78 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -1575,7 +1575,7 @@ fully_constant_vn_reference_p (vn_reference_t ref)
 	ctor = base->op0;
       else if (base->opcode == MEM_REF
 	       && base[1].opcode == ADDR_EXPR
-	       && (TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == VAR_DECL
+	       && (VAR_P (TREE_OPERAND (base[1].op0, 0))
 		   || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == CONST_DECL
 		   || TREE_CODE (TREE_OPERAND (base[1].op0, 0)) == STRING_CST))
 	{
diff --git a/gcc/tree-ssa-sink.cc b/gcc/tree-ssa-sink.cc
index 87b1d40..b1ba7a2 100644
--- a/gcc/tree-ssa-sink.cc
+++ b/gcc/tree-ssa-sink.cc
@@ -382,7 +382,7 @@ statement_sink_location (gimple *stmt, basic_block frombb,
 	{
 	  /* Do not sink loads from hard registers.  */
 	  if (gimple_assign_single_p (stmt)
-	      && TREE_CODE (gimple_assign_rhs1 (stmt)) == VAR_DECL
+	      && VAR_P (gimple_assign_rhs1 (stmt))
 	      && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt)))
 	    return false;
 
diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc
index 56021c5..546dab5 100644
--- a/gcc/tree-ssa-structalias.cc
+++ b/gcc/tree-ssa-structalias.cc
@@ -5831,8 +5831,7 @@ type_must_have_pointers (tree type)
 
   /* A function or method can have pointers as arguments, so track
      those separately.  */
-  if (TREE_CODE (type) == FUNCTION_TYPE
-      || TREE_CODE (type) == METHOD_TYPE)
+  if (FUNC_OR_METHOD_TYPE_P (type))
     return true;
 
   return false;
diff --git a/gcc/tree-ssa-ter.cc b/gcc/tree-ssa-ter.cc
index cab54a3..68e9e1a 100644
--- a/gcc/tree-ssa-ter.cc
+++ b/gcc/tree-ssa-ter.cc
@@ -693,7 +693,7 @@ find_replaceable_in_bb (temp_expr_table *tab, basic_block bb)
       /* Increment counter if this statement sets a local
 	 register variable.  */
       if (gimple_assign_single_p (stmt)
-	  && (TREE_CODE (gimple_assign_lhs (stmt)) == VAR_DECL
+	  && (VAR_P (gimple_assign_lhs (stmt))
 	  && DECL_HARD_REGISTER (gimple_assign_lhs (stmt))))
 	cur_reg_vars_cnt++;
 
diff --git a/gcc/tree-ssa-uninit.cc b/gcc/tree-ssa-uninit.cc
index 9f720ae..f42f76c 100644
--- a/gcc/tree-ssa-uninit.cc
+++ b/gcc/tree-ssa-uninit.cc
@@ -232,7 +232,7 @@ warn_uninit (opt_code opt, tree t, tree var, gimple *context,
 
 	  if (is_gimple_assign (context))
 	    {
-	      if (TREE_CODE (gimple_assign_lhs (context)) == VAR_DECL)
+	      if (VAR_P (gimple_assign_lhs (context)))
 		lhs_var = gimple_assign_lhs (context);
 	      else if (TREE_CODE (gimple_assign_lhs (context)) == SSA_NAME)
 		lhs_var = SSA_NAME_VAR (gimple_assign_lhs (context));
diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc
index 7082835..607b37e 100644
--- a/gcc/tree-ssa.cc
+++ b/gcc/tree-ssa.cc
@@ -1507,7 +1507,7 @@ maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
       && is_gimple_reg_type (TREE_TYPE (*tp))
       && ! VOID_TYPE_P (TREE_TYPE (*tp)))
     {
-      if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
+      if (VECTOR_TYPE_P (TREE_TYPE (sym))
 	  && useless_type_conversion_p (TREE_TYPE (*tp),
 					TREE_TYPE (TREE_TYPE (sym)))
 	  && multiple_p (mem_ref_offset (*tp),
@@ -1608,7 +1608,7 @@ non_rewritable_mem_ref_base (tree ref)
 	  || VOID_TYPE_P (TREE_TYPE (base))
 	  || TREE_THIS_VOLATILE (decl) != TREE_THIS_VOLATILE (base))
 	return decl;
-      if ((TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE
+      if ((VECTOR_TYPE_P (TREE_TYPE (decl))
 	   || TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE)
 	  && useless_type_conversion_p (TREE_TYPE (base),
 					TREE_TYPE (TREE_TYPE (decl)))
diff --git a/gcc/tree-streamer-in.cc b/gcc/tree-streamer-in.cc
index bf4bd5c..c803800 100644
--- a/gcc/tree-streamer-in.cc
+++ b/gcc/tree-streamer-in.cc
@@ -848,8 +848,7 @@ lto_input_ts_type_non_common_tree_pointers (class lto_input_block *ib,
     TYPE_DOMAIN (expr) = stream_read_tree_ref (ib, data_in);
   else if (RECORD_OR_UNION_TYPE_P (expr))
     TYPE_FIELDS (expr) = streamer_read_chain (ib, data_in);
-  else if (TREE_CODE (expr) == FUNCTION_TYPE
-	   || TREE_CODE (expr) == METHOD_TYPE)
+  else if (FUNC_OR_METHOD_TYPE_P (expr))
     TYPE_ARG_TYPES (expr) = stream_read_tree_ref (ib, data_in);
 
   if (!POINTER_TYPE_P (expr))
diff --git a/gcc/tree-streamer-out.cc b/gcc/tree-streamer-out.cc
index 81e6fcb..5751f77 100644
--- a/gcc/tree-streamer-out.cc
+++ b/gcc/tree-streamer-out.cc
@@ -739,8 +739,7 @@ write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr)
     stream_write_tree_ref (ob, TYPE_DOMAIN (expr));
   else if (RECORD_OR_UNION_TYPE_P (expr))
     streamer_write_chain (ob, TYPE_FIELDS (expr));
-  else if (TREE_CODE (expr) == FUNCTION_TYPE
-	   || TREE_CODE (expr) == METHOD_TYPE)
+  else if (FUNC_OR_METHOD_TYPE_P (expr))
     stream_write_tree_ref (ob, TYPE_ARG_TYPES (expr));
 
   if (!POINTER_TYPE_P (expr))
diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc
index 59115b2..fa3809f 100644
--- a/gcc/tree-vect-generic.cc
+++ b/gcc/tree-vect-generic.cc
@@ -173,9 +173,9 @@ do_binop (gimple_stmt_iterator *gsi, tree inner_type, tree a, tree b,
 	  tree bitpos, tree bitsize, enum tree_code code,
 	  tree type ATTRIBUTE_UNUSED)
 {
-  if (TREE_CODE (TREE_TYPE (a)) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (TREE_TYPE (a)))
     a = tree_vec_extract (gsi, inner_type, a, bitsize, bitpos);
-  if (TREE_CODE (TREE_TYPE (b)) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (TREE_TYPE (b)))
     b = tree_vec_extract (gsi, inner_type, b, bitsize, bitpos);
   return gimplify_build2 (gsi, code, inner_type, a, b);
 }
@@ -1733,9 +1733,9 @@ do_cond (gimple_stmt_iterator *gsi, tree inner_type, tree a, tree b,
 	 tree bitpos, tree bitsize, enum tree_code code,
 	 tree type ATTRIBUTE_UNUSED)
 {
-  if (TREE_CODE (TREE_TYPE (a)) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (TREE_TYPE (a)))
     a = tree_vec_extract (gsi, inner_type, a, bitsize, bitpos);
-  if (TREE_CODE (TREE_TYPE (b)) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (TREE_TYPE (b)))
     b = tree_vec_extract (gsi, inner_type, b, bitsize, bitpos);
   tree cond = gimple_assign_rhs1 (gsi_stmt (*gsi));
   return gimplify_build3 (gsi, code, inner_type, unshare_expr (cond), a, b);
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index 7313191..821a8c3 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -1412,7 +1412,7 @@ vect_init_vector (vec_info *vinfo, stmt_vec_info stmt_info, tree val, tree type,
   /* We abuse this function to push sth to a SSA name with initial 'val'.  */
   if (! useless_type_conversion_p (type, TREE_TYPE (val)))
     {
-      gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
+      gcc_assert (VECTOR_TYPE_P (type));
       if (! types_compatible_p (TREE_TYPE (type), TREE_TYPE (val)))
 	{
 	  /* Scalar boolean value should be transformed into
diff --git a/gcc/tree-vector-builder.h b/gcc/tree-vector-builder.h
index 2af6d75d..b916767 100644
--- a/gcc/tree-vector-builder.h
+++ b/gcc/tree-vector-builder.h
@@ -134,7 +134,7 @@ tree_vector_builder::can_elide_p (const_tree elt) const
 inline void
 tree_vector_builder::note_representative (tree *elt1_ptr, tree elt2)
 {
-  if (CONSTANT_CLASS_P (elt2) && TREE_OVERFLOW (elt2))
+  if (TREE_OVERFLOW_P (elt2))
     {
       gcc_assert (operand_equal_p (*elt1_ptr, elt2, 0));
       if (!TREE_OVERFLOW (elt2))
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 7e6de28..8e144bc 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -2719,7 +2719,7 @@ sign_mask_for (tree type)
     return NULL_TREE;
 
   auto mask = wi::set_bit_in_zero (bits - 1, bits);
-  if (TREE_CODE (inttype) == VECTOR_TYPE)
+  if (VECTOR_TYPE_P (inttype))
     {
       tree elt = wide_int_to_tree (TREE_TYPE (inttype), mask);
       return build_vector_from_val (inttype, elt);
@@ -4959,7 +4959,7 @@ do { tree _node = (NODE); \
      address is constant too.  If it's a decl, its address is constant if the
      decl is static.  Everything else is not constant and, furthermore,
      taking the address of a volatile variable is not volatile.  */
-  if (TREE_CODE (node) == INDIRECT_REF
+  if (INDIRECT_REF_P (node)
       || TREE_CODE (node) == MEM_REF)
     UPDATE_FLAGS (TREE_OPERAND (node, 0));
   else if (CONSTANT_CLASS_P (node))
@@ -13462,8 +13462,8 @@ verify_type_variant (const_tree t, tree tv)
   if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t))
        || TREE_CODE (t) == INTEGER_TYPE
        || TREE_CODE (t) == BOOLEAN_TYPE
-       || TREE_CODE (t) == REAL_TYPE
-       || TREE_CODE (t) == FIXED_POINT_TYPE)
+       || SCALAR_FLOAT_TYPE_P (t)
+       || FIXED_POINT_TYPE_P (t))
     {
       verify_variant_match (TYPE_MAX_VALUE);
       verify_variant_match (TYPE_MIN_VALUE);
@@ -13543,7 +13543,7 @@ verify_type_variant (const_tree t, tree tv)
           return false;
 	}
     }
-  else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE))
+  else if (FUNC_OR_METHOD_TYPE_P (t))
     verify_variant_match (TYPE_ARG_TYPES);
   /* For C++ the qualified variant of array type is really an array type
      of qualified TREE_TYPE.
@@ -13684,7 +13684,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
   /* Qualifiers do not matter for canonical type comparison purposes.  */
 
   /* Void types and nullptr types are always the same.  */
-  if (TREE_CODE (t1) == VOID_TYPE
+  if (VOID_TYPE_P (t1)
       || TREE_CODE (t1) == NULLPTR_TYPE)
     return true;
 
@@ -13696,7 +13696,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
   if (INTEGRAL_TYPE_P (t1)
       || SCALAR_FLOAT_TYPE_P (t1)
       || FIXED_POINT_TYPE_P (t1)
-      || TREE_CODE (t1) == VECTOR_TYPE
+      || VECTOR_TYPE_P (t1)
       || TREE_CODE (t1) == COMPLEX_TYPE
       || TREE_CODE (t1) == OFFSET_TYPE
       || POINTER_TYPE_P (t1))
@@ -13726,7 +13726,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
 	}
 
       /* Tail-recurse to components.  */
-      if (TREE_CODE (t1) == VECTOR_TYPE
+      if (VECTOR_TYPE_P (t1)
 	  || TREE_CODE (t1) == COMPLEX_TYPE)
 	return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
 						    TREE_TYPE (t2),
@@ -14043,8 +14043,8 @@ verify_type (const_tree t)
 	  error_found = true;
 	}
     }
-  else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
-	   || TREE_CODE (t) == FIXED_POINT_TYPE)
+  else if (INTEGRAL_TYPE_P (t) || SCALAR_FLOAT_TYPE_P (t)
+	   || FIXED_POINT_TYPE_P (t))
     {
       /* FIXME: The following check should pass:
 	  useless_type_conversion_p (const_cast <tree> (t),
@@ -14070,7 +14070,7 @@ verify_type (const_tree t)
 	  error_found = true;
 	}
     }
-  else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
+  else if (FUNC_OR_METHOD_TYPE_P (t))
     {
       if (TYPE_METHOD_BASETYPE (t)
 	  && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE
@@ -14092,8 +14092,8 @@ verify_type (const_tree t)
 	  error_found = true;
 	}
     }
-  else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE
-	   || TREE_CODE (t) == FIXED_POINT_TYPE)
+  else if (INTEGRAL_TYPE_P (t) || SCALAR_FLOAT_TYPE_P (t)
+	   || FIXED_POINT_TYPE_P (t))
     {
       /* FIXME: The following check should pass:
 	  useless_type_conversion_p (const_cast <tree> (t),
@@ -14235,7 +14235,7 @@ verify_type (const_tree t)
 	      }
 	}
     }
-  else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
+  else if (FUNC_OR_METHOD_TYPE_P (t))
     for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l))
       {
 	/* C++ FE uses TREE_PURPOSE to store initial values.  */
diff --git a/gcc/ubsan.cc b/gcc/ubsan.cc
index e6ffea3..cfae13d 100644
--- a/gcc/ubsan.cc
+++ b/gcc/ubsan.cc
@@ -328,7 +328,7 @@ ubsan_source_location (location_t loc)
 static unsigned short
 get_ubsan_type_info_for_type (tree type)
 {
-  if (TREE_CODE (type) == REAL_TYPE)
+  if (SCALAR_FLOAT_TYPE_P (type))
     return tree_to_uhwi (TYPE_SIZE (type));
   else if (INTEGRAL_TYPE_P (type))
     {
diff --git a/gcc/var-tracking.cc b/gcc/var-tracking.cc
index 68d440d..d8dafa5 100644
--- a/gcc/var-tracking.cc
+++ b/gcc/var-tracking.cc
@@ -6273,7 +6273,7 @@ prepare_call_arguments (basic_block bb, rtx_insn *insn)
 	type = TREE_TYPE (fndecl);
       if (fndecl && TREE_CODE (fndecl) != FUNCTION_DECL)
 	{
-	  if (TREE_CODE (fndecl) == INDIRECT_REF
+	  if (INDIRECT_REF_P (fndecl)
 	      && TREE_CODE (TREE_OPERAND (fndecl, 0)) == OBJ_TYPE_REF)
 	    obj_type_ref = TREE_OPERAND (fndecl, 0);
 	  fndecl = NULL_TREE;
@@ -9949,7 +9949,7 @@ vt_add_function_parameters (void)
     {
       tree vexpr = DECL_VALUE_EXPR (DECL_RESULT (current_function_decl));
 
-      if (TREE_CODE (vexpr) == INDIRECT_REF)
+      if (INDIRECT_REF_P (vexpr))
 	vexpr = TREE_OPERAND (vexpr, 0);
 
       if (TREE_CODE (vexpr) == PARM_DECL
diff --git a/gcc/varasm.cc b/gcc/varasm.cc
index cd0cd88..2e1dee4 100644
--- a/gcc/varasm.cc
+++ b/gcc/varasm.cc
@@ -3014,7 +3014,7 @@ decode_addr_const (tree exp, class addr_const *value)
 	  offset += mem_ref_offset (target).force_shwi ();
 	  target = TREE_OPERAND (TREE_OPERAND (target, 0), 0);
 	}
-      else if (TREE_CODE (target) == INDIRECT_REF
+      else if (INDIRECT_REF_P (target)
 	       && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR
 	       && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0))
 		  == ADDR_EXPR)