JitCore_x86.c File Reference

#include <Python.h>
#include "../JitCore.h"
#include "structmember.h"
#include <stdint.h>
#include <inttypes.h>
#include "../queue.h"
#include "../vm_mngr.h"
#include "../vm_mngr_py.h"
#include "JitCore_x86.h"

Include dependency graph for JitCore_x86.c:

Go to the source code of this file.

Macros
#define	getset_reg_E_u32(regname)
#define	getset_reg_R_u16(regname)

Functions
PyObject *	cpu_get_gpreg (JitCpu *self)
PyObject *	cpu_set_gpreg (JitCpu *self, PyObject *args)
PyObject *	cpu_init_regs (JitCpu *self)
void	dump_gpregs (vm_cpu_t *vmcpu)
PyObject *	cpu_dump_gpregs (JitCpu *self, PyObject *args)
PyObject *	cpu_set_exception (JitCpu *self, PyObject *args)
PyObject *	cpu_get_exception (JitCpu *self, PyObject *args)
PyObject *	cpu_set_segm_base (JitCpu *self, PyObject *args)
PyObject *	cpu_get_segm_base (JitCpu *self, PyObject *args)
uint64_t	segm2addr (JitCpu *jitcpu, uint64_t segm, uint64_t addr)
void	check_automod (JitCpu *jitcpu, uint64_t addr, uint64_t size)
void	MEM_WRITE_08 (JitCpu *jitcpu, uint64_t addr, uint8_t src)
void	MEM_WRITE_16 (JitCpu *jitcpu, uint64_t addr, uint16_t src)
void	MEM_WRITE_32 (JitCpu *jitcpu, uint64_t addr, uint32_t src)
void	MEM_WRITE_64 (JitCpu *jitcpu, uint64_t addr, uint64_t src)
PyObject *	vm_set_mem (JitCpu *self, PyObject *args)
static int	JitCpu_init (JitCpu *self, PyObject *args, PyObject *kwds)
	getset_reg_u64 (RAX)
	getset_reg_u64 (RBX)
	getset_reg_u64 (RCX)
	getset_reg_u64 (RDX)
	getset_reg_u64 (RSI)
	getset_reg_u64 (RDI)
	getset_reg_u64 (RSP)
	getset_reg_u64 (RBP)
	getset_reg_u64 (R8)
	getset_reg_u64 (R9)
	getset_reg_u64 (R10)
	getset_reg_u64 (R11)
	getset_reg_u64 (R12)
	getset_reg_u64 (R13)
	getset_reg_u64 (R14)
	getset_reg_u64 (R15)
	getset_reg_u64 (RIP)
	getset_reg_u64 (zf)
	getset_reg_u64 (nf)
	getset_reg_u64 (pf)
	getset_reg_u64 (of)
	getset_reg_u64 (cf)
	getset_reg_u64 (af)
	getset_reg_u64 (df)
	getset_reg_u64 (ES)
	getset_reg_u64 (CS)
	getset_reg_u64 (SS)
	getset_reg_u64 (DS)
	getset_reg_u64 (FS)
	getset_reg_u64 (GS)
	getset_reg_E_u32 (AX)
	getset_reg_E_u32 (BX)
	getset_reg_E_u32 (CX)
	getset_reg_E_u32 (DX)
	getset_reg_E_u32 (SI)
	getset_reg_E_u32 (DI)
	getset_reg_E_u32 (SP)
	getset_reg_E_u32 (BP)
	getset_reg_E_u32 (IP)
	getset_reg_R_u16 (AX)
	getset_reg_R_u16 (BX)
	getset_reg_R_u16 (CX)
	getset_reg_R_u16 (DX)
	getset_reg_R_u16 (SI)
	getset_reg_R_u16 (DI)
	getset_reg_R_u16 (SP)
	getset_reg_R_u16 (BP)
	getset_reg_R_u16 (IP)
PyObject *	get_gpreg_offset_all (void)
PyMODINIT_FUNC	initJitCore_x86 (void)

Variables
reg_dict	gpreg_dict []
static PyMemberDef	JitCpu_members []
static PyMethodDef	JitCpu_methods []
static PyGetSetDef	JitCpu_getseters []
static PyTypeObject	JitCpuType
static PyMethodDef	JitCore_x86_Methods []
static PyObject *	JitCore_x86_Error

Macro Definition Documentation

#define getset_reg_E_u32

(

regname

)

Value:

static PyObject *JitCpu_get_E ## regname  (JitCpu *self, void *closure) \
    {                               \
        return PyLong_FromUnsignedLongLong((uint32_t)(((vm_cpu_t*)(self->cpu))->R ## regname & 0xFFFFFFFF  )); \
    }                               \
    static int JitCpu_set_E ## regname  (JitCpu *self, PyObject *value, void *closure) \
    {                               \
        uint64_t val;                       \
		PyGetInt_ret0(value, val);                \
        val &= 0xFFFFFFFF;                  \
        val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFF00000000ULL; \
        ((vm_cpu_t*)(self->cpu))->R ## regname   = val;         \
        return 0;                       \
    }

Definition at line 367 of file JitCore_x86.c.

#define getset_reg_R_u16

(

regname

)

Value:

static PyObject *JitCpu_get_ ## regname  (JitCpu *self, void *closure) \
    {                               \
        return PyLong_FromUnsignedLongLong((uint16_t)(((vm_cpu_t*)(self->cpu))->R ## regname & 0xFFFF  )); \
    }                               \
    static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
    {                               \
        uint64_t val;                       \
		PyGetInt_ret0(value, val);                \
        val &= 0xFFFF;                      \
        val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFFFFFF0000ULL; \
        ((vm_cpu_t*)(self->cpu))->R ## regname   = val;         \
        return 0;                       \
    }

Definition at line 384 of file JitCore_x86.c.

Function Documentation

void check_automod	(	JitCpu *	jitcpu,
		uint64_t	addr,
		uint64_t	size
	)

Definition at line 259 of file JitCore_x86.c.

{
    PyObject *result;

    if (!(((VmMngr*)jitcpu->pyvm)->vm_mngr.exception_flags & EXCEPT_CODE_AUTOMOD))
        return;
    result = PyObject_CallMethod(jitcpu->jitter, "automod_cb", "LL", addr, size);
    Py_DECREF(result);

}

Here is the caller graph for this function:

PyObject* cpu_dump_gpregs	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 169 of file JitCore_x86.c.

{
    vm_cpu_t* vmcpu;

    vmcpu = self->cpu;
    dump_gpregs(vmcpu);
    Py_INCREF(Py_None);
    return Py_None;
}

Here is the call graph for this function:

PyObject* cpu_get_exception	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 195 of file JitCore_x86.c.

{
    return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
}

PyObject* cpu_get_gpreg

(

JitCpu *

self

)

Definition at line 58 of file JitCore_x86.c.

{
    PyObject *dict = PyDict_New();
    PyObject *o;

    get_reg(RAX);
    get_reg(RBX);
    get_reg(RCX);
    get_reg(RDX);
    get_reg(RSI);
    get_reg(RDI);
    get_reg(RSP);
    get_reg(RBP);

    get_reg(R8);
    get_reg(R9);
    get_reg(R10);
    get_reg(R11);
    get_reg(R12);
    get_reg(R13);
    get_reg(R14);
    get_reg(R15);

    get_reg(RIP);

    get_reg(zf);
    get_reg(nf);
    get_reg(pf);
    get_reg(of);
    get_reg(cf);
    get_reg(af);
    get_reg(df);


    get_reg(ES);
    get_reg(CS);
    get_reg(SS);
    get_reg(DS);
    get_reg(FS);
    get_reg(GS);

    return dict;
}

PyObject* cpu_get_segm_base	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 220 of file JitCore_x86.c.

{
    PyObject *item1;
    uint64_t segm_num;
    PyObject* v;

    if (!PyArg_ParseTuple(args, "O", &item1))
        return NULL;
    PyGetInt(item1, segm_num);
    v = PyInt_FromLong((long)(((vm_cpu_t*)self->cpu)->segm_base[segm_num]));
    return v;
}

PyObject* cpu_init_regs

(

JitCpu *

self

)

Definition at line 142 of file JitCore_x86.c.

{
    memset(self->cpu, 0, sizeof(vm_cpu_t));

    ((vm_cpu_t*)self->cpu)->tsc1 = 0x22222222;
    ((vm_cpu_t*)self->cpu)->tsc2 = 0x11111111;
    ((vm_cpu_t*)self->cpu)->i_f = 1;

    Py_INCREF(Py_None);
    return Py_None;

}

PyObject* cpu_set_exception	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 180 of file JitCore_x86.c.

{
    PyObject *item1;
    uint64_t i;

    if (!PyArg_ParseTuple(args, "O", &item1))
        return NULL;

    PyGetInt(item1, i);

    ((vm_cpu_t*)self->cpu)->exception_flags = i;
    Py_INCREF(Py_None);
    return Py_None;
}

PyObject* cpu_set_gpreg	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 106 of file JitCore_x86.c.

{
    PyObject* dict;
    PyObject *d_key, *d_value = NULL;
    Py_ssize_t pos = 0;
    uint64_t val;
    unsigned int i, found;

    if (!PyArg_ParseTuple(args, "O", &dict))
        return NULL;
    if(!PyDict_Check(dict))
        RAISE(PyExc_TypeError, "arg must be dict");
    while(PyDict_Next(dict, &pos, &d_key, &d_value)){
        if(!PyString_Check(d_key))
            RAISE(PyExc_TypeError, "key must be str");

        PyGetInt(d_value, val);

        found = 0;
        for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
            if (strcmp(PyString_AsString(d_key), gpreg_dict[i].name))
                continue;
            *((uint64_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
            found = 1;
            break;
        }

        if (found)
            continue;
        fprintf(stderr, "unkown key: %s\n", PyString_AsString(d_key));
        RAISE(PyExc_ValueError, "unkown reg");
    }
    Py_INCREF(Py_None);
    return Py_None;
}

PyObject* cpu_set_segm_base	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 204 of file JitCore_x86.c.

{
    PyObject *item1, *item2;
    uint64_t segm_num, segm_base;

    if (!PyArg_ParseTuple(args, "OO", &item1, &item2))
        return NULL;

    PyGetInt(item1, segm_num);
    PyGetInt(item2, segm_base);
    ((vm_cpu_t*)self->cpu)->segm_base[segm_num] = segm_base;

    Py_INCREF(Py_None);
    return Py_None;
}

void dump_gpregs

(

vm_cpu_t *

vmcpu

)

Definition at line 155 of file JitCore_x86.c.

{

    printf("RAX %.16"PRIX64" RBX %.16"PRIX64" RCX %.16"PRIX64" RDX %.16"PRIX64"\n",
           vmcpu->RAX, vmcpu->RBX, vmcpu->RCX, vmcpu->RDX);
    printf("RSI %.16"PRIX64" RDI %.16"PRIX64" RSP %.16"PRIX64" RBP %.16"PRIX64"\n",
           vmcpu->RSI, vmcpu->RDI, vmcpu->RSP, vmcpu->RBP);
    printf("zf %.16"PRIX64" nf %.16"PRIX64" of %.16"PRIX64" cf %.16"PRIX64"\n",
           vmcpu->zf, vmcpu->nf, vmcpu->of, vmcpu->cf);
    printf("RIP %.16"PRIX64"\n",
           vmcpu->RIP);

}

Here is the caller graph for this function:

PyObject* get_gpreg_offset_all

(

void

)

Definition at line 459 of file JitCore_x86.c.

{
    PyObject *dict = PyDict_New();
    PyObject *o;

    get_reg_off(exception_flags);
    get_reg_off(exception_flags_new);

    get_reg_off(RAX);
    get_reg_off(RBX);
    get_reg_off(RCX);
    get_reg_off(RDX);
    get_reg_off(RSI);
    get_reg_off(RDI);
    get_reg_off(RSP);
    get_reg_off(RBP);
    get_reg_off(R8);
    get_reg_off(R9);
    get_reg_off(R10);
    get_reg_off(R11);
    get_reg_off(R12);
    get_reg_off(R13);
    get_reg_off(R14);
    get_reg_off(R15);
    get_reg_off(RIP);
    get_reg_off(RAX_new);
    get_reg_off(RBX_new);
    get_reg_off(RCX_new);
    get_reg_off(RDX_new);
    get_reg_off(RSI_new);
    get_reg_off(RDI_new);
    get_reg_off(RSP_new);
    get_reg_off(RBP_new);
    get_reg_off(R8_new);
    get_reg_off(R9_new);
    get_reg_off(R10_new);
    get_reg_off(R11_new);
    get_reg_off(R12_new);
    get_reg_off(R13_new);
    get_reg_off(R14_new);
    get_reg_off(R15_new);
    get_reg_off(RIP_new);
    get_reg_off(zf);
    get_reg_off(nf);
    get_reg_off(pf);
    get_reg_off(of);
    get_reg_off(cf);
    get_reg_off(af);
    get_reg_off(df);
    get_reg_off(zf_new);
    get_reg_off(nf_new);
    get_reg_off(pf_new);
    get_reg_off(of_new);
    get_reg_off(cf_new);
    get_reg_off(af_new);
    get_reg_off(df_new);
    get_reg_off(tf);
    get_reg_off(i_f);
    get_reg_off(iopl_f);
    get_reg_off(nt);
    get_reg_off(rf);
    get_reg_off(vm);
    get_reg_off(ac);
    get_reg_off(vif);
    get_reg_off(vip);
    get_reg_off(i_d);
    get_reg_off(tf_new);
    get_reg_off(i_f_new);
    get_reg_off(iopl_f_new);
    get_reg_off(nt_new);
    get_reg_off(rf_new);
    get_reg_off(vm_new);
    get_reg_off(ac_new);
    get_reg_off(vif_new);
    get_reg_off(vip_new);
    get_reg_off(i_d_new);
    get_reg_off(my_tick);
    get_reg_off(cond);

    get_reg_off(float_st0);
    get_reg_off(float_st1);
    get_reg_off(float_st2);
    get_reg_off(float_st3);
    get_reg_off(float_st4);
    get_reg_off(float_st5);
    get_reg_off(float_st6);
    get_reg_off(float_st7);
    get_reg_off(float_st0_new);
    get_reg_off(float_st1_new);
    get_reg_off(float_st2_new);
    get_reg_off(float_st3_new);
    get_reg_off(float_st4_new);
    get_reg_off(float_st5_new);
    get_reg_off(float_st6_new);
    get_reg_off(float_st7_new);

    get_reg_off(ES);
    get_reg_off(CS);
    get_reg_off(SS);
    get_reg_off(DS);
    get_reg_off(FS);
    get_reg_off(GS);
    get_reg_off(ES_new);
    get_reg_off(CS_new);
    get_reg_off(SS_new);
    get_reg_off(DS_new);
    get_reg_off(FS_new);
    get_reg_off(GS_new);

    get_reg_off(pfmem08_0);
    get_reg_off(pfmem08_1);
    get_reg_off(pfmem08_2);
    get_reg_off(pfmem08_3);
    get_reg_off(pfmem08_4);
    get_reg_off(pfmem08_5);
    get_reg_off(pfmem08_6);
    get_reg_off(pfmem08_7);
    get_reg_off(pfmem08_8);
    get_reg_off(pfmem08_9);
    get_reg_off(pfmem08_10);
    get_reg_off(pfmem08_11);
    get_reg_off(pfmem08_12);
    get_reg_off(pfmem08_13);
    get_reg_off(pfmem08_14);
    get_reg_off(pfmem08_15);
    get_reg_off(pfmem08_16);
    get_reg_off(pfmem08_17);
    get_reg_off(pfmem08_18);
    get_reg_off(pfmem08_19);
    get_reg_off(pfmem16_0);
    get_reg_off(pfmem16_1);
    get_reg_off(pfmem16_2);
    get_reg_off(pfmem16_3);
    get_reg_off(pfmem16_4);
    get_reg_off(pfmem16_5);
    get_reg_off(pfmem16_6);
    get_reg_off(pfmem16_7);
    get_reg_off(pfmem16_8);
    get_reg_off(pfmem16_9);
    get_reg_off(pfmem16_10);
    get_reg_off(pfmem16_11);
    get_reg_off(pfmem16_12);
    get_reg_off(pfmem16_13);
    get_reg_off(pfmem16_14);
    get_reg_off(pfmem16_15);
    get_reg_off(pfmem16_16);
    get_reg_off(pfmem16_17);
    get_reg_off(pfmem16_18);
    get_reg_off(pfmem16_19);
    get_reg_off(pfmem32_0);
    get_reg_off(pfmem32_1);
    get_reg_off(pfmem32_2);
    get_reg_off(pfmem32_3);
    get_reg_off(pfmem32_4);
    get_reg_off(pfmem32_5);
    get_reg_off(pfmem32_6);
    get_reg_off(pfmem32_7);
    get_reg_off(pfmem32_8);
    get_reg_off(pfmem32_9);
    get_reg_off(pfmem32_10);
    get_reg_off(pfmem32_11);
    get_reg_off(pfmem32_12);
    get_reg_off(pfmem32_13);
    get_reg_off(pfmem32_14);
    get_reg_off(pfmem32_15);
    get_reg_off(pfmem32_16);
    get_reg_off(pfmem32_17);
    get_reg_off(pfmem32_18);
    get_reg_off(pfmem32_19);
    get_reg_off(pfmem64_0);
    get_reg_off(pfmem64_1);
    get_reg_off(pfmem64_2);
    get_reg_off(pfmem64_3);
    get_reg_off(pfmem64_4);
    get_reg_off(pfmem64_5);
    get_reg_off(pfmem64_6);
    get_reg_off(pfmem64_7);
    get_reg_off(pfmem64_8);
    get_reg_off(pfmem64_9);
    get_reg_off(pfmem64_10);
    get_reg_off(pfmem64_11);
    get_reg_off(pfmem64_12);
    get_reg_off(pfmem64_13);
    get_reg_off(pfmem64_14);
    get_reg_off(pfmem64_15);
    get_reg_off(pfmem64_16);
    get_reg_off(pfmem64_17);
    get_reg_off(pfmem64_18);
    get_reg_off(pfmem64_19);

    get_reg_off(MM0);
    get_reg_off(MM1);
    get_reg_off(MM2);
    get_reg_off(MM3);
    get_reg_off(MM4);
    get_reg_off(MM5);
    get_reg_off(MM6);
    get_reg_off(MM7);
    get_reg_off(MM0_new);
    get_reg_off(MM1_new);
    get_reg_off(MM2_new);
    get_reg_off(MM3_new);
    get_reg_off(MM4_new);
    get_reg_off(MM5_new);
    get_reg_off(MM6_new);
    get_reg_off(MM7_new);
    return dict;
}

getset_reg_E_u32

(

AX

)

getset_reg_E_u32

(

BX

)

getset_reg_E_u32

(

CX

)

getset_reg_E_u32

(

DX

)

getset_reg_E_u32

(

SI

)

getset_reg_E_u32

(

DI

)

getset_reg_E_u32

(

SP

)

getset_reg_E_u32

(

BP

)

getset_reg_E_u32

(

IP

)

getset_reg_R_u16

(

AX

)

getset_reg_R_u16

(

BX

)

getset_reg_R_u16

(

CX

)

getset_reg_R_u16

(

DX

)

getset_reg_R_u16

(

SI

)

getset_reg_R_u16

(

DI

)

getset_reg_R_u16

(

SP

)

getset_reg_R_u16

(

BP

)

getset_reg_R_u16

(

IP

)

getset_reg_u64

(

RAX

)

getset_reg_u64

(

RBX

)

getset_reg_u64

(

RCX

)

getset_reg_u64

(

RDX

)

getset_reg_u64

(

RSI

)

getset_reg_u64

(

RDI

)

getset_reg_u64

(

RSP

)

getset_reg_u64

(

RBP

)

getset_reg_u64

(

R8

)

getset_reg_u64

(

R9

)

getset_reg_u64

(

R10

)

getset_reg_u64

(

R11

)

getset_reg_u64

(

R12

)

getset_reg_u64

(

R13

)

getset_reg_u64

(

R14

)

getset_reg_u64

(

R15

)

getset_reg_u64

(

RIP

)

getset_reg_u64

(

zf

)

getset_reg_u64

(

nf

)

getset_reg_u64

(

pf

)

getset_reg_u64

(

of

)

getset_reg_u64

(

cf

)

getset_reg_u64

(

af

)

getset_reg_u64

(

df

)

getset_reg_u64

(

ES

)

getset_reg_u64

(

CS

)

getset_reg_u64

(

SS

)

getset_reg_u64

(

DS

)

getset_reg_u64

(

FS

)

getset_reg_u64

(

GS

)

PyMODINIT_FUNC initJitCore_x86

(

void

)

Definition at line 795 of file JitCore_x86.c.

{
    PyObject *m;

    if (PyType_Ready(&JitCpuType) < 0)
    return;

    m = Py_InitModule("JitCore_x86", JitCore_x86_Methods);
    if (m == NULL)
        return;

    JitCore_x86_Error = PyErr_NewException("JitCore_x86.error", NULL, NULL);
    Py_INCREF(JitCore_x86_Error);
    PyModule_AddObject(m, "error", JitCore_x86_Error);

    Py_INCREF(&JitCpuType);
    PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);

}

static int JitCpu_init ( JitCpu *  self, PyObject *  args, PyObject *  kwds  )

static

Definition at line 356 of file JitCore_x86.c.

{
    self->cpu = malloc(sizeof(vm_cpu_t));
    if (self->cpu == NULL) {
        fprintf(stderr, "cannot alloc vm_cpu_t\n");
        exit(0);
    }
    return 0;
}

void MEM_WRITE_08	(	JitCpu *	jitcpu,
		uint64_t	addr,
		uint8_t	src
	)

Definition at line 270 of file JitCore_x86.c.

{
    vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
    check_automod(jitcpu, addr, 8);
}

Here is the call graph for this function:

void MEM_WRITE_16	(	JitCpu *	jitcpu,
		uint64_t	addr,
		uint16_t	src
	)

Definition at line 276 of file JitCore_x86.c.

{
    vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
    check_automod(jitcpu, addr, 16);
}

Here is the call graph for this function:

void MEM_WRITE_32	(	JitCpu *	jitcpu,
		uint64_t	addr,
		uint32_t	src
	)

Definition at line 282 of file JitCore_x86.c.

{
    vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
    check_automod(jitcpu, addr, 32);
}

Here is the call graph for this function:

void MEM_WRITE_64	(	JitCpu *	jitcpu,
		uint64_t	addr,
		uint64_t	src
	)

Definition at line 288 of file JitCore_x86.c.

{
    vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
    check_automod(jitcpu, addr, 64);
}

Here is the call graph for this function:

uint64_t segm2addr	(	JitCpu *	jitcpu,
		uint64_t	segm,
		uint64_t	addr
	)

Definition at line 233 of file JitCore_x86.c.

{
    return addr + ((vm_cpu_t*)jitcpu->cpu)->segm_base[segm];
}

PyObject* vm_set_mem	(	JitCpu *	self,
		PyObject *	args
	)

Definition at line 296 of file JitCore_x86.c.

{
       PyObject *py_addr;
       PyObject *py_buffer;
       Py_ssize_t py_length;

       char * buffer;
       uint64_t size;
       uint64_t addr;
       int ret = 0x1337;

       if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
           return NULL;

       PyGetInt(py_addr, addr);

       if(!PyString_Check(py_buffer))
           RAISE(PyExc_TypeError,"arg must be str");

       size = PyString_Size(py_buffer);
       PyString_AsStringAndSize(py_buffer, &buffer, &py_length);

       ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
       if (ret < 0)
           RAISE(PyExc_TypeError,"arg must be str");
       check_automod(self, addr, size*8);

       Py_INCREF(Py_None);
       return Py_None;
}

Here is the call graph for this function:

Variable Documentation

reg_dict gpreg_dict[]

Definition at line 13 of file JitCore_x86.c.

PyObject* JitCore_x86_Error

static

Definition at line 792 of file JitCore_x86.c.

PyMethodDef JitCore_x86_Methods[]

static

Initial value:

= {

    
    {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
    {NULL, NULL, 0, NULL}        

}

Definition at line 782 of file JitCore_x86.c.

PyGetSetDef JitCpu_getseters[]

static

Definition at line 669 of file JitCore_x86.c.

PyMemberDef JitCpu_members[]

static

Initial value:

= {
    {NULL}  
}

Definition at line 327 of file JitCore_x86.c.

PyMethodDef JitCpu_methods[]

static

Initial value:

= {
    {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
     "X"},
    {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
     "X"},
    {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS,
     "X"},
    {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS,
     "X"},
    {"get_segm_base", (PyCFunction)cpu_get_segm_base, METH_VARARGS,
     "X"},
    {"set_segm_base", (PyCFunction)cpu_set_segm_base, METH_VARARGS,
     "X"},
    {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS,
     "X"},
    {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS,
     "X"},
    {"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
     "X"},
    {"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
     "X"},
    {NULL}  
}

Definition at line 331 of file JitCore_x86.c.

PyTypeObject JitCpuType

static

Definition at line 738 of file JitCore_x86.c.