Add HLIL structure initializer instructions

Author: D0ntPanic

binaryninjaapi.h

@@ -16439,6 +16439,9 @@ namespace BinaryNinja {
 		ExprId ArrayIndex(size_t size, ExprId src, ExprId idx, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ArrayIndexSSA(size_t size, ExprId src, size_t srcMemVersion, ExprId idx,
 		    const ILSourceLocation& loc = ILSourceLocation());
+		ExprId StructInit(size_t size, const std::vector<ExprId>& fields, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId StructInitField(size_t size, uint64_t offset, size_t memberIndex, ExprId src,
+			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Split(size_t size, ExprId high, ExprId low, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Deref(size_t size, ExprId src, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId DerefField(size_t size, ExprId src, uint64_t offset, size_t memberIndex,

binaryninjacore.h

@@ -1705,6 +1705,8 @@ extern "C"
 		HLIL_UNDEF,
 		HLIL_UNIMPL,
 		HLIL_UNIMPL_MEM,
+		HLIL_STRUCT_INIT,
+		HLIL_STRUCT_INIT_FIELD,  // Only valid in HLIL_STRUCT_INIT
 
 		// Floating point
 		HLIL_FADD,

highlevelilinstruction.cpp

@@ -89,6 +89,7 @@ static constexpr std::array s_operandTypeForUsage = {
 	OperandUsageType{BlockExprsHighLevelOperandUsage, ExprListHighLevelOperand},
 	OperandUsageType{CasesHighLevelOperandUsage, ExprListHighLevelOperand},
 	OperandUsageType{ValueExprsHighLevelOperandUsage, ExprListHighLevelOperand},
+	OperandUsageType{FieldExprsHighLevelOperandUsage, ExprListHighLevelOperand},
 	OperandUsageType{SourceSSAVariablesHighLevelOperandUsage, SSAVariableListHighLevelOperand},
 	OperandUsageType{SourceMemoryVersionHighLevelOperandUsage, IndexHighLevelOperand},
 	OperandUsageType{SourceMemoryVersionsHighLevelOperandUsage, IndexListHighLevelOperand},
@@ -226,6 +227,8 @@ static constexpr std::array s_instructionOperandUsage = {
 	OperandUsage{HLIL_UNDEF},
 	OperandUsage{HLIL_UNIMPL},
 	OperandUsage{HLIL_UNIMPL_MEM, {SourceExprHighLevelOperandUsage}},
+	OperandUsage{HLIL_STRUCT_INIT, {FieldExprsHighLevelOperandUsage}},
+	OperandUsage{HLIL_STRUCT_INIT_FIELD, {OffsetHighLevelOperandUsage, MemberIndexHighLevelOperandUsage, SourceExprHighLevelOperandUsage}},
 	OperandUsage{HLIL_FADD, {LeftExprHighLevelOperandUsage, RightExprHighLevelOperandUsage}},
 	OperandUsage{HLIL_FSUB, {LeftExprHighLevelOperandUsage, RightExprHighLevelOperandUsage}},
 	OperandUsage{HLIL_FMUL, {LeftExprHighLevelOperandUsage, RightExprHighLevelOperandUsage}},
@@ -1249,6 +1252,14 @@ void HighLevelILInstruction::CollectSubExprs(stack<size_t>& toProcess) const
 	case HLIL_DEREF_FIELD_SSA:
 		toProcess.push(GetSourceExpr<HLIL_DEREF_FIELD_SSA>().exprIndex);
 		break;
+	case HLIL_STRUCT_INIT:
+		exprs = GetFieldExprs<HLIL_STRUCT_INIT>();
+		for (auto i = exprs.rbegin(); i != exprs.rend(); ++i)
+			toProcess.push(i->exprIndex);
+		break;
+	case HLIL_STRUCT_INIT_FIELD:
+		toProcess.push(GetSourceExpr<HLIL_STRUCT_INIT_FIELD>().exprIndex);
+		break;
 	case HLIL_CALL:
 		toProcess.push(GetDestExpr<HLIL_CALL>().exprIndex);
 		exprs = GetParameterExprs<HLIL_CALL>();
@@ -1560,6 +1571,13 @@ ExprId HighLevelILInstruction::CopyTo(
 		return dest->ArrayIndexSSA(size, subExprHandler(GetSourceExpr<HLIL_ARRAY_INDEX_SSA>()),
 		    GetSourceMemoryVersion<HLIL_ARRAY_INDEX_SSA>(), subExprHandler(GetIndexExpr<HLIL_ARRAY_INDEX_SSA>()),
 		    loc);
+	case HLIL_STRUCT_INIT:
+		for (auto i : GetFieldExprs<HLIL_STRUCT_INIT>())
+			params.push_back(subExprHandler(i));
+		return dest->StructInit(size, params, loc);
+	case HLIL_STRUCT_INIT_FIELD:
+		return dest->StructInitField(size, GetOffset<HLIL_STRUCT_INIT_FIELD>(),
+			GetMemberIndex<HLIL_STRUCT_INIT_FIELD>(), subExprHandler(GetSourceExpr<HLIL_STRUCT_INIT_FIELD>()), loc);
 	case HLIL_SPLIT:
 		return dest->Split(
 		    size, subExprHandler(GetHighExpr<HLIL_SPLIT>()), subExprHandler(GetLowExpr<HLIL_SPLIT>()), loc);
@@ -1992,6 +2010,26 @@ bool HighLevelILInstruction::operator<(const HighLevelILInstruction& other) cons
 		if (other.GetIndexExpr<HLIL_ARRAY_INDEX_SSA>() < GetIndexExpr<HLIL_ARRAY_INDEX_SSA>())
 			return false;
 		return GetSourceMemoryVersion<HLIL_ARRAY_INDEX_SSA>() < other.GetSourceMemoryVersion<HLIL_ARRAY_INDEX_SSA>();
+	case HLIL_STRUCT_INIT:
+		if (size < other.size)
+			return true;
+		if (size > other.size)
+			return false;
+		return CompareExprList(GetFieldExprs<HLIL_STRUCT_INIT>(), other.GetFieldExprs<HLIL_STRUCT_INIT>());
+	case HLIL_STRUCT_INIT_FIELD:
+		if (size < other.size)
+			return true;
+		if (size > other.size)
+			return false;
+		if (GetOffset<HLIL_STRUCT_INIT_FIELD>() < other.GetOffset<HLIL_STRUCT_INIT_FIELD>())
+			return true;
+		if (other.GetOffset<HLIL_STRUCT_INIT_FIELD>() < GetOffset<HLIL_STRUCT_INIT_FIELD>())
+			return false;
+		if (GetMemberIndex<HLIL_STRUCT_INIT_FIELD>() < other.GetMemberIndex<HLIL_STRUCT_INIT_FIELD>())
+			return true;
+		if (other.GetMemberIndex<HLIL_STRUCT_INIT_FIELD>() < GetMemberIndex<HLIL_STRUCT_INIT_FIELD>())
+			return false;
+		return GetSourceExpr<HLIL_STRUCT_INIT_FIELD>() < other.GetSourceExpr<HLIL_STRUCT_INIT_FIELD>();
 	case HLIL_SPLIT:
 		if (size < other.size)
 			return true;
@@ -2614,6 +2652,15 @@ HighLevelILInstructionList HighLevelILInstruction::GetValueExprs() const
 }
 
 
+HighLevelILInstructionList HighLevelILInstruction::GetFieldExprs() const
+{
+	size_t operandIndex;
+	if (GetOperandIndexForUsage(FieldExprsHighLevelOperandUsage, operandIndex))
+		return GetRawOperandAsExprList(operandIndex);
+	throw HighLevelILInstructionAccessException();
+}
+
+
 HighLevelILSSAVariableList HighLevelILInstruction::GetSourceSSAVariables() const
 {
 	size_t operandIndex;
@@ -2916,6 +2963,19 @@ ExprId HighLevelILFunction::ArrayIndexSSA(
 }
 
 
+ExprId HighLevelILFunction::StructInit(size_t size, const vector<ExprId>& fields, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(HLIL_STRUCT_INIT, loc, size, fields.size(), AddOperandList(fields));
+}
+
+
+ExprId HighLevelILFunction::StructInitField(
+	size_t size, uint64_t offset, size_t memberIndex, ExprId src, const ILSourceLocation& loc)
+{
+	return AddExprWithLocation(HLIL_STRUCT_INIT_FIELD, loc, size, offset, memberIndex, src);
+}
+
+
 ExprId HighLevelILFunction::Deref(size_t size, ExprId src, const ILSourceLocation& loc)
 {
 	return AddExprWithLocation(HLIL_DEREF, loc, size, src);

highlevelilinstruction.h

@@ -118,6 +118,7 @@ namespace BinaryNinja
 		BlockExprsHighLevelOperandUsage,
 		CasesHighLevelOperandUsage,
 		ValueExprsHighLevelOperandUsage,
+		FieldExprsHighLevelOperandUsage,
 		SourceSSAVariablesHighLevelOperandUsage,
 		SourceMemoryVersionHighLevelOperandUsage,
 		SourceMemoryVersionsHighLevelOperandUsage,
@@ -671,6 +672,11 @@ namespace BinaryNinja
 			return As<N>().GetValueExprs();
 		}
 		template <BNHighLevelILOperation N>
+		HighLevelILInstructionList GetFieldExprs() const
+		{
+			return As<N>().GetFieldExprs();
+		}
+		template <BNHighLevelILOperation N>
 		HighLevelILSSAVariableList GetSourceSSAVariables() const
 		{
 			return As<N>().GetSourceSSAVariables();
@@ -820,6 +826,7 @@ namespace BinaryNinja
 		HighLevelILInstructionList GetBlockExprs() const;
 		HighLevelILInstructionList GetCases() const;
 		HighLevelILInstructionList GetValueExprs() const;
+		HighLevelILInstructionList GetFieldExprs() const;
 		HighLevelILSSAVariableList GetSourceSSAVariables() const;
 		size_t GetSourceMemoryVersion() const;
 		HighLevelILIndexList GetSourceMemoryVersions() const;
@@ -1164,6 +1171,18 @@ namespace BinaryNinja
 		HighLevelILInstruction GetHighExpr() const { return GetRawOperandAsExpr(0); }
 		HighLevelILInstruction GetLowExpr() const { return GetRawOperandAsExpr(1); }
 	};
+	template <>
+	struct HighLevelILInstructionAccessor<HLIL_STRUCT_INIT> : public HighLevelILInstructionBase
+	{
+		HighLevelILInstructionList GetFieldExprs() const { return GetRawOperandAsExprList(0); }
+	};
+	template <>
+	struct HighLevelILInstructionAccessor<HLIL_STRUCT_INIT_FIELD> : public HighLevelILInstructionBase
+	{
+		uint64_t GetOffset() const { return GetRawOperandAsInteger(0); }
+		size_t GetMemberIndex() const { return GetRawOperandAsIndex(1); }
+		HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(2); }
+	};
 
 	template <>
 	struct HighLevelILInstructionAccessor<HLIL_VAR> : public HighLevelILInstructionBase

lang/c/pseudoc.cpp

@@ -697,6 +697,53 @@ void PseudoCFunction::AppendFieldTextTokens(const HighLevelILInstruction& instr,
 }
 
 
+void PseudoCFunction::AppendStructInitFieldTextTokens(const HighLevelILInstruction& init, uint64_t offset,
+	size_t memberIndex, size_t size, HighLevelILTokenEmitter& tokens)
+{
+	Ref<Type> type = init.GetType().GetValue();
+	if (type && (type->GetClass() == NamedTypeReferenceClass))
+		type = GetFunction()->GetView()->GetTypeByRef(type->GetNamedTypeReference());
+
+	if (type && (type->GetClass() == StructureTypeClass))
+	{
+		std::optional<size_t> memberIndexHint;
+		if (memberIndex != BN_INVALID_EXPR)
+			memberIndexHint = memberIndex;
+
+		bool hasField = false;
+		bool correctSize = false;
+		type->GetStructure()->ResolveMemberOrBaseMember(
+			GetFunction()->GetView(), offset, 0,
+			[&](NamedTypeReference*, Structure* s, size_t memberIndex, uint64_t structOffset, uint64_t adjustedOffset,
+				const StructureMember& member) {
+				tokens.Append(OperationToken, ".");
+
+				vector<string> nameList {member.name};
+				tokens.AddNamesForOuterStructureMembers(GetFunction()->GetView(), type, init, nameList);
+
+				tokens.Append(
+					FieldNameToken, member.name, structOffset + member.offset, 0, 0, BN_FULL_CONFIDENCE, nameList);
+
+				offset = adjustedOffset - member.offset;
+				hasField = true;
+				correctSize = member.type.GetValue() && size == member.type->GetWidth();
+			},
+			memberIndexHint);
+		if (hasField && correctSize)
+			return;
+	}
+
+	char offsetStr[64];
+	tokens.Append(OperationToken, ".");
+	snprintf(offsetStr, sizeof(offsetStr), "__offset(0x%" PRIx64 ")", offset);
+
+	vector<string> nameList {offsetStr};
+	tokens.AddNamesForOuterStructureMembers(GetFunction()->GetView(), type, init, nameList);
+
+	tokens.Append(StructOffsetToken, offsetStr, offset, size, 0, BN_FULL_CONFIDENCE, nameList);
+}
+
+
 void PseudoCFunction::GetExprText(const HighLevelILInstruction& instr, HighLevelILTokenEmitter& tokens,
 	DisassemblySettings* settings, BNOperatorPrecedence precedence, bool statement)
 {
@@ -3002,6 +3049,59 @@ void PseudoCFunction::GetExprTextInternal(const HighLevelILInstruction& instr, H
 				tokens.AppendSemicolon();
 		}();
 		break;
+
+	case HLIL_STRUCT_INIT:
+		[&]() {
+			const auto hlilFunc = GetHighLevelILFunction();
+			auto type = instr.GetType();
+			if (type.GetValue())
+			{
+				Ref<Platform> platform;
+				if (hlilFunc->GetFunction())
+					platform = hlilFunc->GetFunction()->GetPlatform();
+				vector<InstructionTextToken> typeTokens = TypePrinter::GetDefault()->GetTypeTokens(
+					type.GetValue(), platform, QualifiedName(), type.GetConfidence());
+				for (auto& i : typeTokens)
+					tokens.Append(i);
+				tokens.Append(TextToken, " ");
+			}
+			else
+			{
+				tokens.Append(KeywordToken, "struct ");
+			}
+			tokens.AppendOpenBrace();
+			tokens.IncreaseIndent();
+			bool first = true;
+			for (auto i : instr.GetFieldExprs<HLIL_STRUCT_INIT>())
+			{
+				if (i.operation != HLIL_STRUCT_INIT_FIELD)
+					continue;
+				if (!first)
+					tokens.Append(OperandSeparatorToken, ",");
+				first = false;
+				tokens.NewLine();
+				tokens.PrependCollapseIndicator();
+				AppendStructInitFieldTextTokens(instr, i.GetOffset<HLIL_STRUCT_INIT_FIELD>(),
+					i.GetMemberIndex<HLIL_STRUCT_INIT_FIELD>(), i.size, tokens);
+				tokens.Append(OperationToken, " = ");
+				GetExprText(i.GetSourceExpr<HLIL_STRUCT_INIT_FIELD>(), tokens, settings, AssignmentOperatorPrecedence);
+			}
+			tokens.DecreaseIndent();
+			tokens.NewLine();
+			tokens.PrependCollapseIndicator();
+			tokens.AppendCloseBrace();
+		}();
+		break;
+
+	case HLIL_STRUCT_INIT_FIELD:
+		[&]() {
+			AppendStructInitFieldTextTokens(instr, instr.GetOffset<HLIL_STRUCT_INIT_FIELD>(),
+				instr.GetMemberIndex<HLIL_STRUCT_INIT_FIELD>(), instr.size, tokens);
+			tokens.Append(OperationToken, " = ");
+			GetExprText(instr.GetSourceExpr<HLIL_STRUCT_INIT_FIELD>(), tokens, settings, AssignmentOperatorPrecedence);
+		}();
+		break;
+
 	default:
 		[&]() {
 			char buf[64]{};

lang/c/pseudoc.h

@@ -54,6 +54,8 @@ class PseudoCFunction: public BinaryNinja::LanguageRepresentationFunction
 	void AppendFieldTextTokens(const BinaryNinja::HighLevelILInstruction& instr,
 		BinaryNinja::HighLevelILTokenEmitter& tokens, BinaryNinja::DisassemblySettings* settings,
 		std::optional<bool> signedHint, bool addrOf);
+	void AppendStructInitFieldTextTokens(const BinaryNinja::HighLevelILInstruction& init, uint64_t offset,
+		size_t memberIndex, size_t size, BinaryNinja::HighLevelILTokenEmitter& tokens);
 	void AppendDefaultSplitExpr(const BinaryNinja::HighLevelILInstruction& instr, BinaryNinja::HighLevelILTokenEmitter& tokens,
 		BinaryNinja::DisassemblySettings* settings, BNOperatorPrecedence precedence);
 	void GetExprTextInternal(const BinaryNinja::HighLevelILInstruction& instr,