mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
[ADT] Partial re-commit of r303383. Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC).
llvm-svn: 305419
This commit is contained in:
Eugene Zelenko
parent
6d2f574331
commit
c35b5b5fe7
@ -63,8 +63,8 @@ public:
|
||||
template <typename T>
|
||||
class ImmutableList {
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef ImmutableListFactory<T> Factory;
|
||||
using value_type = T;
|
||||
using Factory = ImmutableListFactory<T>;
|
||||
|
||||
private:
|
||||
const ImmutableListImpl<T>* X;
|
||||
@ -141,8 +141,8 @@ public:
|
||||
|
||||
template <typename T>
|
||||
class ImmutableListFactory {
|
||||
typedef ImmutableListImpl<T> ListTy;
|
||||
typedef FoldingSet<ListTy> CacheTy;
|
||||
using ListTy = ImmutableListImpl<T>;
|
||||
using CacheTy = FoldingSet<ListTy>;
|
||||
|
||||
CacheTy Cache;
|
||||
uintptr_t Allocator;
|
||||
|
||||
@ -26,12 +26,12 @@ namespace llvm {
|
||||
/// only the first element (the key) is used by isEqual and isLess.
|
||||
template <typename T, typename S>
|
||||
struct ImutKeyValueInfo {
|
||||
typedef const std::pair<T,S> value_type;
|
||||
typedef const value_type& value_type_ref;
|
||||
typedef const T key_type;
|
||||
typedef const T& key_type_ref;
|
||||
typedef const S data_type;
|
||||
typedef const S& data_type_ref;
|
||||
using value_type = const std::pair<T,S>;
|
||||
using value_type_ref = const value_type&;
|
||||
using key_type = const T;
|
||||
using key_type_ref = const T&;
|
||||
using data_type = const S;
|
||||
using data_type_ref = const S&;
|
||||
|
||||
static inline key_type_ref KeyOfValue(value_type_ref V) {
|
||||
return V.first;
|
||||
@ -62,13 +62,13 @@ template <typename KeyT, typename ValT,
|
||||
typename ValInfo = ImutKeyValueInfo<KeyT,ValT>>
|
||||
class ImmutableMap {
|
||||
public:
|
||||
typedef typename ValInfo::value_type value_type;
|
||||
typedef typename ValInfo::value_type_ref value_type_ref;
|
||||
typedef typename ValInfo::key_type key_type;
|
||||
typedef typename ValInfo::key_type_ref key_type_ref;
|
||||
typedef typename ValInfo::data_type data_type;
|
||||
typedef typename ValInfo::data_type_ref data_type_ref;
|
||||
typedef ImutAVLTree<ValInfo> TreeTy;
|
||||
using value_type = typename ValInfo::value_type;
|
||||
using value_type_ref = typename ValInfo::value_type_ref;
|
||||
using key_type = typename ValInfo::key_type;
|
||||
using key_type_ref = typename ValInfo::key_type_ref;
|
||||
using data_type = typename ValInfo::data_type;
|
||||
using data_type_ref = typename ValInfo::data_type_ref;
|
||||
using TreeTy = ImutAVLTree<ValInfo>;
|
||||
|
||||
protected:
|
||||
TreeTy* Root;
|
||||
@ -86,6 +86,10 @@ public:
|
||||
if (Root) { Root->retain(); }
|
||||
}
|
||||
|
||||
~ImmutableMap() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
ImmutableMap &operator=(const ImmutableMap &X) {
|
||||
if (Root != X.Root) {
|
||||
if (X.Root) { X.Root->retain(); }
|
||||
@ -95,10 +99,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
~ImmutableMap() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
class Factory {
|
||||
typename TreeTy::Factory F;
|
||||
const bool Canonicalize;
|
||||
@ -166,12 +166,14 @@ private:
|
||||
template <typename Callback>
|
||||
struct CBWrapper {
|
||||
Callback C;
|
||||
|
||||
void operator()(value_type_ref V) { C(V.first,V.second); }
|
||||
};
|
||||
|
||||
template <typename Callback>
|
||||
struct CBWrapperRef {
|
||||
Callback &C;
|
||||
|
||||
CBWrapperRef(Callback& c) : C(c) {}
|
||||
|
||||
void operator()(value_type_ref V) { C(V.first,V.second); }
|
||||
@ -254,14 +256,14 @@ template <typename KeyT, typename ValT,
|
||||
typename ValInfo = ImutKeyValueInfo<KeyT,ValT>>
|
||||
class ImmutableMapRef {
|
||||
public:
|
||||
typedef typename ValInfo::value_type value_type;
|
||||
typedef typename ValInfo::value_type_ref value_type_ref;
|
||||
typedef typename ValInfo::key_type key_type;
|
||||
typedef typename ValInfo::key_type_ref key_type_ref;
|
||||
typedef typename ValInfo::data_type data_type;
|
||||
typedef typename ValInfo::data_type_ref data_type_ref;
|
||||
typedef ImutAVLTree<ValInfo> TreeTy;
|
||||
typedef typename TreeTy::Factory FactoryTy;
|
||||
using value_type = typename ValInfo::value_type;
|
||||
using value_type_ref = typename ValInfo::value_type_ref;
|
||||
using key_type = typename ValInfo::key_type;
|
||||
using key_type_ref = typename ValInfo::key_type_ref;
|
||||
using data_type = typename ValInfo::data_type;
|
||||
using data_type_ref = typename ValInfo::data_type_ref;
|
||||
using TreeTy = ImutAVLTree<ValInfo>;
|
||||
using FactoryTy = typename TreeTy::Factory;
|
||||
|
||||
protected:
|
||||
TreeTy *Root;
|
||||
@ -292,6 +294,11 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
~ImmutableMapRef() {
|
||||
if (Root)
|
||||
Root->release();
|
||||
}
|
||||
|
||||
ImmutableMapRef &operator=(const ImmutableMapRef &X) {
|
||||
if (Root != X.Root) {
|
||||
if (X.Root)
|
||||
@ -306,11 +313,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
~ImmutableMapRef() {
|
||||
if (Root)
|
||||
Root->release();
|
||||
}
|
||||
|
||||
static inline ImmutableMapRef getEmptyMap(FactoryTy *F) {
|
||||
return ImmutableMapRef(0, F);
|
||||
}
|
||||
|
||||
@ -41,18 +41,16 @@ template <typename ImutInfo> class ImutAVLTreeGenericIterator;
|
||||
template <typename ImutInfo >
|
||||
class ImutAVLTree {
|
||||
public:
|
||||
typedef typename ImutInfo::key_type_ref key_type_ref;
|
||||
typedef typename ImutInfo::value_type value_type;
|
||||
typedef typename ImutInfo::value_type_ref value_type_ref;
|
||||
using key_type_ref = typename ImutInfo::key_type_ref;
|
||||
using value_type = typename ImutInfo::value_type;
|
||||
using value_type_ref = typename ImutInfo::value_type_ref;
|
||||
using Factory = ImutAVLFactory<ImutInfo>;
|
||||
using iterator = ImutAVLTreeInOrderIterator<ImutInfo>;
|
||||
|
||||
typedef ImutAVLFactory<ImutInfo> Factory;
|
||||
friend class ImutAVLFactory<ImutInfo>;
|
||||
friend class ImutIntervalAVLFactory<ImutInfo>;
|
||||
|
||||
friend class ImutAVLTreeGenericIterator<ImutInfo>;
|
||||
|
||||
typedef ImutAVLTreeInOrderIterator<ImutInfo> iterator;
|
||||
|
||||
//===----------------------------------------------------===//
|
||||
// Public Interface.
|
||||
//===----------------------------------------------------===//
|
||||
@ -225,17 +223,17 @@ private:
|
||||
Factory *factory;
|
||||
ImutAVLTree *left;
|
||||
ImutAVLTree *right;
|
||||
ImutAVLTree *prev;
|
||||
ImutAVLTree *next;
|
||||
ImutAVLTree *prev = nullptr;
|
||||
ImutAVLTree *next = nullptr;
|
||||
|
||||
unsigned height : 28;
|
||||
unsigned IsMutable : 1;
|
||||
unsigned IsDigestCached : 1;
|
||||
unsigned IsCanonicalized : 1;
|
||||
unsigned height : 28;
|
||||
bool IsMutable : 1;
|
||||
bool IsDigestCached : 1;
|
||||
bool IsCanonicalized : 1;
|
||||
|
||||
value_type value;
|
||||
uint32_t digest;
|
||||
uint32_t refCount;
|
||||
uint32_t digest = 0;
|
||||
uint32_t refCount = 0;
|
||||
|
||||
//===----------------------------------------------------===//
|
||||
// Internal methods (node manipulation; used by Factory).
|
||||
@ -246,9 +244,8 @@ private:
|
||||
/// ImutAVLFactory.
|
||||
ImutAVLTree(Factory *f, ImutAVLTree* l, ImutAVLTree* r, value_type_ref v,
|
||||
unsigned height)
|
||||
: factory(f), left(l), right(r), prev(nullptr), next(nullptr),
|
||||
height(height), IsMutable(true), IsDigestCached(false),
|
||||
IsCanonicalized(0), value(v), digest(0), refCount(0)
|
||||
: factory(f), left(l), right(r), height(height), IsMutable(true),
|
||||
IsDigestCached(false), IsCanonicalized(false), value(v)
|
||||
{
|
||||
if (left) left->retain();
|
||||
if (right) right->retain();
|
||||
@ -369,11 +366,11 @@ public:
|
||||
template <typename ImutInfo >
|
||||
class ImutAVLFactory {
|
||||
friend class ImutAVLTree<ImutInfo>;
|
||||
typedef ImutAVLTree<ImutInfo> TreeTy;
|
||||
typedef typename TreeTy::value_type_ref value_type_ref;
|
||||
typedef typename TreeTy::key_type_ref key_type_ref;
|
||||
|
||||
typedef DenseMap<unsigned, TreeTy*> CacheTy;
|
||||
using TreeTy = ImutAVLTree<ImutInfo>;
|
||||
using value_type_ref = typename TreeTy::value_type_ref;
|
||||
using key_type_ref = typename TreeTy::key_type_ref;
|
||||
using CacheTy = DenseMap<unsigned, TreeTy*>;
|
||||
|
||||
CacheTy Cache;
|
||||
uintptr_t Allocator;
|
||||
@ -659,7 +656,7 @@ public:
|
||||
enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3,
|
||||
Flags=0x3 };
|
||||
|
||||
typedef ImutAVLTree<ImutInfo> TreeTy;
|
||||
using TreeTy = ImutAVLTree<ImutInfo>;
|
||||
|
||||
ImutAVLTreeGenericIterator() = default;
|
||||
ImutAVLTreeGenericIterator(const TreeTy *Root) {
|
||||
@ -764,11 +761,12 @@ template <typename ImutInfo>
|
||||
class ImutAVLTreeInOrderIterator
|
||||
: public std::iterator<std::bidirectional_iterator_tag,
|
||||
ImutAVLTree<ImutInfo>> {
|
||||
typedef ImutAVLTreeGenericIterator<ImutInfo> InternalIteratorTy;
|
||||
using InternalIteratorTy = ImutAVLTreeGenericIterator<ImutInfo>;
|
||||
|
||||
InternalIteratorTy InternalItr;
|
||||
|
||||
public:
|
||||
typedef ImutAVLTree<ImutInfo> TreeTy;
|
||||
using TreeTy = ImutAVLTree<ImutInfo>;
|
||||
|
||||
ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) {
|
||||
if (Root)
|
||||
@ -840,8 +838,8 @@ struct ImutAVLValueIterator
|
||||
/// and generic handling of pointers is done below.
|
||||
template <typename T>
|
||||
struct ImutProfileInfo {
|
||||
typedef const T value_type;
|
||||
typedef const T& value_type_ref;
|
||||
using value_type = const T;
|
||||
using value_type_ref = const T&;
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
|
||||
FoldingSetTrait<T>::Profile(X,ID);
|
||||
@ -851,8 +849,8 @@ struct ImutProfileInfo {
|
||||
/// Profile traits for integers.
|
||||
template <typename T>
|
||||
struct ImutProfileInteger {
|
||||
typedef const T value_type;
|
||||
typedef const T& value_type_ref;
|
||||
using value_type = const T;
|
||||
using value_type_ref = const T&;
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
|
||||
ID.AddInteger(X);
|
||||
@ -878,8 +876,8 @@ PROFILE_INTEGER_INFO(unsigned long long)
|
||||
/// Profile traits for booleans.
|
||||
template <>
|
||||
struct ImutProfileInfo<bool> {
|
||||
typedef const bool value_type;
|
||||
typedef const bool& value_type_ref;
|
||||
using value_type = const bool;
|
||||
using value_type_ref = const bool&;
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
|
||||
ID.AddBoolean(X);
|
||||
@ -890,8 +888,8 @@ struct ImutProfileInfo<bool> {
|
||||
/// references to unique objects.
|
||||
template <typename T>
|
||||
struct ImutProfileInfo<T*> {
|
||||
typedef const T* value_type;
|
||||
typedef value_type value_type_ref;
|
||||
using value_type = const T*;
|
||||
using value_type_ref = value_type;
|
||||
|
||||
static void Profile(FoldingSetNodeID &ID, value_type_ref X) {
|
||||
ID.AddPointer(X);
|
||||
@ -910,12 +908,12 @@ struct ImutProfileInfo<T*> {
|
||||
/// std::equal_to<> and std::less<> to perform comparison of elements.
|
||||
template <typename T>
|
||||
struct ImutContainerInfo : public ImutProfileInfo<T> {
|
||||
typedef typename ImutProfileInfo<T>::value_type value_type;
|
||||
typedef typename ImutProfileInfo<T>::value_type_ref value_type_ref;
|
||||
typedef value_type key_type;
|
||||
typedef value_type_ref key_type_ref;
|
||||
typedef bool data_type;
|
||||
typedef bool data_type_ref;
|
||||
using value_type = typename ImutProfileInfo<T>::value_type;
|
||||
using value_type_ref = typename ImutProfileInfo<T>::value_type_ref;
|
||||
using key_type = value_type;
|
||||
using key_type_ref = value_type_ref;
|
||||
using data_type = bool;
|
||||
using data_type_ref = bool;
|
||||
|
||||
static key_type_ref KeyOfValue(value_type_ref D) { return D; }
|
||||
static data_type_ref DataOfValue(value_type_ref) { return true; }
|
||||
@ -936,12 +934,12 @@ struct ImutContainerInfo : public ImutProfileInfo<T> {
|
||||
/// their addresses.
|
||||
template <typename T>
|
||||
struct ImutContainerInfo<T*> : public ImutProfileInfo<T*> {
|
||||
typedef typename ImutProfileInfo<T*>::value_type value_type;
|
||||
typedef typename ImutProfileInfo<T*>::value_type_ref value_type_ref;
|
||||
typedef value_type key_type;
|
||||
typedef value_type_ref key_type_ref;
|
||||
typedef bool data_type;
|
||||
typedef bool data_type_ref;
|
||||
using value_type = typename ImutProfileInfo<T*>::value_type;
|
||||
using value_type_ref = typename ImutProfileInfo<T*>::value_type_ref;
|
||||
using key_type = value_type;
|
||||
using key_type_ref = value_type_ref;
|
||||
using data_type = bool;
|
||||
using data_type_ref = bool;
|
||||
|
||||
static key_type_ref KeyOfValue(value_type_ref D) { return D; }
|
||||
static data_type_ref DataOfValue(value_type_ref) { return true; }
|
||||
@ -960,9 +958,9 @@ struct ImutContainerInfo<T*> : public ImutProfileInfo<T*> {
|
||||
template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
|
||||
class ImmutableSet {
|
||||
public:
|
||||
typedef typename ValInfo::value_type value_type;
|
||||
typedef typename ValInfo::value_type_ref value_type_ref;
|
||||
typedef ImutAVLTree<ValInfo> TreeTy;
|
||||
using value_type = typename ValInfo::value_type;
|
||||
using value_type_ref = typename ValInfo::value_type_ref;
|
||||
using TreeTy = ImutAVLTree<ValInfo>;
|
||||
|
||||
private:
|
||||
TreeTy *Root;
|
||||
@ -980,6 +978,10 @@ public:
|
||||
if (Root) { Root->retain(); }
|
||||
}
|
||||
|
||||
~ImmutableSet() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
ImmutableSet &operator=(const ImmutableSet &X) {
|
||||
if (Root != X.Root) {
|
||||
if (X.Root) { X.Root->retain(); }
|
||||
@ -989,10 +991,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
~ImmutableSet() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
class Factory {
|
||||
typename TreeTy::Factory F;
|
||||
const bool Canonicalize;
|
||||
@ -1084,7 +1082,7 @@ public:
|
||||
// Iterators.
|
||||
//===--------------------------------------------------===//
|
||||
|
||||
typedef ImutAVLValueIterator<ImmutableSet> iterator;
|
||||
using iterator = ImutAVLValueIterator<ImmutableSet>;
|
||||
|
||||
iterator begin() const { return iterator(Root); }
|
||||
iterator end() const { return iterator(); }
|
||||
@ -1112,10 +1110,10 @@ public:
|
||||
template <typename ValT, typename ValInfo = ImutContainerInfo<ValT>>
|
||||
class ImmutableSetRef {
|
||||
public:
|
||||
typedef typename ValInfo::value_type value_type;
|
||||
typedef typename ValInfo::value_type_ref value_type_ref;
|
||||
typedef ImutAVLTree<ValInfo> TreeTy;
|
||||
typedef typename TreeTy::Factory FactoryTy;
|
||||
using value_type = typename ValInfo::value_type;
|
||||
using value_type_ref = typename ValInfo::value_type_ref;
|
||||
using TreeTy = ImutAVLTree<ValInfo>;
|
||||
using FactoryTy = typename TreeTy::Factory;
|
||||
|
||||
private:
|
||||
TreeTy *Root;
|
||||
@ -1138,6 +1136,10 @@ public:
|
||||
if (Root) { Root->retain(); }
|
||||
}
|
||||
|
||||
~ImmutableSetRef() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
ImmutableSetRef &operator=(const ImmutableSetRef &X) {
|
||||
if (Root != X.Root) {
|
||||
if (X.Root) { X.Root->retain(); }
|
||||
@ -1147,9 +1149,6 @@ public:
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
~ImmutableSetRef() {
|
||||
if (Root) { Root->release(); }
|
||||
}
|
||||
|
||||
static ImmutableSetRef getEmptySet(FactoryTy *F) {
|
||||
return ImmutableSetRef(0, F);
|
||||
@ -1196,7 +1195,7 @@ public:
|
||||
// Iterators.
|
||||
//===--------------------------------------------------===//
|
||||
|
||||
typedef ImutAVLValueIterator<ImmutableSetRef> iterator;
|
||||
using iterator = ImutAVLValueIterator<ImmutableSetRef>;
|
||||
|
||||
iterator begin() const { return iterator(Root); }
|
||||
iterator end() const { return iterator(); }
|
||||
|
||||
@ -20,28 +20,28 @@
|
||||
#ifndef LLVM_ADT_INDEXEDMAP_H
|
||||
#define LLVM_ADT_INDEXEDMAP_H
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
template <typename T, typename ToIndexT = llvm::identity<unsigned> >
|
||||
template <typename T, typename ToIndexT = identity<unsigned>>
|
||||
class IndexedMap {
|
||||
typedef typename ToIndexT::argument_type IndexT;
|
||||
using IndexT = typename ToIndexT::argument_type;
|
||||
// Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
|
||||
// can grow very large and SmallVector grows more efficiently as long as T
|
||||
// is trivially copyable.
|
||||
typedef SmallVector<T, 0> StorageT;
|
||||
using StorageT = SmallVector<T, 0>;
|
||||
|
||||
StorageT storage_;
|
||||
T nullVal_;
|
||||
ToIndexT toIndex_;
|
||||
|
||||
public:
|
||||
IndexedMap() : nullVal_(T()) { }
|
||||
IndexedMap() : nullVal_(T()) {}
|
||||
|
||||
explicit IndexedMap(const T& val) : nullVal_(val) { }
|
||||
explicit IndexedMap(const T& val) : nullVal_(val) {}
|
||||
|
||||
typename StorageT::reference operator[](IndexT n) {
|
||||
assert(toIndex_(n) < storage_.size() && "index out of bounds!");
|
||||
@ -80,6 +80,6 @@ template <typename T, typename ToIndexT = llvm::identity<unsigned> >
|
||||
}
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_INDEXEDMAP_H
|
||||
|
||||
@ -106,6 +106,7 @@
|
||||
#include "llvm/Support/RecyclingAllocator.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <iterator>
|
||||
#include <new>
|
||||
#include <utility>
|
||||
@ -186,7 +187,7 @@ struct IntervalMapHalfOpenInfo {
|
||||
/// It should be considered private to the implementation.
|
||||
namespace IntervalMapImpl {
|
||||
|
||||
typedef std::pair<unsigned,unsigned> IdxPair;
|
||||
using IdxPair = std::pair<unsigned,unsigned>;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
//--- IntervalMapImpl::NodeBase ---//
|
||||
@ -445,7 +446,7 @@ struct NodeSizer {
|
||||
LeafSize = DesiredLeafSize > MinLeafSize ? DesiredLeafSize : MinLeafSize
|
||||
};
|
||||
|
||||
typedef NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize> LeafBase;
|
||||
using LeafBase = NodeBase<std::pair<KeyT, KeyT>, ValT, LeafSize>;
|
||||
|
||||
enum {
|
||||
// Now that we have the leaf branching factor, compute the actual allocation
|
||||
@ -461,8 +462,8 @@ struct NodeSizer {
|
||||
/// This typedef is very likely to be identical for all IntervalMaps with
|
||||
/// reasonably sized entries, so the same allocator can be shared among
|
||||
/// different kinds of maps.
|
||||
typedef RecyclingAllocator<BumpPtrAllocator, char,
|
||||
AllocBytes, CacheLineBytes> Allocator;
|
||||
using Allocator =
|
||||
RecyclingAllocator<BumpPtrAllocator, char, AllocBytes, CacheLineBytes>;
|
||||
};
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -930,12 +931,12 @@ template <typename KeyT, typename ValT,
|
||||
unsigned N = IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
|
||||
typename Traits = IntervalMapInfo<KeyT>>
|
||||
class IntervalMap {
|
||||
typedef IntervalMapImpl::NodeSizer<KeyT, ValT> Sizer;
|
||||
typedef IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits> Leaf;
|
||||
typedef IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>
|
||||
Branch;
|
||||
typedef IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits> RootLeaf;
|
||||
typedef IntervalMapImpl::IdxPair IdxPair;
|
||||
using Sizer = IntervalMapImpl::NodeSizer<KeyT, ValT>;
|
||||
using Leaf = IntervalMapImpl::LeafNode<KeyT, ValT, Sizer::LeafSize, Traits>;
|
||||
using Branch =
|
||||
IntervalMapImpl::BranchNode<KeyT, ValT, Sizer::BranchSize, Traits>;
|
||||
using RootLeaf = IntervalMapImpl::LeafNode<KeyT, ValT, N, Traits>;
|
||||
using IdxPair = IntervalMapImpl::IdxPair;
|
||||
|
||||
// The RootLeaf capacity is given as a template parameter. We must compute the
|
||||
// corresponding RootBranch capacity.
|
||||
@ -945,8 +946,8 @@ class IntervalMap {
|
||||
RootBranchCap = DesiredRootBranchCap ? DesiredRootBranchCap : 1
|
||||
};
|
||||
|
||||
typedef IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>
|
||||
RootBranch;
|
||||
using RootBranch =
|
||||
IntervalMapImpl::BranchNode<KeyT, ValT, RootBranchCap, Traits>;
|
||||
|
||||
// When branched, we store a global start key as well as the branch node.
|
||||
struct RootBranchData {
|
||||
@ -955,10 +956,10 @@ class IntervalMap {
|
||||
};
|
||||
|
||||
public:
|
||||
typedef typename Sizer::Allocator Allocator;
|
||||
typedef KeyT KeyType;
|
||||
typedef ValT ValueType;
|
||||
typedef Traits KeyTraits;
|
||||
using Allocator = typename Sizer::Allocator;
|
||||
using KeyType = KeyT;
|
||||
using ValueType = ValT;
|
||||
using KeyTraits = Traits;
|
||||
|
||||
private:
|
||||
// The root data is either a RootLeaf or a RootBranchData instance.
|
||||
@ -1290,7 +1291,7 @@ protected:
|
||||
friend class IntervalMap;
|
||||
|
||||
// The map referred to.
|
||||
IntervalMap *map;
|
||||
IntervalMap *map = nullptr;
|
||||
|
||||
// We store a full path from the root to the current position.
|
||||
// The path may be partially filled, but never between iterator calls.
|
||||
@ -1338,7 +1339,7 @@ protected:
|
||||
|
||||
public:
|
||||
/// const_iterator - Create an iterator that isn't pointing anywhere.
|
||||
const_iterator() : map(nullptr) {}
|
||||
const_iterator() = default;
|
||||
|
||||
/// setMap - Change the map iterated over. This call must be followed by a
|
||||
/// call to goToBegin(), goToEnd(), or find()
|
||||
@ -1509,7 +1510,8 @@ const_iterator::treeAdvanceTo(KeyT x) {
|
||||
template <typename KeyT, typename ValT, unsigned N, typename Traits>
|
||||
class IntervalMap<KeyT, ValT, N, Traits>::iterator : public const_iterator {
|
||||
friend class IntervalMap;
|
||||
typedef IntervalMapImpl::IdxPair IdxPair;
|
||||
|
||||
using IdxPair = IntervalMapImpl::IdxPair;
|
||||
|
||||
explicit iterator(IntervalMap &map) : const_iterator(map) {}
|
||||
|
||||
@ -2003,7 +2005,7 @@ iterator::overflow(unsigned Level) {
|
||||
// Elements have been rearranged, now update node sizes and stops.
|
||||
bool SplitRoot = false;
|
||||
unsigned Pos = 0;
|
||||
for (;;) {
|
||||
while (true) {
|
||||
KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1);
|
||||
if (NewNode && Pos == NewNode) {
|
||||
SplitRoot = insertNode(Level, NodeRef(Node[Pos], NewSize[Pos]), Stop);
|
||||
@ -2045,8 +2047,9 @@ iterator::overflow(unsigned Level) {
|
||||
///
|
||||
template <typename MapA, typename MapB>
|
||||
class IntervalMapOverlaps {
|
||||
typedef typename MapA::KeyType KeyType;
|
||||
typedef typename MapA::KeyTraits Traits;
|
||||
using KeyType = typename MapA::KeyType;
|
||||
using Traits = typename MapA::KeyTraits;
|
||||
|
||||
typename MapA::const_iterator posA;
|
||||
typename MapB::const_iterator posB;
|
||||
|
||||
@ -2071,7 +2074,7 @@ class IntervalMapOverlaps {
|
||||
// Already overlapping.
|
||||
return;
|
||||
|
||||
for (;;) {
|
||||
while (true) {
|
||||
// Make a.end > b.start.
|
||||
posA.advanceTo(posB.start());
|
||||
if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start()))
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- C++ -*-==//
|
||||
//==- llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer --*- C++ -*-==//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -73,9 +73,10 @@ template <class Derived> class RefCountedBase {
|
||||
|
||||
public:
|
||||
RefCountedBase() = default;
|
||||
RefCountedBase(const RefCountedBase &) : RefCount(0) {}
|
||||
RefCountedBase(const RefCountedBase &) {}
|
||||
|
||||
void Retain() const { ++RefCount; }
|
||||
|
||||
void Release() const {
|
||||
assert(RefCount > 0 && "Reference count is already zero.");
|
||||
if (--RefCount == 0)
|
||||
@ -136,7 +137,7 @@ template <typename T> class IntrusiveRefCntPtr {
|
||||
T *Obj = nullptr;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
using element_type = T;
|
||||
|
||||
explicit IntrusiveRefCntPtr() = default;
|
||||
IntrusiveRefCntPtr(T *obj) : Obj(obj) { retain(); }
|
||||
@ -153,13 +154,13 @@ public:
|
||||
retain();
|
||||
}
|
||||
|
||||
~IntrusiveRefCntPtr() { release(); }
|
||||
|
||||
IntrusiveRefCntPtr &operator=(IntrusiveRefCntPtr S) {
|
||||
swap(S);
|
||||
return *this;
|
||||
}
|
||||
|
||||
~IntrusiveRefCntPtr() { release(); }
|
||||
|
||||
T &operator*() const { return *Obj; }
|
||||
T *operator->() const { return Obj; }
|
||||
T *get() const { return Obj; }
|
||||
@ -183,6 +184,7 @@ private:
|
||||
if (Obj)
|
||||
IntrusiveRefCntPtrInfo<T>::retain(Obj);
|
||||
}
|
||||
|
||||
void release() {
|
||||
if (Obj)
|
||||
IntrusiveRefCntPtrInfo<T>::release(Obj);
|
||||
@ -248,14 +250,16 @@ bool operator!=(const IntrusiveRefCntPtr<T> &A, std::nullptr_t B) {
|
||||
template <typename From> struct simplify_type;
|
||||
|
||||
template <class T> struct simplify_type<IntrusiveRefCntPtr<T>> {
|
||||
typedef T *SimpleType;
|
||||
using SimpleType = T *;
|
||||
|
||||
static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T> &Val) {
|
||||
return Val.get();
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct simplify_type<const IntrusiveRefCntPtr<T>> {
|
||||
typedef /*const*/ T *SimpleType;
|
||||
using SimpleType = /*const*/ T *;
|
||||
|
||||
static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T> &Val) {
|
||||
return Val.get();
|
||||
}
|
||||
|
||||
@ -19,6 +19,12 @@
|
||||
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
@ -27,20 +33,20 @@ namespace llvm {
|
||||
/// in a deterministic order. The values are kept in a std::vector and the
|
||||
/// mapping is done with DenseMap from Keys to indexes in that vector.
|
||||
template<typename KeyT, typename ValueT,
|
||||
typename MapType = llvm::DenseMap<KeyT, unsigned>,
|
||||
typename VectorType = std::vector<std::pair<KeyT, ValueT> > >
|
||||
typename MapType = DenseMap<KeyT, unsigned>,
|
||||
typename VectorType = std::vector<std::pair<KeyT, ValueT>>>
|
||||
class MapVector {
|
||||
typedef typename VectorType::value_type value_type;
|
||||
typedef typename VectorType::size_type size_type;
|
||||
using value_type = typename VectorType::value_type;
|
||||
using size_type = typename VectorType::size_type;
|
||||
|
||||
MapType Map;
|
||||
VectorType Vector;
|
||||
|
||||
public:
|
||||
typedef typename VectorType::iterator iterator;
|
||||
typedef typename VectorType::const_iterator const_iterator;
|
||||
typedef typename VectorType::reverse_iterator reverse_iterator;
|
||||
typedef typename VectorType::const_reverse_iterator const_reverse_iterator;
|
||||
using iterator = typename VectorType::iterator;
|
||||
using const_iterator = typename VectorType::const_iterator;
|
||||
using reverse_iterator = typename VectorType::reverse_iterator;
|
||||
using const_reverse_iterator = typename VectorType::const_reverse_iterator;
|
||||
|
||||
/// Clear the MapVector and return the underlying vector.
|
||||
VectorType takeVector() {
|
||||
@ -220,4 +226,4 @@ struct SmallMapVector
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_MAPVECTOR_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
|
||||
//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -19,6 +19,8 @@
|
||||
#include "llvm/ADT/None.h"
|
||||
#include "llvm/Support/AlignOf.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/type_traits.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <new>
|
||||
#include <utility>
|
||||
@ -28,15 +30,18 @@ namespace llvm {
|
||||
template<typename T>
|
||||
class Optional {
|
||||
AlignedCharArrayUnion<T> storage;
|
||||
bool hasVal;
|
||||
public:
|
||||
typedef T value_type;
|
||||
bool hasVal = false;
|
||||
|
||||
public:
|
||||
using value_type = T;
|
||||
|
||||
Optional(NoneType) {}
|
||||
explicit Optional() {}
|
||||
|
||||
Optional(NoneType) : hasVal(false) {}
|
||||
explicit Optional() : hasVal(false) {}
|
||||
Optional(const T &y) : hasVal(true) {
|
||||
new (storage.buffer) T(y);
|
||||
}
|
||||
|
||||
Optional(const Optional &O) : hasVal(O.hasVal) {
|
||||
if (hasVal)
|
||||
new (storage.buffer) T(*O);
|
||||
@ -45,12 +50,18 @@ public:
|
||||
Optional(T &&y) : hasVal(true) {
|
||||
new (storage.buffer) T(std::forward<T>(y));
|
||||
}
|
||||
|
||||
Optional(Optional<T> &&O) : hasVal(O) {
|
||||
if (O) {
|
||||
new (storage.buffer) T(std::move(*O));
|
||||
O.reset();
|
||||
}
|
||||
}
|
||||
|
||||
~Optional() {
|
||||
reset();
|
||||
}
|
||||
|
||||
Optional &operator=(T &&y) {
|
||||
if (hasVal)
|
||||
**this = std::move(y);
|
||||
@ -60,6 +71,7 @@ public:
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
Optional &operator=(Optional &&O) {
|
||||
if (!O)
|
||||
reset();
|
||||
@ -112,10 +124,6 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
~Optional() {
|
||||
reset();
|
||||
}
|
||||
|
||||
const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }
|
||||
T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }
|
||||
const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
|
||||
@ -144,8 +152,7 @@ public:
|
||||
#endif
|
||||
};
|
||||
|
||||
template <typename T> struct isPodLike;
|
||||
template <typename T> struct isPodLike<Optional<T> > {
|
||||
template <typename T> struct isPodLike<Optional<T>> {
|
||||
// An Optional<T> is pod-like if T is.
|
||||
static const bool value = isPodLike<T>::value;
|
||||
};
|
||||
@ -284,6 +291,6 @@ template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
|
||||
return !(X < Y);
|
||||
}
|
||||
|
||||
} // end llvm namespace
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_OPTIONAL_H
|
||||
|
||||
@ -76,8 +76,8 @@ template <typename T, unsigned BitNum, typename BitVectorTy = BitVector>
|
||||
class PackedVector : public PackedVectorBase<T, BitNum, BitVectorTy,
|
||||
std::numeric_limits<T>::is_signed> {
|
||||
BitVectorTy Bits;
|
||||
typedef PackedVectorBase<T, BitNum, BitVectorTy,
|
||||
std::numeric_limits<T>::is_signed> base;
|
||||
using base = PackedVectorBase<T, BitNum, BitVectorTy,
|
||||
std::numeric_limits<T>::is_signed>;
|
||||
|
||||
public:
|
||||
class reference {
|
||||
@ -99,7 +99,7 @@ public:
|
||||
};
|
||||
|
||||
PackedVector() = default;
|
||||
explicit PackedVector(unsigned size) : Bits(size << (BitNum-1)) { }
|
||||
explicit PackedVector(unsigned size) : Bits(size << (BitNum-1)) {}
|
||||
|
||||
bool empty() const { return Bits.empty(); }
|
||||
|
||||
|
||||
@ -13,7 +13,10 @@
|
||||
#include "llvm/ADT/DenseMapInfo.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include "llvm/Support/PointerLikeTypeTraits.h"
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -29,7 +32,7 @@ namespace llvm {
|
||||
/// Also, the default constructed value zero initializes the integer.
|
||||
template <typename IntT, int Bits = sizeof(IntT) * CHAR_BIT>
|
||||
class PointerEmbeddedInt {
|
||||
uintptr_t Value;
|
||||
uintptr_t Value = 0;
|
||||
|
||||
// Note: This '<' is correct; using '<=' would result in some shifts
|
||||
// overflowing their storage types.
|
||||
@ -54,15 +57,12 @@ class PointerEmbeddedInt {
|
||||
explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {}
|
||||
|
||||
public:
|
||||
PointerEmbeddedInt() : Value(0) {}
|
||||
PointerEmbeddedInt() = default;
|
||||
|
||||
PointerEmbeddedInt(IntT I) {
|
||||
*this = I;
|
||||
}
|
||||
PointerEmbeddedInt(IntT I) { *this = I; }
|
||||
|
||||
PointerEmbeddedInt &operator=(IntT I) {
|
||||
assert((std::is_signed<IntT>::value ? llvm::isInt<Bits>(I)
|
||||
: llvm::isUInt<Bits>(I)) &&
|
||||
assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&
|
||||
"Integer has bits outside those preserved!");
|
||||
Value = static_cast<uintptr_t>(I) << Shift;
|
||||
return *this;
|
||||
@ -81,15 +81,17 @@ public:
|
||||
// types.
|
||||
template <typename IntT, int Bits>
|
||||
class PointerLikeTypeTraits<PointerEmbeddedInt<IntT, Bits>> {
|
||||
typedef PointerEmbeddedInt<IntT, Bits> T;
|
||||
using T = PointerEmbeddedInt<IntT, Bits>;
|
||||
|
||||
public:
|
||||
static inline void *getAsVoidPointer(const T &P) {
|
||||
return reinterpret_cast<void *>(P.Value);
|
||||
}
|
||||
|
||||
static inline T getFromVoidPointer(void *P) {
|
||||
return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
|
||||
}
|
||||
|
||||
static inline T getFromVoidPointer(const void *P) {
|
||||
return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
|
||||
}
|
||||
@ -101,17 +103,19 @@ public:
|
||||
// itself can be a key.
|
||||
template <typename IntT, int Bits>
|
||||
struct DenseMapInfo<PointerEmbeddedInt<IntT, Bits>> {
|
||||
typedef PointerEmbeddedInt<IntT, Bits> T;
|
||||
|
||||
typedef DenseMapInfo<IntT> IntInfo;
|
||||
using T = PointerEmbeddedInt<IntT, Bits>;
|
||||
using IntInfo = DenseMapInfo<IntT>;
|
||||
|
||||
static inline T getEmptyKey() { return IntInfo::getEmptyKey(); }
|
||||
static inline T getTombstoneKey() { return IntInfo::getTombstoneKey(); }
|
||||
|
||||
static unsigned getHashValue(const T &Arg) {
|
||||
return IntInfo::getHashValue(Arg);
|
||||
}
|
||||
|
||||
static bool isEqual(const T &LHS, const T &RHS) { return LHS == RHS; }
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_ADT_POINTEREMBEDDEDINT_H
|
||||
|
||||
@ -13,9 +13,14 @@
|
||||
#include "llvm/ADT/ilist_base.h"
|
||||
#include "llvm/ADT/ilist_iterator.h"
|
||||
#include "llvm/ADT/ilist_node.h"
|
||||
#include "llvm/ADT/ilist_node_options.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -77,23 +82,23 @@ class simple_ilist
|
||||
typename ilist_detail::compute_node_options<T, Options...>::type> {
|
||||
static_assert(ilist_detail::check_options<Options...>::value,
|
||||
"Unrecognized node option!");
|
||||
typedef
|
||||
typename ilist_detail::compute_node_options<T, Options...>::type OptionsT;
|
||||
typedef typename OptionsT::list_base_type list_base_type;
|
||||
using OptionsT =
|
||||
typename ilist_detail::compute_node_options<T, Options...>::type;
|
||||
using list_base_type = typename OptionsT::list_base_type;
|
||||
ilist_sentinel<OptionsT> Sentinel;
|
||||
|
||||
public:
|
||||
typedef typename OptionsT::value_type value_type;
|
||||
typedef typename OptionsT::pointer pointer;
|
||||
typedef typename OptionsT::reference reference;
|
||||
typedef typename OptionsT::const_pointer const_pointer;
|
||||
typedef typename OptionsT::const_reference const_reference;
|
||||
typedef ilist_iterator<OptionsT, false, false> iterator;
|
||||
typedef ilist_iterator<OptionsT, false, true> const_iterator;
|
||||
typedef ilist_iterator<OptionsT, true, false> reverse_iterator;
|
||||
typedef ilist_iterator<OptionsT, true, true> const_reverse_iterator;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
using value_type = typename OptionsT::value_type;
|
||||
using pointer = typename OptionsT::pointer;
|
||||
using reference = typename OptionsT::reference;
|
||||
using const_pointer = typename OptionsT::const_pointer;
|
||||
using const_reference = typename OptionsT::const_reference;
|
||||
using iterator = ilist_iterator<OptionsT, false, false>;
|
||||
using const_iterator = ilist_iterator<OptionsT, false, true>;
|
||||
using reverse_iterator = ilist_iterator<OptionsT, true, false>;
|
||||
using const_reverse_iterator = ilist_iterator<OptionsT, true, true>;
|
||||
using size_type = size_t;
|
||||
using difference_type = ptrdiff_t;
|
||||
|
||||
simple_ilist() = default;
|
||||
~simple_ilist() = default;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user