diff options
Diffstat (limited to 'highlevelilinstruction.h')
| -rw-r--r-- | highlevelilinstruction.h | 713 |
1 files changed, 713 insertions, 0 deletions
diff --git a/highlevelilinstruction.h b/highlevelilinstruction.h new file mode 100644 index 00000000..2ec67fd3 --- /dev/null +++ b/highlevelilinstruction.h @@ -0,0 +1,713 @@ +// Copyright (c) 2019 Vector 35 Inc +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. + +#pragma once + +#include <functional> +#include <unordered_map> +#include <vector> +#ifdef BINARYNINJACORE_LIBRARY +#include "variable.h" +#else +#include "binaryninjaapi.h" +#endif +#include "mediumlevelilinstruction.h" + +#ifdef BINARYNINJACORE_LIBRARY +namespace BinaryNinjaCore +#else +namespace BinaryNinja +#endif +{ + class HighLevelILFunction; + + template <BNHighLevelILOperation N> + struct HighLevelILInstructionAccessor {}; + + struct HighLevelILInstruction; + struct HighLevelILConstantInstruction; + struct HighLevelILOneOperandInstruction; + struct HighLevelILTwoOperandInstruction; + struct HighLevelILTwoOperandWithCarryInstruction; + struct HighLevelILDoublePrecisionInstruction; + struct MediumLevelILInstruction; + class HighLevelILOperand; + class HighLevelILOperandList; + + enum HighLevelILOperandType + { + IntegerHighLevelOperand, + IndexHighLevelOperand, + IntrinsicHighLevelOperand, + ExprHighLevelOperand, + VariableHighLevelOperand, + SSAVariableHighLevelOperand, + ExprListHighLevelOperand, + SSAVariableListHighLevelOperand + }; + + enum HighLevelILOperandUsage + { + SourceExprHighLevelOperandUsage, + VariableHighLevelOperandUsage, + SSAVariableHighLevelOperandUsage, + DestSSAVariableHighLevelOperandUsage, + DestExprHighLevelOperandUsage, + LeftExprHighLevelOperandUsage, + RightExprHighLevelOperandUsage, + CarryExprHighLevelOperandUsage, + IndexExprHighLevelOperandUsage, + ConditionExprHighLevelOperandUsage, + TrueExprHighLevelOperandUsage, + FalseExprHighLevelOperandUsage, + LoopExprHighLevelOperandUsage, + InitExprHighLevelOperandUsage, + UpdateExprHighLevelOperandUsage, + DefaultExprHighLevelOperandUsage, + HighExprHighLevelOperandUsage, + LowExprHighLevelOperandUsage, + OffsetHighLevelOperandUsage, + ConstantHighLevelOperandUsage, + VectorHighLevelOperandUsage, + IntrinsicHighLevelOperandUsage, + TargetHighLevelOperandUsage, + ParameterExprsHighLevelOperandUsage, + SourceExprsHighLevelOperandUsage, + DestExprsHighLevelOperandUsage, + BlockExprsHighLevelOperandUsage, + CasesHighLevelOperandUsage, + SourceSSAVariablesHighLevelOperandUsage + }; +} + +namespace std +{ + template<> struct hash<BNHighLevelILOperation> + { + typedef BNHighLevelILOperation argument_type; + typedef int result_type; + result_type operator()(argument_type const& value) const + { + return (result_type)value; + } + }; + +#ifdef BINARYNINJACORE_LIBRARY + template<> struct hash<BinaryNinjaCore::HighLevelILOperandUsage> +#else + template<> struct hash<BinaryNinja::HighLevelILOperandUsage> +#endif + { +#ifdef BINARYNINJACORE_LIBRARY + typedef BinaryNinjaCore::HighLevelILOperandUsage argument_type; +#else + typedef BinaryNinja::HighLevelILOperandUsage argument_type; +#endif + typedef int result_type; + result_type operator()(argument_type const& value) const + { + return (result_type)value; + } + }; +} + +#ifdef BINARYNINJACORE_LIBRARY +namespace BinaryNinjaCore +#else +namespace BinaryNinja +#endif +{ + class HighLevelILInstructionAccessException: public std::exception + { + public: + HighLevelILInstructionAccessException(): std::exception() {} + virtual const char* what() const NOEXCEPT { return "invalid access to HLIL instruction"; } + }; + + class HighLevelILIntegerList + { + struct ListIterator + { +#ifdef BINARYNINJACORE_LIBRARY + HighLevelILFunction* function; +#else + Ref<HighLevelILFunction> function; +#endif + BNHighLevelILInstruction instr; + size_t operand, count; + + bool operator==(const ListIterator& a) const; + bool operator!=(const ListIterator& a) const; + bool operator<(const ListIterator& a) const; + ListIterator& operator++(); + uint64_t operator*(); + HighLevelILFunction* GetFunction() const { return function; } + }; + + ListIterator m_start; + + public: + typedef ListIterator const_iterator; + + HighLevelILIntegerList(HighLevelILFunction* func, const BNHighLevelILInstruction& instr, size_t count); + + const_iterator begin() const; + const_iterator end() const; + size_t size() const; + uint64_t operator[](size_t i) const; + + operator std::vector<uint64_t>() const; + }; + + class HighLevelILInstructionList + { + struct ListIterator + { + size_t instructionIndex; + HighLevelILIntegerList::const_iterator pos; + bool operator==(const ListIterator& a) const { return pos == a.pos; } + bool operator!=(const ListIterator& a) const { return pos != a.pos; } + bool operator<(const ListIterator& a) const { return pos < a.pos; } + ListIterator& operator++() { ++pos; return *this; } + const HighLevelILInstruction operator*(); + }; + + HighLevelILIntegerList m_list; + + public: + typedef ListIterator const_iterator; + + HighLevelILInstructionList(HighLevelILFunction* func, const BNHighLevelILInstruction& instr, size_t count); + + const_iterator begin() const; + const_iterator end() const; + size_t size() const; + const HighLevelILInstruction operator[](size_t i) const; + + operator std::vector<HighLevelILInstruction>() const; + }; + + class HighLevelILSSAVariableList + { + struct ListIterator + { + HighLevelILIntegerList::const_iterator pos; + bool operator==(const ListIterator& a) const { return pos == a.pos; } + bool operator!=(const ListIterator& a) const { return pos != a.pos; } + bool operator<(const ListIterator& a) const { return pos < a.pos; } + ListIterator& operator++() { ++pos; ++pos; return *this; } + const SSAVariable operator*(); + }; + + HighLevelILIntegerList m_list; + + public: + typedef ListIterator const_iterator; + + HighLevelILSSAVariableList(HighLevelILFunction* func, const BNHighLevelILInstruction& instr, size_t count); + + const_iterator begin() const; + const_iterator end() const; + size_t size() const; + const SSAVariable operator[](size_t i) const; + + operator std::vector<SSAVariable>() const; + }; + + struct HighLevelILInstructionBase: public BNHighLevelILInstruction + { +#ifdef BINARYNINJACORE_LIBRARY + HighLevelILFunction* function; +#else + Ref<HighLevelILFunction> function; +#endif + size_t exprIndex; + + static std::unordered_map<HighLevelILOperandUsage, HighLevelILOperandType> operandTypeForUsage; + static std::unordered_map<BNHighLevelILOperation, + std::vector<HighLevelILOperandUsage>> operationOperandUsage; + static std::unordered_map<BNHighLevelILOperation, + std::unordered_map<HighLevelILOperandUsage, size_t>> operationOperandIndex; + + HighLevelILOperandList GetOperands() const; + + uint64_t GetRawOperandAsInteger(size_t operand) const; + size_t GetRawOperandAsIndex(size_t operand) const; + HighLevelILInstruction GetRawOperandAsExpr(size_t operand) const; + Variable GetRawOperandAsVariable(size_t operand) const; + SSAVariable GetRawOperandAsSSAVariable(size_t operand) const; + HighLevelILInstructionList GetRawOperandAsExprList(size_t operand) const; + HighLevelILSSAVariableList GetRawOperandAsSSAVariableList(size_t operand) const; + + void UpdateRawOperand(size_t operandIndex, ExprId value); + void UpdateRawOperandAsSSAVariableList(size_t operandIndex, const std::vector<SSAVariable>& vars); + void UpdateRawOperandAsExprList(size_t operandIndex, const std::vector<HighLevelILInstruction>& exprs); + void UpdateRawOperandAsExprList(size_t operandIndex, const std::vector<size_t>& exprs); + + size_t GetMediumLevelILExprIndex() const; + bool HasMediumLevelIL() const; + MediumLevelILInstruction GetMediumLevelIL() const; + MediumLevelILInstruction GetMediumLevelILSSAForm() const; + + void Replace(ExprId expr); + + size_t GetInstructionIndex() const; + HighLevelILInstruction GetInstruction() const; + + template <BNHighLevelILOperation N> + HighLevelILInstructionAccessor<N>& As() + { + if (operation != N) + throw HighLevelILInstructionAccessException(); + return *(HighLevelILInstructionAccessor<N>*)this; + } + HighLevelILOneOperandInstruction& AsOneOperand() + { + return *(HighLevelILOneOperandInstruction*)this; + } + HighLevelILTwoOperandInstruction& AsTwoOperand() + { + return *(HighLevelILTwoOperandInstruction*)this; + } + HighLevelILTwoOperandWithCarryInstruction& AsTwoOperandWithCarry() + { + return *(HighLevelILTwoOperandWithCarryInstruction*)this; + } + + template <BNHighLevelILOperation N> + const HighLevelILInstructionAccessor<N>& As() const + { + if (operation != N) + throw HighLevelILInstructionAccessException(); + return *(const HighLevelILInstructionAccessor<N>*)this; + } + const HighLevelILConstantInstruction& AsConstant() const + { + return *(const HighLevelILConstantInstruction*)this; + } + const HighLevelILOneOperandInstruction& AsOneOperand() const + { + return *(const HighLevelILOneOperandInstruction*)this; + } + const HighLevelILTwoOperandInstruction& AsTwoOperand() const + { + return *(const HighLevelILTwoOperandInstruction*)this; + } + const HighLevelILTwoOperandWithCarryInstruction& AsTwoOperandWithCarry() const + { + return *(const HighLevelILTwoOperandWithCarryInstruction*)this; + } + }; + + struct HighLevelILInstruction: public HighLevelILInstructionBase + { + HighLevelILInstruction(); + HighLevelILInstruction(HighLevelILFunction* func, const BNHighLevelILInstruction& instr, size_t expr); + HighLevelILInstruction(const HighLevelILInstructionBase& instr); + + void VisitExprs(const std::function<bool(const HighLevelILInstruction& expr)>& func) const; + + ExprId CopyTo(HighLevelILFunction* dest) const; + ExprId CopyTo(HighLevelILFunction* dest, + const std::function<ExprId(const HighLevelILInstruction& subExpr)>& subExprHandler) const; + + // Templated accessors for instruction operands, use these for efficient access to a known instruction + template <BNHighLevelILOperation N> HighLevelILInstruction GetSourceExpr() const { return As<N>().GetSourceExpr(); } + template <BNHighLevelILOperation N> Variable GetVariable() const { return As<N>().GetVariable(); } + template <BNHighLevelILOperation N> SSAVariable GetSSAVariable() const { return As<N>().GetSSAVariable(); } + template <BNHighLevelILOperation N> SSAVariable GetDestSSAVariable() const { return As<N>().GetDestSSAVariable(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetDestExpr() const { return As<N>().GetDestExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetLeftExpr() const { return As<N>().GetLeftExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetRightExpr() const { return As<N>().GetRightExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetCarryExpr() const { return As<N>().GetCarryExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetIndexExpr() const { return As<N>().GetIndexExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetConditionExpr() const { return As<N>().GetConditionExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetTrueExpr() const { return As<N>().GetTrueExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetFalseExpr() const { return As<N>().GetFalseExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetLoopExpr() const { return As<N>().GetLoopExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetInitExpr() const { return As<N>().GetInitExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetUpdateExpr() const { return As<N>().GetUpdateExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetDefaultExpr() const { return As<N>().GetDefaultExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetHighExpr() const { return As<N>().GetHighExpr(); } + template <BNHighLevelILOperation N> HighLevelILInstruction GetLowExpr() const { return As<N>().GetLowExpr(); } + template <BNHighLevelILOperation N> uint64_t GetOffset() const { return As<N>().GetOffset(); } + template <BNHighLevelILOperation N> int64_t GetConstant() const { return As<N>().GetConstant(); } + template <BNHighLevelILOperation N> int64_t GetVector() const { return As<N>().GetVector(); } + template <BNHighLevelILOperation N> uint32_t GetIntrinsic() const { return As<N>().GetIntrinsic(); } + template <BNHighLevelILOperation N> size_t GetTarget() const { return As<N>().GetTarget(); } + template <BNHighLevelILOperation N> HighLevelILInstructionList GetParameterExprs() const { return As<N>().GetParameterExprs(); } + template <BNHighLevelILOperation N> HighLevelILInstructionList GetSourceExprs() const { return As<N>().GetSourceExprs(); } + template <BNHighLevelILOperation N> HighLevelILInstructionList GetDestExprs() const { return As<N>().GetDestExprs(); } + template <BNHighLevelILOperation N> HighLevelILInstructionList GetBlockExprs() const { return As<N>().GetBlockExprs(); } + template <BNHighLevelILOperation N> HighLevelILInstructionList GetCases() const { return As<N>().GetCases(); } + template <BNHighLevelILOperation N> HighLevelILSSAVariableList GetSourceSSAVariables() const { return As<N>().GetSourceSSAVariables(); } + + template <BNHighLevelILOperation N> void SetSSAVersion(size_t version) { As<N>().SetSSAVersion(version); } + template <BNHighLevelILOperation N> void SetParameterExprs(const std::vector<MediumLevelILInstruction>& params) { As<N>().SetParameterExprs(params); } + template <BNHighLevelILOperation N> void SetParameterExprs(const std::vector<ExprId>& params) { As<N>().SetParameterExprs(params); } + template <BNHighLevelILOperation N> void SetSourceExprs(const std::vector<MediumLevelILInstruction>& params) { As<N>().SetSourceExprs(params); } + template <BNHighLevelILOperation N> void SetSourceExprs(const std::vector<ExprId>& params) { As<N>().SetSourceExprs(params); } + template <BNHighLevelILOperation N> void SetDestExprs(const std::vector<MediumLevelILInstruction>& params) { As<N>().SetDestExprs(params); } + template <BNHighLevelILOperation N> void SetDestExprs(const std::vector<ExprId>& params) { As<N>().SetDestExprs(params); } + template <BNHighLevelILOperation N> void SetBlockExprs(const std::vector<MediumLevelILInstruction>& params) { As<N>().SetBlockExprs(params); } + template <BNHighLevelILOperation N> void SetBlockExprs(const std::vector<ExprId>& params) { As<N>().SetBlockExprs(params); } + template <BNHighLevelILOperation N> void SetCases(const std::vector<MediumLevelILInstruction>& params) { As<N>().SetCases(params); } + template <BNHighLevelILOperation N> void SetCases(const std::vector<ExprId>& params) { As<N>().SetCases(params); } + template <BNHighLevelILOperation N> void SetSourceSSAVariables(const std::vector<SSAVariable>& vars) { As<N>().SetSourceSSAVariables(vars); } + + bool GetOperandIndexForUsage(HighLevelILOperandUsage usage, size_t& operandIndex) const; + + // Generic accessors for instruction operands, these will throw a HighLevelILInstructionAccessException + // on type mismatch. These are slower than the templated versions above. + HighLevelILInstruction GetSourceExpr() const; + Variable GetVariable() const; + SSAVariable GetSSAVariable() const; + SSAVariable GetDestSSAVariable() const; + HighLevelILInstruction GetDestExpr() const; + HighLevelILInstruction GetLeftExpr() const; + HighLevelILInstruction GetRightExpr() const; + HighLevelILInstruction GetCarryExpr() const; + HighLevelILInstruction GetIndexExpr() const; + HighLevelILInstruction GetConditionExpr() const; + HighLevelILInstruction GetTrueExpr() const; + HighLevelILInstruction GetFalseExpr() const; + HighLevelILInstruction GetLoopExpr() const; + HighLevelILInstruction GetInitExpr() const; + HighLevelILInstruction GetUpdateExpr() const; + HighLevelILInstruction GetDefaultExpr() const; + HighLevelILInstruction GetHighExpr() const; + HighLevelILInstruction GetLowExpr() const; + uint64_t GetOffset() const; + int64_t GetConstant() const; + int64_t GetVector() const; + uint32_t GetIntrinsic() const; + size_t GetTarget() const; + HighLevelILInstructionList GetParameterExprs() const; + HighLevelILInstructionList GetSourceExprs() const; + HighLevelILInstructionList GetDestExprs() const; + HighLevelILInstructionList GetBlockExprs() const; + HighLevelILInstructionList GetCases() const; + HighLevelILSSAVariableList GetSourceSSAVariables() const; + }; + + class HighLevelILOperand + { + HighLevelILInstruction m_instr; + HighLevelILOperandUsage m_usage; + HighLevelILOperandType m_type; + size_t m_operandIndex; + + public: + HighLevelILOperand(const HighLevelILInstruction& instr, HighLevelILOperandUsage usage, + size_t operandIndex); + + HighLevelILOperandType GetType() const { return m_type; } + HighLevelILOperandUsage GetUsage() const { return m_usage; } + + uint64_t GetInteger() const; + size_t GetIndex() const; + uint32_t GetIntrinsic() const; + HighLevelILInstruction GetExpr() const; + Variable GetVariable() const; + SSAVariable GetSSAVariable() const; + HighLevelILInstructionList GetExprList() const; + HighLevelILSSAVariableList GetSSAVariableList() const; + }; + + class HighLevelILOperandList + { + struct ListIterator + { + const HighLevelILOperandList* owner; + std::vector<HighLevelILOperandUsage>::const_iterator pos; + bool operator==(const ListIterator& a) const { return pos == a.pos; } + bool operator!=(const ListIterator& a) const { return pos != a.pos; } + bool operator<(const ListIterator& a) const { return pos < a.pos; } + ListIterator& operator++() { ++pos; return *this; } + const HighLevelILOperand operator*(); + }; + + HighLevelILInstruction m_instr; + const std::vector<HighLevelILOperandUsage>& m_usageList; + const std::unordered_map<HighLevelILOperandUsage, size_t>& m_operandIndexMap; + + public: + typedef ListIterator const_iterator; + + HighLevelILOperandList(const HighLevelILInstruction& instr, + const std::vector<HighLevelILOperandUsage>& usageList, + const std::unordered_map<HighLevelILOperandUsage, size_t>& operandIndexMap); + + const_iterator begin() const; + const_iterator end() const; + size_t size() const; + const HighLevelILOperand operator[](size_t i) const; + + operator std::vector<HighLevelILOperand>() const; + }; + + struct HighLevelILConstantInstruction: public HighLevelILInstructionBase + { + int64_t GetConstant() const { return GetRawOperandAsInteger(0); } + }; + + struct HighLevelILOneOperandInstruction: public HighLevelILInstructionBase + { + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(0); } + }; + + struct HighLevelILTwoOperandInstruction: public HighLevelILInstructionBase + { + HighLevelILInstruction GetLeftExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetRightExpr() const { return GetRawOperandAsExpr(1); } + }; + + struct HighLevelILTwoOperandWithCarryInstruction: public HighLevelILInstructionBase + { + HighLevelILInstruction GetLeftExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetRightExpr() const { return GetRawOperandAsExpr(1); } + HighLevelILInstruction GetCarryExpr() const { return GetRawOperandAsExpr(2); } + }; + + // Implementations of each instruction to fetch the correct operand value for the valid operands, these + // are derived from HighLevelILInstructionBase so that invalid operand accessor functions will generate + // a compiler error. + template <> struct HighLevelILInstructionAccessor<HLIL_BLOCK>: public HighLevelILInstructionBase + { + HighLevelILInstructionList GetBlockExprs() const { return GetRawOperandAsExprList(0); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_IF>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetTrueExpr() const { return GetRawOperandAsExpr(1); } + HighLevelILInstruction GetFalseExpr() const { return GetRawOperandAsExpr(2); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_WHILE>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetLoopExpr() const { return GetRawOperandAsExpr(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_DO_WHILE>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetLoopExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_FOR>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetInitExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(1); } + HighLevelILInstruction GetUpdateExpr() const { return GetRawOperandAsExpr(2); } + HighLevelILInstruction GetLoopExpr() const { return GetRawOperandAsExpr(3); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_SWITCH>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetDefaultExpr() const { return GetRawOperandAsExpr(1); } + HighLevelILInstructionList GetCases() const { return GetRawOperandAsExprList(2); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_CASE>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetConditionExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetTrueExpr() const { return GetRawOperandAsExpr(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_GOTO>: public HighLevelILInstructionBase + { + size_t GetTarget() const { return GetRawOperandAsIndex(0); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_LABEL>: public HighLevelILInstructionBase + { + size_t GetTarget() const { return GetRawOperandAsIndex(0); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_RET>: public HighLevelILInstructionBase + { + HighLevelILInstructionList GetSourceExprs() const { return GetRawOperandAsExprList(0); } + void SetSourceExprs(const std::vector<ExprId>& exprs) { UpdateRawOperandAsExprList(0, exprs); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_ASSIGN>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(1); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_STRUCT_FIELD>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(0); } + uint64_t GetOffset() const { return GetRawOperandAsInteger(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_DEREF_FIELD>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(0); } + uint64_t GetOffset() const { return GetRawOperandAsInteger(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_ARRAY_INDEX>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetIndexExpr() const { return GetRawOperandAsExpr(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_SPLIT>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetHighExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstruction GetLowExpr() const { return GetRawOperandAsExpr(1); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_VAR>: public HighLevelILInstructionBase + { + Variable GetVariable() const { return GetRawOperandAsVariable(0); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_VAR_SSA>: public HighLevelILInstructionBase + { + SSAVariable GetSSAVariable() const { return GetRawOperandAsSSAVariable(0); } + void SetSSAVersion(size_t version) { UpdateRawOperand(1, version); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_VAR_PHI>: public HighLevelILInstructionBase + { + SSAVariable GetDestSSAVariable() const { return GetRawOperandAsSSAVariable(0); } + HighLevelILSSAVariableList GetSourceSSAVariables() const { return GetRawOperandAsSSAVariableList(2); } + void SetSourceSSAVariables(const std::vector<SSAVariable>& vars) { UpdateRawOperandAsSSAVariableList(2, vars); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_JUMP>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_CALL>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExprList(1); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_SYSCALL>: public HighLevelILInstructionBase + { + HighLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExprList(0); } + }; + template <> struct HighLevelILInstructionAccessor<HLIL_TAILCALL>: public HighLevelILInstructionBase + { + HighLevelILInstruction GetDestExpr() const { return GetRawOperandAsExpr(0); } + HighLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExprList(1); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_ASSIGN_UNPACK>: public HighLevelILInstructionBase + { + HighLevelILInstructionList GetDestExprs() const { return GetRawOperandAsExprList(0); } + HighLevelILInstruction GetSourceExpr() const { return GetRawOperandAsExpr(2); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_INTRINSIC>: public HighLevelILInstructionBase + { + uint32_t GetIntrinsic() const { return (uint32_t)GetRawOperandAsInteger(2); } + HighLevelILInstructionList GetParameterExprs() const { return GetRawOperandAsExprList(3); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_TRAP>: public HighLevelILInstructionBase + { + int64_t GetVector() const { return GetRawOperandAsInteger(0); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_EXTERN_PTR>: public HighLevelILConstantInstruction + { + int64_t GetConstant() const { return GetRawOperandAsInteger(0); } + int64_t GetOffset() const { return GetRawOperandAsInteger(1); } + }; + + template <> struct HighLevelILInstructionAccessor<HLIL_NOP>: public HighLevelILInstructionBase {}; + template <> struct HighLevelILInstructionAccessor<HLIL_BREAK>: public HighLevelILInstructionBase {}; + template <> struct HighLevelILInstructionAccessor<HLIL_NORET>: public HighLevelILInstructionBase {}; + template <> struct HighLevelILInstructionAccessor<HLIL_BP>: public HighLevelILInstructionBase {}; + template <> struct HighLevelILInstructionAccessor<HLIL_UNDEF>: public HighLevelILInstructionBase {}; + template <> struct HighLevelILInstructionAccessor<HLIL_UNIMPL>: public HighLevelILInstructionBase {}; + + template <> struct HighLevelILInstructionAccessor<HLIL_CONST>: public HighLevelILConstantInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CONST_PTR>: public HighLevelILConstantInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FLOAT_CONST>: public HighLevelILConstantInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_IMPORT>: public HighLevelILConstantInstruction {}; + + template <> struct HighLevelILInstructionAccessor<HLIL_ADD>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_SUB>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_AND>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_OR>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_XOR>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_LSL>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_LSR>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ASR>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ROL>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ROR>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MUL>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MULU_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MULS_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_DIVU>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_DIVS>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MODU>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MODS>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_DIVU_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_DIVS_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MODU_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_MODS_DP>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_E>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_NE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_SLT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_ULT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_SLE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_ULE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_SGE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_UGE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_SGT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CMP_UGT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_TEST_BIT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ADD_OVERFLOW>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FADD>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FSUB>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FMUL>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FDIV>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_E>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_NE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_LT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_LE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_GE>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_GT>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_O>: public HighLevelILTwoOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FCMP_UO>: public HighLevelILTwoOperandInstruction {}; + + template <> struct HighLevelILInstructionAccessor<HLIL_ADC>: public HighLevelILTwoOperandWithCarryInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_SBB>: public HighLevelILTwoOperandWithCarryInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_RLC>: public HighLevelILTwoOperandWithCarryInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_RRC>: public HighLevelILTwoOperandWithCarryInstruction {}; + + template <> struct HighLevelILInstructionAccessor<HLIL_DEREF>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ADDRESS_OF>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_NEG>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_NOT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_SX>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ZX>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_LOW_PART>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_BOOL_TO_INT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_UNIMPL_MEM>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FSQRT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FNEG>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FABS>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FLOAT_TO_INT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_INT_TO_FLOAT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FLOAT_CONV>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_ROUND_TO_INT>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FLOOR>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_CEIL>: public HighLevelILOneOperandInstruction {}; + template <> struct HighLevelILInstructionAccessor<HLIL_FTRUNC>: public HighLevelILOneOperandInstruction {}; +} |