This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH]: Move FIELD_DECL into it's own structure


This moves FIELD_DECL into it's own structure, as well as unsharing
previously unshared fields shared between FIELD_DECL and other *_DECL's.

FIELD_DECL's now have their own struct, struct tree_field_decl, derived
from struct tree_decl_common.

tree_decl_common is now the common base for _DECL nodes, and will
decrease in size as more things get split out and unshared (IE i don't
expect it to stay the size listed below forever, as some things don't
need even those fields).  This means that if we decide one of the DECL's
(CONST_DECL maybe) can't have attributes, we'll make a substructure
shared by everything but CONST_DECL that contains the attributes tree).

I gave up trying to split out DECL_CONTEXT for the moment, the C++ FE
and Java FE use it all over the place on FIELD_DECL's, and i stopped
after changing about 20 users :)

All things not in common with FIELD_DECL and all other DECL's was moved
to tree_decl_extra.  This is just a temporary storage place as
structures get moved around and split. 


I've moved the FIELD_DECL macros to right before the structure, in line
with the placement of the rest of the file macros.

Sizes:

Before (32 bit machine)
(gdb) p sizeof (struct tree_decl)
$1 = 108

Now (32 bit machine):
(gdb) p sizeof (struct tree_decl_common)
$1 = 72
(gdb) p sizeof (struct tree_decl_extra)
$2 = 108
(gdb) p sizeof (struct tree_field_decl)
$3 = 96


IE we save 12 bytes per FIELD_DECL, or ~12%

Before (64 bit machine)
(gdb) p sizeof (struct tree_decl)
$1 = 208


Now (64 bit machine):

(gdb) p sizeof (struct tree_decl_common)
$1 = 144
(gdb) p sizeof (struct tree_field_decl)
$2 = 192
(gdb) p sizeof (struct tree_decl_extra)
$3 = 208

We save 16 bytes per FIELD_DECL, or ~12%

(we save 64 bytes for the current minimal decl, though again, nothing
uses it yet)

A tree_class_except macro was added to be able to check that something
is any member of a tree class *except* some member.  This is used to
make sure nothing is still trying to access the moved fields in a
FIELD_DECL.

Once the next structure is split, checking other macros may be
necessary.
The same is true of various checks added for != FIELD_DECL.

This patch was bootstrapped and regtested on i686-pc-linux-gnu with all
languages but Ada (which i don't expect to break) an Objective C++
(which may require small changes).


The places int he changelog marked "<x> would abort if used" mean that
the check is not necessary because nothing could set it in the first
place because of the NOT_FIELD_DECL_CHECK.  IE it's not just guessing :)

DECL_NON_ADDR_CONST_P was completely removed because nothing ever set
it.

My current plan is to split PARM_DECL or CONST_DECL next, because it
looks like it uses the least fields other than the ones in
tree_decl_common.

Okay for mainline after the slush?


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.
	(staticp): DECL_NON_ADDR_CONST_P no longer exists.
	(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.
	* varasm.c (initializer_constant_valid_p): DECL_NON_ADDR_CONST_P
	went away.

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	22 May 2005 23:40:11 -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	22 May 2005 23:40:11 -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	22 May 2005 23:40:13 -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	22 May 2005 23: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	22 May 2005 23:40:18 -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	22 May 2005 23:40:18 -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	22 May 2005 23:40:18 -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	22 May 2005 23:40:20 -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++;
 
@@ -1614,7 +1620,6 @@ staticp (tree arg)
     case VAR_DECL:
       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
 	      && ! DECL_THREAD_LOCAL (arg)
-	      && ! DECL_NON_ADDR_CONST_P (arg)
 	      ? arg : NULL);
 
     case CONST_DECL:
@@ -1775,9 +1780,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 +2806,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 +5477,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	22 May 2005 23:40:21 -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,31 @@ 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)
+#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 +2265,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 +2287,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 +2312,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 +2322,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 +2337,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 +2365,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 +2380,137 @@ 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;
 
   /* 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 +2571,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 +2601,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: varasm.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/varasm.c,v
retrieving revision 1.511
diff -u -p -r1.511 varasm.c
--- varasm.c	17 May 2005 06:34:48 -0000	1.511
+++ varasm.c	22 May 2005 23:40:22 -0000
@@ -3621,8 +3621,7 @@ initializer_constant_valid_p (tree value
       /* Taking the address of a nested function involves a trampoline.  */
       if (value
 	  && TREE_CODE (value) == FUNCTION_DECL
-	  && ((decl_function_context (value) && !DECL_NO_STATIC_CHAIN (value))
-	      || DECL_NON_ADDR_CONST_P (value)))
+	  && ((decl_function_context (value) && !DECL_NO_STATIC_CHAIN (value))))
 	return NULL_TREE;
       return value;
 
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	22 May 2005 23:40:24 -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	22 May 2005 23:40:26 -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	22 May 2005 23:40:28 -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	22 May 2005 23:40:29 -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	22 May 2005 23:40:30 -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	22 May 2005 23:40:30 -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)

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]