adding mips3 support

arch/mips/CMakeLists.txt

@@ -46,3 +46,22 @@ if(BN_INTERNAL_BUILD)
 		LIBRARY_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR}
 		RUNTIME_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR})
 endif()
+
+if (DEFINED FORCE_TEST)
+
+	if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+		add_executable(mipstest mips/mips.c mips/test.c)
+
+		target_compile_definitions(mipstest PRIVATE FORCE_TEST=1)
+
+		set_target_properties(mipstest PROPERTIES
+			CXX_STANDARD 17
+			CXX_VISIBILITY_PRESET hidden
+			CXX_STANDARD_REQUIRED ON
+			VISIBILITY_INLINES_HIDDEN ON
+			POSITION_INDEPENDENT_CODE ON)
+
+		target_link_libraries(mipstest PRIVATE arch_mips)
+	endif()
+endif()
+

arch/mips/arch_mips.cpp

@@ -181,20 +181,25 @@ class MipsArchitecture: public Architecture
 protected:
 	size_t m_bits;
 	BNEndianness m_endian;
+	MipsVersion version_overwrite;
 	uint32_t m_decomposeFlags;
 
 	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_decomposeFlags) != 0)
+		if (m_bits == 64)
+		{
+			version = MIPS_64;
+		}
+
+		if (mips_decompose((uint32_t*)data, maxLen, &result, version, addr, m_endian, m_decomposeFlags) != 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)
 	{
@@ -402,8 +407,8 @@ class MipsArchitecture: public Architecture
 	}
 
 public:
-	MipsArchitecture(const std::string& name, BNEndianness endian, size_t bits, uint32_t decomposeFlags = 0)
-		: Architecture(name), m_bits(bits), m_endian(endian), m_decomposeFlags(decomposeFlags)
+	MipsArchitecture(const std::string& name, BNEndianness endian, size_t bits, MipsVersion version_in, uint32_t decomposeFlags = 0)
+		: Architecture(name), m_bits(bits), m_endian(endian), version_overwrite(version_in), m_decomposeFlags(decomposeFlags)
 	{
 		Ref<Settings> settings = Settings::Instance();
 		uint32_t flag_pseudo_ops = settings->Get<bool>("arch.mips.disassembly.pseudoOps") ? DECOMPOSE_FLAGS_PSEUDO_OP : 0;
@@ -3238,18 +3243,20 @@ extern "C"
 	{
 		InitMipsSettings();
 
-		Architecture* mipsel = new MipsArchitecture("mipsel32", LittleEndian, 32);
-		Architecture* mipseb = new MipsArchitecture("mips32", BigEndian, 32);
-		Architecture* mips64el = new MipsArchitecture("mipsel64", LittleEndian, 64);
-		Architecture* mips64eb = new MipsArchitecture("mips64", BigEndian, 64);
-		Architecture* cnmips64eb = new MipsArchitecture("cavium-mips64", BigEndian, 64, DECOMPOSE_FLAGS_CAVIUM);
+		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* mips64el = new MipsArchitecture("mipsel64", LittleEndian, 64, MIPS_64);
+		Architecture* mips64eb = new MipsArchitecture("mips64", BigEndian, 64, MIPS_64);
+		Architecture* cnmips64eb = new MipsArchitecture("cavium-mips64", BigEndian, 64, MIPS_64, DECOMPOSE_FLAGS_CAVIUM);
 
 		Architecture::Register(mipsel);
 		Architecture::Register(mipseb);
+		Architecture::Register(mips3);
 		Architecture::Register(mips64el);
 		Architecture::Register(mips64eb);
 		Architecture::Register(cnmips64eb);
-
+		
 		/* calling conventions */
 		MipsO32CallingConvention* o32LE = new MipsO32CallingConvention(mipsel);
 		MipsO32CallingConvention* o32BE = new MipsO32CallingConvention(mipseb);
@@ -3258,9 +3265,11 @@ extern "C"
 		MipsN64CallingConvention* n64BEc = new MipsN64CallingConvention(cnmips64eb);
 
 		mipsel->RegisterCallingConvention(o32LE);
-		mipseb->RegisterCallingConvention(o32BE);
 		mipsel->SetDefaultCallingConvention(o32LE);
+		mipseb->RegisterCallingConvention(o32BE);
 		mipseb->SetDefaultCallingConvention(o32BE);
+		mips3->RegisterCallingConvention(o32BE);
+		mips3->SetDefaultCallingConvention(o32BE);
 		mips64el->RegisterCallingConvention(n64LE);
 		mips64el->SetDefaultCallingConvention(n64LE);
 		mips64eb->RegisterCallingConvention(n64BE);
@@ -3272,19 +3281,23 @@ extern "C"
 		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));
 		mips64el->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mips64el));
 		mips64eb->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(mips64eb));
 		cnmips64eb->RegisterCallingConvention(new MipsLinuxRtlResolveCallingConvention(cnmips64eb));
 
 		/* 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());
 		mips64el->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
 		mips64eb->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
 		cnmips64eb->RegisterRelocationHandler("ELF", new MipsElfRelocationHandler());
@@ -3303,6 +3316,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);
 
 		Ref<BinaryViewType> elf = BinaryViewType::GetByName("ELF");
 		if (elf)

arch/mips/mips/test.c

@@ -7,11 +7,12 @@ b mips_disassemble
 
 #include <stdio.h>
 #include <stdint.h>
+#include <unistd.h>
 #include <inttypes.h>
 
 #include "mips.h"
 
-int disassemble(uint32_t insword, uint64_t address, enum MipsVersion version, char *result)
+int disassemble(uint32_t insword, uint64_t address, MipsVersion version, char *result)
 {
 	int rc;
 	Instruction instr;
@@ -40,42 +41,88 @@ int disassemble(uint32_t insword, uint64_t address, enum MipsVersion version, ch
 		exit(-1); \
 	}
 
+void usage(char** av)
+{
+	printf("usage:\n");
+	printf("\t%s [instruction_words]\n", av[0]);
+	printf("\t%s test\n", av[0]);
+	printf("example:\n");
+	printf("\t%s 3c028081 68435a50 24445a50 6c830007\n", av[0]);
+	printf("\t%s test\n", av[0]);
+	exit(-1);
+}
+
 int main(int ac, char **av)
 {
 	char instxt[4096];
+	uint32_t insword = 0;
+	uint64_t baseaddr = 0;
+	int instindex = 0;
+	int c = 0;
+	int version = MIPS_32;
 
-	if(ac == 1) {
-		printf("usage:\n");
-		printf("\t%s [<address>] <instruction_word>\n", av[0]);
-		printf("\t%s <instruction_word>\n", av[0]);
-		printf("\t%s test\n", av[0]);
-		printf("examples:\n");
-		printf("\t%s 0 14E00003\n", av[0]);
-		printf("\t%s 00405A58 14E00003\n", av[0]);
-		printf("\t%s test\n", av[0]);
-		exit(-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;
+		default:
+			usage(av);
+			goto cleanup;
+		}
 	}
 
-	if(ac == 2 && !strcmp(av[1], "test")) {
-		disassemble(0x14E00003, 0, MIPS_32, instxt);
+	if (optind >= ac)
+	{
+		usage(av);
+		goto cleanup;
+	}
+
+	instindex = optind;
+
+	if (ac == 2 && !strcmp(av[1], "test"))
+	{
+		disassemble(0x14E00003, 0, version, instxt);
 		ASSERT(!strcmp(instxt, "bne\t$a3, $zero, 0x10"));
-		disassemble(0x14E00003, 0x405a58, MIPS_32, instxt);
+		disassemble(0x14E00003, 4, version, instxt);
 		ASSERT(!strcmp(instxt, "bne\t$a3, $zero, 0x405a68"));
 		exit(0);
 	}
 
-	uint64_t address = 0;
-	uint32_t insword = 0;
-	if(ac == 2) {
-		address = 0;
-		insword = strtoul(av[1], NULL, 16);
-	}
-	else if(ac == 3) {
-		address = strtoul(av[1], NULL, 16);
-		insword = strtoul(av[2], NULL, 16);
-	}
+	while (instindex < ac)
+	{
+		insword = strtoul(av[instindex], NULL, 16);
 
-	if(0 == disassemble(insword, address, MIPS_32, instxt)) {
-		printf("%08" PRIX64 ": %08X %s\n", address, insword, instxt);
+		if (0 == disassemble(insword, baseaddr, version, instxt))
+		{
+			printf("%08llX: %08X %s\n", baseaddr, insword, instxt);
+		}
+		else
+		{
+			printf("%08llX: %08X ??\n", baseaddr, insword);
+		}
+
+		baseaddr += 4;
+		instindex++;
 	}
+
+cleanup:
+	return 0;
 }