/gcc
2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
* typeck.c (cp_build_indirect_ref_1): Add location_t parameter
and use it in error messages.
(build_x_indirect_ref): Adjust call.
(build_indirect_ref): Likewise.
(cp_build_fold_indirect_ref): Likewise.
(cp_build_array_ref): Likewise.
* call.c (build_new_op_1): Likewise.
* semantics.c (finish_omp_clauses): Likewise.
(finish_omp_depobj): Likewise.
* typeck2.c (build_x_arrow): Likewise.
* cp-tree.h (cp_build_indirect_ref): Update declaration.
* call.c (build_new_op_1): Use location argument in warning_at.
* typeck.c (cp_build_modify_expr): Consistently use the
location_t argument.
/libcc1
2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
* libcp1plugin.cc (plugin_pragma_push_user_expression): Update
cp_build_indirect_ref call.
/gcc/testsuite
2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
* g++.dg/diagnostic/base-operand-non-pointer-1.C: New.
* g++.dg/pr53055.C: Check location too.
* g++.old-deja/g++.bugs/900213_02.C: Likewise.
* g++.old-deja/g++.bugs/900215_02.C: Likewise.
* g++.old-deja/g++.other/badarrow.C: Likewise.
* g++.old-deja/g++.other/deref1.C: Likewise.
* g++.dg/warn/Wenum-compare.C: Check location too.
* g++.dg/cpp0x/initlist26.C: Check location too.
* g++.dg/cpp0x/initlist28.C: Likewise.
* g++.dg/cpp0x/initlist29.C: Likewise.
* g++.dg/cpp0x/initlist33.C: Likewise.
* g++.dg/expr/string-2.C: Likewise.
* g++.dg/other/ptrmem5.C: Likewise.
* g++.old-deja/g++.benjamin/14664-1.C: Likewise.
* g++.old-deja/g++.benjamin/14664-2.C: Likewise.
* g++.old-deja/g++.brendan/init12.C: Likewise.
* g++.old-deja/g++.bugs/900324_04.C: Likewise.
* g++.old-deja/g++.ext/array1.C: Likewise.
* g++.old-deja/g++.jason/rfg17.C: Likewise.
From-SVN: r278685
+2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * typeck.c (cp_build_indirect_ref_1): Add location_t parameter
+ and use it in error messages.
+ (build_x_indirect_ref): Adjust call.
+ (build_indirect_ref): Likewise.
+ (cp_build_fold_indirect_ref): Likewise.
+ (cp_build_array_ref): Likewise.
+ * call.c (build_new_op_1): Likewise.
+ * semantics.c (finish_omp_clauses): Likewise.
+ (finish_omp_depobj): Likewise.
+ * typeck2.c (build_x_arrow): Likewise.
+ * cp-tree.h (cp_build_indirect_ref): Update declaration.
+
+ * call.c (build_new_op_1): Use location argument in warning_at.
+
+ * typeck.c (cp_build_modify_expr): Consistently use the
+ location_t argument.
+
2019-11-23 Bernd Edlinger <bernd.edlinger@hotmail.de>
PR c++/92365
&& (TYPE_MAIN_VARIANT (arg1_type)
!= TYPE_MAIN_VARIANT (arg2_type))
&& (complain & tf_warning))
- {
- warning (OPT_Wenum_compare,
- "comparison between %q#T and %q#T",
- arg1_type, arg2_type);
- }
+ warning_at (loc, OPT_Wenum_compare,
+ "comparison between %q#T and %q#T",
+ arg1_type, arg2_type);
break;
default:
break;
return cp_build_modify_expr (loc, arg1, code2, arg2, complain);
case INDIRECT_REF:
- return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
+ return cp_build_indirect_ref (loc, arg1, RO_UNARY_STAR, complain);
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
return cp_build_array_ref (input_location, arg1, arg2, complain);
case MEMBER_REF:
- return build_m_component_ref (cp_build_indirect_ref (arg1, RO_ARROW_STAR,
- complain),
+ return build_m_component_ref (cp_build_indirect_ref (loc, arg1,
+ RO_ARROW_STAR,
+ complain),
arg2, complain);
/* The caller will deal with these. */
extern tree finish_class_member_access_expr (cp_expr, tree, bool,
tsubst_flags_t);
extern tree build_x_indirect_ref (location_t, tree,
- ref_operator, tsubst_flags_t);
-extern tree cp_build_indirect_ref (tree, ref_operator,
- tsubst_flags_t);
+ ref_operator,
+ tsubst_flags_t);
+extern tree cp_build_indirect_ref (location_t, tree,
+ ref_operator,
+ tsubst_flags_t);
extern tree cp_build_fold_indirect_ref (tree);
extern tree build_array_ref (location_t, tree, tree);
extern tree cp_build_array_ref (location_t, tree, tree,
remove = true;
else
{
- t = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+ t = cp_build_indirect_ref (OMP_CLAUSE_LOCATION (c),
+ addr, RO_UNARY_STAR,
tf_warning_or_error);
if (t == error_mark_node)
remove = true;
if (addr == error_mark_node)
depobj = error_mark_node;
else
- depobj = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+ depobj = cp_build_indirect_ref (loc, addr, RO_UNARY_STAR,
tf_warning_or_error);
}
rval = build_new_op (loc, INDIRECT_REF, LOOKUP_NORMAL, expr,
NULL_TREE, NULL_TREE, &overload, complain);
if (!rval)
- rval = cp_build_indirect_ref (expr, errorstring, complain);
+ rval = cp_build_indirect_ref (loc, expr, errorstring, complain);
if (processing_template_decl && rval != error_mark_node)
{
constructs. If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR. */
static tree
-cp_build_indirect_ref_1 (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref_1 (location_t loc, tree ptr, ref_operator errorstring,
tsubst_flags_t complain, bool do_fold)
{
tree pointer, type;
/* A pointer to incomplete type (other than cv void) can be
dereferenced [expr.unary.op]/1 */
if (complain & tf_error)
- error ("%qT is not a pointer-to-object type", type);
+ error_at (loc, "%qT is not a pointer-to-object type", type);
return error_mark_node;
}
else if (do_fold && TREE_CODE (pointer) == ADDR_EXPR
switch (errorstring)
{
case RO_ARRAY_INDEXING:
- error ("invalid use of array indexing on pointer to member");
+ error_at (loc,
+ "invalid use of array indexing on pointer to member");
break;
case RO_UNARY_STAR:
- error ("invalid use of unary %<*%> on pointer to member");
+ error_at (loc, "invalid use of unary %<*%> on pointer to member");
break;
case RO_IMPLICIT_CONVERSION:
- error ("invalid use of implicit conversion on pointer to member");
+ error_at (loc, "invalid use of implicit conversion on pointer "
+ "to member");
break;
case RO_ARROW_STAR:
- error ("left hand operand of %<->*%> must be a pointer to class, "
- "but is a pointer to member of type %qT", type);
+ error_at (loc, "left hand operand of %<->*%> must be a pointer to "
+ "class, but is a pointer to member of type %qT", type);
break;
default:
gcc_unreachable ();
}
else if (pointer != error_mark_node)
- invalid_indirection_error (input_location, type, errorstring);
+ invalid_indirection_error (loc, type, errorstring);
return error_mark_node;
}
/* Entry point used by c-common, which expects folding. */
tree
-build_indirect_ref (location_t /*loc*/,
- tree ptr, ref_operator errorstring)
+build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring)
{
- return cp_build_indirect_ref_1 (ptr, errorstring, tf_warning_or_error, true);
+ return cp_build_indirect_ref_1 (loc, ptr, errorstring,
+ tf_warning_or_error, true);
}
/* Entry point used by internal indirection needs that don't correspond to any
tree
cp_build_fold_indirect_ref (tree pointer)
{
- return cp_build_indirect_ref_1 (pointer, RO_NULL, tf_warning_or_error, true);
+ return cp_build_indirect_ref_1 (input_location, pointer, RO_NULL,
+ tf_warning_or_error, true);
}
/* Entry point used by indirection needs that correspond to some syntactic
construct. */
tree
-cp_build_indirect_ref (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring,
tsubst_flags_t complain)
{
- return cp_build_indirect_ref_1 (ptr, errorstring, complain, false);
+ return cp_build_indirect_ref_1 (loc, ptr, errorstring, complain, false);
}
/* This handles expressions of the form "a[i]", which denotes
ret = cp_build_binary_op (input_location, PLUS_EXPR, ar, ind, complain);
if (first)
ret = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (ret), first, ret);
- ret = cp_build_indirect_ref (ret, RO_ARRAY_INDEXING, complain);
+ ret = cp_build_indirect_ref (loc, ret, RO_ARRAY_INDEXING, complain);
protected_set_expr_location (ret, loc);
if (non_lvalue)
ret = non_lvalue_loc (loc, ret);
if (VOID_TYPE_P (TREE_TYPE (rhs)))
{
if (complain & tf_error)
- error ("void value not ignored as it ought to be");
+ error_at (cp_expr_loc_or_loc (rhs, loc),
+ "void value not ignored as it ought to be");
return error_mark_node;
}
if (modifycode != INIT_EXPR)
{
if (complain & tf_error)
- error ("assigning to an array from an initializer list");
+ error_at (loc,
+ "assigning to an array from an initializer list");
return error_mark_node;
}
if (check_array_initializer (lhs, lhstype, newrhs))
TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))))
{
if (complain & tf_error)
- error ("incompatible types in assignment of %qT to %qT",
- TREE_TYPE (rhs), lhstype);
+ error_at (loc, "incompatible types in assignment of %qT to %qT",
+ TREE_TYPE (rhs), lhstype);
return error_mark_node;
}
if (complain & tf_error)
{
if (modifycode == INIT_EXPR)
- error ("array used as initializer");
+ error_at (loc, "array used as initializer");
else
- error ("invalid array assignment");
+ error_at (loc, "invalid array assignment");
}
return error_mark_node;
}
return expr;
}
- return cp_build_indirect_ref (last_rval, RO_ARROW, complain);
+ return cp_build_indirect_ref (loc, last_rval, RO_ARROW, complain);
}
if (complain & tf_error)
+2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * g++.dg/diagnostic/base-operand-non-pointer-1.C: New.
+ * g++.dg/pr53055.C: Check location too.
+ * g++.old-deja/g++.bugs/900213_02.C: Likewise.
+ * g++.old-deja/g++.bugs/900215_02.C: Likewise.
+ * g++.old-deja/g++.other/badarrow.C: Likewise.
+ * g++.old-deja/g++.other/deref1.C: Likewise.
+
+ * g++.dg/warn/Wenum-compare.C: Check location too.
+
+ * g++.dg/cpp0x/initlist26.C: Check location too.
+ * g++.dg/cpp0x/initlist28.C: Likewise.
+ * g++.dg/cpp0x/initlist29.C: Likewise.
+ * g++.dg/cpp0x/initlist33.C: Likewise.
+ * g++.dg/expr/string-2.C: Likewise.
+ * g++.dg/other/ptrmem5.C: Likewise.
+ * g++.old-deja/g++.benjamin/14664-1.C: Likewise.
+ * g++.old-deja/g++.benjamin/14664-2.C: Likewise.
+ * g++.old-deja/g++.brendan/init12.C: Likewise.
+ * g++.old-deja/g++.bugs/900324_04.C: Likewise.
+ * g++.old-deja/g++.ext/array1.C: Likewise.
+ * g++.old-deja/g++.jason/rfg17.C: Likewise.
+
2019-11-25 Joseph Myers <joseph@codesourcery.com>
PR c/91985
foo (int i)
{
int a[i];
- a = { }; // { dg-error "assign" }
+ a = { }; // { dg-error "5:assigning to an array from an initializer list" }
}
void foo()
{
int a[1];
- throw a = {}; // { dg-error "assign" }
+ throw a = {}; // { dg-error "11:assigning to an array from an initializer list" }
}
{
public:
Mesh(const char*)
- { typele={0}; } // { dg-error "" }
+ { typele={0}; } // { dg-error "11:assigning to an array from an initializer list" }
private:
int typele[7][2];
int main()
{
base ptr_array[1];
- ptr_array = { base() }; // { dg-error "assign" }
+ ptr_array = { base() }; // { dg-error "12:assigning to an array from an initializer list" }
}
--- /dev/null
+class C { public: C f(); int get(); };
+int f(C* p) { return p->f()->get(); } // { dg-error "28:base operand of .->. has non-pointer type .C." }
char a[1];
-int foo(a = "") // { dg-error "invalid array assignment" }
+int foo(a = "") // { dg-error "11:invalid array assignment" }
{
return 0;
}
int main()
{
int a::*n[8];
- n = &a::x; // { dg-error "int \\(a::\\*\\)" }
+ n = &a::x; // { dg-error "5:incompatible types in assignment of .int \\(a::\\*\\)" }
}
// { dg-do compile }
struct A A :: * p ;
-int i = p ->* p ; // { dg-error "" }
+int i = p ->* p ; // { dg-error "11:left hand operand" }
int foo (E1 e1, E2 e2)
{
- return e1 == e2; /* { dg-warning "comparison between" } */
+ return e1 == e2; /* { dg-warning "13:comparison between" } */
}
{
//-g++: incompatible types in assignment of 'const char[]' to 'char[]'
//-edg: expression must be a modifiable lvalue
- foo = "0123456789012345678901234"; // { dg-error "" } // ERROR -
+ foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" } // ERROR -
}
void bar()
{
- foo = "0123456789012345678901234"; // { dg-error "array" }
+ foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" }
}
int main()
{
char a[1][2];
- a[0] = bob();// { dg-error "" } .*
+ a[0] = bob();// { dg-error "10:incompatible types in assignment" } .*
}
void global_function_0 ()
{
- i = *dmp; // { dg-error "invalid use of unary '\\\*' on pointer to member" } causes abort
+ i = *dmp; // { dg-error "7:invalid use of unary '\\\*' on pointer to member" } causes abort
}
int main () { return 0; }
i = (this->*fmp) (); // perfectly legal - for both cfront and g++
i = this->*dmp; // perfectly legal - for both cfront and g++
- i = (*fmp) (); // { dg-error "invalid use of unary '\\\*' on pointer to member" }
- i = *dmp; // { dg-error "invalid use of unary '\\\*' on pointer to member" }
+ i = (*fmp) (); // { dg-error "8:invalid use of unary '\\\*' on pointer to member" }
+ i = *dmp; // { dg-error "7:invalid use of unary '\\\*' on pointer to member" }
}
int main () { return 0; }
void function_0 ()
{
- ia1 = ia2; // { dg-error "" } gnu extension
+ ia1 = ia2; // { dg-error "7:invalid array assignment" } gnu extension
}
int main () { return 0; }
ccBgaInspection::reinspect (unsigned long diag_flags)
{
ct2d_rigid physTdev;
- _dev2phys = physTdev; // { dg-error "" }
+ _dev2phys = physTdev; // { dg-error "13:incompatible types in assignment" }
}
test ()
{
b1 = b2; /* OK */
- a1 = a2; /* { dg-error "" } array assignment */
+ a1 = a2; /* { dg-error "6:invalid array assignment" } array assignment */
}
void f()
{
- s->i = 3; // { dg-error "" } base operand
+ s->i = 3; // { dg-error "4:base operand of .->. has non-pointer type .S." } base operand
}
void fn (void *vp, volatile void *vvp)
{
- *vp; // { dg-error "" } not a pointer to object
- *vvp; // { dg-error "" } not a pointer to object
- &*vp; // { dg-error "" } not a pointer to object
- &*vvp; // { dg-error "" } not a pointer to object
+ *vp; // { dg-error "3:.void\\*. is not a pointer-to-object type" } not a pointer to object
+ *vvp; // { dg-error "3:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
+ &*vp; // { dg-error "4:.void\\*. is not a pointer-to-object type" } not a pointer to object
+ &*vvp; // { dg-error "4:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
}
+2019-11-25 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * libcp1plugin.cc (plugin_pragma_push_user_expression): Update
+ cp_build_indirect_ref call.
+
2019-09-27 Maciej W. Rozycki <macro@wdc.com>
* configure: Regenerate.
usable. */
tree this_val = lookup_name (get_identifier ("this"));
current_class_ref = !this_val ? NULL_TREE
- : cp_build_indirect_ref (this_val, RO_NULL, tf_warning_or_error);
+ : cp_build_indirect_ref (input_location, this_val, RO_NULL,
+ tf_warning_or_error);
current_class_ptr = this_val;
}
}
projects / gcc.git / commitdiff