mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 18:54:02 +01:00
[ADT] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC).
llvm-svn: 305326
This commit is contained in:
Eugene Zelenko
parent
2e89269c45
commit
0c3f2cbd1c
@ -10,10 +10,16 @@
|
||||
#ifndef LLVM_ADT_ALLOCATORLIST_H
|
||||
#define LLVM_ADT_ALLOCATORLIST_H
|
||||
|
||||
#include "llvm/ADT/ilist_node.h"
|
||||
#include "llvm/ADT/iterator.h"
|
||||
#include "llvm/ADT/simple_ilist.h"
|
||||
#include "llvm/Support/Allocator.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -39,7 +45,8 @@ template <class T, class AllocatorT> class AllocatorList : AllocatorT {
|
||||
T V;
|
||||
};
|
||||
|
||||
typedef simple_ilist<Node> list_type;
|
||||
using list_type = simple_ilist<Node>;
|
||||
|
||||
list_type List;
|
||||
|
||||
AllocatorT &getAlloc() { return *this; }
|
||||
@ -51,13 +58,17 @@ template <class T, class AllocatorT> class AllocatorList : AllocatorT {
|
||||
|
||||
struct Cloner {
|
||||
AllocatorList &AL;
|
||||
|
||||
Cloner(AllocatorList &AL) : AL(AL) {}
|
||||
|
||||
Node *operator()(const Node &N) const { return AL.create(N.V); }
|
||||
};
|
||||
|
||||
struct Disposer {
|
||||
AllocatorList &AL;
|
||||
|
||||
Disposer(AllocatorList &AL) : AL(AL) {}
|
||||
|
||||
void operator()(Node *N) const {
|
||||
N->~Node();
|
||||
AL.getAlloc().Deallocate(N);
|
||||
@ -65,13 +76,13 @@ template <class T, class AllocatorT> class AllocatorList : AllocatorT {
|
||||
};
|
||||
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef T *pointer;
|
||||
typedef T &reference;
|
||||
typedef const T *const_pointer;
|
||||
typedef const T &const_reference;
|
||||
typedef typename list_type::size_type size_type;
|
||||
typedef typename list_type::difference_type difference_type;
|
||||
using value_type = T;
|
||||
using pointer = T *;
|
||||
using reference = T &;
|
||||
using const_pointer = const T *;
|
||||
using const_reference = const T &;
|
||||
using size_type = typename list_type::size_type;
|
||||
using difference_type = typename list_type::difference_type;
|
||||
|
||||
private:
|
||||
template <class ValueT, class IteratorBase>
|
||||
@ -83,20 +94,18 @@ private:
|
||||
friend class IteratorImpl;
|
||||
friend AllocatorList;
|
||||
|
||||
typedef iterator_adaptor_base<IteratorImpl<ValueT, IteratorBase>,
|
||||
IteratorBase, std::bidirectional_iterator_tag,
|
||||
ValueT>
|
||||
base_type;
|
||||
using base_type =
|
||||
iterator_adaptor_base<IteratorImpl<ValueT, IteratorBase>, IteratorBase,
|
||||
std::bidirectional_iterator_tag, ValueT>;
|
||||
|
||||
public:
|
||||
typedef ValueT value_type;
|
||||
typedef ValueT *pointer;
|
||||
typedef ValueT &reference;
|
||||
using value_type = ValueT;
|
||||
using pointer = ValueT *;
|
||||
using reference = ValueT &;
|
||||
|
||||
IteratorImpl() = default;
|
||||
IteratorImpl(const IteratorImpl &) = default;
|
||||
IteratorImpl &operator=(const IteratorImpl &) = default;
|
||||
~IteratorImpl() = default;
|
||||
|
||||
explicit IteratorImpl(const IteratorBase &I) : base_type(I) {}
|
||||
|
||||
@ -106,6 +115,8 @@ private:
|
||||
OtherIteratorBase, IteratorBase>::value>::type * = nullptr)
|
||||
: base_type(X.wrapped()) {}
|
||||
|
||||
~IteratorImpl() = default;
|
||||
|
||||
reference operator*() const { return base_type::wrapped()->V; }
|
||||
pointer operator->() const { return &operator*(); }
|
||||
|
||||
@ -118,30 +129,34 @@ private:
|
||||
};
|
||||
|
||||
public:
|
||||
typedef IteratorImpl<T, typename list_type::iterator> iterator;
|
||||
typedef IteratorImpl<T, typename list_type::reverse_iterator>
|
||||
reverse_iterator;
|
||||
typedef IteratorImpl<const T, typename list_type::const_iterator>
|
||||
const_iterator;
|
||||
typedef IteratorImpl<const T, typename list_type::const_reverse_iterator>
|
||||
const_reverse_iterator;
|
||||
using iterator = IteratorImpl<T, typename list_type::iterator>;
|
||||
using reverse_iterator =
|
||||
IteratorImpl<T, typename list_type::reverse_iterator>;
|
||||
using const_iterator =
|
||||
IteratorImpl<const T, typename list_type::const_iterator>;
|
||||
using const_reverse_iterator =
|
||||
IteratorImpl<const T, typename list_type::const_reverse_iterator>;
|
||||
|
||||
AllocatorList() = default;
|
||||
AllocatorList(AllocatorList &&X)
|
||||
: AllocatorT(std::move(X.getAlloc())), List(std::move(X.List)) {}
|
||||
|
||||
AllocatorList(const AllocatorList &X) {
|
||||
List.cloneFrom(X.List, Cloner(*this), Disposer(*this));
|
||||
}
|
||||
|
||||
AllocatorList &operator=(AllocatorList &&X) {
|
||||
clear(); // Dispose of current nodes explicitly.
|
||||
List = std::move(X.List);
|
||||
getAlloc() = std::move(X.getAlloc());
|
||||
return *this;
|
||||
}
|
||||
|
||||
AllocatorList &operator=(const AllocatorList &X) {
|
||||
List.cloneFrom(X.List, Cloner(*this), Disposer(*this));
|
||||
return *this;
|
||||
}
|
||||
|
||||
~AllocatorList() { clear(); }
|
||||
|
||||
void swap(AllocatorList &RHS) {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===--- ArrayRef.h - Array Reference Wrapper -------------------*- C++ -*-===//
|
||||
//===- ArrayRef.h - Array Reference Wrapper ---------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -12,12 +12,21 @@
|
||||
|
||||
#include "llvm/ADT/Hashing.h"
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <initializer_list>
|
||||
#include <iterator>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
/// ArrayRef - Represent a constant reference to an array (0 or more elements
|
||||
/// consecutively in memory), i.e. a start pointer and a length. It allows
|
||||
/// various APIs to take consecutive elements easily and conveniently.
|
||||
@ -32,28 +41,27 @@ namespace llvm {
|
||||
template<typename T>
|
||||
class LLVM_NODISCARD ArrayRef {
|
||||
public:
|
||||
typedef const T *iterator;
|
||||
typedef const T *const_iterator;
|
||||
typedef size_t size_type;
|
||||
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
using iterator = const T *;
|
||||
using const_iterator = const T *;
|
||||
using size_type = size_t;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
|
||||
private:
|
||||
/// The start of the array, in an external buffer.
|
||||
const T *Data;
|
||||
const T *Data = nullptr;
|
||||
|
||||
/// The number of elements.
|
||||
size_type Length;
|
||||
size_type Length = 0;
|
||||
|
||||
public:
|
||||
/// @name Constructors
|
||||
/// @{
|
||||
|
||||
/// Construct an empty ArrayRef.
|
||||
/*implicit*/ ArrayRef() : Data(nullptr), Length(0) {}
|
||||
/*implicit*/ ArrayRef() = default;
|
||||
|
||||
/// Construct an empty ArrayRef from None.
|
||||
/*implicit*/ ArrayRef(NoneType) : Data(nullptr), Length(0) {}
|
||||
/*implicit*/ ArrayRef(NoneType) {}
|
||||
|
||||
/// Construct an ArrayRef from a single element.
|
||||
/*implicit*/ ArrayRef(const T &OneElt)
|
||||
@ -282,9 +290,8 @@ namespace llvm {
|
||||
template<typename T>
|
||||
class LLVM_NODISCARD MutableArrayRef : public ArrayRef<T> {
|
||||
public:
|
||||
typedef T *iterator;
|
||||
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
using iterator = T *;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
|
||||
/// Construct an empty MutableArrayRef.
|
||||
/*implicit*/ MutableArrayRef() : ArrayRef<T>() {}
|
||||
@ -416,19 +423,23 @@ namespace llvm {
|
||||
/// This is a MutableArrayRef that owns its array.
|
||||
template <typename T> class OwningArrayRef : public MutableArrayRef<T> {
|
||||
public:
|
||||
OwningArrayRef() {}
|
||||
OwningArrayRef() = default;
|
||||
OwningArrayRef(size_t Size) : MutableArrayRef<T>(new T[Size], Size) {}
|
||||
|
||||
OwningArrayRef(ArrayRef<T> Data)
|
||||
: MutableArrayRef<T>(new T[Data.size()], Data.size()) {
|
||||
std::copy(Data.begin(), Data.end(), this->begin());
|
||||
}
|
||||
|
||||
OwningArrayRef(OwningArrayRef &&Other) { *this = Other; }
|
||||
|
||||
OwningArrayRef &operator=(OwningArrayRef &&Other) {
|
||||
delete[] this->data();
|
||||
this->MutableArrayRef<T>::operator=(Other);
|
||||
Other.MutableArrayRef<T>::operator=(MutableArrayRef<T>());
|
||||
return *this;
|
||||
}
|
||||
|
||||
~OwningArrayRef() { delete[] this->data(); }
|
||||
};
|
||||
|
||||
@ -517,13 +528,14 @@ namespace llvm {
|
||||
|
||||
// ArrayRefs can be treated like a POD type.
|
||||
template <typename T> struct isPodLike;
|
||||
template <typename T> struct isPodLike<ArrayRef<T> > {
|
||||
template <typename T> struct isPodLike<ArrayRef<T>> {
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
template <typename T> hash_code hash_value(ArrayRef<T> S) {
|
||||
return hash_combine_range(S.begin(), S.end());
|
||||
}
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_ADT_ARRAYREF_H
|
||||
|
||||
@ -16,6 +16,7 @@
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
@ -72,7 +73,7 @@ public:
|
||||
};
|
||||
|
||||
class BitVector {
|
||||
typedef unsigned long BitWord;
|
||||
using BitWord = unsigned long;
|
||||
|
||||
enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * CHAR_BIT };
|
||||
|
||||
@ -80,10 +81,11 @@ class BitVector {
|
||||
"Unsupported word size");
|
||||
|
||||
MutableArrayRef<BitWord> Bits; // Actual bits.
|
||||
unsigned Size; // Size of bitvector in bits.
|
||||
unsigned Size = 0; // Size of bitvector in bits.
|
||||
|
||||
public:
|
||||
typedef unsigned size_type;
|
||||
using size_type = unsigned;
|
||||
|
||||
// Encapsulation of a single bit.
|
||||
class reference {
|
||||
friend class BitVector;
|
||||
@ -118,21 +120,8 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
typedef const_set_bits_iterator_impl<BitVector> const_set_bits_iterator;
|
||||
typedef const_set_bits_iterator set_iterator;
|
||||
|
||||
const_set_bits_iterator set_bits_begin() const {
|
||||
return const_set_bits_iterator(*this);
|
||||
}
|
||||
const_set_bits_iterator set_bits_end() const {
|
||||
return const_set_bits_iterator(*this, -1);
|
||||
}
|
||||
iterator_range<const_set_bits_iterator> set_bits() const {
|
||||
return make_range(set_bits_begin(), set_bits_end());
|
||||
}
|
||||
|
||||
/// BitVector default ctor - Creates an empty bitvector.
|
||||
BitVector() : Size(0) {}
|
||||
BitVector() = default;
|
||||
|
||||
/// BitVector ctor - Creates a bitvector of specified number of bits. All
|
||||
/// bits are initialized to the specified value.
|
||||
@ -163,6 +152,21 @@ public:
|
||||
|
||||
~BitVector() { std::free(Bits.data()); }
|
||||
|
||||
using const_set_bits_iterator = const_set_bits_iterator_impl<BitVector>;
|
||||
using set_iterator = const_set_bits_iterator;
|
||||
|
||||
const_set_bits_iterator set_bits_begin() const {
|
||||
return const_set_bits_iterator(*this);
|
||||
}
|
||||
|
||||
const_set_bits_iterator set_bits_end() const {
|
||||
return const_set_bits_iterator(*this, -1);
|
||||
}
|
||||
|
||||
iterator_range<const_set_bits_iterator> set_bits() const {
|
||||
return make_range(set_bits_begin(), set_bits_end());
|
||||
}
|
||||
|
||||
/// empty - Tests whether there are no bits in this bitvector.
|
||||
bool empty() const { return Size == 0; }
|
||||
|
||||
@ -918,11 +922,13 @@ static inline size_t capacity_in_bytes(const BitVector &X) {
|
||||
} // end namespace llvm
|
||||
|
||||
namespace std {
|
||||
/// Implement std::swap in terms of BitVector swap.
|
||||
inline void
|
||||
swap(llvm::BitVector &LHS, llvm::BitVector &RHS) {
|
||||
LHS.swap(RHS);
|
||||
}
|
||||
|
||||
/// Implement std::swap in terms of BitVector swap.
|
||||
inline void
|
||||
swap(llvm::BitVector &LHS, llvm::BitVector &RHS) {
|
||||
LHS.swap(RHS);
|
||||
}
|
||||
|
||||
} // end namespace std
|
||||
|
||||
#endif // LLVM_ADT_BITVECTOR_H
|
||||
|
||||
@ -25,7 +25,6 @@
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include <iterator>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
@ -49,13 +48,13 @@ template <class GraphT,
|
||||
class bf_iterator
|
||||
: public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
|
||||
public bf_iterator_storage<SetType> {
|
||||
typedef std::iterator<std::forward_iterator_tag, typename GT::NodeRef> super;
|
||||
using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>;
|
||||
|
||||
typedef typename GT::NodeRef NodeRef;
|
||||
typedef typename GT::ChildIteratorType ChildItTy;
|
||||
using NodeRef = typename GT::NodeRef;
|
||||
using ChildItTy = typename GT::ChildIteratorType;
|
||||
|
||||
// First element is the node reference, second is the next child to visit.
|
||||
typedef std::pair<NodeRef, Optional<ChildItTy>> QueueElement;
|
||||
using QueueElement = std::pair<NodeRef, Optional<ChildItTy>>;
|
||||
|
||||
// Visit queue - used to maintain BFS ordering.
|
||||
// Optional<> because we need markers for levels.
|
||||
@ -109,7 +108,7 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
typedef typename super::pointer pointer;
|
||||
using pointer = typename super::pointer;
|
||||
|
||||
// Provide static begin and end methods as our public "constructors"
|
||||
static bf_iterator begin(const GraphT &G) {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===--- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ----*- C++ -*--===//
|
||||
//===- DAGDeltaAlgorithm.h - A DAG Minimization Algorithm ------*- C++ -*--===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -40,12 +40,12 @@ class DAGDeltaAlgorithm {
|
||||
virtual void anchor();
|
||||
|
||||
public:
|
||||
typedef unsigned change_ty;
|
||||
typedef std::pair<change_ty, change_ty> edge_ty;
|
||||
using change_ty = unsigned;
|
||||
using edge_ty = std::pair<change_ty, change_ty>;
|
||||
|
||||
// FIXME: Use a decent data structure.
|
||||
typedef std::set<change_ty> changeset_ty;
|
||||
typedef std::vector<changeset_ty> changesetlist_ty;
|
||||
using changeset_ty = std::set<change_ty>;
|
||||
using changesetlist_ty = std::vector<changeset_ty>;
|
||||
|
||||
public:
|
||||
virtual ~DAGDeltaAlgorithm() = default;
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===--- DeltaAlgorithm.h - A Set Minimization Algorithm -------*- C++ -*--===//
|
||||
//===- DeltaAlgorithm.h - A Set Minimization Algorithm ---------*- C++ -*--===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -35,10 +35,10 @@ namespace llvm {
|
||||
/// predicate.
|
||||
class DeltaAlgorithm {
|
||||
public:
|
||||
typedef unsigned change_ty;
|
||||
using change_ty = unsigned;
|
||||
// FIXME: Use a decent data structure.
|
||||
typedef std::set<change_ty> changeset_ty;
|
||||
typedef std::vector<changeset_ty> changesetlist_ty;
|
||||
using changeset_ty = std::set<change_ty>;
|
||||
using changesetlist_ty = std::vector<changeset_ty>;
|
||||
|
||||
private:
|
||||
/// Cache of failed test results. Successful test results are never cached
|
||||
@ -90,4 +90,4 @@ public:
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_DELTAALGORITHM_H
|
||||
|
||||
@ -25,8 +25,8 @@
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#include <iterator>
|
||||
#include <limits>
|
||||
#include <new>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
@ -57,14 +57,15 @@ class DenseMapBase : public DebugEpochBase {
|
||||
using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;
|
||||
|
||||
public:
|
||||
typedef unsigned size_type;
|
||||
typedef KeyT key_type;
|
||||
typedef ValueT mapped_type;
|
||||
typedef BucketT value_type;
|
||||
using size_type = unsigned;
|
||||
using key_type = KeyT;
|
||||
using mapped_type = ValueT;
|
||||
using value_type = BucketT;
|
||||
|
||||
using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
using const_iterator =
|
||||
DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
|
||||
|
||||
typedef DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT> iterator;
|
||||
typedef DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>
|
||||
const_iterator;
|
||||
inline iterator begin() {
|
||||
// When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
|
||||
return empty() ? end() : iterator(getBuckets(), getBucketsEnd(), *this);
|
||||
@ -387,15 +388,18 @@ protected:
|
||||
static unsigned getHashValue(const KeyT &Val) {
|
||||
return KeyInfoT::getHashValue(Val);
|
||||
}
|
||||
|
||||
template<typename LookupKeyT>
|
||||
static unsigned getHashValue(const LookupKeyT &Val) {
|
||||
return KeyInfoT::getHashValue(Val);
|
||||
}
|
||||
|
||||
static const KeyT getEmptyKey() {
|
||||
static_assert(std::is_base_of<DenseMapBase, DerivedT>::value,
|
||||
"Must pass the derived type to this template!");
|
||||
return KeyInfoT::getEmptyKey();
|
||||
}
|
||||
|
||||
static const KeyT getTombstoneKey() {
|
||||
return KeyInfoT::getTombstoneKey();
|
||||
}
|
||||
@ -404,39 +408,51 @@ private:
|
||||
unsigned getNumEntries() const {
|
||||
return static_cast<const DerivedT *>(this)->getNumEntries();
|
||||
}
|
||||
|
||||
void setNumEntries(unsigned Num) {
|
||||
static_cast<DerivedT *>(this)->setNumEntries(Num);
|
||||
}
|
||||
|
||||
void incrementNumEntries() {
|
||||
setNumEntries(getNumEntries() + 1);
|
||||
}
|
||||
|
||||
void decrementNumEntries() {
|
||||
setNumEntries(getNumEntries() - 1);
|
||||
}
|
||||
|
||||
unsigned getNumTombstones() const {
|
||||
return static_cast<const DerivedT *>(this)->getNumTombstones();
|
||||
}
|
||||
|
||||
void setNumTombstones(unsigned Num) {
|
||||
static_cast<DerivedT *>(this)->setNumTombstones(Num);
|
||||
}
|
||||
|
||||
void incrementNumTombstones() {
|
||||
setNumTombstones(getNumTombstones() + 1);
|
||||
}
|
||||
|
||||
void decrementNumTombstones() {
|
||||
setNumTombstones(getNumTombstones() - 1);
|
||||
}
|
||||
|
||||
const BucketT *getBuckets() const {
|
||||
return static_cast<const DerivedT *>(this)->getBuckets();
|
||||
}
|
||||
|
||||
BucketT *getBuckets() {
|
||||
return static_cast<DerivedT *>(this)->getBuckets();
|
||||
}
|
||||
|
||||
unsigned getNumBuckets() const {
|
||||
return static_cast<const DerivedT *>(this)->getNumBuckets();
|
||||
}
|
||||
|
||||
BucketT *getBucketsEnd() {
|
||||
return getBuckets() + getNumBuckets();
|
||||
}
|
||||
|
||||
const BucketT *getBucketsEnd() const {
|
||||
return getBuckets() + getNumBuckets();
|
||||
}
|
||||
@ -587,10 +603,11 @@ template <typename KeyT, typename ValueT,
|
||||
typename BucketT = detail::DenseMapPair<KeyT, ValueT>>
|
||||
class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
|
||||
KeyT, ValueT, KeyInfoT, BucketT> {
|
||||
friend class DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
|
||||
// Lift some types from the dependent base class into this class for
|
||||
// simplicity of referring to them.
|
||||
typedef DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT> BaseT;
|
||||
friend class DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
|
||||
BucketT *Buckets;
|
||||
unsigned NumEntries;
|
||||
@ -705,6 +722,7 @@ private:
|
||||
unsigned getNumEntries() const {
|
||||
return NumEntries;
|
||||
}
|
||||
|
||||
void setNumEntries(unsigned Num) {
|
||||
NumEntries = Num;
|
||||
}
|
||||
@ -712,6 +730,7 @@ private:
|
||||
unsigned getNumTombstones() const {
|
||||
return NumTombstones;
|
||||
}
|
||||
|
||||
void setNumTombstones(unsigned Num) {
|
||||
NumTombstones = Num;
|
||||
}
|
||||
@ -743,10 +762,12 @@ class SmallDenseMap
|
||||
: public DenseMapBase<
|
||||
SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
|
||||
ValueT, KeyInfoT, BucketT> {
|
||||
friend class DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
|
||||
// Lift some types from the dependent base class into this class for
|
||||
// simplicity of referring to them.
|
||||
typedef DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT> BaseT;
|
||||
friend class DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
using BaseT = DenseMapBase<SmallDenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
|
||||
|
||||
static_assert(isPowerOf2_64(InlineBuckets),
|
||||
"InlineBuckets must be a power of 2.");
|
||||
|
||||
@ -972,6 +993,7 @@ private:
|
||||
unsigned getNumEntries() const {
|
||||
return NumEntries;
|
||||
}
|
||||
|
||||
void setNumEntries(unsigned Num) {
|
||||
// NumEntries is hardcoded to be 31 bits wide.
|
||||
assert(Num < (1U << 31) && "Cannot support more than 1<<31 entries");
|
||||
@ -981,6 +1003,7 @@ private:
|
||||
unsigned getNumTombstones() const {
|
||||
return NumTombstones;
|
||||
}
|
||||
|
||||
void setNumTombstones(unsigned Num) {
|
||||
NumTombstones = Num;
|
||||
}
|
||||
@ -992,15 +1015,18 @@ private:
|
||||
// 'storage.buffer' static type is 'char *'.
|
||||
return reinterpret_cast<const BucketT *>(storage.buffer);
|
||||
}
|
||||
|
||||
BucketT *getInlineBuckets() {
|
||||
return const_cast<BucketT *>(
|
||||
const_cast<const SmallDenseMap *>(this)->getInlineBuckets());
|
||||
}
|
||||
|
||||
const LargeRep *getLargeRep() const {
|
||||
assert(!Small);
|
||||
// Note, same rule about aliasing as with getInlineBuckets.
|
||||
return reinterpret_cast<const LargeRep *>(storage.buffer);
|
||||
}
|
||||
|
||||
LargeRep *getLargeRep() {
|
||||
return const_cast<LargeRep *>(
|
||||
const_cast<const SmallDenseMap *>(this)->getLargeRep());
|
||||
@ -1009,10 +1035,12 @@ private:
|
||||
const BucketT *getBuckets() const {
|
||||
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
|
||||
}
|
||||
|
||||
BucketT *getBuckets() {
|
||||
return const_cast<BucketT *>(
|
||||
const_cast<const SmallDenseMap *>(this)->getBuckets());
|
||||
}
|
||||
|
||||
unsigned getNumBuckets() const {
|
||||
return Small ? InlineBuckets : getLargeRep()->NumBuckets;
|
||||
}
|
||||
@ -1037,23 +1065,25 @@ private:
|
||||
template <typename KeyT, typename ValueT, typename KeyInfoT, typename Bucket,
|
||||
bool IsConst>
|
||||
class DenseMapIterator : DebugEpochBase::HandleBase {
|
||||
typedef DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true> ConstIterator;
|
||||
friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
|
||||
friend class DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, false>;
|
||||
|
||||
using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
|
||||
|
||||
public:
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef typename std::conditional<IsConst, const Bucket, Bucket>::type
|
||||
value_type;
|
||||
typedef value_type *pointer;
|
||||
typedef value_type &reference;
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
using difference_type = ptrdiff_t;
|
||||
using value_type =
|
||||
typename std::conditional<IsConst, const Bucket, Bucket>::type;
|
||||
using pointer = value_type *;
|
||||
using reference = value_type &;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
private:
|
||||
pointer Ptr, End;
|
||||
pointer Ptr = nullptr;
|
||||
pointer End = nullptr;
|
||||
|
||||
public:
|
||||
DenseMapIterator() : Ptr(nullptr), End(nullptr) {}
|
||||
DenseMapIterator() = default;
|
||||
|
||||
DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
|
||||
bool NoAdvance = false)
|
||||
|
||||
@ -18,7 +18,10 @@
|
||||
#include "llvm/ADT/Hashing.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Support/PointerLikeTypeTraits.h"
|
||||
#include "llvm/Support/type_traits.h"
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -38,15 +41,18 @@ struct DenseMapInfo<T*> {
|
||||
Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
|
||||
return reinterpret_cast<T*>(Val);
|
||||
}
|
||||
|
||||
static inline T* getTombstoneKey() {
|
||||
uintptr_t Val = static_cast<uintptr_t>(-2);
|
||||
Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
|
||||
return reinterpret_cast<T*>(Val);
|
||||
}
|
||||
|
||||
static unsigned getHashValue(const T *PtrVal) {
|
||||
return (unsigned((uintptr_t)PtrVal) >> 4) ^
|
||||
(unsigned((uintptr_t)PtrVal) >> 9);
|
||||
}
|
||||
|
||||
static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
|
||||
};
|
||||
|
||||
@ -55,6 +61,7 @@ template<> struct DenseMapInfo<char> {
|
||||
static inline char getEmptyKey() { return ~0; }
|
||||
static inline char getTombstoneKey() { return ~0 - 1; }
|
||||
static unsigned getHashValue(const char& Val) { return Val * 37U; }
|
||||
|
||||
static bool isEqual(const char &LHS, const char &RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -65,6 +72,7 @@ template <> struct DenseMapInfo<unsigned short> {
|
||||
static inline unsigned short getEmptyKey() { return 0xFFFF; }
|
||||
static inline unsigned short getTombstoneKey() { return 0xFFFF - 1; }
|
||||
static unsigned getHashValue(const unsigned short &Val) { return Val * 37U; }
|
||||
|
||||
static bool isEqual(const unsigned short &LHS, const unsigned short &RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -75,6 +83,7 @@ template<> struct DenseMapInfo<unsigned> {
|
||||
static inline unsigned getEmptyKey() { return ~0U; }
|
||||
static inline unsigned getTombstoneKey() { return ~0U - 1; }
|
||||
static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
|
||||
|
||||
static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -84,9 +93,11 @@ template<> struct DenseMapInfo<unsigned> {
|
||||
template<> struct DenseMapInfo<unsigned long> {
|
||||
static inline unsigned long getEmptyKey() { return ~0UL; }
|
||||
static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
|
||||
|
||||
static unsigned getHashValue(const unsigned long& Val) {
|
||||
return (unsigned)(Val * 37UL);
|
||||
}
|
||||
|
||||
static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -96,9 +107,11 @@ template<> struct DenseMapInfo<unsigned long> {
|
||||
template<> struct DenseMapInfo<unsigned long long> {
|
||||
static inline unsigned long long getEmptyKey() { return ~0ULL; }
|
||||
static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
|
||||
|
||||
static unsigned getHashValue(const unsigned long long& Val) {
|
||||
return (unsigned)(Val * 37ULL);
|
||||
}
|
||||
|
||||
static bool isEqual(const unsigned long long& LHS,
|
||||
const unsigned long long& RHS) {
|
||||
return LHS == RHS;
|
||||
@ -118,6 +131,7 @@ template<> struct DenseMapInfo<int> {
|
||||
static inline int getEmptyKey() { return 0x7fffffff; }
|
||||
static inline int getTombstoneKey() { return -0x7fffffff - 1; }
|
||||
static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
|
||||
|
||||
static bool isEqual(const int& LHS, const int& RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -128,10 +142,13 @@ template<> struct DenseMapInfo<long> {
|
||||
static inline long getEmptyKey() {
|
||||
return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
|
||||
}
|
||||
|
||||
static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
|
||||
|
||||
static unsigned getHashValue(const long& Val) {
|
||||
return (unsigned)(Val * 37UL);
|
||||
}
|
||||
|
||||
static bool isEqual(const long& LHS, const long& RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
@ -141,9 +158,11 @@ template<> struct DenseMapInfo<long> {
|
||||
template<> struct DenseMapInfo<long long> {
|
||||
static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
|
||||
static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
|
||||
|
||||
static unsigned getHashValue(const long long& Val) {
|
||||
return (unsigned)(Val * 37ULL);
|
||||
}
|
||||
|
||||
static bool isEqual(const long long& LHS,
|
||||
const long long& RHS) {
|
||||
return LHS == RHS;
|
||||
@ -152,19 +171,21 @@ template<> struct DenseMapInfo<long long> {
|
||||
|
||||
// Provide DenseMapInfo for all pairs whose members have info.
|
||||
template<typename T, typename U>
|
||||
struct DenseMapInfo<std::pair<T, U> > {
|
||||
typedef std::pair<T, U> Pair;
|
||||
typedef DenseMapInfo<T> FirstInfo;
|
||||
typedef DenseMapInfo<U> SecondInfo;
|
||||
struct DenseMapInfo<std::pair<T, U>> {
|
||||
using Pair = std::pair<T, U>;
|
||||
using FirstInfo = DenseMapInfo<T>;
|
||||
using SecondInfo = DenseMapInfo<U>;
|
||||
|
||||
static inline Pair getEmptyKey() {
|
||||
return std::make_pair(FirstInfo::getEmptyKey(),
|
||||
SecondInfo::getEmptyKey());
|
||||
}
|
||||
|
||||
static inline Pair getTombstoneKey() {
|
||||
return std::make_pair(FirstInfo::getTombstoneKey(),
|
||||
SecondInfo::getTombstoneKey());
|
||||
}
|
||||
|
||||
static unsigned getHashValue(const Pair& PairVal) {
|
||||
uint64_t key = (uint64_t)FirstInfo::getHashValue(PairVal.first) << 32
|
||||
| (uint64_t)SecondInfo::getHashValue(PairVal.second);
|
||||
@ -178,6 +199,7 @@ struct DenseMapInfo<std::pair<T, U> > {
|
||||
key ^= (key >> 31);
|
||||
return (unsigned)key;
|
||||
}
|
||||
|
||||
static bool isEqual(const Pair &LHS, const Pair &RHS) {
|
||||
return FirstInfo::isEqual(LHS.first, RHS.first) &&
|
||||
SecondInfo::isEqual(LHS.second, RHS.second);
|
||||
@ -190,16 +212,19 @@ template <> struct DenseMapInfo<StringRef> {
|
||||
return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)),
|
||||
0);
|
||||
}
|
||||
|
||||
static inline StringRef getTombstoneKey() {
|
||||
return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)),
|
||||
0);
|
||||
}
|
||||
|
||||
static unsigned getHashValue(StringRef Val) {
|
||||
assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
|
||||
assert(Val.data() != getTombstoneKey().data() &&
|
||||
"Cannot hash the tombstone key!");
|
||||
return (unsigned)(hash_value(Val));
|
||||
}
|
||||
|
||||
static bool isEqual(StringRef LHS, StringRef RHS) {
|
||||
if (RHS.data() == getEmptyKey().data())
|
||||
return LHS.data() == getEmptyKey().data();
|
||||
@ -215,16 +240,19 @@ template <typename T> struct DenseMapInfo<ArrayRef<T>> {
|
||||
return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)),
|
||||
size_t(0));
|
||||
}
|
||||
|
||||
static inline ArrayRef<T> getTombstoneKey() {
|
||||
return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)),
|
||||
size_t(0));
|
||||
}
|
||||
|
||||
static unsigned getHashValue(ArrayRef<T> Val) {
|
||||
assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
|
||||
assert(Val.data() != getTombstoneKey().data() &&
|
||||
"Cannot hash the tombstone key!");
|
||||
return (unsigned)(hash_value(Val));
|
||||
}
|
||||
|
||||
static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) {
|
||||
if (RHS.data() == getEmptyKey().data())
|
||||
return LHS.data() == getEmptyKey().data();
|
||||
@ -236,4 +264,4 @@ template <typename T> struct DenseMapInfo<ArrayRef<T>> {
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_DENSEMAPINFO_H
|
||||
|
||||
@ -15,11 +15,18 @@
|
||||
#define LLVM_ADT_DENSESET_H
|
||||
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/DenseMapInfo.h"
|
||||
#include "llvm/Support/type_traits.h"
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <initializer_list>
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct DenseSetEmpty {};
|
||||
|
||||
// Use the empty base class trick so we can create a DenseMap where the buckets
|
||||
@ -48,13 +55,14 @@ class DenseSetImpl {
|
||||
static_assert(sizeof(typename MapTy::value_type) == sizeof(ValueT),
|
||||
"DenseMap buckets unexpectedly large!");
|
||||
MapTy TheMap;
|
||||
|
||||
template <typename T>
|
||||
using const_arg_type_t = typename const_pointer_or_const_ref<T>::type;
|
||||
|
||||
public:
|
||||
typedef ValueT key_type;
|
||||
typedef ValueT value_type;
|
||||
typedef unsigned size_type;
|
||||
using key_type = ValueT;
|
||||
using value_type = ValueT;
|
||||
using size_type = unsigned;
|
||||
|
||||
explicit DenseSetImpl(unsigned InitialReserve = 0) : TheMap(InitialReserve) {}
|
||||
|
||||
@ -100,11 +108,11 @@ public:
|
||||
friend class ConstIterator;
|
||||
|
||||
public:
|
||||
typedef typename MapTy::iterator::difference_type difference_type;
|
||||
typedef ValueT value_type;
|
||||
typedef value_type *pointer;
|
||||
typedef value_type &reference;
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
using difference_type = typename MapTy::iterator::difference_type;
|
||||
using value_type = ValueT;
|
||||
using pointer = value_type *;
|
||||
using reference = value_type &;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
Iterator() = default;
|
||||
Iterator(const typename MapTy::iterator &i) : I(i) {}
|
||||
@ -126,16 +134,14 @@ public:
|
||||
friend class Iterator;
|
||||
|
||||
public:
|
||||
typedef typename MapTy::const_iterator::difference_type difference_type;
|
||||
typedef ValueT value_type;
|
||||
typedef value_type *pointer;
|
||||
typedef value_type &reference;
|
||||
typedef std::forward_iterator_tag iterator_category;
|
||||
|
||||
ConstIterator(const Iterator &B) : I(B.I) {}
|
||||
using difference_type = typename MapTy::const_iterator::difference_type;
|
||||
using value_type = ValueT;
|
||||
using pointer = value_type *;
|
||||
using reference = value_type &;
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
|
||||
ConstIterator() = default;
|
||||
|
||||
ConstIterator(const Iterator &B) : I(B.I) {}
|
||||
ConstIterator(const typename MapTy::const_iterator &i) : I(i) {}
|
||||
|
||||
const ValueT &operator*() const { return I->getFirst(); }
|
||||
@ -147,8 +153,8 @@ public:
|
||||
bool operator!=(const ConstIterator& X) const { return I != X.I; }
|
||||
};
|
||||
|
||||
typedef Iterator iterator;
|
||||
typedef ConstIterator const_iterator;
|
||||
using iterator = Iterator;
|
||||
using const_iterator = ConstIterator;
|
||||
|
||||
iterator begin() { return Iterator(TheMap.begin()); }
|
||||
iterator end() { return Iterator(TheMap.end()); }
|
||||
@ -208,7 +214,7 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // end namespace detail
|
||||
|
||||
/// Implements a dense probed hash-table based set.
|
||||
template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
|
||||
@ -246,4 +252,4 @@ public:
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_DENSESET_H
|
||||
|
||||
@ -68,13 +68,14 @@ public:
|
||||
// cross edges in the spanning tree but is not used in the common case.
|
||||
template <typename NodeRef, unsigned SmallSize=8>
|
||||
struct df_iterator_default_set : public SmallPtrSet<NodeRef, SmallSize> {
|
||||
typedef SmallPtrSet<NodeRef, SmallSize> BaseSet;
|
||||
typedef typename BaseSet::iterator iterator;
|
||||
std::pair<iterator,bool> insert(NodeRef N) { return BaseSet::insert(N) ; }
|
||||
using BaseSet = SmallPtrSet<NodeRef, SmallSize>;
|
||||
using iterator = typename BaseSet::iterator;
|
||||
|
||||
std::pair<iterator,bool> insert(NodeRef N) { return BaseSet::insert(N); }
|
||||
template <typename IterT>
|
||||
void insert(IterT Begin, IterT End) { BaseSet::insert(Begin,End); }
|
||||
|
||||
void completed(NodeRef) { }
|
||||
void completed(NodeRef) {}
|
||||
};
|
||||
|
||||
// Generic Depth First Iterator
|
||||
@ -85,15 +86,14 @@ template <class GraphT,
|
||||
class df_iterator
|
||||
: public std::iterator<std::forward_iterator_tag, typename GT::NodeRef>,
|
||||
public df_iterator_storage<SetType, ExtStorage> {
|
||||
typedef std::iterator<std::forward_iterator_tag, typename GT::NodeRef> super;
|
||||
|
||||
typedef typename GT::NodeRef NodeRef;
|
||||
typedef typename GT::ChildIteratorType ChildItTy;
|
||||
using super = std::iterator<std::forward_iterator_tag, typename GT::NodeRef>;
|
||||
using NodeRef = typename GT::NodeRef;
|
||||
using ChildItTy = typename GT::ChildIteratorType;
|
||||
|
||||
// First element is node reference, second is the 'next child' to visit.
|
||||
// The second child is initialized lazily to pick up graph changes during the
|
||||
// DFS.
|
||||
typedef std::pair<NodeRef, Optional<ChildItTy>> StackElement;
|
||||
using StackElement = std::pair<NodeRef, Optional<ChildItTy>>;
|
||||
|
||||
// VisitStack - Used to maintain the ordering. Top = current block
|
||||
std::vector<StackElement> VisitStack;
|
||||
@ -103,12 +103,15 @@ private:
|
||||
this->Visited.insert(Node);
|
||||
VisitStack.push_back(StackElement(Node, None));
|
||||
}
|
||||
|
||||
inline df_iterator() = default; // End is when stack is empty
|
||||
|
||||
inline df_iterator(NodeRef Node, SetType &S)
|
||||
: df_iterator_storage<SetType, ExtStorage>(S) {
|
||||
if (this->Visited.insert(Node).second)
|
||||
VisitStack.push_back(StackElement(Node, None));
|
||||
}
|
||||
|
||||
inline df_iterator(SetType &S)
|
||||
: df_iterator_storage<SetType, ExtStorage>(S) {
|
||||
// End is when stack is empty
|
||||
@ -142,7 +145,7 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
typedef typename super::pointer pointer;
|
||||
using pointer = typename super::pointer;
|
||||
|
||||
// Provide static begin and end methods as our public "constructors"
|
||||
static df_iterator begin(const GraphT &G) {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- llvm/ADT/EquivalenceClasses.h - Generic Equiv. Classes --*- C++ -*-===//
|
||||
//===- llvm/ADT/EquivalenceClasses.h - Generic Equiv. Classes ---*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -69,6 +69,7 @@ class EquivalenceClasses {
|
||||
/// leader is determined by a bit stolen from one of the pointers.
|
||||
class ECValue {
|
||||
friend class EquivalenceClasses;
|
||||
|
||||
mutable const ECValue *Leader, *Next;
|
||||
ElemTy Data;
|
||||
|
||||
@ -141,14 +142,14 @@ public:
|
||||
//
|
||||
|
||||
/// iterator* - Provides a way to iterate over all values in the set.
|
||||
typedef typename std::set<ECValue>::const_iterator iterator;
|
||||
using iterator = typename std::set<ECValue>::const_iterator;
|
||||
|
||||
iterator begin() const { return TheMapping.begin(); }
|
||||
iterator end() const { return TheMapping.end(); }
|
||||
|
||||
bool empty() const { return TheMapping.empty(); }
|
||||
|
||||
/// member_* Iterate over the members of an equivalence class.
|
||||
///
|
||||
class member_iterator;
|
||||
member_iterator member_begin(iterator I) const {
|
||||
// Only leaders provide anything to iterate over.
|
||||
@ -204,7 +205,6 @@ public:
|
||||
/// equivalence class it is in. This does the path-compression part that
|
||||
/// makes union-find "union findy". This returns an end iterator if the value
|
||||
/// is not in the equivalence class.
|
||||
///
|
||||
member_iterator findLeader(iterator I) const {
|
||||
if (I == TheMapping.end()) return member_end();
|
||||
return member_iterator(I->getLeader());
|
||||
@ -241,15 +241,17 @@ public:
|
||||
|
||||
class member_iterator : public std::iterator<std::forward_iterator_tag,
|
||||
const ElemTy, ptrdiff_t> {
|
||||
typedef std::iterator<std::forward_iterator_tag,
|
||||
const ElemTy, ptrdiff_t> super;
|
||||
const ECValue *Node;
|
||||
friend class EquivalenceClasses;
|
||||
|
||||
using super = std::iterator<std::forward_iterator_tag,
|
||||
const ElemTy, ptrdiff_t>;
|
||||
|
||||
const ECValue *Node;
|
||||
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
typedef typename super::pointer pointer;
|
||||
typedef typename super::reference reference;
|
||||
using size_type = size_t;
|
||||
using pointer = typename super::pointer;
|
||||
using reference = typename super::reference;
|
||||
|
||||
explicit member_iterator() = default;
|
||||
explicit member_iterator(const ECValue *N) : Node(N) {}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- llvm/ADT/GraphTraits.h - Graph traits template ----------*- C++ -*-===//
|
||||
//===- llvm/ADT/GraphTraits.h - Graph traits template -----------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -41,7 +41,6 @@ struct GraphTraits {
|
||||
// static ChildIteratorType child_end (NodeRef)
|
||||
// Return iterators that point to the beginning and ending of the child
|
||||
// node list for the specified node.
|
||||
//
|
||||
|
||||
// typedef ...iterator nodes_iterator; - dereference to a NodeRef
|
||||
// static nodes_iterator nodes_begin(GraphType *G)
|
||||
@ -50,7 +49,6 @@ struct GraphTraits {
|
||||
|
||||
// static unsigned size (GraphType *G)
|
||||
// Return total number of nodes in the graph
|
||||
//
|
||||
|
||||
// If anyone tries to use this class without having an appropriate
|
||||
// specialization, make an error. If you get this error, it's because you
|
||||
@ -58,11 +56,9 @@ struct GraphTraits {
|
||||
// graph, or you need to define it for a new graph type. Either that or
|
||||
// your argument to XXX_begin(...) is unknown or needs to have the proper .h
|
||||
// file #include'd.
|
||||
//
|
||||
typedef typename GraphType::UnknownGraphTypeError NodeRef;
|
||||
using NodeRef = typename GraphType::UnknownGraphTypeError;
|
||||
};
|
||||
|
||||
|
||||
// Inverse - This class is used as a little marker class to tell the graph
|
||||
// iterator to iterate over the graph in a graph defined "Inverse" ordering.
|
||||
// Not all graphs define an inverse ordering, and if they do, it depends on
|
||||
@ -73,7 +69,7 @@ struct GraphTraits {
|
||||
// for (; I != E; ++I) { ... }
|
||||
//
|
||||
// Which is equivalent to:
|
||||
// df_iterator<Inverse<Method*> > I = idf_begin(M), E = idf_end(M);
|
||||
// df_iterator<Inverse<Method*>> I = idf_begin(M), E = idf_end(M);
|
||||
// for (; I != E; ++I) { ... }
|
||||
//
|
||||
template <class GraphType>
|
||||
@ -114,6 +110,7 @@ inverse_children(const typename GraphTraits<GraphType>::NodeRef &G) {
|
||||
return make_range(GraphTraits<Inverse<GraphType>>::child_begin(G),
|
||||
GraphTraits<Inverse<GraphType>>::child_end(G));
|
||||
}
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_ADT_GRAPHTRAITS_H
|
||||
|
||||
@ -109,6 +109,7 @@ private:
|
||||
ScopedHashTableVal<K, V> *getLastValInScope() {
|
||||
return LastValInScope;
|
||||
}
|
||||
|
||||
void setLastValInScope(ScopedHashTableVal<K, V> *Val) {
|
||||
LastValInScope = Val;
|
||||
}
|
||||
@ -151,13 +152,14 @@ class ScopedHashTable {
|
||||
public:
|
||||
/// ScopeTy - This is a helpful typedef that allows clients to get easy access
|
||||
/// to the name of the scope for this hash table.
|
||||
typedef ScopedHashTableScope<K, V, KInfo, AllocatorTy> ScopeTy;
|
||||
typedef unsigned size_type;
|
||||
using ScopeTy = ScopedHashTableScope<K, V, KInfo, AllocatorTy>;
|
||||
using size_type = unsigned;
|
||||
|
||||
private:
|
||||
friend class ScopedHashTableScope<K, V, KInfo, AllocatorTy>;
|
||||
|
||||
typedef ScopedHashTableVal<K, V> ValTy;
|
||||
using ValTy = ScopedHashTableVal<K, V>;
|
||||
|
||||
DenseMap<K, ValTy*, KInfo> TopLevelMap;
|
||||
ScopeTy *CurScope = nullptr;
|
||||
|
||||
@ -165,7 +167,7 @@ private:
|
||||
|
||||
public:
|
||||
ScopedHashTable() = default;
|
||||
ScopedHashTable(AllocatorTy A) : CurScope(0), Allocator(A) {}
|
||||
ScopedHashTable(AllocatorTy A) : Allocator(A) {}
|
||||
ScopedHashTable(const ScopedHashTable &) = delete;
|
||||
ScopedHashTable &operator=(const ScopedHashTable &) = delete;
|
||||
|
||||
@ -194,7 +196,7 @@ public:
|
||||
insertIntoScope(CurScope, Key, Val);
|
||||
}
|
||||
|
||||
typedef ScopedHashTableIterator<K, V, KInfo> iterator;
|
||||
using iterator = ScopedHashTableIterator<K, V, KInfo>;
|
||||
|
||||
iterator end() { return iterator(0); }
|
||||
|
||||
|
||||
@ -15,8 +15,15 @@
|
||||
#define LLVM_ADT_SMALLBITVECTOR_H
|
||||
|
||||
#include "llvm/ADT/BitVector.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -29,7 +36,7 @@ class SmallBitVector {
|
||||
// TODO: In "large" mode, a pointer to a BitVector is used, leading to an
|
||||
// unnecessary level of indirection. It would be more efficient to use a
|
||||
// pointer to memory containing size, allocation size, and the array of bits.
|
||||
uintptr_t X;
|
||||
uintptr_t X = 1;
|
||||
|
||||
enum {
|
||||
// The number of bits in this class.
|
||||
@ -54,7 +61,8 @@ class SmallBitVector {
|
||||
"Unsupported word size");
|
||||
|
||||
public:
|
||||
typedef unsigned size_type;
|
||||
using size_type = unsigned;
|
||||
|
||||
// Encapsulation of a single bit.
|
||||
class reference {
|
||||
SmallBitVector &TheVector;
|
||||
@ -134,21 +142,8 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
typedef const_set_bits_iterator_impl<SmallBitVector> const_set_bits_iterator;
|
||||
typedef const_set_bits_iterator set_iterator;
|
||||
|
||||
const_set_bits_iterator set_bits_begin() const {
|
||||
return const_set_bits_iterator(*this);
|
||||
}
|
||||
const_set_bits_iterator set_bits_end() const {
|
||||
return const_set_bits_iterator(*this, -1);
|
||||
}
|
||||
iterator_range<const_set_bits_iterator> set_bits() const {
|
||||
return make_range(set_bits_begin(), set_bits_end());
|
||||
}
|
||||
|
||||
/// Creates an empty bitvector.
|
||||
SmallBitVector() : X(1) {}
|
||||
SmallBitVector() = default;
|
||||
|
||||
/// Creates a bitvector of specified number of bits. All bits are initialized
|
||||
/// to the specified value.
|
||||
@ -176,6 +171,21 @@ public:
|
||||
delete getPointer();
|
||||
}
|
||||
|
||||
using const_set_bits_iterator = const_set_bits_iterator_impl<SmallBitVector>;
|
||||
using set_iterator = const_set_bits_iterator;
|
||||
|
||||
const_set_bits_iterator set_bits_begin() const {
|
||||
return const_set_bits_iterator(*this);
|
||||
}
|
||||
|
||||
const_set_bits_iterator set_bits_end() const {
|
||||
return const_set_bits_iterator(*this, -1);
|
||||
}
|
||||
|
||||
iterator_range<const_set_bits_iterator> set_bits() const {
|
||||
return make_range(set_bits_begin(), set_bits_end());
|
||||
}
|
||||
|
||||
/// Tests whether there are no bits in this bitvector.
|
||||
bool empty() const {
|
||||
return isSmall() ? getSmallSize() == 0 : getPointer()->empty();
|
||||
@ -677,14 +687,16 @@ operator^(const SmallBitVector &LHS, const SmallBitVector &RHS) {
|
||||
return Result;
|
||||
}
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
namespace std {
|
||||
/// Implement std::swap in terms of BitVector swap.
|
||||
inline void
|
||||
swap(llvm::SmallBitVector &LHS, llvm::SmallBitVector &RHS) {
|
||||
LHS.swap(RHS);
|
||||
}
|
||||
|
||||
/// Implement std::swap in terms of BitVector swap.
|
||||
inline void
|
||||
swap(llvm::SmallBitVector &LHS, llvm::SmallBitVector &RHS) {
|
||||
LHS.swap(RHS);
|
||||
}
|
||||
|
||||
#endif
|
||||
} // end namespace std
|
||||
|
||||
#endif // LLVM_ADT_SMALLBITVECTOR_H
|
||||
|
||||
@ -39,8 +39,9 @@ class SmallSet {
|
||||
/// we will never use.
|
||||
SmallVector<T, N> Vector;
|
||||
std::set<T, C> Set;
|
||||
typedef typename SmallVector<T, N>::const_iterator VIterator;
|
||||
typedef typename SmallVector<T, N>::iterator mutable_iterator;
|
||||
|
||||
using VIterator = typename SmallVector<T, N>::const_iterator;
|
||||
using mutable_iterator = typename SmallVector<T, N>::iterator;
|
||||
|
||||
// In small mode SmallPtrSet uses linear search for the elements, so it is
|
||||
// not a good idea to choose this value too high. You may consider using a
|
||||
@ -48,7 +49,7 @@ class SmallSet {
|
||||
static_assert(N <= 32, "N should be small");
|
||||
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
using size_type = size_t;
|
||||
|
||||
SmallSet() = default;
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- llvm/ADT/ilist_base.h - Intrusive List Base ---------------*- C++ -*-==//
|
||||
//===- llvm/ADT/ilist_base.h - Intrusive List Base --------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -12,15 +12,13 @@
|
||||
|
||||
#include "llvm/ADT/ilist_node_base.h"
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
/// Implementations of list algorithms using ilist_node_base.
|
||||
template <bool EnableSentinelTracking> class ilist_base {
|
||||
public:
|
||||
typedef ilist_node_base<EnableSentinelTracking> node_base_type;
|
||||
using node_base_type = ilist_node_base<EnableSentinelTracking>;
|
||||
|
||||
static void insertBeforeImpl(node_base_type &Next, node_base_type &N) {
|
||||
node_base_type &Prev = *Next.getPrev();
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator -------*- C++ -*-==//
|
||||
//===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator ------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -23,28 +23,30 @@ namespace ilist_detail {
|
||||
/// Find const-correct node types.
|
||||
template <class OptionsT, bool IsConst> struct IteratorTraits;
|
||||
template <class OptionsT> struct IteratorTraits<OptionsT, false> {
|
||||
typedef typename OptionsT::value_type value_type;
|
||||
typedef typename OptionsT::pointer pointer;
|
||||
typedef typename OptionsT::reference reference;
|
||||
typedef ilist_node_impl<OptionsT> *node_pointer;
|
||||
typedef ilist_node_impl<OptionsT> &node_reference;
|
||||
using value_type = typename OptionsT::value_type;
|
||||
using pointer = typename OptionsT::pointer;
|
||||
using reference = typename OptionsT::reference;
|
||||
using node_pointer = ilist_node_impl<OptionsT> *;
|
||||
using node_reference = ilist_node_impl<OptionsT> &;
|
||||
};
|
||||
template <class OptionsT> struct IteratorTraits<OptionsT, true> {
|
||||
typedef const typename OptionsT::value_type value_type;
|
||||
typedef typename OptionsT::const_pointer pointer;
|
||||
typedef typename OptionsT::const_reference reference;
|
||||
typedef const ilist_node_impl<OptionsT> *node_pointer;
|
||||
typedef const ilist_node_impl<OptionsT> &node_reference;
|
||||
using value_type = const typename OptionsT::value_type;
|
||||
using pointer = typename OptionsT::const_pointer;
|
||||
using reference = typename OptionsT::const_reference;
|
||||
using node_pointer = const ilist_node_impl<OptionsT> *;
|
||||
using node_reference = const ilist_node_impl<OptionsT> &;
|
||||
};
|
||||
|
||||
template <bool IsReverse> struct IteratorHelper;
|
||||
template <> struct IteratorHelper<false> : ilist_detail::NodeAccess {
|
||||
typedef ilist_detail::NodeAccess Access;
|
||||
using Access = ilist_detail::NodeAccess;
|
||||
|
||||
template <class T> static void increment(T *&I) { I = Access::getNext(*I); }
|
||||
template <class T> static void decrement(T *&I) { I = Access::getPrev(*I); }
|
||||
};
|
||||
template <> struct IteratorHelper<true> : ilist_detail::NodeAccess {
|
||||
typedef ilist_detail::NodeAccess Access;
|
||||
using Access = ilist_detail::NodeAccess;
|
||||
|
||||
template <class T> static void increment(T *&I) { I = Access::getPrev(*I); }
|
||||
template <class T> static void decrement(T *&I) { I = Access::getNext(*I); }
|
||||
};
|
||||
@ -58,24 +60,23 @@ class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> {
|
||||
friend ilist_iterator<OptionsT, !IsReverse, IsConst>;
|
||||
friend ilist_iterator<OptionsT, !IsReverse, !IsConst>;
|
||||
|
||||
typedef ilist_detail::IteratorTraits<OptionsT, IsConst> Traits;
|
||||
typedef ilist_detail::SpecificNodeAccess<OptionsT> Access;
|
||||
using Traits = ilist_detail::IteratorTraits<OptionsT, IsConst>;
|
||||
using Access = ilist_detail::SpecificNodeAccess<OptionsT>;
|
||||
|
||||
public:
|
||||
typedef typename Traits::value_type value_type;
|
||||
typedef typename Traits::pointer pointer;
|
||||
typedef typename Traits::reference reference;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef std::bidirectional_iterator_tag iterator_category;
|
||||
|
||||
typedef typename OptionsT::const_pointer const_pointer;
|
||||
typedef typename OptionsT::const_reference const_reference;
|
||||
using value_type = typename Traits::value_type;
|
||||
using pointer = typename Traits::pointer;
|
||||
using reference = typename Traits::reference;
|
||||
using difference_type = ptrdiff_t;
|
||||
using iterator_category = std::bidirectional_iterator_tag;
|
||||
using const_pointer = typename OptionsT::const_pointer;
|
||||
using const_reference = typename OptionsT::const_reference;
|
||||
|
||||
private:
|
||||
typedef typename Traits::node_pointer node_pointer;
|
||||
typedef typename Traits::node_reference node_reference;
|
||||
using node_pointer = typename Traits::node_pointer;
|
||||
using node_reference = typename Traits::node_reference;
|
||||
|
||||
node_pointer NodePtr;
|
||||
node_pointer NodePtr = nullptr;
|
||||
|
||||
public:
|
||||
/// Create from an ilist_node.
|
||||
@ -83,7 +84,7 @@ public:
|
||||
|
||||
explicit ilist_iterator(pointer NP) : NodePtr(Access::getNodePtr(NP)) {}
|
||||
explicit ilist_iterator(reference NR) : NodePtr(Access::getNodePtr(&NR)) {}
|
||||
ilist_iterator() : NodePtr(nullptr) {}
|
||||
ilist_iterator() = default;
|
||||
|
||||
// This is templated so that we can allow constructing a const iterator from
|
||||
// a nonconst iterator...
|
||||
@ -184,8 +185,8 @@ template <typename From> struct simplify_type;
|
||||
/// FIXME: remove this, since there is no implicit conversion to NodeTy.
|
||||
template <class OptionsT, bool IsConst>
|
||||
struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
|
||||
typedef ilist_iterator<OptionsT, false, IsConst> iterator;
|
||||
typedef typename iterator::pointer SimpleType;
|
||||
using iterator = ilist_iterator<OptionsT, false, IsConst>;
|
||||
using SimpleType = typename iterator::pointer;
|
||||
|
||||
static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; }
|
||||
};
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//==-- llvm/ADT/ilist_node.h - Intrusive Linked List Helper ------*- C++ -*-==//
|
||||
//===- llvm/ADT/ilist_node.h - Intrusive Linked List Helper -----*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -21,11 +21,10 @@
|
||||
namespace llvm {
|
||||
|
||||
namespace ilist_detail {
|
||||
struct NodeAccess;
|
||||
} // end namespace ilist_detail
|
||||
|
||||
template<typename NodeTy>
|
||||
struct ilist_traits;
|
||||
struct NodeAccess;
|
||||
|
||||
} // end namespace ilist_detail
|
||||
|
||||
template <class OptionsT, bool IsReverse, bool IsConst> class ilist_iterator;
|
||||
template <class OptionsT> class ilist_sentinel;
|
||||
@ -39,9 +38,9 @@ template <class OptionsT> class ilist_sentinel;
|
||||
/// provide type safety: you can't insert nodes of \a ilist_node_impl into the
|
||||
/// wrong \a simple_ilist or \a iplist.
|
||||
template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
|
||||
typedef typename OptionsT::value_type value_type;
|
||||
typedef typename OptionsT::node_base_type node_base_type;
|
||||
typedef typename OptionsT::list_base_type list_base_type;
|
||||
using value_type = typename OptionsT::value_type;
|
||||
using node_base_type = typename OptionsT::node_base_type;
|
||||
using list_base_type = typename OptionsT::list_base_type;
|
||||
|
||||
friend typename OptionsT::list_base_type;
|
||||
friend struct ilist_detail::NodeAccess;
|
||||
@ -52,17 +51,18 @@ template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
|
||||
friend class ilist_iterator<OptionsT, true, true>;
|
||||
|
||||
protected:
|
||||
ilist_node_impl() = default;
|
||||
using self_iterator = ilist_iterator<OptionsT, false, false>;
|
||||
using const_self_iterator = ilist_iterator<OptionsT, false, true>;
|
||||
using reverse_self_iterator = ilist_iterator<OptionsT, true, false>;
|
||||
using const_reverse_self_iterator = ilist_iterator<OptionsT, true, true>;
|
||||
|
||||
typedef ilist_iterator<OptionsT, false, false> self_iterator;
|
||||
typedef ilist_iterator<OptionsT, false, true> const_self_iterator;
|
||||
typedef ilist_iterator<OptionsT, true, false> reverse_self_iterator;
|
||||
typedef ilist_iterator<OptionsT, true, true> const_reverse_self_iterator;
|
||||
ilist_node_impl() = default;
|
||||
|
||||
private:
|
||||
ilist_node_impl *getPrev() {
|
||||
return static_cast<ilist_node_impl *>(node_base_type::getPrev());
|
||||
}
|
||||
|
||||
ilist_node_impl *getNext() {
|
||||
return static_cast<ilist_node_impl *>(node_base_type::getNext());
|
||||
}
|
||||
@ -70,6 +70,7 @@ private:
|
||||
const ilist_node_impl *getPrev() const {
|
||||
return static_cast<ilist_node_impl *>(node_base_type::getPrev());
|
||||
}
|
||||
|
||||
const ilist_node_impl *getNext() const {
|
||||
return static_cast<ilist_node_impl *>(node_base_type::getNext());
|
||||
}
|
||||
@ -80,9 +81,11 @@ private:
|
||||
public:
|
||||
self_iterator getIterator() { return self_iterator(*this); }
|
||||
const_self_iterator getIterator() const { return const_self_iterator(*this); }
|
||||
|
||||
reverse_self_iterator getReverseIterator() {
|
||||
return reverse_self_iterator(*this);
|
||||
}
|
||||
|
||||
const_reverse_self_iterator getReverseIterator() const {
|
||||
return const_reverse_self_iterator(*this);
|
||||
}
|
||||
@ -151,6 +154,7 @@ class ilist_node
|
||||
};
|
||||
|
||||
namespace ilist_detail {
|
||||
|
||||
/// An access class for ilist_node private API.
|
||||
///
|
||||
/// This gives access to the private parts of ilist nodes. Nodes for an ilist
|
||||
@ -163,15 +167,18 @@ protected:
|
||||
static ilist_node_impl<OptionsT> *getNodePtr(typename OptionsT::pointer N) {
|
||||
return N;
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static const ilist_node_impl<OptionsT> *
|
||||
getNodePtr(typename OptionsT::const_pointer N) {
|
||||
return N;
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static typename OptionsT::pointer getValuePtr(ilist_node_impl<OptionsT> *N) {
|
||||
return static_cast<typename OptionsT::pointer>(N);
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static typename OptionsT::const_pointer
|
||||
getValuePtr(const ilist_node_impl<OptionsT> *N) {
|
||||
@ -182,15 +189,18 @@ protected:
|
||||
static ilist_node_impl<OptionsT> *getPrev(ilist_node_impl<OptionsT> &N) {
|
||||
return N.getPrev();
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static ilist_node_impl<OptionsT> *getNext(ilist_node_impl<OptionsT> &N) {
|
||||
return N.getNext();
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static const ilist_node_impl<OptionsT> *
|
||||
getPrev(const ilist_node_impl<OptionsT> &N) {
|
||||
return N.getPrev();
|
||||
}
|
||||
|
||||
template <class OptionsT>
|
||||
static const ilist_node_impl<OptionsT> *
|
||||
getNext(const ilist_node_impl<OptionsT> &N) {
|
||||
@ -200,23 +210,27 @@ protected:
|
||||
|
||||
template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
|
||||
protected:
|
||||
typedef typename OptionsT::pointer pointer;
|
||||
typedef typename OptionsT::const_pointer const_pointer;
|
||||
typedef ilist_node_impl<OptionsT> node_type;
|
||||
using pointer = typename OptionsT::pointer;
|
||||
using const_pointer = typename OptionsT::const_pointer;
|
||||
using node_type = ilist_node_impl<OptionsT>;
|
||||
|
||||
static node_type *getNodePtr(pointer N) {
|
||||
return NodeAccess::getNodePtr<OptionsT>(N);
|
||||
}
|
||||
|
||||
static const node_type *getNodePtr(const_pointer N) {
|
||||
return NodeAccess::getNodePtr<OptionsT>(N);
|
||||
}
|
||||
|
||||
static pointer getValuePtr(node_type *N) {
|
||||
return NodeAccess::getValuePtr<OptionsT>(N);
|
||||
}
|
||||
|
||||
static const_pointer getValuePtr(const node_type *N) {
|
||||
return NodeAccess::getValuePtr<OptionsT>(N);
|
||||
}
|
||||
};
|
||||
|
||||
} // end namespace ilist_detail
|
||||
|
||||
template <class OptionsT>
|
||||
@ -265,6 +279,7 @@ public:
|
||||
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
|
||||
return List.getPrevNode(*static_cast<NodeTy *>(this));
|
||||
}
|
||||
|
||||
/// \brief Get the previous node, or \c nullptr for the list head.
|
||||
const NodeTy *getPrevNode() const {
|
||||
return const_cast<ilist_node_with_parent *>(this)->getPrevNode();
|
||||
@ -278,6 +293,7 @@ public:
|
||||
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
|
||||
return List.getNextNode(*static_cast<NodeTy *>(this));
|
||||
}
|
||||
|
||||
/// \brief Get the next node, or \c nullptr for the list tail.
|
||||
const NodeTy *getNextNode() const {
|
||||
return const_cast<ilist_node_with_parent *>(this)->getNextNode();
|
||||
@ -285,6 +301,6 @@ public:
|
||||
/// @}
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_ILIST_NODE_H
|
||||
|
||||
@ -11,9 +11,11 @@
|
||||
#define LLVM_ADT_ITERATOR_H
|
||||
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -206,7 +208,7 @@ template <
|
||||
class iterator_adaptor_base
|
||||
: public iterator_facade_base<DerivedT, IteratorCategoryT, T,
|
||||
DifferenceTypeT, PointerT, ReferenceT> {
|
||||
typedef typename iterator_adaptor_base::iterator_facade_base BaseT;
|
||||
using BaseT = typename iterator_adaptor_base::iterator_facade_base;
|
||||
|
||||
protected:
|
||||
WrappedIteratorT I;
|
||||
@ -221,7 +223,7 @@ protected:
|
||||
const WrappedIteratorT &wrapped() const { return I; }
|
||||
|
||||
public:
|
||||
typedef DifferenceTypeT difference_type;
|
||||
using difference_type = DifferenceTypeT;
|
||||
|
||||
DerivedT &operator+=(difference_type n) {
|
||||
static_assert(
|
||||
@ -279,7 +281,7 @@ public:
|
||||
/// which is implemented with some iterator over T*s:
|
||||
///
|
||||
/// \code
|
||||
/// typedef pointee_iterator<SmallVectorImpl<T *>::iterator> iterator;
|
||||
/// using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
|
||||
/// \endcode
|
||||
template <typename WrappedIteratorT,
|
||||
typename T = typename std::remove_reference<
|
||||
|
||||
Loading…
Reference in New Issue
Block a user