source: EcnlProtoTool/trunk/tcc-0.9.26/tccrun.c@ 286

Last change on this file since 286 was 279, checked in by coas-nagasima, 7 years ago

ファイルを追加、更新。
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
  • Property svn:mime-type set to text/x-csrc
File size: 19.6 KB
Line 
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
27ST_DATA int rt_num_callers = 6;
28ST_DATA const char **rt_bound_error_msg;
29ST_DATA void *rt_prog_main;
30#endif
31
32#ifdef _WIN32
33#define ucontext_t CONTEXT
34#endif
35
36static void set_pages_executable(void *ptr, unsigned long length);
37static void set_exception_handler(void);
38static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level);
39static void rt_error(ucontext_t *uc, const char *fmt, ...);
40static int tcc_relocate_ex(TCCState *s1, void *ptr);
41
42#ifdef _WIN64
43static 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
50LIBTCCAPI 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 */
92LIBTCCAPI 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 */
129static 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
214static 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
234ST_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 */
241static 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
332no_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' */
383static 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 */
408static 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. */
449static 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 */
475static 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 */
516static 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 */
554static 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()
597static 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
607static 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. */
632static void set_exception_handler(void)
633{
634 SetUnhandledExceptionFilter(cpu_exception_handler);
635}
636
637#ifdef _WIN64
638static 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 */
649static 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 */
679ST_FUNC void *dlopen(const char *filename, int flag)
680{
681 return NULL;
682}
683
684ST_FUNC void dlclose(void *p)
685{
686}
687
688ST_FUNC const char *dlerror(void)
689{
690 return "error";
691}
692
693typedef 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 */
700static 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
712ST_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
726ST_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/* ------------------------------------------------------------- */
Note: See TracBrowser for help on using the repository browser.