LinuxI386.h

#ifndef ROSE_BinaryAnalysis_Concolic_LinuxI386_H
#define ROSE_BinaryAnalysis_Concolic_LinuxI386_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/Debugger/Linux.h>

#include <boost/filesystem.hpp>
#include <Sawyer/Callbacks.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

// Linux Intel 80386 and compatible hardware architecture.

class LinuxI386: public Architecture {
    using Super = Architecture;

public:
    using Ptr = LinuxI386Ptr;

private:
    Debugger::Linux::Ptr debugger_;
    rose_addr_t scratchVa_ = 0;                         // subordinate address for scratch page
    bool markingArgvAsInput_ = true;
    bool markingEnvpAsInput_ = false;

protected:
    LinuxI386(const DatabasePtr&, TestCaseId, const Partitioner2::Partitioner&);
public:
    ~LinuxI386();

public:
    static Ptr instance(const DatabasePtr&, TestCaseId, const Partitioner2::Partitioner&);
    static Ptr instance(const DatabasePtr&, const TestCasePtr&, const Partitioner2::Partitioner&);
    Debugger::Linux::Ptr debugger() const;

public:
    RegisterDescriptor systemCallReturnRegister();

public:
    // These are documented in the base class.
    virtual void configureSystemCalls() override;
    virtual void configureSharedMemory() override;
    virtual void load(const boost::filesystem::path&) override;
    virtual bool isTerminated() override;
    virtual ByteOrder::Endianness memoryByteOrder() override;
    virtual std::string readCString(rose_addr_t va, size_t maxBytes = UNLIMITED) override;
    virtual rose_addr_t ip() override;
    virtual void ip(rose_addr_t) 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 std::vector<ExecutionEventPtr> createRegisterRestoreEvents() override;
    virtual bool playEvent(const ExecutionEventPtr&) override;
    virtual void mapMemory(const AddressInterval&, unsigned permissions) override;
    virtual void unmapMemory(const AddressInterval&) override;
    virtual size_t writeMemory(rose_addr_t, const std::vector<uint8_t>&) override;
    virtual std::vector<uint8_t> readMemory(rose_addr_t, size_t) override;
    virtual void writeRegister(RegisterDescriptor, uint64_t) override;
    virtual void writeRegister(RegisterDescriptor, const Sawyer::Container::BitVector&) override;
    virtual Sawyer::Container::BitVector readRegister(RegisterDescriptor) override;
    virtual void executeInstruction(const Partitioner2::Partitioner&) override;
    virtual void executeInstruction(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, SgAsmInstruction*) override;
    virtual void createInputVariables(const Partitioner2::Partitioner&, const Emulation::RiscOperatorsPtr&,
                                      const SmtSolver::Ptr &solver) override;
    virtual void systemCall(const Partitioner2::Partitioner&,
                            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::Partitioner&,
                                      const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);

    // Returns the system call argument.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallArgument(const Partitioner2::Partitioner&,
                       const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, size_t argNumber);

    // Returns the system call return value.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallReturnValue(const Partitioner2::Partitioner&,
                          const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);

    // Modify the symbolic system call return value.
    InstructionSemantics::BaseSemantics::SValuePtr
    systemCallReturnValue(const Partitioner2::Partitioner&,
                          const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&,
                          const InstructionSemantics::BaseSemantics::SValuePtr&);

};

// Linux i386 specific system call operations.

class LinuxI386SyscallBase: public SyscallCallback {
    ExecutionEventPtr   latestReturnEvent_;             // event for most recent system call return
    ExecutionEventPtr   penultimateReturnEvent_;        // event for next most recent system call return

public:
    LinuxI386SyscallBase();
    virtual ~LinuxI386SyscallBase();

    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 LinuxI386SyscallUnimplemented: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallUnimplemented();
public:
    ~LinuxI386SyscallUnimplemented();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallReturnsInput: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallReturnsInput();
public:
    ~LinuxI386SyscallReturnsInput();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallTerminates: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallTerminates();
public:
    ~LinuxI386SyscallTerminates();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallReturn: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallReturn();
public:
    ~LinuxI386SyscallReturn();

protected:
    virtual std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) = 0;

public:
    void handlePostSyscall(SyscallContext&) override final;
};

class LinuxI386SyscallConstant: public LinuxI386SyscallReturn {
protected:
    LinuxI386SyscallConstant();
public:
    ~LinuxI386SyscallConstant();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) override;
};

class LinuxI386SyscallNondecreasing: public LinuxI386SyscallReturn {
protected:
    LinuxI386SyscallNondecreasing();
public:
    ~LinuxI386SyscallNondecreasing();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    std::pair<SymbolicExpressionPtr, Sawyer::Optional<uint64_t>> makeReturnConstraint(SyscallContext&) override;
};

class LinuxI386SyscallAccess: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallAccess();
public:
    ~LinuxI386SyscallAccess();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallBrk: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallBrk();
public:
    ~LinuxI386SyscallBrk();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallMmap2: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallMmap2();
public:
    ~LinuxI386SyscallMmap2();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

class LinuxI386SyscallOpenat: public LinuxI386SyscallBase {
protected:
    LinuxI386SyscallOpenat();
public:
    ~LinuxI386SyscallOpenat();

public:
    static Ptr instance();

    void playback(SyscallContext&) override;
    void handlePostSyscall(SyscallContext&) override;
};

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

#endif
#endif