x64 support

include/retdec/bin2llvmir/optimizations/param_return/collector/collector.h

@@ -0,0 +1,101 @@
+/**
+* @file include/retdec/bin2llvmir/optimizations/param_return/collector/collector.h
+* @brief Collects possible arguments and returns of functions.
+* @copyright (c) 2019 Avast Software, licensed under the MIT license
+*/
+
+#ifndef RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_COLLECTOR_COLLECTOR_H
+#define RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_COLLECTOR_COLLECTOR_H
+
+#include <map>
+#include <vector>
+
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/Module.h>
+
+#include "retdec/bin2llvmir/analyses/reaching_definitions.h"
+#include "retdec/bin2llvmir/optimizations/param_return/data_entries.h"
+#include "retdec/bin2llvmir/providers/abi/abi.h"
+
+namespace retdec {
+namespace bin2llvmir {
+
+class Collector
+{
+	public:
+		typedef std::unique_ptr<Collector> Ptr;
+
+	public:
+		Collector(
+			const Abi* abi,
+			llvm::Module* m,
+			const ReachingDefinitionsAnalysis* rda);
+
+		virtual ~Collector();
+
+	public:
+		virtual void collectCallArgs(CallEntry* ce) const;
+		virtual void collectCallRets(CallEntry* ce) const;
+
+		virtual void collectDefArgs(DataFlowEntry* de) const;
+		virtual void collectDefRets(DataFlowEntry* de) const;
+
+		virtual void collectCallSpecificTypes(CallEntry* ce) const;
+
+	protected:
+
+		void collectRetStores(ReturnEntry* re) const;
+
+		void collectStoresBeforeInstruction(
+			llvm::Instruction* i,
+			std::vector<llvm::StoreInst*>& stores) const;
+
+		void collectLoadsAfterInstruction(
+			llvm::Instruction* i,
+			std::vector<llvm::LoadInst*>& loads) const;
+
+		bool collectLoadsAfterInstruction(
+			llvm::Instruction* i,
+			std::vector<llvm::LoadInst*>& loads,
+			std::set<llvm::Value*>& excluded) const;
+
+		void  collectStoresInSinglePredecessors(
+			llvm::Instruction* i,
+			std::vector<llvm::StoreInst*>& stores) const;
+
+		void collectStoresRecursively(
+			llvm::Instruction* i,
+			std::vector<llvm::StoreInst*>& stores,
+			std::map<llvm::BasicBlock*,
+				std::set<llvm::Value*>>& seen) const;
+
+		bool collectStoresInInstructionBlock(
+			llvm::Instruction* i,
+			std::set<llvm::Value*>& values,
+			std::vector<llvm::StoreInst*>& stores) const;
+
+	protected:
+		bool extractFormatString(CallEntry* ce) const;
+
+		bool storesString(llvm::StoreInst* si, std::string& str) const;
+		llvm::Value* getRoot(llvm::Value* i, bool first = true) const;
+
+	protected:
+		const Abi* _abi;
+		llvm::Module* _module;
+		const ReachingDefinitionsAnalysis* _rda;
+};
+
+class CollectorProvider
+{
+	public:
+		static Collector::Ptr createCollector(
+				const Abi* abi,
+				llvm::Module* m,
+				const ReachingDefinitionsAnalysis* rda);
+};
+
+} // namespace bin2llvmir
+} // namespace retdec
+
+#endif

include/retdec/bin2llvmir/optimizations/param_return/collector/pic32.h

@@ -0,0 +1,32 @@
+/**
+* @file include/retdec/bin2llvmir/optimizations/param_return/collector/pic32.h
+* @brief Pic32 specific collection algorithms.
+* @copyright (c) 2019 Avast Software, licensed under the MIT license
+*/
+
+#ifndef RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_COLLECTOR_PIC32_H
+#define RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_COLLECTOR_PIC32_H
+
+#include "retdec/bin2llvmir/optimizations/param_return/collector/collector.h"
+
+namespace retdec {
+namespace bin2llvmir {
+
+class CollectorPic32 : public Collector
+{
+	public:
+		CollectorPic32(
+			const Abi* abi,
+			llvm::Module* m,
+			const ReachingDefinitionsAnalysis* rda);
+
+		virtual ~CollectorPic32() override;
+
+	public:
+		virtual void collectCallSpecificTypes(CallEntry* ce) const override;
+};
+
+} // namespace bin2llvmir
+} // namespace retdec
+
+#endif

include/retdec/bin2llvmir/optimizations/param_return/data_entries.h

@@ -0,0 +1,185 @@
+/**
+* @file include/retdec/bin2llvmir/optimizations/param_return/data_entries.h
+* @brief Data entries for parameter analysis.
+* @copyright (c) 2019 Avast Software, licensed under the MIT license
+*/
+
+#ifndef RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_DATA_ENTRIES_H
+#define RETDEC_BIN2LLVMIR_OPTIMIZATIONS_PARAM_RETURN_DATA_ENTRIES_H
+
+#include <vector>
+
+#include "retdec/bin2llvmir/providers/calling_convention/calling_convention.h"
+
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+
+namespace retdec {
+namespace bin2llvmir {
+
+class ReturnEntry
+{
+	public:
+		ReturnEntry(llvm::ReturnInst* r);
+
+	public:
+		void addRetStore(llvm::StoreInst* st);
+
+		void setRetStores(std::vector<llvm::StoreInst*>&& stores);
+		void setRetStores(const std::vector<llvm::StoreInst*>& stores);
+		void setRetValues(std::vector<llvm::Value*>&& values);
+
+		void setRetValues(const std::vector<llvm::Value*>& values);
+
+	public:
+		llvm::ReturnInst* getRetInstruction() const;
+
+		const std::vector<llvm::StoreInst*>& retStores() const;
+		const std::vector<llvm::Value*>& retValues() const;
+
+
+	protected:
+		llvm::ReturnInst* _retInst = nullptr;
+
+		std::vector<llvm::StoreInst*> _retStores;
+		std::vector<llvm::Value*> _retValues;
+};
+
+class CallableEntry
+{
+	public:
+		bool isVoidarg() const;
+
+		void addArg(llvm::Value* arg);
+
+		void setVoidarg(bool voidarg = true);
+		void setArgTypes(
+			std::vector<llvm::Type*>&& types,
+			std::vector<std::string>&& names = {});
+
+	public:
+		const std::vector<llvm::Value*>& args() const;
+		const std::vector<llvm::Type*>& argTypes() const;
+		const std::vector<std::string>& argNames() const;
+
+	protected:
+		std::vector<llvm::Value*> _args;
+		std::vector<llvm::Type*> _argTypes;
+		std::vector<std::string> _argNames;
+
+	protected:
+		bool _voidarg = false;
+};
+
+class FunctionEntry : public CallableEntry
+{
+	public:
+		bool isVariadic() const;
+		bool isWrapper() const;
+
+	public:
+		void addRetEntry(const ReturnEntry& ret);
+		ReturnEntry* createRetEntry(llvm::ReturnInst* ret);
+
+		void setArgs(std::vector<llvm::Value*>&& args);
+		void setVariadic(bool variadic = true);
+		void setWrappedCall(llvm::CallInst* wrap);
+		void setRetType(llvm::Type* type);
+		void setRetValue(llvm::Value* val);
+		void setCallingConvention(const CallingConvention::ID& cc);
+
+	public:
+		llvm::Value* getRetValue() const;
+		llvm::Type* getRetType() const;
+		llvm::CallInst* getWrappedCall() const;
+		CallingConvention::ID getCallingConvention() const;
+
+		const std::vector<ReturnEntry>& retEntries() const;
+		std::vector<ReturnEntry>& retEntries();
+
+	private:
+		llvm::CallInst* _wrap = nullptr;
+		llvm::Type* _retType = nullptr;
+		llvm::Value* _retVal = nullptr;
+		bool _variadic = false;
+		CallingConvention::ID _callconv = CallingConvention::ID::CC_UNKNOWN;
+
+		std::vector<ReturnEntry> _retEntries;
+};
+
+class CallEntry : public CallableEntry
+{
+	// Constructor.
+	//
+	public:
+		CallEntry(
+			llvm::CallInst* call,
+			const FunctionEntry* base = nullptr);
+
+	// Usage data.
+	//
+	public:
+		void addRetLoad(llvm::LoadInst* load);
+
+		void setFormatString(const std::string& fmt);
+		void setArgStores(std::vector<llvm::StoreInst*>&& stores);
+		void setArgs(std::vector<llvm::Value*>&& args);
+		void setRetLoads(std::vector<llvm::LoadInst*>&& loads);
+		void setRetValues(std::vector<llvm::Value*>&& values);
+
+		llvm::CallInst* getCallInstruction() const;
+		const FunctionEntry* getBaseFunction() const;
+		std::string getFormatString() const;
+
+	public:
+		const std::vector<llvm::StoreInst*>& argStores() const;
+		const std::vector<llvm::Value*>& retValues() const;
+		const std::vector<llvm::LoadInst*>& retLoads() const;
+
+	private:
+		const FunctionEntry* _baseFunction;
+
+		llvm::CallInst* _callInst = nullptr;
+		std::string _fmtStr = "";
+
+		std::vector<llvm::LoadInst*> _retLoads;
+		std::vector<llvm::Value*> _retValues;
+		std::vector<llvm::StoreInst*> _argStores;
+};
+
+class DataFlowEntry : public FunctionEntry
+{
+	// Constructor
+	//
+	public:
+		DataFlowEntry(llvm::Value* called);
+
+	// Type information
+	//
+	public:
+		bool isFunction() const;
+		bool isValue() const;
+		bool hasDefinition() const;
+
+		llvm::Function* getFunction() const;
+		llvm::Value* getValue() const;
+
+		void setCalledValue(llvm::Value* called);
+
+	// Usage data.
+	//
+	public:
+		CallEntry* createCallEntry(llvm::CallInst *call);
+		const std::vector<CallEntry>& callEntries() const;
+		std::vector<CallEntry>& callEntries();
+
+	private:
+		llvm::Value* _calledValue = nullptr;
+
+		std::vector<CallEntry> _calls;
+};
+
+} // namespace bin2llvmir
+} // namespace retdec
+
+#endif