BasicTypes.h

#ifndef ROSE_Partitioner2_BasicTypes_H
#define ROSE_Partitioner2_BasicTypes_H

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.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 {

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

enum EdgeType {
    E_NORMAL,                                           
    E_FUNCTION_CALL,                                    
    E_FUNCTION_RETURN,                                  
    E_CALL_RETURN,                                      
    E_FUNCTION_XFER,                                    
    E_USER_DEFINED,                                     
};

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 & allowEmptyGlobalBlock & allowFunctionWithNoBasicBlocks & allowEmptyBasicBlocks & 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;                        
    LoaderSettings()
        : deExecuteZerosThreshold(0), deExecuteZerosLeaveAtFront(16), deExecuteZerosLeaveAtBack(1),
          memoryDataAdjustment(DATA_IS_INITIALIZED), memoryIsExecutable(false) {}

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

    template<class S>
    void serialize(S &s, unsigned version) {
        s & deExecuteZerosThreshold & deExecuteZerosLeaveAtFront & deExecuteZerosLeaveAtBack;
        s & memoryDataAdjustment & memoryIsExecutable;
    }
};

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

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

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

struct BasePartitionerSettings {
    bool usingSemantics;                            
    bool checkingCallBranch;                        
    bool basicBlockSemanticsAutoDrop;               
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);
    }

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

struct PartitionerSettings {
    BasePartitionerSettings base;
    std::vector<rose_addr_t> startingVas;           
    bool followingGhostEdges;                       
    bool discontiguousBlocks;                       
    bool findingFunctionPadding;                    
    bool findingDeadCode;                           
    rose_addr_t peScramblerDispatcherVa;            
    bool findingIntraFunctionCode;                  
    bool findingIntraFunctionData;                  
    bool findingInterFunctionCalls;                 
    AddressInterval interruptVector;                
    bool doingPostAnalysis;                         
    bool doingPostFunctionMayReturn;                
    bool doingPostFunctionStackDelta;               
    bool doingPostCallingConvention;                
    bool doingPostFunctionNoop;                     
    FunctionReturnAnalysis functionReturnAnalysis;  
    bool findingDataFunctionPointers;               
    bool findingCodeFunctionPointers;               
    bool findingThunks;                             
    bool splittingThunks;                           
    SemanticMemoryParadigm semanticMemoryParadigm;  
    bool namingConstants;                           
    bool namingStrings;                             
    bool demangleNames;                             
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, unsigned version) {
        s & base;
        s & startingVas;
        s & followingGhostEdges;
        s & discontiguousBlocks;
        s & findingFunctionPadding;
        s & findingDeadCode;
        s & peScramblerDispatcherVa;
        s & findingIntraFunctionCode;
        s & findingIntraFunctionData;
        s & findingInterFunctionCalls;
        s & interruptVector;
        s & doingPostAnalysis;
        s & doingPostFunctionMayReturn;
        s & doingPostFunctionStackDelta;
        s & doingPostCallingConvention;
        s & doingPostFunctionNoop;
        s & functionReturnAnalysis;
        s & findingDataFunctionPointers;
        s & findingCodeFunctionPointers;
        s & findingThunks;
        s & splittingThunks;
        s & semanticMemoryParadigm;
        s & namingConstants;
        s & namingStrings;
    }

public:
    PartitionerSettings()
        : followingGhostEdges(false), discontiguousBlocks(true), findingFunctionPadding(true),
          findingDeadCode(true), peScramblerDispatcherVa(0), findingIntraFunctionCode(true), findingIntraFunctionData(true),
          findingInterFunctionCalls(true), doingPostAnalysis(true), doingPostFunctionMayReturn(true),
          doingPostFunctionStackDelta(true), doingPostCallingConvention(false), doingPostFunctionNoop(false),
          functionReturnAnalysis(MAYRETURN_DEFAULT_YES), findingDataFunctionPointers(false), findingCodeFunctionPointers(false),
          findingThunks(true), splittingThunks(false), semanticMemoryParadigm(LIST_BASED_MEMORY), namingConstants(true),
          namingStrings(true), demangleNames(true) {}
};

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 & configurationNames;
        s & 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;

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

#endif