Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===-- SymbolStringPool.h -- Thread-safe pool for JIT symbols --*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// Contains a thread-safe string pool suitable for use with ORC.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_EXECUTIONENGINE_ORC_SYMBOLSTRINGPOOL_H

#define LLVM_EXECUTIONENGINE_ORC_SYMBOLSTRINGPOOL_H

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/StringMap.h"

#include <atomic>

#include <mutex>

namespace llvm {

class raw_ostream;

namespace orc {

class SymbolStringPtr;

/// String pool for symbol names used by the JIT.

class SymbolStringPool {

  friend class SymbolStringPtr;

  // Implemented in DebugUtils.h.

  friend raw_ostream &operator<<(raw_ostream &OS, const SymbolStringPool &SSP);

public:

  /// Destroy a SymbolStringPool.

  ~SymbolStringPool();

  /// Create a symbol string pointer from the given string.

  SymbolStringPtr intern(StringRef S);

  /// Remove from the pool any entries that are no longer referenced.

  void clearDeadEntries();

  /// Returns true if the pool is empty.

  bool empty() const;

private:

  using RefCountType = std::atomic<size_t>;

  using PoolMap = StringMap<RefCountType>;

  using PoolMapEntry = StringMapEntry<RefCountType>;

  mutable std::mutex PoolMutex;

  PoolMap Pool;

};

/// Pointer to a pooled string representing a symbol name.

class SymbolStringPtr {

  friend class OrcV2CAPIHelper;

  friend class SymbolStringPool;

  friend struct DenseMapInfo<SymbolStringPtr>;

public:

  SymbolStringPtr() = default;

  SymbolStringPtr(std::nullptr_t) {}

  SymbolStringPtr(const SymbolStringPtr &Other)

    : S(Other.S) {

    if (isRealPoolEntry(S))

      ++S->getValue();

  }

  SymbolStringPtr& operator=(const SymbolStringPtr &Other) {

    if (isRealPoolEntry(S)) {

      assert(S->getValue() && "Releasing SymbolStringPtr with zero ref count");

      --S->getValue();

    }

    S = Other.S;

    if (isRealPoolEntry(S))

      ++S->getValue();

    return *this;

  }

  SymbolStringPtr(SymbolStringPtr &&Other) : S(nullptr) {

    std::swap(S, Other.S);

  }

  SymbolStringPtr& operator=(SymbolStringPtr &&Other) {

    if (isRealPoolEntry(S)) {

      assert(S->getValue() && "Releasing SymbolStringPtr with zero ref count");

      --S->getValue();

    }

    S = nullptr;

    std::swap(S, Other.S);

    return *this;

  }

  ~SymbolStringPtr() {

    if (isRealPoolEntry(S)) {

      assert(S->getValue() && "Releasing SymbolStringPtr with zero ref count");

      --S->getValue();

    }

  }

  explicit operator bool() const { return S; }

  StringRef operator*() const { return S->first(); }

  friend bool operator==(const SymbolStringPtr &LHS,

                         const SymbolStringPtr &RHS) {

    return LHS.S == RHS.S;

  }

  friend bool operator!=(const SymbolStringPtr &LHS,

                         const SymbolStringPtr &RHS) {

    return !(LHS == RHS);

  }

  friend bool operator<(const SymbolStringPtr &LHS,

                        const SymbolStringPtr &RHS) {

    return LHS.S < RHS.S;

  }

private:

  using PoolEntry = SymbolStringPool::PoolMapEntry;

  using PoolEntryPtr = PoolEntry *;

  SymbolStringPtr(SymbolStringPool::PoolMapEntry *S)

      : S(S) {

    if (isRealPoolEntry(S))

      ++S->getValue();

  }

  // Returns false for null, empty, and tombstone values, true otherwise.

  bool isRealPoolEntry(PoolEntryPtr P) {

    return ((reinterpret_cast<uintptr_t>(P) - 1) & InvalidPtrMask) !=

           InvalidPtrMask;

  }

  static SymbolStringPtr getEmptyVal() {

    return SymbolStringPtr(reinterpret_cast<PoolEntryPtr>(EmptyBitPattern));

  }

  static SymbolStringPtr getTombstoneVal() {

    return SymbolStringPtr(reinterpret_cast<PoolEntryPtr>(TombstoneBitPattern));

  }

  constexpr static uintptr_t EmptyBitPattern =

      std::numeric_limits<uintptr_t>::max()

      << PointerLikeTypeTraits<PoolEntryPtr>::NumLowBitsAvailable;

  constexpr static uintptr_t TombstoneBitPattern =

      (std::numeric_limits<uintptr_t>::max() - 1)

      << PointerLikeTypeTraits<PoolEntryPtr>::NumLowBitsAvailable;

  constexpr static uintptr_t InvalidPtrMask =

      (std::numeric_limits<uintptr_t>::max() - 3)

      << PointerLikeTypeTraits<PoolEntryPtr>::NumLowBitsAvailable;

  PoolEntryPtr S = nullptr;

};

inline SymbolStringPool::~SymbolStringPool() {

#ifndef NDEBUG

  clearDeadEntries();

  assert(Pool.empty() && "Dangling references at pool destruction time");

#endif // NDEBUG

}

inline SymbolStringPtr SymbolStringPool::intern(StringRef S) {

  std::lock_guard<std::mutex> Lock(PoolMutex);

  PoolMap::iterator I;

  bool Added;

  std::tie(I, Added) = Pool.try_emplace(S, 0);

  return SymbolStringPtr(&*I);

}

inline void SymbolStringPool::clearDeadEntries() {

  std::lock_guard<std::mutex> Lock(PoolMutex);

  for (auto I = Pool.begin(), E = Pool.end(); I != E;) {

    auto Tmp = I++;

    if (Tmp->second == 0)

      Pool.erase(Tmp);

  }

}

inline bool SymbolStringPool::empty() const {

  std::lock_guard<std::mutex> Lock(PoolMutex);

  return Pool.empty();

}

} // end namespace orc

template <>

struct DenseMapInfo<orc::SymbolStringPtr> {

  static orc::SymbolStringPtr getEmptyKey() {

    return orc::SymbolStringPtr::getEmptyVal();

  }

  static orc::SymbolStringPtr getTombstoneKey() {

    return orc::SymbolStringPtr::getTombstoneVal();

  }

  static unsigned getHashValue(const orc::SymbolStringPtr &V) {

    return DenseMapInfo<orc::SymbolStringPtr::PoolEntryPtr>::getHashValue(V.S);

  }

  static bool isEqual(const orc::SymbolStringPtr &LHS,

                      const orc::SymbolStringPtr &RHS) {

    return LHS.S == RHS.S;

  }

};

} // end namespace llvm

#endif // LLVM_EXECUTIONENGINE_ORC_SYMBOLSTRINGPOOL_H