From 3d403cfae9d5a366f112c8a5936a371a01cfd230 Mon Sep 17 00:00:00 2001
From: Rusty Wagner <rusty@vector35.com>
Date: Mon, 10 Jul 2017 21:40:51 -0400
Subject: Add confidence levels to type objects

---
 function.cpp | 48 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 16 deletions(-)

(limited to 'function.cpp')

diff --git a/function.cpp b/function.cpp
index b570499c..0e1fa5cf 100644
--- a/function.cpp
+++ b/function.cpp
@@ -353,7 +353,8 @@ vector<StackVariableReference> Function::GetStackVariablesReferencedByInstructio
 	{
 		StackVariableReference ref;
 		ref.sourceOperand = refs[i].sourceOperand;
-		ref.type = refs[i].type ? new Type(BNNewTypeReference(refs[i].type)) : nullptr;
+		ref.type = Confidence<Ref<Type>>(refs[i].type ? new Type(BNNewTypeReference(refs[i].type)) : nullptr,
+			refs[i].typeConfidence);
 		ref.name = refs[i].name;
 		ref.var = Variable::FromIdentifier(refs[i].varIdentifier);
 		ref.referencedOffset = refs[i].referencedOffset;
@@ -491,7 +492,7 @@ map<int64_t, vector<VariableNameAndType>> Function::GetStackLayout()
 	{
 		VariableNameAndType var;
 		var.name = vars[i].name;
-		var.type = new Type(BNNewTypeReference(vars[i].type));
+		var.type = Confidence<Ref<Type>>(new Type(BNNewTypeReference(vars[i].type)), vars[i].typeConfidence);
 		var.var = vars[i].var;
 		var.autoDefined = vars[i].autoDefined;
 		result[vars[i].var.storage].push_back(var);
@@ -502,15 +503,21 @@ map<int64_t, vector<VariableNameAndType>> Function::GetStackLayout()
 }
 
 
-void Function::CreateAutoStackVariable(int64_t offset, Ref<Type> type, const string& name)
+void Function::CreateAutoStackVariable(int64_t offset, const Confidence<Ref<Type>>& type, const string& name)
 {
-	BNCreateAutoStackVariable(m_object, offset, type->GetObject(), name.c_str());
+	BNTypeWithConfidence tc;
+	tc.type = type->GetObject();
+	tc.confidence = type.GetConfidence();
+	BNCreateAutoStackVariable(m_object, offset, &tc, name.c_str());
 }
 
 
-void Function::CreateUserStackVariable(int64_t offset, Ref<Type> type, const string& name)
+void Function::CreateUserStackVariable(int64_t offset, const Confidence<Ref<Type>>& type, const string& name)
 {
-	BNCreateUserStackVariable(m_object, offset, type->GetObject(), name.c_str());
+	BNTypeWithConfidence tc;
+	tc.type = type->GetObject();
+	tc.confidence = type.GetConfidence();
+	BNCreateUserStackVariable(m_object, offset, &tc, name.c_str());
 }
 
 
@@ -533,7 +540,7 @@ bool Function::GetStackVariableAtFrameOffset(Architecture* arch, uint64_t addr,
 	if (!BNGetStackVariableAtFrameOffset(m_object, arch->GetObject(), addr, offset, &var))
 		return false;
 
-	result.type = new Type(BNNewTypeReference(var.type));
+	result.type = Confidence<Ref<Type>>(new Type(BNNewTypeReference(var.type)), var.typeConfidence);
 	result.name = var.name;
 	result.var = var.var;
 	result.autoDefined = var.autoDefined;
@@ -553,7 +560,7 @@ map<Variable, VariableNameAndType> Function::GetVariables()
 	{
 		VariableNameAndType var;
 		var.name = vars[i].name;
-		var.type = new Type(BNNewTypeReference(vars[i].type));
+		var.type = Confidence<Ref<Type>>(new Type(BNNewTypeReference(vars[i].type)), vars[i].typeConfidence);
 		var.var = vars[i].var;
 		var.autoDefined = vars[i].autoDefined;
 		result[vars[i].var] = var;
@@ -564,15 +571,23 @@ map<Variable, VariableNameAndType> Function::GetVariables()
 }
 
 
-void Function::CreateAutoVariable(const Variable& var, Ref<Type> type, const string& name, bool ignoreDisjointUses)
+void Function::CreateAutoVariable(const Variable& var, const Confidence<Ref<Type>>& type,
+	const string& name, bool ignoreDisjointUses)
 {
-	BNCreateAutoVariable(m_object, &var, type->GetObject(), name.c_str(), ignoreDisjointUses);
+	BNTypeWithConfidence tc;
+	tc.type = type->GetObject();
+	tc.confidence = type.GetConfidence();
+	BNCreateAutoVariable(m_object, &var, &tc, name.c_str(), ignoreDisjointUses);
 }
 
 
-void Function::CreateUserVariable(const Variable& var, Ref<Type> type, const string& name, bool ignoreDisjointUses)
+void Function::CreateUserVariable(const Variable& var, const Confidence<Ref<Type>>& type,
+	const string& name, bool ignoreDisjointUses)
 {
-	BNCreateUserVariable(m_object, &var, type->GetObject(), name.c_str(), ignoreDisjointUses);
+	BNTypeWithConfidence tc;
+	tc.type = type->GetObject();
+	tc.confidence = type.GetConfidence();
+	BNCreateUserVariable(m_object, &var, &tc, name.c_str(), ignoreDisjointUses);
 }
 
 
@@ -588,12 +603,12 @@ void Function::DeleteUserVariable(const Variable& var)
 }
 
 
-Ref<Type> Function::GetVariableType(const Variable& var)
+Confidence<Ref<Type>> Function::GetVariableType(const Variable& var)
 {
-	BNType* type = BNGetVariableType(m_object, &var);
-	if (!type)
+	BNTypeWithConfidence type = BNGetVariableType(m_object, &var);
+	if (!type.type)
 		return nullptr;
-	return new Type(type);
+	return Confidence<Ref<Type>>(new Type(type.type), type.confidence);
 }
 
 
@@ -694,6 +709,7 @@ vector<vector<InstructionTextToken>> Function::GetBlockAnnotations(Architecture*
 			token.size = lines[i].tokens[j].size;
 			token.operand = lines[i].tokens[j].operand;
 			token.context = lines[i].tokens[j].context;
+			token.confidence = lines[i].tokens[j].confidence;
 			token.address = lines[i].tokens[j].address;
 			line.push_back(token);
 		}
-- 
cgit v1.3.1