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/Yaml.h>

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

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