?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
riscv64-asm.c: correct check for 12-bit immediate
[tinycc.git] / tccrun.c
blobb102d829096214d47ec8216b935674922c5ab132
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 typedef struct rt_context
27 {
28 #ifdef CONFIG_TCC_BACKTRACE
29 /* --> tccelf.c:tcc_add_btstub wants those below in that order: */
30 union {
31 struct {
32 Stab_Sym *stab_sym, *stab_sym_end;
33 char *stab_str;
34 };
35 struct {
36 unsigned char *dwarf_line, *dwarf_line_end, *dwarf_line_str;
37 };
38 };
39 addr_t dwarf;
40 ElfW(Sym) *esym_start, *esym_end;
41 char *elf_str;
42 addr_t prog_base;
43 void *bounds_start;
44 struct rt_context *next;
45 /* <-- */
46 int num_callers;
47 addr_t ip, fp, sp;
48 void *top_func;
49 #endif
50 jmp_buf jb;
51 int do_jmp;
52 # define NR_AT_EXIT 32
53 int nr_exit;
54 void *exitfunc[NR_AT_EXIT];
55 void *exitarg[NR_AT_EXIT];
56 } rt_context;
57
58 static rt_context g_rtctxt;
59 static void rt_exit(int code)
60 {
61 rt_context *rc = &g_rtctxt;
62 if (rc->do_jmp)
63 longjmp(rc->jb, code ? code : 256);
64 exit(code);
65 }
66
67 #ifdef CONFIG_TCC_BACKTRACE
68 static void set_exception_handler(void);
69 static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap);
70 #endif /* CONFIG_TCC_BACKTRACE */
71
72 /* defined when included from lib/bt-exe.c */
73 #ifndef CONFIG_TCC_BACKTRACE_ONLY
74
75 #ifndef _WIN32
76 # include <sys/mman.h>
77 #endif
78
79 static int set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length);
80 static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff);
81
82 #ifdef _WIN64
83 static void *win64_add_function_table(TCCState *s1);
84 static void win64_del_function_table(void *);
85 #endif
86
87 /* ------------------------------------------------------------- */
88 /* Do all relocations (needed before using tcc_get_symbol())
89 Returns -1 on error. */
90
91 LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)
92 {
93 int size;
94 addr_t ptr_diff = 0;
95
96 if (TCC_RELOCATE_AUTO != ptr)
97 return tcc_relocate_ex(s1, ptr, 0);
98
99 size = tcc_relocate_ex(s1, NULL, 0);
100 if (size < 0)
101 return -1;
102
103 #ifdef HAVE_SELINUX
104 {
105 /* Using mmap instead of malloc */
106 void *prx;
107 char tmpfname[] = "/tmp/.tccrunXXXXXX";
108 int fd = mkstemp(tmpfname);
109 unlink(tmpfname);
110 ftruncate(fd, size);
111
112 size = (size + (PAGESIZE-1)) & ~(PAGESIZE-1);
113 ptr = mmap(NULL, size * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
114 /* mmap RX memory at a fixed distance */
115 prx = mmap((char*)ptr + size, size, PROT_READ|PROT_EXEC, MAP_SHARED|MAP_FIXED, fd, 0);
116 close(fd);
117 if (ptr == MAP_FAILED || prx == MAP_FAILED)
118 return tcc_error_noabort("tccrun: could not map memory");
119 ptr_diff = (char*)prx - (char*)ptr;
120 //printf("map %p %p %p\n", ptr, prx, (void*)ptr_diff);
121 }
122 #else
123 ptr = tcc_malloc(size);
124 #endif
125 if (tcc_relocate_ex(s1, ptr, ptr_diff))
126 return -1;
127 dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, (void*)(addr_t)size);
128 dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, ptr);
129 return 0;
130 }
131
132 ST_FUNC void tcc_run_free(TCCState *s1)
133 {
134 int i;
135
136 for (i = 0; i < s1->nb_runtime_mem; i += 2) {
137 unsigned size = (unsigned)(addr_t)s1->runtime_mem[i];
138 void *ptr = s1->runtime_mem[i+1];
139 #ifdef HAVE_SELINUX
140 munmap(ptr, size * 2);
141 #else
142 /* unprotect memory to make it usable for malloc again */
143 set_pages_executable(s1, 2, ptr, size);
144 #ifdef _WIN64
145 win64_del_function_table(*(void**)ptr);
146 #endif
147 tcc_free(ptr);
148 #endif
149 }
150 tcc_free(s1->runtime_mem);
151 }
152
153 static void run_cdtors(TCCState *s1, const char *start, const char *end,
154 int argc, char **argv, char **envp)
155 {
156 void **a = (void **)get_sym_addr(s1, start, 0, 0);
157 void **b = (void **)get_sym_addr(s1, end, 0, 0);
158 while (a != b)
159 ((void(*)(int, char **, char **))*a++)(argc, argv, envp);
160 }
161
162 static void run_on_exit(int ret)
163 {
164 rt_context *rc = &g_rtctxt;
165 int n = rc->nr_exit;
166 while (n)
167 --n, ((void(*)(int,void*))rc->exitfunc[n])(ret, rc->exitarg[n]);
168 }
169
170 static int rt_on_exit(void *function, void *arg)
171 {
172 rt_context *rc = &g_rtctxt;
173 if (rc->nr_exit < NR_AT_EXIT) {
174 rc->exitfunc[rc->nr_exit] = function;
175 rc->exitarg[rc->nr_exit++] = arg;
176 return 0;
177 }
178 return 1;
179 }
180
181 static int rt_atexit(void *function)
182 {
183 return rt_on_exit(function, NULL);
184 }
185
186 /* launch the compiled program with the given arguments */
187 LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
188 {
189 int (*prog_main)(int, char **, char **), ret;
190 rt_context *rc = &g_rtctxt;
191
192 #if defined(__APPLE__) || defined(__FreeBSD__)
193 char **envp = NULL;
194 #elif defined(__OpenBSD__) || defined(__NetBSD__)
195 extern char **environ;
196 char **envp = environ;
197 #else
198 char **envp = environ;
199 #endif
200
201 s1->runtime_main = s1->nostdlib ? "_start" : "main";
202 if ((s1->dflag & 16) && (addr_t)-1 == get_sym_addr(s1, s1->runtime_main, 0, 1))
203 return 0;
204
205 tcc_add_symbol(s1, "exit", rt_exit);
206 tcc_add_symbol(s1, "atexit", rt_atexit);
207 tcc_add_symbol(s1, "on_exit", rt_on_exit);
208 if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
209 return -1;
210
211 prog_main = (void*)get_sym_addr(s1, s1->runtime_main, 1, 1);
212 if ((addr_t)-1 == (addr_t)prog_main)
213 return -1;
214
215 memset(rc, 0, sizeof *rc);
216 rc->do_jmp = 1;
217
218 #ifdef CONFIG_TCC_BACKTRACE
219 if (s1->do_debug) {
220 void *p;
221 if (s1->dwarf) {
222 rc->dwarf_line = dwarf_line_section->data;
223 rc->dwarf_line_end = dwarf_line_section->data + dwarf_line_section->data_offset;
224 if (dwarf_line_str_section)
225 rc->dwarf_line_str = dwarf_line_str_section->data;
226 }
227 else
228 {
229 rc->stab_sym = (Stab_Sym *)stab_section->data;
230 rc->stab_sym_end = (Stab_Sym *)(stab_section->data + stab_section->data_offset);
231 rc->stab_str = (char *)stab_section->link->data;
232 }
233 rc->dwarf = s1->dwarf;
234 rc->esym_start = (ElfW(Sym) *)(symtab_section->data);
235 rc->esym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
236 rc->elf_str = (char *)symtab_section->link->data;
237 #if PTR_SIZE == 8
238 rc->prog_base = text_section->sh_addr & 0xffffffff00000000ULL;
239 #if defined TCC_TARGET_MACHO
240 if (s1->dwarf)
241 rc->prog_base = (addr_t) -1;
242 #else
243 #endif
244 #endif
245 rc->top_func = tcc_get_symbol(s1, "main");
246 rc->num_callers = s1->rt_num_callers;
247 if ((p = tcc_get_symbol(s1, "__rt_error")))
248 *(void**)p = _rt_error;
249 #ifdef CONFIG_TCC_BCHECK
250 if (s1->do_bounds_check) {
251 rc->bounds_start = (void*)bounds_section->sh_addr;
252 if ((p = tcc_get_symbol(s1, "__bound_init")))
253 ((void(*)(void*,int))p)(rc->bounds_start, 1);
254 }
255 #endif
256 set_exception_handler();
257 }
258 #endif
259
260 errno = 0; /* clean errno value */
261 fflush(stdout);
262 fflush(stderr);
263
264 /* These aren't C symbols, so don't need leading underscore handling. */
265 run_cdtors(s1, "__init_array_start", "__init_array_end", argc, argv, envp);
266 if (!(ret = setjmp(rc->jb)))
267 ret = prog_main(argc, argv, envp);
268 run_cdtors(s1, "__fini_array_start", "__fini_array_end", 0, NULL, NULL);
269 run_on_exit(ret);
270 if (s1->dflag & 16 && ret) /* tcc -dt -run ... */
271 fprintf(s1->ppfp, "[returns %d]\n", ret), fflush(s1->ppfp);
272 return ret;
273 }
274
275 #define DEBUG_RUNMEN 0
276
277 /* enable rx/ro/rw permissions */
278 #define CONFIG_RUNMEM_RO 1
279
280 #if CONFIG_RUNMEM_RO
281 # define PAGE_ALIGN PAGESIZE
282 #elif defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
283 /* To avoid that x86 processors would reload cached instructions
284 each time when data is written in the near, we need to make
285 sure that code and data do not share the same 64 byte unit */
286 # define PAGE_ALIGN 64
287 #else
288 # define PAGE_ALIGN 1
289 #endif
290
291 /* relocate code. Return -1 on error, required size if ptr is NULL,
292 otherwise copy code into buffer passed by the caller */
293 static int tcc_relocate_ex(TCCState *s1, void *ptr, addr_t ptr_diff)
294 {
295 Section *s;
296 unsigned offset, length, align, max_align, i, k, f;
297 unsigned n, copy;
298 addr_t mem, addr;
299
300 if (NULL == ptr) {
301 s1->nb_errors = 0;
302 #ifdef TCC_TARGET_PE
303 pe_output_file(s1, NULL);
304 #else
305 tcc_add_runtime(s1);
306 resolve_common_syms(s1);
307 build_got_entries(s1, 0);
308 #endif
309 if (s1->nb_errors)
310 return -1;
311 }
312
313 offset = max_align = 0, mem = (addr_t)ptr;
314 #ifdef _WIN64
315 offset += sizeof (void*); /* space for function_table pointer */
316 #endif
317 copy = 0;
318 redo:
319 for (k = 0; k < 3; ++k) { /* 0:rx, 1:ro, 2:rw sections */
320 n = 0; addr = 0;
321 for(i = 1; i < s1->nb_sections; i++) {
322 static const char shf[] = {
323 SHF_ALLOC|SHF_EXECINSTR, SHF_ALLOC, SHF_ALLOC|SHF_WRITE
324 };
325 s = s1->sections[i];
326 if (shf[k] != (s->sh_flags & (SHF_ALLOC|SHF_WRITE|SHF_EXECINSTR)))
327 continue;
328 length = s->data_offset;
329 if (copy) {
330 if (addr == 0)
331 addr = s->sh_addr;
332 n = (s->sh_addr - addr) + length;
333 ptr = (void*)s->sh_addr;
334 if (k == 0)
335 ptr = (void*)(s->sh_addr - ptr_diff);
336 if (NULL == s->data || s->sh_type == SHT_NOBITS)
337 memset(ptr, 0, length);
338 else
339 memcpy(ptr, s->data, length);
340 #ifdef _WIN64
341 if (s == s1->uw_pdata)
342 *(void**)mem = win64_add_function_table(s1);
343 #endif
344 if (s->data) {
345 tcc_free(s->data);
346 s->data = NULL;
347 s->data_allocated = 0;
348 }
349 s->data_offset = 0;
350 continue;
351 }
352 align = s->sh_addralign - 1;
353 if (++n == 1 && align < (PAGE_ALIGN - 1))
354 align = (PAGE_ALIGN - 1);
355 if (max_align < align)
356 max_align = align;
357 addr = k ? mem : mem + ptr_diff;
358 offset += -(addr + offset) & align;
359 s->sh_addr = mem ? addr + offset : 0;
360 offset += length;
361 #if DEBUG_RUNMEN
362 if (mem)
363 printf("%d: %-16s %p len %04x align %04x\n",
364 k, s->name, (void*)s->sh_addr, length, align + 1);
365 #endif
366 }
367 if (copy) { /* set permissions */
368 if (k == 0 && ptr_diff)
369 continue; /* not with HAVE_SELINUX */
370 f = k;
371 #if !CONFIG_RUNMEM_RO
372 if (f != 0)
373 continue;
374 f = 3; /* change only SHF_EXECINSTR to rwx */
375 #endif
376 #if DEBUG_RUNMEN
377 printf("protect %d %p %04x\n", f, (void*)addr, n);
378 #endif
379 if (n) {
380 if (set_pages_executable(s1, f, (void*)addr, n))
381 return -1;
382 }
383 }
384 }
385
386 if (copy)
387 return 0;
388
389 /* relocate symbols */
390 relocate_syms(s1, s1->symtab, !(s1->nostdlib));
391 if (s1->nb_errors)
392 return -1;
393 if (0 == mem)
394 return offset + max_align;
395
396 #ifdef TCC_TARGET_PE
397 s1->pe_imagebase = mem;
398 #endif
399
400 /* relocate sections */
401 #ifndef TCC_TARGET_PE
402 relocate_plt(s1);
403 #endif
404 relocate_sections(s1);
405 copy = 1;
406 goto redo;
407 }
408
409 /* ------------------------------------------------------------- */
410 /* allow to run code in memory */
411
412 static int set_pages_executable(TCCState *s1, int mode, void *ptr, unsigned long length)
413 {
414 #ifdef _WIN32
415 static const unsigned char protect[] = {
416 PAGE_EXECUTE_READ,
417 PAGE_READONLY,
418 PAGE_READWRITE,
419 PAGE_EXECUTE_READWRITE
420 };
421 DWORD old;
422 if (!VirtualProtect(ptr, length, protect[mode], &old))
423 return -1;
424 return 0;
425 #else
426 static const unsigned char protect[] = {
427 PROT_READ | PROT_EXEC,
428 PROT_READ,
429 PROT_READ | PROT_WRITE,
430 PROT_READ | PROT_WRITE | PROT_EXEC
431 };
432 addr_t start, end;
433 start = (addr_t)ptr & ~(PAGESIZE - 1);
434 end = (addr_t)ptr + length;
435 end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
436 if (mprotect((void *)start, end - start, protect[mode]))
437 return tcc_error_noabort("mprotect failed: did you mean to configure --with-selinux?");
438 /* XXX: BSD sometimes dump core with bad system call */
439 # if (defined TCC_TARGET_ARM && !TARGETOS_BSD) || defined TCC_TARGET_ARM64
440 if (mode == 0 || mode == 3) {
441 void __clear_cache(void *beginning, void *end);
442 __clear_cache(ptr, (char *)ptr + length);
443 }
444 # endif
445 return 0;
446 #endif
447 }
448
449 #ifdef _WIN64
450 static void *win64_add_function_table(TCCState *s1)
451 {
452 void *p = NULL;
453 if (s1->uw_pdata) {
454 p = (void*)s1->uw_pdata->sh_addr;
455 RtlAddFunctionTable(
456 (RUNTIME_FUNCTION*)p,
457 s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
458 s1->pe_imagebase
459 );
460 s1->uw_pdata = NULL;
461 }
462 return p;
463 }
464
465 static void win64_del_function_table(void *p)
466 {
467 if (p) {
468 RtlDeleteFunctionTable((RUNTIME_FUNCTION*)p);
469 }
470 }
471 #endif
472 #endif //ndef CONFIG_TCC_BACKTRACE_ONLY
473 /* ------------------------------------------------------------- */
474 #ifdef CONFIG_TCC_BACKTRACE
475
476 static int rt_vprintf(const char *fmt, va_list ap)
477 {
478 int ret = vfprintf(stderr, fmt, ap);
479 fflush(stderr);
480 return ret;
481 }
482
483 static int rt_printf(const char *fmt, ...)
484 {
485 va_list ap;
486 int r;
487 va_start(ap, fmt);
488 r = rt_vprintf(fmt, ap);
489 va_end(ap);
490 return r;
491 }
492
493 static char *rt_elfsym(rt_context *rc, addr_t wanted_pc, addr_t *func_addr)
494 {
495 ElfW(Sym) *esym;
496 for (esym = rc->esym_start + 1; esym < rc->esym_end; ++esym) {
497 int type = ELFW(ST_TYPE)(esym->st_info);
498 if ((type == STT_FUNC || type == STT_GNU_IFUNC)
499 && wanted_pc >= esym->st_value
500 && wanted_pc < esym->st_value + esym->st_size) {
501 *func_addr = esym->st_value;
502 return rc->elf_str + esym->st_name;
503 }
504 }
505 return NULL;
506 }
507
508
509 /* print the position in the source file of PC value 'pc' by reading
510 the stabs debug information */
511 static addr_t rt_printline (rt_context *rc, addr_t wanted_pc,
512 const char *msg, const char *skip)
513 {
514 char func_name[128];
515 addr_t func_addr, last_pc, pc;
516 const char *incl_files[INCLUDE_STACK_SIZE];
517 int incl_index, last_incl_index, len, last_line_num, i;
518 const char *str, *p;
519 Stab_Sym *sym;
520
521 next:
522 func_name[0] = '\0';
523 func_addr = 0;
524 incl_index = 0;
525 last_pc = (addr_t)-1;
526 last_line_num = 1;
527 last_incl_index = 0;
528
529 for (sym = rc->stab_sym + 1; sym < rc->stab_sym_end; ++sym) {
530 str = rc->stab_str + sym->n_strx;
531 pc = sym->n_value;
532
533 switch(sym->n_type) {
534 case N_SLINE:
535 if (func_addr)
536 goto rel_pc;
537 case N_SO:
538 case N_SOL:
539 goto abs_pc;
540 case N_FUN:
541 if (sym->n_strx == 0) /* end of function */
542 goto rel_pc;
543 abs_pc:
544 #if PTR_SIZE == 8
545 /* Stab_Sym.n_value is only 32bits */
546 pc += rc->prog_base;
547 #endif
548 goto check_pc;
549 rel_pc:
550 pc += func_addr;
551 check_pc:
552 if (pc >= wanted_pc && wanted_pc >= last_pc)
553 goto found;
554 break;
555 }
556
557 switch(sym->n_type) {
558 /* function start or end */
559 case N_FUN:
560 if (sym->n_strx == 0)
561 goto reset_func;
562 p = strchr(str, ':');
563 if (0 == p || (len = p - str + 1, len > sizeof func_name))
564 len = sizeof func_name;
565 pstrcpy(func_name, len, str);
566 func_addr = pc;
567 break;
568 /* line number info */
569 case N_SLINE:
570 last_pc = pc;
571 last_line_num = sym->n_desc;
572 last_incl_index = incl_index;
573 break;
574 /* include files */
575 case N_BINCL:
576 if (incl_index < INCLUDE_STACK_SIZE)
577 incl_files[incl_index++] = str;
578 break;
579 case N_EINCL:
580 if (incl_index > 1)
581 incl_index--;
582 break;
583 /* start/end of translation unit */
584 case N_SO:
585 incl_index = 0;
586 if (sym->n_strx) {
587 /* do not add path */
588 len = strlen(str);
589 if (len > 0 && str[len - 1] != '/')
590 incl_files[incl_index++] = str;
591 }
592 reset_func:
593 func_name[0] = '\0';
594 func_addr = 0;
595 last_pc = (addr_t)-1;
596 break;
597 /* alternative file name (from #line or #include directives) */
598 case N_SOL:
599 if (incl_index)
600 incl_files[incl_index-1] = str;
601 break;
602 }
603 }
604
605 func_name[0] = '\0';
606 func_addr = 0;
607 last_incl_index = 0;
608 /* we try symtab symbols (no line number info) */
609 p = rt_elfsym(rc, wanted_pc, &func_addr);
610 if (p) {
611 pstrcpy(func_name, sizeof func_name, p);
612 goto found;
613 }
614 if ((rc = rc->next))
615 goto next;
616 found:
617 i = last_incl_index;
618 if (i > 0) {
619 str = incl_files[--i];
620 if (skip[0] && strstr(str, skip))
621 return (addr_t)-1;
622 rt_printf("%s:%d: ", str, last_line_num);
623 } else
624 rt_printf("%08llx : ", (long long)wanted_pc);
625 rt_printf("%s %s", msg, func_name[0] ? func_name : "???");
626 #if 0
627 if (--i >= 0) {
628 rt_printf(" (included from ");
629 for (;;) {
630 rt_printf("%s", incl_files[i]);
631 if (--i < 0)
632 break;
633 rt_printf(", ");
634 }
635 rt_printf(")");
636 }
637 #endif
638 return func_addr;
639 }
640
641 /* ------------------------------------------------------------- */
642 /* rt_printline - dwarf version */
643
644 #define MAX_128 ((8 * sizeof (long long) + 6) / 7)
645
646 #define DIR_TABLE_SIZE (64)
647 #define FILE_TABLE_SIZE (512)
648
649 #define dwarf_read_1(ln,end) \
650 ((ln) < (end) ? *(ln)++ : 0)
651 #define dwarf_read_2(ln,end) \
652 ((ln) + 2 < (end) ? (ln) += 2, read16le((ln) - 2) : 0)
653 #define dwarf_read_4(ln,end) \
654 ((ln) + 4 < (end) ? (ln) += 4, read32le((ln) - 4) : 0)
655 #define dwarf_read_8(ln,end) \
656 ((ln) + 8 < (end) ? (ln) += 8, read64le((ln) - 8) : 0)
657 #define dwarf_ignore_type(ln, end) /* timestamp/size/md5/... */ \
658 switch (entry_format[j].form) { \
659 case DW_FORM_data1: (ln) += 1; break; \
660 case DW_FORM_data2: (ln) += 2; break; \
661 case DW_FORM_data4: (ln) += 3; break; \
662 case DW_FORM_data8: (ln) += 8; break; \
663 case DW_FORM_data16: (ln) += 16; break; \
664 case DW_FORM_udata: dwarf_read_uleb128(&(ln), (end)); break; \
665 default: goto next_line; \
666 }
667
668 static unsigned long long
669 dwarf_read_uleb128(unsigned char **ln, unsigned char *end)
670 {
671 unsigned char *cp = *ln;
672 unsigned long long retval = 0;
673 int i;
674
675 for (i = 0; i < MAX_128; i++) {
676 unsigned long long byte = dwarf_read_1(cp, end);
677
678 retval |= (byte & 0x7f) << (i * 7);
679 if ((byte & 0x80) == 0)
680 break;
681 }
682 *ln = cp;
683 return retval;
684 }
685
686 static long long
687 dwarf_read_sleb128(unsigned char **ln, unsigned char *end)
688 {
689 unsigned char *cp = *ln;
690 long long retval = 0;
691 int i;
692
693 for (i = 0; i < MAX_128; i++) {
694 unsigned long long byte = dwarf_read_1(cp, end);
695
696 retval |= (byte & 0x7f) << (i * 7);
697 if ((byte & 0x80) == 0) {
698 if ((byte & 0x40) && (i + 1) * 7 < 64)
699 retval |= -1LL << ((i + 1) * 7);
700 break;
701 }
702 }
703 *ln = cp;
704 return retval;
705 }
706
707 static addr_t rt_printline_dwarf (rt_context *rc, addr_t wanted_pc,
708 const char *msg, const char *skip)
709 {
710 unsigned char *ln;
711 unsigned char *cp;
712 unsigned char *end;
713 unsigned char *opcode_length;
714 unsigned long long size;
715 unsigned int length;
716 unsigned char version;
717 unsigned int min_insn_length;
718 unsigned int max_ops_per_insn;
719 int line_base;
720 unsigned int line_range;
721 unsigned int opcode_base;
722 unsigned int opindex;
723 unsigned int col;
724 unsigned int i;
725 unsigned int j;
726 unsigned int len;
727 unsigned long long value;
728 struct {
729 unsigned int type;
730 unsigned int form;
731 } entry_format[256];
732 unsigned int dir_size;
733 #if 0
734 char *dirs[DIR_TABLE_SIZE];
735 #endif
736 unsigned int filename_size;
737 struct dwarf_filename_struct {
738 unsigned int dir_entry;
739 char *name;
740 } filename_table[FILE_TABLE_SIZE];
741 addr_t last_pc;
742 addr_t pc;
743 addr_t func_addr;
744 int line;
745 char *filename;
746 char *function;
747
748 next:
749 ln = rc->dwarf_line;
750 while (ln < rc->dwarf_line_end) {
751 dir_size = 0;
752 filename_size = 0;
753 last_pc = 0;
754 pc = 0;
755 func_addr = 0;
756 line = 1;
757 filename = NULL;
758 function = NULL;
759 length = 4;
760 size = dwarf_read_4(ln, rc->dwarf_line_end);
761 if (size == 0xffffffffu) // dwarf 64
762 length = 8, size = dwarf_read_8(ln, rc->dwarf_line_end);
763 end = ln + size;
764 if (end < ln || end > rc->dwarf_line_end)
765 break;
766 version = dwarf_read_2(ln, end);
767 if (version >= 5)
768 ln += length + 2; // address size, segment selector, prologue Length
769 else
770 ln += length; // prologue Length
771 min_insn_length = dwarf_read_1(ln, end);
772 if (version >= 4)
773 max_ops_per_insn = dwarf_read_1(ln, end);
774 else
775 max_ops_per_insn = 1;
776 ln++; // Initial value of 'is_stmt'
777 line_base = dwarf_read_1(ln, end);
778 line_base |= line_base >= 0x80 ? ~0xff : 0;
779 line_range = dwarf_read_1(ln, end);
780 opcode_base = dwarf_read_1(ln, end);
781 opcode_length = ln;
782 ln += opcode_base - 1;
783 opindex = 0;
784 if (version >= 5) {
785 col = dwarf_read_1(ln, end);
786 for (i = 0; i < col; i++) {
787 entry_format[i].type = dwarf_read_uleb128(&ln, end);
788 entry_format[i].form = dwarf_read_uleb128(&ln, end);
789 }
790 dir_size = dwarf_read_uleb128(&ln, end);
791 for (i = 0; i < dir_size; i++) {
792 for (j = 0; j < col; j++) {
793 if (entry_format[j].type == DW_LNCT_path) {
794 if (entry_format[j].form != DW_FORM_line_strp)
795 goto next_line;
796 #if 0
797 value = length == 4 ? dwarf_read_4(ln, end)
798 : dwarf_read_8(ln, end);
799 if (i < DIR_TABLE_SIZE)
800 dirs[i] = (char *)rc->dwarf_line_str + value;
801 #else
802 length == 4 ? dwarf_read_4(ln, end)
803 : dwarf_read_8(ln, end);
804 #endif
805 }
806 else
807 dwarf_ignore_type(ln, end);
808 }
809 }
810 col = dwarf_read_1(ln, end);
811 for (i = 0; i < col; i++) {
812 entry_format[i].type = dwarf_read_uleb128(&ln, end);
813 entry_format[i].form = dwarf_read_uleb128(&ln, end);
814 }
815 filename_size = dwarf_read_uleb128(&ln, end);
816 for (i = 0; i < filename_size; i++)
817 for (j = 0; j < col; j++) {
818 if (entry_format[j].type == DW_LNCT_path) {
819 if (entry_format[j].form != DW_FORM_line_strp)
820 goto next_line;
821 value = length == 4 ? dwarf_read_4(ln, end)
822 : dwarf_read_8(ln, end);
823 if (i < FILE_TABLE_SIZE)
824 filename_table[i].name =
825 (char *)rc->dwarf_line_str + value;
826 }
827 else if (entry_format[j].type == DW_LNCT_directory_index) {
828 switch (entry_format[j].form) {
829 case DW_FORM_data1: value = dwarf_read_1(ln, end); break;
830 case DW_FORM_data2: value = dwarf_read_2(ln, end); break;
831 case DW_FORM_data4: value = dwarf_read_4(ln, end); break;
832 case DW_FORM_udata: value = dwarf_read_uleb128(&ln, end); break;
833 default: goto next_line;
834 }
835 if (i < FILE_TABLE_SIZE)
836 filename_table[i].dir_entry = value;
837 }
838 else
839 dwarf_ignore_type(ln, end);
840 }
841 }
842 else {
843 while ((dwarf_read_1(ln, end))) {
844 #if 0
845 if (++dir_size < DIR_TABLE_SIZE)
846 dirs[dir_size - 1] = (char *)ln - 1;
847 #endif
848 while (dwarf_read_1(ln, end)) {}
849 }
850 while ((dwarf_read_1(ln, end))) {
851 if (++filename_size < FILE_TABLE_SIZE) {
852 filename_table[filename_size - 1].name = (char *)ln - 1;
853 while (dwarf_read_1(ln, end)) {}
854 filename_table[filename_size - 1].dir_entry =
855 dwarf_read_uleb128(&ln, end);
856 }
857 else {
858 while (dwarf_read_1(ln, end)) {}
859 dwarf_read_uleb128(&ln, end);
860 }
861 dwarf_read_uleb128(&ln, end); // time
862 dwarf_read_uleb128(&ln, end); // size
863 }
864 }
865 if (filename_size >= 1)
866 filename = filename_table[0].name;
867 while (ln < end) {
868 last_pc = pc;
869 i = dwarf_read_1(ln, end);
870 if (i >= opcode_base) {
871 if (max_ops_per_insn == 1)
872 pc += ((i - opcode_base) / line_range) * min_insn_length;
873 else {
874 pc += (opindex + (i - opcode_base) / line_range) /
875 max_ops_per_insn * min_insn_length;
876 opindex = (opindex + (i - opcode_base) / line_range) %
877 max_ops_per_insn;
878 }
879 i = (int)((i - opcode_base) % line_range) + line_base;
880 check_pc:
881 if (pc >= wanted_pc && wanted_pc >= last_pc)
882 goto found;
883 line += i;
884 }
885 else {
886 switch (i) {
887 case 0:
888 len = dwarf_read_uleb128(&ln, end);
889 cp = ln;
890 ln += len;
891 if (len == 0)
892 goto next_line;
893 switch (dwarf_read_1(cp, end)) {
894 case DW_LNE_end_sequence:
895 break;
896 case DW_LNE_set_address:
897 #if PTR_SIZE == 4
898 pc = dwarf_read_4(cp, end);
899 #else
900 pc = dwarf_read_8(cp, end);
901 #endif
902 #if defined TCC_TARGET_MACHO
903 if (rc->prog_base != (addr_t) -1)
904 pc += rc->prog_base;
905 #endif
906 opindex = 0;
907 break;
908 case DW_LNE_define_file: /* deprecated */
909 if (++filename_size < FILE_TABLE_SIZE) {
910 filename_table[filename_size - 1].name = (char *)ln - 1;
911 while (dwarf_read_1(ln, end)) {}
912 filename_table[filename_size - 1].dir_entry =
913 dwarf_read_uleb128(&ln, end);
914 }
915 else {
916 while (dwarf_read_1(ln, end)) {}
917 dwarf_read_uleb128(&ln, end);
918 }
919 dwarf_read_uleb128(&ln, end); // time
920 dwarf_read_uleb128(&ln, end); // size
921 break;
922 case DW_LNE_hi_user - 1:
923 function = (char *)cp;
924 func_addr = pc;
925 break;
926 default:
927 break;
928 }
929 break;
930 case DW_LNS_advance_pc:
931 if (max_ops_per_insn == 1)
932 pc += dwarf_read_uleb128(&ln, end) * min_insn_length;
933 else {
934 unsigned long long off = dwarf_read_uleb128(&ln, end);
935
936 pc += (opindex + off) / max_ops_per_insn *
937 min_insn_length;
938 opindex = (opindex + off) % max_ops_per_insn;
939 }
940 i = 0;
941 goto check_pc;
942 case DW_LNS_advance_line:
943 line += dwarf_read_sleb128(&ln, end);
944 break;
945 case DW_LNS_set_file:
946 i = dwarf_read_uleb128(&ln, end);
947 i -= i > 0 && version < 5;
948 if (i < FILE_TABLE_SIZE && i < filename_size)
949 filename = filename_table[i].name;
950 break;
951 case DW_LNS_const_add_pc:
952 if (max_ops_per_insn == 1)
953 pc += ((255 - opcode_base) / line_range) * min_insn_length;
954 else {
955 unsigned int off = (255 - opcode_base) / line_range;
956
957 pc += ((opindex + off) / max_ops_per_insn) *
958 min_insn_length;
959 opindex = (opindex + off) % max_ops_per_insn;
960 }
961 i = 0;
962 goto check_pc;
963 case DW_LNS_fixed_advance_pc:
964 i = dwarf_read_2(ln, end);
965 pc += i;
966 opindex = 0;
967 i = 0;
968 goto check_pc;
969 default:
970 for (j = 0; j < opcode_length[i - 1]; j++)
971 dwarf_read_uleb128 (&ln, end);
972 break;
973 }
974 }
975 }
976 next_line:
977 ln = end;
978 }
979
980 filename = NULL;
981 func_addr = 0;
982 /* we try symtab symbols (no line number info) */
983 function = rt_elfsym(rc, wanted_pc, &func_addr);
984 if (function)
985 goto found;
986 if ((rc = rc->next))
987 goto next;
988 found:
989 if (filename) {
990 if (skip[0] && strstr(filename, skip))
991 return (addr_t)-1;
992 rt_printf("%s:%d: ", filename, line);
993 }
994 else
995 rt_printf("0x%08llx : ", (long long)wanted_pc);
996 rt_printf("%s %s", msg, function ? function : "???");
997 return (addr_t)func_addr;
998 }
999 /* ------------------------------------------------------------- */
1000
1001 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level);
1002
1003 static int _rt_error(void *fp, void *ip, const char *fmt, va_list ap)
1004 {
1005 rt_context *rc = &g_rtctxt;
1006 addr_t pc = 0;
1007 char skip[100];
1008 int i, level, ret, n, one;
1009 const char *a, *b, *msg;
1010
1011 if (fp) {
1012 /* we're called from tcc_backtrace. */
1013 rc->fp = (addr_t)fp;
1014 rc->ip = (addr_t)ip;
1015 msg = "";
1016 } else {
1017 /* we're called from signal/exception handler */
1018 msg = "RUNTIME ERROR: ";
1019 }
1020
1021 skip[0] = 0;
1022 /* If fmt is like "^file.c^..." then skip calls from 'file.c' */
1023 if (fmt[0] == '^' && (b = strchr(a = fmt + 1, fmt[0]))) {
1024 memcpy(skip, a, b - a), skip[b - a] = 0;
1025 fmt = b + 1;
1026 }
1027 one = 0;
1028 /* hack for bcheck.c:dprintf(): one level, no newline */
1029 if (fmt[0] == '\001')
1030 ++fmt, one = 1;
1031
1032 n = rc->num_callers ? rc->num_callers : 6;
1033 for (i = level = 0; level < n; i++) {
1034 ret = rt_get_caller_pc(&pc, rc, i);
1035 a = "%s";
1036 if (ret != -1) {
1037 if (rc->dwarf)
1038 pc = rt_printline_dwarf(rc, pc, level ? "by" : "at", skip);
1039 else
1040 pc = rt_printline(rc, pc, level ? "by" : "at", skip);
1041 if (pc == (addr_t)-1)
1042 continue;
1043 a = ": %s";
1044 }
1045 if (level == 0) {
1046 rt_printf(a, msg);
1047 rt_vprintf(fmt, ap);
1048 } else if (ret == -1)
1049 break;
1050 if (one)
1051 break;
1052 rt_printf("\n");
1053 if (ret == -1 || (pc == (addr_t)rc->top_func && pc))
1054 break;
1055 ++level;
1056 }
1057
1058 rc->ip = rc->fp = 0;
1059 return 0;
1060 }
1061
1062 /* emit a run time error at position 'pc' */
1063 static int rt_error(const char *fmt, ...)
1064 {
1065 va_list ap;
1066 int ret;
1067 va_start(ap, fmt);
1068 ret = _rt_error(0, 0, fmt, ap);
1069 va_end(ap);
1070 return ret;
1071 }
1072
1073 /* ------------------------------------------------------------- */
1074
1075 #ifndef _WIN32
1076 # include <signal.h>
1077 # ifndef __OpenBSD__
1078 # include <sys/ucontext.h>
1079 # endif
1080 #else
1081 # define ucontext_t CONTEXT
1082 #endif
1083
1084 /* translate from ucontext_t* to internal rt_context * */
1085 static void rt_getcontext(ucontext_t *uc, rt_context *rc)
1086 {
1087 #if defined _WIN64
1088 rc->ip = uc->Rip;
1089 rc->fp = uc->Rbp;
1090 rc->sp = uc->Rsp;
1091 #elif defined _WIN32
1092 rc->ip = uc->Eip;
1093 rc->fp = uc->Ebp;
1094 rc->sp = uc->Esp;
1095 #elif defined __i386__
1096 # if defined(__APPLE__)
1097 rc->ip = uc->uc_mcontext->__ss.__eip;
1098 rc->fp = uc->uc_mcontext->__ss.__ebp;
1099 # elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1100 rc->ip = uc->uc_mcontext.mc_eip;
1101 rc->fp = uc->uc_mcontext.mc_ebp;
1102 # elif defined(__dietlibc__)
1103 rc->ip = uc->uc_mcontext.eip;
1104 rc->fp = uc->uc_mcontext.ebp;
1105 # elif defined(__NetBSD__)
1106 rc->ip = uc->uc_mcontext.__gregs[_REG_EIP];
1107 rc->fp = uc->uc_mcontext.__gregs[_REG_EBP];
1108 # elif defined(__OpenBSD__)
1109 rc->ip = uc->sc_eip;
1110 rc->fp = uc->sc_ebp;
1111 # elif !defined REG_EIP && defined EIP /* fix for glibc 2.1 */
1112 rc->ip = uc->uc_mcontext.gregs[EIP];
1113 rc->fp = uc->uc_mcontext.gregs[EBP];
1114 # else
1115 rc->ip = uc->uc_mcontext.gregs[REG_EIP];
1116 rc->fp = uc->uc_mcontext.gregs[REG_EBP];
1117 # endif
1118 #elif defined(__x86_64__)
1119 # if defined(__APPLE__)
1120 rc->ip = uc->uc_mcontext->__ss.__rip;
1121 rc->fp = uc->uc_mcontext->__ss.__rbp;
1122 # elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1123 rc->ip = uc->uc_mcontext.mc_rip;
1124 rc->fp = uc->uc_mcontext.mc_rbp;
1125 # elif defined(__NetBSD__)
1126 rc->ip = uc->uc_mcontext.__gregs[_REG_RIP];
1127 rc->fp = uc->uc_mcontext.__gregs[_REG_RBP];
1128 # elif defined(__OpenBSD__)
1129 rc->ip = uc->sc_rip;
1130 rc->fp = uc->sc_rbp;
1131 # else
1132 rc->ip = uc->uc_mcontext.gregs[REG_RIP];
1133 rc->fp = uc->uc_mcontext.gregs[REG_RBP];
1134 # endif
1135 #elif defined(__arm__) && defined(__NetBSD__)
1136 rc->ip = uc->uc_mcontext.__gregs[_REG_PC];
1137 rc->fp = uc->uc_mcontext.__gregs[_REG_FP];
1138 #elif defined(__arm__) && defined(__OpenBSD__)
1139 rc->ip = uc->sc_pc;
1140 rc->fp = uc->sc_r11;
1141 #elif defined(__arm__) && defined(__FreeBSD__)
1142 rc->ip = uc->uc_mcontext.__gregs[_REG_PC];
1143 rc->fp = uc->uc_mcontext.__gregs[_REG_FP];
1144 #elif defined(__arm__)
1145 rc->ip = uc->uc_mcontext.arm_pc;
1146 rc->fp = uc->uc_mcontext.arm_fp;
1147 #elif defined(__aarch64__) && defined(__APPLE__)
1148 // see:
1149 // /Library/Developer/CommandLineTools/SDKs/MacOSX11.1.sdk/usr/include/mach/arm/_structs.h
1150 rc->ip = uc->uc_mcontext->__ss.__pc;
1151 rc->fp = uc->uc_mcontext->__ss.__fp;
1152 #elif defined(__aarch64__) && defined(__FreeBSD__)
1153 rc->ip = uc->uc_mcontext.mc_gpregs.gp_elr; /* aka REG_PC */
1154 rc->fp = uc->uc_mcontext.mc_gpregs.gp_x[29];
1155 #elif defined(__aarch64__) && defined(__NetBSD__)
1156 rc->ip = uc->uc_mcontext.__gregs[_REG_PC];
1157 rc->fp = uc->uc_mcontext.__gregs[_REG_FP];
1158 #elif defined(__aarch64__) && defined(__OpenBSD__)
1159 rc->ip = uc->sc_elr;
1160 rc->fp = uc->sc_x[29];
1161 #elif defined(__aarch64__)
1162 rc->ip = uc->uc_mcontext.pc;
1163 rc->fp = uc->uc_mcontext.regs[29];
1164 #elif defined(__riscv) && defined(__OpenBSD__)
1165 rc->ip = uc->sc_sepc;
1166 rc->fp = uc->sc_s[0];
1167 #elif defined(__riscv)
1168 rc->ip = uc->uc_mcontext.__gregs[REG_PC];
1169 rc->fp = uc->uc_mcontext.__gregs[REG_S0];
1170 #endif
1171 }
1172
1173 /* ------------------------------------------------------------- */
1174 #ifndef _WIN32
1175 /* signal handler for fatal errors */
1176 static void sig_error(int signum, siginfo_t *siginf, void *puc)
1177 {
1178 rt_context *rc = &g_rtctxt;
1179 rt_getcontext(puc, rc);
1180
1181 switch(signum) {
1182 case SIGFPE:
1183 switch(siginf->si_code) {
1184 case FPE_INTDIV:
1185 case FPE_FLTDIV:
1186 rt_error("division by zero");
1187 break;
1188 default:
1189 rt_error("floating point exception");
1190 break;
1191 }
1192 break;
1193 case SIGBUS:
1194 case SIGSEGV:
1195 rt_error("invalid memory access");
1196 break;
1197 case SIGILL:
1198 rt_error("illegal instruction");
1199 break;
1200 case SIGABRT:
1201 rt_error("abort() called");
1202 break;
1203 default:
1204 rt_error("caught signal %d", signum);
1205 break;
1206 }
1207 rt_exit(255);
1208 }
1209
1210 #ifndef SA_SIGINFO
1211 # define SA_SIGINFO 0x00000004u
1212 #endif
1213
1214 /* Generate a stack backtrace when a CPU exception occurs. */
1215 static void set_exception_handler(void)
1216 {
1217 struct sigaction sigact;
1218 /* install TCC signal handlers to print debug info on fatal
1219 runtime errors */
1220 sigemptyset (&sigact.sa_mask);
1221 sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
1222 #if 0//def SIGSTKSZ // this causes signals not to work at all on some (older) linuxes
1223 sigact.sa_flags |= SA_ONSTACK;
1224 #endif
1225 sigact.sa_sigaction = sig_error;
1226 sigemptyset(&sigact.sa_mask);
1227 sigaction(SIGFPE, &sigact, NULL);
1228 sigaction(SIGILL, &sigact, NULL);
1229 sigaction(SIGSEGV, &sigact, NULL);
1230 sigaction(SIGBUS, &sigact, NULL);
1231 sigaction(SIGABRT, &sigact, NULL);
1232 #if 0//def SIGSTKSZ
1233 /* This allows stack overflow to be reported instead of a SEGV */
1234 {
1235 stack_t ss;
1236 static unsigned char stack[SIGSTKSZ] __attribute__((aligned(16)));
1237
1238 ss.ss_sp = stack;
1239 ss.ss_size = SIGSTKSZ;
1240 ss.ss_flags = 0;
1241 sigaltstack(&ss, NULL);
1242 }
1243 #endif
1244 }
1245
1246 #else /* WIN32 */
1247
1248 /* signal handler for fatal errors */
1249 static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
1250 {
1251 rt_context *rc = &g_rtctxt;
1252 unsigned code;
1253 rt_getcontext(ex_info->ContextRecord, rc);
1254
1255 switch (code = ex_info->ExceptionRecord->ExceptionCode) {
1256 case EXCEPTION_ACCESS_VIOLATION:
1257 rt_error("invalid memory access");
1258 break;
1259 case EXCEPTION_STACK_OVERFLOW:
1260 rt_error("stack overflow");
1261 break;
1262 case EXCEPTION_INT_DIVIDE_BY_ZERO:
1263 rt_error("division by zero");
1264 break;
1265 case EXCEPTION_BREAKPOINT:
1266 case EXCEPTION_SINGLE_STEP:
1267 rc->ip = *(addr_t*)rc->sp;
1268 rt_error("breakpoint/single-step exception:");
1269 return EXCEPTION_CONTINUE_SEARCH;
1270 default:
1271 rt_error("caught exception %08x", code);
1272 break;
1273 }
1274 if (rc->do_jmp)
1275 rt_exit(255);
1276 return EXCEPTION_EXECUTE_HANDLER;
1277 }
1278
1279 /* Generate a stack backtrace when a CPU exception occurs. */
1280 static void set_exception_handler(void)
1281 {
1282 SetUnhandledExceptionFilter(cpu_exception_handler);
1283 }
1284
1285 #endif
1286
1287 /* ------------------------------------------------------------- */
1288 /* return the PC at frame level 'level'. Return negative if not found */
1289 #if defined(__i386__) || defined(__x86_64__)
1290 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level)
1291 {
1292 addr_t ip, fp;
1293 if (level == 0) {
1294 ip = rc->ip;
1295 } else {
1296 ip = 0;
1297 fp = rc->fp;
1298 while (--level) {
1299 /* XXX: check address validity with program info */
1300 if (fp <= 0x1000)
1301 break;
1302 fp = ((addr_t *)fp)[0];
1303 }
1304 if (fp > 0x1000)
1305 ip = ((addr_t *)fp)[1];
1306 }
1307 if (ip <= 0x1000)
1308 return -1;
1309 *paddr = ip;
1310 return 0;
1311 }
1312
1313 #elif defined(__arm__)
1314 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level)
1315 {
1316 /* XXX: only supports linux/bsd */
1317 #if !defined(__linux__) && \
1318 !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
1319 return -1;
1320 #else
1321 if (level == 0) {
1322 *paddr = rc->ip;
1323 } else {
1324 addr_t fp = rc->fp;
1325 while (--level)
1326 fp = ((addr_t *)fp)[0];
1327 *paddr = ((addr_t *)fp)[2];
1328 }
1329 return 0;
1330 #endif
1331 }
1332
1333 #elif defined(__aarch64__)
1334 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level)
1335 {
1336 if (level == 0) {
1337 *paddr = rc->ip;
1338 } else {
1339 addr_t *fp = (addr_t*)rc->fp;
1340 while (--level)
1341 fp = (addr_t *)fp[0];
1342 *paddr = fp[1];
1343 }
1344 return 0;
1345 }
1346
1347 #elif defined(__riscv)
1348 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level)
1349 {
1350 if (level == 0) {
1351 *paddr = rc->ip;
1352 } else {
1353 addr_t *fp = (addr_t*)rc->fp;
1354 while (--level && fp >= (addr_t*)0x1000)
1355 fp = (addr_t *)fp[-2];
1356 if (fp < (addr_t*)0x1000)
1357 return -1;
1358 *paddr = fp[-1];
1359 }
1360 return 0;
1361 }
1362
1363 #else
1364 #warning add arch specific rt_get_caller_pc()
1365 static int rt_get_caller_pc(addr_t *paddr, rt_context *rc, int level)
1366 {
1367 return -1;
1368 }
1369
1370 #endif
1371 #endif /* CONFIG_TCC_BACKTRACE */
1372 /* ------------------------------------------------------------- */
1373 #ifdef CONFIG_TCC_STATIC
1374
1375 /* dummy function for profiling */
1376 ST_FUNC void *dlopen(const char *filename, int flag)
1377 {
1378 return NULL;
1379 }
1380
1381 ST_FUNC void dlclose(void *p)
1382 {
1383 }
1384
1385 ST_FUNC const char *dlerror(void)
1386 {
1387 return "error";
1388 }
1389
1390 typedef struct TCCSyms {
1391 char *str;
1392 void *ptr;
1393 } TCCSyms;
1394
1395
1396 /* add the symbol you want here if no dynamic linking is done */
1397 static TCCSyms tcc_syms[] = {
1398 #if !defined(CONFIG_TCCBOOT)
1399 #define TCCSYM(a) { #a, &a, },
1400 TCCSYM(printf)
1401 TCCSYM(fprintf)
1402 TCCSYM(fopen)
1403 TCCSYM(fclose)
1404 #undef TCCSYM
1405 #endif
1406 { NULL, NULL },
1407 };
1408
1409 ST_FUNC void *dlsym(void *handle, const char *symbol)
1410 {
1411 TCCSyms *p;
1412 p = tcc_syms;
1413 while (p->str != NULL) {
1414 if (!strcmp(p->str, symbol))
1415 return p->ptr;
1416 p++;
1417 }
1418 return NULL;
1419 }
1420
1421 #endif /* CONFIG_TCC_STATIC */
1422 #endif /* TCC_IS_NATIVE */
1423 /* ------------------------------------------------------------- */
Tiny C Compiler main repository