Add notion of instruction length

Author: noone

arch/powerpc/arch_ppc.cpp

@@ -340,12 +340,22 @@ class PowerpcArchitecture: public Architecture
 
 	bool FillInstruction(Instruction* instruction, const uint8_t* data, size_t length, uint64_t address)
 	{
-		uint32_t word32 = *(const uint32_t *) data;
+		switch (length)
+		{
+			case 4:
+			{
+				uint32_t word32 = *(const uint32_t *) data;
 
-		if (endian == BigEndian)
-			word32 = bswap32(word32);
+				if (endian == BigEndian)
+					word32 = bswap32(word32);
 
-		return Decompose(instruction, word32, address, decodeFlags);
+				return Decompose32(instruction, word32, address, decodeFlags);
+			}
+
+			default:
+				MYLOG("FillInstruction: unrecognized length %d", length);
+				return false;
+		}
 	}
 
 	/* think "GetInstructionBranchBehavior()"
@@ -361,17 +371,17 @@ class PowerpcArchitecture: public Architecture
 	virtual bool GetInstructionInfo(const uint8_t* data, uint64_t addr,
 		size_t maxLen, InstructionInfo& result) override
 	{
-		Instruction instruction;
-
-		if (maxLen < 4)
+		size_t instructionLength = GetInstructionLength(data, maxLen, decodeFlags);
+		if (instructionLength == 0)
 		{
-			MYLOG("ERROR: need at least 4 bytes\n");
+			MYLOG("ERROR: not enough bytes for instruction\n");
 			return false;
 		}
 
-		result.length = 4;
+		result.length = instructionLength;
 
-		if (!FillInstruction(&instruction, data, maxLen, addr))
+		Instruction instruction;
+		if (!FillInstruction(&instruction, data, instructionLength, addr))
 		{
 			MYLOG("ERROR: FillInstruction()\n");
 			return false;
@@ -540,15 +550,15 @@ class PowerpcArchitecture: public Architecture
 		const char* mnemonic = NULL;
 
 		//MYLOG("%s()\n", __func__);
-
-		if (len < 4)
+		size_t instructionLength = GetInstructionLength(data, len, decodeFlags);
+		if (instructionLength == 0)
 		{
-			MYLOG("ERROR: need at least 4 bytes\n");
+			MYLOG("ERROR: not enough bytes for instruction\n");
 			return false;
 		}
 
-		len = 4;
-		if (!FillInstruction(&instruction, data, len, addr))
+		len = instructionLength;
+		if (!FillInstruction(&instruction, data, instructionLength, addr))
 		{
 			MYLOG("ERROR: FillInstruction()\n");
 			return false;
@@ -740,27 +750,24 @@ class PowerpcArchitecture: public Architecture
 
 	virtual bool GetInstructionLowLevelIL(const uint8_t* data, uint64_t addr, size_t& len, LowLevelILFunction& il) override
 	{
-		Instruction instruction;
-		bool rc = false;
-
-		if (len < 4)
+		size_t instructionLength = GetInstructionLength(data, len, decodeFlags);
+		if (instructionLength == 0)
 		{
-			MYLOG("ERROR: need at least 4 bytes\n");
-			goto cleanup;
+			MYLOG("ERROR: not enough bytes for instruction\n");
+			return false;
 		}
 
-		if (!FillInstruction(&instruction, data, len, addr))
+		len = instructionLength;
+
+		Instruction instruction;
+		if (!FillInstruction(&instruction, data, instructionLength, addr))
 		{
 			MYLOG("ERROR: FillInstruction()\n");
 			il.AddInstruction(il.Undefined());
-			goto cleanup;
+			return false;
 		}
 
-		rc = GetLowLevelILForPPCInstruction(this, il, &instruction, addr);
-		len = 4;
-
-		cleanup:
-		return rc;
+		return GetLowLevelILForPPCInstruction(this, il, &instruction, addr);
 	}
 
 	virtual size_t GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,

arch/powerpc/decode/decode.c

@@ -9,6 +9,15 @@
 //    Implementations of the PowerPC^TM Architecture" by Freescale/NXP
 //
 
+size_t GetInstructionLength(const uint8_t* data, size_t data_length, uint32_t decodeFlags)
+{
+	(void)data;
+	(void)data_length;
+	(void)decodeFlags;
+
+	return 4;
+}
+
 static InstructionId DecodeAltivec0x04(uint32_t word32, uint32_t decodeFlags)
 {
 	uint32_t subop = word32 & 0x3f;
@@ -5429,7 +5438,7 @@ static InstructionId Decode0x3F(uint32_t word32, uint32_t flags)
 	return true;
 }
 
-static InstructionId Decode(uint32_t word32, uint32_t decodeFlags)
+static InstructionId Decode32(uint32_t word32, uint32_t decodeFlags)
 {
 	uint32_t a = GetA(word32);
 
@@ -5754,14 +5763,14 @@ static InstructionId Decode(uint32_t word32, uint32_t decodeFlags)
 	}
 }
 
-bool Decompose(Instruction* instruction, uint32_t word32, uint64_t address, uint32_t flags)
+bool Decompose32(Instruction* instruction, uint32_t word32, uint64_t address, uint32_t flags)
 {
 	memset(instruction, 0, sizeof *instruction);
 
-	instruction->id = Decode(word32, flags);
+	instruction->id = Decode32(word32, flags);
 	if (instruction->id == PPC_ID_INVALID)
 		return false;
 
-	FillOperands(instruction, word32, address);
+	FillOperands32(instruction, word32, address);
 	return true;
 }

arch/powerpc/decode/decode.h

@@ -1647,7 +1647,10 @@ extern "C" {
 	typedef struct Instruction Instruction;
 #endif
 
-	bool Decompose(Instruction* instruction, uint32_t word32, uint64_t address, uint32_t flags);
+	// returns 0 if data_length is too small to tell
+	size_t GetInstructionLength(const uint8_t* data, size_t data_length, uint32_t flags);
+
+	bool Decompose32(Instruction* instruction, uint32_t word32, uint64_t address, uint32_t flags);
 	void FillBcxOperands(OperandsList* bcx, const Instruction* instruction);
 	void FillBcctrxOperands(OperandsList* bcctrx, const Instruction* instruction);
 	void FillBclrxOperands(OperandsList* bclrx, const Instruction* instruction);

arch/powerpc/decode/operands.c

@@ -310,7 +310,7 @@ static void PushAltivecVS(Instruction* instruction, uint32_t word32)
 	PushRegister(instruction, PPC_OP_REG_AV_VS, AltivecVr(vs));
 }
 
-void FillOperands(Instruction* instruction, uint32_t word32, uint64_t address)
+void FillOperands32(Instruction* instruction, uint32_t word32, uint64_t address)
 {
 	switch (instruction->id)
 	{

arch/powerpc/decode/priv.h

@@ -24,4 +24,4 @@ uint32_t GetSH(uint32_t word32);
 uint32_t GetSH64(uint32_t word32);
 uint32_t GetMX64(uint32_t word32);
 
-void FillOperands(Instruction* instruction, uint32_t word32, uint64_t address);
+void FillOperands32(Instruction* instruction, uint32_t word32, uint64_t address);