From 08e34ac325743085911f96b62c81d9a1f2127806 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Mon, 27 Apr 2026 16:39:21 -0400 Subject: Extend MLIL call instruction outputs to be expressions --- mediumlevelilinstruction.cpp | 223 +++++++++++++++++++++++++++++++++---------- 1 file changed, 171 insertions(+), 52 deletions(-) (limited to 'mediumlevelilinstruction.cpp') diff --git a/mediumlevelilinstruction.cpp b/mediumlevelilinstruction.cpp index 0c89ace3..74b1d76f 100644 --- a/mediumlevelilinstruction.cpp +++ b/mediumlevelilinstruction.cpp @@ -84,8 +84,10 @@ static constexpr std::array s_operandTypeForUsage = { OperandUsageType{SourceMemoryVersionsMediumLevelOperandUsage, IndexListMediumLevelOperand}, OperandUsageType{OutputVariablesMediumLevelOperandUsage, VariableListMediumLevelOperand}, OperandUsageType{OutputVariablesSubExprMediumLevelOperandUsage, VariableListMediumLevelOperand}, + OperandUsageType{OutputVariablesSubExprMediumLevelOperandUsage, ExprListMediumLevelOperand}, OperandUsageType{OutputSSAVariablesMediumLevelOperandUsage, SSAVariableListMediumLevelOperand}, OperandUsageType{OutputSSAVariablesSubExprMediumLevelOperandUsage, SSAVariableListMediumLevelOperand}, + OperandUsageType{OutputExprsSubExprMediumLevelOperandUsage, ExprListMediumLevelOperand}, OperandUsageType{OutputSSAMemoryVersionMediumLevelOperandUsage, IndexMediumLevelOperand}, OperandUsageType{ParameterExprsMediumLevelOperandUsage, ExprListMediumLevelOperand}, OperandUsageType{SourceExprsMediumLevelOperandUsage, ExprListMediumLevelOperand}, @@ -126,6 +128,7 @@ struct MediumLevelILOperationTraits // Represented as subexpression, so only takes one slot even though it is a list return 1; case OutputSSAVariablesSubExprMediumLevelOperandUsage: + case OutputExprsSubExprMediumLevelOperandUsage: // OutputSSAMemoryVersionMediumLevelOperandUsage follows at same operand return 0; case UntypedParameterSSAExprsMediumLevelOperandUsage: @@ -206,12 +209,12 @@ static constexpr std::array s_instructionOperandUsage = { OperandUsage{MLIL_JUMP, {DestExprMediumLevelOperandUsage}}, OperandUsage{MLIL_JUMP_TO, {DestExprMediumLevelOperandUsage, TargetsMediumLevelOperandUsage}}, OperandUsage{MLIL_RET_HINT, {DestExprMediumLevelOperandUsage}}, - OperandUsage{MLIL_CALL, {OutputVariablesMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, - OperandUsage{MLIL_CALL_UNTYPED, {OutputVariablesSubExprMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage}}, - OperandUsage{MLIL_CALL_OUTPUT, {OutputVariablesMediumLevelOperandUsage}}, + OperandUsage{MLIL_CALL, {OutputExprsMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, + OperandUsage{MLIL_CALL_UNTYPED, {OutputExprsMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_CALL_PARAM, {ParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_SEPARATE_PARAM_LIST, {ParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_SHARED_PARAM_SLOT, {ParameterExprsMediumLevelOperandUsage}}, + OperandUsage{MLIL_VAR_OUTPUT, {DestVariableMediumLevelOperandUsage}}, OperandUsage{MLIL_RET, {SourceExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_NORET}, OperandUsage{MLIL_IF, {ConditionExprMediumLevelOperandUsage, TrueTargetMediumLevelOperandUsage, FalseTargetMediumLevelOperandUsage}}, @@ -229,10 +232,10 @@ static constexpr std::array s_instructionOperandUsage = { OperandUsage{MLIL_TEST_BIT, {LeftExprMediumLevelOperandUsage, RightExprMediumLevelOperandUsage}}, OperandUsage{MLIL_BOOL_TO_INT, {SourceExprMediumLevelOperandUsage}}, OperandUsage{MLIL_ADD_OVERFLOW, {LeftExprMediumLevelOperandUsage, RightExprMediumLevelOperandUsage}}, - OperandUsage{MLIL_SYSCALL, {OutputVariablesMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, - OperandUsage{MLIL_SYSCALL_UNTYPED, {OutputVariablesSubExprMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, - OperandUsage{MLIL_TAILCALL, {OutputVariablesMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, - OperandUsage{MLIL_TAILCALL_UNTYPED, {OutputVariablesSubExprMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage}}, + OperandUsage{MLIL_SYSCALL, {OutputExprsMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, + OperandUsage{MLIL_SYSCALL_UNTYPED, {OutputExprsMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, + OperandUsage{MLIL_TAILCALL, {OutputExprsMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, + OperandUsage{MLIL_TAILCALL_UNTYPED, {OutputExprsMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_INTRINSIC, {OutputVariablesMediumLevelOperandUsage, IntrinsicMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_FREE_VAR_SLOT, {DestVariableMediumLevelOperandUsage}}, OperandUsage{MLIL_BP}, @@ -274,14 +277,15 @@ static constexpr std::array s_instructionOperandUsage = { OperandUsage{MLIL_VAR_SPLIT_SSA, {HighSSAVariableMediumLevelOperandUsage, LowSSAVariableMediumLevelOperandUsage}}, OperandUsage{MLIL_ASSERT_SSA, {SourceSSAVariableMediumLevelOperandUsage, ConstraintMediumLevelOperandUsage}}, OperandUsage{MLIL_FORCE_VER_SSA, {DestSSAVariableMediumLevelOperandUsage, SourceSSAVariableMediumLevelOperandUsage}}, - OperandUsage{MLIL_CALL_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, - OperandUsage{MLIL_CALL_UNTYPED_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, - OperandUsage{MLIL_SYSCALL_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, - OperandUsage{MLIL_SYSCALL_UNTYPED_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, - OperandUsage{MLIL_TAILCALL_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, - OperandUsage{MLIL_TAILCALL_UNTYPED_SSA, {OutputSSAVariablesSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, + OperandUsage{MLIL_CALL_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, + OperandUsage{MLIL_CALL_UNTYPED_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, + OperandUsage{MLIL_SYSCALL_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, + OperandUsage{MLIL_SYSCALL_UNTYPED_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, + OperandUsage{MLIL_TAILCALL_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, ParameterExprsMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, + OperandUsage{MLIL_TAILCALL_UNTYPED_SSA, {OutputExprsSubExprMediumLevelOperandUsage, OutputSSAMemoryVersionMediumLevelOperandUsage, DestExprMediumLevelOperandUsage, UntypedParameterSSAExprsMediumLevelOperandUsage, ParameterSSAMemoryVersionMediumLevelOperandUsage, StackExprMediumLevelOperandUsage}}, OperandUsage{MLIL_CALL_PARAM_SSA, {ParameterExprsMediumLevelOperandUsage}}, OperandUsage{MLIL_CALL_OUTPUT_SSA, {OutputSSAVariablesMediumLevelOperandUsage}}, + OperandUsage{MLIL_VAR_OUTPUT_SSA, {DestSSAVariableMediumLevelOperandUsage}}, OperandUsage{MLIL_MEMORY_INTRINSIC_OUTPUT_SSA, {OutputSSAVariablesMediumLevelOperandUsage}}, OperandUsage{MLIL_LOAD_SSA, {SourceExprMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, OperandUsage{MLIL_LOAD_STRUCT_SSA, {SourceExprMediumLevelOperandUsage, OffsetMediumLevelOperandUsage, SourceMemoryVersionMediumLevelOperandUsage}}, @@ -674,6 +678,16 @@ MediumLevelILInstructionList::operator vector() const } +MediumLevelILInstructionList::operator vector() const +{ + vector result; + result.reserve(size()); + for (auto i : *this) + result.push_back(i.exprIndex); + return result; +} + + MediumLevelILOperand::MediumLevelILOperand( const MediumLevelILInstruction& instr, MediumLevelILOperandUsage usage, size_t operandIndex) : m_instr(instr), @@ -787,6 +801,8 @@ MediumLevelILInstructionList MediumLevelILOperand::GetExprList() const return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsExprList(0); if (m_usage == UntypedParameterSSAExprsMediumLevelOperandUsage) return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsExprList(1); + if (m_usage == OutputExprsSubExprMediumLevelOperandUsage) + return m_instr.GetRawOperandAsExpr(m_operandIndex).GetRawOperandAsExprList(1); return m_instr.GetRawOperandAsExprList(m_operandIndex); } @@ -1379,57 +1395,81 @@ void MediumLevelILInstruction::VisitExprs(bn::base::function_ref().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_CALL_UNTYPED: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_CALL_SSA: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_CALL_UNTYPED_SSA: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_SYSCALL: + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_SYSCALL_UNTYPED: + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_SYSCALL_SSA: + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_SYSCALL_UNTYPED_SSA: + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_TAILCALL: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_TAILCALL_UNTYPED: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_TAILCALL_SSA: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; case MLIL_TAILCALL_UNTYPED_SSA: GetDestExpr().VisitExprs(func); + for (auto i : GetOutputExprs()) + i.VisitExprs(func); for (auto i : GetParameterExprs()) i.VisitExprs(func); break; @@ -1569,7 +1609,7 @@ ExprId MediumLevelILInstruction::CopyTo(MediumLevelILFunction* dest, bn::base::function_ref subExprHandler, const ILSourceLocation& sourceLocation) const { - vector params; + vector output, params; BNMediumLevelILLabel* labelA; BNMediumLevelILLabel* labelB; @@ -1629,6 +1669,8 @@ ExprId MediumLevelILInstruction::CopyTo(MediumLevelILFunction* dest, case MLIL_VAR_SPLIT_SSA: return dest->VarSplitSSA( size, GetHighSSAVariable(), GetLowSSAVariable(), loc); + case MLIL_VAR_OUTPUT_SSA: + return dest->VarOutputSSA(size, GetDestSSAVariable(), loc); case MLIL_FORCE_VER: return dest->ForceVer(size, GetDestVariable(), GetSourceVariable(), loc); case MLIL_FORCE_VER_SSA: @@ -1643,69 +1685,93 @@ ExprId MediumLevelILInstruction::CopyTo(MediumLevelILFunction* dest, return dest->AddressOfField( GetSourceVariable(), GetOffset(), loc); case MLIL_CALL: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->Call(GetOutputVariables(), subExprHandler(GetDestExpr()), params, loc); + return dest->Call(output, subExprHandler(GetDestExpr()), params, loc); case MLIL_CALL_UNTYPED: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->CallUntyped(GetOutputVariables(), + return dest->CallUntyped(output, subExprHandler(GetDestExpr()), params, subExprHandler(GetStackExpr()), loc); case MLIL_CALL_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->CallSSA(GetOutputSSAVariables(), subExprHandler(GetDestExpr()), + return dest->CallSSA(output, subExprHandler(GetDestExpr()), params, GetDestMemoryVersion(), GetSourceMemoryVersion(), loc); case MLIL_CALL_UNTYPED_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->CallUntypedSSA(GetOutputSSAVariables(), + return dest->CallUntypedSSA(output, subExprHandler(GetDestExpr()), params, GetDestMemoryVersion(), GetSourceMemoryVersion(), subExprHandler(GetStackExpr()), loc); case MLIL_SYSCALL: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->Syscall(GetOutputVariables(), params, loc); + return dest->Syscall(output, params, loc); case MLIL_SYSCALL_UNTYPED: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->SyscallUntyped(GetOutputVariables(), + return dest->SyscallUntyped(output, params, subExprHandler(GetStackExpr()), loc); case MLIL_SYSCALL_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->SyscallSSA(GetOutputSSAVariables(), params, + return dest->SyscallSSA(output, params, GetDestMemoryVersion(), GetSourceMemoryVersion(), loc); case MLIL_SYSCALL_UNTYPED_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->SyscallUntypedSSA(GetOutputSSAVariables(), + return dest->SyscallUntypedSSA(output, params, GetDestMemoryVersion(), GetSourceMemoryVersion(), subExprHandler(GetStackExpr()), loc); case MLIL_TAILCALL: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); return dest->TailCall( - GetOutputVariables(), subExprHandler(GetDestExpr()), params, loc); + output, subExprHandler(GetDestExpr()), params, loc); case MLIL_TAILCALL_UNTYPED: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->TailCallUntyped(GetOutputVariables(), + return dest->TailCallUntyped(output, subExprHandler(GetDestExpr()), params, subExprHandler(GetStackExpr()), loc); case MLIL_TAILCALL_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->TailCallSSA(GetOutputSSAVariables(), + return dest->TailCallSSA(output, subExprHandler(GetDestExpr()), params, GetDestMemoryVersion(), GetSourceMemoryVersion(), loc); case MLIL_TAILCALL_UNTYPED_SSA: + for (auto i : GetOutputExprs()) + output.push_back(subExprHandler(i)); for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); - return dest->TailCallUntypedSSA(GetOutputSSAVariables(), + return dest->TailCallUntypedSSA(output, subExprHandler(GetDestExpr()), params, GetDestMemoryVersion(), GetSourceMemoryVersion(), @@ -1718,6 +1784,8 @@ ExprId MediumLevelILInstruction::CopyTo(MediumLevelILFunction* dest, for (auto i : GetParameterExprs()) params.push_back(subExprHandler(i)); return dest->SharedParamSlot(params, loc); + case MLIL_VAR_OUTPUT: + return dest->VarOutput(size, GetDestVariable(), loc); case MLIL_RET: for (auto i : GetSourceExprs()) params.push_back(subExprHandler(i)); @@ -2165,24 +2233,39 @@ MediumLevelILIndexList MediumLevelILInstruction::GetSourceMemoryVersions() const } -MediumLevelILVariableList MediumLevelILInstruction::GetOutputVariables() const +vector MediumLevelILInstruction::GetOutputVariables() const { size_t operandIndex; if (GetOperandIndexForUsage(OutputVariablesMediumLevelOperandUsage, operandIndex)) return GetRawOperandAsVariableList(operandIndex); if (GetOperandIndexForUsage(OutputVariablesSubExprMediumLevelOperandUsage, operandIndex)) return GetRawOperandAsExpr(operandIndex).GetRawOperandAsVariableList(0); + if (GetOperandIndexForUsage(OutputExprsMediumLevelOperandUsage, operandIndex)) + return reinterpret_cast(this)->GetOutputVariables(); throw MediumLevelILInstructionAccessException(); } -MediumLevelILSSAVariableList MediumLevelILInstruction::GetOutputSSAVariables() const +vector MediumLevelILInstruction::GetOutputSSAVariables() const { size_t operandIndex; if (GetOperandIndexForUsage(OutputSSAVariablesMediumLevelOperandUsage, operandIndex)) return GetRawOperandAsSSAVariableList(operandIndex); if (GetOperandIndexForUsage(OutputSSAVariablesSubExprMediumLevelOperandUsage, operandIndex)) return GetRawOperandAsExpr(operandIndex).GetRawOperandAsSSAVariableList(1); + if (GetOperandIndexForUsage(OutputExprsSubExprMediumLevelOperandUsage, operandIndex)) + return reinterpret_cast(this)->GetOutputSSAVariables(); + throw MediumLevelILInstructionAccessException(); +} + + +MediumLevelILInstructionList MediumLevelILInstruction::GetOutputExprs() const +{ + size_t operandIndex; + if (GetOperandIndexForUsage(OutputExprsMediumLevelOperandUsage, operandIndex)) + return GetRawOperandAsExprList(operandIndex); + if (GetOperandIndexForUsage(OutputExprsSubExprMediumLevelOperandUsage, operandIndex)) + return GetRawOperandAsExpr(operandIndex).GetRawOperandAsExprList(1); throw MediumLevelILInstructionAccessException(); } @@ -2218,6 +2301,30 @@ MediumLevelILSSAVariableList MediumLevelILInstruction::GetSourceSSAVariables() c } +vector MediumLevelILCallInstruction::GetOutputVariables() const +{ + vector result; + for (auto i : GetOutputExprs()) + { + if (i.operation == MLIL_VAR_OUTPUT) + result.push_back(i.GetDestVariable()); + } + return result; +} + + +vector MediumLevelILCallSSAInstruction::GetOutputSSAVariables() const +{ + vector result; + for (auto i : GetOutputExprs()) + { + if (i.operation == MLIL_VAR_OUTPUT_SSA) + result.push_back(i.GetDestSSAVariable()); + } + return result; +} + + ExprId MediumLevelILFunction::Nop(const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_NOP, loc, 0); @@ -2412,6 +2519,12 @@ ExprId MediumLevelILFunction::VarSplitSSA( } +ExprId MediumLevelILFunction::VarOutputSSA(size_t size, const SSAVariable& dest, const ILSourceLocation& loc) +{ + return AddExprWithLocation(MLIL_VAR_OUTPUT_SSA, loc, size, dest.var.ToIdentifier(), dest.version); +} + + ExprId MediumLevelILFunction::AddressOf(const Variable& var, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_ADDRESS_OF, loc, 0, var.ToIdentifier()); @@ -2689,111 +2802,111 @@ ExprId MediumLevelILFunction::ReturnHint(ExprId dest, const ILSourceLocation& lo ExprId MediumLevelILFunction::Call( - const vector& output, ExprId dest, const vector& params, const ILSourceLocation& loc) + const vector& output, ExprId dest, const vector& params, const ILSourceLocation& loc) { return AddExprWithLocation( - MLIL_CALL, loc, 0, output.size(), AddVariableList(output), dest, params.size(), AddOperandList(params)); + MLIL_CALL, loc, 0, output.size(), AddOperandList(output), dest, params.size(), AddOperandList(params)); } -ExprId MediumLevelILFunction::CallUntyped(const vector& output, ExprId dest, const vector& params, +ExprId MediumLevelILFunction::CallUntyped(const vector& output, ExprId dest, const vector& params, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_CALL_UNTYPED, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT, loc, 0, output.size(), AddVariableList(output)), dest, + output.size(), AddOperandList(output), dest, AddExprWithLocation(MLIL_CALL_PARAM, loc, 0, params.size(), AddOperandList(params)), stack); } ExprId MediumLevelILFunction::Syscall( - const vector& output, const vector& params, const ILSourceLocation& loc) + const vector& output, const vector& params, const ILSourceLocation& loc) { return AddExprWithLocation( - MLIL_SYSCALL, loc, 0, output.size(), AddVariableList(output), params.size(), AddOperandList(params)); + MLIL_SYSCALL, loc, 0, output.size(), AddOperandList(output), params.size(), AddOperandList(params)); } ExprId MediumLevelILFunction::SyscallUntyped( - const vector& output, const vector& params, ExprId stack, const ILSourceLocation& loc) + const vector& output, const vector& params, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_SYSCALL_UNTYPED, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT, loc, 0, output.size(), AddVariableList(output)), + output.size(), AddOperandList(output), AddExprWithLocation(MLIL_CALL_PARAM, loc, 0, params.size(), AddOperandList(params)), stack); } ExprId MediumLevelILFunction::TailCall( - const vector& output, ExprId dest, const vector& params, const ILSourceLocation& loc) + const vector& output, ExprId dest, const vector& params, const ILSourceLocation& loc) { return AddExprWithLocation( - MLIL_TAILCALL, loc, 0, output.size(), AddVariableList(output), dest, params.size(), AddOperandList(params)); + MLIL_TAILCALL, loc, 0, output.size(), AddOperandList(output), dest, params.size(), AddOperandList(params)); } -ExprId MediumLevelILFunction::TailCallUntyped(const vector& output, ExprId dest, +ExprId MediumLevelILFunction::TailCallUntyped(const vector& output, ExprId dest, const vector& params, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_TAILCALL_UNTYPED, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT, loc, 0, output.size(), AddVariableList(output)), dest, + output.size(), AddOperandList(output), dest, AddExprWithLocation(MLIL_CALL_PARAM, loc, 0, params.size(), AddOperandList(params)), stack); } -ExprId MediumLevelILFunction::CallSSA(const vector& output, ExprId dest, const vector& params, +ExprId MediumLevelILFunction::CallSSA(const vector& output, ExprId dest, const vector& params, size_t newMemVersion, size_t prevMemVersion, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_CALL_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), dest, params.size(), AddOperandList(params), prevMemVersion); } -ExprId MediumLevelILFunction::CallUntypedSSA(const vector& output, ExprId dest, +ExprId MediumLevelILFunction::CallUntypedSSA(const vector& output, ExprId dest, const vector& params, size_t newMemVersion, size_t prevMemVersion, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_CALL_UNTYPED_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), dest, AddExprWithLocation(MLIL_CALL_PARAM_SSA, loc, 0, prevMemVersion, params.size(), AddOperandList(params)), stack); } -ExprId MediumLevelILFunction::SyscallSSA(const vector& output, const vector& params, +ExprId MediumLevelILFunction::SyscallSSA(const vector& output, const vector& params, size_t newMemVersion, size_t prevMemVersion, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_SYSCALL_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), params.size(), AddOperandList(params), prevMemVersion); } -ExprId MediumLevelILFunction::SyscallUntypedSSA(const vector& output, const vector& params, +ExprId MediumLevelILFunction::SyscallUntypedSSA(const vector& output, const vector& params, size_t newMemVersion, size_t prevMemVersion, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_SYSCALL_UNTYPED_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), AddExprWithLocation(MLIL_CALL_PARAM_SSA, loc, 0, prevMemVersion, params.size(), AddOperandList(params)), stack); } -ExprId MediumLevelILFunction::TailCallSSA(const vector& output, ExprId dest, const vector& params, +ExprId MediumLevelILFunction::TailCallSSA(const vector& output, ExprId dest, const vector& params, size_t newMemVersion, size_t prevMemVersion, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_TAILCALL_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), dest, params.size(), AddOperandList(params), prevMemVersion); } -ExprId MediumLevelILFunction::TailCallUntypedSSA(const vector& output, ExprId dest, +ExprId MediumLevelILFunction::TailCallUntypedSSA(const vector& output, ExprId dest, const vector& params, size_t newMemVersion, size_t prevMemVersion, ExprId stack, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_TAILCALL_UNTYPED_SSA, loc, 0, - AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size() * 2, AddSSAVariableList(output)), + AddExprWithLocation(MLIL_CALL_OUTPUT_SSA, loc, 0, newMemVersion, output.size(), AddOperandList(output)), dest, AddExprWithLocation(MLIL_CALL_PARAM_SSA, loc, 0, prevMemVersion, params.size(), AddOperandList(params)), stack); @@ -2812,6 +2925,12 @@ ExprId MediumLevelILFunction::SharedParamSlot(const vector& params, cons } +ExprId MediumLevelILFunction::VarOutput(size_t size, const Variable& var, const ILSourceLocation& loc) +{ + return AddExprWithLocation(MLIL_VAR_OUTPUT, loc, size, var.ToIdentifier()); +} + + ExprId MediumLevelILFunction::Return(const vector& sources, const ILSourceLocation& loc) { return AddExprWithLocation(MLIL_RET, loc, 0, sources.size(), AddOperandList(sources)); -- cgit v1.3.1