/// we won't know until all lvalue-to-rvalue and discarded value conversions
/// have been applied to all subexpressions of the enclosing full expression.
/// This is cleared at the end of each full expression.
- using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>,
- llvm::SmallPtrSet<Expr *, 4>>;
+ using MaybeODRUseExprSet = llvm::SmallSetVector<Expr *, 4>;
MaybeODRUseExprSet MaybeODRUseExprs;
std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
/// enumeration types.
class BuiltinCandidateTypeSet {
/// TypeSet - A set of types.
- typedef llvm::SetVector<QualType, SmallVector<QualType, 8>,
- llvm::SmallPtrSet<QualType, 8>> TypeSet;
+ typedef llvm::SmallSetVector<QualType, 8> TypeSet;
/// PointerTypes - The set of pointer types that will be used in the
/// built-in candidates.
namespace {
// Use SetVector since the diagnostic cares about the ordering of the Decl's.
- using DeclSetVector =
- llvm::SetVector<VarDecl *, llvm::SmallVector<VarDecl *, 8>,
- llvm::SmallPtrSet<VarDecl *, 8>>;
+ using DeclSetVector = llvm::SmallSetVector<VarDecl *, 8>;
// This visitor will traverse a conditional statement and store all
// the evaluated decls into a vector. Simple is set to true if none
#ifndef LLVM_ADT_GENERICCYCLEINFO_H
#define LLVM_ADT_GENERICCYCLEINFO_H
+#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/GenericSSAContext.h"
#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
/// Basic blocks that are contained in the cycle, including entry blocks,
/// and including blocks that are part of a child cycle.
using BlockSetVectorT = SetVector<BlockT *, SmallVector<BlockT *, 8>,
- SmallPtrSet<const BlockT *, 8>>;
+ DenseSet<const BlockT *>, 8>;
BlockSetVectorT Blocks;
/// Depth of the cycle in the tree. The root "cycle" is at depth 0.
/// a load, eliminate the register by folding the def into the use.
bool foldAsLoad(LiveInterval *LI, SmallVectorImpl<MachineInstr *> &Dead);
- using ToShrinkSet = SetVector<LiveInterval *, SmallVector<LiveInterval *, 8>,
- SmallPtrSet<LiveInterval *, 8>>;
+ using ToShrinkSet = SmallSetVector<LiveInterval *, 8>;
/// Helper for eliminateDeadDefs.
void eliminateDeadDef(MachineInstr *MI, ToShrinkSet &ToShrink);
/// directly promoted. Finally, each time we rewrite a use of an alloca other
/// the one being actively rewritten, we add it back onto the list if not
/// already present to ensure it is re-visited.
- SetVector<AllocaInst *, SmallVector<AllocaInst *, 16>> Worklist;
+ SmallSetVector<AllocaInst *, 16> Worklist;
/// A collection of instructions to delete.
/// We try to batch deletions to simplify code and make things a bit more
///
/// Note that we have to be very careful to clear allocas out of this list in
/// the event they are deleted.
- SetVector<AllocaInst *, SmallVector<AllocaInst *, 16>> PostPromotionWorklist;
+ SmallSetVector<AllocaInst *, 16> PostPromotionWorklist;
/// A collection of alloca instructions we can directly promote.
std::vector<AllocaInst *> PromotableAllocas;
/// All of these PHIs have been checked for the safety of speculation and by
/// being speculated will allow promoting allocas currently in the promotable
/// queue.
- SetVector<PHINode *, SmallVector<PHINode *, 8>> SpeculatablePHIs;
+ SmallSetVector<PHINode *, 8> SpeculatablePHIs;
/// A worklist of select instructions to rewrite prior to promoting
/// allocas.
// basic blocks in a breadth-first order as we insert live successors. To
// accomplish this, prioritizing for small iterations because we exit after
// crossing our threshold, we use a small-size optimized SetVector.
- typedef SetVector<BasicBlock *, SmallVector<BasicBlock *, 16>,
- SmallPtrSet<BasicBlock *, 16>>
- BBSetVector;
+ typedef SmallSetVector<BasicBlock *, 16> BBSetVector;
BBSetVector BBWorklist;
BBWorklist.insert(&F.getEntryBlock());
/// This is a collection of subprogram MDNodes that are processed to
/// create DIEs.
- SetVector<const DISubprogram *, SmallVector<const DISubprogram *, 16>,
- SmallPtrSet<const DISubprogram *, 16>>
- ProcessedSPNodes;
+ SmallSetVector<const DISubprogram *, 16> ProcessedSPNodes;
/// If nonnull, stores the current machine function we're processing.
const MachineFunction *CurFn = nullptr;