Subversion Repositories Kolibri OS

/*

 *  TCC - Tiny C Compiler - Support for -run switch

 *

 *  Copyright (c) 2001-2004 Fabrice Bellard

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "tcc.h"

/* only native compiler supports -run */

#ifdef TCC_IS_NATIVE

#ifdef CONFIG_TCC_BACKTRACE

ST_DATA int rt_num_callers = 6;

ST_DATA const char **rt_bound_error_msg;

ST_DATA void *rt_prog_main;

#endif

#ifdef _WIN32

#define ucontext_t CONTEXT

#endif

static void set_pages_executable(void *ptr, unsigned long length);

static void set_exception_handler(void);

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level);

static void rt_error(ucontext_t *uc, const char *fmt, ...);

static int tcc_relocate_ex(TCCState *s1, void *ptr);

#ifdef _WIN64

static void win64_add_function_table(TCCState *s1);

#endif

/* ------------------------------------------------------------- */

/* Do all relocations (needed before using tcc_get_symbol())

   Returns -1 on error. */

LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr)

{

    int ret;

    if (TCC_RELOCATE_AUTO != ptr)

        return tcc_relocate_ex(s1, ptr);

    ret = tcc_relocate_ex(s1, NULL);

    if (ret < 0)

        return ret;

#ifdef HAVE_SELINUX

    {   /* Use mmap instead of malloc for Selinux.  Ref:

           http://www.gnu.org/s/libc/manual/html_node/File-Size.html */

        char tmpfname[] = "/tmp/.tccrunXXXXXX";

        int fd = mkstemp (tmpfname);

        s1->mem_size = ret;

        unlink (tmpfname);

        ftruncate (fd, s1->mem_size);

        s1->write_mem = mmap (NULL, ret, PROT_READ|PROT_WRITE,

            MAP_SHARED, fd, 0);

        if (s1->write_mem == MAP_FAILED)

            tcc_error("/tmp not writeable");

        s1->runtime_mem = mmap (NULL, ret, PROT_READ|PROT_EXEC,

            MAP_SHARED, fd, 0);

        if (s1->runtime_mem == MAP_FAILED)

            tcc_error("/tmp not executable");

        ret = tcc_relocate_ex(s1, s1->write_mem);

    }

#else

    s1->runtime_mem = tcc_malloc(ret);

    ret = tcc_relocate_ex(s1, s1->runtime_mem);

#endif

    return ret;

}

/* launch the compiled program with the given arguments */

LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)

{

    int (*prog_main)(int, char **);

    int ret;

    if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)

        return -1;

    prog_main = tcc_get_symbol_err(s1, s1->runtime_main);

#ifdef CONFIG_TCC_BACKTRACE

    if (s1->do_debug) {

        set_exception_handler();

        rt_prog_main = prog_main;

    }

#endif

#ifdef CONFIG_TCC_BCHECK

    if (s1->do_bounds_check) {

        void (*bound_init)(void);

        void (*bound_exit)(void);

        void (*bound_new_region)(void *p, addr_t size);

        int  (*bound_delete_region)(void *p);

        int i;

        /* set error function */

        rt_bound_error_msg = tcc_get_symbol_err(s1, "__bound_error_msg");

        /* XXX: use .init section so that it also work in binary ? */

        bound_init = tcc_get_symbol_err(s1, "__bound_init");

        bound_exit = tcc_get_symbol_err(s1, "__bound_exit");

        bound_new_region = tcc_get_symbol_err(s1, "__bound_new_region");

        bound_delete_region = tcc_get_symbol_err(s1, "__bound_delete_region");

        bound_init();

        /* mark argv area as valid */

        bound_new_region(argv, argc*sizeof(argv[0]));

        for (i=0; i

            bound_new_region(argv[i], strlen(argv[i]));

	errno = 0; /* clean errno value */

        ret = (*prog_main)(argc, argv);

        /* unmark argv area */

        for (i=0; i

            bound_delete_region(argv[i]);

        bound_delete_region(argv);

        bound_exit();

    } else

#endif

    {

	errno = 0; /* clean errno value */

        ret = (*prog_main)(argc, argv);

    }

    return ret;

}

/* relocate code. Return -1 on error, required size if ptr is NULL,

   otherwise copy code into buffer passed by the caller */

static int tcc_relocate_ex(TCCState *s1, void *ptr)

{

    Section *s;

    unsigned long offset, length;

    addr_t mem;

    int i;

    if (NULL == ptr) {

        s1->nb_errors = 0;

#ifdef TCC_TARGET_PE

        pe_output_file(s1, NULL);

#else

        tcc_add_runtime(s1);

        relocate_common_syms();

        tcc_add_linker_symbols(s1);

        build_got_entries(s1);

#endif

        if (s1->nb_errors)

            return -1;

    }

    offset = 0, mem = (addr_t)ptr;

    for(i = 1; i < s1->nb_sections; i++) {

        s = s1->sections[i];

        if (0 == (s->sh_flags & SHF_ALLOC))

            continue;

        length = s->data_offset;

        s->sh_addr = mem ? (mem + offset + 15) & ~15 : 0;

        offset = (offset + length + 15) & ~15;

    }

    offset += 16;

    /* relocate symbols */

    relocate_syms(s1, 1);

    if (s1->nb_errors)

        return -1;

    if (0 == mem)

        return offset;

    /* relocate each section */

    for(i = 1; i < s1->nb_sections; i++) {

        s = s1->sections[i];

        if (s->reloc)

            relocate_section(s1, s);

    }

    relocate_plt(s1);

    for(i = 1; i < s1->nb_sections; i++) {

        s = s1->sections[i];

        if (0 == (s->sh_flags & SHF_ALLOC))

            continue;

        length = s->data_offset;

        // printf("%-12s %08lx %04x\n", s->name, s->sh_addr, length);

        ptr = (void*)s->sh_addr;

        if (NULL == s->data || s->sh_type == SHT_NOBITS)

            memset(ptr, 0, length);

        else

            memcpy(ptr, s->data, length);

        /* mark executable sections as executable in memory */

        if (s->sh_flags & SHF_EXECINSTR)

            set_pages_executable(ptr, length);

    }

#ifdef _WIN64

    win64_add_function_table(s1);

#endif

    return 0;

}

/* ------------------------------------------------------------- */

/* allow to run code in memory */

static void set_pages_executable(void *ptr, unsigned long length)

{

#ifdef _WIN32

    unsigned long old_protect;

    VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);

#else

    extern void __clear_cache(void *beginning, void *end);

#ifndef PAGESIZE

# define PAGESIZE 4096

#endif

    addr_t start, end;

    start = (addr_t)ptr & ~(PAGESIZE - 1);

    end = (addr_t)ptr + length;

    end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);

    mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC);

  #ifndef __PCC__

    __clear_cache(ptr, (char *)ptr + length);

  #else

    /* pcc 1.2.0.DEVEL 20141206 don't have such proc */

  #endif

#endif

}

/* ------------------------------------------------------------- */

#ifdef CONFIG_TCC_BACKTRACE

ST_FUNC void tcc_set_num_callers(int n)

{

    rt_num_callers = n;

}

/* print the position in the source file of PC value 'pc' by reading

   the stabs debug information */

static addr_t rt_printline(addr_t wanted_pc, const char *msg)

{

    char func_name[128], last_func_name[128];

    addr_t func_addr, last_pc, pc;

    const char *incl_files[INCLUDE_STACK_SIZE];

    int incl_index, len, last_line_num, i;

    const char *str, *p;

    Stab_Sym *stab_sym = NULL, *stab_sym_end, *sym;

    int stab_len = 0;

    char *stab_str = NULL;

    if (stab_section) {

        stab_len = stab_section->data_offset;

        stab_sym = (Stab_Sym *)stab_section->data;

        stab_str = (char *) stabstr_section->data;

    }

    func_name[0] = '\0';

    func_addr = 0;

    incl_index = 0;

    last_func_name[0] = '\0';

    last_pc = (addr_t)-1;

    last_line_num = 1;

    if (!stab_sym)

        goto no_stabs;

    stab_sym_end = (Stab_Sym*)((char*)stab_sym + stab_len);

    for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {

        switch(sym->n_type) {

            /* function start or end */

        case N_FUN:

            if (sym->n_strx == 0) {

                /* we test if between last line and end of function */

                pc = sym->n_value + func_addr;

                if (wanted_pc >= last_pc && wanted_pc < pc)

                    goto found;

                func_name[0] = '\0';

                func_addr = 0;

            } else {

                str = stab_str + sym->n_strx;

                p = strchr(str, ':');

                if (!p) {

                    pstrcpy(func_name, sizeof(func_name), str);

                } else {

                    len = p - str;

                    if (len > sizeof(func_name) - 1)

                        len = sizeof(func_name) - 1;

                    memcpy(func_name, str, len);

                    func_name[len] = '\0';

                }

                func_addr = sym->n_value;

            }

            break;

            /* line number info */

        case N_SLINE:

            pc = sym->n_value + func_addr;

            if (wanted_pc >= last_pc && wanted_pc < pc)

                goto found;

            last_pc = pc;

            last_line_num = sym->n_desc;

            /* XXX: slow! */

            strcpy(last_func_name, func_name);

            break;

            /* include files */

        case N_BINCL:

            str = stab_str + sym->n_strx;

        add_incl:

            if (incl_index < INCLUDE_STACK_SIZE) {

                incl_files[incl_index++] = str;

            }

            break;

        case N_EINCL:

            if (incl_index > 1)

                incl_index--;

            break;

        case N_SO:

            if (sym->n_strx == 0) {

                incl_index = 0; /* end of translation unit */

            } else {

                str = stab_str + sym->n_strx;

                /* do not add path */

                len = strlen(str);

                if (len > 0 && str[len - 1] != '/')

                    goto add_incl;

            }

            break;

        }

    }

no_stabs:

    /* second pass: we try symtab symbols (no line number info) */

    incl_index = 0;

    if (symtab_section)

    {

        ElfW(Sym) *sym, *sym_end;

        int type;

        sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);

        for(sym = (ElfW(Sym) *)symtab_section->data + 1;

            sym < sym_end;

            sym++) {

            type = ELFW(ST_TYPE)(sym->st_info);

            if (type == STT_FUNC || type == STT_GNU_IFUNC) {

                if (wanted_pc >= sym->st_value &&

                    wanted_pc < sym->st_value + sym->st_size) {

                    pstrcpy(last_func_name, sizeof(last_func_name),

                            (char *) strtab_section->data + sym->st_name);

                    func_addr = sym->st_value;

                    goto found;

                }

            }

        }

    }

    /* did not find any info: */

    fprintf(stderr, "%s %p ???\n", msg, (void*)wanted_pc);

    fflush(stderr);

    return 0;

 found:

    i = incl_index;

    if (i > 0)

        fprintf(stderr, "%s:%d: ", incl_files[--i], last_line_num);

    fprintf(stderr, "%s %p", msg, (void*)wanted_pc);

    if (last_func_name[0] != '\0')

        fprintf(stderr, " %s()", last_func_name);

    if (--i >= 0) {

        fprintf(stderr, " (included from ");

        for (;;) {

            fprintf(stderr, "%s", incl_files[i]);

            if (--i < 0)

                break;

            fprintf(stderr, ", ");

        }

        fprintf(stderr, ")");

    }

    fprintf(stderr, "\n");

    fflush(stderr);

    return func_addr;

}

/* emit a run time error at position 'pc' */

static void rt_error(ucontext_t *uc, const char *fmt, ...)

{

    va_list ap;

    addr_t pc;

    int i;

    fprintf(stderr, "Runtime error: ");

    va_start(ap, fmt);

    vfprintf(stderr, fmt, ap);

    va_end(ap);

    fprintf(stderr, "\n");

    for(i=0;i

        if (rt_get_caller_pc(&pc, uc, i) < 0)

            break;

        pc = rt_printline(pc, i ? "by" : "at");

        if (pc == (addr_t)rt_prog_main && pc)

            break;

    }

}

/* ------------------------------------------------------------- */

#ifndef _WIN32

/* signal handler for fatal errors */

static void sig_error(int signum, siginfo_t *siginf, void *puc)

{

    ucontext_t *uc = puc;

    switch(signum) {

    case SIGFPE:

        switch(siginf->si_code) {

        case FPE_INTDIV:

        case FPE_FLTDIV:

            rt_error(uc, "division by zero");

            break;

        default:

            rt_error(uc, "floating point exception");

            break;

        }

        break;

    case SIGBUS:

    case SIGSEGV:

        if (rt_bound_error_msg && *rt_bound_error_msg)

            rt_error(uc, *rt_bound_error_msg);

        else

            rt_error(uc, "dereferencing invalid pointer");

        break;

    case SIGILL:

        rt_error(uc, "illegal instruction");

        break;

    case SIGABRT:

        rt_error(uc, "abort() called");

        break;

    default:

        rt_error(uc, "caught signal %d", signum);

        break;

    }

    exit(255);

}

#ifndef SA_SIGINFO

# define SA_SIGINFO 0x00000004u

#endif

/* Generate a stack backtrace when a CPU exception occurs. */

static void set_exception_handler(void)

{

    struct sigaction sigact;

    /* install TCC signal handlers to print debug info on fatal

       runtime errors */

    sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;

    sigact.sa_sigaction = sig_error;

    sigemptyset(&sigact.sa_mask);

    sigaction(SIGFPE, &sigact, NULL);

    sigaction(SIGILL, &sigact, NULL);

    sigaction(SIGSEGV, &sigact, NULL);

    sigaction(SIGBUS, &sigact, NULL);

    sigaction(SIGABRT, &sigact, NULL);

}

/* ------------------------------------------------------------- */

#ifdef __i386__

/* fix for glibc 2.1 */

#ifndef REG_EIP

#define REG_EIP EIP

#define REG_EBP EBP

#endif

/* return the PC at frame level 'level'. Return negative if not found */

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)

{

    addr_t fp;

    int i;

    if (level == 0) {

#if defined(__APPLE__)

        *paddr = uc->uc_mcontext->__ss.__eip;

#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

        *paddr = uc->uc_mcontext.mc_eip;

#elif defined(__dietlibc__)

        *paddr = uc->uc_mcontext.eip;

#elif defined(__NetBSD__)

        *paddr = uc->uc_mcontext.__gregs[_REG_EIP];

#else

        *paddr = uc->uc_mcontext.gregs[REG_EIP];

#endif

        return 0;

    } else {

#if defined(__APPLE__)

        fp = uc->uc_mcontext->__ss.__ebp;

#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

        fp = uc->uc_mcontext.mc_ebp;

#elif defined(__dietlibc__)

        fp = uc->uc_mcontext.ebp;

#elif defined(__NetBSD__)

        fp = uc->uc_mcontext.__gregs[_REG_EBP];

#else

        fp = uc->uc_mcontext.gregs[REG_EBP];

#endif

        for(i=1;i

            /* XXX: check address validity with program info */

            if (fp <= 0x1000 || fp >= 0xc0000000)

                return -1;

            fp = ((addr_t *)fp)[0];

        }

        *paddr = ((addr_t *)fp)[1];

        return 0;

    }

}

/* ------------------------------------------------------------- */

#elif defined(__x86_64__)

/* return the PC at frame level 'level'. Return negative if not found */

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)

{

    addr_t fp;

    int i;

    if (level == 0) {

        /* XXX: only support linux */

#if defined(__APPLE__)

        *paddr = uc->uc_mcontext->__ss.__rip;

#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

        *paddr = uc->uc_mcontext.mc_rip;

#elif defined(__NetBSD__)

        *paddr = uc->uc_mcontext.__gregs[_REG_RIP];

#else

        *paddr = uc->uc_mcontext.gregs[REG_RIP];

#endif

        return 0;

    } else {

#if defined(__APPLE__)

        fp = uc->uc_mcontext->__ss.__rbp;

#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)

        fp = uc->uc_mcontext.mc_rbp;

#elif defined(__NetBSD__)

        fp = uc->uc_mcontext.__gregs[_REG_RBP];

#else

        fp = uc->uc_mcontext.gregs[REG_RBP];

#endif

        for(i=1;i

            /* XXX: check address validity with program info */

            if (fp <= 0x1000)

                return -1;

            fp = ((addr_t *)fp)[0];

        }

        *paddr = ((addr_t *)fp)[1];

        return 0;

    }

}

/* ------------------------------------------------------------- */

#elif defined(__arm__)

/* return the PC at frame level 'level'. Return negative if not found */

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)

{

    addr_t fp, sp;

    int i;

    if (level == 0) {

        /* XXX: only supports linux */

#if defined(__linux__)

        *paddr = uc->uc_mcontext.arm_pc;

#else

        return -1;

#endif

        return 0;

    } else {

#if defined(__linux__)

        fp = uc->uc_mcontext.arm_fp;

        sp = uc->uc_mcontext.arm_sp;

        if (sp < 0x1000)

            sp = 0x1000;

#else

        return -1;

#endif

        /* XXX: specific to tinycc stack frames */

        if (fp < sp + 12 || fp & 3)

            return -1;

        for(i = 1; i < level; i++) {

            sp = ((addr_t *)fp)[-2];

            if (sp < fp || sp - fp > 16 || sp & 3)

                return -1;

            fp = ((addr_t *)fp)[-3];

            if (fp <= sp || fp - sp < 12 || fp & 3)

                return -1;

        }

        /* XXX: check address validity with program info */

        *paddr = ((addr_t *)fp)[-1];

        return 0;

    }

}

/* ------------------------------------------------------------- */

#elif defined(__aarch64__)

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)

{

    if (level < 0)

        return -1;

    else if (level == 0) {

        *paddr = uc->uc_mcontext.pc;

        return 0;

    }

    else {

        addr_t *fp = (addr_t *)uc->uc_mcontext.regs[29];

        int i;

        for (i = 1; i < level; i++)

            fp = (addr_t *)fp[0];

        *paddr = fp[1];

        return 0;

    }

}

/* ------------------------------------------------------------- */

#else

#warning add arch specific rt_get_caller_pc()

static int rt_get_caller_pc(addr_t *paddr, ucontext_t *uc, int level)

{

    return -1;

}

#endif /* !__i386__ */

/* ------------------------------------------------------------- */

#else /* WIN32 */

static long __stdcall cpu_exception_handler(EXCEPTION_POINTERS *ex_info)

{

    EXCEPTION_RECORD *er = ex_info->ExceptionRecord;

    CONTEXT *uc = ex_info->ContextRecord;

    switch (er->ExceptionCode) {

    case EXCEPTION_ACCESS_VIOLATION:

        if (rt_bound_error_msg && *rt_bound_error_msg)

            rt_error(uc, *rt_bound_error_msg);

        else

	    rt_error(uc, "access violation");

        break;

    case EXCEPTION_STACK_OVERFLOW:

        rt_error(uc, "stack overflow");

        break;

    case EXCEPTION_INT_DIVIDE_BY_ZERO:

        rt_error(uc, "division by zero");

        break;

    default:

        rt_error(uc, "exception caught");

        break;

    }

    return EXCEPTION_EXECUTE_HANDLER;

}

/* Generate a stack backtrace when a CPU exception occurs. */

static void set_exception_handler(void)

{

    SetUnhandledExceptionFilter(cpu_exception_handler);

}

#ifdef _WIN64

static void win64_add_function_table(TCCState *s1)

{

    RtlAddFunctionTable(

        (RUNTIME_FUNCTION*)s1->uw_pdata->sh_addr,

        s1->uw_pdata->data_offset / sizeof (RUNTIME_FUNCTION),

        text_section->sh_addr

        );

}

#endif

/* return the PC at frame level 'level'. Return non zero if not found */

static int rt_get_caller_pc(addr_t *paddr, CONTEXT *uc, int level)

{

    addr_t fp, pc;

    int i;

#ifdef _WIN64

    pc = uc->Rip;

    fp = uc->Rbp;

#else

    pc = uc->Eip;

    fp = uc->Ebp;

#endif

    if (level > 0) {

        for(i=1;i

	    /* XXX: check address validity with program info */

	    if (fp <= 0x1000 || fp >= 0xc0000000)

		return -1;

	    fp = ((addr_t*)fp)[0];

	}

        pc = ((addr_t*)fp)[1];

    }

    *paddr = pc;

    return 0;

}

#endif /* _WIN32 */

#endif /* CONFIG_TCC_BACKTRACE */

/* ------------------------------------------------------------- */

#ifdef CONFIG_TCC_STATIC

/* dummy function for profiling */

ST_FUNC void *dlopen(const char *filename, int flag)

{

    return NULL;

}

ST_FUNC void dlclose(void *p)

{

}

ST_FUNC const char *dlerror(void)

{

    return "error";

}

typedef struct TCCSyms {

    char *str;

    void *ptr;

} TCCSyms;

/* add the symbol you want here if no dynamic linking is done */

static TCCSyms tcc_syms[] = {

#if !defined(CONFIG_TCCBOOT)

#define TCCSYM(a) { #a, &a, },

    TCCSYM(printf)

    TCCSYM(fprintf)

    TCCSYM(fopen)

    TCCSYM(fclose)

#undef TCCSYM

#endif

    { NULL, NULL },

};

ST_FUNC void *resolve_sym(TCCState *s1, const char *symbol)

{

    TCCSyms *p;

    p = tcc_syms;

    while (p->str != NULL) {

        if (!strcmp(p->str, symbol))

            return p->ptr;

        p++;

    }

    return NULL;

}

#elif !defined(_WIN32)

ST_FUNC void *resolve_sym(TCCState *s1, const char *sym)

{

    return dlsym(RTLD_DEFAULT, sym);

}

#endif /* CONFIG_TCC_STATIC */

#endif /* TCC_IS_NATIVE */

/* ------------------------------------------------------------- */