BinaryAnalysis/Partitioner2/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_BasicTypes_H
#define ROSE_BinaryAnalysis_Partitioner2_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <boost/filesystem.hpp>
#include <boost/regex.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <Sawyer/Graph.h>
#include <Sawyer/Map.h>
#include <Sawyer/Set.h>
#include <set>
#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 = false;

    bool allowFunctionWithNoBasicBlocks = false;

    bool allowEmptyBasicBlocks = false;

    bool copyAllInstructions = true;

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:
    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 = 0;
    size_t deExecuteZerosLeaveAtFront = 16;
    size_t deExecuteZerosLeaveAtBack = 1;
    MemoryDataAdjustment memoryDataAdjustment = DATA_IS_INITIALIZED;

    bool memoryIsExecutable = false;

    bool linkObjectFiles = true;

    bool linkStaticArchives = true;

    std::string linker = "ld -o %o --unresolved-symbols=ignore-all --whole-archive %f";

    std::vector<std::string> envEraseNames;

    std::vector<boost::regex> envErasePatterns;

    std::vector<std::string> envInsert;

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;
            for (const boost::regex &re: envErasePatterns)
                reStrings.push_back(re.str());
            s & BOOST_SERIALIZATION_NVP(reStrings);
            if (envErasePatterns.empty()) {
                for (const std::string &reStr: reStrings)
                    envErasePatterns.push_back(boost::regex(reStr));
            }
        }
    }
};

struct DisassemblerSettings {
    bool doDisassemble = true;

    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);
    }
};

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

struct BasePartitionerSettings {
    bool usingSemantics = false;

    bool checkingCallBranch = false;

    bool basicBlockSemanticsAutoDrop = true;

    bool ignoringUnknownInsns = false;

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);
    }
};

struct PartitionerSettings {
    BasePartitionerSettings base;

    std::vector<rose_addr_t> functionStartingVas;

    bool followingGhostEdges = false;

    bool discontiguousBlocks = true;

    size_t maxBasicBlockSize = 0;

    std::vector<rose_addr_t> ipRewrites;

    bool findingFunctionPadding = true;

    bool findingDeadCode = true;

    rose_addr_t peScramblerDispatcherVa = 0;

    size_t findingIntraFunctionCode = 10;

    bool findingIntraFunctionData = true;

    bool findingInterFunctionCalls = true;

    bool findingFunctionCallFunctions = true;

    bool findingEntryFunctions = true;

    bool findingErrorFunctions = true;

    bool findingImportFunctions = true;

    bool findingExportFunctions = true;

    bool findingSymbolFunctions = true;

    AddressInterval interruptVector;

    bool doingPostAnalysis = true;

    bool doingPostFunctionMayReturn = true;

    bool doingPostFunctionStackDelta = true;

    bool doingPostCallingConvention = false;

    bool doingPostFunctionNoop = false;

    FunctionReturnAnalysis functionReturnAnalysis = MAYRETURN_DEFAULT_YES;

    size_t functionReturnAnalysisMaxSorts = 50;

    bool findingDataFunctionPointers = false;

    bool findingCodeFunctionPointers = false;

    bool findingThunks = true;

    bool splittingThunks = false;

    SemanticMemoryParadigm semanticMemoryParadigm = LIST_BASED_MEMORY;

    AddressInterval namingConstants = AddressInterval::hull(4096, AddressInterval::whole().greatest());

    AddressInterval namingStrings = AddressInterval::hull(4096, AddressInterval::whole().greatest());

    bool namingSyscalls = true;

    boost::filesystem::path syscallHeader;

    bool demangleNames = true;

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);
        if (version >= 8) {
            s & BOOST_SERIALIZATION_NVP(namingConstants);
        } else if (S::is_loading()) {
            bool b;
            s & boost::serialization::make_nvp("namingConstants", b);
            if (b) {
                namingConstants = AddressInterval::whole();
            } else {
                namingConstants = AddressInterval();
            }
        }
        if (version >= 7) {
            s & BOOST_SERIALIZATION_NVP(namingStrings);
        } else if (S::is_loading()) {
            bool b;
            s & boost::serialization::make_nvp("namingStrings", b);
            if (b) {
                namingStrings = AddressInterval::whole();
            } else {
                namingStrings = AddressInterval();
            }
        }
        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;
        }
    }
};

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

struct EngineSettings {
    std::vector<std::string> configurationNames;

    bool 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 incomplete definitions.
class AddressUser;
class AddressUsers;
class AddressUsageMap;

class BasicBlock;
using BasicBlockPtr = Sawyer::SharedPointer<BasicBlock>; 
class BasicBlockError;

class BasicBlockCallback;
using BasicBlockCallbackPtr = Sawyer::SharedPointer<BasicBlockCallback>; 
class BasicBlockSuccessor;
using BasicBlockSuccessors = std::vector<BasicBlockSuccessor>; 
class CfgAdjustmentCallback;

class CfgEdge;

class CfgVertex;

using ControlFlowGraph = Sawyer::Container::Graph<CfgVertex, CfgEdge>; 
class Configuration;

class DataBlock;
using DataBlockPtr = Sawyer::SharedPointer<DataBlock>;  
class DataBlockError;

class Engine;
using EnginePtr = Sawyer::SharedPointer<Engine>;  ;

class EngineBinary;
using EngineBinaryPtr = Sawyer::SharedPointer<EngineBinary>;  ;

class EngineJvm;
using EngineJvmPtr = Sawyer::SharedPointer<EngineJvm>;  ;

class Exception;

class Function;
using FunctionPtr = Sawyer::SharedPointer<Function>;    
using Functions = Sawyer::Container::Map<rose_addr_t, FunctionPtr>; 
class FunctionCallGraph;

class FunctionPaddingMatcher;
using FunctionPaddingMatcherPtr = Sawyer::SharedPointer<FunctionPaddingMatcher>; 
class FunctionPrologueMatcher;
using FunctionPrologueMatcherPtr = Sawyer::SharedPointer<FunctionPrologueMatcher>; 
using FunctionSet = Sawyer::Container::Set<FunctionPtr>; 
class FunctionError;

class Partitioner;
using PartitionerPtr = Sawyer::SharedPointer<Partitioner>;            
using PartitionerConstPtr = Sawyer::SharedPointer<const Partitioner>; 
class PlaceholderError;

class Reference;
using ReferenceSet = std::set<Reference>;                                
using CrossReferences = Sawyer::Container::Map<Reference, ReferenceSet>; 
class ThunkPredicates;
using ThunkPredicatesPtr = Sawyer::SharedPointer<ThunkPredicates>; 
} // namespace
} // namespace
} // namespace

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::PartitionerSettings, 8);
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