fix-mixed-struct (patch by Pip Cet)
[tinycc.git] / tccrun.c
blob55db31094c958e2197d6133ef5d31e4a62972410
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 */
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)
51 {
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);
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 }
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;
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(char *beginning, char *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 __clear_cache(ptr, ptr + length);
239 #endif
242 /* ------------------------------------------------------------- */
243 #ifdef CONFIG_TCC_BACKTRACE
245 ST_FUNC void tcc_set_num_callers(int n)
247 rt_num_callers = n;
250 /* print the position in the source file of PC value 'pc' by reading
251 the stabs debug information */
252 static addr_t rt_printline(addr_t wanted_pc, const char *msg)
254 char func_name[128], last_func_name[128];
255 addr_t func_addr, last_pc, pc;
256 const char *incl_files[INCLUDE_STACK_SIZE];
257 int incl_index, len, last_line_num, i;
258 const char *str, *p;
260 Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;
261 int stab_len = 0;
262 char *stab_str = NULL;
264 if (stab_section) {
265 stab_len = stab_section->data_offset;
266 stab_sym = (Stab_Sym *)stab_section->data;
267 stab_str = (char *) stabstr_section->data;
270 func_name[0] = '\0';
271 func_addr = 0;
272 incl_index = 0;
273 last_func_name[0] = '\0';
274 last_pc = (addr_t)-1;
275 last_line_num = 1;
277 if (!stab_sym)
278 goto no_stabs;
280 stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);
281 for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {
282 switch(sym->n_type) {
283 /* function start or end */
284 case N_FUN:
285 if (sym->n_strx == 0) {
286 /* we test if between last line and end of function */
287 pc = sym->n_value + func_addr;
288 if (wanted_pc >= last_pc && wanted_pc < pc)
289 goto found;
290 func_name[0] = '\0';
291 func_addr = 0;
292 } else {
293 str = stab_str + sym->n_strx;
294 p = strchr(str, ':');
295 if (!p) {
296 pstrcpy(func_name, sizeof(func_name), str);
297 } else {
298 len = p - str;
299 if (len > sizeof(func_name) - 1)
300 len = sizeof(func_name) - 1;
301 memcpy(func_name, str, len);
302 func_name[len] = '\0';
304 func_addr = sym->n_value;
306 break;
307 /* line number info */
308 case N_SLINE:
309 pc = sym->n_value + func_addr;
310 if (wanted_pc >= last_pc && wanted_pc < pc)
311 goto found;
312 last_pc = pc;
313 last_line_num = sym->n_desc;
314 /* XXX: slow! */
315 strcpy(last_func_name, func_name);
316 break;
317 /* include files */
318 case N_BINCL:
319 str = stab_str + sym->n_strx;
320 add_incl:
321 if (incl_index < INCLUDE_STACK_SIZE) {
322 incl_files[incl_index++] = str;
324 break;
325 case N_EINCL:
326 if (incl_index > 1)
327 incl_index--;
328 break;
329 case N_SO:
330 if (sym->n_strx == 0) {
331 incl_index = 0; /* end of translation unit */
332 } else {
333 str = stab_str + sym->n_strx;
334 /* do not add path */
335 len = strlen(str);
336 if (len > 0 && str[len - 1] != '/')
337 goto add_incl;
339 break;
343 no_stabs:
344 /* second pass: we try symtab symbols (no line number info) */
345 incl_index = 0;
346 if (symtab_section)
348 ElfW(Sym) *sym, *sym_end;
349 int type;
351 sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
352 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
353 sym < sym_end;
354 sym++) {
355 type = ELFW(ST_TYPE)(sym->st_info);
356 if (type == STT_FUNC || type == STT_GNU_IFUNC) {
357 if (wanted_pc >= sym->st_value &&
358 wanted_pc < sym->st_value + sym->st_size) {
359 pstrcpy(last_func_name, sizeof(last_func_name),
360 (char *) strtab_section->data + sym->st_name);
361 func_addr = sym->st_value;
362 goto found;
367 /* did not find any info: */
368 fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);
369 fflush(stderr);
370 return 0;
371 found:
372 i = incl_index;
373 if (i > 0)
374 fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);
375 fprintf(stderr, "%s %p", msg, (void*)wanted_pc);
376 if (last_func_name[0] != '\0')
377 fprintf(stderr, " %s()", last_func_name);
378 if (--i >= 0) {
379 fprintf(stderr, " (included from ");
380 for (;;) {
381 fprintf(stderr, "%s", incl_files[i]);
382 if (--i < 0)
383 break;
384 fprintf(stderr, ", ");
386 fprintf(stderr, ")");
388 fprintf(stderr, "\n");
389 fflush(stderr);
390 return func_addr;
393 /* emit a run time error at position 'pc' */
394 static void rt_error(ucontext_t *uc, const char *fmt, ...)
396 va_list ap;
397 addr_t pc;
398 int i;
400 fprintf(stderr, "Runtime error: ");
401 va_start(ap, fmt);
402 vfprintf(stderr, fmt, ap);
403 va_end(ap);
404 fprintf(stderr, "\n");
406 for(i=0;i<rt_num_callers;i++) {
407 if (rt_get_caller_pc(&pc, uc, i) < 0)
408 break;
409 pc = rt_printline(pc, i ? "by" : "at");
410 if (pc == (addr_t)rt_prog_main && pc)
411 break;
415 /* ------------------------------------------------------------- */
416 #ifndef _WIN32
418 /* signal handler for fatal errors */
419 static void sig_error(int signum, siginfo_t *siginf, void *puc)
421 ucontext_t *uc = puc;
423 switch(signum) {
424 case SIGFPE:
425 switch(siginf->si_code) {
426 case FPE_INTDIV:
427 case FPE_FLTDIV:
428 rt_error(uc, "division by zero");
429 break;
430 default:
431 rt_error(uc, "floating point exception");
432 break;
434 break;
435 case SIGBUS:
436 case SIGSEGV:
437 if (rt_bound_error_msg && *rt_bound_error_msg)
438 rt_error(uc, *rt_bound_error_msg);
439 else
440 rt_error(uc, "dereferencing invalid pointer");
441 break;
442 case SIGILL:
443 rt_error(uc, "illegal instruction");
444 break;
445 case SIGABRT:
446 rt_error(uc, "abort() called");
447 break;
448 default:
449 rt_error(uc, "caught signal %d", signum);
450 break;
452 exit(255);
455 #ifndef SA_SIGINFO
456 # define SA_SIGINFO 0x00000004u
457 #endif
459 /* Generate a stack backtrace when a CPU exception occurs. */
460 static void set_exception_handler(void)
462 struct sigaction sigact;
463 /* install TCC signal handlers to print debug info on fatal
464 runtime errors */
465 sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
466 sigact.sa_sigaction = sig_error;
467 sigemptyset(&sigact.sa_mask);
468 sigaction(SIGFPE, &sigact, NULL);
469 sigaction(SIGILL, &sigact, NULL);
470 sigaction(SIGSEGV, &sigact, NULL);
471 sigaction(SIGBUS, &sigact, NULL);
472 sigaction(SIGABRT, &sigact, NULL);
475 /* ------------------------------------------------------------- */
476 #ifdef __i386__
478 /* fix for glibc 2.1 */
479 #ifndef REG_EIP
480 #define REG_EIP EIP
481 #define REG_EBP EBP
482 #endif
484 /* return the PC at frame level 'level'. Return negative if not found */
485 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
487 addr_t fp;
488 int i;
490 if (level == 0) {
491 #if defined(__APPLE__)
492 *paddr = uc->uc_mcontext->__ss.__eip;
493 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
494 *paddr = uc->uc_mcontext.mc_eip;
495 #elif defined(__dietlibc__)
496 *paddr = uc->uc_mcontext.eip;
497 #elif defined(__NetBSD__)
498 *paddr = uc->uc_mcontext.__gregs[_REG_EIP];
499 #else
500 *paddr = uc->uc_mcontext.gregs[REG_EIP];
501 #endif
502 return 0;
503 } else {
504 #if defined(__APPLE__)
505 fp = uc->uc_mcontext->__ss.__ebp;
506 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
507 fp = uc->uc_mcontext.mc_ebp;
508 #elif defined(__dietlibc__)
509 fp = uc->uc_mcontext.ebp;
510 #elif defined(__NetBSD__)
511 fp = uc->uc_mcontext.__gregs[_REG_EBP];
512 #else
513 fp = uc->uc_mcontext.gregs[REG_EBP];
514 #endif
515 for(i=1;i<level;i++) {
516 /* XXX: check address validity with program info */
517 if (fp <= 0x1000 || fp >= 0xc0000000)
518 return -1;
519 fp = ((addr_t *)fp)[0];
521 *paddr = ((addr_t *)fp)[1];
522 return 0;
526 /* ------------------------------------------------------------- */
527 #elif defined(__x86_64__)
529 /* return the PC at frame level 'level'. Return negative if not found */
530 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
532 addr_t fp;
533 int i;
535 if (level == 0) {
536 /* XXX: only support linux */
537 #if defined(__APPLE__)
538 *paddr = uc->uc_mcontext->__ss.__rip;
539 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
540 *paddr = uc->uc_mcontext.mc_rip;
541 #elif defined(__NetBSD__)
542 *paddr = uc->uc_mcontext.__gregs[_REG_RIP];
543 #else
544 *paddr = uc->uc_mcontext.gregs[REG_RIP];
545 #endif
546 return 0;
547 } else {
548 #if defined(__APPLE__)
549 fp = uc->uc_mcontext->__ss.__rbp;
550 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
551 fp = uc->uc_mcontext.mc_rbp;
552 #elif defined(__NetBSD__)
553 fp = uc->uc_mcontext.__gregs[_REG_RBP];
554 #else
555 fp = uc->uc_mcontext.gregs[REG_RBP];
556 #endif
557 for(i=1;i<level;i++) {
558 /* XXX: check address validity with program info */
559 if (fp <= 0x1000)
560 return -1;
561 fp = ((addr_t *)fp)[0];
563 *paddr = ((addr_t *)fp)[1];
564 return 0;
568 /* ------------------------------------------------------------- */
569 #elif defined(__arm__)
571 /* return the PC at frame level 'level'. Return negative if not found */
572 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
574 addr_t fp, sp;
575 int i;
577 if (level == 0) {
578 /* XXX: only supports linux */
579 #if defined(__linux__)
580 *paddr = uc->uc_mcontext.arm_pc;
581 #else
582 return -1;
583 #endif
584 return 0;
585 } else {
586 #if defined(__linux__)
587 fp = uc->uc_mcontext.arm_fp;
588 sp = uc->uc_mcontext.arm_sp;
589 if (sp < 0x1000)
590 sp = 0x1000;
591 #else
592 return -1;
593 #endif
594 /* XXX: specific to tinycc stack frames */
595 if (fp < sp + 12 || fp & 3)
596 return -1;
597 for(i = 1; i < level; i++) {
598 sp = ((addr_t *)fp)[-2];
599 if (sp < fp || sp - fp > 16 || sp & 3)
600 return -1;
601 fp = ((addr_t *)fp)[-3];
602 if (fp <= sp || fp - sp < 12 || fp & 3)
603 return -1;
605 /* XXX: check address validity with program info */
606 *paddr = ((addr_t *)fp)[-1];
607 return 0;
611 /* ------------------------------------------------------------- */
612 #elif defined(__aarch64__)
614 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
616 if (level < 0)
617 return -1;
618 else if (level == 0) {
619 *paddr = uc->uc_mcontext.pc;
620 return 0;
622 else {
623 addr_t *fp = (addr_t *)uc->uc_mcontext.regs[29];
624 int i;
625 for (i = 1; i < level; i++)
626 fp = (addr_t *)fp[0];
627 *paddr = fp[1];
628 return 0;
632 /* ------------------------------------------------------------- */
633 #else
635 #warning add arch specific rt_get_caller_pc()
636 static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)
638 return -1;
641 #endif /* !__i386__ */
643 /* ------------------------------------------------------------- */
644 #else /* WIN32 */
646 static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)
648 EXCEPTION_RECORD *er = ex_info->ExceptionRecord;
649 CONTEXT *uc = ex_info->ContextRecord;
650 switch (er->ExceptionCode) {
651 case EXCEPTION_ACCESS_VIOLATION:
652 if (rt_bound_error_msg && *rt_bound_error_msg)
653 rt_error(uc, *rt_bound_error_msg);
654 else
655 rt_error(uc, "access violation");
656 break;
657 case EXCEPTION_STACK_OVERFLOW:
658 rt_error(uc, "stack overflow");
659 break;
660 case EXCEPTION_INT_DIVIDE_BY_ZERO:
661 rt_error(uc, "division by zero");
662 break;
663 default:
664 rt_error(uc, "exception caught");
665 break;
667 return EXCEPTION_EXECUTE_HANDLER;
670 /* Generate a stack backtrace when a CPU exception occurs. */
671 static void set_exception_handler(void)
673 SetUnhandledExceptionFilter(cpu_exception_handler);
676 #ifdef _WIN64
677 static void win64_add_function_table(TCCState *s1)
679 RtlAddFunctionTable(
680 (RUNTIME_FUNCTION*)s1->uw_pdata->sh_addr,
681 s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),
682 text_section->sh_addr
683 );
685 #endif
687 /* return the PC at frame level 'level'. Return non zero if not found */
688 static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)
690 addr_t fp, pc;
691 int i;
692 #ifdef _WIN64
693 pc = uc->Rip;
694 fp = uc->Rbp;
695 #else
696 pc = uc->Eip;
697 fp = uc->Ebp;
698 #endif
699 if (level > 0) {
700 for(i=1;i<level;i++) {
701 /* XXX: check address validity with program info */
702 if (fp <= 0x1000 || fp >= 0xc0000000)
703 return -1;
704 fp = ((addr_t*)fp)[0];
706 pc = ((addr_t*)fp)[1];
708 *paddr = pc;
709 return 0;
712 #endif /* _WIN32 */
713 #endif /* CONFIG_TCC_BACKTRACE */
714 /* ------------------------------------------------------------- */
715 #ifdef CONFIG_TCC_STATIC
717 /* dummy function for profiling */
718 ST_FUNC void *dlopen(const char *filename, int flag)
720 return NULL;
723 ST_FUNC void dlclose(void *p)
727 ST_FUNC const char *dlerror(void)
729 return "error";
732 typedef struct TCCSyms {
733 char *str;
734 void *ptr;
735 } TCCSyms;
738 /* add the symbol you want here if no dynamic linking is done */
739 static TCCSyms tcc_syms[] = {
740 #if !defined(CONFIG_TCCBOOT)
741 #define TCCSYM(a) { #a, &a, },
742 TCCSYM(printf)
743 TCCSYM(fprintf)
744 TCCSYM(fopen)
745 TCCSYM(fclose)
746 #undef TCCSYM
747 #endif
748 { NULL, NULL },
749 };
751 ST_FUNC void *resolve_sym(TCCState *s1, const char *symbol)
753 TCCSyms *p;
754 p = tcc_syms;
755 while (p->str != NULL) {
756 if (!strcmp(p->str, symbol))
757 return p->ptr;
758 p++;
760 return NULL;
763 #elif !defined(_WIN32)
765 ST_FUNC void *resolve_sym(TCCState *s1, const char *sym)
767 return dlsym(RTLD_DEFAULT, sym);
770 #endif /* CONFIG_TCC_STATIC */
771 #endif /* TCC_IS_NATIVE */
772 /* ------------------------------------------------------------- */