DebugInfo - plugable debug information importers - C++, Rust, and Python APIs

1 files changed, 249 insertions, 0 deletions

diff --git a/debuginfo.cpp b/debuginfo.cpp
new file mode 100644
index 00000000..2bdc2e47
--- /dev/null
+++ b/debuginfo.cpp
@@ -0,0 +1,249 @@
+// Copyright (c) 2015-2021 Vector 35 Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+
+// TODO : Documentation
+
+
+#include "binaryninjaapi.h"
+using namespace BinaryNinja;
+using namespace std;
+
+
+///////////////
+// DebugInfo //
+///////////////
+
+
+DebugInfo::DebugInfo(BNDebugInfo* debugInfo)
+{
+	m_object = debugInfo;
+}
+
+
+vector<NameAndType> DebugInfo::GetTypes(const string& parserName)
+{
+	size_t count;
+	BNNameAndType* nameAndTypes = BNGetDebugTypes(m_object, parserName.size() == 0 ? nullptr : parserName.c_str(), &count);
+
+	vector<NameAndType> result;
+	for (size_t i = 0; i < count; ++i)
+	{
+		result.emplace_back(nameAndTypes[i].name,
+		                    Confidence<Ref<Type>>(
+		                        new Type(BNNewTypeReference(nameAndTypes[i].type)),
+		                        nameAndTypes[i].typeConfidence));
+	}
+
+	BNFreeDebugTypes(nameAndTypes, count);
+	return result;
+}
+
+
+vector<DebugFunctionInfo> DebugInfo::GetFunctions(const string& parserName)
+{
+	size_t count;
+	BNDebugFunctionInfo* functions = BNGetDebugFunctions(m_object, parserName.size() == 0 ? nullptr : parserName.c_str(), &count);
+
+	vector<DebugFunctionInfo> result;
+	for (size_t i = 0; i < count; ++i)
+	{
+		vector<tuple<string, Ref<Type>>> parameters;
+		for (size_t j = 0; j < functions[i].parameterCount; ++j)
+			parameters.emplace_back(functions[i].parameterNames[j], new Type(BNNewTypeReference(functions[i].parameterTypes[j])));
+
+		result.emplace_back(functions[i].shortName ? functions[i].shortName : "",
+		                    functions[i].fullName ? functions[i].fullName : "",
+		                    functions[i].rawName ? functions[i].rawName : "",
+		                    functions[i].address,
+		                    functions[i].returnType ? new Type(BNNewTypeReference(functions[i].returnType)) : nullptr,
+		                    parameters,
+		                    functions[i].variableParameters,
+		                    functions[i].callingConvention ? new CoreCallingConvention(BNNewCallingConventionReference(functions[i].callingConvention)) : nullptr,
+		                    functions[i].platform ? new Platform(BNNewPlatformReference(functions[i].platform)) : nullptr);
+	}
+
+	BNFreeDebugFunctions(functions, count);
+	return result;
+}
+
+
+vector<DataVariableAndName> DebugInfo::GetDataVariables(const string& parserName)
+{
+	size_t count;
+	BNDataVariableAndName* variableAndNames = BNGetDebugDataVariables(m_object, parserName.size() == 0 ? nullptr : parserName.c_str(), &count);
+
+	vector<DataVariableAndName> result;
+	for (size_t i = 0; i < count; ++i)
+	{
+		result.emplace_back(variableAndNames[i].address,
+		                    Confidence(new Type(BNNewTypeReference(variableAndNames[i].type)), variableAndNames[i].typeConfidence),
+		                    variableAndNames[i].autoDiscovered,
+		                    variableAndNames[i].name);
+	}
+
+	BNFreeDataVariablesAndName(variableAndNames, count);
+	return result;
+}
+
+
+bool DebugInfo::AddType(const string& name, Ref<Type> type)
+{
+	return BNAddDebugType(m_object, name.c_str(), type->GetObject());
+}
+
+
+bool DebugInfo::AddFunction(const DebugFunctionInfo& function)
+{
+	BNDebugFunctionInfo* input = new BNDebugFunctionInfo();
+
+	input->shortName          = function.shortName.size() ? BNAllocString(function.shortName.c_str()) : nullptr;
+	input->fullName           = function.fullName.size() ? BNAllocString(function.fullName.c_str()) : nullptr;
+	input->rawName            = function.rawName.size() ? BNAllocString(function.rawName.c_str()) : nullptr;
+	input->address            = function.address;
+	input->returnType         = function.returnType ? function.returnType->GetObject() : nullptr;
+	input->variableParameters = function.variableParameters;
+	input->callingConvention  = function.callingConvention ? function.callingConvention->GetObject() : nullptr;
+	input->platform           = function.platform ? function.platform->GetObject() : nullptr;
+
+	size_t parameterCount = function.parameters.size();
+	input->parameterCount = parameterCount;
+	input->parameterNames = new char*[parameterCount];
+	input->parameterTypes = new BNType*[parameterCount];
+	for (size_t i = 0; i < parameterCount; ++i)
+	{
+		input->parameterNames[i] = BNAllocString(std::get<0>(function.parameters[i]).c_str());
+		input->parameterTypes[i] = std::get<1>(function.parameters[i])->GetObject();
+	}
+
+	bool result = BNAddDebugFunction(m_object, input);
+
+	BNFreeString(input->shortName);
+	BNFreeString(input->fullName);
+	BNFreeString(input->rawName);
+
+	for (size_t i = 0; i < parameterCount; ++i)
+		BNFreeString(input->parameterNames[i]);
+
+	return result;
+}
+
+
+bool DebugInfo::AddDataVariable(uint64_t address, Ref<Type> type, const string& name)
+{
+	if (name.size() == 0)
+		return BNAddDebugDataVariable(m_object, address, type->GetObject(), nullptr);
+	return BNAddDebugDataVariable(m_object, address, type->GetObject(), name.c_str());
+}
+
+
+/////////////////////
+// DebugInfoParser //
+/////////////////////
+
+
+DebugInfoParser::DebugInfoParser(BNDebugInfoParser* parser)
+{
+	m_object = parser;
+}
+
+
+Ref<DebugInfoParser> DebugInfoParser::GetByName(const string& name)
+{
+	BNDebugInfoParser* parser = BNGetDebugInfoParserByName(name.c_str());
+	if (parser)
+		return new DebugInfoParser(BNNewDebugInfoParserReference(parser));
+	return nullptr;
+}
+
+
+vector<Ref<DebugInfoParser>> DebugInfoParser::GetList()
+{
+	size_t count                = 0;
+	BNDebugInfoParser** parsers = BNGetDebugInfoParsers(&count);
+
+	vector<Ref<DebugInfoParser>> result;
+	for (size_t i = 0; i < count; ++i)
+	{
+		result.emplace_back(new DebugInfoParser(BNNewDebugInfoParserReference(parsers[i])));
+	}
+
+	BNFreeDebugInfoParserList(parsers, count);
+	return result;
+}
+
+
+vector<Ref<DebugInfoParser>> DebugInfoParser::GetListForView(const Ref<BinaryView> data)
+{
+	size_t count                = 0;
+	BNDebugInfoParser** parsers = BNGetDebugInfoParsersForView(data->GetObject(), &count);
+
+	vector<Ref<DebugInfoParser>> result;
+	for (size_t i = 0; i < count; ++i)
+	{
+		result.emplace_back(new DebugInfoParser(BNNewDebugInfoParserReference(parsers[i])));
+	}
+
+	BNFreeDebugInfoParserList(parsers, count);
+	return result;
+}
+
+
+string DebugInfoParser::GetName() const
+{
+	return BNGetDebugInfoParserName(m_object);
+}
+
+
+Ref<DebugInfo> DebugInfoParser::Parse(Ref<BinaryView> view, Ref<DebugInfo> existingDebugInfo) const
+{
+	if (existingDebugInfo)
+		return new DebugInfo(BNNewDebugInfoReference(BNParseDebugInfo(m_object, view->GetObject(), existingDebugInfo->GetObject())));
+	return new DebugInfo(BNParseDebugInfo(m_object, view->GetObject(), nullptr));
+}
+
+
+bool DebugInfoParser::IsValidForView(const Ref<BinaryView> view) const
+{
+	return BNIsDebugInfoParserValidForView(m_object, view->GetObject());
+}
+
+
+//////////////////////////////
+// Plugin registration APIs //
+//////////////////////////////
+
+
+bool CustomDebugInfoParser::IsValidCallback(void* ctxt, BNBinaryView* view)
+{
+	CustomDebugInfoParser* parser = (CustomDebugInfoParser*)ctxt;
+	return parser->IsValid(new BinaryView(view));
+}
+
+
+void CustomDebugInfoParser::ParseCallback(void* ctxt, BNDebugInfo* debugInfo, BNBinaryView* view)
+{
+	CustomDebugInfoParser* parser = (CustomDebugInfoParser*)ctxt;
+	parser->ParseInfo(new DebugInfo(debugInfo), new BinaryView(view));
+}
+
+
+CustomDebugInfoParser::CustomDebugInfoParser(const string& name) :
+    DebugInfoParser(BNNewDebugInfoParserReference(BNRegisterDebugInfoParser(name.c_str(), IsValidCallback, ParseCallback, this))) {}