Rose/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 <Rose/BinaryAnalysis/AddressInterval.h>
 
#include <Sawyer/Graph.h>
#include <Sawyer/Map.h>
#include <Sawyer/Set.h>
#include <Sawyer/SharedPointer.h>
 
#include <boost/filesystem.hpp>
#include <boost/regex.hpp>
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
#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;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
 
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;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
struct DisassemblerSettings {
    bool doDisassemble = true;
 
    std::string isaName;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
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;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
struct PartitionerSettings {
    BasePartitionerSettings base;
 
    std::vector<Address> functionStartingVas;
 
    bool followingGhostEdges = false;
 
    bool discontiguousBlocks = true;
 
    size_t maxBasicBlockSize = 0;
 
    std::vector<Address> ipRewrites;
 
    bool findingFunctionPadding = true;
 
    bool findingDeadCode = true;
 
    Address 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;
 
    bool naiveJumpTables = true;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
namespace IndirectControlFlow {
    struct Settings {
        bool enabled = false;
 
        size_t maxReversePathLength = 10;
 
        size_t maxInliningDepth = 1;
 
        size_t maxDataflowIterationFactor = 2;
 
        size_t maxDataflowVertices = 50;
 
        size_t maxDataflowSetSize = 10;
 
        size_t maxSymbolicExprSize = 10000;
 
        bool reanalyzeSomeBlocks = true;
 
        Sawyer::Optional<Address> debugAddress;
    };
} // namespace
 
 
struct EngineSettings {
    std::vector<std::string> configurationNames;
 
    bool exitOnError = true;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
struct JvmSettings {
    std::vector<std::string> classPath;
 
    bool loadAllClasses = false;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
};
 
// 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<Address, 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 JumpTable;
using JumpTablePtr = std::shared_ptr<JumpTable>;            
using JumpTableConstPtr = std::shared_ptr<const JumpTable>; 
class MemoryTable;
using MemoryTablePtr = std::shared_ptr<MemoryTable>;            
using MemoryTableConstPtr = std::shared_ptr<const MemoryTable>; 
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
 
#endif
#endif