Jittcc.c File Reference

#include <Python.h>
#include <inttypes.h>
#include <libtcc.h>
#include <stdint.h>

Include dependency graph for Jittcc.c:

Go to the source code of this file.

Classes
struct	block_id

Typedefs
typedef int(*	jitted_func )(block_id *, PyObject *)

Functions
TCCState *	tcc_init_state (void)
PyObject *	tcc_end (PyObject *self, PyObject *args)
PyObject *	tcc_set_emul_lib_path (PyObject *self, PyObject *args)
PyObject *	tcc_exec_bloc (PyObject *self, PyObject *args)
PyObject *	tcc_compil (PyObject *self, PyObject *args)
PyObject *	tcc_loop_exec (PyObject *self, PyObject *args)
PyMODINIT_FUNC	initJittcc (void)

Variables
int	include_array_count = 0
char **	include_array = NULL
int	lib_array_count = 0
char **	lib_array = NULL
static PyObject *	TccError
static PyMethodDef	TccMethods []

Typedef Documentation

typedef int(* jitted_func)(block_id *, PyObject *)

Definition at line 127 of file Jittcc.c.

Function Documentation

PyMODINIT_FUNC initJittcc

(

void

)

Definition at line 279 of file Jittcc.c.

{
    PyObject *m;

    m = Py_InitModule("Jittcc", TccMethods);
    if (m == NULL)
        return;

    TccError = PyErr_NewException("tcc.error", NULL, NULL);
    Py_INCREF(TccError);
    PyModule_AddObject(m, "error", TccError);
}

PyObject* tcc_compil	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 180 of file Jittcc.c.

{
    char* func_name;
    char* func_code;
    int (*entry)(void);
    TCCState *tcc_state = NULL;
    PyObject* ret;

    tcc_state = tcc_init_state();

    if (!PyArg_ParseTuple(args, "ss", &func_name, &func_code))
        return NULL;

    if (tcc_compile_string(tcc_state, func_code) != 0) {
        fprintf(stderr, "Erreur de compilation !\n");
        fprintf(stderr, "%s\n", func_code);
        exit(1);
    }
    /* XXX configure tinycc install with --disable-static */
    if (tcc_relocate(tcc_state, TCC_RELOCATE_AUTO) < 0) {
        fprintf(stderr, "tcc relocate error\n");
        exit(1);
    }
    entry = tcc_get_symbol(tcc_state, func_name);
    if (!entry){
        fprintf(stderr, "Erreur de symbole %s!\n", func_name);
        fprintf(stderr, "%s\n", func_name);
        exit(1);
    }

    ret = PyTuple_New(2);
    if (ret == NULL) {
        fprintf(stderr, "Erreur alloc %s!\n", func_name);
        fprintf(stderr, "%s\n", func_name);
        exit(1);
    }

    PyTuple_SetItem(ret, 0, PyLong_FromUnsignedLongLong((uint64_t)tcc_state));
    PyTuple_SetItem(ret, 1, PyLong_FromUnsignedLongLong((uint64_t)entry));

    return ret;

}

Here is the call graph for this function:

PyObject* tcc_end	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 60 of file Jittcc.c.

{
    TCCState *tcc_state = NULL;
    if (!PyArg_ParseTuple(args, "K", &tcc_state))
        return NULL;
    tcc_delete(tcc_state);

    Py_INCREF(Py_None);
    return Py_None;
}

PyObject* tcc_exec_bloc	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 130 of file Jittcc.c.

{
    jitted_func func;
    PyObject* jitcpu;
    PyObject* func_py;
    PyObject* lbl2ptr;
    PyObject* breakpoints;
    PyObject* retaddr = NULL;
    int status;
    block_id BlockDst;

    if (!PyArg_ParseTuple(args, "OOOO", &retaddr, &jitcpu, &lbl2ptr, &breakpoints))
        return NULL;

    /* The loop will decref retaddr always once */
    Py_INCREF(retaddr);

    for (;;) {
        // Init
        BlockDst.is_local = 0;
        BlockDst.address = 0;

        // Get the expected jitted function address
        func_py = PyDict_GetItem(lbl2ptr, retaddr);
        if (func_py)
            func = (jitted_func) PyInt_AsLong((PyObject*) func_py);
        else {
            if (BlockDst.is_local == 1) {
                fprintf(stderr, "return on local label!\n");
                exit(1);
            }
            // retaddr is not jitted yet
            return retaddr;
        }

        // Execute it
        status = func(&BlockDst, jitcpu);
        Py_DECREF(retaddr);
        retaddr = PyLong_FromUnsignedLongLong(BlockDst.address);

        // Check exception
        if (status)
            return retaddr;

        // Check breakpoint
        if (PyDict_Contains(breakpoints, retaddr))
            return retaddr;
    }
}

TCCState* tcc_init_state

(

void

)

Definition at line 37 of file Jittcc.c.

{
    int i;
    TCCState *tcc_state = NULL;
    tcc_state = tcc_new();
    if (!tcc_state) {
        fprintf(stderr, "Impossible de creer un contexte TCC\n");
        exit(1);
    }
    tcc_set_output_type(tcc_state, TCC_OUTPUT_MEMORY);

    //tcc_add_file(tcc_state, libcodenat_path);
    for (i=0;i<lib_array_count; i++){
        tcc_add_file(tcc_state, lib_array[i]);
    }

    for (i=0;i<include_array_count; i++){
        tcc_add_include_path(tcc_state, include_array[i]);
    }
    return tcc_state;
}

Here is the caller graph for this function:

PyObject* tcc_loop_exec	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 226 of file Jittcc.c.

{
    //PyObject* (*func)(void*, void*);
    uint64_t* vm;
    uint64_t* cpu;
    PyObject* ret;
    PyObject* func;
    PyObject* pArgs;


    if (!PyArg_ParseTuple(args, "OKK", &func, &cpu, &vm))
        return NULL;

    while (1) {
        if (!PyCallable_Check (func)) {
            fprintf(stderr, "function not callable!\n");
            exit(0);
        }

        pArgs = PyTuple_New(2);
        PyTuple_SetItem(pArgs, 0, PyLong_FromUnsignedLongLong((uint64_t)cpu));
        PyTuple_SetItem(pArgs, 1, PyLong_FromUnsignedLongLong((uint64_t)vm));
        ret = PyObject_CallObject(func, pArgs);
        Py_DECREF(2);

        if (ret == Py_None) {
            Py_INCREF(Py_None);
            return Py_None;
        }
        func = ret;
    }

    return ret;
}

Here is the call graph for this function:

PyObject* tcc_set_emul_lib_path	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 71 of file Jittcc.c.

{
    char* include_arg;
    char* lib_arg;

    char* str1, * str2, * init_ptr;
    if (!PyArg_ParseTuple(args, "ss",
                  &include_arg,
                  &lib_arg))
        return NULL;

    init_ptr = str2 = strdup(include_arg);
    while (str2){
        str1 = strsep(&str2, ";");
        if (str1){
            include_array_count ++;
            include_array = realloc(include_array,
                             include_array_count * sizeof(char*));
            include_array[include_array_count-1] = strdup(str1);
            // fprintf(stderr, "adding include file: %s\n", str1);
        }
    }
    if (init_ptr != NULL)
        free(init_ptr);

    init_ptr = str2 = strdup(lib_arg);
    while (str2){
        str1 = strsep(&str2, ";");
        if (str1){
            lib_array_count ++;
            lib_array = realloc(lib_array,
                         lib_array_count * sizeof(char*));
            lib_array[lib_array_count-1] = strdup(str1);
            // fprintf(stderr, "adding lib file: %s\n", str1);
        }
    }
    if (init_ptr != NULL)
        free(init_ptr);


    /*
    libcodenat_path = (char*)malloc(strlen(libcodenat_path_arg)+1);
    strcpy(libcodenat_path, libcodenat_path_arg);
    */
    Py_INCREF(Py_None);


    return Py_None;
}

Variable Documentation

char** include_array = NULL

Definition at line 28 of file Jittcc.c.

int include_array_count = 0

Definition at line 27 of file Jittcc.c.

char** lib_array = NULL

Definition at line 32 of file Jittcc.c.

int lib_array_count = 0

Definition at line 31 of file Jittcc.c.

PyObject* TccError

static

Definition at line 263 of file Jittcc.c.

PyMethodDef TccMethods[]

static

Initial value:

= {
    {"tcc_set_emul_lib_path",  tcc_set_emul_lib_path, METH_VARARGS,
     "init tcc path"},
    {"tcc_exec_bloc",  tcc_exec_bloc, METH_VARARGS,
     "tcc exec bloc"},
    {"tcc_compil",  tcc_compil, METH_VARARGS,
     "tcc compil"},
    {"tcc_end",  tcc_end, METH_VARARGS,
     "tcc end"},
    {NULL, NULL, 0, NULL}        
}

Definition at line 266 of file Jittcc.c.