RelativeVirtualAddress.h

#ifndef ROSE_BinaryAnalysis_RelativeVirtualAddress_H
#define ROSE_BinaryAnalysis_RelativeVirtualAddress_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Address.h>
 
#include <ROSE_DEPRECATED.h>
#include <Cxx_GrammarDeclarations.h>
 
#include <Sawyer/Optional.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class RelativeVirtualAddress {
    // Offset relative to a section's preferred mapping address (if `section_` is not null) or relative to a file's base address (if
    // `section_` is null). The offset is treated as a signed quantity by virtue of unsigned 64-bit overflow.
    rose_addr_t rva_ = 0;
 
    // Optional base section. If present, then it must have a preferred mapping address, and the `rva_` is an offset to the
    // section's preferred address.
    SgAsmGenericSection *section_ = nullptr;
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(rva_);
        s & BOOST_SERIALIZATION_NVP(section_);
    }
#endif
 
public:
    RelativeVirtualAddress();
 
    RelativeVirtualAddress(const rose_addr_t rva, SgAsmGenericSection* = nullptr); //implicit
 
    RelativeVirtualAddress(const RelativeVirtualAddress&);
 
    RelativeVirtualAddress operator=(const RelativeVirtualAddress&);
 
    static RelativeVirtualAddress sectionRelative(SgAsmGenericSection*, rose_addr_t sectionOffset);
 
    bool isBound() const;
 
    rose_addr_t rva() const;
 
    RelativeVirtualAddress& rva(rose_addr_t rva);
 
    SgAsmGenericSection *boundSection() const;
 
    RelativeVirtualAddress& bindSection(SgAsmGenericSection*);
 
    RelativeVirtualAddress& bindBestSection(SgAsmGenericHeader*);
 
    Sawyer::Optional<rose_addr_t> va() const;
 
    Sawyer::Optional<rose_addr_t> boundOffset() const;
 
    rose_addr_t offsetFrom(SgAsmGenericSection*) const;
 
    void increment(rose_addr_t amount);
 
    std::string toString() const;
 
    // [Robb Matzke 2024-02-05]: deprecated
public:
    static RelativeVirtualAddress section_relative(SgAsmGenericSection*, rose_addr_t) ROSE_DEPRECATED("use sectionRelative instead");
    bool is_bound() const ROSE_DEPRECATED("use isBound instead");
    rose_addr_t get_rva() const ROSE_DEPRECATED("use rva instead");
    RelativeVirtualAddress& set_rva(rose_addr_t rva) ROSE_DEPRECATED("use rva instead");
    SgAsmGenericSection *get_section() const ROSE_DEPRECATED("use boundSection instead");
    RelativeVirtualAddress& set_section(SgAsmGenericSection*) ROSE_DEPRECATED("use bindSection instead");
    RelativeVirtualAddress& bind(SgAsmGenericHeader*) ROSE_DEPRECATED("use bindBestSection instead");
    rose_addr_t get_va() const ROSE_DEPRECATED("use va instead");
    rose_addr_t get_rel() const ROSE_DEPRECATED("use boundOffset instead");
    rose_addr_t get_rel(SgAsmGenericSection*) ROSE_DEPRECATED("use offsetFrom instead");
    std::string to_string() const ROSE_DEPRECATED("use toString instead");
};
 
} // namespace
} // namespace
 
// Old name used from 2008-2024
using rose_rva_t = Rose::BinaryAnalysis::RelativeVirtualAddress;
 
std::ostream &operator<<(std::ostream&, const Rose::BinaryAnalysis::RelativeVirtualAddress&);
 
rose_addr_t operator-(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1,
                      const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
rose_addr_t operator+(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1,
                      const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
 
bool operator< (const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
bool operator<=(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
bool operator> (const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
bool operator>=(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
bool operator==(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
bool operator!=(const Rose::BinaryAnalysis::RelativeVirtualAddress &a1, const Rose::BinaryAnalysis::RelativeVirtualAddress &a2);
 
#endif
#endif