This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
RFC: C++ PATCH to adjust empty class parameter passing ABI
- From: Jason Merrill <jason at redhat dot com>
- To: gcc-patches List <gcc-patches at gcc dot gnu dot org>, Jonathan Wakely <jwakely at redhat dot com>
- Cc: "H.J. Lu" <hjl dot tools at gmail dot com>
- Date: Tue, 12 Apr 2016 16:27:48 -0400
- Subject: RFC: C++ PATCH to adjust empty class parameter passing ABI
- Authentication-results: sourceware.org; auth=none
A revision of the patch previously posted at
https://gcc.gnu.org/ml/gcc-patches/2016-03/msg00841.html
To recap quickly, the C++ compiler has used a different calling
convention for passing empty classes, because C++ says they have size 1,
while the GCC C extension gives them size 0. But this difference
doesn't mean that they need to be passed differently; in either case
there's no actual data involved. And the Clang folks recently pointed
out that if you squint properly, it seems that the x86_64 psABI says
that an empty class shouldn't be passed either in registers or memory.
H.J. had a back-end fix, but it seemed to me that a front-end fix would
be simpler and safer.
The first patch corrects errors in what the C++ front end considers an
empty classes; unnamed bit-fields aren't really members. I'm checking
this in now.
The second patch is the actual ABI change under -fabi-version=10,
including a warning. Jonathan, please check this in with your library
changes.
Unfortunately, a drawback of doing this in the front end is that it's
difficult to warn only about affected cases; the front end doesn't know
what's actually going to be emitted, and has to warn conservatively,
leading to false positives particularly for inline functions.
The third patch is a sketch of an attempt to address this by delaying
the warning until expand time. We can't use front end information at
this point because it has been thrown away by pass_ipa_free_lang_data,
so I'm resorting to pre-generating the warning and stashing it away.
This is several kinds of kludge, including hashing on a call location,
but it greatly improves the accuracy of the warning. I'm hoping that
someone will have a better idea about how to approach this.
For normal calls we could observe the difference in DECL_ARG_TYPE for a
RECORD_TYPE parameter, but that won't help with varargs, for which the
front end hides the real type from the back end. I suppose we could
tell the back end about the magic empty_struct_type and warn when it
comes up. Or we could just warn about varargs in the front end, and not
worry about the rare false positives. I suppose I'll pursue that direction.
Also note that in some cases the following parameter is still passed in
the same place even when the empty parameter changes.
Any other clever ideas?
Jason
commit 0d8472ada9703f2dc0e288a230b280ec45d60583
Author: Jason Merrill <jason@redhat.com>
Date: Fri Mar 11 13:39:52 2016 -0500
* class.c (is_really_empty_class): A zero-length array is empty.
An unnamed bit-field doesn't make a class non-empty.
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index e66f0b9..02a992f 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -8406,12 +8406,15 @@ is_really_empty_class (tree type)
for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL
&& !DECL_ARTIFICIAL (field)
+ /* An unnamed bit-field is not a data member. */
+ && (DECL_NAME (field) || !DECL_C_BIT_FIELD (field))
&& !is_really_empty_class (TREE_TYPE (field)))
return false;
return true;
}
else if (TREE_CODE (type) == ARRAY_TYPE)
- return is_really_empty_class (TREE_TYPE (type));
+ return (integer_zerop (array_type_nelts_top (type))
+ || is_really_empty_class (TREE_TYPE (type)));
return false;
}
commit 2dad2abc1694e7a70f523cf639ebbe4b945247db
Author: Jason Merrill <jason@redhat.com>
Date: Fri Mar 11 13:40:02 2016 -0500
Pass empty class parameters like C.
* call.c (pass_as_empty_struct, empty_class_arg)
(warn_empty_class_abi): New.
(type_passed_as, build_x_va_arg): Use pass_as_empty_struct.
(build_call_a): Use empty_class_arg, warn_empty_class_abi.
* cp-tree.h (CPTI_EMPTY_STRUCT, empty_struct_type): New.
* decl.c (cxx_init_decl_processing): Create empty_struct_type.
(store_parm_decls): Use warn_empty_class_abi.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index ed23490..3ba9cd2 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -214,6 +214,8 @@ static void add_candidates (tree, tree, const vec<tree, va_gc> *, tree, tree,
tsubst_flags_t);
static conversion *merge_conversion_sequences (conversion *, conversion *);
static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t);
+static bool pass_as_empty_struct (tree type);
+static tree empty_class_arg (tree);
/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
NAME can take many forms... */
@@ -379,16 +381,28 @@ build_call_a (tree function, int n, tree *argarray)
/* Don't pass empty class objects by value. This is useful
for tags in STL, which are used to control overload resolution.
We don't need to handle other cases of copying empty classes. */
+ bool warned = false;
+ if (decl && !TREE_PUBLIC (decl))
+ /* Don't warn about the ABI of a function local to this TU. */
+ warned = true;
+ tree empty_arg = NULL_TREE;
if (! decl || ! DECL_BUILT_IN (decl))
for (i = 0; i < n; i++)
{
tree arg = CALL_EXPR_ARG (function, i);
- if (is_empty_class (TREE_TYPE (arg))
- && ! TREE_ADDRESSABLE (TREE_TYPE (arg)))
+ tree type = TREE_TYPE (arg);
+ if (is_really_empty_class (type)
+ && ! TREE_ADDRESSABLE (type))
{
- tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (arg));
- arg = build2 (COMPOUND_EXPR, TREE_TYPE (t), arg, t);
- CALL_EXPR_ARG (function, i) = arg;
+ empty_arg = arg;
+ CALL_EXPR_ARG (function, i) = empty_class_arg (arg);
+ }
+ /* Warn about ABI changes for a non-final argument. */
+ else if (!warned && empty_arg)
+ {
+ location_t loc = EXPR_LOC_OR_LOC (empty_arg, input_location);
+ warn_empty_class_abi (empty_arg, loc);
+ warned = true;
}
}
@@ -6872,6 +6886,14 @@ build_x_va_arg (source_location loc, tree expr, tree type)
expr = build_va_arg (loc, expr, ref);
return convert_from_reference (expr);
}
+ else if (is_really_empty_class (type) && !TREE_ADDRESSABLE (type))
+ {
+ /* Do the reverse of empty_class_arg. */
+ tree etype = pass_as_empty_struct (type) ? empty_struct_type : type;
+ expr = build_va_arg (loc, expr, etype);
+ tree ec = build0 (EMPTY_CLASS_EXPR, type);
+ return build2 (COMPOUND_EXPR, type, expr, ec);
+ }
return build_va_arg (loc, expr, type);
}
@@ -6968,6 +6990,58 @@ convert_default_arg (tree type, tree arg, tree fn, int parmnum,
return arg;
}
+/* Return true iff TYPE should be passed and returned as a size 0 type rather
+ than its normal size, for compatibility with C. */
+
+static bool
+pass_as_empty_struct (tree type)
+{
+ return (abi_version_at_least (10)
+ && type != error_mark_node
+ && COMPLETE_TYPE_P (type)
+ && !TREE_ADDRESSABLE (type)
+ && is_really_empty_class (type));
+}
+
+/* Adjust the value VAL of empty class type TYPE for argument passing.
+ Keep this synced with build_x_va_arg. */
+
+static tree
+empty_class_arg (tree val)
+{
+ /* Don't pass empty class objects by value. This is useful
+ for tags in STL, which are used to control overload resolution.
+ We don't need to handle other cases of copying empty classes. */
+ tree type = TREE_TYPE (val);
+ tree etype = pass_as_empty_struct (type) ? empty_struct_type : type;
+ tree empty = build0 (EMPTY_CLASS_EXPR, etype);
+ return build2 (COMPOUND_EXPR, etype, val, empty);
+}
+
+/* Warn about the change in empty class parameter passing ABI. Returns true
+ if we warned. */
+
+void
+warn_empty_class_abi (tree arg, location_t loc)
+{
+ if (!warn_abi || !abi_version_crosses (10))
+ return;
+
+ tree type;
+ if (TYPE_P (arg))
+ type = arg;
+ else
+ {
+ if (TREE_TYPE (arg) == empty_struct_type
+ && TREE_CODE (arg) == COMPOUND_EXPR)
+ arg = TREE_OPERAND (arg, 0);
+ type = TREE_TYPE (arg);
+ }
+
+ warning_at (loc, OPT_Wabi, "empty class %qT parameter passing ABI "
+ "changes in -fabi-version=10 (GCC 6)", type);
+}
+
/* Returns the type which will really be used for passing an argument of
type TYPE. */
@@ -6986,6 +7060,8 @@ type_passed_as (tree type)
&& COMPLETE_TYPE_P (type)
&& tree_int_cst_lt (TYPE_SIZE (type), TYPE_SIZE (integer_type_node)))
type = integer_type_node;
+ else if (pass_as_empty_struct (type))
+ type = empty_struct_type;
return type;
}
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 0f7e08f..dd1cfa4 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -1150,6 +1150,8 @@ enum cp_tree_index
CPTI_NULLPTR,
CPTI_NULLPTR_TYPE,
+ CPTI_EMPTY_STRUCT,
+
CPTI_MAX
};
@@ -1185,6 +1187,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
#define current_aggr cp_global_trees[CPTI_AGGR_TAG]
#define nullptr_node cp_global_trees[CPTI_NULLPTR]
#define nullptr_type_node cp_global_trees[CPTI_NULLPTR_TYPE]
+#define empty_struct_type cp_global_trees[CPTI_EMPTY_STRUCT]
/* We cache these tree nodes so as to call get_identifier less
frequently. */
@@ -5537,6 +5540,7 @@ extern tree build_addr_func (tree, tsubst_flags_t);
extern void set_flags_from_callee (tree);
extern tree build_call_a (tree, int, tree*);
extern tree build_call_n (tree, int, ...);
+extern void warn_empty_class_abi (tree, location_t);
extern bool null_ptr_cst_p (tree);
extern bool null_member_pointer_value_p (tree);
extern bool sufficient_parms_p (const_tree);
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 9260f4c..f1c274f 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -4152,6 +4152,10 @@ cxx_init_decl_processing (void)
nullptr_node = build_int_cst (nullptr_type_node, 0);
}
+ empty_struct_type = make_node (RECORD_TYPE);
+ finish_builtin_struct (empty_struct_type, "__empty_struct",
+ NULL_TREE, NULL_TREE);
+
abort_fndecl
= build_library_fn_ptr ("__cxa_pure_virtual", void_ftype,
ECF_NORETURN | ECF_NOTHROW);
@@ -14297,16 +14301,34 @@ store_parm_decls (tree current_function_parms)
they end in the correct forward order. */
specparms = nreverse (specparms);
+ /* Don't warn about the ABI of a function local to this TU. */
+ bool warned = !TREE_PUBLIC (current_function_decl);
+ bool saw_nonempty = false;
for (parm = specparms; parm; parm = next)
{
next = DECL_CHAIN (parm);
if (TREE_CODE (parm) == PARM_DECL)
{
+ tree type = TREE_TYPE (parm);
if (DECL_NAME (parm) == NULL_TREE
- || !VOID_TYPE_P (parm))
+ || !VOID_TYPE_P (type))
pushdecl (parm);
else
error ("parameter %qD declared void", parm);
+ /* If this isn't the last parameter, maybe warn about ABI change
+ in passing empty classes. */
+ if (processing_template_decl)
+ continue;
+ if (TREE_ADDRESSABLE (type)
+ || !is_really_empty_class (type))
+ saw_nonempty = true;
+ else if (!warned
+ && (saw_nonempty
+ || varargs_function_p (current_function_decl)))
+ {
+ warn_empty_class_abi (parm, DECL_SOURCE_LOCATION (parm));
+ warned = true;
+ }
}
else
{
diff --git a/gcc/testsuite/g++.dg/abi/empty12.C b/gcc/testsuite/g++.dg/abi/empty12.C
new file mode 100644
index 0000000..ce1f6f2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty12.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty12a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty12.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty12.h b/gcc/testsuite/g++.dg/abi/empty12.h
new file mode 100644
index 0000000..c61afcd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty12.h
@@ -0,0 +1,9 @@
+struct dummy { };
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty12a.c b/gcc/testsuite/g++.dg/abi/empty12a.c
new file mode 100644
index 0000000..34a25ba
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty12a.c
@@ -0,0 +1,6 @@
+#include "empty12.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty13.C b/gcc/testsuite/g++.dg/abi/empty13.C
new file mode 100644
index 0000000..d1e0946
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty13.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-x c -fabi-version=9" }
+// { dg-additional-sources "empty13a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty13.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty13.h b/gcc/testsuite/g++.dg/abi/empty13.h
new file mode 100644
index 0000000..c61afcd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty13.h
@@ -0,0 +1,9 @@
+struct dummy { };
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty13a.c b/gcc/testsuite/g++.dg/abi/empty13a.c
new file mode 100644
index 0000000..b4303a6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty13a.c
@@ -0,0 +1,6 @@
+#include "empty13.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 == -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty14.C b/gcc/testsuite/g++.dg/abi/empty14.C
new file mode 100644
index 0000000..1b9c397
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty14.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty14a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty14.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty14.h b/gcc/testsuite/g++.dg/abi/empty14.h
new file mode 100644
index 0000000..5842279
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty14.h
@@ -0,0 +1,10 @@
+struct dummy0 { };
+struct dummy { struct dummy0 d[140]; };
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty14a.c b/gcc/testsuite/g++.dg/abi/empty14a.c
new file mode 100644
index 0000000..8b3d780
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty14a.c
@@ -0,0 +1,6 @@
+#include "empty14.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty15.C b/gcc/testsuite/g++.dg/abi/empty15.C
new file mode 100644
index 0000000..ac0a868
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty15.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty15a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty15.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty15.h b/gcc/testsuite/g++.dg/abi/empty15.h
new file mode 100644
index 0000000..1c6f26f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty15.h
@@ -0,0 +1,30 @@
+struct A1 {};
+struct A2 {};
+struct B1 { struct A1 a; struct A2 b; };
+struct B2 { struct A1 a; struct A2 b; };
+struct C1 { struct B1 a; struct B2 b; };
+struct C2 { struct B1 a; struct B2 b; };
+struct D1 { struct C1 a; struct C2 b; };
+struct D2 { struct C1 a; struct C2 b; };
+struct E1 { struct D1 a; struct D2 b; };
+struct E2 { struct D1 a; struct D2 b; };
+struct F1 { struct E1 a; struct E2 b; };
+struct F2 { struct E1 a; struct E2 b; };
+struct G1 { struct F1 a; struct F2 b; };
+struct G2 { struct F1 a; struct F2 b; };
+struct H1 { struct G1 a; struct G2 b; };
+struct H2 { struct G1 a; struct G2 b; };
+struct I1 { struct H1 a; struct H2 b; };
+struct I2 { struct H1 a; struct H2 b; };
+struct J1 { struct I1 a; struct I2 b; };
+struct J2 { struct I1 a; struct I2 b; };
+struct dummy { struct J1 a; struct J2 b; };
+
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty15a.c b/gcc/testsuite/g++.dg/abi/empty15a.c
new file mode 100644
index 0000000..325b2c5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty15a.c
@@ -0,0 +1,6 @@
+#include "empty15.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty16.C b/gcc/testsuite/g++.dg/abi/empty16.C
new file mode 100644
index 0000000..de2bf5c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty16.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty16a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty16.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty16.h b/gcc/testsuite/g++.dg/abi/empty16.h
new file mode 100644
index 0000000..7552ae0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty16.h
@@ -0,0 +1,16 @@
+#ifdef __cplusplus
+struct A1 {};
+struct A2 {};
+struct dummy : A1, A2 {} ;
+#else
+struct dummy {};
+#endif
+
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty16a.c b/gcc/testsuite/g++.dg/abi/empty16a.c
new file mode 100644
index 0000000..6cb7fbc
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty16a.c
@@ -0,0 +1,6 @@
+#include "empty16.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty17.C b/gcc/testsuite/g++.dg/abi/empty17.C
new file mode 100644
index 0000000..c7a37c0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty17.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty17a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty17.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty17.h b/gcc/testsuite/g++.dg/abi/empty17.h
new file mode 100644
index 0000000..9cf72ba
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty17.h
@@ -0,0 +1,27 @@
+#ifdef __cplusplus
+struct A1
+{
+ void foo (void);
+ unsigned int : 15;
+};
+struct A2
+{
+ void bar (void);
+ unsigned int : 15;
+};
+struct dummy : A1, A2
+{
+ unsigned int : 15;
+};
+#else
+struct dummy {};
+#endif
+
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty17a.c b/gcc/testsuite/g++.dg/abi/empty17a.c
new file mode 100644
index 0000000..24408fd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty17a.c
@@ -0,0 +1,6 @@
+#include "empty17.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty18.C b/gcc/testsuite/g++.dg/abi/empty18.C
new file mode 100644
index 0000000..6cad33c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty18.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty18a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty18.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty18.h b/gcc/testsuite/g++.dg/abi/empty18.h
new file mode 100644
index 0000000..86e7ecd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty18.h
@@ -0,0 +1,9 @@
+struct dummy { int d[0]; };
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty18a.c b/gcc/testsuite/g++.dg/abi/empty18a.c
new file mode 100644
index 0000000..902860b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty18a.c
@@ -0,0 +1,6 @@
+#include "empty18.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty19.C b/gcc/testsuite/g++.dg/abi/empty19.C
new file mode 100644
index 0000000..e3e855a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty19.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-Wabi=9 -x c" }
+// { dg-additional-sources "empty19a.c" }
+// { dg-prune-output "command line option" }
+
+#include "empty19.h"
+extern "C" void fun(struct dummy, struct foo);
+
+int main()
+{
+ struct dummy d;
+ struct foo f = { -1, -2, -3, -4, -5 };
+
+ fun(d, f); // { dg-warning "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty19.h b/gcc/testsuite/g++.dg/abi/empty19.h
new file mode 100644
index 0000000..616b87b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty19.h
@@ -0,0 +1,10 @@
+struct dummy0 { };
+struct dummy { struct dummy0 d[0]; };
+struct foo
+{
+ int i1;
+ int i2;
+ int i3;
+ int i4;
+ int i5;
+};
diff --git a/gcc/testsuite/g++.dg/abi/empty19a.c b/gcc/testsuite/g++.dg/abi/empty19a.c
new file mode 100644
index 0000000..767b1eb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty19a.c
@@ -0,0 +1,6 @@
+#include "empty19.h"
+void fun(struct dummy d, struct foo f)
+{
+ if (f.i1 != -1)
+ __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/abi/empty21.C b/gcc/testsuite/g++.dg/abi/empty21.C
new file mode 100644
index 0000000..7538dd8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty21.C
@@ -0,0 +1,21 @@
+// { dg-options "-Wabi=9" }
+
+#include <stdarg.h>
+
+struct A { };
+
+void f(int i, ...)
+{
+ va_list ap;
+ va_start (ap, i);
+ if (i >= 1)
+ va_arg (ap, A); // { dg-warning "ABI" }
+ if (i >= 2)
+ va_arg (ap, int);
+}
+
+int main()
+{
+ f(0);
+ f(2, A(), 42); // { dg-warning "ABI" }
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-1.C b/gcc/testsuite/g++.dg/abi/pr60336-1.C
new file mode 100644
index 0000000..af08638
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-1.C
@@ -0,0 +1,17 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+struct dummy { };
+struct true_type { struct dummy i; };
+
+extern true_type y;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx9true_type" { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-10.C b/gcc/testsuite/g++.dg/abi/pr60336-10.C
new file mode 100644
index 0000000..6c9c990
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-10.C
@@ -0,0 +1,50 @@
+// { dg-do run }
+// { dg-options "-O2" }
+
+#include <stdarg.h>
+
+struct dummy0 { };
+struct dummy1 { };
+struct dummy : dummy0, dummy1 { };
+
+void
+test (struct dummy a, int m, ...)
+{
+ va_list va_arglist;
+ int i;
+ int count = 0;
+
+ if (m == 0)
+ count++;
+ va_start (va_arglist, m);
+ i = va_arg (va_arglist, int);
+ if (i == 1)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 2)
+ i = va_arg (va_arglist, int);
+ count++;
+ if (i == 3)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 4)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 5)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 6)
+ count++;
+ va_end (va_arglist);
+ if (count != 7)
+ __builtin_abort ();
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0, 1, 2, 3, 4, 5, 6);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-11.C b/gcc/testsuite/g++.dg/abi/pr60336-11.C
new file mode 100644
index 0000000..c92f3d4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-11.C
@@ -0,0 +1,56 @@
+// { dg-do run }
+// { dg-options "-O2" }
+
+#include <stdarg.h>
+
+struct dummy0
+{
+ void bar (void);
+};
+struct dummy1
+{
+ void foo (void);
+};
+struct dummy : dummy0, dummy1 { };
+
+void
+test (struct dummy a, int m, ...)
+{
+ va_list va_arglist;
+ int i;
+ int count = 0;
+
+ if (m == 0)
+ count++;
+ va_start (va_arglist, m);
+ i = va_arg (va_arglist, int);
+ if (i == 1)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 2)
+ i = va_arg (va_arglist, int);
+ count++;
+ if (i == 3)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 4)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 5)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 6)
+ count++;
+ va_end (va_arglist);
+ if (count != 7)
+ __builtin_abort ();
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0, 1, 2, 3, 4, 5, 6);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-12.C b/gcc/testsuite/g++.dg/abi/pr60336-12.C
new file mode 100644
index 0000000..83a7bb0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-12.C
@@ -0,0 +1,57 @@
+// { dg-do run }
+// { dg-options "-O2" }
+
+#include <stdarg.h>
+
+struct dummy0
+{
+};
+struct dummy1
+{
+ unsigned : 15;
+};
+struct dummy : dummy0, dummy1
+{
+};
+
+void
+test (struct dummy a, int m, ...)
+{
+ va_list va_arglist;
+ int i;
+ int count = 0;
+
+ if (m == 0)
+ count++;
+ va_start (va_arglist, m);
+ i = va_arg (va_arglist, int);
+ if (i == 1)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 2)
+ i = va_arg (va_arglist, int);
+ count++;
+ if (i == 3)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 4)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 5)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 6)
+ count++;
+ va_end (va_arglist);
+ if (count != 7)
+ __builtin_abort ();
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0, 1, 2, 3, 4, 5, 6);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-2.C b/gcc/testsuite/g++.dg/abi/pr60336-2.C
new file mode 100644
index 0000000..32eecb3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-2.C
@@ -0,0 +1,48 @@
+// { dg-do run }
+// { dg-options "-O2 -Wabi=9" }
+
+#include <stdarg.h>
+
+struct dummy { };
+
+void
+test (struct dummy a, int m, ...) // { dg-message "empty" }
+{
+ va_list va_arglist;
+ int i;
+ int count = 0;
+
+ if (m == 0)
+ count++;
+ va_start (va_arglist, m);
+ i = va_arg (va_arglist, int);
+ if (i == 1)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 2)
+ i = va_arg (va_arglist, int);
+ count++;
+ if (i == 3)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 4)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 5)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 6)
+ count++;
+ va_end (va_arglist);
+ if (count != 7)
+ __builtin_abort ();
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0, 1, 2, 3, 4, 5, 6); // { dg-message "empty" }
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-3.C b/gcc/testsuite/g++.dg/abi/pr60336-3.C
new file mode 100644
index 0000000..8ebd4dd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-3.C
@@ -0,0 +1,15 @@
+// { dg-do compile }
+// { dg-options "-O2 -Wabi=9" }
+
+struct dummy { struct{}__attribute__((aligned (4))) a[7]; };
+
+extern void test1 (struct dummy, ...);
+extern void (*test2) (struct dummy, ...);
+
+void
+foo ()
+{
+ struct dummy a0;
+ test1 (a0, 42); // { dg-message "empty" }
+ test2 (a0, 42); // { dg-message "empty" }
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-4.C b/gcc/testsuite/g++.dg/abi/pr60336-4.C
new file mode 100644
index 0000000..8790a66
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-4.C
@@ -0,0 +1,48 @@
+// { dg-do run { target { { i?86-*-* x86_64-*-* } && { ! { ia32 } } } } }
+// { dg-options "-O2 -fabi-version=9" }
+
+#include <stdarg.h>
+
+struct dummy { };
+
+void
+test (struct dummy a, int m, ...)
+{
+ va_list va_arglist;
+ int i;
+ int count = 0;
+
+ if (m == 0)
+ count++;
+ va_start (va_arglist, m);
+ i = va_arg (va_arglist, int);
+ if (i == 1)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 2)
+ i = va_arg (va_arglist, int);
+ count++;
+ if (i == 3)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 4)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 5)
+ count++;
+ i = va_arg (va_arglist, int);
+ if (i == 6)
+ count++;
+ va_end (va_arglist);
+ if (count == 7)
+ __builtin_abort ();
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0, 1, 2, 3, 4, 5, 6);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-5.C b/gcc/testsuite/g++.dg/abi/pr60336-5.C
new file mode 100644
index 0000000..b0c76ad
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-5.C
@@ -0,0 +1,17 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+struct dummy { };
+struct true_type { struct dummy i; struct dummy j; };
+
+extern true_type y;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx9true_type" { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-6.C b/gcc/testsuite/g++.dg/abi/pr60336-6.C
new file mode 100644
index 0000000..5879651
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-6.C
@@ -0,0 +1,17 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+struct dummy { };
+struct true_type { struct dummy i1; struct dummy i2; };
+
+extern true_type y;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx9true_type" { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-7.C b/gcc/testsuite/g++.dg/abi/pr60336-7.C
new file mode 100644
index 0000000..0e5d2ef
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-7.C
@@ -0,0 +1,17 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+struct dummy { };
+struct true_type { struct dummy i[120]; };
+
+extern true_type y;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx9true_type" { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-8.C b/gcc/testsuite/g++.dg/abi/pr60336-8.C
new file mode 100644
index 0000000..fdfc924
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-8.C
@@ -0,0 +1,15 @@
+// { dg-do compile }
+// { dg-options "-O2 -Wabi=9" }
+
+struct dummy { struct{} a[7][3]; };
+
+extern void test1 (struct dummy, ...);
+extern void (*test2) (struct dummy, ...);
+
+void
+foo ()
+{
+ struct dummy a0;
+ test1 (a0, 42); // { dg-message "empty" }
+ test2 (a0, 42); // { dg-message "empty" }
+}
diff --git a/gcc/testsuite/g++.dg/abi/pr60336-9.C b/gcc/testsuite/g++.dg/abi/pr60336-9.C
new file mode 100644
index 0000000..4ad333f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr60336-9.C
@@ -0,0 +1,28 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+struct A1 {}; struct A2 {};
+struct B1 { A1 a; A2 b; }; struct B2 { A1 a; A2 b; };
+struct C1 { B1 a; B2 b; }; struct C2 { B1 a; B2 b; };
+struct D1 { C1 a; C2 b; }; struct D2 { C1 a; C2 b; };
+struct E1 { D1 a; D2 b; }; struct E2 { D1 a; D2 b; };
+struct F1 { E1 a; E2 b; }; struct F2 { E1 a; E2 b; };
+struct G1 { F1 a; F2 b; }; struct G2 { F1 a; F2 b; };
+struct H1 { G1 a; G2 b; }; struct H2 { G1 a; G2 b; };
+struct I1 { H1 a; H2 b; }; struct I2 { H1 a; H2 b; };
+struct J1 { I1 a; I2 b; }; struct J2 { I1 a; I2 b; };
+struct dummy { J1 a; J2 b; };
+
+struct true_type { struct dummy i; };
+
+extern true_type y;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx9true_type" { target i?86-*-* x86_64-*-* } } }
diff --git a/gcc/testsuite/g++.dg/abi/pr68355.C b/gcc/testsuite/g++.dg/abi/pr68355.C
new file mode 100644
index 0000000..1354fc4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/pr68355.C
@@ -0,0 +1,24 @@
+// { dg-do compile }
+// { dg-options "-O2 -std=c++11 -fno-pic" }
+// { dg-require-effective-target fpic }
+
+template<typename _Tp, _Tp __v>
+struct integral_constant
+{
+ static constexpr _Tp value = __v;
+ typedef _Tp value_type;
+ typedef integral_constant<_Tp, __v> type;
+ constexpr operator value_type() const { return value; }
+};
+
+typedef integral_constant<bool, true> true_type;
+extern void xxx (true_type c);
+
+void
+yyy (void)
+{
+ true_type y;
+ xxx (y);
+}
+
+// { dg-final { scan-assembler "jmp\[\t \]+\[^\$\]*?_Z3xxx17integral_constantIbLb1EE" { target i?86-*-* x86_64-*-* } } }
commit e7a1517f3f04ab8f42fc3f07f2e1887f14c0d2c7
Author: Jason Merrill <jason@redhat.com>
Date: Tue Apr 12 13:16:50 2016 -0400
warn-pass
diff --git a/gcc/calls.c b/gcc/calls.c
index 6415e08..3b1348e 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -2340,6 +2340,8 @@ avoid_likely_spilled_reg (rtx x)
If the value is stored in TARGET then TARGET is returned.
If IGNORE is nonzero, then we ignore the value of the function call. */
+void
+maybe_warn_emitted_call (location_t loc);
rtx
expand_call (tree exp, rtx target, int ignore)
{
@@ -2490,6 +2492,9 @@ expand_call (tree exp, rtx target, int ignore)
if (AGGREGATE_TYPE_P (rettype))
warning (OPT_Waggregate_return, "function call has aggregate value");
+ if (EXPR_HAS_LOCATION (exp))
+ maybe_warn_emitted_call (EXPR_LOCATION (exp));
+
/* If the result of a non looping pure or const function call is
ignored (or void), and none of its arguments are volatile, we can
avoid expanding the call and just evaluate the arguments for
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 1341c14..a1baade 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -6083,6 +6083,9 @@ stack_protect_prologue (void)
emit_move_insn (x, y);
}
+void
+maybe_warn_emitted_fn (tree fn);
+
/* Translate the intermediate representation contained in the CFG
from GIMPLE trees to RTL.
@@ -6186,6 +6189,8 @@ pass_expand::execute (function *fun)
/* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
discover_nonconstant_array_refs ();
+ maybe_warn_emitted_fn (current_function_decl);
+
targetm.expand_to_rtl_hook ();
crtl->stack_alignment_needed = STACK_BOUNDARY;
crtl->max_used_stack_slot_alignment = STACK_BOUNDARY;
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 3ba9cd2..ee1e492 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -216,6 +216,7 @@ static conversion *merge_conversion_sequences (conversion *, conversion *);
static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t);
static bool pass_as_empty_struct (tree type);
static tree empty_class_arg (tree);
+static void cp_push_warn_emitted_call (location_t, tree);
/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
NAME can take many forms... */
@@ -400,8 +401,8 @@ build_call_a (tree function, int n, tree *argarray)
/* Warn about ABI changes for a non-final argument. */
else if (!warned && empty_arg)
{
- location_t loc = EXPR_LOC_OR_LOC (empty_arg, input_location);
- warn_empty_class_abi (empty_arg, loc);
+ cp_push_warn_emitted_call (input_location, TREE_TYPE (empty_arg));
+ CALL_EXPR_ABI_SENSITIVE_P (function) = true;
warned = true;
}
}
@@ -6891,6 +6892,7 @@ build_x_va_arg (source_location loc, tree expr, tree type)
/* Do the reverse of empty_class_arg. */
tree etype = pass_as_empty_struct (type) ? empty_struct_type : type;
expr = build_va_arg (loc, expr, etype);
+ cp_push_warn_emitted_call (loc, type);
tree ec = build0 (EMPTY_CLASS_EXPR, type);
return build2 (COMPOUND_EXPR, type, expr, ec);
}
@@ -7021,25 +7023,37 @@ empty_class_arg (tree val)
/* Warn about the change in empty class parameter passing ABI. Returns true
if we warned. */
+static tree
+empty_class_msg (tree type)
+{
+ pp_printf (global_dc->printer, "empty class %qT parameter passing ABI "
+ "changes in -fabi-version=10 (GCC 6)", type);
+ tree msg = get_identifier (pp_formatted_text (global_dc->printer));
+ pp_clear_output_area (global_dc->printer);
+ return msg;
+}
+
+extern void push_warn_emitted_call (location_t, tree);
+extern void push_warn_emitted_fn (tree, tree);
+
void
-warn_empty_class_abi (tree arg, location_t loc)
+cp_push_warn_emitted_fn (tree fn, tree type)
{
if (!warn_abi || !abi_version_crosses (10))
return;
- tree type;
- if (TYPE_P (arg))
- type = arg;
- else
- {
- if (TREE_TYPE (arg) == empty_struct_type
- && TREE_CODE (arg) == COMPOUND_EXPR)
- arg = TREE_OPERAND (arg, 0);
- type = TREE_TYPE (arg);
- }
+ tree msg = empty_class_msg (type);
+ push_warn_emitted_fn (fn, msg);
+}
+
+void
+cp_push_warn_emitted_call (location_t loc, tree type)
+{
+ if (!warn_abi || !abi_version_crosses (10))
+ return;
- warning_at (loc, OPT_Wabi, "empty class %qT parameter passing ABI "
- "changes in -fabi-version=10 (GCC 6)", type);
+ tree msg = empty_class_msg (type);
+ push_warn_emitted_call (loc, msg);
}
/* Returns the type which will really be used for passing an argument of
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index dd1cfa4..0f66e97 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3391,6 +3391,10 @@ extern void decl_shadowed_for_var_insert (tree, tree);
should be performed at instantiation time. */
#define KOENIG_LOOKUP_P(NODE) TREE_LANG_FLAG_0 (CALL_EXPR_CHECK (NODE))
+/* Kludge. */
+#define CALL_EXPR_ABI_SENSITIVE_P(NODE) \
+ TREE_LANG_FLAG_1 (CALL_EXPR_CHECK (NODE))
+
/* True if CALL_EXPR expresses list-initialization of an object. */
#define CALL_EXPR_LIST_INIT_P(NODE) \
TREE_LANG_FLAG_3 (TREE_CHECK2 ((NODE),CALL_EXPR,AGGR_INIT_EXPR))
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index f1c274f..7ff4f2f 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -14271,6 +14271,8 @@ use_eh_spec_block (tree fn)
Also install to binding contour return value identifier, if any. */
+extern void
+cp_push_warn_emitted_fn (tree fn, tree type);
static void
store_parm_decls (tree current_function_parms)
{
@@ -14326,7 +14328,7 @@ store_parm_decls (tree current_function_parms)
&& (saw_nonempty
|| varargs_function_p (current_function_decl)))
{
- warn_empty_class_abi (parm, DECL_SOURCE_LOCATION (parm));
+ cp_push_warn_emitted_fn (current_function_decl, type);
warned = true;
}
}
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 00e211e..c94fe93 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -6903,7 +6903,9 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
koenig_p,
complain);
- if (close_paren_loc != UNKNOWN_LOCATION)
+ if (close_paren_loc != UNKNOWN_LOCATION
+ && ! (TREE_CODE (postfix_expression) == CALL_EXPR
+ && CALL_EXPR_ABI_SENSITIVE_P (postfix_expression)))
{
location_t combined_loc = make_location (token->location,
start_loc,
diff --git a/gcc/expr.c b/gcc/expr.c
index 29d22b0..3c81fbc 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -61,6 +61,48 @@ along with GCC; see the file COPYING3. If not see
#include "rtl-chkp.h"
#include "ccmp.h"
+struct location_hash
+ : int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION> {};
+typedef hash_map<location_hash, tree> location_tree_map;
+
+static GTY(()) location_tree_map *warn_emitted_calls;
+
+void
+push_warn_emitted_call (location_t loc, tree msg)
+{
+ if (warn_emitted_calls == NULL)
+ warn_emitted_calls = location_tree_map::create_ggc (13);
+ loc = get_pure_location (loc);
+ warn_emitted_calls->put (loc, msg);
+}
+
+void
+maybe_warn_emitted_call (location_t loc)
+{
+ loc = get_pure_location (loc);
+ if (warn_emitted_calls && warn_abi)
+ if (tree *msg = warn_emitted_calls->get (loc))
+ warning_at (loc, OPT_Wabi, "%D", *msg);
+}
+
+static GTY(()) hash_map<tree, tree> *warn_emitted_fns;
+
+void
+push_warn_emitted_fn (tree fn, tree msg)
+{
+ if (warn_emitted_fns == NULL)
+ warn_emitted_fns = hash_map<tree,tree>::create_ggc (13);
+ warn_emitted_fns->put (fn, msg);
+}
+
+void
+maybe_warn_emitted_fn (tree fn)
+{
+ if (warn_emitted_fns && warn_abi)
+ if (tree *msg = warn_emitted_fns->get (fn))
+ warning_at (DECL_SOURCE_LOCATION (fn), OPT_Wabi, "%D", *msg);
+}
+
/* If this is nonzero, we do not bother generating VOLATILE
around volatile memory references, and we are willing to
diff --git a/gcc/testsuite/g++.dg/abi/empty20.C b/gcc/testsuite/g++.dg/abi/empty20.C
new file mode 100644
index 0000000..4450a28
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty20.C
@@ -0,0 +1,18 @@
+// { dg-options "-Wabi=9 -O0" }
+
+struct A { };
+
+void f(A, A) { } // No warning, trailing parms all empty
+void f(A, A, int) { } // { dg-warning "ABI" }
+__attribute__ ((always_inline))
+inline void f(A a, int i) // No warning, always inlined
+{
+ f(a,a,i); // { dg-warning "ABI" }
+}
+int main()
+{
+ A a;
+ f(a,a);
+ f(a,a,42); // { dg-warning "ABI" }
+ f(a,42);
+}
diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c
index 13b92f0..664d498 100644
--- a/gcc/tree-stdarg.c
+++ b/gcc/tree-stdarg.c
@@ -1006,6 +1006,8 @@ gimple_call_ifn_va_arg_p (gimple *stmt)
/* Expand IFN_VA_ARGs in FUN. */
+void
+maybe_warn_emitted_call (location_t loc);
static void
expand_ifn_va_arg_1 (function *fun)
{
@@ -1024,6 +1026,8 @@ expand_ifn_va_arg_1 (function *fun)
if (!gimple_call_ifn_va_arg_p (stmt))
continue;
+ maybe_warn_emitted_call (gimple_location (stmt));
+
modified = true;
type = TREE_TYPE (TREE_TYPE (gimple_call_arg (stmt, 1)));
commit 5817a569c22c79fa9077631093eaa1964e84c462
Author: Jason Merrill <jason@redhat.com>
Date: Tue Apr 12 14:13:14 2016 -0400
* gimple.c (gimple_build_call_from_tree): Copy EXPR_LOCATION.
diff --git a/gcc/gimple.c b/gcc/gimple.c
index b0e19d5..bd12565 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -371,6 +371,7 @@ gimple_build_call_from_tree (tree t)
gimple_call_set_nothrow (call, TREE_NOTHROW (t));
gimple_set_no_warning (call, TREE_NO_WARNING (t));
gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
+ gimple_set_location (call, EXPR_LOCATION (t));
return call;
}
diff --git a/gcc/testsuite/g++.dg/ext/builtin-object-size3.C b/gcc/testsuite/g++.dg/ext/builtin-object-size3.C
index 09263e5..8d30984 100644
--- a/gcc/testsuite/g++.dg/ext/builtin-object-size3.C
+++ b/gcc/testsuite/g++.dg/ext/builtin-object-size3.C
@@ -3,15 +3,15 @@
void baz (int *, int *);
-#define MEMCPY(d,s,l) __builtin___memcpy_chk (d, s, l, __builtin_object_size (d, 0))
+#define MEMCPY(d,s,l) __builtin___memcpy_chk (d, s, l, __builtin_object_size (d, 0)) // { dg-warning "will always overflow" }
int
foo ()
{
int *p = new int;
int *q = new int[4];
- MEMCPY (p, "abcdefghijklmnopqrstuvwxyz", sizeof (int));
- MEMCPY (q, "abcdefghijklmnopqrstuvwxyz", 4 * sizeof (int));
+ MEMCPY (p, "abcdefghijklmnopqrstuvwxyz", sizeof (int)); // { dg-bogus "" }
+ MEMCPY (q, "abcdefghijklmnopqrstuvwxyz", 4 * sizeof (int)); // { dg-bogus "" }
baz (p, q);
}
@@ -20,7 +20,7 @@ bar ()
{
int *p = new int;
int *q = new int[4];
- MEMCPY (p, "abcdefghijklmnopqrstuvwxyz", sizeof (int) + 1); // { dg-warning "will always overflow destination buffer" }
- MEMCPY (q, "abcdefghijklmnopqrstuvwxyz", 4 * sizeof (int) + 1); // { dg-warning "will always overflow destination buffer" }
+ MEMCPY (p, "abcdefghijklmnopqrstuvwxyz", sizeof (int) + 1); // { dg-message "MEMCPY" }
+ MEMCPY (q, "abcdefghijklmnopqrstuvwxyz", 4 * sizeof (int) + 1); // { dg-message "MEMCPY" }
baz (p, q);
}