Starting implementation of register analysis

2 files changed, 150 insertions, 0 deletions

diff --git a/architecture.cpp b/architecture.cpp
index 83e577b6..60585826 100644
--- a/architecture.cpp
+++ b/architecture.cpp
@@ -138,6 +138,52 @@ char* Architecture::GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags)
 }
 
 
+uint32_t* Architecture::GetFullWidthRegistersCallback(void* ctxt, size_t* count)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	vector<uint32_t> regs = arch->GetFullWidthRegisters();
+	*count = regs.size();
+
+	uint32_t* result = new uint32_t[regs.size()];
+	for (size_t i = 0; i < regs.size(); i++)
+		result[i] = regs[i];
+	return result;
+}
+
+
+uint32_t* Architecture::GetAllRegistersCallback(void* ctxt, size_t* count)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	vector<uint32_t> regs = arch->GetAllRegisters();
+	*count = regs.size();
+
+	uint32_t* result = new uint32_t[regs.size()];
+	for (size_t i = 0; i < regs.size(); i++)
+		result[i] = regs[i];
+	return result;
+}
+
+
+void Architecture::FreeRegisterListCallback(void*, uint32_t* regs)
+{
+	delete[] regs;
+}
+
+
+BNRegisterInfo Architecture::GetRegisterInfoCallback(void* ctxt, uint32_t reg)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	return arch->GetRegisterInfo(reg);
+}
+
+
+uint32_t Architecture::GetStackPointerRegisterCallback(void* ctxt)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	return arch->GetStackPointerRegister();
+}
+
+
 bool Architecture::AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors)
 {
 	Architecture* arch = (Architecture*)ctxt;
@@ -227,6 +273,11 @@ void Architecture::Register(Architecture* arch)
 	callbacks.getRegisterName = GetRegisterNameCallback;
 	callbacks.getFlagName = GetFlagNameCallback;
 	callbacks.getFlagWriteTypeName = GetFlagWriteTypeNameCallback;
+	callbacks.getFullWidthRegisters = GetFullWidthRegistersCallback;
+	callbacks.getAllRegisters = GetAllRegistersCallback;
+	callbacks.freeRegisterList = FreeRegisterListCallback;
+	callbacks.getRegisterInfo = GetRegisterInfoCallback;
+	callbacks.getStackPointerRegister = GetStackPointerRegisterCallback;
 	callbacks.assemble = AssembleCallback;
 	callbacks.isNeverBranchPatchAvailable = IsNeverBranchPatchAvailableCallback;
 	callbacks.isAlwaysBranchPatchAvailable = IsAlwaysBranchPatchAvailableCallback;
@@ -305,6 +356,49 @@ string Architecture::GetFlagWriteTypeName(uint32_t flags)
 }
 
 
+vector<uint32_t> Architecture::GetFullWidthRegisters()
+{
+	return vector<uint32_t>();
+}
+
+
+vector<uint32_t> Architecture::GetAllRegisters()
+{
+	return vector<uint32_t>();
+}
+
+
+BNRegisterInfo Architecture::GetRegisterInfo(uint32_t)
+{
+	BNRegisterInfo result;
+	result.fullWidthRegister = 0;
+	result.offset = 0;
+	result.size = 0;
+	result.extend = NoExtend;
+	return result;
+}
+
+
+uint32_t Architecture::GetStackPointerRegister()
+{
+	return 0;
+}
+
+
+vector<uint32_t> Architecture::GetModifiedRegistersOnWrite(uint32_t reg)
+{
+	size_t count;
+	uint32_t* regs = BNGetModifiedArchitectureRegistersOnWrite(m_arch, reg, &count);
+
+	vector<uint32_t> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(regs[i]);
+
+	BNFreeRegisterList(regs);
+	return result;
+}
+
+
 bool Architecture::Assemble(const std::string&, uint64_t, DataBuffer&, std::string& errors)
 {
 	errors = "Architecture does not implement an assembler.\n";
@@ -437,6 +531,46 @@ string CoreArchitecture::GetFlagWriteTypeName(uint32_t flags)
 }
 
 
+vector<uint32_t> CoreArchitecture::GetFullWidthRegisters()
+{
+	size_t count;
+	uint32_t* regs = BNGetFullWidthArchitectureRegisters(m_arch, &count);
+
+	vector<uint32_t> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(regs[i]);
+
+	BNFreeRegisterList(regs);
+	return result;
+}
+
+
+vector<uint32_t> CoreArchitecture::GetAllRegisters()
+{
+	size_t count;
+	uint32_t* regs = BNGetAllArchitectureRegisters(m_arch, &count);
+
+	vector<uint32_t> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(regs[i]);
+
+	BNFreeRegisterList(regs);
+	return result;
+}
+
+
+BNRegisterInfo CoreArchitecture::GetRegisterInfo(uint32_t reg)
+{
+	return BNGetArchitectureRegisterInfo(m_arch, reg);
+}
+
+
+uint32_t CoreArchitecture::GetStackPointerRegister()
+{
+	return BNGetArchitectureStackPointerRegister(m_arch);
+}
+
+
 bool CoreArchitecture::Assemble(const string& code, uint64_t addr, DataBuffer& result, string& errors)
 {
 	char* errorStr = nullptr;
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index a27ac261..de1855a0 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -811,6 +811,12 @@ namespace BinaryNinja
 		static char* GetRegisterNameCallback(void* ctxt, uint32_t reg);
 		static char* GetFlagNameCallback(void* ctxt, uint32_t flag);
 		static char* GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags);
+		static uint32_t* GetFullWidthRegistersCallback(void* ctxt, size_t* count);
+		static uint32_t* GetAllRegistersCallback(void* ctxt, size_t* count);
+		static void FreeRegisterListCallback(void* ctxt, uint32_t* regs);
+		static BNRegisterInfo GetRegisterInfoCallback(void* ctxt, uint32_t reg);
+		static uint32_t GetStackPointerRegisterCallback(void* ctxt);
+
 		static bool AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors);
 
 		static bool IsNeverBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len);
@@ -846,6 +852,11 @@ namespace BinaryNinja
 		virtual std::string GetRegisterName(uint32_t reg);
 		virtual std::string GetFlagName(uint32_t flag);
 		virtual std::string GetFlagWriteTypeName(uint32_t flags);
+		virtual std::vector<uint32_t> GetFullWidthRegisters();
+		virtual std::vector<uint32_t> GetAllRegisters();
+		virtual BNRegisterInfo GetRegisterInfo(uint32_t reg);
+		virtual uint32_t GetStackPointerRegister();
+		std::vector<uint32_t> GetModifiedRegistersOnWrite(uint32_t reg);
 
 		virtual bool Assemble(const std::string& code, uint64_t addr, DataBuffer& result, std::string& errors);
 
@@ -874,6 +885,11 @@ namespace BinaryNinja
 		virtual std::string GetRegisterName(uint32_t reg) override;
 		virtual std::string GetFlagName(uint32_t flag) override;
 		virtual std::string GetFlagWriteTypeName(uint32_t flags) override;
+		virtual std::vector<uint32_t> GetFullWidthRegisters() override;
+		virtual std::vector<uint32_t> GetAllRegisters() override;
+		virtual BNRegisterInfo GetRegisterInfo(uint32_t reg) override;
+		virtual uint32_t GetStackPointerRegister() override;
+
 		virtual bool Assemble(const std::string& code, uint64_t addr, DataBuffer& result, std::string& errors) override;
 
 		virtual bool IsNeverBranchPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;