From c9845e5a200228f20809336d9e9afee45e776d19 Mon Sep 17 00:00:00 2001 From: Rusty Wagner Date: Thu, 1 Aug 2019 16:31:34 -0400 Subject: Add mem SSA to HLIL --- highlevelilinstruction.cpp | 257 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 255 insertions(+), 2 deletions(-) (limited to 'highlevelilinstruction.cpp') diff --git a/highlevelilinstruction.cpp b/highlevelilinstruction.cpp index a53d5fe4..801f5ec1 100644 --- a/highlevelilinstruction.cpp +++ b/highlevelilinstruction.cpp @@ -63,7 +63,10 @@ unordered_map {DestExprsHighLevelOperandUsage, ExprListHighLevelOperand}, {BlockExprsHighLevelOperandUsage, ExprListHighLevelOperand}, {CasesHighLevelOperandUsage, ExprListHighLevelOperand}, - {SourceSSAVariablesHighLevelOperandUsage, SSAVariableListHighLevelOperand} + {SourceSSAVariablesHighLevelOperandUsage, SSAVariableListHighLevelOperand}, + {SourceMemoryVersionHighLevelOperandUsage, IndexHighLevelOperand}, + {SourceMemoryVersionsHighLevelOperandUsage, IndexListHighLevelOperand}, + {DestMemoryVersionHighLevelOperandUsage, IndexHighLevelOperand} }; @@ -92,19 +95,35 @@ unordered_map> {HLIL_LABEL, {TargetHighLevelOperandUsage}}, {HLIL_ASSIGN, {DestExprHighLevelOperandUsage, SourceExprHighLevelOperandUsage}}, {HLIL_ASSIGN_UNPACK, {DestExprsHighLevelOperandUsage, SourceExprHighLevelOperandUsage}}, + {HLIL_ASSIGN_MEM_SSA, {DestExprHighLevelOperandUsage, DestMemoryVersionHighLevelOperandUsage, + SourceExprHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage}}, + {HLIL_ASSIGN_UNPACK, {DestExprsHighLevelOperandUsage, DestMemoryVersionHighLevelOperandUsage, + SourceExprHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage}}, {HLIL_VAR, {VariableHighLevelOperandUsage}}, {HLIL_VAR_SSA, {SSAVariableHighLevelOperandUsage}}, {HLIL_VAR_PHI, {DestSSAVariableHighLevelOperandUsage, SourceSSAVariablesHighLevelOperandUsage}}, + {HLIL_MEM_PHI, {DestMemoryVersionHighLevelOperandUsage, SourceMemoryVersionsHighLevelOperandUsage}}, {HLIL_STRUCT_FIELD, {SourceExprHighLevelOperandUsage, OffsetHighLevelOperandUsage}}, {HLIL_ARRAY_INDEX, {SourceExprHighLevelOperandUsage, IndexExprHighLevelOperandUsage}}, + {HLIL_ARRAY_INDEX_SSA, {SourceExprHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage, + IndexExprHighLevelOperandUsage}}, {HLIL_SPLIT, {HighExprHighLevelOperandUsage, LowExprHighLevelOperandUsage}}, {HLIL_DEREF, {SourceExprHighLevelOperandUsage}}, {HLIL_DEREF_FIELD, {SourceExprHighLevelOperandUsage, OffsetHighLevelOperandUsage}}, + {HLIL_DEREF_SSA, {SourceExprHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage}}, + {HLIL_DEREF_FIELD_SSA, {SourceExprHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage, + OffsetHighLevelOperandUsage}}, {HLIL_ADDRESS_OF, {SourceExprHighLevelOperandUsage}}, {HLIL_CALL, {DestExprHighLevelOperandUsage, ParameterExprsHighLevelOperandUsage}}, {HLIL_SYSCALL, {ParameterExprsHighLevelOperandUsage}}, {HLIL_TAILCALL, {DestExprHighLevelOperandUsage, ParameterExprsHighLevelOperandUsage}}, {HLIL_INTRINSIC, {IntrinsicHighLevelOperandUsage, ParameterExprsHighLevelOperandUsage}}, + {HLIL_CALL_SSA, {DestExprHighLevelOperandUsage, ParameterExprsHighLevelOperandUsage, + DestMemoryVersionHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage}}, + {HLIL_SYSCALL_SSA, {ParameterExprsHighLevelOperandUsage, DestMemoryVersionHighLevelOperandUsage, + SourceMemoryVersionHighLevelOperandUsage}}, + {HLIL_INTRINSIC_SSA, {IntrinsicHighLevelOperandUsage, ParameterExprsHighLevelOperandUsage, + DestMemoryVersionHighLevelOperandUsage, SourceMemoryVersionHighLevelOperandUsage}}, {HLIL_TRAP, {VectorHighLevelOperandUsage}}, {HLIL_CONST, {ConstantHighLevelOperandUsage}}, {HLIL_CONST_PTR, {ConstantHighLevelOperandUsage}}, @@ -201,6 +220,7 @@ static unordered_map() const } +size_t HighLevelILIndexList::ListIterator::operator*() +{ + return (size_t)*pos; +} + + +HighLevelILIndexList::HighLevelILIndexList(HighLevelILFunction* func, + const BNHighLevelILInstruction& instr, size_t count): m_list(func, instr, count) +{ +} + + +HighLevelILIndexList::const_iterator HighLevelILIndexList::begin() const +{ + const_iterator result; + result.pos = m_list.begin(); + return result; +} + + +HighLevelILIndexList::const_iterator HighLevelILIndexList::end() const +{ + const_iterator result; + result.pos = m_list.end(); + return result; +} + + +size_t HighLevelILIndexList::size() const +{ + return m_list.size(); +} + + +size_t HighLevelILIndexList::operator[](size_t i) const +{ + if (i >= size()) + throw HighLevelILInstructionAccessException(); + auto iter = begin(); + for (size_t j = 0; j < i; j++) + ++iter; + return *iter; +} + + +HighLevelILIndexList::operator vector() const +{ + vector result; + for (auto i : *this) + result.push_back(i); + return result; +} + + const HighLevelILInstruction HighLevelILInstructionList::ListIterator::operator*() { return HighLevelILInstruction(pos.GetFunction(), pos.GetFunction()->GetRawExpr((size_t)*pos), (size_t)*pos); @@ -497,6 +571,14 @@ HighLevelILSSAVariableList HighLevelILOperand::GetSSAVariableList() const } +HighLevelILIndexList HighLevelILOperand::GetIndexList() const +{ + if (m_type != IndexListHighLevelOperand) + throw HighLevelILInstructionAccessException(); + return m_instr.GetRawOperandAsIndexList(m_operandIndex); +} + + const HighLevelILOperand HighLevelILOperandList::ListIterator::operator*() { HighLevelILOperandUsage usage = *pos; @@ -659,6 +741,12 @@ HighLevelILSSAVariableList HighLevelILInstructionBase::GetRawOperandAsSSAVariabl } +HighLevelILIndexList HighLevelILInstructionBase::GetRawOperandAsIndexList(size_t operand) const +{ + return HighLevelILIndexList(function, function->GetRawExpr(operands[operand + 1]), operands[operand]); +} + + void HighLevelILInstructionBase::UpdateRawOperand(size_t operandIndex, ExprId value) { operands[operandIndex] = value; @@ -806,6 +894,16 @@ void HighLevelILInstruction::VisitExprs(const std::functionexprIndex); break; + case HLIL_ASSIGN_MEM_SSA: + toProcess.push(cur.GetSourceExpr().exprIndex); + toProcess.push(cur.GetDestExpr().exprIndex); + break; + case HLIL_ASSIGN_UNPACK_MEM_SSA: + toProcess.push(cur.GetSourceExpr().exprIndex); + exprs = cur.GetDestExprs(); + for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) + toProcess.push(i->exprIndex); + break; case HLIL_STRUCT_FIELD: toProcess.push(cur.GetSourceExpr().exprIndex); break; @@ -813,6 +911,10 @@ void HighLevelILInstruction::VisitExprs(const std::function().exprIndex); toProcess.push(cur.GetSourceExpr().exprIndex); break; + case HLIL_ARRAY_INDEX_SSA: + toProcess.push(cur.GetIndexExpr().exprIndex); + toProcess.push(cur.GetSourceExpr().exprIndex); + break; case HLIL_SPLIT: toProcess.push(cur.GetLowExpr().exprIndex); toProcess.push(cur.GetHighExpr().exprIndex); @@ -820,6 +922,12 @@ void HighLevelILInstruction::VisitExprs(const std::function().exprIndex); break; + case HLIL_DEREF_SSA: + toProcess.push(cur.GetSourceExpr().exprIndex); + break; + case HLIL_DEREF_FIELD_SSA: + toProcess.push(cur.GetSourceExpr().exprIndex); + break; case HLIL_CALL: exprs = cur.GetParameterExprs(); for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) @@ -837,6 +945,17 @@ void HighLevelILInstruction::VisitExprs(const std::functionexprIndex); toProcess.push(cur.GetDestExpr().exprIndex); break; + case HLIL_CALL_SSA: + exprs = cur.GetParameterExprs(); + for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) + toProcess.push(i->exprIndex); + toProcess.push(cur.GetDestExpr().exprIndex); + break; + case HLIL_SYSCALL_SSA: + exprs = cur.GetParameterExprs(); + for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) + toProcess.push(i->exprIndex); + break; case HLIL_RET: exprs = cur.GetSourceExprs(); for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) @@ -925,6 +1044,11 @@ void HighLevelILInstruction::VisitExprs(const std::functionexprIndex); break; + case HLIL_INTRINSIC_SSA: + exprs = cur.GetParameterExprs(); + for (auto i = exprs.rbegin(); i != exprs.rend(); ++i) + toProcess.push(i->exprIndex); + break; default: break; } @@ -985,18 +1109,34 @@ ExprId HighLevelILInstruction::CopyTo(HighLevelILFunction* dest, output.push_back(subExprHandler(i)); return dest->AssignUnpack(output, subExprHandler(GetSourceExpr()), *this); + case HLIL_ASSIGN_MEM_SSA: + return dest->AssignMemSSA(size, subExprHandler(GetDestExpr()), + GetDestMemoryVersion(), subExprHandler(GetSourceExpr()), + GetSourceMemoryVersion(), *this); + case HLIL_ASSIGN_UNPACK_MEM_SSA: + for (auto& i : GetDestExprs()) + output.push_back(subExprHandler(i)); + return dest->AssignUnpackMemSSA(output, GetDestMemoryVersion(), + subExprHandler(GetSourceExpr()), + GetSourceMemoryVersion(), *this); case HLIL_VAR: return dest->Var(size, GetVariable(), *this); case HLIL_VAR_SSA: return dest->VarSSA(size, GetSSAVariable(), *this); case HLIL_VAR_PHI: return dest->VarPhi(GetDestSSAVariable(), GetSourceSSAVariables(), *this); + case HLIL_MEM_PHI: + return dest->MemPhi(GetDestMemoryVersion(), GetSourceMemoryVersions(), *this); case HLIL_STRUCT_FIELD: return dest->StructField(size, subExprHandler(GetSourceExpr()), GetOffset(), *this); case HLIL_ARRAY_INDEX: return dest->ArrayIndex(size, subExprHandler(GetSourceExpr()), subExprHandler(GetIndexExpr()), *this); + case HLIL_ARRAY_INDEX_SSA: + return dest->ArrayIndexSSA(size, subExprHandler(GetSourceExpr()), + GetSourceMemoryVersion(), + subExprHandler(GetIndexExpr()), *this); case HLIL_SPLIT: return dest->Split(size, subExprHandler(GetHighExpr()), subExprHandler(GetLowExpr()), *this); @@ -1005,6 +1145,12 @@ ExprId HighLevelILInstruction::CopyTo(HighLevelILFunction* dest, case HLIL_DEREF_FIELD: return dest->DerefField(size, subExprHandler(GetSourceExpr()), GetOffset(), *this); + case HLIL_DEREF_SSA: + return dest->DerefSSA(size, subExprHandler(GetSourceExpr()), + GetSourceMemoryVersion(), *this); + case HLIL_DEREF_FIELD_SSA: + return dest->DerefFieldSSA(size, subExprHandler(GetSourceExpr()), + GetSourceMemoryVersion(), GetOffset(), *this); case HLIL_ADDRESS_OF: return dest->AddressOf(subExprHandler(GetSourceExpr()), *this); case HLIL_CALL: @@ -1019,6 +1165,16 @@ ExprId HighLevelILInstruction::CopyTo(HighLevelILFunction* dest, for (auto& i : GetParameterExprs()) params.push_back(subExprHandler(i)); return dest->TailCall(subExprHandler(GetDestExpr()), params, *this); + case HLIL_CALL_SSA: + for (auto& i : GetParameterExprs()) + params.push_back(subExprHandler(i)); + return dest->CallSSA(subExprHandler(GetDestExpr()), params, + GetDestMemoryVersion(), GetSourceMemoryVersion(), *this); + case HLIL_SYSCALL_SSA: + for (auto& i : GetParameterExprs()) + params.push_back(subExprHandler(i)); + return dest->SyscallSSA(params, GetDestMemoryVersion(), + GetSourceMemoryVersion(), *this); case HLIL_RET: for (auto& i : GetSourceExprs()) params.push_back(subExprHandler(i)); @@ -1118,6 +1274,11 @@ ExprId HighLevelILInstruction::CopyTo(HighLevelILFunction* dest, for (auto& i : GetParameterExprs()) params.push_back(subExprHandler(i)); return dest->Intrinsic(GetIntrinsic(), params, *this); + case HLIL_INTRINSIC_SSA: + for (auto& i : GetParameterExprs()) + params.push_back(subExprHandler(i)); + return dest->IntrinsicSSA(GetIntrinsic(), params, + GetDestMemoryVersion(), GetSourceMemoryVersion(), *this); case HLIL_UNDEF: return dest->Undefined(*this); case HLIL_UNIMPL: @@ -1402,6 +1563,33 @@ HighLevelILSSAVariableList HighLevelILInstruction::GetSourceSSAVariables() const } +size_t HighLevelILInstruction::GetSourceMemoryVersion() const +{ + size_t operandIndex; + if (GetOperandIndexForUsage(SourceMemoryVersionHighLevelOperandUsage, operandIndex)) + return GetRawOperandAsIndex(operandIndex); + throw HighLevelILInstructionAccessException(); +} + + +HighLevelILIndexList HighLevelILInstruction::GetSourceMemoryVersions() const +{ + size_t operandIndex; + if (GetOperandIndexForUsage(SourceMemoryVersionsHighLevelOperandUsage, operandIndex)) + return GetRawOperandAsIndexList(operandIndex); + throw HighLevelILInstructionAccessException(); +} + + +size_t HighLevelILInstruction::GetDestMemoryVersion() const +{ + size_t operandIndex; + if (GetOperandIndexForUsage(DestMemoryVersionHighLevelOperandUsage, operandIndex)) + return GetRawOperandAsIndex(operandIndex); + throw HighLevelILInstructionAccessException(); +} + + ExprId HighLevelILFunction::Nop(const ILSourceLocation& loc) { return AddExprWithLocation(HLIL_NOP, loc, 0); @@ -1509,6 +1697,21 @@ ExprId HighLevelILFunction::AssignUnpack(const vector& output, ExprId sr } +ExprId HighLevelILFunction::AssignMemSSA(size_t size, ExprId dest, size_t destMemVersion, ExprId src, + size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_ASSIGN_MEM_SSA, loc, size, dest, destMemVersion, src, srcMemVersion); +} + + +ExprId HighLevelILFunction::AssignUnpackMemSSA(const vector& output, size_t destMemVersion, ExprId src, + size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_ASSIGN_UNPACK_MEM_SSA, loc, 0, output.size(), AddOperandList(output), + destMemVersion, src, srcMemVersion); +} + + ExprId HighLevelILFunction::Var(size_t size, const Variable& src, const ILSourceLocation& loc) { @@ -1530,6 +1733,12 @@ ExprId HighLevelILFunction::VarPhi(const SSAVariable& dest, const vector& sources, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_MEM_PHI, loc, 0, dest, sources.size(), AddIndexList(sources)); +} + + ExprId HighLevelILFunction::StructField(size_t size, ExprId src, uint64_t offset, const ILSourceLocation& loc) { return AddExprWithLocation(HLIL_STRUCT_FIELD, loc, size, src, offset); @@ -1544,7 +1753,14 @@ ExprId HighLevelILFunction::Split(size_t size, ExprId high, ExprId low, const IL ExprId HighLevelILFunction::ArrayIndex(size_t size, ExprId src, ExprId idx, const ILSourceLocation& loc) { - return AddExprWithLocation(HLIL_STRUCT_FIELD, loc, size, src, idx); + return AddExprWithLocation(HLIL_ARRAY_INDEX, loc, size, src, idx); +} + + +ExprId HighLevelILFunction::ArrayIndexSSA(size_t size, ExprId src, size_t srcMemVersion, ExprId idx, + const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_ARRAY_INDEX_SSA, loc, size, src, srcMemVersion, idx); } @@ -1560,6 +1776,19 @@ ExprId HighLevelILFunction::DerefField(size_t size, ExprId src, uint64_t offset, } +ExprId HighLevelILFunction::DerefSSA(size_t size, ExprId src, size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_DEREF_SSA, loc, size, src, srcMemVersion); +} + + +ExprId HighLevelILFunction::DerefFieldSSA(size_t size, ExprId src, size_t srcMemVersion, + uint64_t offset, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_DEREF_FIELD_SSA, loc, size, src, srcMemVersion, offset); +} + + ExprId HighLevelILFunction::AddressOf(ExprId src, const ILSourceLocation& loc) { return AddExprWithLocation(HLIL_ADDRESS_OF, loc, 0, src); @@ -1839,6 +2068,22 @@ ExprId HighLevelILFunction::TailCall(ExprId dest, const vector& params, } +ExprId HighLevelILFunction::CallSSA(ExprId dest, const vector& params, size_t destMemVersion, + size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_CALL_SSA, loc, 0, dest, params.size(), AddOperandList(params), + destMemVersion, srcMemVersion); +} + + +ExprId HighLevelILFunction::SyscallSSA(const vector& params, size_t destMemVersion, + size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_SYSCALL_SSA, loc, 0, params.size(), AddOperandList(params), + destMemVersion, srcMemVersion); +} + + ExprId HighLevelILFunction::CompareEqual(size_t size, ExprId left, ExprId right, const ILSourceLocation& loc) { @@ -1949,6 +2194,14 @@ ExprId HighLevelILFunction::Intrinsic(uint32_t intrinsic, const vector& } +ExprId HighLevelILFunction::IntrinsicSSA(uint32_t intrinsic, const vector& params, + size_t destMemVersion, size_t srcMemVersion, const ILSourceLocation& loc) +{ + return AddExprWithLocation(HLIL_INTRINSIC_SSA, loc, 0, intrinsic, + params.size(), AddOperandList(params), destMemVersion, srcMemVersion); +} + + ExprId HighLevelILFunction::Undefined(const ILSourceLocation& loc) { return AddExprWithLocation(HLIL_UNDEF, loc, 0); -- cgit v1.3.1