summaryrefslogtreecommitdiff
path: root/libobjc/objc-private/module-abi-8.h
diff options
context:
space:
mode:
Diffstat (limited to 'libobjc/objc-private/module-abi-8.h')
-rw-r--r--libobjc/objc-private/module-abi-8.h315
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 */