dbg.h

Go to the documentation of this file.

#pragma once
 
#include <bit>
#include <ostream>
#include <tuple>
 
#include <ankerl/unordered_dense.h>
 
#include "fe/format.h"
#include "fe/loc.h"
#include "fe/sym.h"
 
namespace fe {
 
/// The debug info of an entity: where it came from and what it was called.
struct Dbg {
    /// @name Constructors
    ///@{
    constexpr Dbg() noexcept = default;
    constexpr Dbg(Loc loc, Sym sym) noexcept
        : loc_(loc)
        , sym_(sym) {}
    constexpr Dbg(Loc loc) noexcept
        : Dbg(loc, {}) {}
    constexpr Dbg(Sym sym) noexcept
        : Dbg({}, sym) {}
    ///@}
 
    /// @name Getters
    ///@{
    constexpr Sym sym() const noexcept { return sym_; }
    constexpr Loc loc() const noexcept { return loc_; }
    /// Assumes `_` as the anonymous name.
    constexpr bool is_anon() const noexcept { return !sym() || sym() == '_'; }
    constexpr explicit operator bool() const noexcept { return sym().operator bool(); }
    ///@}
 
    /// @name Setters
    ///@{
    constexpr Dbg& set(Sym sym) noexcept { return sym_ = sym, *this; }
    constexpr Dbg& set(Loc loc) noexcept { return loc_ = loc, *this; }
    ///@}
 
    /// @name Comparison and Hashing
    ///@{
    /// @note Like Loc::operator==, this only compares Loc::src by pointer identity.
    constexpr bool operator==(const Dbg& other) const noexcept { return loc_ == other.loc_ && sym_ == other.sym_; }
 
    struct Hash {
        using is_avalanching = void;
 
        size_t operator()(Dbg dbg) const noexcept {
            using Tuple = std::tuple<uintptr_t, uint32_t, uint32_t, uintptr_t>;
            return ankerl::unordered_dense::hash<Tuple>()(
                {std::bit_cast<uintptr_t>(dbg.loc_.src), dbg.loc_.begin.off, dbg.loc_.end.off, dbg.sym_.raw()});
        }
    };
 
    struct Eq {
        constexpr bool operator()(Dbg d1, Dbg d2) const noexcept { return d1 == d2; }
    };
    ///@}
 
private:
    Loc loc_;
    Sym sym_;
 
    friend std::ostream& operator<<(std::ostream& os, const Dbg& dbg) { return os << dbg.sym(); }
};
 
/// @name DbgMap/DbgSet
///@{
template<class V>
using DbgMap = ankerl::unordered_dense::map<Dbg, V, Dbg::Hash, Dbg::Eq>;
using DbgSet = ankerl::unordered_dense::set<Dbg, Dbg::Hash, Dbg::Eq>;
///@}
 
/// Opaque handle to a Dbg interned in a Driver; see Driver::dbg.
/// Handing one node another's key copies the handle verbatim: no Dbg is materialised and nothing is
/// looked up in the Driver's table.
/// @warning A key is only meaningful within the Driver that interned it.
class DbgKey {
public:
    constexpr DbgKey() noexcept = default; ///< The empty Dbg.
 
    constexpr explicit operator bool() const noexcept { return key_ != 0; } ///< Not the empty Dbg?
    constexpr bool operator==(const DbgKey&) const noexcept = default;
 
private:
    constexpr explicit DbgKey(uint32_t key) noexcept
        : key_(key) {}
 
    uint32_t key_ = 0;
 
    friend struct Driver;
};
 
} // namespace fe
 
#ifndef DOXYGEN
template<>
struct std::formatter<fe::Dbg> : fe::ostream_formatter {};
#endif