From ad05dd2072917e2487dcd34dbc249b2a0efac589 Mon Sep 17 00:00:00 2001
From: Rusty Wagner <rusty@vector35.com>
Date: Mon, 25 Jan 2016 15:16:43 -0500
Subject: Initial implementation of platform ABI classes

---
 architecture.cpp | 115 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 115 insertions(+)

(limited to 'architecture.cpp')

diff --git a/architecture.cpp b/architecture.cpp
index 98e53b5c..2420d69b 100644
--- a/architecture.cpp
+++ b/architecture.cpp
@@ -226,6 +226,13 @@ uint32_t Architecture::GetStackPointerRegisterCallback(void* ctxt)
 }
 
 
+uint32_t Architecture::GetLinkRegisterCallback(void* ctxt)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	return arch->GetLinkRegister();
+}
+
+
 bool Architecture::AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors)
 {
 	Architecture* arch = (Architecture*)ctxt;
@@ -324,6 +331,7 @@ void Architecture::Register(Architecture* arch)
 	callbacks.freeRegisterList = FreeRegisterListCallback;
 	callbacks.getRegisterInfo = GetRegisterInfoCallback;
 	callbacks.getStackPointerRegister = GetStackPointerRegisterCallback;
+	callbacks.getLinkRegister = GetLinkRegisterCallback;
 	callbacks.assemble = AssembleCallback;
 	callbacks.isNeverBranchPatchAvailable = IsNeverBranchPatchAvailableCallback;
 	callbacks.isAlwaysBranchPatchAvailable = IsAlwaysBranchPatchAvailableCallback;
@@ -451,6 +459,12 @@ uint32_t Architecture::GetStackPointerRegister()
 }
 
 
+uint32_t Architecture::GetLinkRegister()
+{
+	return BN_INVALID_REGISTER;
+}
+
+
 vector<uint32_t> Architecture::GetModifiedRegistersOnWrite(uint32_t reg)
 {
 	size_t count;
@@ -623,6 +637,101 @@ bool Architecture::ParseTypesFromSourceFile(const string& fileName, map<string,
 }
 
 
+void Architecture::RegisterCallingConvention(CallingConvention* cc)
+{
+	BNRegisterCallingConvention(m_arch, cc->GetCallingConventionObject());
+}
+
+
+vector<Ref<CallingConvention>> Architecture::GetCallingConventions()
+{
+	size_t count;
+	BNCallingConvention** list = BNGetArchitectureCallingConventions(m_arch, &count);
+
+	vector<Ref<CallingConvention>> result;
+	for (size_t i = 0; i < count; i++)
+		result.push_back(new CoreCallingConvention(BNNewCallingConventionReference(list[i])));
+
+	BNFreeCallingConventionList(list, count);
+	return result;
+}
+
+
+Ref<CallingConvention> Architecture::GetCallingConventionByName(const string& name)
+{
+	BNCallingConvention* cc = BNGetArchitectureCallingConventionByName(m_arch, name.c_str());
+	if (!cc)
+		return nullptr;
+	return new CoreCallingConvention(cc);
+}
+
+
+void Architecture::SetDefaultCallingConvention(CallingConvention* cc)
+{
+	BNSetArchitectureDefaultCallingConvention(m_arch, cc->GetCallingConventionObject());
+}
+
+
+void Architecture::SetCdeclCallingConvention(CallingConvention* cc)
+{
+	BNSetArchitectureCdeclCallingConvention(m_arch, cc->GetCallingConventionObject());
+}
+
+
+void Architecture::SetStdcallCallingConvention(CallingConvention* cc)
+{
+	BNSetArchitectureStdcallCallingConvention(m_arch, cc->GetCallingConventionObject());
+}
+
+
+void Architecture::SetFastcallCallingConvention(CallingConvention* cc)
+{
+	BNSetArchitectureFastcallCallingConvention(m_arch, cc->GetCallingConventionObject());
+}
+
+
+Ref<CallingConvention> Architecture::GetDefaultCallingConvention()
+{
+	BNCallingConvention* cc = BNGetArchitectureDefaultCallingConvention(m_arch);
+	if (!cc)
+		return nullptr;
+	return new CoreCallingConvention(cc);
+}
+
+
+Ref<CallingConvention> Architecture::GetCdeclCallingConvention()
+{
+	BNCallingConvention* cc = BNGetArchitectureCdeclCallingConvention(m_arch);
+	if (!cc)
+		return nullptr;
+	return new CoreCallingConvention(cc);
+}
+
+
+Ref<CallingConvention> Architecture::GetStdcallCallingConvention()
+{
+	BNCallingConvention* cc = BNGetArchitectureStdcallCallingConvention(m_arch);
+	if (!cc)
+		return nullptr;
+	return new CoreCallingConvention(cc);
+}
+
+
+Ref<CallingConvention> Architecture::GetFastcallCallingConvention()
+{
+	BNCallingConvention* cc = BNGetArchitectureFastcallCallingConvention(m_arch);
+	if (!cc)
+		return nullptr;
+	return new CoreCallingConvention(cc);
+}
+
+
+Ref<Platform> Architecture::GetStandalonePlatform()
+{
+	return new Platform(BNGetArchitectureStandalonePlatform(m_arch));
+}
+
+
 CoreArchitecture::CoreArchitecture(BNArchitecture* arch): Architecture(arch)
 {
 }
@@ -768,6 +877,12 @@ uint32_t CoreArchitecture::GetStackPointerRegister()
 }
 
 
+uint32_t CoreArchitecture::GetLinkRegister()
+{
+	return BNGetArchitectureLinkRegister(m_arch);
+}
+
+
 bool CoreArchitecture::Assemble(const string& code, uint64_t addr, DataBuffer& result, string& errors)
 {
 	char* errorStr = nullptr;
-- 
cgit v1.3.1