diff options
| -rw-r--r-- | binaryninjaapi.h | 71 | ||||
| -rw-r--r-- | binaryninjacore.h | 38 | ||||
| -rw-r--r-- | plugins/dwarf/dwarf_export/src/lib.rs | 4 | ||||
| -rw-r--r-- | plugins/warp/src/convert/types.rs | 4 | ||||
| -rw-r--r-- | python/types.py | 110 | ||||
| -rw-r--r-- | type.cpp | 183 |
6 files changed, 390 insertions, 20 deletions
diff --git a/binaryninjaapi.h b/binaryninjaapi.h index e62b1d3e..a36ee271 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -10676,22 +10676,6 @@ namespace BinaryNinja { /*! Retrieve the Type Class for this Structure - One of: - - VoidTypeClass - BoolTypeClass - IntegerTypeClass - FloatTypeClass - StructureTypeClass - EnumerationTypeClass - PointerTypeClass - ArrayTypeClass - FunctionTypeClass - VarArgsTypeClass - ValueTypeClass - NamedTypeReferenceClass - WideCharTypeClass - \return The type class */ BNTypeClass GetClass() const; @@ -10801,6 +10785,14 @@ namespace BinaryNinja { BNPointerBaseType GetPointerBaseType() const; int64_t GetPointerBaseOffset() const; + uint64_t GetFragmentOriginalOffsetBytes() const; + size_t GetFragmentOriginalWidthBytes() const; + size_t GetFragmentStartBit() const; + size_t GetFragmentWidthBits() const; + size_t GetFragmentTruncatedStartBits() const; + size_t GetFragmentWrapBit() const; + BNEndianness GetFragmentEndianness() const; + std::set<BNPointerSuffix> GetPointerSuffix() const; std::string GetPointerSuffixString() const; std::vector<InstructionTextToken> GetPointerSuffixTokens(uint8_t baseConfidence = BN_FULL_CONFIDENCE) const; @@ -10917,6 +10909,33 @@ namespace BinaryNinja { const Confidence<bool>& cnst = Confidence<bool>(false, 0), const Confidence<bool>& vltl = Confidence<bool>(false, 0), BNReferenceType refType = PointerReferenceType); + /*! Create a Fragment type, which represents a bounded load from an existing type + + \param width Width of the fragment in bytes + \param type Type that this fragment was loaded from + \param offset Offset into type that this fragment represents + \param endianness Endianness of the load operation creating the fragment + \return The created type + */ + static Ref<Type> FragmentType(size_t width, const Confidence<Ref<Type>>& type, uint64_t offset, BNEndianness endianness); + + /*! Create a Fragment type, which represents a bounded load from an existing type + + \param width Width of the fragment in its current storage location; can be larger/smaller than the original fragment load + \param type Type that this fragment was loaded from + \param originalFragmentOffsetBytes Offset into type that this fragment represents + \param originalFragmentWidthBytes Width of the initial load that created the fragment + \param endianness Endianness of the load operation creating the fragment + \param fragmentStartBit Logical bit position inside the fragment container where fragment data starts (0 = lsb of fragment type) + \param fragmentWidthBits Number of remaining contiguous bits still represented in the fragment type + \param fragmentTruncatedStartBits Number of low-order bits of fragment data lost + \param wrapBit Logical bit position inside the fragment container where fragment data wraps around (0 = irrelevant) + \return The created type + */ + static Ref<Type> FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit = 0); + /*! Create an Array Type \param type Type for Elements contained in this Array @@ -11217,12 +11236,28 @@ namespace BinaryNinja { BNPointerBaseType GetPointerBaseType() const; int64_t GetPointerBaseOffset() const; + uint64_t GetFragmentOriginalOffsetBytes() const; + size_t GetFragmentOriginalWidthBytes() const; + size_t GetFragmentStartBit() const; + size_t GetFragmentWidthBits() const; + size_t GetFragmentTruncatedStartBits() const; + size_t GetFragmentWrapBit() const; + BNEndianness GetFragmentEndianness() const; + TypeBuilder& SetOffset(uint64_t offset); TypeBuilder& SetFunctionCanReturn(const Confidence<bool>& canReturn); TypeBuilder& SetPure(const Confidence<bool>& pure); TypeBuilder& SetParameters(const std::vector<FunctionParameter>& params); TypeBuilder& SetPointerBase(BNPointerBaseType baseType, int64_t baseOffset); + TypeBuilder& SetFragmentOriginalOffsetBytes(uint64_t offset); + TypeBuilder& SetFragmentOriginalWidthBytes(size_t size); + TypeBuilder& SetFragmentStartBit(size_t startBit); + TypeBuilder& SetFragmentWidthBits(size_t widthBits); + TypeBuilder& SetFragmentTruncatedStartBits(size_t truncatedBits); + TypeBuilder& SetFragmentWrapBit(size_t wrapBit); + TypeBuilder& SetFragmentEndianness(BNEndianness endianness); + std::set<BNPointerSuffix> GetPointerSuffix() const; std::string GetPointerSuffixString() const; std::vector<InstructionTextToken> GetPointerSuffixTokens(uint8_t baseConfidence = BN_FULL_CONFIDENCE) const; @@ -11274,6 +11309,10 @@ namespace BinaryNinja { static TypeBuilder PointerType(size_t width, const Confidence<Ref<Type>>& type, const Confidence<bool>& cnst = Confidence<bool>(false, 0), const Confidence<bool>& vltl = Confidence<bool>(false, 0), BNReferenceType refType = PointerReferenceType); + static TypeBuilder FragmentType(size_t width, const Confidence<Ref<Type>>& type, uint64_t offset, BNEndianness endianness); + static TypeBuilder FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit = 0); static TypeBuilder ArrayType(const Confidence<Ref<Type>>& type, uint64_t elem); static TypeBuilder FunctionType(const Confidence<Ref<Type>>& returnValue, const Confidence<Ref<CallingConvention>>& callingConvention, const std::vector<FunctionParameter>& params, diff --git a/binaryninjacore.h b/binaryninjacore.h index 2cd8df31..f140ef91 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -37,14 +37,14 @@ // Current ABI version for linking to the core. This is incremented any time // there are changes to the API that affect linking, including new functions, // new types, or modifications to existing functions or types. -#define BN_CURRENT_CORE_ABI_VERSION 164 +#define BN_CURRENT_CORE_ABI_VERSION 165 // Minimum ABI version that is supported for loading of plugins. Plugins that // are linked to an ABI version less than this will not be able to load and // will require rebuilding. The minimum version is increased when there are // incompatible changes that break binary compatibility, such as changes to // existing types or functions. -#define BN_MINIMUM_CORE_ABI_VERSION 164 +#define BN_MINIMUM_CORE_ABI_VERSION 165 #ifdef __GNUC__ #ifdef BINARYNINJACORE_LIBRARY @@ -871,7 +871,8 @@ extern "C" VarArgsTypeClass = 9, ValueTypeClass = 10, NamedTypeReferenceClass = 11, - WideCharTypeClass = 12 + WideCharTypeClass = 12, + FragmentTypeClass = 13, }; BN_ENUM(uint8_t, BNNamedTypeReferenceClass) @@ -7006,6 +7007,11 @@ extern "C" BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, BNReferenceType refType); BINARYNINJACOREAPI BNType* BNCreatePointerTypeOfWidth(size_t width, const BNTypeWithConfidence* const type, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, BNReferenceType refType); + BINARYNINJACOREAPI BNType* BNCreateFragmentType(size_t width, const BNTypeWithConfidence* const type, + uint64_t offset, BNEndianness endianness); + BINARYNINJACOREAPI BNType* BNCreateFragmentTypeBits(size_t width, const BNTypeWithConfidence* const type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit); BINARYNINJACOREAPI BNType* BNCreateArrayType(const BNTypeWithConfidence* const type, uint64_t elem); BINARYNINJACOREAPI BNType* BNCreateFunctionType(BNTypeWithConfidence* returnValue, BNCallingConventionWithConfidence* callingConvention, BNFunctionParameter* params, size_t paramCount, BNBoolWithConfidence* varArg, @@ -7041,6 +7047,11 @@ extern "C" BINARYNINJACOREAPI BNTypeBuilder* BNCreatePointerTypeBuilderOfWidth(size_t width, const BNTypeWithConfidence* const type, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl, BNReferenceType refType); + BINARYNINJACOREAPI BNTypeBuilder* BNCreateFragmentTypeBuilder(size_t width, const BNTypeWithConfidence* const type, + uint64_t offset, BNEndianness endianness); + BINARYNINJACOREAPI BNTypeBuilder* BNCreateFragmentTypeBuilderBits(size_t width, const BNTypeWithConfidence* const type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit); BINARYNINJACOREAPI BNTypeBuilder* BNCreateArrayTypeBuilder(const BNTypeWithConfidence* const type, uint64_t elem); BINARYNINJACOREAPI BNTypeBuilder* BNCreateFunctionTypeBuilder(BNTypeWithConfidence* returnValue, BNCallingConventionWithConfidence* callingConvention, BNFunctionParameter* params, size_t paramCount, BNBoolWithConfidence* varArg, @@ -7078,6 +7089,13 @@ extern "C" BINARYNINJACOREAPI BNNamedTypeReference* BNGetTypeNamedTypeReference(BNType* type); BINARYNINJACOREAPI uint64_t BNGetTypeElementCount(BNType* type); BINARYNINJACOREAPI uint64_t BNGetTypeOffset(BNType* type); + BINARYNINJACOREAPI uint64_t BNGetTypeFragmentOriginalOffsetBytes(BNType* type); + BINARYNINJACOREAPI size_t BNGetTypeFragmentOriginalWidthBytes(BNType* type); + BINARYNINJACOREAPI size_t BNGetTypeFragmentStartBit(BNType* type); + BINARYNINJACOREAPI size_t BNGetTypeFragmentWidthBits(BNType* type); + BINARYNINJACOREAPI size_t BNGetTypeFragmentTruncatedStartBits(BNType* type); + BINARYNINJACOREAPI size_t BNGetTypeFragmentWrapBit(BNType* type); + BINARYNINJACOREAPI BNEndianness BNGetTypeFragmentEndianness(BNType* type); BINARYNINJACOREAPI BNOffsetWithConfidence BNGetTypeStackAdjustment(BNType* type); BINARYNINJACOREAPI BNQualifiedName BNTypeGetStructureName(BNType* type); BINARYNINJACOREAPI BNNamedTypeReference* BNGetRegisteredTypeName(BNType* type); @@ -7145,8 +7163,22 @@ extern "C" BINARYNINJACOREAPI void BNSetTypeBuilderNamedTypeReference(BNTypeBuilder* type, BNNamedTypeReference* ntr); BINARYNINJACOREAPI uint64_t BNGetTypeBuilderElementCount(BNTypeBuilder* type); BINARYNINJACOREAPI uint64_t BNGetTypeBuilderOffset(BNTypeBuilder* type); + BINARYNINJACOREAPI uint64_t BNGetTypeBuilderFragmentOriginalOffsetBytes(BNTypeBuilder* type); + BINARYNINJACOREAPI size_t BNGetTypeBuilderFragmentOriginalWidthBytes(BNTypeBuilder* type); + BINARYNINJACOREAPI size_t BNGetTypeBuilderFragmentStartBit(BNTypeBuilder* type); + BINARYNINJACOREAPI size_t BNGetTypeBuilderFragmentWidthBits(BNTypeBuilder* type); + BINARYNINJACOREAPI size_t BNGetTypeBuilderFragmentTruncatedStartBits(BNTypeBuilder* type); + BINARYNINJACOREAPI size_t BNGetTypeBuilderFragmentWrapBit(BNTypeBuilder* type); + BINARYNINJACOREAPI BNEndianness BNGetTypeBuilderFragmentEndianness(BNTypeBuilder* type); BINARYNINJACOREAPI void BNSetTypeBuilderOffset(BNTypeBuilder* type, uint64_t offset); BINARYNINJACOREAPI void BNSetTypeBuilderPointerBase(BNTypeBuilder* type, BNPointerBaseType baseType, int64_t baseOffset); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentOriginalOffsetBytes(BNTypeBuilder* type, uint64_t offset); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentOriginalWidthBytes(BNTypeBuilder* type, size_t size); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentStartBit(BNTypeBuilder* type, size_t startBit); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentWidthBits(BNTypeBuilder* type, size_t widthBits); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentTruncatedStartBits(BNTypeBuilder* type, size_t truncatedBits); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentWrapBit(BNTypeBuilder* type, size_t wrapBit); + BINARYNINJACOREAPI void BNSetTypeBuilderFragmentEndianness(BNTypeBuilder* type, BNEndianness endianness); BINARYNINJACOREAPI void BNSetFunctionTypeBuilderCanReturn(BNTypeBuilder* type, BNBoolWithConfidence* canReturn); BINARYNINJACOREAPI void BNSetTypeBuilderPure(BNTypeBuilder* type, BNBoolWithConfidence* pure); BINARYNINJACOREAPI void BNSetFunctionTypeBuilderParameters( diff --git a/plugins/dwarf/dwarf_export/src/lib.rs b/plugins/dwarf/dwarf_export/src/lib.rs index 284ca34b..fac7b2bb 100644 --- a/plugins/dwarf/dwarf_export/src/lib.rs +++ b/plugins/dwarf/dwarf_export/src/lib.rs @@ -401,6 +401,10 @@ fn export_type( ); Some(wide_char_die_uid) } + TypeClass::FragmentTypeClass => { + tracing::error!("Fragment types are not representable in DWARF"); + None + } } } diff --git a/plugins/warp/src/convert/types.rs b/plugins/warp/src/convert/types.rs index 8421eb5e..abfa3bc9 100644 --- a/plugins/warp/src/convert/types.rs +++ b/plugins/warp/src/convert/types.rs @@ -244,6 +244,10 @@ pub fn from_bn_type_internal( }; TypeClass::Character(char_class) } + BNTypeClass::FragmentTypeClass => { + // XXX: possibly unrepresentable? + TypeClass::Void + } }; let name = raw_ty.registered_name().map(|n| n.name().to_string()); diff --git a/python/types.py b/python/types.py index c149c70a..b47d98ce 100644 --- a/python/types.py +++ b/python/types.py @@ -31,7 +31,8 @@ from .enums import ( ReferenceType, VariableSourceType, TypeReferenceType, MemberAccess, MemberScope, TypeDefinitionLineType, TokenEscapingType, - NameType, PointerSuffix, PointerBaseType + NameType, PointerSuffix, PointerBaseType, + Endianness ) from . import callingconvention from . import function as _function @@ -655,6 +656,7 @@ class TypeBuilder: TypeClass.StructureTypeClass: StructureType, TypeClass.EnumerationTypeClass: EnumerationType, TypeClass.NamedTypeReferenceClass: NamedTypeReferenceType, + TypeClass.FragmentTypeClass: FragmentType, } return Types[self.type_class](self._finalized, self.platform, self.confidence) @@ -1125,6 +1127,74 @@ class PointerBuilder(TypeBuilder): def pointer_base_offset(self, value: int): self.set_pointer_base(self.pointer_base_type, value) +class FragmentBuilder(TypeBuilder): + @classmethod + def create( + cls, type: SomeType, width: int, + offset: int, endianness: Endianness = Endianness.LittleEndian, + confidence: int = core.max_confidence + ) -> 'FragmentBuilder': + ic = type.immutable_copy() + handle = core.BNCreateFragmentTypeBuilder(width, ic._to_core_struct(), offset, endianness) + assert handle is not None, "BNCreateFragmentTypeBuilder returned None" + return cls(handle, None, confidence) + + @property + def offset(self) -> int: + return core.BNGetTypeBuilderFragmentOriginalOffsetBytes(self._handle) + + @offset.setter + def offset(self, value: int): + core.BNSetTypeBuilderFragmentOriginalOffsetBytes(self._handle, value) + + @property + def fragment_original_width(self) -> int: + return core.BNGetTypeBuilderFragmentOriginalWidthBytes(self._handle) + + @fragment_original_width.setter + def fragment_original_width(self, value: int): + core.BNSetTypeBuilderFragmentOriginalWidthBytes(self._handle, value) + + @property + def fragment_start_bit(self) -> int: + return core.BNGetTypeBuilderFragmentStartBit(self._handle) + + @fragment_start_bit.setter + def fragment_start_bit(self, value: int): + core.BNSetTypeBuilderFragmentStartBit(self._handle, value) + + @property + def fragment_width_bits(self) -> int: + return core.BNGetTypeBuilderFragmentWidthBits(self._handle) + + @fragment_width_bits.setter + def fragment_width_bits(self, value: int): + core.BNSetTypeBuilderFragmentWidthBits(self._handle, value) + + @property + def fragment_truncated_start_bits(self) -> int: + return core.BNGetTypeBuilderFragmentTruncatedStartBits(self._handle) + + @fragment_truncated_start_bits.setter + def fragment_truncated_start_bits(self, value: int): + core.BNSetTypeBuilderFragmentTruncatedStartBits(self._handle, value) + + @property + def fragment_wrap_bit(self) -> int: + return core.BNGetTypeBuilderFragmentWrapBit(self._handle) + + @fragment_wrap_bit.setter + def fragment_wrap_bit(self, value: int): + core.BNSetTypeBuilderFragmentWrapBit(self._handle, value) + + @property + def endianness(self) -> Endianness: + return Endianness(core.BNGetTypeBuilderFragmentEndianness(self._handle)) + + @endianness.setter + def endianness(self, value: Endianness): + core.BNSetTypeBuilderFragmentEndianness(self._handle, value) + class ArrayBuilder(TypeBuilder): @classmethod @@ -2289,6 +2359,7 @@ class Type: TypeClass.IntegerTypeClass: IntegerBuilder, TypeClass.FloatTypeClass: FloatBuilder, TypeClass.PointerTypeClass: PointerBuilder, TypeClass.ArrayTypeClass: ArrayBuilder, TypeClass.FunctionTypeClass: FunctionBuilder, TypeClass.WideCharTypeClass: WideCharBuilder, + TypeClass.FragmentTypeClass: FragmentBuilder, # TypeClass.StructureTypeClass:Structure, # TypeClass.EnumerationTypeClass:Enumeration, # TypeClass.NamedTypeReferenceClass:NamedTypeReference, @@ -3484,6 +3555,42 @@ class WideCharType(Type): assert core_type is not None, "core.BNCreateWideCharType returned None" return cls(core_type, platform, confidence) +class FragmentType(Type): + @property + def target(self) -> Type: + """Target (read-only)""" + result = core.BNGetChildType(self._handle) + assert result is not None, "core.BNGetChildType returned None" + return Type.create(result.type, self._platform, result.confidence) + + @property + def offset(self) -> int: + return core.BNGetTypeFragmentOriginalOffsetBytes(self._handle) + + @property + def fragment_original_width_bytes(self) -> int: + return core.BNGetTypeFragmentOriginalWidthBytes(self._handle) + + @property + def fragment_start_bit(self) -> int: + return core.BNGetTypeFragmentStartBit(self._handle) + + @property + def fragment_width_bits(self) -> int: + return core.BNGetTypeFragmentWidthBits(self._handle) + + @property + def fragment_truncated_start_bits(self) -> int: + return core.BNGetTypeFragmentTruncatedStartBits(self._handle) + + @property + def fragment_wrap_bit(self) -> int: + return core.BNGetTypeFragmentWrapBit(self._handle) + + @property + def fragment_endianness(self) -> Endianness: + return Endianness(core.BNGetTypeFragmentEndianness(self._handle)) + Types = { TypeClass.VoidTypeClass: VoidType, TypeClass.BoolTypeClass: BoolType, TypeClass.IntegerTypeClass: IntegerType, @@ -3491,6 +3598,7 @@ Types = { TypeClass.EnumerationTypeClass: EnumerationType, TypeClass.PointerTypeClass: PointerType, TypeClass.ArrayTypeClass: ArrayType, TypeClass.FunctionTypeClass: FunctionType, TypeClass.NamedTypeReferenceClass: NamedTypeReferenceType, TypeClass.WideCharTypeClass: WideCharType, + TypeClass.FragmentTypeClass: FragmentType, } @@ -716,6 +716,48 @@ int64_t Type::GetPointerBaseOffset() const } +uint64_t Type::GetFragmentOriginalOffsetBytes() const +{ + return BNGetTypeFragmentOriginalOffsetBytes(m_object); +} + + +size_t Type::GetFragmentOriginalWidthBytes() const +{ + return BNGetTypeFragmentOriginalWidthBytes(m_object); +} + + +size_t Type::GetFragmentStartBit() const +{ + return BNGetTypeFragmentStartBit(m_object); +} + + +size_t Type::GetFragmentWidthBits() const +{ + return BNGetTypeFragmentWidthBits(m_object); +} + + +size_t Type::GetFragmentTruncatedStartBits() const +{ + return BNGetTypeFragmentTruncatedStartBits(m_object); +} + + +size_t Type::GetFragmentWrapBit() const +{ + return BNGetTypeFragmentWrapBit(m_object); +} + + +BNEndianness Type::GetFragmentEndianness() const +{ + return BNGetTypeFragmentEndianness(m_object); +} + + Confidence<int64_t> Type::GetStackAdjustment() const { BNOffsetWithConfidence result = BNGetTypeStackAdjustment(m_object); @@ -991,6 +1033,31 @@ Ref<Type> Type::PointerType(size_t width, const Confidence<Ref<Type>>& type, con } +Ref<Type> Type::FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t offset, BNEndianness endianness) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + return new Type(BNCreateFragmentType(width, &typeConf, offset, endianness)); +} + + +Ref<Type> Type::FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + return new Type(BNCreateFragmentTypeBits(width, &typeConf, + originalFragmentOffsetBytes, originalFragmentWidthBytes, endianness, + fragmentStartBit, fragmentWidthBits, fragmentTruncatedStartBits, wrapBit)); +} + + Ref<Type> Type::ArrayType(const Confidence<Ref<Type>>& type, uint64_t elem) { BNTypeWithConfidence typeConf; @@ -1985,6 +2052,31 @@ TypeBuilder TypeBuilder::PointerType(size_t width, const Confidence<Ref<Type>>& } +TypeBuilder TypeBuilder::FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t offset, BNEndianness endianness) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + return TypeBuilder(BNCreateFragmentTypeBuilder(width, &typeConf, offset, endianness)); +} + + +TypeBuilder TypeBuilder::FragmentType(size_t width, const Confidence<Ref<Type>>& type, + uint64_t originalFragmentOffsetBytes, size_t originalFragmentWidthBytes, BNEndianness endianness, + size_t fragmentStartBit, size_t fragmentWidthBits, size_t fragmentTruncatedStartBits, size_t wrapBit) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + return TypeBuilder(BNCreateFragmentTypeBuilderBits(width, &typeConf, + originalFragmentOffsetBytes, originalFragmentWidthBytes, endianness, + fragmentStartBit, fragmentWidthBits, fragmentTruncatedStartBits, wrapBit)); +} + + TypeBuilder TypeBuilder::ArrayType(const Confidence<Ref<Type>>& type, uint64_t elem) { BNTypeWithConfidence typeConf; @@ -2180,6 +2272,55 @@ TypeBuilder& TypeBuilder::SetPointerBase(BNPointerBaseType baseType, int64_t bas } +TypeBuilder& TypeBuilder::SetFragmentOriginalOffsetBytes(uint64_t offset) +{ + BNSetTypeBuilderFragmentOriginalOffsetBytes(m_object, offset); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentOriginalWidthBytes(size_t width) +{ + BNSetTypeBuilderFragmentOriginalWidthBytes(m_object, width); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentStartBit(size_t startBit) +{ + BNSetTypeBuilderFragmentStartBit(m_object, startBit); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentWidthBits(size_t widthBits) +{ + BNSetTypeBuilderFragmentWidthBits(m_object, widthBits); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentTruncatedStartBits(size_t truncatedBits) +{ + BNSetTypeBuilderFragmentTruncatedStartBits(m_object, truncatedBits); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentWrapBit(size_t wrapBit) +{ + BNSetTypeBuilderFragmentWrapBit(m_object, wrapBit); + return *this; +} + + +TypeBuilder& TypeBuilder::SetFragmentEndianness(BNEndianness endianness) +{ + BNSetTypeBuilderFragmentEndianness(m_object, endianness); + return *this; +} + + std::set<BNPointerSuffix> TypeBuilder::GetPointerSuffix() const { size_t count = 0; @@ -2335,6 +2476,48 @@ int64_t TypeBuilder::GetPointerBaseOffset() const } +uint64_t TypeBuilder::GetFragmentOriginalOffsetBytes() const +{ + return BNGetTypeBuilderFragmentOriginalOffsetBytes(m_object); +} + + +size_t TypeBuilder::GetFragmentOriginalWidthBytes() const +{ + return BNGetTypeBuilderFragmentOriginalWidthBytes(m_object); +} + + +size_t TypeBuilder::GetFragmentStartBit() const +{ + return BNGetTypeBuilderFragmentStartBit(m_object); +} + + +size_t TypeBuilder::GetFragmentWidthBits() const +{ + return BNGetTypeBuilderFragmentWidthBits(m_object); +} + + +size_t TypeBuilder::GetFragmentTruncatedStartBits() const +{ + return BNGetTypeBuilderFragmentTruncatedStartBits(m_object); +} + + +size_t TypeBuilder::GetFragmentWrapBit() const +{ + return BNGetTypeBuilderFragmentWrapBit(m_object); +} + + +BNEndianness TypeBuilder::GetFragmentEndianness() const +{ + return BNGetTypeBuilderFragmentEndianness(m_object); +} + + QualifiedName TypeBuilder::GetStructureName() const { BNQualifiedName name = BNTypeBuilderGetStructureName(m_object); |