vm_mngr.c File Reference

#include <Python.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <math.h>
#include "queue.h"
#include "vm_mngr.h"

Include dependency graph for vm_mngr.c:

Go to the source code of this file.

Macros
#define	MIN(a, b)   (((a)<(b))?(a):(b))
#define	MAX(a, b)   (((a)>(b))?(a):(b))

Functions
uint16_t	set_endian16 (vm_mngr_t *vm_mngr, uint16_t val)
uint32_t	set_endian32 (vm_mngr_t *vm_mngr, uint32_t val)
uint64_t	set_endian64 (vm_mngr_t *vm_mngr, uint64_t val)
void	print_val (uint64_t base, uint64_t addr)
int	is_mem_mapped (vm_mngr_t *vm_mngr, uint64_t ad)
uint64_t	get_mem_base_addr (vm_mngr_t *vm_mngr, uint64_t ad, uint64_t *addr_base)
struct memory_page_node *	get_memory_page_from_address (vm_mngr_t *vm_mngr, uint64_t ad)
static uint64_t	memory_page_read (vm_mngr_t *vm_mngr, unsigned int my_size, uint64_t ad)
static void	memory_page_write (vm_mngr_t *vm_mngr, unsigned int my_size, uint64_t ad, uint64_t src)
uint16_t	bcdadd_16 (uint16_t a, uint16_t b)
uint16_t	bcdadd_cf_16 (uint16_t a, uint16_t b)
void	dump_code_bloc (vm_mngr_t *vm_mngr)
void	check_write_code_bloc (vm_mngr_t *vm_mngr, uint64_t my_size, uint64_t addr)
PyObject *	addr2BlocObj (vm_mngr_t *vm_mngr, uint64_t addr)
void	vm_MEM_WRITE_08 (vm_mngr_t *vm_mngr, uint64_t addr, unsigned char src)
void	vm_MEM_WRITE_16 (vm_mngr_t *vm_mngr, uint64_t addr, unsigned short src)
void	vm_MEM_WRITE_32 (vm_mngr_t *vm_mngr, uint64_t addr, unsigned int src)
void	vm_MEM_WRITE_64 (vm_mngr_t *vm_mngr, uint64_t addr, uint64_t src)
unsigned char	vm_MEM_LOOKUP_08 (vm_mngr_t *vm_mngr, uint64_t addr)
unsigned short	vm_MEM_LOOKUP_16 (vm_mngr_t *vm_mngr, uint64_t addr)
unsigned int	vm_MEM_LOOKUP_32 (vm_mngr_t *vm_mngr, uint64_t addr)
uint64_t	vm_MEM_LOOKUP_64 (vm_mngr_t *vm_mngr, uint64_t addr)
int	vm_read_mem (vm_mngr_t *vm_mngr, uint64_t addr, char **buffer_ptr, uint64_t size)
int	vm_write_mem (vm_mngr_t *vm_mngr, uint64_t addr, char *buffer, uint64_t size)
unsigned int	parity (unsigned int a)
int	shift_right_arith (unsigned int size, int a, unsigned int b)
uint64_t	shift_right_logic (uint64_t size, uint64_t a, uint64_t b)
uint64_t	shift_left_logic (uint64_t size, uint64_t a, uint64_t b)
unsigned int	mul_lo_op (unsigned int size, unsigned int a, unsigned int b)
unsigned int	mul_hi_op (unsigned int size, unsigned int a, unsigned int b)
unsigned int	imul_lo_op_08 (char a, char b)
unsigned int	imul_lo_op_16 (short a, short b)
unsigned int	imul_lo_op_32 (int a, int b)
int	imul_hi_op_08 (char a, char b)
int	imul_hi_op_16 (short a, short b)
int	imul_hi_op_32 (int a, int b)
unsigned int	umul16_lo (unsigned short a, unsigned short b)
unsigned int	umul16_hi (unsigned short a, unsigned short b)
unsigned int	div_op (unsigned int size, unsigned int a, unsigned int b, unsigned int c)
unsigned int	rem_op (unsigned int size, unsigned int a, unsigned int b, unsigned int c)
uint64_t	rot_left (uint64_t size, uint64_t a, uint64_t b)
uint64_t	rot_right (uint64_t size, uint64_t a, uint64_t b)
int	rcl_rez_op (unsigned int size, unsigned int a, unsigned int b, unsigned int cf)
int	rcr_rez_op (unsigned int size, unsigned int a, unsigned int b, unsigned int cf)
int	rcl_cf_op (unsigned int size, unsigned int a, unsigned int b, unsigned int cf)
int	rcr_cf_op (unsigned int size, unsigned int a, unsigned int b, unsigned int cf)
unsigned int	x86_bsr (uint64_t src, unsigned int size)
unsigned int	x86_bsf (uint64_t src, unsigned int size)
unsigned int	my_imul08 (unsigned int a, unsigned int b)
unsigned int	cpuid (unsigned int a, unsigned int reg_num)
void	dump_float (void)
double	mem_32_to_double (unsigned int m)
double	mem_64_to_double (uint64_t m)
double	int_16_to_double (unsigned int m)
double	int_32_to_double (unsigned int m)
double	int_64_to_double (uint64_t m)
int32_t	double_to_int_32 (double d)
int64_t	double_to_int_64 (double d)
double	fadd (double a, double b)
double	fsub (double a, double b)
double	fmul (double a, double b)
double	fdiv (double a, double b)
double	ftan (double a)
double	frndint (double a)
double	fsin (double a)
double	fcos (double a)
double	fscale (double a, double b)
double	f2xm1 (double a)
double	fsqrt (double a)
double	fabs (double a)
unsigned int	fcom_c0 (double a, double b)
unsigned int	fcom_c1 (double a, double b)
unsigned int	fcom_c2 (double a, double b)
unsigned int	fcom_c3 (double a, double b)
unsigned int	double_to_mem_32 (double d)
uint64_t	double_to_mem_64 (double d)
struct memory_page_node *	create_memory_page_node (uint64_t ad, unsigned int size, unsigned int access)
struct code_bloc_node *	create_code_bloc_node (uint64_t ad_start, uint64_t ad_stop)
void	add_code_bloc (vm_mngr_t *vm_mngr, struct code_bloc_node *cbp)
void	dump_code_bloc_pool (vm_mngr_t *vm_mngr)
void	init_memory_page_pool (vm_mngr_t *vm_mngr)
void	init_code_bloc_pool (vm_mngr_t *vm_mngr)
void	init_memory_breakpoint (vm_mngr_t *vm_mngr)
void	reset_memory_page_pool (vm_mngr_t *vm_mngr)
void	reset_code_bloc_pool (vm_mngr_t *vm_mngr)
void	reset_memory_breakpoint (vm_mngr_t *vm_mngr)
int	is_mpn_in_tab (vm_mngr_t *vm_mngr, struct memory_page_node *mpn_a)
void	insert_mpn_in_tab (struct memory_page_node *mpn_a)
void	add_memory_page (vm_mngr_t *vm_mngr, struct memory_page_node *mpn_a)
char *	dump (vm_mngr_t *vm_mngr)
void	dump_memory_breakpoint_pool (vm_mngr_t *vm_mngr)
void	add_memory_breakpoint (vm_mngr_t *vm_mngr, uint64_t ad, uint64_t size, unsigned int access)
void	remove_memory_breakpoint (vm_mngr_t *vm_mngr, uint64_t ad, unsigned int access)
unsigned int	get_memory_page_next (vm_mngr_t *vm_mngr, unsigned int n_ad)
void	hexdump (char *m, unsigned int l)
unsigned int	access_segment (unsigned int d)
unsigned int	access_segment_ok (unsigned int d)
unsigned int	load_segment_limit (unsigned int d)
unsigned int	load_segment_limit_ok (unsigned int d)
unsigned int	load_tr_segment_selector (unsigned int d)
uint64_t	get_exception_flag (vm_mngr_t *vm_mngr)

Macro Definition Documentation

#define MAX	(		a,
			b
	)		(((a)>(b))?(a):(b))

Definition at line 48 of file vm_mngr.c.

#define MIN	(		a,
			b
	)		(((a)<(b))?(a):(b))

Definition at line 47 of file vm_mngr.c.

Function Documentation

unsigned int access_segment

(

unsigned int

d

)

Definition at line 1668 of file vm_mngr.c.

{
    // XXX TODO
    printf("access segment %X\n", d);
    return 0;
}

unsigned int access_segment_ok

(

unsigned int

d

)

Definition at line 1674 of file vm_mngr.c.

{
    // XXX TODO
    printf("access segment ok %X\n", d);
    return 0;
}

void add_code_bloc	(	vm_mngr_t *	vm_mngr,
		struct code_bloc_node *	cbp
	)

Definition at line 1337 of file vm_mngr.c.

{
    LIST_INSERT_HEAD(&vm_mngr->code_bloc_pool, cbp, next);
    if (vm_mngr->code_bloc_pool_ad_min> cbp->ad_start)
        vm_mngr->code_bloc_pool_ad_min = cbp->ad_start;
    if (vm_mngr->code_bloc_pool_ad_max< cbp->ad_stop)
        vm_mngr->code_bloc_pool_ad_max = cbp->ad_stop;
}

Here is the caller graph for this function:

void add_memory_breakpoint	(	vm_mngr_t *	vm_mngr,
		uint64_t	ad,
		uint64_t	size,
		unsigned int	access
	)

Definition at line 1543 of file vm_mngr.c.

{
    struct memory_breakpoint_info * mpn_a;
    mpn_a = malloc(sizeof(*mpn_a));
    if (!mpn_a) {
        printf("cannot alloc\n");
        exit(0);
    }
    mpn_a->ad = ad;
    mpn_a->size = size;
    mpn_a->access = access;

    LIST_INSERT_HEAD(&vm_mngr->memory_breakpoint_pool, mpn_a, next);

}

Here is the caller graph for this function:

void add_memory_page	(	vm_mngr_t *	vm_mngr,
		struct memory_page_node *	mpn_a
	)

Definition at line 1467 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    struct memory_page_node * lmpn;

    if (LIST_EMPTY(&vm_mngr->memory_page_pool)){
        LIST_INSERT_HEAD(&vm_mngr->memory_page_pool, mpn_a, next);
        insert_mpn_in_tab(mpn_a);
        return;
    }
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        lmpn = mpn;
        if (mpn->ad < mpn_a->ad)
            continue;
        LIST_INSERT_BEFORE(mpn, mpn_a, next);
        insert_mpn_in_tab(mpn_a);
        return;
    }
    LIST_INSERT_AFTER(lmpn, mpn_a, next);
    insert_mpn_in_tab(mpn_a);

}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* addr2BlocObj	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr
	)

Definition at line 415 of file vm_mngr.c.

{
    PyObject* pyaddr;
    PyObject* b;

    //printf("addr2blocobj %"PRIx64"\n", addr);
    pyaddr = PyLong_FromUnsignedLongLong(addr);
    /*
    Py_INCREF(pyaddr);
    return pyaddr;
    */
    b = PyDict_GetItem(vm_mngr->addr2obj, pyaddr);
    if (b == NULL) {
        Py_INCREF(Py_None);
        return Py_None;
    }

    //printf("addr2blocobj OBJ %p\n", b);
    Py_INCREF(b);
    return b;
}

Here is the call graph for this function:

uint16_t bcdadd_16	(	uint16_t	a,
		uint16_t	b
	)

Definition at line 335 of file vm_mngr.c.

{
    int carry = 0;
    int i,j = 0;
    uint16_t res = 0;
    int nib_a, nib_b;
    for (i = 0; i < 16; i += 4) {
        nib_a = (a  >> i) & (0xF);
        nib_b = (b >> i) & (0xF);

        j = (carry + nib_a + nib_b);
        if (j >= 10) {
            carry = 1;
            j -= 10;
            j &=0xf;
        }
        else {
            carry = 0;
        }
        res += j << i;
    }
    return res;
}

Here is the call graph for this function:

uint16_t bcdadd_cf_16	(	uint16_t	a,
		uint16_t	b
	)

Definition at line 359 of file vm_mngr.c.

{
    int carry = 0;
    int i,j = 0;
    int nib_a, nib_b;
    for (i = 0; i < 16; i += 4) {
        nib_a = (a >> i) & (0xF);
        nib_b = (b >> i) & (0xF);

        j = (carry + nib_a + nib_b);
        if (j >= 10) {
            carry = 1;
            j -= 10;
            j &=0xf;
        }
        else {
            carry = 0;
        }
    }
    return carry;
}

Here is the call graph for this function:

void check_write_code_bloc	(	vm_mngr_t *	vm_mngr,
		uint64_t	my_size,
		uint64_t	addr
	)

Definition at line 391 of file vm_mngr.c.

{
    struct code_bloc_node * cbp;

    if (!(addr + my_size/8 <= vm_mngr->code_bloc_pool_ad_min ||
          addr >=vm_mngr->code_bloc_pool_ad_max)){
        LIST_FOREACH(cbp, &vm_mngr->code_bloc_pool, next){
            if ((cbp->ad_start < addr + my_size/8) &&
                (addr < cbp->ad_stop)){
#ifdef DEBUG_MIASM_AUTOMOD_CODE
                fprintf(stderr, "**********************************\n");
                fprintf(stderr, "self modifying code %"PRIX64" %.8X\n",
                       addr, my_size);
                fprintf(stderr, "**********************************\n");
                //dump_code_bloc(vm_mngr);
#endif
                vm_mngr->exception_flags |= EXCEPT_CODE_AUTOMOD;

                break;
            }
        }
    }
}

Here is the caller graph for this function:

unsigned int cpuid	(	unsigned int	a,
		unsigned int	reg_num
	)

Definition at line 965 of file vm_mngr.c.

{
    if (reg_num >3){
        fprintf(stderr, "not implemented cpuid reg %x\n", reg_num);
        exit(-1);
    }

    if (a == 0){
        switch(reg_num){
        case 0:
            return 0xa;
        case 1:
            return 0x756E6547;
        case 2:
            return 0x6C65746E;
        case 3:
            return 0x49656E69;
        }
    }

    else if (a == 1){
        switch(reg_num){
        case 0:
            //return 0x000006FB;
            return 0x00020652;
        case 1:
            //return 0x02040800;
            return 0x00000800;
        case 2:
            //return 0x0004E3BD;
            return 0x00000209;
        case 3:
            //return 0xBFEBFBFF;
            return 0x078bf9ff;
        }
    }
    else{
        fprintf(stderr, "WARNING not implemented cpuid index %X!\n", a);
        //exit(-1);
    }
    return 0;
}

struct code_bloc_node* create_code_bloc_node	(	uint64_t	ad_start,
		uint64_t	ad_stop
	)

Definition at line 1320 of file vm_mngr.c.

{
    struct code_bloc_node * cbp;

    cbp = malloc(sizeof(*cbp));
    if (!cbp){
        fprintf(stderr, "cannot alloc cbp\n");
        exit(-1);
    }

    cbp->ad_start = ad_start;
    cbp->ad_stop = ad_stop;

    return cbp;
}

Here is the caller graph for this function:

struct memory_page_node* create_memory_page_node	(	uint64_t	ad,
		unsigned int	size,
		unsigned int	access
	)

Definition at line 1295 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    void* p;

    mpn = malloc(sizeof(*mpn));
    if (!mpn){
        fprintf(stderr, "cannot alloc mpn\n");
        return NULL;
    }
    p = malloc(size);
    if (!p){
        free(mpn);
        fprintf(stderr, "cannot alloc %d\n", size);
        return NULL;
    }
    mpn->ad = ad;
    mpn->size = size;
    mpn->access = access;
    mpn->ad_hp = p;

    return mpn;
}

Here is the caller graph for this function:

unsigned int div_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	c
	)

Definition at line 769 of file vm_mngr.c.

{
    int64_t num;
    if (c == 0)
    {
        //vmmngr.exception_flags |= EXCEPT_INT_DIV_BY_ZERO;
        return 0;
    }
    num = ((int64_t)a << size) + b;
    num/=(int64_t)c;
    return num;
}

Here is the call graph for this function:

int32_t double_to_int_32

(

double

d

)

Definition at line 1086 of file vm_mngr.c.

{
    int32_t i;

    i = (int32_t)d;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e int %d\n", d, i);
#endif
    return i;
}

Here is the call graph for this function:

int64_t double_to_int_64

(

double

d

)

Definition at line 1098 of file vm_mngr.c.

{
    int64_t i;

    i = (int64_t)d;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e int %"PRId64"\n", d, i);
#endif
    return i;
}

Here is the call graph for this function:

unsigned int double_to_mem_32

(

double

d

)

Definition at line 1271 of file vm_mngr.c.

{
    unsigned int m;
    float f;
    f = d;
    m = *((unsigned int*)&f);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%d %e\n", m, d);
#endif
    return m;
}

Here is the call graph for this function:

uint64_t double_to_mem_64

(

double

d

)

Definition at line 1284 of file vm_mngr.c.

{
    uint64_t m;
    m = *((uint64_t*)&d);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%"PRId64" %e\n", m, d);
#endif
    return m;
}

Here is the call graph for this function:

char* dump

(

vm_mngr_t *

vm_mngr

)

Definition at line 1493 of file vm_mngr.c.

{
    char buf[100];
    int length;
    int total_len = 0;
    char *buf_final;
    struct memory_page_node * mpn;

    buf_final = malloc(1);
    if (buf_final == NULL) {
        printf("cannot alloc\n");
        exit(0);
    }
    buf_final[0] = '\x00';
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){

        length = snprintf(buf, sizeof(buf),
                  "ad 0x%"PRIX64" size 0x%"PRIX64" %c%c%c\n",
                  (uint64_t)mpn->ad,
                  (uint64_t)mpn->size,
                  mpn->access & PAGE_READ? 'R':'_',
                  mpn->access & PAGE_WRITE? 'W':'_',
                  mpn->access & PAGE_EXEC? 'X':'_'
                  );
        total_len += length+1;
        buf_final = realloc(buf_final, total_len);
        if (buf_final == NULL) {
            printf("cannot alloc\n");
            exit(0);
        }
        strcat(buf_final, buf);
    }

    return buf_final;
}

Here is the caller graph for this function:

void dump_code_bloc

(

vm_mngr_t *

vm_mngr

)

Definition at line 382 of file vm_mngr.c.

{
    struct code_bloc_node * cbp;
    LIST_FOREACH(cbp, &vm_mngr->code_bloc_pool, next){
        fprintf(stderr, "%"PRIX64"%"PRIX64"\n", cbp->ad_start,  cbp->ad_stop);
    }

}

void dump_code_bloc_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1346 of file vm_mngr.c.

{
    struct code_bloc_node * cbp;

    LIST_FOREACH(cbp, &vm_mngr->code_bloc_pool, next){
        printf("ad start %"PRIX64" ad_stop %"PRIX64"\n",
               cbp->ad_start,
               cbp->ad_stop);
    }
}

Here is the caller graph for this function:

void dump_float

(

void

)

Definition at line 1010 of file vm_mngr.c.

{
    /*
    printf("%e\n", vmmngr.float_st0);
    printf("%e\n", vmmngr.float_st1);
    printf("%e\n", vmmngr.float_st2);
    printf("%e\n", vmmngr.float_st3);
    printf("%e\n", vmmngr.float_st4);
    printf("%e\n", vmmngr.float_st5);
    printf("%e\n", vmmngr.float_st6);
    printf("%e\n", vmmngr.float_st7);
    */
}

Here is the caller graph for this function:

void dump_memory_breakpoint_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1529 of file vm_mngr.c.

{
    struct memory_breakpoint_info * mpn;

    LIST_FOREACH(mpn, &vm_mngr->memory_breakpoint_pool, next){
        printf("ad %"PRIX64" size %"PRIX64" access %"PRIX64"\n",
               mpn->ad,
               mpn->size,
               mpn->access
               );
    }
}

Here is the caller graph for this function:

double f2xm1

(

double

a

)

Definition at line 1213 of file vm_mngr.c.

{
    double b;
    b = exp2(a)-1;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e exp2 -1 %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

double fabs

(

double

a

)

Definition at line 1235 of file vm_mngr.c.

{
    double b;
    b = abs(a);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e abs %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

double fadd	(	double	a,
		double	b
	)

Definition at line 1111 of file vm_mngr.c.

{
    double c;
    c = a + b;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e + %e -> %e\n", a, b, c);
#endif
    return c;
}

Here is the call graph for this function:

unsigned int fcom_c0	(	double	a,
		double	b
	)

Definition at line 1248 of file vm_mngr.c.

{
    if (a>=b)
        return 0;
    return 1;
}

unsigned int fcom_c1	(	double	a,
		double	b
	)

Definition at line 1254 of file vm_mngr.c.

{
    //XXX
    return 0;
}

unsigned int fcom_c2	(	double	a,
		double	b
	)

Definition at line 1259 of file vm_mngr.c.

{
    return 0;
}

unsigned int fcom_c3	(	double	a,
		double	b
	)

Definition at line 1263 of file vm_mngr.c.

{
    if (a==b)
        return 1;
    return 0;
}

double fcos

(

double

a

)

Definition at line 1190 of file vm_mngr.c.

{
    double b;
    b = cos(a);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e cos %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

double fdiv	(	double	a,
		double	b
	)

Definition at line 1144 of file vm_mngr.c.

{
    double c;
    c = a / b;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e / %e -> %e\n", a, b, c);
#endif
    return c;
}

Here is the call graph for this function:

double fmul	(	double	a,
		double	b
	)

Definition at line 1133 of file vm_mngr.c.

{
    double c;
    c = a * b;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e * %e -> %e\n", a, b, c);
#endif
    return c;
}

Here is the call graph for this function:

double frndint

(

double

a

)

Definition at line 1166 of file vm_mngr.c.

{
    int64_t b;
    double c;
    b = (int64_t)a;
    c = (double)b;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e double %e\n", a, c);
#endif
    return c;
}

Here is the call graph for this function:

double fscale	(	double	a,
		double	b
	)

Definition at line 1202 of file vm_mngr.c.

{
    double c;
    c = a * exp2(trunc(b));
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e *exp2 %e -> %e\n", a, b, c);
#endif
    return c;
}

Here is the call graph for this function:

double fsin

(

double

a

)

Definition at line 1179 of file vm_mngr.c.

{
    double b;
    b = sin(a);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e sin %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

double fsqrt

(

double

a

)

Definition at line 1224 of file vm_mngr.c.

{
    double b;
    b = sqrt(a);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e sqrt %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

double fsub	(	double	a,
		double	b
	)

Definition at line 1122 of file vm_mngr.c.

{
    double c;
    c = a - b;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e - %e -> %e\n", a, b, c);
#endif
    return c;
}

Here is the call graph for this function:

double ftan

(

double

a

)

Definition at line 1155 of file vm_mngr.c.

{
    double b;
    b = tan(a);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%e tan %e\n", a, b);
#endif
    return b;
}

Here is the call graph for this function:

uint64_t get_exception_flag

(

vm_mngr_t *

vm_mngr

)

Definition at line 1701 of file vm_mngr.c.

{
    return vm_mngr->exception_flags;
}

uint64_t get_mem_base_addr	(	vm_mngr_t *	vm_mngr,
		uint64_t	ad,
		uint64_t *	addr_base
	)

Definition at line 107 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    /*
    mpn = memory_page_pool_tab[ad>>MEMORY_PAGE_POOL_MASK_BIT];
    if ( mpn && (mpn->ad <= ad) && (ad < mpn->ad + mpn->size)){
        *addr_base = mpn->ad;
        return 1;
    }
    */
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        if ((mpn->ad <= ad)  && (ad <mpn->ad + mpn->size)) {
            *addr_base = mpn->ad;
            return 1;
        }
    }
    return 0;
}

Here is the caller graph for this function:

struct memory_page_node* get_memory_page_from_address	(	vm_mngr_t *	vm_mngr,
		uint64_t	ad
	)

Definition at line 126 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
#if 0
    mpn = memory_page_pool_tab[ad>>MEMORY_PAGE_POOL_MASK_BIT];
    if ( mpn && (mpn->ad <= ad) && (ad < mpn->ad + mpn->size))
        return mpn;

    fprintf(stderr, "WARNING: address 0x%"PRIX64" is not mapped in virtual memory:\n", ad);
    //dump_gpregs();
    //exit(-1);
    vm_mngr->exception_flags |= EXCEPT_ACCESS_VIOL;

    return NULL;
#else

    //printf("search for page ad: %X\n", ad);
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        if ((mpn->ad <= ad) && (ad < mpn->ad + mpn->size))
            return mpn;
    }
    fprintf(stderr, "WARNING: address 0x%"PRIX64" is not mapped in virtual memory:\n", ad);
    //dump_gpregs();
    //exit(-1);
    vm_mngr->exception_flags |= EXCEPT_ACCESS_VIOL;
    return NULL;
#endif
}

Here is the caller graph for this function:

unsigned int get_memory_page_next	(	vm_mngr_t *	vm_mngr,
		unsigned int	n_ad
	)

Definition at line 1576 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    uint64_t ad = 0;

    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        if (mpn->ad < n_ad)
            continue;

        if (ad == 0 || mpn->ad <ad)
            ad = mpn->ad;
    }
    return ad;
}

void hexdump	(	char *	m,
		unsigned int	l
	)

Definition at line 1626 of file vm_mngr.c.

{
  int i, j, last;
  last = 0;
  for (i=0;i<l;i++){
      if (!(i%0x10) && i){
      last = i;
      printf("    ");
      for (j=-0x10;j<0;j++){
          if (isprint(m[i+j])){
              printf("%c", m[i+j]);
          }
          else{
              printf(".");
          }
      }
      printf("\n");
      }
      printf("%.2X ", m[i]&0xFF);
  }
  l-=last;
  if (l){
    for (j=i;j<last+0x10;j++)
      printf("   ");
    printf("    ");
    for (j = 0;l;j++){
      if (isprint(m[last+j])){
          printf("%c", m[last+j]);
      }
      else{
          printf(".");
      }
      l--;
    }
  }
  printf("\n");

}

Here is the call graph for this function:

int imul_hi_op_08	(	char	a,
		char	b
	)

Definition at line 732 of file vm_mngr.c.

{
    int64_t res = 0;
    res = a*b;
    return res>>8;
}

Here is the call graph for this function:

int imul_hi_op_16	(	short	a,
		short	b
	)

Definition at line 739 of file vm_mngr.c.

{
    int64_t res = 0;
    res = a*b;
    return res>>16;
}

Here is the call graph for this function:

int imul_hi_op_32	(	int	a,
		int	b
	)

Definition at line 746 of file vm_mngr.c.

{
    int64_t res = 0;
    res = (int64_t)a*(int64_t)b;
    //printf("%x %x dd %"PRIx64"\n", a, b, res);
    return res>>32ULL;
}

Here is the call graph for this function:

unsigned int imul_lo_op_08	(	char	a,
		char	b
	)

Definition at line 717 of file vm_mngr.c.

{
    return a*b;
}

Here is the call graph for this function:

unsigned int imul_lo_op_16	(	short	a,
		short	b
	)

Definition at line 722 of file vm_mngr.c.

{
    return a*b;
}

Here is the call graph for this function:

unsigned int imul_lo_op_32	(	int	a,
		int	b
	)

Definition at line 727 of file vm_mngr.c.

{
    return a*b;
}

Here is the call graph for this function:

void init_code_bloc_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1366 of file vm_mngr.c.

{
    LIST_INIT(&vm_mngr->code_bloc_pool);
    vm_mngr->code_bloc_pool_ad_min = 0xffffffff;
    vm_mngr->code_bloc_pool_ad_max = 0;
}

Here is the caller graph for this function:

void init_memory_breakpoint

(

vm_mngr_t *

vm_mngr

)

Definition at line 1373 of file vm_mngr.c.

{
    LIST_INIT(&vm_mngr->memory_breakpoint_pool);
}

Here is the caller graph for this function:

void init_memory_page_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1358 of file vm_mngr.c.

{
    unsigned int i;
    LIST_INIT(&vm_mngr->memory_page_pool);
    for (i=0;i<MAX_MEMORY_PAGE_POOL_TAB; i++)
        vm_mngr->memory_page_pool_tab[i] = NULL;
}

Here is the caller graph for this function:

void insert_mpn_in_tab

(

struct memory_page_node *

mpn_a

)

Definition at line 1451 of file vm_mngr.c.

{
    /*
    for (i=mpn_a->ad >> MEMORY_PAGE_POOL_MASK_BIT;
         i<(mpn_a->ad + mpn_a->size + PAGE_SIZE - 1)>>MEMORY_PAGE_POOL_MASK_BIT;
         i++){
        if (memory_page_pool_tab[i] !=NULL){
            fprintf(stderr, "known page in tab\n");
            exit(1);
        }
        memory_page_pool_tab[i] = mpn_a;
    }
    */

}

Here is the caller graph for this function:

double int_16_to_double

(

unsigned int

m

)

Definition at line 1050 of file vm_mngr.c.

{
    double d;

    d = (double)(m&0xffff);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%d double %e\n", m, d);
#endif
    return d;
}

Here is the call graph for this function:

double int_32_to_double

(

unsigned int

m

)

Definition at line 1062 of file vm_mngr.c.

{
    double d;

    d = (double)m;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%d double %e\n", m, d);
#endif
    return d;
}

Here is the call graph for this function:

double int_64_to_double

(

uint64_t

m

)

Definition at line 1074 of file vm_mngr.c.

{
    double d;

    d = (double)m;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%"PRId64" double %e\n", m, d);
#endif
    return d;
}

Here is the call graph for this function:

int is_mem_mapped	(	vm_mngr_t *	vm_mngr,
		uint64_t	ad
	)

Definition at line 87 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    /*
    mpn = memory_page_pool_tab[ad>>MEMORY_PAGE_POOL_MASK_BIT];
    if ( mpn && (mpn->ad <= ad) && (ad < mpn->ad + mpn->size))
        return 1;
    */
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        if ((mpn->ad <= ad)  && (ad <mpn->ad + mpn->size))
            return 1;
    }

    return 0;
}

Here is the caller graph for this function:

int is_mpn_in_tab	(	vm_mngr_t *	vm_mngr,
		struct memory_page_node *	mpn_a
	)

Definition at line 1424 of file vm_mngr.c.

{
    struct memory_page_node * mpn;

    /*
    for (i=mpn_a->ad >> MEMORY_PAGE_POOL_MASK_BIT;
         i<(mpn_a->ad + mpn_a->size + PAGE_SIZE - 1)>>MEMORY_PAGE_POOL_MASK_BIT;
         i++){
        if (memory_page_pool_tab[i] !=NULL){
            return 1;
        }
    }
    */
    LIST_FOREACH(mpn, &vm_mngr->memory_page_pool, next){
        if (mpn->ad >= mpn_a->ad + mpn_a->size)
            continue;
        if (mpn->ad + mpn->size  <= mpn_a->ad)
            continue;
        printf("is mpn in! %"PRIX64" %"PRIX64" \n", mpn_a->ad, mpn_a->size);
        printf("known:! %"PRIX64" %"PRIX64" \n", mpn->ad, mpn->size);

        return 1;
    }

    return 0;
}

Here is the caller graph for this function:

unsigned int load_segment_limit

(

unsigned int

d

)

Definition at line 1681 of file vm_mngr.c.

{
    // XXX TODO
    printf("load segment limit %X\n", d);
    return 0;
}

unsigned int load_segment_limit_ok

(

unsigned int

d

)

Definition at line 1687 of file vm_mngr.c.

{
    // XXX TODO
    printf("load segment limit ok %X\n", d);
    return 0;
}

unsigned int load_tr_segment_selector

(

unsigned int

d

)

Definition at line 1694 of file vm_mngr.c.

{
    // XXX TODO
    return 0;
}

double mem_32_to_double

(

unsigned int

m

)

Definition at line 1024 of file vm_mngr.c.

{
    float f;
    double d;

    f = *((float*)&m);
    d = f;
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%d float %e\n", m, d);
#endif
    return d;
}

Here is the call graph for this function:

double mem_64_to_double

(

uint64_t

m

)

Definition at line 1039 of file vm_mngr.c.

{
    double d;
    d = *((double*)&m);
#ifdef DEBUG_MIASM_DOUBLE
    dump_float();
    printf("%"PRId64" double %e\n", m, d);
#endif
    return d;
}

Here is the call graph for this function:

static uint64_t memory_page_read ( vm_mngr_t *  vm_mngr, unsigned int  my_size, uint64_t  ad  )

static

Definition at line 158 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    unsigned char * addr;
    uint64_t ret = 0;
    struct memory_breakpoint_info * b;


    mpn = get_memory_page_from_address(vm_mngr, ad);
    if (!mpn)
        return 0;

    if ((mpn->access & PAGE_READ) == 0){
        fprintf(stderr, "access to non readable page!! %"PRIX64"\n", ad);
        vm_mngr->exception_flags |= EXCEPT_ACCESS_VIOL;
        return 0;
    }

    /* check read breakpoint*/
    LIST_FOREACH(b, &vm_mngr->memory_breakpoint_pool, next){
        if ((b->access & BREAKPOINT_READ) == 0)
            continue;
        if ((b->ad <= ad) && (ad < b->ad + b->size))
            vm_mngr->exception_flags |= EXCEPT_BREAKPOINT_INTERN;
    }


    addr = &((unsigned char*)mpn->ad_hp)[ad - mpn->ad];

    /* read fits in a page */
    if (ad - mpn->ad + my_size/8 <= mpn->size){
        switch(my_size){
        case 8:
            ret = *((unsigned char*)addr)&0xFF;
            break;
        case 16:
            ret = *((unsigned short*)addr)&0xFFFF;
            ret = set_endian16(vm_mngr, ret);
            break;
        case 32:
            ret = *((unsigned int*)addr)&0xFFFFFFFF;
            ret = set_endian32(vm_mngr, ret);
            break;
        case 64:
            ret = *((uint64_t*)addr)&0xFFFFFFFFFFFFFFFFULL;
            ret = set_endian64(vm_mngr, ret);
            break;
        default:
            exit(0);
            break;
        }
    }
    /* read is multiple page wide */
    else{
        unsigned int new_size = my_size;
        int index = 0;
        //fprintf(stderr, "read multiple page! %"PRIX64" %d\n", ad, new_size);
        while (new_size){
            mpn = get_memory_page_from_address(vm_mngr, ad);
            if (!mpn)
                return 0;
            addr = &((unsigned char*)mpn->ad_hp)[ad - mpn->ad];
            ret |= (*((unsigned char*)addr)&0xFF)<<(index);
            index +=8;
            new_size -= 8;
            ad ++;
        }
        switch(my_size){
        case 8:
            ret = ret;
            break;
        case 16:
            ret = set_endian16(vm_mngr, ret);
            break;
        case 32:
            ret = set_endian32(vm_mngr, ret);
            break;
        case 64:
            ret = set_endian64(vm_mngr, ret);
            break;
        default:
            exit(0);
            break;
        }
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void memory_page_write ( vm_mngr_t *  vm_mngr, unsigned int  my_size, uint64_t  ad, uint64_t  src  )

static

Definition at line 246 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    unsigned char * addr;
    struct memory_breakpoint_info * b;

    mpn = get_memory_page_from_address(vm_mngr, ad);
    if (!mpn)
        return;

    if ((mpn->access & PAGE_WRITE) == 0){
        fprintf(stderr, "access to non writable page!! %"PRIX64"\n", ad);
        vm_mngr->exception_flags |= EXCEPT_ACCESS_VIOL;
        return ;
    }

    /* check read breakpoint*/
    LIST_FOREACH(b, &vm_mngr->memory_breakpoint_pool, next){
        if ((b->access & BREAKPOINT_WRITE) == 0)
            continue;
        if ((b->ad <= ad) && (ad < b->ad + b->size))
            vm_mngr->exception_flags |= EXCEPT_BREAKPOINT_INTERN;
    }

    addr = &((unsigned char*)mpn->ad_hp)[ad - mpn->ad];

    /* write fits in a page */
    if (ad - mpn->ad + my_size/8 <= mpn->size){
        switch(my_size){
        case 8:
            *((unsigned char*)addr) = src&0xFF;
            break;
        case 16:
            src = set_endian16(vm_mngr, src);
            *((unsigned short*)addr) = src&0xFFFF;
            break;
        case 32:
            src = set_endian32(vm_mngr, src);
            *((unsigned int*)addr) = src&0xFFFFFFFF;
            break;
        case 64:
            src = set_endian64(vm_mngr, src);
            *((uint64_t*)addr) = src&0xFFFFFFFFFFFFFFFFULL;
            break;
        default:
            exit(0);
            break;
        }
    }
    /* write is multiple page wide */
    else{
        //fprintf(stderr, "write multiple page! %"PRIX64" %d\n", ad, my_size);
        switch(my_size){

        case 8:
            src = src;
            break;
        case 16:
            src = set_endian16(vm_mngr, src);
            break;
        case 32:
            src = set_endian32(vm_mngr, src);
            break;
        case 64:
            src = set_endian64(vm_mngr, src);
            break;
        default:
            exit(0);
            break;
        }
        while (my_size){
            mpn = get_memory_page_from_address(vm_mngr, ad);
            if (!mpn)
                return;

            addr = &((unsigned char*)mpn->ad_hp)[ad - mpn->ad];
            *((unsigned char*)addr) = src&0xFF;
            my_size -= 8;
            src >>=8;
            ad ++;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int mul_hi_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b
	)

Definition at line 698 of file vm_mngr.c.

{
    uint64_t res = 0;
    unsigned int mask;

    switch (size) {
        case 8: mask = 0xff; break;
        case 16: mask = 0xffff; break;
        case 32: mask = 0xffffffff; break;
        default: fprintf(stderr, "inv size in mul %d\n", size); exit(0);
    }

    a &= mask;
    b &= mask;
    res = ((uint64_t)a * (uint64_t)b);
    return (res >> 32) & mask;
}

Here is the call graph for this function:

unsigned int mul_lo_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b
	)

Definition at line 682 of file vm_mngr.c.

{
    unsigned int mask;

    switch (size) {
        case 8: mask = 0xff; break;
        case 16: mask = 0xffff; break;
        case 32: mask = 0xffffffff; break;
        default: fprintf(stderr, "inv size in mul %d\n", size); exit(0);
    }

    a &= mask;
    b &= mask;
    return ((int64_t)a * (int64_t) b) & mask;
}

unsigned int my_imul08	(	unsigned int	a,
		unsigned int	b
	)

Definition at line 952 of file vm_mngr.c.

{
    char a08, b08;
    short a16;

    a08 = a&0xFF;
    b08 = b&0xFF;
    a16 = a08*b08;
    return (int)a16;
}

unsigned int parity

(

unsigned int

a

)

Definition at line 545 of file vm_mngr.c.

{
#if defined(__builtin_parity)
    return __builtin_parity(a);
#else
    unsigned int tmp, cpt;

    tmp = a&0xFF;
    cpt = 1;
    while (tmp!=0){
        cpt^=tmp&1;
        tmp>>=1;
    }
    return cpt;
#endif
}

void print_val	(	uint64_t	base,
		uint64_t	addr
	)

Definition at line 80 of file vm_mngr.c.

{
    uint64_t *ptr =  (uint64_t *) addr;
    fprintf(stderr, "addr 0x%"PRIX64" val 0x%"PRIX64"\n", addr-base, *ptr);
}

int rcl_cf_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	cf
	)

Definition at line 897 of file vm_mngr.c.

{
    uint64_t tmp;

    tmp = (cf<< size) | a;

    size++;
    b %= size;

    switch(size){
        case 8+1:
            tmp = (tmp << b) | ((tmp&0x1FF) >> (size-b));
            return (tmp>>8)&1;
        case 16+1:
            tmp = (tmp << b) | ((tmp&0x1FFFF) >> (size-b));
            return (tmp>>16)&1;
        case 32+1:
            tmp = (tmp << b) | ((tmp&0x1FFFFFFFFULL) >> (size-b));
            return (tmp>>32)&1;
        default:
            fprintf(stderr, "inv size in rclleft %d\n", size);
            exit(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rcl_rez_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	cf
	)

Definition at line 850 of file vm_mngr.c.

{
    uint64_t tmp;


    size++;
    b %= size;

    if (b == 0) {
        switch(size){
            case 8+1:
                return a&0xff;
            case 16+1:
                return a&0xffff;
            case 32+1:
                return a&0xffffffff;
            default:
                fprintf(stderr, "inv size in rclleft %d\n", size);
                exit(0);
        }
    }

    tmp = (a<<1) | cf;
    b -=1;
    switch(size){
        case 8+1:
            tmp = (tmp << b) | ((tmp&0x1FF) >> (size-b));
            return tmp&0xff;
        case 16+1:
            tmp = (tmp << b) | ((tmp&0x1FFFF) >> (size-b));
            return tmp&0xffff;
        case 32+1:
            tmp = (tmp << b) | ((tmp&0x1FFFFFFFFULL) >> (size-b));
            return tmp&0xffffffff;
        default:
            fprintf(stderr, "inv size in rclleft %d\n", size);
            exit(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int rcr_cf_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	cf
	)

Definition at line 922 of file vm_mngr.c.

{
    return rcl_cf_op(size, a, size+1-b, cf);
}

Here is the call graph for this function:

int rcr_rez_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	cf
	)

Definition at line 890 of file vm_mngr.c.

{
    return rcl_rez_op(size, a, size+1-b, cf);

}

Here is the call graph for this function:

unsigned int rem_op	(	unsigned int	size,
		unsigned int	a,
		unsigned int	b,
		unsigned int	c
	)

Definition at line 783 of file vm_mngr.c.

{
    int64_t num;

    if (c == 0)
    {
        //vmmngr.exception_flags |= EXCEPT_INT_DIV_BY_ZERO;
        return 0;
    }

    num = ((int64_t)a << size) + b;
    num = (int64_t)num-c*(num/c);
    return num;
}

Here is the call graph for this function:

void remove_memory_breakpoint	(	vm_mngr_t *	vm_mngr,
		uint64_t	ad,
		unsigned int	access
	)

Definition at line 1559 of file vm_mngr.c.

{
    struct memory_breakpoint_info * mpn;

    LIST_FOREACH(mpn, &vm_mngr->memory_breakpoint_pool, next){
        if (mpn->ad == ad && mpn->access == access)
            LIST_REMOVE(mpn, next);
    }

}

Here is the caller graph for this function:

void reset_code_bloc_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1396 of file vm_mngr.c.

{
    struct code_bloc_node * cbp;


    while (!LIST_EMPTY(&vm_mngr->code_bloc_pool)) {
        cbp = LIST_FIRST(&vm_mngr->code_bloc_pool);
        LIST_REMOVE(cbp, next);
        free(cbp);
    }
    vm_mngr->code_bloc_pool_ad_min = 0xffffffff;
    vm_mngr->code_bloc_pool_ad_max = 0;
}

Here is the caller graph for this function:

void reset_memory_breakpoint

(

vm_mngr_t *

vm_mngr

)

Definition at line 1411 of file vm_mngr.c.

{
    struct memory_breakpoint_info * mpn;

    while (!LIST_EMPTY(&vm_mngr->memory_breakpoint_pool)) {
        mpn = LIST_FIRST(&vm_mngr->memory_breakpoint_pool);
        LIST_REMOVE(mpn, next);
        free(mpn);
    }

}

Here is the caller graph for this function:

void reset_memory_page_pool

(

vm_mngr_t *

vm_mngr

)

Definition at line 1379 of file vm_mngr.c.

{
    struct memory_page_node * mpn;
    unsigned int i;

    while (!LIST_EMPTY(&vm_mngr->memory_page_pool)) {
        mpn = LIST_FIRST(&vm_mngr->memory_page_pool);
        LIST_REMOVE(mpn, next);
        free(mpn->ad_hp);
        free(mpn);
    }
    for (i=0;i<MAX_MEMORY_PAGE_POOL_TAB; i++)
        vm_mngr->memory_page_pool_tab[i] = NULL;

}

Here is the caller graph for this function:

uint64_t rot_left	(	uint64_t	size,
		uint64_t	a,
		uint64_t	b
	)

Definition at line 799 of file vm_mngr.c.

{
    uint64_t tmp;

    b = b&0x3F;
    b %= size;
    switch(size){
        case 8:
            tmp = (a << b) | ((a&0xFF) >> (size-b));
            return tmp&0xff;
        case 16:
            tmp = (a << b) | ((a&0xFFFF) >> (size-b));
            return tmp&0xffff;
        case 32:
            tmp = (a << b) | ((a&0xFFFFFFFF) >> (size-b));
            return tmp&0xffffffff;
        case 64:
            tmp = (a << b) | ((a&0xFFFFFFFFFFFFFFFF) >> (size-b));
            return tmp&0xFFFFFFFFFFFFFFFF;
        default:
            fprintf(stderr, "inv size in rotleft %"PRIX64"\n", size);
            exit(0);
    }
}

Here is the call graph for this function:

uint64_t rot_right	(	uint64_t	size,
		uint64_t	a,
		uint64_t	b
	)

Definition at line 824 of file vm_mngr.c.

{
    uint64_t tmp;

    b = b&0x3F;
    b %= size;
    switch(size){
        case 8:
            tmp = ((a&0xFF) >> b) | (a << (size-b));
            return tmp&0xff;
        case 16:
            tmp = ((a&0xFFFF) >> b) | (a << (size-b));
            return tmp&0xffff;
        case 32:
            tmp = ((a&0xFFFFFFFF) >> b) | (a << (size-b));
            return tmp&0xffffffff;
        case 64:
            tmp = ((a&0xFFFFFFFFFFFFFFFF) >> b) | (a << (size-b));
            return tmp&0xFFFFFFFFFFFFFFFF;
        default:
            fprintf(stderr, "inv size in rotright %"PRIX64"\n", size);
            exit(0);
    }
}

Here is the call graph for this function:

uint16_t set_endian16	(	vm_mngr_t *	vm_mngr,
		uint16_t	val
	)

Definition at line 55 of file vm_mngr.c.

{
    if (vm_mngr->sex == __BYTE_ORDER)
        return val;
    else
        return Endian16_Swap(val);
}

Here is the caller graph for this function:

uint32_t set_endian32	(	vm_mngr_t *	vm_mngr,
		uint32_t	val
	)

Definition at line 63 of file vm_mngr.c.

{
    if (vm_mngr->sex == __BYTE_ORDER)
        return val;
    else
        return Endian32_Swap(val);
}

Here is the caller graph for this function:

uint64_t set_endian64	(	vm_mngr_t *	vm_mngr,
		uint64_t	val
	)

Definition at line 71 of file vm_mngr.c.

{
    if (vm_mngr->sex == __BYTE_ORDER)
        return val;
    else
        return Endian64_Swap(val);
}

Here is the caller graph for this function:

uint64_t shift_left_logic	(	uint64_t	size,
		uint64_t	a,
		uint64_t	b
	)

Definition at line 649 of file vm_mngr.c.

{
    switch(size){
        case 8:
            return (a<<b)&0xff;
        case 16:
            return (a<<b)&0xffff;
        case 32:
            return (a<<b)&0xffffffff;
        case 64:
            return (a<<b)&0xffffffffffffffff;
        default:
            fprintf(stderr, "inv size in shift %"PRIx64"\n", size);
            exit(0);
    }
}

int shift_right_arith	(	unsigned int	size,
		int	a,
		unsigned int	b
	)

Definition at line 563 of file vm_mngr.c.

{
    int i32_a;
    short i16_a;
    char i8_a;
    switch(size){
        case 8:
            i8_a = a;
            return (i8_a >> b)&0xff;
        case 16:
            i16_a = a;
            return (i16_a >> b)&0xffff;
        case 32:
            i32_a = a;
            return (i32_a >> b)&0xffffffff;
        default:
            fprintf(stderr, "inv size in shift %d\n", size);
            exit(0);
    }
}

uint64_t shift_right_logic	(	uint64_t	size,
		uint64_t	a,
		uint64_t	b
	)

Definition at line 605 of file vm_mngr.c.

{
    uint64_t u32_a;
    unsigned short u16_a;
    unsigned char u8_a;
    switch(size){
        case 8:
            u8_a = a;
            return (u8_a >> b)&0xff;
        case 16:
            u16_a = a;
            return (u16_a >> b)&0xffff;
        case 32:
            u32_a = a;
            return (u32_a >> b)&0xffffffff;
        default:
            fprintf(stderr, "inv size in shift %"PRIx64"\n", size);
            exit(0);
    }
}

unsigned int umul16_hi	(	unsigned short	a,
		unsigned short	b
	)

Definition at line 759 of file vm_mngr.c.

{
    uint32_t c;
    c = a*b;
    return (c>>16) & 0xffff;
}

Here is the call graph for this function:

unsigned int umul16_lo	(	unsigned short	a,
		unsigned short	b
	)

Definition at line 754 of file vm_mngr.c.

{
    return (a*b) & 0xffff;
}

unsigned char vm_MEM_LOOKUP_08	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr
	)

Definition at line 460 of file vm_mngr.c.

{
    unsigned char ret;
    ret = memory_page_read(vm_mngr, 8, addr);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned short vm_MEM_LOOKUP_16	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr
	)

Definition at line 466 of file vm_mngr.c.

{
    unsigned short ret;
    ret = memory_page_read(vm_mngr, 16, addr);
    return ret;
}

Here is the call graph for this function:

unsigned int vm_MEM_LOOKUP_32	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr
	)

Definition at line 472 of file vm_mngr.c.

{
    unsigned int ret;
    ret = memory_page_read(vm_mngr, 32, addr);
    return ret;
}

Here is the call graph for this function:

uint64_t vm_MEM_LOOKUP_64	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr
	)

Definition at line 478 of file vm_mngr.c.

{
    uint64_t ret;
    ret = memory_page_read(vm_mngr, 64, addr);
    return ret;
}

Here is the call graph for this function:

void vm_MEM_WRITE_08	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		unsigned char	src
	)

Definition at line 438 of file vm_mngr.c.

{
    check_write_code_bloc(vm_mngr, 8, addr);
    memory_page_write(vm_mngr, 8, addr, src);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vm_MEM_WRITE_16	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		unsigned short	src
	)

Definition at line 444 of file vm_mngr.c.

{
    check_write_code_bloc(vm_mngr, 16, addr);
    memory_page_write(vm_mngr, 16, addr, src);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vm_MEM_WRITE_32	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		unsigned int	src
	)

Definition at line 449 of file vm_mngr.c.

{
    check_write_code_bloc(vm_mngr, 32, addr);
    memory_page_write(vm_mngr, 32, addr, src);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void vm_MEM_WRITE_64	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		uint64_t	src
	)

Definition at line 454 of file vm_mngr.c.

{
    check_write_code_bloc(vm_mngr, 64, addr);
    memory_page_write(vm_mngr, 64, addr, src);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int vm_read_mem	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		char **	buffer_ptr,
		uint64_t	size
	)

Definition at line 486 of file vm_mngr.c.

{
       char* buffer;
       uint64_t len;
       struct memory_page_node * mpn;

       buffer = malloc(size);
       *buffer_ptr = buffer;
       if (!buffer){
          fprintf(stderr, "cannot alloc read\n");
          exit(-1);
       }

       /* read is multiple page wide */
       while (size){
          mpn = get_memory_page_from_address(vm_mngr, addr);
          if (!mpn){
              free(*buffer_ptr);
              PyErr_SetString(PyExc_RuntimeError, "cannot find address");
              return -1;
          }

          len = MIN(size, mpn->size - (addr - mpn->ad));
          memcpy(buffer, (char*)(mpn->ad_hp + (addr - mpn->ad)), len);
          buffer += len;
          addr += len;
          size -= len;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int vm_write_mem	(	vm_mngr_t *	vm_mngr,
		uint64_t	addr,
		char *	buffer,
		uint64_t	size
	)

Definition at line 518 of file vm_mngr.c.

{
       uint64_t len;
       struct memory_page_node * mpn;

       check_write_code_bloc(vm_mngr, size * 8, addr);

       /* write is multiple page wide */
       while (size){
          mpn = get_memory_page_from_address(vm_mngr, addr);
          if (!mpn){
              PyErr_SetString(PyExc_RuntimeError, "cannot find address");
              return -1;
          }

          len = MIN(size, mpn->size - (addr - mpn->ad));
          memcpy(mpn->ad_hp + (addr-mpn->ad), buffer, len);
          buffer += len;
          addr += len;
          size -= len;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int x86_bsf	(	uint64_t	src,
		unsigned int	size
	)

Definition at line 939 of file vm_mngr.c.

{
    int i;

    for (i=0; i<size; i++){
        if (src & (1<<i))
            return i;
    }
    fprintf(stderr, "sanity check error bsf\n");
    exit(0);
}

unsigned int x86_bsr	(	uint64_t	src,
		unsigned int	size
	)

Definition at line 927 of file vm_mngr.c.

{
    int i;

    for (i=size-1; i>=0; i--){
        if (src & (1<<i))
            return i;
    }
    fprintf(stderr, "sanity check error bsr\n");
    exit(0);
}