From 8967672015d3e1a1a63c48e03622a7bf64ca6860 Mon Sep 17 00:00:00 2001 From: Adam Nemet Date: Fri, 19 May 2017 02:56:37 +0000 Subject: [PATCH] Revert "[ADT] Fix some Clang-tidy modernize-use-using warnings; other minor fixes (NFC)." This reverts commit r303383. This breaks the modules-enabled macOS build with: lib/Support/LockFileManager.cpp:86:7: error: declaration of 'gethostuuid' must be imported from module 'Darwin.POSIX.unistd' before it is required llvm-svn: 303402 --- llvm/include/llvm/ADT/ImmutableList.h | 8 +- llvm/include/llvm/ADT/ImmutableMap.h | 62 +++++++-------- llvm/include/llvm/ADT/ImmutableSet.h | 121 +++++++++++++++-------------- llvm/include/llvm/ADT/IndexedMap.h | 16 ++-- llvm/include/llvm/ADT/IntervalMap.h | 49 ++++++------ llvm/include/llvm/ADT/IntrusiveRefCntPtr.h | 18 ++--- llvm/include/llvm/ADT/MapVector.h | 24 +++--- llvm/include/llvm/ADT/Optional.h | 33 ++++---- llvm/include/llvm/ADT/PackedVector.h | 6 +- llvm/include/llvm/ADT/PointerEmbeddedInt.h | 30 ++++--- llvm/include/llvm/ADT/PointerIntPair.h | 29 ++----- llvm/include/llvm/ADT/PointerSumType.h | 49 ++++++------ llvm/include/llvm/ADT/PointerUnion.h | 74 ++++++++---------- llvm/include/llvm/ADT/simple_ilist.h | 33 ++++---- 14 files changed, 250 insertions(+), 302 deletions(-) diff --git a/llvm/include/llvm/ADT/ImmutableList.h b/llvm/include/llvm/ADT/ImmutableList.h index 60d63e0..e5f51ba 100644 --- a/llvm/include/llvm/ADT/ImmutableList.h +++ b/llvm/include/llvm/ADT/ImmutableList.h @@ -63,8 +63,8 @@ public: template class ImmutableList { public: - using value_type = T; - using Factory = ImmutableListFactory; + typedef T value_type; + typedef ImmutableListFactory Factory; private: const ImmutableListImpl* X; @@ -141,8 +141,8 @@ public: template class ImmutableListFactory { - using ListTy = ImmutableListImpl; - using CacheTy = FoldingSet; + typedef ImmutableListImpl ListTy; + typedef FoldingSet CacheTy; CacheTy Cache; uintptr_t Allocator; diff --git a/llvm/include/llvm/ADT/ImmutableMap.h b/llvm/include/llvm/ADT/ImmutableMap.h index 10d1e1f..f197d40 100644 --- a/llvm/include/llvm/ADT/ImmutableMap.h +++ b/llvm/include/llvm/ADT/ImmutableMap.h @@ -26,12 +26,12 @@ namespace llvm { /// only the first element (the key) is used by isEqual and isLess. template struct ImutKeyValueInfo { - using value_type = const std::pair; - 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&; + typedef const std::pair 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; static inline key_type_ref KeyOfValue(value_type_ref V) { return V.first; @@ -62,13 +62,13 @@ template > class ImmutableMap { public: - 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; + 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 TreeTy; protected: TreeTy* Root; @@ -86,10 +86,6 @@ 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(); } @@ -99,6 +95,10 @@ public: return *this; } + ~ImmutableMap() { + if (Root) { Root->release(); } + } + class Factory { typename TreeTy::Factory F; const bool Canonicalize; @@ -166,14 +166,12 @@ private: template struct CBWrapper { Callback C; - void operator()(value_type_ref V) { C(V.first,V.second); } }; template struct CBWrapperRef { Callback &C; - CBWrapperRef(Callback& c) : C(c) {} void operator()(value_type_ref V) { C(V.first,V.second); } @@ -256,14 +254,14 @@ template > class ImmutableMapRef { public: - 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; - using FactoryTy = typename TreeTy::Factory; + 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 TreeTy; + typedef typename TreeTy::Factory FactoryTy; protected: TreeTy *Root; @@ -294,11 +292,6 @@ public: } } - ~ImmutableMapRef() { - if (Root) - Root->release(); - } - ImmutableMapRef &operator=(const ImmutableMapRef &X) { if (Root != X.Root) { if (X.Root) @@ -313,6 +306,11 @@ public: return *this; } + ~ImmutableMapRef() { + if (Root) + Root->release(); + } + static inline ImmutableMapRef getEmptyMap(FactoryTy *F) { return ImmutableMapRef(0, F); } diff --git a/llvm/include/llvm/ADT/ImmutableSet.h b/llvm/include/llvm/ADT/ImmutableSet.h index e7a9132..0724a28 100644 --- a/llvm/include/llvm/ADT/ImmutableSet.h +++ b/llvm/include/llvm/ADT/ImmutableSet.h @@ -41,16 +41,18 @@ template class ImutAVLTreeGenericIterator; template class ImutAVLTree { public: - 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; - using iterator = ImutAVLTreeInOrderIterator; + 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; + typedef ImutAVLFactory Factory; friend class ImutAVLFactory; friend class ImutIntervalAVLFactory; + friend class ImutAVLTreeGenericIterator; + typedef ImutAVLTreeInOrderIterator iterator; + //===----------------------------------------------------===// // Public Interface. //===----------------------------------------------------===// @@ -223,17 +225,17 @@ private: Factory *factory; ImutAVLTree *left; ImutAVLTree *right; - ImutAVLTree *prev = nullptr; - ImutAVLTree *next = nullptr; + ImutAVLTree *prev; + ImutAVLTree *next; - unsigned height : 28; - bool IsMutable : 1; - bool IsDigestCached : 1; - bool IsCanonicalized : 1; + unsigned height : 28; + unsigned IsMutable : 1; + unsigned IsDigestCached : 1; + unsigned IsCanonicalized : 1; value_type value; - uint32_t digest = 0; - uint32_t refCount = 0; + uint32_t digest; + uint32_t refCount; //===----------------------------------------------------===// // Internal methods (node manipulation; used by Factory). @@ -244,8 +246,9 @@ private: /// ImutAVLFactory. ImutAVLTree(Factory *f, ImutAVLTree* l, ImutAVLTree* r, value_type_ref v, unsigned height) - : factory(f), left(l), right(r), height(height), IsMutable(true), - IsDigestCached(false), IsCanonicalized(false), value(v) + : factory(f), left(l), right(r), prev(nullptr), next(nullptr), + height(height), IsMutable(true), IsDigestCached(false), + IsCanonicalized(0), value(v), digest(0), refCount(0) { if (left) left->retain(); if (right) right->retain(); @@ -366,11 +369,11 @@ public: template class ImutAVLFactory { friend class ImutAVLTree; + typedef ImutAVLTree TreeTy; + typedef typename TreeTy::value_type_ref value_type_ref; + typedef typename TreeTy::key_type_ref key_type_ref; - using TreeTy = ImutAVLTree; - using value_type_ref = typename TreeTy::value_type_ref; - using key_type_ref = typename TreeTy::key_type_ref; - using CacheTy = DenseMap; + typedef DenseMap CacheTy; CacheTy Cache; uintptr_t Allocator; @@ -656,7 +659,7 @@ public: enum VisitFlag { VisitedNone=0x0, VisitedLeft=0x1, VisitedRight=0x3, Flags=0x3 }; - using TreeTy = ImutAVLTree; + typedef ImutAVLTree TreeTy; ImutAVLTreeGenericIterator() = default; ImutAVLTreeGenericIterator(const TreeTy *Root) { @@ -761,12 +764,11 @@ template class ImutAVLTreeInOrderIterator : public std::iterator> { - using InternalIteratorTy = ImutAVLTreeGenericIterator; - + typedef ImutAVLTreeGenericIterator InternalIteratorTy; InternalIteratorTy InternalItr; public: - using TreeTy = ImutAVLTree; + typedef ImutAVLTree TreeTy; ImutAVLTreeInOrderIterator(const TreeTy* Root) : InternalItr(Root) { if (Root) @@ -838,8 +840,8 @@ struct ImutAVLValueIterator /// and generic handling of pointers is done below. template struct ImutProfileInfo { - using value_type = const T; - using value_type_ref = const T&; + typedef const T value_type; + typedef const T& value_type_ref; static void Profile(FoldingSetNodeID &ID, value_type_ref X) { FoldingSetTrait::Profile(X,ID); @@ -849,8 +851,8 @@ struct ImutProfileInfo { /// Profile traits for integers. template struct ImutProfileInteger { - using value_type = const T; - using value_type_ref = const T&; + typedef const T value_type; + typedef const T& value_type_ref; static void Profile(FoldingSetNodeID &ID, value_type_ref X) { ID.AddInteger(X); @@ -876,8 +878,8 @@ PROFILE_INTEGER_INFO(unsigned long long) /// Profile traits for booleans. template <> struct ImutProfileInfo { - using value_type = const bool; - using value_type_ref = const bool&; + typedef const bool value_type; + typedef const bool& value_type_ref; static void Profile(FoldingSetNodeID &ID, value_type_ref X) { ID.AddBoolean(X); @@ -888,8 +890,8 @@ struct ImutProfileInfo { /// references to unique objects. template struct ImutProfileInfo { - using value_type = const T*; - using value_type_ref = value_type; + typedef const T* value_type; + typedef value_type value_type_ref; static void Profile(FoldingSetNodeID &ID, value_type_ref X) { ID.AddPointer(X); @@ -908,12 +910,12 @@ struct ImutProfileInfo { /// std::equal_to<> and std::less<> to perform comparison of elements. template struct ImutContainerInfo : public ImutProfileInfo { - using value_type = typename ImutProfileInfo::value_type; - using value_type_ref = typename ImutProfileInfo::value_type_ref; - using key_type = value_type; - using key_type_ref = value_type_ref; - using data_type = bool; - using data_type_ref = bool; + typedef typename ImutProfileInfo::value_type value_type; + typedef typename ImutProfileInfo::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; static key_type_ref KeyOfValue(value_type_ref D) { return D; } static data_type_ref DataOfValue(value_type_ref) { return true; } @@ -934,12 +936,12 @@ struct ImutContainerInfo : public ImutProfileInfo { /// their addresses. template struct ImutContainerInfo : public ImutProfileInfo { - using value_type = typename ImutProfileInfo::value_type; - using value_type_ref = typename ImutProfileInfo::value_type_ref; - using key_type = value_type; - using key_type_ref = value_type_ref; - using data_type = bool; - using data_type_ref = bool; + typedef typename ImutProfileInfo::value_type value_type; + typedef typename ImutProfileInfo::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; static key_type_ref KeyOfValue(value_type_ref D) { return D; } static data_type_ref DataOfValue(value_type_ref) { return true; } @@ -958,9 +960,9 @@ struct ImutContainerInfo : public ImutProfileInfo { template > class ImmutableSet { public: - using value_type = typename ValInfo::value_type; - using value_type_ref = typename ValInfo::value_type_ref; - using TreeTy = ImutAVLTree; + typedef typename ValInfo::value_type value_type; + typedef typename ValInfo::value_type_ref value_type_ref; + typedef ImutAVLTree TreeTy; private: TreeTy *Root; @@ -978,10 +980,6 @@ 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(); } @@ -991,6 +989,10 @@ public: return *this; } + ~ImmutableSet() { + if (Root) { Root->release(); } + } + class Factory { typename TreeTy::Factory F; const bool Canonicalize; @@ -1082,7 +1084,7 @@ public: // Iterators. //===--------------------------------------------------===// - using iterator = ImutAVLValueIterator; + typedef ImutAVLValueIterator iterator; iterator begin() const { return iterator(Root); } iterator end() const { return iterator(); } @@ -1110,10 +1112,10 @@ public: template > class ImmutableSetRef { public: - using value_type = typename ValInfo::value_type; - using value_type_ref = typename ValInfo::value_type_ref; - using TreeTy = ImutAVLTree; - using FactoryTy = typename TreeTy::Factory; + typedef typename ValInfo::value_type value_type; + typedef typename ValInfo::value_type_ref value_type_ref; + typedef ImutAVLTree TreeTy; + typedef typename TreeTy::Factory FactoryTy; private: TreeTy *Root; @@ -1136,10 +1138,6 @@ 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(); } @@ -1149,6 +1147,9 @@ public: } return *this; } + ~ImmutableSetRef() { + if (Root) { Root->release(); } + } static ImmutableSetRef getEmptySet(FactoryTy *F) { return ImmutableSetRef(0, F); @@ -1195,7 +1196,7 @@ public: // Iterators. //===--------------------------------------------------===// - using iterator = ImutAVLValueIterator; + typedef ImutAVLValueIterator iterator; iterator begin() const { return iterator(Root); } iterator end() const { return iterator(); } diff --git a/llvm/include/llvm/ADT/IndexedMap.h b/llvm/include/llvm/ADT/IndexedMap.h index 04609d9..5ba85c0 100644 --- a/llvm/include/llvm/ADT/IndexedMap.h +++ b/llvm/include/llvm/ADT/IndexedMap.h @@ -23,25 +23,25 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include +#include namespace llvm { -template > +template > class IndexedMap { - using IndexT = typename ToIndexT::argument_type; + typedef typename ToIndexT::argument_type IndexT; // 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. - using StorageT = SmallVector; - + typedef SmallVector StorageT; 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 > } }; -} // end namespace llvm +} // End llvm namespace -#endif // LLVM_ADT_INDEXEDMAP_H +#endif diff --git a/llvm/include/llvm/ADT/IntervalMap.h b/llvm/include/llvm/ADT/IntervalMap.h index f713668..430b967 100644 --- a/llvm/include/llvm/ADT/IntervalMap.h +++ b/llvm/include/llvm/ADT/IntervalMap.h @@ -106,7 +106,6 @@ #include "llvm/Support/RecyclingAllocator.h" #include #include -#include #include #include #include @@ -187,7 +186,7 @@ struct IntervalMapHalfOpenInfo { /// It should be considered private to the implementation. namespace IntervalMapImpl { -using IdxPair = std::pair; +typedef std::pair IdxPair; //===----------------------------------------------------------------------===// //--- IntervalMapImpl::NodeBase ---// @@ -446,7 +445,7 @@ struct NodeSizer { LeafSize = DesiredLeafSize > MinLeafSize ? DesiredLeafSize : MinLeafSize }; - using LeafBase = NodeBase, ValT, LeafSize>; + typedef NodeBase, ValT, LeafSize> LeafBase; enum { // Now that we have the leaf branching factor, compute the actual allocation @@ -462,8 +461,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. - using Allocator = - RecyclingAllocator; + typedef RecyclingAllocator Allocator; }; //===----------------------------------------------------------------------===// @@ -931,12 +930,12 @@ template ::LeafSize, typename Traits = IntervalMapInfo> class IntervalMap { - using Sizer = IntervalMapImpl::NodeSizer; - using Leaf = IntervalMapImpl::LeafNode; - using Branch = - IntervalMapImpl::BranchNode; - using RootLeaf = IntervalMapImpl::LeafNode; - using IdxPair = IntervalMapImpl::IdxPair; + typedef IntervalMapImpl::NodeSizer Sizer; + typedef IntervalMapImpl::LeafNode Leaf; + typedef IntervalMapImpl::BranchNode + Branch; + typedef IntervalMapImpl::LeafNode RootLeaf; + typedef IntervalMapImpl::IdxPair IdxPair; // The RootLeaf capacity is given as a template parameter. We must compute the // corresponding RootBranch capacity. @@ -946,8 +945,8 @@ class IntervalMap { RootBranchCap = DesiredRootBranchCap ? DesiredRootBranchCap : 1 }; - using RootBranch = - IntervalMapImpl::BranchNode; + typedef IntervalMapImpl::BranchNode + RootBranch; // When branched, we store a global start key as well as the branch node. struct RootBranchData { @@ -956,10 +955,10 @@ class IntervalMap { }; public: - using Allocator = typename Sizer::Allocator; - using KeyType = KeyT; - using ValueType = ValT; - using KeyTraits = Traits; + typedef typename Sizer::Allocator Allocator; + typedef KeyT KeyType; + typedef ValT ValueType; + typedef Traits KeyTraits; private: // The root data is either a RootLeaf or a RootBranchData instance. @@ -1291,7 +1290,7 @@ protected: friend class IntervalMap; // The map referred to. - IntervalMap *map = nullptr; + IntervalMap *map; // We store a full path from the root to the current position. // The path may be partially filled, but never between iterator calls. @@ -1339,7 +1338,7 @@ protected: public: /// const_iterator - Create an iterator that isn't pointing anywhere. - const_iterator() = default; + const_iterator() : map(nullptr) {} /// setMap - Change the map iterated over. This call must be followed by a /// call to goToBegin(), goToEnd(), or find() @@ -1510,8 +1509,7 @@ const_iterator::treeAdvanceTo(KeyT x) { template class IntervalMap::iterator : public const_iterator { friend class IntervalMap; - - using IdxPair = IntervalMapImpl::IdxPair; + typedef IntervalMapImpl::IdxPair IdxPair; explicit iterator(IntervalMap &map) : const_iterator(map) {} @@ -2005,7 +2003,7 @@ iterator::overflow(unsigned Level) { // Elements have been rearranged, now update node sizes and stops. bool SplitRoot = false; unsigned Pos = 0; - while (true) { + for (;;) { KeyT Stop = Node[Pos]->stop(NewSize[Pos]-1); if (NewNode && Pos == NewNode) { SplitRoot = insertNode(Level, NodeRef(Node[Pos], NewSize[Pos]), Stop); @@ -2047,9 +2045,8 @@ iterator::overflow(unsigned Level) { /// template class IntervalMapOverlaps { - using KeyType = typename MapA::KeyType; - using Traits = typename MapA::KeyTraits; - + typedef typename MapA::KeyType KeyType; + typedef typename MapA::KeyTraits Traits; typename MapA::const_iterator posA; typename MapB::const_iterator posB; @@ -2074,7 +2071,7 @@ class IntervalMapOverlaps { // Already overlapping. return; - while (true) { + for (;;) { // Make a.end > b.start. posA.advanceTo(posB.start()); if (!posA.valid() || !Traits::stopLess(posB.stop(), posA.start())) diff --git a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h index 430ef86..a77cf04 100644 --- a/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h +++ b/llvm/include/llvm/ADT/IntrusiveRefCntPtr.h @@ -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,10 +73,9 @@ template class RefCountedBase { public: RefCountedBase() = default; - RefCountedBase(const RefCountedBase &) {} + RefCountedBase(const RefCountedBase &) : RefCount(0) {} void Retain() const { ++RefCount; } - void Release() const { assert(RefCount > 0 && "Reference count is already zero."); if (--RefCount == 0) @@ -137,7 +136,7 @@ template class IntrusiveRefCntPtr { T *Obj = nullptr; public: - using element_type = T; + typedef T element_type; explicit IntrusiveRefCntPtr() = default; IntrusiveRefCntPtr(T *obj) : Obj(obj) { retain(); } @@ -154,13 +153,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; } @@ -184,7 +183,6 @@ private: if (Obj) IntrusiveRefCntPtrInfo::retain(Obj); } - void release() { if (Obj) IntrusiveRefCntPtrInfo::release(Obj); @@ -250,16 +248,14 @@ bool operator!=(const IntrusiveRefCntPtr &A, std::nullptr_t B) { template struct simplify_type; template struct simplify_type> { - using SimpleType = T *; - + typedef T *SimpleType; static SimpleType getSimplifiedValue(IntrusiveRefCntPtr &Val) { return Val.get(); } }; template struct simplify_type> { - using SimpleType = /*const*/ T *; - + typedef /*const*/ T *SimpleType; static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr &Val) { return Val.get(); } diff --git a/llvm/include/llvm/ADT/MapVector.h b/llvm/include/llvm/ADT/MapVector.h index 26a555e..ac18857 100644 --- a/llvm/include/llvm/ADT/MapVector.h +++ b/llvm/include/llvm/ADT/MapVector.h @@ -19,12 +19,6 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/SmallVector.h" -#include -#include -#include -#include -#include -#include #include namespace llvm { @@ -33,20 +27,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 VectorType = std::vector>> + typename MapType = llvm::DenseMap, + typename VectorType = std::vector > > class MapVector { - using value_type = typename VectorType::value_type; - using size_type = typename VectorType::size_type; + typedef typename VectorType::value_type value_type; + typedef typename VectorType::size_type size_type; MapType Map; VectorType Vector; public: - 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; + 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; /// Clear the MapVector and return the underlying vector. VectorType takeVector() { @@ -226,4 +220,4 @@ struct SmallMapVector } // end namespace llvm -#endif // LLVM_ADT_MAPVECTOR_H +#endif diff --git a/llvm/include/llvm/ADT/Optional.h b/llvm/include/llvm/ADT/Optional.h index b782d9d..701872c 100644 --- a/llvm/include/llvm/ADT/Optional.h +++ b/llvm/include/llvm/ADT/Optional.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,8 +19,6 @@ #include "llvm/ADT/None.h" #include "llvm/Support/AlignOf.h" #include "llvm/Support/Compiler.h" -#include "llvm/Support/type_traits.h" -#include #include #include #include @@ -30,18 +28,15 @@ namespace llvm { template class Optional { AlignedCharArrayUnion storage; - bool hasVal = false; - + bool hasVal; public: - using value_type = T; - - Optional(NoneType) {} - explicit Optional() {} + typedef T value_type; + 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); @@ -50,18 +45,12 @@ public: Optional(T &&y) : hasVal(true) { new (storage.buffer) T(std::forward(y)); } - Optional(Optional &&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); @@ -71,7 +60,6 @@ public: } return *this; } - Optional &operator=(Optional &&O) { if (!O) reset(); @@ -124,6 +112,10 @@ public: } } + ~Optional() { + reset(); + } + const T* getPointer() const { assert(hasVal); return reinterpret_cast(storage.buffer); } T* getPointer() { assert(hasVal); return reinterpret_cast(storage.buffer); } const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); } @@ -152,7 +144,8 @@ public: #endif }; -template struct isPodLike> { +template struct isPodLike; +template struct isPodLike > { // An Optional is pod-like if T is. static const bool value = isPodLike::value; }; @@ -291,6 +284,6 @@ template bool operator>=(const T &X, const Optional &Y) { return !(X < Y); } -} // end namespace llvm +} // end llvm namespace -#endif // LLVM_ADT_OPTIONAL_H +#endif diff --git a/llvm/include/llvm/ADT/PackedVector.h b/llvm/include/llvm/ADT/PackedVector.h index 95adc29..8f925f1 100644 --- a/llvm/include/llvm/ADT/PackedVector.h +++ b/llvm/include/llvm/ADT/PackedVector.h @@ -76,8 +76,8 @@ template class PackedVector : public PackedVectorBase::is_signed> { BitVectorTy Bits; - using base = PackedVectorBase::is_signed>; + typedef PackedVectorBase::is_signed> base; 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(); } diff --git a/llvm/include/llvm/ADT/PointerEmbeddedInt.h b/llvm/include/llvm/ADT/PointerEmbeddedInt.h index 34323b5..2279d43 100644 --- a/llvm/include/llvm/ADT/PointerEmbeddedInt.h +++ b/llvm/include/llvm/ADT/PointerEmbeddedInt.h @@ -13,10 +13,7 @@ #include "llvm/ADT/DenseMapInfo.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/PointerLikeTypeTraits.h" -#include #include -#include -#include namespace llvm { @@ -32,7 +29,7 @@ namespace llvm { /// Also, the default constructed value zero initializes the integer. template class PointerEmbeddedInt { - uintptr_t Value = 0; + uintptr_t Value; // Note: This '<' is correct; using '<=' would result in some shifts // overflowing their storage types. @@ -57,12 +54,15 @@ class PointerEmbeddedInt { explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {} public: - PointerEmbeddedInt() = default; + PointerEmbeddedInt() : Value(0) {} - PointerEmbeddedInt(IntT I) { *this = I; } + PointerEmbeddedInt(IntT I) { + *this = I; + } PointerEmbeddedInt &operator=(IntT I) { - assert((std::is_signed::value ? isInt(I) : isUInt(I)) && + assert((std::is_signed::value ? llvm::isInt(I) + : llvm::isUInt(I)) && "Integer has bits outside those preserved!"); Value = static_cast(I) << Shift; return *this; @@ -81,17 +81,15 @@ public: // types. template class PointerLikeTypeTraits> { - using T = PointerEmbeddedInt; + typedef PointerEmbeddedInt T; public: static inline void *getAsVoidPointer(const T &P) { return reinterpret_cast(P.Value); } - static inline T getFromVoidPointer(void *P) { return T(reinterpret_cast(P), typename T::RawValueTag()); } - static inline T getFromVoidPointer(const void *P) { return T(reinterpret_cast(P), typename T::RawValueTag()); } @@ -103,19 +101,17 @@ public: // itself can be a key. template struct DenseMapInfo> { - using T = PointerEmbeddedInt; - using IntInfo = DenseMapInfo; + typedef PointerEmbeddedInt T; + + typedef DenseMapInfo IntInfo; 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; } }; +} -} // end namespace llvm - -#endif // LLVM_ADT_POINTEREMBEDDEDINT_H +#endif diff --git a/llvm/include/llvm/ADT/PointerIntPair.h b/llvm/include/llvm/ADT/PointerIntPair.h index 2d49add..83fbf12 100644 --- a/llvm/include/llvm/ADT/PointerIntPair.h +++ b/llvm/include/llvm/ADT/PointerIntPair.h @@ -14,9 +14,9 @@ #ifndef LLVM_ADT_POINTERINTPAIR_H #define LLVM_ADT_POINTERINTPAIR_H +#include "llvm/Support/Compiler.h" #include "llvm/Support/PointerLikeTypeTraits.h" #include -#include #include namespace llvm { @@ -44,20 +44,20 @@ template , typename Info = PointerIntPairInfo> class PointerIntPair { - intptr_t Value = 0; + intptr_t Value; public: - PointerIntPair() = default; - + PointerIntPair() : Value(0) {} PointerIntPair(PointerTy PtrVal, IntType IntVal) { setPointerAndInt(PtrVal, IntVal); } - explicit PointerIntPair(PointerTy PtrVal) { initWithPointer(PtrVal); } PointerTy getPointer() const { return Info::getPointer(Value); } - IntType getInt() const { return (IntType)Info::getInt(Value); } + IntType getInt() const { + return (IntType)Info::getInt(Value); + } void setPointer(PointerTy PtrVal) { Value = Info::updatePointer(Value, PtrVal); @@ -88,7 +88,6 @@ public: } void *getOpaqueValue() const { return reinterpret_cast(Value); } - void setFromOpaqueValue(void *Val) { Value = reinterpret_cast(Val); } @@ -109,18 +108,14 @@ public: bool operator==(const PointerIntPair &RHS) const { return Value == RHS.Value; } - bool operator!=(const PointerIntPair &RHS) const { return Value != RHS.Value; } - bool operator<(const PointerIntPair &RHS) const { return Value < RHS.Value; } bool operator>(const PointerIntPair &RHS) const { return Value > RHS.Value; } - bool operator<=(const PointerIntPair &RHS) const { return Value <= RHS.Value; } - bool operator>=(const PointerIntPair &RHS) const { return Value >= RHS.Value; } @@ -185,25 +180,21 @@ struct isPodLike> { // Provide specialization of DenseMapInfo for PointerIntPair. template struct DenseMapInfo> { - using Ty = PointerIntPair; - + typedef PointerIntPair Ty; static Ty getEmptyKey() { uintptr_t Val = static_cast(-1); Val <<= PointerLikeTypeTraits::NumLowBitsAvailable; return Ty::getFromOpaqueValue(reinterpret_cast(Val)); } - static Ty getTombstoneKey() { uintptr_t Val = static_cast(-2); Val <<= PointerLikeTypeTraits::NumLowBitsAvailable; return Ty::getFromOpaqueValue(reinterpret_cast(Val)); } - static unsigned getHashValue(Ty V) { uintptr_t IV = reinterpret_cast(V.getOpaqueValue()); return unsigned(IV) ^ unsigned(IV >> 9); } - static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; } }; @@ -217,20 +208,16 @@ public: getAsVoidPointer(const PointerIntPair &P) { return P.getOpaqueValue(); } - static inline PointerIntPair getFromVoidPointer(void *P) { return PointerIntPair::getFromOpaqueValue(P); } - static inline PointerIntPair getFromVoidPointer(const void *P) { return PointerIntPair::getFromOpaqueValue(P); } - enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits }; }; } // end namespace llvm - -#endif // LLVM_ADT_POINTERINTPAIR_H +#endif diff --git a/llvm/include/llvm/ADT/PointerSumType.h b/llvm/include/llvm/ADT/PointerSumType.h index 825c62b..062544e 100644 --- a/llvm/include/llvm/ADT/PointerSumType.h +++ b/llvm/include/llvm/ADT/PointerSumType.h @@ -11,10 +11,8 @@ #define LLVM_ADT_POINTERSUMTYPE_H #include "llvm/ADT/DenseMapInfo.h" +#include "llvm/Support/Compiler.h" #include "llvm/Support/PointerLikeTypeTraits.h" -#include -#include -#include namespace llvm { @@ -26,15 +24,16 @@ template > struct PointerSumTypeMember { enum { Tag = N }; - using PointerT = PointerArgT; - using TraitsT = TraitsArgT; + typedef PointerArgT PointerT; + typedef TraitsArgT TraitsT; }; namespace detail { -template struct PointerSumTypeHelper; +template +struct PointerSumTypeHelper; -} // end namespace detail +} /// A sum type over pointer-like types. /// @@ -61,12 +60,12 @@ template struct PointerSumTypeHelper; /// There is no support for constructing or accessing with a dynamic tag as /// that would fundamentally violate the type safety provided by the sum type. template class PointerSumType { - uintptr_t Value = 0; + uintptr_t Value; - using HelperT = detail::PointerSumTypeHelper; + typedef detail::PointerSumTypeHelper HelperT; public: - PointerSumType() = default; + PointerSumType() : Value(0) {} /// A typed constructor for a specific tagged member of the sum type. template @@ -129,14 +128,14 @@ struct PointerSumTypeHelper : MemberTs... { template static void LookupOverload(...); template struct Lookup { // Compute a particular member type by resolving the lookup helper ovorload. - using MemberT = decltype( - LookupOverload(static_cast(nullptr))); + typedef decltype(LookupOverload( + static_cast(nullptr))) MemberT; /// The Nth member's pointer type. - using PointerT = typename MemberT::PointerT; + typedef typename MemberT::PointerT PointerT; /// The Nth member's traits type. - using TraitsT = typename MemberT::TraitsT; + typedef typename MemberT::TraitsT TraitsT; }; // Next we need to compute the number of bits available for the discriminant @@ -172,37 +171,35 @@ struct PointerSumTypeHelper : MemberTs... { "Each member must pass the checker."); }; -} // end namespace detail +} // Teach DenseMap how to use PointerSumTypes as keys. template struct DenseMapInfo> { - using SumType = PointerSumType; + typedef PointerSumType SumType; - using HelperT = detail::PointerSumTypeHelper; + typedef detail::PointerSumTypeHelper HelperT; enum { SomeTag = HelperT::MinTag }; - using SomePointerT = - typename HelperT::template Lookup::PointerT; - using SomePointerInfo = DenseMapInfo; + typedef typename HelperT::template Lookup::PointerT + SomePointerT; + typedef DenseMapInfo SomePointerInfo; static inline SumType getEmptyKey() { return SumType::create(SomePointerInfo::getEmptyKey()); } - static inline SumType getTombstoneKey() { - return SumType::create(SomePointerInfo::getTombstoneKey()); + return SumType::create( + SomePointerInfo::getTombstoneKey()); } - static unsigned getHashValue(const SumType &Arg) { uintptr_t OpaqueValue = Arg.getOpaqueValue(); return DenseMapInfo::getHashValue(OpaqueValue); } - static bool isEqual(const SumType &LHS, const SumType &RHS) { return LHS == RHS; } }; -} // end namespace llvm +} -#endif // LLVM_ADT_POINTERSUMTYPE_H +#endif diff --git a/llvm/include/llvm/ADT/PointerUnion.h b/llvm/include/llvm/ADT/PointerUnion.h index d0497dd..9eb1552 100644 --- a/llvm/include/llvm/ADT/PointerUnion.h +++ b/llvm/include/llvm/ADT/PointerUnion.h @@ -19,13 +19,13 @@ #include "llvm/ADT/PointerIntPair.h" #include "llvm/Support/PointerLikeTypeTraits.h" #include -#include #include +#include namespace llvm { template struct PointerUnionTypeSelectorReturn { - using Return = T; + typedef T Return; }; /// Get a type based on whether two types are the same or not. @@ -39,19 +39,19 @@ template struct PointerUnionTypeSelectorReturn { /// Ret will be EQ type if T1 is same as T2 or NE type otherwise. template struct PointerUnionTypeSelector { - using Return = typename PointerUnionTypeSelectorReturn::Return; + typedef typename PointerUnionTypeSelectorReturn::Return Return; }; template struct PointerUnionTypeSelector { - using Return = typename PointerUnionTypeSelectorReturn::Return; + typedef typename PointerUnionTypeSelectorReturn::Return Return; }; template struct PointerUnionTypeSelectorReturn< PointerUnionTypeSelector> { - using Return = - typename PointerUnionTypeSelector::Return; + typedef + typename PointerUnionTypeSelector::Return Return; }; /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion @@ -86,8 +86,8 @@ public: /// X = P.get(); // runtime assertion failure. template class PointerUnion { public: - using ValTy = - PointerIntPair>; + typedef PointerIntPair> + ValTy; private: ValTy Val; @@ -121,10 +121,10 @@ public: /// Test if the Union currently holds the type matching T. template int is() const { - using Ty = typename ::llvm::PointerUnionTypeSelector< - PT1, T, IsPT1, - ::llvm::PointerUnionTypeSelector>>::Return; + typedef typename ::llvm::PointerUnionTypeSelector< + PT1, T, IsPT1, ::llvm::PointerUnionTypeSelector< + PT2, T, IsPT2, UNION_DOESNT_CONTAIN_TYPE>>::Return + Ty; int TyNo = Ty::Num; return static_cast(Val.getInt()) == TyNo; } @@ -228,22 +228,19 @@ public: /// for usage. template class PointerUnion3 { public: - using InnerUnion = PointerUnion; - using ValTy = PointerUnion; + typedef PointerUnion InnerUnion; + typedef PointerUnion ValTy; private: ValTy Val; struct IsInnerUnion { ValTy Val; - IsInnerUnion(ValTy val) : Val(val) {} - template int is() const { return Val.template is() && Val.template get().template is(); } - template T get() const { return Val.template get().template get(); } @@ -251,15 +248,14 @@ private: struct IsPT3 { ValTy Val; - IsPT3(ValTy val) : Val(val) {} - template int is() const { return Val.template is(); } template T get() const { return Val.template get(); } }; public: PointerUnion3() = default; + PointerUnion3(PT1 V) { Val = InnerUnion(V); } PointerUnion3(PT2 V) { Val = InnerUnion(V); } PointerUnion3(PT3 V) { Val = V; } @@ -272,9 +268,10 @@ public: /// Test if the Union currently holds the type matching T. template int is() const { // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3. - using Ty = typename ::llvm::PointerUnionTypeSelector< + typedef typename ::llvm::PointerUnionTypeSelector< PT1, T, IsInnerUnion, - ::llvm::PointerUnionTypeSelector>::Return; + ::llvm::PointerUnionTypeSelector>::Return + Ty; return Ty(Val).template is(); } @@ -284,9 +281,10 @@ public: template T get() const { assert(is() && "Invalid accessor called"); // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3. - using Ty = typename ::llvm::PointerUnionTypeSelector< + typedef typename ::llvm::PointerUnionTypeSelector< PT1, T, IsInnerUnion, - ::llvm::PointerUnionTypeSelector>::Return; + ::llvm::PointerUnionTypeSelector>::Return + Ty; return Ty(Val).template get(); } @@ -352,15 +350,16 @@ public: template class PointerUnion4 { public: - using InnerUnion1 = PointerUnion; - using InnerUnion2 = PointerUnion; - using ValTy = PointerUnion; + typedef PointerUnion InnerUnion1; + typedef PointerUnion InnerUnion2; + typedef PointerUnion ValTy; private: ValTy Val; public: PointerUnion4() = default; + PointerUnion4(PT1 V) { Val = InnerUnion1(V); } PointerUnion4(PT2 V) { Val = InnerUnion1(V); } PointerUnion4(PT3 V) { Val = InnerUnion2(V); } @@ -374,10 +373,9 @@ public: /// Test if the Union currently holds the type matching T. template int is() const { // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2. - using Ty = typename ::llvm::PointerUnionTypeSelector< - PT1, T, InnerUnion1, - ::llvm::PointerUnionTypeSelector>::Return; + typedef typename ::llvm::PointerUnionTypeSelector< + PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector< + PT2, T, InnerUnion1, InnerUnion2>>::Return Ty; return Val.template is() && Val.template get().template is(); } @@ -387,10 +385,9 @@ public: template T get() const { assert(is() && "Invalid accessor called"); // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2. - using Ty = typename ::llvm::PointerUnionTypeSelector< - PT1, T, InnerUnion1, - ::llvm::PointerUnionTypeSelector>::Return; + typedef typename ::llvm::PointerUnionTypeSelector< + PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector< + PT2, T, InnerUnion1, InnerUnion2>>::Return Ty; return Val.template get().template get(); } @@ -458,21 +455,18 @@ public: // Teach DenseMap how to use PointerUnions as keys. template struct DenseMapInfo> { - using Pair = PointerUnion; - using FirstInfo = DenseMapInfo; - using SecondInfo = DenseMapInfo; + typedef PointerUnion Pair; + typedef DenseMapInfo FirstInfo; + typedef DenseMapInfo SecondInfo; static inline Pair getEmptyKey() { return Pair(FirstInfo::getEmptyKey()); } - static inline Pair getTombstoneKey() { return Pair(FirstInfo::getTombstoneKey()); } - static unsigned getHashValue(const Pair &PairVal) { intptr_t key = (intptr_t)PairVal.getOpaqueValue(); return DenseMapInfo::getHashValue(key); } - static bool isEqual(const Pair &LHS, const Pair &RHS) { return LHS.template is() == RHS.template is() && (LHS.template is() ? FirstInfo::isEqual(LHS.template get(), diff --git a/llvm/include/llvm/ADT/simple_ilist.h b/llvm/include/llvm/ADT/simple_ilist.h index 4c7598a..a1ab591 100644 --- a/llvm/include/llvm/ADT/simple_ilist.h +++ b/llvm/include/llvm/ADT/simple_ilist.h @@ -13,14 +13,9 @@ #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 #include #include -#include -#include -#include namespace llvm { @@ -82,23 +77,23 @@ class simple_ilist typename ilist_detail::compute_node_options::type> { static_assert(ilist_detail::check_options::value, "Unrecognized node option!"); - using OptionsT = - typename ilist_detail::compute_node_options::type; - using list_base_type = typename OptionsT::list_base_type; + typedef + typename ilist_detail::compute_node_options::type OptionsT; + typedef typename OptionsT::list_base_type list_base_type; ilist_sentinel Sentinel; public: - 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; - using const_iterator = ilist_iterator; - using reverse_iterator = ilist_iterator; - using const_reverse_iterator = ilist_iterator; - using size_type = size_t; - using difference_type = ptrdiff_t; + 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 iterator; + typedef ilist_iterator const_iterator; + typedef ilist_iterator reverse_iterator; + typedef ilist_iterator const_reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; simple_ilist() = default; ~simple_ilist() = default; -- 2.7.4