obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 315 insertions, 0 deletions

diff --git a/libobjc/objc-private/module-abi-8.h b/libobjc/objc-private/module-abi-8.h
new file mode 100644
index 000000000..0c9574bb4
--- /dev/null
+++ b/libobjc/objc-private/module-abi-8.h
@@ -0,0 +1,315 @@
+/* Definitions of Module Structures used by ABI version 8
+   Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2003, 2004, 2005,
+   2007, 2009, 2010 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation; either version 3, or (at your option) any later version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef __objc_private_module_abi_8_INCLUDE_GNU
+#define __objc_private_module_abi_8_INCLUDE_GNU
+
+/* For every class which happens to have statically allocated instances in
+   this module, one OBJC_STATIC_INSTANCES is allocated by the compiler.
+   INSTANCES is NULL terminated and points to all statically allocated
+   instances of this class.  */
+struct objc_static_instances
+{
+  char *class_name;
+#ifdef __cplusplus
+  id instances[1];
+#else
+  id instances[0];
+#endif
+};
+
+/* Whereas a Module (defined further down) is the root (typically) of a file,
+   a Symtab is the root of the class and category definitions within the
+   module.  
+   
+   A Symtab contains a variable length array of pointers to classes and
+   categories  defined in the module.   */
+struct objc_symtab
+{
+  unsigned long sel_ref_cnt;  /* Unused (always set to 0). */
+  struct objc_selector *refs; /* The table of selectors referenced in
+                                 this module.  This is terminated by a
+                                 selector with NULL sel_id and NULL
+                                 sel_types.  Note that we use the type
+                                 'struct objc_selector *' and not
+                                 'SEL' (which is 'const struct
+                                 objc_selector *') because the sel_id
+                                 of these selectors is patched up by
+                                 the runtime when the module is
+                                 loaded.  */
+  unsigned short cls_def_cnt; /* Number of classes compiled (defined)
+                                 in the module. */
+  unsigned short cat_def_cnt; /* Number of categories compiled
+                                 (defined) in the module. */
+  void      *defs[1];         /* Variable array of pointers.
+				 cls_def_cnt of type Class followed by
+				 cat_def_cnt of type Category_t,
+				 followed by a NULL terminated array
+				 of objc_static_instances. */
+};
+
+/* The compiler generates one of these structures for each module that
+   composes the executable (eg main.m).
+ 
+   This data structure is the root of the definition tree for the
+   module.
+ 
+   A collect program runs between ld stages and creates a ObjC ctor
+   array.  That array holds a pointer to each module structure of the
+   executable.  */
+struct objc_module
+{
+  unsigned long version;      /* Version of the Module data
+				 structure.  */
+  unsigned long size;         /* sizeof(Module) according to the
+				 compiler - only used to sanity check
+				 that it matches sizeof(Module)
+				 according to the runtime.  */
+  const char* name;           /* Name of the file used to compile the
+				 module - not set by modern compilers
+				 for security reasons.  */
+  struct objc_symtab *symtab; /* Pointer to the Symtab of the module.
+				 The Symtab holds an array of pointers
+				 to the classes and categories defined
+				 in the module. */
+};
+
+/* The compiler generates one of these structures for a class that has
+   instance variables defined in its specification.  */
+struct objc_ivar
+{
+  const char* ivar_name;  /* Name of the instance variable as entered
+			     in the class definition. */
+  const char* ivar_type;  /* Description of the Ivar's type.  Useful
+			     for debuggers. */
+  int        ivar_offset; /* Byte offset from the base address of the
+			     instance structure to the variable. */
+};
+
+struct objc_ivar_list
+{
+  int   ivar_count;              /* Number of structures (Ivar)
+				    contained in the list.  One
+				    structure per instance variable
+				    defined in the class. */
+  struct objc_ivar ivar_list[1]; /* Variable length structure. */
+};
+
+/* The compiler generates one (or more) of these structures for a
+   class that has methods defined in its specification.
+ 
+   The implementation of a class can be broken into separate pieces in
+   a file and categories can break them across modules. To handle this
+   problem is a singly linked list of methods.  */
+struct objc_method
+{
+  SEL         method_name;  /* This variable is the method's name.
+			       The compiler puts a char* here, and
+			       it's replaced by a real SEL at runtime
+			       when the method is registered.  */
+  const char* method_types; /* Description of the method's parameter
+			       list.  Used when registering the
+			       selector with the runtime.  When that
+			       happens, method_name will contain the
+			       method's parameter list.  */
+  IMP         method_imp;   /* Address of the method in the
+			       executable. */
+};
+
+struct objc_method_list
+{
+  struct objc_method_list*  method_next; /* This variable is used to
+					    link a method list to
+					    another.  It is a singly
+					    linked list. */
+  int            method_count;            /* Number of methods defined
+					     in this structure. */
+  struct objc_method method_list[1];      /* Variable length
+					     structure. */
+};
+
+/* Currently defined in Protocol.m (that definition should go away
+   once we include this file).  Note that a 'struct
+   objc_method_description' as embedded inside a Protocol uses the
+   same trick as a 'struct objc_method': the method_name is a 'char *'
+   according to the compiler, who puts the method name as a string in
+   there.  At runtime, the selectors need to be registered, and the
+   method_name then becomes a SEL.  */
+struct objc_method_description_list
+{
+  int count;
+  struct objc_method_description list[1];
+};
+
+/* Currently defined by objc/objc.h.  */
+/*
+struct objc_protocol {
+  struct objc_class* class_pointer;
+  char *protocol_name;
+  struct objc_protocol_list *protocol_list;
+  struct objc_method_description_list *instance_methods, *class_methods; 
+};
+*/
+
+struct objc_protocol_list
+{
+  struct objc_protocol_list *next;
+  size_t count;
+  Protocol *list[1];
+};
+
+/*
+  The compiler generates one of these structures for each class.  
+
+  This structure is the definition for classes.
+
+  This structure is generated by the compiler in the executable and
+  used by the run-time during normal messaging operations.  Therefore
+  some members change type. The compiler generates "char* const" and
+  places a string in the following member variables: super_class.
+*/
+#ifndef __objc_STRUCT_OBJC_CLASS_defined
+struct objc_class {
+  struct objc_class*  class_pointer;    /* Pointer to the class's meta
+					   class. */
+  struct objc_class*  super_class;      /* Pointer to the super
+					   class. NULL for class
+					   Object. */
+  const char*         name;             /* Name of the class. */
+  long                version;          /* Unknown. */
+  unsigned long       info;             /* Bit mask.  See class masks
+					   defined below. */
+  long                instance_size;    /* Size in bytes of the class.
+					   The sum of the class
+					   definition and all super
+					   class definitions. */
+#ifdef _WIN64
+  /* We pad the structure manually to prevent warning when -Wpadded is
+     used.  The compiler automatically pads the structures that it
+     generates, so this manually padded structure still matches the
+     one generated by the compiler, but if we don't pad manually,
+     -Wpadded detects that padding is being added and generates
+     annoying warnings.  This hack is necessary as on LLP64 targets
+     sizeof (long) isn't equal to sizeof (void *).  */
+  long pad;
+#endif
+  struct objc_ivar_list* ivars;         /* Pointer to a structure that
+					   describes the instance
+					   variables in the class
+					   definition.  NULL indicates
+					   no instance variables.
+					   Does not include super
+					   class variables. */
+  struct objc_method_list*  methods;    /* Linked list of instance
+					   methods defined for the
+					   class. */
+  struct sarray *    dtable;            /* Pointer to instance method
+					   dispatch table. */  
+  struct objc_class* subclass_list;     /* Subclasses */
+  struct objc_class* sibling_class;
+
+  struct objc_protocol_list *protocols; /* Protocols conformed to */
+  void* gc_object_type;
+};
+#endif /* __objc_STRUCT_OBJC_CLASS_defined */
+
+/* This is used to assure consistent access to the info field of 
+   classes.  */
+#ifndef HOST_BITS_PER_LONG
+# define HOST_BITS_PER_LONG  (sizeof(long)*8)
+#endif 
+
+#define __CLS_INFO(cls) ((cls)->info)
+#define __CLS_ISINFO(cls, mask) ((__CLS_INFO(cls)&mask)==mask)
+#define __CLS_SETINFO(cls, mask) (__CLS_INFO(cls) |= mask)
+#define __CLS_SETNOTINFO(cls, mask) (__CLS_INFO(cls) &= ~mask)
+
+/* The structure is of type MetaClass */
+#define _CLS_META 0x2L
+#define CLS_ISMETA(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_META))
+
+/* The structure is of type Class */
+#define _CLS_CLASS 0x1L
+#define CLS_ISCLASS(cls) ((cls)&&__CLS_ISINFO(cls, _CLS_CLASS))
+
+/* The class is initialized within the runtime.  This means that it
+   has had correct super and sublinks assigned.  */
+#define _CLS_RESOLV 0x8L
+#define CLS_ISRESOLV(cls) __CLS_ISINFO(cls, _CLS_RESOLV)
+#define CLS_SETRESOLV(cls) __CLS_SETINFO(cls, _CLS_RESOLV)
+
+/* The class has been send a +initialize message or a such is not 
+   defined for this class.  */
+#define _CLS_INITIALIZED 0x04L
+#define CLS_ISINITIALIZED(cls) __CLS_ISINFO(cls, _CLS_INITIALIZED)
+#define CLS_SETINITIALIZED(cls) __CLS_SETINFO(cls, _CLS_INITIALIZED)
+
+/* The class is being constructed; it has been allocated using
+   objc_allocateClassPair(), but has not been registered yet by using
+   objc_registerClassPair().  This means it is possible to freely add
+   instance variables to the class, but it can't be used for anything
+   yet.  */
+#define _CLS_IN_CONSTRUCTION 0x10L
+#define CLS_IS_IN_CONSTRUCTION(cls) __CLS_ISINFO(cls, _CLS_IN_CONSTRUCTION)
+#define CLS_SET_IN_CONSTRUCTION(cls) __CLS_SETINFO(cls, _CLS_IN_CONSTRUCTION)
+#define CLS_SET_NOT_IN_CONSTRUCTION(cls) __CLS_SETNOTINFO(cls, _CLS_IN_CONSTRUCTION)
+
+/* The class number of this class.  This must be the same for both the
+   class and its meta class object.  */
+#define CLS_GETNUMBER(cls) (__CLS_INFO(cls) >> (HOST_BITS_PER_LONG/2))
+#define CLS_SETNUMBER(cls, num) \
+  ({ (cls)->info <<= (HOST_BITS_PER_LONG/2); \
+     (cls)->info >>= (HOST_BITS_PER_LONG/2); \
+     __CLS_SETINFO(cls, (((unsigned long)num) << (HOST_BITS_PER_LONG/2))); })
+
+
+/* The compiler generates one of these structures for each category.
+   A class may have many categories and contain both instance and
+   factory methods.  */
+struct objc_category
+{
+  const char*   category_name;                /* Name of the category.
+						 Name contained in the
+						 () of the category
+						 definition.  */
+  const char*   class_name;                   /* Name of the class to
+						 which the category
+						 belongs.  */
+  struct objc_method_list  *instance_methods; /* Linked list of
+						 instance methods
+						 defined in the
+						 category. NULL
+						 indicates no instance
+						 methods defined.  */
+  struct objc_method_list *class_methods;     /* Linked list of
+						 factory methods
+						 defined in the
+						 category.  NULL
+						 indicates no class
+						 methods defined.  */
+  struct objc_protocol_list *protocols;	      /* List of Protocols
+					         conformed to.  */
+};
+
+#endif /* __objc_private_module_abi_8_INCLUDE_GNU */