diff --git a/GNUmakefile b/GNUmakefile index f6eb4aa..19c77f8 100644 --- a/GNUmakefile +++ b/GNUmakefile @@ -22,7 +22,7 @@ libobjc_C_FILES = \ category_loader.c\ class_table.c\ dtable.c\ - encoding.c\ + encoding2.c\ hash_table.c\ exception.c\ hooks.c\ diff --git a/encoding.c b/encoding.c deleted file mode 100644 index bcab04f..0000000 --- a/encoding.c +++ /dev/null @@ -1,1082 +0,0 @@ -/* Encoding of types for Objective C. - Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000, 2002, 2004, 2009 - Free Software Foundation, Inc. - Contributed by Kresten Krab Thorup - Bitfield support by Ovidiu Predescu - -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 -. */ - -/* FIXME: This file has no business including tm.h. */ - -#include "objc/objc-api.h" -#include "objc/encoding.h" -#include - -#undef MAX -#define MAX(X, Y) \ - ({ __typeof (X) __x = (X), __y = (Y); \ - (__x > __y ? __x : __y); }) - -#undef MIN -#define MIN(X, Y) \ - ({ __typeof (X) __x = (X), __y = (Y); \ - (__x < __y ? __x : __y); }) - -#undef ROUND -#define ROUND(V, A) \ - ({ __typeof (V) __v = (V); __typeof (A) __a = (A); \ - __a * ((__v+__a - 1)/__a); }) - - -/* Various hacks for objc_layout_record. These are used by the target - macros. */ - -#define TREE_CODE(TYPE) *(TYPE) -#define TREE_TYPE(TREE) (TREE) - -#define RECORD_TYPE _C_STRUCT_B -#define UNION_TYPE _C_UNION_B -#define QUAL_UNION_TYPE _C_UNION_B -#define ARRAY_TYPE _C_ARY_B - -#define REAL_TYPE _C_DBL - -#define VECTOR_TYPE _C_VECTOR - -#define TYPE_FIELDS(TYPE) ({const char *_field = (TYPE)+1; \ - while (*_field != _C_STRUCT_E && *_field != _C_STRUCT_B \ - && *_field != _C_UNION_B && *_field++ != '=') \ - /* do nothing */; \ - _field;}) - -#define DECL_MODE(TYPE) *(TYPE) -#define TYPE_MODE(TYPE) *(TYPE) - -#define DFmode _C_DBL - -#define strip_array_types(TYPE) ({const char *_field = (TYPE); \ - while (*_field == _C_ARY_B)\ - {\ - while (isdigit ((unsigned char)*++_field))\ - ;\ - }\ - _field;}) - -/* Some ports (eg ARM) allow the structure size boundary to be - selected at compile-time. We override the normal definition with - one that has a constant value for this compilation. */ -#ifndef BITS_PER_UNIT -#define BITS_PER_UNIT 8 -#endif -#undef STRUCTURE_SIZE_BOUNDARY -#define STRUCTURE_SIZE_BOUNDARY (BITS_PER_UNIT * sizeof (struct{char a;})) - -/* Some ROUND_TYPE_ALIGN macros use TARGET_foo, and consequently - target_flags. Define a dummy entry here to so we don't die. - We have to rename it because target_flags may already have been - declared extern. */ -#define target_flags not_target_flags -static int __attribute__ ((__unused__)) not_target_flags = 0; - -/* Some ROUND_TYPE_ALIGN use ALTIVEC_VECTOR_MODE (rs6000 darwin). - Define a dummy ALTIVEC_VECTOR_MODE so it will not die. */ -#undef ALTIVEC_VECTOR_MODE -#define ALTIVEC_VECTOR_MODE(MODE) (0) - - -/* FIXME: while this file has no business including tm.h, this - definitely has no business defining this macro but it - is only way around without really rewritting this file, - should look after the branch of 3.4 to fix this. */ -#define rs6000_special_round_type_align(STRUCT, COMPUTED, SPECIFIED) \ - ({ const char *_fields = TYPE_FIELDS (STRUCT); \ - ((_fields != 0 \ - && TYPE_MODE (strip_array_types (TREE_TYPE (_fields))) == DFmode) \ - ? MAX (MAX (COMPUTED, SPECIFIED), 64) \ - : MAX (COMPUTED, SPECIFIED));}) -/* FIXME: The word 'fixme' is insufficient to explain the wrong-ness - of this next macro definition. */ -#define darwin_rs6000_special_round_type_align(S,C,S2) \ - rs6000_special_round_type_align(S,C,S2) - -/* - return the size of an object specified by type -*/ - -int -objc_sizeof_type (const char *type) -{ - /* Skip the variable name if any */ - if (*type == '"') - { - for (type++; *type++ != '"';) - /* do nothing */; - } - - switch (*type) { - case _C_BOOL: - return sizeof (_Bool); - break; - - case _C_ID: - return sizeof (id); - break; - - case _C_CLASS: - return sizeof (Class); - break; - - case _C_SEL: - return sizeof (SEL); - break; - - case _C_CHR: - return sizeof (char); - break; - - case _C_UCHR: - return sizeof (unsigned char); - break; - - case _C_SHT: - return sizeof (short); - break; - - case _C_USHT: - return sizeof (unsigned short); - break; - - case _C_INT: - return sizeof (int); - break; - - case _C_UINT: - return sizeof (unsigned int); - break; - - case _C_LNG: - return sizeof (long); - break; - - case _C_ULNG: - return sizeof (unsigned long); - break; - - case _C_LNG_LNG: - return sizeof (long long); - break; - - case _C_ULNG_LNG: - return sizeof (unsigned long long); - break; - - case _C_FLT: - return sizeof (float); - break; - - case _C_DBL: - return sizeof (double); - break; - - case _C_VOID: - return sizeof (void); - break; - - case _C_PTR: - case _C_ATOM: - case _C_CHARPTR: - return sizeof (char *); - break; - - case _C_ARY_B: - { - int len = atoi (type + 1); - while (isdigit ((unsigned char)*++type)) - ; - return len * objc_aligned_size (type); - } - break; - - case _C_BFLD: - { - /* The new encoding of bitfields is: b 'position' 'type' 'size' */ - int position, size; - int startByte, endByte; - - position = atoi (type + 1); - while (isdigit ((unsigned char)*++type)) - ; - size = atoi (type + 1); - - startByte = position / BITS_PER_UNIT; - endByte = (position + size) / BITS_PER_UNIT; - return endByte - startByte; - } - - case _C_UNION_B: - case _C_STRUCT_B: - { - struct objc_struct_layout layout; - unsigned int size; - - objc_layout_structure (type, &layout); - while (objc_layout_structure_next_member (&layout)) - /* do nothing */ ; - objc_layout_finish_structure (&layout, &size, NULL); - - return size; - } - - case _C_COMPLEX: - { - type++; /* Skip after the 'j'. */ - switch (*type) - { - case _C_CHR: - return sizeof (_Complex char); - break; - - case _C_UCHR: - return sizeof (_Complex unsigned char); - break; - - case _C_SHT: - return sizeof (_Complex short); - break; - - case _C_USHT: - return sizeof (_Complex unsigned short); - break; - - case _C_INT: - return sizeof (_Complex int); - break; - - case _C_UINT: - return sizeof (_Complex unsigned int); - break; - - case _C_LNG: - return sizeof (_Complex long); - break; - - case _C_ULNG: - return sizeof (_Complex unsigned long); - break; - - case _C_LNG_LNG: - return sizeof (_Complex long long); - break; - - case _C_ULNG_LNG: - return sizeof (_Complex unsigned long long); - break; - - case _C_FLT: - return sizeof (_Complex float); - break; - - case _C_DBL: - return sizeof (_Complex double); - break; - - default: - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown complex type %s\n", - type); - return 0; - } - } - } - - default: - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type); - return 0; - } - } -} - - -/* - Return the alignment of an object specified by type -*/ - -int -objc_alignof_type (const char *type) -{ - /* Skip the variable name if any */ - if (*type == '"') - { - for (type++; *type++ != '"';) - /* do nothing */; - } - switch (*type) { - case _C_BOOL: - return __alignof__ (_Bool); - break; - - case _C_ID: - return __alignof__ (id); - break; - - case _C_CLASS: - return __alignof__ (Class); - break; - - case _C_SEL: - return __alignof__ (SEL); - break; - - case _C_CHR: - return __alignof__ (char); - break; - - case _C_UCHR: - return __alignof__ (unsigned char); - break; - - case _C_SHT: - return __alignof__ (short); - break; - - case _C_USHT: - return __alignof__ (unsigned short); - break; - - case _C_INT: - return __alignof__ (int); - break; - - case _C_UINT: - return __alignof__ (unsigned int); - break; - - case _C_LNG: - return __alignof__ (long); - break; - - case _C_ULNG: - return __alignof__ (unsigned long); - break; - - case _C_LNG_LNG: - return __alignof__ (long long); - break; - - case _C_ULNG_LNG: - return __alignof__ (unsigned long long); - break; - - case _C_FLT: - return __alignof__ (float); - break; - - case _C_DBL: - return __alignof__ (double); - break; - - case _C_PTR: - case _C_ATOM: - case _C_CHARPTR: - return __alignof__ (char *); - break; - - case _C_ARY_B: - while (isdigit ((unsigned char)*++type)) - /* do nothing */; - return objc_alignof_type (type); - - case _C_STRUCT_B: - case _C_UNION_B: - { - struct objc_struct_layout layout; - unsigned int align; - - objc_layout_structure (type, &layout); - while (objc_layout_structure_next_member (&layout)) - /* do nothing */; - objc_layout_finish_structure (&layout, NULL, &align); - - return align; - } - - - case _C_COMPLEX: - { - type++; /* Skip after the 'j'. */ - switch (*type) - { - case _C_CHR: - return __alignof__ (_Complex char); - break; - - case _C_UCHR: - return __alignof__ (_Complex unsigned char); - break; - - case _C_SHT: - return __alignof__ (_Complex short); - break; - - case _C_USHT: - return __alignof__ (_Complex unsigned short); - break; - - case _C_INT: - return __alignof__ (_Complex int); - break; - - case _C_UINT: - return __alignof__ (_Complex unsigned int); - break; - - case _C_LNG: - return __alignof__ (_Complex long); - break; - - case _C_ULNG: - return __alignof__ (_Complex unsigned long); - break; - - case _C_LNG_LNG: - return __alignof__ (_Complex long long); - break; - - case _C_ULNG_LNG: - return __alignof__ (_Complex unsigned long long); - break; - - case _C_FLT: - return __alignof__ (_Complex float); - break; - - case _C_DBL: - return __alignof__ (_Complex double); - break; - - default: - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown complex type %s\n", - type); - return 0; - } - } - } - - default: - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type); - return 0; - } - } -} - -/* - The aligned size if the size rounded up to the nearest alignment. -*/ - -int -objc_aligned_size (const char *type) -{ - int size, align; - - /* Skip the variable name */ - if (*type == '"') - { - for (type++; *type++ != '"';) - /* do nothing */; - } - - size = objc_sizeof_type (type); - align = objc_alignof_type (type); - - return ROUND (size, align); -} - -/* - The size rounded up to the nearest integral of the wordsize, taken - to be the size of a void *. -*/ - -int -objc_promoted_size (const char *type) -{ - int size, wordsize; - - /* Skip the variable name */ - if (*type == '"') - { - for (type++; *type++ != '"';) - /* do nothing */; - } - - size = objc_sizeof_type (type); - wordsize = sizeof (void *); - - return ROUND (size, wordsize); -} - -/* - Skip type qualifiers. These may eventually precede typespecs - occurring in method prototype encodings. -*/ - -inline const char * -objc_skip_type_qualifiers (const char *type) -{ - while (*type == _C_CONST - || *type == _C_IN - || *type == _C_INOUT - || *type == _C_OUT - || *type == _C_BYCOPY - || *type == _C_BYREF - || *type == _C_ONEWAY - || *type == _C_GCINVISIBLE) - { - type += 1; - } - return type; -} - - -/* - Skip one typespec element. If the typespec is prepended by type - qualifiers, these are skipped as well. -*/ - -const char * -objc_skip_typespec (const char *type) -{ - /* Skip the variable name if any */ - if (*type == '"') - { - for (type++; *type++ != '"';) - /* do nothing */; - } - - type = objc_skip_type_qualifiers (type); - - switch (*type) { - - case _C_ID: - /* An id may be annotated by the actual type if it is known - with the @"ClassName" syntax */ - - if (*++type != '"') - return type; - else - { - while (*++type != '"') - /* do nothing */; - return type + 1; - } - - /* The following are one character type codes */ - case _C_CLASS: - case _C_SEL: - case _C_CHR: - case _C_UCHR: - case _C_CHARPTR: - case _C_ATOM: - case _C_SHT: - case _C_USHT: - case _C_INT: - case _C_UINT: - case _C_LNG: - case _C_BOOL: - case _C_ULNG: - case _C_LNG_LNG: - case _C_ULNG_LNG: - case _C_FLT: - case _C_DBL: - case _C_VOID: - case _C_UNDEF: - return ++type; - break; - - case _C_COMPLEX: - return type + 2; - break; - - case _C_ARY_B: - /* skip digits, typespec and closing ']' */ - - while (isdigit ((unsigned char)*++type)) - ; - type = objc_skip_typespec (type); - if (*type == _C_ARY_E) - return ++type; - else - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "bad array type %s\n", type); - return 0; - } - - case _C_BFLD: - /* The new encoding of bitfields is: b 'position' 'type' 'size' */ - while (isdigit ((unsigned char)*++type)) - ; /* skip position */ - while (isdigit ((unsigned char)*++type)) - ; /* skip type and size */ - return type; - - case _C_STRUCT_B: - /* skip name, and elements until closing '}' */ - - while (*type != _C_STRUCT_E && *type++ != '=') - ; - while (*type != _C_STRUCT_E) - { - type = objc_skip_typespec (type); - } - return ++type; - - case _C_UNION_B: - /* skip name, and elements until closing ')' */ - - while (*type != _C_UNION_E && *type++ != '=') - ; - while (*type != _C_UNION_E) - { - type = objc_skip_typespec (type); - } - return ++type; - - case _C_PTR: - /* Just skip the following typespec */ - - return objc_skip_typespec (++type); - - default: - { - objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type); - return 0; - } - } -} - -/* - Skip an offset as part of a method encoding. This is prepended by a - '+' if the argument is passed in registers. - For historical reasons this is buggy and actually skips an extra byte - whether there is an offset or not. -*/ -inline const char * -objc_skip_offset (const char *type) -{ - if (*type == '+') - type++; - while (isdigit ((unsigned char) *++type)) - ; - return type; -} - -/* - Skip an argument specification of a method encoding. -*/ -const char * -objc_skip_argspec (const char *type) -{ - type = objc_skip_typespec (type); - type = objc_skip_offset (type); - return type; -} - -/* - Return the number of arguments that the method MTH expects. - Note that all methods need two implicit arguments `self' and - `_cmd'. -*/ -int -method_get_number_of_arguments (struct objc_method *mth) -{ - int i = 0; - const char *type = mth->method_types; - while (*type) - { - type = objc_skip_argspec (type); - i += 1; - } - return i - 1; -} - -/* - Return the size of the argument block needed on the stack to invoke - the method MTH. This may be zero, if all arguments are passed in - registers. -*/ - -int -method_get_sizeof_arguments (struct objc_method *mth) -{ - const char *type = objc_skip_typespec (mth->method_types); - return atoi (type); -} - -/* - Return a pointer to the next argument of ARGFRAME. type points to - the last argument. Typical use of this look like: - - { - char *datum, *type; - for (datum = method_get_first_argument (method, argframe, &type); - datum; datum = method_get_next_argument (argframe, &type)) - { - unsigned flags = objc_get_type_qualifiers (type); - type = objc_skip_type_qualifiers (type); - if (*type != _C_PTR) - [portal encodeData: datum ofType: type]; - else - { - if ((flags & _F_IN) == _F_IN) - [portal encodeData: *(char **) datum ofType: ++type]; - } - } - } -*/ - -char * -method_get_next_argument (arglist_t argframe, const char **type) -{ - const char *t = objc_skip_argspec (*type); - - if (*t == '\0') - return 0; - - *type = t; - t = objc_skip_typespec (t); - - if (*t == '+') - return argframe->arg_regs + atoi (++t); - else - return argframe->arg_ptr + atoi (t); -} - -/* - Return a pointer to the value of the first argument of the method - described in M with the given argumentframe ARGFRAME. The type - is returned in TYPE. type must be passed to successive calls of - method_get_next_argument. -*/ -char * -method_get_first_argument (struct objc_method *m, - arglist_t argframe, - const char **type) -{ - *type = m->method_types; - return method_get_next_argument (argframe, type); -} - -/* - Return a pointer to the ARGth argument of the method - M from the frame ARGFRAME. The type of the argument - is returned in the value-result argument TYPE -*/ - -char * -method_get_nth_argument (struct objc_method *m, - arglist_t argframe, int arg, - const char **type) -{ - const char *t = objc_skip_argspec (m->method_types); - - if (arg > method_get_number_of_arguments (m)) - return 0; - - while (arg--) - t = objc_skip_argspec (t); - - *type = t; - t = objc_skip_typespec (t); - - if (*t == '+') - return argframe->arg_regs + atoi (++t); - else - return argframe->arg_ptr + atoi (t); -} - -unsigned -objc_get_type_qualifiers (const char *type) -{ - unsigned res = 0; - BOOL flag = YES; - - while (flag) - switch (*type++) - { - case _C_CONST: res |= _F_CONST; break; - case _C_IN: res |= _F_IN; break; - case _C_INOUT: res |= _F_INOUT; break; - case _C_OUT: res |= _F_OUT; break; - case _C_BYCOPY: res |= _F_BYCOPY; break; - case _C_BYREF: res |= _F_BYREF; break; - case _C_ONEWAY: res |= _F_ONEWAY; break; - case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break; - default: flag = NO; - } - - return res; -} - - -/* The following three functions can be used to determine how a - structure is laid out by the compiler. For example: - - struct objc_struct_layout layout; - int i; - - objc_layout_structure (type, &layout); - while (objc_layout_structure_next_member (&layout)) - { - int position, align; - const char *type; - - objc_layout_structure_get_info (&layout, &position, &align, &type); - printf ("element %d has offset %d, alignment %d\n", - i++, position, align); - } - - These functions are used by objc_sizeof_type and objc_alignof_type - functions to compute the size and alignment of structures. The - previous method of computing the size and alignment of a structure - was not working on some architectures, particulary on AIX, and in - the presence of bitfields inside the structure. */ -void -objc_layout_structure (const char *type, - struct objc_struct_layout *layout) -{ - const char *ntype; - - if (*type != _C_UNION_B && *type != _C_STRUCT_B) - { - objc_error (nil, OBJC_ERR_BAD_TYPE, - "record (or union) type expected in objc_layout_structure, got %s\n", - type); - } - - type ++; - layout->original_type = type; - - /* Skip "=" if any. Avoid embedded structures and unions. */ - ntype = type; - while (*ntype != _C_STRUCT_E && *ntype != _C_STRUCT_B && *ntype != _C_UNION_B - && *ntype++ != '=') - /* do nothing */; - - /* If there's a "=", ntype - 1 points to '='; skip the the name */ - if (*(ntype - 1) == '=') - type = ntype; - - layout->type = type; - layout->prev_type = NULL; - layout->record_size = 0; - layout->record_align = BITS_PER_UNIT; - - layout->record_align = MAX (layout->record_align, STRUCTURE_SIZE_BOUNDARY); -} - - -BOOL -objc_layout_structure_next_member (struct objc_struct_layout *layout) -{ - register int desired_align = 0; - - /* The following are used only if the field is a bitfield */ - register const char *bfld_type = 0; - register int bfld_type_size, bfld_type_align = 0, bfld_field_size = 0; - - /* The current type without the type qualifiers */ - const char *type; - BOOL unionp = layout->original_type[-1] == _C_UNION_B; - - /* Add the size of the previous field to the size of the record. */ - if (layout->prev_type) - { - type = objc_skip_type_qualifiers (layout->prev_type); - if (unionp) - layout->record_size = MAX (layout->record_size, - objc_sizeof_type (type) * BITS_PER_UNIT); - - else if (*type != _C_BFLD) - layout->record_size += objc_sizeof_type (type) * BITS_PER_UNIT; - else { - /* Get the bitfield's type */ - for (bfld_type = type + 1; - isdigit ((unsigned char)*bfld_type); - bfld_type++) - /* do nothing */; - - bfld_type_size = objc_sizeof_type (bfld_type) * BITS_PER_UNIT; - bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT; - bfld_field_size = atoi (objc_skip_typespec (bfld_type)); - layout->record_size += bfld_field_size; - } - } - - if ((unionp && *layout->type == _C_UNION_E) - || (!unionp && *layout->type == _C_STRUCT_E)) - return NO; - - /* Skip the variable name if any */ - if (*layout->type == '"') - { - for (layout->type++; *layout->type++ != '"';) - /* do nothing */; - } - - type = objc_skip_type_qualifiers (layout->type); - - if (*type != _C_BFLD) - desired_align = objc_alignof_type (type) * BITS_PER_UNIT; - else - { - desired_align = 1; - /* Skip the bitfield's offset */ - for (bfld_type = type + 1; - isdigit ((unsigned char) *bfld_type); - bfld_type++) - /* do nothing */; - - bfld_type_size = objc_sizeof_type (bfld_type) * BITS_PER_UNIT; - bfld_type_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT; - bfld_field_size = atoi (objc_skip_typespec (bfld_type)); - } - -#ifdef BIGGEST_FIELD_ALIGNMENT - desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT); -#endif -#ifdef ADJUST_FIELD_ALIGN - desired_align = ADJUST_FIELD_ALIGN (type, desired_align); -#endif - - /* Record must have at least as much alignment as any field. - Otherwise, the alignment of the field within the record - is meaningless. */ -#ifndef PCC_BITFIELD_TYPE_MATTERS - layout->record_align = MAX (layout->record_align, desired_align); -#else /* PCC_BITFIELD_TYPE_MATTERS */ - if (*type == _C_BFLD) - { - /* For these machines, a zero-length field does not - affect the alignment of the structure as a whole. - It does, however, affect the alignment of the next field - within the structure. */ - if (bfld_field_size) - layout->record_align = MAX (layout->record_align, desired_align); - else - desired_align = objc_alignof_type (bfld_type) * BITS_PER_UNIT; - - /* A named bit field of declared type `int' - forces the entire structure to have `int' alignment. - Q1: How is encoded this thing and how to check for it? - Q2: How to determine maximum_field_alignment at runtime? */ - -/* if (DECL_NAME (field) != 0) */ - { - int type_align = bfld_type_align; -#if 0 - if (maximum_field_alignment != 0) - type_align = MIN (type_align, maximum_field_alignment); - else if (DECL_PACKED (field)) - type_align = MIN (type_align, BITS_PER_UNIT); -#endif - - layout->record_align = MAX (layout->record_align, type_align); - } - } - else - layout->record_align = MAX (layout->record_align, desired_align); -#endif /* PCC_BITFIELD_TYPE_MATTERS */ - - /* Does this field automatically have alignment it needs - by virtue of the fields that precede it and the record's - own alignment? */ - - if (*type == _C_BFLD) - layout->record_size = atoi (type + 1); - else if (layout->record_size % desired_align != 0) - { - /* No, we need to skip space before this field. - Bump the cumulative size to multiple of field alignment. */ - layout->record_size = ROUND (layout->record_size, desired_align); - } - - /* Jump to the next field in record. */ - - layout->prev_type = layout->type; - layout->type = objc_skip_typespec (layout->type); /* skip component */ - - return YES; -} - - -void objc_layout_finish_structure (struct objc_struct_layout *layout, - unsigned int *size, - unsigned int *align) -{ - BOOL unionp = layout->original_type[-1] == _C_UNION_B; - if (layout->type - && ((!unionp && *layout->type == _C_STRUCT_E) - || (unionp && *layout->type == _C_UNION_E))) - { - /* Work out the alignment of the record as one expression and store - in the record type. Round it up to a multiple of the record's - alignment. */ -#if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__) - layout->record_align = ROUND_TYPE_ALIGN (layout->original_type-1, - 1, - layout->record_align); -#else - layout->record_align = MAX (1, layout->record_align); -#endif - -#ifdef ROUND_TYPE_SIZE - layout->record_size = ROUND_TYPE_SIZE (layout->original_type, - layout->record_size, - layout->record_align); -#else - /* Round the size up to be a multiple of the required alignment */ - layout->record_size = ROUND (layout->record_size, layout->record_align); -#endif - - layout->type = NULL; - } - if (size) - *size = layout->record_size / BITS_PER_UNIT; - if (align) - *align = layout->record_align / BITS_PER_UNIT; -} - - -void objc_layout_structure_get_info (struct objc_struct_layout *layout, - unsigned int *offset, - unsigned int *align, - const char **type) -{ - if (offset) - *offset = layout->record_size / BITS_PER_UNIT; - if (align) - *align = layout->record_align / BITS_PER_UNIT; - if (type) - *type = layout->prev_type; -} diff --git a/encoding2.c b/encoding2.c new file mode 100644 index 0000000..250b634 --- /dev/null +++ b/encoding2.c @@ -0,0 +1,563 @@ +#include +#include +#include +#include + +#include "objc/runtime.h" +#include "method_list.h" + +size_t objc_alignof_type (const char *type); + +// It would be so nice if this works, but in fact it returns nonsense: +//#define alignof(x) __alignof__(x) +// +#define alignof(type) __builtin_offsetof(struct { const char c; type member; }, member) + +const char *objc_skip_type_qualifiers (const char *type) +{ + static const char *type_qualifiers = "rnNoORV"; + while('\0' != *type && strchr(type_qualifiers, *type)) + { + type++; + } + return type; +} + +static const char *sizeof_type(const char *type, size_t *size); + +const char *objc_skip_typespec(const char *type) +{ + size_t ignored = 0; + return sizeof_type(type, &ignored); +} + +const char *objc_skip_argspec(const char *type) +{ + type = objc_skip_typespec(type); + while(isdigit(*type)) { type++; } + return type; +} + +static size_t lengthOfTypeEncoding(const char *types) +{ + const char *end = objc_skip_typespec(types); + size_t length = end - types + 1; + return length; +} + +static char *copyTypeEncoding(const char *types) +{ + size_t length = lengthOfTypeEncoding(types); + char *copy = malloc(length + 1); + memcpy(copy, types, length); + copy[length] = '\0'; + return copy; +} + +static const char * findParameterStart(const char *types, unsigned int index) +{ + for (unsigned int i=0 ; iv2 ? v : v2; +} + +static const char *sizeof_union_field(const char *type, size_t *size); + +static const char *sizeof_type(const char *type, size_t *size) +{ + type = objc_skip_type_qualifiers(type); + switch (*type) + { + // For all primitive types, we round up the current size to the + // required alignment of the type, then add the size +#define APPLY_TYPE(typeName, name, capitalizedName, encodingChar) \ + case encodingChar:\ + {\ + round_up(size, (alignof(typeName) * 8));\ + *size += (sizeof(typeName) * 8);\ + return type + 1;\ + } +#define NON_INTEGER_TYPES 1 +#include "type_encoding_cases.h" + case '?': + case 'v': return type+1; + case 'j': + { + type++; + switch (*type) + { +#define APPLY_TYPE(typeName, name, capitalizedName, encodingChar) \ + case encodingChar:\ + {\ + round_up(size, (alignof(_Complex typeName) * 8));\ + *size += (sizeof(_Complex typeName) * 8);\ + return type + 1;\ + } +#include "type_encoding_cases.h" + } + } + case '{': + { + const char *t = type; + parse_struct(&t, (type_parser)sizeof_type, size); + size_t align = objc_alignof_type(type); + round_up(size, align * 8); + return t; + } + case '[': + { + const char *t = type; + int element_size = 0; + // FIXME: aligned size + int element_count = parse_array(&t, (type_parser)sizeof_type, &element_size); + (*size) += element_size * element_count; + return t; + } + case '(': + { + const char *t = type; + size_t union_size = 0; + parse_union(&t, (type_parser)sizeof_union_field, &union_size); + *size += union_size; + return t; + } + //FIXME: union + case 'b': + { + // Consume the b + type++; + // Ignore the offset + strtol(type, (char**)&type, 10); + // Consume the element type + type++; + // Read the number of bits + *size += strtol(type, (char**)&type, 10); + return type; + } + case '^': + { + // All pointers look the same to me. + *size += sizeof(void*) * 8; + size_t ignored; + // Skip the definition of the pointeee type. + return sizeof_type(type+1, &ignored); + } + } + abort(); + return NULL; +} + +static const char *sizeof_union_field(const char *type, size_t *size) +{ + size_t field_size = 0; + const char *end = sizeof_type(type, &field_size); + *size = max(*size, field_size); + return end; +} + +static const char *alignof_type(const char *type, size_t *align) +{ + type = objc_skip_type_qualifiers(type); + switch (*type) + { + // For all primitive types, we return the maximum of the new alignment + // and the old one +#define APPLY_TYPE(typeName, name, capitalizedName, encodingChar) \ + case encodingChar:\ + {\ + *align = max((alignof(typeName) * 8), *align);\ + return type + 1;\ + } +#define NON_INTEGER_TYPES 1 +#include "type_encoding_cases.h" + case '?': + case 'v': return type+1; + case 'j': + { + type++; + switch (*type) + { +#define APPLY_TYPE(typeName, name, capitalizedName, encodingChar) \ + case encodingChar:\ + {\ + *align = max((alignof(_Complex typeName) * 8), *align);\ + return type + 1;\ + } +#include "type_encoding_cases.h" + } + } + case '{': + { + const char *t = type; + parse_struct(&t, (type_parser)alignof_type, align); + return t; + } + case '(': + { + const char *t = type; + parse_union(&t, (type_parser)alignof_type, align); + return t; + } + case '[': + { + const char *t = type; + // FIXME: aligned size + parse_array(&t, (type_parser)alignof_type, &align); + return t; + } + //FIXME: union + case 'b': + { + // Consume the b + type++; + // Ignore the offset + strtol(type, (char**)&type, 10); + // Alignment of a bitfield is the alignment of the type that + // contains it + type = alignof_type(type, align); + // Ignore the number of bits + strtol(type, (char**)&type, 10); + return type; + } + case '^': + { + *align = max((alignof(void*) * 8), *align); + // All pointers look the same to me. + size_t ignored; + // Skip the definition of the pointeee type. + return alignof_type(type+1, &ignored); + } + } + abort(); + return NULL; +} + +size_t objc_sizeof_type(const char *type) +{ + size_t size = 0; + sizeof_type(type, &size); + return size / 8; +} + +size_t objc_alignof_type (const char *type) +{ + size_t align = 0; + alignof_type(type, &align); + return align / 8; +} + +size_t objc_aligned_size(const char *type) +{ + size_t size = objc_sizeof_type(type); + size_t align = objc_alignof_type(type); + return size + (size % align); +} + +/* + The size rounded up to the nearest integral of the wordsize, taken + to be the size of a void *. +*/ + +size_t objc_promoted_size(const char *type) +{ + size_t size = objc_sizeof_type(type); + return size + (size % sizeof(void*)); +} + +void method_getReturnType(Method method, char *dst, size_t dst_len) +{ + //TODO: Coped and pasted code. Factor it out. + const char *types = method->types; + size_t length = lengthOfTypeEncoding(types); + if (length < dst_len) + { + memcpy(dst, types, length); + dst[length] = '\0'; + } + else + { + memcpy(dst, types, dst_len); + } +} + +const char *method_getTypeEncoding(Method method) +{ + return method->types; +} + + +void method_getArgumentType(Method method, + unsigned int index, + char *dst, + size_t dst_len) +{ + const char *types = findParameterStart(method->types, index); + if (NULL == types) + { + strncpy(dst, "", dst_len); + return; + } + size_t length = lengthOfTypeEncoding(types); + if (length < dst_len) + { + memcpy(dst, types, length); + dst[length] = '\0'; + } + else + { + memcpy(dst, types, dst_len); + } +} + +unsigned method_getNumberOfArguments(Method method) +{ + const char *types = method->types; + unsigned int count = 0; + while('\0' != *types) + { + types = objc_skip_argspec(types); + count++; + } + return count - 1; +} + +unsigned method_get_number_of_arguments(struct objc_method *method) +{ + return method_getNumberOfArguments(method); +} + + +char * method_copyArgumentType(Method method, unsigned int index) +{ + const char *types = findParameterStart(method->types, index); + if (NULL == types) + { + return NULL; + } + return copyTypeEncoding(types); +} + +char * method_copyReturnType(Method method) +{ + return copyTypeEncoding(method->types); +} + +unsigned objc_get_type_qualifiers (const char *type) +{ + unsigned flags = 0; +#define MAP(chr, bit) case chr: flags |= (1<original_type = type; + layout->type = 0; +} + +static const char *layout_structure_callback(const char *type, struct objc_struct_layout *layout) +{ + size_t align = 0; + size_t size = 0; + const char *end = sizeof_type(type, &size); + alignof_type(type, &align); + //printf("Callback called with %s\n", type); + if (layout->prev_type < type) + { + if (layout->record_align == 0) + { + layout->record_align = align; + layout->type = type; + } + } + else + { + round_up(&layout->record_size, align); + layout->record_size += size; + } + return end; +} + +BOOL objc_layout_structure_next_member(struct objc_struct_layout *layout) +{ + const char *end = layout->type; + layout->record_size = 0; + layout->record_align = 0; + layout->prev_type = layout->type; + const char *type = layout->original_type; + parse_struct(&type, (type_parser)layout_structure_callback, layout); + //printf("Calculated: (%s) %s %d %d\n", layout->original_type, layout->type, layout->record_size, layout->record_align); + //printf("old start %s, new start %s\n", end, layout->type); + return layout->type != end; +} + +void objc_layout_structure_get_info (struct objc_struct_layout *layout, + unsigned int *offset, + unsigned int *align, + const char **type) +{ + //printf("%p\n", layout); + *type = layout->type; + *offset = layout->record_size / 8; + *align= layout->record_align / 8; + round_up(offset, *align); + printf("%s %d %d\n", *type, *offset, *align); +} + +#ifdef ENCODING_TESTS + +#define TEST(type) do {\ + if (alignof(type) != objc_alignof_type(@encode(type)))\ + printf("Incorrect alignment for %s: %d != %d\n", @encode(type), objc_alignof_type(@encode(type)), alignof(type));\ + if (sizeof(type) != objc_sizeof_type(@encode(type)))\ + printf("Incorrect size for %s: %d != %d\n", @encode(type), objc_sizeof_type(@encode(type)), sizeof(type));\ + } while(0) + +struct foo +{ + int a[2]; + int b:5; + struct + { + double d; + const char *str; + float e; + }c; + long long **g; + union { const char c; long long b; } h; + long long f; + _Complex int z; + _Complex double y; + char v; +}; + +typedef struct +{ + float x,y; +} Point; + +typedef struct +{ + Point a, b; +} Rect; + + +int main(void) +{ + TEST(int); + TEST(const char); + TEST(unsigned long long); + TEST(_Complex int); + TEST(struct foo); + struct objc_struct_layout layout; + + objc_layout_structure(@encode(Rect), &layout); + while (objc_layout_structure_next_member (&layout)) + { + unsigned offset; + unsigned align; + const char *ftype; + struct objc_struct_layout layout2; + objc_layout_structure_get_info (&layout, &offset, &align, &ftype); + printf("%s: offset: %d, alignment: %d\n", ftype, offset, align); + objc_layout_structure(ftype, &layout2); + while (objc_layout_structure_next_member (&layout2)) + { + objc_layout_structure_get_info (&layout2, &offset, &align, &ftype); + printf("%s: offset: %d, alignment: %d\n", ftype, offset, align); + } + } + printf("%d\n", offsetof(Rect, a.x)); + printf("%d\n", offsetof(Rect, a.y)); + printf("%d\n", offsetof(Rect, b.x)); + printf("%d\n", offsetof(Rect, b.y)); + +} +#endif diff --git a/runtime.c b/runtime.c index 7b4b8d3..854d608 100644 --- a/runtime.c +++ b/runtime.c @@ -491,49 +491,6 @@ const char * ivar_getTypeEncoding(Ivar ivar) return ivar->ivar_type; } -static size_t lengthOfTypeEncoding(const char *types) -{ - const char *end = objc_skip_argspec(types); - end--; - while (isdigit(*end)) { end--; } - size_t length = end - types + 1; - return length; -} -static char *copyTypeEncoding(const char *types) -{ - size_t length = lengthOfTypeEncoding(types); - char *copy = malloc(length + 1); - memcpy(copy, types, length); - copy[length] = '\0'; - return copy; -} -static const char * findParameterStart(const char *types, unsigned int index) -{ - for (unsigned int i=0 ; imethod_types, index); - if (NULL == types) - { - return NULL; - } - return copyTypeEncoding(types); -} - -char * method_copyReturnType(Method method) -{ - return copyTypeEncoding(method->method_types); -} void method_exchangeImplementations(Method m1, Method m2) { @@ -543,28 +500,6 @@ void method_exchangeImplementations(Method m1, Method m2) objc_updateDtableForClassContainingMethod(m1); objc_updateDtableForClassContainingMethod(m2); } -void method_getArgumentType(Method method, - unsigned int index, - char *dst, - size_t dst_len) -{ - const char *types = findParameterStart(method->method_types, index); - if (NULL == types) - { - strncpy(dst, "", dst_len); - return; - } - size_t length = lengthOfTypeEncoding(types); - if (length < dst_len) - { - memcpy(dst, types, length); - dst[length] = '\0'; - } - else - { - memcpy(dst, types, dst_len); - } -} IMP method_getImplementation(Method method) { @@ -576,38 +511,6 @@ SEL method_getName(Method method) return (SEL)method->method_name; } -unsigned method_getNumberOfArguments(Method method) -{ - const char *types = method->method_types; - unsigned int count = 0; - while('\0' != *types) - { - types = objc_skip_argspec(types); - count++; - } - return count - 1; -} - -void method_getReturnType(Method method, char *dst, size_t dst_len) -{ - //TODO: Coped and pasted code. Factor it out. - const char *types = method->method_types; - size_t length = lengthOfTypeEncoding(types); - if (length < dst_len) - { - memcpy(dst, types, length); - dst[length] = '\0'; - } - else - { - memcpy(dst, types, dst_len); - } -} - -const char * method_getTypeEncoding(Method method) -{ - return method->method_types; -} IMP method_setImplementation(Method method, IMP imp) {