From 203717232e816d42973f05f1c9fbc950914d71dc Mon Sep 17 00:00:00 2001
From: Rusty Wagner <rusty@vector35.com>
Date: Tue, 23 Jul 2019 22:40:39 -0400
Subject: Early HLIL testing

---
 highlevelilinstruction.h | 713 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 713 insertions(+)
 create mode 100644 highlevelilinstruction.h

(limited to 'highlevelilinstruction.h')

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 {};
+}
-- 
cgit v1.3.1