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