Rein in unintended external functions on Windows.
[tinycc.git] / tccrun.c
blob9ee70e439ab661259ec675855243d0c6b900c252
1 /*
2 * TCC - Tiny C Compiler - Support for -run switch
4 * Copyright (c) 2001-2004 Fabrice Bellard
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.
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.
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
21 #include "tcc.h"
23 /* only native compiler supports -run */
24 #ifdef TCC_IS_NATIVE
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
32 #ifdef _WIN32
33 #define ucontext_t CONTEXT
34 #endif
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);
42 #ifdef _WIN64
43 static void win64_add_function_table(TCCState *s1);
44 #endif
46 /* ------------------------------------------------------------- */
47 /* Do all relocations (needed before using tcc_get_symbol())
48 Returns -1 on error. */
50 LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)
52 int ret;
54 if (TCC_RELOCATE_AUTO != ptr)
55 return tcc_relocate_ex(s1, ptr);
57 ret = tcc_relocate_ex(s1, NULL);
58 if (ret < 0)
59 return ret;
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 */
65 char tmpfname[] = "/tmp/.tccrunXXXXXX";
66 int fd = mkstemp (tmpfname);
68 s1->mem_size = ret;
69 unlink (tmpfname);
70 ftruncate (fd, s1->mem_size);
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");
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");
82 ret = tcc_relocate_ex(s1, s1->write_mem);
84 #else
85 s1->runtime_mem = tcc_malloc(ret);
86 ret = tcc_relocate_ex(s1, s1->runtime_mem);
87 #endif
88 return ret;
91 /* launch the compiled program with the given arguments */
92 LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
94 int (*prog_main)(int, char **);
95 int ret;
97 if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
98 return -1;
100 prog_main = tcc_get_symbol_err(s1, s1->runtime_main);
102 #ifdef CONFIG_TCC_BACKTRACE
103 if (s1->do_debug) {
104 set_exception_handler();
105 rt_prog_main = prog_main;
107 #endif
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, addr_t size);
114 int (*bound_delete_region)(void *p);
115 int i;
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]));
130 errno = 0; /* clean errno value */
131 ret = (*prog_main)(argc, argv);
133 /* unmark argv area */
134 for (i=0; i<argc; ++i)
135 bound_delete_region(argv[i]);
136 bound_delete_region(argv);
138 bound_exit();
139 } else
140 #endif
142 errno = 0; /* clean errno value */
143 ret = (*prog_main)(argc, argv);
145 return ret;
148 /* relocate code. Return -1 on error, required size if ptr is NULL,
149 otherwise copy code into buffer passed by the caller */
150 static int tcc_relocate_ex(TCCState *s1, void *ptr)
152 Section *s;
153 unsigned long offset, length;
154 addr_t mem;
155 int i;
157 if (NULL == ptr) {
158 s1->nb_errors = 0;
159 #ifdef TCC_TARGET_PE
160 pe_output_file(s1, NULL);
161 #else
162 tcc_add_runtime(s1);
163 relocate_common_syms();
164 tcc_add_linker_symbols(s1);
165 build_got_entries(s1);
166 #endif
167 if (s1->nb_errors)
168 return -1;
171 offset = 0, mem = (addr_t)ptr;
172 for(i = 1; i < s1->nb_sections; i++) {
173 s = s1->sections[i];
174 if (0 == (s->sh_flags & SHF_ALLOC))
175 continue;
176 length = s->data_offset;
177 s->sh_addr = mem ? (mem + offset + 15) & ~15 : 0;
178 offset = (offset + length + 15) & ~15;
180 offset += 16;
182 /* relocate symbols */
183 relocate_syms(s1, 1);
184 if (s1->nb_errors)
185 return -1;
187 if (0 == mem)
188 return offset;
190 /* relocate each section */
191 for(i = 1; i < s1->nb_sections; i++) {
192 s = s1->sections[i];
193 if (s->reloc)
194 relocate_section(s1, s);
196 relocate_plt(s1);
198 for(i = 1; i < s1->nb_sections; i++) {
199 s = s1->sections[i];
200 if (0 == (s->sh_flags & SHF_ALLOC))
201 continue;
202 length = s->data_offset;
203 // printf("%-12s %08lx %04x\n", s->name, s->sh_addr, length);
204 ptr = (void*)s->sh_addr;
205 if (NULL == s->data || s->sh_type == SHT_NOBITS)
206 memset(ptr, 0, length);
207 else
208 memcpy(ptr, s->data, length);
209 /* mark executable sections as executable in memory */
210 if (s->sh_flags & SHF_EXECINSTR)
211 set_pages_executable(ptr, length);
214 #ifdef _WIN64
215 win64_add_function_table(s1);
216 #endif
217 return 0;
220 /* ------------------------------------------------------------- */
221 /* allow to run code in memory */
223 static void set_pages_executable(void *ptr, unsigned long length)
225 #ifdef _WIN32
226 unsigned long old_protect;
227 VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
228 #else
229 extern void __clear_cache(void *beginning, void *end);
230 #ifndef PAGESIZE
231 # define PAGESIZE 4096
232 #endif
233 addr_t start, end;
234 start = (addr_t)ptr & ~(PAGESIZE - 1);
235 end = (addr_t)ptr + length;
236 end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
237 mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC);
238 #ifndef __PCC__
239 __clear_cache(ptr, (char *)ptr + length);
240 #else
241 /* pcc 1.2.0.DEVEL 20141206 don't have such proc */
242 #endif
243 #endif
246 /* ------------------------------------------------------------- */
247 #ifdef CONFIG_TCC_BACKTRACE
249 ST_FUNC void tcc_set_num_callers(int n)
251 rt_num_callers = n;
254 /* print the position in the source file of PC value 'pc' by reading
255 the stabs debug information */
256 static addr_t rt_printline(addr_t wanted_pc, const char *msg)
258 char func_name[128], last_func_name[128];
259 addr_t func_addr, last_pc, pc;
260 const char *incl_files[INCLUDE_STACK_SIZE];
261 int incl_index, len, last_line_num, i;
262 const char *str, *p;
264 Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;
265 int stab_len = 0;
266 char *stab_str = NULL;
268 if (stab_section) {
269 stab_len = stab_section->data_offset;
270 stab_sym = (Stab_Sym *)stab_section->data;
271 stab_str = (char *) stabstr_section->data;
274 func_name[0] = '\0';
275 func_addr = 0;
276 incl_index = 0;
277 last_func_name[0] = '\0';
278 last_pc = (addr_t)-1;
279 last_line_num = 1;
281 if (!stab_sym)
282 goto no_stabs;
284 stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);
285 for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {
286 switch(sym->n_type) {
287 /* function start or end */
288 case N_FUN:
289 if (sym->n_strx == 0) {
290 /* we test if between last line and end of function */
291 pc = sym->n_value + func_addr;
292 if (wanted_pc >= last_pc && wanted_pc < pc)
293 goto found;
294 func_name[0] = '\0';
295 func_addr = 0;
296 } else {
297 str = stab_str + sym->n_strx;
298 p = strchr(str, ':');
299 if (!p) {
300 pstrcpy(func_name, sizeof(func_name), str);
301 } else {
302 len = p - str;
303 if (len > sizeof(func_name) - 1)
304 len = sizeof(func_name) - 1;
305 memcpy(func_name, str, len);
306 func_name[len] = '\0';
308 func_addr = sym->n_value;
310 break;
311 /* line number info */
312 case N_SLINE:
313 pc = sym->n_value + func_addr;
314 if (wanted_pc >= last_pc && wanted_pc < pc)
315 goto found;
316 last_pc = pc;
317 last_line_num = sym->n_desc;
318 /* XXX: slow! */
319 strcpy(last_func_name, func_name);
320 break;
321 /* include files */
322 case N_BINCL:
323 str = stab_str + sym->n_strx;
324 add_incl:
325 if (incl_index < INCLUDE_STACK_SIZE) {
326 incl_files[incl_index++] = str;
328 break;
329 case N_EINCL:
330 if (incl_index > 1)
331 incl_index--;
332 break;
333 case N_SO:
334 if (sym->n_strx == 0) {
335 incl_index = 0; /* end of translation unit */
336 } else {
337 str = stab_str + sym->n_strx;
338 /* do not add path */
339 len = strlen(str);
340 if (len > 0 && str[len - 1] != '/')
341 goto add_incl;
343 break;
347 no_stabs:
348 /* second pass: we try symtab symbols (no line number info) */
349 incl_index = 0;
350 if (symtab_section)
352 ElfW(Sym) *sym, *sym_end;
353 int type;
355 sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
356 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
357 sym < sym_end;
358 sym++) {
359 type = ELFW(ST_TYPE)(sym->st_info);
360 if (type == STT_FUNC || type == STT_GNU_IFUNC) {
361 if (wanted_pc >= sym->st_value &&
362 wanted_pc < sym->st_value + sym->st_size) {
363 pstrcpy(last_func_name, sizeof(last_func_name),
364 (char *) strtab_section->data + sym->st_name);
365 func_addr = sym->st_value;
366 goto found;
371 /* did not find any info: */
372 fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);
373 fflush(stderr);
374 return 0;
375 found:
376 i = incl_index;
377 if (i > 0)
378 fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);
379 fprintf(stderr, "%s %p", msg, (void*)wanted_pc);
380 if (last_func_name[0] != '\0')
381 fprintf(stderr, " %s()", last_func_name);
382 if (--i >= 0) {
383 fprintf(stderr, " (included from ");
384 for (;;) {
385 fprintf(stderr, "%s", incl_files[i]);
386 if (--i < 0)
387 break;
388 fprintf(stderr, ", ");
390 fprintf(stderr, ")");
392 fprintf(stderr, "\n");
393 fflush(stderr);
394 return func_addr;
397 /* emit a run time error at position 'pc' */
398 static void rt_error(ucontext_t *uc, const char *fmt, ...)
400 va_list ap;
401 addr_t pc;
402 int i;
404 fprintf(stderr, "Runtime error: ");
405 va_start(ap, fmt);
406 vfprintf(stderr, fmt, ap);
407 va_end(ap);
408 fprintf(stderr, "\n");
410 for(i=0;i<rt_num_callers;i++) {
411 if (rt_get_caller_pc(&pc, uc, i) < 0)
412 break;
413 pc = rt_printline(pc, i ? "by" : "at");
414 if (pc == (addr_t)rt_prog_main && pc)
415 break;
419 /* ------------------------------------------------------------- */
420 #ifndef _WIN32
422 /* signal handler for fatal errors */
423 static void sig_error(int signum, siginfo_t *siginf, void *puc)
425 ucontext_t *uc = puc;
427 switch(signum) {
428 case SIGFPE:
429 switch(siginf->si_code) {
430 case FPE_INTDIV:
431 case FPE_FLTDIV:
432 rt_error(uc, "division by zero");
433 break;
434 default:
435 rt_error(uc, "floating point exception");
436 break;
438 break;
439 case SIGBUS:
440 case SIGSEGV:
441 if (rt_bound_error_msg && *rt_bound_error_msg)
442 rt_error(uc, *rt_bound_error_msg);
443 else
444 rt_error(uc, "dereferencing invalid pointer");
445 break;
446 case SIGILL:
447 rt_error(uc, "illegal instruction");
448 break;
449 case SIGABRT:
450 rt_error(uc, "abort() called");
451 break;
452 default:
453 rt_error(uc, "caught signal %d", signum);
454 break;
456 exit(255);
459 #ifndef SA_SIGINFO
460 # define SA_SIGINFO 0x00000004u
461 #endif
463 /* Generate a stack backtrace when a CPU exception occurs. */
464 static void set_exception_handler(void)
466 struct sigaction sigact;
467 /* install TCC signal handlers to print debug info on fatal
468 runtime errors */
469 sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
470 sigact.sa_sigaction = sig_error;
471 sigemptyset(&sigact.sa_mask);
472 sigaction(SIGFPE, &sigact, NULL);
473 sigaction(SIGILL, &sigact, NULL);
474 sigaction(SIGSEGV, &sigact, NULL);
475 sigaction(SIGBUS, &sigact, NULL);
476 sigaction(SIGABRT, &sigact, NULL);
479 /* ------------------------------------------------------------- */
480 #ifdef __i386__
482 /* fix for glibc 2.1 */
483 #ifndef REG_EIP
484 #define REG_EIP EIP
485 #define REG_EBP EBP
486 #endif
488 /* return the PC at frame level 'level'. Return negative if not found */
489 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
491 addr_t fp;
492 int i;
494 if (level == 0) {
495 #if defined(__APPLE__)
496 *paddr = uc->uc_mcontext->__ss.__eip;
497 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
498 *paddr = uc->uc_mcontext.mc_eip;
499 #elif defined(__dietlibc__)
500 *paddr = uc->uc_mcontext.eip;
501 #elif defined(__NetBSD__)
502 *paddr = uc->uc_mcontext.__gregs[_REG_EIP];
503 #else
504 *paddr = uc->uc_mcontext.gregs[REG_EIP];
505 #endif
506 return 0;
507 } else {
508 #if defined(__APPLE__)
509 fp = uc->uc_mcontext->__ss.__ebp;
510 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
511 fp = uc->uc_mcontext.mc_ebp;
512 #elif defined(__dietlibc__)
513 fp = uc->uc_mcontext.ebp;
514 #elif defined(__NetBSD__)
515 fp = uc->uc_mcontext.__gregs[_REG_EBP];
516 #else
517 fp = uc->uc_mcontext.gregs[REG_EBP];
518 #endif
519 for(i=1;i<level;i++) {
520 /* XXX: check address validity with program info */
521 if (fp <= 0x1000 || fp >= 0xc0000000)
522 return -1;
523 fp = ((addr_t *)fp)[0];
525 *paddr = ((addr_t *)fp)[1];
526 return 0;
530 /* ------------------------------------------------------------- */
531 #elif defined(__x86_64__)
533 /* return the PC at frame level 'level'. Return negative if not found */
534 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
536 addr_t fp;
537 int i;
539 if (level == 0) {
540 /* XXX: only support linux */
541 #if defined(__APPLE__)
542 *paddr = uc->uc_mcontext->__ss.__rip;
543 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
544 *paddr = uc->uc_mcontext.mc_rip;
545 #elif defined(__NetBSD__)
546 *paddr = uc->uc_mcontext.__gregs[_REG_RIP];
547 #else
548 *paddr = uc->uc_mcontext.gregs[REG_RIP];
549 #endif
550 return 0;
551 } else {
552 #if defined(__APPLE__)
553 fp = uc->uc_mcontext->__ss.__rbp;
554 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
555 fp = uc->uc_mcontext.mc_rbp;
556 #elif defined(__NetBSD__)
557 fp = uc->uc_mcontext.__gregs[_REG_RBP];
558 #else
559 fp = uc->uc_mcontext.gregs[REG_RBP];
560 #endif
561 for(i=1;i<level;i++) {
562 /* XXX: check address validity with program info */
563 if (fp <= 0x1000)
564 return -1;
565 fp = ((addr_t *)fp)[0];
567 *paddr = ((addr_t *)fp)[1];
568 return 0;
572 /* ------------------------------------------------------------- */
573 #elif defined(__arm__)
575 /* return the PC at frame level 'level'. Return negative if not found */
576 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
578 addr_t fp, sp;
579 int i;
581 if (level == 0) {
582 /* XXX: only supports linux */
583 #if defined(__linux__)
584 *paddr = uc->uc_mcontext.arm_pc;
585 #else
586 return -1;
587 #endif
588 return 0;
589 } else {
590 #if defined(__linux__)
591 fp = uc->uc_mcontext.arm_fp;
592 sp = uc->uc_mcontext.arm_sp;
593 if (sp < 0x1000)
594 sp = 0x1000;
595 #else
596 return -1;
597 #endif
598 /* XXX: specific to tinycc stack frames */
599 if (fp < sp + 12 || fp & 3)
600 return -1;
601 for(i = 1; i < level; i++) {
602 sp = ((addr_t *)fp)[-2];
603 if (sp < fp || sp - fp > 16 || sp & 3)
604 return -1;
605 fp = ((addr_t *)fp)[-3];
606 if (fp <= sp || fp - sp < 12 || fp & 3)
607 return -1;
609 /* XXX: check address validity with program info */
610 *paddr = ((addr_t *)fp)[-1];
611 return 0;
615 /* ------------------------------------------------------------- */
616 #elif defined(__aarch64__)
618 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
620 if (level < 0)
621 return -1;
622 else if (level == 0) {
623 *paddr = uc->uc_mcontext.pc;
624 return 0;
626 else {
627 addr_t *fp = (addr_t *)uc->uc_mcontext.regs[29];
628 int i;
629 for (i = 1; i < level; i++)
630 fp = (addr_t *)fp[0];
631 *paddr = fp[1];
632 return 0;
636 /* ------------------------------------------------------------- */
637 #else
639 #warning add arch specific rt_get_caller_pc()
640 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
642 return -1;
645 #endif /* !__i386__ */
647 /* ------------------------------------------------------------- */
648 #else /* WIN32 */
650 static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
652 EXCEPTION_RECORD *er = ex_info->ExceptionRecord;
653 CONTEXT *uc = ex_info->ContextRecord;
654 switch (er->ExceptionCode) {
655 case EXCEPTION_ACCESS_VIOLATION:
656 if (rt_bound_error_msg && *rt_bound_error_msg)
657 rt_error(uc, *rt_bound_error_msg);
658 else
659 rt_error(uc, "access violation");
660 break;
661 case EXCEPTION_STACK_OVERFLOW:
662 rt_error(uc, "stack overflow");
663 break;
664 case EXCEPTION_INT_DIVIDE_BY_ZERO:
665 rt_error(uc, "division by zero");
666 break;
667 default:
668 rt_error(uc, "exception caught");
669 break;
671 return EXCEPTION_EXECUTE_HANDLER;
674 /* Generate a stack backtrace when a CPU exception occurs. */
675 static void set_exception_handler(void)
677 SetUnhandledExceptionFilter(cpu_exception_handler);
680 #ifdef _WIN64
681 static void win64_add_function_table(TCCState *s1)
683 RtlAddFunctionTable(
684 (RUNTIME_FUNCTION*)s1->uw_pdata->sh_addr,
685 s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
686 text_section->sh_addr
689 #endif
691 /* return the PC at frame level 'level'. Return non zero if not found */
692 static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)
694 addr_t fp, pc;
695 int i;
696 #ifdef _WIN64
697 pc = uc->Rip;
698 fp = uc->Rbp;
699 #else
700 pc = uc->Eip;
701 fp = uc->Ebp;
702 #endif
703 if (level > 0) {
704 for(i=1;i<level;i++) {
705 /* XXX: check address validity with program info */
706 if (fp <= 0x1000 || fp >= 0xc0000000)
707 return -1;
708 fp = ((addr_t*)fp)[0];
710 pc = ((addr_t*)fp)[1];
712 *paddr = pc;
713 return 0;
716 #endif /* _WIN32 */
717 #endif /* CONFIG_TCC_BACKTRACE */
718 /* ------------------------------------------------------------- */
719 #ifdef CONFIG_TCC_STATIC
721 /* dummy function for profiling */
722 ST_FUNC void *dlopen(const char *filename, int flag)
724 return NULL;
727 ST_FUNC void dlclose(void *p)
731 ST_FUNC const char *dlerror(void)
733 return "error";
736 typedef struct TCCSyms {
737 char *str;
738 void *ptr;
739 } TCCSyms;
742 /* add the symbol you want here if no dynamic linking is done */
743 static TCCSyms tcc_syms[] = {
744 #if !defined(CONFIG_TCCBOOT)
745 #define TCCSYM(a) { #a, &a, },
746 TCCSYM(printf)
747 TCCSYM(fprintf)
748 TCCSYM(fopen)
749 TCCSYM(fclose)
750 #undef TCCSYM
751 #endif
752 { NULL, NULL },
755 ST_FUNC void *resolve_sym(TCCState *s1, const char *symbol)
757 TCCSyms *p;
758 p = tcc_syms;
759 while (p->str != NULL) {
760 if (!strcmp(p->str, symbol))
761 return p->ptr;
762 p++;
764 return NULL;
767 #elif !defined(_WIN32)
769 ST_FUNC void *resolve_sym(TCCState *s1, const char *sym)
771 return dlsym(RTLD_DEFAULT, sym);
774 #endif /* CONFIG_TCC_STATIC */
775 #endif /* TCC_IS_NATIVE */
776 /* ------------------------------------------------------------- */