Addr.hpp

Go to the documentation of this file.

//===- Addr.hpp -------------------------------------------------*- C++ -*-===//
//
//  Copyright (C) 2020 GrammaTech, Inc.
//
//  This code is licensed under the MIT license. See the LICENSE file in the
//  project root for license terms.
//
//  This project is sponsored by the Office of Naval Research, One Liberty
//  Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
//  N68335-17-C-0700.  The content of the information does not necessarily
//  reflect the position or policy of the Government and no official
//  endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_ADDR_H
#define GTIRB_ADDR_H
 
#include <gtirb/Export.hpp>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <iosfwd>
#include <optional>
 
 
namespace gtirb {
class GTIRB_EXPORT_API Addr {
public:
  typedef uint64_t value_type;
  typedef int64_t difference_type;
 
  constexpr Addr() noexcept : Address{0} {}
 
  constexpr explicit Addr(value_type X) noexcept : Address(X) {}
 
  constexpr explicit operator value_type() const noexcept { return Address; }
 
  constexpr Addr operator+() const noexcept { return Addr(+Address); }
 
  constexpr Addr operator~() const noexcept { return Addr(~Address); }
 
  constexpr Addr& operator++() noexcept {
    ++Address;
    return *this;
  }
 
  constexpr Addr operator++(int) noexcept {
    Addr R(*this);
    ++Address;
    return R;
  }
 
  constexpr Addr& operator--() noexcept {
    --Address;
    return *this;
  }
 
  constexpr Addr operator--(int) noexcept {
    Addr R(*this);
    --Address;
    return R;
  }
 
  friend constexpr Addr operator+(const Addr& A, value_type Offset) noexcept {
    return Addr(A.Address + Offset);
  }
 
  friend constexpr Addr operator+(value_type Offset, const Addr& A) noexcept {
    return A + Offset;
  }
 
  constexpr Addr& operator+=(value_type Offset) noexcept {
    Address += Offset;
    return *this;
  }
 
  friend constexpr Addr operator-(const Addr& A, value_type Offset) noexcept {
    return Addr(A.Address - Offset);
  }
 
  constexpr Addr& operator-=(value_type Offset) noexcept {
    Address -= Offset;
    return *this;
  }
 
  friend constexpr difference_type operator-(const Addr& A,
                                             const Addr& B) noexcept {
    return static_cast<difference_type>(A.Address - B.Address);
  }
 
  friend constexpr bool operator==(const Addr& LHS, const Addr& RHS) noexcept {
    return LHS.Address == RHS.Address;
  }
 
  friend constexpr bool operator!=(const Addr& LHS, const Addr& RHS) noexcept {
    return !operator==(LHS, RHS);
  }
 
  friend constexpr bool operator<(const Addr& LHS, const Addr& RHS) noexcept {
    return LHS.Address < RHS.Address;
  }
 
  friend constexpr bool operator>(const Addr& LHS, const Addr& RHS) noexcept {
    return operator<(RHS, LHS);
  }
 
  friend constexpr bool operator<=(const Addr& LHS, const Addr& RHS) noexcept {
    return !operator<(RHS, LHS);
  }
 
  friend constexpr bool operator>=(const Addr& LHS, const Addr& RHS) noexcept {
    return !operator<(LHS, RHS);
  }
 
private:
  value_type Address{0};
};
 
class GTIRB_EXPORT_API AddrRange {
public:
  constexpr explicit AddrRange(Addr Lower, Addr Upper) noexcept
      : First(Lower), Size(Upper - (Lower < Upper ? Lower : Upper)) {}
 
  constexpr explicit AddrRange(Addr Lower, uint64_t Count) noexcept
      : First(Lower), Size(Count) {}
 
  constexpr bool operator==(const AddrRange& RHS) const noexcept {
    return First == RHS.First && Size == RHS.Size;
  }
 
  constexpr bool operator!=(const AddrRange& RHS) const noexcept {
    return First != RHS.First || Size != RHS.Size;
  }
 
  constexpr Addr lower() const noexcept { return First; }
 
  constexpr Addr upper() const noexcept { return First + Size; }
 
  constexpr uint64_t size() const noexcept { return Size; }
 
private:
  Addr First;
 
  uint64_t Size;
};
 
template <typename T> std::optional<uint64_t> asOptionalSize(T X);
 
template <> std::optional<uint64_t> inline asOptionalSize(uint64_t X) {
  return X;
}
 
template <>
std::optional<uint64_t> inline asOptionalSize(std::optional<uint64_t> X) {
  return X;
}
 
template <typename T> std::optional<AddrRange> addressRange(const T& Object) {
  if (std::optional<Addr> A = Object.getAddress()) {
    if (std::optional<uint64_t> S = Object.getSize()) {
      return AddrRange{*A, *S};
    }
  }
  return std::nullopt;
}
 
template <typename T> std::optional<Addr> addressLimit(const T& Object) {
  auto A = Object.getAddress();
  auto B = asOptionalSize(Object.getSize());
  if (A && B) {
    return *A + *B;
  }
  return std::nullopt;
}
 
template <typename T> bool containsAddr(const T& Object, Addr Ea) {
  return Object.getAddress() <= Ea && addressLimit(Object) > Ea;
}
 
template <typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& Stream, Addr A) {
  auto Flags = Stream.flags();
  Stream << std::setbase(16) << std::showbase << static_cast<uint64_t>(A);
  Stream.flags(Flags);
  return Stream;
}
 
template <typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& Stream, std::optional<Addr> A) {
  if (A)
    return Stream << *A;
  return Stream << "<none>";
}
 
} // namespace gtirb
 
namespace std {
 
template <> struct hash<gtirb::Addr> {
  size_t operator()(const gtirb::Addr& A) const {
    return std::hash<uint64_t>{}(static_cast<uint64_t>(A));
  }
};
 
} // namespace std
 
#endif // GTIRB_ADDR_H