1 files changed, 97 insertions, 0 deletions

diff --git a/callingconvention.cpp b/callingconvention.cpp
index fb5ed73f..b0783ad6 100644
--- a/callingconvention.cpp
+++ b/callingconvention.cpp
@@ -44,6 +44,10 @@ CallingConvention::CallingConvention(Architecture* arch, const string& name)
 	cc.getIntegerReturnValueRegister = GetIntegerReturnValueRegisterCallback;
 	cc.getHighIntegerReturnValueRegister = GetHighIntegerReturnValueRegisterCallback;
 	cc.getFloatReturnValueRegister = GetFloatReturnValueRegisterCallback;
+	cc.getGlobalPointerRegister = GetGlobalPointerRegisterCallback;
+	cc.getImplicitlyDefinedRegisters = GetImplicitlyDefinedRegistersCallback;
+	cc.getIncomingRegisterValue = GetIncomingRegisterValueCallback;
+	cc.getIncomingFlagValue = GetIncomingFlagValueCallback;
 
 	AddRefForRegistration();
 	m_object = BNCreateCallingConvention(arch->GetObject(), name.c_str(), &cc);
@@ -137,6 +141,46 @@ uint32_t CallingConvention::GetFloatReturnValueRegisterCallback(void* ctxt)
 }
 
 
+uint32_t CallingConvention::GetGlobalPointerRegisterCallback(void* ctxt)
+{
+	CallingConvention* cc = (CallingConvention*)ctxt;
+	return cc->GetGlobalPointerRegister();
+}
+
+
+uint32_t* CallingConvention::GetImplicitlyDefinedRegistersCallback(void* ctxt, size_t* count)
+{
+	CallingConvention* cc = (CallingConvention*)ctxt;
+	vector<uint32_t> regs = cc->GetImplicitlyDefinedRegisters();
+	*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;
+}
+
+
+BNRegisterValue CallingConvention::GetIncomingRegisterValueCallback(void* ctxt, uint32_t reg, BNFunction* func)
+{
+	CallingConvention* cc = (CallingConvention*)ctxt;
+	Ref<Function> funcObj;
+	if (func)
+		funcObj = new Function(BNNewFunctionReference(func));
+	return cc->GetIncomingRegisterValue(reg, funcObj).ToAPIObject();
+}
+
+
+BNRegisterValue CallingConvention::GetIncomingFlagValueCallback(void* ctxt, uint32_t reg, BNFunction* func)
+{
+	CallingConvention* cc = (CallingConvention*)ctxt;
+	Ref<Function> funcObj;
+	if (func)
+		funcObj = new Function(BNNewFunctionReference(func));
+	return cc->GetIncomingFlagValue(reg, funcObj).ToAPIObject();
+}
+
+
 Ref<Architecture> CallingConvention::GetArchitecture() const
 {
 	return new CoreArchitecture(BNGetCallingConventionArchitecture(m_object));
@@ -194,6 +238,30 @@ uint32_t CallingConvention::GetFloatReturnValueRegister()
 }
 
 
+uint32_t CallingConvention::GetGlobalPointerRegister()
+{
+	return BN_INVALID_REGISTER;
+}
+
+
+vector<uint32_t> CallingConvention::GetImplicitlyDefinedRegisters()
+{
+	return vector<uint32_t>();
+}
+
+
+RegisterValue CallingConvention::GetIncomingRegisterValue(uint32_t, Function*)
+{
+	return RegisterValue();
+}
+
+
+RegisterValue CallingConvention::GetIncomingFlagValue(uint32_t, Function*)
+{
+	return RegisterValue();
+}
+
+
 CoreCallingConvention::CoreCallingConvention(BNCallingConvention* cc): CallingConvention(cc)
 {
 }
@@ -260,3 +328,32 @@ uint32_t CoreCallingConvention::GetFloatReturnValueRegister()
 {
 	return BNGetFloatReturnValueRegister(m_object);
 }
+
+
+uint32_t CoreCallingConvention::GetGlobalPointerRegister()
+{
+	return BNGetGlobalPointerRegister(m_object);
+}
+
+
+vector<uint32_t> CoreCallingConvention::GetImplicitlyDefinedRegisters()
+{
+	size_t count;
+	uint32_t* regs = BNGetImplicitlyDefinedRegisters(m_object, &count);
+	vector<uint32_t> result;
+	result.insert(result.end(), regs, &regs[count]);
+	BNFreeRegisterList(regs);
+	return result;
+}
+
+
+RegisterValue CoreCallingConvention::GetIncomingRegisterValue(uint32_t reg, Function* func)
+{
+	return RegisterValue::FromAPIObject(BNGetIncomingRegisterValue(m_object, reg, func ? func->GetObject() : nullptr));
+}
+
+
+RegisterValue CoreCallingConvention::GetIncomingFlagValue(uint32_t flag, Function* func)
+{
+	return RegisterValue::FromAPIObject(BNGetIncomingFlagValue(m_object, flag, func ? func->GetObject() : nullptr));
+}