tccrun.c

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