BasicTypes.h

#ifndef ROSE_Partitioner2_BasicTypes_H
#define ROSE_Partitioner2_BasicTypes_H

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/regex.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <string>
#include <vector>

// Define this as one if you want extra invariant checks that are quite expensive, or define as zero. This only makes a
// difference if NDEBUG and SAWYER_NDEBUG are both undefined--if either one of them are defined then no expensive (or
// inexpensive) checks are performed.
#define ROSE_PARTITIONER_EXPENSIVE_CHECKS 0

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

namespace Precision {
enum Level {                                            
    LOW,                                                
    HIGH                                                
};
} // namespace

namespace AllowParallelEdges {
enum Type {                                             
    NO,                                                 
    YES                                                 
};
} // namespace

enum VertexType {
    V_BASIC_BLOCK,                                      
    V_UNDISCOVERED,                                     
    V_INDETERMINATE,                                    
    V_NONEXISTING,                                      
    V_USER_DEFINED,                                     
};

enum EdgeType {
    E_NORMAL            = 0x00000001,                   
    E_FUNCTION_CALL     = 0x00000002,                   
    E_FUNCTION_RETURN   = 0x00000004,                   
    E_CALL_RETURN       = 0x00000008,                   
    E_FUNCTION_XFER     = 0x00000010,                   
    E_USER_DEFINED      = 0x00000020,                   
};

enum Confidence {
    ASSUMED,                                            
    PROVED,                                             
};

enum SemanticMemoryParadigm {
    LIST_BASED_MEMORY,                                  
    MAP_BASED_MEMORY                                    
};

struct AstConstructionSettings {
    bool allowEmptyGlobalBlock;

    bool allowFunctionWithNoBasicBlocks;

    bool allowEmptyBasicBlocks;

    bool copyAllInstructions;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        s & BOOST_SERIALIZATION_NVP(allowEmptyGlobalBlock);
        s & BOOST_SERIALIZATION_NVP(allowFunctionWithNoBasicBlocks);
        s & BOOST_SERIALIZATION_NVP(allowEmptyBasicBlocks);
        s & BOOST_SERIALIZATION_NVP(copyAllInstructions);
    }

public:
    AstConstructionSettings()
        : allowEmptyGlobalBlock(false), allowFunctionWithNoBasicBlocks(false), allowEmptyBasicBlocks(false),
          copyAllInstructions(true) {}

    static AstConstructionSettings strict() {
        AstConstructionSettings s;
        s.allowEmptyGlobalBlock = false;
        s.allowFunctionWithNoBasicBlocks = false;
        s.allowEmptyBasicBlocks = false;
        s.copyAllInstructions = true;
        return s;
    }

    static AstConstructionSettings permissive() {
        AstConstructionSettings s;
        s.allowEmptyGlobalBlock = true;
        s.allowFunctionWithNoBasicBlocks = true;
        s.allowEmptyBasicBlocks = true;
        s.copyAllInstructions = true;               // true keeps the AST a tree instead of a lattice
        return s;
    }
};

// Settings.  All settings must act like properties, which means the following:
//   1. Each setting must have a name that does not begin with a verb.
//   2. Each setting must have a command-line switch to manipulate it.
//   3. Each setting must have a method that queries the property (same name as the property and taking no arguments).
//   4. Each setting must have a modifier method (same name as property but takes a value and returns void)

enum MemoryDataAdjustment {
    DATA_IS_CONSTANT,                               
    DATA_IS_INITIALIZED,                            
    DATA_NO_CHANGE,                                 
};

struct LoaderSettings {
    size_t deExecuteZerosThreshold;                 
    size_t deExecuteZerosLeaveAtFront;              
    size_t deExecuteZerosLeaveAtBack;               
    MemoryDataAdjustment memoryDataAdjustment;      
    bool memoryIsExecutable;                        
    bool linkObjectFiles;                           
    bool linkStaticArchives;                        
    std::string linker;                             
    std::vector<std::string> envEraseNames;         
    std::vector<boost::regex> envErasePatterns;     
    std::vector<std::string> envInsert;             
    LoaderSettings()
        : deExecuteZerosThreshold(0), deExecuteZerosLeaveAtFront(16), deExecuteZerosLeaveAtBack(1),
          memoryDataAdjustment(DATA_IS_INITIALIZED), memoryIsExecutable(false), linkObjectFiles(true),
          linkStaticArchives(true), linker("ld -o %o --unresolved-symbols=ignore-all --whole-archive %f") {}

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        s & BOOST_SERIALIZATION_NVP(deExecuteZerosThreshold);
        s & BOOST_SERIALIZATION_NVP(deExecuteZerosLeaveAtFront);
        s & BOOST_SERIALIZATION_NVP(deExecuteZerosLeaveAtBack);
        s & BOOST_SERIALIZATION_NVP(memoryDataAdjustment);
        s & BOOST_SERIALIZATION_NVP(memoryIsExecutable);
        if (version >= 1) {
            s & BOOST_SERIALIZATION_NVP(envEraseNames);
            s & BOOST_SERIALIZATION_NVP(envInsert);

            // There's no serialization for boost::regex, so we do it ourselves.
            std::vector<std::string> reStrings;
            BOOST_FOREACH (const boost::regex &re, envErasePatterns)
                reStrings.push_back(re.str());
            s & BOOST_SERIALIZATION_NVP(reStrings);
            if (envErasePatterns.empty()) {
                BOOST_FOREACH (const std::string &reStr, reStrings)
                    envErasePatterns.push_back(boost::regex(reStr));
            }
        }
    }
};

struct DisassemblerSettings {
    bool doDisassemble;                             
    std::string isaName;                            
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(doDisassemble);
        s & BOOST_SERIALIZATION_NVP(isaName);
    }

public:
    DisassemblerSettings()
        : doDisassemble(true) {}
};

enum FunctionReturnAnalysis {
    MAYRETURN_DEFAULT_YES,                          
    MAYRETURN_DEFAULT_NO,                           
    MAYRETURN_ALWAYS_YES,                           
    MAYRETURN_ALWAYS_NO,                            
};

struct BasePartitionerSettings {
    bool usingSemantics;                            
    bool checkingCallBranch;                        
    bool basicBlockSemanticsAutoDrop;               
    bool ignoringUnknownInsns;                      
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned version) {
        s & BOOST_SERIALIZATION_NVP(usingSemantics);
        s & BOOST_SERIALIZATION_NVP(checkingCallBranch);
        s & BOOST_SERIALIZATION_NVP(basicBlockSemanticsAutoDrop);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(ignoringUnknownInsns);
    }

public:
    BasePartitionerSettings()
        : usingSemantics(false), checkingCallBranch(false), basicBlockSemanticsAutoDrop(true), ignoringUnknownInsns(false) {}
};

struct PartitionerSettings {
    BasePartitionerSettings base;
    std::vector<rose_addr_t> functionStartingVas;   
    bool followingGhostEdges;                       
    bool discontiguousBlocks;                       
    size_t maxBasicBlockSize;                       
    std::vector<rose_addr_t> ipRewrites;            
    bool findingFunctionPadding;                    
    bool findingDeadCode;                           
    rose_addr_t peScramblerDispatcherVa;            
    size_t findingIntraFunctionCode;                
    bool findingIntraFunctionData;                  
    bool findingInterFunctionCalls;                 
    bool findingFunctionCallFunctions;              
    bool findingEntryFunctions;                     
    bool findingErrorFunctions;                     
    bool findingImportFunctions;                    
    bool findingExportFunctions;                    
    bool findingSymbolFunctions;                    
    AddressInterval interruptVector;                
    bool doingPostAnalysis;                         
    bool doingPostFunctionMayReturn;                
    bool doingPostFunctionStackDelta;               
    bool doingPostCallingConvention;                
    bool doingPostFunctionNoop;                     
    FunctionReturnAnalysis functionReturnAnalysis;  
    size_t functionReturnAnalysisMaxSorts;          
    bool findingDataFunctionPointers;               
    bool findingCodeFunctionPointers;               
    bool findingThunks;                             
    bool splittingThunks;                           
    SemanticMemoryParadigm semanticMemoryParadigm;  
    bool namingConstants;                           
    bool namingStrings;                             
    bool namingSyscalls;                            
    boost::filesystem::path syscallHeader;          
    bool demangleNames;                             
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        s & BOOST_SERIALIZATION_NVP(base);
        s & BOOST_SERIALIZATION_NVP(functionStartingVas);
        s & BOOST_SERIALIZATION_NVP(followingGhostEdges);
        s & BOOST_SERIALIZATION_NVP(discontiguousBlocks);
        s & BOOST_SERIALIZATION_NVP(maxBasicBlockSize);
        if (version >= 6)
            s & BOOST_SERIALIZATION_NVP(ipRewrites);
        s & BOOST_SERIALIZATION_NVP(findingFunctionPadding);
        s & BOOST_SERIALIZATION_NVP(findingDeadCode);
        s & BOOST_SERIALIZATION_NVP(peScramblerDispatcherVa);
        if (version >= 2) {
            s & BOOST_SERIALIZATION_NVP(findingIntraFunctionCode);
        } else {
            bool temp = false;
            if (S::is_saving::value)
                temp = findingIntraFunctionCode > 0;
            s & boost::serialization::make_nvp("findingIntraFunctionCode", temp);
            if (S::is_loading::value)
                findingIntraFunctionCode = temp ? 10 : 0; // arbitrary number of passes
        }
        s & BOOST_SERIALIZATION_NVP(findingIntraFunctionData);
        s & BOOST_SERIALIZATION_NVP(findingInterFunctionCalls);
        if (version >= 4)
            s & BOOST_SERIALIZATION_NVP(findingFunctionCallFunctions);
        if (version >= 5) {
            s & BOOST_SERIALIZATION_NVP(findingEntryFunctions);
            s & BOOST_SERIALIZATION_NVP(findingErrorFunctions);
            s & BOOST_SERIALIZATION_NVP(findingImportFunctions);
            s & BOOST_SERIALIZATION_NVP(findingExportFunctions);
            s & BOOST_SERIALIZATION_NVP(findingSymbolFunctions);
        }
        s & BOOST_SERIALIZATION_NVP(interruptVector);
        s & BOOST_SERIALIZATION_NVP(doingPostAnalysis);
        s & BOOST_SERIALIZATION_NVP(doingPostFunctionMayReturn);
        s & BOOST_SERIALIZATION_NVP(doingPostFunctionStackDelta);
        s & BOOST_SERIALIZATION_NVP(doingPostCallingConvention);
        s & BOOST_SERIALIZATION_NVP(doingPostFunctionNoop);
        s & BOOST_SERIALIZATION_NVP(functionReturnAnalysis);
        if (version >= 3)
            s & BOOST_SERIALIZATION_NVP(functionReturnAnalysisMaxSorts);
        s & BOOST_SERIALIZATION_NVP(findingDataFunctionPointers);
        s & BOOST_SERIALIZATION_NVP(findingCodeFunctionPointers);
        s & BOOST_SERIALIZATION_NVP(findingThunks);
        s & BOOST_SERIALIZATION_NVP(splittingThunks);
        s & BOOST_SERIALIZATION_NVP(semanticMemoryParadigm);
        s & BOOST_SERIALIZATION_NVP(namingConstants);
        s & BOOST_SERIALIZATION_NVP(namingStrings);
        s & BOOST_SERIALIZATION_NVP(demangleNames);
        if (version >= 1) {
            s & BOOST_SERIALIZATION_NVP(namingSyscalls);

            // There is no support for boost::filesystem serialization due to arguments by the maintainers over who has
            // responsibility, so we do it the hard way.
            std::string temp;
            if (S::is_saving::value)
                temp = syscallHeader.string();
            s & boost::serialization::make_nvp("syscallHeader", temp);
            if (S::is_loading::value)
                syscallHeader = temp;
        }
    }

public:
    PartitionerSettings()
        : followingGhostEdges(false), discontiguousBlocks(true), maxBasicBlockSize(0), findingFunctionPadding(true),
          findingDeadCode(true), peScramblerDispatcherVa(0), findingIntraFunctionCode(10), findingIntraFunctionData(true),
          findingInterFunctionCalls(true), findingFunctionCallFunctions(true), findingEntryFunctions(true),
          findingErrorFunctions(true), findingImportFunctions(true), findingExportFunctions(true), findingSymbolFunctions(true),
          doingPostAnalysis(true), doingPostFunctionMayReturn(true), doingPostFunctionStackDelta(true),
          doingPostCallingConvention(false), doingPostFunctionNoop(false), functionReturnAnalysis(MAYRETURN_DEFAULT_YES),
          functionReturnAnalysisMaxSorts(50), findingDataFunctionPointers(false), findingCodeFunctionPointers(false),
          findingThunks(true), splittingThunks(false), semanticMemoryParadigm(LIST_BASED_MEMORY), namingConstants(true),
          namingStrings(true), namingSyscalls(true), demangleNames(true) {}
};

// BOOST_CLASS_VERSION(PartitionerSettings, 1); -- see end of file (cannot be in a namespace)

struct EngineSettings {
    std::vector<std::string> configurationNames;    
    bool exitOnError;                               
    EngineSettings()
        : exitOnError(true) {}

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        s & BOOST_SERIALIZATION_NVP(configurationNames);
        s & BOOST_SERIALIZATION_NVP(exitOnError);
    }
};

// Additional declarations w/out definitions yet.
class Partitioner;
class Function;
typedef Sawyer::SharedPointer<Function> FunctionPtr;
class BasicBlock;
typedef Sawyer::SharedPointer<BasicBlock> BasicBlockPtr;
class DataBlock;
typedef Sawyer::SharedPointer<DataBlock> DataBlockPtr;
class ThunkPredicates;
typedef Sawyer::SharedPointer<ThunkPredicates> ThunkPredicatesPtr;

} // namespace
} // namespace
} // namespace

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::PartitionerSettings, 6);
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::BasePartitionerSettings, 1);
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::LoaderSettings, 1);
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::DisassemblerSettings, 1);

#endif
#endif