1 | /*
|
---|
2 | * TCC - Tiny C Compiler - Support for -run switch
|
---|
3 | *
|
---|
4 | * Copyright (c) 2001-2004 Fabrice Bellard
|
---|
5 | *
|
---|
6 | * This library is free software; you can redistribute it and/or
|
---|
7 | * modify it under the terms of the GNU Lesser General Public
|
---|
8 | * License as published by the Free Software Foundation; either
|
---|
9 | * version 2 of the License, or (at your option) any later version.
|
---|
10 | *
|
---|
11 | * This library is distributed in the hope that it will be useful,
|
---|
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
14 | * Lesser General Public License for more details.
|
---|
15 | *
|
---|
16 | * You should have received a copy of the GNU Lesser General Public
|
---|
17 | * License along with this library; if not, write to the Free Software
|
---|
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
---|
19 | */
|
---|
20 |
|
---|
21 | #include "tcc.h"
|
---|
22 |
|
---|
23 | /* only native compiler supports -run */
|
---|
24 | #ifdef TCC_IS_NATIVE
|
---|
25 |
|
---|
26 | #ifndef _WIN32
|
---|
27 | # include <sys/mman.h>
|
---|
28 | #endif
|
---|
29 |
|
---|
30 | #ifdef CONFIG_TCC_BACKTRACE
|
---|
31 | # ifndef _WIN32
|
---|
32 | # include <signal.h>
|
---|
33 | # ifndef __OpenBSD__
|
---|
34 | # include <sys/ucontext.h>
|
---|
35 | # endif
|
---|
36 | # else
|
---|
37 | # define ucontext_t CONTEXT
|
---|
38 | # endif
|
---|
39 | ST_DATA int rt_num_callers = 6;
|
---|
40 | ST_DATA const char **rt_bound_error_msg;
|
---|
41 | ST_DATA void *rt_prog_main;
|
---|
42 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level);
|
---|
43 | static void rt_error(ucontext_t *uc, const char *fmt, ...);
|
---|
44 | static void set_exception_handler(void);
|
---|
45 | #endif
|
---|
46 |
|
---|
47 | static void set_pages_executable(void *ptr, unsigned long length);
|
---|
48 | static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff);
|
---|
49 |
|
---|
50 | #ifdef _WIN64
|
---|
51 | static void *win64_add_function_table(TCCState *s1);
|
---|
52 | static void win64_del_function_table(void *);
|
---|
53 | #endif
|
---|
54 |
|
---|
55 | /* ------------------------------------------------------------- */
|
---|
56 | /* Do all relocations (needed before using tcc_get_symbol())
|
---|
57 | Returns -1 on error. */
|
---|
58 |
|
---|
59 | LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)
|
---|
60 | {
|
---|
61 | int size;
|
---|
62 | addr_t ptr_diff = 0;
|
---|
63 |
|
---|
64 | if (TCC_RELOCATE_AUTO != ptr)
|
---|
65 | return tcc_relocate_ex(s1, ptr, 0);
|
---|
66 |
|
---|
67 | size = tcc_relocate_ex(s1, NULL, 0);
|
---|
68 | if (size < 0)
|
---|
69 | return -1;
|
---|
70 |
|
---|
71 | #ifdef HAVE_SELINUX
|
---|
72 | {
|
---|
73 | /* Using mmap instead of malloc */
|
---|
74 | void *prx;
|
---|
75 | char tmpfname[] = "/tmp/.tccrunXXXXXX";
|
---|
76 | int fd = mkstemp(tmpfname);
|
---|
77 | unlink(tmpfname);
|
---|
78 | ftruncate(fd, size);
|
---|
79 |
|
---|
80 | ptr = mmap (NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
|
---|
81 | prx = mmap (NULL, size, PROT_READ|PROT_EXEC, MAP_SHARED, fd, 0);
|
---|
82 | if (ptr == MAP_FAILED || prx == MAP_FAILED)
|
---|
83 | tcc_error("tccrun: could not map memory");
|
---|
84 | dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, (void*)(addr_t)size);
|
---|
85 | dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, prx);
|
---|
86 | ptr_diff = (char*)prx - (char*)ptr;
|
---|
87 | }
|
---|
88 | #else
|
---|
89 | ptr = tcc_malloc(size);
|
---|
90 | #endif
|
---|
91 | tcc_relocate_ex(s1, ptr, ptr_diff); /* no more errors expected */
|
---|
92 | dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, ptr);
|
---|
93 | return 0;
|
---|
94 | }
|
---|
95 |
|
---|
96 | ST_FUNC void tcc_run_free(TCCState *s1)
|
---|
97 | {
|
---|
98 | int i;
|
---|
99 |
|
---|
100 | for (i = 0; i < s1->nb_runtime_mem; ++i) {
|
---|
101 | #ifdef HAVE_SELINUX
|
---|
102 | unsigned size = (unsigned)(addr_t)s1->runtime_mem[i++];
|
---|
103 | munmap(s1->runtime_mem[i++], size);
|
---|
104 | munmap(s1->runtime_mem[i], size);
|
---|
105 | #else
|
---|
106 | #ifdef _WIN64
|
---|
107 | win64_del_function_table(*(void**)s1->runtime_mem[i]);
|
---|
108 | #endif
|
---|
109 | tcc_free(s1->runtime_mem[i]);
|
---|
110 | #endif
|
---|
111 | }
|
---|
112 | tcc_free(s1->runtime_mem);
|
---|
113 | }
|
---|
114 |
|
---|
115 | /* launch the compiled program with the given arguments */
|
---|
116 | LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
|
---|
117 | {
|
---|
118 | int (*prog_main)(int, char **);
|
---|
119 |
|
---|
120 | s1->runtime_main = "main";
|
---|
121 | if ((s1->dflag & 16) && !find_elf_sym(s1->symtab, s1->runtime_main))
|
---|
122 | return 0;
|
---|
123 | if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
|
---|
124 | return -1;
|
---|
125 | prog_main = tcc_get_symbol_err(s1, s1->runtime_main);
|
---|
126 |
|
---|
127 | #ifdef CONFIG_TCC_BACKTRACE
|
---|
128 | if (s1->do_debug) {
|
---|
129 | set_exception_handler();
|
---|
130 | rt_prog_main = prog_main;
|
---|
131 | }
|
---|
132 | #endif
|
---|
133 |
|
---|
134 | errno = 0; /* clean errno value */
|
---|
135 |
|
---|
136 | #ifdef CONFIG_TCC_BCHECK
|
---|
137 | if (s1->do_bounds_check) {
|
---|
138 | void (*bound_init)(void);
|
---|
139 | void (*bound_exit)(void);
|
---|
140 | void (*bound_new_region)(void *p, addr_t size);
|
---|
141 | int (*bound_delete_region)(void *p);
|
---|
142 | int i, ret;
|
---|
143 |
|
---|
144 | /* set error function */
|
---|
145 | rt_bound_error_msg = tcc_get_symbol_err(s1, "__bound_error_msg");
|
---|
146 | /* XXX: use .init section so that it also work in binary ? */
|
---|
147 | bound_init = tcc_get_symbol_err(s1, "__bound_init");
|
---|
148 | bound_exit = tcc_get_symbol_err(s1, "__bound_exit");
|
---|
149 | bound_new_region = tcc_get_symbol_err(s1, "__bound_new_region");
|
---|
150 | bound_delete_region = tcc_get_symbol_err(s1, "__bound_delete_region");
|
---|
151 |
|
---|
152 | bound_init();
|
---|
153 | /* mark argv area as valid */
|
---|
154 | bound_new_region(argv, argc*sizeof(argv[0]));
|
---|
155 | for (i=0; i<argc; ++i)
|
---|
156 | bound_new_region(argv[i], strlen(argv[i]) + 1);
|
---|
157 |
|
---|
158 | ret = (*prog_main)(argc, argv);
|
---|
159 |
|
---|
160 | /* unmark argv area */
|
---|
161 | for (i=0; i<argc; ++i)
|
---|
162 | bound_delete_region(argv[i]);
|
---|
163 | bound_delete_region(argv);
|
---|
164 | bound_exit();
|
---|
165 | return ret;
|
---|
166 | }
|
---|
167 | #endif
|
---|
168 | return (*prog_main)(argc, argv);
|
---|
169 | }
|
---|
170 |
|
---|
171 | #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
|
---|
172 | #define RUN_SECTION_ALIGNMENT 63
|
---|
173 | #else
|
---|
174 | #define RUN_SECTION_ALIGNMENT 15
|
---|
175 | #endif
|
---|
176 |
|
---|
177 | /* relocate code. Return -1 on error, required size if ptr is NULL,
|
---|
178 | otherwise copy code into buffer passed by the caller */
|
---|
179 | static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff)
|
---|
180 | {
|
---|
181 | Section *s;
|
---|
182 | unsigned offset, length, fill, i, k;
|
---|
183 | addr_t mem;
|
---|
184 |
|
---|
185 | if (NULL == ptr) {
|
---|
186 | s1->nb_errors = 0;
|
---|
187 | #ifdef TCC_TARGET_PE
|
---|
188 | pe_output_file(s1, NULL);
|
---|
189 | #else
|
---|
190 | tcc_add_runtime(s1);
|
---|
191 | resolve_common_syms(s1);
|
---|
192 | build_got_entries(s1);
|
---|
193 | #endif
|
---|
194 | if (s1->nb_errors)
|
---|
195 | return -1;
|
---|
196 | }
|
---|
197 |
|
---|
198 | offset = 0, mem = (addr_t)ptr;
|
---|
199 | fill = -mem & RUN_SECTION_ALIGNMENT;
|
---|
200 | #ifdef _WIN64
|
---|
201 | offset += sizeof (void*);
|
---|
202 | #endif
|
---|
203 | for (k = 0; k < 2; ++k) {
|
---|
204 | for(i = 1; i < s1->nb_sections; i++) {
|
---|
205 | s = s1->sections[i];
|
---|
206 | if (0 == (s->sh_flags & SHF_ALLOC))
|
---|
207 | continue;
|
---|
208 | if (k != !(s->sh_flags & SHF_EXECINSTR))
|
---|
209 | continue;
|
---|
210 | offset += fill;
|
---|
211 | if (!mem)
|
---|
212 | s->sh_addr = 0;
|
---|
213 | else if (s->sh_flags & SHF_EXECINSTR)
|
---|
214 | s->sh_addr = mem + offset + ptr_diff;
|
---|
215 | else
|
---|
216 | s->sh_addr = mem + offset;
|
---|
217 | #if 0
|
---|
218 | if (mem)
|
---|
219 | printf("%-16s +%02lx %p %04x\n",
|
---|
220 | s->name, fill, (void*)s->sh_addr, (unsigned)s->data_offset);
|
---|
221 | #endif
|
---|
222 | offset += s->data_offset;
|
---|
223 | fill = -(mem + offset) & 15;
|
---|
224 | }
|
---|
225 | #if RUN_SECTION_ALIGNMENT > 15
|
---|
226 | /* To avoid that x86 processors would reload cached instructions each time
|
---|
227 | when data is written in the near, we need to make sure that code and data
|
---|
228 | do not share the same 64 byte unit */
|
---|
229 | fill = -(mem + offset) & RUN_SECTION_ALIGNMENT;
|
---|
230 | #endif
|
---|
231 | }
|
---|
232 |
|
---|
233 | /* relocate symbols */
|
---|
234 | relocate_syms(s1, s1->symtab, 1);
|
---|
235 | if (s1->nb_errors)
|
---|
236 | return -1;
|
---|
237 |
|
---|
238 | if (0 == mem)
|
---|
239 | return offset + RUN_SECTION_ALIGNMENT;
|
---|
240 |
|
---|
241 | #ifdef TCC_TARGET_PE
|
---|
242 | s1->pe_imagebase = mem;
|
---|
243 | #endif
|
---|
244 |
|
---|
245 | /* relocate each section */
|
---|
246 | for(i = 1; i < s1->nb_sections; i++) {
|
---|
247 | s = s1->sections[i];
|
---|
248 | if (s->reloc)
|
---|
249 | relocate_section(s1, s);
|
---|
250 | }
|
---|
251 | relocate_plt(s1);
|
---|
252 |
|
---|
253 | for(i = 1; i < s1->nb_sections; i++) {
|
---|
254 | s = s1->sections[i];
|
---|
255 | if (0 == (s->sh_flags & SHF_ALLOC))
|
---|
256 | continue;
|
---|
257 | length = s->data_offset;
|
---|
258 | ptr = (void*)s->sh_addr;
|
---|
259 | if (s->sh_flags & SHF_EXECINSTR)
|
---|
260 | ptr = (char*)ptr - ptr_diff;
|
---|
261 | if (NULL == s->data || s->sh_type == SHT_NOBITS)
|
---|
262 | memset(ptr, 0, length);
|
---|
263 | else
|
---|
264 | memcpy(ptr, s->data, length);
|
---|
265 | /* mark executable sections as executable in memory */
|
---|
266 | if (s->sh_flags & SHF_EXECINSTR)
|
---|
267 | set_pages_executable((char*)ptr + ptr_diff, length);
|
---|
268 | }
|
---|
269 |
|
---|
270 | #ifdef _WIN64
|
---|
271 | *(void**)mem = win64_add_function_table(s1);
|
---|
272 | #endif
|
---|
273 |
|
---|
274 | return 0;
|
---|
275 | }
|
---|
276 |
|
---|
277 | /* ------------------------------------------------------------- */
|
---|
278 | /* allow to run code in memory */
|
---|
279 |
|
---|
280 | static void set_pages_executable(void *ptr, unsigned long length)
|
---|
281 | {
|
---|
282 | #ifdef _WIN32
|
---|
283 | unsigned long old_protect;
|
---|
284 | VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
|
---|
285 | #else
|
---|
286 | void __clear_cache(void *beginning, void *end);
|
---|
287 | # ifndef HAVE_SELINUX
|
---|
288 | addr_t start, end;
|
---|
289 | # ifndef PAGESIZE
|
---|
290 | # define PAGESIZE 4096
|
---|
291 | # endif
|
---|
292 | start = (addr_t)ptr & ~(PAGESIZE - 1);
|
---|
293 | end = (addr_t)ptr + length;
|
---|
294 | end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
|
---|
295 | if (mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC))
|
---|
296 | tcc_error("mprotect failed: did you mean to configure --with-selinux?");
|
---|
297 | # endif
|
---|
298 | # if defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64
|
---|
299 | __clear_cache(ptr, (char *)ptr + length);
|
---|
300 | # endif
|
---|
301 | #endif
|
---|
302 | }
|
---|
303 |
|
---|
304 | #ifdef _WIN64
|
---|
305 | static void *win64_add_function_table(TCCState *s1)
|
---|
306 | {
|
---|
307 | void *p = NULL;
|
---|
308 | if (s1->uw_pdata) {
|
---|
309 | p = (void*)s1->uw_pdata->sh_addr;
|
---|
310 | RtlAddFunctionTable(
|
---|
311 | (RUNTIME_FUNCTION*)p,
|
---|
312 | s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
|
---|
313 | s1->pe_imagebase
|
---|
314 | );
|
---|
315 | s1->uw_pdata = NULL;
|
---|
316 | }
|
---|
317 | return p;
|
---|
318 | }
|
---|
319 |
|
---|
320 | static void win64_del_function_table(void *p)
|
---|
321 | {
|
---|
322 | if (p) {
|
---|
323 | RtlDeleteFunctionTable((RUNTIME_FUNCTION*)p);
|
---|
324 | }
|
---|
325 | }
|
---|
326 | #endif
|
---|
327 |
|
---|
328 | /* ------------------------------------------------------------- */
|
---|
329 | #ifdef CONFIG_TCC_BACKTRACE
|
---|
330 |
|
---|
331 | ST_FUNC void tcc_set_num_callers(int n)
|
---|
332 | {
|
---|
333 | rt_num_callers = n;
|
---|
334 | }
|
---|
335 |
|
---|
336 | /* print the position in the source file of PC value 'pc' by reading
|
---|
337 | the stabs debug information */
|
---|
338 | static addr_t rt_printline(addr_t wanted_pc, const char *msg)
|
---|
339 | {
|
---|
340 | char func_name[128], last_func_name[128];
|
---|
341 | addr_t func_addr, last_pc, pc;
|
---|
342 | const char *incl_files[INCLUDE_STACK_SIZE];
|
---|
343 | int incl_index, len, last_line_num, i;
|
---|
344 | const char *str, *p;
|
---|
345 |
|
---|
346 | Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;
|
---|
347 | int stab_len = 0;
|
---|
348 | char *stab_str = NULL;
|
---|
349 |
|
---|
350 | if (stab_section) {
|
---|
351 | stab_len = stab_section->data_offset;
|
---|
352 | stab_sym = (Stab_Sym *)stab_section->data;
|
---|
353 | stab_str = (char *) stabstr_section->data;
|
---|
354 | }
|
---|
355 |
|
---|
356 | func_name[0] = '\0';
|
---|
357 | func_addr = 0;
|
---|
358 | incl_index = 0;
|
---|
359 | last_func_name[0] = '\0';
|
---|
360 | last_pc = (addr_t)-1;
|
---|
361 | last_line_num = 1;
|
---|
362 |
|
---|
363 | if (!stab_sym)
|
---|
364 | goto no_stabs;
|
---|
365 |
|
---|
366 | stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);
|
---|
367 | for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {
|
---|
368 | switch(sym->n_type) {
|
---|
369 | /* function start or end */
|
---|
370 | case N_FUN:
|
---|
371 | if (sym->n_strx == 0) {
|
---|
372 | /* we test if between last line and end of function */
|
---|
373 | pc = sym->n_value + func_addr;
|
---|
374 | if (wanted_pc >= last_pc && wanted_pc < pc)
|
---|
375 | goto found;
|
---|
376 | func_name[0] = '\0';
|
---|
377 | func_addr = 0;
|
---|
378 | } else {
|
---|
379 | str = stab_str + sym->n_strx;
|
---|
380 | p = strchr(str, ':');
|
---|
381 | if (!p) {
|
---|
382 | pstrcpy(func_name, sizeof(func_name), str);
|
---|
383 | } else {
|
---|
384 | len = p - str;
|
---|
385 | if (len > sizeof(func_name) - 1)
|
---|
386 | len = sizeof(func_name) - 1;
|
---|
387 | memcpy(func_name, str, len);
|
---|
388 | func_name[len] = '\0';
|
---|
389 | }
|
---|
390 | func_addr = sym->n_value;
|
---|
391 | }
|
---|
392 | break;
|
---|
393 | /* line number info */
|
---|
394 | case N_SLINE:
|
---|
395 | pc = sym->n_value + func_addr;
|
---|
396 | if (wanted_pc >= last_pc && wanted_pc < pc)
|
---|
397 | goto found;
|
---|
398 | last_pc = pc;
|
---|
399 | last_line_num = sym->n_desc;
|
---|
400 | /* XXX: slow! */
|
---|
401 | strcpy(last_func_name, func_name);
|
---|
402 | break;
|
---|
403 | /* include files */
|
---|
404 | case N_BINCL:
|
---|
405 | str = stab_str + sym->n_strx;
|
---|
406 | add_incl:
|
---|
407 | if (incl_index < INCLUDE_STACK_SIZE) {
|
---|
408 | incl_files[incl_index++] = str;
|
---|
409 | }
|
---|
410 | break;
|
---|
411 | case N_EINCL:
|
---|
412 | if (incl_index > 1)
|
---|
413 | incl_index--;
|
---|
414 | break;
|
---|
415 | case N_SO:
|
---|
416 | if (sym->n_strx == 0) {
|
---|
417 | incl_index = 0; /* end of translation unit */
|
---|
418 | } else {
|
---|
419 | str = stab_str + sym->n_strx;
|
---|
420 | /* do not add path */
|
---|
421 | len = strlen(str);
|
---|
422 | if (len > 0 && str[len - 1] != '/')
|
---|
423 | goto add_incl;
|
---|
424 | }
|
---|
425 | break;
|
---|
426 | }
|
---|
427 | }
|
---|
428 |
|
---|
429 | no_stabs:
|
---|
430 | /* second pass: we try symtab symbols (no line number info) */
|
---|
431 | incl_index = 0;
|
---|
432 | if (symtab_section)
|
---|
433 | {
|
---|
434 | ElfW(Sym) *sym, *sym_end;
|
---|
435 | int type;
|
---|
436 |
|
---|
437 | sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
|
---|
438 | for(sym = (ElfW(Sym) *)symtab_section->data + 1;
|
---|
439 | sym < sym_end;
|
---|
440 | sym++) {
|
---|
441 | type = ELFW(ST_TYPE)(sym->st_info);
|
---|
442 | if (type == STT_FUNC || type == STT_GNU_IFUNC) {
|
---|
443 | if (wanted_pc >= sym->st_value &&
|
---|
444 | wanted_pc < sym->st_value + sym->st_size) {
|
---|
445 | pstrcpy(last_func_name, sizeof(last_func_name),
|
---|
446 | (char *) symtab_section->link->data + sym->st_name);
|
---|
447 | func_addr = sym->st_value;
|
---|
448 | goto found;
|
---|
449 | }
|
---|
450 | }
|
---|
451 | }
|
---|
452 | }
|
---|
453 | /* did not find any info: */
|
---|
454 | fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);
|
---|
455 | fflush(stderr);
|
---|
456 | return 0;
|
---|
457 | found:
|
---|
458 | i = incl_index;
|
---|
459 | if (i > 0)
|
---|
460 | fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);
|
---|
461 | fprintf(stderr, "%s %p", msg, (void*)wanted_pc);
|
---|
462 | if (last_func_name[0] != '\0')
|
---|
463 | fprintf(stderr, " %s()", last_func_name);
|
---|
464 | if (--i >= 0) {
|
---|
465 | fprintf(stderr, " (included from ");
|
---|
466 | for (;;) {
|
---|
467 | fprintf(stderr, "%s", incl_files[i]);
|
---|
468 | if (--i < 0)
|
---|
469 | break;
|
---|
470 | fprintf(stderr, ", ");
|
---|
471 | }
|
---|
472 | fprintf(stderr, ")");
|
---|
473 | }
|
---|
474 | fprintf(stderr, "\n");
|
---|
475 | fflush(stderr);
|
---|
476 | return func_addr;
|
---|
477 | }
|
---|
478 |
|
---|
479 | /* emit a run time error at position 'pc' */
|
---|
480 | static void rt_error(ucontext_t *uc, const char *fmt, ...)
|
---|
481 | {
|
---|
482 | va_list ap;
|
---|
483 | addr_t pc;
|
---|
484 | int i;
|
---|
485 |
|
---|
486 | fprintf(stderr, "Runtime error: ");
|
---|
487 | va_start(ap, fmt);
|
---|
488 | vfprintf(stderr, fmt, ap);
|
---|
489 | va_end(ap);
|
---|
490 | fprintf(stderr, "\n");
|
---|
491 |
|
---|
492 | for(i=0;i<rt_num_callers;i++) {
|
---|
493 | if (rt_get_caller_pc(&pc, uc, i) < 0)
|
---|
494 | break;
|
---|
495 | pc = rt_printline(pc, i ? "by" : "at");
|
---|
496 | if (pc == (addr_t)rt_prog_main && pc)
|
---|
497 | break;
|
---|
498 | }
|
---|
499 | }
|
---|
500 |
|
---|
501 | /* ------------------------------------------------------------- */
|
---|
502 | #ifndef _WIN32
|
---|
503 |
|
---|
504 | /* signal handler for fatal errors */
|
---|
505 | static void sig_error(int signum, siginfo_t *siginf, void *puc)
|
---|
506 | {
|
---|
507 | ucontext_t *uc = puc;
|
---|
508 |
|
---|
509 | switch(signum) {
|
---|
510 | case SIGFPE:
|
---|
511 | switch(siginf->si_code) {
|
---|
512 | case FPE_INTDIV:
|
---|
513 | case FPE_FLTDIV:
|
---|
514 | rt_error(uc, "division by zero");
|
---|
515 | break;
|
---|
516 | default:
|
---|
517 | rt_error(uc, "floating point exception");
|
---|
518 | break;
|
---|
519 | }
|
---|
520 | break;
|
---|
521 | case SIGBUS:
|
---|
522 | case SIGSEGV:
|
---|
523 | if (rt_bound_error_msg && *rt_bound_error_msg)
|
---|
524 | rt_error(uc, *rt_bound_error_msg);
|
---|
525 | else
|
---|
526 | rt_error(uc, "dereferencing invalid pointer");
|
---|
527 | break;
|
---|
528 | case SIGILL:
|
---|
529 | rt_error(uc, "illegal instruction");
|
---|
530 | break;
|
---|
531 | case SIGABRT:
|
---|
532 | rt_error(uc, "abort() called");
|
---|
533 | break;
|
---|
534 | default:
|
---|
535 | rt_error(uc, "caught signal %d", signum);
|
---|
536 | break;
|
---|
537 | }
|
---|
538 | exit(255);
|
---|
539 | }
|
---|
540 |
|
---|
541 | #ifndef SA_SIGINFO
|
---|
542 | # define SA_SIGINFO 0x00000004u
|
---|
543 | #endif
|
---|
544 |
|
---|
545 | /* Generate a stack backtrace when a CPU exception occurs. */
|
---|
546 | static void set_exception_handler(void)
|
---|
547 | {
|
---|
548 | struct sigaction sigact;
|
---|
549 | /* install TCC signal handlers to print debug info on fatal
|
---|
550 | runtime errors */
|
---|
551 | sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
|
---|
552 | sigact.sa_sigaction = sig_error;
|
---|
553 | sigemptyset(&sigact.sa_mask);
|
---|
554 | sigaction(SIGFPE, &sigact, NULL);
|
---|
555 | sigaction(SIGILL, &sigact, NULL);
|
---|
556 | sigaction(SIGSEGV, &sigact, NULL);
|
---|
557 | sigaction(SIGBUS, &sigact, NULL);
|
---|
558 | sigaction(SIGABRT, &sigact, NULL);
|
---|
559 | }
|
---|
560 |
|
---|
561 | /* ------------------------------------------------------------- */
|
---|
562 | #ifdef __i386__
|
---|
563 |
|
---|
564 | /* fix for glibc 2.1 */
|
---|
565 | #ifndef REG_EIP
|
---|
566 | #define REG_EIP EIP
|
---|
567 | #define REG_EBP EBP
|
---|
568 | #endif
|
---|
569 |
|
---|
570 | /* return the PC at frame level 'level'. Return negative if not found */
|
---|
571 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
|
---|
572 | {
|
---|
573 | addr_t fp;
|
---|
574 | int i;
|
---|
575 |
|
---|
576 | if (level == 0) {
|
---|
577 | #if defined(__APPLE__)
|
---|
578 | *paddr = uc->uc_mcontext->__ss.__eip;
|
---|
579 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
---|
580 | *paddr = uc->uc_mcontext.mc_eip;
|
---|
581 | #elif defined(__dietlibc__)
|
---|
582 | *paddr = uc->uc_mcontext.eip;
|
---|
583 | #elif defined(__NetBSD__)
|
---|
584 | *paddr = uc->uc_mcontext.__gregs[_REG_EIP];
|
---|
585 | #elif defined(__OpenBSD__)
|
---|
586 | *paddr = uc->sc_eip;
|
---|
587 | #else
|
---|
588 | *paddr = uc->uc_mcontext.gregs[REG_EIP];
|
---|
589 | #endif
|
---|
590 | return 0;
|
---|
591 | } else {
|
---|
592 | #if defined(__APPLE__)
|
---|
593 | fp = uc->uc_mcontext->__ss.__ebp;
|
---|
594 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
---|
595 | fp = uc->uc_mcontext.mc_ebp;
|
---|
596 | #elif defined(__dietlibc__)
|
---|
597 | fp = uc->uc_mcontext.ebp;
|
---|
598 | #elif defined(__NetBSD__)
|
---|
599 | fp = uc->uc_mcontext.__gregs[_REG_EBP];
|
---|
600 | #elif defined(__OpenBSD__)
|
---|
601 | *paddr = uc->sc_ebp;
|
---|
602 | #else
|
---|
603 | fp = uc->uc_mcontext.gregs[REG_EBP];
|
---|
604 | #endif
|
---|
605 | for(i=1;i<level;i++) {
|
---|
606 | /* XXX: check address validity with program info */
|
---|
607 | if (fp <= 0x1000 || fp >= 0xc0000000)
|
---|
608 | return -1;
|
---|
609 | fp = ((addr_t *)fp)[0];
|
---|
610 | }
|
---|
611 | *paddr = ((addr_t *)fp)[1];
|
---|
612 | return 0;
|
---|
613 | }
|
---|
614 | }
|
---|
615 |
|
---|
616 | /* ------------------------------------------------------------- */
|
---|
617 | #elif defined(__x86_64__)
|
---|
618 |
|
---|
619 | /* return the PC at frame level 'level'. Return negative if not found */
|
---|
620 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
|
---|
621 | {
|
---|
622 | addr_t fp;
|
---|
623 | int i;
|
---|
624 |
|
---|
625 | if (level == 0) {
|
---|
626 | /* XXX: only support linux */
|
---|
627 | #if defined(__APPLE__)
|
---|
628 | *paddr = uc->uc_mcontext->__ss.__rip;
|
---|
629 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
---|
630 | *paddr = uc->uc_mcontext.mc_rip;
|
---|
631 | #elif defined(__NetBSD__)
|
---|
632 | *paddr = uc->uc_mcontext.__gregs[_REG_RIP];
|
---|
633 | #else
|
---|
634 | *paddr = uc->uc_mcontext.gregs[REG_RIP];
|
---|
635 | #endif
|
---|
636 | return 0;
|
---|
637 | } else {
|
---|
638 | #if defined(__APPLE__)
|
---|
639 | fp = uc->uc_mcontext->__ss.__rbp;
|
---|
640 | #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
---|
641 | fp = uc->uc_mcontext.mc_rbp;
|
---|
642 | #elif defined(__NetBSD__)
|
---|
643 | fp = uc->uc_mcontext.__gregs[_REG_RBP];
|
---|
644 | #else
|
---|
645 | fp = uc->uc_mcontext.gregs[REG_RBP];
|
---|
646 | #endif
|
---|
647 | for(i=1;i<level;i++) {
|
---|
648 | /* XXX: check address validity with program info */
|
---|
649 | if (fp <= 0x1000)
|
---|
650 | return -1;
|
---|
651 | fp = ((addr_t *)fp)[0];
|
---|
652 | }
|
---|
653 | *paddr = ((addr_t *)fp)[1];
|
---|
654 | return 0;
|
---|
655 | }
|
---|
656 | }
|
---|
657 |
|
---|
658 | /* ------------------------------------------------------------- */
|
---|
659 | #elif defined(__arm__)
|
---|
660 |
|
---|
661 | /* return the PC at frame level 'level'. Return negative if not found */
|
---|
662 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
|
---|
663 | {
|
---|
664 | addr_t fp, sp;
|
---|
665 | int i;
|
---|
666 |
|
---|
667 | if (level == 0) {
|
---|
668 | /* XXX: only supports linux */
|
---|
669 | #if defined(__linux__)
|
---|
670 | *paddr = uc->uc_mcontext.arm_pc;
|
---|
671 | #else
|
---|
672 | return -1;
|
---|
673 | #endif
|
---|
674 | return 0;
|
---|
675 | } else {
|
---|
676 | #if defined(__linux__)
|
---|
677 | fp = uc->uc_mcontext.arm_fp;
|
---|
678 | sp = uc->uc_mcontext.arm_sp;
|
---|
679 | if (sp < 0x1000)
|
---|
680 | sp = 0x1000;
|
---|
681 | #else
|
---|
682 | return -1;
|
---|
683 | #endif
|
---|
684 | /* XXX: specific to tinycc stack frames */
|
---|
685 | if (fp < sp + 12 || fp & 3)
|
---|
686 | return -1;
|
---|
687 | for(i = 1; i < level; i++) {
|
---|
688 | sp = ((addr_t *)fp)[-2];
|
---|
689 | if (sp < fp || sp - fp > 16 || sp & 3)
|
---|
690 | return -1;
|
---|
691 | fp = ((addr_t *)fp)[-3];
|
---|
692 | if (fp <= sp || fp - sp < 12 || fp & 3)
|
---|
693 | return -1;
|
---|
694 | }
|
---|
695 | /* XXX: check address validity with program info */
|
---|
696 | *paddr = ((addr_t *)fp)[-1];
|
---|
697 | return 0;
|
---|
698 | }
|
---|
699 | }
|
---|
700 |
|
---|
701 | /* ------------------------------------------------------------- */
|
---|
702 | #elif defined(__aarch64__)
|
---|
703 |
|
---|
704 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
|
---|
705 | {
|
---|
706 | if (level < 0)
|
---|
707 | return -1;
|
---|
708 | else if (level == 0) {
|
---|
709 | *paddr = uc->uc_mcontext.pc;
|
---|
710 | return 0;
|
---|
711 | }
|
---|
712 | else {
|
---|
713 | addr_t *fp = (addr_t *)uc->uc_mcontext.regs[29];
|
---|
714 | int i;
|
---|
715 | for (i = 1; i < level; i++)
|
---|
716 | fp = (addr_t *)fp[0];
|
---|
717 | *paddr = fp[1];
|
---|
718 | return 0;
|
---|
719 | }
|
---|
720 | }
|
---|
721 |
|
---|
722 | /* ------------------------------------------------------------- */
|
---|
723 | #else
|
---|
724 |
|
---|
725 | #warning add arch specific rt_get_caller_pc()
|
---|
726 | static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
|
---|
727 | {
|
---|
728 | return -1;
|
---|
729 | }
|
---|
730 |
|
---|
731 | #endif /* !__i386__ */
|
---|
732 |
|
---|
733 | /* ------------------------------------------------------------- */
|
---|
734 | #else /* WIN32 */
|
---|
735 |
|
---|
736 | static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
|
---|
737 | {
|
---|
738 | EXCEPTION_RECORD *er = ex_info->ExceptionRecord;
|
---|
739 | CONTEXT *uc = ex_info->ContextRecord;
|
---|
740 | switch (er->ExceptionCode) {
|
---|
741 | case EXCEPTION_ACCESS_VIOLATION:
|
---|
742 | if (rt_bound_error_msg && *rt_bound_error_msg)
|
---|
743 | rt_error(uc, *rt_bound_error_msg);
|
---|
744 | else
|
---|
745 | rt_error(uc, "access violation");
|
---|
746 | break;
|
---|
747 | case EXCEPTION_STACK_OVERFLOW:
|
---|
748 | rt_error(uc, "stack overflow");
|
---|
749 | break;
|
---|
750 | case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
---|
751 | rt_error(uc, "division by zero");
|
---|
752 | break;
|
---|
753 | default:
|
---|
754 | rt_error(uc, "exception caught");
|
---|
755 | break;
|
---|
756 | }
|
---|
757 | return EXCEPTION_EXECUTE_HANDLER;
|
---|
758 | }
|
---|
759 |
|
---|
760 | /* Generate a stack backtrace when a CPU exception occurs. */
|
---|
761 | static void set_exception_handler(void)
|
---|
762 | {
|
---|
763 | SetUnhandledExceptionFilter(cpu_exception_handler);
|
---|
764 | }
|
---|
765 |
|
---|
766 | /* return the PC at frame level 'level'. Return non zero if not found */
|
---|
767 | static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)
|
---|
768 | {
|
---|
769 | addr_t fp, pc;
|
---|
770 | int i;
|
---|
771 | #ifdef _WIN64
|
---|
772 | pc = uc->Rip;
|
---|
773 | fp = uc->Rbp;
|
---|
774 | #else
|
---|
775 | pc = uc->Eip;
|
---|
776 | fp = uc->Ebp;
|
---|
777 | #endif
|
---|
778 | if (level > 0) {
|
---|
779 | for(i=1;i<level;i++) {
|
---|
780 | /* XXX: check address validity with program info */
|
---|
781 | if (fp <= 0x1000 || fp >= 0xc0000000)
|
---|
782 | return -1;
|
---|
783 | fp = ((addr_t*)fp)[0];
|
---|
784 | }
|
---|
785 | pc = ((addr_t*)fp)[1];
|
---|
786 | }
|
---|
787 | *paddr = pc;
|
---|
788 | return 0;
|
---|
789 | }
|
---|
790 |
|
---|
791 | #endif /* _WIN32 */
|
---|
792 | #endif /* CONFIG_TCC_BACKTRACE */
|
---|
793 | /* ------------------------------------------------------------- */
|
---|
794 | #ifdef CONFIG_TCC_STATIC
|
---|
795 |
|
---|
796 | /* dummy function for profiling */
|
---|
797 | ST_FUNC void *dlopen(const char *filename, int flag)
|
---|
798 | {
|
---|
799 | return NULL;
|
---|
800 | }
|
---|
801 |
|
---|
802 | ST_FUNC void dlclose(void *p)
|
---|
803 | {
|
---|
804 | }
|
---|
805 |
|
---|
806 | ST_FUNC const char *dlerror(void)
|
---|
807 | {
|
---|
808 | return "error";
|
---|
809 | }
|
---|
810 |
|
---|
811 | typedef struct TCCSyms {
|
---|
812 | char *str;
|
---|
813 | void *ptr;
|
---|
814 | } TCCSyms;
|
---|
815 |
|
---|
816 | #if !defined(CONFIG_TCCBOOT)
|
---|
817 | extern int __environ;
|
---|
818 | extern int __expand_heap;
|
---|
819 | extern int __get_handler_set;
|
---|
820 | extern int __get_locale;
|
---|
821 | extern int __gmt;
|
---|
822 | extern int __h_errno_location;
|
---|
823 | extern int __hwcap;
|
---|
824 | extern int __init_tls;
|
---|
825 | extern int __libc;
|
---|
826 | extern int __libc_sigaction;
|
---|
827 | extern int __libc_start_main;
|
---|
828 | extern int __malloc0;
|
---|
829 | extern int __ofl_lock;
|
---|
830 | extern int __ofl_unlock;
|
---|
831 | extern int __progname;
|
---|
832 | extern int __progname_full;
|
---|
833 | extern int __secs_to_zone;
|
---|
834 | extern int __sigaction;
|
---|
835 | extern int __sysinfo;
|
---|
836 | extern int __tm_to_tzname;
|
---|
837 | //extern int atexit;
|
---|
838 | //extern int environ;
|
---|
839 | //extern int free;
|
---|
840 | extern int gethostbyname2;
|
---|
841 | //extern int getopt;
|
---|
842 | extern int getpwnam;
|
---|
843 | //extern int gmtime;
|
---|
844 | //extern int localtime;
|
---|
845 | //extern int malloc;
|
---|
846 | extern int mbrtowc;
|
---|
847 | //extern int optarg;
|
---|
848 | extern int optind;
|
---|
849 | //extern int rand;
|
---|
850 | //extern int realloc;
|
---|
851 | //extern int setenv;
|
---|
852 | extern int setlocale;
|
---|
853 | //extern int sigaction;
|
---|
854 | //extern int srand;
|
---|
855 | //extern int stderr;
|
---|
856 | //extern int stdin;
|
---|
857 | //extern int stdout;
|
---|
858 | //extern int strtok;
|
---|
859 | extern int syslog;
|
---|
860 | extern int vsyslog;
|
---|
861 | #endif
|
---|
862 |
|
---|
863 | /* add the symbol you want here if no dynamic linking is done */
|
---|
864 | static TCCSyms tcc_syms[] = {
|
---|
865 | #if !defined(CONFIG_TCCBOOT)
|
---|
866 | #define TCCSYM(a) { #a, &a, },
|
---|
867 | TCCSYM(__environ)
|
---|
868 | TCCSYM(__expand_heap)
|
---|
869 | TCCSYM(__get_handler_set)
|
---|
870 | TCCSYM(__get_locale)
|
---|
871 | TCCSYM(__gmt)
|
---|
872 | TCCSYM(__h_errno_location)
|
---|
873 | TCCSYM(__hwcap)
|
---|
874 | TCCSYM(__init_tls)
|
---|
875 | TCCSYM(__libc)
|
---|
876 | TCCSYM(__libc_sigaction)
|
---|
877 | TCCSYM(__libc_start_main)
|
---|
878 | TCCSYM(__malloc0)
|
---|
879 | TCCSYM(__ofl_lock)
|
---|
880 | TCCSYM(__ofl_unlock)
|
---|
881 | TCCSYM(__progname)
|
---|
882 | TCCSYM(__progname_full)
|
---|
883 | TCCSYM(__secs_to_zone)
|
---|
884 | TCCSYM(__sigaction)
|
---|
885 | TCCSYM(__sysinfo)
|
---|
886 | TCCSYM(__tm_to_tzname)
|
---|
887 | TCCSYM(atexit)
|
---|
888 | TCCSYM(environ)
|
---|
889 | TCCSYM(free)
|
---|
890 | TCCSYM(gethostbyname2)
|
---|
891 | TCCSYM(getopt)
|
---|
892 | TCCSYM(getpwnam)
|
---|
893 | TCCSYM(gmtime)
|
---|
894 | TCCSYM(localtime)
|
---|
895 | TCCSYM(malloc)
|
---|
896 | TCCSYM(mbrtowc)
|
---|
897 | TCCSYM(optarg)
|
---|
898 | TCCSYM(optind)
|
---|
899 | TCCSYM(rand)
|
---|
900 | TCCSYM(realloc)
|
---|
901 | TCCSYM(setenv)
|
---|
902 | TCCSYM(setlocale)
|
---|
903 | TCCSYM(sigaction)
|
---|
904 | TCCSYM(srand)
|
---|
905 | TCCSYM(stderr)
|
---|
906 | TCCSYM(stdin)
|
---|
907 | TCCSYM(stdout)
|
---|
908 | TCCSYM(strtok)
|
---|
909 | TCCSYM(syslog)
|
---|
910 | TCCSYM(vsyslog)
|
---|
911 | #undef TCCSYM
|
---|
912 | #endif
|
---|
913 | { NULL, NULL },
|
---|
914 | };
|
---|
915 |
|
---|
916 | ST_FUNC void *dlsym(void *handle, const char *symbol)
|
---|
917 | {
|
---|
918 | TCCSyms *p;
|
---|
919 | p = tcc_syms;
|
---|
920 | while (p->str != NULL) {
|
---|
921 | if (!strcmp(p->str, symbol))
|
---|
922 | return p->ptr;
|
---|
923 | p++;
|
---|
924 | }
|
---|
925 | return NULL;
|
---|
926 | }
|
---|
927 |
|
---|
928 | #endif /* CONFIG_TCC_STATIC */
|
---|
929 | #endif /* TCC_IS_NATIVE */
|
---|
930 | /* ------------------------------------------------------------- */
|
---|