adding test updates and new architecture mips3 to disassembly

Author: v1X3Q0

arch/mips/arch_mips.cpp

@@ -182,19 +182,24 @@ class MipsArchitecture: public Architecture
 	size_t m_bits;
 	BNEndianness m_endian;
 	uint32_t m_enablePseudoOps;
+	MipsVersion version_overwrite;
 
 	virtual bool Disassemble(const uint8_t* data, uint64_t addr, size_t maxLen, Instruction& result)
 	{
+		MipsVersion version = version_overwrite;
+
 		memset(&result, 0, sizeof(result));
-		if (mips_decompose((uint32_t*)data, maxLen,  &result, m_bits == 64 ? MIPS_64 : MIPS_32, addr, m_endian, m_enablePseudoOps) != 0)
+		if (m_bits == 64)
+		{
+			version = MIPS_64;
+		}
+
+		if (mips_decompose((uint32_t*)data, maxLen, &result, version, addr, m_endian, m_enablePseudoOps) != 0)
 			return false;
 		return true;
 	}
 
-	virtual size_t GetAddressSize() const override
-	{
-		return m_bits / 8;
-	}
+	virtual size_t GetAddressSize() const override { return m_bits / 8; }
 
 	size_t InstructionHasBranchDelay(const Instruction& instr)
 	{
@@ -383,7 +388,8 @@ class MipsArchitecture: public Architecture
 	}
 
 public:
-	MipsArchitecture(const std::string& name, BNEndianness endian, size_t bits): Architecture(name), m_bits(bits), m_endian(endian)
+	MipsArchitecture(const std::string& name, BNEndianness endian, size_t bits, MipsVersion version_in):
+		Architecture(name), m_bits(bits), m_endian(endian), version_overwrite(version_in)
 	{
 		Ref<Settings> settings = Settings::Instance();
 		m_enablePseudoOps = settings->Get<bool>("arch.mips.disassembly.pseudoOps") ? 1 : 0;
@@ -2228,12 +2234,14 @@ extern "C"
 	{
 		InitMipsSettings();
 
-		Architecture* mipsel = new MipsArchitecture("mipsel32", LittleEndian, 32);
-		Architecture* mipseb = new MipsArchitecture("mips32", BigEndian, 32);
-		Architecture* mips64eb = new MipsArchitecture("mips64", BigEndian, 64);
+		Architecture* mipsel = new MipsArchitecture("mipsel32", LittleEndian, 32, MIPS_32);
+		Architecture* mipseb = new MipsArchitecture("mips32", BigEndian, 32, MIPS_32);
+		Architecture* mips3 = new MipsArchitecture("mips3", BigEndian, 32, MIPS_3);
+		Architecture* mips64eb = new MipsArchitecture("mips64", BigEndian, 64, MIPS_64);
 
 		Architecture::Register(mipsel);
 		Architecture::Register(mipseb);
+		Architecture::Register(mips3);
 		Architecture::Register(mips64eb);
 
 		/* calling conventions */
@@ -2242,27 +2250,33 @@ extern "C"
 		MipsN64CallingConvention* n64BE = new MipsN64CallingConvention(mips64eb);
 
 		mipsel->RegisterCallingConvention(o32LE);
-		mipseb->RegisterCallingConvention(o32BE);
 		mipsel->SetDefaultCallingConvention(o32LE);
+		mipseb->RegisterCallingConvention(o32BE);
 		mipseb->SetDefaultCallingConvention(o32BE);
+		mips3->RegisterCallingConvention(o32BE);
+		mips3->SetDefaultCallingConvention(o32BE);
 		mips64eb->RegisterCallingConvention(n64BE);
 		mips64eb->SetDefaultCallingConvention(n64BE);
 
 		MipsLinuxSyscallCallingConvention* linuxSyscallLE = new MipsLinuxSyscallCallingConvention(mipsel);
 		MipsLinuxSyscallCallingConvention* linuxSyscallBE = new MipsLinuxSyscallCallingConvention(mipseb);
 		mipsel->RegisterCallingConvention(linuxSyscallLE);
 		mipseb->RegisterCallingConvention(linuxSyscallBE);
+		mips3->RegisterCallingConvention(linuxSyscallBE);
 
 		mipsel->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mipsel));
 		mipseb->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mipseb));
+		mips3->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mips3));
 		mips64eb->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mips64eb));
 
 		/* function recognizers */
 		mipsel->RegisterFunctionRecognizer(new MipsImportedFunctionRecognizer());
 		mipseb->RegisterFunctionRecognizer(new MipsImportedFunctionRecognizer());
+		mips3->RegisterFunctionRecognizer(new MipsImportedFunctionRecognizer());
 
 		mipsel->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
 		mipseb->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
+		mips3->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
 		mips64eb->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
 
 		// Register the architectures with the binary format parsers so that they know when to use
@@ -2278,6 +2292,7 @@ extern "C"
 		BinaryViewType::RegisterArchitecture("ELF", ARCH_ID_MIPS64, BigEndian, mips64eb);
 		BinaryViewType::RegisterArchitecture("ELF", ARCH_ID_MIPS32, LittleEndian, mipsel);
 		BinaryViewType::RegisterArchitecture("ELF", ARCH_ID_MIPS32, BigEndian, mipseb);
+		BinaryViewType::RegisterArchitecture("ELF", ARCH_ID_MIPS32, BigEndian, mips3);
 		BinaryViewType::RegisterArchitecture("PE", 0x166, LittleEndian, mipsel);
 		return true;
 	}

arch/mips/mips/test.c

@@ -58,11 +58,27 @@ int main(int ac, char **av)
 	uint64_t baseaddr = 0;
 	int instindex = 0;
 	int c = 0;
+	int version = MIPS_32;
 
-	while ((c = getopt(ac, av, "a:")) != -1)
+	while ((c = getopt(ac, av, "klmnoa:")) != -1)
 	{
 		switch (c)
 		{
+		case 'k':
+			version = MIPS_64;
+			break;
+		case 'l':
+			version = MIPS_1;
+			break;
+		case 'm':
+			version = MIPS_2;
+			break;
+		case 'n':
+			version = MIPS_3;
+			break;
+		case 'o':
+			version = MIPS_4;
+			break;
 		case 'a':
 			baseaddr = strtoull(optarg, NULL, 0x10);
 			break;
@@ -82,9 +98,9 @@ int main(int ac, char **av)
 
 	if (ac == 2 && !strcmp(av[1], "test"))
 	{
-		disassemble(0x14E00003, 0, MIPS_32, instxt);
+		disassemble(0x14E00003, 0, version, instxt);
 		ASSERT(!strcmp(instxt, "bne\t$a3, $zero, 0x10"));
-		disassemble(0x14E00003, 4, MIPS_32, instxt);
+		disassemble(0x14E00003, 4, version, instxt);
 		ASSERT(!strcmp(instxt, "bne\t$a3, $zero, 0x405a68"));
 		exit(0);
 	}
@@ -93,7 +109,7 @@ int main(int ac, char **av)
 	{
 		insword = strtoul(av[instindex], NULL, 16);
 
-		if (0 == disassemble(insword, baseaddr, MIPS_32, instxt))
+		if (0 == disassemble(insword, baseaddr, version, instxt))
 		{
 			printf("%08llX: %08X %s\n", baseaddr, insword, instxt);
 		}