SRecord.h

#ifndef ROSE_BinaryAnalysis_SRecord_H
#define ROSE_BinaryAnalysis_SRecord_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
 
#include <Sawyer/Optional.h>
 
#include <ostream>
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
 
class SRecord {
public:
    enum Syntax {
        SREC_MOTOROLA,                                  
        SREC_INTEL,                                     
        SREC_UNKNOWN_SYNTAX                             
    };
    enum Syntax {…};
 
    enum Type {
        // Motorola
        SREC_M_HEADER,                                  
        SREC_M_DATA16,                                  
        SREC_M_DATA24,                                  
        SREC_M_DATA32,                                  
        SREC_M_RESERVED,                                
        SREC_M_COUNT16,                                 
        SREC_M_COUNT24,                                 
        SREC_M_START32,                                 
        SREC_M_START24,                                 
        SREC_M_START16,                                 
        // Intel
        SREC_I_DATA,                                    
        SREC_I_END,                                     
        SREC_I_EXTENDED_SA,                             
        SREC_I_START_SA,                                
        SREC_I_EXTENDED_LA,                             
        SREC_I_START_LA,                                
        SREC_UNKNOWN_TYPE                               
    };
    enum Type {…};
 
private:
    Type type_;
    Address addr_;
    std::vector<uint8_t> data_;
    std::string error_;
 
    // Constructors, etc.
public:
    SRecord(): type_(SREC_UNKNOWN_TYPE), addr_(0) {}
 
    SRecord(Type type, Address addr, const std::vector<uint8_t> data)
        : type_(type), addr_(addr), data_(data) {}
    SRecord(Type type, Address addr, const std::vector<uint8_t> data) {…}
    SRecord(Type type, Address addr, const uint8_t *buffer, size_t bufsz)
        : type_(type), addr_(addr), data_(buffer+0, buffer+bufsz) {}
    SRecord(Type type, Address addr, const uint8_t *buffer, size_t bufsz) {…}
    // High-level functions.
public:
    static SRecord parse(const std::string&);
 
    static std::vector<SRecord> parse(std::istream&);
 
    static AddressIntervalSet dataAddresses(const std::vector<SRecord>&);
 
    static AddressIntervalSet createSegments(const std::vector<SRecord>&, const MemoryMapPtr &map, Address alignment,
                                             unsigned accessPermissions, const std::string &segmentName,
                                             MemoryMap::Clobber clobber);
 
    static Sawyer::Optional<Address> load(const std::vector<SRecord>&, const MemoryMapPtr&);
 
    static Sawyer::Optional<Address> load(const std::vector<SRecord>&, const MemoryMapPtr&, Address alignment,
                                               unsigned accessPerms, const std::string &name, MemoryMap::Clobber);
 
    static std::vector<SRecord> create(const MemoryMapPtr&, Syntax, size_t bytesPerRecord=28, size_t preferredAddrSize=4);
 
    std::string toString() const;
 
    void print(std::ostream&) const;
    friend std::ostream& operator<<(std::ostream&, const SRecord&);
    // S-Record properties.
public:
    Syntax syntax() const;
 
    Type type() const { return type_; }
    SRecord& type(Type type) { type_ = type; return *this; }
    Address address() const { return addr_; }
    SRecord& address(Address addr) { addr_ = addr; return *this; }
    const std::vector<uint8_t>& data() const { return data_; }
    std::vector<uint8_t>& data() { return data_; }
    SRecord& data(const std::vector<uint8_t>& data) { data_ = data; return *this; }
    const std::string& error() const { return error_; }
    SRecord& error(const std::string &error) { error_ = error; return *this; }
    // Low-level functions.
public:
    class RunLengthEncoding {
        Sawyer::Optional<Address> dataVa_, executionVa_;
        size_t nDataRecords_;
    public:
        RunLengthEncoding()
            : nDataRecords_(0) {}
        RunLengthEncoding() {…}
 
        void insert(const SRecord&);
 
        Sawyer::Optional<Address> dataAddress(const SRecord&) const;
 
        Address baseDataAddress() const;
 
        Sawyer::Optional<Address> executionAddress() const;
 
        size_t nDataRecords() const { return nDataRecords_; }
    };
    class RunLengthEncoding {…};
 
    static SRecord parseMotorola(const std::string&);
 
    static SRecord parseIntel(const std::string&);
 
    static Sawyer::Optional<Address> parseBigEndianInteger(const std::string&, size_t start, size_t nChars);
 
    static unsigned bigEndian(const std::vector<uint8_t> &data, size_t nBytes);
 
    static size_t addressNBytes(Type);
 
    static uint8_t checksum(Syntax, const std::string&, size_t start, size_t n);
};
class SRecord {…};
 
} // namespace
} // namespace
 
#endif
#endif