Merging with dev

1 files changed, 430 insertions, 41 deletions

diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index 7fabe042..ad28273d 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -486,6 +486,7 @@ namespace BinaryNinja
 	};
 
 	class Architecture;
+	class BackgroundTask;
 	class Platform;
 	class Type;
 	class DataBuffer;
@@ -679,8 +680,10 @@ namespace BinaryNinja
 		void erase(std::vector<std::string>::iterator i);
 		void clear();
 		void push_back(const std::string& name);
+		// Returns count of names
 		size_t size() const;
-
+		// Returns size of output string
+		size_t StringSize() const;
 		std::string GetString() const;
 
 		BNQualifiedName GetAPIObject() const;
@@ -864,6 +867,7 @@ namespace BinaryNinja
 		static void FunctionAddedCallback(void* ctxt, BNBinaryView* data, BNFunction* func);
 		static void FunctionRemovedCallback(void* ctxt, BNBinaryView* data, BNFunction* func);
 		static void FunctionUpdatedCallback(void* ctxt, BNBinaryView* data, BNFunction* func);
+		static void FunctionUpdateRequestedCallback(void* ctxt, BNBinaryView* data, BNFunction* func);
 		static void DataVariableAddedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var);
 		static void DataVariableRemovedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var);
 		static void DataVariableUpdatedCallback(void* ctxt, BNBinaryView* data, BNDataVariable* var);
@@ -884,6 +888,7 @@ namespace BinaryNinja
 		virtual void OnAnalysisFunctionAdded(BinaryView* view, Function* func) { (void)view; (void)func; }
 		virtual void OnAnalysisFunctionRemoved(BinaryView* view, Function* func) { (void)view; (void)func; }
 		virtual void OnAnalysisFunctionUpdated(BinaryView* view, Function* func) { (void)view; (void)func; }
+		virtual void OnAnalysisFunctionUpdateRequested(BinaryView* view, Function* func) { (void)view; (void)func; }
 		virtual void OnDataVariableAdded(BinaryView* view, const DataVariable& var) { (void)view; (void)var; }
 		virtual void OnDataVariableRemoved(BinaryView* view, const DataVariable& var) { (void)view; (void)var; }
 		virtual void OnDataVariableUpdated(BinaryView* view, const DataVariable& var) { (void)view; (void)var; }
@@ -934,8 +939,6 @@ namespace BinaryNinja
 	public:
 		Symbol(BNSymbolType type, const std::string& shortName, const std::string& fullName, const std::string& rawName, uint64_t addr);
 		Symbol(BNSymbolType type, const std::string& name, uint64_t addr);
-		//Symbol(const std::string& shortName, const std::string& fullName, const std::string& rawName, SymbolBinding binding, size_t size);
-		//Symbol(const std::string& name, SymbolBinding binding, size_t size);
 		Symbol(BNSymbol* sym);
 
 		BNSymbolType GetType() const;
@@ -967,6 +970,7 @@ namespace BinaryNinja
 		uint64_t address;
 
 		InstructionTextToken();
+		InstructionTextToken(uint8_t confidence, BNInstructionTextTokenType t, const std::string& txt);
 		InstructionTextToken(BNInstructionTextTokenType type, const std::string& text, uint64_t value = 0,
 			size_t size = 0, size_t operand = BN_INVALID_OPERAND, uint8_t confidence = BN_FULL_CONFIDENCE);
 		InstructionTextToken(BNInstructionTextTokenType type, BNInstructionTextTokenContext context,
@@ -979,6 +983,7 @@ namespace BinaryNinja
 	struct DisassemblyTextLine
 	{
 		uint64_t addr;
+		size_t instrIndex;
 		std::vector<InstructionTextToken> tokens;
 	};
 
@@ -1297,6 +1302,7 @@ namespace BinaryNinja
 		Ref<AnalysisCompletionEvent> AddAnalysisCompletionEvent(const std::function<void()>& callback);
 
 		BNAnalysisProgress GetAnalysisProgress();
+		Ref<BackgroundTask> GetBackgroundAnalysisTask();
 
 		uint64_t GetNextFunctionStartAfterAddress(uint64_t addr);
 		uint64_t GetNextBasicBlockStartAfterAddress(uint64_t addr);
@@ -1373,6 +1379,9 @@ namespace BinaryNinja
 		std::string GetStringMetadata(const std::string& key);
 		std::vector<uint8_t> GetRawMetadata(const std::string& key);
 		uint64_t GetUIntMetadata(const std::string& key);
+
+		uint64_t GetMaxFunctionSizeForAnalysis();
+		void SetMaxFunctionSizeForAnalysis(uint64_t size);
 	};
 
 	class BinaryData: public BinaryView
@@ -1601,7 +1610,18 @@ namespace BinaryNinja
 		void AddBranch(BNBranchType type, uint64_t target = 0, Architecture* arch = nullptr, bool hasDelaySlot = false);
 	};
 
+	struct NameAndType
+	{
+		std::string name;
+		Confidence<Ref<Type>> type;
+
+		NameAndType() {}
+		NameAndType(const Confidence<Ref<Type>>& t): type(t) {}
+		NameAndType(const std::string& n, const Confidence<Ref<Type>>& t): name(n), type(t) {}
+	};
+
 	class LowLevelILFunction;
+	class MediumLevelILFunction;
 	class FunctionRecognizer;
 	class CallingConvention;
 
@@ -1636,23 +1656,45 @@ namespace BinaryNinja
 		static char* GetRegisterNameCallback(void* ctxt, uint32_t reg);
 		static char* GetFlagNameCallback(void* ctxt, uint32_t flag);
 		static char* GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags);
+		static char* GetSemanticFlagClassNameCallback(void* ctxt, uint32_t semClass);
+		static char* GetSemanticFlagGroupNameCallback(void* ctxt, uint32_t semGroup);
 		static uint32_t* GetFullWidthRegistersCallback(void* ctxt, size_t* count);
 		static uint32_t* GetAllRegistersCallback(void* ctxt, size_t* count);
 		static uint32_t* GetAllFlagsCallback(void* ctxt, size_t* count);
 		static uint32_t* GetAllFlagWriteTypesCallback(void* ctxt, size_t* count);
-		static BNFlagRole GetFlagRoleCallback(void* ctxt, uint32_t flag);
-		static uint32_t* GetFlagsRequiredForFlagConditionCallback(void* ctxt, BNLowLevelILFlagCondition cond, size_t* count);
+		static uint32_t* GetAllSemanticFlagClassesCallback(void* ctxt, size_t* count);
+		static uint32_t* GetAllSemanticFlagGroupsCallback(void* ctxt, size_t* count);
+		static BNFlagRole GetFlagRoleCallback(void* ctxt, uint32_t flag, uint32_t semClass);
+		static uint32_t* GetFlagsRequiredForFlagConditionCallback(void* ctxt, BNLowLevelILFlagCondition cond,
+			uint32_t semClass, size_t* count);
+		static uint32_t* GetFlagsRequiredForSemanticFlagGroupCallback(void* ctxt, uint32_t semGroup, size_t* count);
+		static BNFlagConditionForSemanticClass* GetFlagConditionsForSemanticFlagGroupCallback(void* ctxt,
+			uint32_t semGroup, size_t* count);
+		static void FreeFlagConditionsForSemanticFlagGroupCallback(void* ctxt, BNFlagConditionForSemanticClass* conditions);
 		static uint32_t* GetFlagsWrittenByFlagWriteTypeCallback(void* ctxt, uint32_t writeType, size_t* count);
+		static uint32_t GetSemanticClassForFlagWriteTypeCallback(void* ctxt, uint32_t writeType);
 		static size_t GetFlagWriteLowLevelILCallback(void* ctxt, BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
 			uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, BNLowLevelILFunction* il);
 		static size_t GetFlagConditionLowLevelILCallback(void* ctxt, BNLowLevelILFlagCondition cond,
-			BNLowLevelILFunction* il);
+			uint32_t semClass, BNLowLevelILFunction* il);
+		static size_t GetSemanticFlagGroupLowLevelILCallback(void* ctxt, uint32_t semGroup, BNLowLevelILFunction* il);
 		static void FreeRegisterListCallback(void* ctxt, uint32_t* regs);
 		static void GetRegisterInfoCallback(void* ctxt, uint32_t reg, BNRegisterInfo* result);
 		static uint32_t GetStackPointerRegisterCallback(void* ctxt);
 		static uint32_t GetLinkRegisterCallback(void* ctxt);
 		static uint32_t* GetGlobalRegistersCallback(void* ctxt, size_t* count);
 
+		static char* GetRegisterStackNameCallback(void* ctxt, uint32_t regStack);
+		static uint32_t* GetAllRegisterStacksCallback(void* ctxt, size_t* count);
+		static void GetRegisterStackInfoCallback(void* ctxt, uint32_t regStack, BNRegisterStackInfo* result);
+
+		static char* GetIntrinsicNameCallback(void* ctxt, uint32_t intrinsic);
+		static uint32_t* GetAllIntrinsicsCallback(void* ctxt, size_t* count);
+		static BNNameAndType* GetIntrinsicInputsCallback(void* ctxt, uint32_t intrinsic, size_t* count);
+		static void FreeNameAndTypeListCallback(void* ctxt, BNNameAndType* nt, size_t count);
+		static BNTypeWithConfidence* GetIntrinsicOutputsCallback(void* ctxt, uint32_t intrinsic, size_t* count);
+		static void FreeTypeListCallback(void* ctxt, BNTypeWithConfidence* types, size_t count);
+
 		static bool AssembleCallback(void* ctxt, const char* code, uint64_t addr, BNDataBuffer* result, char** errors);
 		static bool IsNeverBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len);
 		static bool IsAlwaysBranchPatchAvailableCallback(void* ctxt, const uint8_t* data, uint64_t addr, size_t len);
@@ -1670,6 +1712,8 @@ namespace BinaryNinja
 		// static bool ApplyMachoRelocationCallback(void* ctxt, BNBinaryView* view, BNRelocation* rel, uint8_t* data, size_t len);
 		static bool GetRelocationInfoCallback(void* ctxt, BNBinaryView* view, uint64_t relocType, BNRelocationInfo* result);
 
+		virtual void Register(BNCustomArchitecture* callbacks);
+
 	public:
 		Architecture(const std::string& name);
 
@@ -1704,19 +1748,28 @@ namespace BinaryNinja
 		virtual std::string GetRegisterName(uint32_t reg);
 		virtual std::string GetFlagName(uint32_t flag);
 		virtual std::string GetFlagWriteTypeName(uint32_t flags);
+		virtual std::string GetSemanticFlagClassName(uint32_t semClass);
+		virtual std::string GetSemanticFlagGroupName(uint32_t semGroup);
 		virtual std::vector<uint32_t> GetFullWidthRegisters();
 		virtual std::vector<uint32_t> GetAllRegisters();
 		virtual std::vector<uint32_t> GetAllFlags();
 		virtual std::vector<uint32_t> GetAllFlagWriteTypes();
-		virtual BNFlagRole GetFlagRole(uint32_t flag);
-		virtual std::vector<uint32_t> GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond);
+		virtual std::vector<uint32_t> GetAllSemanticFlagClasses();
+		virtual std::vector<uint32_t> GetAllSemanticFlagGroups();
+		virtual BNFlagRole GetFlagRole(uint32_t flag, uint32_t semClass = 0);
+		virtual std::vector<uint32_t> GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond,
+			uint32_t semClass = 0);
+		virtual std::vector<uint32_t> GetFlagsRequiredForSemanticFlagGroup(uint32_t semGroup);
+		virtual std::map<uint32_t, BNLowLevelILFlagCondition> GetFlagConditionsForSemanticFlagGroup(uint32_t semGroup);
 		virtual std::vector<uint32_t> GetFlagsWrittenByFlagWriteType(uint32_t writeType);
+		virtual uint32_t GetSemanticClassForFlagWriteType(uint32_t writeType);
 		virtual ExprId GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
 			uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il);
 		ExprId GetDefaultFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, BNFlagRole role,
 			BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il);
-		virtual ExprId GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond, LowLevelILFunction& il);
-		ExprId GetDefaultFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond, LowLevelILFunction& il);
+		virtual ExprId GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il);
+		ExprId GetDefaultFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond, uint32_t semClass, LowLevelILFunction& il);
+		virtual ExprId GetSemanticFlagGroupLowLevelIL(uint32_t semGroup, LowLevelILFunction& il);
 		virtual BNRegisterInfo GetRegisterInfo(uint32_t reg);
 		virtual uint32_t GetStackPointerRegister();
 		virtual uint32_t GetLinkRegister();
@@ -1725,6 +1778,16 @@ namespace BinaryNinja
 		std::vector<uint32_t> GetModifiedRegistersOnWrite(uint32_t reg);
 		uint32_t GetRegisterByName(const std::string& name);
 
+		virtual std::string GetRegisterStackName(uint32_t regStack);
+		virtual std::vector<uint32_t> GetAllRegisterStacks();
+		virtual BNRegisterStackInfo GetRegisterStackInfo(uint32_t regStack);
+		uint32_t GetRegisterStackForRegister(uint32_t reg);
+
+		virtual std::string GetIntrinsicName(uint32_t intrinsic);
+		virtual std::vector<uint32_t> GetAllIntrinsics();
+		virtual std::vector<NameAndType> GetIntrinsicInputs(uint32_t intrinsic);
+		virtual std::vector<Confidence<Ref<Type>>> GetIntrinsicOutputs(uint32_t intrinsic);
+
 		virtual bool Assemble(const std::string& code, uint64_t addr, DataBuffer& result, std::string& errors);
 
 		/*! IsNeverBranchPatchAvailable returns true if the instruction at addr can be patched to never branch.
@@ -1824,6 +1887,8 @@ namespace BinaryNinja
 			(void)view; (void)relocType; (void)result;
 			return false;
 		}
+
+		void AddArchitectureRedirection(Architecture* from, Architecture* to);
 	};
 
 	class CoreArchitecture: public Architecture
@@ -1844,21 +1909,45 @@ namespace BinaryNinja
 		virtual std::string GetRegisterName(uint32_t reg) override;
 		virtual std::string GetFlagName(uint32_t flag) override;
 		virtual std::string GetFlagWriteTypeName(uint32_t flags) override;
+		//virtual bool ApplyPERelocation(BinaryView* view, Relocation* rel, uint8_t* dest, size_t len) override;
+		virtual bool ApplyELFRelocation(BinaryView* view, BNRelocationInfo& rel, uint8_t* dest, size_t len) override;
+		//virtual bool ApplyMachoRelocation(BinaryView* view, Relocation* rel, uint8_t* dest, size_t len) override;
+		virtual bool GetRelocationInfo(BinaryView* view, uint64_t relocType, BNRelocationInfo& result) override;
+
+		virtual std::string GetSemanticFlagClassName(uint32_t semClass) override;
+		virtual std::string GetSemanticFlagGroupName(uint32_t semGroup) override;
 		virtual std::vector<uint32_t> GetFullWidthRegisters() override;
 		virtual std::vector<uint32_t> GetAllRegisters() override;
 		virtual std::vector<uint32_t> GetAllFlags() override;
 		virtual std::vector<uint32_t> GetAllFlagWriteTypes() override;
-		virtual BNFlagRole GetFlagRole(uint32_t flag) override;
-		virtual std::vector<uint32_t> GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond) override;
+		virtual std::vector<uint32_t> GetAllSemanticFlagClasses() override;
+		virtual std::vector<uint32_t> GetAllSemanticFlagGroups() override;
+		virtual BNFlagRole GetFlagRole(uint32_t flag, uint32_t semClass = 0) override;
+		virtual std::vector<uint32_t> GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond,
+			uint32_t semClass = 0) override;
+		virtual std::vector<uint32_t> GetFlagsRequiredForSemanticFlagGroup(uint32_t semGroup) override;
+		virtual std::map<uint32_t, BNLowLevelILFlagCondition> GetFlagConditionsForSemanticFlagGroup(uint32_t semGroup) override;
 		virtual std::vector<uint32_t> GetFlagsWrittenByFlagWriteType(uint32_t writeType) override;
+		virtual uint32_t GetSemanticClassForFlagWriteType(uint32_t writeType) override;
 		virtual ExprId GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
 			uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il) override;
-		virtual ExprId GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond, LowLevelILFunction& il) override;
+		virtual ExprId GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
+			uint32_t semClass, LowLevelILFunction& il) override;
+		virtual ExprId GetSemanticFlagGroupLowLevelIL(uint32_t semGroup, LowLevelILFunction& il) override;
 		virtual BNRegisterInfo GetRegisterInfo(uint32_t reg) override;
 		virtual uint32_t GetStackPointerRegister() override;
 		virtual uint32_t GetLinkRegister() override;
 		virtual std::vector<uint32_t> GetGlobalRegisters() override;
 
+		virtual std::string GetRegisterStackName(uint32_t regStack) override;
+		virtual std::vector<uint32_t> GetAllRegisterStacks() override;
+		virtual BNRegisterStackInfo GetRegisterStackInfo(uint32_t regStack) override;
+
+		virtual std::string GetIntrinsicName(uint32_t intrinsic) override;
+		virtual std::vector<uint32_t> GetAllIntrinsics() override;
+		virtual std::vector<NameAndType> GetIntrinsicInputs(uint32_t intrinsic) override;
+		virtual std::vector<Confidence<Ref<Type>>> GetIntrinsicOutputs(uint32_t intrinsic) override;
+
 		virtual bool Assemble(const std::string& code, uint64_t addr, DataBuffer& result, std::string& errors) override;
 
 		virtual bool IsNeverBranchPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
@@ -1871,11 +1960,91 @@ namespace BinaryNinja
 		virtual bool AlwaysBranch(uint8_t* data, uint64_t addr, size_t len) override;
 		virtual bool InvertBranch(uint8_t* data, uint64_t addr, size_t len) override;
 		virtual bool SkipAndReturnValue(uint8_t* data, uint64_t addr, size_t len, uint64_t value) override;
+	};
 
-		//virtual bool ApplyPERelocation(BinaryView* view, Relocation* rel, uint8_t* dest, size_t len) override;
-		virtual bool ApplyELFRelocation(BinaryView* view, BNRelocationInfo& rel, uint8_t* dest, size_t len) override;
-		//virtual bool ApplyMachoRelocation(BinaryView* view, Relocation* rel, uint8_t* dest, size_t len) override;
-		virtual bool GetRelocationInfo(BinaryView* view, uint64_t relocType, BNRelocationInfo& result) override;
+	class ArchitectureExtension: public Architecture
+	{
+	protected:
+		Ref<Architecture> m_base;
+
+		virtual void Register(BNCustomArchitecture* callbacks) override;
+
+	public:
+		ArchitectureExtension(const std::string& name, Architecture* base);
+
+		Ref<Architecture> GetBaseArchitecture() const { return m_base; }
+
+		virtual BNEndianness GetEndianness() const override;
+		virtual size_t GetAddressSize() const override;
+		virtual size_t GetDefaultIntegerSize() const override;
+		virtual size_t GetInstructionAlignment() const override;
+		virtual size_t GetMaxInstructionLength() const override;
+		virtual size_t GetOpcodeDisplayLength() const override;
+		virtual Ref<Architecture> GetAssociatedArchitectureByAddress(uint64_t& addr) override;
+		virtual bool GetInstructionInfo(const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result) override;
+		virtual bool GetInstructionText(const uint8_t* data, uint64_t addr, size_t& len,
+		                                std::vector<InstructionTextToken>& result) override;
+		virtual bool GetInstructionLowLevelIL(const uint8_t* data, uint64_t addr, size_t& len, LowLevelILFunction& il) override;
+		virtual std::string GetRegisterName(uint32_t reg) override;
+		virtual std::string GetFlagName(uint32_t flag) override;
+		virtual std::string GetFlagWriteTypeName(uint32_t flags) override;
+		virtual std::string GetSemanticFlagClassName(uint32_t semClass) override;
+		virtual std::string GetSemanticFlagGroupName(uint32_t semGroup) override;
+		virtual std::vector<uint32_t> GetFullWidthRegisters() override;
+		virtual std::vector<uint32_t> GetAllRegisters() override;
+		virtual std::vector<uint32_t> GetAllFlags() override;
+		virtual std::vector<uint32_t> GetAllFlagWriteTypes() override;
+		virtual std::vector<uint32_t> GetAllSemanticFlagClasses() override;
+		virtual std::vector<uint32_t> GetAllSemanticFlagGroups() override;
+		virtual BNFlagRole GetFlagRole(uint32_t flag, uint32_t semClass = 0) override;
+		virtual std::vector<uint32_t> GetFlagsRequiredForFlagCondition(BNLowLevelILFlagCondition cond,
+			uint32_t semClass = 0) override;
+		virtual std::vector<uint32_t> GetFlagsRequiredForSemanticFlagGroup(uint32_t semGroup) override;
+		virtual std::map<uint32_t, BNLowLevelILFlagCondition> GetFlagConditionsForSemanticFlagGroup(uint32_t semGroup) override;
+		virtual std::vector<uint32_t> GetFlagsWrittenByFlagWriteType(uint32_t writeType) override;
+		virtual uint32_t GetSemanticClassForFlagWriteType(uint32_t writeType) override;
+		virtual ExprId GetFlagWriteLowLevelIL(BNLowLevelILOperation op, size_t size, uint32_t flagWriteType,
+			uint32_t flag, BNRegisterOrConstant* operands, size_t operandCount, LowLevelILFunction& il) override;
+		virtual ExprId GetFlagConditionLowLevelIL(BNLowLevelILFlagCondition cond,
+			uint32_t semClass, LowLevelILFunction& il) override;
+		virtual ExprId GetSemanticFlagGroupLowLevelIL(uint32_t semGroup, LowLevelILFunction& il) override;
+		virtual BNRegisterInfo GetRegisterInfo(uint32_t reg) override;
+		virtual uint32_t GetStackPointerRegister() override;
+		virtual uint32_t GetLinkRegister() override;
+		virtual std::vector<uint32_t> GetGlobalRegisters() override;
+
+		virtual std::string GetRegisterStackName(uint32_t regStack) override;
+		virtual std::vector<uint32_t> GetAllRegisterStacks() override;
+		virtual BNRegisterStackInfo GetRegisterStackInfo(uint32_t regStack) override;
+
+		virtual std::string GetIntrinsicName(uint32_t intrinsic) override;
+		virtual std::vector<uint32_t> GetAllIntrinsics() override;
+		virtual std::vector<NameAndType> GetIntrinsicInputs(uint32_t intrinsic) override;
+		virtual std::vector<Confidence<Ref<Type>>> GetIntrinsicOutputs(uint32_t intrinsic) override;
+
+		virtual bool Assemble(const std::string& code, uint64_t addr, DataBuffer& result, std::string& errors) override;
+
+		virtual bool IsNeverBranchPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool IsAlwaysBranchPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool IsInvertBranchPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool IsSkipAndReturnZeroPatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool IsSkipAndReturnValuePatchAvailable(const uint8_t* data, uint64_t addr, size_t len) override;
+
+		virtual bool ConvertToNop(uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool AlwaysBranch(uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool InvertBranch(uint8_t* data, uint64_t addr, size_t len) override;
+		virtual bool SkipAndReturnValue(uint8_t* data, uint64_t addr, size_t len, uint64_t value) override;
+	};
+
+	class ArchitectureHook: public CoreArchitecture
+	{
+	protected:
+		Ref<Architecture> m_base;
+
+		virtual void Register(BNCustomArchitecture* callbacks) override;
+
+	public:
+		ArchitectureHook(Architecture* base);
 	};
 
 	class Structure;
@@ -2136,6 +2305,12 @@ namespace BinaryNinja
 		void SetUserBasicBlockHighlight(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255);
 
 		static bool IsBackEdge(BasicBlock* source, BasicBlock* target);
+
+		bool IsILBlock() const;
+		bool IsLowLevelILBlock() const;
+		bool IsMediumLevelILBlock() const;
+		Ref<LowLevelILFunction> GetLowLevelILFunction() const;
+		Ref<MediumLevelILFunction> GetMediumLevelILFunction() const;
 	};
 
 	struct VariableNameAndType
@@ -2256,28 +2431,34 @@ namespace BinaryNinja
 
 		Ref<Type> GetType() const;
 		Confidence<Ref<Type>> GetReturnType() const;
+		Confidence<std::vector<uint32_t>> GetReturnRegisters() const;
 		Confidence<Ref<CallingConvention>> GetCallingConvention() const;
 		Confidence<std::vector<Variable>> GetParameterVariables() const;
 		Confidence<bool> HasVariableArguments() const;
 		Confidence<size_t> GetStackAdjustment() const;
+		std::map<uint32_t, Confidence<int32_t>> GetRegisterStackAdjustments() const;
 		Confidence<std::set<uint32_t>> GetClobberedRegisters() const;
 
 		void SetAutoType(Type* type);
 		void SetAutoReturnType(const Confidence<Ref<Type>>& type);
+		void SetAutoReturnRegisters(const Confidence<std::vector<uint32_t>>& returnRegs);
 		void SetAutoCallingConvention(const Confidence<Ref<CallingConvention>>& convention);
 		void SetAutoParameterVariables(const Confidence<std::vector<Variable>>& vars);
 		void SetAutoHasVariableArguments(const Confidence<bool>& varArgs);
 		void SetAutoCanReturn(const Confidence<bool>& returns);
 		void SetAutoStackAdjustment(const Confidence<size_t>& stackAdjust);
+		void SetAutoRegisterStackAdjustments(const std::map<uint32_t, Confidence<int32_t>>& regStackAdjust);
 		void SetAutoClobberedRegisters(const Confidence<std::set<uint32_t>>& clobbered);
 
 		void SetUserType(Type* type);
 		void SetReturnType(const Confidence<Ref<Type>>& type);
+		void SetReturnRegisters(const Confidence<std::vector<uint32_t>>& returnRegs);
 		void SetCallingConvention(const Confidence<Ref<CallingConvention>>& convention);
 		void SetParameterVariables(const Confidence<std::vector<Variable>>& vars);
 		void SetHasVariableArguments(const Confidence<bool>& varArgs);
 		void SetCanReturn(const Confidence<bool>& returns);
 		void SetStackAdjustment(const Confidence<size_t>& stackAdjust);
+		void SetRegisterStackAdjustments(const std::map<uint32_t, Confidence<int32_t>>& regStackAdjust);
 		void SetClobberedRegisters(const Confidence<std::set<uint32_t>>& clobbered);
 
 		void ApplyImportedTypes(Symbol* sym);
@@ -2308,6 +2489,21 @@ namespace BinaryNinja
 		std::vector<IndirectBranchInfo> GetIndirectBranches();
 		std::vector<IndirectBranchInfo> GetIndirectBranchesAt(Architecture* arch, uint64_t addr);
 
+		void SetAutoCallStackAdjustment(Architecture* arch, uint64_t addr, const Confidence<size_t>& adjust);
+		void SetAutoCallRegisterStackAdjustment(Architecture* arch, uint64_t addr,
+			const std::map<uint32_t, Confidence<int32_t>>& adjust);
+		void SetAutoCallRegisterStackAdjustment(Architecture* arch, uint64_t addr, uint32_t regStack,
+			const Confidence<int32_t>& adjust);
+		void SetUserCallStackAdjustment(Architecture* arch, uint64_t addr, const Confidence<size_t>& adjust);
+		void SetUserCallRegisterStackAdjustment(Architecture* arch, uint64_t addr,
+			const std::map<uint32_t, Confidence<int32_t>>& adjust);
+		void SetUserCallRegisterStackAdjustment(Architecture* arch, uint64_t addr, uint32_t regStack,
+			const Confidence<int32_t>& adjust);
+
+		Confidence<size_t> GetCallStackAdjustment(Architecture* arch, uint64_t addr);
+		std::map<uint32_t, Confidence<int32_t>> GetCallRegisterStackAdjustment(Architecture* arch, uint64_t addr);
+		Confidence<int32_t> GetCallRegisterStackAdjustment(Architecture* arch, uint64_t addr, uint32_t regStack);
+
 		std::vector<std::vector<InstructionTextToken>> GetBlockAnnotations(Architecture* arch, uint64_t addr);
 
 		BNIntegerDisplayType GetIntegerConstantDisplayType(Architecture* arch, uint64_t instrAddr, uint64_t value,
@@ -2343,6 +2539,11 @@ namespace BinaryNinja
 
 		Confidence<RegisterValue> GetGlobalPointerValue() const;
 		Confidence<RegisterValue> GetRegisterValueAtExit(uint32_t reg) const;
+
+		bool IsFunctionTooLarge();
+		bool IsAnalysisSkipped();
+		BNFunctionAnalysisSkipOverride GetAnalysisSkipOverride();
+		void SetAnalysisSkipOverride(BNFunctionAnalysisSkipOverride skip);
 	};
 
 	class AdvancedFunctionAnalysisDataRequestor
@@ -2418,6 +2619,7 @@ namespace BinaryNinja
 		void Abort();
 
 		std::vector<Ref<FunctionGraphBlock>> GetBlocks();
+		bool HasBlocks() const;
 
 		int GetWidth() const;
 		int GetHeight() const;
@@ -2425,6 +2627,12 @@ namespace BinaryNinja
 
 		bool IsOptionSet(BNDisassemblyOption option) const;
 		void SetOption(BNDisassemblyOption option, bool state = true);
+
+		bool IsILGraph() const;
+		bool IsLowLevelILGraph() const;
+		bool IsMediumLevelILGraph() const;
+		Ref<LowLevelILFunction> GetLowLevelILFunction() const;
+		Ref<MediumLevelILFunction> GetMediumLevelILFunction() const;
 	};
 
 	struct LowLevelILLabel: public BNLowLevelILLabel
@@ -2458,8 +2666,11 @@ namespace BinaryNinja
 	};
 
 	struct LowLevelILInstruction;
+	struct RegisterOrFlag;
 	struct SSARegister;
+	struct SSARegisterStack;
 	struct SSAFlag;
+	struct SSARegisterOrFlag;
 
 	class LowLevelILFunction: public CoreRefCountObject<BNLowLevelILFunction,
 		BNNewLowLevelILFunctionReference, BNFreeLowLevelILFunction>
@@ -2501,6 +2712,14 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId SetRegisterSplitSSA(size_t size, const SSARegister& high, const SSARegister& low, ExprId val,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId SetRegisterStackTopRelative(size_t size, uint32_t regStack, ExprId entry, ExprId val,
+			uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackPush(size_t size, uint32_t regStack, ExprId val, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId SetRegisterStackTopRelativeSSA(size_t size, uint32_t regStack, size_t destVersion, size_t srcVersion,
+			ExprId entry, const SSARegister& top, ExprId val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId SetRegisterStackAbsoluteSSA(size_t size, uint32_t regStack, size_t destVersion, size_t srcVersion,
+			uint32_t reg, ExprId val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId SetFlag(uint32_t flag, ExprId val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId SetFlagSSA(const SSAFlag& flag, ExprId val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Load(size_t size, ExprId addr, uint32_t flags = 0,
@@ -2518,8 +2737,29 @@ namespace BinaryNinja
 		ExprId RegisterSSA(size_t size, const SSARegister& reg, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId RegisterSSAPartial(size_t size, const SSARegister& fullReg, uint32_t partialReg,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterSplit(size_t size, uint32_t high, uint32_t low, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterSplitSSA(size_t size, const SSARegister& high, const SSARegister& low,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackTopRelative(size_t size, uint32_t regStack, ExprId entry,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackPop(size_t size, uint32_t regStack, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackFreeReg(uint32_t reg, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackFreeTopRelative(uint32_t regStack, ExprId entry,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackTopRelativeSSA(size_t size, const SSARegisterStack& regStack, ExprId entry,
+			const SSARegister& top, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackAbsoluteSSA(size_t size, const SSARegisterStack& regStack, uint32_t reg,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackFreeTopRelativeSSA(uint32_t regStack, size_t destVersion, size_t srcVersion,
+			ExprId entry, const SSARegister& top, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackFreeAbsoluteSSA(uint32_t regStack, size_t destVersion, size_t srcVersion,
+			uint32_t reg, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Const(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ConstPointer(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstRaw(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstSingle(float val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstDouble(double val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Flag(uint32_t flag, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId FlagSSA(const SSAFlag& flag, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId FlagBit(size_t size, uint32_t flag, uint32_t bitIndex,
@@ -2562,19 +2802,19 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId DivUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId DivDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags = 0,
+		ExprId DivDoublePrecUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId DivSigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId DivDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags = 0,
+		ExprId DivDoublePrecSigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ModUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId ModDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags = 0,
+		ExprId ModDoublePrecUnsigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ModSigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId ModDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId div, uint32_t flags = 0,
+		ExprId ModDoublePrecSigned(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Neg(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Not(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
@@ -2588,16 +2828,19 @@ namespace BinaryNinja
 		ExprId JumpTo(ExprId dest, const std::vector<BNLowLevelILLabel*>& targets,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Call(ExprId dest, const ILSourceLocation& loc = ILSourceLocation());
-		ExprId CallStackAdjust(ExprId dest, size_t adjust, const ILSourceLocation& loc = ILSourceLocation());
-		ExprId CallSSA(const std::vector<SSARegister>& output, ExprId dest, const std::vector<SSARegister>& params,
+		ExprId CallStackAdjust(ExprId dest, size_t adjust, const std::map<uint32_t, int32_t>& regStackAdjust,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId CallSSA(const std::vector<SSARegister>& output, ExprId dest, const std::vector<ExprId>& params,
 			const SSARegister& stack, size_t newMemoryVer, size_t prevMemoryVer,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId SystemCallSSA(const std::vector<SSARegister>& output, const std::vector<SSARegister>& params,
+		ExprId SystemCallSSA(const std::vector<SSARegister>& output, const std::vector<ExprId>& params,
 			const SSARegister& stack, size_t newMemoryVer, size_t prevMemoryVer,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Return(size_t dest, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId NoReturn(const ILSourceLocation& loc = ILSourceLocation());
-		ExprId FlagCondition(BNLowLevelILFlagCondition cond, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FlagCondition(BNLowLevelILFlagCondition cond, uint32_t semClass = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FlagGroup(uint32_t semGroup, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId CompareEqual(size_t size, ExprId a, ExprId b,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId CompareNotEqual(size_t size, ExprId a, ExprId b,
@@ -2621,6 +2864,11 @@ namespace BinaryNinja
 		ExprId TestBit(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId BoolToInt(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId SystemCall(const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Intrinsic(const std::vector<RegisterOrFlag>& outputs, uint32_t intrinsic,
+			const std::vector<ExprId>& params, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId IntrinsicSSA(const std::vector<SSARegisterOrFlag>& outputs, uint32_t intrinsic,
+			const std::vector<ExprId>& params, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Breakpoint(const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Trap(uint32_t num, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Undefined(const ILSourceLocation& loc = ILSourceLocation());
@@ -2628,10 +2876,38 @@ namespace BinaryNinja
 		ExprId UnimplementedMemoryRef(size_t size, ExprId addr, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId RegisterPhi(const SSARegister& dest, const std::vector<SSARegister>& sources,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RegisterStackPhi(const SSARegisterStack& dest, const std::vector<SSARegisterStack>& sources,
+			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId FlagPhi(const SSAFlag& dest, const std::vector<SSAFlag>& sources,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId MemoryPhi(size_t dest, const std::vector<size_t>& sources,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatAdd(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatSub(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatMult(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatDiv(size_t size, ExprId a, ExprId b, uint32_t flags = 0,
+			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatSqrt(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatNeg(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatAbs(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatToInt(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId IntToFloat(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConvert(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RoundToInt(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Floor(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Ceil(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatTrunc(size_t size, ExprId a, uint32_t flags = 0, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareNotEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareLessThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareLessEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareGreaterEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareGreaterThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareOrdered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareUnordered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
 
 		ExprId Goto(BNLowLevelILLabel& label, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId If(ExprId operand, BNLowLevelILLabel& t, BNLowLevelILLabel& f,
@@ -2642,8 +2918,11 @@ namespace BinaryNinja
 		ExprId AddLabelList(const std::vector<BNLowLevelILLabel*>& labels);
 		ExprId AddOperandList(const std::vector<ExprId> operands);
 		ExprId AddIndexList(const std::vector<size_t> operands);
+		ExprId AddRegisterOrFlagList(const std::vector<RegisterOrFlag>& regs);
 		ExprId AddSSARegisterList(const std::vector<SSARegister>& regs);
+		ExprId AddSSARegisterStackList(const std::vector<SSARegisterStack>& regStacks);
 		ExprId AddSSAFlagList(const std::vector<SSAFlag>& flags);
+		ExprId AddSSARegisterOrFlagList(const std::vector<SSARegisterOrFlag>& regs);
 
 		ExprId GetExprForRegisterOrConstant(const BNRegisterOrConstant& operand, size_t size);
 		ExprId GetNegExprForRegisterOrConstant(const BNRegisterOrConstant& operand, size_t size);
@@ -2790,6 +3069,8 @@ namespace BinaryNinja
 		ExprId Var(size_t size, const Variable& src, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId VarField(size_t size, const Variable& src, uint64_t offset,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId VarSplit(size_t size, const Variable& high, const Variable& low,
+			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId VarSSA(size_t size, const SSAVariable& src, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId VarSSAField(size_t size, const SSAVariable& src, uint64_t offset,
 			const ILSourceLocation& loc = ILSourceLocation());
@@ -2797,11 +3078,16 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId VarAliasedField(size_t size, const Variable& src, size_t memVersion, uint64_t offset,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId VarSplitSSA(size_t size, const SSAVariable& high, const SSAVariable& low,
+			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId AddressOf(const Variable& var, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId AddressOfField(const Variable& var, uint64_t offset,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Const(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ConstPointer(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstRaw(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstSingle(float val, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConstDouble(double val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ImportedAddress(size_t size, uint64_t val, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Add(size_t size, ExprId left, ExprId right, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId AddWithCarry(size_t size, ExprId left, ExprId right, ExprId carry,
@@ -2835,17 +3121,17 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId DivUnsigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId DivDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId right,
+		ExprId DivDoublePrecSigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId DivDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId right,
+		ExprId DivDoublePrecUnsigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ModSigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId ModUnsigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId ModDoublePrecSigned(size_t size, ExprId high, ExprId low, ExprId right,
+		ExprId ModDoublePrecSigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
-		ExprId ModDoublePrecUnsigned(size_t size, ExprId high, ExprId low, ExprId right,
+		ExprId ModDoublePrecUnsigned(size_t size, ExprId left, ExprId right,
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Neg(size_t size, ExprId src, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Not(size_t size, ExprId src, const ILSourceLocation& loc = ILSourceLocation());
@@ -2902,6 +3188,13 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Breakpoint(const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Trap(int64_t vector, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Intrinsic(const std::vector<Variable>& outputs, uint32_t intrinsic,
+			const std::vector<ExprId>& params, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId IntrinsicSSA(const std::vector<SSAVariable>& outputs, uint32_t intrinsic,
+			const std::vector<ExprId>& params, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FreeVarSlot(const Variable& var, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FreeVarSlotSSA(const Variable& var, size_t newVersion, size_t prevVersion,
+			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Undefined(const ILSourceLocation& loc = ILSourceLocation());
 		ExprId Unimplemented(const ILSourceLocation& loc = ILSourceLocation());
 		ExprId UnimplementedMemoryRef(size_t size, ExprId target,
@@ -2910,6 +3203,28 @@ namespace BinaryNinja
 			const ILSourceLocation& loc = ILSourceLocation());
 		ExprId MemoryPhi(size_t destMemVersion, const std::vector<size_t>& sourceMemVersions,
 			const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatAdd(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatSub(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatMult(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatDiv(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatSqrt(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatNeg(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatAbs(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatToInt(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId IntToFloat(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatConvert(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId RoundToInt(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Floor(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId Ceil(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatTrunc(size_t size, ExprId a, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareNotEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareLessThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareLessEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareGreaterEqual(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareGreaterThan(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareOrdered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
+		ExprId FloatCompareUnordered(size_t size, ExprId a, ExprId b, const ILSourceLocation& loc = ILSourceLocation());
 
 		ExprId Goto(BNMediumLevelILLabel& label, const ILSourceLocation& loc = ILSourceLocation());
 		ExprId If(ExprId operand, BNMediumLevelILLabel& t, BNMediumLevelILLabel& f,
@@ -3060,7 +3375,10 @@ namespace BinaryNinja
 	{
 		Ref<BinaryView> view;
 		uint64_t address, length;
+		size_t instrIndex;
 		Ref<Function> function;
+		Ref<LowLevelILFunction> lowLevelILFunction;
+		Ref<MediumLevelILFunction> mediumLevelILFunction;
 
 		PluginCommandContext();
 	};
@@ -3093,15 +3411,55 @@ namespace BinaryNinja
 			std::function<bool(BinaryView*, Function*)> isValid;
 		};
 
+		struct RegisteredLowLevelILFunctionCommand
+		{
+			std::function<void(BinaryView*, LowLevelILFunction*)> action;
+			std::function<bool(BinaryView*, LowLevelILFunction*)> isValid;
+		};
+
+		struct RegisteredLowLevelILInstructionCommand
+		{
+			std::function<void(BinaryView*, const LowLevelILInstruction&)> action;
+			std::function<bool(BinaryView*, const LowLevelILInstruction&)> isValid;
+		};
+
+		struct RegisteredMediumLevelILFunctionCommand
+		{
+			std::function<void(BinaryView*, MediumLevelILFunction*)> action;
+			std::function<bool(BinaryView*, MediumLevelILFunction*)> isValid;
+		};
+
+		struct RegisteredMediumLevelILInstructionCommand
+		{
+			std::function<void(BinaryView*, const MediumLevelILInstruction&)> action;
+			std::function<bool(BinaryView*, const MediumLevelILInstruction&)> isValid;
+		};
+
 		static void DefaultPluginCommandActionCallback(void* ctxt, BNBinaryView* view);
 		static void AddressPluginCommandActionCallback(void* ctxt, BNBinaryView* view, uint64_t addr);
 		static void RangePluginCommandActionCallback(void* ctxt, BNBinaryView* view, uint64_t addr, uint64_t len);
 		static void FunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view, BNFunction* func);
+		static void LowLevelILFunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
+			BNLowLevelILFunction* func);
+		static void LowLevelILInstructionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
+			BNLowLevelILFunction* func, size_t instr);
+		static void MediumLevelILFunctionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
+			BNMediumLevelILFunction* func);
+		static void MediumLevelILInstructionPluginCommandActionCallback(void* ctxt, BNBinaryView* view,
+			BNMediumLevelILFunction* func, size_t instr);
 
 		static bool DefaultPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view);
 		static bool AddressPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view, uint64_t addr);
 		static bool RangePluginCommandIsValidCallback(void* ctxt, BNBinaryView* view, uint64_t addr, uint64_t len);
 		static bool FunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view, BNFunction* func);
+		static bool LowLevelILFunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
+			BNLowLevelILFunction* func);
+		static bool LowLevelILInstructionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
+			BNLowLevelILFunction* func, size_t instr);
+		static bool MediumLevelILFunctionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
+			BNMediumLevelILFunction* func);
+		static bool MediumLevelILInstructionPluginCommandIsValidCallback(void* ctxt, BNBinaryView* view,
+			BNMediumLevelILFunction* func, size_t instr);
 
 	public:
 		PluginCommand(const BNPluginCommand& cmd);
@@ -3111,25 +3469,45 @@ namespace BinaryNinja
 		PluginCommand& operator=(const PluginCommand& cmd);
 
 		static void Register(const std::string& name, const std::string& description,
-		                     const std::function<void(BinaryView* view)>& action);
+			const std::function<void(BinaryView* view)>& action);
 		static void Register(const std::string& name, const std::string& description,
-		                     const std::function<void(BinaryView* view)>& action,
-		                     const std::function<bool(BinaryView* view)>& isValid);
+			const std::function<void(BinaryView* view)>& action,
+			const std::function<bool(BinaryView* view)>& isValid);
 		static void RegisterForAddress(const std::string& name, const std::string& description,
-		                               const std::function<void(BinaryView* view, uint64_t addr)>& action);
+			const std::function<void(BinaryView* view, uint64_t addr)>& action);
 		static void RegisterForAddress(const std::string& name, const std::string& description,
-		                               const std::function<void(BinaryView* view, uint64_t addr)>& action,
-		                               const std::function<bool(BinaryView* view, uint64_t addr)>& isValid);
+			const std::function<void(BinaryView* view, uint64_t addr)>& action,
+			const std::function<bool(BinaryView* view, uint64_t addr)>& isValid);
 		static void RegisterForRange(const std::string& name, const std::string& description,
-		                             const std::function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action);
+			const std::function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action);
 		static void RegisterForRange(const std::string& name, const std::string& description,
-		                             const std::function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action,
-		                             const std::function<bool(BinaryView* view, uint64_t addr, uint64_t len)>& isValid);
+			const std::function<void(BinaryView* view, uint64_t addr, uint64_t len)>& action,
+			const std::function<bool(BinaryView* view, uint64_t addr, uint64_t len)>& isValid);
 		static void RegisterForFunction(const std::string& name, const std::string& description,
-		                                const std::function<void(BinaryView* view, Function* func)>& action);
+			const std::function<void(BinaryView* view, Function* func)>& action);
 		static void RegisterForFunction(const std::string& name, const std::string& description,
-		                                const std::function<void(BinaryView* view, Function* func)>& action,
-		                                const std::function<bool(BinaryView* view, Function* func)>& isValid);
+			const std::function<void(BinaryView* view, Function* func)>& action,
+			const std::function<bool(BinaryView* view, Function* func)>& isValid);
+		static void RegisterForLowLevelILFunction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, LowLevelILFunction* func)>& action);
+		static void RegisterForLowLevelILFunction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, LowLevelILFunction* func)>& action,
+			const std::function<bool(BinaryView* view, LowLevelILFunction* func)>& isValid);
+		static void RegisterForLowLevelILInstruction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action);
+		static void RegisterForLowLevelILInstruction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, const LowLevelILInstruction& instr)>& action,
+			const std::function<bool(BinaryView* view, const LowLevelILInstruction& instr)>& isValid);
+		static void RegisterForMediumLevelILFunction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, MediumLevelILFunction* func)>& action);
+		static void RegisterForMediumLevelILFunction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, MediumLevelILFunction* func)>& action,
+			const std::function<bool(BinaryView* view, MediumLevelILFunction* func)>& isValid);
+		static void RegisterForMediumLevelILInstruction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action);
+		static void RegisterForMediumLevelILInstruction(const std::string& name, const std::string& description,
+			const std::function<void(BinaryView* view, const MediumLevelILInstruction& instr)>& action,
+			const std::function<bool(BinaryView* view, const MediumLevelILInstruction& instr)>& isValid);
 
 		static std::vector<PluginCommand> GetList();
 		static std::vector<PluginCommand> GetValidList(const PluginCommandContext& ctxt);
@@ -3168,6 +3546,11 @@ namespace BinaryNinja
 		static void GetIncomingRegisterValueCallback(void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result);
 		static void GetIncomingFlagValueCallback(void* ctxt, uint32_t reg, BNFunction* func, BNRegisterValue* result);
 
+		static void GetIncomingVariableForParameterVariableCallback(void* ctxt, const BNVariable* var,
+			BNFunction* func, BNVariable* result);
+		static void GetParameterVariableForIncomingVariableCallback(void* ctxt, const BNVariable* var,
+			BNFunction* func, BNVariable* result);
+
 	public:
 		Ref<Architecture> GetArchitecture() const;
 		std::string GetName() const;
@@ -3188,6 +3571,9 @@ namespace BinaryNinja
 		virtual std::vector<uint32_t> GetImplicitlyDefinedRegisters();
 		virtual RegisterValue GetIncomingRegisterValue(uint32_t reg, Function* func);
 		virtual RegisterValue GetIncomingFlagValue(uint32_t flag, Function* func);
+
+		virtual Variable GetIncomingVariableForParameterVariable(const Variable& var, Function* func);
+		virtual Variable GetParameterVariableForIncomingVariable(const Variable& var, Function* func);
 	};
 
 	class CoreCallingConvention: public CallingConvention
@@ -3211,6 +3597,9 @@ namespace BinaryNinja
 		virtual std::vector<uint32_t> GetImplicitlyDefinedRegisters() override;
 		virtual RegisterValue GetIncomingRegisterValue(uint32_t reg, Function* func) override;
 		virtual RegisterValue GetIncomingFlagValue(uint32_t flag, Function* func) override;
+
+		virtual Variable GetIncomingVariableForParameterVariable(const Variable& var, Function* func) override;
+		virtual Variable GetParameterVariableForIncomingVariable(const Variable& var, Function* func) override;
 	};
 
 	/*!