File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/include/llvm/ADT

usr / src / contrib / llvm-project / llvm / include / llvm / ADT /

📁 ..
📄 APFloat.h(48.83 KB)
📄 APInt.h(74.48 KB)
📄 APSInt.h(11.75 KB)
📄 AllocatorList.h(7.53 KB)
📄 Any.h(5.05 KB)
📄 ArrayRef.h(17.92 KB)
📄 BitVector.h(29.74 KB)
📄 Bitfields.h(11.65 KB)
📄 BitmaskEnum.h(5.53 KB)
📄 BreadthFirstIterator.h(4.82 KB)
📄 CachedHashString.h(5.9 KB)
📄 CoalescingBitVector.h(14.91 KB)
📄 DAGDeltaAlgorithm.h(3.13 KB)
📄 DeltaAlgorithm.h(3.54 KB)
📄 DenseMap.h(43.14 KB)
📄 DenseMapInfo.h(11.4 KB)
📄 DenseSet.h(9.33 KB)
📄 DepthFirstIterator.h(10.37 KB)
📄 DirectedGraph.h(9.56 KB)
📄 EnumeratedArray.h(1.6 KB)
📄 EpochTracker.h(3.2 KB)
📄 EquivalenceClasses.h(10.52 KB)
📄 FloatingPointMode.h(5.62 KB)
📄 FoldingSet.h(30.16 KB)
📄 FunctionExtras.h(14.55 KB)
📄 GraphTraits.h(5.71 KB)
📄 Hashing.h(25.12 KB)
📄 ImmutableList.h(7.57 KB)
📄 ImmutableMap.h(10.84 KB)
📄 ImmutableSet.h(37.52 KB)
📄 IndexedMap.h(2.5 KB)
📄 IntEqClasses.h(2.87 KB)
📄 IntervalMap.h(72.88 KB)
📄 IntrusiveRefCntPtr.h(8.1 KB)
📄 MapVector.h(7.79 KB)
📄 None.h(983 B)
📄 Optional.h(10.82 KB)
📄 PackedVector.h(4.17 KB)
📄 PointerEmbeddedInt.h(4.05 KB)
📄 PointerIntPair.h(8.72 KB)
📄 PointerSumType.h(11.61 KB)
📄 PointerUnion.h(10.17 KB)
📄 PostOrderIterator.h(11.05 KB)
📄 PriorityQueue.h(2.69 KB)
📄 PriorityWorklist.h(8.11 KB)
📄 SCCIterator.h(8.02 KB)
📄 STLExtras.h(70.56 KB)
📄 ScopeExit.h(1.83 KB)
📄 ScopedHashTable.h(8.27 KB)
📄 Sequence.h(2.59 KB)
📄 SetOperations.h(2.58 KB)
📄 SetVector.h(9.39 KB)
📄 SmallBitVector.h(20.36 KB)
📄 SmallPtrSet.h(16.93 KB)
📄 SmallSet.h(8.37 KB)
📄 SmallString.h(8.55 KB)
📄 SmallVector.h(32.33 KB)
📄 SparseBitVector.h(26.2 KB)
📄 SparseMultiSet.h(17.83 KB)
📄 SparseSet.h(11.41 KB)
📄 Statistic.h(7.01 KB)
📄 StringExtras.h(13.25 KB)
📄 StringMap.h(15.7 KB)
📄 StringMapEntry.h(4.83 KB)
📄 StringRef.h(31.68 KB)
📄 StringSet.h(1.51 KB)
📄 StringSwitch.h(6.25 KB)
📄 TinyPtrVector.h(10.19 KB)
📄 Triple.h(27.4 KB)
📄 Twine.h(17.48 KB)
📄 TypeSwitch.h(5.82 KB)
📄 UniqueVector.h(3.09 KB)
📄 Waymarking.h(11.96 KB)
📄 bit.h(2.26 KB)
📄 edit_distance.h(3.57 KB)
📄 fallible_iterator.h(8.31 KB)
📄 ilist.h(13.68 KB)
📄 ilist_base.h(2.72 KB)
📄 ilist_iterator.h(7.21 KB)
📄 ilist_node.h(9.84 KB)
📄 ilist_node_base.h(1.7 KB)
📄 ilist_node_options.h(5.07 KB)
📄 iterator.h(13.46 KB)
📄 iterator_range.h(2.22 KB)
📄 simple_ilist.h(10.78 KB)

Editing: CachedHashString.h

//===- llvm/ADT/CachedHashString.h - Prehashed string/StringRef -*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines CachedHashString and CachedHashStringRef.  These are owning
// and not-owning string types that store their hash in addition to their string
// data.
//
// Unlike std::string, CachedHashString can be used in DenseSet/DenseMap
// (because, unlike std::string, CachedHashString lets us have empty and
// tombstone values).
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ADT_CACHED_HASH_STRING_H
#define LLVM_ADT_CACHED_HASH_STRING_H

#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/StringRef.h"

namespace llvm {

/// A container which contains a StringRef plus a precomputed hash.
class CachedHashStringRef {
  const char *P;
  uint32_t Size;
  uint32_t Hash;

public:
  // Explicit because hashing a string isn't free.
  explicit CachedHashStringRef(StringRef S)
      : CachedHashStringRef(S, DenseMapInfo<StringRef>::getHashValue(S)) {}

CachedHashStringRef(StringRef S, uint32_t Hash)
      : P(S.data()), Size(S.size()), Hash(Hash) {
    assert(S.size() <= std::numeric_limits<uint32_t>::max());
  }

StringRef val() const { return StringRef(P, Size); }
  const char *data() const { return P; }
  uint32_t size() const { return Size; }
  uint32_t hash() const { return Hash; }
};

template <> struct DenseMapInfo<CachedHashStringRef> {
  static CachedHashStringRef getEmptyKey() {
    return CachedHashStringRef(DenseMapInfo<StringRef>::getEmptyKey(), 0);
  }
  static CachedHashStringRef getTombstoneKey() {
    return CachedHashStringRef(DenseMapInfo<StringRef>::getTombstoneKey(), 1);
  }
  static unsigned getHashValue(const CachedHashStringRef &S) {
    assert(!isEqual(S, getEmptyKey()) && "Cannot hash the empty key!");
    assert(!isEqual(S, getTombstoneKey()) && "Cannot hash the tombstone key!");
    return S.hash();
  }
  static bool isEqual(const CachedHashStringRef &LHS,
                      const CachedHashStringRef &RHS) {
    return LHS.hash() == RHS.hash() &&
           DenseMapInfo<StringRef>::isEqual(LHS.val(), RHS.val());
  }
};

/// A container which contains a string, which it owns, plus a precomputed hash.
///
/// We do not null-terminate the string.
class CachedHashString {
  friend struct DenseMapInfo<CachedHashString>;

char *P;
  uint32_t Size;
  uint32_t Hash;

static char *getEmptyKeyPtr() { return DenseMapInfo<char *>::getEmptyKey(); }
  static char *getTombstoneKeyPtr() {
    return DenseMapInfo<char *>::getTombstoneKey();
  }

bool isEmptyOrTombstone() const {
    return P == getEmptyKeyPtr() || P == getTombstoneKeyPtr();
  }

struct ConstructEmptyOrTombstoneTy {};

CachedHashString(ConstructEmptyOrTombstoneTy, char *EmptyOrTombstonePtr)
      : P(EmptyOrTombstonePtr), Size(0), Hash(0) {
    assert(isEmptyOrTombstone());
  }

// TODO: Use small-string optimization to avoid allocating.

public:
  explicit CachedHashString(const char *S) : CachedHashString(StringRef(S)) {}

// Explicit because copying and hashing a string isn't free.
  explicit CachedHashString(StringRef S)
      : CachedHashString(S, DenseMapInfo<StringRef>::getHashValue(S)) {}

CachedHashString(StringRef S, uint32_t Hash)
      : P(new char[S.size()]), Size(S.size()), Hash(Hash) {
    memcpy(P, S.data(), S.size());
  }

// Ideally this class would not be copyable.  But SetVector requires copyable
  // keys, and we want this to be usable there.
  CachedHashString(const CachedHashString &Other)
      : Size(Other.Size), Hash(Other.Hash) {
    if (Other.isEmptyOrTombstone()) {
      P = Other.P;
    } else {
      P = new char[Size];
      memcpy(P, Other.P, Size);
    }
  }

CachedHashString &operator=(CachedHashString Other) {
    swap(*this, Other);
    return *this;
  }

CachedHashString(CachedHashString &&Other) noexcept
      : P(Other.P), Size(Other.Size), Hash(Other.Hash) {
    Other.P = getEmptyKeyPtr();
  }

~CachedHashString() {
    if (!isEmptyOrTombstone())
      delete[] P;
  }

StringRef val() const { return StringRef(P, Size); }
  uint32_t size() const { return Size; }
  uint32_t hash() const { return Hash; }

operator StringRef() const { return val(); }
  operator CachedHashStringRef() const {
    return CachedHashStringRef(val(), Hash);
  }

friend void swap(CachedHashString &LHS, CachedHashString &RHS) {
    using std::swap;
    swap(LHS.P, RHS.P);
    swap(LHS.Size, RHS.Size);
    swap(LHS.Hash, RHS.Hash);
  }
};

template <> struct DenseMapInfo<CachedHashString> {
  static CachedHashString getEmptyKey() {
    return CachedHashString(CachedHashString::ConstructEmptyOrTombstoneTy(),
                            CachedHashString::getEmptyKeyPtr());
  }
  static CachedHashString getTombstoneKey() {
    return CachedHashString(CachedHashString::ConstructEmptyOrTombstoneTy(),
                            CachedHashString::getTombstoneKeyPtr());
  }
  static unsigned getHashValue(const CachedHashString &S) {
    assert(!isEqual(S, getEmptyKey()) && "Cannot hash the empty key!");
    assert(!isEqual(S, getTombstoneKey()) && "Cannot hash the tombstone key!");
    return S.hash();
  }
  static bool isEqual(const CachedHashString &LHS,
                      const CachedHashString &RHS) {
    if (LHS.hash() != RHS.hash())
      return false;
    if (LHS.P == CachedHashString::getEmptyKeyPtr())
      return RHS.P == CachedHashString::getEmptyKeyPtr();
    if (LHS.P == CachedHashString::getTombstoneKeyPtr())
      return RHS.P == CachedHashString::getTombstoneKeyPtr();

// This is safe because if RHS.P is the empty or tombstone key, it will have
    // length 0, so we'll never dereference its pointer.
    return LHS.val() == RHS.val();
  }
};

} // namespace llvm

#endif

003 File Manager

Editing: CachedHashString.h

Upload File

Create Folder