Concolic/I386Linux/Architecture.h

#ifndef ROSE_BinaryAnalysis_Concolic_I386Linux_Architecture_H
#define ROSE_BinaryAnalysis_Concolic_I386Linux_Architecture_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
 
#include <Rose/BinaryAnalysis/Concolic/Architecture.h>
#include <Rose/BinaryAnalysis/Concolic/ExecutionEvent.h>
#include <Rose/BinaryAnalysis/Concolic/SharedMemory.h>
#include <Rose/BinaryAnalysis/Concolic/SystemCall.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/Yaml.h>
 
#include <Sawyer/Callbacks.h>
 
#include <boost/filesystem.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
namespace I386Linux {
 
// Linux Intel 80386 and compatible hardware architecture.
 
class Architecture: public Concolic::Architecture {
    using Super = Concolic::Architecture;
 
public:
    using Ptr = ArchitecturePtr;
 
private:
    bool markingArgvAsInput_ = true;
    bool markingEnvpAsInput_ = false;
 
protected:
    Architecture(const std::string&);                   // for instantiating a factory
    Architecture(const DatabasePtr&, TestCaseId);
public:
    ~Architecture();
 
public:
    static Ptr factory();
 
    static Ptr instance(const DatabasePtr&, TestCaseId, const Yaml::Node &config);
    static Ptr instance(const DatabasePtr&, const TestCasePtr&, const Yaml::Node &config);
public:
    // Same as super class, but casts result to a Linux debugger.
    Debugger::LinuxPtr debugger() const;
 
    RegisterDescriptor systemCallReturnRegister();
 
public:
    // These are documented in the base class.
    virtual bool matchFactory(const Yaml::Node&) const override;
    virtual Super::Ptr instanceFromFactory(const DatabasePtr&, TestCaseId, const Yaml::Node &config) const override;
    virtual Partitioner2::PartitionerPtr partition(const Partitioner2::EnginePtr&, const std::string &specimen) override;
    virtual void configureSystemCalls() override;
    virtual void configureSharedMemory(const Yaml::Node &config) override;
    virtual void load(const boost::filesystem::path&) override;
    virtual ByteOrder::Endianness memoryByteOrder() override;
    virtual std::vector<ExecutionEventPtr> createMemoryRestoreEvents() override;
    virtual std::vector<ExecutionEventPtr> createMemoryHashEvents() override;
    virtual std::vector<ExecutionEventPtr> createMemoryAdjustEvents(const MemoryMap::Ptr&, rose_addr_t insnVa) override;
    virtual bool playEvent(const ExecutionEventPtr&) override;
    virtual void mapMemory(const AddressInterval&, unsigned permissions) override;
    virtual void unmapMemory(const AddressInterval&) override;
    virtual void createInputVariables(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                                      const SmtSolver::Ptr &solver) override;
    virtual void systemCall(const Partitioner2::PartitionerConstPtr&,
                            const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) override;
    virtual void advanceExecution(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) override;
    virtual InstructionSemantics::BaseSemantics::DispatcherPtr
        makeDispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) override;
 
private:
    // Maps a scratch page for internal use and updates scratchVa_ with the address of the page.
    void mapScratchPage();
 
    // Copy (share) some data from the dst map to the src map at where. Generate map and write events that will map the memory
    // and initialize it when played back.
    std::vector<ExecutionEventPtr> copyMemory(const MemoryMap::Ptr &src, const MemoryMap::Ptr &dst, const AddressInterval &where,
                                              rose_addr_t insnVa);
 
    // List of process memory segments that are not special.
    std::vector<MemoryMap::ProcessMapRecord> disposableMemory();
 
    // Unmap nearly all memory. The scratch page is not unmapped, nor is the VDSO or VVAR.
    void unmapAllMemory();
 
    // When stopped at the beginning of a system call, return the system call function number. See <sys/unistd_32.h> for the
    // mapping function system call number to the Linux kernel function that handles it.
    uint64_t systemCallFunctionNumber(const Partitioner2::PartitionerConstPtr&,
                                      const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);
 
    // Returns the system call argument.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallArgument(const Partitioner2::PartitionerConstPtr&,
                       const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, size_t argNumber);
 
    // Returns the system call return value.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallReturnValue(const Partitioner2::PartitionerConstPtr&,
                          const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);
 
    // Modify the symbolic system call return value.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallReturnValue(const Partitioner2::PartitionerConstPtr&,
                          const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&,
                          const InstructionSemantics::BaseSemantics::SValuePtr&);
 
};
 
// Linux i386 specific system call operations.
 
class SyscallBase: public SyscallCallback {
    ExecutionEventPtr   latestReturnEvent_;             // event for most recent system call return
    ExecutionEventPtr   penultimateReturnEvent_;        // event for next most recent system call return
 
public:
    SyscallBase();
    virtual ~SyscallBase();
 
    void hello(const std::string &name, const SyscallContext&) const;
 
    virtual void playback(SyscallContext&) = 0;
 
    virtual void handlePreSyscall(SyscallContext&) {}
    virtual void handlePostSyscall(SyscallContext&) = 0;
    ExecutionEventPtr latestReturnEvent() const;
    ExecutionEventPtr penultimateReturnEvent() const;
    void showRecentReturnValues(std::ostream&, const SyscallContext&) const;
 
    SymbolicExpressionPtr penultimateSymbolicReturn() const;
 
public:
    // Subclasses need not provide a function operator.
    virtual bool operator()(bool /*handled*/, SyscallContext&) override final;
};
 
class SyscallUnimplemented: public SyscallBase {
protected:
    SyscallUnimplemented();
public:
    ~SyscallUnimplemented();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallReturnsInput: public SyscallBase {
protected:
    SyscallReturnsInput();
public:
    ~SyscallReturnsInput();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallTerminates: public SyscallBase {
protected:
    SyscallTerminates();
public:
    ~SyscallTerminates();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallReturn: public SyscallBase {
protected:
    SyscallReturn();
public:
    ~SyscallReturn();
 
protected:
    virtual std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) = 0;
 
public:
    void handlePostSyscall(SyscallContext&) override final;
};
 
class SyscallConstant: public SyscallReturn {
protected:
    SyscallConstant();
public:
    ~SyscallConstant();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) override;
};
 
class SyscallNondecreasing: public SyscallReturn {
protected:
    SyscallNondecreasing();
public:
    ~SyscallNondecreasing();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) override;
};
 
class SyscallAccess: public SyscallBase {
protected:
    SyscallAccess();
public:
    ~SyscallAccess();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallBrk: public SyscallBase {
protected:
    SyscallBrk();
public:
    ~SyscallBrk();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallMmap2: public SyscallBase {
protected:
    SyscallMmap2();
public:
    ~SyscallMmap2();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
class SyscallOpenat: public SyscallBase {
protected:
    SyscallOpenat();
public:
    ~SyscallOpenat();
 
public:
    static Ptr instance();
 
    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif