Add architecture plugin type, x86 plugin, and get ready for threads

5 files changed, 217 insertions, 67 deletions

diff --git a/api.pro b/api.pro
index 449c53d0..e53097d6 100644
--- a/api.pro
+++ b/api.pro
@@ -18,7 +18,8 @@ SOURCES += \
     binaryviewtype.cpp \
     binaryreader.cpp \
     binarywriter.cpp \
-    transform.cpp
+    transform.cpp \
+	architecture.cpp
 
 HEADERS += binaryninjaapi.h
 unix {
diff --git a/architecture.cpp b/architecture.cpp
new file mode 100644
index 00000000..60fa4efa
--- /dev/null
+++ b/architecture.cpp
@@ -0,0 +1,95 @@
+#include "binaryninjaapi.h"
+
+using namespace BinaryNinja;
+using namespace std;
+
+
+InstructionInfo::InstructionInfo()
+{
+	length = 0;
+	branchCount = 0;
+}
+
+
+void InstructionInfo::AddBranch(BNBranchType type, uint64_t target)
+{
+	if (branchCount >= BN_MAX_INSTRUCTION_BRANCHES)
+		return;
+	branchType[branchCount] = type;
+	branchTarget[branchCount++] = target;
+}
+
+
+Architecture::Architecture(BNArchitecture* arch): m_arch(arch)
+{
+}
+
+
+Architecture::Architecture(const string& name): m_nameForRegister(name)
+{
+}
+
+
+bool Architecture::GetInstructionInfoCallback(void* ctxt, BNBinaryView* data, uint64_t addr, BNInstructionInfo* result)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
+
+	InstructionInfo info;
+	bool ok = arch->GetInstructionInfo(view, addr, info);
+	*result = info;
+	return ok;
+}
+
+
+void Architecture::Register(Architecture* arch)
+{
+	BNCustomArchitecture callbacks;
+	callbacks.context = arch;
+	callbacks.getInstructionInfo = GetInstructionInfoCallback;
+	arch->m_arch = BNRegisterArchitecture(arch->m_nameForRegister.c_str(), &callbacks);
+}
+
+
+Ref<Architecture> Architecture::GetByName(const string& name)
+{
+	BNArchitecture* arch = BNGetArchitectureByName(name.c_str());
+	if (!arch)
+		return nullptr;
+	return new CoreArchitecture(arch);
+}
+
+
+vector<Ref<Architecture>> Architecture::GetList()
+{
+	BNArchitecture** archs;
+	size_t count;
+	archs = BNGetArchitectureList(&count);
+
+	vector<Ref<Architecture>> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(new CoreArchitecture(BNNewArchitectureReference(archs[i])));
+
+	BNFreeArchitectureList(archs, count);
+	return result;
+}
+
+
+string Architecture::GetName() const
+{
+	char* name = BNGetArchitectureName(m_arch);
+	string result = name;
+	BNFreeString(name);
+	return result;
+}
+
+
+CoreArchitecture::CoreArchitecture(BNArchitecture* arch): Architecture(arch)
+{
+}
+
+
+bool CoreArchitecture::GetInstructionInfo(BinaryView* view, uint64_t addr, InstructionInfo& result)
+{
+	return BNGetInstructionInfo(m_arch, view->GetViewObject(), addr, &result);
+}
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index 06c4c8c0..dbbd4b25 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -285,7 +285,6 @@ namespace BinaryNinja
 		Ref<FileMetadata> m_file;
 
 		BinaryView(FileMetadata* file);
-		BinaryView(BNBinaryView* view);
 
 	private:
 		static size_t ReadCallback(void* ctxt, void* dest, uint64_t offset, size_t len);
@@ -298,7 +297,20 @@ namespace BinaryNinja
 		static bool IsExecutableCallback(void* ctxt);
 		static bool SaveCallback(void* ctxt, BNFileAccessor* file);
 
+		virtual size_t PerformRead(void* dest, uint64_t offset, size_t len) { (void)dest; (void)offset; (void)len; return 0; }
+		virtual size_t PerformWrite(uint64_t offset, const void* data, size_t len) { (void)offset; (void)data; (void)len; return 0; }
+		virtual size_t PerformInsert(uint64_t offset, const void* data, size_t len) { (void)offset; (void)data; (void)len; return 0; }
+		virtual size_t PerformRemove(uint64_t offset, uint64_t len) { (void)offset; (void)len; return 0; }
+
+		virtual BNModificationStatus PerformGetModification(uint64_t offset) { (void)offset; return Original; }
+		virtual uint64_t PerformGetStart() const { return 0; }
+		virtual uint64_t PerformGetLength() const { return 0; }
+		virtual bool PerformIsExecutable() const { return false; }
+
+		virtual bool PerformSave(FileAccessor* file) { (void)file; return false; }
+
 	public:
+		BinaryView(BNBinaryView* view);
 		virtual ~BinaryView();
 
 		FileMetadata* GetFile() const { return m_file; }
@@ -317,54 +329,34 @@ namespace BinaryNinja
 		uint64_t GetCurrentOffset();
 		bool Navigate(const std::string& view, uint64_t offset);
 
-		virtual size_t Read(void* dest, uint64_t offset, size_t len) = 0;
+		size_t Read(void* dest, uint64_t offset, size_t len);
 		DataBuffer ReadBuffer(uint64_t offset, size_t len);
 
-		virtual size_t Write(uint64_t offset, const void* data, size_t len) { (void)offset; (void)data; (void)len; return 0; }
+		size_t Write(uint64_t offset, const void* data, size_t len);
 		size_t WriteBuffer(uint64_t offset, const DataBuffer& data);
 
-		virtual size_t Insert(uint64_t offset, const void* data, size_t len) { (void)offset; (void)data; (void)len; return 0; }
+		size_t Insert(uint64_t offset, const void* data, size_t len);
 		size_t InsertBuffer(uint64_t offset, const DataBuffer& data);
 
-		virtual size_t Remove(uint64_t offset, uint64_t len) { (void)offset; (void)len; return 0; }
+		size_t Remove(uint64_t offset, uint64_t len);
 
-		virtual BNModificationStatus GetModification(uint64_t offset) { (void)offset; return Original; }
+		BNModificationStatus GetModification(uint64_t offset);
 		std::vector<BNModificationStatus> GetModification(uint64_t offset, size_t len);
 
-		virtual uint64_t GetStart() const { return 0; }
+		uint64_t GetStart() const;
 		uint64_t GetEnd() const;
-		virtual uint64_t GetLength() const = 0;
+		uint64_t GetLength() const;
 
-		virtual bool IsExecutable() const { return false; }
+		bool IsExecutable() const;
 
-		virtual bool Save(FileAccessor* file) { (void)file; return false; }
+		bool Save(FileAccessor* file);
 		bool Save(const std::string& path);
 
 		void RegisterNotification(BinaryDataNotification* notify);
 		void UnregisterNotification(BinaryDataNotification* notify);
 	};
 
-	class CoreBinaryView: public BinaryView
-	{
-	public:
-		CoreBinaryView(BNBinaryView* view);
-
-		virtual size_t Read(void* dest, uint64_t offset, size_t len) override;
-		virtual size_t Write(uint64_t offset, const void* data, size_t len) override;
-		virtual size_t Insert(uint64_t offset, const void* data, size_t len) override;
-		virtual size_t Remove(uint64_t offset, uint64_t len) override;
-
-		virtual BNModificationStatus GetModification(uint64_t offset) override;
-
-		virtual uint64_t GetStart() const override;
-		virtual uint64_t GetLength() const override;
-
-		virtual bool IsExecutable() const override;
-
-		virtual bool Save(FileAccessor* file) override;
-	};
-
-	class BinaryData: public CoreBinaryView
+	class BinaryData: public BinaryView
 	{
 	public:
 		BinaryData(FileMetadata* file);
@@ -374,6 +366,8 @@ namespace BinaryNinja
 		BinaryData(FileMetadata* file, FileAccessor* accessor);
 	};
 
+	class Architecture;
+
 	class BinaryViewType: public RefCountObject
 	{
 	protected:
@@ -393,6 +387,10 @@ namespace BinaryNinja
 		static Ref<BinaryViewType> GetByName(const std::string& name);
 		static std::vector<Ref<BinaryViewType>> GetViewTypesForData(BinaryView* data);
 
+		static void RegisterArchitecture(const std::string& name, uint32_t id, Architecture* arch);
+		void RegisterArchitecture(uint32_t id, Architecture* arch);
+		Ref<Architecture> GetArchitecture(uint32_t id);
+
 		std::string GetName();
 		std::string GetLongName();
 
@@ -568,4 +566,41 @@ namespace BinaryNinja
 		virtual bool Encode(const DataBuffer& input, DataBuffer& output, const std::map<std::string, DataBuffer>& params =
 		                    std::map<std::string, DataBuffer>()) override;
 	};
+
+	struct InstructionInfo: public BNInstructionInfo
+	{
+		InstructionInfo();
+		void AddBranch(BNBranchType type, uint64_t target = 0);
+	};
+
+	class Architecture: public RefCountObject
+	{
+	protected:
+		BNArchitecture* m_arch;
+		std::string m_nameForRegister;
+
+		Architecture(BNArchitecture* arch);
+
+		static bool GetInstructionInfoCallback(void* ctxt, BNBinaryView* data, uint64_t addr, BNInstructionInfo* result);
+
+	public:
+		Architecture(const std::string& name);
+
+		BNArchitecture* GetArchitectureObject() const { return m_arch; }
+
+		static void Register(Architecture* arch);
+		static Ref<Architecture> GetByName(const std::string& name);
+		static std::vector<Ref<Architecture>> GetList();
+
+		std::string GetName() const;
+
+		virtual bool GetInstructionInfo(BinaryView* data, uint64_t addr, InstructionInfo& result) = 0;
+	};
+
+	class CoreArchitecture: public Architecture
+	{
+	public:
+		CoreArchitecture(BNArchitecture* arch);
+		virtual bool GetInstructionInfo(BinaryView* view, uint64_t addr, InstructionInfo& result) override;
+	};
 }
diff --git a/binaryview.cpp b/binaryview.cpp
index 23ff8c56..1dc21283 100644
--- a/binaryview.cpp
+++ b/binaryview.cpp
@@ -7,7 +7,7 @@ using namespace std;
 void BinaryDataNotification::DataWrittenCallback(void* ctxt, BNBinaryView* object, uint64_t offset, size_t len)
 {
 	BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;
-	Ref<BinaryView> view = new CoreBinaryView(BNNewViewReference(object));
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));
 	notify->OnBinaryDataWritten(view, offset, len);
 }
 
@@ -15,7 +15,7 @@ void BinaryDataNotification::DataWrittenCallback(void* ctxt, BNBinaryView* objec
 void BinaryDataNotification::DataInsertedCallback(void* ctxt, BNBinaryView* object, uint64_t offset, size_t len)
 {
 	BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;
-	Ref<BinaryView> view = new CoreBinaryView(BNNewViewReference(object));
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));
 	notify->OnBinaryDataInserted(view, offset, len);
 }
 
@@ -23,7 +23,7 @@ void BinaryDataNotification::DataInsertedCallback(void* ctxt, BNBinaryView* obje
 void BinaryDataNotification::DataRemovedCallback(void* ctxt, BNBinaryView* object, uint64_t offset, uint64_t len)
 {
 	BinaryDataNotification* notify = (BinaryDataNotification*)ctxt;
-	Ref<BinaryView> view = new CoreBinaryView(BNNewViewReference(object));
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(object));
 	notify->OnBinaryDataRemoved(view, offset, len);
 }
 
@@ -72,56 +72,56 @@ BinaryView::~BinaryView()
 size_t BinaryView::ReadCallback(void* ctxt, void* dest, uint64_t offset, size_t len)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->Read(dest, offset, len);
+	return view->PerformRead(dest, offset, len);
 }
 
 
 size_t BinaryView::WriteCallback(void* ctxt, uint64_t offset, const void* src, size_t len)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->Write(offset, src, len);
+	return view->PerformWrite(offset, src, len);
 }
 
 
 size_t BinaryView::InsertCallback(void* ctxt, uint64_t offset, const void* src, size_t len)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->Insert(offset, src, len);
+	return view->PerformInsert(offset, src, len);
 }
 
 
 size_t BinaryView::RemoveCallback(void* ctxt, uint64_t offset, uint64_t len)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->Remove(offset, len);
+	return view->PerformRemove(offset, len);
 }
 
 
 BNModificationStatus BinaryView::GetModificationCallback(void* ctxt, uint64_t offset)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->GetModification(offset);
+	return view->PerformGetModification(offset);
 }
 
 
 uint64_t BinaryView::GetStartCallback(void* ctxt)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->GetStart();
+	return view->PerformGetStart();
 }
 
 
 uint64_t BinaryView::GetLengthCallback(void* ctxt)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->GetLength();
+	return view->PerformGetLength();
 }
 
 
 bool BinaryView::IsExecutableCallback(void* ctxt)
 {
 	BinaryView* view = (BinaryView*)ctxt;
-	return view->IsExecutable();
+	return view->PerformIsExecutable();
 }
 
 
@@ -129,13 +129,13 @@ bool BinaryView::SaveCallback(void* ctxt, BNFileAccessor* file)
 {
 	BinaryView* view = (BinaryView*)ctxt;
 	CoreFileAccessor accessor(file);
-	return view->Save(&accessor);
+	return view->PerformSave(&accessor);
 }
 
 
 bool BinaryView::IsModified() const
 {
-	return m_file->IsModified();
+	return BNIsViewModified(m_view);
 }
 
 
@@ -244,89 +244,84 @@ void BinaryView::UnregisterNotification(BinaryDataNotification* notify)
 }
 
 
-CoreBinaryView::CoreBinaryView(BNBinaryView* view): BinaryView(view)
-{
-}
-
-
-size_t CoreBinaryView::Read(void* dest, uint64_t offset, size_t len)
+size_t BinaryView::Read(void* dest, uint64_t offset, size_t len)
 {
 	return BNReadViewData(m_view, dest, offset, len);
 }
 
 
-size_t CoreBinaryView::Write(uint64_t offset, const void* data, size_t len)
+size_t BinaryView::Write(uint64_t offset, const void* data, size_t len)
 {
 	return BNWriteViewData(m_view, offset, data, len);
 }
 
 
-size_t CoreBinaryView::Insert(uint64_t offset, const void* data, size_t len)
+size_t BinaryView::Insert(uint64_t offset, const void* data, size_t len)
 {
 	return BNInsertViewData(m_view, offset, data, len);
 }
 
 
-size_t CoreBinaryView::Remove(uint64_t offset, uint64_t len)
+size_t BinaryView::Remove(uint64_t offset, uint64_t len)
 {
 	return BNRemoveViewData(m_view, offset, len);
 }
 
 
-BNModificationStatus CoreBinaryView::GetModification(uint64_t offset)
+BNModificationStatus BinaryView::GetModification(uint64_t offset)
 {
 	return BNGetModification(m_view, offset);
 }
 
 
-uint64_t CoreBinaryView::GetStart() const
+uint64_t BinaryView::GetStart() const
 {
 	return BNGetStartOffset(m_view);
 }
 
 
-uint64_t CoreBinaryView::GetLength() const
+uint64_t BinaryView::GetLength() const
 {
 	return BNGetViewLength(m_view);
 }
 
 
-bool CoreBinaryView::IsExecutable() const
+bool BinaryView::IsExecutable() const
 {
 	return BNIsExecutableView(m_view);
 }
 
 
-bool CoreBinaryView::Save(FileAccessor* file)
+bool BinaryView::Save(FileAccessor* file)
 {
 	return BNSaveToFile(m_view, file->GetCallbacks());
 }
 
 
-BinaryData::BinaryData(FileMetadata* file): CoreBinaryView(BNCreateBinaryDataView(file->GetFileObject()))
+BinaryData::BinaryData(FileMetadata* file): BinaryView(BNCreateBinaryDataView(file->GetFileObject()))
 {
 }
 
 
 BinaryData::BinaryData(FileMetadata* file, const DataBuffer& data):
-	CoreBinaryView(BNCreateBinaryDataViewFromBuffer(file->GetFileObject(), data.GetBufferObject()))
+	BinaryView(BNCreateBinaryDataViewFromBuffer(file->GetFileObject(), data.GetBufferObject()))
 {
 }
 
 
 BinaryData::BinaryData(FileMetadata* file, const void* data, size_t len):
-	CoreBinaryView(BNCreateBinaryDataViewFromData(file->GetFileObject(), data, len))
+	BinaryView(BNCreateBinaryDataViewFromData(file->GetFileObject(), data, len))
 {
 }
 
 
 BinaryData::BinaryData(FileMetadata* file, const string& path):
-	CoreBinaryView(BNCreateBinaryDataViewFromFilename(file->GetFileObject(), path.c_str()))
+	BinaryView(BNCreateBinaryDataViewFromFilename(file->GetFileObject(), path.c_str()))
 {
 }
 
 
 BinaryData::BinaryData(FileMetadata* file, FileAccessor* accessor):
-	CoreBinaryView(BNCreateBinaryDataViewFromFile(file->GetFileObject(), accessor->GetCallbacks()))
+	BinaryView(BNCreateBinaryDataViewFromFile(file->GetFileObject(), accessor->GetCallbacks()))
 {
 }
diff --git a/binaryviewtype.cpp b/binaryviewtype.cpp
index 8089f506..5d74de2b 100644
--- a/binaryviewtype.cpp
+++ b/binaryviewtype.cpp
@@ -7,7 +7,7 @@ using namespace std;
 BNBinaryView* BinaryViewType::CreateCallback(void* ctxt, BNBinaryView* data)
 {
 	BinaryViewType* type = (BinaryViewType*)ctxt;
-	Ref<BinaryView> view = new CoreBinaryView(BNNewViewReference(data));
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	Ref<BinaryView> result = type->Create(view);
 	return BNNewViewReference(result->GetViewObject());
 }
@@ -16,7 +16,7 @@ BNBinaryView* BinaryViewType::CreateCallback(void* ctxt, BNBinaryView* data)
 bool BinaryViewType::IsValidCallback(void* ctxt, BNBinaryView* data)
 {
 	BinaryViewType* type = (BinaryViewType*)ctxt;
-	Ref<BinaryView> view = new CoreBinaryView(BNNewViewReference(data));
+	Ref<BinaryView> view = new BinaryView(BNNewViewReference(data));
 	return type->IsTypeValidForData(view);
 }
 
@@ -74,6 +74,30 @@ vector<Ref<BinaryViewType>> BinaryViewType::GetViewTypesForData(BinaryView* data
 }
 
 
+void BinaryViewType::RegisterArchitecture(const string& name, uint32_t id, Architecture* arch)
+{
+	Ref<BinaryViewType> type = BinaryViewType::GetByName(name);
+	if (!type)
+		return;
+	type->RegisterArchitecture(id, arch);
+}
+
+
+void BinaryViewType::RegisterArchitecture(uint32_t id, Architecture* arch)
+{
+	BNRegisterArchitectureForViewType(m_type, id, arch->GetArchitectureObject());
+}
+
+
+Ref<Architecture> BinaryViewType::GetArchitecture(uint32_t id)
+{
+	BNArchitecture* arch = BNGetArchitectureForViewType(m_type, id);
+	if (!arch)
+		return nullptr;
+	return new CoreArchitecture(arch);
+}
+
+
 string BinaryViewType::GetName()
 {
 	char* contents = BNGetBinaryViewTypeName(m_type);
@@ -102,7 +126,7 @@ BinaryView* CoreBinaryViewType::Create(BinaryView* data)
 	BNBinaryView* view = BNCreateBinaryViewOfType(m_type, data->GetViewObject());
 	if (!view)
 		return nullptr;
-	return new CoreBinaryView(view);
+	return new BinaryView(view);
 }