types: fragment type API support (C++, Python)

Author: rssor

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,

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 163
+#define BN_CURRENT_CORE_ABI_VERSION 164
 
 // 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 163
+#define BN_MINIMUM_CORE_ABI_VERSION 164
 
 #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(

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
+        }
     }
 }
 

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());

python/types.py

@@ -31,7 +31,8 @@
 	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 @@ def immutable_copy(self):
 		    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 @@ def pointer_base_offset(self) -> int:
 	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 @@ def mutable_copy(self) -> 'TypeBuilder':
 		    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,13 +3555,43 @@ def create(
 		assert core_type is not None, "core.BNCreateWideCharType returned None"
 		return cls(core_type, platform, confidence)
 
+class FragmentType(Type):
+	@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,
     TypeClass.FloatTypeClass: FloatType, TypeClass.StructureTypeClass: StructureType,
     TypeClass.EnumerationTypeClass: EnumerationType, TypeClass.PointerTypeClass: PointerType,
     TypeClass.ArrayTypeClass: ArrayType, TypeClass.FunctionTypeClass: FunctionType,
     TypeClass.NamedTypeReferenceClass: NamedTypeReferenceType, TypeClass.WideCharTypeClass: WideCharType,
+    TypeClass.FragmentTypeClass: FragmentType,
 }