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