From 087fdd83b85dd894d5b895557a378bb01828d0ff Mon Sep 17 00:00:00 2001 From: Glenn Smith Date: Tue, 28 May 2019 13:47:14 -0400 Subject: Tags --- function.cpp | 232 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) (limited to 'function.cpp') diff --git a/function.cpp b/function.cpp index 752d0bd1..0d5cb2ba 100644 --- a/function.cpp +++ b/function.cpp @@ -1300,6 +1300,237 @@ void Function::SetUserInstructionHighlight(Architecture* arch, uint64_t addr, ui } +std::vector Function::GetAllTagReferences() +{ + size_t count; + BNTagReference* refs = BNGetFunctionAllTagReferences(m_object, &count); + return TagReference::ConvertAndFreeTagReferenceList(refs, count); +} + + +std::vector Function::GetTagReferencesOfType(Ref tagType) +{ + size_t count; + BNTagReference* refs = BNGetFunctionTagReferencesOfType(m_object, tagType->GetObject(), &count); + return TagReference::ConvertAndFreeTagReferenceList(refs, count); +} + + +std::vector Function::GetAddressTagReferences() +{ + size_t count; + BNTagReference* refs = BNGetAddressTagReferences(m_object, &count); + return TagReference::ConvertAndFreeTagReferenceList(refs, count); +} + + +std::vector> Function::GetAddressTags(Architecture* arch, uint64_t addr) +{ + size_t count; + BNTag** tags = BNGetAddressTags(m_object, arch->GetObject(), addr, &count); + return Tag::ConvertAndFreeTagList(tags, count); +} + + +std::vector> Function::GetAddressTagsOfType(Architecture* arch, uint64_t addr, Ref tagType) +{ + size_t count; + BNTag** tags = BNGetAddressTagsOfType(m_object, arch->GetObject(), addr, tagType->GetObject(), &count); + return Tag::ConvertAndFreeTagList(tags, count); +} + + +void Function::AddAutoAddressTag(Architecture* arch, uint64_t addr, Ref tag) +{ + BNAddAutoAddressTag(m_object, arch->GetObject(), addr, tag->GetObject()); +} + + +void Function::RemoveAutoAddressTag(Architecture* arch, uint64_t addr, Ref tag) +{ + BNRemoveAutoAddressTag(m_object, arch->GetObject(), addr, tag->GetObject()); +} + + +void Function::AddUserAddressTag(Architecture* arch, uint64_t addr, Ref tag) +{ + BNAddUserAddressTag(m_object, arch->GetObject(), addr, tag->GetObject()); +} + + +void Function::RemoveUserAddressTag(Architecture* arch, uint64_t addr, Ref tag) +{ + BNRemoveUserAddressTag(m_object, arch->GetObject(), addr, tag->GetObject()); +} + + +std::vector Function::GetFunctionTagReferences() +{ + size_t count; + BNTagReference* refs = BNGetFunctionTagReferences(m_object, &count); + return TagReference::ConvertAndFreeTagReferenceList(refs, count); +} + + +std::vector> Function::GetFunctionTags() +{ + size_t count; + BNTag** tags = BNGetFunctionTags(m_object, &count); + return Tag::ConvertAndFreeTagList(tags, count); +} + + +std::vector> Function::GetFunctionTagsOfType(Ref tagType) +{ + size_t count; + BNTag** tags = BNGetFunctionTagsOfType(m_object, tagType->GetObject(), &count); + return Tag::ConvertAndFreeTagList(tags, count); +} + + +void Function::AddAutoFunctionTag(Ref tag) +{ + BNAddAutoFunctionTag(m_object, tag->GetObject()); +} + + +void Function::RemoveAutoFunctionTag(Ref tag) +{ + BNRemoveAutoFunctionTag(m_object, tag->GetObject()); +} + + +void Function::AddUserFunctionTag(Ref tag) +{ + BNAddUserFunctionTag(m_object, tag->GetObject()); +} + + +void Function::RemoveUserFunctionTag(Ref tag) +{ + BNRemoveUserFunctionTag(m_object, tag->GetObject()); +} + + +Ref Function::CreateAutoAddressTag(Architecture* arch, uint64_t addr, const std::string& tagTypeName, const std::string& data, bool unique) +{ + Ref tagType = GetView()->GetTagType(tagTypeName); + if (!tagType) + return nullptr; + + return CreateAutoAddressTag(arch, addr, tagType, data, unique); +} + + +Ref Function::CreateAutoAddressTag(Architecture* arch, uint64_t addr, Ref tagType, const std::string& data, bool unique) +{ + if (unique) + { + auto tags = GetAddressTags(arch, addr); + for (const auto& tag : tags) + { + if (tag->GetType() == tagType && tag->GetData() == data) + return nullptr; + } + } + + Ref tag = new Tag(tagType, data); + GetView()->AddTag(tag); + + AddAutoAddressTag(arch, addr, tag); + return tag; +} + + +Ref Function::CreateUserAddressTag(Architecture* arch, uint64_t addr, const std::string& tagTypeName, const std::string& data, bool unique) +{ + Ref tagType = GetView()->GetTagType(tagTypeName); + if (!tagType) + return nullptr; + + return CreateUserAddressTag(arch, addr, tagType, data, unique); +} + + +Ref Function::CreateUserAddressTag(Architecture* arch, uint64_t addr, Ref tagType, const std::string& data, bool unique) +{ + if (unique) + { + auto tags = GetAddressTags(arch, addr); + for (const auto& tag : tags) + { + if (tag->GetType() == tagType && tag->GetData() == data) + return nullptr; + } + } + Ref tag = new Tag(tagType, data); + GetView()->AddTag(tag); + + AddUserAddressTag(arch, addr, tag); + return tag; +} + + +Ref Function::CreateAutoFunctionTag(const std::string& tagTypeName, const std::string& data, bool unique) +{ + Ref tagType = GetView()->GetTagType(tagTypeName); + if (!tagType) + return nullptr; + + return CreateAutoFunctionTag(tagType, data, unique); +} + + +Ref Function::CreateAutoFunctionTag(Ref tagType, const std::string& data, bool unique) +{ + if (unique) + { + auto tags = GetFunctionTags(); + for (const auto& tag : tags) + { + if (tag->GetType() == tagType && tag->GetData() == data) + return nullptr; + } + } + + Ref tag = new Tag(tagType, data); + GetView()->AddTag(tag); + + AddAutoFunctionTag(tag); + return tag; +} + + +Ref Function::CreateUserFunctionTag(const std::string& tagTypeName, const std::string& data, bool unique) +{ + Ref tagType = GetView()->GetTagType(tagTypeName); + if (!tagType) + return nullptr; + + return CreateUserFunctionTag(tagType, data, unique); +} + + +Ref Function::CreateUserFunctionTag(Ref tagType, const std::string& data, bool unique) +{ + if (unique) + { + auto tags = GetFunctionTags(); + for (const auto& tag : tags) + { + if (tag->GetType() == tagType && tag->GetData() == data) + return nullptr; + } + } + + Ref tag = new Tag(tagType, data); + GetView()->AddTag(tag); + + AddUserFunctionTag(tag); + return tag; +} + + Confidence Function::GetGlobalPointerValue() const { BNRegisterValueWithConfidence value = BNGetFunctionGlobalPointerValue(m_object); @@ -1370,6 +1601,7 @@ vector Function::GetTypeTokens(DisassemblySettings* setting line.instrIndex = lines[i].instrIndex; line.highlight = lines[i].highlight; line.tokens = InstructionTextToken::ConvertInstructionTextTokenList(lines[i].tokens, lines[i].count); + line.tags = Tag::ConvertTagList(lines[i].tags, lines[i].tagCount); result.push_back(line); } -- cgit v1.3.1