Allow the creation of const/volatile NTRs

5 files changed, 81 insertions, 26 deletions

diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index 828da41b..77b949b6 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -2829,7 +2829,8 @@ __attribute__ ((format (printf, 1, 2)))
 		static Ref<Type> FloatType(size_t width, const std::string& altName = "");
 		static Ref<Type> WideCharType(size_t width, const std::string& altName = "");
 		static Ref<Type> StructureType(Structure* strct);
-		static Ref<Type> NamedType(NamedTypeReference* ref, size_t width = 0, size_t align = 1);
+		static Ref<Type> NamedType(NamedTypeReference* ref, size_t width = 0, size_t align = 1,
+			const Confidence<bool>& cnst = Confidence<bool>(false, 0), const Confidence<bool>& vltl = Confidence<bool>(false, 0));
 		static Ref<Type> NamedType(const QualifiedName& name, Type* type);
 		static Ref<Type> NamedType(const std::string& id, const QualifiedName& name, Type* type);
 		static Ref<Type> NamedType(BinaryView* view, const QualifiedName& name);
@@ -2959,8 +2960,10 @@ __attribute__ ((format (printf, 1, 2)))
 		static TypeBuilder WideCharType(size_t width, const std::string& typeName = "");
 		static TypeBuilder StructureType(Structure* strct);
 		static TypeBuilder StructureType(StructureBuilder* strct);
-		static TypeBuilder NamedType(NamedTypeReference* ref, size_t width = 0, size_t align = 1);
-		static TypeBuilder NamedType(NamedTypeReferenceBuilder* ref, size_t width = 0, size_t align = 1);
+		static TypeBuilder NamedType(NamedTypeReference* ref, size_t width = 0, size_t align = 1,
+			const Confidence<bool>& cnst = Confidence<bool>(false, 0), const Confidence<bool>& vltl = Confidence<bool>(false, 0));
+		static TypeBuilder NamedType(NamedTypeReferenceBuilder* ref, size_t width = 0, size_t align = 1,
+			const Confidence<bool>& cnst = Confidence<bool>(false, 0), const Confidence<bool>& vltl = Confidence<bool>(false, 0));
 		static TypeBuilder NamedType(const QualifiedName& name, Type* type);
 		static TypeBuilder NamedType(const std::string& id, const QualifiedName& name, Type* type);
 		static TypeBuilder NamedType(BinaryView* view, const QualifiedName& name);
diff --git a/binaryninjacore.h b/binaryninjacore.h
index 1943d8a2..5a9edfc2 100644
--- a/binaryninjacore.h
+++ b/binaryninjacore.h
@@ -28,14 +28,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 14
+#define BN_CURRENT_CORE_ABI_VERSION 15
 
 // 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 12
+#define BN_MINIMUM_CORE_ABI_VERSION 13
 
 #ifdef __GNUC__
 #  ifdef BINARYNINJACORE_LIBRARY
@@ -4845,11 +4845,11 @@ __attribute__ ((format (printf, 1, 2)))
 	BINARYNINJACOREAPI BNInstructionTextToken* BNGetTypeBuilderTokensAfterName(BNTypeBuilder* type, BNPlatform* platform,
 		uint8_t baseConfidence, size_t* count);
 
-	BINARYNINJACOREAPI BNType* BNCreateNamedTypeReference(BNNamedTypeReference* nt, size_t width, size_t align);
+	BINARYNINJACOREAPI BNType* BNCreateNamedTypeReference(BNNamedTypeReference* nt, size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl);
 	BINARYNINJACOREAPI BNType* BNCreateNamedTypeReferenceFromTypeAndId(const char* id, BNQualifiedName* name, BNType* type);
 	BINARYNINJACOREAPI BNType* BNCreateNamedTypeReferenceFromType(BNBinaryView* view, BNQualifiedName* name);
-	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilder(BNNamedTypeReference* nt, size_t width, size_t align);
-	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderWithBuilder(BNNamedTypeReferenceBuilder* nt, size_t width, size_t align);
+	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilder(BNNamedTypeReference* nt, size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl);
+	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderWithBuilder(BNNamedTypeReferenceBuilder* nt, size_t width, size_t align, BNBoolWithConfidence* cnst, BNBoolWithConfidence* vltl);
 	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderFromTypeAndId(const char* id, BNQualifiedName* name, BNType* type);
 	BINARYNINJACOREAPI BNTypeBuilder* BNCreateNamedTypeReferenceBuilderFromType(BNBinaryView* view, BNQualifiedName* name);
 	BINARYNINJACOREAPI BNNamedTypeReference* BNCreateNamedType(BNNamedTypeReferenceClass cls, const char* id, BNQualifiedName* name);
diff --git a/python/types.py b/python/types.py
index 7ce9e2cb..ad3d4590 100644
--- a/python/types.py
+++ b/python/types.py
@@ -674,8 +674,11 @@ class TypeBuilder:
 
 	@staticmethod
 	def named_type_reference(type_class:NamedTypeReferenceClass, name:QualifiedName,
-		type_id:Optional[str]=None, alignment:_int=1, width:_int=0) -> 'NamedTypeReferenceBuilder':
-		return NamedTypeReferenceBuilder.create(type_class, type_id, name, width, alignment)
+		type_id:Optional[str]=None, alignment:_int=1, width:_int=0,
+		const:BoolWithConfidenceType=BoolWithConfidence(False),
+		volatile:BoolWithConfidenceType=BoolWithConfidence(False)) -> 'NamedTypeReferenceBuilder':
+		return NamedTypeReferenceBuilder.create(type_class, type_id, name, width, alignment,
+			None, core.max_confidence, const, volatile)
 
 	@property
 	def width(self) -> _int:
@@ -1339,17 +1342,25 @@ class NamedTypeReferenceBuilder(TypeBuilder):
 	@classmethod
 	def create(cls, type_class:NamedTypeReferenceClass=NamedTypeReferenceClass.UnknownNamedTypeClass,
 		type_id:Optional[str]=None, name:QualifiedName=QualifiedName(""), width:int=0, align:int=1,
-		platform:'_platform.Platform'=None, confidence:int=core.max_confidence) -> 'NamedTypeReferenceBuilder':
+		platform:'_platform.Platform'=None, confidence:int=core.max_confidence,
+		const:BoolWithConfidenceType=False, volatile:BoolWithConfidenceType=False) -> 'NamedTypeReferenceBuilder':
 		ntr_builder_handle = core.BNCreateNamedTypeBuilder(type_class, type_id, name._to_core_struct())
 		assert ntr_builder_handle is not None, "core.BNCreateNamedTypeBuilder returned None"
-		type_builder_handle = core.BNCreateNamedTypeReferenceBuilderWithBuilder(ntr_builder_handle, width, align)
+
+		_const = BoolWithConfidence.get_core_struct(const)
+		_volatile = BoolWithConfidence.get_core_struct(volatile)
+		type_builder_handle = core.BNCreateNamedTypeReferenceBuilderWithBuilder(ntr_builder_handle, width, align, _const, _volatile)
 		assert type_builder_handle is not None, "core.BNCreateNamedTypeReferenceBuilderWithBuilder returned None"
 		return cls(type_builder_handle, ntr_builder_handle, platform, confidence)
 
 	def immutable_copy(self) -> 'NamedTypeReferenceType':
 		ntr_handle = core.BNFinalizeNamedTypeReferenceBuilder(self.ntr_builder_handle)
 		assert ntr_handle is not None, "core.BNFinalizeEnumerationBuilder returned None"
-		handle = core.BNCreateNamedTypeReference(ntr_handle, self.width, self.alignment)
+
+		_const = BoolWithConfidence.get_core_struct(self.const)
+		_volatile = BoolWithConfidence.get_core_struct(self.volatile)
+
+		handle = core.BNCreateNamedTypeReference(ntr_handle, self.width, self.alignment, _const, _volatile)
 		assert handle is not None, "core.BNCreateEnumerationType returned None"
 		return NamedTypeReferenceType(handle, self.platform, self.confidence)
 
@@ -1370,8 +1381,11 @@ class NamedTypeReferenceBuilder(TypeBuilder):
 		return NamedTypeReferenceClass(core.BNGetTypeReferenceBuilderClass(self.ntr_builder_handle))
 
 	@staticmethod
-	def named_type(named_type:'NamedTypeReferenceBuilder', width:int=0, align:int=1) -> 'NamedTypeReferenceBuilder':
-		return NamedTypeReferenceBuilder.create(named_type.named_type_class, named_type.id, named_type.name, width, align)
+	def named_type(named_type:'NamedTypeReferenceBuilder', width:int=0, align:int=1,
+		const:BoolWithConfidenceType=BoolWithConfidence(False),
+		volatile:BoolWithConfidenceType=BoolWithConfidence(False)) -> 'NamedTypeReferenceBuilder':
+		return NamedTypeReferenceBuilder.create(named_type.named_type_class, named_type.id,
+			named_type.name, width, align, const, volatile)
 
 	@staticmethod
 	def named_type_from_type_and_id(type_id:str, name:QualifiedName, type:Optional['Type']) -> 'NamedTypeReferenceBuilder':
@@ -1756,8 +1770,11 @@ class Type:
 
 	@staticmethod
 	def named_type_reference(type_class:NamedTypeReferenceClass, name:QualifiedName,
-		type_id:Optional[str]=None, alignment:_int=1, width:_int=0):
-		return NamedTypeReferenceType.create(type_class, type_id, name, alignment, width)
+		type_id:Optional[str]=None, alignment:_int=1, width:_int=0,
+		const:BoolWithConfidenceType=BoolWithConfidence(False),
+		volatile:BoolWithConfidenceType=BoolWithConfidence(False)):
+		return NamedTypeReferenceType.create(type_class, type_id, name, alignment, width,
+			None, core.max_confidence, const, volatile)
 
 	@property
 	@abstractmethod
@@ -2235,7 +2252,7 @@ class NamedTypeReferenceType(Type):
 	@classmethod
 	def create(cls, named_type_class:NamedTypeReferenceClass, guid:Optional[str],
 		name:QualifiedName, alignment:int=0, width:int=0, platform:'_platform.Platform'=None,
-		confidence:int=core.max_confidence) -> 'NamedTypeReferenceType':
+		confidence:int=core.max_confidence, const:BoolWithConfidenceType=False, volatile:BoolWithConfidenceType=False) -> 'NamedTypeReferenceType':
 		_guid = guid
 		if guid is None:
 			_guid = str(uuid.uuid4())
@@ -2243,7 +2260,10 @@ class NamedTypeReferenceType(Type):
 		_name = QualifiedName(name)._to_core_struct()
 		core_ntr = core.BNCreateNamedType(named_type_class, _guid, _name)
 		assert core_ntr is not None, "core.BNCreateNamedType returned None"
-		core_type = core.BNCreateNamedTypeReference(core_ntr, width, alignment)
+
+		_const = BoolWithConfidence.get_core_struct(const)
+		_volatile = BoolWithConfidence.get_core_struct(volatile)
+		core_type = core.BNCreateNamedTypeReference(core_ntr, width, alignment, _const, _volatile)
 		assert core_type is not None, "core.BNCreateNamedTypeReference returned None"
 		return cls(core.BNNewTypeReference(core_type), platform, confidence)
 
diff --git a/rust/src/types.rs b/rust/src/types.rs
index 2567f72d..ec36e5d9 100644
--- a/rust/src/types.rs
+++ b/rust/src/types.rs
@@ -397,11 +397,15 @@ impl TypeBuilder {
     }
 
     pub fn named_type(type_reference: NamedTypeReference) -> Self {
+        let mut is_const = Conf::new(false, min_confidence()).into();
+        let mut is_volatile = Conf::new(false, min_confidence()).into();
         unsafe {
             Self::from_raw(BNCreateNamedTypeReferenceBuilder(
                 type_reference.handle,
                 0,
                 1,
+                &mut is_const,
+                &mut is_volatile
             ))
         }
     }
@@ -744,7 +748,13 @@ impl Type {
     }
 
     pub fn named_type(type_reference: &NamedTypeReference) -> Ref<Self> {
-        unsafe { Self::ref_from_raw(BNCreateNamedTypeReference(type_reference.handle, 0, 1)) }
+        let mut is_const = Conf::new(false, min_confidence()).into();
+        let mut is_volatile = Conf::new(false, min_confidence()).into();
+        unsafe { Self::ref_from_raw(BNCreateNamedTypeReference(type_reference.handle,
+                0,
+                1,
+                &mut is_const,
+                &mut is_volatile)) }
     }
 
     pub fn named_type_from_type<S: BnStrCompatible>(name: S, t: &Type) -> Ref<Self> {
diff --git a/type.cpp b/type.cpp
index bbc1c233..6762a21b 100644
--- a/type.cpp
+++ b/type.cpp
@@ -707,9 +707,17 @@ Ref<Type> Type::StructureType(Structure* strct)
 }
 
 
-Ref<Type> Type::NamedType(NamedTypeReference* ref, size_t width, size_t align)
+Ref<Type> Type::NamedType(NamedTypeReference* ref, size_t width, size_t align, const Confidence<bool>& cnst, const Confidence<bool>& vltl)
 {
-	return new Type(BNCreateNamedTypeReference(ref->GetObject(), width, align));
+	BNBoolWithConfidence cnstConf;
+	cnstConf.value = cnst.GetValue();
+	cnstConf.confidence = cnst.GetConfidence();
+
+	BNBoolWithConfidence vltlConf;
+	vltlConf.value = vltl.GetValue();
+	vltlConf.confidence = vltl.GetConfidence();
+
+	return new Type(BNCreateNamedTypeReference(ref->GetObject(), width, align, &cnstConf, &vltlConf));
 }
 
 
@@ -1369,15 +1377,29 @@ TypeBuilder TypeBuilder::StructureType(StructureBuilder* strct)
 }
 
 
-TypeBuilder TypeBuilder::NamedType(NamedTypeReference* ref, size_t width, size_t align)
+TypeBuilder TypeBuilder::NamedType(NamedTypeReference* ref, size_t width, size_t align, const Confidence<bool>& cnst, const Confidence<bool>& vltl)
 {
-	return TypeBuilder(BNCreateNamedTypeReferenceBuilder(ref->GetObject(), width, align));
+	BNBoolWithConfidence cnstConf;
+	cnstConf.value = cnst.GetValue();
+	cnstConf.confidence = cnst.GetConfidence();
+
+	BNBoolWithConfidence vltlConf;
+	vltlConf.value = vltl.GetValue();
+	vltlConf.confidence = vltl.GetConfidence();
+	return TypeBuilder(BNCreateNamedTypeReferenceBuilder(ref->GetObject(), width, align, &cnstConf, &vltlConf));
 }
 
 
-TypeBuilder TypeBuilder::NamedType(NamedTypeReferenceBuilder* ref, size_t width, size_t align)
+TypeBuilder TypeBuilder::NamedType(NamedTypeReferenceBuilder* ref, size_t width, size_t align, const Confidence<bool>& cnst, const Confidence<bool>& vltl)
 {
-	return TypeBuilder(BNCreateNamedTypeReferenceBuilderWithBuilder(ref->GetObject(), width, align));
+	BNBoolWithConfidence cnstConf;
+	cnstConf.value = cnst.GetValue();
+	cnstConf.confidence = cnst.GetConfidence();
+
+	BNBoolWithConfidence vltlConf;
+	vltlConf.value = vltl.GetValue();
+	vltlConf.confidence = vltl.GetConfidence();
+	return TypeBuilder(BNCreateNamedTypeReferenceBuilderWithBuilder(ref->GetObject(), width, align, &cnstConf, &vltlConf));
 }