16汇编学习:数据传送指令的反汇编

最新推荐文章于 2024-08-19 14:42:59 发布
最新推荐文章于 2024-08-19 14:42:59 发布
阅读量159 收藏
点赞数 2
文章标签： 汇编 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74197261/article/details/137384681
版权

数据传送指令大概是pdf的第一页

这里有些疑惑的是xchg的第二种类型,和累加寄存器交换,如果携程xchg ax,ax会被xp debug当成nop(可能是交换无意义吧,毕竟都没变)

MyTransfer.h

#pragma once
#include<string>
#include <iostream>
#include <iomanip>
#include<map>
#include<share.h>
#include<sstream>
#include<vector>
//#define BIT(a,start,end) ((a)&0xff)>>((end-start))
int GetBit(unsigned char num, int n, int m);//第n位开始的m个位数
#define PMT std::shared_ptr<Type>
#define PTR std::shared_ptr<Transfer>
enum RegType
{
	/*八大常用寄存器*/
	AX=0,AL=0,AH=4,
	CX=1,CL=1,CH=5,
	DX=2,DL=2,DH=6,
	BX=3,BL=3,BH=7,
	SP=4,
	BP=5,
	SI=6,
	DI=7,
	/*段寄存器*/
	ES=0,
	CS = 1,
	SS=2,
	DS=3,
	/*基址和变址寄存器*/
	BXSI=0,
	BXDI=1,
	BPSI=2,
	BPDI=3,
	IRSI=4,
	IRDI=5,
	BRBP=6,
	BRBX=7
};
class Type
{
public:
	virtual bool cmp(unsigned char Key) = 0;//如果键值匹配返回true
	virtual std::string Decode(const unsigned char* ptr, int& offset) = 0;
	static std::string getSmallReg(unsigned char reg );//小的寄存器 ah,al...
	static std::string getGeneralReg(unsigned char reg);//八大常用寄存器
	static std::string getSegementReg(unsigned char reg);//段寄存器
	static std::string getBrIrReg(unsigned char reg);//基址变址寄存器
	static std::string getHex(unsigned char data);//获取一字节16进制数据
	static std::string getAddress(unsigned char mod,unsigned char r, unsigned char* ptr=nullptr,unsigned char w=1);//获取寄存器是off1当做w 1返回大寄存器 0返回小的
	static std::string getReg(unsigned char w, unsigned char reg);
	static std:: string getRegMem( unsigned char rm);
	static std::string getRegMem1( unsigned char rm, unsigned char off1);
	static std::string getRegMem2( unsigned char rm,unsigned char off1,unsigned char off2);
	static int getOffset(unsigned char mod, unsigned char rm);
private:

};
class MovType1:public Type
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short w : 1;
	unsigned short d : 1;
	unsigned short key : 6;
public:
	
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType2 :public Type
{
	unsigned short rm : 3;
	unsigned short z3:3;
	unsigned short mod : 2;
	unsigned short w : 1;
	unsigned  short key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType3:public Type
{
	unsigned char reg : 3;
	unsigned char w : 1;
	unsigned char key : 4;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType4 :public Type
{
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType5 :public Type
{
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType6 :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 2;
	unsigned short z1 : 1;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class MovType7 :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 2;
	unsigned short z1 : 1;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//push [地址]
class PushType1:public Type
{
	unsigned short rm:3;
	unsigned short n110 : 3;
	unsigned short mod : 2;
	unsigned short key:8;
public:
	PushType1() { n110 = 6; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
//push 常用寄存器
class PushType2:public Type
{
	unsigned char reg : 3;
	unsigned char n01010 : 5;
public:
	PushType2() { n01010 = 0b01010; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
//push 段寄存器
class PushType3 :public Type
{
	unsigned char n110 : 3;
	unsigned char sreg : 2;
	unsigned char n000 : 3;
public:
	PushType3() { n000 = 0b000;
	n110 = 0b110;
	}
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
class PopType1 :public Type
{
	unsigned short rm : 3;
	unsigned short n000 : 2;
	unsigned short mod : 2;
	unsigned short key : 8;
public :
	PopType1() { n000 = 0b000; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class PopType2 :public Type
{
	unsigned char reg : 3;
	unsigned char n01011 : 5;
public:
	PopType2() { n01011 = 0b01011; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class PopType3 :public Type
{
	unsigned char n111 : 3;
	unsigned char sreg : 2;
	unsigned char n000 : 3;
public:
	PopType3() {
		n000 = 0b000;
		n111 = 0b111;
	}
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
//1.寄存器与寄存器之间可以对换数据
//2.寄存器与存储器之间可以对换数据
//3.不能在存储器与存储器之间对换数据
class XchgType1 :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short w : 1;
	unsigned short key : 7;

public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
class XchgType2 :public Type
{
	unsigned char reg : 3;
	unsigned char key : 5;
	
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};

class XlatType :public Type
{

public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//in al,port in ax port
class InType1:public Type
{
	unsigned short  port:8;
	unsigned short w : 1;
	unsigned short key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
class InType2 :public Type
{
	
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);

};
class OutType1:public Type
{
	unsigned short  port : 8;
	unsigned short w : 1;
	unsigned short key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class OutType2 :public Type
{
	unsigned char w : 1;
	unsigned char key : 7;
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class LeaType :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	LeaType() { key = 0x8d; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//LDS r16, mem
//r16←mem
//DS←mem + 2
class LdsType :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	LdsType() { key = 0xc5; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class LesType :public Type
{
	unsigned short rm : 3;
	unsigned short reg : 3;
	unsigned short mod : 2;
	unsigned short key : 8;
public:
	LesType() { key = 0xc4; }
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//LAHF指令将标志寄存器的低字节送寄存器AH flag->ah
class LahfType :public Type
{
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//SAHF将AH寄存器内容送FLAGS的低字节 ah->flag
class SahfType :public Type
{
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//PUSHF指令将标志寄存器的内容压入堆栈，同时栈顶指针SP减2
class PushfType :public Type
{
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
//POPF指令将栈顶字单元内容送标志寄存器，同时栈顶指针SP加2
class PopfType :public Type
{
public:
	virtual bool cmp(unsigned char Key);
	virtual std::string Decode(const unsigned char* ptr, int& offset);
};
class Transfer
{
public :
	Transfer();
	virtual std::string Decode(int index, unsigned char*ptr,int &offset);
	virtual int cmp(unsigned char Key);
private:
	std::vector<PMT>mVec;
};
class Disassembly
{
public:
	static  std::string Decode(unsigned char *ptr,int& offset);//解析字符串  返回
public:
	static std::vector<PTR>mVec;
};


#include "MyTransfer.h"
std::vector<PTR> Disassembly::mVec = {PTR(new Transfer()) };
std::string Disassembly::Decode(unsigned char* ptr, int& offset)
{
	int ret = -1;
	for (int i = 0; i < mVec.size(); i++)
	{
		ret = mVec[i]->cmp(ptr[0]);
		if ( ret!= -1)
		{
			return mVec[i]->Decode(ret, ptr, offset);
		}
	}
	
	offset = 1;
	return "unkown";
}

std::string Type::getSmallReg(unsigned char reg)
{
	switch (reg)
	{
	case AL:
		return "AL";
	case CL:
		return "CL";
	case DL:
		return "DL";
	case BL:
		return "BL";
	case AH:
		return "AH";
	case CH:
		return "CH";
	case DH:
		return "DH";
	case BH:
		return "BH";
	}
	return std::string();
}

std::string Type::getGeneralReg(unsigned char reg)
{
	switch (reg)
	{
	case AX:
		return "AX";
	case CX:
		return "CX";
	case DX:
		return "DX";
	case BX:
		return "BX";
	case SP:
		return "SP";
	case BP:
		return "BP";
	case SI:
		return "SI";
	case DI:
		return "DI";
	}
	return "unkown GeneralReg";
}

std::string Type::getSegementReg(unsigned char reg)
{
	switch (reg)
	{
	case ES:
		return "ES";
	case CS:
		return "CS";
	case SS:
		return "SS";
	case DS:
		return "DS";
	}
	return "unkown SegementReg";
}

std::string Type::getBrIrReg(unsigned char reg)
{
	switch (reg)
	{
	case BXSI:
		return "BX+SI";
	case BXDI:
		return "BX+DI";
	case BPSI:
		return "BP+SI";
	case BPDI:
		return "BP+DI";
	case IRSI:
		return "SI";
	case IRDI:
		return "DI";
	case BRBX:
		return "BX";
	case BRBP:
		return "BP";
	}
	return "unkown BrIrReg";
}

std::string Type::getHex(unsigned char data)
{
	static unsigned char a[] = { "0123456789ABCDEF" };
	std::string ret;
	do
	{
		ret .insert(ret.begin(), a[data % 16]);
		data /= 16;
	} while (data > 0);
	if (ret.size() == 1)
		ret .insert(ret.begin(), '0');
	return ret;
}

std::string Type::getAddress(unsigned char mod, unsigned char r,unsigned char*ptr, unsigned char w)
{
	switch (mod)
	{
	case 3:
		return getReg( w, r);
	case 2:
		return getRegMem2(r, ptr[1], ptr[2]);
	case 1:
		return getRegMem1( r, ptr[1]);
	case 0:
	{
		if (r != BRBP)
			return getRegMem(r);
		else
		{
			return std::string("[") + getHex(ptr[2]) + getHex(ptr[1]) + "]";
		}
	}
		
	}
	return std::string("unkown mod");
}

std::string Type::getReg(unsigned char w,unsigned char reg)
{
	return w == 1 ? getGeneralReg(reg) : getSmallReg(reg);
}

std::string Type::getRegMem( unsigned char rm)
{
	std::string ret;
	ret = "[" + getBrIrReg(rm)+"]";
	return ret;
}

std::string Type::getRegMem1(unsigned char rm, unsigned char off1)
{
	std::string ret;
	ret = "[" + getBrIrReg(rm) + "+" + getHex(off1) + "]";
	return ret;
}

std::string Type::getRegMem2( unsigned char rm, unsigned char off1, unsigned char off2)
{
	std::string ret;
	ret = "[" + getBrIrReg(rm) + "+" + getHex(off2)+getHex(off1) + "]";
	return ret;
}

int Type::getOffset(unsigned char mod, unsigned char rm)
{
	int offset = 1;
	if (mod == 0b11)// reg,reg
	{
		offset = 0;
	}
	else if (mod == 0b10)
		offset = 2;
	else if (mod == 0b01)
		offset = 1;
	else if (mod == 0b00)
	{
		if (rm == BRBP)
			offset = 2;
		else
			offset = 0;
	}
	return offset;
}



bool MovType1::cmp(unsigned char Key)
{
	if (Key >= 0x88 && Key <= 0x8B)
	{
		return true;
	}
	
	return false;
}
/**/
//mod 2位
//00 表示基址变址
//01相对基址变址+1字节偏移
//10相对基址变址+2字节偏移
//11寄存器到寄存器

//w
//1 2字节寄存器
//0 1字节寄存器
//d
//0 到[reg]
//1到reg
std::string MovType1::Decode(const unsigned char* ptr, int& offset)
{
	//unsigned char 

	std::string hex_str;
	std::string ret="mov ";
	key = GetBit(ptr[0], 2, 6);
	d = GetBit(ptr[0], 1, 1);
	w = GetBit(ptr[0], 0, 1);
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1],3,3 );
	rm = GetBit(ptr[1], 0, 3);
	std::string Rm= getAddress(mod, rm, (unsigned char*)ptr, w);;
	std::string Reg= getReg(w, reg);;
	switch (mod)
	{
	case 3:
		offset = 2;
		break;
	case 2:
		offset = 4;
		break;
	case 1:
		offset = 3;
		break;
	case 0:
		offset = rm == BRBP ? 4 : 2;
		break;
	}
	if (d)
	{
		ret += Reg + "," + Rm;
	}
	else
	{
		ret += Rm + "," + Reg;
	}
	return ret;
}

bool MovType2::cmp(unsigned char Key)
{
	if (Key == 0xc7 || Key == 0xc6)
		return true;
	return false;
}
// w 1两字节偏移 0一字节偏移
std::string MovType2::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	rm = GetBit(ptr[1], 0, 3);
	mod = GetBit(ptr[1], 6, 2);
	std::string ret = "mov ";
	std::string hex_str;
	std::string Rm= getAddress(mod,rm,(unsigned char*)(ptr+1),w);
	std::string Reg;
	hex_str = (w == 1 ? getHex(ptr[3]) : "") + getHex(ptr[2]);
	ret += w == 1 ? "word ptr" : "byte ptr";
	
	if (mod == 0)
	{
		ret += Rm+","+hex_str;
		//基址变址 变址表 1/2字节数据
		if (rm!= BRBP)
		{
			offset = w == 1 ? 4 : 3;
		}
		// mov [1234],1234
		else
		{
			offset = w == 1 ? 6: 5;
		}
	}
	else if (mod == 1)
	{
		ret += Rm + "," + hex_str;
		offset = w == 1 ? 5 : 4;
	}
	else if (mod == 2)
	{
		ret += Rm + "," + hex_str;
		offset = w == 1 ? 6 : 5;
	}
	//mov reg ,imm
	else
	{
		Reg = getReg(w, rm);
		ret += Reg + ",";
		ret += hex_str;
		offset = w == 1 ? 4 : 3;
	}

	return ret;
}

bool MovType3::cmp(unsigned char Key)
{
	if (Key >= 0xB0 && Key <= 0xBF)
		return true;
	
	return false;
}
//w 1 2字节立即数 0 1字节立即数 
std::string MovType3::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 3, 1);
	reg = GetBit(ptr[0], 0, 3);
	std::string ret="mov ";
	if (w == 1)
	{
		ret += getGeneralReg(reg)+","+getHex(ptr[2])+getHex(ptr[1]);
		offset = 3;
	}
	else
	{
		ret += getSmallReg(reg) + "," + getHex(ptr[1]) ;
		offset = 2;
	}
	return ret;
}
//内存到累加器
//w =1 ax
//w =0 al
bool MovType4::cmp(unsigned char Key)
{
	if (Key == 0xa1||Key==0xa0)
		return true;
	return false;
}

std::string MovType4::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	std::string ret = "mov ";
	std::string Reg= getReg(w, AX);
	ret += Reg;
	ret += " ,[" + getHex(ptr[2]) + getHex(ptr[1]) + ']';
	offset = 3;
	return ret;
}

bool MovType5::cmp(unsigned char Key)
{
	if (Key == 0xa2 || Key == 0xa3)
		return true;
	return false;
}

std::string MovType5::Decode(const unsigned char* ptr, int& offset)
{
	std::string ret = "mov ";
	w = GetBit(ptr[0], 0, 1);
	std::string Reg= getReg(w, AX);
	if (w == 1)
	{
		ret += '[' + getHex(ptr[2]) + getHex(ptr[1])+"],"+Reg;
		offset = 3;
	}
	else
	{
		ret += '[' + getHex(ptr[1]) + "],al" + Reg;
		offset = 2;
	}
	return ret;
}

bool MovType6::cmp(unsigned char Key)
{
	if (Key == 0x8E)
		return true;
	return false;
}

std::string MovType6::Decode(const unsigned char* ptr, int& offset)
{
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 2);
	rm = GetBit(ptr[1], 0, 3);
	std::string ret = "mov ";
	std::string Reg = getSegementReg(reg);
	std::string Rm = getAddress(mod,rm,(unsigned char*)ptr+1);//= getBrIrReg(rm);
	std::string hex_str;
	ret += Reg + ",";
	ret += Rm;
	offset=2+ getOffset(mod,rm);
	return ret;
}

bool MovType7::cmp(unsigned char Key)
{
	if (Key == 0x8c)
		return true;
	return false;
}

std::string MovType7::Decode(const unsigned char* ptr, int& offset)
{
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 2);
	rm = GetBit(ptr[1], 0, 3);
	std::string ret = "mov ";
	std::string Reg = getSegementReg(reg);
	std::string Rm = getAddress(mod, rm, (unsigned char*)ptr + 1);
	std::string hex_str;
	ret+= Rm + ",";
	offset = getOffset(mod, rm) + 2;
	ret += Reg;
	return ret;	
}
int GetBit(unsigned char num, int n, int m)
{
	return (num >> n) & ((1 << m) - 1);
}
bool XchgType2::cmp(unsigned char Key)
{
	if (Key >= 0x90 && Key <= 0x97)
		return true;
	return false;
}

std::string XchgType2::Decode(const unsigned char* ptr, int& offset)
{
	offset = 1;
	if (ptr[0] == 0x90)
		return "nop";
	reg = GetBit(ptr[0], 0, 3);
	std::string Reg = getGeneralReg(reg);
	std::string ret = "xchg "+Reg+",ax";
	return ret;
}

bool XchgType1::cmp(unsigned char Key)
{
	if (Key >= 0x86 && Key <= 0x87)
		return true;
	return false;
}

std::string XchgType1::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	rm = GetBit(ptr[1], 0, 3);
	reg = GetBit(ptr[1], 3, 3);
	mod = GetBit(ptr[1], 6, 2);
	std::string Reg=getReg(w,reg);
	std::string Rm=getAddress(mod,rm,(unsigned char*)ptr);
	std::string ret = "xchg "+Reg+","+Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;
}

Transfer::Transfer()
{
	mVec = {
PMT(new MovType1()),PMT(new MovType2()),PMT(new MovType3()),
PMT(new MovType4()),PMT(new MovType5()),PMT(new MovType6()),PMT(new MovType7()),
PMT(new XchgType1()),PMT(new XchgType2()),PMT(new PushType1()),PMT(new PushType2()),
PMT(new PushType3()),PMT(new PopType1()),PMT(new PopType2()),PMT(new PopType3()),
PMT(new LeaType()),PMT(new LesType()),PMT(new LdsType()),PMT(new LahfType()),
PMT(new SahfType()),PMT(new InType1()),PMT(new InType2()),PMT(new OutType1()),PMT(new  OutType2()),
PMT(new XlatType()),
	};
}

std::string Transfer::Decode(int index, unsigned char* ptr, int& offset)
{
	int len = mVec.size();
	if (index >= len || index < 0)
	{
		offset = 1;
		return "unkown index";
	}
	return mVec[index]->Decode(ptr, offset);
}

int Transfer::cmp(unsigned char Key)
{
	int len = mVec.size();
	for (int i = 0; i < len; i++)
	{
		if (mVec[i].get()->cmp(Key))
		{
			return i;
		}
	}
	return -1;
}
bool PushType1::cmp(unsigned char Key)
{
	if (Key == 0xff)
		return true;
	return false;
}

std::string PushType1::Decode(const unsigned char* ptr, int& offset)
{
	if (GetBit(ptr[1], 3, 3) != n110)
	{
		offset = 1;
		return "unkown";
	}
	rm = GetBit(ptr[1], 0, 3);
	mod = GetBit(ptr[1], 6, 2);
	std::string Rm = getAddress(mod, rm, (unsigned char*)(ptr + 1));
	std::string ret = "push " + Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;
}

bool PushType2::cmp(unsigned char Key)
{
	if (GetBit(Key,3, 5) == n01010)
		return true;
	return false;
}

std::string PushType2::Decode(const unsigned char* ptr, int& offset)
{
	reg = GetBit(ptr[0], 0, 3);
	std::string ret = "push " + getGeneralReg(reg);
	offset = 1;
	return ret;
}

bool PushType3::cmp(unsigned char Key)
{
	if (GetBit(Key, 0, 3) == n110 && GetBit(Key, 5, 3) == n000)
		return true;
	return false;
}

std::string PushType3::Decode(const unsigned char* ptr, int& offset)
{
	sreg = GetBit(ptr[0], 3, 2);
	std::string ret = "push " + getSegementReg(sreg);
	offset = 1;
	return ret;
}
bool PopType1::cmp(unsigned char Key)
{
	if (Key == 0x8f)
		return true;
	return false;
}

std::string PopType1::Decode(const unsigned char* ptr, int& offset)
{
	if (GetBit(ptr[1], 3, 3) != n000)
	{
		offset = 1;
		return "unkown";
	}
	rm = GetBit(ptr[1], 0, 3);
	mod = GetBit(ptr[1], 6, 2);
	std::string Rm = getAddress(mod, rm, (unsigned char*)(ptr + 1));
	std::string ret = "pop " + Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;
}

bool PopType2::cmp(unsigned char Key)
{
	if (GetBit(Key, 3, 5) == n01011)
		return true;
	return false;
}

std::string PopType2::Decode(const unsigned char* ptr, int& offset)
{
	reg = GetBit(ptr[0], 0, 3);
	std::string ret = "pop " + getGeneralReg(reg);
	offset = 1;
	return ret;
}

bool PopType3::cmp(unsigned char Key)
{
	if (GetBit(Key, 0, 3) == n111 && GetBit(Key, 5, 3) == n000)
		return true;
	return false;
}

std::string PopType3::Decode(const unsigned char* ptr, int& offset)
{
	sreg = GetBit(ptr[0], 3, 2);
	std::string ret = "pop " + getSegementReg(sreg);
	offset = 1;
	return ret;
}

bool XlatType::cmp(unsigned char Key)
{
	if (Key == 0xd7)
		return true;
	return false;
}

std::string XlatType::Decode(const unsigned char* ptr, int& offset)
{
	std::string ret = "xlat";
	offset = 1;
	return ret;
}

bool InType1::cmp(unsigned char Key)
{
	return Key == 0xE4 || Key == 0xE5;
}

std::string InType1::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	std::string ret = "in ";
	ret+=(w == 1 ? "ax," : "al,");
	port = ptr[1];
	ret += getHex(port);
	offset = 2;
	return ret;
}

bool InType2::cmp(unsigned char Key)
{
	return Key == 0xEC || Key == 0xED;
}

std::string InType2::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0],0,1);
	std::string ret = (w == 1 ? "in ax," : "in al,");
	ret += "dx";
	offset = 1;
	return ret;
}

bool OutType1::cmp(unsigned char Key)
{
	return Key == 0xe7 || Key == 0xe6;
}

std::string OutType1::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	std::string ret = "out ";
	port = ptr[1];
	ret += getHex(port);
	ret += (w == 1 ? ",ax" : ",al");
	offset = 2;
	return ret;
}

bool OutType2::cmp(unsigned char Key)
{
	return Key == 0xee || Key == 0xef;
}

std::string OutType2::Decode(const unsigned char* ptr, int& offset)
{
	w = GetBit(ptr[0], 0, 1);
	std::string ret =  "out dx,";
	ret += (w==1?"ax":"al");
	offset = 1;
	return ret;
}

bool LeaType::cmp(unsigned char Key)
{
	return Key == key;
}

std::string LeaType::Decode(const unsigned char* ptr, int& offset)
{
	std::string ret = "lea ";
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 3);
	rm = GetBit(ptr[1], 0, 3);
	std::string Reg = getGeneralReg(reg);
	std::string Rm = getAddress(mod, rm, (unsigned char*)ptr+1);
	ret += Reg + "," + Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;

}

bool LdsType::cmp(unsigned char Key)
{

	return Key== 0xc5;
}

std::string LdsType::Decode(const unsigned char* ptr, int& offset)
{
	std::string ret = "lds ";
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 3);
	rm = GetBit(ptr[1], 0, 3);
	std::string Reg = getGeneralReg(reg);
	std::string Rm = getAddress(mod, rm, (unsigned char*)ptr);
	ret += Reg + "," + Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;
}

bool LesType::cmp(unsigned char Key)
{
	
	return Key==key;
}

std::string LesType::Decode(const unsigned char* ptr, int& offset)
{
	std::string ret = "les ";
	mod = GetBit(ptr[1], 6, 2);
	reg = GetBit(ptr[1], 3, 3);
	rm = GetBit(ptr[1], 0, 3);
	std::string Reg = getGeneralReg(reg);
	std::string Rm = getAddress(mod, rm, (unsigned char*)ptr);
	ret += Reg + "," + Rm;
	offset = 2 + getOffset(mod, rm);
	return ret;
}

bool LahfType::cmp(unsigned char Key)
{
	return Key==0x9f;
}

std::string LahfType::Decode(const unsigned char* ptr, int& offset)
{
	offset = 1;
	return "lahf";
}

bool SahfType::cmp(unsigned char Key)
{

	return Key==0x9e;
}

std::string SahfType::Decode(const unsigned char* ptr, int& offset)
{
	offset = 1;
	return" sahf";
}

bool PushfType::cmp(unsigned char Key)
{
	return Key==0x9c;
}

std::string PushfType::Decode(const unsigned char* ptr, int& offset)
{
	offset = 1;
	return "pushf";
}

bool PopfType::cmp(unsigned char Key)
{
	return Key == 0x9d;
}

std::string PopfType::Decode(const unsigned char* ptr, int& offset)
{
	offset = 1;
	return "popf";
}

MyTransfer.cpp

代码还是比较冗余,尽管优化了一点，但还是有很多地方显得重复,代码测试较少，有bug正常

那个叔叔
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
汇编语言之指令系统(2) :数据运算指令
censorship的博客
03-30 824
数据运算指令数据运算指令数据传送指令通用数据传送指令输入输出指令算数运算指令类型转换指令二进制加法指令 数据运算指令 指令系统是汇编语言学习的基础，上次介绍了操作数寻址指令，这次以x86汇编为基础继续总结数据运算类指令 数据传送指令 通用数据传送指令 （1） MOV 指令 格式： MOV 目标 源 举几个例子： MOV AX 5 ；把立即数传送给寄存器AX MOV AX BX ； 把BX中的...
常用汇编指令汇总 如： POP 把字弹出堆栈
02-29
#### 一、数据传送指令 1. **MOV**：该指令用于将一个字或字节的数据从源位置移动到目标位置。例如，`MOV AX, BX`会将BX寄存器中的内容复制到AX寄存器中。 2. **MOVSX**：这是一种特殊的传送指令，它先对数据进行...
汇编语言02：8086数据传送指令
qq_35933041的博客
10-05 800
汇编语言的数据传送类指令，或是程序内直接传输数据，或是通过堆栈进行程序间数据传输，或是传输标志，或者传送指针，都具有明确的目的性，需要在应用的同时仔细分辨理解。
基于ARM9的汇编指令：数据传送指令，算术运算指令，比较指令和跳转指令
small_is_powerful , small_is_beautiful
04-23 1863
32位汇编指令集大体分为四大类，四大类又细分为13小类：大类1：3种类型的存储器访问指令； 功能：用于控制存储器与寄存器之间的数据传送。 小类1：用于优化的灵活寻址 小类2：用于快速上下文切换 小类3：用于交换数据大类2：3种类型的数据处理指令； 功能：使用片内累加器ALU，桶形移位器和乘法器，对31个寄存器完成高速数据处理操作；大类3：4种类型的分
5.2 汇编语言：标志位测试指令
热门推荐
CSDN
08-22 1万+
汇编语言是一种面向机器的低级语言，用于编写计算机程序。汇编语言与计算机机器语言非常接近，汇编语言程序可以使用符号、助记符等来代替机器语言的二进制码，但最终会被汇编器编译成计算机可执行的机器码。标志位测试指令是汇编语言中用于测试处理器标志位状态的指令。标志位是位于处理器状态寄存器中的一组特殊标志，用于指示上一个运算的结果是否为零、是否进位/借位、是否溢出等等。可以使用标志位测试指令来检查标志位的状态，并在需要时根据标志位状态进行操作。
1. x86-64汇编之数据传送指令MOV
qq_44631972的博客
09-06 2516
这些指令的寄存器可以是16个寄存器有标号部分中的任意一个。寄存器部分的大小必须与指令最后一个字符（‘b’，’w’，‘l’或‘q’）指定的大小匹配大多数情况中，mov指令只会更新目的操作数指定的那些寄存器字节或者内存位置。唯一的例外是movl指令意寄存器作为目的时，它会把该寄存器的高四字节设置为0（x86-64的惯例，任何为寄存器生成32位值得指令都会把该寄存器的高位部分置成0）。首先lea指令是mov指令的变种，据说，lea指令是x86体系结构中，是一条最古老但是从某个方面来讲又是最神奇的指令。
汇编笔记：常用汇编指令及基础
qq_53069972的博客
12-02 201
二进制与十六进制的映射 0 0000 1 0001 2 0010 3 0011 4 0101 5 0101 6 0110 7 0111 8 1000 9 1001 A 1010 B 1011 C 1100 D 1101 E 1110 F 1111
汇编语言：x86汇编指令大全及其注意事项
温柔的博客
05-15 1307
使用最精炼的语言，记录我遇到的所有常用或不常用或极其重要的汇编指令及其注意事项，以方便自己和读者进行查阅，如有错误敬请指证。 Part 1 积少成多，持续更新。（这将会是一个极其漫长的过程） 表格中各条指令的顺序根据笔者所认为的重要或常用程度进行排序，仅供参考。 Part 2 本表格中所涉及的F是指状态寄存器，CF指进位标志位，其它以此类推。 指令 作用 注意事项 示例 mov dest, src 传送指令 1.dest和src不能同时为存储器操作数2.CS不能作为dest3.段寄存器之间不
ARM汇编之数据处理指令
wto9109的博客
10-30 2604
ARM汇编中有关数据处理的相关指令有哪些吗？数据处理指令可以分为哪几类呢？今天，我们来一起探索并回答这些问题。
汇编语言：指令集合
weixin_44627672的博客
10-14 879
有一定编程基础可以很轻松用高级语言编写出程序，但是如何使用低级语言实现同样功能的代码是一个不断练习的过程； 汇编指令集合指令集合循环指令 指令集合 循环指令 LOOP ;每执行一次loop指令CX=CX-1，判断cx是否为零，CX不为零跳转执行，CX为零跳出循环顺序执行下条语句； ...
汇编语言：ARM汇编中的数据处理指令1【ARM汇编系列--指令篇02】
光年之外
08-31 1341
索引：鼠标右键上拉可回来1、写在前面的话2、数据传送指令01 MOV指令02 MVN指令3、算数运算指令01 ADD指令02 SUB指令03 RSB指令04 ADC指令05 SBC指令06 RSC指令 1、写在前面的话 这篇博客主要讲下ARM汇编中的数据处理指令，这类指令包括数据传送指令、算数运算指令、逻辑运算指令、比较指令等，下面详细归类说明下。 2、数据传送指令 01 MOV指令 格式：...
常用ARM指令集及汇编.pdf
08-30
**ARM指令集与汇编详解** ARM（Advanced RISC Machines）指令集是高效能、低功耗的微处理器设计的基础，广泛应用于嵌入式系统、...在实际工作中，结合反汇编工具，可以帮助理解和调试底层代码，提升软件性能和效率。
8086 汇编指令速查手册.doc
03-18
本文档提供了8086汇编指令的速查手册，涵盖了数据传输指令、输入输出端口传送指令、目的地址传送指令、标志传送指令和算术运算指令等多个方面。 数据传输指令： 1. MOV指令：传送字或字节。 2. MOVSX指令：先符号...
x86汇编指令集大全（带注释）.pdf
03-08
1. 通用数据传送指令： - MOV：将数据从一个位置移动到另一个位置。 - MOVSX：符号扩展后传送数据。 - MOVZX：零扩展后传送数据。 - PUSH：将数据压入堆栈。 - POP：从堆栈中弹出数据。 - PUSHA：将16位通用寄存器压...
汇编程序 排序 数据传送
08-28
- 常见的数据传送指令有MOV（移动）、XCHG（交换）等，它们用于在CPU的不同部件之间转移数据。 - 在排序过程中，数据传送用于获取待比较的数值，以及在排序完成后将结果存储回内存。 4. **电话号码排序**： - ...
ARM64的汇编资源
bit_mike的博客
08-17 506
前面的比较通俗，后面的就相当艰深了，特别是关于内存处理的那部分。Perry Kivolowitz的电子书，适合有C语言基础的学习，作者主要是通过C语言和汇编的对比来讲解指令。内容不多，但很实用。最近在写一本ARM64的教材，所以在晚上查找了一下相关资源，都是免费开源的，不包括盗版书籍。这是一本针对ARM32的书，2018年写的，内容全面，可操作性强。有关ARM64仿真器的资源没有列在这里，感兴趣的可以看我以前发的博客。一个退休教授写的书， 其实是学习计算机组成的好的教材。各位朋友有资源推荐的，欢迎留言。
编程的魅力及基础知识和学习路径
最新发布
z86666610的博客
08-19 128
这包括了解计算机如何工作（硬件与软件的关系）、熟悉基本的数据类型（如整数、浮点数、字符串等）、掌握条件语句和循环结构以实现逻辑判断与重复执行、以及理解函数和模块的概念以实现代码的复用和模块化。从古老的汇编语言到现代的Python、Java、C++等高级语言，每一种语言都有其独特的优势和适用场景，为开发者提供了广阔的选择空间。在数字化浪潮席卷全球的今天，编程已不再是计算机科学专业人士的专属领地，它如同一把钥匙，解锁了通往未来世界的无数可能。在这个充满变革的时代，掌握编程技能，就是掌握了开启未来之门的钥匙。
【OCR 学习笔记】二值化——全局阈值方法
TeamLee的博客
08-14 905
该文介绍了图像二值化操作中的全局阈值方法，包括固定阈值方法和Otsu算法（最大类间方差法）。
CVPR2024 | PromptAD: 仅使用正常样本进行小样本异常检测的学习提示
08-16 1068
本文提出的PromptAD模型结构如图2所示。PromptAD建立在VV-CLIP之上，其视觉编码器用于提取全局和局部的特征。本文提出的语义串联（SC）用来设计提示。具体来说，将N个可学习的普通前缀与目标名称串联起来获得普通提示（NPs），然后将这N个普通提示分别与M个手动设置的异常后缀和L个可学习的异常后缀串联，以获得N×M个异常提示（MAPs）和N×L个可学习的异常提示（LAPs）。视觉特征和提示特征用于通过对比损失和本文提出的显式异常边界（EMA）损失来完成提示学习。
全面掌握汇编指令：数据传送与堆栈操作详解
这份资料着重介绍了两个主要的汇编指令类别：数据传送指令和堆栈操作指令，以及一个辅助的指令——数据交换指令。 首先，数据传送指令（如MOVE）是核心部分。它用于在寄存器与寄存器、寄存器与存储器、以及立即数与...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值