* [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
@ 2015-11-17 11:01 H.J. Lu
2015-11-17 12:22 ` Richard Biener
0 siblings, 1 reply; 14+ messages in thread
From: H.J. Lu @ 2015-11-17 11:01 UTC (permalink / raw)
To: gcc-patches
Empty record should be returned and passed the same way in C and C++.
This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
to is_really_empty_class, which returns true for C++ empty classes. For
LTO, we stream out a bit to indicate if a record is empty and we store
it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
changed to set bitsize to 0 for empty records. Middle-end and x86
backend are updated to ignore empty records for parameter passing and
function value return. Other targets may need similar changes.
gcc/
PR c++/60336
PR middle-end/67239
PR target/68355
* calls.c (store_one_arg): Use 0 for empty record size. Don't
push 0 size argument onto stack.
(must_pass_in_stack_var_size_or_pad): Return false for empty
record.
* function.c (locate_and_pad_parm): Use 0 for empty record size.
* tree-dfa.c (get_ref_base_and_extent): Likewise.
* langhooks-def.h (LANG_HOOKS_EMPTY_RECORD_P): New.
(LANG_HOOKS_DECLS): Add LANG_HOOKS_EMPTY_RECORD_P.
* langhooks.h (lang_hooks_for_decls): Add empty_record_p.
* lto-streamer.h (LTO_major_version): Increase by 1 to 6.
* targhooks.c: Include "langhooks.h".
(std_gimplify_va_arg_expr): Use 0 for empty record size.
* tree-streamer-in.c (unpack_ts_base_value_fields): Stream in
TYPE_LANG_FLAG_0.
* tree-streamer-out.c: Include "langhooks.h".
(pack_ts_base_value_fields): Stream out a bit to indicate if a
record is empty.
* config/i386/i386.c (classify_argument): Return 0 for empty
record.
(construct_container): Return NULL for empty record.
(ix86_function_arg): Likewise.
(ix86_function_arg_advance): Skip empty record.
(ix86_return_in_memory): Return false for empty record.
(ix86_gimplify_va_arg): Use 0 for empty record size.
gcc/cp/
PR c++/60336
PR middle-end/67239
PR target/68355
* class.c (is_empty_class): Changed to return bool and take
const_tree.
(is_really_empty_class): Changed to take const_tree. Check
if TYPE_BINFO is zero.
* cp-tree.h (is_empty_class): Updated.
(is_really_empty_class): Likewise.
* cp-lang.c (LANG_HOOKS_EMPTY_RECORD_P): New.
gcc/lto/
PR c++/60336
PR middle-end/67239
PR target/68355
* lto-lang.c (lto_empty_record_p): New.
(LANG_HOOKS_EMPTY_RECORD_P): Likewise.
gcc/testsuite/
PR c++/60336
PR middle-end/67239
PR target/68355
* g++.dg/abi/empty12.C: New test.
* g++.dg/abi/empty12.h: Likewise.
* g++.dg/abi/empty12a.c: Likewise.
* g++.dg/pr60336-1.C: Likewise.
* g++.dg/pr60336-2.C: Likewise.
* g++.dg/pr68355.C: Likewise.
---
gcc/calls.c | 41 +++++++++++++++++++++++++++----------
gcc/config/i386/i386.c | 18 +++++++++++++++-
gcc/cp/class.c | 17 ++++++++-------
gcc/cp/cp-lang.c | 2 ++
gcc/cp/cp-tree.h | 4 ++--
gcc/function.c | 7 +++++--
gcc/langhooks-def.h | 2 ++
gcc/langhooks.h | 3 +++
gcc/lto-streamer.h | 2 +-
gcc/lto/lto-lang.c | 13 ++++++++++++
gcc/targhooks.c | 6 +++++-
gcc/testsuite/g++.dg/abi/empty12.C | 17 +++++++++++++++
gcc/testsuite/g++.dg/abi/empty12.h | 9 ++++++++
gcc/testsuite/g++.dg/abi/empty12a.c | 6 ++++++
gcc/testsuite/g++.dg/pr60336-1.C | 17 +++++++++++++++
gcc/testsuite/g++.dg/pr60336-2.C | 28 +++++++++++++++++++++++++
gcc/testsuite/g++.dg/pr68355.C | 24 ++++++++++++++++++++++
gcc/tree-dfa.c | 2 ++
gcc/tree-streamer-in.c | 5 +++++
gcc/tree-streamer-out.c | 6 ++++++
20 files changed, 204 insertions(+), 25 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/abi/empty12.C
create mode 100644 gcc/testsuite/g++.dg/abi/empty12.h
create mode 100644 gcc/testsuite/g++.dg/abi/empty12a.c
create mode 100644 gcc/testsuite/g++.dg/pr60336-1.C
create mode 100644 gcc/testsuite/g++.dg/pr60336-2.C
create mode 100644 gcc/testsuite/g++.dg/pr68355.C
diff --git a/gcc/calls.c b/gcc/calls.c
index b56556a..ecc9b7a 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -4835,7 +4835,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
Note that in C the default argument promotions
will prevent such mismatches. */
- size = GET_MODE_SIZE (arg->mode);
+ if (lang_hooks.decls.empty_record_p (TREE_TYPE (pval)))
+ size = 0;
+ else
+ size = GET_MODE_SIZE (arg->mode);
/* Compute how much space the push instruction will push.
On many machines, pushing a byte will advance the stack
pointer by a halfword. */
@@ -4865,10 +4868,14 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
/* This isn't already where we want it on the stack, so put it there.
This can either be done with push or copy insns. */
- if (!emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
- parm_align, partial, reg, used - size, argblock,
- ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
- ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
+ if (used
+ && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
+ NULL_RTX, parm_align, partial, reg,
+ used - size, argblock,
+ ARGS_SIZE_RTX (arg->locate.offset),
+ reg_parm_stack_space,
+ ARGS_SIZE_RTX (arg->locate.alignment_pad),
+ true))
sibcall_failure = 1;
/* Unless this is a partially-in-register argument, the argument is now
@@ -4900,10 +4907,16 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
{
/* PUSH_ROUNDING has no effect on us, because emit_push_insn
for BLKmode is careful to avoid it. */
+ bool empty_record
+ = lang_hooks.decls.empty_record_p (TREE_TYPE (pval));
excess = (arg->locate.size.constant
- - int_size_in_bytes (TREE_TYPE (pval))
+ - (empty_record
+ ? 0
+ : int_size_in_bytes (TREE_TYPE (pval)))
+ partial);
- size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
+ size_rtx = expand_expr ((empty_record
+ ? size_zero_node
+ : size_in_bytes (TREE_TYPE (pval))),
NULL_RTX, TYPE_MODE (sizetype),
EXPAND_NORMAL);
}
@@ -4971,10 +4984,13 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
}
}
- emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
- parm_align, partial, reg, excess, argblock,
- ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
- ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
+ if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
+ emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
+ size_rtx, parm_align, partial, reg, excess,
+ argblock, ARGS_SIZE_RTX (arg->locate.offset),
+ reg_parm_stack_space,
+ ARGS_SIZE_RTX (arg->locate.alignment_pad),
+ false);
/* Unless this is a partially-in-register argument, the argument is now
in the stack.
@@ -5052,6 +5068,9 @@ must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
if (TREE_ADDRESSABLE (type))
return true;
+ if (lang_hooks.decls.empty_record_p (type))
+ return false;
+
/* If the padding and mode of the type is such that a copy into
a register would put it into the wrong part of the register. */
if (mode == BLKmode
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 6173dae..8bd6198 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -7920,6 +7920,9 @@ static int
classify_argument (machine_mode mode, const_tree type,
enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
{
+ if (type && lang_hooks.decls.empty_record_p (type))
+ return 0;
+
HOST_WIDE_INT bytes =
(mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
int words = CEIL (bytes + (bit_offset % 64) / 8, UNITS_PER_WORD);
@@ -8371,6 +8374,9 @@ construct_container (machine_mode mode, machine_mode orig_mode,
static bool issued_sse_ret_error;
static bool issued_x87_ret_error;
+ if (type && lang_hooks.decls.empty_record_p (type))
+ return NULL;
+
machine_mode tmpmode;
int bytes =
(mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
@@ -8783,6 +8789,9 @@ ix86_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
HOST_WIDE_INT bytes, words;
int nregs;
+ if (type && lang_hooks.decls.empty_record_p (type))
+ return;
+
if (mode == BLKmode)
bytes = int_size_in_bytes (type);
else
@@ -9099,6 +9108,9 @@ ix86_function_arg (cumulative_args_t cum_v, machine_mode omode,
HOST_WIDE_INT bytes, words;
rtx arg;
+ if (type && lang_hooks.decls.empty_record_p (type))
+ return NULL;
+
/* All pointer bounds arguments are handled separately here. */
if ((type && POINTER_BOUNDS_TYPE_P (type))
|| POINTER_BOUNDS_MODE_P (mode))
@@ -9708,6 +9720,9 @@ ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
if (POINTER_BOUNDS_TYPE_P (type))
return false;
+ if (type && lang_hooks.decls.empty_record_p (type))
+ return false;
+
if (TARGET_64BIT)
{
if (ix86_function_type_abi (fntype) == MS_ABI)
@@ -10266,7 +10281,8 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
if (indirect_p)
type = build_pointer_type (type);
- size = int_size_in_bytes (type);
+ bool empty_record = type && lang_hooks.decls.empty_record_p (type);
+ size = empty_record ? 0 : int_size_in_bytes (type);
rsize = CEIL (size, UNITS_PER_WORD);
nat_mode = type_natural_mode (type, NULL, false);
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 216a301..c380734 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -8068,8 +8068,8 @@ build_self_reference (void)
/* Returns 1 if TYPE contains only padding bytes. */
-int
-is_empty_class (tree type)
+bool
+is_empty_class (const_tree type)
{
if (type == error_mark_node)
return 0;
@@ -8084,7 +8084,7 @@ is_empty_class (tree type)
possible combinations of empty classes and possibly a vptr. */
bool
-is_really_empty_class (tree type)
+is_really_empty_class (const_tree type)
{
if (CLASS_TYPE_P (type))
{
@@ -8098,10 +8098,13 @@ is_really_empty_class (tree type)
if (COMPLETE_TYPE_P (type) && is_empty_class (type))
return true;
- for (binfo = TYPE_BINFO (type), i = 0;
- BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
- if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
- return false;
+ /* TYPE_BINFO may be zeron when is_really_empty_class is called
+ from LANG_HOOKS_EMPTY_RECORD_P. */
+ binfo = TYPE_BINFO (type);
+ if (binfo)
+ for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
+ if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
+ return false;
for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL
&& !DECL_ARTIFICIAL (field)
diff --git a/gcc/cp/cp-lang.c b/gcc/cp/cp-lang.c
index 048108d..80174cb 100644
--- a/gcc/cp/cp-lang.c
+++ b/gcc/cp/cp-lang.c
@@ -78,6 +78,8 @@ static tree cxx_enum_underlying_base_type (const_tree);
#define LANG_HOOKS_EH_RUNTIME_TYPE build_eh_type_type
#undef LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE
#define LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE cxx_enum_underlying_base_type
+#undef LANG_HOOKS_EMPTY_RECORD_P
+#define LANG_HOOKS_EMPTY_RECORD_P is_really_empty_class
/* Each front end provides its own lang hook initializer. */
struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 84437b4..dc79979 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -5578,8 +5578,8 @@ extern tree finish_struct (tree, tree);
extern void finish_struct_1 (tree);
extern int resolves_to_fixed_type_p (tree, int *);
extern void init_class_processing (void);
-extern int is_empty_class (tree);
-extern bool is_really_empty_class (tree);
+extern bool is_empty_class (const_tree);
+extern bool is_really_empty_class (const_tree);
extern void pushclass (tree);
extern void popclass (void);
extern void push_nested_class (tree);
diff --git a/gcc/function.c b/gcc/function.c
index afc2c87..b59157d 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -4093,8 +4093,11 @@ locate_and_pad_parm (machine_mode passed_mode, tree type, int in_regs,
part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
- sizetree
- = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
+ if (type)
+ sizetree = (lang_hooks.decls.empty_record_p (type)
+ ? size_zero_node : size_in_bytes (type));
+ else
+ sizetree = size_int (GET_MODE_SIZE (passed_mode));
where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
boundary = targetm.calls.function_arg_boundary (passed_mode, type);
round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h
index 18ac84d..df4cbf8 100644
--- a/gcc/langhooks-def.h
+++ b/gcc/langhooks-def.h
@@ -163,6 +163,7 @@ extern tree lhd_make_node (enum tree_code);
#define LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P hook_bool_const_tree_false
#define LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P \
hook_bool_tree_tree_false
+#define LANG_HOOKS_EMPTY_RECORD_P hook_bool_const_tree_false
#define LANG_HOOKS_GET_GENERIC_FUNCTION_DECL hook_tree_const_tree_null
#define LANG_HOOKS_TYPE_PROMOTES_TO lhd_type_promotes_to
#define LANG_HOOKS_REGISTER_BUILTIN_TYPE lhd_register_builtin_type
@@ -228,6 +229,7 @@ extern tree lhd_make_node (enum tree_code);
LANG_HOOKS_FUNCTION_DECL_DELETED_P, \
LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P, \
LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P, \
+ LANG_HOOKS_EMPTY_RECORD_P, \
LANG_HOOKS_GET_GENERIC_FUNCTION_DECL, \
LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL, \
LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS, \
diff --git a/gcc/langhooks.h b/gcc/langhooks.h
index d8d01fa..450bdee 100644
--- a/gcc/langhooks.h
+++ b/gcc/langhooks.h
@@ -177,6 +177,9 @@ struct lang_hooks_for_decls
function parameter pack. */
bool (*function_parm_expanded_from_pack_p) (tree, tree);
+ /* Determine if a type is an empty record. */
+ bool (*empty_record_p) (const_tree type);
+
/* Returns the generic declaration of a generic function instantiations. */
tree (*get_generic_function_decl) (const_tree);
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index 5aae9e9..cc4cede 100644
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -128,7 +128,7 @@ along with GCC; see the file COPYING3. If not see
String are represented in the table as pairs, a length in ULEB128
form followed by the data for the string. */
-#define LTO_major_version 5
+#define LTO_major_version 6
#define LTO_minor_version 0
typedef unsigned char lto_decl_flags_t;
diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
index 53dd8f6..dc849a4 100644
--- a/gcc/lto/lto-lang.c
+++ b/gcc/lto/lto-lang.c
@@ -1306,6 +1306,16 @@ static void lto_init_ts (void)
tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
}
+/* Return true if TYPE contains no actual data, just various possible
+ combinations of empty records. */
+
+static bool
+lto_empty_record_p (const_tree type)
+{
+ /* Set if a record is empty. */
+ return TYPE_LANG_FLAG_0 (type);
+}
+
#undef LANG_HOOKS_NAME
#define LANG_HOOKS_NAME "GNU GIMPLE"
#undef LANG_HOOKS_OPTION_LANG_MASK
@@ -1363,6 +1373,9 @@ static void lto_init_ts (void)
#undef LANG_HOOKS_INIT_TS
#define LANG_HOOKS_INIT_TS lto_init_ts
+#undef LANG_HOOKS_EMPTY_RECORD_P
+#define LANG_HOOKS_EMPTY_RECORD_P lto_empty_record_p
+
struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
/* Language hooks that are not part of lang_hooks. */
diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index c34b4e9..5e74dd9 100644
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -74,6 +74,7 @@ along with GCC; see the file COPYING3. If not see
#include "intl.h"
#include "opts.h"
#include "gimplify.h"
+#include "langhooks.h"
bool
@@ -1823,9 +1824,12 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
/* Hoist the valist value into a temporary for the moment. */
valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
+ bool empty_record = lang_hooks.decls.empty_record_p (type);
+
/* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
requires greater alignment, we must perform dynamic alignment. */
if (boundary > align
+ && !empty_record
&& !integer_zerop (TYPE_SIZE (type)))
{
t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
@@ -1852,7 +1856,7 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
}
/* Compute the rounded size of the type. */
- type_size = size_in_bytes (type);
+ type_size = empty_record ? size_zero_node : size_in_bytes (type);
rounded_size = round_up (type_size, align);
/* Reduce rounded_size so it's sharable with the postqueue. */
diff --git a/gcc/testsuite/g++.dg/abi/empty12.C b/gcc/testsuite/g++.dg/abi/empty12.C
new file mode 100644
index 0000000..430d57d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty12.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-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);
+ 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/pr60336-1.C b/gcc/testsuite/g++.dg/pr60336-1.C
new file mode 100644
index 0000000..af08638
--- /dev/null
+++ b/gcc/testsuite/g++.dg/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/pr60336-2.C b/gcc/testsuite/g++.dg/pr60336-2.C
new file mode 100644
index 0000000..7b902e8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr60336-2.C
@@ -0,0 +1,28 @@
+// { dg-do run }
+// { dg-options "-O2" }
+
+#include <stdarg.h>
+
+struct dummy { struct{}__attribute__((aligned (4))) a[7]; };
+
+void
+test (struct dummy a, ...)
+{
+ va_list va_arglist;
+ int i;
+
+ va_start (va_arglist, a);
+ i = va_arg (va_arglist, int);
+ if (i != 0x10)
+ __builtin_abort ();
+ va_end (va_arglist);
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0x10);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/pr68355.C b/gcc/testsuite/g++.dg/pr68355.C
new file mode 100644
index 0000000..1354fc4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/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-*-* } } }
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index bb5cd49..6b1e25d 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -394,6 +394,8 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
if (mode == BLKmode)
size_tree = TYPE_SIZE (TREE_TYPE (exp));
+ else if (lang_hooks.decls.empty_record_p (TREE_TYPE (exp)))
+ bitsize = 0;
else
bitsize = int (GET_MODE_PRECISION (mode));
}
diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
index 65a1ce3..1c32d81 100644
--- a/gcc/tree-streamer-in.c
+++ b/gcc/tree-streamer-in.c
@@ -154,6 +154,11 @@ unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
}
else
bp_unpack_value (bp, 9);
+ if (TYPE_P (expr))
+ /* Set if a record is empty. */
+ TYPE_LANG_FLAG_0 (expr) = (unsigned) bp_unpack_value (bp, 1);
+ else
+ bp_unpack_value (bp, 1);
}
diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index d0b7f6d..a1bf962 100644
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
#include "alias.h"
#include "stor-layout.h"
#include "gomp-constants.h"
+#include "langhooks.h"
/* Output the STRING constant to the string
@@ -128,6 +129,11 @@ pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
}
else
bp_pack_value (bp, 0, 9);
+ if (TYPE_P (expr))
+ /* Stream out a bit to indicate if a record is empty. */
+ bp_pack_value (bp, lang_hooks.decls.empty_record_p (expr), 1);
+ else
+ bp_pack_value (bp, 0, 1);
}
--
2.4.3
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-17 11:01 [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class H.J. Lu
@ 2015-11-17 12:22 ` Richard Biener
2015-11-20 18:52 ` H.J. Lu
0 siblings, 1 reply; 14+ messages in thread
From: Richard Biener @ 2015-11-17 12:22 UTC (permalink / raw)
To: H.J. Lu; +Cc: GCC Patches
On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
> Empty record should be returned and passed the same way in C and C++.
> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
> to is_really_empty_class, which returns true for C++ empty classes. For
> LTO, we stream out a bit to indicate if a record is empty and we store
> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
> changed to set bitsize to 0 for empty records. Middle-end and x86
> backend are updated to ignore empty records for parameter passing and
> function value return. Other targets may need similar changes.
Please avoid a new langhook for this and instead claim a bit in tree_type_common
like for example restrict_flag (double-check it is unused for non-pointers).
I don't like that you need to modify targets - those checks should be done
in the caller (which may just use a new wrapper with the logic and then
dispatching to the actual hook).
Why do you need do adjust get_ref_base_and_extent?
Thanks,
Richard.
> gcc/
>
> PR c++/60336
> PR middle-end/67239
> PR target/68355
> * calls.c (store_one_arg): Use 0 for empty record size. Don't
> push 0 size argument onto stack.
> (must_pass_in_stack_var_size_or_pad): Return false for empty
> record.
> * function.c (locate_and_pad_parm): Use 0 for empty record size.
> * tree-dfa.c (get_ref_base_and_extent): Likewise.
> * langhooks-def.h (LANG_HOOKS_EMPTY_RECORD_P): New.
> (LANG_HOOKS_DECLS): Add LANG_HOOKS_EMPTY_RECORD_P.
> * langhooks.h (lang_hooks_for_decls): Add empty_record_p.
> * lto-streamer.h (LTO_major_version): Increase by 1 to 6.
> * targhooks.c: Include "langhooks.h".
> (std_gimplify_va_arg_expr): Use 0 for empty record size.
> * tree-streamer-in.c (unpack_ts_base_value_fields): Stream in
> TYPE_LANG_FLAG_0.
> * tree-streamer-out.c: Include "langhooks.h".
> (pack_ts_base_value_fields): Stream out a bit to indicate if a
> record is empty.
> * config/i386/i386.c (classify_argument): Return 0 for empty
> record.
> (construct_container): Return NULL for empty record.
> (ix86_function_arg): Likewise.
> (ix86_function_arg_advance): Skip empty record.
> (ix86_return_in_memory): Return false for empty record.
> (ix86_gimplify_va_arg): Use 0 for empty record size.
>
> gcc/cp/
>
> PR c++/60336
> PR middle-end/67239
> PR target/68355
> * class.c (is_empty_class): Changed to return bool and take
> const_tree.
> (is_really_empty_class): Changed to take const_tree. Check
> if TYPE_BINFO is zero.
> * cp-tree.h (is_empty_class): Updated.
> (is_really_empty_class): Likewise.
> * cp-lang.c (LANG_HOOKS_EMPTY_RECORD_P): New.
>
> gcc/lto/
>
> PR c++/60336
> PR middle-end/67239
> PR target/68355
> * lto-lang.c (lto_empty_record_p): New.
> (LANG_HOOKS_EMPTY_RECORD_P): Likewise.
>
> gcc/testsuite/
>
> PR c++/60336
> PR middle-end/67239
> PR target/68355
> * g++.dg/abi/empty12.C: New test.
> * g++.dg/abi/empty12.h: Likewise.
> * g++.dg/abi/empty12a.c: Likewise.
> * g++.dg/pr60336-1.C: Likewise.
> * g++.dg/pr60336-2.C: Likewise.
> * g++.dg/pr68355.C: Likewise.
> ---
> gcc/calls.c | 41 +++++++++++++++++++++++++++----------
> gcc/config/i386/i386.c | 18 +++++++++++++++-
> gcc/cp/class.c | 17 ++++++++-------
> gcc/cp/cp-lang.c | 2 ++
> gcc/cp/cp-tree.h | 4 ++--
> gcc/function.c | 7 +++++--
> gcc/langhooks-def.h | 2 ++
> gcc/langhooks.h | 3 +++
> gcc/lto-streamer.h | 2 +-
> gcc/lto/lto-lang.c | 13 ++++++++++++
> gcc/targhooks.c | 6 +++++-
> gcc/testsuite/g++.dg/abi/empty12.C | 17 +++++++++++++++
> gcc/testsuite/g++.dg/abi/empty12.h | 9 ++++++++
> gcc/testsuite/g++.dg/abi/empty12a.c | 6 ++++++
> gcc/testsuite/g++.dg/pr60336-1.C | 17 +++++++++++++++
> gcc/testsuite/g++.dg/pr60336-2.C | 28 +++++++++++++++++++++++++
> gcc/testsuite/g++.dg/pr68355.C | 24 ++++++++++++++++++++++
> gcc/tree-dfa.c | 2 ++
> gcc/tree-streamer-in.c | 5 +++++
> gcc/tree-streamer-out.c | 6 ++++++
> 20 files changed, 204 insertions(+), 25 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/abi/empty12.C
> create mode 100644 gcc/testsuite/g++.dg/abi/empty12.h
> create mode 100644 gcc/testsuite/g++.dg/abi/empty12a.c
> create mode 100644 gcc/testsuite/g++.dg/pr60336-1.C
> create mode 100644 gcc/testsuite/g++.dg/pr60336-2.C
> create mode 100644 gcc/testsuite/g++.dg/pr68355.C
>
> diff --git a/gcc/calls.c b/gcc/calls.c
> index b56556a..ecc9b7a 100644
> --- a/gcc/calls.c
> +++ b/gcc/calls.c
> @@ -4835,7 +4835,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
> Note that in C the default argument promotions
> will prevent such mismatches. */
>
> - size = GET_MODE_SIZE (arg->mode);
> + if (lang_hooks.decls.empty_record_p (TREE_TYPE (pval)))
> + size = 0;
> + else
> + size = GET_MODE_SIZE (arg->mode);
> /* Compute how much space the push instruction will push.
> On many machines, pushing a byte will advance the stack
> pointer by a halfword. */
> @@ -4865,10 +4868,14 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
>
> /* This isn't already where we want it on the stack, so put it there.
> This can either be done with push or copy insns. */
> - if (!emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
> - parm_align, partial, reg, used - size, argblock,
> - ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
> - ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
> + if (used
> + && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
> + NULL_RTX, parm_align, partial, reg,
> + used - size, argblock,
> + ARGS_SIZE_RTX (arg->locate.offset),
> + reg_parm_stack_space,
> + ARGS_SIZE_RTX (arg->locate.alignment_pad),
> + true))
> sibcall_failure = 1;
>
> /* Unless this is a partially-in-register argument, the argument is now
> @@ -4900,10 +4907,16 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
> {
> /* PUSH_ROUNDING has no effect on us, because emit_push_insn
> for BLKmode is careful to avoid it. */
> + bool empty_record
> + = lang_hooks.decls.empty_record_p (TREE_TYPE (pval));
> excess = (arg->locate.size.constant
> - - int_size_in_bytes (TREE_TYPE (pval))
> + - (empty_record
> + ? 0
> + : int_size_in_bytes (TREE_TYPE (pval)))
> + partial);
> - size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
> + size_rtx = expand_expr ((empty_record
> + ? size_zero_node
> + : size_in_bytes (TREE_TYPE (pval))),
> NULL_RTX, TYPE_MODE (sizetype),
> EXPAND_NORMAL);
> }
> @@ -4971,10 +4984,13 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
> }
> }
>
> - emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
> - parm_align, partial, reg, excess, argblock,
> - ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
> - ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
> + if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
> + emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
> + size_rtx, parm_align, partial, reg, excess,
> + argblock, ARGS_SIZE_RTX (arg->locate.offset),
> + reg_parm_stack_space,
> + ARGS_SIZE_RTX (arg->locate.alignment_pad),
> + false);
>
> /* Unless this is a partially-in-register argument, the argument is now
> in the stack.
> @@ -5052,6 +5068,9 @@ must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
> if (TREE_ADDRESSABLE (type))
> return true;
>
> + if (lang_hooks.decls.empty_record_p (type))
> + return false;
> +
> /* If the padding and mode of the type is such that a copy into
> a register would put it into the wrong part of the register. */
> if (mode == BLKmode
> diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
> index 6173dae..8bd6198 100644
> --- a/gcc/config/i386/i386.c
> +++ b/gcc/config/i386/i386.c
> @@ -7920,6 +7920,9 @@ static int
> classify_argument (machine_mode mode, const_tree type,
> enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
> {
> + if (type && lang_hooks.decls.empty_record_p (type))
> + return 0;
> +
> HOST_WIDE_INT bytes =
> (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
> int words = CEIL (bytes + (bit_offset % 64) / 8, UNITS_PER_WORD);
> @@ -8371,6 +8374,9 @@ construct_container (machine_mode mode, machine_mode orig_mode,
> static bool issued_sse_ret_error;
> static bool issued_x87_ret_error;
>
> + if (type && lang_hooks.decls.empty_record_p (type))
> + return NULL;
> +
> machine_mode tmpmode;
> int bytes =
> (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
> @@ -8783,6 +8789,9 @@ ix86_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
> HOST_WIDE_INT bytes, words;
> int nregs;
>
> + if (type && lang_hooks.decls.empty_record_p (type))
> + return;
> +
> if (mode == BLKmode)
> bytes = int_size_in_bytes (type);
> else
> @@ -9099,6 +9108,9 @@ ix86_function_arg (cumulative_args_t cum_v, machine_mode omode,
> HOST_WIDE_INT bytes, words;
> rtx arg;
>
> + if (type && lang_hooks.decls.empty_record_p (type))
> + return NULL;
> +
> /* All pointer bounds arguments are handled separately here. */
> if ((type && POINTER_BOUNDS_TYPE_P (type))
> || POINTER_BOUNDS_MODE_P (mode))
> @@ -9708,6 +9720,9 @@ ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
> if (POINTER_BOUNDS_TYPE_P (type))
> return false;
>
> + if (type && lang_hooks.decls.empty_record_p (type))
> + return false;
> +
> if (TARGET_64BIT)
> {
> if (ix86_function_type_abi (fntype) == MS_ABI)
> @@ -10266,7 +10281,8 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
> indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
> if (indirect_p)
> type = build_pointer_type (type);
> - size = int_size_in_bytes (type);
> + bool empty_record = type && lang_hooks.decls.empty_record_p (type);
> + size = empty_record ? 0 : int_size_in_bytes (type);
> rsize = CEIL (size, UNITS_PER_WORD);
>
> nat_mode = type_natural_mode (type, NULL, false);
> diff --git a/gcc/cp/class.c b/gcc/cp/class.c
> index 216a301..c380734 100644
> --- a/gcc/cp/class.c
> +++ b/gcc/cp/class.c
> @@ -8068,8 +8068,8 @@ build_self_reference (void)
>
> /* Returns 1 if TYPE contains only padding bytes. */
>
> -int
> -is_empty_class (tree type)
> +bool
> +is_empty_class (const_tree type)
> {
> if (type == error_mark_node)
> return 0;
> @@ -8084,7 +8084,7 @@ is_empty_class (tree type)
> possible combinations of empty classes and possibly a vptr. */
>
> bool
> -is_really_empty_class (tree type)
> +is_really_empty_class (const_tree type)
> {
> if (CLASS_TYPE_P (type))
> {
> @@ -8098,10 +8098,13 @@ is_really_empty_class (tree type)
> if (COMPLETE_TYPE_P (type) && is_empty_class (type))
> return true;
>
> - for (binfo = TYPE_BINFO (type), i = 0;
> - BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
> - if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
> - return false;
> + /* TYPE_BINFO may be zeron when is_really_empty_class is called
> + from LANG_HOOKS_EMPTY_RECORD_P. */
> + binfo = TYPE_BINFO (type);
> + if (binfo)
> + for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
> + if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
> + return false;
> for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
> if (TREE_CODE (field) == FIELD_DECL
> && !DECL_ARTIFICIAL (field)
> diff --git a/gcc/cp/cp-lang.c b/gcc/cp/cp-lang.c
> index 048108d..80174cb 100644
> --- a/gcc/cp/cp-lang.c
> +++ b/gcc/cp/cp-lang.c
> @@ -78,6 +78,8 @@ static tree cxx_enum_underlying_base_type (const_tree);
> #define LANG_HOOKS_EH_RUNTIME_TYPE build_eh_type_type
> #undef LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE
> #define LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE cxx_enum_underlying_base_type
> +#undef LANG_HOOKS_EMPTY_RECORD_P
> +#define LANG_HOOKS_EMPTY_RECORD_P is_really_empty_class
>
> /* Each front end provides its own lang hook initializer. */
> struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 84437b4..dc79979 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -5578,8 +5578,8 @@ extern tree finish_struct (tree, tree);
> extern void finish_struct_1 (tree);
> extern int resolves_to_fixed_type_p (tree, int *);
> extern void init_class_processing (void);
> -extern int is_empty_class (tree);
> -extern bool is_really_empty_class (tree);
> +extern bool is_empty_class (const_tree);
> +extern bool is_really_empty_class (const_tree);
> extern void pushclass (tree);
> extern void popclass (void);
> extern void push_nested_class (tree);
> diff --git a/gcc/function.c b/gcc/function.c
> index afc2c87..b59157d 100644
> --- a/gcc/function.c
> +++ b/gcc/function.c
> @@ -4093,8 +4093,11 @@ locate_and_pad_parm (machine_mode passed_mode, tree type, int in_regs,
>
> part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
>
> - sizetree
> - = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
> + if (type)
> + sizetree = (lang_hooks.decls.empty_record_p (type)
> + ? size_zero_node : size_in_bytes (type));
> + else
> + sizetree = size_int (GET_MODE_SIZE (passed_mode));
> where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
> boundary = targetm.calls.function_arg_boundary (passed_mode, type);
> round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
> diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h
> index 18ac84d..df4cbf8 100644
> --- a/gcc/langhooks-def.h
> +++ b/gcc/langhooks-def.h
> @@ -163,6 +163,7 @@ extern tree lhd_make_node (enum tree_code);
> #define LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P hook_bool_const_tree_false
> #define LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P \
> hook_bool_tree_tree_false
> +#define LANG_HOOKS_EMPTY_RECORD_P hook_bool_const_tree_false
> #define LANG_HOOKS_GET_GENERIC_FUNCTION_DECL hook_tree_const_tree_null
> #define LANG_HOOKS_TYPE_PROMOTES_TO lhd_type_promotes_to
> #define LANG_HOOKS_REGISTER_BUILTIN_TYPE lhd_register_builtin_type
> @@ -228,6 +229,7 @@ extern tree lhd_make_node (enum tree_code);
> LANG_HOOKS_FUNCTION_DECL_DELETED_P, \
> LANG_HOOKS_GENERIC_GENERIC_PARAMETER_DECL_P, \
> LANG_HOOKS_FUNCTION_PARM_EXPANDED_FROM_PACK_P, \
> + LANG_HOOKS_EMPTY_RECORD_P, \
> LANG_HOOKS_GET_GENERIC_FUNCTION_DECL, \
> LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL, \
> LANG_HOOKS_POST_COMPILATION_PARSING_CLEANUPS, \
> diff --git a/gcc/langhooks.h b/gcc/langhooks.h
> index d8d01fa..450bdee 100644
> --- a/gcc/langhooks.h
> +++ b/gcc/langhooks.h
> @@ -177,6 +177,9 @@ struct lang_hooks_for_decls
> function parameter pack. */
> bool (*function_parm_expanded_from_pack_p) (tree, tree);
>
> + /* Determine if a type is an empty record. */
> + bool (*empty_record_p) (const_tree type);
> +
> /* Returns the generic declaration of a generic function instantiations. */
> tree (*get_generic_function_decl) (const_tree);
>
> diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
> index 5aae9e9..cc4cede 100644
> --- a/gcc/lto-streamer.h
> +++ b/gcc/lto-streamer.h
> @@ -128,7 +128,7 @@ along with GCC; see the file COPYING3. If not see
> String are represented in the table as pairs, a length in ULEB128
> form followed by the data for the string. */
>
> -#define LTO_major_version 5
> +#define LTO_major_version 6
> #define LTO_minor_version 0
>
> typedef unsigned char lto_decl_flags_t;
> diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
> index 53dd8f6..dc849a4 100644
> --- a/gcc/lto/lto-lang.c
> +++ b/gcc/lto/lto-lang.c
> @@ -1306,6 +1306,16 @@ static void lto_init_ts (void)
> tree_contains_struct[NAMESPACE_DECL][TS_DECL_MINIMAL] = 1;
> }
>
> +/* Return true if TYPE contains no actual data, just various possible
> + combinations of empty records. */
> +
> +static bool
> +lto_empty_record_p (const_tree type)
> +{
> + /* Set if a record is empty. */
> + return TYPE_LANG_FLAG_0 (type);
> +}
> +
> #undef LANG_HOOKS_NAME
> #define LANG_HOOKS_NAME "GNU GIMPLE"
> #undef LANG_HOOKS_OPTION_LANG_MASK
> @@ -1363,6 +1373,9 @@ static void lto_init_ts (void)
> #undef LANG_HOOKS_INIT_TS
> #define LANG_HOOKS_INIT_TS lto_init_ts
>
> +#undef LANG_HOOKS_EMPTY_RECORD_P
> +#define LANG_HOOKS_EMPTY_RECORD_P lto_empty_record_p
> +
> struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
>
> /* Language hooks that are not part of lang_hooks. */
> diff --git a/gcc/targhooks.c b/gcc/targhooks.c
> index c34b4e9..5e74dd9 100644
> --- a/gcc/targhooks.c
> +++ b/gcc/targhooks.c
> @@ -74,6 +74,7 @@ along with GCC; see the file COPYING3. If not see
> #include "intl.h"
> #include "opts.h"
> #include "gimplify.h"
> +#include "langhooks.h"
>
>
> bool
> @@ -1823,9 +1824,12 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
> /* Hoist the valist value into a temporary for the moment. */
> valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
>
> + bool empty_record = lang_hooks.decls.empty_record_p (type);
> +
> /* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
> requires greater alignment, we must perform dynamic alignment. */
> if (boundary > align
> + && !empty_record
> && !integer_zerop (TYPE_SIZE (type)))
> {
> t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
> @@ -1852,7 +1856,7 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
> }
>
> /* Compute the rounded size of the type. */
> - type_size = size_in_bytes (type);
> + type_size = empty_record ? size_zero_node : size_in_bytes (type);
> rounded_size = round_up (type_size, align);
>
> /* Reduce rounded_size so it's sharable with the postqueue. */
> diff --git a/gcc/testsuite/g++.dg/abi/empty12.C b/gcc/testsuite/g++.dg/abi/empty12.C
> new file mode 100644
> index 0000000..430d57d
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/abi/empty12.C
> @@ -0,0 +1,17 @@
> +// PR c++/60336
> +// { dg-do run }
> +// { dg-options "-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);
> + 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/pr60336-1.C b/gcc/testsuite/g++.dg/pr60336-1.C
> new file mode 100644
> index 0000000..af08638
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/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/pr60336-2.C b/gcc/testsuite/g++.dg/pr60336-2.C
> new file mode 100644
> index 0000000..7b902e8
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/pr60336-2.C
> @@ -0,0 +1,28 @@
> +// { dg-do run }
> +// { dg-options "-O2" }
> +
> +#include <stdarg.h>
> +
> +struct dummy { struct{}__attribute__((aligned (4))) a[7]; };
> +
> +void
> +test (struct dummy a, ...)
> +{
> + va_list va_arglist;
> + int i;
> +
> + va_start (va_arglist, a);
> + i = va_arg (va_arglist, int);
> + if (i != 0x10)
> + __builtin_abort ();
> + va_end (va_arglist);
> +}
> +
> +struct dummy a0;
> +
> +int
> +main ()
> +{
> + test (a0, 0x10);
> + return 0;
> +}
> diff --git a/gcc/testsuite/g++.dg/pr68355.C b/gcc/testsuite/g++.dg/pr68355.C
> new file mode 100644
> index 0000000..1354fc4
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/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-*-* } } }
> diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
> index bb5cd49..6b1e25d 100644
> --- a/gcc/tree-dfa.c
> +++ b/gcc/tree-dfa.c
> @@ -394,6 +394,8 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
> machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
> if (mode == BLKmode)
> size_tree = TYPE_SIZE (TREE_TYPE (exp));
> + else if (lang_hooks.decls.empty_record_p (TREE_TYPE (exp)))
> + bitsize = 0;
> else
> bitsize = int (GET_MODE_PRECISION (mode));
> }
> diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
> index 65a1ce3..1c32d81 100644
> --- a/gcc/tree-streamer-in.c
> +++ b/gcc/tree-streamer-in.c
> @@ -154,6 +154,11 @@ unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
> }
> else
> bp_unpack_value (bp, 9);
> + if (TYPE_P (expr))
> + /* Set if a record is empty. */
> + TYPE_LANG_FLAG_0 (expr) = (unsigned) bp_unpack_value (bp, 1);
> + else
> + bp_unpack_value (bp, 1);
> }
>
>
> diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
> index d0b7f6d..a1bf962 100644
> --- a/gcc/tree-streamer-out.c
> +++ b/gcc/tree-streamer-out.c
> @@ -31,6 +31,7 @@ along with GCC; see the file COPYING3. If not see
> #include "alias.h"
> #include "stor-layout.h"
> #include "gomp-constants.h"
> +#include "langhooks.h"
>
>
> /* Output the STRING constant to the string
> @@ -128,6 +129,11 @@ pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
> }
> else
> bp_pack_value (bp, 0, 9);
> + if (TYPE_P (expr))
> + /* Stream out a bit to indicate if a record is empty. */
> + bp_pack_value (bp, lang_hooks.decls.empty_record_p (expr), 1);
> + else
> + bp_pack_value (bp, 0, 1);
> }
>
>
> --
> 2.4.3
>
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-17 12:22 ` Richard Biener
@ 2015-11-20 18:52 ` H.J. Lu
2015-11-20 22:17 ` Jason Merrill
0 siblings, 1 reply; 14+ messages in thread
From: H.J. Lu @ 2015-11-20 18:52 UTC (permalink / raw)
To: Richard Biener; +Cc: GCC Patches
On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
<richard.guenther@gmail.com> wrote:
> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>> Empty record should be returned and passed the same way in C and C++.
>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>> to is_really_empty_class, which returns true for C++ empty classes. For
>> LTO, we stream out a bit to indicate if a record is empty and we store
>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>> changed to set bitsize to 0 for empty records. Middle-end and x86
>> backend are updated to ignore empty records for parameter passing and
>> function value return. Other targets may need similar changes.
>
> Please avoid a new langhook for this and instead claim a bit in tree_type_common
> like for example restrict_flag (double-check it is unused for non-pointers).
There is no bit in tree_type_common I can overload. restrict_flag is
checked for non-pointers to issue an error when it is used on non-pointers:
/export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
qualifiers cannot" "" }
Should I add a bit to tree_type_common? It may crease the size
of tree_type_common by 4 bytes since there is unused bits in
tree_type_common.
> I don't like that you need to modify targets - those checks should be done
> in the caller (which may just use a new wrapper with the logic and then
> dispatching to the actual hook).
I can do that.
> Why do you need do adjust get_ref_base_and_extent?
get_ref_base_and_extent is changed to set bitsize to 0 for empty records
so that when ref_maybe_used_by_call_p_1 calls get_ref_base_and_extent to
get 0 as the maximum size on empty record. Otherwise, find_tail_calls
won't perform tail call optimization for functions with empty record
parameters, as in
struct dummy { };
struct true_type { struct dummy i; };
extern true_type y;
extern void xxx (true_type c);
void
yyy (void)
{
xxx (y);
}
--
H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-20 18:52 ` H.J. Lu
@ 2015-11-20 22:17 ` Jason Merrill
2015-11-20 22:24 ` Jason Merrill
2015-11-20 23:47 ` H.J. Lu
0 siblings, 2 replies; 14+ messages in thread
From: Jason Merrill @ 2015-11-20 22:17 UTC (permalink / raw)
To: H.J. Lu, Richard Biener; +Cc: GCC Patches
On 11/20/2015 01:52 PM, H.J. Lu wrote:
> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
> <richard.guenther@gmail.com> wrote:
>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>> Empty record should be returned and passed the same way in C and C++.
>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>> backend are updated to ignore empty records for parameter passing and
>>> function value return. Other targets may need similar changes.
>>
>> Please avoid a new langhook for this and instead claim a bit in tree_type_common
>> like for example restrict_flag (double-check it is unused for non-pointers).
>
> There is no bit in tree_type_common I can overload. restrict_flag is
> checked for non-pointers to issue an error when it is used on non-pointers:
>
> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
> qualifiers cannot" "" }
The C++ front end only needs to check TYPE_RESTRICT for this purpose on
front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals
could handle that specifically if you change TYPE_RESTRICT to only apply
to pointers.
Jason
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-20 22:17 ` Jason Merrill
@ 2015-11-20 22:24 ` Jason Merrill
2015-11-20 23:47 ` H.J. Lu
1 sibling, 0 replies; 14+ messages in thread
From: Jason Merrill @ 2015-11-20 22:24 UTC (permalink / raw)
To: gcc-patches; +Cc: GCC Patches
On 11/20/2015 01:52 PM, H.J. Lu wrote:
> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
> <richard.guenther@gmail.com> wrote:
>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>> Empty record should be returned and passed the same way in C and C++.
>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>> backend are updated to ignore empty records for parameter passing and
>>> function value return. Other targets may need similar changes.
>>
>> Please avoid a new langhook for this and instead claim a bit in tree_type_common
>> like for example restrict_flag (double-check it is unused for non-pointers).
>
> There is no bit in tree_type_common I can overload. restrict_flag is
> checked for non-pointers to issue an error when it is used on non-pointers:
>
> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
> qualifiers cannot" "" }
The C++ front end only needs to check TYPE_RESTRICT for this purpose on
front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals
could handle that specifically if you change TYPE_RESTRICT to only apply
to pointers.
Jason
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-20 22:17 ` Jason Merrill
2015-11-20 22:24 ` Jason Merrill
@ 2015-11-20 23:47 ` H.J. Lu
2015-11-23 9:59 ` Richard Biener
1 sibling, 1 reply; 14+ messages in thread
From: H.J. Lu @ 2015-11-20 23:47 UTC (permalink / raw)
To: Jason Merrill; +Cc: Richard Biener, GCC Patches
On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>
>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>> <richard.guenther@gmail.com> wrote:
>>>
>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>
>>>> Empty record should be returned and passed the same way in C and C++.
>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>> backend are updated to ignore empty records for parameter passing and
>>>> function value return. Other targets may need similar changes.
>>>
>>>
>>> Please avoid a new langhook for this and instead claim a bit in
>>> tree_type_common
>>> like for example restrict_flag (double-check it is unused for
>>> non-pointers).
>>
>>
>> There is no bit in tree_type_common I can overload. restrict_flag is
>> checked for non-pointers to issue an error when it is used on
>> non-pointers:
>>
>>
>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>> qualifiers cannot" "" }
>
>
> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
> handle that specifically if you change TYPE_RESTRICT to only apply to
> pointers.
>
restrict_flag is also checked in this case:
[hjl@gnu-6 gcc]$ cat x.i
struct dummy { };
struct dummy
foo (struct dummy __restrict__ i)
{
return i;
}
[hjl@gnu-6 gcc]$ gcc -S x.i -Wall
x.i:4:13: error: invalid use of ‘restrict’
foo (struct dummy __restrict__ i)
^
x.i:4:13: error: invalid use of ‘restrict’
[hjl@gnu-6 gcc]$
restrict_flag can't also be used to indicate `i' is an empty record.
H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-20 23:47 ` H.J. Lu
@ 2015-11-23 9:59 ` Richard Biener
2015-11-23 20:54 ` H.J. Lu
0 siblings, 1 reply; 14+ messages in thread
From: Richard Biener @ 2015-11-23 9:59 UTC (permalink / raw)
To: H.J. Lu; +Cc: Jason Merrill, GCC Patches
On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>
>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>> <richard.guenther@gmail.com> wrote:
>>>>
>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>
>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>> backend are updated to ignore empty records for parameter passing and
>>>>> function value return. Other targets may need similar changes.
>>>>
>>>>
>>>> Please avoid a new langhook for this and instead claim a bit in
>>>> tree_type_common
>>>> like for example restrict_flag (double-check it is unused for
>>>> non-pointers).
>>>
>>>
>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>> checked for non-pointers to issue an error when it is used on
>>> non-pointers:
>>>
>>>
>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>> qualifiers cannot" "" }
>>
>>
>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>> handle that specifically if you change TYPE_RESTRICT to only apply to
>> pointers.
>>
>
> restrict_flag is also checked in this case:
>
> [hjl@gnu-6 gcc]$ cat x.i
> struct dummy { };
>
> struct dummy
> foo (struct dummy __restrict__ i)
> {
> return i;
> }
> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
> x.i:4:13: error: invalid use of ‘restrict’
> foo (struct dummy __restrict__ i)
> ^
> x.i:4:13: error: invalid use of ‘restrict’
> [hjl@gnu-6 gcc]$
>
> restrict_flag can't also be used to indicate `i' is an empty record.
I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
But well, use any other free bit (but do not enlarge
tree_type_common). Eventually
you can free up a bit by putting sth into type_lang_specific currently
using bits
in tree_type_common.
Richard.
>
> H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-23 9:59 ` Richard Biener
@ 2015-11-23 20:54 ` H.J. Lu
2015-11-24 3:48 ` Patrick Palka
0 siblings, 1 reply; 14+ messages in thread
From: H.J. Lu @ 2015-11-23 20:54 UTC (permalink / raw)
To: Richard Biener; +Cc: Jason Merrill, GCC Patches
[-- Attachment #1: Type: text/plain, Size: 3058 bytes --]
On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
<richard.guenther@gmail.com> wrote:
> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>
>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>> <richard.guenther@gmail.com> wrote:
>>>>>
>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>
>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>> function value return. Other targets may need similar changes.
>>>>>
>>>>>
>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>> tree_type_common
>>>>> like for example restrict_flag (double-check it is unused for
>>>>> non-pointers).
>>>>
>>>>
>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>> checked for non-pointers to issue an error when it is used on
>>>> non-pointers:
>>>>
>>>>
>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>> qualifiers cannot" "" }
>>>
>>>
>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>> pointers.
>>>
>>
>> restrict_flag is also checked in this case:
>>
>> [hjl@gnu-6 gcc]$ cat x.i
>> struct dummy { };
>>
>> struct dummy
>> foo (struct dummy __restrict__ i)
>> {
>> return i;
>> }
>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>> x.i:4:13: error: invalid use of ‘restrict’
>> foo (struct dummy __restrict__ i)
>> ^
>> x.i:4:13: error: invalid use of ‘restrict’
>> [hjl@gnu-6 gcc]$
>>
>> restrict_flag can't also be used to indicate `i' is an empty record.
>
> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>
> But well, use any other free bit (but do not enlarge
> tree_type_common). Eventually
> you can free up a bit by putting sth into type_lang_specific currently
> using bits
> in tree_type_common.
There are no bits in tree_type_common I can move. Instead,
this patch overloads side_effects_flag in tree_base. Tested on
Linux/x86-64. OK for trunk?
Thanks.
--
H.J.
[-- Attachment #2: 0001-Add-TYPE_EMPTY_RECORD-for-C-empty-class.patch --]
[-- Type: text/x-patch, Size: 31923 bytes --]
From 1e3e6ed42ed86b74d01bd3a6b869c15dba964c21 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Sun, 15 Nov 2015 13:19:05 -0800
Subject: [PATCH] Add TYPE_EMPTY_RECORD for C++ empty class
Empty record should be returned and passed the same way in C and C++.
This patch overloads a bit, side_effects_flag, in tree_base for C++
empty class. Middle-end and x86 backend are updated to ignore empty
records for parameter passing and function value return. Other targets
may need similar changes.
get_ref_base_and_extent is changed to set bitsize to 0 for empty records
so that when ref_maybe_used_by_call_p_1 calls get_ref_base_and_extent to
get 0 as the maximum size on empty record. Otherwise, find_tail_calls
won't perform tail call optimization for functions with empty record
parameters, as shown in g++.dg/pr60336-1.C and g++.dg/pr60336-2.C.
gcc/
PR c++/60336
PR middle-end/67239
PR target/68355
* calls.c (initialize_argument_information): Replace
targetm.calls.function_arg, targetm.calls.function_incoming_arg
and targetm.calls.function_arg_advance with function_arg,
function_incoming_arg and function_arg_advance.
(expand_call): Likewise.
(emit_library_call_value_1): Likewise.
(store_one_arg): Use 0 for empty record size. Don't
push 0 size argument onto stack.
(must_pass_in_stack_var_size_or_pad): Return false for empty
record.
* dse.c (get_call_args): Replace targetm.calls.function_arg
and targetm.calls.function_arg_advance with function_arg and
function_arg_advance.
* expr.c (block_move_libcall_safe_for_call_parm): Likewise.
* function.c (aggregate_value_p): Replace
targetm.calls.return_in_memory with return_in_memory.
(assign_parm_find_entry_rtl): Replace
targetm.calls.function_incoming_arg with function_incoming_arg.
(assign_parms): Replace targetm.calls.function_arg_advance with
function_arg_advance.
(gimplify_parameters): Replace targetm.calls.function_arg_advance
with function_arg_advance.
(locate_and_pad_parm): Use 0 for empty record size.
(function_arg_advance): New wrapper function.
(function_arg): Likewise.
(function_incoming_arg): Likewise.
(return_in_memory): Likewise.
* lto-streamer-out.c (hash_tree): Call hstate.add_flag with
TYPE_EMPTY_RECORD for types.
* print-tree.c (print_node): Also handle TYPE_EMPTY_RECORD.
* ubsan.c (ubsan_type_descriptor): Likewise.
* target.h (function_arg_advance): New prototype.
(function_arg): Likewise.
(function_incoming_arg): Likewise.
(return_in_memory): Likewise.
* targhooks.c (std_gimplify_va_arg_expr): Use 0 for empty record
size.
* tree-dfa.c (get_ref_base_and_extent): Likewise.
* tree-core.h (tree_base): Mention TYPE_EMPTY_RECORD in comments
for side_effects_flag.
* tree-streamer-in.c (unpack_ts_base_value_fields): Stream in
TYPE_EMPTY_RECORD for types.
* tree-streamer-out.c (pack_ts_base_value_fields): Stream out
TYPE_EMPTY_RECORD for types.
* tree.h (TYPE_EMPTY_RECORD): New.
(type_is_empty_record_p): New static inline function.
* var-tracking.c (prepare_call_arguments): Replace
targetm.calls.function_arg and targetm.calls.function_arg_advance
with function_arg and function_arg_advance.
* config/i386/i386.c (ix86_gimplify_va_arg): Use 0 for empty
record size.
gcc/c
PR c++/60336
PR middle-end/67239
PR target/68355
* c-aux-info.c (gen_type): Add TYPE_EMPTY_RECORD check.
gcc/cp/
PR c++/60336
PR middle-end/67239
PR target/68355
* class.c (finish_struct_1): Set TYPE_EMPTY_RECORD with return
value from is_really_empty_class ().
gcc/lto/
PR c++/60336
PR middle-end/67239
PR target/68355
* lto.c (compare_tree_sccs_1): Call compare_values with
TYPE_EMPTY_RECORD for types.
gcc/testsuite/
PR c++/60336
PR middle-end/67239
PR target/68355
* g++.dg/abi/empty12.C: New test.
* g++.dg/abi/empty12.h: Likewise.
* g++.dg/abi/empty12a.c: Likewise.
* g++.dg/pr60336-1.C: Likewise.
* g++.dg/pr60336-2.C: Likewise.
* g++.dg/pr68355.C: Likewise.
---
gcc/c/c-aux-info.c | 2 +
gcc/calls.c | 76 +++++++++++++++++++++---------------
gcc/config/i386/i386.c | 3 +-
gcc/cp/class.c | 2 +
gcc/dse.c | 4 +-
gcc/expr.c | 5 +--
gcc/function.c | 78 ++++++++++++++++++++++++++++++-------
gcc/lto-streamer-out.c | 2 +
gcc/lto/lto.c | 2 +
gcc/print-tree.c | 3 ++
gcc/target.h | 8 ++++
gcc/targhooks.c | 5 ++-
gcc/testsuite/g++.dg/abi/empty12.C | 17 ++++++++
gcc/testsuite/g++.dg/abi/empty12.h | 9 +++++
gcc/testsuite/g++.dg/abi/empty12a.c | 6 +++
gcc/testsuite/g++.dg/pr60336-1.C | 17 ++++++++
gcc/testsuite/g++.dg/pr60336-2.C | 28 +++++++++++++
gcc/testsuite/g++.dg/pr68355.C | 24 ++++++++++++
gcc/tree-core.h | 3 ++
gcc/tree-dfa.c | 2 +
gcc/tree-streamer-in.c | 5 ++-
gcc/tree-streamer-out.c | 5 ++-
gcc/tree.h | 12 ++++++
gcc/ubsan.c | 3 +-
gcc/var-tracking.c | 18 ++++-----
25 files changed, 274 insertions(+), 65 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/abi/empty12.C
create mode 100644 gcc/testsuite/g++.dg/abi/empty12.h
create mode 100644 gcc/testsuite/g++.dg/abi/empty12a.c
create mode 100644 gcc/testsuite/g++.dg/pr60336-1.C
create mode 100644 gcc/testsuite/g++.dg/pr60336-2.C
create mode 100644 gcc/testsuite/g++.dg/pr68355.C
diff --git a/gcc/c/c-aux-info.c b/gcc/c/c-aux-info.c
index 79d9851..93b001b 100644
--- a/gcc/c/c-aux-info.c
+++ b/gcc/c/c-aux-info.c
@@ -433,6 +433,8 @@ gen_type (const char *ret_val, tree t, formals_style style)
ret_val = concat ("volatile ", ret_val, NULL);
if (TYPE_RESTRICT (t))
ret_val = concat ("restrict ", ret_val, NULL);
+ if (TYPE_EMPTY_RECORD (t))
+ ret_val = concat ("empty-record ", ret_val, NULL);
return ret_val;
}
diff --git a/gcc/calls.c b/gcc/calls.c
index b56556a..a81cb3d 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -1391,8 +1391,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
args[i].unsignedp = unsignedp;
args[i].mode = mode;
- args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
- argpos < n_named_args);
+ args[i].reg = function_arg (args_so_far, mode, type,
+ argpos < n_named_args);
if (args[i].reg && CONST_INT_P (args[i].reg))
{
@@ -1405,8 +1405,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
arguments have to go into the incoming registers. */
if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
args[i].tail_call_reg
- = targetm.calls.function_incoming_arg (args_so_far, mode, type,
- argpos < n_named_args);
+ = function_incoming_arg (args_so_far, mode, type,
+ argpos < n_named_args);
else
args[i].tail_call_reg = args[i].reg;
@@ -1467,8 +1467,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
/* Increment ARGS_SO_FAR, which has info about which arg-registers
have been used, etc. */
- targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
- type, argpos < n_named_args);
+ function_arg_advance (args_so_far, TYPE_MODE (type), type,
+ argpos < n_named_args);
}
}
@@ -3320,14 +3320,11 @@ expand_call (tree exp, rtx target, int ignore)
/* Set up next argument register. For sibling calls on machines
with register windows this should be the incoming register. */
if (pass == 0)
- next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
- VOIDmode,
- void_type_node,
- true);
+ next_arg_reg = function_incoming_arg (args_so_far, VOIDmode,
+ void_type_node, true);
else
- next_arg_reg = targetm.calls.function_arg (args_so_far,
- VOIDmode, void_type_node,
- true);
+ next_arg_reg = function_arg (args_so_far, VOIDmode,
+ void_type_node, true);
if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
{
@@ -3939,8 +3936,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
argvec[count].mode = Pmode;
argvec[count].partial = 0;
- argvec[count].reg = targetm.calls.function_arg (args_so_far,
- Pmode, NULL_TREE, true);
+ argvec[count].reg = function_arg (args_so_far, Pmode, NULL_TREE,
+ true);
gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
NULL_TREE, 1) == 0);
@@ -3957,7 +3954,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
|| reg_parm_stack_space > 0)
args_size.constant += argvec[count].locate.size.constant;
- targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
+ function_arg_advance (args_so_far, Pmode, (tree) 0, true);
count++;
}
@@ -4022,7 +4019,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
argvec[count].mode = mode;
argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
- argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
+ argvec[count].reg = function_arg (args_so_far, mode,
NULL_TREE, true);
argvec[count].partial
@@ -4052,7 +4049,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
GET_MODE_SIZE (mode) <= UNITS_PER_WORD);
#endif
- targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
+ function_arg_advance (args_so_far, mode, (tree) 0, true);
}
/* If this machine requires an external definition for library
@@ -4399,8 +4396,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
build_function_type (tfom, NULL_TREE),
original_args_size.constant, args_size.constant,
struct_value_size,
- targetm.calls.function_arg (args_so_far,
- VOIDmode, void_type_node, true),
+ function_arg (args_so_far, VOIDmode, void_type_node, true),
valreg,
old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
@@ -4835,7 +4831,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
Note that in C the default argument promotions
will prevent such mismatches. */
- size = GET_MODE_SIZE (arg->mode);
+ if (type_is_empty_record_p (TREE_TYPE (pval)))
+ size = 0;
+ else
+ size = GET_MODE_SIZE (arg->mode);
/* Compute how much space the push instruction will push.
On many machines, pushing a byte will advance the stack
pointer by a halfword. */
@@ -4865,10 +4864,14 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
/* This isn't already where we want it on the stack, so put it there.
This can either be done with push or copy insns. */
- if (!emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
- parm_align, partial, reg, used - size, argblock,
- ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
- ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
+ if (used
+ && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
+ NULL_RTX, parm_align, partial, reg,
+ used - size, argblock,
+ ARGS_SIZE_RTX (arg->locate.offset),
+ reg_parm_stack_space,
+ ARGS_SIZE_RTX (arg->locate.alignment_pad),
+ true))
sibcall_failure = 1;
/* Unless this is a partially-in-register argument, the argument is now
@@ -4900,10 +4903,15 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
{
/* PUSH_ROUNDING has no effect on us, because emit_push_insn
for BLKmode is careful to avoid it. */
+ bool empty_record = type_is_empty_record_p (TREE_TYPE (pval));
excess = (arg->locate.size.constant
- - int_size_in_bytes (TREE_TYPE (pval))
+ - (empty_record
+ ? 0
+ : int_size_in_bytes (TREE_TYPE (pval)))
+ partial);
- size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
+ size_rtx = expand_expr ((empty_record
+ ? size_zero_node
+ : size_in_bytes (TREE_TYPE (pval))),
NULL_RTX, TYPE_MODE (sizetype),
EXPAND_NORMAL);
}
@@ -4971,10 +4979,13 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
}
}
- emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
- parm_align, partial, reg, excess, argblock,
- ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
- ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
+ if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
+ emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
+ size_rtx, parm_align, partial, reg, excess,
+ argblock, ARGS_SIZE_RTX (arg->locate.offset),
+ reg_parm_stack_space,
+ ARGS_SIZE_RTX (arg->locate.alignment_pad),
+ false);
/* Unless this is a partially-in-register argument, the argument is now
in the stack.
@@ -5052,6 +5063,9 @@ must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
if (TREE_ADDRESSABLE (type))
return true;
+ if (type_is_empty_record_p (type))
+ return false;
+
/* If the padding and mode of the type is such that a copy into
a register would put it into the wrong part of the register. */
if (mode == BLKmode
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index cc42544..01d4d80 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -10277,7 +10277,8 @@ ix86_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
indirect_p = pass_by_reference (NULL, TYPE_MODE (type), type, false);
if (indirect_p)
type = build_pointer_type (type);
- size = int_size_in_bytes (type);
+ bool empty_record = type && type_is_empty_record_p (type);
+ size = empty_record ? 0 : int_size_in_bytes (type);
rsize = CEIL (size, UNITS_PER_WORD);
nat_mode = type_natural_mode (type, NULL, false);
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 216a301..d97aae6 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -6802,6 +6802,8 @@ finish_struct_1 (tree t)
TYPE_TRANSPARENT_AGGR (t) = 0;
}
}
+
+ TYPE_EMPTY_RECORD (t) = is_really_empty_class (t);
}
/* Insert FIELDS into T for the sorted case if the FIELDS count is
diff --git a/gcc/dse.c b/gcc/dse.c
index 35eef71..594106f 100644
--- a/gcc/dse.c
+++ b/gcc/dse.c
@@ -2366,7 +2366,7 @@ get_call_args (rtx call_insn, tree fn, rtx *args, int nargs)
{
machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
rtx reg, link, tmp;
- reg = targetm.calls.function_arg (args_so_far, mode, NULL_TREE, true);
+ reg = function_arg (args_so_far, mode, NULL_TREE, true);
if (!reg || !REG_P (reg) || GET_MODE (reg) != mode
|| GET_MODE_CLASS (mode) != MODE_INT)
return false;
@@ -2400,7 +2400,7 @@ get_call_args (rtx call_insn, tree fn, rtx *args, int nargs)
if (tmp)
args[idx] = tmp;
- targetm.calls.function_arg_advance (args_so_far, mode, NULL_TREE, true);
+ function_arg_advance (args_so_far, mode, NULL_TREE, true);
}
if (arg != void_list_node || idx != nargs)
return false;
diff --git a/gcc/expr.c b/gcc/expr.c
index bd43dc4..384581a 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -1198,13 +1198,12 @@ block_move_libcall_safe_for_call_parm (void)
for ( ; arg != void_list_node ; arg = TREE_CHAIN (arg))
{
machine_mode mode = TYPE_MODE (TREE_VALUE (arg));
- rtx tmp = targetm.calls.function_arg (args_so_far, mode,
- NULL_TREE, true);
+ rtx tmp = function_arg (args_so_far, mode, NULL_TREE, true);
if (!tmp || !REG_P (tmp))
return false;
if (targetm.calls.arg_partial_bytes (args_so_far, mode, NULL, 1))
return false;
- targetm.calls.function_arg_advance (args_so_far, mode,
+ function_arg_advance (args_so_far, mode,
NULL_TREE, true);
}
}
diff --git a/gcc/function.c b/gcc/function.c
index afc2c87..d8924fe 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -2073,7 +2073,7 @@ aggregate_value_p (const_tree exp, const_tree fntype)
if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
return 1;
- if (targetm.calls.return_in_memory (type, fntype))
+ if (return_in_memory (type, fntype))
return 1;
/* Make sure we have suitable call-clobbered regs to return
@@ -2523,10 +2523,10 @@ assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
return;
}
- entry_parm = targetm.calls.function_incoming_arg (all->args_so_far,
- data->promoted_mode,
- data->passed_type,
- data->named_arg);
+ entry_parm = function_incoming_arg (all->args_so_far,
+ data->promoted_mode,
+ data->passed_type,
+ data->named_arg);
if (entry_parm == 0)
data->promoted_mode = data->passed_mode;
@@ -2550,9 +2550,9 @@ assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
if (targetm.calls.pretend_outgoing_varargs_named (all->args_so_far))
{
rtx tem;
- tem = targetm.calls.function_incoming_arg (all->args_so_far,
- data->promoted_mode,
- data->passed_type, true);
+ tem = function_incoming_arg (all->args_so_far,
+ data->promoted_mode,
+ data->passed_type, true);
in_regs = tem != NULL;
}
}
@@ -3752,8 +3752,8 @@ assign_parms (tree fndecl)
}
/* Update info on where next arg arrives in registers. */
- targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode,
- data.passed_type, data.named_arg);
+ function_arg_advance (all.args_so_far, data.promoted_mode,
+ data.passed_type, data.named_arg);
if (POINTER_BOUNDS_TYPE_P (data.passed_type))
bound_no++;
@@ -3949,8 +3949,8 @@ gimplify_parameters (void)
continue;
/* Update info on where next arg arrives in registers. */
- targetm.calls.function_arg_advance (all.args_so_far, data.promoted_mode,
- data.passed_type, data.named_arg);
+ function_arg_advance (all.args_so_far, data.promoted_mode,
+ data.passed_type, data.named_arg);
/* ??? Once upon a time variable_size stuffed parameter list
SAVE_EXPRs (amongst others) onto a pending sizes list. This
@@ -4093,8 +4093,11 @@ locate_and_pad_parm (machine_mode passed_mode, tree type, int in_regs,
part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
- sizetree
- = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
+ if (type)
+ sizetree = (type_is_empty_record_p (type)
+ ? size_zero_node : size_in_bytes (type));
+ else
+ sizetree = size_int (GET_MODE_SIZE (passed_mode));
where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
boundary = targetm.calls.function_arg_boundary (passed_mode, type);
round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
@@ -6821,5 +6824,52 @@ make_pass_match_asm_constraints (gcc::context *ctxt)
return new pass_match_asm_constraints (ctxt);
}
+/* Wrapper for targetm.calls.function_arg_advance. */
+
+void
+function_arg_advance (cumulative_args_t ca, machine_mode mode,
+ const_tree type, bool named)
+{
+ if (type && type_is_empty_record_p (type))
+ return;
+
+ targetm.calls.function_arg_advance (ca, mode, type, named);
+}
+
+/* Wrapper for targetm.calls.function_arg. */
+
+rtx
+function_arg (cumulative_args_t ca, machine_mode mode, const_tree type,
+ bool named)
+{
+ if (type && type_is_empty_record_p (type))
+ return NULL;
+
+ return targetm.calls.function_arg (ca, mode, type, named);
+}
+
+/* Wrapper for targetm.calls.function_incoming_arg. */
+
+rtx
+function_incoming_arg (cumulative_args_t ca, machine_mode mode,
+ const_tree type, bool named)
+{
+ if (type && type_is_empty_record_p (type))
+ return NULL;
+
+ return targetm.calls.function_incoming_arg (ca, mode, type, named);
+}
+
+/* Wrapper for targetm.calls.return_in_memory. */
+
+bool
+return_in_memory (const_tree type, const_tree fntype)
+{
+ if (type && type_is_empty_record_p (type))
+ return false;
+
+ return targetm.calls.return_in_memory (type, fntype);
+}
+
#include "gt-function.h"
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index 0d610f1..898cee9 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -940,6 +940,8 @@ hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map,
hstate.add_flag (TREE_READONLY (t));
hstate.add_flag (TREE_PUBLIC (t));
}
+ else
+ hstate.add_flag (TYPE_EMPTY_RECORD (t));
hstate.add_flag (TREE_ADDRESSABLE (t));
hstate.add_flag (TREE_THIS_VOLATILE (t));
if (DECL_P (t))
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index 2661491..df403bf 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -1002,6 +1002,8 @@ compare_tree_sccs_1 (tree t1, tree t2, tree **map)
compare_values (TREE_READONLY);
compare_values (TREE_PUBLIC);
}
+ else
+ compare_values (TYPE_EMPTY_RECORD);
compare_values (TREE_ADDRESSABLE);
compare_values (TREE_THIS_VOLATILE);
if (DECL_P (t1))
diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index cb0f1fd..bb489ff 100644
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -587,6 +587,9 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
if (TYPE_RESTRICT (node))
fputs (" restrict", file);
+ if (TYPE_EMPTY_RECORD (node))
+ fputs (" empty-record", file);
+
if (TYPE_LANG_FLAG_0 (node))
fputs (" type_0", file);
if (TYPE_LANG_FLAG_1 (node))
diff --git a/gcc/target.h b/gcc/target.h
index ffc4d6a..eb01a76 100644
--- a/gcc/target.h
+++ b/gcc/target.h
@@ -104,6 +104,14 @@ extern bool target_default_pointer_address_modes_p (void);
behaviour. */
extern unsigned int get_move_ratio (bool);
+extern void function_arg_advance (cumulative_args_t, machine_mode,
+ const_tree, bool);
+extern rtx function_arg (cumulative_args_t, machine_mode, const_tree,
+ bool);
+extern rtx function_incoming_arg (cumulative_args_t, machine_mode,
+ const_tree, bool);
+extern bool return_in_memory (const_tree, const_tree);
+
struct stdarg_info;
struct spec_info_def;
struct hard_reg_set_container;
diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index 01d3686..de10ec3 100644
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -1829,9 +1829,12 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
/* Hoist the valist value into a temporary for the moment. */
valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
+ bool empty_record = type_is_empty_record_p (type);
+
/* va_list pointer is aligned to PARM_BOUNDARY. If argument actually
requires greater alignment, we must perform dynamic alignment. */
if (boundary > align
+ && !empty_record
&& !integer_zerop (TYPE_SIZE (type)))
{
t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
@@ -1858,7 +1861,7 @@ std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
}
/* Compute the rounded size of the type. */
- type_size = size_in_bytes (type);
+ type_size = empty_record ? size_zero_node : size_in_bytes (type);
rounded_size = round_up (type_size, align);
/* Reduce rounded_size so it's sharable with the postqueue. */
diff --git a/gcc/testsuite/g++.dg/abi/empty12.C b/gcc/testsuite/g++.dg/abi/empty12.C
new file mode 100644
index 0000000..430d57d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/abi/empty12.C
@@ -0,0 +1,17 @@
+// PR c++/60336
+// { dg-do run }
+// { dg-options "-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);
+ 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/pr60336-1.C b/gcc/testsuite/g++.dg/pr60336-1.C
new file mode 100644
index 0000000..af08638
--- /dev/null
+++ b/gcc/testsuite/g++.dg/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/pr60336-2.C b/gcc/testsuite/g++.dg/pr60336-2.C
new file mode 100644
index 0000000..7b902e8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr60336-2.C
@@ -0,0 +1,28 @@
+// { dg-do run }
+// { dg-options "-O2" }
+
+#include <stdarg.h>
+
+struct dummy { struct{}__attribute__((aligned (4))) a[7]; };
+
+void
+test (struct dummy a, ...)
+{
+ va_list va_arglist;
+ int i;
+
+ va_start (va_arglist, a);
+ i = va_arg (va_arglist, int);
+ if (i != 0x10)
+ __builtin_abort ();
+ va_end (va_arglist);
+}
+
+struct dummy a0;
+
+int
+main ()
+{
+ test (a0, 0x10);
+ return 0;
+}
diff --git a/gcc/testsuite/g++.dg/pr68355.C b/gcc/testsuite/g++.dg/pr68355.C
new file mode 100644
index 0000000..1354fc4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/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-*-* } } }
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 9cc64d9..67bffa4 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -1086,6 +1086,9 @@ struct GTY(()) tree_base {
FORCED_LABEL in
LABEL_DECL
+ TYPE_EMPTY_RECORD in
+ all types
+
volatile_flag:
TREE_THIS_VOLATILE in
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index bb5cd49..1634ed6 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -394,6 +394,8 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset,
machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
if (mode == BLKmode)
size_tree = TYPE_SIZE (TREE_TYPE (exp));
+ else if (type_is_empty_record_p (TREE_TYPE (exp)))
+ bitsize = 0;
else
bitsize = int (GET_MODE_PRECISION (mode));
}
diff --git a/gcc/tree-streamer-in.c b/gcc/tree-streamer-in.c
index 65a1ce3..7b67534 100644
--- a/gcc/tree-streamer-in.c
+++ b/gcc/tree-streamer-in.c
@@ -112,7 +112,10 @@ unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
}
else
- bp_unpack_value (bp, 4);
+ {
+ TYPE_EMPTY_RECORD (expr) = (unsigned) bp_unpack_value (bp, 1);
+ bp_unpack_value (bp, 3);
+ }
TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
if (DECL_P (expr))
diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index d0b7f6d..9b14db8 100644
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -83,7 +83,10 @@ pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
bp_pack_value (bp, TREE_PUBLIC (expr), 1);
}
else
- bp_pack_value (bp, 0, 4);
+ {
+ bp_pack_value (bp, TYPE_EMPTY_RECORD (expr), 1);
+ bp_pack_value (bp, 0, 3);
+ }
bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
if (DECL_P (expr))
diff --git a/gcc/tree.h b/gcc/tree.h
index cb52deb..569f709 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -766,6 +766,10 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
computed gotos. */
#define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)
+/* Nonzero in a type considered an empty record. */
+#define TYPE_EMPTY_RECORD(NODE) \
+ (TYPE_CHECK (NODE)->base.side_effects_flag)
+
/* Nonzero means this expression is volatile in the C sense:
its address should be of type `volatile WHATEVER *'.
In other words, the declared item is volatile qualified.
@@ -5337,6 +5341,14 @@ type_with_alias_set_p (const_tree t)
return false;
}
+/* Return true if type T is an empty record. */
+
+static inline bool
+type_is_empty_record_p (const_tree t)
+{
+ return TYPE_EMPTY_RECORD (TYPE_MAIN_VARIANT (t));
+}
+
extern location_t set_block (location_t loc, tree block);
extern void gt_ggc_mx (tree &);
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index 6fc6233..6dafc90 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -379,10 +379,11 @@ ubsan_type_descriptor (tree type, enum ubsan_print_style pstyle)
if (pstyle == UBSAN_PRINT_POINTER)
{
- pp_printf (&pretty_name, "'%s%s%s%s%s%s%s",
+ pp_printf (&pretty_name, "'%s%s%s%s%s%s%s%s",
TYPE_VOLATILE (type2) ? "volatile " : "",
TYPE_READONLY (type2) ? "const " : "",
TYPE_RESTRICT (type2) ? "restrict " : "",
+ TYPE_EMPTY_RECORD (type2) ? "empty-record " : "",
TYPE_ATOMIC (type2) ? "_Atomic " : "",
TREE_CODE (type2) == RECORD_TYPE
? "struct "
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index 9185bfd..e9fdbe9 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -6140,10 +6140,10 @@ prepare_call_arguments (basic_block bb, rtx_insn *insn)
rtx reg;
INIT_CUMULATIVE_ARGS (args_so_far_v, type, NULL_RTX, fndecl,
nargs + 1);
- reg = targetm.calls.function_arg (args_so_far, mode,
- struct_addr, true);
- targetm.calls.function_arg_advance (args_so_far, mode,
- struct_addr, true);
+ reg = function_arg (args_so_far, mode, struct_addr,
+ true);
+ function_arg_advance (args_so_far, mode, struct_addr,
+ true);
if (reg == NULL_RTX)
{
for (; link; link = XEXP (link, 1))
@@ -6164,8 +6164,8 @@ prepare_call_arguments (basic_block bb, rtx_insn *insn)
machine_mode mode;
t = TYPE_ARG_TYPES (type);
mode = TYPE_MODE (TREE_VALUE (t));
- this_arg = targetm.calls.function_arg (args_so_far, mode,
- TREE_VALUE (t), true);
+ this_arg = function_arg (args_so_far, mode,
+ TREE_VALUE (t), true);
if (this_arg && !REG_P (this_arg))
this_arg = NULL_RTX;
else if (this_arg == NULL_RTX)
@@ -6280,8 +6280,7 @@ prepare_call_arguments (basic_block bb, rtx_insn *insn)
argtype = build_pointer_type (argtype);
mode = TYPE_MODE (argtype);
}
- reg = targetm.calls.function_arg (args_so_far, mode,
- argtype, true);
+ reg = function_arg (args_so_far, mode, argtype, true);
if (TREE_CODE (argtype) == REFERENCE_TYPE
&& INTEGRAL_TYPE_P (TREE_TYPE (argtype))
&& reg
@@ -6335,8 +6334,7 @@ prepare_call_arguments (basic_block bb, rtx_insn *insn)
}
}
}
- targetm.calls.function_arg_advance (args_so_far, mode,
- argtype, true);
+ function_arg_advance (args_so_far, mode, argtype, true);
t = TREE_CHAIN (t);
}
}
--
2.4.3
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-23 20:54 ` H.J. Lu
@ 2015-11-24 3:48 ` Patrick Palka
2015-11-24 6:00 ` H.J. Lu
0 siblings, 1 reply; 14+ messages in thread
From: Patrick Palka @ 2015-11-24 3:48 UTC (permalink / raw)
To: H.J. Lu; +Cc: Richard Biener, Jason Merrill, GCC Patches
[-- Attachment #1: Type: text/plain, Size: 3731 bytes --]
On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
> <richard.guenther@gmail.com> wrote:
>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>
>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>
>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>
>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>> function value return. Other targets may need similar changes.
>>>>>>
>>>>>>
>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>> tree_type_common
>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>> non-pointers).
>>>>>
>>>>>
>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>> checked for non-pointers to issue an error when it is used on
>>>>> non-pointers:
>>>>>
>>>>>
>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>> qualifiers cannot" "" }
>>>>
>>>>
>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>> pointers.
>>>>
>>>
>>> restrict_flag is also checked in this case:
>>>
>>> [hjl@gnu-6 gcc]$ cat x.i
>>> struct dummy { };
>>>
>>> struct dummy
>>> foo (struct dummy __restrict__ i)
>>> {
>>> return i;
>>> }
>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>> x.i:4:13: error: invalid use of ‘restrict’
>>> foo (struct dummy __restrict__ i)
>>> ^
>>> x.i:4:13: error: invalid use of ‘restrict’
>>> [hjl@gnu-6 gcc]$
>>>
>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>
>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>
>> But well, use any other free bit (but do not enlarge
>> tree_type_common). Eventually
>> you can free up a bit by putting sth into type_lang_specific currently
>> using bits
>> in tree_type_common.
>
> There are no bits in tree_type_common I can move. Instead,
> this patch overloads side_effects_flag in tree_base. Tested on
> Linux/x86-64. OK for trunk?
>
Hi,
Coincidentally a few months ago I was experimenting with making
empty-struct function arguments zero-cost (and thus making them behave
the same way as in GNU C). My approach (patch attached) was to assign
empty-struct arguments to a virtual register (instead of on the stack
or to a hard register) during RTL call expansion. These
virtual-register assignments would then be trivially DCE'd later.
This approach seemed to work surprisingly well with minimal code
changes. I wonder what
your thoughts are on this approach..
[-- Attachment #2: 0001-zero-cost-structs.patch --]
[-- Type: text/x-patch, Size: 3155 bytes --]
From 8eb52639992ad0f6e5482783604f362bcc04d230 Mon Sep 17 00:00:00 2001
From: Patrick Palka <patrick@parcs.ath.cx>
Date: Mon, 23 Nov 2015 21:02:09 -0500
Subject: [PATCH] zero-cost structs
---
gcc/calls.c | 15 +++++++++++++++
gcc/tree-tailcall.c | 7 ++++++-
gcc/tree.c | 17 +++++++++++++++++
3 files changed, 38 insertions(+), 1 deletion(-)
diff --git a/gcc/calls.c b/gcc/calls.c
index b56556a..4ca668c 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -1394,6 +1394,21 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
argpos < n_named_args);
+ bool empty_record_or_union_type_p (const_tree);
+
+ if (type != NULL_TREE
+#if 0
+ /* ??? This condition was necessary to fix a C regression whose
+ details I have forgot about. In GNU C the mode of an empty struct is BLKmode
+ (and TYPE_SIZE 0) so this condition makes it so that we don't mess
+ with the codegen of empty structs in C. In C++ the mode of the empty struct
+ is QImode and TYPE_SIZE_UNIT 1. Maybe it's not necessary anymore? */
+ && mode != BLKmode
+#endif
+ && args[i].reg == NULL_RTX
+ && empty_record_or_union_type_p (type))
+ args[i].reg = gen_reg_rtx (mode);
+
if (args[i].reg && CONST_INT_P (args[i].reg))
{
args[i].special_slot = args[i].reg;
diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index bbd1b29..fa8f66a 100644
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -497,6 +497,8 @@ find_tail_calls (basic_block bb, struct tailcall **ret)
tail_recursion = true;
}
+ bool empty_record_or_union_type_p (const_tree);
+
/* Make sure the tail invocation of this function does not refer
to local variables. */
FOR_EACH_LOCAL_DECL (cfun, idx, var)
@@ -504,7 +506,10 @@ find_tail_calls (basic_block bb, struct tailcall **ret)
if (TREE_CODE (var) != PARM_DECL
&& auto_var_in_fn_p (var, cfun->decl)
&& (ref_maybe_used_by_stmt_p (call, var)
- || call_may_clobber_ref_p (call, var)))
+ || call_may_clobber_ref_p (call, var))
+ /* This change does the same thing as your aliasing change, to allow
+ tail calling of functions taking by argument empty structs. */
+ && !empty_record_or_union_type_p (TREE_TYPE (var)))
return;
}
diff --git a/gcc/tree.c b/gcc/tree.c
index 779fe93..f710d15 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -9069,6 +9069,23 @@ auto_var_in_fn_p (const_tree var, const_tree fn)
|| TREE_CODE (var) == RESULT_DECL));
}
+/* Return true if if type TYPE is an empty record or union type. */
+
+/* This predicate is inferior to your TYPE_EMPTY_RECORD-flag approach. */
+
+bool
+empty_record_or_union_type_p (const_tree type)
+{
+ if (!RECORD_OR_UNION_TYPE_P (type))
+ return false;
+
+ for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
+ if (TREE_CODE (field) == FIELD_DECL)
+ return false;
+
+ return true;
+}
+
/* Subprogram of following function. Called by walk_tree.
Return *TP if it is an automatic variable or parameter of the
--
2.6.3.424.g74c917e.dirty
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-24 3:48 ` Patrick Palka
@ 2015-11-24 6:00 ` H.J. Lu
2015-11-24 6:10 ` Andrew Pinski
2015-11-24 16:31 ` Patrick Palka
0 siblings, 2 replies; 14+ messages in thread
From: H.J. Lu @ 2015-11-24 6:00 UTC (permalink / raw)
To: Patrick Palka; +Cc: Richard Biener, Jason Merrill, GCC Patches
On Mon, Nov 23, 2015 at 7:22 PM, Patrick Palka <patrick@parcs.ath.cx> wrote:
> On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
>> <richard.guenther@gmail.com> wrote:
>>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>>
>>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>>
>>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>>
>>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>>> function value return. Other targets may need similar changes.
>>>>>>>
>>>>>>>
>>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>>> tree_type_common
>>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>>> non-pointers).
>>>>>>
>>>>>>
>>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>>> checked for non-pointers to issue an error when it is used on
>>>>>> non-pointers:
>>>>>>
>>>>>>
>>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>>> qualifiers cannot" "" }
>>>>>
>>>>>
>>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>>> pointers.
>>>>>
>>>>
>>>> restrict_flag is also checked in this case:
>>>>
>>>> [hjl@gnu-6 gcc]$ cat x.i
>>>> struct dummy { };
>>>>
>>>> struct dummy
>>>> foo (struct dummy __restrict__ i)
>>>> {
>>>> return i;
>>>> }
>>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>> foo (struct dummy __restrict__ i)
>>>> ^
>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>> [hjl@gnu-6 gcc]$
>>>>
>>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>>
>>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>>
>>> But well, use any other free bit (but do not enlarge
>>> tree_type_common). Eventually
>>> you can free up a bit by putting sth into type_lang_specific currently
>>> using bits
>>> in tree_type_common.
>>
>> There are no bits in tree_type_common I can move. Instead,
>> this patch overloads side_effects_flag in tree_base. Tested on
>> Linux/x86-64. OK for trunk?
>>
>
> Hi,
>
> Coincidentally a few months ago I was experimenting with making
> empty-struct function arguments zero-cost (and thus making them behave
> the same way as in GNU C). My approach (patch attached) was to assign
> empty-struct arguments to a virtual register (instead of on the stack
> or to a hard register) during RTL call expansion. These
> virtual-register assignments would then be trivially DCE'd later.
> This approach seemed to work surprisingly well with minimal code
> changes. I wonder what
> your thoughts are on this approach..
I don't think it works for C++ class. empty_record_or_union_type_p
missed:
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
return false;
Does it work with variable argument list? Did you run GCC
testsuite for both i686 and x86-64?
--
H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-24 6:00 ` H.J. Lu
@ 2015-11-24 6:10 ` Andrew Pinski
2015-11-24 12:52 ` H.J. Lu
2015-11-24 16:31 ` Patrick Palka
1 sibling, 1 reply; 14+ messages in thread
From: Andrew Pinski @ 2015-11-24 6:10 UTC (permalink / raw)
To: H.J. Lu; +Cc: Patrick Palka, Richard Biener, Jason Merrill, GCC Patches
On Mon, Nov 23, 2015 at 9:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
> On Mon, Nov 23, 2015 at 7:22 PM, Patrick Palka <patrick@parcs.ath.cx> wrote:
>> On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
>>> <richard.guenther@gmail.com> wrote:
>>>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>>>
>>>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>>>
>>>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>>>> function value return. Other targets may need similar changes.
>>>>>>>>
>>>>>>>>
>>>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>>>> tree_type_common
>>>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>>>> non-pointers).
>>>>>>>
>>>>>>>
>>>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>>>> checked for non-pointers to issue an error when it is used on
>>>>>>> non-pointers:
>>>>>>>
>>>>>>>
>>>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>>>> qualifiers cannot" "" }
>>>>>>
>>>>>>
>>>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>>>> pointers.
>>>>>>
>>>>>
>>>>> restrict_flag is also checked in this case:
>>>>>
>>>>> [hjl@gnu-6 gcc]$ cat x.i
>>>>> struct dummy { };
>>>>>
>>>>> struct dummy
>>>>> foo (struct dummy __restrict__ i)
>>>>> {
>>>>> return i;
>>>>> }
>>>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>> foo (struct dummy __restrict__ i)
>>>>> ^
>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>> [hjl@gnu-6 gcc]$
>>>>>
>>>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>>>
>>>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>>>
>>>> But well, use any other free bit (but do not enlarge
>>>> tree_type_common). Eventually
>>>> you can free up a bit by putting sth into type_lang_specific currently
>>>> using bits
>>>> in tree_type_common.
>>>
>>> There are no bits in tree_type_common I can move. Instead,
>>> this patch overloads side_effects_flag in tree_base. Tested on
>>> Linux/x86-64. OK for trunk?
>>>
>>
>> Hi,
>>
>> Coincidentally a few months ago I was experimenting with making
>> empty-struct function arguments zero-cost (and thus making them behave
>> the same way as in GNU C). My approach (patch attached) was to assign
>> empty-struct arguments to a virtual register (instead of on the stack
>> or to a hard register) during RTL call expansion. These
>> virtual-register assignments would then be trivially DCE'd later.
>> This approach seemed to work surprisingly well with minimal code
>> changes. I wonder what
>> your thoughts are on this approach..
>
> I don't think it works for C++ class. empty_record_or_union_type_p
> missed:
>
> for (binfo = TYPE_BINFO (type), i = 0;
> BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
> if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
> return false;
This above should not be needed as TYPE_FIELDS should include one
already. Or do you have prove it does not?
Thanks,
Andrew
>
> Does it work with variable argument list? Did you run GCC
> testsuite for both i686 and x86-64?
>
>
> --
> H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-24 6:10 ` Andrew Pinski
@ 2015-11-24 12:52 ` H.J. Lu
0 siblings, 0 replies; 14+ messages in thread
From: H.J. Lu @ 2015-11-24 12:52 UTC (permalink / raw)
To: Andrew Pinski; +Cc: Patrick Palka, Richard Biener, Jason Merrill, GCC Patches
On Mon, Nov 23, 2015 at 10:00 PM, Andrew Pinski <pinskia@gmail.com> wrote:
> On Mon, Nov 23, 2015 at 9:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>> On Mon, Nov 23, 2015 at 7:22 PM, Patrick Palka <patrick@parcs.ath.cx> wrote:
>>> On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
>>>> <richard.guenther@gmail.com> wrote:
>>>>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>>>>
>>>>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>>>>
>>>>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>>>>> function value return. Other targets may need similar changes.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>>>>> tree_type_common
>>>>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>>>>> non-pointers).
>>>>>>>>
>>>>>>>>
>>>>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>>>>> checked for non-pointers to issue an error when it is used on
>>>>>>>> non-pointers:
>>>>>>>>
>>>>>>>>
>>>>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>>>>> qualifiers cannot" "" }
>>>>>>>
>>>>>>>
>>>>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>>>>> pointers.
>>>>>>>
>>>>>>
>>>>>> restrict_flag is also checked in this case:
>>>>>>
>>>>>> [hjl@gnu-6 gcc]$ cat x.i
>>>>>> struct dummy { };
>>>>>>
>>>>>> struct dummy
>>>>>> foo (struct dummy __restrict__ i)
>>>>>> {
>>>>>> return i;
>>>>>> }
>>>>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>>> foo (struct dummy __restrict__ i)
>>>>>> ^
>>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>>> [hjl@gnu-6 gcc]$
>>>>>>
>>>>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>>>>
>>>>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>>>>
>>>>> But well, use any other free bit (but do not enlarge
>>>>> tree_type_common). Eventually
>>>>> you can free up a bit by putting sth into type_lang_specific currently
>>>>> using bits
>>>>> in tree_type_common.
>>>>
>>>> There are no bits in tree_type_common I can move. Instead,
>>>> this patch overloads side_effects_flag in tree_base. Tested on
>>>> Linux/x86-64. OK for trunk?
>>>>
>>>
>>> Hi,
>>>
>>> Coincidentally a few months ago I was experimenting with making
>>> empty-struct function arguments zero-cost (and thus making them behave
>>> the same way as in GNU C). My approach (patch attached) was to assign
>>> empty-struct arguments to a virtual register (instead of on the stack
>>> or to a hard register) during RTL call expansion. These
>>> virtual-register assignments would then be trivially DCE'd later.
>>> This approach seemed to work surprisingly well with minimal code
>>> changes. I wonder what
>>> your thoughts are on this approach..
>>
>> I don't think it works for C++ class. empty_record_or_union_type_p
>> missed:
>>
>> for (binfo = TYPE_BINFO (type), i = 0;
>> BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
>> if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
>> return false;
>
> This above should not be needed as TYPE_FIELDS should include one
> already. Or do you have prove it does not?
You can remove the above from
---
/* Returns true if TYPE contains no actual data, just various
possible combinations of empty classes and possibly a vptr. */
bool
is_really_empty_class (tree type)
{
if (CLASS_TYPE_P (type))
{
tree field;
tree binfo;
tree base_binfo;
int i;
/* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
out, but we'd like to be able to check this before then. */
if (COMPLETE_TYPE_P (type) && is_empty_class (type))
return true;
for (binfo = TYPE_BINFO (type), i = 0;
BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
return false;
for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
if (TREE_CODE (field) == FIELD_DECL
&& !DECL_ARTIFICIAL (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 false;
}
---
and see what happens.
--
H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-24 6:00 ` H.J. Lu
2015-11-24 6:10 ` Andrew Pinski
@ 2015-11-24 16:31 ` Patrick Palka
2015-11-24 16:59 ` H.J. Lu
1 sibling, 1 reply; 14+ messages in thread
From: Patrick Palka @ 2015-11-24 16:31 UTC (permalink / raw)
To: H.J. Lu; +Cc: Richard Biener, Jason Merrill, GCC Patches
On Tue, Nov 24, 2015 at 12:53 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
> On Mon, Nov 23, 2015 at 7:22 PM, Patrick Palka <patrick@parcs.ath.cx> wrote:
>> On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
>>> <richard.guenther@gmail.com> wrote:
>>>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>>>
>>>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>>>
>>>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>>>> function value return. Other targets may need similar changes.
>>>>>>>>
>>>>>>>>
>>>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>>>> tree_type_common
>>>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>>>> non-pointers).
>>>>>>>
>>>>>>>
>>>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>>>> checked for non-pointers to issue an error when it is used on
>>>>>>> non-pointers:
>>>>>>>
>>>>>>>
>>>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>>>> qualifiers cannot" "" }
>>>>>>
>>>>>>
>>>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>>>> pointers.
>>>>>>
>>>>>
>>>>> restrict_flag is also checked in this case:
>>>>>
>>>>> [hjl@gnu-6 gcc]$ cat x.i
>>>>> struct dummy { };
>>>>>
>>>>> struct dummy
>>>>> foo (struct dummy __restrict__ i)
>>>>> {
>>>>> return i;
>>>>> }
>>>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>> foo (struct dummy __restrict__ i)
>>>>> ^
>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>> [hjl@gnu-6 gcc]$
>>>>>
>>>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>>>
>>>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>>>
>>>> But well, use any other free bit (but do not enlarge
>>>> tree_type_common). Eventually
>>>> you can free up a bit by putting sth into type_lang_specific currently
>>>> using bits
>>>> in tree_type_common.
>>>
>>> There are no bits in tree_type_common I can move. Instead,
>>> this patch overloads side_effects_flag in tree_base. Tested on
>>> Linux/x86-64. OK for trunk?
>>>
>>
>> Hi,
>>
>> Coincidentally a few months ago I was experimenting with making
>> empty-struct function arguments zero-cost (and thus making them behave
>> the same way as in GNU C). My approach (patch attached) was to assign
>> empty-struct arguments to a virtual register (instead of on the stack
>> or to a hard register) during RTL call expansion. These
>> virtual-register assignments would then be trivially DCE'd later.
>> This approach seemed to work surprisingly well with minimal code
>> changes. I wonder what
>> your thoughts are on this approach..
>
> I don't think it works for C++ class. empty_record_or_union_type_p
> missed:
>
> for (binfo = TYPE_BINFO (type), i = 0;
> BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
> if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
> return false;
Yeah, your TYPE_EMPTY_RECORD flag covers more instances of empty
structs than this predicate does.
>
> Does it work with variable argument list? Did you run GCC
> testsuite for both i686 and x86-64?
Hmm, I don't think it works with variable argument lists, at least not
perfectly. And I just finished running the testsuite on x86-64 and
observed a failure in struct-layout-1.exp which makes no sense to me.
Now I remember why I didn't pursue this change any further.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class
2015-11-24 16:31 ` Patrick Palka
@ 2015-11-24 16:59 ` H.J. Lu
0 siblings, 0 replies; 14+ messages in thread
From: H.J. Lu @ 2015-11-24 16:59 UTC (permalink / raw)
To: Patrick Palka; +Cc: Richard Biener, Jason Merrill, GCC Patches
On Tue, Nov 24, 2015 at 8:28 AM, Patrick Palka <patrick@parcs.ath.cx> wrote:
> On Tue, Nov 24, 2015 at 12:53 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>> On Mon, Nov 23, 2015 at 7:22 PM, Patrick Palka <patrick@parcs.ath.cx> wrote:
>>> On Mon, Nov 23, 2015 at 3:53 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>> On Mon, Nov 23, 2015 at 1:57 AM, Richard Biener
>>>> <richard.guenther@gmail.com> wrote:
>>>>> On Sat, Nov 21, 2015 at 12:46 AM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>> On Fri, Nov 20, 2015 at 2:17 PM, Jason Merrill <jason@redhat.com> wrote:
>>>>>>> On 11/20/2015 01:52 PM, H.J. Lu wrote:
>>>>>>>>
>>>>>>>> On Tue, Nov 17, 2015 at 4:22 AM, Richard Biener
>>>>>>>> <richard.guenther@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>> On Tue, Nov 17, 2015 at 12:01 PM, H.J. Lu <hjl.tools@gmail.com> wrote:
>>>>>>>>>>
>>>>>>>>>> Empty record should be returned and passed the same way in C and C++.
>>>>>>>>>> This patch adds LANG_HOOKS_EMPTY_RECORD_P for C++ empty class, which
>>>>>>>>>> defaults to return false. For C++, LANG_HOOKS_EMPTY_RECORD_P is defined
>>>>>>>>>> to is_really_empty_class, which returns true for C++ empty classes. For
>>>>>>>>>> LTO, we stream out a bit to indicate if a record is empty and we store
>>>>>>>>>> it in TYPE_LANG_FLAG_0 when streaming in. get_ref_base_and_extent is
>>>>>>>>>> changed to set bitsize to 0 for empty records. Middle-end and x86
>>>>>>>>>> backend are updated to ignore empty records for parameter passing and
>>>>>>>>>> function value return. Other targets may need similar changes.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Please avoid a new langhook for this and instead claim a bit in
>>>>>>>>> tree_type_common
>>>>>>>>> like for example restrict_flag (double-check it is unused for
>>>>>>>>> non-pointers).
>>>>>>>>
>>>>>>>>
>>>>>>>> There is no bit in tree_type_common I can overload. restrict_flag is
>>>>>>>> checked for non-pointers to issue an error when it is used on
>>>>>>>> non-pointers:
>>>>>>>>
>>>>>>>>
>>>>>>>> /export/gnu/import/git/sources/gcc/gcc/testsuite/g++.dg/template/qualttp20.C:19:38:
>>>>>>>> error: ‘__restrict__’ qualifiers cannot be applied to ‘AS::L’
>>>>>>>> typedef typename T::L __restrict__ r;// { dg-error "'__restrict__'
>>>>>>>> qualifiers cannot" "" }
>>>>>>>
>>>>>>>
>>>>>>> The C++ front end only needs to check TYPE_RESTRICT for this purpose on
>>>>>>> front-end-specific type codes like TEMPLATE_TYPE_PARM; cp_type_quals could
>>>>>>> handle that specifically if you change TYPE_RESTRICT to only apply to
>>>>>>> pointers.
>>>>>>>
>>>>>>
>>>>>> restrict_flag is also checked in this case:
>>>>>>
>>>>>> [hjl@gnu-6 gcc]$ cat x.i
>>>>>> struct dummy { };
>>>>>>
>>>>>> struct dummy
>>>>>> foo (struct dummy __restrict__ i)
>>>>>> {
>>>>>> return i;
>>>>>> }
>>>>>> [hjl@gnu-6 gcc]$ gcc -S x.i -Wall
>>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>>> foo (struct dummy __restrict__ i)
>>>>>> ^
>>>>>> x.i:4:13: error: invalid use of ‘restrict’
>>>>>> [hjl@gnu-6 gcc]$
>>>>>>
>>>>>> restrict_flag can't also be used to indicate `i' is an empty record.
>>>>>
>>>>> I'm sure this error can be done during parsing w/o relying on TYPE_RESTRICT.
>>>>>
>>>>> But well, use any other free bit (but do not enlarge
>>>>> tree_type_common). Eventually
>>>>> you can free up a bit by putting sth into type_lang_specific currently
>>>>> using bits
>>>>> in tree_type_common.
>>>>
>>>> There are no bits in tree_type_common I can move. Instead,
>>>> this patch overloads side_effects_flag in tree_base. Tested on
>>>> Linux/x86-64. OK for trunk?
>>>>
>>>
>>> Hi,
>>>
>>> Coincidentally a few months ago I was experimenting with making
>>> empty-struct function arguments zero-cost (and thus making them behave
>>> the same way as in GNU C). My approach (patch attached) was to assign
>>> empty-struct arguments to a virtual register (instead of on the stack
>>> or to a hard register) during RTL call expansion. These
>>> virtual-register assignments would then be trivially DCE'd later.
>>> This approach seemed to work surprisingly well with minimal code
>>> changes. I wonder what
>>> your thoughts are on this approach..
>>
>> I don't think it works for C++ class. empty_record_or_union_type_p
>> missed:
>>
>> for (binfo = TYPE_BINFO (type), i = 0;
>> BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
>> if (!is_really_empty_class (BINFO_TYPE (base_binfo)))
>> return false;
>
> Yeah, your TYPE_EMPTY_RECORD flag covers more instances of empty
> structs than this predicate does.
>
>>
>> Does it work with variable argument list? Did you run GCC
>> testsuite for both i686 and x86-64?
>
> Hmm, I don't think it works with variable argument lists, at least not
> perfectly. And I just finished running the testsuite on x86-64 and
> observed a failure in struct-layout-1.exp which makes no sense to me.
> Now I remember why I didn't pursue this change any further.
I tried a similar approach and got quite a few C++ failures in
gcc testsuite. There were more failures on i686 than x86-64.
See
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60336
for more details. My current patch passes all tests on i686 and
x86-64.
--
H.J.
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2015-11-24 16:35 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-11-17 11:01 [PATCH] Add LANG_HOOKS_EMPTY_RECORD_P for C++ empty class H.J. Lu
2015-11-17 12:22 ` Richard Biener
2015-11-20 18:52 ` H.J. Lu
2015-11-20 22:17 ` Jason Merrill
2015-11-20 22:24 ` Jason Merrill
2015-11-20 23:47 ` H.J. Lu
2015-11-23 9:59 ` Richard Biener
2015-11-23 20:54 ` H.J. Lu
2015-11-24 3:48 ` Patrick Palka
2015-11-24 6:00 ` H.J. Lu
2015-11-24 6:10 ` Andrew Pinski
2015-11-24 12:52 ` H.J. Lu
2015-11-24 16:31 ` Patrick Palka
2015-11-24 16:59 ` H.J. Lu
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).