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 ST_DATA int rt_num_callers = 6;
  28 ST_DATA const char **rt_bound_error_msg;
  29 ST_DATA void *rt_prog_main;
  30 #endif
  31
  32 #ifdef _WIN32
  33 #define ucontext_t CONTEXT
  34 #endif
  35
  36 static void set_pages_executable(void *ptr, unsigned long length);
  37 static void set_exception_handler(void);
  38 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level);
  39 static void rt_error(ucontext_t *uc, const char *fmt, ...);
  40 static int tcc_relocate_ex(TCCState *s1, void *ptr);
  41
  42 #ifdef _WIN64
  43 static void win64_add_function_table(TCCState *s1);
  44 #endif
  45
  46 /* ------------------------------------------------------------- */
  47 /* Do all relocations (needed before using tcc_get_symbol())
  48    Returns -1 on error. */
  49
  50 LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)
  51 {
  52     int ret;
  53
  54     if (TCC_RELOCATE_AUTO != ptr)
  55         return tcc_relocate_ex(s1, ptr);
  56
  57     ret = tcc_relocate_ex(s1, NULL);
  58     if (ret < 0)
  59         return ret;
  60
  61 #ifdef HAVE_SELINUX
  62     {   /* Use mmap instead of malloc for Selinux.  Ref:
  63            http://www.gnu.org/s/libc/manual/html_node/File-Size.html */
  64
  65         char tmpfname[] = "/tmp/.tccrunXXXXXX";
  66         int fd = mkstemp (tmpfname);
  67
  68         s1->mem_size = ret;
  69         unlink (tmpfname);
  70         ftruncate (fd, s1->mem_size);
  71
  72         s1->write_mem = mmap (NULL, ret, PROT_READ|PROT_WRITE,
  73             MAP_SHARED, fd, 0);
  74         if (s1->write_mem == MAP_FAILED)
  75             tcc_error("/tmp not writeable");
  76
  77         s1->runtime_mem = mmap (NULL, ret, PROT_READ|PROT_EXEC,
  78             MAP_SHARED, fd, 0);
  79         if (s1->runtime_mem == MAP_FAILED)
  80             tcc_error("/tmp not executable");
  81
  82         ret = tcc_relocate_ex(s1, s1->write_mem);
  83     }
  84 #else
  85     s1->runtime_mem = tcc_malloc(ret);
  86     ret = tcc_relocate_ex(s1, s1->runtime_mem);
  87 #endif
  88     return ret;
  89 }
  90
  91 /* launch the compiled program with the given arguments */
  92 LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
  93 {
  94     int (*prog_main)(int, char **);
  95     int ret;
  96
  97     if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
  98         return -1;
  99
 100     prog_main = tcc_get_symbol_err(s1, s1->runtime_main);
 101
 102 #ifdef CONFIG_TCC_BACKTRACE
 103     if (s1->do_debug) {
 104         set_exception_handler();
 105         rt_prog_main = prog_main;
 106     }
 107 #endif
 108
 109 #ifdef CONFIG_TCC_BCHECK
 110     if (s1->do_bounds_check) {
 111         void (*bound_init)(void);
 112         void (*bound_exit)(void);
 113         void (*bound_new_region)(void *p, unsigned long size);
 114         int  (*bound_delete_region)(void *p);
 115         int i;
 116
 117         /* set error function */
 118         rt_bound_error_msg = tcc_get_symbol_err(s1, "__bound_error_msg");
 119         /* XXX: use .init section so that it also work in binary ? */
 120         bound_init = tcc_get_symbol_err(s1, "__bound_init");
 121         bound_exit = tcc_get_symbol_err(s1, "__bound_exit");
 122         bound_new_region = tcc_get_symbol_err(s1, "__bound_new_region");
 123         bound_delete_region = tcc_get_symbol_err(s1, "__bound_delete_region");
 124         bound_init();
 125         /* mark argv area as valid */
 126         bound_new_region(argv, argc*sizeof(argv[0]));
 127         for (i=0; i<argc; ++i)
 128             bound_new_region(argv[i], strlen(argv[i]));
 129
 130         ret = (*prog_main)(argc, argv);
 131
 132         /* unmark argv area */
 133         for (i=0; i<argc; ++i)
 134             bound_delete_region(argv[i]);
 135         bound_delete_region(argv);
 136
 137         bound_exit();
 138     } else
 139 #endif
 140         ret = (*prog_main)(argc, argv);
 141     return ret;
 142 }
 143
 144 /* relocate code. Return -1 on error, required size if ptr is NULL,
 145    otherwise copy code into buffer passed by the caller */
 146 static int tcc_relocate_ex(TCCState *s1, void *ptr)
 147 {
 148     Section *s;
 149     unsigned long offset, length;
 150     addr_t mem;
 151     int i;
 152
 153     if (NULL == ptr) {
 154         s1->nb_errors = 0;
 155 #ifdef TCC_TARGET_PE
 156         pe_output_file(s1, NULL);
 157 #else
 158         tcc_add_runtime(s1);
 159         relocate_common_syms();
 160         tcc_add_linker_symbols(s1);
 161         build_got_entries(s1);
 162 #endif
 163         if (s1->nb_errors)
 164             return -1;
 165     }
 166
 167     offset = 0, mem = (addr_t)ptr;
 168     for(i = 1; i < s1->nb_sections; i++) {
 169         s = s1->sections[i];
 170         if (0 == (s->sh_flags & SHF_ALLOC))
 171             continue;
 172         length = s->data_offset;
 173         s->sh_addr = mem ? (mem + offset + 15) & ~15 : 0;
 174         offset = (offset + length + 15) & ~15;
 175     }
 176     offset += 16;
 177
 178     /* relocate symbols */
 179     relocate_syms(s1, 1);
 180     if (s1->nb_errors)
 181         return -1;
 182
 183 #ifdef TCC_HAS_RUNTIME_PLTGOT
 184     s1->runtime_plt_and_got_offset = 0;
 185     s1->runtime_plt_and_got = (char *)(mem + offset);
 186     /* double the size of the buffer for got and plt entries
 187        XXX: calculate exact size for them? */
 188     offset *= 2;
 189 #endif
 190
 191     if (0 == mem)
 192         return offset;
 193
 194     /* relocate each section */
 195     for(i = 1; i < s1->nb_sections; i++) {
 196         s = s1->sections[i];
 197         if (s->reloc)
 198             relocate_section(s1, s);
 199     }
 200     relocate_plt(s1);
 201
 202     for(i = 1; i < s1->nb_sections; i++) {
 203         s = s1->sections[i];
 204         if (0 == (s->sh_flags & SHF_ALLOC))
 205             continue;
 206         length = s->data_offset;
 207         // printf("%-12s %08x %04x\n", s->name, s->sh_addr, length);
 208         ptr = (void*)s->sh_addr;
 209         if (NULL == s->data || s->sh_type == SHT_NOBITS)
 210             memset(ptr, 0, length);
 211         else
 212             memcpy(ptr, s->data, length);
 213         /* mark executable sections as executable in memory */
 214         if (s->sh_flags & SHF_EXECINSTR)
 215             set_pages_executable(ptr, length);
 216     }
 217
 218 #ifdef TCC_HAS_RUNTIME_PLTGOT
 219     set_pages_executable(s1->runtime_plt_and_got,
 220                          s1->runtime_plt_and_got_offset);
 221 #endif
 222
 223 #ifdef _WIN64
 224     win64_add_function_table(s1);
 225 #endif
 226     return 0;
 227 }
 228
 229 /* ------------------------------------------------------------- */
 230 /* allow to run code in memory */
 231
 232 static void set_pages_executable(void *ptr, unsigned long length)
 233 {
 234 #ifdef _WIN32
 235     unsigned long old_protect;
 236     VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
 237 #else
 238     extern void __clear_cache(char *beginning, char *end);
 239 #ifndef PAGESIZE
 240 # define PAGESIZE 4096
 241 #endif
 242     addr_t start, end;
 243     start = (addr_t)ptr & ~(PAGESIZE - 1);
 244     end = (addr_t)ptr + length;
 245     end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
 246     mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC);
 247     __clear_cache(ptr, ptr + length);
 248 #endif
 249 }
 250
 251 /* ------------------------------------------------------------- */
 252 #ifdef CONFIG_TCC_BACKTRACE
 253
 254 ST_FUNC void tcc_set_num_callers(int n)
 255 {
 256     rt_num_callers = n;
 257 }
 258
 259 /* print the position in the source file of PC value 'pc' by reading
 260    the stabs debug information */
 261 static addr_t rt_printline(addr_t wanted_pc, const char *msg)
 262 {
 263     char func_name[128], last_func_name[128];
 264     addr_t func_addr, last_pc, pc;
 265     const char *incl_files[INCLUDE_STACK_SIZE];
 266     int incl_index, len, last_line_num, i;
 267     const char *str, *p;
 268
 269     Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;
 270     int stab_len = 0;
 271     char *stab_str = NULL;
 272
 273     if (stab_section) {
 274         stab_len = stab_section->data_offset;
 275         stab_sym = (Stab_Sym *)stab_section->data;
 276         stab_str = (char *) stabstr_section->data;
 277     }
 278
 279     func_name[0] = '\0';
 280     func_addr = 0;
 281     incl_index = 0;
 282     last_func_name[0] = '\0';
 283     last_pc = (addr_t)-1;
 284     last_line_num = 1;
 285
 286     if (!stab_sym)
 287         goto no_stabs;
 288
 289     stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);
 290     for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {
 291         switch(sym->n_type) {
 292             /* function start or end */
 293         case N_FUN:
 294             if (sym->n_strx == 0) {
 295                 /* we test if between last line and end of function */
 296                 pc = sym->n_value + func_addr;
 297                 if (wanted_pc >= last_pc && wanted_pc < pc)
 298                     goto found;
 299                 func_name[0] = '\0';
 300                 func_addr = 0;
 301             } else {
 302                 str = stab_str + sym->n_strx;
 303                 p = strchr(str, ':');
 304                 if (!p) {
 305                     pstrcpy(func_name, sizeof(func_name), str);
 306                 } else {
 307                     len = p - str;
 308                     if (len > sizeof(func_name) - 1)
 309                         len = sizeof(func_name) - 1;
 310                     memcpy(func_name, str, len);
 311                     func_name[len] = '\0';
 312                 }
 313                 func_addr = sym->n_value;
 314             }
 315             break;
 316             /* line number info */
 317         case N_SLINE:
 318             pc = sym->n_value + func_addr;
 319             if (wanted_pc >= last_pc && wanted_pc < pc)
 320                 goto found;
 321             last_pc = pc;
 322             last_line_num = sym->n_desc;
 323             /* XXX: slow! */
 324             strcpy(last_func_name, func_name);
 325             break;
 326             /* include files */
 327         case N_BINCL:
 328             str = stab_str + sym->n_strx;
 329         add_incl:
 330             if (incl_index < INCLUDE_STACK_SIZE) {
 331                 incl_files[incl_index++] = str;
 332             }
 333             break;
 334         case N_EINCL:
 335             if (incl_index > 1)
 336                 incl_index--;
 337             break;
 338         case N_SO:
 339             if (sym->n_strx == 0) {
 340                 incl_index = 0; /* end of translation unit */
 341             } else {
 342                 str = stab_str + sym->n_strx;
 343                 /* do not add path */
 344                 len = strlen(str);
 345                 if (len > 0 && str[len - 1] != '/')
 346                     goto add_incl;
 347             }
 348             break;
 349         }
 350     }
 351
 352 no_stabs:
 353     /* second pass: we try symtab symbols (no line number info) */
 354     incl_index = 0;
 355     if (symtab_section)
 356     {
 357         ElfW(Sym) *sym, *sym_end;
 358         int type;
 359
 360         sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
 361         for(sym = (ElfW(Sym) *)symtab_section->data + 1;
 362             sym < sym_end;
 363             sym++) {
 364             type = ELFW(ST_TYPE)(sym->st_info);
 365             if (type == STT_FUNC || type == STT_GNU_IFUNC) {
 366                 if (wanted_pc >= sym->st_value &&
 367                     wanted_pc < sym->st_value + sym->st_size) {
 368                     pstrcpy(last_func_name, sizeof(last_func_name),
 369                             (char *) strtab_section->data + sym->st_name);
 370                     func_addr = sym->st_value;
 371                     goto found;
 372                 }
 373             }
 374         }
 375     }
 376     /* did not find any info: */
 377     fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);
 378     fflush(stderr);
 379     return 0;
 380  found:
 381     i = incl_index;
 382     if (i > 0)
 383         fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);
 384     fprintf(stderr, "%s %p", msg, (void*)wanted_pc);
 385     if (last_func_name[0] != '\0')
 386         fprintf(stderr, " %s()", last_func_name);
 387     if (--i >= 0) {
 388         fprintf(stderr, " (included from ");
 389         for (;;) {
 390             fprintf(stderr, "%s", incl_files[i]);
 391             if (--i < 0)
 392                 break;
 393             fprintf(stderr, ", ");
 394         }
 395         fprintf(stderr, ")");
 396     }
 397     fprintf(stderr, "\n");
 398     fflush(stderr);
 399     return func_addr;
 400 }
 401
 402 /* emit a run time error at position 'pc' */
 403 static void rt_error(ucontext_t *uc, const char *fmt, ...)
 404 {
 405     va_list ap;
 406     addr_t pc;
 407     int i;
 408
 409     fprintf(stderr, "Runtime error: ");
 410     va_start(ap, fmt);
 411     vfprintf(stderr, fmt, ap);
 412     va_end(ap);
 413     fprintf(stderr, "\n");
 414
 415     for(i=0;i<rt_num_callers;i++) {
 416         if (rt_get_caller_pc(&pc, uc, i) < 0)
 417             break;
 418         pc = rt_printline(pc, i ? "by" : "at");
 419         if (pc == (addr_t)rt_prog_main && pc)
 420             break;
 421     }
 422 }
 423
 424 /* ------------------------------------------------------------- */
 425 #ifndef _WIN32
 426
 427 /* signal handler for fatal errors */
 428 static void sig_error(int signum, siginfo_t *siginf, void *puc)
 429 {
 430     ucontext_t *uc = puc;
 431
 432     switch(signum) {
 433     case SIGFPE:
 434         switch(siginf->si_code) {
 435         case FPE_INTDIV:
 436         case FPE_FLTDIV:
 437             rt_error(uc, "division by zero");
 438             break;
 439         default:
 440             rt_error(uc, "floating point exception");
 441             break;
 442         }
 443         break;
 444     case SIGBUS:
 445     case SIGSEGV:
 446         if (rt_bound_error_msg && *rt_bound_error_msg)
 447             rt_error(uc, *rt_bound_error_msg);
 448         else
 449             rt_error(uc, "dereferencing invalid pointer");
 450         break;
 451     case SIGILL:
 452         rt_error(uc, "illegal instruction");
 453         break;
 454     case SIGABRT:
 455         rt_error(uc, "abort() called");
 456         break;
 457     default:
 458         rt_error(uc, "caught signal %d", signum);
 459         break;
 460     }
 461     exit(255);
 462 }
 463
 464 #ifndef SA_SIGINFO
 465 # define SA_SIGINFO 0x00000004u
 466 #endif
 467
 468 /* Generate a stack backtrace when a CPU exception occurs. */
 469 static void set_exception_handler(void)
 470 {
 471     struct sigaction sigact;
 472     /* install TCC signal handlers to print debug info on fatal
 473        runtime errors */
 474     sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
 475     sigact.sa_sigaction = sig_error;
 476     sigemptyset(&sigact.sa_mask);
 477     sigaction(SIGFPE, &sigact, NULL);
 478     sigaction(SIGILL, &sigact, NULL);
 479     sigaction(SIGSEGV, &sigact, NULL);
 480     sigaction(SIGBUS, &sigact, NULL);
 481     sigaction(SIGABRT, &sigact, NULL);
 482 }
 483
 484 /* ------------------------------------------------------------- */
 485 #ifdef __i386__
 486
 487 /* fix for glibc 2.1 */
 488 #ifndef REG_EIP
 489 #define REG_EIP EIP
 490 #define REG_EBP EBP
 491 #endif
 492
 493 /* return the PC at frame level 'level'. Return negative if not found */
 494 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 495 {
 496     addr_t fp;
 497     int i;
 498
 499     if (level == 0) {
 500 #if defined(__APPLE__)
 501         *paddr = uc->uc_mcontext->__ss.__eip;
 502 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 503         *paddr = uc->uc_mcontext.mc_eip;
 504 #elif defined(__dietlibc__)
 505         *paddr = uc->uc_mcontext.eip;
 506 #else
 507         *paddr = uc->uc_mcontext.gregs[REG_EIP];
 508 #endif
 509         return 0;
 510     } else {
 511 #if defined(__APPLE__)
 512         fp = uc->uc_mcontext->__ss.__ebp;
 513 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 514         fp = uc->uc_mcontext.mc_ebp;
 515 #elif defined(__dietlibc__)
 516         fp = uc->uc_mcontext.ebp;
 517 #else
 518         fp = uc->uc_mcontext.gregs[REG_EBP];
 519 #endif
 520         for(i=1;i<level;i++) {
 521             /* XXX: check address validity with program info */
 522             if (fp <= 0x1000 || fp >= 0xc0000000)
 523                 return -1;
 524             fp = ((addr_t *)fp)[0];
 525         }
 526         *paddr = ((addr_t *)fp)[1];
 527         return 0;
 528     }
 529 }
 530
 531 /* ------------------------------------------------------------- */
 532 #elif defined(__x86_64__)
 533
 534 /* return the PC at frame level 'level'. Return negative if not found */
 535 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 536 {
 537     addr_t fp;
 538     int i;
 539
 540     if (level == 0) {
 541         /* XXX: only support linux */
 542 #if defined(__APPLE__)
 543         *paddr = uc->uc_mcontext->__ss.__rip;
 544 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 545         *paddr = uc->uc_mcontext.mc_rip;
 546 #else
 547         *paddr = uc->uc_mcontext.gregs[REG_RIP];
 548 #endif
 549         return 0;
 550     } else {
 551 #if defined(__APPLE__)
 552         fp = uc->uc_mcontext->__ss.__rbp;
 553 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 554         fp = uc->uc_mcontext.mc_rbp;
 555 #else
 556         fp = uc->uc_mcontext.gregs[REG_RBP];
 557 #endif
 558         for(i=1;i<level;i++) {
 559             /* XXX: check address validity with program info */
 560             if (fp <= 0x1000)
 561                 return -1;
 562             fp = ((addr_t *)fp)[0];
 563         }
 564         *paddr = ((addr_t *)fp)[1];
 565         return 0;
 566     }
 567 }
 568
 569 /* ------------------------------------------------------------- */
 570 #elif defined(__arm__)
 571
 572 /* return the PC at frame level 'level'. Return negative if not found */
 573 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 574 {
 575     addr_t fp, sp;
 576     int i;
 577
 578     if (level == 0) {
 579         /* XXX: only supports linux */
 580 #if defined(__linux__)
 581         *paddr = uc->uc_mcontext.arm_pc;
 582 #else
 583         return -1;
 584 #endif
 585         return 0;
 586     } else {
 587 #if defined(__linux__)
 588         fp = uc->uc_mcontext.arm_fp;
 589         sp = uc->uc_mcontext.arm_sp;
 590         if (sp < 0x1000)
 591             sp = 0x1000;
 592 #else
 593         return -1;
 594 #endif
 595         /* XXX: specific to tinycc stack frames */
 596         if (fp < sp + 12 || fp & 3)
 597             return -1;
 598         for(i = 1; i < level; i++) {
 599             sp = ((addr_t *)fp)[-2];
 600             if (sp < fp || sp - fp > 16 || sp & 3)
 601                 return -1;
 602             fp = ((addr_t *)fp)[-3];
 603             if (fp <= sp || fp - sp < 12 || fp & 3)
 604                 return -1;
 605         }
 606         /* XXX: check address validity with program info */
 607         *paddr = ((addr_t *)fp)[-1];
 608         return 0;
 609     }
 610 }
 611
 612 /* ------------------------------------------------------------- */
 613 #else
 614
 615 #warning add arch specific rt_get_caller_pc()
 616 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
 617 {
 618     return -1;
 619 }
 620
 621 #endif /* !__i386__ */
 622
 623 /* ------------------------------------------------------------- */
 624 #else /* WIN32 */
 625
 626 static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
 627 {
 628     EXCEPTION_RECORD *er = ex_info->ExceptionRecord;
 629     CONTEXT *uc = ex_info->ContextRecord;
 630     switch (er->ExceptionCode) {
 631     case EXCEPTION_ACCESS_VIOLATION:
 632         if (rt_bound_error_msg && *rt_bound_error_msg)
 633             rt_error(uc, *rt_bound_error_msg);
 634         else
 635             rt_error(uc, "access violation");
 636         break;
 637     case EXCEPTION_STACK_OVERFLOW:
 638         rt_error(uc, "stack overflow");
 639         break;
 640     case EXCEPTION_INT_DIVIDE_BY_ZERO:
 641         rt_error(uc, "division by zero");
 642         break;
 643     default:
 644         rt_error(uc, "exception caught");
 645         break;
 646     }
 647     return EXCEPTION_EXECUTE_HANDLER;
 648 }
 649
 650 /* Generate a stack backtrace when a CPU exception occurs. */
 651 static void set_exception_handler(void)
 652 {
 653     SetUnhandledExceptionFilter(cpu_exception_handler);
 654 }
 655
 656 #ifdef _WIN64
 657 static void win64_add_function_table(TCCState *s1)
 658 {
 659     RtlAddFunctionTable(
 660         (RUNTIME_FUNCTION*)s1->uw_pdata->sh_addr,
 661         s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
 662         text_section->sh_addr
 663         );
 664 }
 665 #endif
 666
 667 /* return the PC at frame level 'level'. Return non zero if not found */
 668 static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)
 669 {
 670     addr_t fp, pc;
 671     int i;
 672 #ifdef _WIN64
 673     pc = uc->Rip;
 674     fp = uc->Rbp;
 675 #else
 676     pc = uc->Eip;
 677     fp = uc->Ebp;
 678 #endif
 679     if (level > 0) {
 680         for(i=1;i<level;i++) {
 681             /* XXX: check address validity with program info */
 682             if (fp <= 0x1000 || fp >= 0xc0000000)
 683                 return -1;
 684             fp = ((addr_t*)fp)[0];
 685         }
 686         pc = ((addr_t*)fp)[1];
 687     }
 688     *paddr = pc;
 689     return 0;
 690 }
 691
 692 #endif /* _WIN32 */
 693 #endif /* CONFIG_TCC_BACKTRACE */
 694 /* ------------------------------------------------------------- */
 695 #ifdef CONFIG_TCC_STATIC
 696
 697 /* dummy function for profiling */
 698 ST_FUNC void *dlopen(const char *filename, int flag)
 699 {
 700     return NULL;
 701 }
 702
 703 ST_FUNC void dlclose(void *p)
 704 {
 705 }
 706
 707 ST_FUNC const char *dlerror(void)
 708 {
 709     return "error";
 710 }
 711
 712 typedef struct TCCSyms {
 713     char *str;
 714     void *ptr;
 715 } TCCSyms;
 716
 717
 718 /* add the symbol you want here if no dynamic linking is done */
 719 static TCCSyms tcc_syms[] = {
 720 #if !defined(CONFIG_TCCBOOT)
 721 #define TCCSYM(a) { #a, &a, },
 722     TCCSYM(printf)
 723     TCCSYM(fprintf)
 724     TCCSYM(fopen)
 725     TCCSYM(fclose)
 726 #undef TCCSYM
 727 #endif
 728     { NULL, NULL },
 729 };
 730
 731 ST_FUNC void *resolve_sym(TCCState *s1, const char *symbol)
 732 {
 733     TCCSyms *p;
 734     p = tcc_syms;
 735     while (p->str != NULL) {
 736         if (!strcmp(p->str, symbol))
 737             return p->ptr;
 738         p++;
 739     }
 740     return NULL;
 741 }
 742
 743 #elif !defined(_WIN32)
 744
 745 ST_FUNC void *resolve_sym(TCCState *s1, const char *sym)
 746 {
 747     return dlsym(RTLD_DEFAULT, sym);
 748 }
 749
 750 #endif /* CONFIG_TCC_STATIC */
 751 #endif /* TCC_IS_NATIVE */
 752 /* ------------------------------------------------------------- */