mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
[ADT] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).
llvm-svn: 316818
This commit is contained in:
Eugene Zelenko
parent
1745f38fdd
commit
df1c971e39
@ -1,4 +1,4 @@
|
||||
//===-- llvm/ADT/FoldingSet.h - Uniquing Hash Set ---------------*- C++ -*-===//
|
||||
//===- llvm/ADT/FoldingSet.h - Uniquing Hash Set ----------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -115,11 +115,9 @@ class FoldingSetBase {
|
||||
|
||||
protected:
|
||||
/// Buckets - Array of bucket chains.
|
||||
///
|
||||
void **Buckets;
|
||||
|
||||
/// NumBuckets - Length of the Buckets array. Always a power of 2.
|
||||
///
|
||||
unsigned NumBuckets;
|
||||
|
||||
/// NumNodes - Number of nodes in the folding set. Growth occurs when NumNodes
|
||||
@ -135,14 +133,13 @@ public:
|
||||
//===--------------------------------------------------------------------===//
|
||||
/// Node - This class is used to maintain the singly linked bucket list in
|
||||
/// a folding set.
|
||||
///
|
||||
class Node {
|
||||
private:
|
||||
// NextInFoldingSetBucket - next link in the bucket list.
|
||||
void *NextInFoldingSetBucket;
|
||||
void *NextInFoldingSetBucket = nullptr;
|
||||
|
||||
public:
|
||||
Node() : NextInFoldingSetBucket(nullptr) {}
|
||||
Node() = default;
|
||||
|
||||
// Accessors
|
||||
void *getNextInBucket() const { return NextInFoldingSetBucket; }
|
||||
@ -221,7 +218,6 @@ protected:
|
||||
|
||||
/// DefaultFoldingSetTrait - This class provides default implementations
|
||||
/// for FoldingSetTrait implementations.
|
||||
///
|
||||
template<typename T> struct DefaultFoldingSetTrait {
|
||||
static void Profile(const T &X, FoldingSetNodeID &ID) {
|
||||
X.Profile(ID);
|
||||
@ -307,7 +303,6 @@ public:
|
||||
/// FoldingSetNodeID - This class is used to gather all the unique data bits of
|
||||
/// a node. When all the bits are gathered this class is used to produce a
|
||||
/// hash value for the node.
|
||||
///
|
||||
class FoldingSetNodeID {
|
||||
/// Bits - Vector of all the data bits that make the node unique.
|
||||
/// Use a SmallVector to avoid a heap allocation in the common case.
|
||||
@ -320,7 +315,6 @@ public:
|
||||
: Bits(Ref.getData(), Ref.getData() + Ref.getSize()) {}
|
||||
|
||||
/// Add* - Add various data types to Bit data.
|
||||
///
|
||||
void AddPointer(const void *Ptr);
|
||||
void AddInteger(signed I);
|
||||
void AddInteger(unsigned I);
|
||||
@ -344,7 +338,6 @@ public:
|
||||
unsigned ComputeHash() const;
|
||||
|
||||
/// operator== - Used to compare two nodes to each other.
|
||||
///
|
||||
bool operator==(const FoldingSetNodeID &RHS) const;
|
||||
bool operator==(const FoldingSetNodeIDRef RHS) const;
|
||||
|
||||
@ -363,7 +356,7 @@ public:
|
||||
};
|
||||
|
||||
// Convenience type to hide the implementation of the folding set.
|
||||
typedef FoldingSetBase::Node FoldingSetNode;
|
||||
using FoldingSetNode = FoldingSetBase::Node;
|
||||
template<class T> class FoldingSetIterator;
|
||||
template<class T> class FoldingSetBucketIterator;
|
||||
|
||||
@ -415,15 +408,17 @@ protected:
|
||||
~FoldingSetImpl() = default;
|
||||
|
||||
public:
|
||||
typedef FoldingSetIterator<T> iterator;
|
||||
using iterator = FoldingSetIterator<T>;
|
||||
|
||||
iterator begin() { return iterator(Buckets); }
|
||||
iterator end() { return iterator(Buckets+NumBuckets); }
|
||||
|
||||
typedef FoldingSetIterator<const T> const_iterator;
|
||||
using const_iterator = FoldingSetIterator<const T>;
|
||||
|
||||
const_iterator begin() const { return const_iterator(Buckets); }
|
||||
const_iterator end() const { return const_iterator(Buckets+NumBuckets); }
|
||||
|
||||
typedef FoldingSetBucketIterator<T> bucket_iterator;
|
||||
using bucket_iterator = FoldingSetBucketIterator<T>;
|
||||
|
||||
bucket_iterator bucket_begin(unsigned hash) {
|
||||
return bucket_iterator(Buckets + (hash & (NumBuckets-1)));
|
||||
@ -503,9 +498,7 @@ template <class T> class FoldingSet final : public FoldingSetImpl<T> {
|
||||
}
|
||||
|
||||
public:
|
||||
explicit FoldingSet(unsigned Log2InitSize = 6)
|
||||
: Super(Log2InitSize) {}
|
||||
|
||||
explicit FoldingSet(unsigned Log2InitSize = 6) : Super(Log2InitSize) {}
|
||||
FoldingSet(FoldingSet &&Arg) = default;
|
||||
FoldingSet &operator=(FoldingSet &&RHS) = default;
|
||||
};
|
||||
@ -552,8 +545,7 @@ class ContextualFoldingSet final : public FoldingSetImpl<T> {
|
||||
|
||||
public:
|
||||
explicit ContextualFoldingSet(Ctx Context, unsigned Log2InitSize = 6)
|
||||
: Super(Log2InitSize), Context(Context)
|
||||
{}
|
||||
: Super(Log2InitSize), Context(Context) {}
|
||||
|
||||
Ctx getContext() const { return Context; }
|
||||
};
|
||||
@ -569,15 +561,15 @@ class FoldingSetVector {
|
||||
VectorT Vector;
|
||||
|
||||
public:
|
||||
explicit FoldingSetVector(unsigned Log2InitSize = 6)
|
||||
: Set(Log2InitSize) {
|
||||
}
|
||||
explicit FoldingSetVector(unsigned Log2InitSize = 6) : Set(Log2InitSize) {}
|
||||
|
||||
using iterator = pointee_iterator<typename VectorT::iterator>;
|
||||
|
||||
typedef pointee_iterator<typename VectorT::iterator> iterator;
|
||||
iterator begin() { return Vector.begin(); }
|
||||
iterator end() { return Vector.end(); }
|
||||
|
||||
typedef pointee_iterator<typename VectorT::const_iterator> const_iterator;
|
||||
using const_iterator = pointee_iterator<typename VectorT::const_iterator>;
|
||||
|
||||
const_iterator begin() const { return Vector.begin(); }
|
||||
const_iterator end() const { return Vector.end(); }
|
||||
|
||||
@ -667,15 +659,13 @@ public:
|
||||
/// FoldingSetBucketIteratorImpl - This is the common bucket iterator support
|
||||
/// shared by all folding sets, which knows how to walk a particular bucket
|
||||
/// of a folding set hash table.
|
||||
|
||||
class FoldingSetBucketIteratorImpl {
|
||||
protected:
|
||||
void *Ptr;
|
||||
|
||||
explicit FoldingSetBucketIteratorImpl(void **Bucket);
|
||||
|
||||
FoldingSetBucketIteratorImpl(void **Bucket, bool)
|
||||
: Ptr(Bucket) {}
|
||||
FoldingSetBucketIteratorImpl(void **Bucket, bool) : Ptr(Bucket) {}
|
||||
|
||||
void advance() {
|
||||
void *Probe = static_cast<FoldingSetNode*>(Ptr)->getNextInBucket();
|
||||
|
||||
@ -14,15 +14,14 @@
|
||||
#ifndef LLVM_ADT_POINTERINTPAIR_H
|
||||
#define LLVM_ADT_POINTERINTPAIR_H
|
||||
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/PointerLikeTypeTraits.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
template <typename T> struct DenseMapInfo;
|
||||
|
||||
template <typename PointerT, unsigned IntBits, typename PtrTraits>
|
||||
struct PointerIntPairInfo;
|
||||
|
||||
@ -39,25 +38,24 @@ struct PointerIntPairInfo;
|
||||
/// for something else. For example, this allows:
|
||||
/// PointerIntPair<PointerIntPair<void*, 1, bool>, 1, bool>
|
||||
/// ... and the two bools will land in different bits.
|
||||
///
|
||||
template <typename PointerTy, unsigned IntBits, typename IntType = unsigned,
|
||||
typename PtrTraits = PointerLikeTypeTraits<PointerTy>,
|
||||
typename Info = PointerIntPairInfo<PointerTy, IntBits, PtrTraits>>
|
||||
class PointerIntPair {
|
||||
intptr_t Value;
|
||||
intptr_t Value = 0;
|
||||
|
||||
public:
|
||||
constexpr PointerIntPair() : Value(0) {}
|
||||
constexpr PointerIntPair() = default;
|
||||
|
||||
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,6 +86,7 @@ public:
|
||||
}
|
||||
|
||||
void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
|
||||
|
||||
void setFromOpaqueValue(void *Val) {
|
||||
Value = reinterpret_cast<intptr_t>(Val);
|
||||
}
|
||||
@ -108,14 +107,18 @@ 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;
|
||||
}
|
||||
@ -180,21 +183,25 @@ struct isPodLike<PointerIntPair<PointerTy, IntBits, IntType>> {
|
||||
// Provide specialization of DenseMapInfo for PointerIntPair.
|
||||
template <typename PointerTy, unsigned IntBits, typename IntType>
|
||||
struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType>> {
|
||||
typedef PointerIntPair<PointerTy, IntBits, IntType> Ty;
|
||||
using Ty = PointerIntPair<PointerTy, IntBits, IntType>;
|
||||
|
||||
static Ty getEmptyKey() {
|
||||
uintptr_t Val = static_cast<uintptr_t>(-1);
|
||||
Val <<= PointerLikeTypeTraits<Ty>::NumLowBitsAvailable;
|
||||
return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
|
||||
}
|
||||
|
||||
static Ty getTombstoneKey() {
|
||||
uintptr_t Val = static_cast<uintptr_t>(-2);
|
||||
Val <<= PointerLikeTypeTraits<PointerTy>::NumLowBitsAvailable;
|
||||
return Ty::getFromOpaqueValue(reinterpret_cast<void *>(Val));
|
||||
}
|
||||
|
||||
static unsigned getHashValue(Ty V) {
|
||||
uintptr_t IV = reinterpret_cast<uintptr_t>(V.getOpaqueValue());
|
||||
return unsigned(IV) ^ unsigned(IV >> 9);
|
||||
}
|
||||
|
||||
static bool isEqual(const Ty &LHS, const Ty &RHS) { return LHS == RHS; }
|
||||
};
|
||||
|
||||
@ -207,16 +214,20 @@ struct PointerLikeTypeTraits<
|
||||
getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
|
||||
return P.getOpaqueValue();
|
||||
}
|
||||
|
||||
static inline PointerIntPair<PointerTy, IntBits, IntType>
|
||||
getFromVoidPointer(void *P) {
|
||||
return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
|
||||
}
|
||||
|
||||
static inline PointerIntPair<PointerTy, IntBits, IntType>
|
||||
getFromVoidPointer(const void *P) {
|
||||
return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
|
||||
}
|
||||
|
||||
enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
|
||||
};
|
||||
|
||||
} // end namespace llvm
|
||||
#endif
|
||||
|
||||
#endif // LLVM_ADT_POINTERINTPAIR_H
|
||||
|
||||
@ -11,8 +11,10 @@
|
||||
#define LLVM_ADT_POINTERSUMTYPE_H
|
||||
|
||||
#include "llvm/ADT/DenseMapInfo.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/PointerLikeTypeTraits.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -24,16 +26,15 @@ template <uintptr_t N, typename PointerArgT,
|
||||
typename TraitsArgT = PointerLikeTypeTraits<PointerArgT>>
|
||||
struct PointerSumTypeMember {
|
||||
enum { Tag = N };
|
||||
typedef PointerArgT PointerT;
|
||||
typedef TraitsArgT TraitsT;
|
||||
using PointerT = PointerArgT;
|
||||
using TraitsT = TraitsArgT;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename TagT, typename... MemberTs>
|
||||
struct PointerSumTypeHelper;
|
||||
template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper;
|
||||
|
||||
}
|
||||
} // end namespace detail
|
||||
|
||||
/// A sum type over pointer-like types.
|
||||
///
|
||||
@ -60,12 +61,12 @@ 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 <typename TagT, typename... MemberTs> class PointerSumType {
|
||||
uintptr_t Value;
|
||||
uintptr_t Value = 0;
|
||||
|
||||
typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
|
||||
using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
|
||||
|
||||
public:
|
||||
constexpr PointerSumType() : Value(0) {}
|
||||
constexpr PointerSumType() = default;
|
||||
|
||||
/// A typed constructor for a specific tagged member of the sum type.
|
||||
template <TagT N>
|
||||
@ -128,14 +129,14 @@ struct PointerSumTypeHelper : MemberTs... {
|
||||
template <TagT N> static void LookupOverload(...);
|
||||
template <TagT N> struct Lookup {
|
||||
// Compute a particular member type by resolving the lookup helper ovorload.
|
||||
typedef decltype(LookupOverload<N>(
|
||||
static_cast<PointerSumTypeHelper *>(nullptr))) MemberT;
|
||||
using MemberT = decltype(
|
||||
LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr)));
|
||||
|
||||
/// The Nth member's pointer type.
|
||||
typedef typename MemberT::PointerT PointerT;
|
||||
using PointerT = typename MemberT::PointerT;
|
||||
|
||||
/// The Nth member's traits type.
|
||||
typedef typename MemberT::TraitsT TraitsT;
|
||||
using TraitsT = typename MemberT::TraitsT;
|
||||
};
|
||||
|
||||
// Next we need to compute the number of bits available for the discriminant
|
||||
@ -171,35 +172,36 @@ struct PointerSumTypeHelper : MemberTs... {
|
||||
"Each member must pass the checker.");
|
||||
};
|
||||
|
||||
}
|
||||
} // end namespace detail
|
||||
|
||||
// Teach DenseMap how to use PointerSumTypes as keys.
|
||||
template <typename TagT, typename... MemberTs>
|
||||
struct DenseMapInfo<PointerSumType<TagT, MemberTs...>> {
|
||||
typedef PointerSumType<TagT, MemberTs...> SumType;
|
||||
|
||||
typedef detail::PointerSumTypeHelper<TagT, MemberTs...> HelperT;
|
||||
using SumType = PointerSumType<TagT, MemberTs...>;
|
||||
using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
|
||||
enum { SomeTag = HelperT::MinTag };
|
||||
typedef typename HelperT::template Lookup<HelperT::MinTag>::PointerT
|
||||
SomePointerT;
|
||||
typedef DenseMapInfo<SomePointerT> SomePointerInfo;
|
||||
using SomePointerT =
|
||||
typename HelperT::template Lookup<HelperT::MinTag>::PointerT;
|
||||
using SomePointerInfo = DenseMapInfo<SomePointerT>;
|
||||
|
||||
static inline SumType getEmptyKey() {
|
||||
return SumType::create<SomeTag>(SomePointerInfo::getEmptyKey());
|
||||
}
|
||||
|
||||
static inline SumType getTombstoneKey() {
|
||||
return SumType::create<SomeTag>(
|
||||
SomePointerInfo::getTombstoneKey());
|
||||
return SumType::create<SomeTag>(SomePointerInfo::getTombstoneKey());
|
||||
}
|
||||
|
||||
static unsigned getHashValue(const SumType &Arg) {
|
||||
uintptr_t OpaqueValue = Arg.getOpaqueValue();
|
||||
return DenseMapInfo<uintptr_t>::getHashValue(OpaqueValue);
|
||||
}
|
||||
|
||||
static bool isEqual(const SumType &LHS, const SumType &RHS) {
|
||||
return LHS == RHS;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_ADT_POINTERSUMTYPE_H
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
namespace llvm {
|
||||
|
||||
template <typename T> struct PointerUnionTypeSelectorReturn {
|
||||
typedef T Return;
|
||||
using Return = T;
|
||||
};
|
||||
|
||||
/// Get a type based on whether two types are the same or not.
|
||||
@ -33,25 +33,25 @@ template <typename T> struct PointerUnionTypeSelectorReturn {
|
||||
/// For:
|
||||
///
|
||||
/// \code
|
||||
/// typedef typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return Ret;
|
||||
/// using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
|
||||
/// \endcode
|
||||
///
|
||||
/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
|
||||
template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
|
||||
struct PointerUnionTypeSelector {
|
||||
typedef typename PointerUnionTypeSelectorReturn<RET_NE>::Return Return;
|
||||
using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
|
||||
};
|
||||
|
||||
template <typename T, typename RET_EQ, typename RET_NE>
|
||||
struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
|
||||
typedef typename PointerUnionTypeSelectorReturn<RET_EQ>::Return Return;
|
||||
using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
|
||||
};
|
||||
|
||||
template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
|
||||
struct PointerUnionTypeSelectorReturn<
|
||||
PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
|
||||
typedef
|
||||
typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return Return;
|
||||
using Return =
|
||||
typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
|
||||
};
|
||||
|
||||
/// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
|
||||
@ -86,8 +86,8 @@ public:
|
||||
/// X = P.get<int*>(); // runtime assertion failure.
|
||||
template <typename PT1, typename PT2> class PointerUnion {
|
||||
public:
|
||||
typedef PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>
|
||||
ValTy;
|
||||
using ValTy =
|
||||
PointerIntPair<void *, 1, bool, PointerUnionUIntTraits<PT1, PT2>>;
|
||||
|
||||
private:
|
||||
ValTy Val;
|
||||
@ -102,7 +102,6 @@ private:
|
||||
|
||||
public:
|
||||
PointerUnion() = default;
|
||||
|
||||
PointerUnion(PT1 V)
|
||||
: Val(const_cast<void *>(
|
||||
PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) {}
|
||||
@ -117,14 +116,15 @@ public:
|
||||
// we recursively strip off low bits if we have a nested PointerUnion.
|
||||
return !PointerLikeTypeTraits<PT1>::getFromVoidPointer(Val.getPointer());
|
||||
}
|
||||
|
||||
explicit operator bool() const { return !isNull(); }
|
||||
|
||||
/// Test if the Union currently holds the type matching T.
|
||||
template <typename T> int is() const {
|
||||
typedef typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, IsPT1, ::llvm::PointerUnionTypeSelector<
|
||||
PT2, T, IsPT2, UNION_DOESNT_CONTAIN_TYPE<T>>>::Return
|
||||
Ty;
|
||||
using Ty = typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, IsPT1,
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, IsPT2,
|
||||
UNION_DOESNT_CONTAIN_TYPE<T>>>::Return;
|
||||
int TyNo = Ty::Num;
|
||||
return static_cast<int>(Val.getInt()) == TyNo;
|
||||
}
|
||||
@ -158,7 +158,8 @@ public:
|
||||
assert(
|
||||
get<PT1>() == Val.getPointer() &&
|
||||
"Can't get the address because PointerLikeTypeTraits changes the ptr");
|
||||
return const_cast<PT1 *>(reinterpret_cast<const PT1 *>(Val.getAddrOfPointer()));
|
||||
return const_cast<PT1 *>(
|
||||
reinterpret_cast<const PT1 *>(Val.getAddrOfPointer()));
|
||||
}
|
||||
|
||||
/// Assignment from nullptr which just clears the union.
|
||||
@ -227,19 +228,22 @@ struct PointerLikeTypeTraits<PointerUnion<PT1, PT2>> {
|
||||
/// for usage.
|
||||
template <typename PT1, typename PT2, typename PT3> class PointerUnion3 {
|
||||
public:
|
||||
typedef PointerUnion<PT1, PT2> InnerUnion;
|
||||
typedef PointerUnion<InnerUnion, PT3> ValTy;
|
||||
using InnerUnion = PointerUnion<PT1, PT2>;
|
||||
using ValTy = PointerUnion<InnerUnion, PT3>;
|
||||
|
||||
private:
|
||||
ValTy Val;
|
||||
|
||||
struct IsInnerUnion {
|
||||
ValTy Val;
|
||||
|
||||
IsInnerUnion(ValTy val) : Val(val) {}
|
||||
|
||||
template <typename T> int is() const {
|
||||
return Val.template is<InnerUnion>() &&
|
||||
Val.template get<InnerUnion>().template is<T>();
|
||||
}
|
||||
|
||||
template <typename T> T get() const {
|
||||
return Val.template get<InnerUnion>().template get<T>();
|
||||
}
|
||||
@ -247,14 +251,15 @@ private:
|
||||
|
||||
struct IsPT3 {
|
||||
ValTy Val;
|
||||
|
||||
IsPT3(ValTy val) : Val(val) {}
|
||||
|
||||
template <typename T> int is() const { return Val.template is<T>(); }
|
||||
template <typename T> T get() const { return Val.template get<T>(); }
|
||||
};
|
||||
|
||||
public:
|
||||
PointerUnion3() = default;
|
||||
|
||||
PointerUnion3(PT1 V) { Val = InnerUnion(V); }
|
||||
PointerUnion3(PT2 V) { Val = InnerUnion(V); }
|
||||
PointerUnion3(PT3 V) { Val = V; }
|
||||
@ -267,10 +272,9 @@ public:
|
||||
/// Test if the Union currently holds the type matching T.
|
||||
template <typename T> int is() const {
|
||||
// If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
|
||||
typedef typename ::llvm::PointerUnionTypeSelector<
|
||||
using Ty = typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, IsInnerUnion,
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
|
||||
Ty;
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
|
||||
return Ty(Val).template is<T>();
|
||||
}
|
||||
|
||||
@ -280,10 +284,9 @@ public:
|
||||
template <typename T> T get() const {
|
||||
assert(is<T>() && "Invalid accessor called");
|
||||
// If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3.
|
||||
typedef typename ::llvm::PointerUnionTypeSelector<
|
||||
using Ty = typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, IsInnerUnion,
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return
|
||||
Ty;
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3>>::Return;
|
||||
return Ty(Val).template get<T>();
|
||||
}
|
||||
|
||||
@ -348,16 +351,15 @@ struct PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3>> {
|
||||
template <typename PT1, typename PT2, typename PT3, typename PT4>
|
||||
class PointerUnion4 {
|
||||
public:
|
||||
typedef PointerUnion<PT1, PT2> InnerUnion1;
|
||||
typedef PointerUnion<PT3, PT4> InnerUnion2;
|
||||
typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy;
|
||||
using InnerUnion1 = PointerUnion<PT1, PT2>;
|
||||
using InnerUnion2 = PointerUnion<PT3, PT4>;
|
||||
using ValTy = PointerUnion<InnerUnion1, InnerUnion2>;
|
||||
|
||||
private:
|
||||
ValTy Val;
|
||||
|
||||
public:
|
||||
PointerUnion4() = default;
|
||||
|
||||
PointerUnion4(PT1 V) { Val = InnerUnion1(V); }
|
||||
PointerUnion4(PT2 V) { Val = InnerUnion1(V); }
|
||||
PointerUnion4(PT3 V) { Val = InnerUnion2(V); }
|
||||
@ -371,9 +373,10 @@ public:
|
||||
/// Test if the Union currently holds the type matching T.
|
||||
template <typename T> int is() const {
|
||||
// If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
|
||||
typedef typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
|
||||
PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
|
||||
using Ty = typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, InnerUnion1,
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
|
||||
InnerUnion2>>::Return;
|
||||
return Val.template is<Ty>() && Val.template get<Ty>().template is<T>();
|
||||
}
|
||||
|
||||
@ -383,9 +386,10 @@ public:
|
||||
template <typename T> T get() const {
|
||||
assert(is<T>() && "Invalid accessor called");
|
||||
// If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2.
|
||||
typedef typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, InnerUnion1, ::llvm::PointerUnionTypeSelector<
|
||||
PT2, T, InnerUnion1, InnerUnion2>>::Return Ty;
|
||||
using Ty = typename ::llvm::PointerUnionTypeSelector<
|
||||
PT1, T, InnerUnion1,
|
||||
::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1,
|
||||
InnerUnion2>>::Return;
|
||||
return Val.template get<Ty>().template get<T>();
|
||||
}
|
||||
|
||||
@ -452,18 +456,21 @@ struct PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4>> {
|
||||
|
||||
// Teach DenseMap how to use PointerUnions as keys.
|
||||
template <typename T, typename U> struct DenseMapInfo<PointerUnion<T, U>> {
|
||||
typedef PointerUnion<T, U> Pair;
|
||||
typedef DenseMapInfo<T> FirstInfo;
|
||||
typedef DenseMapInfo<U> SecondInfo;
|
||||
using Pair = PointerUnion<T, U>;
|
||||
using FirstInfo = DenseMapInfo<T>;
|
||||
using SecondInfo = DenseMapInfo<U>;
|
||||
|
||||
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<intptr_t>::getHashValue(key);
|
||||
}
|
||||
|
||||
static bool isEqual(const Pair &LHS, const Pair &RHS) {
|
||||
return LHS.template is<T>() == RHS.template is<T>() &&
|
||||
(LHS.template is<T>() ? FirstInfo::isEqual(LHS.template get<T>(),
|
||||
|
||||
@ -17,23 +17,24 @@
|
||||
#ifndef LLVM_ADT_STLEXTRAS_H
|
||||
#define LLVM_ADT_STLEXTRAS_H
|
||||
|
||||
#include <algorithm> // for std::all_of
|
||||
#include <cassert>
|
||||
#include <cstddef> // for std::size_t
|
||||
#include <cstdlib> // for qsort
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
#include <limits>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <utility> // for std::pair
|
||||
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/iterator.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/Support/Compiler.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
#include <iterator>
|
||||
#include <limits>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
@ -50,7 +51,7 @@ template <typename RangeT>
|
||||
using ValueOfRange = typename std::remove_reference<decltype(
|
||||
*std::begin(std::declval<RangeT &>()))>::type;
|
||||
|
||||
} // End detail namespace
|
||||
} // end namespace detail
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Extra additions to <functional>
|
||||
@ -58,6 +59,7 @@ using ValueOfRange = typename std::remove_reference<decltype(
|
||||
|
||||
template <class Ty> struct identity {
|
||||
using argument_type = Ty;
|
||||
|
||||
Ty &operator()(Ty &self) const {
|
||||
return self;
|
||||
}
|
||||
@ -88,7 +90,7 @@ template<typename Fn> class function_ref;
|
||||
|
||||
template<typename Ret, typename ...Params>
|
||||
class function_ref<Ret(Params...)> {
|
||||
Ret (*callback)(intptr_t callable, Params ...params);
|
||||
Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
|
||||
intptr_t callable;
|
||||
|
||||
template<typename Callable>
|
||||
@ -98,7 +100,7 @@ class function_ref<Ret(Params...)> {
|
||||
}
|
||||
|
||||
public:
|
||||
function_ref() : callback(nullptr) {}
|
||||
function_ref() = default;
|
||||
|
||||
template <typename Callable>
|
||||
function_ref(Callable &&callable,
|
||||
@ -107,6 +109,7 @@ public:
|
||||
function_ref>::value>::type * = nullptr)
|
||||
: callback(callback_fn<typename std::remove_reference<Callable>::type>),
|
||||
callable(reinterpret_cast<intptr_t>(&callable)) {}
|
||||
|
||||
Ret operator()(Params ...params) const {
|
||||
return callback(callable, std::forward<Params>(params)...);
|
||||
}
|
||||
@ -118,41 +121,34 @@ public:
|
||||
// delete on something. It is used like this:
|
||||
//
|
||||
// for_each(V.begin(), B.end(), deleter<Interval>);
|
||||
//
|
||||
template <class T>
|
||||
inline void deleter(T *Ptr) {
|
||||
delete Ptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Extra additions to <iterator>
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// mapped_iterator - This is a simple iterator adapter that causes a function to
|
||||
// be applied whenever operator* is invoked on the iterator.
|
||||
//
|
||||
template <class RootIt, class UnaryFunc>
|
||||
class mapped_iterator {
|
||||
RootIt current;
|
||||
UnaryFunc Fn;
|
||||
|
||||
public:
|
||||
typedef typename std::iterator_traits<RootIt>::iterator_category
|
||||
iterator_category;
|
||||
typedef typename std::iterator_traits<RootIt>::difference_type
|
||||
difference_type;
|
||||
typedef decltype(std::declval<UnaryFunc>()(*std::declval<RootIt>()))
|
||||
value_type;
|
||||
using iterator_category =
|
||||
typename std::iterator_traits<RootIt>::iterator_category;
|
||||
using difference_type =
|
||||
typename std::iterator_traits<RootIt>::difference_type;
|
||||
using value_type =
|
||||
decltype(std::declval<UnaryFunc>()(*std::declval<RootIt>()));
|
||||
|
||||
typedef void pointer;
|
||||
//typedef typename UnaryFunc::result_type *pointer;
|
||||
typedef void reference; // Can't modify value returned by fn
|
||||
using pointer = void;
|
||||
using reference = void; // Can't modify value returned by fn
|
||||
|
||||
typedef RootIt iterator_type;
|
||||
|
||||
inline const RootIt &getCurrent() const { return current; }
|
||||
inline const UnaryFunc &getFunc() const { return Fn; }
|
||||
using iterator_type = RootIt;
|
||||
|
||||
inline explicit mapped_iterator(const RootIt &I, UnaryFunc F)
|
||||
: current(I), Fn(F) {}
|
||||
@ -204,6 +200,9 @@ public:
|
||||
difference_type operator-(const mapped_iterator &X) const {
|
||||
return current - X.current;
|
||||
}
|
||||
|
||||
inline const RootIt &getCurrent() const { return current; }
|
||||
inline const UnaryFunc &getFunc() const { return Fn; }
|
||||
};
|
||||
|
||||
template <class Iterator, class Func>
|
||||
@ -213,10 +212,8 @@ operator+(typename mapped_iterator<Iterator, Func>::difference_type N,
|
||||
return mapped_iterator<Iterator, Func>(X.getCurrent() - N, X.getFunc());
|
||||
}
|
||||
|
||||
|
||||
// map_iterator - Provide a convenient way to create mapped_iterators, just like
|
||||
// make_pair is useful for creating pairs...
|
||||
//
|
||||
template <class ItTy, class FuncTy>
|
||||
inline mapped_iterator<ItTy, FuncTy> map_iterator(const ItTy &I, FuncTy F) {
|
||||
return mapped_iterator<ItTy, FuncTy>(I, F);
|
||||
@ -224,8 +221,8 @@ inline mapped_iterator<ItTy, FuncTy> map_iterator(const ItTy &I, FuncTy F) {
|
||||
|
||||
/// Helper to determine if type T has a member called rbegin().
|
||||
template <typename Ty> class has_rbegin_impl {
|
||||
typedef char yes[1];
|
||||
typedef char no[2];
|
||||
using yes = char[1];
|
||||
using no = char[2];
|
||||
|
||||
template <typename Inner>
|
||||
static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
|
||||
@ -363,12 +360,13 @@ template <size_t... I> struct index_sequence;
|
||||
template <class... Ts> struct index_sequence_for;
|
||||
|
||||
namespace detail {
|
||||
|
||||
using std::declval;
|
||||
|
||||
// We have to alias this since inlining the actual type at the usage site
|
||||
// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
|
||||
template<typename... Iters> struct ZipTupleType {
|
||||
typedef std::tuple<decltype(*declval<Iters>())...> type;
|
||||
using type = std::tuple<decltype(*declval<Iters>())...>;
|
||||
};
|
||||
|
||||
template <typename ZipType, typename... Iters>
|
||||
@ -454,11 +452,11 @@ class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
|
||||
public:
|
||||
using Base = zip_common<zip_shortest<Iters...>, Iters...>;
|
||||
|
||||
zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
|
||||
|
||||
bool operator==(const zip_shortest<Iters...> &other) const {
|
||||
return !test(other, index_sequence_for<Iters...>{});
|
||||
}
|
||||
|
||||
zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
|
||||
};
|
||||
|
||||
template <template <typename...> class ItType, typename... Args> class zippy {
|
||||
@ -481,11 +479,13 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
|
||||
|
||||
iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
|
||||
iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
|
||||
zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
|
||||
};
|
||||
} // End detail namespace
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
/// zip iterator for two or more iteratable types.
|
||||
template <typename T, typename U, typename... Args>
|
||||
@ -518,7 +518,7 @@ template <typename ValueT, typename... IterTs>
|
||||
class concat_iterator
|
||||
: public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
|
||||
std::forward_iterator_tag, ValueT> {
|
||||
typedef typename concat_iterator::iterator_facade_base BaseT;
|
||||
using BaseT = typename concat_iterator::iterator_facade_base;
|
||||
|
||||
/// We store both the current and end iterators for each concatenated
|
||||
/// sequence in a tuple of pairs.
|
||||
@ -595,6 +595,7 @@ public:
|
||||
: IterPairs({std::begin(Ranges), std::end(Ranges)}...) {}
|
||||
|
||||
using BaseT::operator++;
|
||||
|
||||
concat_iterator &operator++() {
|
||||
increment(index_sequence_for<IterTs...>());
|
||||
return *this;
|
||||
@ -608,6 +609,7 @@ public:
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
/// Helper to store a sequence of ranges being concatenated and access them.
|
||||
///
|
||||
/// This is designed to facilitate providing actual storage when temporaries
|
||||
@ -615,9 +617,9 @@ namespace detail {
|
||||
/// based for loops.
|
||||
template <typename ValueT, typename... RangeTs> class concat_range {
|
||||
public:
|
||||
typedef concat_iterator<ValueT,
|
||||
decltype(std::begin(std::declval<RangeTs &>()))...>
|
||||
iterator;
|
||||
using iterator =
|
||||
concat_iterator<ValueT,
|
||||
decltype(std::begin(std::declval<RangeTs &>()))...>;
|
||||
|
||||
private:
|
||||
std::tuple<RangeTs...> Ranges;
|
||||
@ -631,12 +633,14 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
|
||||
iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
|
||||
concat_range(RangeTs &&... Ranges)
|
||||
: Ranges(std::forward<RangeTs>(Ranges)...) {}
|
||||
|
||||
iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
|
||||
iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
|
||||
};
|
||||
}
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
/// Concatenated range across two or more ranges.
|
||||
///
|
||||
@ -673,7 +677,7 @@ struct less_second {
|
||||
|
||||
/// \brief Represents a compile-time sequence of integers.
|
||||
template <class T, T... I> struct integer_sequence {
|
||||
typedef T value_type;
|
||||
using value_type = T;
|
||||
|
||||
static constexpr size_t size() { return sizeof...(I); }
|
||||
};
|
||||
@ -750,7 +754,6 @@ inline int (*get_array_pod_sort_comparator(const T &))
|
||||
return array_pod_sort_comparator<T>;
|
||||
}
|
||||
|
||||
|
||||
/// array_pod_sort - This sorts an array with the specified start and end
|
||||
/// extent. This is just like std::sort, except that it calls qsort instead of
|
||||
/// using an inlined template. qsort is slightly slower than std::sort, but
|
||||
@ -1000,6 +1003,7 @@ struct equal {
|
||||
/// operands.
|
||||
template <typename T> struct deref {
|
||||
T func;
|
||||
|
||||
// Could be further improved to cope with non-derivable functors and
|
||||
// non-binary functors (should be a variadic template member function
|
||||
// operator()).
|
||||
@ -1012,12 +1016,13 @@ template <typename T> struct deref {
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename R> class enumerator_iter;
|
||||
|
||||
template <typename R> struct result_pair {
|
||||
friend class enumerator_iter<R>;
|
||||
|
||||
result_pair() : Index(-1) {}
|
||||
result_pair() = default;
|
||||
result_pair(std::size_t Index, IterOfRange<R> Iter)
|
||||
: Index(Index), Iter(Iter) {}
|
||||
|
||||
@ -1032,7 +1037,7 @@ template <typename R> struct result_pair {
|
||||
ValueOfRange<R> &value() { return *Iter; }
|
||||
|
||||
private:
|
||||
std::size_t Index;
|
||||
std::size_t Index = std::numeric_limits<std::size_t>::max();
|
||||
IterOfRange<R> Iter;
|
||||
};
|
||||
|
||||
@ -1047,7 +1052,7 @@ class enumerator_iter
|
||||
|
||||
public:
|
||||
explicit enumerator_iter(IterOfRange<R> EndIter)
|
||||
: Result(std::numeric_limits<size_t>::max(), EndIter) { }
|
||||
: Result(std::numeric_limits<size_t>::max(), EndIter) {}
|
||||
|
||||
enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
|
||||
: Result(Index, Iter) {}
|
||||
@ -1085,6 +1090,7 @@ public:
|
||||
enumerator_iter<R> begin() {
|
||||
return enumerator_iter<R>(0, std::begin(TheRange));
|
||||
}
|
||||
|
||||
enumerator_iter<R> end() {
|
||||
return enumerator_iter<R>(std::end(TheRange));
|
||||
}
|
||||
@ -1092,7 +1098,8 @@ public:
|
||||
private:
|
||||
R TheRange;
|
||||
};
|
||||
}
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
/// Given an input range, returns a new range whose values are are pair (A,B)
|
||||
/// such that A is the 0-based index of the item in the sequence, and B is
|
||||
@ -1114,12 +1121,14 @@ template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename F, typename Tuple, std::size_t... I>
|
||||
auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
|
||||
-> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
|
||||
return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
|
||||
}
|
||||
}
|
||||
|
||||
} // end namespace detail
|
||||
|
||||
/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
|
||||
/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
|
||||
@ -1135,6 +1144,7 @@ auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
|
||||
return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
|
||||
Indices{});
|
||||
}
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_ADT_STLEXTRAS_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- Twine.h - Fast Temporary String Concatenation -----------*- C++ -*-===//
|
||||
//===- Twine.h - Fast Temporary String Concatenation ------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -155,17 +155,19 @@ namespace llvm {
|
||||
/// LHS - The prefix in the concatenation, which may be uninitialized for
|
||||
/// Null or Empty kinds.
|
||||
Child LHS;
|
||||
|
||||
/// RHS - The suffix in the concatenation, which may be uninitialized for
|
||||
/// Null or Empty kinds.
|
||||
Child RHS;
|
||||
|
||||
/// LHSKind - The NodeKind of the left hand side, \see getLHSKind().
|
||||
NodeKind LHSKind;
|
||||
NodeKind LHSKind = EmptyKind;
|
||||
|
||||
/// RHSKind - The NodeKind of the right hand side, \see getRHSKind().
|
||||
NodeKind RHSKind;
|
||||
NodeKind RHSKind = EmptyKind;
|
||||
|
||||
/// Construct a nullary twine; the kind must be NullKind or EmptyKind.
|
||||
explicit Twine(NodeKind Kind)
|
||||
: LHSKind(Kind), RHSKind(EmptyKind) {
|
||||
explicit Twine(NodeKind Kind) : LHSKind(Kind) {
|
||||
assert(isNullary() && "Invalid kind!");
|
||||
}
|
||||
|
||||
@ -252,7 +254,7 @@ namespace llvm {
|
||||
/// @{
|
||||
|
||||
/// Construct from an empty string.
|
||||
/*implicit*/ Twine() : LHSKind(EmptyKind), RHSKind(EmptyKind) {
|
||||
/*implicit*/ Twine() {
|
||||
assert(isValid() && "Invalid twine!");
|
||||
}
|
||||
|
||||
@ -263,8 +265,7 @@ namespace llvm {
|
||||
/// We take care here to optimize "" into the empty twine -- this will be
|
||||
/// optimized out for string constants. This allows Twine arguments have
|
||||
/// default "" values, without introducing unnecessary string constants.
|
||||
/*implicit*/ Twine(const char *Str)
|
||||
: RHSKind(EmptyKind) {
|
||||
/*implicit*/ Twine(const char *Str) {
|
||||
if (Str[0] != '\0') {
|
||||
LHS.cString = Str;
|
||||
LHSKind = CStringKind;
|
||||
@ -275,84 +276,73 @@ namespace llvm {
|
||||
}
|
||||
|
||||
/// Construct from an std::string.
|
||||
/*implicit*/ Twine(const std::string &Str)
|
||||
: LHSKind(StdStringKind), RHSKind(EmptyKind) {
|
||||
/*implicit*/ Twine(const std::string &Str) : LHSKind(StdStringKind) {
|
||||
LHS.stdString = &Str;
|
||||
assert(isValid() && "Invalid twine!");
|
||||
}
|
||||
|
||||
/// Construct from a StringRef.
|
||||
/*implicit*/ Twine(const StringRef &Str)
|
||||
: LHSKind(StringRefKind), RHSKind(EmptyKind) {
|
||||
/*implicit*/ Twine(const StringRef &Str) : LHSKind(StringRefKind) {
|
||||
LHS.stringRef = &Str;
|
||||
assert(isValid() && "Invalid twine!");
|
||||
}
|
||||
|
||||
/// Construct from a SmallString.
|
||||
/*implicit*/ Twine(const SmallVectorImpl<char> &Str)
|
||||
: LHSKind(SmallStringKind), RHSKind(EmptyKind) {
|
||||
: LHSKind(SmallStringKind) {
|
||||
LHS.smallString = &Str;
|
||||
assert(isValid() && "Invalid twine!");
|
||||
}
|
||||
|
||||
/// Construct from a formatv_object_base.
|
||||
/*implicit*/ Twine(const formatv_object_base &Fmt)
|
||||
: LHSKind(FormatvObjectKind), RHSKind(EmptyKind) {
|
||||
: LHSKind(FormatvObjectKind) {
|
||||
LHS.formatvObject = &Fmt;
|
||||
assert(isValid() && "Invalid twine!");
|
||||
}
|
||||
|
||||
/// Construct from a char.
|
||||
explicit Twine(char Val)
|
||||
: LHSKind(CharKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(char Val) : LHSKind(CharKind) {
|
||||
LHS.character = Val;
|
||||
}
|
||||
|
||||
/// Construct from a signed char.
|
||||
explicit Twine(signed char Val)
|
||||
: LHSKind(CharKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(signed char Val) : LHSKind(CharKind) {
|
||||
LHS.character = static_cast<char>(Val);
|
||||
}
|
||||
|
||||
/// Construct from an unsigned char.
|
||||
explicit Twine(unsigned char Val)
|
||||
: LHSKind(CharKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(unsigned char Val) : LHSKind(CharKind) {
|
||||
LHS.character = static_cast<char>(Val);
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as an unsigned decimal integer.
|
||||
explicit Twine(unsigned Val)
|
||||
: LHSKind(DecUIKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(unsigned Val) : LHSKind(DecUIKind) {
|
||||
LHS.decUI = Val;
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as a signed decimal integer.
|
||||
explicit Twine(int Val)
|
||||
: LHSKind(DecIKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(int Val) : LHSKind(DecIKind) {
|
||||
LHS.decI = Val;
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as an unsigned decimal integer.
|
||||
explicit Twine(const unsigned long &Val)
|
||||
: LHSKind(DecULKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(const unsigned long &Val) : LHSKind(DecULKind) {
|
||||
LHS.decUL = &Val;
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as a signed decimal integer.
|
||||
explicit Twine(const long &Val)
|
||||
: LHSKind(DecLKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(const long &Val) : LHSKind(DecLKind) {
|
||||
LHS.decL = &Val;
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as an unsigned decimal integer.
|
||||
explicit Twine(const unsigned long long &Val)
|
||||
: LHSKind(DecULLKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(const unsigned long long &Val) : LHSKind(DecULLKind) {
|
||||
LHS.decULL = &Val;
|
||||
}
|
||||
|
||||
/// Construct a twine to print \p Val as a signed decimal integer.
|
||||
explicit Twine(const long long &Val)
|
||||
: LHSKind(DecLLKind), RHSKind(EmptyKind) {
|
||||
explicit Twine(const long long &Val) : LHSKind(DecLLKind) {
|
||||
LHS.decLL = &Val;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user