ModulesLinux.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_ModulesLinux_H
#define ROSE_BinaryAnalysis_Partitioner2_ModulesLinux_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/Modules.h>
 
#include <Rose/BinaryAnalysis/SystemCall.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
namespace ModulesLinux {
 
SystemCall systemCallAnalyzer(const PartitionerConstPtr&, const boost::filesystem::path &syscallHeader = "");
 
class SyscallSuccessors: public BasicBlockCallback {
    SystemCall analyzer_;
protected:
    SyscallSuccessors(const PartitionerConstPtr&, const boost::filesystem::path &syscallHeader);
public:
    static Ptr instance(const PartitionerConstPtr&, const boost::filesystem::path &syscallHeader = "");
 
    virtual bool operator()(bool chain, const Args&) override;
};
class SyscallSuccessors: public BasicBlockCallback {…};
 
class LibcStartMain: public BasicBlockCallback {
    Sawyer::Optional<Address> mainVa_;
public:
    typedef Sawyer::SharedPointer<LibcStartMain> Ptr;
 
    static Ptr instance() { return Ptr(new LibcStartMain); } 
    virtual bool operator()(bool chain, const Args&) override;
 
    void nameMainFunction(const PartitionerConstPtr&) const;
 
private:
    // Read a value from the stack
    InstructionSemantics::BaseSemantics::SValuePtr
    readStack(const PartitionerConstPtr &partitioner, const InstructionSemantics::BaseSemantics::DispatcherPtr &cpu, int byteOffset,
              size_t nBitsToRead, RegisterDescriptor segmentRegister);
};
 
void nameSystemCalls(const PartitionerConstPtr&, const boost::filesystem::path &syscallHeader = "");
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif
    virtual bool operator()(bool chain, const Args&) override; {…}
class LibcStartMain: public BasicBlockCallback {…};
namespace ModulesLinux {…}