From 142004d7f31ad2eee58dc6c9bdec7bdcc530cf58 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Tue, 10 Dec 2019 16:16:33 -0500 Subject: Immutable type/struct/enum objects, allowing deduplication for reduced memory usage. In C++ API, modifying or creating types, structures, or enumerations should be done with the new TypeBuilder, StructureBuilder, and EnumerationBuilder objects, then converted to a final Type, Structure, or Enumeration object using the Finalize method once the modifications are complete. When modifying structures or enumerations inside existing types, use the WithReplacedStructure or WithReplacedEnumeration methods on the root type object and reregister the type to use the modified object. In Python API, types, structures, and enumerations can be created as in previous versions, but the objects become immutable once they are passed to a method. To modify an existing type, structure, or enumeration, use the mutable_copy() method. When modifying structures or enumerations, replace the modified object in the Type with the with_replaced_structure() or with_replaced_enumeration() methods. --- type.cpp | 1109 +++++++++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 926 insertions(+), 183 deletions(-) (limited to 'type.cpp') diff --git a/type.cpp b/type.cpp index 3b1d3466..bf96a32c 100644 --- a/type.cpp +++ b/type.cpp @@ -496,15 +496,6 @@ Confidence Type::GetScope() const } -void Type::SetScope(const Confidence& scope) -{ - BNMemberScopeWithConfidence mc; - mc.value = scope.GetValue(); - mc.confidence = scope.GetConfidence(); - return BNTypeSetMemberScope(m_object, &mc); -} - - Confidence Type::GetAccess() const { BNMemberAccessWithConfidence result = BNTypeGetMemberAccess(m_object); @@ -512,33 +503,6 @@ Confidence Type::GetAccess() const } -void Type::SetAccess(const Confidence& access) -{ - BNMemberAccessWithConfidence mc; - mc.value = access.GetValue(); - mc.confidence = access.GetConfidence(); - return BNTypeSetMemberAccess(m_object, &mc); -} - - -void Type::SetConst(const Confidence& cnst) -{ - BNBoolWithConfidence bc; - bc.value = cnst.GetValue(); - bc.confidence = cnst.GetConfidence(); - BNTypeSetConst(m_object, &bc); -} - - -void Type::SetVolatile(const Confidence& vltl) -{ - BNBoolWithConfidence bc; - bc.value = vltl.GetValue(); - bc.confidence = vltl.GetConfidence(); - BNTypeSetVolatile(m_object, &bc); -} - - Confidence> Type::GetChildType() const { BNTypeWithConfidence type = BNGetChildType(m_object); @@ -868,15 +832,6 @@ Ref Type::FunctionType(const Confidence>& returnValue, } -void Type::SetFunctionCanReturn(const Confidence& canReturn) -{ - BNBoolWithConfidence bc; - bc.value = canReturn.GetValue(); - bc.confidence = canReturn.GetConfidence(); - BNSetFunctionTypeCanReturn(m_object, &bc); -} - - string Type::GenerateAutoTypeId(const string& source, const QualifiedName& name) { BNQualifiedName nameObj = name.GetAPIObject(); @@ -943,14 +898,6 @@ QualifiedName Type::GetTypeName() const } -void Type::SetTypeName(const QualifiedName& names) -{ - BNQualifiedName nameObj = names.GetAPIObject(); - BNTypeSetTypeName(m_object, &nameObj); - QualifiedName::FreeAPIObject(&nameObj); -} - - Confidence> Type::WithConfidence(uint8_t conf) { return Confidence>(this, conf); @@ -966,269 +913,1065 @@ QualifiedName Type::GetStructureName() const } -NamedTypeReference::NamedTypeReference(BNNamedTypeReference* nt) +Ref Type::WithReplacedStructure(Structure* from, Structure* to) { - m_object = nt; + BNType* result = BNTypeWithReplacedStructure(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeType(result); + return this; + } + return new Type(result); } -NamedTypeReference::NamedTypeReference(BNNamedTypeReferenceClass cls, const string& id, const QualifiedName& names) +Ref Type::WithReplacedEnumeration(Enumeration* from, Enumeration* to) { - m_object = BNCreateNamedType(); - BNSetTypeReferenceClass(m_object, cls); - if (id.size() != 0) + BNType* result = BNTypeWithReplacedEnumeration(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) { - BNSetTypeReferenceId(m_object, id.c_str()); + BNFreeType(result); + return this; } - if (names.size() != 0) + return new Type(result); +} + + +Ref Type::WithReplacedNamedTypeReference(NamedTypeReference* from, NamedTypeReference* to) +{ + BNType* result = BNTypeWithReplacedNamedTypeReference(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) { - BNQualifiedName nameObj = names.GetAPIObject(); - BNSetTypeReferenceName(m_object, &nameObj); - QualifiedName::FreeAPIObject(&nameObj); + BNFreeType(result); + return this; } + return new Type(result); } -void NamedTypeReference::SetTypeClass(BNNamedTypeReferenceClass cls) +TypeBuilder::TypeBuilder() { - BNSetTypeReferenceClass(m_object, cls); + m_object = BNCreateVoidTypeBuilder(); } -BNNamedTypeReferenceClass NamedTypeReference::GetTypeClass() const +TypeBuilder::TypeBuilder(BNTypeBuilder* type) { - return BNGetTypeReferenceClass(m_object); + m_object = type; } -string NamedTypeReference::GetTypeId() const +TypeBuilder::TypeBuilder(const TypeBuilder& type) { - char* str = BNGetTypeReferenceId(m_object); - string result = str; - BNFreeString(str); - return result; + m_object = BNDuplicateTypeBuilder(type.m_object); } -void NamedTypeReference::SetTypeId(const string& id) +TypeBuilder::TypeBuilder(TypeBuilder&& type) { - BNSetTypeReferenceId(m_object, id.c_str()); + m_object = type.m_object; + type.m_object = BNCreateVoidTypeBuilder(); } -void NamedTypeReference::SetName(const QualifiedName& names) +TypeBuilder::TypeBuilder(Type* type) { - BNQualifiedName nameObj = names.GetAPIObject(); - BNSetTypeReferenceName(m_object, &nameObj); - QualifiedName::FreeAPIObject(&nameObj); + m_object = BNCreateTypeBuilderFromType(type->GetObject()); } -QualifiedName NamedTypeReference::GetName() const +TypeBuilder& TypeBuilder::operator=(const TypeBuilder& type) { - BNQualifiedName name = BNGetTypeReferenceName(m_object); - QualifiedName result = QualifiedName::FromAPIObject(&name); - BNFreeQualifiedName(&name); - return result; + if (this != &type) + { + BNFreeTypeBuilder(m_object); + m_object = BNDuplicateTypeBuilder(type.m_object); + } + return *this; } -Ref NamedTypeReference::GenerateAutoTypeReference(BNNamedTypeReferenceClass cls, - const string& source, const QualifiedName& name) +TypeBuilder& TypeBuilder::operator=(TypeBuilder&& type) { - string id = Type::GenerateAutoTypeId(source, name); - return new NamedTypeReference(cls, id, name); + std::swap(m_object, type.m_object); + return *this; } -Ref NamedTypeReference::GenerateAutoDemangledTypeReference(BNNamedTypeReferenceClass cls, - const QualifiedName& name) +TypeBuilder& TypeBuilder::operator=(Type* type) { - string id = Type::GenerateAutoDemangledTypeId(name); - return new NamedTypeReference(cls, id, name); + BNFreeTypeBuilder(m_object); + m_object = BNCreateTypeBuilderFromType(type->GetObject()); + return *this; } -Ref NamedTypeReference::GenerateAutoDebugTypeReference(BNNamedTypeReferenceClass cls, - const QualifiedName& name) +Ref TypeBuilder::Finalize() { - string id = Type::GenerateAutoDebugTypeId(name); - return new NamedTypeReference(cls, id, name); + return new Type(BNFinalizeTypeBuilder(m_object)); } -Structure::Structure() +BNTypeClass TypeBuilder::GetClass() const { - m_object = BNCreateStructure(); + return BNGetTypeBuilderClass(m_object); } -Structure::Structure(BNStructureType type, bool packed) +uint64_t TypeBuilder::GetWidth() const { - m_object = BNCreateStructureWithOptions(type, packed); + return BNGetTypeBuilderWidth(m_object); } -Structure::Structure(BNStructure* s) +size_t TypeBuilder::GetAlignment() const { - m_object = s; + return BNGetTypeBuilderAlignment(m_object); } -vector Structure::GetMembers() const +Confidence TypeBuilder::IsSigned() const +{ + BNBoolWithConfidence result = BNIsTypeBuilderSigned(m_object); + return Confidence(result.value, result.confidence); +} + + +Confidence TypeBuilder::IsConst() const +{ + BNBoolWithConfidence result = BNIsTypeBuilderConst(m_object); + return Confidence(result.value, result.confidence); +} + + +Confidence TypeBuilder::GetScope() const +{ + BNMemberScopeWithConfidence result = BNTypeBuilderGetMemberScope(m_object); + return Confidence(result.value, result.confidence); +} + + +void TypeBuilder::SetScope(const Confidence& scope) +{ + BNMemberScopeWithConfidence mc; + mc.value = scope.GetValue(); + mc.confidence = scope.GetConfidence(); + return BNTypeBuilderSetMemberScope(m_object, &mc); +} + + +Confidence TypeBuilder::GetAccess() const +{ + BNMemberAccessWithConfidence result = BNTypeBuilderGetMemberAccess(m_object); + return Confidence(result.value, result.confidence); +} + + +void TypeBuilder::SetAccess(const Confidence& access) +{ + BNMemberAccessWithConfidence mc; + mc.value = access.GetValue(); + mc.confidence = access.GetConfidence(); + return BNTypeBuilderSetMemberAccess(m_object, &mc); +} + + +void TypeBuilder::SetConst(const Confidence& cnst) +{ + BNBoolWithConfidence bc; + bc.value = cnst.GetValue(); + bc.confidence = cnst.GetConfidence(); + BNTypeBuilderSetConst(m_object, &bc); +} + + +void TypeBuilder::SetVolatile(const Confidence& vltl) +{ + BNBoolWithConfidence bc; + bc.value = vltl.GetValue(); + bc.confidence = vltl.GetConfidence(); + BNTypeBuilderSetVolatile(m_object, &bc); +} + + +Confidence> TypeBuilder::GetChildType() const +{ + BNTypeWithConfidence type = BNGetTypeBuilderChildType(m_object); + if (type.type) + return Confidence>(new Type(type.type), type.confidence); + return nullptr; +} + + +Confidence> TypeBuilder::GetCallingConvention() const +{ + BNCallingConventionWithConfidence cc = BNGetTypeBuilderCallingConvention(m_object); + if (cc.convention) + return Confidence>(new CoreCallingConvention(cc.convention), cc.confidence); + return nullptr; +} + + +vector TypeBuilder::GetParameters() const { size_t count; - BNStructureMember* members = BNGetStructureMembers(m_object, &count); + BNFunctionParameter* types = BNGetTypeBuilderParameters(m_object, &count); - vector result; + vector result; result.reserve(count); for (size_t i = 0; i < count; i++) { - StructureMember member; - member.type = new Type(BNNewTypeReference(members[i].type)); - member.name = members[i].name; - member.offset = members[i].offset; - result.push_back(member); + FunctionParameter param; + param.name = types[i].name; + param.type = Confidence>(new Type(BNNewTypeReference(types[i].type)), types[i].typeConfidence); + param.defaultLocation = types[i].defaultLocation; + param.location.type = types[i].location.type; + param.location.index = types[i].location.index; + param.location.storage = types[i].location.storage; + result.push_back(param); } - BNFreeStructureMemberList(members, count); + BNFreeTypeParameterList(types, count); return result; } -bool Structure::GetMemberByName(const string& name, StructureMember& result) const +Confidence TypeBuilder::HasVariableArguments() const { - BNStructureMember* member = BNGetStructureMemberByName(m_object, name.c_str()); - if (member) - { - result.type = new Type(BNNewTypeReference(member->type)); - result.name = member->name; - result.offset = member->offset; - BNFreeStructureMember(member); - return true; - } - return false; + BNBoolWithConfidence result = BNTypeBuilderHasVariableArguments(m_object); + return Confidence(result.value, result.confidence); } -bool Structure::GetMemberAtOffset(int64_t offset, StructureMember& result) const +Confidence TypeBuilder::CanReturn() const { - BNStructureMember* member = BNGetStructureMemberAtOffset(m_object, offset); - if (member) - { - result.type = new Type(BNNewTypeReference(member->type)); - result.name = member->name; - result.offset = member->offset; - BNFreeStructureMember(member); - return true; - } - return false; + BNBoolWithConfidence result = BNFunctionTypeBuilderCanReturn(m_object); + return Confidence(result.value, result.confidence); } -uint64_t Structure::GetWidth() const +Ref TypeBuilder::GetStructure() const { - return BNGetStructureWidth(m_object); + BNStructure* s = BNGetTypeBuilderStructure(m_object); + if (s) + return new Structure(s); + return nullptr; } -void Structure::SetWidth(size_t width) +Ref TypeBuilder::GetEnumeration() const { - BNSetStructureWidth(m_object, width); + BNEnumeration* e = BNGetTypeBuilderEnumeration(m_object); + if (e) + return new Enumeration(e); + return nullptr; } -size_t Structure::GetAlignment() const +Ref TypeBuilder::GetNamedTypeReference() const { - return BNGetStructureAlignment(m_object); + BNNamedTypeReference* ref = BNGetTypeBuilderNamedTypeReference(m_object); + if (ref) + return new NamedTypeReference(ref); + return nullptr; } -void Structure::SetAlignment(size_t align) +uint64_t TypeBuilder::GetElementCount() const { - BNSetStructureAlignment(m_object, align); + return BNGetTypeBuilderElementCount(m_object); } -bool Structure::IsPacked() const +uint64_t TypeBuilder::GetOffset() const { - return BNIsStructurePacked(m_object); + return BNGetTypeBuilderOffset(m_object); } -void Structure::SetPacked(bool packed) +Confidence TypeBuilder::GetStackAdjustment() const { - BNSetStructurePacked(m_object, packed); + BNOffsetWithConfidence result = BNGetTypeBuilderStackAdjustment(m_object); + return Confidence(result.value, result.confidence); } -bool Structure::IsUnion() const +string TypeBuilder::GetString(Platform* platform) const { - return BNIsStructureUnion(m_object); + char* str = BNGetTypeBuilderString(m_object, platform ? platform->GetObject() : nullptr); + string result = str; + BNFreeString(str); + return result; } -void Structure::SetStructureType(BNStructureType t) +string TypeBuilder::GetTypeAndName(const QualifiedName& nameList) const +{ + BNQualifiedName name = nameList.GetAPIObject(); + char* outName = BNGetTypeBuilderTypeAndName(m_object, &name); + QualifiedName::FreeAPIObject(&name); + return outName; +} + +string TypeBuilder::GetStringBeforeName(Platform* platform) const { - BNSetStructureType(m_object, t); + char* str = BNGetTypeBuilderStringBeforeName(m_object, platform ? platform->GetObject() : nullptr); + string result = str; + BNFreeString(str); + return result; } -BNStructureType Structure::GetStructureType() const +string TypeBuilder::GetStringAfterName(Platform* platform) const { - return BNGetStructureType(m_object); + char* str = BNGetTypeBuilderStringAfterName(m_object, platform ? platform->GetObject() : nullptr); + string result = str; + BNFreeString(str); + return result; } -void Structure::AddMember(const Confidence>& type, const string& name) +vector TypeBuilder::GetTokens(Platform* platform, uint8_t baseConfidence) const { - BNTypeWithConfidence tc; - tc.type = type->GetObject(); - tc.confidence = type.GetConfidence(); - BNAddStructureMember(m_object, &tc, name.c_str()); + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokens(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); } -void Structure::AddMemberAtOffset(const Confidence>& type, const string& name, uint64_t offset) +vector TypeBuilder::GetTokensBeforeName(Platform* platform, uint8_t baseConfidence) const { - BNTypeWithConfidence tc; - tc.type = type->GetObject(); - tc.confidence = type.GetConfidence(); - BNAddStructureMemberAtOffset(m_object, &tc, name.c_str(), offset); + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokensBeforeName(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); +} + + +vector TypeBuilder::GetTokensAfterName(Platform* platform, uint8_t baseConfidence) const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokensAfterName(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); } -void Structure::RemoveMember(size_t idx) +TypeBuilder TypeBuilder::VoidType() { - BNRemoveStructureMember(m_object, idx); + return TypeBuilder(BNCreateVoidTypeBuilder()); } -void Structure::ReplaceMember(size_t idx, const Confidence>& type, const std::string& name) +TypeBuilder TypeBuilder::BoolType() { - BNTypeWithConfidence tc; - tc.type = type->GetObject(); - tc.confidence = type.GetConfidence(); - BNReplaceStructureMember(m_object, idx, &tc, name.c_str()); + return TypeBuilder(BNCreateBoolTypeBuilder()); } -Enumeration::Enumeration(BNEnumeration* e) +TypeBuilder TypeBuilder::IntegerType(size_t width, const Confidence& sign, const string& altName) { - m_object = e; + BNBoolWithConfidence bc; + bc.value = sign.GetValue(); + bc.confidence = sign.GetConfidence(); + return TypeBuilder(BNCreateIntegerTypeBuilder(width, &bc, altName.c_str())); } -Enumeration::Enumeration() +TypeBuilder TypeBuilder::FloatType(size_t width, const string& altName) { - m_object = BNCreateEnumeration(); + return TypeBuilder(BNCreateFloatTypeBuilder(width, altName.c_str())); } -vector Enumeration::GetMembers() const +TypeBuilder TypeBuilder::StructureType(Structure* strct) { - size_t count; - BNEnumerationMember* members = BNGetEnumerationMembers(m_object, &count); + return TypeBuilder(BNCreateStructureTypeBuilder(strct->GetObject())); +} + + +TypeBuilder TypeBuilder::NamedType(NamedTypeReference* ref, size_t width, size_t align) +{ + return TypeBuilder(BNCreateNamedTypeReferenceBuilder(ref->GetObject(), width, align)); +} + + +TypeBuilder TypeBuilder::NamedType(const QualifiedName& name, Type* type) +{ + return NamedType("", name, type); +} + + +TypeBuilder TypeBuilder::NamedType(const string& id, const QualifiedName& name, Type* type) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + BNTypeBuilder* coreObj = BNCreateNamedTypeReferenceBuilderFromTypeAndId(id.c_str(), &nameObj, + type ? type->GetObject() : nullptr); + QualifiedName::FreeAPIObject(&nameObj); + return coreObj ? TypeBuilder(coreObj) : VoidType(); +} + + +TypeBuilder TypeBuilder::NamedType(BinaryView* view, const QualifiedName& name) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + BNTypeBuilder* coreObj = BNCreateNamedTypeReferenceBuilderFromType(view->GetObject(), &nameObj); + QualifiedName::FreeAPIObject(&nameObj); + return coreObj ? TypeBuilder(coreObj) : VoidType(); +} + + +TypeBuilder TypeBuilder::EnumerationType(Architecture* arch, Enumeration* enm, size_t width, bool isSigned) +{ + return TypeBuilder(BNCreateEnumerationTypeBuilder(arch->GetObject(), enm->GetObject(), width, isSigned)); +} + + +TypeBuilder TypeBuilder::PointerType(Architecture* arch, const Confidence>& type, + const Confidence& cnst, const Confidence& vltl, BNReferenceType refType) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + BNBoolWithConfidence cnstConf; + cnstConf.value = cnst.GetValue(); + cnstConf.confidence = cnst.GetConfidence(); + + BNBoolWithConfidence vltlConf; + vltlConf.value = vltl.GetValue(); + vltlConf.confidence = vltl.GetConfidence(); + + return TypeBuilder(BNCreatePointerTypeBuilder(arch->GetObject(), &typeConf, &cnstConf, &vltlConf, refType)); +} + + +TypeBuilder TypeBuilder::PointerType(size_t width, const Confidence>& type, + const Confidence& cnst, const Confidence& vltl, BNReferenceType refType) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + BNBoolWithConfidence cnstConf; + cnstConf.value = cnst.GetValue(); + cnstConf.confidence = cnst.GetConfidence(); + + BNBoolWithConfidence vltlConf; + vltlConf.value = vltl.GetValue(); + vltlConf.confidence = vltl.GetConfidence(); + + return TypeBuilder(BNCreatePointerTypeBuilderOfWidth(width, &typeConf, &cnstConf, &vltlConf, refType)); +} + + +TypeBuilder TypeBuilder::ArrayType(const Confidence>& type, uint64_t elem) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + return TypeBuilder(BNCreateArrayTypeBuilder(&typeConf, elem)); +} + + +TypeBuilder TypeBuilder::FunctionType(const Confidence>& returnValue, + const Confidence>& callingConvention, + const std::vector& params, const Confidence& varArg, + const Confidence& stackAdjust) +{ + BNTypeWithConfidence returnValueConf; + returnValueConf.type = returnValue->GetObject(); + returnValueConf.confidence = returnValue.GetConfidence(); + + BNCallingConventionWithConfidence callingConventionConf; + callingConventionConf.convention = callingConvention ? callingConvention->GetObject() : nullptr; + callingConventionConf.confidence = callingConvention.GetConfidence(); + + BNFunctionParameter* paramArray = new BNFunctionParameter[params.size()]; + for (size_t i = 0; i < params.size(); i++) + { + paramArray[i].name = (char*)params[i].name.c_str(); + paramArray[i].type = params[i].type->GetObject(); + paramArray[i].typeConfidence = params[i].type.GetConfidence(); + paramArray[i].defaultLocation = params[i].defaultLocation; + paramArray[i].location.type = params[i].location.type; + paramArray[i].location.index = params[i].location.index; + paramArray[i].location.storage = params[i].location.storage; + } + + BNBoolWithConfidence varArgConf; + varArgConf.value = varArg.GetValue(); + varArgConf.confidence = varArg.GetConfidence(); + + BNOffsetWithConfidence stackAdjustConf; + stackAdjustConf.value = stackAdjust.GetValue(); + stackAdjustConf.confidence = stackAdjust.GetConfidence(); + + TypeBuilder type(BNCreateFunctionTypeBuilder(&returnValueConf, &callingConventionConf, + paramArray, params.size(), &varArgConf, &stackAdjustConf)); + delete[] paramArray; + return type; +} + + +void TypeBuilder::SetFunctionCanReturn(const Confidence& canReturn) +{ + BNBoolWithConfidence bc; + bc.value = canReturn.GetValue(); + bc.confidence = canReturn.GetConfidence(); + BNSetFunctionTypeBuilderCanReturn(m_object, &bc); +} + + +bool TypeBuilder::IsReferenceOfType(BNNamedTypeReferenceClass refType) +{ + return (GetClass() == NamedTypeReferenceClass) && (GetNamedTypeReference()->GetTypeClass() == refType); +} + + +QualifiedName TypeBuilder::GetTypeName() const +{ + BNQualifiedName name = BNTypeBuilderGetTypeName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); + return result; +} + + +void TypeBuilder::SetTypeName(const QualifiedName& names) +{ + BNQualifiedName nameObj = names.GetAPIObject(); + BNTypeBuilderSetTypeName(m_object, &nameObj); + QualifiedName::FreeAPIObject(&nameObj); +} + + +QualifiedName TypeBuilder::GetStructureName() const +{ + BNQualifiedName name = BNTypeBuilderGetStructureName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); + return result; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReference* nt) +{ + m_object = nt; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReferenceClass cls, const string& id, const QualifiedName& names) +{ + BNQualifiedName nameObj = names.GetAPIObject(); + m_object = BNCreateNamedType(cls, id.c_str(), &nameObj); + QualifiedName::FreeAPIObject(&nameObj); +} + + +BNNamedTypeReferenceClass NamedTypeReference::GetTypeClass() const +{ + return BNGetTypeReferenceClass(m_object); +} + + +string NamedTypeReference::GetTypeId() const +{ + char* str = BNGetTypeReferenceId(m_object); + string result = str; + BNFreeString(str); + return result; +} + + +QualifiedName NamedTypeReference::GetName() const +{ + BNQualifiedName name = BNGetTypeReferenceName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); + return result; +} + + +Ref NamedTypeReference::GenerateAutoTypeReference(BNNamedTypeReferenceClass cls, + const string& source, const QualifiedName& name) +{ + string id = Type::GenerateAutoTypeId(source, name); + return new NamedTypeReference(cls, id, name); +} + + +Ref NamedTypeReference::GenerateAutoDemangledTypeReference(BNNamedTypeReferenceClass cls, + const QualifiedName& name) +{ + string id = Type::GenerateAutoDemangledTypeId(name); + return new NamedTypeReference(cls, id, name); +} + + +Ref NamedTypeReference::GenerateAutoDebugTypeReference(BNNamedTypeReferenceClass cls, + const QualifiedName& name) +{ + string id = Type::GenerateAutoDebugTypeId(name); + return new NamedTypeReference(cls, id, name); +} + + +Structure::Structure(BNStructure* s) +{ + m_object = s; +} + + +vector Structure::GetMembers() const +{ + size_t count; + BNStructureMember* members = BNGetStructureMembers(m_object, &count); + + vector result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + StructureMember member; + member.type = new Type(BNNewTypeReference(members[i].type)); + member.name = members[i].name; + member.offset = members[i].offset; + result.push_back(member); + } + + BNFreeStructureMemberList(members, count); + return result; +} + + +bool Structure::GetMemberByName(const string& name, StructureMember& result) const +{ + BNStructureMember* member = BNGetStructureMemberByName(m_object, name.c_str()); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +bool Structure::GetMemberAtOffset(int64_t offset, StructureMember& result) const +{ + size_t i; + return GetMemberAtOffset(offset, result, i); +} + + +bool Structure::GetMemberAtOffset(int64_t offset, StructureMember& result, size_t& idx) const +{ + BNStructureMember* member = BNGetStructureMemberAtOffset(m_object, offset, &idx); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +uint64_t Structure::GetWidth() const +{ + return BNGetStructureWidth(m_object); +} + + +size_t Structure::GetAlignment() const +{ + return BNGetStructureAlignment(m_object); +} + + +bool Structure::IsPacked() const +{ + return BNIsStructurePacked(m_object); +} + + +bool Structure::IsUnion() const +{ + return BNIsStructureUnion(m_object); +} + + +BNStructureType Structure::GetStructureType() const +{ + return BNGetStructureType(m_object); +} + + +Ref Structure::WithReplacedStructure(Structure* from, Structure* to) +{ + BNStructure* result = BNStructureWithReplacedStructure(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); +} + + +Ref Structure::WithReplacedEnumeration(Enumeration* from, Enumeration* to) +{ + BNStructure* result = BNStructureWithReplacedEnumeration(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); +} + + +Ref Structure::WithReplacedNamedTypeReference(NamedTypeReference* from, NamedTypeReference* to) +{ + BNStructure* result = BNStructureWithReplacedNamedTypeReference(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); +} + + +StructureBuilder::StructureBuilder() +{ + m_object = BNCreateStructureBuilder(); +} + + +StructureBuilder::StructureBuilder(BNStructureBuilder* s) +{ + m_object = s; +} + + +StructureBuilder::StructureBuilder(BNStructureType type, bool packed) +{ + m_object = BNCreateStructureBuilderWithOptions(type, packed); +} + + +StructureBuilder::StructureBuilder(const StructureBuilder& s) +{ + m_object = BNDuplicateStructureBuilder(s.m_object); +} + + +StructureBuilder::StructureBuilder(StructureBuilder&& s) +{ + m_object = s.m_object; + s.m_object = BNCreateStructureBuilder(); +} + + +StructureBuilder::StructureBuilder(Structure* s) +{ + m_object = BNCreateStructureBuilderFromStructure(s->GetObject()); +} + + +StructureBuilder::~StructureBuilder() +{ + BNFreeStructureBuilder(m_object); +} + + +StructureBuilder& StructureBuilder::operator=(const StructureBuilder& s) +{ + if (this != &s) + { + BNFreeStructureBuilder(m_object); + m_object = BNDuplicateStructureBuilder(s.m_object); + } + return *this; +} + + +StructureBuilder& StructureBuilder::operator=(StructureBuilder&& s) +{ + if (this != &s) + std::swap(m_object, s.m_object); + return *this; +} + + +StructureBuilder& StructureBuilder::operator=(Structure* s) +{ + BNFreeStructureBuilder(m_object); + m_object = BNCreateStructureBuilderFromStructure(s->GetObject()); + return *this; +} + + +Ref StructureBuilder::Finalize() const +{ + return new Structure(BNFinalizeStructureBuilder(m_object)); +} + + +vector StructureBuilder::GetMembers() const +{ + size_t count; + BNStructureMember* members = BNGetStructureBuilderMembers(m_object, &count); + + vector result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + StructureMember member; + member.type = new Type(BNNewTypeReference(members[i].type)); + member.name = members[i].name; + member.offset = members[i].offset; + result.push_back(member); + } + + BNFreeStructureMemberList(members, count); + return result; +} + + +bool StructureBuilder::GetMemberByName(const string& name, StructureMember& result) const +{ + BNStructureMember* member = BNGetStructureBuilderMemberByName(m_object, name.c_str()); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +bool StructureBuilder::GetMemberAtOffset(int64_t offset, StructureMember& result) const +{ + size_t i; + return GetMemberAtOffset(offset, result, i); +} + + +bool StructureBuilder::GetMemberAtOffset(int64_t offset, StructureMember& result, size_t& idx) const +{ + BNStructureMember* member = BNGetStructureBuilderMemberAtOffset(m_object, offset, &idx); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +uint64_t StructureBuilder::GetWidth() const +{ + return BNGetStructureBuilderWidth(m_object); +} + + +void StructureBuilder::SetWidth(size_t width) +{ + BNSetStructureBuilderWidth(m_object, width); +} + + +size_t StructureBuilder::GetAlignment() const +{ + return BNGetStructureBuilderAlignment(m_object); +} + + +void StructureBuilder::SetAlignment(size_t align) +{ + BNSetStructureBuilderAlignment(m_object, align); +} + + +bool StructureBuilder::IsPacked() const +{ + return BNIsStructureBuilderPacked(m_object); +} + + +void StructureBuilder::SetPacked(bool packed) +{ + BNSetStructureBuilderPacked(m_object, packed); +} + + +bool StructureBuilder::IsUnion() const +{ + return BNIsStructureBuilderUnion(m_object); +} + + +void StructureBuilder::SetStructureType(BNStructureType t) +{ + BNSetStructureBuilderType(m_object, t); +} + + +BNStructureType StructureBuilder::GetStructureType() const +{ + return BNGetStructureBuilderType(m_object); +} + + +void StructureBuilder::AddMember(const Confidence>& type, const string& name) +{ + BNTypeWithConfidence tc; + tc.type = type->GetObject(); + tc.confidence = type.GetConfidence(); + BNAddStructureBuilderMember(m_object, &tc, name.c_str()); +} + + +void StructureBuilder::AddMemberAtOffset(const Confidence>& type, const string& name, uint64_t offset) +{ + BNTypeWithConfidence tc; + tc.type = type->GetObject(); + tc.confidence = type.GetConfidence(); + BNAddStructureBuilderMemberAtOffset(m_object, &tc, name.c_str(), offset); +} + + +void StructureBuilder::RemoveMember(size_t idx) +{ + BNRemoveStructureBuilderMember(m_object, idx); +} + + +void StructureBuilder::ReplaceMember(size_t idx, const Confidence>& type, const std::string& name) +{ + BNTypeWithConfidence tc; + tc.type = type->GetObject(); + tc.confidence = type.GetConfidence(); + BNReplaceStructureBuilderMember(m_object, idx, &tc, name.c_str()); +} + + +Enumeration::Enumeration(BNEnumeration* e) +{ + m_object = e; +} + + +vector Enumeration::GetMembers() const +{ + size_t count; + BNEnumerationMember* members = BNGetEnumerationMembers(m_object, &count); + + vector result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + EnumerationMember member; + member.name = members[i].name; + member.value = members[i].value; + member.isDefault = members[i].isDefault; + result.push_back(member); + } + + BNFreeEnumerationMemberList(members, count); + return result; +} + + +EnumerationBuilder::EnumerationBuilder() +{ + m_object = BNCreateEnumerationBuilder(); +} + + +EnumerationBuilder::EnumerationBuilder(BNEnumerationBuilder* e) +{ + m_object = e; +} + + +EnumerationBuilder::EnumerationBuilder(const EnumerationBuilder& e) +{ + m_object = BNDuplicateEnumerationBuilder(e.m_object); +} + + +EnumerationBuilder::EnumerationBuilder(EnumerationBuilder&& e) +{ + m_object = e.m_object; + e.m_object = BNCreateEnumerationBuilder(); +} + + +EnumerationBuilder::EnumerationBuilder(Enumeration* e) +{ + m_object = BNCreateEnumerationBuilderFromEnumeration(e->GetObject()); +} + + +EnumerationBuilder::~EnumerationBuilder() +{ + BNFreeEnumerationBuilder(m_object); +} + + +EnumerationBuilder& EnumerationBuilder::operator=(const EnumerationBuilder& e) +{ + if (this != &e) + { + BNFreeEnumerationBuilder(m_object); + m_object = BNDuplicateEnumerationBuilder(e.m_object); + } + return *this; +} + + +EnumerationBuilder& EnumerationBuilder::operator=(EnumerationBuilder&& e) +{ + if (this != &e) + std::swap(m_object, e.m_object); + return *this; +} + + +EnumerationBuilder& EnumerationBuilder::operator=(Enumeration* e) +{ + BNFreeEnumerationBuilder(m_object); + m_object = BNCreateEnumerationBuilderFromEnumeration(e->GetObject()); + return *this; +} + + +Ref EnumerationBuilder::Finalize() const +{ + return new Enumeration(BNFinalizeEnumerationBuilder(m_object)); +} + + +vector EnumerationBuilder::GetMembers() const +{ + size_t count; + BNEnumerationMember* members = BNGetEnumerationBuilderMembers(m_object, &count); vector result; result.reserve(count); @@ -1246,27 +1989,27 @@ vector Enumeration::GetMembers() const } -void Enumeration::AddMember(const string& name) +void EnumerationBuilder::AddMember(const string& name) { - BNAddEnumerationMember(m_object, name.c_str()); + BNAddEnumerationBuilderMember(m_object, name.c_str()); } -void Enumeration::AddMemberWithValue(const string& name, uint64_t value) +void EnumerationBuilder::AddMemberWithValue(const string& name, uint64_t value) { - BNAddEnumerationMemberWithValue(m_object, name.c_str(), value); + BNAddEnumerationBuilderMemberWithValue(m_object, name.c_str(), value); } -void Enumeration::RemoveMember(size_t idx) +void EnumerationBuilder::RemoveMember(size_t idx) { - BNRemoveEnumerationMember(m_object, idx); + BNRemoveEnumerationBuilderMember(m_object, idx); } -void Enumeration::ReplaceMember(size_t idx, const string& name, uint64_t value) +void EnumerationBuilder::ReplaceMember(size_t idx, const string& name, uint64_t value) { - BNReplaceEnumerationMember(m_object, idx, name.c_str(), value); + BNReplaceEnumerationBuilderMember(m_object, idx, name.c_str(), value); } -- cgit v1.3.1