global.c

一个MIPS虚拟机的源码

#ifdef EXTERN
#undef EXTERN
#endif
#define EXTERN extern

#include "global.h"


/*generate a random value between lowbound and uppbound(include lowbound and uppbound)
notice:use srand((int)time(0)) before random_value
*/
int random_value(int lowbound,int uppbound)
{
	float interval;
	interval = uppbound-lowbound;
	return (lowbound+(int)(interval*rand()/(RAND_MAX+1.0)));
}



/*load 4 bytes  to construct UNIT32 */
UINT32 bytes2word(UINT8   baseaddr[])
{
	UINT32 return_value;

	if (target_end==LITTLEEND)
		{
		return  (( (0x00000000 | baseaddr[3])<<24  ) |  ((0x00000000 | baseaddr[2]) <<16 )   \
				    | ((0x00000000 | baseaddr[1])<<8)   |   (0x00000000 | baseaddr[0])          )  ;
			}
	else
		{
			return  (( (0x00000000 | baseaddr[0])<<24  ) |  ((0x00000000 | baseaddr[1]) <<16 )   \
				    | ((0x00000000 | baseaddr[2])<<8)   |   (0x00000000 | baseaddr[3])          )  ;
		}
}

UINT16 bytes2halfword(UINT8   baseaddr[])
{
	UINT16 return_value;

	if (target_end==LITTLEEND)
		{
		return   ((0x00000000 | baseaddr[1])<<8)  |   (0x00000000 | baseaddr[0])   ;
		}
	else
		{
			return  ((0x00000000 | baseaddr[0])<<8)   |   (0x00000000 | baseaddr[1])  ;
		}
}


void word2bytes(UINT32 data, UINT8  baseaddr[])
{
	if (target_end ==LITTLEEND)
		{
			baseaddr[0]= 0x000000ff & data;
			baseaddr[1]= (0x0000ff00 & data)>>8 ;
			baseaddr[2]= (0x00ff0000 & data)>>16 ;
			baseaddr[3]= (0xff000000 & data)>>24 ;
		}
	else
		{
			baseaddr[0]=  (0xff000000 & data)>>24 ;
			baseaddr[1]= (0x00ff0000 & data)>>16 ;
			baseaddr[2]= (0x0000ff00 & data)>>8 ;
			baseaddr[3]= 0x000000ff & data;
		}
}
void halfword2bytes(UINT16 data, UINT8  baseaddr[])
{
	if (target_end ==LITTLEEND)
		{
			baseaddr[0]= 0x00ff & data;
			baseaddr[1]= (0xff00 & data)>>8 ;
		
		}
	else
		{
			baseaddr[0]=  (0xff00 & data)>>8 ;
			baseaddr[1]= 0x00ff & data;
		
		}
}


UINT8 get_byte_from_word(UINT32 word,UINT8 offset)
{
	if (target_end ==BIGEND)
		offset = 3- offset;
	return (word>>(offset * 8)) & 0x000000ff; 
	
}

UINT16 get_halfword_from_word(UINT32 word,UINT8 offset)
{
	if (target_end ==BIGEND)
		offset = 1- offset;
	return (word>>(offset * 16)) & 0x0000ffff; 
	
}



void mult_signed(UINT32 * high,UINT32 * low, INT32 rs, INT32 rd)
{
	
	//UINT32 high,low;

	UINT32 fuhaobit;
	
	rs = (INT32)rs;
	rd = (INT32)rd;
	fuhaobit = (rs<0)^(rd<0);
	if (rs<0)
		rs = -rs;
	if (rd<0)
		rd = -rd;
	//printf("rs= %x\n",rs);
	//printf("rd = %x\n",rd);
	mult_unsigned(high,low,(UINT32)rs,(UINT32)rd);
	//printf("high= %x\n",*high);
	//printf("low = %x\n",*low);
	if (fuhaobit)
		{
			*high = (~(*high));
			*low = (~(*low));
			if (((*low)&0xffffffff)==0xffffffff)
				{
					*high = *high +1;
					*low = 0x00000000;
				}
			else
				*low=(*low) +1;

			
		}
	
}

void mult_unsigned(UINT32 * high,UINT32 * low,UINT32 rs, UINT32 rd)
{
	/* we divide UINT32 into 2 UINT16

	   UINT16 a,b,c,d
	   UINT32 m,n,o,p	
	
	   a  b
	* c  d 
=--------------------

     m=b*d;
     n= a*d ;
     o=b*c 
     p=a*c ;
             high               |      low
    m:                          |X X X X X X X X                                                  
    n:               X X X X |X X X X                   
    o:               X X X X |X X X X                   
    p:   X X X X X X X X | 
    -----------------------------------------------------


        high= p + ((0x0000ffff) & (o>>16)) + ((0x0000ffff) & (n>>16) )
        low=  m + (0xffff0000& (o<<16))  +( 0xffff0000&(n<<16) )   ;

	*/

	//printf("rs= %x\n",rs);
	//printf("rd = %x\n",rd);
	UINT16 a,b,c,d;
  	UINT32 m,n,o,p;	
	int overflow;
  	
	a = 0xffff & (rs>>16);
	b = 0xffff & rs;
	c = 0xffff & (rd>>16);
	d = 0xffff & rd;
	//printf("a= %x\n",a);
	//printf("b = %x\n",b);
	//printf("c= %x\n",c);
	//printf("d = %x\n",d);

	m = b * d;
	n = a * d;
	o = b * c;
	p = a * c;
	//printf("m= %x\n",m);
	//printf("n = %x\n",n);
	//printf("o= %x\n",o);
	//printf("p = %x\n",p);
	*high = p + ((0x0000ffff) & (o>>16)) + ((0x0000ffff) & (n>>16) );
	*low = m + (0xffff0000& (o<<16))  +( 0xffff0000&(n<<16) ) ;

	overflow = ( ((m>>16)& 0x0000ffff)   +   (o & 0x0000ffff) +   (n & 0x0000ffff) )/ 0x0000ffff ;
	*high = *high +overflow;
	
	

	
	
	//printf("high= %x\n",*high);
	//printf("low = %x\n", *low);

	
}


int trim(char in[],int len)
{
	int i,j,k;
	
	for (i=0;i<len;i++)
		if (in[i]!=' ')
			break;
	for (j=len-1;j>=0;j--)
		if (in[j]!=' ')
			break;

	if (i>j)
		{
			in[0]='\0';
			return 0;
			
		}
	else if (i==j)
		{
		in[0]=in[i];
		in[1]='\0';
		return 1;
		}
	else
		{
			for (k=0;k<=j-i;k++)
				{
					in[k]=in[k+i];
				}
			in[k]='\0';
			return k+1;
		}
}