Started with some simulation to determine 'step into' symbol lookup

IDEHelper/Compiler/BfSystem.cpp

@@ -2992,15 +2992,18 @@ BfTypeDef* BfSystem::GetCombinedPartial(BfTypeDef* typeDef)
 {
 	if ((!typeDef->mIsPartial) || (typeDef->mIsCombinedPartial))
 		return typeDef;
-		
+
-	auto itr = mTypeDefs.TryGet(typeDef->mFullName);
+	bool foundPartial = false;
+	BfTypeDef* checkTypeDef = typeDef;
+	auto itr = mTypeDefs.TryGet(checkTypeDef->mFullName);
 	do
 	{
-		BF_ASSERT(typeDef->mIsPartial);
+		if (checkTypeDef == typeDef)
-		typeDef = *itr;
+			foundPartial = true;
+		checkTypeDef = *itr;
 		itr.MoveToNextHashMatch();
-	} while (!typeDef->mIsCombinedPartial);
+	} while ((!checkTypeDef->mIsCombinedPartial) || (!foundPartial));
-	return typeDef;
+	return checkTypeDef;
 }
 
 BfTypeDef* BfSystem::GetOuterTypeNonPartial(BfTypeDef* typeDef)

IDEHelper/WinDebugger.cpp

@@ -11710,15 +11710,16 @@ String WinDebugger::FindLineCallAddresses(intptr inAddress)
 				if (!mDebugTarget->DecodeInstruction(addr, &inst))
 					break;
 
+				*registers.GetPCRegisterRef() = addr;
 				if (inst.IsCall())
 				{
 					bool addSymbol = true;
 
 					if (addr < (addr_target)inAddress)
 						callAddresses += "-";
-					callAddresses += EncodeDataPtr(addr, false);
+					callAddresses += EncodeDataPtr(addr, false);					
 
-					addr_target targetAddr = inst.GetTarget(&registers);
+					addr_target targetAddr = inst.GetTarget(this, &registers);
 					if (targetAddr != 0)
 					{
 						String outSymbol;
@@ -11784,6 +11785,7 @@ String WinDebugger::FindLineCallAddresses(intptr inAddress)
 						callAddresses += "\n";
 				}
 
+				inst.PartialSimulate(this, &registers);
 				addr += inst.GetLength();
 			}
 		};

IDEHelper/X64.cpp

@@ -520,10 +520,14 @@ bool X64Instr::GetIndexRegisterAndOffset(int* outRegister, int* outOffset)
 	if ((form == llvm::X86II::MRMDestMem) || (form == llvm::X86II::MRMSrcMem) ||
 		((form >= llvm::X86II::MRM0m) && (form <= llvm::X86II::MRM7m)))
 	{
-		auto baseReg = mMCInst.getOperand(llvm::X86::AddrBaseReg);
+		int regOffset = 0;
-		auto scaleAmt = mMCInst.getOperand(llvm::X86::AddrScaleAmt);
+		if (form == llvm::X86II::MRMSrcMem)
-		auto indexReg = mMCInst.getOperand(llvm::X86::AddrIndexReg);
+			regOffset = 1;
-		auto addrDisp = mMCInst.getOperand(llvm::X86::AddrDisp);
+
+		auto baseReg = mMCInst.getOperand(regOffset + llvm::X86::AddrBaseReg);
+		auto scaleAmt = mMCInst.getOperand(regOffset + llvm::X86::AddrScaleAmt);
+		auto indexReg = mMCInst.getOperand(regOffset + llvm::X86::AddrIndexReg);
+		auto addrDisp = mMCInst.getOperand(regOffset + llvm::X86::AddrDisp);
 
 		/*bool a = baseReg.isReg();
 		bool b = scaleAmt.isImm();
@@ -695,19 +699,35 @@ void X64Instr::MarkRegsUsed(Array<RegForm>& regsUsed, bool overrideForm)
 	}
 }
 
-uint64 X64Instr::GetTarget(X64CPURegisters* registers)
+uint64 X64Instr::GetTarget(Debugger* debugger, X64CPURegisters* registers)
 {
 	const MCInstrDesc &instDesc = mX64->mInstrInfo->get(mMCInst.getOpcode());
 
 	if (mMCInst.getNumOperands() < 1)
 		return 0;
 
+	/*if ((debugger != NULL) && (registers != NULL))
+	{
+		int regNum = 0;
+		int offset = 0;
+		if (GetIndexRegisterAndOffset(&regNum, &offset))
+		{
+			uint64 addr = registers->mIntRegsArray[regNum] + offset;
+			uint64 val = 0;
+			debugger->ReadMemory(addr, 8, &val);
+			return val;
+		}
+	}*/
+
 	int opIdx = 0;
 	auto operand = mMCInst.getOperand(0);
-	if ((instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY))
+	if (mMCInst.getNumOperands() > 4)
 	{
-		opIdx = 4;
+		if ((instDesc.OpInfo[0].OperandType == MCOI::OPERAND_REGISTER) && (instDesc.OpInfo[4].OperandType == MCOI::OPERAND_MEMORY))
-		operand = mMCInst.getOperand(opIdx);
+		{
+			opIdx = 4;
+			operand = mMCInst.getOperand(opIdx);
+		}
 	}
 
 	if (operand.isImm())
@@ -720,6 +740,72 @@ uint64 X64Instr::GetTarget(X64CPURegisters* registers)
 	return 0;
 }
 
+bool X64Instr::PartialSimulate(Debugger* debugger, X64CPURegisters* registers)
+{
+//	const MCInstrDesc &instDesc = mX64->mInstrInfo->get(mMCInst.getOpcode());
+//
+//	for (int i = 0; i < instDesc.NumOperands; i++)
+//	{
+//		auto regInfo = mMCInst.getOperand(i);
+//		NOP;
+//	}
+//
+//	if (instDesc.getOpcode() == X86::MOV64rm)
+//	{
+//		auto form = (instDesc.TSFlags & llvm::X86II::FormMask);
+//
+//		if ((form == llvm::X86II::MRMSrcMem) && (instDesc.NumOperands == 6))
+//		{			
+//			auto destReg = mMCInst.getOperand(llvm::X86::AddrBaseReg);
+//			if (destReg.isReg())
+//			{				
+//				int regNum = 0;
+//				int offset = 0;
+//				if (GetIndexRegisterAndOffset(&regNum, &offset))
+//				{
+//					uint64 addr = registers->mIntRegsArray[regNum] + offset;
+//					uint64 val = 0;
+//					debugger->ReadMemory(addr, 8, &val);
+//					
+//					switch (destReg.getReg())
+//					{
+//
+//					}
+//				}
+//			}
+//		}
+//
+//// 		if ((form == llvm::X86II::MRMDestMem) || (form == llvm::X86II::MRMSrcMem) ||
+//// 			((form >= llvm::X86II::MRM0m) && (form <= llvm::X86II::MRM7m)))
+//// 		{
+//// 		}		
+//	}
+//
+//	if (instDesc.getOpcode() == X86::XOR8rr)
+//	{
+//		if (instDesc.NumOperands == 3)
+//		{
+//			auto destReg = mMCInst.getOperand(0);
+//			auto srcReg = mMCInst.getOperand(1);
+//
+//			if ((destReg.isReg()) && (srcReg.isReg()))
+//			{
+//				if (destReg.getReg() == srcReg.getReg())
+//				{					
+//					switch (destReg.getReg())
+//					{
+//					case X86::AL:
+//						((uint8*)&registers->mIntRegs.rax)[0] = 0;
+//						break;
+//					}
+//				}
+//			}
+//		}
+//	}
+
+	return false;
+}
+
 X64CPU::X64CPU() :
 	mWarningStream(mWarningString),
 	mCommentStream(mCommentString)

IDEHelper/X64.h

@@ -466,7 +466,8 @@ public:
 	int GetJmpState(int flags);
 	void MarkRegsUsed(Array<RegForm>& regsUsed, bool overrideForm);
 
-	uint64 GetTarget(X64CPURegisters* registers = NULL);
+	uint64 GetTarget(Debugger* debugger = NULL, X64CPURegisters* registers = NULL);
+	bool PartialSimulate(Debugger* debugger, X64CPURegisters* registers);
 };
 
 

IDEHelper/X86.cpp

@@ -374,7 +374,7 @@ void X86Instr::MarkRegsUsed(Array<RegForm>& regsUsed, bool overrideForm)
 	}
 }
 
-uint32 X86Instr::GetTarget(X86CPURegisters* registers)
+uint32 X86Instr::GetTarget(Debugger* debugger, X86CPURegisters* registers)
 {	
 	const MCInstrDesc &instDesc = mX86->mInstrInfo->get(mMCInst.getOpcode());
 	
@@ -388,7 +388,7 @@ uint32 X86Instr::GetTarget(X86CPURegisters* registers)
 		opIdx = 4;
 		operand = mMCInst.getOperand(opIdx);
 	}
-
+	
 	if (operand.isImm())
 	{
 		auto targetAddr = (uint32)operand.getImm();
@@ -402,6 +402,11 @@ uint32 X86Instr::GetTarget(X86CPURegisters* registers)
 	return 0;
 }
 
+bool X86Instr::PartialSimulate(Debugger* debugger, X86CPURegisters* registers)
+{
+	return false;
+}
+
 X86CPU::X86CPU() :
 	mWarningStream(mWarningString),
 	mCommentStream(mCommentString)

IDEHelper/X86.h

@@ -303,7 +303,8 @@ public:
 	int GetJmpState(int flags);
 	void MarkRegsUsed(Array<RegForm>& regsUsed, bool overrideForm);
 
-	uint32 GetTarget(X86CPURegisters* registers = NULL);
+	uint32 GetTarget(Debugger* debugger = NULL, X86CPURegisters* registers = NULL);
+	bool PartialSimulate(Debugger* debugger, X86CPURegisters* registers);
 };
 
 class X86CPU