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