2 * 'sparse' library helper routines.
4 * Copyright (C) 2003 Transmeta Corp.
7 * Licensed under the Open Software License version 1.1
18 #include <sys/types.h>
25 #include "expression.h"
27 #include "linearize.h"
29 struct token
*skip_to(struct token
*token
, int op
)
31 while (!match_op(token
, op
) && !eof_token(token
))
36 struct token
*expect(struct token
*token
, int op
, const char *where
)
38 if (!match_op(token
, op
)) {
39 static struct token bad_token
;
40 if (token
!= &bad_token
) {
41 bad_token
.next
= token
;
42 warn(token
->pos
, "Expected %s %s", show_special(op
), where
);
43 warn(token
->pos
, "got %s", show_token(token
));
46 return skip_to(token
, op
);
52 unsigned int hexval(unsigned int c
)
60 retval
= c
- 'a' + 10;
63 retval
= c
- 'A' + 10;
70 * Simple allocator for data that doesn't get partially free'd.
71 * The tokenizer and parser allocate a _lot_ of small data structures
72 * (often just two-three bytes for things like small integers),
73 * and since they all depend on each other you can't free them
74 * individually _anyway_. So do something that is very space-
75 * efficient: allocate larger "blobs", and give out individual
76 * small bits and pieces of it with no maintenance overhead.
78 struct allocation_blob
{
79 struct allocation_blob
*next
;
80 unsigned int left
, offset
;
85 #define blob_alloc(size) mmap(NULL, ((size)+4095) & ~4095, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)
86 #define blob_free(addr,size) munmap((addr), ((size)+4095) & ~4095)
88 struct allocator_struct
{
90 struct allocation_blob
*blobs
;
91 unsigned int alignment
;
92 unsigned int chunking
;
94 unsigned int allocations
, total_bytes
, useful_bytes
;
97 void drop_all_allocations(struct allocator_struct
*desc
)
99 struct allocation_blob
*blob
= desc
->blobs
;
102 desc
->allocations
= 0;
103 desc
->total_bytes
= 0;
104 desc
->useful_bytes
= 0;
106 struct allocation_blob
*next
= blob
->next
;
107 blob_free(blob
, desc
->chunking
);
112 void *allocate(struct allocator_struct
*desc
, unsigned int size
)
114 unsigned long alignment
= desc
->alignment
;
115 struct allocation_blob
*blob
= desc
->blobs
;
119 desc
->useful_bytes
+= size
;
120 size
= (size
+ alignment
- 1) & ~(alignment
-1);
121 if (!blob
|| blob
->left
< size
) {
122 unsigned int offset
, chunking
= desc
->chunking
;
123 struct allocation_blob
*newblob
= blob_alloc(chunking
);
125 die("out of memory");
126 desc
->total_bytes
+= chunking
;
127 newblob
->next
= blob
;
129 desc
->blobs
= newblob
;
130 offset
= offsetof(struct allocation_blob
, data
);
131 if (alignment
> offset
)
133 blob
->left
= chunking
- offset
;
134 blob
->offset
= offset
- offsetof(struct allocation_blob
, data
);
136 retval
= blob
->data
+ blob
->offset
;
137 blob
->offset
+= size
;
142 static void show_allocations(struct allocator_struct
*x
)
144 fprintf(stderr
, "%s: %d allocations, %d bytes (%d total bytes, "
145 "%6.2f%% usage, %6.2f average size)\n",
146 x
->name
, x
->allocations
, x
->useful_bytes
, x
->total_bytes
,
147 100 * (double) x
->useful_bytes
/ x
->total_bytes
,
148 (double) x
->useful_bytes
/ x
->allocations
);
151 struct allocator_struct ident_allocator
= { "identifiers", NULL
, __alignof__(struct ident
), CHUNK
};
152 struct allocator_struct token_allocator
= { "tokens", NULL
, __alignof__(struct token
), CHUNK
};
153 struct allocator_struct symbol_allocator
= { "symbols", NULL
, __alignof__(struct symbol
), CHUNK
};
154 struct allocator_struct expression_allocator
= { "expressions", NULL
, __alignof__(struct expression
), CHUNK
};
155 struct allocator_struct statement_allocator
= { "statements", NULL
, __alignof__(struct statement
), CHUNK
};
156 struct allocator_struct string_allocator
= { "strings", NULL
, __alignof__(struct statement
), CHUNK
};
157 struct allocator_struct scope_allocator
= { "scopes", NULL
, __alignof__(struct scope
), CHUNK
};
158 struct allocator_struct bytes_allocator
= { "bytes", NULL
, 1, CHUNK
};
159 struct allocator_struct basic_block_allocator
= { "basic_block", NULL
, __alignof__(struct basic_block
), CHUNK
};
160 struct allocator_struct entrypoint_allocator
= { "entrypoint", NULL
, __alignof__(struct entrypoint
), CHUNK
};
162 #define __ALLOCATOR(type, size, x) \
163 type *__alloc_##x(int extra) \
165 return allocate(&x##_allocator, size+extra); \
167 void show_##x##_alloc(void) \
169 show_allocations(&x##_allocator); \
171 void clear_##x##_alloc(void) \
173 drop_all_allocations(&x##_allocator); \
175 #define ALLOCATOR(x) __ALLOCATOR(struct x, sizeof(struct x), x)
177 ALLOCATOR(ident
); ALLOCATOR(token
); ALLOCATOR(symbol
);
178 ALLOCATOR(expression
); ALLOCATOR(statement
); ALLOCATOR(string
);
179 ALLOCATOR(scope
); __ALLOCATOR(void, 0, bytes
);
180 ALLOCATOR(basic_block
); ALLOCATOR(entrypoint
);
182 int ptr_list_size(struct ptr_list
*head
)
187 struct ptr_list
*list
= head
;
190 } while ((list
= list
->next
) != head
);
195 void iterate(struct ptr_list
*head
, void (*callback
)(void *, void *, int), void *data
)
197 struct ptr_list
*list
= head
;
198 int flag
= ITERATE_FIRST
;
204 for (i
= 0; i
< list
->nr
; i
++) {
205 if (i
== list
->nr
-1 && list
->next
== head
)
206 flag
|= ITERATE_LAST
;
207 callback(list
->list
[i
], data
, flag
);
211 } while (list
!= head
);
214 void add_ptr_list(struct ptr_list
**listp
, void *ptr
)
216 struct ptr_list
*list
= *listp
;
219 if (!list
|| (nr
= list
->nr
) >= LIST_NODE_NR
) {
220 struct ptr_list
*newlist
= malloc(sizeof(*newlist
));
222 die("out of memory for symbol/statement lists");
223 memset(newlist
, 0, sizeof(*newlist
));
225 newlist
->next
= newlist
;
226 newlist
->prev
= newlist
;
229 newlist
->next
= list
;
230 newlist
->prev
= list
->prev
;
231 list
->prev
->next
= newlist
;
232 list
->prev
= newlist
;
237 list
->list
[nr
] = ptr
;
242 void concat_ptr_list(struct ptr_list
*a
, struct ptr_list
**b
)
245 FOR_EACH_PTR(a
, entry
) {
246 add_ptr_list(b
, entry
);
250 void free_ptr_list(struct ptr_list
**listp
)
252 struct ptr_list
*tmp
, *list
= *listp
;
257 list
->prev
->next
= NULL
;
267 static void do_warn(const char *type
, struct position pos
, const char * fmt
, va_list args
)
269 static char buffer
[512];
272 vsprintf(buffer
, fmt
, args
);
273 name
= input_streams
[pos
.stream
].name
;
275 fprintf(stderr
, "%s: %s:%d:%d: %s\n",
276 type
, name
, pos
.line
, pos
.pos
, buffer
);
279 void warn(struct position pos
, const char * fmt
, ...)
281 static int warnings
= 0;
284 if (warnings
> 100) {
288 fmt
= "too many warnings";
293 do_warn("warning", pos
, fmt
, args
);
298 void error(struct position pos
, const char * fmt
, ...)
302 do_warn("error", pos
, fmt
, args
);
307 void die(const char *fmt
, ...)
310 static char buffer
[512];
313 vsnprintf(buffer
, sizeof(buffer
), fmt
, args
);
316 fprintf(stderr
, "%s\n", buffer
);
320 unsigned int pre_buffer_size
;
321 unsigned char pre_buffer
[8192];
327 void add_pre_buffer(const char *fmt
, ...)
333 size
= pre_buffer_size
;
334 size
+= vsnprintf(pre_buffer
+ size
,
335 sizeof(pre_buffer
) - size
,
337 pre_buffer_size
= size
;
341 char **handle_switch_D(char *arg
, char **next
)
343 const char *name
= arg
+ 1;
344 const char *value
= "";
350 if (isspace(c
) || c
== '=') {
356 add_pre_buffer("#define %s %s\n", name
, value
);
360 char **handle_switch_E(char *arg
, char **next
)
366 char **handle_switch_v(char *arg
, char **next
)
371 char **handle_switch_I(char *arg
, char **next
)
373 add_pre_buffer("#add_include \"%s/\"\n", arg
+ 1);
377 char **handle_switch_i(char *arg
, char **next
)
379 if (*next
&& !strcmp(arg
, "include")) {
380 char *name
= *++next
;
381 int fd
= open(name
, O_RDONLY
);
391 char **handle_switch(char *arg
, char **next
)
396 case 'D': rc
= handle_switch_D(arg
, next
); break;
397 case 'E': rc
= handle_switch_E(arg
, next
); break;
398 case 'v': rc
= handle_switch_v(arg
, next
); break;
399 case 'I': rc
= handle_switch_I(arg
, next
); break;
400 case 'i': rc
= handle_switch_i(arg
, next
); break;
403 * Ignore unknown command line options:
404 * they're probably gcc switches
411 void create_builtin_stream(void)
413 add_pre_buffer("#define __i386__ 1\n");
414 add_pre_buffer("#define __linux__ 1\n");
415 add_pre_buffer("#define __STDC__ 1\n");
416 add_pre_buffer("#define linux linux\n");
417 add_pre_buffer("#define cond_syscall(x)\n");
418 add_pre_buffer("#define __GNUC__ 2\n");
419 add_pre_buffer("#define __GNUC_MINOR__ 95\n");
420 add_pre_buffer("#define __func__ \"function\"\n");
421 add_pre_buffer("#define __extension__\n");
422 add_pre_buffer("#define __pragma__\n");
423 add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
424 add_pre_buffer("#define __builtin_va_arg(arg,type) ((type)0)\n");
425 add_pre_buffer("#define __builtin_va_end(arg)\n");