From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; 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. --- libobjc/objc-private/module-abi-8.h | 315 ++++++++++++++++++++++++++++++++++++ 1 file changed, 315 insertions(+) create mode 100644 libobjc/objc-private/module-abi-8.h (limited to 'libobjc/objc-private/module-abi-8.h') 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 +. */ + +#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 */ -- cgit v1.2.3