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