BinaryVxcoreParser.h

#ifndef ROSE_BinaryAnalysis_VxcoreParser_H
#define ROSE_BinaryAnalysis_VxcoreParser_H
 
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RegisterState.h>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <Rose/Diagnostics.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/StringUtility.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class VxcoreParser {
public:
    struct Settings {
        unsigned version;                               
        Sawyer::Optional<unsigned> protOverride;        
        unsigned protDefault;                           
        Settings()
            : version(1) {}
    };
    
    class Exception: public Rose::Exception {
        boost::filesystem::path fileName_;
        size_t offset_;
 
    public:
        Exception(const boost::filesystem::path &fileName, size_t offset, const std::string &what)
            : Rose::Exception(what), fileName_(fileName), offset_(offset) {}
 
        ~Exception() throw () {}
 
        std::string toString() const {
            return StringUtility::cEscape(fileName_.string()) + ":" + boost::lexical_cast<std::string>(offset_) + ": " + what();
        }
 
        void print(std::ostream &out) const {
            out <<toString();
        }
 
        friend std::ostream& operator<<(std::ostream &out, const Exception &e) {
            e.print(out);
            return out;
        }
    };
 
private:
    // Message headers for version 2.
    struct HeaderVersion2 {
        uint8_t version;                                // must be 2
        uint8_t unused0;
        uint8_t unused1;
        uint8_t mapFlags;                               // MemoryMap::{READABLE,WRITABLE,EXECUTABLE}
        uint32_t payloadSize;                           // little-endian
        uint64_t addr;                                  // little-endian
    };
 
private:
    Settings settings_;
    std::string isaName_;                               // Parsed instruction set architecture name
 
public:
    static Sawyer::Message::Facility mlog;              
    static void initDiagnostics();                      // used internally
 
public:
    const Settings& settings() const { return settings_; }
    Settings& settings() { return settings_; }
    void settings(const Settings &s) { settings_ = s; }
    boost::filesystem::path parseUrl(const std::string&);
 
    void parse(const boost::filesystem::path&, const MemoryMap::Ptr&);
    void parse(const boost::filesystem::path&, const InstructionSemantics::BaseSemantics::RegisterStatePtr &registers,
               const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &ops);
    void parse(const boost::filesystem::path&, const MemoryMap::Ptr&,
               const InstructionSemantics::BaseSemantics::RegisterStatePtr &registers,
               const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &ops);
    void parse(std::istream&, const MemoryMap::Ptr&, const InstructionSemantics::BaseSemantics::RegisterStatePtr &registers,
               const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &ops, const std::string &inputName = "input");
    void unparse(std::ostream&, const MemoryMap::Ptr&, const AddressInterval &memoryLimit,
                 const std::string &outputName = "output");
    void unparse(std::ostream&, const InstructionSemantics::BaseSemantics::RegisterStatePtr&,
                 const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&,
                 const std::string &outputName = "output");
    void unparse(std::ostream&, const MemoryMap::Ptr&, const AddressInterval &memoryLimit,
                 const InstructionSemantics::BaseSemantics::RegisterStatePtr&,
                 const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&,
                 const std::string &outputName = "output");
    const std::string& isaName() const { return isaName_; }
    
private:
    // Parse a memory section of the input when given a header and the input stream positioned at the first byte after the
    // header.  Returns false if the header is invalid, throws an Exception if there's a problem reading the data, and returns
    // true if the memory section was parsed. The memory map can be null, in which case all the normal parsing occurs but
    // nothing is updated. The inputName is only for the exceptions.
    bool parseMemory(const std::string &header, std::istream&, const MemoryMap::Ptr&, const std::string &inputName,
                     size_t headerOffset);
 
    // Similar to parseMemory except for registers.
    bool parseRegisters(const std::string &header, std::istream&, const InstructionSemantics::BaseSemantics::RegisterStatePtr&,
                        const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &ops,
                        const std::string &inputName, size_t headerOffset);
};
 
} // namespace
} // namespace
 
#endif
#endif