Add visitors for llil and hlil

Implement detailed_operands for both, add visitors for both.
Improve consistency of type_name field of detailed_operands in MLIL

1 files changed, 384 insertions, 106 deletions

diff --git a/python/highlevelil.py b/python/highlevelil.py
index 1784c806..a267101f 100644
--- a/python/highlevelil.py
+++ b/python/highlevelil.py
@@ -20,7 +20,7 @@
 
 import ctypes
 import struct
-from typing import Optional, Generator, List, Union, NewType, Tuple, ClassVar, Mapping, Set
+from typing import Optional, Generator, List, Union, NewType, Tuple, ClassVar, Mapping, Set, Callable
 from dataclasses import dataclass
 from enum import Enum
 
@@ -59,10 +59,11 @@ OperandsType = Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, Expressi
 HighLevelILOperandType = Union['HighLevelILInstruction', 'lowlevelil.ILIntrinsic', 'variable.Variable',
                                'mediumlevelil.SSAVariable', List[int], List['variable.Variable'],
                                List['mediumlevelil.SSAVariable'], List['HighLevelILInstruction'], Optional[int], float,
-                               'GotoLabel', databuffer.DataBuffer]
+                               'GotoLabel', variable.ConstantData, databuffer.DataBuffer]
 VariablesList = List[Union['mediumlevelil.SSAVariable', 'variable.Variable']]
 StringOrType = Union[str, '_types.Type', '_types.TypeBuilder']
 ILInstructionAttributeSet = Union[Set[ILInstructionAttribute], List[ILInstructionAttribute]]
+HighLevelILVisitorCallback = Callable[[str, HighLevelILOperandType, str, Optional['HighLevelILInstruction']], bool]
 
 
 class VariableReferenceType(Enum):
@@ -768,8 +769,86 @@ class HighLevelILInstruction(BaseILInstruction):
 
 	@property
 	def operands(self) -> List[HighLevelILOperandType]:
+		"""Operands for the instruction"""
+		return list(map(lambda x: x[1], self.detailed_operands))
+
+	@property
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		"""
+		Returns a list of tuples containing the name of the operand, the operand, and the type of the operand.
+		Useful for iterating over all operands of an instruction and sub-instructions.
+		"""
 		return []
 
+	def visit_all(self, cb: HighLevelILVisitorCallback,
+	       name: str = "root", parent: Optional['HighLevelILInstruction'] = None) -> bool:
+		"""
+		Visits all operands of this instruction and all operands of any sub-instructions.
+		Using pre-order traversal.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback returned False
+		"""
+		if cb(name, self, "HighLevelILInstruction", parent) == False:
+			return False
+		for name, op, opType in self.detailed_operands:
+			if opType == "HighLevelILInstruction":
+				assert isinstance(op, HighLevelILInstruction)
+				if not op.visit_all(cb, name, self):
+					return False
+			elif opType == "List[HighLevelILInstruction]":
+				assert isinstance(op, list) and all(isinstance(i, HighLevelILInstruction) for i in op)
+				for i in op:
+					if not i.visit_all(cb, name, self): # type: ignore
+						return False
+			elif cb(name, op, opType, self) == False:
+				return False
+		return True
+
+	def visit_operands(self, cb: HighLevelILVisitorCallback,
+	       name: str = "root", parent: Optional['HighLevelILInstruction'] = None) -> bool:
+		"""
+		Visits all leaf operands of this instruction and any sub-instructions.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback returned False
+		"""
+		for name, op, opType in self.detailed_operands:
+			if opType == "HighLevelILInstruction":
+				assert isinstance(op, HighLevelILInstruction)
+				if not op.visit_operands(cb, name, self):
+					return False
+			elif opType == "List[HighLevelILInstruction]":
+				assert isinstance(op, list) and all(isinstance(i, HighLevelILInstruction) for i in op)
+				for i in op:
+					if not i.visit_operands(cb, name, self): # type: ignore
+						return False
+			elif cb(name, op, opType, self) == False:
+				return False
+		return True
+
+	def visit(self, cb: HighLevelILVisitorCallback,
+	       name: str = "root", parent: Optional['HighLevelILInstruction'] = None) -> bool:
+		"""
+		Visits all HighLevelILInstructions in the operands of this instruction and any sub-instructions.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback returned False
+		"""
+		if cb(name, self, "HighLevelILInstruction", parent) == False:
+			return False
+		for name, op, opType in self.detailed_operands:
+			if opType == "HighLevelILInstruction":
+				assert isinstance(op, HighLevelILInstruction)
+				if not op.visit(cb, name, self):
+					return False
+			elif opType == "List[HighLevelILInstruction]":
+				assert isinstance(op, list) and all(isinstance(i, HighLevelILInstruction) for i in op)
+				for i in op:
+					if not i.visit(cb, name, self): # type: ignore
+						return False
+		return True
+
 
 @dataclass(frozen=True, repr=False, eq=False)
 class HighLevelILUnaryBase(HighLevelILInstruction, UnaryOperation):
@@ -778,8 +857,10 @@ class HighLevelILUnaryBase(HighLevelILInstruction, UnaryOperation):
 		return self.get_expr(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -793,8 +874,11 @@ class HighLevelILBinaryBase(HighLevelILInstruction, BinaryOperation):
 		return self.get_expr(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.left, self.right]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("left", self.left, "HighLevelILInstruction"),
+			("right", self.right, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -817,8 +901,12 @@ class HighLevelILCarryBase(HighLevelILInstruction, Arithmetic):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.left, self.right, self.carry]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("left", self.left, "HighLevelILInstruction"),
+			("right", self.right, "HighLevelILInstruction"),
+			("carry", self.carry, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -836,6 +924,12 @@ class HighLevelILBlock(HighLevelILInstruction):
 		for expr in self.body:
 			yield expr
 
+	@property
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("body", self.body, "List[HighLevelILInstruction]"),
+		]
+
 
 @dataclass(frozen=True, repr=False, eq=False)
 class HighLevelILIf(HighLevelILInstruction, ControlFlow):
@@ -852,8 +946,12 @@ class HighLevelILIf(HighLevelILInstruction, ControlFlow):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("condition", self.condition, "HighLevelILInstruction"),
+			("true", self.true, "HighLevelILInstruction"),
+			("false", self.false, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -867,8 +965,11 @@ class HighLevelILWhile(HighLevelILInstruction, Loop):
 		return self.get_expr(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("condition", self.condition, "HighLevelILInstruction"),
+			("body", self.body, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -886,8 +987,12 @@ class HighLevelILWhileSsa(HighLevelILInstruction, Loop, SSA):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition_phi, self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("condition_phi", self.condition_phi, "HighLevelILInstruction"),
+			("condition", self.condition, "HighLevelILInstruction"),
+			("body", self.body, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -901,8 +1006,11 @@ class HighLevelILDoWhile(HighLevelILInstruction, Loop):
 		return self.get_expr(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("body", self.body, "HighLevelILInstruction"),
+			("condition", self.condition, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -920,8 +1028,12 @@ class HighLevelILDoWhileSsa(HighLevelILInstruction, Loop, SSA):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition_phi, self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("body", self.body, "HighLevelILInstruction"),
+			("condition_phi", self.condition_phi, "HighLevelILInstruction"),
+			("condition", self.condition, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -943,8 +1055,13 @@ class HighLevelILFor(HighLevelILInstruction, Loop):
 		return self.get_expr(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.init, self.condition, self.update]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("init", self.init, "HighLevelILInstruction"),
+			("condition", self.condition, "HighLevelILInstruction"),
+			("update", self.update, "HighLevelILInstruction"),
+			("body", self.body, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -970,8 +1087,14 @@ class HighLevelILForSsa(HighLevelILInstruction, Loop, SSA):
 		return self.get_expr(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.init, self.condition_phi, self.condition, self.update]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("init", self.init, "HighLevelILInstruction"),
+			("condition_phi", self.condition_phi, "HighLevelILInstruction"),
+			("condition", self.condition, "HighLevelILInstruction"),
+			("update", self.update, "HighLevelILInstruction"),
+			("body", self.body, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -989,8 +1112,12 @@ class HighLevelILSwitch(HighLevelILInstruction, ControlFlow):
 		return self.get_expr_list(2, 3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.condition]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("condition", self.condition, "HighLevelILInstruction"),
+			("default", self.default, "HighLevelILInstruction"),
+			("cases", self.cases, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1004,8 +1131,11 @@ class HighLevelILCase(HighLevelILInstruction):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.values]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("values", self.values, "List[HighLevelILInstruction]"),
+			("body", self.body, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1025,8 +1155,10 @@ class HighLevelILJump(HighLevelILInstruction, Terminal):
 		return self.get_expr(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1036,8 +1168,10 @@ class HighLevelILRet(HighLevelILInstruction, Return):
 		return self.get_expr_list(0, 1)
 
 	@property
-	def operands(self) -> List[HighLevelILInstruction]:
-		return self.src
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1057,8 +1191,10 @@ class HighLevelILGoto(HighLevelILInstruction, Terminal):
 		return self.get_label(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.target]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("target", self.target, "GotoLabel"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1068,8 +1204,10 @@ class HighLevelILLabel(HighLevelILInstruction):
 		return self.get_label(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.target]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("target", self.target, "GotoLabel"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1079,8 +1217,10 @@ class HighLevelILVarDeclare(HighLevelILInstruction):
 		return self.get_var(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.var]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("var", self.var, "Variable"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1094,12 +1234,15 @@ class HighLevelILVarInit(HighLevelILInstruction):
 		return self.get_expr(1)
 
 	@property
-	def vars_written(self) -> VariablesList:
-		return [self.dest]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "Variable"),
+			("src", self.src, "HighLevelILInstruction"),
+		]
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
+	def vars_written(self) -> VariablesList:
+		return [self.dest]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1113,12 +1256,15 @@ class HighLevelILVarInitSsa(HighLevelILInstruction, SSA):
 		return self.get_expr(2)
 
 	@property
-	def vars_written(self) -> VariablesList:
-		return [self.dest]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "SSAVariable"),
+			("src", self.src, "HighLevelILInstruction"),
+		]
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
+	def vars_written(self) -> VariablesList:
+		return [self.dest]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1132,6 +1278,13 @@ class HighLevelILAssign(HighLevelILInstruction):
 		return self.get_expr(1)
 
 	@property
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+			("src", self.src, "HighLevelILInstruction"),
+		]
+
+	@property
 	def vars_written(self) -> VariablesList:
 		if isinstance(self.dest, (HighLevelILSplit, HighLevelILVar)):
 			return [*self.dest.vars, *self.src.vars_written]
@@ -1140,10 +1293,6 @@ class HighLevelILAssign(HighLevelILInstruction):
 		else:
 			return [*self.dest.vars_written, *self.src.vars_written]
 
-	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
-
 
 @dataclass(frozen=True, repr=False, eq=False)
 class HighLevelILAssignUnpack(HighLevelILInstruction):
@@ -1156,6 +1305,13 @@ class HighLevelILAssignUnpack(HighLevelILInstruction):
 		return self.get_expr(2)
 
 	@property
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "List[HighLevelILInstruction]"),
+			("src", self.src, "HighLevelILInstruction"),
+		]
+
+	@property
 	def vars_written(self) -> VariablesList:
 		result = []
 		for i in self.dest:
@@ -1165,10 +1321,6 @@ class HighLevelILAssignUnpack(HighLevelILInstruction):
 				result.extend(i.vars_written)
 		return result
 
-	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
-
 
 @dataclass(frozen=True, repr=False, eq=False)
 class HighLevelILAssignMemSsa(HighLevelILInstruction, SSA):
@@ -1189,8 +1341,13 @@ class HighLevelILAssignMemSsa(HighLevelILInstruction, SSA):
 		return self.get_int(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.dest_memory, self.src, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+			("dest_memory", self.dest_memory, "int"),
+			("src", self.src, "HighLevelILInstruction"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1212,8 +1369,13 @@ class HighLevelILAssignUnpackMemSsa(HighLevelILInstruction, SSA, Memory):
 		return self.get_int(4)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.dest_memory, self.src, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "List[HighLevelILInstruction]"),
+			("dest_memory", self.dest_memory, "int"),
+			("src", self.src, "HighLevelILInstruction"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1223,8 +1385,10 @@ class HighLevelILVar(HighLevelILInstruction):
 		return self.get_var(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.var]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("var", self.var, "Variable"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1234,8 +1398,10 @@ class HighLevelILVarSsa(HighLevelILInstruction, SSA):
 		return self.get_var_ssa(0, 1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.var]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("var", self.var, "SSAVariable"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1253,8 +1419,11 @@ class HighLevelILVarPhi(HighLevelILInstruction, Phi):
 		return [self.dest]
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "SSAVariable"),
+			("src", self.src, "List[SSAVariable]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1268,8 +1437,11 @@ class HighLevelILMemPhi(HighLevelILInstruction, Memory, Phi):
 		return self.get_int_list(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.src]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "int"),
+			("src", self.src, "List[int]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1287,8 +1459,12 @@ class HighLevelILStructField(HighLevelILInstruction):
 		return self.get_member_index(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.offset, self.member_index]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("offset", self.offset, "int"),
+			("member_index", self.member_index, "Optional[int]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1302,8 +1478,11 @@ class HighLevelILArrayIndex(HighLevelILInstruction):
 		return self.get_expr(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.index]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("index", self.index, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1321,8 +1500,12 @@ class HighLevelILArrayIndexSsa(HighLevelILInstruction, SSA):
 		return self.get_expr(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.src_memory, self.index]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("src_memory", self.src_memory, "int"),
+			("index", self.index, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1336,8 +1519,11 @@ class HighLevelILSplit(HighLevelILInstruction):
 		return self.get_expr(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.high, self.low]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("high", self.high, "HighLevelILInstruction"),
+			("low", self.low, "HighLevelILInstruction"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1360,8 +1546,12 @@ class HighLevelILDerefField(HighLevelILInstruction):
 		return self.get_member_index(2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.offset, self.member_index]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("offset", self.offset, "int"),
+			("member_index", self.member_index, "Optional[int]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1375,8 +1565,11 @@ class HighLevelILDerefSsa(HighLevelILInstruction, SSA):
 		return self.get_int(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1398,8 +1591,13 @@ class HighLevelILDerefFieldSsa(HighLevelILInstruction, SSA):
 		return self.get_member_index(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.src, self.src_memory, self.offset, self.member_index]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("src", self.src, "HighLevelILInstruction"),
+			("src_memory", self.src_memory, "int"),
+			("offset", self.offset, "int"),
+			("member_index", self.member_index, "Optional[int]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1420,8 +1618,10 @@ class HighLevelILConst(HighLevelILInstruction, Constant):
 		return self.get_int(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant", self.constant, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1431,8 +1631,10 @@ class HighLevelILConstPtr(HighLevelILInstruction, Constant):
 		return self.get_int(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant", self.constant, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1446,8 +1648,11 @@ class HighLevelILExternPtr(HighLevelILInstruction, Constant):
 		return self.get_int(1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant, self.offset]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant", self.constant, "int"),
+			("offset", self.offset, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1457,8 +1662,10 @@ class HighLevelILFloatConst(HighLevelILInstruction, Constant):
 		return self.get_float(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant", self.constant, "float"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1468,8 +1675,10 @@ class HighLevelILImport(HighLevelILInstruction, Constant):
 		return self.get_int(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant", self.constant, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1479,8 +1688,10 @@ class HighLevelILConstData(HighLevelILInstruction, Constant):
 		return self.get_constant_data(0, 1)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.constant_data]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("constant_data", self.constant_data, "ConstantData"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1644,8 +1855,11 @@ class HighLevelILCall(HighLevelILInstruction, Localcall):
 		return self.get_expr_list(1, 2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.params]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+			("params", self.params, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1667,8 +1881,13 @@ class HighLevelILCallSsa(HighLevelILInstruction, Localcall, SSA):
 		return self.get_int(4)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.params, self.dest_memory, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+			("params", self.params, "List[HighLevelILInstruction]"),
+			("dest_memory", self.dest_memory, "int"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1743,8 +1962,10 @@ class HighLevelILSyscall(HighLevelILInstruction, Syscall):
 		return self.get_expr_list(0, 1)
 
 	@property
-	def operands(self) -> List[HighLevelILInstruction]:
-		return self.params
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("params", self.params, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1762,8 +1983,12 @@ class HighLevelILSyscallSsa(HighLevelILInstruction, Syscall, SSA):
 		return self.get_int(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.params, self.dest_memory, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("params", self.params, "List[HighLevelILInstruction]"),
+			("dest_memory", self.dest_memory, "int"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1777,8 +2002,11 @@ class HighLevelILTailcall(HighLevelILInstruction, Tailcall):
 		return self.get_expr_list(1, 2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.dest, self.params]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("dest", self.dest, "HighLevelILInstruction"),
+			("params", self.params, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1793,8 +2021,10 @@ class HighLevelILTrap(HighLevelILInstruction, Terminal):
 		return self.get_int(0)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.vector]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("vector", self.vector, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1808,8 +2038,11 @@ class HighLevelILIntrinsic(HighLevelILInstruction, Intrinsic):
 		return self.get_expr_list(1, 2)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.intrinsic, self.params]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("intrinsic", self.intrinsic, "ILIntrinsic"),
+			("params", self.params, "List[HighLevelILInstruction]"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -1831,8 +2064,13 @@ class HighLevelILIntrinsicSsa(HighLevelILInstruction, SSA):
 		return self.get_int(3)
 
 	@property
-	def operands(self) -> List[HighLevelILOperandType]:
-		return [self.intrinsic, self.params, self.dest_memory, self.src_memory]
+	def detailed_operands(self) -> List[Tuple[str, HighLevelILOperandType, str]]:
+		return [
+			("intrinsic", self.intrinsic, "ILIntrinsic"),
+			("params", self.params, "List[HighLevelILInstruction]"),
+			("dest_memory", self.dest_memory, "int"),
+			("src_memory", self.src_memory, "int"),
+		]
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -2270,6 +2508,46 @@ class HighLevelILFunction:
 
 		return HighLevelILBasicBlock(block, self, view)
 
+
+	def visit(self, cb: HighLevelILVisitorCallback) -> bool:
+		"""
+		Iterates over all the instructions in the function and calls the callback function
+		for each instruction and each sub-instruction.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback function returned False.
+		"""
+		for instr in self.instructions:
+			if not instr.visit(cb):
+				return False
+		return True
+
+	def visit_all(self, cb: HighLevelILVisitorCallback) -> bool:
+		"""
+		Iterates over all the instructions in the function and calls the callback function for each instruction and their operands.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback function returned False.
+		"""
+		for instr in self.instructions:
+			if not instr.visit_all(cb):
+				return False
+		return True
+
+	def visit_operands(self, cb: HighLevelILVisitorCallback) -> bool:
+		"""
+		Iterates over all the instructions in the function and calls the callback function for each operand and
+		 the operands of each sub-instruction.
+
+		:param HighLevelILVisitorCallback cb: Callback function that takes the name of the operand, the operand, operand type, and parent instruction
+		:return: True if all instructions were visited, False if the callback function returned False.
+		"""
+		for instr in self.instructions:
+			if not instr.visit_operands(cb):
+				return False
+		return True
+
+
 	@property
 	def instructions(self) -> Generator[HighLevelILInstruction, None, None]:
 		"""A generator of hlil instructions of the current function"""