first draft can run the IR builder

README.md

-TBD
\ No newline at end of file
+
+This is the IRDB SDK.  Include only files in include/, other files shall be included indirectly.
+
+
+All of the interface is in the IRDB_SDK namespace.    
+
+Include file "irdb-<foo> needs to be linked against libIRDB-foo.

include/inc-core/address.hpp

+namespace IRDB_SDK
+{
+	class AddressID_t : virtual public BaseObj_t
+	{
+		protected:
+			AddressID_t() {}
+			AddressID_t(const AddressID_t& copy)=delete;
+
+		public:
+			virtual ~AddressID_t() {}
+
+			virtual DatabaseID_t    getFileID()        const = 0;
+			virtual VirtualOffset_t getVirtualOffset() const = 0;
+
+			virtual void setFileID(DatabaseID_t thefileID)      = 0;
+			virtual void setVirtualOffset(VirtualOffset_t voff) = 0;
+	};
+
+}

include/inc-core/archdesc.hpp

+namespace IRDB_SDK
+{
+
+	class ArchitectureDescription_t
+	{
+		protected:
+			ArchitectureDescription_t() {}
+			ArchitectureDescription_t(const ArchitectureDescription_t& copy) = delete;
+		public:
+			~ArchitectureDescription_t() {}
+
+			virtual int             getBitWidth()    const = 0;
+			virtual ADFileType_t    getFileType()    const = 0;
+			virtual ADMachineType_t getMachineType() const = 0;
+
+			virtual void setFileType(const ADFileType_t t)       = 0;
+			virtual void setBitWidth(const int _bits)            = 0;
+			virtual void setMachineType(const ADMachineType_t t) = 0;
+
+	};
+
+}

include/inc-core/baseobj.hpp

+namespace IRDB_SDK
+{
+	class BaseObj_t
+	{
+		protected:
+			BaseObj_t() {}
+			BaseObj_t(const BaseObj_t& copy) = delete;
+
+		public:
+			virtual ~BaseObj_t() {}
+
+			virtual DatabaseID_t           getBaseID()      const = 0;
+			virtual DatabaseID_t           getDoipID()      const = 0;
+			virtual const RelocationSet_t& getRelocations() const = 0;
+
+			virtual void setRelocations(const RelocationSet_t& rels) = 0;
+			virtual void setDoipID(Doip_t *p_dp)      = 0;
+			virtual void setBaseID(DatabaseID_t p_id) = 0;
+
+			const static int NOT_IN_DATABASE;
+		        static void setInterface(DBinterface_t *dbintr);
+
+	};
+
+}

include/inc-core/basetypes.hpp

+namespace IRDB_SDK
+{
+	using namespace std;
+
+	// enums
+	enum ADFileType           { 
+	                                  adftELF, 
+	                                  adftCGC, 
+	                                  adftPE, 
+	                                  adftNone 
+	                          };
+
+	enum ADMachineType        { 
+	                                   admtAarch64,  
+	                                   admtX86_64, 
+	                                   admtI386, 
+	                                   admtNone 
+	                          };
+
+	enum DatabaseErrorType    {
+	                                   detVariantNotInDatabase, 
+	                                   detVariantTableNotRegistered
+	                          };
+
+	enum ICFSAnalysisStatus   { 
+	                                   iasAnalysisIncomplete, 
+	                                   iasAnalysisModuleComplete, 
+	                                   iasAnalysisComplete 
+	                          };
+
+	enum IRDBType             {
+	                                   itUnknown,
+	                                   itNumeric,
+	                                   itPointer,
+	                                   itVoid,
+	                                   itVariadic,
+	                                   itInt,
+	                                   itChar,
+	                                   itFloat,
+	                                   itDouble,
+	                                   itTypedef,
+	                                   itSubtype,
+	                                   itFunc,
+	                                   itAggregate
+	                          };
+
+	// enum renames
+	using ADFileType_t         = enum ADFileType;
+	using ADMachineType_t      = enum ADMachineType;
+	using DatabaseErrorType_t  = enum DatabaseErrorType;
+	using ICFSAnalysisStatus_t = enum ICFSAnalysisStatus; 
+	using IRDBType_t           = enum IRDBType;
+
+
+
+	// forward decls;
+	class AddressID_t;
+	class ArchitectureDescription_t;
+	class BaseObj_t;
+	class DatabaseError_t;
+	class DBinterface_t;
+	class DecodedInstruction_t;
+	class DecodedOperand_t;
+	class Doip_t;
+	class EhProgram_t;
+	class EhCallSite_t;
+	class File_t;
+	class FileIR_t;
+	class Function_t;
+	class ICFS_t;
+	class Instruction_t;
+	class IRDBObjects_t;
+	class pqxxDB_t;
+	class Relocation_t;
+	class DataScoop_t;
+	class Type_t;
+	class BasicType_t;
+	class PointerType_t;
+	class AggregateType_t;
+	class FuncType_t;
+	class VariantID_t;
+
+	// typedefs
+	using VirtualOffset_t         = uintptr_t;
+	using DatabaseID_t            = int32_t;
+	using SchemaVersionID_t       = int32_t;
+	using EhProgramInstruction_t  = string;
+	using EhProgramListing_t      = vector<EhProgramInstruction_t>;
+	using EhProgramSet_t          = set<EhProgram_t*>;
+	using TTOrderVector_t         = vector<int>;
+	using EhCallSiteSet_t         = set<EhCallSite_t*>;
+	using FunctionSet_t           = set<Function_t*>;
+	using AddressSet_t            = set<AddressID_t*>;
+	using ICFSSet_t               = set<ICFS_t*>;
+	using RelocationSet_t         = set<Relocation_t*>; 
+	using InstructionSet_t        = set<Instruction_t*>; 
+	using DataScoopSet_t          = set<DataScoop_t*>;
+	using TypeSet_t               = set<Type_t*>;
+	using TypeVector_t            = vector<Type_t*>;
+	using FileSet_t               = set<File_t*>;
+	using DecodedOperandVector_t  = vector<shared_ptr < DecodedOperand_t > >;
+
+
+
+}

include/inc-core/dbinterface.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class DatabaseError_t : virtual public exception 
+	{
+		protected:
+		public: 
+			enum DatabaseErrorType_t {VariantNotInDatabase, VariantTableNotRegistered};
+	};
+
+	ostream& operator<<(ostream& output, const DatabaseError_t& p);
+
+
+	// an interface to a database
+	class DBinterface_t
+	{
+		protected:
+			DBinterface_t() {}
+			DBinterface_t(const DBinterface_t& copy) = delete;
+		public:
+			virtual ~DBinterface_t() {};
+
+			virtual void   issueQuery(string query)        = 0;
+			virtual void   moveToNextRow()                 = 0;
+			virtual string getResultColumn(string colname) = 0;
+			virtual bool   isDone()                        = 0;
+			virtual void   commit()                        = 0;
+
+	};
+
+}

include/inc-core/decode.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class DecodedInstruction_t
+	{
+		protected:
+			DecodedInstruction_t() {};
+			DecodedInstruction_t(const DecodedInstruction_t& copy) = delete;
+		public:
+
+			virtual ~DecodedInstruction_t() {}
+
+			virtual string   getDisassembly()               const = 0;
+			virtual bool     valid()                        const = 0;
+			virtual uint32_t length()                       const = 0;
+			virtual bool     isBranch()                     const = 0;
+			virtual bool     isCall()                       const = 0;
+			virtual bool     isUnconditionalBranch()        const = 0;
+			virtual bool     isConditionalBranch()          const = 0;
+			virtual bool     isReturn()                     const = 0;
+			virtual string   getMnemonic()                  const = 0;
+			virtual int64_t  getImmediate()                 const = 0;
+			virtual VirtualOffset_t        
+			                 getAddress()                   const = 0;
+			virtual bool     setsStackPointer()             const = 0;
+			virtual uint32_t getPrefixCount()               const = 0;
+			virtual bool     hasRelevantRepPrefix()         const = 0;
+			virtual bool     hasRelevantRepnePrefix()       const = 0;
+			virtual bool     hasRelevantOperandSizePrefix() const = 0;
+			virtual bool     hasRexWPrefix()                const = 0;
+			virtual bool     hasImplicitlyModifiedRegs()    const = 0;
+			virtual bool     hasOperand(const int op_num)   const = 0;
+			virtual shared_ptr<DecodedOperand_t>       
+			                 getOperand(const int op_num)   const = 0;
+			virtual DecodedOperandVector_t 
+			                 getOperands()                  const = 0;
+			virtual VirtualOffset_t        
+			                 getMemoryDisplacementOffset(
+			                                             const DecodedOperand_t* t, 
+			                                             const Instruction_t* insn
+			                                            )  const = 0;
+
+			// factories
+			static unique_ptr<DecodedInstruction_t> factory(const Instruction_t* p_in);
+			static unique_ptr<DecodedInstruction_t> factory(const VirtualOffset_t start_addr, const void *data, uint32_t max_len);
+			static unique_ptr<DecodedInstruction_t> factory(const VirtualOffset_t start_addr, const void *data, const void* endptr);
+
+
+	};
+
+	class DecodedOperand_t
+	{
+		protected:
+			DecodedOperand_t() {}
+			DecodedOperand_t(const DecodedOperand_t& copy) = delete;
+		public:
+			virtual ~DecodedOperand_t() {}
+
+			virtual bool            isConstant()                        const = 0;
+			virtual uint64_t        getConstant()                       const = 0;
+			virtual string          getString()                         const = 0;
+			virtual bool            isRegister()                        const = 0;
+			virtual bool            isGeneralPurposeRegister()          const = 0;
+			virtual bool            isMmxRegister()                     const = 0;
+			virtual bool            isFpuRegister()                     const = 0;
+			virtual bool            isSseRegister()                     const = 0;
+			virtual bool            isAvxRegister()                     const = 0;
+			virtual bool            isZmmRegister()                     const = 0;
+			virtual bool            isSpecialRegister()                 const = 0;
+			virtual bool            isSegmentRegister()                 const = 0;
+			virtual uint32_t        getRegNumber()                      const = 0;
+			virtual bool            isMemory()                          const = 0;
+			virtual bool            hasSegmentRegister()                const = 0;
+			virtual uint32_t        getSegmentRegister()                const = 0;
+			virtual bool            hasBaseRegister()                   const = 0;
+			virtual bool            hasIndexRegister()                  const = 0;
+			virtual uint32_t        getBaseRegister()                   const = 0;
+			virtual uint32_t        getIndexRegister()                  const = 0;
+			virtual bool            hasMemoryDisplacement()             const = 0;
+			virtual VirtualOffset_t getMemoryDisplacement()             const = 0;
+			virtual bool            isPcrel()                           const = 0;
+			virtual uint32_t        getScaleValue()                     const = 0;
+			virtual uint32_t        getMemoryDisplacementEncodingSize() const = 0;
+			virtual uint32_t        getArgumentSizeInBytes()            const = 0;
+			virtual uint32_t        getArgumentSizeInBits()             const = 0;
+			virtual bool            isRead()                            const = 0;
+			virtual bool            isWritten()                         const = 0;
+
+	};
+}

include/inc-core/doip.hpp

+namespace IRDB_SDK
+{
+	class Doip_t 
+	{
+		protected:
+			Doip_t() {}
+			Doip_t(const Doip_t& copy) = delete;
+		public: 
+			virtual DatabaseID_t GetBaseID() const = 0;
+
+	};
+}

include/inc-core/eh.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class EhProgram_t : virtual public BaseObj_t
+	{
+		protected:
+			EhProgram_t() { }
+			EhProgram_t(const EhProgram_t& copy) = delete;
+		public:
+
+			virtual ~EhProgram_t() { }
+			virtual const EhProgramListing_t& getCIEProgram()          const = 0;
+			virtual const EhProgramListing_t& getFDEProgram()          const = 0;
+			virtual uint64_t                  getCodeAlignmentFactor() const = 0;
+			virtual int64_t                   getDataAlignmentFactor() const = 0;
+			virtual int64_t                   getReturnRegNumber()     const = 0;
+			virtual uint8_t                   getPointerSize()         const = 0;
+
+			virtual void setCodeAlignmentFactor(const uint64_t caf) = 0;
+			virtual void setDataAlignmentFactor(const int64_t daf)  = 0;
+			virtual void setReturnRegNumber    (const uint8_t rr  ) = 0;
+
+			// helpers
+			virtual void print() const = 0;
+	};
+
+	class EhCallSite_t : virtual public BaseObj_t
+	{
+		protected:
+			EhCallSite_t() { } ;
+			EhCallSite_t(const EhCallSite_t& copy)=delete;
+		public:
+
+			virtual ~EhCallSite_t() { } ;
+			virtual uint64_t               getTTEncoding()    const = 0;
+			virtual const TTOrderVector_t& getTTOrderVector() const = 0;
+			virtual Instruction_t*         getLandingPad()    const = 0;
+			virtual bool                   getHasCleanup()    const = 0;
+
+			virtual void setTTEncoding(const uint64_t p_tt)     = 0;
+			virtual void setLandingPad(Instruction_t* lp)       = 0;
+			virtual void setHasCleanup(bool p_has_cleanup=true) = 0;
+			virtual void setTTOrderVector(const TTOrderVector_t& ) = 0;
+
+	};
+
+}

include/inc-core/file.hpp

+
+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class File_t : virtual public BaseObj_t
+	{
+		protected:
+			File_t() { };
+			File_t(const File_t& copy) = delete;
+		public:
+			virtual ~File_t() { };
+
+			virtual string       getAddressTableName()     const = 0;
+			virtual string       getFunctionTableName()    const = 0;
+			virtual string       getInstructionTableName() const = 0;
+			virtual string       getICFSTableName()        const = 0;
+			virtual string       getICFSMapTableName()     const = 0;
+			virtual string       getRelocationsTableName() const = 0;
+			virtual string       getTypesTableName()       const = 0;
+			virtual string       getScoopTableName()       const = 0;
+			virtual string       getEhProgramTableName()   const = 0;
+			virtual string       getEhCallSiteTableName()  const = 0;
+			virtual string       getURL()                  const = 0;
+			virtual int          getELFOID()               const = 0;
+			virtual DatabaseID_t getFileID()               const = 0;
+
+	};
+
+}

include/inc-core/fileir.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class FileIR_t : virtual public BaseObj_t
+	{
+		protected:
+			FileIR_t(){}
+			FileIR_t(const FileIR_t& p_copy) = delete;
+		public:
+			virtual ~FileIR_t() {}
+		  
+			// accessors 
+			virtual const FunctionSet_t&    getFunctions()      const = 0;
+			virtual const InstructionSet_t& getInstructions()   const = 0;
+			virtual const AddressSet_t&     getAddresses()      const = 0;
+			virtual const RelocationSet_t&  getRelocations()    const = 0;
+			virtual const DataScoopSet_t&   getDataScoops()     const = 0;
+			virtual const ICFSSet_t&        getAllICFS()        const = 0;
+			virtual const EhProgramSet_t&   getAllEhPrograms()  const = 0;
+			virtual const EhCallSiteSet_t&  getAllEhCallSites() const = 0;
+			virtual File_t*                 getFile()           const = 0;
+			virtual DatabaseID_t            getMaxBaseID()      const = 0;
+			virtual DataScoop_t*            findScoop(
+			         const VirtualOffset_t &p_addr)             const = 0;
+
+			virtual void         setBaseIDS()                                                   = 0;
+			virtual void         assembleRegistry()                                             = 0;
+			virtual void         registerAssembly(Instruction_t *p_instr, string p_assembly)    = 0;
+			virtual void         unregisterAssembly(Instruction_t *p_instr)                     = 0;
+			virtual string       lookupAssembly(Instruction_t *p_instr)                         = 0;
+			virtual void         changeRegistryKey(
+			                                   Instruction_t* p_orig, Instruction_t* p_updated) = 0;
+			virtual void         splitScoop(
+			                                DataScoop_t *p_to_split, 
+			                                const VirtualOffset_t &p_addr, 
+			                                size_t p_size, 
+			                                DataScoop_t* &p_before,
+			                                DataScoop_t* &p_containing, 
+			                                DataScoop_t* &p_after, 
+			                                DatabaseID_t *p_max_id=NULL
+			                               )                                                    = 0;
+
+			virtual void writeToDB(std::ostream *verbose_logging=&std::cerr) = 0;
+
+			virtual EhCallSite_t* addEhCallSite_t(Instruction_t* for_insn, const uint64_t enc=0, Instruction_t* lp=nullptr) = 0;
+			virtual Relocation_t* addNewRelocation(
+					BaseObj_t* from_obj, 
+					int32_t _offset, 
+					string _type, 
+					BaseObj_t* p_wrt_obj=nullptr, 
+					int32_t p_addend=0
+					) = 0;
+
+			virtual EhProgram_t* addEhProgram(
+					Instruction_t* insn=nullptr, 
+					const uint64_t caf=1, 
+					const int64_t daf=1, 
+					const uint8_t rr=1, 
+					const uint8_t p_ptrsize=8,
+					const EhProgramListing_t& p_cie_program={},
+					const EhProgramListing_t& p_fde_program={}
+					) = 0;
+
+			virtual AddressID_t* addNewAddress(const DatabaseID_t& myfileID, const VirtualOffset_t& voff) =0 ;
+			virtual ICFS_t*      addNewICFS   (Instruction_t* insn=nullptr, const InstructionSet_t& targets={}, const ICFSAnalysisStatus_t& status=iasAnalysisIncomplete) = 0; 
+
+			virtual Instruction_t* addNewInstruction(
+					AddressID_t* addr=nullptr, 
+					Function_t* func=nullptr, 
+					const string& bits="", 
+					const string& comment="user-added", 
+					AddressID_t* indTarg=nullptr
+					) =0;
+			virtual DataScoop_t* addNewDataScoop(    
+					const string& p_name="user-added",
+					AddressID_t* p_start=nullptr,
+					AddressID_t* p_end=nullptr,
+					Type_t* p_type=nullptr,
+					uint8_t p_permissions=0,
+					bool p_is_relro=false,
+					const string &p_contents="",
+					DatabaseID_t id=BaseObj_t::NOT_IN_DATABASE
+					) = 0;
+
+
+
+			virtual void removeScoop(DataScoop_t* s) = 0;
+			virtual void moveRelocation(Relocation_t* reloc, Instruction_t* from, Instruction_t* to) = 0;
+
+
+		// static methods
+			static uint32_t  getArchitectureBitWidth() ;
+			static const IRDB_SDK::ArchitectureDescription_t* getArchitecture() ;
+
+
+		// factories:
+			static unique_ptr<FileIR_t> factory(VariantID_t *p_progid, File_t* p_fid=nullptr);
+
+
+	};
+
+}

include/inc-core/function.hpp

+
+
+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class Function_t : virtual public BaseObj_t
+	{
+		protected:
+			Function_t() {}
+			Function_t(const Function_t&copy) = delete;
+
+		public:
+			// getters
+			virtual const InstructionSet_t& getInstructions()      const = 0;
+			virtual const int               getStackFrameSize()    const = 0;
+			virtual const string&           getName()              const = 0;
+			virtual uint32_t                getOutArgsRegionSize() const = 0;
+			virtual Instruction_t*          getEntryPoint()        const = 0;
+			virtual bool                    getUseFramePointer()   const = 0;
+			virtual int                     getNumArguments()      const = 0;
+			virtual FuncType_t*             getType()              const = 0;
+			virtual bool                    isSafe()               const = 0;
+
+			// muttators
+			virtual void setStackFrameSize(int size)            = 0;
+			virtual void setName(string newname)	            = 0;
+			virtual void setOutArgsRegionSize(uint32_t oa_size) = 0;
+			virtual void setEntryPoint(Instruction_t *insn)     = 0;
+			virtual void setUseFramePointer(bool useFP)         = 0;
+			virtual void setSafe(bool safe)                     = 0;
+			virtual void setType(FuncType_t *t)                 = 0;
+	};
+
+}

include/inc-core/icfs.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class ICFS_t : virtual public InstructionSet_t, virtual public BaseObj_t
+	{
+		protected:
+			ICFS_t() {};
+			ICFS_t(const ICFS_t& copy) = delete;
+		public:
+			 
+			// getters
+			virtual bool                 isIncomplete()      const = 0;
+			virtual bool                 isComplete()        const = 0;
+			virtual bool                 isModuleComplete()  const = 0;
+			virtual ICFSAnalysisStatus_t getAnalysisStatus() const = 0;
+
+			// mutators
+			virtual void setTargets(const InstructionSet_t &other)              = 0;
+			virtual void addTargets(const InstructionSet_t &other)              = 0;
+			virtual void setAnalysisStatus(const ICFSAnalysisStatus_t p_status) = 0;
+
+	};
+
+}

include/inc-core/instruction.hpp

+namespace IRDB_SDK
+{
+	using namespace std;
+
+	class Instruction_t : virtual public BaseObj_t
+	{
+		protected:
+			Instruction_t() {}
+			Instruction_t(const Instruction_t& copy) = delete;
+		public:
+
+			virtual AddressID_t*   getAddress()                     const = 0;
+			virtual Function_t*    getFunction()                    const = 0;
+			virtual DatabaseID_t   getOriginalAddressID()           const = 0;
+			virtual Instruction_t* getFallthrough()                 const = 0;
+			virtual Instruction_t* getTarget()                      const = 0;
+			virtual ICFS_t*        getIBTargets()                   const = 0;
+			virtual string         getDataBits()                    const = 0;
+			virtual string         getCallback()                    const = 0;
+			virtual string         getComment()                     const = 0;
+			virtual EhProgram_t*   getEhProgram()                   const = 0;
+			virtual EhCallSite_t*  getEhCallSite()                  const = 0;
+			virtual AddressID_t*   getIndirectBranchTargetAddress() const = 0;
+			virtual bool           isFunctionExit()                 const = 0;
+			virtual string         getDisassembly()                 const = 0;
+	  
+			virtual void setAddress(AddressID_t* newaddr)                       = 0;
+			virtual void setFunction(Function_t* func   )                       = 0;
+			virtual void setOriginalAddressID(DatabaseID_t origid)              = 0;
+			virtual void setFallthrough(Instruction_t* i)                       = 0;
+			virtual void setTarget(Instruction_t* i)                            = 0;
+			virtual void setIBTargets(ICFS_t *p_icfs)                           = 0;
+			virtual void setDataBits(string orig)	                            = 0;
+			virtual void setCallback(string orig)	                            = 0;
+			virtual void setComment(string orig)	                            = 0;
+			virtual void setEhProgram(EhProgram_t* orig)                        = 0;
+			virtual void setEhCallSite(EhCallSite_t* orig)                      = 0;
+			virtual void setIndirectBranchTargetAddress(AddressID_t* myIndTarg) = 0;
+			virtual bool assemble(string assembly)                              = 0;
+
+	};
+}

include/inc-core/irdbobjs.hpp

+namespace IRDB_SDK
+{
+	using namespace std;
+
+	class IRDBObjects_t
+	{
+		protected:
+			IRDBObjects_t() {}
+			IRDBObjects_t(const IRDBObjects_t& copy) = delete;
+		public:
+			virtual ~IRDBObjects_t() {}
+			virtual FileIR_t*    addFileIR(const DatabaseID_t variant_id, const DatabaseID_t file_id)               = 0;
+			virtual void         deleteFileIR(const DatabaseID_t file_id)                                           = 0;
+			virtual VariantID_t* addVariant(const DatabaseID_t variant_id)                                          = 0;
+			virtual void         deleteVariant(DatabaseID_t variant_id)                                             = 0;
+			virtual pqxxDB_t*    getDBInterface() const                                                             = 0;
+			virtual pqxxDB_t*    resetDBInterface()                                                                 = 0;
+			virtual int          writeBackFileIR(const DatabaseID_t file_id, ostream *verbose_logging=nullptr)      = 0;
+			virtual int          writeBackVariant(const DatabaseID_t variant_id)                                    = 0;
+			virtual int          writeBackAll(ostream* verbose_logging=nullptr)                                     = 0;
+			virtual void         deleteAll(void)                                                                    = 0;
+			virtual void         tidyIR()                                                                           = 0;
+	};
+
+}
+
+ 

include/inc-core/pqxxdb.hpp

+
+namespace IRDB_SDK
+{
+	using namespace std;
+
+	class pqxxDB_t : virtual public DBinterface_t
+	{
+		protected:
+			pqxxDB_t() {}
+			pqxxDB_t(const pqxxDB_t& copy) = delete;
+		public:
+			virtual ~pqxxDB_t() { };
+
+			virtual void         issueQuery(string query)         = 0;
+			virtual void         issueQuery(stringstream & query) = 0;
+			virtual void         moveToNextRow()                  = 0;
+			virtual string       getResultColumn(string colname)  = 0;
+			virtual bool         isDone()                         = 0;
+			virtual void         commit()                         = 0;
+			virtual pqxx::connection&  
+				             getConnection()                  = 0; 
+			virtual pqxx::work&  getTransaction()                 = 0; 
+
+			static unique_ptr<pqxxDB_t> factory();
+
+	};
+}

include/inc-core/reloc.hpp

+
+namespace IRDB_SDK
+{
+	using namespace std;
+
+	class Relocation_t : virtual public BaseObj_t
+	{
+		protected:
+			Relocation_t() { }
+			Relocation_t(const Relocation_t& copy) = delete;
+		
+		public:
+			virtual ~Relocation_t() { }
+
+			virtual int        getOffset() const = 0;
+			virtual string     getType()   const = 0;
+			virtual uint32_t   getAddend() const = 0;
+			virtual BaseObj_t* getWRT()    const = 0;
+
+			virtual void setOffset(int off)              = 0;
+			virtual void setType(string ty)              = 0;
+			virtual void setAddend(uint32_t p_addend)    = 0;
+			virtual void setWRT(BaseObj_t* WRT)          = 0;
+
+	};
+}

include/inc-core/scoop.hpp

+namespace IRDB_SDK
+{
+	using namespace std;
+
+	class DataScoop_t : virtual public BaseObj_t
+	{
+
+		protected:
+			DataScoop_t() {}
+			DataScoop_t(const DataScoop_t& copy) = delete;
+		public:
+			virtual ~DataScoop_t() { }
+
+			virtual const string     getName()       const = 0;
+			virtual const string&    getContents()   const = 0;
+			virtual AddressID_t*     getStart()      const = 0;
+			virtual AddressID_t*     getEnd()        const = 0;
+			virtual Type_t*          getType()       const = 0;
+			virtual VirtualOffset_t  getSize()       const = 0;
+			virtual bool             isReadable()    const = 0;
+			virtual bool             isWriteable()   const = 0;
+			virtual bool             isExecuteable() const = 0;
+			virtual bool             isRelRo()       const = 0;
+			virtual uint8_t          getRawPerms()   const = 0;
+
+			virtual void setName(const string &n)     = 0;
+			virtual void setContents(const string &n) = 0;
+			virtual void setStart( AddressID_t* addr) = 0;
+			virtual void setEnd( AddressID_t* addr )  = 0;
+			virtual void setType( Type_t*  t)         = 0;
+			virtual void setReadable()                = 0;
+			virtual void setWriteable()               = 0;
+			virtual void setExecuteable()             = 0;
+			virtual void setRelRo()                   = 0;
+			virtual void clearReadable()              = 0;
+			virtual void clearWriteable()             = 0;
+			virtual void clearExecuteable()           = 0;
+			virtual void clearRelRo()                 = 0;
+			virtual void setRawPerms(int newperms)    = 0;
+
+	};
+}

include/inc-core/transform_step.h

+namespace IRDB_SDK
+{
+	using namespace std;
+	class TransformStep_t
+	{
+		protected:
+			TransformStep_t() { }
+		public:
+			virtual        ~TransformStep_t(void) { } 
+
+			virtual string getStepName(void) const = 0;
+
+			virtual int    parseArgs(const vector<string> step_args)      = 0;
+			virtual int    executeStep(IRDBObjects_t *const irdb_objects) = 0;
+	};
+
+}
+
+
+// Must also declare a getTransformStep global function in your thanos-enabled .so file
+// so that thanos can use it as a factory to create your transform class.  It must
+// follow this signature:
+//
+// extern "C" std::shared_ptr<TransformStep_t> getTransformStep(void);    
+
+

include/inc-core/type.hpp

+namespace IRDB_SDK
+{
+
+	using namespace std;
+
+	class Type_t : virtual public BaseObj_t
+	{
+		protected:
+			Type_t() {}
+			Type_t(const Type_t& copy) = delete;
+		public:
+			virtual ~Type_t() {}
+
+			virtual string     getName()         const = 0;
+			virtual IRDBType_t getTypeID()       const = 0;
+			virtual bool       isUnknownType()   const = 0;
+			virtual bool       isVariadicType()  const = 0;
+			virtual bool       isAggregateType() const = 0;
+			virtual bool       isFuncType()      const = 0;
+			virtual bool       isBasicType()     const = 0;
+			virtual bool       isPointerType()   const = 0;
+			virtual bool       isNumericType()   const = 0;
+
+			virtual void       setTypeID(IRDBType t)          = 0;
+			virtual void       setName(const string& newname) = 0;
+
+	};
+
+	class BasicType_t : virtual public Type_t
+	{
+		protected:
+			BasicType_t() {}	
+			BasicType_t(const BasicType_t& copy) = delete;
+		public:
+			virtual ~BasicType_t() {}
+
+			virtual bool isBasicType()   const = 0;
+			virtual bool isNumericType() const = 0;
+	};
+
+	class PointerType_t : virtual public Type_t
+	{
+		protected:
+			PointerType_t() {}
+			PointerType_t(const PointerType_t& copy) = delete;
+		public:
+			virtual ~PointerType_t() {}
+
+			virtual bool    isPointerType()   const = 0;
+			virtual Type_t* getReferentType() const = 0;
+
+			virtual void setReferentType(Type_t* r) = 0;
+	};
+
+	class AggregateType_t : virtual public Type_t
+	{
+		protected:
+			AggregateType_t() { }
+			AggregateType_t(const AggregateType_t& copy) = delete;
+		public:
+			virtual ~AggregateType_t() {}
+
+			virtual bool    isAggregateType()                   const = 0;
+			virtual size_t  getNumAggregatedTypes()             const = 0;
+			virtual Type_t* getAggregatedType(unsigned int pos) const = 0;
+
+			virtual void addAggregatedType(Type_t *t, int pos) = 0;
+	};
+
+	class FuncType_t : virtual public Type_t
+	{
+		protected:
+			FuncType_t() {}
+			FuncType_t(const FuncType_t& copy) = delete;
+		public:
+			virtual ~FuncType_t() {}
+
+			virtual bool             isFuncType()       const = 0;
+			virtual Type_t*          getReturnType()    const = 0;
+			virtual AggregateType_t* getArgumentsType() const = 0;
+
+			virtual void setReturnType(Type_t *t)             = 0;
+			virtual void setArgumentsType(AggregateType_t *t) = 0;
+
+	};
+}