Skip to content

Commit ad05dd2

Browse files
D0ntPanicD0ntPanic
committed
Initial implementation of platform ABI classes
1 parent c2b2e11 commit ad05dd2

9 files changed

Lines changed: 803 additions & 19 deletions

‎architecture.cpp‎

Lines changed: 115 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,13 @@ uint32_t Architecture::GetStackPointerRegisterCallback(void* ctxt)
226226
}
227227

228228

229+
uint32_t Architecture::GetLinkRegisterCallback(void* ctxt)
230+
{
231+
Architecture* arch = (Architecture*)ctxt;
232+
return arch->GetLinkRegister();
233+
}
234+
235+
229236
bool Architecture::AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors)
230237
{
231238
Architecture* arch = (Architecture*)ctxt;
@@ -324,6 +331,7 @@ void Architecture::Register(Architecture* arch)
324331
callbacks.freeRegisterList = FreeRegisterListCallback;
325332
callbacks.getRegisterInfo = GetRegisterInfoCallback;
326333
callbacks.getStackPointerRegister = GetStackPointerRegisterCallback;
334+
callbacks.getLinkRegister = GetLinkRegisterCallback;
327335
callbacks.assemble = AssembleCallback;
328336
callbacks.isNeverBranchPatchAvailable = IsNeverBranchPatchAvailableCallback;
329337
callbacks.isAlwaysBranchPatchAvailable = IsAlwaysBranchPatchAvailableCallback;
@@ -451,6 +459,12 @@ uint32_t Architecture::GetStackPointerRegister()
451459
}
452460

453461

462+
uint32_t Architecture::GetLinkRegister()
463+
{
464+
return BN_INVALID_REGISTER;
465+
}
466+
467+
454468
vector<uint32_t> Architecture::GetModifiedRegistersOnWrite(uint32_t reg)
455469
{
456470
size_t count;
@@ -623,6 +637,101 @@ bool Architecture::ParseTypesFromSourceFile(const string& fileName, map<string,
623637
}
624638

625639

640+
void Architecture::RegisterCallingConvention(CallingConvention* cc)
641+
{
642+
BNRegisterCallingConvention(m_arch, cc->GetCallingConventionObject());
643+
}
644+
645+
646+
vector<Ref<CallingConvention>> Architecture::GetCallingConventions()
647+
{
648+
size_t count;
649+
BNCallingConvention** list = BNGetArchitectureCallingConventions(m_arch, &count);
650+
651+
vector<Ref<CallingConvention>> result;
652+
for (size_t i = 0; i < count; i++)
653+
result.push_back(new CoreCallingConvention(BNNewCallingConventionReference(list[i])));
654+
655+
BNFreeCallingConventionList(list, count);
656+
return result;
657+
}
658+
659+
660+
Ref<CallingConvention> Architecture::GetCallingConventionByName(const string& name)
661+
{
662+
BNCallingConvention* cc = BNGetArchitectureCallingConventionByName(m_arch, name.c_str());
663+
if (!cc)
664+
return nullptr;
665+
return new CoreCallingConvention(cc);
666+
}
667+
668+
669+
void Architecture::SetDefaultCallingConvention(CallingConvention* cc)
670+
{
671+
BNSetArchitectureDefaultCallingConvention(m_arch, cc->GetCallingConventionObject());
672+
}
673+
674+
675+
void Architecture::SetCdeclCallingConvention(CallingConvention* cc)
676+
{
677+
BNSetArchitectureCdeclCallingConvention(m_arch, cc->GetCallingConventionObject());
678+
}
679+
680+
681+
void Architecture::SetStdcallCallingConvention(CallingConvention* cc)
682+
{
683+
BNSetArchitectureStdcallCallingConvention(m_arch, cc->GetCallingConventionObject());
684+
}
685+
686+
687+
void Architecture::SetFastcallCallingConvention(CallingConvention* cc)
688+
{
689+
BNSetArchitectureFastcallCallingConvention(m_arch, cc->GetCallingConventionObject());
690+
}
691+
692+
693+
Ref<CallingConvention> Architecture::GetDefaultCallingConvention()
694+
{
695+
BNCallingConvention* cc = BNGetArchitectureDefaultCallingConvention(m_arch);
696+
if (!cc)
697+
return nullptr;
698+
return new CoreCallingConvention(cc);
699+
}
700+
701+
702+
Ref<CallingConvention> Architecture::GetCdeclCallingConvention()
703+
{
704+
BNCallingConvention* cc = BNGetArchitectureCdeclCallingConvention(m_arch);
705+
if (!cc)
706+
return nullptr;
707+
return new CoreCallingConvention(cc);
708+
}
709+
710+
711+
Ref<CallingConvention> Architecture::GetStdcallCallingConvention()
712+
{
713+
BNCallingConvention* cc = BNGetArchitectureStdcallCallingConvention(m_arch);
714+
if (!cc)
715+
return nullptr;
716+
return new CoreCallingConvention(cc);
717+
}
718+
719+
720+
Ref<CallingConvention> Architecture::GetFastcallCallingConvention()
721+
{
722+
BNCallingConvention* cc = BNGetArchitectureFastcallCallingConvention(m_arch);
723+
if (!cc)
724+
return nullptr;
725+
return new CoreCallingConvention(cc);
726+
}
727+
728+
729+
Ref<Platform> Architecture::GetStandalonePlatform()
730+
{
731+
return new Platform(BNGetArchitectureStandalonePlatform(m_arch));
732+
}
733+
734+
626735
CoreArchitecture::CoreArchitecture(BNArchitecture* arch): Architecture(arch)
627736
{
628737
}
@@ -768,6 +877,12 @@ uint32_t CoreArchitecture::GetStackPointerRegister()
768877
}
769878

770879

880+
uint32_t CoreArchitecture::GetLinkRegister()
881+
{
882+
return BNGetArchitectureLinkRegister(m_arch);
883+
}
884+
885+
771886
bool CoreArchitecture::Assemble(const string& code, uint64_t addr, DataBuffer& result, string& errors)
772887
{
773888
char* errorStr = nullptr;

‎binaryninjaapi.cpp‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -100,3 +100,21 @@ uint32_t BinaryNinja::GetBuildId()
100100
{
101101
return BNGetBuildId();
102102
}
103+
104+
105+
void BinaryNinja::SetCurrentPluginLoadOrder(BNPluginLoadOrder order)
106+
{
107+
BNSetCurrentPluginLoadOrder(order);
108+
}
109+
110+
111+
void BinaryNinja::AddRequiredPluginDependency(const string& name)
112+
{
113+
BNAddRequiredPluginDependency(name.c_str());
114+
}
115+
116+
117+
void BinaryNinja::AddOptionalPluginDependency(const string& name)
118+
{
119+
BNAddOptionalPluginDependency(name.c_str());
120+
}

0 commit comments

Comments
 (0)