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 #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     /* relocate each section */
 242     for(i = 1; i < s1->nb_sections; i++) {
 243         s = s1->sections[i];
 244         if (s->reloc)
 245             relocate_section(s1, s);
 246     }
 247     relocate_plt(s1);
 248
 249     for(i = 1; i < s1->nb_sections; i++) {
 250         s = s1->sections[i];
 251         if (0 == (s->sh_flags & SHF_ALLOC))
 252             continue;
 253         length = s->data_offset;
 254         ptr = (void*)s->sh_addr;
 255         if (s->sh_flags & SHF_EXECINSTR)
 256             ptr = (char*)ptr - ptr_diff;
 257         if (NULL == s->data || s->sh_type == SHT_NOBITS)
 258             memset(ptr, 0, length);
 259         else
 260             memcpy(ptr, s->data, length);
 261         /* mark executable sections as executable in memory */
 262         if (s->sh_flags & SHF_EXECINSTR)
 263             set_pages_executable((char*)ptr + ptr_diff, length);
 264     }
 265
 266 #ifdef _WIN64
 267     *(void**)mem = win64_add_function_table(s1);
 268 #endif
 269
 270     return 0;
 271 }
 272
 273 /* ------------------------------------------------------------- */
 274 /* allow to run code in memory */
 275
 276 static void set_pages_executable(void *ptr, unsigned long length)
 277 {
 278 #ifdef _WIN32
 279     unsigned long old_protect;
 280     VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
 281 #else
 282     void __clear_cache(void *beginning, void *end);
 283 # ifndef HAVE_SELINUX
 284     addr_t start, end;
 285 #  ifndef PAGESIZE
 286 #   define PAGESIZE 4096
 287 #  endif
 288     start = (addr_t)ptr & ~(PAGESIZE - 1);
 289     end = (addr_t)ptr + length;
 290     end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
 291     if (mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC))
 292         tcc_error("mprotect failed: did you mean to configure --with-selinux?");
 293 # endif
 294 # if defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64
 295     __clear_cache(ptr, (char *)ptr + length);
 296 # endif
 297 #endif
 298 }
 299
 300 #ifdef _WIN64
 301 static void *win64_add_function_table(TCCState *s1)
 302 {
 303     void *p = NULL;
 304     if (s1->uw_pdata) {
 305         p = (void*)s1->uw_pdata->sh_addr;
 306         RtlAddFunctionTable(
 307             (RUNTIME_FUNCTION*)p,
 308             s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
 309             text_section->sh_addr
 310             );
 311         s1->uw_pdata = NULL;
 312     }
 313     return p;;
 314 }
 315
 316 static void win64_del_function_table(void *p)
 317 {
 318     if (p) {
 319         RtlDeleteFunctionTable((RUNTIME_FUNCTION*)p);
 320     }
 321 }
 322 #endif
 323
 324 /* ------------------------------------------------------------- */
 325 #ifdef CONFIG_TCC_BACKTRACE
 326
 327 ST_FUNC void tcc_set_num_callers(int n)
 328 {
 329     rt_num_callers = n;
 330 }
 331
 332 /* print the position in the source file of PC value 'pc' by reading
 333    the stabs debug information */
 334 static addr_t rt_printline(addr_t wanted_pc, const char *msg)
 335 {
 336     char func_name[128], last_func_name[128];
 337     addr_t func_addr, last_pc, pc;
 338     const char *incl_files[INCLUDE_STACK_SIZE];
 339     int incl_index, len, last_line_num, i;
 340     const char *str, *p;
 341
 342     Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;
 343     int stab_len = 0;
 344     char *stab_str = NULL;
 345
 346     if (stab_section) {
 347         stab_len = stab_section->data_offset;
 348         stab_sym = (Stab_Sym *)stab_section->data;
 349         stab_str = (char *) stabstr_section->data;
 350     }
 351
 352     func_name[0] = '\0';
 353     func_addr = 0;
 354     incl_index = 0;
 355     last_func_name[0] = '\0';
 356     last_pc = (addr_t)-1;
 357     last_line_num = 1;
 358
 359     if (!stab_sym)
 360         goto no_stabs;
 361
 362     stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);
 363     for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {
 364         switch(sym->n_type) {
 365             /* function start or end */
 366         case N_FUN:
 367             if (sym->n_strx == 0) {
 368                 /* we test if between last line and end of function */
 369                 pc = sym->n_value + func_addr;
 370                 if (wanted_pc >= last_pc && wanted_pc < pc)
 371                     goto found;
 372                 func_name[0] = '\0';
 373                 func_addr = 0;
 374             } else {
 375                 str = stab_str + sym->n_strx;
 376                 p = strchr(str, ':');
 377                 if (!p) {
 378                     pstrcpy(func_name, sizeof(func_name), str);
 379                 } else {
 380                     len = p - str;
 381                     if (len > sizeof(func_name) - 1)
 382                         len = sizeof(func_name) - 1;
 383                     memcpy(func_name, str, len);
 384                     func_name[len] = '\0';
 385                 }
 386                 func_addr = sym->n_value;
 387             }
 388             break;
 389             /* line number info */
 390         case N_SLINE:
 391             pc = sym->n_value + func_addr;
 392             if (wanted_pc >= last_pc && wanted_pc < pc)
 393                 goto found;
 394             last_pc = pc;
 395             last_line_num = sym->n_desc;
 396             /* XXX: slow! */
 397             strcpy(last_func_name, func_name);
 398             break;
 399             /* include files */
 400         case N_BINCL:
 401             str = stab_str + sym->n_strx;
 402         add_incl:
 403             if (incl_index < INCLUDE_STACK_SIZE) {
 404                 incl_files[incl_index++] = str;
 405             }
 406             break;
 407         case N_EINCL:
 408             if (incl_index > 1)
 409                 incl_index--;
 410             break;
 411         case N_SO:
 412             if (sym->n_strx == 0) {
 413                 incl_index = 0; /* end of translation unit */
 414             } else {
 415                 str = stab_str + sym->n_strx;
 416                 /* do not add path */
 417                 len = strlen(str);
 418                 if (len > 0 && str[len - 1] != '/')
 419                     goto add_incl;
 420             }
 421             break;
 422         }
 423     }
 424
 425 no_stabs:
 426     /* second pass: we try symtab symbols (no line number info) */
 427     incl_index = 0;
 428     if (symtab_section)
 429     {
 430         ElfW(Sym) *sym, *sym_end;
 431         int type;
 432
 433         sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
 434         for(sym = (ElfW(Sym) *)symtab_section->data + 1;
 435             sym < sym_end;
 436             sym++) {
 437             type = ELFW(ST_TYPE)(sym->st_info);
 438             if (type == STT_FUNC || type == STT_GNU_IFUNC) {
 439                 if (wanted_pc >= sym->st_value &&
 440                     wanted_pc < sym->st_value + sym->st_size) {
 441                     pstrcpy(last_func_name, sizeof(last_func_name),
 442                             (char *) strtab_section->data + sym->st_name);
 443                     func_addr = sym->st_value;
 444                     goto found;
 445                 }
 446             }
 447         }
 448     }
 449     /* did not find any info: */
 450     fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);
 451     fflush(stderr);
 452     return 0;
 453  found:
 454     i = incl_index;
 455     if (i > 0)
 456         fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);
 457     fprintf(stderr, "%s %p", msg, (void*)wanted_pc);
 458     if (last_func_name[0] != '\0')
 459         fprintf(stderr, " %s()", last_func_name);
 460     if (--i >= 0) {
 461         fprintf(stderr, " (included from ");
 462         for (;;) {
 463             fprintf(stderr, "%s", incl_files[i]);
 464             if (--i < 0)
 465                 break;
 466             fprintf(stderr, ", ");
 467         }
 468         fprintf(stderr, ")");
 469     }
 470     fprintf(stderr, "\n");
 471     fflush(stderr);
 472     return func_addr;
 473 }
 474
 475 /* emit a run time error at position 'pc' */
 476 static void rt_error(ucontext_t *uc, const char *fmt, ...)
 477 {
 478     va_list ap;
 479     addr_t pc;
 480     int i;
 481
 482     fprintf(stderr, "Runtime error: ");
 483     va_start(ap, fmt);
 484     vfprintf(stderr, fmt, ap);
 485     va_end(ap);
 486     fprintf(stderr, "\n");
 487
 488     for(i=0;i<rt_num_callers;i++) {
 489         if (rt_get_caller_pc(&pc, uc, i) < 0)
 490             break;
 491         pc = rt_printline(pc, i ? "by" : "at");
 492         if (pc == (addr_t)rt_prog_main && pc)
 493             break;
 494     }
 495 }
 496
 497 /* ------------------------------------------------------------- */
 498 #ifndef _WIN32
 499
 500 /* signal handler for fatal errors */
 501 static void sig_error(int signum, siginfo_t *siginf, void *puc)
 502 {
 503     ucontext_t *uc = puc;
 504
 505     switch(signum) {
 506     case SIGFPE:
 507         switch(siginf->si_code) {
 508         case FPE_INTDIV:
 509         case FPE_FLTDIV:
 510             rt_error(uc, "division by zero");
 511             break;
 512         default:
 513             rt_error(uc, "floating point exception");
 514             break;
 515         }
 516         break;
 517     case SIGBUS:
 518     case SIGSEGV:
 519         if (rt_bound_error_msg && *rt_bound_error_msg)
 520             rt_error(uc, *rt_bound_error_msg);
 521         else
 522             rt_error(uc, "dereferencing invalid pointer");
 523         break;
 524     case SIGILL:
 525         rt_error(uc, "illegal instruction");
 526         break;
 527     case SIGABRT:
 528         rt_error(uc, "abort() called");
 529         break;
 530     default:
 531         rt_error(uc, "caught signal %d", signum);
 532         break;
 533     }
 534     exit(255);
 535 }
 536
 537 #ifndef SA_SIGINFO
 538 # define SA_SIGINFO 0x00000004u
 539 #endif
 540
 541 /* Generate a stack backtrace when a CPU exception occurs. */
 542 static void set_exception_handler(void)
 543 {
 544     struct sigaction sigact;
 545     /* install TCC signal handlers to print debug info on fatal
 546        runtime errors */
 547     sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
 548     sigact.sa_sigaction = sig_error;
 549     sigemptyset(&sigact.sa_mask);
 550     sigaction(SIGFPE, &sigact, NULL);
 551     sigaction(SIGILL, &sigact, NULL);
 552     sigaction(SIGSEGV, &sigact, NULL);
 553     sigaction(SIGBUS, &sigact, NULL);
 554     sigaction(SIGABRT, &sigact, NULL);
 555 }
 556
 557 /* ------------------------------------------------------------- */
 558 #ifdef __i386__
 559
 560 /* fix for glibc 2.1 */
 561 #ifndef REG_EIP
 562 #define REG_EIP EIP
 563 #define REG_EBP EBP
 564 #endif
 565
 566 /* return the PC at frame level 'level'. Return negative if not found */
 567 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 568 {
 569     addr_t fp;
 570     int i;
 571
 572     if (level == 0) {
 573 #if defined(__APPLE__)
 574         *paddr = uc->uc_mcontext->__ss.__eip;
 575 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 576         *paddr = uc->uc_mcontext.mc_eip;
 577 #elif defined(__dietlibc__)
 578         *paddr = uc->uc_mcontext.eip;
 579 #elif defined(__NetBSD__)
 580         *paddr = uc->uc_mcontext.__gregs[_REG_EIP];
 581 #elif defined(__OpenBSD__)
 582         *paddr = uc->sc_eip;
 583 #else
 584         *paddr = uc->uc_mcontext.gregs[REG_EIP];
 585 #endif
 586         return 0;
 587     } else {
 588 #if defined(__APPLE__)
 589         fp = uc->uc_mcontext->__ss.__ebp;
 590 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 591         fp = uc->uc_mcontext.mc_ebp;
 592 #elif defined(__dietlibc__)
 593         fp = uc->uc_mcontext.ebp;
 594 #elif defined(__NetBSD__)
 595         fp = uc->uc_mcontext.__gregs[_REG_EBP];
 596 #elif defined(__OpenBSD__)
 597         *paddr = uc->sc_ebp;
 598 #else
 599         fp = uc->uc_mcontext.gregs[REG_EBP];
 600 #endif
 601         for(i=1;i<level;i++) {
 602             /* XXX: check address validity with program info */
 603             if (fp <= 0x1000 || fp >= 0xc0000000)
 604                 return -1;
 605             fp = ((addr_t *)fp)[0];
 606         }
 607         *paddr = ((addr_t *)fp)[1];
 608         return 0;
 609     }
 610 }
 611
 612 /* ------------------------------------------------------------- */
 613 #elif defined(__x86_64__)
 614
 615 /* return the PC at frame level 'level'. Return negative if not found */
 616 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 617 {
 618     addr_t fp;
 619     int i;
 620
 621     if (level == 0) {
 622         /* XXX: only support linux */
 623 #if defined(__APPLE__)
 624         *paddr = uc->uc_mcontext->__ss.__rip;
 625 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 626         *paddr = uc->uc_mcontext.mc_rip;
 627 #elif defined(__NetBSD__)
 628         *paddr = uc->uc_mcontext.__gregs[_REG_RIP];
 629 #else
 630         *paddr = uc->uc_mcontext.gregs[REG_RIP];
 631 #endif
 632         return 0;
 633     } else {
 634 #if defined(__APPLE__)
 635         fp = uc->uc_mcontext->__ss.__rbp;
 636 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
 637         fp = uc->uc_mcontext.mc_rbp;
 638 #elif defined(__NetBSD__)
 639         fp = uc->uc_mcontext.__gregs[_REG_RBP];
 640 #else
 641         fp = uc->uc_mcontext.gregs[REG_RBP];
 642 #endif
 643         for(i=1;i<level;i++) {
 644             /* XXX: check address validity with program info */
 645             if (fp <= 0x1000)
 646                 return -1;
 647             fp = ((addr_t *)fp)[0];
 648         }
 649         *paddr = ((addr_t *)fp)[1];
 650         return 0;
 651     }
 652 }
 653
 654 /* ------------------------------------------------------------- */
 655 #elif defined(__arm__)
 656
 657 /* return the PC at frame level 'level'. Return negative if not found */
 658 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 659 {
 660     addr_t fp, sp;
 661     int i;
 662
 663     if (level == 0) {
 664         /* XXX: only supports linux */
 665 #if defined(__linux__)
 666         *paddr = uc->uc_mcontext.arm_pc;
 667 #else
 668         return -1;
 669 #endif
 670         return 0;
 671     } else {
 672 #if defined(__linux__)
 673         fp = uc->uc_mcontext.arm_fp;
 674         sp = uc->uc_mcontext.arm_sp;
 675         if (sp < 0x1000)
 676             sp = 0x1000;
 677 #else
 678         return -1;
 679 #endif
 680         /* XXX: specific to tinycc stack frames */
 681         if (fp < sp + 12 || fp & 3)
 682             return -1;
 683         for(i = 1; i < level; i++) {
 684             sp = ((addr_t *)fp)[-2];
 685             if (sp < fp || sp - fp > 16 || sp & 3)
 686                 return -1;
 687             fp = ((addr_t *)fp)[-3];
 688             if (fp <= sp || fp - sp < 12 || fp & 3)
 689                 return -1;
 690         }
 691         /* XXX: check address validity with program info */
 692         *paddr = ((addr_t *)fp)[-1];
 693         return 0;
 694     }
 695 }
 696
 697 /* ------------------------------------------------------------- */
 698 #elif defined(__aarch64__)
 699
 700 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 701 {
 702     if (level < 0)
 703         return -1;
 704     else if (level == 0) {
 705         *paddr = uc->uc_mcontext.pc;
 706         return 0;
 707     }
 708     else {
 709         addr_t *fp = (addr_t *)uc->uc_mcontext.regs[29];
 710         int i;
 711         for (i = 1; i < level; i++)
 712             fp = (addr_t *)fp[0];
 713         *paddr = fp[1];
 714         return 0;
 715     }
 716 }
 717
 718 /* ------------------------------------------------------------- */
 719 #else
 720
 721 #warning add arch specific rt_get_caller_pc()
 722 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 723 {
 724     return -1;
 725 }
 726
 727 #endif /* !__i386__ */
 728
 729 /* ------------------------------------------------------------- */
 730 #else /* WIN32 */
 731
 732 static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
 733 {
 734     EXCEPTION_RECORD *er = ex_info->ExceptionRecord;
 735     CONTEXT *uc = ex_info->ContextRecord;
 736     switch (er->ExceptionCode) {
 737     case EXCEPTION_ACCESS_VIOLATION:
 738         if (rt_bound_error_msg && *rt_bound_error_msg)
 739             rt_error(uc, *rt_bound_error_msg);
 740         else
 741             rt_error(uc, "access violation");
 742         break;
 743     case EXCEPTION_STACK_OVERFLOW:
 744         rt_error(uc, "stack overflow");
 745         break;
 746     case EXCEPTION_INT_DIVIDE_BY_ZERO:
 747         rt_error(uc, "division by zero");
 748         break;
 749     default:
 750         rt_error(uc, "exception caught");
 751         break;
 752     }
 753     return EXCEPTION_EXECUTE_HANDLER;
 754 }
 755
 756 /* Generate a stack backtrace when a CPU exception occurs. */
 757 static void set_exception_handler(void)
 758 {
 759     SetUnhandledExceptionFilter(cpu_exception_handler);
 760 }
 761
 762 /* return the PC at frame level 'level'. Return non zero if not found */
 763 static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)
 764 {
 765     addr_t fp, pc;
 766     int i;
 767 #ifdef _WIN64
 768     pc = uc->Rip;
 769     fp = uc->Rbp;
 770 #else
 771     pc = uc->Eip;
 772     fp = uc->Ebp;
 773 #endif
 774     if (level > 0) {
 775         for(i=1;i<level;i++) {
 776             /* XXX: check address validity with program info */
 777             if (fp <= 0x1000 || fp >= 0xc0000000)
 778                 return -1;
 779             fp = ((addr_t*)fp)[0];
 780         }
 781         pc = ((addr_t*)fp)[1];
 782     }
 783     *paddr = pc;
 784     return 0;
 785 }
 786
 787 #endif /* _WIN32 */
 788 #endif /* CONFIG_TCC_BACKTRACE */
 789 /* ------------------------------------------------------------- */
 790 #ifdef CONFIG_TCC_STATIC
 791
 792 /* dummy function for profiling */
 793 ST_FUNC void *dlopen(const char *filename, int flag)
 794 {
 795     return NULL;
 796 }
 797
 798 ST_FUNC void dlclose(void *p)
 799 {
 800 }
 801
 802 ST_FUNC const char *dlerror(void)
 803 {
 804     return "error";
 805 }
 806
 807 typedef struct TCCSyms {
 808     char *str;
 809     void *ptr;
 810 } TCCSyms;
 811
 812
 813 /* add the symbol you want here if no dynamic linking is done */
 814 static TCCSyms tcc_syms[] = {
 815 #if !defined(CONFIG_TCCBOOT)
 816 #define TCCSYM(a) { #a, &a, },
 817     TCCSYM(printf)
 818     TCCSYM(fprintf)
 819     TCCSYM(fopen)
 820     TCCSYM(fclose)
 821 #undef TCCSYM
 822 #endif
 823     { NULL, NULL },
 824 };
 825
 826 ST_FUNC void *dlsym(void *handle, const char *symbol)
 827 {
 828     TCCSyms *p;
 829     p = tcc_syms;
 830     while (p->str != NULL) {
 831         if (!strcmp(p->str, symbol))
 832             return p->ptr;
 833         p++;
 834     }
 835     return NULL;
 836 }
 837
 838 #endif /* CONFIG_TCC_STATIC */
 839 #endif /* TCC_IS_NATIVE */
 840 /* ------------------------------------------------------------- */