Parameter location display and parsing

Author: D0ntPanic

binaryninjaapi.h

@@ -10572,6 +10572,8 @@ namespace BinaryNinja {
 
 		static ValueLocationComponent FromAPIObject(const BNValueLocationComponent* loc);
 		BNValueLocationComponent ToAPIObject() const;
+
+		std::string ToString(Architecture* arch) const;
 	};
 
 	struct ValueLocation
@@ -10601,6 +10603,9 @@ namespace BinaryNinja {
 		static ValueLocation FromAPIObject(const BNValueLocation* loc);
 		BNValueLocation ToAPIObject() const;
 		static void FreeAPIObject(BNValueLocation* loc);
+
+		static std::optional<ValueLocation> Parse(const std::string& str, Architecture* arch, std::string& error);
+		std::string ToString(Architecture* arch) const;
 	};
 
 	struct FunctionParameter

binaryninjacore.h

@@ -478,6 +478,7 @@ extern "C"
 		BaseStructureNameToken = 37,
 		BaseStructureSeparatorToken = 38,
 		BraceToken = 39,
+		ValueLocationToken = 40,
 		// The following are output by the analysis system automatically, these should
 		// not be used directly by the architecture plugins
 		CodeSymbolToken = 64,
@@ -7177,6 +7178,10 @@ extern "C"
 	BINARYNINJACOREAPI BNReturnValue BNGetTypeReturnValue(BNType* type);
 	BINARYNINJACOREAPI bool BNIsTypeReturnValueDefaultLocation(BNType* type);
 	BINARYNINJACOREAPI BNValueLocationWithConfidence BNGetTypeReturnValueLocation(BNType* type);
+	BINARYNINJACOREAPI bool BNParseValueLocation(
+		const char* str, BNArchitecture* arch, BNValueLocation* location, char** error);
+	BINARYNINJACOREAPI char* BNValueLocationToString(BNValueLocation* location, BNArchitecture* arch);
+	BINARYNINJACOREAPI char* BNValueLocationComponentToString(BNValueLocationComponent* component, BNArchitecture* arch);
 	BINARYNINJACOREAPI void BNFreeValueLocation(BNValueLocation* location);
 	BINARYNINJACOREAPI BNCallingConventionWithConfidence BNGetTypeCallingConvention(BNType* type);
 	BINARYNINJACOREAPI BNCallingConventionName BNGetTypeCallingConventionName(BNType* type);

lang/rust/rusttypes.cpp

@@ -177,7 +177,6 @@ vector<InstructionTextToken> RustTypePrinter::GetTypeTokensAfterNameInternal(
 
 			if (!params[i].defaultLocation && platform && var.has_value())
 			{
-				// TODO: Emit a syntax for parameters spanning multiple storage locations
 				switch (var->type)
 				{
 				case RegisterVariableSourceType:
@@ -202,10 +201,14 @@ vector<InstructionTextToken> RustTypePrinter::GetTypeTokensAfterNameInternal(
 					tokens.emplace_back(IntegerToken, storageStr, var->storage);
 					break;
 				}
-				case CompositeReturnValueSourceType:
-				case CompositeParameterSourceType:
+				default:
+				{
+					string locationStr = params[i].location.ToString(platform->GetArchitecture());
+					tokens.emplace_back(TextToken, " @ ");
+					tokens.emplace_back(ValueLocationToken, locationStr);
 					break;
 				}
+				}
 			}
 		}
 
@@ -235,6 +238,13 @@ vector<InstructionTextToken> RustTypePrinter::GetTypeTokensAfterNameInternal(
 					i.context = FunctionReturnTokenContext;
 			}
 			tokens.insert(tokens.end(), retn.begin(), retn.end());
+			if (!type->GetReturnValue().defaultLocation)
+			{
+				auto location = type->GetReturnValue().location;
+				string locationStr = location->ToString(platform->GetArchitecture());
+				tokens.emplace_back(TextToken, " @ ");
+				tokens.emplace_back(location.GetCombinedConfidence(baseConfidence), ValueLocationToken, locationStr);
+			}
 		}
 		break;
 	}

python/examples/pseudo_python.py

@@ -1136,23 +1136,33 @@ def function_type_tokens(self, func: Function, settings: DisassemblySettings) ->
         tokens.append(InstructionTextToken(InstructionTextTokenType.KeywordToken, "def "))
         tokens.append(InstructionTextToken(InstructionTextTokenType.CodeSymbolToken, func.name, value=func.start))
         tokens.append(InstructionTextToken(InstructionTextTokenType.BraceToken, "("))
+        params = func.type.parameters
         for (i, param) in enumerate(func.type.parameters_with_all_locations):
             if i > 0:
                 tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, ", "))
+            var = param.location.variable_for_parameter(i)
             tokens.append(InstructionTextToken(InstructionTextTokenType.ArgumentNameToken, param.name,
                                                context=InstructionTextTokenContext.LocalVariableTokenContext,
-                                               address=param.location.identifier))
+                                               address=var.identifier))
             tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, ": "))
             for token in param.type.get_tokens():
                 token.context = InstructionTextTokenContext.LocalVariableTokenContext
-                token.address = param.location.identifier
+                token.address = var.identifier
                 tokens.append(token)
+            if i < len(params) and params[i].location is not None:
+                tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, " @ "))
+                tokens.append(InstructionTextToken(InstructionTextTokenType.ValueLocationToken,
+                                                   params[i].location.to_string(func.arch)))
         tokens.append(InstructionTextToken(InstructionTextTokenType.BraceToken, ")"))
         if func.can_return.value and func.type.return_value is not None and not isinstance(func.type.return_value, VoidType):
             tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, " -> "))
             for token in func.type.return_value.get_tokens():
                 token.context = InstructionTextTokenContext.FunctionReturnTokenContext
                 tokens.append(token)
+            if func.type.return_value_location is not None:
+                tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, " @ "))
+                tokens.append(InstructionTextToken(InstructionTextTokenType.ValueLocationToken,
+                    func.type.return_value_location.location.to_string(func.arch)))
         tokens.append(InstructionTextToken(InstructionTextTokenType.TextToken, ":"))
         return [DisassemblyTextLine(tokens, func.start)]
 

python/types.py

@@ -479,6 +479,31 @@ def _to_core_struct(self) -> core.BNValueLocationComponent:
 			struct.returnedPointer = self.returned_pointer.to_BNVariable()
 		return struct
 
+	def to_string(self, arch: Optional['architecture.Architecture']):
+		if arch is None:
+			if isinstance(self.var, variable.ArchitectureVariable):
+				arch = self.var.arch
+			elif isinstance(self.var, variable.Variable):
+				arch = self.var.function.arch
+		if arch is None:
+			if self.indirect:
+				indirect = " indirect"
+			else:
+				indirect = ""
+			if self.returned_pointer is None:
+				ret_ptr = ""
+			else:
+				ret_ptr = f" returned ptr {repr(self.returned_pointer)}"
+			return f"{repr(self.var)} offset {hex(self.offset)} size {repr(self.size)}{indirect}{ret_ptr}"
+		struct = self._to_core_struct()
+		return core.BNValueLocationComponentToString(struct, arch.handle)
+
+	def __str__(self):
+		return self.to_string(None)
+
+	def __repr__(self):
+		return f"<component {self.to_string(None)}>"
+
 
 @dataclass
 class ValueLocation:
@@ -503,6 +528,46 @@ def _to_core_struct(self) -> core.BNValueLocation:
 	def with_confidence(self, confidence: int) -> 'ValueLocationWithConfidence':
 		return ValueLocationWithConfidence(self, confidence)
 
+	def variable_for_parameter(self, idx: int) -> Optional['variable.CoreVariable']:
+		struct = self._to_core_struct()
+		var = core.BNVariable()
+		if core.BNGetValueLocationVariableForParameter(struct, var, idx):
+			return variable.CoreVariable.from_BNVariable(var)
+		return None
+
+	@staticmethod
+	def parse(string: str, arch: 'architecture.Architecture') -> 'ValueLocation':
+		struct = core.BNValueLocation()
+		error = ctypes.c_char_p()
+		if not core.BNParseValueLocation(string, arch.handle, struct, error):
+			assert error.value is not None, "core.BNParseValueLocation returned 'error' set to None"
+			error_str = error.value.decode("utf-8")
+			core.free_string(error)
+			raise SyntaxError(error_str)
+		result = ValueLocation._from_core_struct(struct, arch)
+		core.BNFreeValueLocation(struct)
+		return result
+
+	def to_string(self, arch: Optional['architecture.Architecture']):
+		if arch is None:
+			for component in self.components:
+				if isinstance(component.var, variable.ArchitectureVariable):
+					arch = component.var.arch
+					break
+				if isinstance(component.var, variable.Variable):
+					arch = component.var.function.arch
+					break
+		if arch is None:
+			return repr(self.components)
+		struct = self._to_core_struct()
+		return core.BNValueLocationToString(struct, arch.handle)
+
+	def __str__(self):
+		return self.to_string(None)
+
+	def __repr__(self):
+		return f"<value location {self.to_string(None)}>"
+
 
 @dataclass
 class ValueLocationWithConfidence:
@@ -519,6 +584,9 @@ def from_optional_location(location: OptionalLocation) -> Optional['ValueLocatio
 			return ValueLocation([ValueLocationComponent(location)]).with_confidence(core.max_confidence)
 		return None
 
+	def __repr__(self):
+		return f"<value location {self.location.to_string(None)} confidence {self.confidence}>"
+
 
 @dataclass
 class ReturnValue:
@@ -570,7 +638,7 @@ def __init__(self, type: SomeType, name: str = "", location: OptionalLocation =
 
 	def __repr__(self):
 		ic = self.type.immutable_copy()
-		if self.location is not None:
+		if (self.location is not None) and (str(self.location) != self.name):
 			return f"{ic.get_string_before_name()} {self.name}{ic.get_string_after_name()} @ {self.location}"
 		return f"{ic.get_string_before_name()} {self.name}{ic.get_string_after_name()}"
 

rust/src/disassembly.rs

@@ -506,6 +506,7 @@ pub enum InstructionTextTokenKind {
         // TODO: Explain what this is
         hash: Option<u64>,
     },
+    ValueLocation,
     CodeSymbol {
         // Target address of the symbol
         value: u64,
@@ -700,6 +701,7 @@ impl InstructionTextTokenKind {
                     hash => Some(hash),
                 },
             },
+            BNInstructionTextTokenType::ValueLocationToken => Self::ValueLocation,
             BNInstructionTextTokenType::CodeSymbolToken => Self::CodeSymbol {
                 value: value.value,
                 size: value.size,
@@ -914,6 +916,9 @@ impl From<InstructionTextTokenKind> for BNInstructionTextTokenType {
                 BNInstructionTextTokenType::BaseStructureSeparatorToken
             }
             InstructionTextTokenKind::Brace { .. } => BNInstructionTextTokenType::BraceToken,
+            InstructionTextTokenKind::ValueLocation => {
+                BNInstructionTextTokenType::ValueLocationToken
+            }
             InstructionTextTokenKind::CodeSymbol { .. } => {
                 BNInstructionTextTokenType::CodeSymbolToken
             }

rust/src/types.rs

@@ -1291,7 +1291,7 @@ impl ValueLocation {
         }
     }
 
-    pub(crate) fn into_rust_raw(value: &Self) -> BNValueLocation {
+    pub fn into_rust_raw(value: &Self) -> BNValueLocation {
         let components: Box<[BNValueLocationComponent]> = value
             .components
             .iter()
@@ -1304,7 +1304,7 @@ impl ValueLocation {
     }
 
     /// Free a RUST ALLOCATED possible value set. Do not use this with CORE ALLOCATED values.
-    pub(crate) fn free_rust_raw(value: BNValueLocation) {
+    pub fn free_rust_raw(value: BNValueLocation) {
         let raw_components =
             unsafe { std::slice::from_raw_parts_mut(value.components, value.count) };
         let _ = unsafe { Box::from_raw(raw_components) };

type.cpp

@@ -591,6 +591,16 @@ BNValueLocationComponent ValueLocationComponent::ToAPIObject() const
 }
 
 
+std::string ValueLocationComponent::ToString(Architecture* arch) const
+{
+	auto componentRaw = ToAPIObject();
+	char* str = BNValueLocationComponentToString(&componentRaw, arch->GetObject());
+	string result = str;
+	BNFreeString(str);
+	return result;
+}
+
+
 std::optional<Variable> ValueLocation::GetVariableForReturnValue() const
 {
 	BNValueLocation loc = ToAPIObject();
@@ -680,6 +690,34 @@ void ValueLocation::FreeAPIObject(BNValueLocation* loc)
 }
 
 
+std::optional<ValueLocation> ValueLocation::Parse(const std::string& str, Architecture* arch, std::string& error)
+{
+	BNValueLocation locationRaw;
+	char* errorRaw;
+	if (BNParseValueLocation(str.c_str(), arch->GetObject(), &locationRaw, &errorRaw))
+	{
+		auto location = FromAPIObject(&locationRaw);
+		BNFreeValueLocation(&locationRaw);
+		return location;
+	}
+
+	error = errorRaw;
+	BNFreeString(errorRaw);
+	return std::nullopt;
+}
+
+
+std::string ValueLocation::ToString(Architecture* arch) const
+{
+	auto locationRaw = ToAPIObject();
+	char* str = BNValueLocationToString(&locationRaw, arch->GetObject());
+	FreeAPIObject(&locationRaw);
+	string result = str;
+	BNFreeString(str);
+	return result;
+}
+
+
 bool ReturnValue::operator==(const ReturnValue& nt) const
 {
 	if (type != nt.type)