SystemCall.h

#ifndef ROSE_BinaryAnalysis_SystemCall_H
#define ROSE_BinaryAnalysis_SystemCall_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AbstractLocation.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <boost/filesystem.hpp>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/Exception.h>
#include <Sawyer/Map.h>
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
 
class SystemCall {
public:
    class Exception: public Rose::Exception {
    public:
        Exception(const std::string &mesg): Rose::Exception(mesg) {}
 
        ~Exception() throw () {}
    };
        
    struct Declaration {
        uint64_t id;                                    
        std::string name;                               
        Declaration()
            : id(0) {}
        
        Declaration(uint64_t id, const std::string &name)
            : id(id), name(name) {}
    };
 
    typedef Sawyer::Container::Map<uint64_t /*id*/, Declaration> Declarations; 
 
private:
    Declarations declarations_;                         // table describing all known system calls index by system call number
    AbstractLocation ident_;                            // location that identifies the system call
 
public:
    virtual ~SystemCall() {}
 
    void declare(const Declaration &declaration);
 
    void declare(const std::vector<Declaration> &declarations);
 
    void declare(const boost::filesystem::path &headerFileName);
 
    const Declarations& declarations() const { return declarations_; }
 
    Sawyer::Optional<Declaration> lookup(uint64_t id) const;
 
    std::vector<Declaration> lookup(const std::string &name) const;
    
    static std::vector<Declaration> parseHeaderFile(const boost::filesystem::path &headerFileName);
 
    SgAsmInstruction* hasSystemCall(const Partitioner2::BasicBlockPtr&) const;
 
    const AbstractLocation& ident() const { return ident_; }
    void ident(const AbstractLocation &location) { ident_ = location; }
    virtual Sawyer::Optional<Declaration>
    analyze(const Partitioner2::PartitionerConstPtr&, const Partitioner2::BasicBlockPtr&, SgAsmInstruction*,
            const SmtSolver::Ptr &solver = SmtSolver::Ptr()) const;
 
    virtual bool isSystemCall(SgAsmInstruction*) const;
};
 
} // namespace
} // namespace
 
#endif
#endif