a64-2.c

Intel x86处理器的汇编器

	while (p->mode && !str_cmp(s, p->mode))
		p++;

	return p->mode_id;
}

unsigned char get_bitsid(char *s)
{
	bits_t *p = bits;

	if (!s || !s[0])
		return 0;

	while (p->bits && !str_cmp(s, p->bits))
		p++;

	return p->bits_id;
}

/*************************************************************/
int check_cast(unsigned char cast)
{
	if (cast == NEAR_ID || cast == FAR_ID) {
		/* it's transfer cast */
	} else if (cast && (current_bits == 64)) {
	} else if (!cast || cast == 64)
		return 0;
		
	return 1;
}


int check_oseg(unsigned char oseg)
{
	if (oseg && (current_bits != 64)) { 
		/* 32-bit */
	} else if (!oseg || (oseg == 0x2e) || (oseg ==  0x3e) || 
			(oseg == 0x26) || (oseg == 0x36))
		/* in 64-bit mode: the CS,DS,ES and SS is invalid */
		return 0;

	return 1;
}

/*****************************************
 check register is GPR
*****************************************/
/*
int is_GPR(unsigned char regid)
{
	return regid && ((regid & 0xf0) < 0xa0);
}
*/
// #define is_GPR(regid)	((regid) && ((regid & 0xf0) < 0xa0))

/*
int is_eGPR(unsigned char regid)
{
	return regid && ((regid & 0xf0) == 0x80);
}
*/

// #define is_eGPR(regid)	((regid) && ((regid & 0xf0) == 0x80))


int get_reg_size(unsigned char regid)
{
	int reg_size = 0;

	if (is_GPR(regid))
		reg_size = (regid & 0xf0) >> 1;	
	else if ((regid & 0xf0) == 0xa0)	/* segment register */
		reg_size = 16;
	else if ((regid & 0xf0) == 0xc0)	/* control register */
		reg_size = 16;
	else if ((regid & 0xf0) == 0xd0)	/* debug register */
		reg_size = 16;
	else if ((regid & 0xf0) == 0xe0)	/* mmx register */
		reg_size = 64;
	else if ((regid & 0xf0) == 0xf0)	/* xmm register */
		reg_size = 128;
	
	return reg_size;
}


/**************************************************
 the funtion check base or index register
***************************************************/
int check_mreg(unsigned char regid)
{
	if (!regid || ((regid & 0xF0) == 0x10))	/* 1-byte register */
		return 0;
	else if ((regid & 0xF0) >= 0xa0)	/* not GPR */
		return 0;
	else if ((regid & 0xF0) == 0x20) {	/* 2-byte register */
		/* it's 16-bit address mode */
		/* in 64-bit mode: not support 16-bit address */
		if (current_bits == 64)
			return 0;
		/* in 32-bit mode: 16-bit address base register 
		   only support bx, bp, si and di register */
		else if (regid == BX || regid == BP || regid == SI 
			|| regid == DI) {
			/* at 32-bit or 16-bit... OK */
		} else 
			return 0;
	} else if ((regid == ESP) || (regid == RSP)) {
		
		/* 32-bit address or 64-bit address is OK */
		
	}

	return 1;
}

/*********************************************************
 check the string is var ????
**********************************************************/
int check_var(char *s)
{
	return 1;
}


/************************************************************/
kw_id_t get_keyword(char *s) {
	 keyword_t *p = keyword;

	if (!s) return 0;
	
	while (p->keyword && !str_cmp(p->keyword, s)) 
		p++;

	return p->keyword_id;
}


long long strd_to_n(char *s) {
	long long retval = 0;
	while (*s)
		retval = retval * 10 + (*s++ - '0');
	return retval;
}

long long strh_to_n(char *s) {
	long long retval = 0;
	int i = 0;

	s++;
	if (*s == 'x' || *s == 'X') {
		s++;
		while (*s) {
			if (is_n(*s))
				i = *s - '0';
			else if (is_hc(*s))
				i = *s - 'a' + 10;
			else
				return 0;
			retval = retval * 16 + i;
			s++;
		}
	} else {
		while (*s) {
			if (*s == 'h' || *s == 'H')
				break;
			if (is_n(*s))
				i = *s - '0';	
			else if (is_hc(*s))
				i = *s - 'a' + 10;
			else
				return 0;
			retval = retval * 16 + i;
			s++;
		}
	}

	return retval;
}

long long strb_to_n(char *s) {
	long long retval = 0;

	while (*s) {
		if (*s == 'b' || *s == 'B')
			break;
		retval = retval * 2 + (*s - '0');
		s++;
	}
	return retval;
}


long long str_to_n(char *s) 
{
	long long retval = 0;

	if (!s || !s[0]) return 0;

	if (is_hex(s)) 
		retval = strh_to_n(s);
	else if (is_dec(s))
		retval = strd_to_n(s);
	else if (is_binary(s))
		retval = strb_to_n(s);
	else
		return 0;

	return retval;
}





/***********************************************************
 *  i_key_t *get_i_key(char *s)
 *  return value: i_key if found
 *                  0   if no found
************************************************************/
i_key_t *get_ins(char *s)
{
	if (!s || !s[0])
		return 0;

	i_set_t *p = i_set;
	
	while (p->mnemonic && !str_cmp(s, p->mnemonic)) 
		p++;

	return p->i_key;

}

i_key_t *get_transfer_ins(char *s)
{
	if (!s || !s[0])
		return 0;

	i_set_t *p = i_transfer;

	while (p->mnemonic && !str_cmp(s, p->mnemonic))
		p++;

	return p->i_key;
}


int is_string_ins(i_key_t *ins_key)
{
	if (ins_key == CMPSB) {
	} else if (ins_key == CMPSW) {
	} else if (ins_key == CMPSD) {
	} else if (ins_key == CMPSQ) {
	} else if (ins_key == SCASB) {
	} else if (ins_key == SCASW) {
	} else if (ins_key == SCASD) {
	} else if (ins_key == SCASQ) {
	} else if (ins_key == MOVSB) {
	} else if (ins_key == MOVSW) {
	} else if (ins_key == MOVSD) {
	} else if (ins_key == MOVSQ) {
	} else if (ins_key == LODSB) { 
	} else if (ins_key == LODSW) { 
	} else if (ins_key == LODSD) {
	} else if (ins_key == LODSQ) {
	} else if (ins_key == STOSB) {
	} else if (ins_key == STOSW) {
	} else if (ins_key == STOSD) {
	} else if (ins_key == STOSQ) {
	} else
		return 0;

	return 1;
}


int is_transfer_ins(i_key_t *ins_key)
{
	if (ins_key == JMP) {
	} else if (ins_key == CALL) {
	} else if (ins_key == JO) { 
	} else if (ins_key == JNO) {
	} else if (ins_key == JB) {
	} else if (ins_key == JNB) {
	} else if (ins_key == JZ) {
	} else if (ins_key == JNZ) {
	} else if (ins_key == JBE) { 
	} else if (ins_key == JNBE) {
	} else if (ins_key == JS) {
	} else if (ins_key == JNS) {
	} else if (ins_key == JP) { 
	} else if (ins_key == JNP) {
	} else if (ins_key == JL) {
	} else if (ins_key == JNL) {
	} else if (ins_key == JLE) {
	} else if (ins_key == JNLE) {
	} else if (ins_key == LOOP) {
	} else if (ins_key == LOOPZ) {
	} else 
		return 0;

	return 1;
}

int is_imul_ins(i_key_t *i_key) 
{
	int ret = 0;
	if ((i_key >= IMUL) && (i_key < (IMUL + sizeof(IMUL))))
		ret = 1;
	return ret;
}


/****************************************************************/
i_key_t *get_i_key(i_key_t *i_key, ops_attr_t *ops_attr)
{
	if (!i_key || !ops_attr)
			return 0;

	unsigned int i_attr = 0;
	unsigned int i_so_attr = 0;
	unsigned int i_do_attr = 0;
	unsigned int i_to_attr = 0;
	
	unsigned int so_attr = ops_attr->so_attr;
	unsigned int do_attr = ops_attr->do_attr;
	unsigned int to_attr = ops_attr->to_attr;

	
	while (i_key->opcode || i_key->i_attr) {

		i_attr = i_key->i_attr;
		i_so_attr = i_key->so_attr;
		i_do_attr = i_key->do_attr;
		i_to_attr = i_key->to_attr;


		if (((i_so_attr == 0) && (so_attr != 0))
			|| ((i_so_attr != 0) && (so_attr == 0))
			|| ((i_do_attr == 0) && (do_attr != 0))
			|| ((i_do_attr != 0) && (do_attr == 0))
			|| ((i_to_attr == 0) && (to_attr != 0))	
			|| ((i_to_attr != 0) && (to_attr == 0))) 
		{
			i_key++;
			continue;
		}

/*

		if (((OPTYPE(i_so_attr) == 0) && (OPTYPE(so_attr) != 0)) 
			|| ((SIZE(i_so_attr) == 0) && (SIZE(so_attr) != 0)) 
			|| ((OPTYPE(i_so_attr) != 0) && (OPTYPE(so_attr) == 0))
			|| ((SIZE(i_so_attr) != 0) && (SIZE(so_attr) == 0))

			|| ((OPTYPE(i_do_attr) == 0) && (OPTYPE(do_attr) != 0))
			|| ((SIZE(i_do_attr) == 0) && (SIZE(do_attr) != 0))
			|| ((OPTYPE(i_do_attr) != 0) && (OPTYPE(do_attr) == 0))
			|| ((SIZE(i_do_attr) != 0) && (SIZE(do_attr) == 0))

			|| ((OPTYPE(i_to_attr) == 0) && (OPTYPE(to_attr) != 0))
			|| ((SIZE(i_to_attr) == 0) && (SIZE(to_attr) != 0))
			|| ((OPTYPE(i_to_attr) != 0) && (OPTYPE(to_attr) == 0))
			|| ((SIZE(i_to_attr) != 0) && (SIZE(to_attr) == 0)))
		{
			i_key++;
			continue;
		}

*/

		if (((so_attr & i_so_attr) == so_attr) 
	   	   && ((do_attr & i_do_attr) == do_attr)
		   && ((to_attr & i_to_attr) == to_attr))
		{
			if (current_bits == 64) {
				if (is_INVLD_IN_64(i_attr)) {
					i_key++;
					continue;
				}
			}

			if (is_FS_64(i_attr) && (current_bits != 64)) {
				i_key++;
				continue;
			}
			

			return i_key;
		}

		i_key++;
	}
		
	return 0;
}



/*********************************************************/
static void release_o_key(o_key_t *o_key)
{
	if (o_key->mem)
		a64_free(o_key->mem);
	
	if (o_key->imme)
		a64_free(o_key->imme);

	a64_free(o_key);
}


static void release_ops_key(ops_key_t *ops_key)
{
	if (ops_key->so_key)
		release_o_key(ops_key->so_key);
	
	if (ops_key->do_key)
		release_o_key(ops_key->do_key);	

	if (ops_key->to_key)
		release_o_key(ops_key->to_key);

	a64_free(ops_key);
}


static void release_e_key(e_key_t *e_key)
{
	if (e_key) {
		if (e_key->ops_key)
			release_ops_key(e_key->ops_key);
/*
	e_key->i_key it's not need malloc()!!!
*/
		if (e_key->i_prefix)
			a64_free(e_key->i_prefix);
	}

	a64_free(e_key);
}



static void release_e_key_link()
{
	e_key_t *e_key_next;

	while (e_key_link) {
		e_key_next = e_key_link->next;
		release_e_key(e_key_link);
		e_key_link = e_key_next;
	}
}

void release_resource()
{
	release_e_key_link();
	release_label_table();
	release_hole_link();
	release_err_link();
}

void reset_environment()
{
	current_mode = LONG_64;
	current_bits = 64;
	current_pc = 0;
	line = 0;
	org = 0;
}