diff options
Diffstat (limited to 'type.cpp')
| -rw-r--r-- | type.cpp | 517 |
1 files changed, 488 insertions, 29 deletions
@@ -24,6 +24,219 @@ using namespace BinaryNinja; using namespace std; +QualifiedName::QualifiedName() +{ +} + + +QualifiedName::QualifiedName(const string& name) +{ + m_name.push_back(name); +} + + +QualifiedName::QualifiedName(const vector<string>& name): m_name(name) +{ +} + + +QualifiedName::QualifiedName(const QualifiedName& name): m_name(name.m_name) +{ +} + + +QualifiedName& QualifiedName::operator=(const string& name) +{ + m_name = vector<string>{name}; + return *this; +} + + +QualifiedName& QualifiedName::operator=(const vector<string>& name) +{ + m_name = name; + return *this; +} + + +QualifiedName& QualifiedName::operator=(const QualifiedName& name) +{ + m_name = name.m_name; + return *this; +} + + +bool QualifiedName::operator==(const QualifiedName& other) const +{ + return m_name == other.m_name; +} + + +bool QualifiedName::operator!=(const QualifiedName& other) const +{ + return m_name != other.m_name; +} + + +bool QualifiedName::operator<(const QualifiedName& other) const +{ + return m_name < other.m_name; +} + + +QualifiedName QualifiedName::operator+(const QualifiedName& other) const +{ + QualifiedName result(*this); + result.m_name.insert(result.m_name.end(), other.m_name.begin(), other.m_name.end()); + return result; +} + + +string& QualifiedName::operator[](size_t i) +{ + return m_name[i]; +} + + +const string& QualifiedName::operator[](size_t i) const +{ + return m_name[i]; +} + + +vector<string>::iterator QualifiedName::begin() +{ + return m_name.begin(); +} + + +vector<string>::iterator QualifiedName::end() +{ + return m_name.end(); +} + + +vector<string>::const_iterator QualifiedName::begin() const +{ + return m_name.begin(); +} + + +vector<string>::const_iterator QualifiedName::end() const +{ + return m_name.end(); +} + + +string& QualifiedName::front() +{ + return m_name.front(); +} + + +const string& QualifiedName::front() const +{ + return m_name.front(); +} + + +string& QualifiedName::back() +{ + return m_name.back(); +} + + +const string& QualifiedName::back() const +{ + return m_name.back(); +} + + +void QualifiedName::insert(vector<string>::iterator loc, const string& name) +{ + m_name.insert(loc, name); +} + + +void QualifiedName::insert(vector<string>::iterator loc, vector<string>::iterator b, vector<string>::iterator e) +{ + m_name.insert(loc, b, e); +} + + +void QualifiedName::erase(vector<string>::iterator i) +{ + m_name.erase(i); +} + + +void QualifiedName::clear() +{ + m_name.clear(); +} + + +void QualifiedName::push_back(const string& name) +{ + m_name.push_back(name); +} + + +size_t QualifiedName::size() const +{ + return m_name.size(); +} + + +string QualifiedName::GetString() const +{ + bool first = true; + string out; + for (auto &name : m_name) + { + if (!first) + { + out += "::" + name; + } + else + { + out += name; + } + if (name.length() != 0) + first = false; + } + return out; +} + + +BNQualifiedName QualifiedName::GetAPIObject() const +{ + BNQualifiedName result; + result.nameCount = m_name.size(); + result.name = new char*[m_name.size()]; + for (size_t i = 0; i < m_name.size(); i++) + result.name[i] = BNAllocString(m_name[i].c_str()); + return result; +} + + +void QualifiedName::FreeAPIObject(BNQualifiedName* name) +{ + for (size_t i = 0; i < name->nameCount; i++) + BNFreeString(name->name[i]); + delete[] name->name; +} + + +QualifiedName QualifiedName::FromAPIObject(BNQualifiedName* name) +{ + QualifiedName result; + for (size_t i = 0; i < name->nameCount; i++) + result.push_back(name->name[i]); + return result; +} + + Type::Type(BNType* type) { m_object = type; @@ -133,6 +346,15 @@ Ref<Enumeration> Type::GetEnumeration() const } +Ref<NamedTypeReference> Type::GetNamedTypeReference() const +{ + BNNamedTypeReference* ref = BNGetTypeNamedTypeReference(m_object); + if (ref) + return new NamedTypeReference(ref); + return nullptr; +} + + uint64_t Type::GetElementCount() const { return BNGetTypeElementCount(m_object); @@ -148,6 +370,14 @@ string Type::GetString() const } +string Type::GetTypeAndName(const QualifiedName& nameList) const +{ + BNQualifiedName name = nameList.GetAPIObject(); + char* outName = BNGetTypeAndName(m_object, &name); + QualifiedName::FreeAPIObject(&name); + return outName; +} + string Type::GetStringBeforeName() const { char* str = BNGetTypeStringBeforeName(m_object); @@ -166,6 +396,78 @@ string Type::GetStringAfterName() const } +vector<InstructionTextToken> Type::GetTokens() const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeTokens(m_object, &count); + + vector<InstructionTextToken> result; + for (size_t i = 0; i < count; i++) + { + InstructionTextToken token; + token.type = tokens[i].type; + token.text = tokens[i].text; + token.value = tokens[i].value; + token.size = tokens[i].size; + token.operand = tokens[i].operand; + token.context = tokens[i].context; + token.address = tokens[i].address; + result.push_back(token); + } + + BNFreeTokenList(tokens, count); + return result; +} + + +vector<InstructionTextToken> Type::GetTokensBeforeName() const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeTokensBeforeName(m_object, &count); + + vector<InstructionTextToken> result; + for (size_t i = 0; i < count; i++) + { + InstructionTextToken token; + token.type = tokens[i].type; + token.text = tokens[i].text; + token.value = tokens[i].value; + token.size = tokens[i].size; + token.operand = tokens[i].operand; + token.context = tokens[i].context; + token.address = tokens[i].address; + result.push_back(token); + } + + BNFreeTokenList(tokens, count); + return result; +} + + +vector<InstructionTextToken> Type::GetTokensAfterName() const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeTokensAfterName(m_object, &count); + + vector<InstructionTextToken> result; + for (size_t i = 0; i < count; i++) + { + InstructionTextToken token; + token.type = tokens[i].type; + token.text = tokens[i].text; + token.value = tokens[i].value; + token.size = tokens[i].size; + token.operand = tokens[i].operand; + token.context = tokens[i].context; + token.address = tokens[i].address; + result.push_back(token); + } + + BNFreeTokenList(tokens, count); + return result; +} + + Ref<Type> Type::Duplicate() const { return new Type(BNDuplicateType(m_object)); @@ -184,15 +486,15 @@ Ref<Type> Type::BoolType() } -Ref<Type> Type::IntegerType(size_t width, bool sign) +Ref<Type> Type::IntegerType(size_t width, bool sign, const string& altName) { - return new Type(BNCreateIntegerType(width, sign)); + return new Type(BNCreateIntegerType(width, sign, altName.c_str())); } -Ref<Type> Type::FloatType(size_t width) +Ref<Type> Type::FloatType(size_t width, const string& altName) { - return new Type(BNCreateFloatType(width)); + return new Type(BNCreateFloatType(width, altName.c_str())); } @@ -202,15 +504,46 @@ Ref<Type> Type::StructureType(Structure* strct) } -Ref<Type> Type::EnumerationType(Architecture* arch, Enumeration* enm, size_t width) +Ref<Type> Type::NamedType(NamedTypeReference* ref, size_t width, size_t align) { - return new Type(BNCreateEnumerationType(arch->GetObject(), enm->GetObject(), width)); + return new Type(BNCreateNamedTypeReference(ref->GetObject(), width, align)); } -Ref<Type> Type::PointerType(Architecture* arch, Type* type, bool cnst) +Ref<Type> Type::NamedType(const QualifiedName& name, Type* type) { - return new Type(BNCreatePointerType(arch->GetObject(), type->GetObject(), cnst)); + return NamedType("", name, type); +} + + +Ref<Type> Type::NamedType(const string& id, const QualifiedName& name, Type* type) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + Type* result = new Type(BNCreateNamedTypeReferenceFromTypeAndId(id.c_str(), &nameObj, + type ? type->GetObject() : nullptr)); + QualifiedName::FreeAPIObject(&nameObj); + return result; +} + + +Ref<Type> Type::NamedType(BinaryView* view, const QualifiedName& name) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + Type* result = new Type(BNCreateNamedTypeReferenceFromType(view->GetObject(), &nameObj)); + QualifiedName::FreeAPIObject(&nameObj); + return result; +} + + +Ref<Type> Type::EnumerationType(Architecture* arch, Enumeration* enm, size_t width, bool isSigned) +{ + return new Type(BNCreateEnumerationType(arch->GetObject(), enm->GetObject(), width, isSigned)); +} + + +Ref<Type> Type::PointerType(Architecture* arch, Type* type, bool cnst, bool vltl, BNReferenceType refType) +{ + return new Type(BNCreatePointerType(arch->GetObject(), type->GetObject(), cnst, vltl, refType)); } @@ -238,24 +571,135 @@ Ref<Type> Type::FunctionType(Type* returnValue, CallingConvention* callingConven } -Structure::Structure(BNStructure* s) +void Type::SetFunctionCanReturn(bool canReturn) { - m_object = s; + BNSetFunctionCanReturn(m_object, canReturn); +} + + +string Type::GenerateAutoTypeId(const string& source, const QualifiedName& name) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + char* str = BNGenerateAutoTypeId(source.c_str(), &nameObj); + string result = str; + QualifiedName::FreeAPIObject(&nameObj); + BNFreeString(str); + return result; +} + + +string Type::GenerateAutoDemangledTypeId(const QualifiedName& name) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + char* str = BNGenerateAutoDemangledTypeId(&nameObj); + string result = str; + QualifiedName::FreeAPIObject(&nameObj); + BNFreeString(str); + return result; +} + + +string Type::GetAutoDemangledTypeIdSource() +{ + char* str = BNGetAutoDemangledTypeIdSource(); + string result = str; + BNFreeString(str); + return result; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReference* nt) +{ + m_object = nt; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReferenceClass cls, const string& id, const QualifiedName& names) +{ + m_object = BNCreateNamedType(); + BNSetTypeReferenceClass(m_object, cls); + if (id.size() != 0) + { + BNSetTypeReferenceId(m_object, id.c_str()); + } + if (names.size() != 0) + { + BNQualifiedName nameObj = names.GetAPIObject(); + BNSetTypeReferenceName(m_object, &nameObj); + QualifiedName::FreeAPIObject(&nameObj); + } +} + + +void NamedTypeReference::SetTypeClass(BNNamedTypeReferenceClass cls) +{ + BNSetTypeReferenceClass(m_object, cls); +} + + +BNNamedTypeReferenceClass NamedTypeReference::GetTypeClass() const +{ + return BNGetTypeReferenceClass(m_object); +} + + +string NamedTypeReference::GetTypeId() const +{ + char* str = BNGetTypeReferenceId(m_object); + string result = str; + BNFreeString(str); + return result; +} + + +void NamedTypeReference::SetTypeId(const string& id) +{ + BNSetTypeReferenceId(m_object, id.c_str()); +} + + +void NamedTypeReference::SetName(const QualifiedName& names) +{ + BNQualifiedName nameObj = names.GetAPIObject(); + BNSetTypeReferenceName(m_object, &nameObj); + QualifiedName::FreeAPIObject(&nameObj); } -string Structure::GetName() const +QualifiedName NamedTypeReference::GetName() const { - char* name = BNGetStructureName(m_object); - string result = name; - BNFreeString(name); + BNQualifiedName name = BNGetTypeReferenceName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); return result; } -void Structure::SetName(const string& name) +Ref<NamedTypeReference> NamedTypeReference::GenerateAutoTypeReference(BNNamedTypeReferenceClass cls, + const string& source, const QualifiedName& name) +{ + string id = Type::GenerateAutoTypeId(source, name); + return new NamedTypeReference(cls, id, name); +} + + +Ref<NamedTypeReference> NamedTypeReference::GenerateAutoDemangledTypeReference(BNNamedTypeReferenceClass cls, + const QualifiedName& name) { - BNSetStructureName(m_object, name.c_str()); + string id = Type::GenerateAutoDemangledTypeId(name); + return new NamedTypeReference(cls, id, name); +} + + +Structure::Structure() +{ + m_object = BNCreateStructure(); +} + + +Structure::Structure(BNStructure* s) +{ + m_object = s; } @@ -285,12 +729,24 @@ uint64_t Structure::GetWidth() const } +void Structure::SetWidth(size_t width) +{ + BNSetStructureWidth(m_object, width); +} + + size_t Structure::GetAlignment() const { return BNGetStructureAlignment(m_object); } +void Structure::SetAlignment(size_t align) +{ + BNSetStructureAlignment(m_object, align); +} + + bool Structure::IsPacked() const { return BNIsStructurePacked(m_object); @@ -333,24 +789,15 @@ void Structure::RemoveMember(size_t idx) } -Enumeration::Enumeration(BNEnumeration* e) +void Structure::ReplaceMember(size_t idx, Type* type, const std::string& name) { - m_object = e; + BNReplaceStructureMember(m_object, idx, type->GetObject(), name.c_str()); } -string Enumeration::GetName() const -{ - char* name = BNGetEnumerationName(m_object); - string result = name; - BNFreeString(name); - return result; -} - - -void Enumeration::SetName(const string& name) +Enumeration::Enumeration(BNEnumeration* e) { - BNSetEnumerationName(m_object, name.c_str()); + m_object = e; } @@ -386,6 +833,18 @@ void Enumeration::AddMemberWithValue(const string& name, uint64_t value) } +void Enumeration::RemoveMember(size_t idx) +{ + BNRemoveEnumerationMember(m_object, idx); +} + + +void Enumeration::ReplaceMember(size_t idx, const string& name, uint64_t value) +{ + BNReplaceEnumerationMember(m_object, idx, name.c_str(), value); +} + + bool BinaryNinja::PreprocessSource(const string& source, const string& fileName, string& output, string& errors, const vector<string>& includeDirs) { |