1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
struct obstack
{
long chunk_size;
struct _obstack_chunk *chunk;
char *object_base;
char *next_free;
char *chunk_limit;
int alignment_mask;
unsigned maybe_empty_object;
};
struct objfile
{
struct objfile *next;
struct obstack type_obstack;
};
struct type
{
unsigned length;
struct objfile *objfile;
short nfields;
struct field
{
union field_location
{
int bitpos;
unsigned long physaddr;
char *physname;
}
loc;
int bitsize;
struct type *type;
char *name;
}
*fields;
};
struct type *alloc_type (void);
void * xmalloc (unsigned int z);
void _obstack_newchunk (struct obstack *o, int i);
void get_discrete_bounds (long long *lowp, long long *highp);
extern void *memset(void *, int, __SIZE_TYPE__);
struct type *
create_array_type (struct type *result_type, struct type *element_type)
{
long long low_bound, high_bound;
if (result_type == ((void *)0))
{
result_type = alloc_type ();
}
get_discrete_bounds (&low_bound, &high_bound);
(result_type)->length =
(element_type)->length * (high_bound - low_bound + 1);
(result_type)->nfields = 1;
(result_type)->fields =
(struct field *) ((result_type)->objfile != ((void *)0)
? (
{
struct obstack *__h =
(&(result_type)->objfile -> type_obstack);
{
struct obstack *__o = (__h);
int __len = ((sizeof (struct field)));
if (__o->chunk_limit - __o->next_free < __len)
_obstack_newchunk (__o, __len);
__o->next_free += __len; (void) 0;
};
({
struct obstack *__o1 = (__h);
void *value;
value = (void *) __o1->object_base;
if (__o1->next_free == value)
__o1->maybe_empty_object = 1;
__o1->next_free = (((((__o1->next_free) - (char *) 0)
+__o1->alignment_mask)
& ~ (__o1->alignment_mask))
+ (char *) 0);
if (__o1->next_free - (char *)__o1->chunk
> __o1->chunk_limit - (char *)__o1->chunk)
__o1->next_free = __o1->chunk_limit;
__o1->object_base = __o1->next_free;
value;
});
}) : xmalloc (sizeof (struct field)));
return (result_type);
}
struct type *
alloc_type (void)
{
abort ();
}
void * xmalloc (unsigned int z)
{
return 0;
}
void _obstack_newchunk (struct obstack *o, int i)
{
abort ();
}
void
get_discrete_bounds (long long *lowp, long long *highp)
{
*lowp = 0;
*highp = 2;
}
int main(void)
{
struct type element_type;
struct type result_type;
memset (&element_type, 0, sizeof (struct type));
memset (&result_type, 0, sizeof (struct type));
element_type.length = 4;
create_array_type (&result_type, &element_type);
if (result_type.length != 12)
abort ();
exit (0);
}
|
