This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH]: Move FIELD_DECL into it's own structure
On Mon, 2005-05-23 at 08:36 -0400, Daniel Berlin wrote:
> On Mon, 2005-05-23 at 19:17 +1200, Danny Smith wrote:
> > Daniel Berlin wrote:
> >
> > > DECL_NON_ADDR_CONST_P was completely removed because nothing ever set
> > > it.
> >
> > Umm, it is set and needed by dllimport-using targets (see config/i386/winnt.c).
> > But I was just about to submit a patch (ie, when unslushed) that removes it,
> > replacing with targetm.decl_non_addr_const_p hook, to fix some dllimport bugs
> > (cuurently the flag is set too late).
>
> You are right, i missed that.
>
> What would you like to do?
> Want me to keep it removed, which will temporarily break your port, or
> put it back and let you remove it?
>
Here's an updated patch that doesn't remove it.
Feel free to try it out on your target. If you find it breaks
something, you are likely setting attributes on FIELD_DECL's that you
shouldn't be :)
2005-05-22 Daniel Berlin <dberlin@dberlin.org>
* c-decl.c (merge_decls): Fix the copying of decl nodes of various
types for the new strucutres.
(grokdeclarator): FIELD_DECL can't have DECL_ASSEMBLER_NAME set,
it would abort if it tried to happen.
(finish_struct): Use DECL_FIELD_CONTEXT.
* c-objc-common.c (c_tree_printer): DECL_DEBUG_EXPR would abort if
used FIELD_DECL.
* dwarf2out.c (gen_type_die_member): Attempting to set
DECL_ABSTRACT_ORIGIN would fail on FIELD_DECL.
* fold-const.c (fold_checksum_tree): Use tree_decl_extra as sizeof
buffer.
* ggc-page.c (extra_order_size_table): Add sizes for
tree_decl_extra and tree_field_decl.
* print-tree (print_node): Don't try to print nodes no longer in
FIELD_DECL.
* tree-nested.c (insert_field_into_struct): Use DECL_FIELD_CONTEXT.
* tree.c (decl_assembler_name): FIELD_DECL doesn't have an
assembler name.
(tree_code_size): Update for new structures.
(tree_node_structure): Update for new structures.
(build_decl_stat): Don't try to set visibility on FIELD_DECL's.
(tree_class_except_check_failed): New function.
* tree.h (TREE_CLASS_EXCEPT_CHECK): New macro.
(DECL_ASSEMBLER_NAME_SET_P): Add NOT_FIELD_DECL_CHECK, update to
look at decl_extra member.
(DECL_ASSEMBLER_NAME): Ditto.
(DECL_SECTION_NAME): Ditto.
(DECL_DEFER_OUTPUT): Ditto.
(DECL_ARGUMENTS): Ditto.
(DECL_RESULT_FLD): Ditto.
(DECL_VINDEX): Ditto.
(DECL_DEBUG_EXPR): Ditto.
(DECL_IN_SYSTEM_HEADER): Ditto.
(DECL_REGISTER): Ditto.
(DECL_SEEN_IN_BIND_EXPR_P): Ditto.
(DECL_VISIBILITY): Ditto.
(DECL_VISIBILITY_SPECIFIED): Ditto.
(DECL_WEAK): Ditto.
(DECL_ONE_ONLY): Ditto.
(DECL_COMDAT): Ditto.
(DECL_GIMPLE_FORMAL_TEMP_P): Ditto.
(DECL_RESULT): Update to look at decl_extra.
(DECL_ORIGINAL_TYPE): Ditto.
(DECL_ARG_TYPE_AS_WRITTEN): Ditto.
(DECL_INCOMING_RTL): Ditto.
(DECL_ERROR_ISSUED): Ditto.
(DECL_NO_STATIC_CHAIN): Ditto.
(DECL_INLINE): Ditto.
(DECL_DECLARED_INLINE_P): Ditto.
(DECL_HARD_REGISTER): Ditto.
(DECL_UNINLINABLE): Ditto.
(DECL_THREAD_LOCAL): Ditto.
(DECL_SAVED_TREE): Ditto.
(DECL_VALUE_EXPR): Ditto.
(DECL_IS_MALLOC): Ditto.
(DECL_IS_RETURNS_TWICE): Ditto.
(DECL_IS_PURE): Ditto.
(DECL_IS_NOVOPS): Ditto.
(DECL_IN_TEXT_SECTION): Ditto.
(DECL_BUILT_IN_CLASS): Ditto.
(DECL_STATIC_DESTRUCTOR): Ditto.
(DECL_STATIC_CONSTRUCTOR): Ditto.
(DECL_TRANSPARENT_UNION): Ditto.
(DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT): Ditto.
(DECL_NO_LIMIT_STACK): Ditto.
(DECL_POSSIBLY_INLINED): Ditto.
(struct tree_decl_common): Remove various fields.
(struct tree_decl_extra): New structures.
(struct tree_field_decl): Ditto.
(DECL_FIELD_OFFSET): Moved and update for FIELD_DECL structure.
(DECL_FIELD_BIT_OFFSET): Ditto.
(DECL_BIT_FIELD_TYPE): Ditto.
(DECL_OFFSET_ALIGN): Ditto.
(DECL_QUALIFIER): Ditto.
(SET_DECL_OFFSET_ALIGN): Ditto.
(DECL_FCONTEXT): Ditto.
(DECL_PACKED): Ditto.
(DECL_BIT_FIELD): Ditto.
(DECL_NONADDRESSABLE_P): Ditto.
(enum tree_node_structure): Remove TS_DECL, add TS_DECL_COMMON,
TS_DECL_EXTRA, and TS_FIELD_DECL.
(union tree_node): Add decl_extra and field_decl.
In cp/
* class.c (create_vtable_ptr): Stop setting DECL_ASSEMBLER_NAME on
the field.
* cp-tree.h (DECL_NAMESPACE_ASSOCIATIONS): Use decl_extra.
(DECL_INIT_PRIORITY): Ditto.
* decl.c (duplicate_decls): Update for new/updated structures.
* name-lookup.c (push_class_level_binding): Use
DECL_FIELD_CONTEXT.
In java/
* java-tree.h (LABEL_RETURN_LABELS): Use decl_extra.
(LABEL_PENDING_CHAIN): Ditto.
(LABEL_PC): Ditto.
In objc/
* objc-act.h (KEYWORD_ARG_NAME): Use decl_extra.
(METHOD_SEL_ARGS): Ditto.
(METHOD_ADD_ARGS): Ditto.
Index: c-decl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-decl.c,v
retrieving revision 1.656
diff -u -p -r1.656 c-decl.c
--- c-decl.c 17 May 2005 20:11:34 -0000 1.656
+++ c-decl.c 23 May 2005 13:40:16 -0000
@@ -1827,15 +1827,33 @@ merge_decls (tree newdecl, tree olddecl,
/* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
But preserve OLDDECL's DECL_UID and DECL_CONTEXT. */
- {
- unsigned olddecl_uid = DECL_UID (olddecl);
- tree olddecl_context = DECL_CONTEXT (olddecl);
-
- memcpy ((char *) olddecl + sizeof (struct tree_common),
- (char *) newdecl + sizeof (struct tree_common),
- sizeof (struct tree_decl) - sizeof (struct tree_common));
- DECL_UID (olddecl) = olddecl_uid;
- DECL_CONTEXT (olddecl) = olddecl_context;
+ if (TREE_CODE (olddecl) != FIELD_DECL)
+ {
+ unsigned olddecl_uid = DECL_UID (olddecl);
+ tree olddecl_context = DECL_CONTEXT (olddecl);
+
+ memcpy ((char *) olddecl + sizeof (struct tree_common),
+ (char *) newdecl + sizeof (struct tree_common),
+ sizeof (struct tree_decl_common) - sizeof (struct tree_common));
+ memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+ (char *) newdecl + sizeof (struct tree_decl_common),
+ sizeof (struct tree_decl_extra) - sizeof (struct tree_decl_common));
+ DECL_UID (olddecl) = olddecl_uid;
+ DECL_CONTEXT (olddecl) = olddecl_context;
+ }
+ else
+ {
+ unsigned olddecl_uid = DECL_UID (olddecl);
+ tree olddecl_context = DECL_FIELD_CONTEXT (olddecl);
+
+ memcpy ((char *) olddecl + sizeof (struct tree_common),
+ (char *) newdecl + sizeof (struct tree_common),
+ sizeof (struct tree_decl_common) - sizeof (struct tree_common));
+ memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+ (char *) newdecl + sizeof (struct tree_decl_common),
+ sizeof (struct tree_field_decl) - sizeof (struct tree_decl_common));
+ DECL_UID (olddecl) = olddecl_uid;
+ DECL_FIELD_CONTEXT (olddecl) = olddecl_context;
}
/* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
@@ -4704,7 +4722,7 @@ grokdeclarator (const struct c_declarato
/* This is the earliest point at which we might know the assembler
name of a variable. Thus, if it's known before this, die horribly. */
- gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
+ gcc_assert ((TREE_CODE (decl) == FIELD_DECL) || !DECL_ASSEMBLER_NAME_SET_P (decl));
decl_attributes (&decl, returned_attrs, 0);
@@ -5272,7 +5290,7 @@ finish_struct (tree t, tree fieldlist, t
saw_named_field = 0;
for (x = fieldlist; x; x = TREE_CHAIN (x))
{
- DECL_CONTEXT (x) = t;
+ DECL_FIELD_CONTEXT (x) = t;
DECL_PACKED (x) |= TYPE_PACKED (t);
/* If any field is const, the structure type is pseudo-const. */
Index: c-objc-common.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-objc-common.c,v
retrieving revision 1.65
diff -u -p -r1.65 c-objc-common.c
--- c-objc-common.c 25 Apr 2005 19:03:20 -0000 1.65
+++ c-objc-common.c 23 May 2005 13:40:16 -0000
@@ -171,7 +171,8 @@ c_tree_printer (pretty_printer *pp, text
switch (*text->format_spec)
{
case 'D':
- if (DECL_DEBUG_EXPR (t) && DECL_DEBUG_EXPR_IS_FROM (t))
+ if (TREE_CODE (t) != FIELD_DECL && DECL_DEBUG_EXPR (t)
+ && DECL_DEBUG_EXPR_IS_FROM (t))
{
t = DECL_DEBUG_EXPR (t);
if (!DECL_P (t))
Index: dwarf2out.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarf2out.c,v
retrieving revision 1.595
diff -u -p -r1.595 dwarf2out.c
--- dwarf2out.c 16 May 2005 21:36:55 -0000 1.595
+++ dwarf2out.c 23 May 2005 13:40:16 -0000
@@ -11224,7 +11224,8 @@ gen_type_die_for_member (tree type, tree
&& ! lookup_decl_die (member))
{
dw_die_ref type_die;
- gcc_assert (!decl_ultimate_origin (member));
+ gcc_assert (TREE_CODE (member) == FIELD_DECL
+ || !decl_ultimate_origin (member));
push_decl_scope (type);
type_die = lookup_type_die (type);
Index: fold-const.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/fold-const.c,v
retrieving revision 1.581
diff -u -p -r1.581 fold-const.c
--- fold-const.c 17 May 2005 09:55:20 -0000 1.581
+++ fold-const.c 23 May 2005 13:40:17 -0000
@@ -10391,12 +10391,12 @@ fold_checksum_tree (tree expr, struct md
{
void **slot;
enum tree_code code;
- char buf[sizeof (struct tree_decl)];
+ char buf[sizeof (struct tree_decl_extra)];
int i, len;
gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
- <= sizeof (struct tree_decl))
- && sizeof (struct tree_type) <= sizeof (struct tree_decl));
+ <= sizeof (struct tree_decl_extra))
+ && sizeof (struct tree_type) <= sizeof (struct tree_decl_extra));
if (expr == NULL)
return;
slot = htab_find_slot (ht, expr, INSERT);
Index: ggc-page.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ggc-page.c,v
retrieving revision 1.101
diff -u -p -r1.101 ggc-page.c
--- ggc-page.c 17 May 2005 19:41:37 -0000 1.101
+++ ggc-page.c 23 May 2005 13:40:17 -0000
@@ -186,7 +186,8 @@ Software Foundation, 59 Temple Place - S
static const size_t extra_order_size_table[] = {
sizeof (struct stmt_ann_d),
- sizeof (struct tree_decl),
+ sizeof (struct tree_decl_extra),
+ sizeof (struct tree_field_decl),
sizeof (struct tree_list),
TREE_EXP_SIZE (2),
RTL_SIZE (2), /* MEM, PLUS, etc. */
Index: print-tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/print-tree.c,v
retrieving revision 1.100
diff -u -p -r1.100 print-tree.c
--- print-tree.c 31 Mar 2005 00:09:10 -0000 1.100
+++ print-tree.c 23 May 2005 13:40:17 -0000
@@ -326,15 +326,17 @@ print_node (FILE *file, const char *pref
fputs (" common", file);
if (DECL_EXTERNAL (node))
fputs (" external", file);
- if (DECL_WEAK (node))
- fputs (" weak", file);
- if (DECL_REGISTER (node) && TREE_CODE (node) != FIELD_DECL
- && TREE_CODE (node) != FUNCTION_DECL
- && TREE_CODE (node) != LABEL_DECL)
- fputs (" regdecl", file);
- if (DECL_NONLOCAL (node))
- fputs (" nonlocal", file);
-
+ if (TREE_CODE (node) != FIELD_DECL)
+ {
+ if (DECL_WEAK (node))
+ fputs (" weak", file);
+ if (TREE_CODE (node) != FUNCTION_DECL
+ && TREE_CODE (node) != LABEL_DECL
+ && DECL_REGISTER (node))
+ fputs (" regdecl", file);
+ if (DECL_NONLOCAL (node))
+ fputs (" nonlocal", file);
+ }
if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
@@ -365,7 +367,7 @@ print_node (FILE *file, const char *pref
if (DECL_VIRTUAL_P (node))
fputs (" virtual", file);
- if (DECL_DEFER_OUTPUT (node))
+ if (TREE_CODE (node) != FIELD_DECL && DECL_DEFER_OUTPUT (node))
fputs (" defer-output", file);
if (DECL_PRESERVE_P (node))
@@ -431,13 +433,17 @@ print_node (FILE *file, const char *pref
}
print_node_brief (file, "context", DECL_CONTEXT (node), indent + 4);
+
print_node_brief (file, "attributes",
DECL_ATTRIBUTES (node), indent + 4);
- print_node_brief (file, "abstract_origin",
- DECL_ABSTRACT_ORIGIN (node), indent + 4);
- print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
- print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
+ if (TREE_CODE (node) != FIELD_DECL)
+ {
+ print_node_brief (file, "abstract_origin",
+ DECL_ABSTRACT_ORIGIN (node), indent + 4);
+ print_node (file, "arguments", DECL_ARGUMENTS (node), indent + 4);
+ print_node (file, "result", DECL_RESULT_FLD (node), indent + 4);
+ }
print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4);
lang_hooks.print_decl (file, node, indent);
Index: tree-nested.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-nested.c,v
retrieving revision 2.24
diff -u -p -r2.24 tree-nested.c
--- tree-nested.c 23 Jan 2005 15:05:31 -0000 2.24
+++ tree-nested.c 23 May 2005 13:40:17 -0000
@@ -171,7 +171,7 @@ insert_field_into_struct (tree type, tre
{
tree *p;
- DECL_CONTEXT (field) = type;
+ DECL_FIELD_CONTEXT (field) = type;
for (p = &TYPE_FIELDS (type); *p ; p = &TREE_CHAIN (*p))
if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
Index: tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.c,v
retrieving revision 1.480
diff -u -p -r1.480 tree.c
--- tree.c 18 May 2005 20:11:20 -0000 1.480
+++ tree.c 23 May 2005 13:40:17 -0000
@@ -165,9 +165,11 @@ init_ttree (void)
tree
decl_assembler_name (tree decl)
{
+ gcc_assert (TREE_CODE (decl) != FIELD_DECL);
+
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
lang_hooks.set_decl_assembler_name (decl);
- return DECL_CHECK (decl)->decl.assembler_name;
+ return NOT_FIELD_DECL_CHECK (decl)->decl_extra.assembler_name;
}
/* Compute the number of bytes occupied by a tree with code CODE.
@@ -179,7 +181,10 @@ tree_code_size (enum tree_code code)
switch (TREE_CODE_CLASS (code))
{
case tcc_declaration: /* A decl node */
- return sizeof (struct tree_decl);
+ if (code == FIELD_DECL)
+ return sizeof (struct tree_field_decl);
+ else
+ return sizeof (struct tree_decl_extra);
case tcc_type: /* a type node */
return sizeof (struct tree_type);
@@ -365,7 +370,8 @@ make_node_stat (enum tree_code code MEM_
if (code != FUNCTION_DECL)
DECL_ALIGN (t) = 1;
DECL_USER_ALIGN (t) = 0;
- DECL_IN_SYSTEM_HEADER (t) = in_system_header;
+ if (code != FIELD_DECL)
+ DECL_IN_SYSTEM_HEADER (t) = in_system_header;
DECL_SOURCE_LOCATION (t) = input_location;
DECL_UID (t) = next_decl_uid++;
@@ -1775,9 +1781,14 @@ tree_node_structure (tree t)
enum tree_code code = TREE_CODE (t);
switch (TREE_CODE_CLASS (code))
- {
+ {
case tcc_declaration:
- return TS_DECL;
+ {
+ if (code == FIELD_DECL)
+ return TS_FIELD_DECL;
+ else
+ return TS_DECL_EXTRA;
+ }
case tcc_type:
return TS_TYPE;
case tcc_reference:
@@ -2796,10 +2807,13 @@ build_decl_stat (enum tree_code code, tr
else if (code == FUNCTION_DECL)
DECL_MODE (t) = FUNCTION_MODE;
- /* Set default visibility to whatever the user supplied with
- visibility_specified depending on #pragma GCC visibility. */
- DECL_VISIBILITY (t) = default_visibility;
- DECL_VISIBILITY_SPECIFIED (t) = visibility_options.inpragma;
+ if (code != FIELD_DECL)
+ {
+ /* Set default visibility to whatever the user supplied with
+ visibility_specified depending on #pragma GCC visibility. */
+ DECL_VISIBILITY (t) = default_visibility;
+ DECL_VISIBILITY_SPECIFIED (t) = visibility_options.inpragma;
+ }
return t;
}
@@ -5464,6 +5478,24 @@ tree_class_check_failed (const tree node
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
}
+/* Similar to tree_class_check_failed, except that we check for a class of tree
+ code, given in CL, and allow any member but CODE. */
+
+void
+tree_class_except_check_failed (const tree node,
+ const enum tree_code_class cl,
+ const enum tree_code code,
+ const char *file, int line,
+ const char *function)
+{
+ internal_error
+ ("tree check: expected any member of class %qs, except %qs, have %qs (%s) in %s, at %s:%d",
+ TREE_CODE_CLASS_STRING (cl),
+ tree_code_name[code],
+ TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
+ tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
+}
+
/* Similar to above, except that the check is for the bounds of a TREE_VEC's
(dynamically sized) vector. */
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.728
diff -u -p -r1.728 tree.h
--- tree.h 17 May 2005 20:02:56 -0000 1.728
+++ tree.h 23 May 2005 13:40:17 -0000
@@ -543,6 +543,14 @@ struct tree_common GTY(())
__FUNCTION__); \
__t; })
+#define TREE_CLASS_EXCEPT_CHECK(T, CLASS, CODE) __extension__ \
+({ const tree __t = (T); \
+ if ((TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS)) \
+ || TREE_CODE (__t) == (CODE)) \
+ tree_class_except_check_failed (__t, (CLASS), (CODE), __FILE__, \
+ __LINE__, __FUNCTION__); \
+ __t; })
+
/* These checks have to be special cased. */
#define EXPR_CHECK(T) __extension__ \
({ const tree __t = (T); \
@@ -619,6 +627,11 @@ extern void tree_not_check_failed (const
extern void tree_class_check_failed (const tree, const enum tree_code_class,
const char *, int, const char *)
ATTRIBUTE_NORETURN;
+extern void tree_class_except_check_failed (const tree,
+ const enum tree_code_class,
+ const enum tree_code,
+ const char *, int, const char *)
+ ATTRIBUTE_NORETURN;
extern void tree_vec_elt_check_failed (int, int, const char *,
int, const char *)
ATTRIBUTE_NORETURN;
@@ -642,6 +655,7 @@ extern void tree_operand_check_failed (i
#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
#define TREE_CLASS_CHECK(T, CODE) (T)
+#define TREE_CLASS_EXCEPT_CHECK(T, CODE, CODE) (T)
#define EXPR_CHECK(T) (T)
#define NON_TYPE_CHECK(T) (T)
#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
@@ -658,6 +672,7 @@ extern void tree_operand_check_failed (i
#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
#define DECL_CHECK(T) TREE_CLASS_CHECK (T, tcc_declaration)
+#define NOT_FIELD_DECL_CHECK(T) TREE_CLASS_EXCEPT_CHECK (T, tcc_declaration, FIELD_DECL)
#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
@@ -1895,11 +1910,11 @@ struct tree_binfo GTY (())
the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
yet. */
#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
- (DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
+ (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.assembler_name != NULL_TREE)
/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
- (DECL_CHECK (NODE)->decl.assembler_name = (NAME))
+ (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.assembler_name = (NAME))
/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's
DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
@@ -1918,7 +1933,7 @@ struct tree_binfo GTY (())
/* Records the section name in a section attribute. Used to pass
the name from decl_attributes to make_function_rtl and make_decl_rtl. */
-#define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
+#define DECL_SECTION_NAME(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.section_name)
/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
@@ -1929,46 +1944,38 @@ struct tree_binfo GTY (())
scope". */
#define DECL_CONTEXT(NODE) (DECL_CHECK (NODE)->decl.context)
#define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.context)
+
/* In a DECL this is the field where attributes are stored. */
#define DECL_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.attributes)
-/* In a FIELD_DECL, this is the field position, counting in bytes, of the
- byte containing the bit closest to the beginning of the structure. */
-#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.arguments)
-/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
- field from DECL_FIELD_OFFSET. */
-#define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.u2.t)
-/* In a FIELD_DECL, this indicates whether the field was a bit-field and
- if so, the type that was originally specified for it.
- TREE_TYPE may have been modified (in finish_struct). */
-#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->decl.result)
/* In FUNCTION_DECL, a chain of ..._DECL nodes.
VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
uses. */
-#define DECL_ARGUMENTS(NODE) (DECL_CHECK (NODE)->decl.arguments)
+#define DECL_ARGUMENTS(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.arguments)
/* This field is used to reference anything in decl.result and is meant only
for use by the garbage collector. */
-#define DECL_RESULT_FLD(NODE) (DECL_CHECK (NODE)->decl.result)
+#define DECL_RESULT_FLD(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.result)
/* In FUNCTION_DECL, holds the decl for the return value. */
-#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.result)
+#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.result)
/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
-#define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl.result)
+#define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl_extra.result)
/* In PARM_DECL, holds the type as written (perhaps a function or array). */
-#define DECL_ARG_TYPE_AS_WRITTEN(NODE) (PARM_DECL_CHECK (NODE)->decl.result)
+#define DECL_ARG_TYPE_AS_WRITTEN(NODE) (PARM_DECL_CHECK (NODE)->decl_extra.result)
/* For a FUNCTION_DECL, holds the tree of BINDINGs.
For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
For a VAR_DECL, holds the initial value.
For a PARM_DECL, not used--default
values for parameters are encoded in the type of the function,
not in the PARM_DECL slot.
+ For a FIELD_DECL, this is used for enumeration values and the C
+ frontend uses it for temporarily storing bitwidth of bitfields.
??? Need to figure out some way to check this isn't a PARM_DECL. */
#define DECL_INITIAL(NODE) (DECL_CHECK (NODE)->decl.initial)
+
/* For a PARM_DECL, records the data type used to pass the argument,
which may be different from the type seen in the program. */
#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl.initial)
-/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
- if nonzero, indicates that the field occupies the type. */
-#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->decl.initial)
+
/* These two fields describe where in the source code the declaration
was. If the declaration appears in several places (as for a C
function that is declared first and then defined later), this
@@ -1995,13 +2002,6 @@ struct tree_binfo GTY (())
DECL_FIELD_OFFSET which are known to be always zero.
DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
has. */
-#define DECL_OFFSET_ALIGN(NODE) \
- (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align)
-/* Specify that DECL_ALIGN(NODE) is a multiple of X. */
-#define SET_DECL_OFFSET_ALIGN(NODE, X) \
- (FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align = exact_log2 ((X) & -(X)))
-/* 1 if the alignment for this type was requested by "aligned" attribute,
- 0 if it is the default for this type. */
#define DECL_USER_ALIGN(NODE) (DECL_CHECK (NODE)->decl.user_align)
/* Holds the machine mode corresponding to the declaration of a variable or
field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
@@ -2011,7 +2011,7 @@ struct tree_binfo GTY (())
This value can be evaluated lazily for functions, variables with
static storage duration, and labels. */
#define DECL_RTL(NODE) \
- (DECL_CHECK (NODE)->decl.rtl \
+ (DECL_CHECK (NODE)->decl.rtl \
? (NODE)->decl.rtl \
: (make_decl_rtl (NODE), (NODE)->decl.rtl))
/* Set the DECL_RTL for NODE to RTL. */
@@ -2022,16 +2022,17 @@ struct tree_binfo GTY (())
NODE1, it will not be set for NODE2; this is a lazy copy. */
#define COPY_DECL_RTL(NODE1, NODE2) \
(DECL_CHECK (NODE2)->decl.rtl = DECL_CHECK (NODE1)->decl.rtl)
+
/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
/* For PARM_DECL, holds an RTL for the stack slot or register
where the data was actually passed. */
-#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r)
+#define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl_extra.u2.r)
/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
that describes the status of this function. */
-#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
+#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.u2.f)
/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
operation it is. Note, however, that this field is overloaded, with
@@ -2045,18 +2046,15 @@ struct tree_binfo GTY (())
is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
function. When the class is laid out, this pointer is changed
to an INTEGER_CST node which is suitable for use as an index
- into the virtual function table. */
-#define DECL_VINDEX(NODE) (DECL_CHECK (NODE)->decl.vindex)
+ into the virtual function table.
+ C++ also uses this field in namespaces, hence the NOT_FIELD_DECL_CHECK. */
+#define DECL_VINDEX(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.vindex)
-/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
- which this FIELD_DECL is defined. This information is needed when
- writing debugging information about vfield and vbase decls for C++. */
-#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.vindex)
/* For VAR_DECL, this is set to either an expression that it was split
from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of
subexpressions that it was split into. */
-#define DECL_DEBUG_EXPR(NODE) (DECL_CHECK (NODE)->decl.vindex)
+#define DECL_DEBUG_EXPR(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.vindex)
#define DECL_DEBUG_EXPR_IS_FROM(NODE) \
(DECL_CHECK (NODE)->decl.debug_expr_is_from)
@@ -2069,7 +2067,7 @@ struct tree_binfo GTY (())
that this decl is not an instance of some other decl. For example,
in a nested declaration of an inline function, this points back to the
definition. */
-#define DECL_ABSTRACT_ORIGIN(NODE) (DECL_CHECK (NODE)->decl.abstract_origin)
+#define DECL_ABSTRACT_ORIGIN(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.abstract_origin)
/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
@@ -2098,12 +2096,12 @@ struct tree_binfo GTY (())
/* Nonzero for a given ..._DECL node means that no warnings should be
generated just because this node is unused. */
#define DECL_IN_SYSTEM_HEADER(NODE) \
- (DECL_CHECK (NODE)->decl.in_system_header_flag)
+ (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.in_system_header_flag)
/* Nonzero for a given ..._DECL node means that this node should be
put in .common, if possible. If a DECL_INITIAL is given, and it
is not error_mark_node, then the decl cannot be put in .common. */
-#define DECL_COMMON(NODE) (DECL_CHECK (NODE)->decl.common_flag)
+#define DECL_COMMON(NODE) (DECL_CHECK (NODE)->decl_extra.common_flag)
/* Language-specific decl information. */
#define DECL_LANG_SPECIFIC(NODE) (DECL_CHECK (NODE)->decl.lang_specific)
@@ -2111,7 +2109,7 @@ struct tree_binfo GTY (())
/* In a VAR_DECL or FUNCTION_DECL,
nonzero means external reference:
do not allocate storage, and refer to a definition elsewhere. */
-#define DECL_EXTERNAL(NODE) (DECL_CHECK (NODE)->decl.external_flag)
+#define DECL_EXTERNAL(NODE) (DECL_CHECK (NODE)->decl_extra.external_flag)
/* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority
initializations. */
@@ -2124,22 +2122,19 @@ struct tree_binfo GTY (())
Instead it will generate cross reference ('x') of names.
This uses the same flag as DECL_EXTERNAL. */
#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
- (TYPE_DECL_CHECK (NODE)->decl.external_flag)
+ (TYPE_DECL_CHECK (NODE)->decl_extra.external_flag)
/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
-#define DECL_REGISTER(NODE) (DECL_CHECK (NODE)->decl.regdecl_flag)
+#define DECL_REGISTER(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.regdecl_flag)
/* In LABEL_DECL nodes, nonzero means that an error message about
jumping into such a binding contour has been printed for this label. */
-#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl.regdecl_flag)
-
-/* In a FIELD_DECL, indicates this field should be bit-packed. */
-#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag)
+#define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl_extra.regdecl_flag)
/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
static chain is not needed. */
#define DECL_NO_STATIC_CHAIN(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.regdecl_flag)
/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
@@ -2152,84 +2147,81 @@ struct tree_binfo GTY (())
/* Nonzero in a FUNCTION_DECL means this function can be substituted
where it is called. */
-#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.inline_flag)
/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
such as via the `inline' keyword in C/C++. This flag controls the linkage
semantics of 'inline'; whether or not the function is inlined is
controlled by DECL_INLINE. */
#define DECL_DECLARED_INLINE_P(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.declared_inline_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.declared_inline_flag)
/* Nonzero in a decl means that the gimplifier has seen (or placed)
this variable in a BIND_EXPR. */
#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
- (DECL_CHECK (NODE)->decl.seen_in_bind_expr)
+ (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.seen_in_bind_expr)
/* In a VAR_DECL, nonzero if the decl is a register variable with
an explicit asm specification. */
-#define DECL_HARD_REGISTER(NODE) (VAR_DECL_CHECK (NODE)->decl.inline_flag)
+#define DECL_HARD_REGISTER(NODE) (VAR_DECL_CHECK (NODE)->decl_extra.inline_flag)
/* Value of the decls's visibility attribute */
-#define DECL_VISIBILITY(NODE) (DECL_CHECK (NODE)->decl.visibility)
+#define DECL_VISIBILITY(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.visibility)
/* Nonzero means that the decl had its visibility specified rather than
being inferred. */
-#define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_CHECK (NODE)->decl.visibility_specified)
+#define DECL_VISIBILITY_SPECIFIED(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.visibility_specified)
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
-#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
+#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.uninlinable)
/* In a VAR_DECL, nonzero if the data should be allocated from
thread-local storage. */
-#define DECL_THREAD_LOCAL(NODE) (VAR_DECL_CHECK (NODE)->decl.thread_local_flag)
+#define DECL_THREAD_LOCAL(NODE) (VAR_DECL_CHECK (NODE)->decl_extra.thread_local_flag)
/* In a FUNCTION_DECL, the saved representation of the body of the
entire function. */
-#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.saved_tree)
+#define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.saved_tree)
/* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
if transformations have made this more complicated than evaluating the
decl itself. This should only be used for debugging; once this field has
been set, the decl itself may not legitimately appear in the function. */
#define DECL_VALUE_EXPR(NODE) \
- (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl.saved_tree)
+ (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_extra.saved_tree)
/* Nonzero in a FUNCTION_DECL means this function should be treated
as if it were a malloc, meaning it returns a pointer that is
not an alias. */
-#define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.malloc_flag)
+#define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.malloc_flag)
/* Nonzero in a FUNCTION_DECL means this function may return more
than once. */
#define DECL_IS_RETURNS_TWICE(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.returns_twice_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.returns_twice_flag)
/* Nonzero in a FUNCTION_DECL means this function should be treated
as "pure" function (like const function, but may read global memory). */
-#define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.pure_flag)
+#define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.pure_flag)
/* Nonzero in a FUNCTION_DECL means this function should be treated
as "novops" function (function that does not read global memory,
but may have arbitrary side effects). */
-#define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.novops_flag)
+#define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_extra.novops_flag)
-/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
- specially. */
-#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl.bit_field_flag)
/* Unused in FUNCTION_DECL. */
/* In a VAR_DECL that's static,
nonzero if the space is in the text section. */
-#define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl.bit_field_flag)
+#define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl_extra.in_text_section)
/* In a FUNCTION_DECL, nonzero means a built in function. */
#define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
/* For a builtin function, identify which part of the compiler defined it. */
#define DECL_BUILT_IN_CLASS(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.built_in_class)
/* Used in VAR_DECLs to indicate that the variable is a vtable.
Used in FIELD_DECLs for vtable pointers.
@@ -2238,31 +2230,35 @@ struct tree_binfo GTY (())
/* Used to indicate that the linkage status of this DECL is not yet known,
so it should not be output now. */
-#define DECL_DEFER_OUTPUT(NODE) (DECL_CHECK (NODE)->decl.defer_output)
+#define DECL_DEFER_OUTPUT(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.defer_output)
/* Used in PARM_DECLs whose type are unions to indicate that the
argument should be passed in the same way that the first union
alternative would be passed. */
#define DECL_TRANSPARENT_UNION(NODE) \
- (PARM_DECL_CHECK (NODE)->decl.transparent_union)
+ (PARM_DECL_CHECK (NODE)->decl_extra.transparent_union)
/* Used in FUNCTION_DECLs to indicate that they should be run automatically
at the beginning or end of execution. */
#define DECL_STATIC_CONSTRUCTOR(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.static_ctor_flag)
#define DECL_STATIC_DESTRUCTOR(NODE) \
-(FUNCTION_DECL_CHECK (NODE)->decl.static_dtor_flag)
+(FUNCTION_DECL_CHECK (NODE)->decl_extra.static_dtor_flag)
/* Used to indicate that this DECL represents a compiler-generated entity. */
#define DECL_ARTIFICIAL(NODE) (DECL_CHECK (NODE)->decl.artificial_flag)
-/* Used to indicate that this DECL has weak linkage. */
-#define DECL_WEAK(NODE) (DECL_CHECK (NODE)->decl.weak_flag)
+/* Used to indicate that the pointer to this DECL cannot be treated as
+ an address constant. */
+#define DECL_NON_ADDR_CONST_P(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.non_addr_const_p)
+
+ /* Used to indicate that this DECL has weak linkage. */
+#define DECL_WEAK(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.weak_flag)
/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
multiple translation units should be merged. */
-#define DECL_ONE_ONLY(NODE) (DECL_CHECK (NODE)->decl.transparent_union)
+#define DECL_ONE_ONLY(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.transparent_union)
/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
not be put out unless it is needed in this translation unit.
@@ -2273,17 +2269,17 @@ struct tree_binfo GTY (())
back-end; it is up to front-ends which set this flag to ensure
that there will never be any harm, other than bloat, in putting out
something which is DECL_COMDAT. */
-#define DECL_COMDAT(NODE) (DECL_CHECK (NODE)->decl.comdat_flag)
+#define DECL_COMDAT(NODE) (NOT_FIELD_DECL_CHECK (NODE)->decl_extra.comdat_flag)
/* Used in FUNCTION_DECLs to indicate that function entry and exit should
be instrumented with calls to support routines. */
#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.no_instrument_function_entry_exit)
/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
disabled in this function. */
#define DECL_NO_LIMIT_STACK(NODE) \
- (FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
+ (FUNCTION_DECL_CHECK (NODE)->decl_extra.no_limit_stack)
/* Additional flags for language-specific uses. */
#define DECL_LANG_FLAG_0(NODE) (DECL_CHECK (NODE)->decl.lang_flag_0)
@@ -2295,22 +2291,12 @@ struct tree_binfo GTY (())
#define DECL_LANG_FLAG_6(NODE) (DECL_CHECK (NODE)->decl.lang_flag_6)
#define DECL_LANG_FLAG_7(NODE) (DECL_CHECK (NODE)->decl.lang_flag_7)
-/* Used to indicate that the pointer to this DECL cannot be treated as
- an address constant. */
-#define DECL_NON_ADDR_CONST_P(NODE) (DECL_CHECK (NODE)->decl.non_addr_const_p)
-
-/* Used in a FIELD_DECL to indicate that we cannot form the address of
- this component. */
-#define DECL_NONADDRESSABLE_P(NODE) \
- (FIELD_DECL_CHECK (NODE)->decl.non_addressable)
-
/* Used to indicate an alias set for the memory pointed to by this
particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
pointer (or reference) type. */
#define DECL_POINTER_ALIAS_SET(NODE) \
(DECL_CHECK (NODE)->decl.pointer_alias_set)
-
/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
dense, unique within any one function, and may be used to index arrays.
If the value is -1, then no UID has been assigned. */
@@ -2330,7 +2316,7 @@ struct tree_binfo GTY (())
at least one call site. It is not meaningful to look at this
directly; always use cgraph_function_possibly_inlined_p. */
#define DECL_POSSIBLY_INLINED(DECL) \
- FUNCTION_DECL_CHECK (DECL)->decl.possibly_inlined
+ FUNCTION_DECL_CHECK (DECL)->decl_extra.possibly_inlined
/* Nonzero for a decl that is decorated using attribute used.
This indicates compiler tools that this decl needs to be preserved. */
@@ -2340,7 +2326,7 @@ struct tree_binfo GTY (())
/* Internal to the gimplifier. Indicates that the value is a formal
temporary controlled by the gimplifier. */
#define DECL_GIMPLE_FORMAL_TEMP_P(DECL) \
- DECL_CHECK (DECL)->decl.gimple_formal_temp
+ NOT_FIELD_DECL_CHECK (DECL)->decl_extra.gimple_formal_temp
/* Enumerate visibility settings. */
#ifndef SYMBOL_VISIBILITY_DEFINED
@@ -2355,47 +2341,24 @@ enum symbol_visibility
#endif
struct function;
-struct tree_decl GTY(())
+
+struct tree_decl_common GTY(())
{
struct tree_common common;
location_t locus;
unsigned int uid;
tree size;
+
ENUM_BITFIELD(machine_mode) mode : 8;
- unsigned external_flag : 1;
unsigned nonlocal_flag : 1;
- unsigned regdecl_flag : 1;
- unsigned inline_flag : 1;
- unsigned bit_field_flag : 1;
unsigned virtual_flag : 1;
unsigned ignored_flag : 1;
unsigned abstract_flag : 1;
-
- unsigned in_system_header_flag : 1;
- unsigned common_flag : 1;
- unsigned defer_output : 1;
- unsigned transparent_union : 1;
- unsigned static_ctor_flag : 1;
- unsigned static_dtor_flag : 1;
unsigned artificial_flag : 1;
- unsigned weak_flag : 1;
-
- unsigned non_addr_const_p : 1;
- unsigned no_instrument_function_entry_exit : 1;
- unsigned comdat_flag : 1;
- unsigned malloc_flag : 1;
- unsigned no_limit_stack : 1;
- ENUM_BITFIELD(built_in_class) built_in_class : 2;
- unsigned pure_flag : 1;
-
- unsigned non_addressable : 1;
unsigned user_align : 1;
- unsigned uninlinable : 1;
- unsigned thread_local_flag : 1;
- unsigned declared_inline_flag : 1;
- ENUM_BITFIELD(symbol_visibility) visibility : 2;
- unsigned visibility_specified : 1;
+ unsigned preserve_flag: 1;
+ unsigned debug_expr_is_from : 1;
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
@@ -2406,15 +2369,6 @@ struct tree_decl GTY(())
unsigned lang_flag_6 : 1;
unsigned lang_flag_7 : 1;
- unsigned possibly_inlined : 1;
- unsigned preserve_flag: 1;
- unsigned gimple_formal_temp : 1;
- unsigned debug_expr_is_from : 1;
- unsigned returns_twice_flag : 1;
- unsigned seen_in_bind_expr : 1;
- unsigned novops_flag : 1;
- /* 9 unused bits. */
-
union tree_decl_u1 {
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
DECL_FUNCTION_CODE. */
@@ -2430,37 +2384,138 @@ struct tree_decl GTY(())
} a;
} GTY ((skip)) u1;
+ rtx rtl; /* RTL representation for object. */
tree size_unit;
tree name;
- tree context;
- tree arguments; /* Also used for DECL_FIELD_OFFSET */
- tree result; /* Also used for DECL_BIT_FIELD_TYPE */
- tree initial; /* Also used for DECL_QUALIFIER */
- tree abstract_origin;
- tree assembler_name;
- tree section_name;
+ tree initial;
tree attributes;
- rtx rtl; /* RTL representation for object. */
+ tree context;
+
+ HOST_WIDE_INT pointer_alias_set;
+ /* Points to a structure whose details depend on the language in use. */
+ struct lang_decl *lang_specific;
+};
+
+struct tree_decl_extra GTY(())
+{
+ struct tree_decl_common common;
+
+ unsigned transparent_union : 1;
+ unsigned gimple_formal_temp : 1;
+ unsigned seen_in_bind_expr : 1;
+ unsigned weak_flag : 1;
+ unsigned defer_output : 1;
+ ENUM_BITFIELD(symbol_visibility) visibility : 2;
+ unsigned visibility_specified : 1;
+
+ unsigned static_ctor_flag : 1;
+ unsigned static_dtor_flag : 1;
+ unsigned uninlinable : 1;
+ unsigned possibly_inlined : 1;
+ unsigned novops_flag : 1;
+ unsigned returns_twice_flag : 1;
+ unsigned malloc_flag : 1;
+ unsigned pure_flag : 1;
+
+ unsigned common_flag : 1;
+ unsigned in_system_header_flag : 1;
+ unsigned thread_local_flag : 1;
+ unsigned declared_inline_flag : 1;
+ unsigned regdecl_flag : 1;
+ unsigned external_flag : 1;
+ unsigned inline_flag : 1;
+ unsigned no_instrument_function_entry_exit : 1;
+
+ unsigned comdat_flag : 1;
+ unsigned no_limit_stack : 1;
+ unsigned in_text_section : 1;
+ ENUM_BITFIELD(built_in_class) built_in_class : 2;
+ unsigned non_addr_const_p : 1;
/* In FUNCTION_DECL, if it is inline, holds the saved insn chain.
- In FIELD_DECL, is DECL_FIELD_BIT_OFFSET.
In PARM_DECL, holds an RTL for the stack slot
of register where the data was actually passed.
Used by Chill and Java in LABEL_DECL and by C++ and Java in VAR_DECL. */
union tree_decl_u2 {
struct function * GTY ((tag ("FUNCTION_DECL"))) f;
rtx GTY ((tag ("PARM_DECL"))) r;
- tree GTY ((tag ("FIELD_DECL"))) t;
int GTY ((tag ("VAR_DECL"))) i;
} GTY ((desc ("TREE_CODE((tree) &(%0))"))) u2;
+
+ tree arguments;
+ tree result;
+ tree abstract_origin;
+
/* In a FUNCTION_DECL, this is DECL_SAVED_TREE.
In a VAR_DECL or PARM_DECL, this is DECL_VALUE_EXPR. */
tree saved_tree;
tree vindex;
- HOST_WIDE_INT pointer_alias_set;
- /* Points to a structure whose details depend on the language in use. */
- struct lang_decl *lang_specific;
+ tree assembler_name;
+ tree section_name;
+};
+
+/* In a FIELD_DECL, this is the field position, counting in bytes, of the
+ byte containing the bit closest to the beginning of the structure. */
+#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
+
+/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
+ field from DECL_FIELD_OFFSET. */
+#define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
+
+/* In a FIELD_DECL, this indicates whether the field was a bit-field and
+ if so, the type that was originally specified for it.
+ TREE_TYPE may have been modified (in finish_struct). */
+#define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
+
+/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
+ if nonzero, indicates that the field occupies the type. */
+#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
+
+/* For FIELD_DECLs, off_align holds the number of low-order bits of
+ DECL_FIELD_OFFSET which are known to be always zero.
+ DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
+ has. */
+#define DECL_OFFSET_ALIGN(NODE) \
+ (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align)
+
+/* Specify that DECL_ALIGN(NODE) is a multiple of X. */
+#define SET_DECL_OFFSET_ALIGN(NODE, X) \
+ (FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align = exact_log2 ((X) & -(X)))
+/* 1 if the alignment for this type was requested by "aligned" attribute,
+ 0 if it is the default for this type. */
+
+/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
+ which this FIELD_DECL is defined. This information is needed when
+ writing debugging information about vfield and vbase decls for C++. */
+#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
+
+/* In a FIELD_DECL, indicates this field should be bit-packed. */
+#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.packed_flag)
+
+/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
+ specially. */
+#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_flag)
+
+/* Used in a FIELD_DECL to indicate that we cannot form the address of
+ this component. */
+#define DECL_NONADDRESSABLE_P(NODE) \
+ (FIELD_DECL_CHECK (NODE)->field_decl.non_addressable)
+
+struct tree_field_decl GTY(())
+{
+ struct tree_decl_common common;
+
+ unsigned packed_flag : 1;
+ unsigned bit_field_flag : 1;
+ unsigned non_addressable : 1;
+
+ tree offset;
+ tree bit_field_type;
+ tree qualifier;
+ tree bit_offset;
+ tree fcontext;
+
};
@@ -2521,7 +2576,9 @@ enum tree_node_structure_enum {
TS_STRING,
TS_COMPLEX,
TS_IDENTIFIER,
- TS_DECL,
+ TS_DECL_COMMON,
+ TS_DECL_EXTRA,
+ TS_FIELD_DECL,
TS_TYPE,
TS_LIST,
TS_VEC,
@@ -2549,7 +2606,9 @@ union tree_node GTY ((ptr_alias (union l
struct tree_string GTY ((tag ("TS_STRING"))) string;
struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
- struct tree_decl GTY ((tag ("TS_DECL"))) decl;
+ struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl;
+ struct tree_decl_extra GTY ((tag ("TS_DECL_EXTRA"))) decl_extra;
+ struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
struct tree_type GTY ((tag ("TS_TYPE"))) type;
struct tree_list GTY ((tag ("TS_LIST"))) list;
struct tree_vec GTY ((tag ("TS_VEC"))) vec;
Index: cp/class.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/class.c,v
retrieving revision 1.717
diff -u -p -r1.717 class.c
--- cp/class.c 8 May 2005 02:17:54 -0000 1.717
+++ cp/class.c 23 May 2005 13:40:18 -0000
@@ -4162,7 +4162,6 @@ create_vtable_ptr (tree t, tree* virtual
tree field;
field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node);
- SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE));
DECL_VIRTUAL_P (field) = 1;
DECL_ARTIFICIAL (field) = 1;
DECL_FIELD_CONTEXT (field) = t;
Index: cp/cp-tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/cp-tree.h,v
retrieving revision 1.1137
diff -u -p -r1.1137 cp-tree.h
--- cp/cp-tree.h 17 May 2005 20:04:58 -0000 1.1137
+++ cp/cp-tree.h 23 May 2005 13:40:18 -0000
@@ -2000,7 +2000,7 @@ struct lang_decl GTY(())
/* In a NAMESPACE_DECL, the list of namespaces which have associated
themselves with this one. */
#define DECL_NAMESPACE_ASSOCIATIONS(NODE) \
- (NAMESPACE_DECL_CHECK (NODE)->decl.saved_tree)
+ (NAMESPACE_DECL_CHECK (NODE)->decl_extra.saved_tree)
/* In a NAMESPACE_DECL, points to the original namespace if this is
a namespace alias. */
@@ -2018,7 +2018,7 @@ struct lang_decl GTY(())
/* In a non-local VAR_DECL with static storage duration, this is the
initialization priority. If this value is zero, the NODE will be
initialized at the DEFAULT_INIT_PRIORITY. */
-#define DECL_INIT_PRIORITY(NODE) (VAR_DECL_CHECK (NODE)->decl.u2.i)
+#define DECL_INIT_PRIORITY(NODE) (VAR_DECL_CHECK (NODE)->decl_extra.u2.i)
/* In a TREE_LIST concatenating using directives, indicate indirect
directives */
Index: cp/decl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/decl.c,v
retrieving revision 1.1396
diff -u -p -r1.1396 decl.c
--- cp/decl.c 19 May 2005 07:37:40 -0000 1.1396
+++ cp/decl.c 23 May 2005 13:40:18 -0000
@@ -1841,12 +1841,15 @@ duplicate_decls (tree newdecl, tree oldd
{
int function_size;
- function_size = sizeof (struct tree_decl);
+ function_size = sizeof (struct tree_decl_common);
memcpy ((char *) olddecl + sizeof (struct tree_common),
(char *) newdecl + sizeof (struct tree_common),
function_size - sizeof (struct tree_common));
+ memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+ (char *) newdecl + sizeof (struct tree_decl_common),
+ sizeof (struct tree_decl_extra) - sizeof (struct tree_decl_common));
if (DECL_TEMPLATE_INSTANTIATION (newdecl))
/* If newdecl is a template instantiation, it is possible that
the following sequence of events has occurred:
@@ -1873,14 +1876,27 @@ duplicate_decls (tree newdecl, tree oldd
DECL_TI_TEMPLATE (newdecl),
olddecl);
}
+ else if (TREE_CODE (olddecl) != FIELD_DECL)
+ {
+ memcpy ((char *) olddecl + sizeof (struct tree_common),
+ (char *) newdecl + sizeof (struct tree_common),
+ sizeof (struct tree_decl_common) - sizeof (struct tree_common));
+ memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+ (char *) newdecl + sizeof (struct tree_decl_common),
+ sizeof (struct tree_decl_extra) - sizeof (struct tree_decl_common)
+ + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
+ }
else
{
memcpy ((char *) olddecl + sizeof (struct tree_common),
(char *) newdecl + sizeof (struct tree_common),
- sizeof (struct tree_decl) - sizeof (struct tree_common)
+ sizeof (struct tree_decl_common) - sizeof (struct tree_common)
+ + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
+ memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+ (char *) newdecl + sizeof (struct tree_decl_common),
+ sizeof (struct tree_field_decl) - sizeof (struct tree_decl_common)
+ TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
}
-
DECL_UID (olddecl) = olddecl_uid;
if (olddecl_friend)
DECL_FRIEND_P (olddecl) = 1;
Index: cp/name-lookup.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/name-lookup.c,v
retrieving revision 1.119
diff -u -p -r1.119 name-lookup.c
--- cp/name-lookup.c 7 May 2005 02:29:34 -0000 1.119
+++ cp/name-lookup.c 23 May 2005 13:40:18 -0000
@@ -2594,7 +2594,7 @@ push_class_level_binding (tree name, tre
&& !DECL_SELF_REFERENCE_P (x))
/* A data member of an anonymous union. */
|| (TREE_CODE (x) == FIELD_DECL
- && DECL_CONTEXT (x) != current_class_type))
+ && DECL_FIELD_CONTEXT (x) != current_class_type))
&& DECL_NAME (x) == constructor_name (current_class_type))
{
tree scope = context_for_name_lookup (x);
Index: java/java-tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/java/java-tree.h,v
retrieving revision 1.230
diff -u -p -r1.230 java-tree.h
--- java/java-tree.h 29 Apr 2005 18:42:48 -0000 1.230
+++ java/java-tree.h 23 May 2005 13:40:19 -0000
@@ -857,14 +857,14 @@ union lang_tree_node
/* In the label of a sub-routine, a chain of the return location labels. */
#define LABEL_RETURN_LABELS(node) \
- (LABEL_DECL_CHECK (LABEL_RETURN_LABEL (node))->decl.result)
+ (LABEL_DECL_CHECK (LABEL_RETURN_LABEL (node))->decl_extra.result)
/* In a LABEL_DECL, the next pending label.
See pending_blocks in expr.c. */
-#define LABEL_PENDING_CHAIN(NODE) (LABEL_DECL_CHECK (NODE)->decl.result)
+#define LABEL_PENDING_CHAIN(NODE) (LABEL_DECL_CHECK (NODE)->decl_extra.result)
/* In a LABEL_DECL, the corresponding bytecode program counter. */
-#define LABEL_PC(NODE) (LABEL_DECL_CHECK (NODE)->decl.u2.i)
+#define LABEL_PC(NODE) (LABEL_DECL_CHECK (NODE)->decl_extra.u2.i)
/* Used during verification to mark the label has "changed". (See JVM Spec). */
#define LABEL_CHANGED(NODE) DECL_LANG_FLAG_6 (LABEL_DECL_CHECK (NODE))
Index: objc/objc-act.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/objc/objc-act.h,v
retrieving revision 1.38
diff -u -p -r1.38 objc-act.h
--- objc/objc-act.h 17 May 2005 20:07:08 -0000 1.38
+++ objc/objc-act.h 23 May 2005 13:40:19 -0000
@@ -46,12 +46,12 @@ enum gimplify_status objc_gimplify_expr
/* KEYWORD_DECL */
#define KEYWORD_KEY_NAME(DECL) ((DECL)->decl.name)
-#define KEYWORD_ARG_NAME(DECL) ((DECL)->decl.arguments)
+#define KEYWORD_ARG_NAME(DECL) ((DECL)->decl_extra.arguments)
/* INSTANCE_METHOD_DECL, CLASS_METHOD_DECL */
#define METHOD_SEL_NAME(DECL) ((DECL)->decl.name)
-#define METHOD_SEL_ARGS(DECL) ((DECL)->decl.arguments)
-#define METHOD_ADD_ARGS(DECL) ((DECL)->decl.result)
+#define METHOD_SEL_ARGS(DECL) ((DECL)->decl_extra.arguments)
+#define METHOD_ADD_ARGS(DECL) ((DECL)->decl_extra.result)
#define METHOD_ADD_ARGS_ELLIPSIS_P(DECL) ((DECL)->decl.lang_flag_0)
#define METHOD_DEFINITION(DECL) ((DECL)->decl.initial)
#define METHOD_ENCODING(DECL) ((DECL)->decl.context)