dasmcode.cpp

win32 exe程序反汇编

		else if( pszMask[-2] == 'a' )
		{
			if( ( m_adrSzOverd ^ ( pszMask[-3] == 'n') ) == 0 )
				return false ;
		}
		else
			assert(0) ;
		continue ;
	case 'j' :	// jmp
	case 'c' :
		if( pszMask[1] == '8' )
		{
			dwData = (signed int)*(signed char*)m_pvCur ;
			dwData += GetExe()->ptr2va( m_pvCur ) + 1; // rel a l'instr suivante
			if( m_iPass == ctePassScan )
				GetExe()->AddSymbol( dwData ,0,true , cSymJmp ) ;
			m_pvCur ++ ;
		}
		else	// == 32
		{
			dwData = *(DWORD*)m_pvCur ;
			dwData += GetExe()->ptr2va( m_pvCur ) + 4 ; // rel a l'instr suivante
			if( m_iPass == ctePassScan )
			{
				if( cCur == 'j' )
					GetExe()->AddSymbol( dwData ,0,true , cSymJmp ) ;
				else
					GetExe()->AddSymbol( dwData ,0,true , cSymFunc ) ;
			}
			m_pvCur += 4 ;
		}
		if( m_iPass == ctePassEcho )
			strcpy( *ppszCurOprd++ , GetExe()->GetSymbName( dwData , 0 , true , 0 ) ) ;
		pszMask += 2 ;
		bBytePtr = 8 ;
		continue ;
	case 'a' :
	case 'i' : // donnees ou adresse 
		BYTE bSize ;
		bool bAdress ;
		bool sFlag ;
		vaRef = GetExe()->ptr2va( m_pvCur ) ;
		bAdress = ( cCur == 'a' ) ;
		if( pszMask[1] == '0' )	// determination par context
		{
			sFlag = m_sFlag ;
			bSize = m_OperandSize ;
		}
		else
		{
			sFlag = ( pszMask[0] == 's' ) ;
			if( pszMask[1] == '8'  )
				bSize = 1 ; 
			else if( pszMask[1] == '6' )
				bSize = 2 ; 
			else
				bSize = 3 ; 
		};
		if(sFlag)
		{
			dwData = (signed int)*(signed char*)m_pvCur ;
			m_pvCur ++ ;
			if( m_iPass == ctePassEcho )
				strcpy( *ppszCurOprd , GetExe()->GetValue(dwData ,0 ) ) ;
		}
		else if( bSize == 1 )
		{

			dwData = *m_pvCur ;	
			m_pvCur ++ ;
			if( m_iPass == ctePassEcho )
				strcpy( *ppszCurOprd , GetExe()->GetValue(dwData , 0 ) ) ;
		}
		else if( bSize == 2 )	
		{
			dwData = *(WORD*)m_pvCur ;
			m_pvCur += 2 ;
			if( m_iPass == ctePassEcho )
				strcpy( *ppszCurOprd , GetExe()->GetValue(dwData, 0 ) ) ;
		}
		else
		{
			dwData = *(DWORD*)m_pvCur ;
			if( ( m_iPass == ctePassScan ) && ( m_segPrefix == 0xff ) )
				GetExe()->AddSymbol( dwData ,vaRef,bAdress, cSymData );  // symbol ou constante ?
			if( m_iPass == ctePassEcho )	
			{
				if( bAdress )
				{
					if( m_segPrefix != 0xff )
						sprintf( *ppszCurOprd, "%s:[%s]" ,cteSegReg[m_segPrefix]
							,GetExe()->GetValue( dwData , cteDecorate ) ) ;
					else
						strcpy( *ppszCurOprd 
						, GetExe()->GetSymbName( dwData , vaRef , true , cteDecorate ) ) ;				
				}
				else
					strcpy( *ppszCurOprd 
					, GetExe()->GetSymbName( dwData , vaRef , false , cteDecorate | cteDecOffset ) ) ;
			}
			ppszCurOprd ++ ;
			m_pvCur += 4;
		}
		++ ppszCurOprd ;
		pszMask += 2 ;
		bBytePtr = 8 ;
		continue ;
	default :
		assert(0) ;
	}
}

void CDasmCode::PrintInstr(  )
{
	static char_buff pszTemp ;
	char* pszOut = m_pszInstr ;
	const char* pszCurFmt  ;
	const char* pszCur ;
	bool bPtrQualif = false;

// 1ere passe recuperation operandes
	for( pszCurFmt = m_pszFormat ; *pszCurFmt != '\0'; pszCurFmt ++ )
	{
		if( *pszCurFmt == '%' )
		{
			pszCurFmt++ ;
			switch( *pszCurFmt )
			{
				case '0':
				case '1':
				case '2':
					if( bPtrQualif )
					{
						strcpy( pszTemp ,  m_pszOperand[ *pszCurFmt - '0']  );
						sprintf( m_pszOperand[ *pszCurFmt - '0'] ,"%s %s" , cteOperandQualif[ m_OperandSize ] , (const char*)pszTemp) ;
					}
					bPtrQualif = false ;
					break ;
				case 'p':
					bPtrQualif = true ;			
					break ;
			}
		}
	}
// inversion des operandes %0 et %1 si besoin
	if( m_dFlag )						
	{	
		strcpy( pszTemp , m_pszOperand[ 0 ] ) ;
		strcpy( m_pszOperand[ 0 ] , m_pszOperand[ 1 ] ) ;
		strcpy( m_pszOperand[ 1 ] , pszTemp ) ;
	}

// 2eme passe emission du source
	for(  pszCurFmt = m_pszFormat ; *pszCurFmt != '\0'; pszCurFmt ++ )
	{
		if( *pszCurFmt == '%' )
		{
			pszCurFmt++ ;
			switch( *pszCurFmt )
			{
				case '0':
				case '1':
				case '2':
					pszCur = m_pszOperand[ *pszCurFmt - '0'] ;
					for(  ; *pszCur != '\0' ; ++pszCur ) 
						*pszOut++ =	*pszCur	;
					break ;
				case 'p':		
					break ;
				case 'c':
					for( pszCur = cteConditions[ m_tttnFlag ] ; *pszCur != '\0' ; ++pszCur ) 
						*pszOut++ =	*pszCur	;
					break ;
				case 'g':
					for( pszCur = cteMmxPack[ m_mmxPack ] ; *pszCur != '\0' ; ++pszCur ) 
						*pszOut++ =	*pszCur	;
					break ;
				case 'r':
					pszCurFmt++ ;
					if( m_repPrefix != 0 )
					{						
						const char* pszPrefix = 0 ;
						if( *pszCurFmt == '_' )
							pszPrefix = cteRep[ m_repPrefix - 0xf0 ] ;
						else if(*pszCurFmt == 'z' )
							pszPrefix = cteRepZ[ m_repPrefix - 0xf0 ] ;
						else 
							assert(0);
						for( pszCur = pszPrefix ; *pszCur != '\0' ; ++pszCur ) 
							*pszOut++ =	*pszCur	;

					}
					break ;
				default:
					assert(0) ;
			}
		}
		else
			*pszOut++ = *pszCurFmt ;
	}
	*pszOut = '\0' ;
	fprintf( m_pFileOut ,"\t%s", m_pszInstr ) ;
}

//////////////////////////////////////////////////////////////////
// fonctions d'aides

bool CDasmCode::ModMProcess( char* pszBuff )
{
	bool bRet = true ;
	unsigned int uDisp , uVARef ;

// on exclue le mode registre : traite a part 
	if( m_Mod ==0x03 )
		return false ;
	
	char* pszIdx = pszBuff ;
	uVARef = GetExe()->ptr2va( m_pvCur ) ;

// registre segment override
	if( ( m_iPass == ctePassEcho ) && ( m_segPrefix != 0xff ) )
	{
		sprintf( pszIdx, "%s:" ,cteSegReg[m_segPrefix] ) ;
		pszIdx = pszBuff + strlen( pszBuff ) ;
	}

// utilisation du SIB	
	if( m_RM == 0x04 )
		return SIBProcess( pszIdx ) ;
	else if( m_Mod == 0x00 )
	{
		if( m_RM == 0x05 )	// cas particulier [ variable ]
		{
			uDisp = *(DWORD*)m_pvCur ;
			if( ( m_iPass == ctePassScan ) && ( m_segPrefix == 0xff ) )		
				GetExe()->AddSymbol( uDisp , 0 , true ,cSymData );
			if( m_iPass == ctePassEcho )
			{					
				if( m_segPrefix != 0xff )
					sprintf( pszIdx ,"[%s]",GetExe()->GetValue( uDisp , cteDecorate ) ) ;
				else					
					strcpy( pszIdx , GetExe()->GetSymbName(uDisp,0,true ,cteDecorate ) );
			}
			m_pvCur += 4 ;
		}
		else				// [reg]
			if( m_iPass == ctePassEcho )
				sprintf( pszIdx , "[%s]" , cteGenReg[3][m_RM] ) ;
	}
	else if( m_Mod == 0x01 )
	{		// disp8[reg]
		uDisp = (signed int)(*((signed char*)m_pvCur++));
		if( m_iPass == ctePassEcho )
			sprintf( pszIdx , "[ %s %s ]" , cteGenReg[3][m_RM] 
				, GetExe()->GetValue( uDisp , cteFmtInteger | cteFmtSign ) ) ;
	}
	else 
	{	// disp32[reg]
		assert( m_Mod == 0x02 ) ;
		uDisp = *(DWORD*)m_pvCur ;
		if( m_iPass == ctePassScan )		
			GetExe()->AddSymbol( uDisp , uVARef , false , cSymData ) ;
		if( m_iPass == ctePassEcho )
			sprintf( pszIdx , "[ %s + %s ]" , cteGenReg[3][m_RM] 
			, GetExe()->GetSymbName(uDisp, uVARef , false , 0) ) ;
		m_pvCur += 4 ;	
	}
	return bRet ;
}

bool CDasmCode::SIBProcess( char* pszBuff )
{
	char* pszIdx = pszBuff ;
	BYTE	Scale , Index , Base ;
	unsigned int uDisp = 0 ;
	ByteSplit3( *m_pvCur++ , Scale , Index , Base ) ;
	unsigned int uVARef = GetExe()->ptr2va( m_pvCur ) ;

//base
	if( ( Base == 0x05 ) && ( m_Mod == 0x00 ) )
	{	// cas particulier : pas de registre de base
		if( Index == 0x04 )	// pas d'index non plus -> quit
			return false ;
		if( m_iPass == ctePassEcho )
			strcpy( pszIdx , "[ " );		
	}
	else if( m_iPass == ctePassEcho )
	{
		if(  Index == 4  )
			sprintf( pszIdx , "[ %s" , cteGenReg[3][Base] ) ;
		else
			sprintf( pszIdx , "[ %s + " , cteGenReg[3][Base] ) ;
	};
	if( m_iPass == ctePassEcho )
		pszIdx = pszBuff + strlen( pszBuff ) ;

// scale index		
	if( ( Index != 4 ) && ( m_iPass == ctePassEcho ) )		//sinon pas d'index
	{
		if( Scale == 0 ) // pas d'echelle
			sprintf( pszIdx , "%s" , cteGenReg[3][Index]);
		else
			sprintf( pszIdx , "%i * %s" , 1 << Scale , cteGenReg[3][Index] );
	}
	pszIdx = pszBuff + strlen( pszBuff ) ;

// offset 
	if( m_Mod == 0x01 )					// disp8
		uDisp = (signed int)(*((signed char*)m_pvCur++)) ;
	else if( ( m_Mod == 0x02 ) || ( ( Base == 0x05 ) && ( m_Mod == 0x00 )  )) //disp32
	{
		uDisp = *(DWORD*)m_pvCur ;
		if( m_iPass == ctePassScan )	
			GetExe()->AddSymbol( uDisp , uVARef , false , cSymData  );
		m_pvCur += 4 ;
	}
	
	if( m_iPass == ctePassEcho )
	{
		if( uDisp == 0 )
			strcpy( pszIdx ," ]" ) ;
		else if( ( m_Mod == 0x00 ) || ( m_Mod == 0x02 ) )	//disp32
			sprintf( pszIdx , " + %s ]" , GetExe()->GetSymbName( uDisp , uVARef , false , 0 ) ) ;
		else											// disp8
			sprintf( pszIdx , " %s ]" , GetExe()->GetValue( uDisp , cteFmtInteger | cteFmtSign ) ) ;				
	}		
	return true ;
}


//////////////////////////////////////////////////////////////////
// fonctions globales