@@ -4816,6 +4816,9 @@ build_conditional_expr_1 (location_t loc, tree arg1, tree arg2, tree arg3,
orig_arg2 = arg2;
orig_arg3 = arg3;
+ STRIP_ANY_LOCATION_WRAPPER (arg2);
+ STRIP_ANY_LOCATION_WRAPPER (arg3);
+
if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1)))
{
tree arg1_type = TREE_TYPE (arg1);
@@ -5588,6 +5591,10 @@ build_new_op_1 (location_t loc, enum tree_code code, int flags, tree arg1,
|| error_operand_p (arg3))
return error_mark_node;
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (arg1);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (arg2);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (arg3);
+
bool ismodop = code == MODIFY_EXPR;
if (ismodop)
{
@@ -1377,6 +1377,7 @@ mark_or_check_attr_tags (tree attr, tree *tp, abi_tag_data *p, bool val)
list = TREE_CHAIN (list))
{
tree tag = TREE_VALUE (list);
+ STRIP_ANY_LOCATION_WRAPPER (tag);
tree id = get_identifier (TREE_STRING_POINTER (tag));
if (tp)
check_tag (tag, id, tp, p);
@@ -3943,6 +3943,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t,
tree *jump_target)
{
constexpr_ctx new_ctx;
+ STRIP_ANY_LOCATION_WRAPPER (t);
tree r = t;
if (jump_target && *jump_target)
@@ -766,6 +766,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags,
the original value is within the range of the enumeration
values. Otherwise, the resulting enumeration value is
unspecified. */
+ STRIP_ANY_LOCATION_WRAPPER (e);
if ((complain & tf_warning)
&& TREE_CODE (e) == INTEGER_CST
&& ENUM_UNDERLYING_TYPE (type)
@@ -5809,6 +5809,8 @@ reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
if (error_operand_p (init))
return error_mark_node;
+ STRIP_ANY_LOCATION_WRAPPER (init);
+
if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
&& has_designator_problem (d, complain))
return error_mark_node;
@@ -8115,6 +8117,8 @@ cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
int failure;
tree type, elt_type;
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (initial_value);
+
/* Don't get confused by a CONSTRUCTOR for some other type. */
if (initial_value && TREE_CODE (initial_value) == CONSTRUCTOR
&& !BRACE_ENCLOSED_INITIALIZER_P (initial_value)
@@ -220,6 +220,8 @@ mark_discarded_use (tree expr)
if (expr == NULL_TREE)
return expr;
+ STRIP_ANY_LOCATION_WRAPPER (expr);
+
switch (TREE_CODE (expr))
{
case COND_EXPR:
@@ -428,6 +428,8 @@ build_capture_proxy (tree member, tree init)
TREE_USED (var) = 1;
DECL_CONTEXT (var) = fn;
+ STRIP_ANY_LOCATION_WRAPPER (init);
+
if (DECL_NORMAL_CAPTURE_P (member))
{
if (DECL_VLA_CAPTURE_P (member))
@@ -444,6 +446,7 @@ build_capture_proxy (tree member, tree init)
init = TREE_OPERAND (init, 0);
STRIP_NOPS (init);
}
+ STRIP_ANY_LOCATION_WRAPPER (init);
gcc_assert (VAR_P (init) || TREE_CODE (init) == PARM_DECL);
while (is_normal_capture_proxy (init))
init = DECL_CAPTURED_VARIABLE (init);
@@ -5026,6 +5026,7 @@ handle_namespace_attrs (tree ns, tree attributes)
rather than the namespace as a whole, so we don't touch the
NAMESPACE_DECL at all. */
tree x = args ? TREE_VALUE (args) : NULL_TREE;
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (x);
if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
{
warning (OPT_Wattributes,
@@ -7168,9 +7168,12 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
}
}
- if (TREE_CODE (postfix_expression) == FUNCTION_DECL
- && DECL_BUILT_IN_CLASS (postfix_expression) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (postfix_expression) == BUILT_IN_MEMSET
+ tree postfix_expr_noloc = postfix_expression;
+ STRIP_ANY_LOCATION_WRAPPER (postfix_expr_noloc);
+
+ if (TREE_CODE (postfix_expr_noloc) == FUNCTION_DECL
+ && DECL_BUILT_IN_CLASS (postfix_expr_noloc) == BUILT_IN_NORMAL
+ && DECL_FUNCTION_CODE (postfix_expr_noloc) == BUILT_IN_MEMSET
&& vec_safe_length (args) == 3)
{
tree arg0 = (*args)[0];
@@ -7184,10 +7187,10 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
warn_for_memset (input_location, arg0, arg2, literal_mask);
}
- if (TREE_CODE (postfix_expression) == COMPONENT_REF)
+ if (TREE_CODE (postfix_expr_noloc) == COMPONENT_REF)
{
- tree instance = TREE_OPERAND (postfix_expression, 0);
- tree fn = TREE_OPERAND (postfix_expression, 1);
+ tree instance = TREE_OPERAND (postfix_expr_noloc, 0);
+ tree fn = TREE_OPERAND (postfix_expr_noloc, 1);
if (processing_template_decl
&& (type_dependent_object_expression_p (instance)
@@ -7221,9 +7224,9 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
/*koenig_p=*/false,
complain);
}
- else if (TREE_CODE (postfix_expression) == OFFSET_REF
- || TREE_CODE (postfix_expression) == MEMBER_REF
- || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
+ else if (TREE_CODE (postfix_expr_noloc) == OFFSET_REF
+ || TREE_CODE (postfix_expr_noloc) == MEMBER_REF
+ || TREE_CODE (postfix_expr_noloc) == DOTSTAR_EXPR)
postfix_expression = (build_offset_ref_call_from_tree
(postfix_expression, &args,
complain));
@@ -8335,18 +8338,22 @@ cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
case NEGATE_EXPR:
/* Immediately fold negation of a constant, unless the constant is 0
(since -0 == 0) or it would overflow. */
- if (unary_operator == NEGATE_EXPR && op_ttype == CPP_NUMBER
- && CONSTANT_CLASS_P (cast_expression)
- && !integer_zerop (cast_expression)
- && !TREE_OVERFLOW (cast_expression))
+ if (unary_operator == NEGATE_EXPR && op_ttype == CPP_NUMBER)
{
- tree folded = fold_build1 (unary_operator,
- TREE_TYPE (cast_expression),
- cast_expression);
- if (CONSTANT_CLASS_P (folded) && !TREE_OVERFLOW (folded))
+ cast_expression.strip_any_location_wrapper ();
+ if (CONSTANT_CLASS_P (cast_expression)
+ && !integer_zerop (cast_expression)
+ && !TREE_OVERFLOW (cast_expression))
{
- expression = cp_expr (folded, loc);
- break;
+ tree folded = fold_build1 (unary_operator,
+ TREE_TYPE (cast_expression),
+ cast_expression);
+ if (CONSTANT_CLASS_P (folded) && !TREE_OVERFLOW (folded))
+ {
+ expression = cp_expr (folded, loc);
+ expression.maybe_add_location_wrapper ();
+ break;
+ }
}
}
/* Fall through. */
@@ -16415,6 +16422,7 @@ cp_parser_template_argument (cp_parser* parser)
/*cast_p=*/false,
/*template_arg_p=*/true,
&idk);
+ STRIP_ANY_LOCATION_WRAPPER (argument);
if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
|| !cp_parser_next_token_ends_template_argument_p (parser))
cp_parser_simulate_error (parser);
@@ -16444,6 +16452,7 @@ cp_parser_template_argument (cp_parser* parser)
/*cast_p=*/false,
/*template_arg_p=*/true,
&idk);
+ STRIP_ANY_LOCATION_WRAPPER (argument);
if (cp_parser_error_occurred (parser)
|| !cp_parser_next_token_ends_template_argument_p (parser))
cp_parser_abort_tentative_parse (parser);
@@ -34686,6 +34695,7 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
cp_lexer_consume_token (parser->lexer);
lhs = cp_parser_simple_cast_expression (parser);
+ STRIP_ANY_LOCATION_WRAPPER (lhs);
if (lhs != decl
&& (!processing_template_decl || !cp_tree_equal (lhs, decl)))
return error_mark_node;
@@ -34693,6 +34703,7 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
}
lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
+ STRIP_ANY_LOCATION_WRAPPER (lhs);
if (lhs != decl
&& (!processing_template_decl || !cp_tree_equal (lhs, decl)))
return error_mark_node;
@@ -34720,6 +34731,8 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
lhs = cp_parser_binary_expression (parser, false, false,
PREC_ADDITIVE_EXPRESSION, NULL);
token = cp_lexer_peek_token (parser->lexer);
+
+ STRIP_ANY_LOCATION_WRAPPER (lhs);
decl_first = (lhs == decl
|| (processing_template_decl && cp_tree_equal (lhs, decl)));
if (decl_first)
@@ -34754,6 +34767,7 @@ cp_parser_omp_for_incr (cp_parser *parser, tree decl)
if (!decl_first)
{
+ STRIP_ANY_LOCATION_WRAPPER (rhs);
if ((rhs != decl
&& (!processing_template_decl || !cp_tree_equal (rhs, decl)))
|| op == MINUS_EXPR)
@@ -34943,6 +34957,7 @@ cp_parser_omp_for_loop_init (cp_parser *parser,
cp_parser_parse_tentatively (parser);
decl = cp_parser_primary_expression (parser, false, false,
false, &idk);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (decl);
cp_token *last_tok = cp_lexer_peek_token (parser->lexer);
if (!cp_parser_error_occurred (parser)
&& decl
@@ -37563,10 +37578,13 @@ cp_parser_omp_declare_reduction_exprs (tree fndecl, cp_parser *parser)
unsigned int i;
tree arg;
FOR_EACH_VEC_SAFE_ELT (args, i, arg)
- if (arg == omp_priv
- || (TREE_CODE (arg) == ADDR_EXPR
- && TREE_OPERAND (arg, 0) == omp_priv))
- break;
+ {
+ STRIP_ANY_LOCATION_WRAPPER (arg);
+ if (arg == omp_priv
+ || (TREE_CODE (arg) == ADDR_EXPR
+ && TREE_OPERAND (arg, 0) == omp_priv))
+ break;
+ }
cp_parser_abort_tentative_parse (parser);
if (arg == NULL_TREE)
error ("one of the initializer call arguments should be %<omp_priv%>"
@@ -39165,6 +39183,7 @@ cp_parser_cilk_simd_linear (cp_parser *parser, tree clauses)
e = cp_parser_assignment_expression (parser);
e = maybe_constant_value (e);
+ STRIP_ANY_LOCATION_WRAPPER (e);
if (e == error_mark_node)
{
@@ -6063,6 +6063,7 @@ convert_nontype_argument_function (tree type, tree expr,
-- the address of an object or function with external [C++11: or
internal] linkage. */
+ STRIP_ANY_LOCATION_WRAPPER (fn_no_ptr);
if (TREE_CODE (fn_no_ptr) != FUNCTION_DECL)
{
if (complain & tf_error)
@@ -6410,6 +6411,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
{
tree expr_type;
location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
+ STRIP_ANY_LOCATION_WRAPPER (expr);
tree orig_expr = expr;
/* Detect immediately string literals as invalid non-type argument.
@@ -6475,6 +6477,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
to a null value, but otherwise still need to be of a specific form. */
if (cxx_dialect >= cxx11)
{
+ STRIP_ANY_LOCATION_WRAPPER (expr);
if (TREE_CODE (expr) == PTRMEM_CST)
/* A PTRMEM_CST is already constant, and a valid template
argument for a parameter of pointer to member type, we just want
@@ -6506,6 +6509,8 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
else
expr = mark_rvalue_use (expr);
+ STRIP_ANY_LOCATION_WRAPPER (expr);
+
/* HACK: Due to double coercion, we can get a
NOP_EXPR<REFERENCE_TYPE>(ADDR_EXPR<POINTER_TYPE> (arg)) here,
which is the tree that we built on the first call (see
@@ -6559,6 +6564,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
/* Notice that there are constant expressions like '4 % 0' which
do not fold into integer constants. */
+ STRIP_ANY_LOCATION_WRAPPER (expr);
if (TREE_CODE (expr) != INTEGER_CST
&& !value_dependent_expression_p (expr))
{
@@ -6592,6 +6598,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
conversion (_conv.array_) are applied. */
else if (TYPE_PTROBV_P (type))
{
+ STRIP_ANY_LOCATION_WRAPPER (expr);
tree decayed = expr;
/* Look through any NOP_EXPRs around an ADDR_EXPR, whether they come from
@@ -6630,6 +6637,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
/* Null pointer values are OK in C++11. */;
else if (TREE_CODE (expr) != ADDR_EXPR)
{
+ STRIP_ANY_LOCATION_WRAPPER (expr);
if (VAR_P (expr))
{
if (complain & tf_error)
@@ -6653,7 +6661,7 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
else
{
tree decl = TREE_OPERAND (expr, 0);
-
+ STRIP_ANY_LOCATION_WRAPPER (decl);
if (!VAR_P (decl))
{
if (complain & tf_error)
@@ -1489,6 +1489,8 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands,
otherwise we'll get an error. Gross, but ... */
STRIP_NOPS (operand);
+ STRIP_ANY_LOCATION_WRAPPER (operand);
+
operand = mark_lvalue_use (operand);
if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error))
@@ -2249,6 +2251,8 @@ perform_koenig_lookup (cp_expr fn, vec<tree, va_gc> *args,
bool template_id = false;
location_t loc = fn.get_location ();
+ fn.strip_any_location_wrapper ();
+
if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
{
/* Use a separate flag to handle null args. */
@@ -4603,7 +4607,9 @@ handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
type = TREE_TYPE (ret);
low_bound = TREE_PURPOSE (t);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (low_bound);
length = TREE_VALUE (t);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (length);
if ((low_bound && type_dependent_expression_p (low_bound))
|| (length && type_dependent_expression_p (length)))
return NULL_TREE;
@@ -4894,11 +4900,13 @@ handle_omp_array_sections (tree c, enum c_omp_region_type ort)
tree length = TREE_VALUE (t);
i--;
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (low_bound);
if (low_bound
&& TREE_CODE (low_bound) == INTEGER_CST
&& TYPE_PRECISION (TREE_TYPE (low_bound))
> TYPE_PRECISION (sizetype))
low_bound = fold_convert (sizetype, low_bound);
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (length);
if (length
&& TREE_CODE (length) == INTEGER_CST
&& TYPE_PRECISION (TREE_TYPE (length))
@@ -5204,6 +5212,7 @@ omp_reduction_lookup (location_t loc, tree id, tree type, tree *baselinkp,
type),
false, false);
tree fns = id;
+ STRIP_ANY_LOCATION_WRAPPER (fns);
id = NULL_TREE;
if (fns && is_overloaded_fn (fns))
{
@@ -8062,22 +8071,25 @@ finish_omp_for (location_t locus, enum tree_code code, tree declv,
if (decl == NULL)
{
if (init != NULL)
- switch (TREE_CODE (init))
- {
- case MODIFY_EXPR:
- decl = TREE_OPERAND (init, 0);
- init = TREE_OPERAND (init, 1);
- break;
- case MODOP_EXPR:
- if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
- {
- decl = TREE_OPERAND (init, 0);
- init = TREE_OPERAND (init, 2);
- }
- break;
- default:
- break;
- }
+ {
+ STRIP_ANY_LOCATION_WRAPPER (init);
+ switch (TREE_CODE (init))
+ {
+ case MODIFY_EXPR:
+ decl = TREE_OPERAND (init, 0);
+ init = TREE_OPERAND (init, 1);
+ break;
+ case MODOP_EXPR:
+ if (TREE_CODE (TREE_OPERAND (init, 1)) == NOP_EXPR)
+ {
+ decl = TREE_OPERAND (init, 0);
+ init = TREE_OPERAND (init, 2);
+ }
+ break;
+ default:
+ break;
+ }
+ }
if (decl == NULL)
{
@@ -333,6 +333,8 @@ bitfield_p (const_tree ref)
tree
cp_stabilize_reference (tree ref)
{
+ STRIP_ANY_LOCATION_WRAPPER (ref);
+
switch (TREE_CODE (ref))
{
case NON_DEPENDENT_EXPR:
@@ -377,6 +379,8 @@ cp_stabilize_reference (tree ref)
bool
builtin_valid_in_constant_expr_p (const_tree decl)
{
+ STRIP_ANY_LOCATION_WRAPPER (decl);
+
if (!(TREE_CODE (decl) == FUNCTION_DECL
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL))
/* Not a built-in. */
@@ -2425,6 +2429,8 @@ lookup_keep (tree lookup, bool keep)
int
is_overloaded_fn (tree x)
{
+ STRIP_ANY_LOCATION_WRAPPER (x);
+
/* A baselink is also considered an overloaded function. */
if (TREE_CODE (x) == OFFSET_REF
|| TREE_CODE (x) == COMPONENT_REF)
@@ -2472,6 +2478,7 @@ really_overloaded_fn (tree x)
tree
get_fns (tree from)
{
+ STRIP_ANY_LOCATION_WRAPPER (from);
/* A baselink is also considered an overloaded function. */
if (TREE_CODE (from) == OFFSET_REF
|| TREE_CODE (from) == COMPONENT_REF)
@@ -4467,6 +4474,7 @@ check_abi_tag_args (tree args, tree name)
for (tree arg = args; arg; arg = TREE_CHAIN (arg))
{
tree elt = TREE_VALUE (arg);
+ STRIP_ANY_LOCATION_WRAPPER (elt);
if (TREE_CODE (elt) != STRING_CST
|| (!same_type_ignoring_top_level_qualifiers_p
(strip_array_types (TREE_TYPE (elt)),
@@ -1614,6 +1614,8 @@ cxx_sizeof_nowarn (tree type)
static tree
cxx_sizeof_expr (tree e, tsubst_flags_t complain)
{
+ STRIP_ANY_LOCATION_WRAPPER (e);
+
if (e == error_mark_node)
return error_mark_node;
@@ -4202,6 +4204,9 @@ cp_build_binary_op (location_t location,
/* True if both operands have arithmetic type. */
bool arithmetic_types_p;
+ STRIP_ANY_LOCATION_WRAPPER (orig_op0);
+ STRIP_ANY_LOCATION_WRAPPER (orig_op1);
+
/* Apply default conversions. */
op0 = orig_op0;
op1 = orig_op1;
@@ -4394,6 +4399,7 @@ cp_build_binary_op (location_t location,
tree type0 = TREE_OPERAND (op0, 0);
tree type1 = TREE_OPERAND (op1, 0);
tree first_arg = type0;
+ STRIP_ANY_LOCATION_WRAPPER (first_arg);
if (!TYPE_P (type0))
type0 = TREE_TYPE (type0);
if (!TYPE_P (type1))
@@ -7751,6 +7757,9 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
{
lhs = mark_lvalue_use_nonread (lhs);
+ STRIP_ANY_LOCATION_WRAPPER (lhs);
+ STRIP_ANY_LOCATION_WRAPPER (rhs);
+
tree result = NULL_TREE;
tree newrhs = rhs;
tree lhstype = TREE_TYPE (lhs);
@@ -8888,10 +8897,16 @@ maybe_warn_about_returning_address_of_local (tree retval)
for (;;)
{
if (TREE_CODE (whats_returned) == COMPOUND_EXPR)
- whats_returned = TREE_OPERAND (whats_returned, 1);
+ {
+ whats_returned = TREE_OPERAND (whats_returned, 1);
+ STRIP_ANY_LOCATION_WRAPPER (whats_returned);
+ }
else if (CONVERT_EXPR_P (whats_returned)
|| TREE_CODE (whats_returned) == NON_LVALUE_EXPR)
- whats_returned = TREE_OPERAND (whats_returned, 0);
+ {
+ whats_returned = TREE_OPERAND (whats_returned, 0);
+ STRIP_ANY_LOCATION_WRAPPER (whats_returned);
+ }
else
break;
}
@@ -8899,10 +8914,14 @@ maybe_warn_about_returning_address_of_local (tree retval)
if (TREE_CODE (whats_returned) != ADDR_EXPR)
return false;
whats_returned = TREE_OPERAND (whats_returned, 0);
+ STRIP_ANY_LOCATION_WRAPPER (whats_returned);
while (TREE_CODE (whats_returned) == COMPONENT_REF
|| TREE_CODE (whats_returned) == ARRAY_REF)
- whats_returned = TREE_OPERAND (whats_returned, 0);
+ {
+ whats_returned = TREE_OPERAND (whats_returned, 0);
+ STRIP_ANY_LOCATION_WRAPPER (whats_returned);
+ }
if (TREE_CODE (valtype) == REFERENCE_TYPE)
{
@@ -464,6 +464,8 @@ cxx_incomplete_type_diagnostic (location_t loc, const_tree value,
if (TREE_CODE (type) == ERROR_MARK)
return;
+ STRIP_ANY_LOCATION_WRAPPER_SAFE (value);
+
if (value != 0 && (VAR_P (value)
|| TREE_CODE (value) == PARM_DECL
|| TREE_CODE (value) == FIELD_DECL))
@@ -1023,6 +1025,8 @@ digest_init_r (tree type, tree init, bool nested, int flags,
location_t loc = EXPR_LOC_OR_LOC (init, input_location);
+ STRIP_ANY_LOCATION_WRAPPER (init);
+
/* Initialization of an array of chars from a string constant. The initializer
can be optionally enclosed in braces, but reshape_init has already removed
them if they were present. */