On 9/24/21 13:53, Richard Sandiford wrote:
This patch adds a lang hook for defining a struct/RECORD_TYPE
“as if” it had appeared directly in the source code. It follows
the similar existing hook for enums.
It's the caller's responsibility to create the fields
(as FIELD_DECLs) but the hook's responsibility to create
and declare the associated RECORD_TYPE.
For now the hook is hard-coded to do the equivalent of:
typedef struct NAME { FIELDS } NAME;
but this could be controlled by an extra parameter if some callers
want a different behaviour in future.
The motivating use case is to allow the long list of struct
definitions in arm_neon.h to be provided by the compiler,
which in turn unblocks various arm_neon.h optimisations.
Tested on aarch64-linux-gnu, individually and with a follow-on
patch from Jonathan that makes use of the hook. OK to install?
Richard
gcc/
* langhooks.h (lang_hooks_for_types::simulate_record_decl): New hook.
* langhooks-def.h (lhd_simulate_record_decl): Declare.
(LANG_HOOKS_SIMULATE_RECORD_DECL): Define.
(LANG_HOOKS_FOR_TYPES_INITIALIZER): Include it.
* langhooks.c (lhd_simulate_record_decl): New function.
gcc/c/
* c-tree.h (c_simulate_record_decl): Declare.
* c-objc-common.h (LANG_HOOKS_SIMULATE_RECORD_DECL): Override.
* c-decl.c (c_simulate_record_decl): New function.
gcc/cp/
* decl.c: Include langhooks-def.h.
(cxx_simulate_record_decl): New function.
* cp-objcp-common.h (cxx_simulate_record_decl): Declare.
(LANG_HOOKS_SIMULATE_RECORD_DECL): Override.
---
gcc/c/c-decl.c | 31 +++++++++++++++++++++++++++++++
gcc/c/c-objc-common.h | 2 ++
gcc/c/c-tree.h | 2 ++
gcc/cp/cp-objcp-common.h | 4 ++++
gcc/cp/decl.c | 38 ++++++++++++++++++++++++++++++++++++++
gcc/langhooks-def.h | 4 ++++
gcc/langhooks.c | 21 +++++++++++++++++++++
gcc/langhooks.h | 10 ++++++++++
8 files changed, 112 insertions(+)
diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
index 771efa3eadf..8d1324b118c 100644
--- a/gcc/c/c-decl.c
+++ b/gcc/c/c-decl.c
@@ -9436,6 +9436,37 @@ c_simulate_enum_decl (location_t loc, const char *name,
input_location = saved_loc;
return enumtype;
}
+
+/* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
+
+tree
+c_simulate_record_decl (location_t loc, const char *name,
+ array_slice<const tree> fields)
+{
+ location_t saved_loc = input_location;
+ input_location = loc;
+
+ class c_struct_parse_info *struct_info;
+ tree ident = get_identifier (name);
+ tree type = start_struct (loc, RECORD_TYPE, ident, &struct_info);
+
+ for (unsigned int i = 0; i < fields.size (); ++i)
+ {
+ DECL_FIELD_CONTEXT (fields[i]) = type;
+ if (i > 0)
+ DECL_CHAIN (fields[i - 1]) = fields[i];
+ }
+
+ finish_struct (loc, type, fields[0], NULL_TREE, struct_info);
+
+ tree decl = build_decl (loc, TYPE_DECL, ident, type);
+ TYPE_NAME (type) = decl;
+ TYPE_STUB_DECL (type) = decl;
+ lang_hooks.decls.pushdecl (decl);
+
+ input_location = saved_loc;
+ return type;
+}
/* Create the FUNCTION_DECL for a function definition.
DECLSPECS, DECLARATOR and ATTRIBUTES are the parts of
diff --git a/gcc/c/c-objc-common.h b/gcc/c/c-objc-common.h
index 7d35a0621e4..f4e8271f06c 100644
--- a/gcc/c/c-objc-common.h
+++ b/gcc/c/c-objc-common.h
@@ -81,6 +81,8 @@ along with GCC; see the file COPYING3. If not see
#undef LANG_HOOKS_SIMULATE_ENUM_DECL
#define LANG_HOOKS_SIMULATE_ENUM_DECL c_simulate_enum_decl
+#undef LANG_HOOKS_SIMULATE_RECORD_DECL
+#define LANG_HOOKS_SIMULATE_RECORD_DECL c_simulate_record_decl
#undef LANG_HOOKS_TYPE_FOR_MODE
#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode
#undef LANG_HOOKS_TYPE_FOR_SIZE
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index d50d0cb7f2d..8578d2d1e77 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -598,6 +598,8 @@ extern tree finish_struct (location_t, tree, tree, tree,
class c_struct_parse_info *);
extern tree c_simulate_enum_decl (location_t, const char *,
vec<string_int_pair> *);
+extern tree c_simulate_record_decl (location_t, const char *,
+ array_slice<const tree>);
extern struct c_arg_info *build_arg_info (void);
extern struct c_arg_info *get_parm_info (bool, tree);
extern tree grokfield (location_t, struct c_declarator *,
diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h
index f1704aad557..d5859406e8f 100644
--- a/gcc/cp/cp-objcp-common.h
+++ b/gcc/cp/cp-objcp-common.h
@@ -39,6 +39,8 @@ extern bool cp_handle_option (size_t, const char *,
HOST_WIDE_INT, int,
extern tree cxx_make_type_hook (tree_code);
extern tree cxx_simulate_enum_decl (location_t, const char *,
vec<string_int_pair> *);
+extern tree cxx_simulate_record_decl (location_t, const char *,
+ array_slice<const tree>);
/* Lang hooks that are shared between C++ and ObjC++ are defined here. Hooks
specific to C++ or ObjC++ go in cp/cp-lang.c and objcp/objcp-lang.c,
@@ -139,6 +141,8 @@ extern tree cxx_simulate_enum_decl (location_t, const char
*,
#define LANG_HOOKS_MAKE_TYPE cxx_make_type_hook
#undef LANG_HOOKS_SIMULATE_ENUM_DECL
#define LANG_HOOKS_SIMULATE_ENUM_DECL cxx_simulate_enum_decl
+#undef LANG_HOOKS_SIMULATE_RECORD_DECL
+#define LANG_HOOKS_SIMULATE_RECORD_DECL cxx_simulate_record_decl
#undef LANG_HOOKS_TYPE_FOR_MODE
#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode
#undef LANG_HOOKS_TYPE_FOR_SIZE
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 58ddc6a537e..38f065c1c36 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -56,6 +56,7 @@ along with GCC; see the file COPYING3. If not see
#include "context.h" /* For 'g'. */
#include "omp-general.h"
#include "omp-offload.h" /* For offload_vars. */
+#include "langhooks-def.h" /* For lhd_simulate_record_decl */
/* Possible cases of bad specifiers type used by bad_specifiers. */
enum bad_spec_place {
@@ -16597,6 +16598,43 @@ cxx_simulate_enum_decl (location_t loc, const char
*name,
input_location = saved_loc;
return enumtype;
}
+
+/* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
+
+tree
+cxx_simulate_record_decl (location_t loc, const char *name,
+ array_slice<const tree> fields)
+{
+ iloc_sentinel ils (loc);
+
+ tree ident = get_identifier (name);
+ tree type = xref_tag (/*tag_code=*/record_type, ident);
+ if (type != error_mark_node
+ && (TREE_CODE (type) != RECORD_TYPE || COMPLETE_TYPE_P (type)))
+ {
+ error ("redefinition of %q#T", type);
+ type = error_mark_node;
+ }
+ if (type == error_mark_node)
+ return lhd_simulate_record_decl (loc, name, fields);
Why fall back to the language-independent function on error? Is there a
case where that gives better error recovery than just returning
error_mark_node?
+ xref_basetypes (type, NULL_TREE);
+ type = begin_class_definition (type);
+ if (type == error_mark_node)
+ return lhd_simulate_record_decl (loc, name, fields);
+
+ for (tree field : fields)
+ finish_member_declaration (field);
+
+ type = finish_struct (type, NULL_TREE);
+
+ tree decl = build_decl (loc, TYPE_DECL, ident, type);
+ TYPE_NAME (type) = decl;
+ TYPE_STUB_DECL (type) = decl;
Setting TYPE_NAME and TYPE_STUB_DECL to the typedef is wrong; it should
work to just remove these two lines. I expect they're also wrong for C.
For C++ only, I wonder if you need this typedef at all.
If you do want it, you need to use set_underlying_type to create a real
typedef. I expect that's also true for C.
+ lang_hooks.decls.pushdecl (decl);
+
+ return type;
+}
/* We're defining DECL. Make sure that its type is OK. */
diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h
index 02b4681dd96..5f17620aaeb 100644
--- a/gcc/langhooks-def.h
+++ b/gcc/langhooks-def.h
@@ -56,6 +56,8 @@ extern void lhd_overwrite_decl_assembler_name (tree decl,
tree name);
extern bool lhd_warn_unused_global_decl (const_tree);
extern tree lhd_simulate_enum_decl (location_t, const char *,
vec<string_int_pair> *);
+extern tree lhd_simulate_record_decl (location_t, const char *,
+ array_slice<const tree>);
extern tree lhd_type_for_size (unsigned precision, int unsignedp);
extern void lhd_incomplete_type_error (location_t, const_tree, const_tree);
extern tree lhd_type_promotes_to (tree);
@@ -183,6 +185,7 @@ extern tree lhd_unit_size_without_reusable_padding (tree);
#define LANG_HOOKS_MAKE_TYPE lhd_make_node
#define LANG_HOOKS_SIMULATE_ENUM_DECL lhd_simulate_enum_decl
+#define LANG_HOOKS_SIMULATE_RECORD_DECL lhd_simulate_record_decl
#define LANG_HOOKS_CLASSIFY_RECORD NULL
#define LANG_HOOKS_TYPE_FOR_SIZE lhd_type_for_size
#define LANG_HOOKS_INCOMPLETE_TYPE_ERROR lhd_incomplete_type_error
@@ -217,6 +220,7 @@ extern tree lhd_unit_size_without_reusable_padding (tree);
#define LANG_HOOKS_FOR_TYPES_INITIALIZER { \
LANG_HOOKS_MAKE_TYPE, \
LANG_HOOKS_SIMULATE_ENUM_DECL, \
+ LANG_HOOKS_SIMULATE_RECORD_DECL, \
LANG_HOOKS_CLASSIFY_RECORD, \
LANG_HOOKS_TYPE_FOR_MODE, \
LANG_HOOKS_TYPE_FOR_SIZE, \
diff --git a/gcc/langhooks.c b/gcc/langhooks.c
index 48c72377778..b54da177137 100644
--- a/gcc/langhooks.c
+++ b/gcc/langhooks.c
@@ -516,6 +516,27 @@ lhd_simulate_enum_decl (location_t loc, const char *name,
return enumtype;
}
+/* Default implementation of LANG_HOOKS_SIMULATE_RECORD_DECL.
+ Just create a normal RECORD_TYPE and a TYPE_DECL for it. */
+tree
+lhd_simulate_record_decl (location_t loc, const char *name,
+ array_slice<const tree> fields)
+{
+ for (unsigned int i = 1; i < fields.size (); ++i)
+ /* Reversed by finish_builtin_struct. */
+ DECL_CHAIN (fields[i]) = fields[i - 1];
+
+ tree type = lang_hooks.types.make_type (RECORD_TYPE);
+ finish_builtin_struct (type, name, fields.back (), NULL_TREE);
+
+ tree decl = build_decl (loc, TYPE_DECL, get_identifier (name), type);
+ TYPE_NAME (type) = decl;
+ TYPE_STUB_DECL (type) = decl;
+ lang_hooks.decls.pushdecl (decl);
+
+ return type;
+}
+
/* Default implementation of LANG_HOOKS_TYPE_FOR_SIZE.
Return an integer type with PRECISION bits of precision,
that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
diff --git a/gcc/langhooks.h b/gcc/langhooks.h
index ffd3e0bf2db..3e89134e8b4 100644
--- a/gcc/langhooks.h
+++ b/gcc/langhooks.h
@@ -68,6 +68,16 @@ struct lang_hooks_for_types
them all with the given source location. */
tree (*simulate_enum_decl) (location_t, const char *, vec<string_int_pair>
*);
+ /* Do the equivalent of:
+
+ typedef struct NAME { FIELDS; } NAME;
+
+ associating it with location LOC. Return the associated RECORD_TYPE.
+
+ FIELDS is a list of FIELD_DECLs, in layout order. */
+ tree (*simulate_record_decl) (location_t loc, const char *name,
+ array_slice<const tree> fields);
+
/* Return what kind of RECORD_TYPE this is, mainly for purposes of
debug information. If not defined, record types are assumed to
be structures. */
