converted to irdb-sdk's irdb-transform instead of libtransform

afl_transforms/tools/constant_decompose/constant_decompose.cpp

@@ -25,18 +25,15 @@
 
 #include "constant_decompose.hpp"
 
-#include <Rewrite_Utility.hpp>
-#include <utils.hpp>
+#include <irdb-util>
 
 using namespace std;
-using namespace libTransform;
 using namespace IRDB_SDK;
 using namespace ConstantDecompose;
-using namespace IRDBUtility;
 
 ConstantDecompose_t::ConstantDecompose_t(IRDB_SDK::pqxxDB_t &p_dbinterface, IRDB_SDK::FileIR_t *p_variantIR, bool p_verbose)
 	:
-	Transform(NULL, p_variantIR, NULL),
+	Transform(p_variantIR),
 	m_dbinterface(p_dbinterface),
 	m_verbose(p_verbose)
 {

afl_transforms/tools/constant_decompose/constant_decompose.hpp

@@ -2,13 +2,13 @@
 #define _LIBTRANSFORM_CONSTANT_DECOMPOSE_H
 
 #include <irdb-core>
-#include <transform.hpp>
+#include <irdb-transform>
 
 
 namespace ConstantDecompose
 {
 // the actual transform.
-class ConstantDecompose_t : public libTransform::Transform
+class ConstantDecompose_t : public IRDB_SDK::Transform
 {
 public:
 	// explicitly disable default and copy constructors

afl_transforms/tools/zax/critical_edge_breaker.cpp

@@ -22,14 +22,13 @@
  **************************************************************************/
 
 #include <irdb-cfg>
-#include <Rewrite_Utility.hpp>
+#include <irdb-transform>
 
 #include "critical_edge_breaker.hpp"
 
 using namespace std;
 using namespace IRDB_SDK;
 using namespace Zafl;
-using namespace IRDBUtility;
 
 CriticalEdgeBreaker_t::CriticalEdgeBreaker_t(IRDB_SDK::FileIR_t *p_IR, const bool p_verbose) :
 	m_IR(p_IR),
@@ -92,13 +91,14 @@ unsigned CriticalEdgeBreaker_t::breakCriticalEdges(Function_t* p_func)
 
 		if (source_block->endsInConditionalBranch())
 		{
-			const auto fileID = last_instruction_in_source_block->getAddress()->getFileID();
+			// const auto fileID = last_instruction_in_source_block->getAddress()->getFileID();
 			const auto func = last_instruction_in_source_block->getFunction();
 
 			if (last_instruction_in_source_block->getTarget() == first_instruction_in_target_block)
 			{
-				auto jmp = IRDBUtility::allocateNewInstruction(m_IR, fileID, func);
-				IRDBUtility::setInstructionAssembly(m_IR, jmp, "jmp 0", nullptr, first_instruction_in_target_block);
+				//auto jmp = IRDBUtility::allocateNewInstruction(m_IR, fileID, func);
+				auto jmp=m_IR->addNewInstruction(nullptr,func);	
+				setInstructionAssembly(m_IR, jmp, "jmp 0", nullptr, first_instruction_in_target_block);
 				jmp->setComment("break_critical_edge_jmp");
 
 				last_instruction_in_source_block->setTarget(jmp);
@@ -106,8 +106,9 @@ unsigned CriticalEdgeBreaker_t::breakCriticalEdges(Function_t* p_func)
 			}
 			else if (last_instruction_in_source_block->getFallthrough() == first_instruction_in_target_block)
 			{
-				auto jmp = IRDBUtility::allocateNewInstruction(m_IR, fileID, func);
-				IRDBUtility::setInstructionAssembly(m_IR, jmp, "jmp 0", nullptr, first_instruction_in_target_block);
+				// auto jmp = IRDBUtility::allocateNewInstruction(m_IR, fileID, func);
+				auto jmp=m_IR->addNewInstruction(nullptr,func);	
+				setInstructionAssembly(m_IR, jmp, "jmp 0", nullptr, first_instruction_in_target_block);
 				jmp->setComment("break_critical_edge_fallthrough");
 
 				last_instruction_in_source_block->setFallthrough(jmp);

afl_transforms/tools/zax/critical_edge_breaker.hpp

@@ -6,27 +6,28 @@
 namespace Zafl
 {
 	using namespace IRDB_SDK;
-//
-// Break critical edges
-//
-class CriticalEdgeBreaker_t
-{
-  public:
-	// explicitly disable default and copy constructors
-	CriticalEdgeBreaker_t(IRDB_SDK::FileIR_t *p_variantIR, const bool p_verbose=false);
-	unsigned getNumberExtraNodes() const;
-
-  protected:
-	void breakCriticalEdges();
-
-  private:
-	unsigned breakCriticalEdges(IRDB_SDK::Function_t*);
-
-  private:
-	FileIR_t*  m_IR;
-	const bool          m_verbose;
-	unsigned            m_extra_nodes;
-};
+
+	//
+	// Break critical edges
+	//
+	class CriticalEdgeBreaker_t
+	{
+	  public:
+		// explicitly disable default and copy constructors
+		CriticalEdgeBreaker_t(IRDB_SDK::FileIR_t *p_variantIR, const bool p_verbose=false);
+		unsigned getNumberExtraNodes() const;
+
+	  protected:
+		void breakCriticalEdges();
+
+	  private:
+		unsigned breakCriticalEdges(IRDB_SDK::Function_t*);
+
+	  private:
+		FileIR_t*  m_IR;
+		const bool          m_verbose;
+		unsigned            m_extra_nodes;
+	};
 
 
 } 

afl_transforms/tools/zax/zax.cpp

@@ -27,26 +27,23 @@
 #include <cctype>
 #include <sstream>
 #include <irdb-cfg>
+#include <irdb-transform>
 #include <libElfDep.hpp>
-#include <Rewrite_Utility.hpp>
 #include <MEDS_DeadRegAnnotation.hpp>
 #include <MEDS_SafeFuncAnnotation.hpp>
-#include <utils.hpp> 
 
 #include "zax.hpp"
 
 using namespace std;
-using namespace libTransform;
 using namespace IRDB_SDK;
 using namespace Zafl;
-using namespace IRDBUtility;
 using namespace MEDS_Annotation;
 
 #define ALLOF(a) begin(a),end(a)
 
 Zax_t::Zax_t(IRDB_SDK::pqxxDB_t &p_dbinterface, IRDB_SDK::FileIR_t *p_variantIR, string p_forkServerEntryPoint, set<string> p_exitPoints, bool p_use_stars, bool p_autozafl, bool p_verbose)
 	:
-	Transform(NULL, p_variantIR, NULL),
+	Transform(p_variantIR),
 	m_dbinterface(p_dbinterface),
 	m_stars_analysis_engine(p_dbinterface),
 	m_fork_server_entry(p_forkServerEntryPoint),

afl_transforms/tools/zax/zax.hpp

@@ -3,9 +3,10 @@
 
 #include <irdb-core>
 #include <irdb-cfg>
+#include <irdb-transform>
 #include <stars.h>
+#include <MEDS_Register.hpp>
 
-#include "transform.hpp"
 
 // utility functions
 // @todo: move these functions into other libs for reuse
@@ -15,92 +16,92 @@ extern MEDS_Annotation::RegisterSet_t get_free_regs(const MEDS_Annotation::Regis
 
 namespace Zafl
 {
-using namespace IRDB_SDK;
-using namespace std;
-typedef unsigned zafl_blockid_t;
-typedef unsigned zafl_labelid_t;
-typedef vector<Instruction_t*> BBRecord_t;
-
-
-//
-// Transform to add afl-compatible instrumentation, including a fork server
-//
-class Zax_t : public libTransform::Transform
-{
-public:
-	// explicitly disable default and copy constructors
-	Zax_t() = delete;
-	Zax_t(const Zafl::Zax_t&) = delete;
-	Zax_t(pqxxDB_t &p_dbinterface, FileIR_t *p_variantIR, string p_entry, set<string> p_exits, bool p_use_stars=false, bool p_autozafl=false, bool p_verbose=false);
-	virtual ~Zax_t() {};
-	virtual int execute();
-	void setWhitelist(const string& p_filename); 
-	void setBlacklist(const string& p_filename); 
-	void setBasicBlockOptimization(bool p_bb_graph_optimize) {m_bb_graph_optimize=p_bb_graph_optimize;}
-	void setEnableForkServer(bool p_forkserver_enabled) {m_forkserver_enabled=p_forkserver_enabled;}
-	void setBreakupCriticalEdges(const bool p_breakupCriticalEdges);
-
-protected:
-	virtual zafl_blockid_t get_blockid(const unsigned p_maxid=0xFFFF);
-	virtual zafl_labelid_t get_labelid(const unsigned p_maxid=0xFFFF);
-	virtual set<BasicBlock_t*> getBlocksToInstrument(ControlFlowGraph_t &cfg);
-	virtual void afl_instrument_bb(Instruction_t *inst, const bool p_hasLeafAnnotation, const bool p_collafl_optimization=false);
-	void insertExitPoint(Instruction_t *inst);
-	void insertForkServer(Instruction_t* p_entry);
-	void insertForkServer(string p_forkServerEntry);
-	void setupForkServer();
-	void insertExitPoints();
-	bool isBlacklisted(const Function_t*) const;
-	bool isWhitelisted(const Function_t*) const;
-	bool isBlacklisted(const Instruction_t*) const;
-	bool isWhitelisted(const Instruction_t*) const;
-	bool BB_isPushJmp(const BasicBlock_t *p_bb);
-	bool BB_isPaddingNop(const BasicBlock_t *p_bb);
-	virtual void setup();
-	virtual void teardown();
-	virtual void dumpMap();
-	virtual void dumpAttributes();
-
-protected:
-	pqxxDB_t&           m_dbinterface;
-	STARS::IRDB_Interface_t      m_stars_analysis_engine;
-
-	string                       m_fork_server_entry;  // string to specify fork server entry point
-	set<string>                  m_exitpoints;         // set of strings to specify exit points
-	bool                         m_use_stars;          // use STARS to have access to dead register info
-	bool                         m_autozafl;           // link in library w/ auto fork server
-	bool                         m_bb_graph_optimize;  // skip basic blocks based on graph
-	bool                         m_forkserver_enabled; // fork server enabled?
-	bool                         m_breakupCriticalEdges;
-	bool                         m_verbose;
-
-        pair<DataScoop_t*,int>  m_trace_map;  // afl shared memory trace map
-        pair<DataScoop_t*,int>  m_prev_id;    // id of previous block
-	Instruction_t*               m_plt_zafl_initAflForkServer; // plt entry for afl fork server initialization routine
-
-	set<string>        m_whitelist;   // whitelisted functions and/or instructions
-	set<string>        m_blacklist;   // blacklisted functions and/or instructions
-
-	zafl_labelid_t               m_labelid;     // internal bookkeeping to generate labels
-
-	map<zafl_blockid_t, BBRecord_t> m_modifiedBlocks;  // keep track of modified blocks
-
-	// stats
-	unsigned m_num_bb;
-	unsigned m_num_bb_instrumented;
-	unsigned m_num_bb_skipped;
-	unsigned m_num_bb_skipped_pushjmp;
-	unsigned m_num_bb_skipped_nop_padding;
-	unsigned m_num_bb_skipped_innernode;
-	unsigned m_num_bb_skipped_cbranch;
-	unsigned m_num_bb_skipped_onlychild;
-	unsigned m_num_bb_keep_exit_block;
-	unsigned m_num_bb_keep_cbranch_back_edge;
-	unsigned m_num_style_collafl;
-
-private:
-	set<zafl_blockid_t>     m_used_blockid;      // internal bookkeeping to keep track of used block ids
-};
+	using namespace IRDB_SDK;
+	using namespace std;
+	typedef unsigned zafl_blockid_t;
+	typedef unsigned zafl_labelid_t;
+	typedef vector<Instruction_t*> BBRecord_t;
+
+
+	//
+	// Transform to add afl-compatible instrumentation, including a fork server
+	//
+	class Zax_t : public Transform
+	{
+	public:
+		// explicitly disable default and copy constructors
+		Zax_t() = delete;
+		Zax_t(const Zafl::Zax_t&) = delete;
+		Zax_t(pqxxDB_t &p_dbinterface, FileIR_t *p_variantIR, string p_entry, set<string> p_exits, bool p_use_stars=false, bool p_autozafl=false, bool p_verbose=false);
+		virtual ~Zax_t() {};
+		virtual int execute();
+		void setWhitelist(const string& p_filename); 
+		void setBlacklist(const string& p_filename); 
+		void setBasicBlockOptimization(bool p_bb_graph_optimize) {m_bb_graph_optimize=p_bb_graph_optimize;}
+		void setEnableForkServer(bool p_forkserver_enabled) {m_forkserver_enabled=p_forkserver_enabled;}
+		void setBreakupCriticalEdges(const bool p_breakupCriticalEdges);
+
+	protected:
+		virtual zafl_blockid_t get_blockid(const unsigned p_maxid=0xFFFF);
+		virtual zafl_labelid_t get_labelid(const unsigned p_maxid=0xFFFF);
+		virtual set<BasicBlock_t*> getBlocksToInstrument(ControlFlowGraph_t &cfg);
+		virtual void afl_instrument_bb(Instruction_t *inst, const bool p_hasLeafAnnotation, const bool p_collafl_optimization=false);
+		void insertExitPoint(Instruction_t *inst);
+		void insertForkServer(Instruction_t* p_entry);
+		void insertForkServer(string p_forkServerEntry);
+		void setupForkServer();
+		void insertExitPoints();
+		bool isBlacklisted(const Function_t*) const;
+		bool isWhitelisted(const Function_t*) const;
+		bool isBlacklisted(const Instruction_t*) const;
+		bool isWhitelisted(const Instruction_t*) const;
+		bool BB_isPushJmp(const BasicBlock_t *p_bb);
+		bool BB_isPaddingNop(const BasicBlock_t *p_bb);
+		virtual void setup();
+		virtual void teardown();
+		virtual void dumpMap();
+		virtual void dumpAttributes();
+
+	protected:
+		pqxxDB_t&           m_dbinterface;
+		STARS::IRDB_Interface_t      m_stars_analysis_engine;
+
+		string                       m_fork_server_entry;  // string to specify fork server entry point
+		set<string>                  m_exitpoints;         // set of strings to specify exit points
+		bool                         m_use_stars;          // use STARS to have access to dead register info
+		bool                         m_autozafl;           // link in library w/ auto fork server
+		bool                         m_bb_graph_optimize;  // skip basic blocks based on graph
+		bool                         m_forkserver_enabled; // fork server enabled?
+		bool                         m_breakupCriticalEdges;
+		bool                         m_verbose;
+
+		pair<DataScoop_t*,int>  m_trace_map;  // afl shared memory trace map
+		pair<DataScoop_t*,int>  m_prev_id;    // id of previous block
+		Instruction_t*               m_plt_zafl_initAflForkServer; // plt entry for afl fork server initialization routine
+
+		set<string>        m_whitelist;   // whitelisted functions and/or instructions
+		set<string>        m_blacklist;   // blacklisted functions and/or instructions
+
+		zafl_labelid_t               m_labelid;     // internal bookkeeping to generate labels
+
+		map<zafl_blockid_t, BBRecord_t> m_modifiedBlocks;  // keep track of modified blocks
+
+		// stats
+		unsigned m_num_bb;
+		unsigned m_num_bb_instrumented;
+		unsigned m_num_bb_skipped;
+		unsigned m_num_bb_skipped_pushjmp;
+		unsigned m_num_bb_skipped_nop_padding;
+		unsigned m_num_bb_skipped_innernode;
+		unsigned m_num_bb_skipped_cbranch;
+		unsigned m_num_bb_skipped_onlychild;
+		unsigned m_num_bb_keep_exit_block;
+		unsigned m_num_bb_keep_cbranch_back_edge;
+		unsigned m_num_style_collafl;
+
+	private:
+		set<zafl_blockid_t>     m_used_blockid;      // internal bookkeeping to keep track of used block ids
+	};
 
 } 
 

afl_transforms/tools/zax/zuntracer.hpp

@@ -8,28 +8,28 @@ namespace Zafl
 
 	using namespace IRDB_SDK;
 
-// Block-level instrumentation for Untracer
-class ZUntracer_t : public Zax_t
-{
-	public:
-		ZUntracer_t() = delete;
-		ZUntracer_t(const ZUntracer_t&) = delete;
-		ZUntracer_t(IRDB_SDK::pqxxDB_t &p_dbinterface, IRDB_SDK::FileIR_t *p_variantIR, string p_entry, set<string> p_exits, bool p_use_stars=false, bool p_autozafl=false, bool p_verbose=false);
-		virtual ~ZUntracer_t() {};
-		virtual int execute();
-
-	protected:
-		virtual zafl_blockid_t get_blockid(const unsigned p_maxid = 0xFFFF);
-		virtual void afl_instrument_bb(Instruction_t *p_inst, const bool p_hasLeafAnnotation, const bool p_collafl_optimization=false);
-		virtual set<BasicBlock_t*> getBlocksToInstrument(ControlFlowGraph_t &cfg);
-
-	private:
-		void _afl_instrument_bb_fixed(Instruction_t *p_inst, char* p_tracemap_addr);
-		void _afl_instrument_bb(Instruction_t *p_inst, const bool p_redZoneHint);
-
-	private:
-		zafl_blockid_t   m_blockid;
-};
+	// Block-level instrumentation for Untracer
+	class ZUntracer_t : public Zax_t
+	{
+		public:
+			ZUntracer_t() = delete;
+			ZUntracer_t(const ZUntracer_t&) = delete;
+			ZUntracer_t(IRDB_SDK::pqxxDB_t &p_dbinterface, IRDB_SDK::FileIR_t *p_variantIR, string p_entry, set<string> p_exits, bool p_use_stars=false, bool p_autozafl=false, bool p_verbose=false);
+			virtual ~ZUntracer_t() {};
+			virtual int execute();
+
+		protected:
+			virtual zafl_blockid_t get_blockid(const unsigned p_maxid = 0xFFFF);
+			virtual void afl_instrument_bb(Instruction_t *p_inst, const bool p_hasLeafAnnotation, const bool p_collafl_optimization=false);
+			virtual set<BasicBlock_t*> getBlocksToInstrument(ControlFlowGraph_t &cfg);
+
+		private:
+			void _afl_instrument_bb_fixed(Instruction_t *p_inst, char* p_tracemap_addr);
+			void _afl_instrument_bb(Instruction_t *p_inst, const bool p_redZoneHint);
+
+		private:
+			zafl_blockid_t   m_blockid;
+	};
 
 }