reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
  702   DenseMap(const DenseMap &other) : BaseT() {
  707   DenseMap(DenseMap &&other) : BaseT() {
  728   void swap(DenseMap& RHS) {
  737   DenseMap& operator=(const DenseMap& other) {
  737   DenseMap& operator=(const DenseMap& other) {
  743   DenseMap& operator=(DenseMap &&other) {
  743   DenseMap& operator=(DenseMap &&other) {
  751   void copyFrom(const DenseMap& other) {
 1269 inline size_t capacity_in_bytes(const DenseMap<KeyT, ValueT, KeyInfoT> &X) {

  250                      ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
  255                            DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,

  372   using CacheTy = DenseMap<unsigned, TreeTy*>;

   71   DenseMap<NodeRef, unsigned> nodeVisitNumbers;
  160     typename DenseMap<NodeRef, unsigned>::iterator Visited =

  162   DenseMap<K, ValTy*, KInfo> TopLevelMap;

  351   using PointerMapType = DenseMap<ASTCallbackVH, AliasSet::PointerRec *,

   69       DenseMap<AffectedValueCallbackVH, SmallVector<WeakTrackingVH, 1>,
  203       DenseMap<FunctionCallbackVH, std::unique_ptr<AssumptionCache>,

  859   DenseMap<const BlockT *, BlockNode> Nodes;

  140   using SccMap = DenseMap<const BasicBlock *, int>;
  141   using SccHeaderMap = DenseMap<const BasicBlock *, bool>;
  179   DenseMap<Edge, BranchProbability> Probs;

   85   DenseMap<const Function *, Optional<FunctionInfo>> Cache;

  101   DenseMap<Function *, Optional<FunctionInfo>> Cache;

   59   DenseMap<const BasicBlock *, unsigned> NumBBInsts;

   79   DenseMap<Instruction *, APInt> AliveBits;

  100   using InstToNodeMap = DenseMap<Instruction *, NodeType *>;

  114 DenseMap<BasicBlock *, ColorVector> colorEHFunclets(Function &F);

   48   DenseMap<const Value *, const GlobalValue *> AllocsForIndirectGlobals;
   51   DenseMap<const Function *, FunctionInfo> FunctionInfos;
   56   DenseMap<const Function *, unsigned> FunctionToSCCMap;

  196                          DenseMap<Instruction *, Instruction *> &SinkAfter,

   32   DenseMap<const BasicBlock *, const Instruction *> FirstSpecialInsts;

  296     DenseMap<Node *, int> EdgeIndexMap;
 1126   DenseMap<const Function *, Node *> NodeMap;
 1138   DenseMap<Node *, SCC *> SCCMap;
 1150   DenseMap<RefSCC *, int> RefSCCIndices;

  244   DenseMap<Instruction *, unsigned> generateInstructionOrderMap() const {
  245     DenseMap<Instruction *, unsigned> OrderMap;
  268   DenseMap<MemAccessInfo, std::vector<unsigned> > Accesses;
  750   DenseMap<Loop *, std::unique_ptr<LoopAccessInfo>> LoopAccessInfoMap;

  850   DenseMap<const BlockT *, LoopT *> BBMap;

  629 void addInnerLoopsToHeadersMap(DenseMap<BlockT *, const LoopT *> &LoopHeaders,
  640                          DenseMap<BlockT *, const LoopT *> &OtherLoopHeaders) {
  708   DenseMap<BlockT *, const LoopT *> OtherLoopHeaders;

  111   DenseMap<BasicBlock*, unsigned> PostNumbers;
  147     DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB);
  153     DenseMap<BasicBlock*, unsigned>::const_iterator I = PostNumbers.find(BB);

   49                        DenseMap<Value *, Constant *> &SimplifiedValues,
   65   DenseMap<Value *, SimplifiedAddress> SimplifiedAddresses;
   79   DenseMap<Value *, Constant *> &SimplifiedValues;

  288   using CacheMapTy = DenseMap<const Value *, WeakEvalType>;

  278   using LocalDepMapType = DenseMap<Instruction *, MemDepResult>;
  317   DenseMap<AssertingVH<const Value>, NonLocalDepResult> NonLocalDefsCache;
  319     DenseMap<Instruction *, SmallPtrSet<const Value*, 4>>;
  328       DenseMap<ValueIsLoadPair, NonLocalPointerInfo>;
  333       DenseMap<Instruction *, SmallPtrSet<ValueIsLoadPair, 4>>;
  344   using NonLocalDepMapType = DenseMap<Instruction *, PerInstNLInfo>;
  351       DenseMap<Instruction *, SmallPtrSet<Instruction *, 4>>;
  495                                    DenseMap<BasicBlock *, Value *> &Visited,

  850   using AccessMap = DenseMap<const BasicBlock *, std::unique_ptr<AccessList>>;
  851   using DefsMap = DenseMap<const BasicBlock *, std::unique_ptr<DefsList>>;
  876   DenseMap<const Value *, MemoryAccess *> ValueToMemoryAccess;
  892   mutable DenseMap<const MemoryAccess *, unsigned long> BlockNumbering;

  273                         DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &);
  276                           DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &);

   56   DenseMap<BasicBlock *, ColorVector> BlockColors;
   64   const DenseMap<BasicBlock *, ColorVector> &getBlockColors() const;
  441   DenseMap<const Instruction *, MustBeExecutedIterator *>

   92                            DenseMap<const Value *, WeakTrackingVH> &Cache) {

   31   mutable DenseMap<const BasicBlock *, std::unique_ptr<OrderedBasicBlock>>

   82   DenseMap<const PHINode *, unsigned int> DepthMap;
   85   DenseMap<unsigned int, ValueSet> NonPhiReachableMap;
   88   DenseMap<unsigned int, ConstValueSet> ReachableMap;

   63   DenseMap<int, uint64_t> ThresholdCache;

  693   using BBtoBBMap = DenseMap<BlockT *, BlockT *>;
  694   using BBtoRegionMap = DenseMap<BlockT *, RegionT *>;

  400       DenseMap<const SCEV *, SmallVector<const SCEVPredicate *, 4>>;
 1131   using HasRecMapType = DenseMap<const SCEV *, bool>;
 1138   using ExprValueMapType = DenseMap<const SCEV *, SetVector<ValueOffsetPair>>;
 1164       DenseMap<SCEVCallbackVH, const SCEV *, DenseMapInfo<Value *>>;
 1187   DenseMap<const SCEV *, uint32_t> MinTrailingZerosCache;
 1358   DenseMap<const Loop *, BackedgeTakenInfo> BackedgeTakenCounts;
 1362   DenseMap<const Loop *, BackedgeTakenInfo> PredicatedBackedgeTakenCounts;
 1368   DenseMap<PHINode *, Constant *> ConstantEvolutionLoopExitValue;
 1373   DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
 1377   DenseMap<const SCEV *,
 1395   DenseMap<const Loop *, LoopProperties> LoopPropertiesCache;
 1412   DenseMap<
 1421   DenseMap<const SCEV *, ConstantRange> UnsignedRanges;
 1424   DenseMap<const SCEV *, ConstantRange> SignedRanges;
 1432     DenseMap<const SCEV *, ConstantRange> &Cache =
 1898   DenseMap<const Loop *, SmallVector<const SCEV *, 4>> LoopUsers;
 1902   DenseMap<std::pair<const SCEVUnknown *, const Loop *>,
 2027   DenseMap<const SCEV *, RewriteEntry> RewriteMap;

   53     DenseMap<std::pair<const SCEV *, Instruction *>, TrackingVH<Value>>
   61     DenseMap<const SCEV *, const Loop *> RelevantLoops;

  657     DenseMap<const SCEV *, const SCEV *> RewriteResults;
  785   using ValueToValueMap = DenseMap<const Value *, Value *>;
  817   using LoopToScevMapT = DenseMap<const Loop *, const SCEV *>;

   90                           DenseMap<LatticeKey, LatticeVal> &ChangedValues,
  118   DenseMap<LatticeKey, LatticeVal> ValueState;
  402     DenseMap<LatticeKey, LatticeVal> ChangedValues;
  457   DenseMap<LatticeKey, LatticeVal> ChangedValues;

   51   llvm::DenseMap<unsigned, std::string> CustomNames;

  499   DenseMap<int32_t, InstTy *> Members;
  603   DenseMap<Instruction *, InterleaveGroup<Instruction> *> InterleaveGroupMap;
  609   DenseMap<Instruction *, SmallPtrSet<Instruction *, 2>> Dependences;

  145 DenseMap<const MachineBasicBlock *, int>

   56     DenseMap<unsigned, float> Hint;

   90   DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
   93   DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;

  202   DenseMap<const Value *, unsigned> LocalValueMap;
  571     DenseMap<MachineInstr *, unsigned> Orders;

   73   DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
   78   DenseMap<const Value *, unsigned> ValueMap;
   85   DenseMap<unsigned, const Value*> VirtReg2Value;
   92   DenseMap<const Value *, unsigned> CatchPadExceptionPointers;
  101     using SlotMapTy = DenseMap<const Value *, Optional<int>>;
  109     DenseMap<const Value *, const Value *> DuplicateMap;
  123   DenseMap<const Instruction *, StatepointSpillMap> StatepointSpillMaps;
  128   DenseMap<const AllocaInst*, int> StaticAllocaMap;
  131   DenseMap<const Argument*, int> ByValArgFrameIndexMap;
  142   DenseMap<unsigned, unsigned> RegFixups;
  168   DenseMap<const Value *, ISD::NodeType> PreferredExtendType;
  260     DenseMap<const Value*, unsigned>::const_iterator It = ValueMap.find(PN);

  177   using finfo_map_type = DenseMap<const Function *, GCFunctionInfo *>;

   84   DenseMap<const MachineInstr *, UniqueMachineInstr *> InstrMapping;
   92   DenseMap<unsigned, unsigned> OpcodeHitTable;

   33   DenseMap<MachineInstr *, unsigned> WorklistMap;

   78         DenseMap<const Value *, VRegListT *>::const_iterator;
   80         DenseMap<const Value *, OffsetListT *>::const_iterator;
  139     DenseMap<const Value *, VRegListT*> ValToVRegs;
  140     DenseMap<const Type *, OffsetListT*> TypeToOffsets;
  150   DenseMap<const BasicBlock *, MachineBasicBlock *> BBToMBB;
  158   DenseMap<CFGEdge, SmallVector<MachineBasicBlock *, 1>> MachinePreds;
  167   DenseMap<const AllocaInst *, int> FrameIndices;

  411     DenseMap<unsigned, unsigned> TempRegisters;

 1328   using TypeMap = DenseMap<LLT, LegalizeAction>;

  393   mutable DenseMap<unsigned, std::unique_ptr<const PartialMapping>>
  398   mutable DenseMap<unsigned, std::unique_ptr<const ValueMapping>>
  403   mutable DenseMap<unsigned, std::unique_ptr<ValueMapping[]>>
  408   mutable DenseMap<unsigned, std::unique_ptr<const InstructionMapping>>
  413   mutable DenseMap<unsigned, const TargetRegisterClass *> PhysRegMinimalRCs;

   29 using ValueToVReg = DenseMap<const Value *, unsigned>;

  223                             DenseMap<const MachineInstr *, LexicalScope *> &M);
  227                           DenseMap<const MachineInstr *, LexicalScope *> &M);

   75   using EntryInfoMap = DenseMap<LiveRange *, std::pair<BitVector, BitVector>>;

  146   DenseMap<MachineInstr*, unsigned> DistanceMap;

  166   DenseMap<unsigned, MachineBasicBlock *> MBBSlots;
  167   DenseMap<unsigned, VRegInfo *> VRegInfos;
  169   DenseMap<unsigned, int> FixedStackObjectSlots;
  170   DenseMap<unsigned, int> StackObjectSlots;
  171   DenseMap<unsigned, unsigned> ConstantPoolSlots;
  172   DenseMap<unsigned, unsigned> JumpTableSlots;

  318   DenseMap<MCSymbol*, SmallVector<unsigned, 4>> LPadToCallSiteMap;
  321   DenseMap<const MachineBasicBlock *, unsigned> WasmLPadToIndexMap;
  324   DenseMap<MCSymbol*, unsigned> CallSiteMap;
  400   using CallSiteInfoMap = DenseMap<const MachineInstr *, CallSiteInfo>;
  862   void tidyLandingPads(DenseMap<MCSymbol *, uintptr_t> *LPMap = nullptr,

   70   static SymbolListTy getSortedStubs(DenseMap<MCSymbol*, StubValueTy>&);
  141   DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions;

   31   DenseMap<MCSymbol *, StubValueTy> GVStubs;
   36   DenseMap<MCSymbol *, StubValueTy> ThreadLocalGVStubs;
   65   DenseMap<MCSymbol *, StubValueTy> GVStubs;
   87   DenseMap<MCSymbol *, StubValueTy> GVStubs;

  144   using ValueMapTy = DenseMap<unsigned, unsigned>;
  146   using InstrMapTy = DenseMap<MachineInstr *, MachineInstr *>;
  149   DenseMap<SUnit *, std::pair<unsigned, int64_t>> InstrChanges;
  153   DenseMap<MachineInstr*, MachineInstr *> NewMIs;
  270     DenseMap<SUnit *, std::pair<unsigned, int64_t>>::iterator It =
  484   DenseMap<int, std::deque<SUnit *>> ScheduledInstrs;
  542   using sched_iterator = DenseMap<int, std::deque<SUnit *>>::iterator;
  544       DenseMap<int, std::deque<SUnit *>>::const_iterator;

  325     DenseMap<const MachineInstr*, InstrCycles> Cycles;

   89   DenseMap<MachineInstr *, int> Cycle;
   92   DenseMap<MachineInstr *, int> Stage;
  107                  DenseMap<MachineInstr *, int> Cycle,
  108                  DenseMap<MachineInstr *, int> Stage)
  155   using InstrChangesTy = DenseMap<MachineInstr *, std::pair<unsigned, int64_t>>;
  158   using ValueMapTy = DenseMap<unsigned, unsigned>;
  160   using InstrMapTy = DenseMap<MachineInstr *, MachineInstr *>;
  288   DenseMap<MachineBasicBlock *, BitVector> LiveStages;
  292   DenseMap<MachineBasicBlock *, BitVector> AvailableStages;
  296   DenseMap<MachineInstr *, MachineInstr *> CanonicalMIs;
  297   DenseMap<std::pair<MachineBasicBlock *, MachineInstr *>, MachineInstr *>

   59   DenseMap<MachineInstr *, int> InstIds;

  162   DenseMap<unsigned, GraphBase::NodeId> VRegToNodeId;

   63   DenseMap<const Function *, std::vector<uint32_t>> RegMasks;

  158     DenseMap<MachineInstr*, SUnit*> MISUnitMap;
  396     DenseMap<MachineInstr*, SUnit*>::const_iterator I = MISUnitMap.find(MI);

  152   using DbgValMapType = DenseMap<const SDNode *, SmallVector<SDDbgValue *, 2>>;
  278   DenseMap<const SDNode *, CallSiteDbgInfo> SDCallSiteDbgInfo;
 1753   DenseMap<MCSymbol *, SDNode *> MCSymbols;

  324     using Mi2IndexMap = DenseMap<const MachineInstr *, SlotIndex>;

   40   using SSPLayoutMap = DenseMap<const AllocaInst *,

   45   DenseMap<std::pair<const MachineBasicBlock *, const Value *>, Register>
   51   DenseMap<std::pair<const MachineBasicBlock *, const Value *>, Register>
   56   llvm::DenseMap<PointerIntPair<const Instruction *, 1, bool>, Register>

   54   DenseMap<unsigned, AvailableValsTy> SSAUpdateVals;
   96                   DenseMap<unsigned, RegSubRegPair> &LocalVRMap,
  101                             DenseMap<unsigned, RegSubRegPair> &LocalVRMap,

 1062       DenseMap<unsigned, unsigned> &InstIdxForVirtReg) const;
 1070                       DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const;

  382   const DenseMap<unsigned int, unsigned int> &getBypassSlowDivWidths() const {
 2680   DenseMap <unsigned int, unsigned int> BypassSlowDivWidths;

   30   DenseMap<BBOrMBB, BBOrMBB> EHPadUnwindMap;

   91   DenseMap<const Instruction *, int> EHPadStateMap;
   92   DenseMap<const FuncletPadInst *, int> FuncletBaseStateMap;
   93   DenseMap<const InvokeInst *, int> InvokeStateMap;
   94   DenseMap<MCSymbol *, std::pair<int, MCSymbol *>> LabelToStateMap;

   93   DenseMap<uint32_t, uint32_t> OffsetMap;

   87   DenseMap<uint32_t, StringRef> IdToString;

   41   DenseMap<GloballyHashedType, TypeIndex> HashedRecords;

   41   DenseMap<LocallyHashedType, TypeIndex> HashedRecords;

  575   DenseMap<uint64_t, const NameIndex *> CUToNameIndex;

   34 using RelocAddrMap = DenseMap<uint64_t, RelocAddrEntry>;

  138   DenseMap<llvm::gsym::FileEntry, uint32_t> FileEntryToIndex;

  104   DenseMap<uint32_t, std::vector<CacheEntry>> CacheMap;

  105   DenseMap<uint32_t, std::string> NamedStreamData;

   40   DenseMap<codeview::TypeIndex, SymIndexId> TypeIndexToSymbolId;
   45   DenseMap<std::pair<codeview::TypeIndex, uint32_t>, SymIndexId>
   53   DenseMap<uint32_t, SymIndexId> GlobalOffsetToSymbolId;

  947 using AsyncLookupResult = DenseMap<StringRef, JITEvaluatedSymbol>;

   51   using SegmentsRequestMap = DenseMap<unsigned, SegmentRequest>;

   50 using SymbolMap = DenseMap<SymbolStringPtr, JITEvaluatedSymbol>;
   53 using SymbolFlagsMap = DenseMap<SymbolStringPtr, JITSymbolFlags>;
   56 using SymbolDependenceMap = DenseMap<JITDylib *, SymbolNameSet>;
   71 using SymbolAliasMap = DenseMap<SymbolStringPtr, SymbolAliasMapEntry>;
  637       DenseMap<SymbolStringPtr, std::shared_ptr<UnmaterializedInfo>>;
  657   using MaterializingInfosMap = DenseMap<SymbolStringPtr, MaterializingInfo>;
  706   using SymbolTable = DenseMap<SymbolStringPtr, SymbolTableEntry>;

  152   DenseMap<VModuleKey, AllocPtr> TrackedAllocs;
  174   DenseMap<MaterializationResponsibility *, EHFrameRange> InProcessLinks;
  175   DenseMap<VModuleKey, EHFrameRange> TrackedEHFrameRanges;

   33   using ResultTy = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
   57   using VisitedBlocksInfoTy = DenseMap<const BasicBlock *, WalkDirection>;

   45   using ImapTy = DenseMap<Alias, AliaseeDetails>;
   68   using FunctionCandidatesMap = DenseMap<SymbolStringPtr, SymbolNameSet>;
   69   using StubAddrLikelies = DenseMap<TargetFAddr, SymbolNameSet>;
  171   using IRlikiesStrRef = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
  173   using TargetAndLikelies = DenseMap<SymbolStringPtr, SymbolNameSet>;
  185   internToJITSymbols(DenseMap<StringRef, DenseSet<StringRef>> IRNames) {

   70     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedVariables;
   73     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedLabels;

   90                                     DenseMap<const MDNode *, MDNode *> &Cache,

  239   DenseMap<Pass *, Pass *> LastUser;
  244   DenseMap<Pass *, SmallPtrSet<Pass *, 8> > InversedLastUser;
  288   DenseMap<Pass *, AnalysisUsage*> AnUsageMap;
  294   mutable DenseMap<AnalysisID, const PassInfo *> AnalysisPassInfos;
  393   DenseMap<AnalysisID, Pass*> *getAvailableAnalysis() {
  436   DenseMap<AnalysisID, Pass *> *InheritedAnalysis[PMT_Last];
  450   DenseMap<AnalysisID, Pass*> AvailableAnalysis;

   30   mutable DenseMap<const GlobalValue*, unsigned> AnonGlobalIDs;

  884 using GVSummaryMapTy = DenseMap<GlobalValue::GUID, GlobalValueSummary *>;

  630   using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
  636       DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
  999       DenseMap<AnalysisKey *, std::unique_ptr<PassConceptT>>;

   59   DenseMap<PassInvocationID, std::unique_ptr<Timer>> TimingData;

   29   mutable DenseMap<BasicBlock *, BasicBlock **> BlockToPredsMap;
   30   mutable DenseMap<BasicBlock *, unsigned> BlockToPredCountMap;

   89   using MapT = DenseMap<ValueMapCVH, ValueT, DenseMapInfo<ValueMapCVH>>;
   90   using MDMapT = DenseMap<const Metadata *, TrackingMDRef>;

   54   DenseMap<const MDNode *, TBAABaseNodeSummary> TBAABaseNodes;
   58   DenseMap<const MDNode *, bool> TBAAScalarNodes;

  340     DenseMap<GlobalValue::GUID, StringRef> PrevailingModuleForGUID;

   44   typedef DenseMap<const Metadata *, TrackingMDRef> MDMapT;

   37   mutable DenseMap<const MCSection *, MCFragment *> LastValidFragment;

   56   DenseMap<MCPaddingFragment *, MCPFRange> FragmentToJurisdiction;
   61   DenseMap<MCPaddingFragment *, uint64_t> FragmentToMaxWindowSize;

  117   DenseMap<unsigned, LineInfo> InlinedAtMap;

  108     DenseMap<std::pair<unsigned, unsigned>, MCSymbol *> LocalSymbols;
  124     DenseMap<unsigned, MCLabel *> Instances;

   31 using SectionAddrMap = DenseMap<const MCSection *, uint64_t>;

  105   DenseMap<const MCSection *, std::vector<RelAndSymbol>> Relocations;
  106   DenseMap<const MCSection *, unsigned> IndirectSymBase;

  172   mutable DenseMap<const MCSymbol *, unsigned> StackSizesUniquing;

  176   DenseMap<MCRegister, int> L2SEHRegs;        // LLVM to SEH regs mapping
  177   DenseMap<MCRegister, int> L2CVRegs;         // LLVM to CV regs mapping

  211   DenseMap<const MCSymbol *, unsigned> SymbolOrdering;

   28   DenseMap<CachedHashStringRef, size_t> StringIndexMap;

  195   DenseMap<unsigned, std::unique_ptr<MemoryGroup>> Groups;

   45   DenseMap<unsigned short, std::unique_ptr<const InstrDesc>> Descriptors;
   46   DenseMap<const MCInst *, std::unique_ptr<const InstrDesc>> VariantDescriptors;

  166                DenseMap<minidump::StreamType, std::size_t> StreamMap)
  186   DenseMap<minidump::StreamType, std::size_t> StreamMap;

  138   DenseMap<unsigned, OptRange> OptRanges;

   42   using MapType = DenseMap<const void *, const PassInfo *>;

  161   DenseMap<CounterExpression, unsigned> ExpressionIndices;
  514   DenseMap<size_t, DenseSet<size_t>> RecordProvenance;
  516   DenseMap<size_t, SmallVector<unsigned, 0>> FilenameHash2RecordIndices;

  397   using FunctionLines = DenseMap<uint32_t, FunctionVector>;
  399   using BlockLines = DenseMap<uint32_t, BlockVector>;

  561   DenseMap<uint64_t, StringRef> *GUIDToFuncNameMap = nullptr;

  286   DenseMap<SymbolRemappingReader::Key, FunctionSamples *> SampleMap;
  612   DenseMap<StringRef, uint64_t> FuncOffsetTable;
  640   DenseMap<StringRef, uint64_t> FuncOffsetTable;

  175   DenseMap<unsigned, CounterInfo> Counters;

  243      DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;

   73   DenseMap<NodePtr, InfoRec> NodeToInfo;
   88     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FutureSuccessors;
   89     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FuturePredecessors;

   91   using Storage = DenseMap<ObjectKey, Value, llvm::DenseMapInfo<StringRef>>;

   66   DenseMap<void *, cl::Option *> Options;

 1907   DenseMap<Init *, MappedValue> Map;
 1919   DenseMap<Init *, Init *> Cache;

  338   using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;

  606     DenseMap<const Function *, unsigned> SccSize;
  615   using OpcodeInstMapTy = DenseMap<unsigned, SmallVector<Instruction *, 32>>;
  658   using FuncInstOpcodeMapTy = DenseMap<const Function *, OpcodeInstMapTy>;
  661   using FuncRWInstsMapTy = DenseMap<const Function *, InstructionVectorTy>;
  680   Optional<DenseMap<const Function *, unsigned>> SccSizeOpt;
  984       DenseMap<const char *, AbstractAttribute *>;
  985   DenseMap<IRPosition, KindToAbstractAttributeMap> AAMap;

   91       DenseMap<GlobalValue::GUID,

   37   DenseMap<GlobalValue *, SmallPtrSet<GlobalValue *, 4>> GVDependencies;
   47   DenseMap<Metadata *, SmallSet<std::pair<GlobalVariable *, uint64_t>, 4>>

   28   DenseMap<Instruction*, unsigned> WorklistMap;
   70     DenseMap<Instruction*, unsigned>::iterator It = WorklistMap.find(I);

   71   DenseMap<GlobalVariable *, Entry> Entries;

   59   DenseMap<GlobalVariable *, PerFunctionProfileData> ProfileDataMap;

  147   using ConstCandMapType = DenseMap<ConstPtrUnionType, unsigned>;

   90     DenseMap<Value *, uint32_t> valueNumbering;
   91     DenseMap<Expression, uint32_t> expressionNumbering;
  103     DenseMap<uint32_t, PHINode *> NumberingPhi;
  107         DenseMap<std::pair<uint32_t, const BasicBlock *>, uint32_t>;
  175   DenseMap<uint32_t, LeaderTableEntry> LeaderTable;
  186   DenseMap<AssertingVH<BasicBlock>, uint32_t> BlockRPONumber;
  274   void dump(DenseMap<uint32_t, Value *> &d) const;

  183   DenseMap<const SCEV *, SmallVector<WeakTrackingVH, 2>> SeenExprs;

   77   DenseMap<BasicBlock *, unsigned> RankMap;
   78   DenseMap<AssertingVH<Value>, unsigned> ValueRankMap;
   92   DenseMap<std::pair<Value *, Value *>, PairMapValue> PairMap[NumBinaryOps];

   70     BasicBlock *BB, const DenseMap<unsigned int, unsigned int> &BypassWidth);

   51   DenseMap<BasicBlock *, DenseSet<Value *>> BaseMemAddrs;
  223         DenseMap<BasicBlock *, BlockFrequency> &ExitWeights,

   88   const DenseMap<Constant*, Constant*> &getMutatedMemory() const {
  102   std::deque<DenseMap<Value*, Constant*>> ValueStack;
  111   DenseMap<Constant*, Constant*> MutatedMemory;

  384   mutable DenseMap<const Value*, int> sn_mapL, sn_mapR;

   49   DenseMap<const Comdat *, Comdat *> RenamedComdats;

  350                                DenseMap<Value *, AllocaInst *> &AllocaForValue);

  132   DenseMap<const Value *, const RuntimePointerChecking::CheckingPtrGroup *>
  136   DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>
  140   DenseMap<const RuntimePointerChecking::CheckingPtrGroup *, MDNode *>

  253   DenseMap<const Value *, const PredicateBase *> PredicateMap;
  261   DenseMap<Value *, unsigned int> ValueInfoNums;

   42     DenseMap<BasicBlock *, Value *> Defines;

   72   using AvailableValsTy = DenseMap<BlkT *, ValT>;
   79   using BBMapTy = DenseMap<BlkT *, BBInfo *>;

  211   using ReductionList = DenseMap<PHINode *, RecurrenceDescriptor>;
  247   DenseMap<Instruction *, Instruction *> &getSinkAfter() { return SinkAfter; }
  442   DenseMap<Instruction *, Instruction *> SinkAfter;

   36   using Index = DenseMap<std::pair<uint64_t, int32_t>, std::vector<Block>>;

   93   using EdgeMapT = DenseMap<EdgeIdentifier, EdgeAttribute>;
   97   using VertexMapT = DenseMap<VertexIdentifier, VertexAttribute>;
  107   using NeighborLookupT = DenseMap<VertexIdentifier, NeighborSetT>;

  134   DenseMap<PathID, TrieNode *> PathIDMap;

  179   using HashTable = DenseMap<BlockNode::IndexType, Weight>;

  161   using ValueStateMap = DenseMap<InstantiatedValue, StateSet>;
  162   using ValueReachMap = DenseMap<InstantiatedValue, ValueStateMap>;
  202   using MemMapType = DenseMap<InstantiatedValue, MemSet>;
  226   using MapType = DenseMap<InstantiatedValue, AliasAttrs>;
  327   DenseMap<const Value *, std::vector<OffsetValue>> AliasMap;
  330   DenseMap<const Value *, AliasAttrs> AttrMap;
  369 static void populateAttrMap(DenseMap<const Value *, AliasAttrs> &AttrMap,
  383 populateAliasMap(DenseMap<const Value *, std::vector<OffsetValue>> &AliasMap,
  430   DenseMap<Value *, ValueSummary> ValueMap;

   98   using ValueMap = DenseMap<Value *, ValueInfo>;

  124   DenseMap<StratifiedIndex, InterfaceValue> InterfaceMap;

  203   DenseMap<Value *, CallGraphNode *> Calls;
  297         DenseMap<Value *, CallGraphNode *>::iterator ExistingIt =

   77 DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
   80   DenseMap<BasicBlock *, ColorVector> BlockColors;

  673     DenseMap<Instruction *, Instruction *> &SinkAfter, DominatorTree *DT) {

  169   DenseMap<Value *, Constant *> SimplifiedValues;
  173   DenseMap<Value *, Value *> SROAArgValues;
  178   DenseMap<Value *, int> SROAArgCosts;
  181   DenseMap<Value *, std::pair<Value *, APInt>> ConstantOffsetPtrs;
  188   DenseMap<BasicBlock *, BasicBlock *> KnownSuccessors;
  200                             DenseMap<Value *, int>::iterator &CostIt);
  201   void disableSROA(DenseMap<Value *, int>::iterator CostIt);
  204   void accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
  334     Value *V, Value *&Arg, DenseMap<Value *, int>::iterator &CostIt) {
  338   DenseMap<Value *, Value *>::iterator ArgIt = SROAArgValues.find(V);
  351 void CallAnalyzer::disableSROA(DenseMap<Value *, int>::iterator CostIt) {
  364   DenseMap<Value *, int>::iterator CostIt;
  370 void CallAnalyzer::accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
  552     DenseMap<Value *, int>::iterator CostIt;
  584   DenseMap<Value *, int>::iterator CostIt;
  647   DenseMap<Value *, int>::iterator CostIt;
  681   DenseMap<Value *, int>::iterator CostIt;
  707   DenseMap<Value *, int>::iterator CostIt;
 1024   DenseMap<Value *, int>::iterator CostIt;
 1127   DenseMap<Value *, int>::iterator CostIt;
 1151   DenseMap<Value *, int>::iterator CostIt;
 1385       DenseMap<Value *, int>::iterator CostIt;
 1426     DenseMap<Value *, int>::iterator CostIt;

   63                     DenseMap<LazyCallGraph::Node *, int> &EdgeIndexMap,

  167     typedef DenseMap<PoisoningVH<BasicBlock>, SmallPtrSet<Value *, 4>>
  175     DenseMap<Value *, std::unique_ptr<ValueCacheEntryTy>> ValueCache;
 1277                       DenseMap<Value*, ValueLatticeElement> &Visited);
 1281                           DenseMap<Value*, ValueLatticeElement> &Visited) {
 1314                       DenseMap<Value*, ValueLatticeElement> &Visited) {
 1327   DenseMap<Value*, ValueLatticeElement> Visited;

  360   DenseMap<Value *, unsigned> PositionMap;
  718     DenseMap<Value *, unsigned> DepSetId;
  845     typedef DenseMap<const Value*, MemAccessInfo> UnderlyingObjToAccessMap;

  671   DenseMap<Loop *, Loop *> SubloopParents;

   37     typedef DenseMap<const Instruction *, DepSet> DepSetMap;

   99 RemoveFromReverseMap(DenseMap<Instruction *, SmallPtrSet<KeyTy, 4>> &ReverseMap,
  101   typename DenseMap<Instruction *, SmallPtrSet<KeyTy, 4>>::iterator InstIt =
  963   DenseMap<BasicBlock *, Value *> Visited;
 1096     DenseMap<BasicBlock *, Value *> &Visited, bool SkipFirstBlock) {
 1180         DenseMap<BasicBlock *, Value *>::iterator VI =
 1284         std::pair<DenseMap<BasicBlock *, Value *>::iterator, bool> InsertRes =
 1347       std::pair<DenseMap<BasicBlock *, Value *>::iterator, bool> InsertRes =

 1302                            DenseMap<MemoryLocOrCall, MemlocStackInfo> &);
 1327     DenseMap<MemoryLocOrCall, MemlocStackInfo> &LocStackInfo) {
 1480   DenseMap<MemoryLocOrCall, MemlocStackInfo> LocStackInfo;

   43     DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &CachedPreviousDef) {
  145   DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> CachedPreviousDef;
  179     DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> &CachedPreviousDef) {
  396         DenseMap<BasicBlock *, TrackingVH<MemoryAccess>> CachedPreviousDef;

   29 const DenseMap<BasicBlock *, ColorVector> &
  383   DenseMap<const Value*, SmallVector<Loop*, 4> > MustExec;

 2268 CollectAddOperandsWithScales(DenseMap<const SCEV *, APInt> &M,
 2317       std::pair<DenseMap<const SCEV *, APInt>::iterator, bool> Pair =
 2573     DenseMap<const SCEV *, APInt> M;
 5539   DenseMap<const SCEV *, ConstantRange> &Cache =
 5547   DenseMap<const SCEV *, ConstantRange>::iterator I = Cache.find(S);
 6669   std::pair<DenseMap<const Loop *, BackedgeTakenInfo>::iterator, bool> Pair =
 7744                                DenseMap<Instruction *, PHINode *> &PHIMap,
 7793   DenseMap<Instruction *, PHINode *> PHIMap;
 7802                                     DenseMap<Instruction *, Constant *> &Vals,
 7887   DenseMap<Instruction *, Constant *> CurrentIterVals;
 7917     DenseMap<Instruction *, Constant *> NextIterVals;
 7967   DenseMap<Instruction *, Constant *> CurrentIterVals;
 7999     DenseMap<Instruction *, Constant *> NextIterVals;

 1967   DenseMap<const SCEV *, PHINode *> ExprToIVMap;

  399   DenseMap<const GlobalValue *, SmallVector<const GlobalValue *, 4>> Callers;

   90   StratifiedSets(DenseMap<T, StratifiedInfo> Map,
  107   DenseMap<T, StratifiedInfo> Values;
  269     DenseMap<StratifiedIndex, StratifiedIndex> Remaps;
  393   DenseMap<T, StratifiedInfo> Values;

   55   DenseMap<NodeRef, Scaled64> AdditionalCounts;

  378   DenseMap<Value *, uint64_t> DBits;

  497   DenseMap<Function *, FunctionType *> FunctionTypes;
  526   using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
  538   DenseMap<Function*, uint64_t> DeferredFunctionInfo;
  548   DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
  760       DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
  790   DenseMap<unsigned, std::pair<ValueInfo, GlobalValue::GUID>>
  797   DenseMap<uint64_t, StringRef> ModuleIdMap;
  823       DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);
 5194     DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
 5227   DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
 5398     DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {
 5494   DenseMap<unsigned, GlobalValue::LinkageTypes> ValueIdToLinkageMap;

  462   DenseMap<unsigned, unsigned> MDKindMap;
 2027         DenseMap<unsigned, unsigned>::iterator I = MDKindMap.find(Kind);

  385       DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
  390                 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
 3045   DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
 3168     DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
 3967   DenseMap<const GlobalValueSummary *, unsigned> SummaryToValueIdMap;
 4265   DenseMap<const Function *, uint64_t> FunctionToBitcodeIndex;

   57   DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
 1021                                  DenseMap<const BasicBlock*, unsigned> &IDMap) {

   58   using TypeMapType = DenseMap<Type *, unsigned>;
   62   using ValueMapType = DenseMap<const Value *, unsigned>;
   91   using MetadataMapType = DenseMap<const Metadata *, MDIndex>;
  109   using AttributeGroupMapType = DenseMap<IndexAndAttrSet, unsigned>;
  113   using AttributeListMapType = DenseMap<AttributeList, unsigned>;
  119   mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs;
  121   using InstructionMapType = DenseMap<const Instruction *, unsigned>;

  698     DenseMap<const MachineBasicBlock *, int> &EHScopeMembership, int EHScope,
  726 DenseMap<const MachineBasicBlock *, int>
  728   DenseMap<const MachineBasicBlock *, int> EHScopeMembership;

  217   DenseMap<uint32_t, SmallVector<AttributeEncoding, 2>> Abbreviations;

   30   DenseMap<const MCSymbol *, AddressPoolEntry> Pool;

  151 using gcp_map_type = DenseMap<GCStrategy *, std::unique_ptr<GCMetadataPrinter>>;

 2981   DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>

  193   DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables;
  198   DenseMap<const DIScope*, std::unique_ptr<GlobalVariableList> > ScopeGlobals;
  240   DenseMap<StringRef, unsigned> FileIdMap;
  251   DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
  256   DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;

  105   DenseMap<const DIE *, unsigned> Numbering;

  287   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
  317   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =

   62   using ImportedEntityMap = DenseMap<const MDNode *, ImportedEntityList>;
   79   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   80   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
   91   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
   97   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {

  577   DenseMap<unsigned, unsigned> RegsForEntryValues;
  945   DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
 2504   DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan>> Spans;

  300   DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap;
  306   DenseMap<const MCSymbol *, uint64_t> SymSize;
  339   DenseMap<const MDNode *, uint64_t> TypeSignatures;
  341   DenseMap<const MCSection *, const MCSymbol *> SectionLabels;

   91   DenseMap<LexicalScope *, ScopeVars> ScopeVariables;
   95   DenseMap<LexicalScope *, LabelList> ScopeLabels;
   98   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   99   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
  104   DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
  165   DenseMap<LexicalScope *, ScopeVars> &getScopeVariables() {
  169   DenseMap<LexicalScope *, LabelList> &getScopeLabels() {
  173   DenseMap<const MDNode *, DIE *> &getAbstractSPDies() {
  177   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> &getAbstractEntities() {

   63   DenseMap<const MDNode *, DIE *> MDNodeToDieMap;
   74   DenseMap<DIE *, const DINode *> ContainingTypeMap;

   51   using RangeMapType = DenseMap<MCSymbol *, PadRange>;

 1111   DenseMap<const MachineBasicBlock *, int> HandlerStates;

   77     DenseMap<const MachineBasicBlock *, int> EHScopeMembership;
  151       DenseMap<const MachineBasicBlock *, BlockFrequency> MergedBBFreq;

  238 using InstrToOrigTy = DenseMap<Instruction *, TypeIsSExt>;
  240 using ValueToSExts = DenseMap<Value *, SExts>;
  277     DenseMap<Value *, Instruction *> SeenChainsForSExt;
  291     DenseMap<AssertingVH<GetElementPtrInst>, int> LargeOffsetGEPID;
  447     const DenseMap<unsigned int, unsigned int> &BypassWidths =
  881     DenseMap<GCRelocateInst *, SmallVector<GCRelocateInst *, 2>>
  886   DenseMap<std::pair<unsigned, unsigned>, GCRelocateInst *> RelocateIdxMap;
 1059   DenseMap<GCRelocateInst *, SmallVector<GCRelocateInst *, 2>> RelocateInstMap;
 1076   DenseMap<BasicBlock*, CastInst*> InsertedCasts;
 1360   DenseMap<BasicBlock*, CmpInst*> InsertedCmps;
 1523                      DenseMap<BasicBlock *, BinaryOperator *> &InsertedShifts,
 1526   DenseMap<BasicBlock *, CastInst *> InsertedTruncs;
 1617   DenseMap<BasicBlock *, BinaryOperator *> InsertedShifts;
 2979   DenseMap<Value *, Value *> Storage;
 3070   typedef DenseMap<Value *, Value *> FoldAddrToValueMapping;
 5522     DenseMap<Value *, Instruction *>::iterator AlreadySeen =
 5621   DenseMap<BasicBlock*, Instruction*> InsertedTruncs;
 6129   DenseMap<BasicBlock*, Instruction*> InsertedShuffles;
 6190   DenseMap<Instruction *, Instruction *> NewInstructions;

  450   DenseMap<MachineInstr *, const SUnit *> MISUnitMap;

   46   DenseMap<const MachineBasicBlock *, int> FuncletMembership =

  430   DenseMap<MachineBasicBlock *, MachineInstr *> EmittedInsns;

  110   DenseMap<std::pair<MachineBasicBlock *, unsigned>, unsigned> MBBWithLocalDef;

  283   DenseMap<Function *, size_t /*UsedGlobalSetIdx*/> GlobalUsesByFunction;
  604   DenseMap<std::pair<unsigned, StringRef>, SmallVector<GlobalVariable *, 16>>

  104   DenseMap<int, std::unique_ptr<LiveInterval>> StackSlotToOrigLI;
  116   DenseMap<unsigned, SmallSetVector<unsigned, 16>> Virt2SiblingsMap;
 1329   DenseMap<MachineDomTreeNode *, unsigned> SpillsToKeep;
 1331   DenseMap<MachineDomTreeNode *, MachineInstr *> SpillBBToSpill;
 1345   DenseMap<MachineDomTreeNode *, NodesCostPair> SpillsInSubTreeMap;
 1486     DenseMap<MachineBasicBlock *, unsigned> SpillsToIns;

  363   DenseMap<ExtractElementInst *, std::pair<Value *, int>> ReplacementMap;

   58   DenseMap<const MachineInstr *, LexicalScope *> MI2ScopeMap;
   70     DenseMap<const MachineInstr *, LexicalScope *> &MI2ScopeMap) {
  260     DenseMap<const MachineInstr *, LexicalScope *> &MI2ScopeMap) {

  388       DenseMap<FragmentOfVar, SmallVector<DIExpression::FragmentInfo, 1>>;
  393       DenseMap<const DILocalVariable *, SmallSet<FragmentInfo, 4>>;
 1279   DenseMap<unsigned int, MachineBasicBlock *> OrderToBB;
 1280   DenseMap<MachineBasicBlock *, unsigned int> BBToOrder;

  139 using SpillOffsetMap = DenseMap<unsigned, unsigned>;
  405   using VRMap = DenseMap<unsigned, SmallVector<UserValue *, 4>>;
  409   using UVMap = DenseMap<UserValueIdentity, UserValue *>;

   69 using InstOrderMap = DenseMap<MachineInstr *, unsigned>;
  120   DenseMap<unsigned, std::pair<unsigned, MachineInstr *>> UseMap;

  372   DenseMap<unsigned, const BasicBlock *> Slots2BasicBlocks;
  374   DenseMap<unsigned, const Value *> Slots2Values;
  395   parseBasicBlockDefinitions(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
  406   parseBasicBlockDefinition(DenseMap<unsigned, MachineBasicBlock *> &MBBSlots);
  585     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
  652     DenseMap<unsigned, MachineBasicBlock *> &MBBSlots) {
 2961     DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
 2976     const DenseMap<unsigned, const BasicBlock *> &Slots2BasicBlocks) {
 2992   DenseMap<unsigned, const BasicBlock *> CustomSlots2BasicBlocks;
 2998                            DenseMap<unsigned, const Value *> &Slots2Values) {
 3007                              DenseMap<unsigned, const Value *> &Slots2Values) {

  811   DenseMap<unsigned, unsigned> &ConstantPoolSlots = PFS.ConstantPoolSlots;

  112   DenseMap<const uint32_t *, unsigned> RegisterMaskIds;
  115   DenseMap<int, FrameIndexOperand> StackObjectOperandMapping;
  145   const DenseMap<const uint32_t *, unsigned> &RegisterMaskIds;
  146   const DenseMap<int, FrameIndexOperand> &StackObjectOperandMapping;
  155             const DenseMap<const uint32_t *, unsigned> &RegisterMaskIds,
  156             const DenseMap<int, FrameIndexOperand> &StackObjectOperandMapping)

  119   DenseMap<const MachineBasicBlock *, int> LayoutOrderMap;

  202 using BlockToChainMapType = DenseMap<const MachineBasicBlock *, BlockChain *>;
  337   DenseMap<const MachineBasicBlock *, BlockAndTailDupResult> ComputedEdges;
  387   DenseMap<const MachineBasicBlock *, BlockChain *> BlockToChain;
 1171   DenseMap<const MachineBasicBlock *, TriangleChain> TriangleChainMap;

  108     DenseMap<MachineBasicBlock *, ScopeType *> ScopeMap;
  109     DenseMap<MachineInstr *, MachineBasicBlock *, MachineInstrExpressionTrait>
  134                          DenseMap<MachineDomTreeNode*, unsigned> &OpenChildren);
  504   DenseMap<MachineBasicBlock*, ScopeType*>::iterator SI = ScopeMap.find(MBB);
  720                         DenseMap<MachineDomTreeNode*, unsigned> &OpenChildren) {
  740   DenseMap<MachineDomTreeNode*, unsigned> OpenChildren;

   89                     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg,
   98                           DenseMap<unsigned, unsigned> &InstrIdxForVirtReg,
  158                           DenseMap<unsigned, unsigned> &InstrIdxForVirtReg,
  177       DenseMap<unsigned, unsigned>::iterator II =
  303     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg,
  469     DenseMap<unsigned, unsigned> InstrIdxForVirtReg;
  549       DenseMap<unsigned, unsigned> InstrIdxForVirtReg;

   83   DenseMap<unsigned, CopyInfo> Copies;
  224   DenseMap<MachineInstr*, SmallVector<MachineInstr*, 2>> CopyDbgUsers;

  715 void MachineFunction::tidyLandingPads(DenseMap<MCSymbol *, uintptr_t> *LPMap,

  132     DenseMap<unsigned, std::vector<const MachineInstr *>> CSEMap;
  199     bool CanCauseHighRegPressure(const DenseMap<unsigned, int> &Cost,
  214         DenseMap<MachineDomTreeNode *, unsigned> &OpenChildren,
  215         DenseMap<MachineDomTreeNode *, MachineDomTreeNode *> &ParentMap);
  225     DenseMap<unsigned, int> calcRegisterCost(const MachineInstr *MI,
  240         DenseMap<unsigned, std::vector<const MachineInstr *>>::iterator &CI);
  648     DenseMap<MachineDomTreeNode*, unsigned> &OpenChildren,
  649     DenseMap<MachineDomTreeNode*, MachineDomTreeNode*> &ParentMap) {
  677   DenseMap<MachineDomTreeNode*, MachineDomTreeNode*> ParentMap;
  678   DenseMap<MachineDomTreeNode*, unsigned> OpenChildren;
  844 DenseMap<unsigned, int>
  847   DenseMap<unsigned, int> Cost;
 1149 MachineLICMBase::CanCauseHighRegPressure(const DenseMap<unsigned, int>& Cost,
 1363     DenseMap<unsigned, std::vector<const MachineInstr *>>::iterator &CI) {
 1422   DenseMap<unsigned, std::vector<const MachineInstr *>>::iterator
 1468   DenseMap<unsigned, std::vector<const MachineInstr *>>::iterator

   45   DenseMap<unsigned, Register> Remaps;

   71   DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols;
   80   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>
  126   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>::iterator I =

  125   DenseMap<unsigned, SuffixTreeNode *> Children;
  617   DenseMap<MachineInstr *, unsigned, MachineInstrExpressionTrait>
  621   DenseMap<MachineBasicBlock *, unsigned> MBBFlagsMap;
  665     DenseMap<MachineInstr *, unsigned, MachineInstrExpressionTrait>::iterator

  531   DenseMap<MachineInstr *, int> Cycles, Stages;
  541   DenseMap<MachineInstr *, std::pair<unsigned, int64_t>> NewInstrChanges;
  908   DenseMap<unsigned, unsigned> Resources;
 1144   DenseMap<int, int> OutputDeps;
 2152   DenseMap<SUnit *, std::pair<unsigned, int64_t>>::iterator It =
 2772         DenseMap<SUnit *, std::pair<unsigned, int64_t>>::iterator It =

   37 using AvailableValsTy = DenseMap<MachineBasicBlock *, unsigned>;

 1599   DenseMap<unsigned, unsigned> StoreChainIDs;
 1617     std::pair<DenseMap<unsigned, unsigned>::iterator, bool> Result =

  109     DenseMap<unsigned, TinyPtrVector<MachineInstr *>> SeenDbgUsers;
 1078   DenseMap<unsigned, TinyPtrVector<MachineInstr *>> SeenDbgInstrs;

  948 using MIHeightMap = DenseMap<const MachineInstr *, unsigned>;

  108     using RegMap = DenseMap<unsigned, const MachineInstr *>;
  213     DenseMap<const MachineBasicBlock*, BBInfo> MBBInfoMap;

 1254   DenseMap<const TargetRegisterClass *, Register> Undefs;
 1257   DenseMap<std::pair<unsigned, unsigned>, Register> Phis;
 1259   DenseMap<Register, Register> UndefPhis;
 1990   DenseMap<MachineInstr *, int> Cycle, Stage;

  107     using VRegPHIUse = DenseMap<BBVRegPair, unsigned>;
  116         DenseMap<MachineInstr*, unsigned, MachineInstrExpressionTrait>;

  200                          DenseMap<unsigned, MachineInstr*> &ImmDefMIs);
  202                        DenseMap<unsigned, MachineInstr*> &ImmDefMIs);
  218                            DenseMap<unsigned, MachineInstr *> &CopyMIs);
  229         DenseMap<unsigned, MachineInstr *> &NAPhysToVirtMIs);
 1332     DenseMap<unsigned, MachineInstr *> &ImmDefMIs) {
 1353     DenseMap<unsigned, MachineInstr *> &ImmDefMIs) {
 1366     DenseMap<unsigned, MachineInstr*>::iterator II = ImmDefMIs.find(Reg);
 1392     DenseMap<unsigned, MachineInstr *> &CopyMIs) {
 1439     MachineInstr &MI, DenseMap<unsigned, MachineInstr *> &NAPhysToVirtMIs) {
 1622     DenseMap<unsigned, MachineInstr*> ImmDefMIs;
 1630     DenseMap<unsigned, MachineInstr *> NAPhysToVirtMIs;
 1634     DenseMap<unsigned, MachineInstr *> CopySrcMIs;

  102     DenseMap<unsigned, SmallVector<MachineInstr *, 2>> LiveDbgValueMap;

  300     using EvicteeInfo = llvm::DenseMap<unsigned /* evictee */, EvictorInfo>;
 2626   DenseMap<unsigned, unsigned> VirtRegToPhysReg;

  219   using IMatrixCache = DenseMap<IKey, PBQPRAGraph::MatrixPtr>;

  170     DenseMap<unsigned, unsigned long> LargeLIVisitCounter;

   68   DenseMap<BasicBlock *, SmallDenseMap<Instruction *, Marker>> BBMarkerSet;

   75   using LivenessMap = DenseMap<BasicBlock *, BlockLifetimeInfo>;
   82   DenseMap<Instruction *, unsigned> InstructionNumbering;
   86   DenseMap<const BasicBlock *, std::pair<unsigned, unsigned>> BlockInstRange;
   90   DenseMap<AllocaInst *, unsigned> AllocaNumbering;
  106   DenseMap<BasicBlock *, SmallVector<std::pair<unsigned, Marker>, 4>> BBMarkers;

   48   DenseMap<const Value *, unsigned> ObjectOffsets;
   49   DenseMap<const Value *, unsigned> ObjectAlignments;

  152     DenseMap<SDNode *, unsigned> WorklistMap;
  170     DenseMap<SDNode *, std::pair<SDNode *, unsigned>> StoreRootCountMap;

  159     DenseMap<const Value *, unsigned>::iterator VI = LocalValueMap.find(&*I);
  480   DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(V);
 1770   DenseMap<const Value *, unsigned>::iterator I = FuncInfo.ValueMap.find(Op0);

  101   DenseMap<const AllocaInst *, TinyPtrVector<int *>> CatchObjects;
  319     DenseMap<BBOrMBB, BBOrMBB> NewMap;

   87                 unsigned SrcReg, DenseMap<SDValue, unsigned> &VRBaseMap) {
  193                                        DenseMap<SDValue, unsigned> &VRBaseMap) {
  267                              DenseMap<SDValue, unsigned> &VRBaseMap) {
  281   DenseMap<SDValue, unsigned>::iterator I = VRBaseMap.find(Op);
  295                                  DenseMap<SDValue, unsigned> &VRBaseMap,
  366                               DenseMap<SDValue, unsigned> &VRBaseMap,
  476                                   DenseMap<SDValue, unsigned> &VRBaseMap,
  609                                      DenseMap<SDValue, unsigned> &VRBaseMap) {
  629                                   DenseMap<SDValue, unsigned> &VRBaseMap,
  678                            DenseMap<SDValue, unsigned> &VRBaseMap) {
  722     DenseMap<SDValue, unsigned>::iterator I = VRBaseMap.find(Op);
  783                 DenseMap<SDValue, unsigned> &VRBaseMap) {
  981                 DenseMap<SDValue, unsigned> &VRBaseMap) {

   43                        DenseMap<SDValue, unsigned> &VRBaseMap);
   49                               DenseMap<SDValue, unsigned> &VRBaseMap);
   54                  DenseMap<SDValue, unsigned> &VRBaseMap);
   63                           DenseMap<SDValue, unsigned> &VRBaseMap,
   74                   DenseMap<SDValue, unsigned> &VRBaseMap,
   85   void EmitSubregNode(SDNode *Node, DenseMap<SDValue, unsigned> &VRBaseMap,
   93                               DenseMap<SDValue, unsigned> &VRBaseMap);
   97   void EmitRegSequence(SDNode *Node, DenseMap<SDValue, unsigned> &VRBaseMap,
  108                              DenseMap<SDValue, unsigned> &VRBaseMap);
  116                 DenseMap<SDValue, unsigned> &VRBaseMap) {
  135                        DenseMap<SDValue, unsigned> &VRBaseMap);
  137                        DenseMap<SDValue, unsigned> &VRBaseMap);

  232   DenseMap<SDValue, SDValue>::iterator I = LegalizedNodes.find(Op);

  541   DenseMap<SUnit*, SmallVector<unsigned, 4> > LRegsMap;
  654   DenseMap<SDNode*, SDNode*> GluedMap;  // Cache glue to its user
  693       DenseMap<SDNode*, SDNode*>::iterator DI = GluedMap.find(OpN);
  764   DenseMap<SDValue, unsigned> VRBaseMap;

  176   using LRegsMapT = DenseMap<SUnit *, SmallVector<unsigned, 4>>;
  186   DenseMap<SUnit*, SUnit*> CallSeqEndForStart;

  225   DenseMap<long long, SDNode*> O2SMap;  // Map from offset to SDNode.
  734                    DenseMap<SDValue, unsigned> &VRBaseMap, unsigned Order) {
  761                   DenseMap<SDValue, unsigned> &VRBaseMap,
  787 EmitPhysRegCopy(SUnit *SU, DenseMap<SUnit*, unsigned> &VRBaseMap,
  794       DenseMap<SUnit*, unsigned>::iterator VRI = VRBaseMap.find(I->getSUnit());
  829   DenseMap<SDValue, unsigned> VRBaseMap;
  830   DenseMap<SUnit*, unsigned> CopyVRBaseMap;

  187     void EmitPhysRegCopy(SUnit *SU, DenseMap<SUnit*, unsigned> &VRBaseMap,

 8411   DenseMap<SDNode *, unsigned> Degree;
 8434   DenseMap<const SDNode *, bool> DivergenceMap;

 1371   DenseMap<const Value *, unsigned>::iterator It = FuncInfo.ValueMap.find(V);
 1558     DenseMap<const AllocaInst*, int>::iterator SI =
 1936   DenseMap<const Value *, unsigned>::iterator VMI = FuncInfo.ValueMap.find(V);
 5550     DenseMap<const Value *, unsigned>::const_iterator
 9412     DenseMap<const Argument *,
 9512     DenseMap<int, int> &ArgCopyElisionFrameIndexMap,
 9779   DenseMap<int, int> ArgCopyElisionFrameIndexMap;
 9969         DenseMap<const Value *, unsigned>::iterator I =

  100   DenseMap<const Value*, SDValue> NodeMap;
  104   DenseMap<const Value*, SDValue> UnusedArgNodeMap;
  406   DenseMap<const Constant *, unsigned> ConstantsOut;
  418   DenseMap<MachineBasicBlock *, SmallVector<unsigned, 4>> LPadToCallSiteMap;

  514   for (DenseMap<unsigned, unsigned>::iterator I = FuncInfo->RegFixups.begin(),
  522       DenseMap<unsigned, unsigned>::iterator J = FuncInfo->RegFixups.find(To);
  563   DenseMap<unsigned, unsigned> LiveInMap;
  589     DenseMap<unsigned, unsigned>::iterator LDI = LiveInMap.find(Reg);
  661   for (DenseMap<unsigned, unsigned>::iterator
  669       DenseMap<unsigned, unsigned>::iterator J = FuncInfo->RegFixups.find(To);

  281   DenseMap<SDValue, const Value *> Seen;

  111   DenseMap<SDValue, SDValue> Locations;

  319   using ValueMap = DenseMap<std::pair<unsigned, unsigned>, ValueForcePair>;

  402   using LivenessMap = DenseMap<const MachineBasicBlock *, BlockLifetimeInfo>;
  406   DenseMap<const MachineBasicBlock *, int> BasicBlocks;
  451   using BlockBitVecMap = DenseMap<const MachineBasicBlock *, BitVector>;
  498   void remapInstructions(DenseMap<int, int> &SlotRemap);
  510   void expungeSlotMap(DenseMap<int, int> &SlotRemap, unsigned NumSlots);
  886 void StackColoring::remapInstructions(DenseMap<int, int> &SlotRemap) {
  904   DenseMap<const AllocaInst*, const AllocaInst*> Allocas;
 1119 void StackColoring::expungeSlotMap(DenseMap<int, int> &SlotRemap,
 1205   DenseMap<int, int> SlotRemap;

  195   DenseMap<MachineBasicBlock*, BranchProbability> JTProbs;

  200       DenseMap<unsigned, AvailableValsTy>::iterator LI =
  324   DenseMap<unsigned, AvailableValsTy>::iterator LI =
  340     DenseMap<unsigned, RegSubRegPair> &LocalVRMap,
  372     DenseMap<unsigned, RegSubRegPair> &LocalVRMap,
  498       DenseMap<unsigned, AvailableValsTy>::iterator LI =
  841     DenseMap<unsigned, RegSubRegPair> LocalVRMap;
  897       DenseMap<unsigned, RegSubRegPair> LocalVRMap;
  960     DenseMap<unsigned, RegSubRegPair> LocalVRMap;

  776     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const {
  859     DenseMap<unsigned, unsigned> &InstIdxForVirtReg) const {

  320   DenseMap<AnalysisID,IdentifyingPassPtr> TargetPasses;
  499   DenseMap<AnalysisID, IdentifyingPassPtr>::const_iterator

  107   DenseMap<MachineInstr*, unsigned> DistanceMap;
  119   DenseMap<unsigned, unsigned> SrcRegMap;
  124   DenseMap<unsigned, unsigned> DstRegMap;
  392     DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
  547 getMappedReg(unsigned Reg, DenseMap<unsigned, unsigned> &RegMap) {
  549     DenseMap<unsigned, unsigned>::iterator SI = RegMap.find(Reg);
  784     DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(UseMI);
  865   DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);
 1031     DenseMap<MachineInstr*, unsigned>::iterator DDI = DistanceMap.find(&DefMI);
 1055   DenseMap<MachineInstr*, unsigned>::iterator DI = DistanceMap.find(MI);

   80                           DenseMap<BasicBlock *, Value *> &Loads, Function &F);
   96   DenseMap<BasicBlock *, ColorVector> BlockColors;
  175   DenseMap<BasicBlock *, ColorVector> BlockColors = colorEHFunclets(*F);
 1091   DenseMap<BasicBlock *, Value *> Loads;
 1162                                       DenseMap<BasicBlock *, Value *> &Loads,

  358   DenseMap<uint64_t, CIE *> CIEs;

  917   DenseMap<uint64_t, uint64_t> CUMap;

   78 typedef llvm::DenseMap<JITEventListener::ObjectKey, RegisteredObjectInfo>

   74   DenseMap<StringRef, Symbol *> GOTEntries;
   75   DenseMap<StringRef, Symbol *> Stubs;

   72   DenseMap<JITTargetAddress, CIEInformation> CIEInfos;

   50   using SegmentLayoutMap = DenseMap<unsigned, SegmentLayout>;

   22   using AllocationMap = DenseMap<unsigned, sys::MemoryBlock>;

  258   DenseMap<unsigned, NormalizedSection> IndexToSection;
  261   DenseMap<uint32_t, NormalizedSymbol *> IndexToSymbol;

  169   using AnonToNamedDependenciesMap = DenseMap<const Symbol *, SymbolNameSet>;
  315   DenseMap<SymbolStringPtr, SymbolNameSet> NamedSymbolDeps;

   89   DenseMap<StringRef, DenseSet<StringRef>> CallerAndCalles;
  285   DenseMap<StringRef, DenseSet<StringRef>> CallerAndCalles;

  142   DenseMap<SID, SID> SectionToGOTMap;

  101   DenseMap<const Value *, std::pair<unsigned, bool>> IDs;
  492   DenseMap<StructType *, unsigned> Type2Number;
  673   using ValueMap = DenseMap<const Value *, unsigned>;
  696   DenseMap<const MDNode*, unsigned> mdnMap;
  700   DenseMap<AttributeSet, unsigned> asMap;
  708   DenseMap<GlobalValue::GUID, unsigned> GUIDMap;
  763   using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;
  771   using as_iterator = DenseMap<AttributeSet, unsigned>::iterator;
  779   using guid_iterator = DenseMap<GlobalValue::GUID, unsigned>::iterator;
 2368   DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;

  671     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,

  581   using LayoutInfoTy = DenseMap<StructType*, StructLayout*>;

  320   DenseMap<MDNode*, MDNode*> LoopIDsMap;
  384   DenseMap<Metadata *, Metadata *> Replacements;
  395   DenseMap<DISubprogram *, StringRef> NewToLinkageName;

   84                                    DenseMap<const MDNode *, MDNode *> &Cache,

 1261       DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>;
 1265       DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>;
 1273   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
 1274   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
 1276   DenseMap<const Value*, ValueName*> ValueNames;
 1283   Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
 1291   DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;
 1302   DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
 1304   DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
 1308   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
 1327   DenseMap<unsigned, IntegerType*> IntegerTypes;
 1336   DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
 1337   DenseMap<std::pair<Type *, ElementCount>, VectorType*> VectorTypes;
 1338   DenseMap<Type*, PointerType*> PointerTypes;  // Pointers in AddrSpace = 0
 1339   DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
 1344   using ValueHandlesTy = DenseMap<Value *, ValueHandleBase *>;
 1351   DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
 1354   DenseMap<const GlobalObject *, MDGlobalAttachmentMap> GlobalObjectMetadata;
 1357   DenseMap<const GlobalObject *, StringRef> GlobalObjectSections;
 1360   DenseMap<const GlobalValue *, StringRef> GlobalValuePartitions;
 1365   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
 1399   DenseMap<const Function*, std::string> GCNames;

  654   DenseMap<Pass *, SmallPtrSet<Pass *, 8> >::iterator DMI =
  975   for (DenseMap<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(),
  977     DenseMap<AnalysisID, Pass*>::iterator Info = I++;
  997     for (DenseMap<AnalysisID, Pass*>::iterator
 1000       DenseMap<AnalysisID, Pass *>::iterator Info = I++;
 1058       DenseMap<AnalysisID, Pass*>::iterator Pos =
 1190   DenseMap<AnalysisID, Pass*>::const_iterator I =  AvailableAnalysis.find(AID);

  368   DenseMap<GlobalValue::GUID, std::vector<uint64_t>> NodeMap;

   62   DenseMap<PassInstanceID, std::unique_ptr<Timer>> TimingData; ///< timers for pass instances

  447   DenseMap<const BasicBlock *, BasicBlockState *> BlockMap;

  820   DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles;
  836   for (DenseMap<Value*, ValueHandleBase*>::iterator I = Handles.begin(),
  863   DenseMap<Value*, ValueHandleBase*> &Handles = pImpl->ValueHandles;

  268   DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
  284   DenseMap<const DICompileUnit *, bool> HasSourceDebugInfo;
  288   DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
  414                        DenseMap<const MDString *, const MDNode *> &SeenIDs,
 1364   DenseMap<const MDString*, const MDNode*> SeenIDs;
 1392                           DenseMap<const MDString *, const MDNode *> &SeenIDs,

  900   DenseMap<GlobalValue::GUID, PrevailingType> GUIDPrevailingResolutions;

  130     DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy) {
  468     const DenseMap<GlobalValue::GUID, const GlobalValueSummary *>
  601   const DenseMap<GlobalValue::GUID, const GlobalValueSummary *> &PrevailingCopy;
  602   IsPrevailing(const DenseMap<GlobalValue::GUID, const GlobalValueSummary *>
  658   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
  820   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
  995   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;

   32   DenseMap<Type *, Type *> MappedTypes;
  378 typedef DenseMap<const Metadata *, TrackingMDRef> MDMapT;
 1209   DenseMap<MDString *, std::pair<MDNode *, unsigned>> Flags;

   76   DenseMap<const Comdat *, std::vector<GlobalValue *>> LazyComdatMembers;

   70 using SectionIndexMapTy = DenseMap<const MCSectionELF *, uint32_t>;
  192   using RevGroupMapTy = DenseMap<const MCSymbol *, unsigned>;
  235   DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>> Relocations;
  237   DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;

 1859   DenseMap<CIEKey, const MCSymbol *> CIEStarts;

   57   DenseMap<const MCSection*, bool> HasSectionLabel;
  481   DenseMap<const MCFragment *, const MCSymbol *> DefiningSymbolMap;

  110   const DenseMap<MCRegister, int>::const_iterator I = L2SEHRegs.find(RegNum);
  118   const DenseMap<MCRegister, int>::const_iterator I = L2CVRegs.find(RegNum);

  546   DenseMap<const MCSection*, uint8_t> SectionIndexMap;

  228   DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
  231   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
  234   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
  235   DenseMap<const MCSymbolWasm *, uint32_t> GOTIndices;
  237   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
  245   DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
  249   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
  251   DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo> SignatureIndices;

  131   using symbol_map = DenseMap<MCSymbol const *, COFFSymbol *>;
  132   using section_map = DenseMap<MCSection const *, COFFSection *>;

  273   DenseMap<const MCSectionXCOFF *, ControlSection *> WrapperMap;

   58   DenseMap<uint64_t, unsigned> SuperResources;

  435   DenseMap<uint64_t, uint64_t> GotToPlt;

   80   DenseMap<const Comdat *, int> ComdatMap;

  128   DenseMap<StreamType, std::size_t> StreamMap;

   36   DenseMap<const MCSymbol *, std::vector<StringRef>> SymverAliasMap;

  414   DenseMap<NameRefType, size_t> FunctionRecords;

  757         DenseMap<const GCOVFunction *, bool> LineExecs;

  726   DenseMap<SymbolRemappingReader::Key, StringRef> MappedNames;

  100                       DenseMap<StringRef, uint64_t> &TargetCountMap) {
  233       DenseMap<StringRef, uint64_t> TargetCountMap;

  430   DenseMap<uint32_t, uint32_t> IndexMap;

 1189                                   DenseMap<StringRef, KeyStatus> &Keys) {
 1204   bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
 1302     DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
 1503     DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));

 1473   static DenseMap<Key, VarInit*> ThePool;
 1502   static DenseMap<Key, VarBitInit*> ThePool;
 1527   static DenseMap<Key, VarListElementInit*> ThePool;
 1709   static DenseMap<Key, FieldInit*> ThePool;

   46   using CountMap = DenseMap<uint64_t, unsigned>;

  207   DenseMap<unsigned, SmallVector<MachineInstr *, 4>> TagMap;

  364   DenseMap<const AllocaInst *, int>::iterator SI =
  671     DenseMap<const AllocaInst *, int>::iterator SI =

 3144   DenseMap<unsigned, SDValue> CopiedRegs;
 3487   DenseMap<unsigned, SDValue> CopiedRegs;
 8841   DenseMap<ShuffleVectorInst *, SmallVector<Value *, 4>> SubVecs;

 4102     DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const {

  231       DenseMap<unsigned, unsigned> &InstrIdxForVirtReg) const override;

  310   DenseMap<int, std::pair<unsigned, MCSymbol *>> JumpTableEntryInfo;

  148   using InsertionPoints = DenseMap<Instruction *, Uses>;

  525   DenseMap<Value *, AllocaInst *> AllocaForValue;

  181   DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;

   36   DenseMap<Value*, GetElementPtrInst*> noClobberClones;

  158   DenseMap<const Function *, AMDGPUFunctionArgInfo> ArgInfoMap;

   59   DenseMap<const Function *, SIFunctionResourceInfo> CallGraphResourceInfo;

  470                 DenseMap<MachineRegion *, RegionMRT *> &RegionMap);
  624                    DenseMap<MachineRegion *, RegionMRT *> &RegionMap) {
  639   DenseMap<MachineRegion *, RegionMRT *> RegionMap;
 1095   DenseMap<MachineBasicBlock *, MachineBasicBlock *> FallthroughMap;

  262   DenseMap<ReturnInst *, ReplacementVec> Replacements;

  431   DenseMap<MachineInstr*, SmallVector<unsigned, 4>> RegSeqWithOpNos;

  100   using LiveRegSet = DenseMap<unsigned, LaneBitmask>;
  202 DenseMap<MachineInstr*, GCNRPTracker::LiveRegSet>
  214   DenseMap<MachineInstr *, GCNRPTracker::LiveRegSet> LiveRegMap;

  503 DenseMap<MachineInstr *, GCNRPTracker::LiveRegSet>

   94   DenseMap<const MachineBasicBlock*, GCNRPTracker::LiveRegSet> MBBLiveIns;
   96   DenseMap<MachineInstr *, GCNRPTracker::LiveRegSet> BBLiveInMap;
   97   DenseMap<MachineInstr *, GCNRPTracker::LiveRegSet> getBBLiveInMap() const;

 1689   DenseMap<unsigned, unsigned> &RemapSwizzle) {
 1738                                 DenseMap<unsigned, unsigned> &RemapSwizzle) {
 1781   DenseMap<unsigned, unsigned> SwizzleRemap;

  342                            const DenseMap<unsigned, unsigned> &PV,
  536                                        const DenseMap<unsigned, unsigned> &PV,

   45   ExtractSrcs(MachineInstr &MI, const DenseMap<unsigned, unsigned> &PV,
  144                                const DenseMap<unsigned, unsigned> &PV,

   72   DenseMap<unsigned, unsigned> RegToChan;
   96   using InstructionSetMap = DenseMap<unsigned, std::vector<MachineInstr *>>;
  100   DenseMap<MachineInstr *, RegSeqInfo> PreviousRegSeq;
  168   for (DenseMap<unsigned, unsigned>::iterator It = ToMerge->RegToChan.begin(),
  170     DenseMap<unsigned, unsigned>::const_iterator PosInUntouched =
  206   DenseMap<unsigned, unsigned> UpdatedRegToChan = BaseRSI->RegToChan;
  208   for (DenseMap<unsigned, unsigned>::iterator It = RSI->RegToChan.begin(),
  325   for (DenseMap<unsigned, unsigned>::const_iterator

   68   DenseMap<unsigned, unsigned> getPreviousVector(MachineBasicBlock::iterator I)
   70     DenseMap<unsigned, unsigned> Result;
  128   void substitutePV(MachineInstr &MI, const DenseMap<unsigned, unsigned> &PVs)
  140       const DenseMap<unsigned, unsigned>::const_iterator It = PVs.find(Src);
  227                                  const DenseMap<unsigned, unsigned> &PV,
  294     const DenseMap<unsigned, unsigned> &PV =

  698         DenseMap<TargetInstrInfo::RegSubRegPair, Register> VGPRCopies;

   40   typedef DenseMap<unsigned, std::pair<unsigned, LaneBitmask>> RegUse;

  386   DenseMap<MachineBasicBlock *, unsigned> RpotIdxMap;

  202   using MemInfoMap = DenseMap<MachineInstr *, MemAddress>;

  137   DenseMap<MachineBasicBlock *, bool> ReachableMap;
  264   DenseMap<MachineBasicBlock *, unsigned> Visited;

  363   DenseMap<const Value *,
  365   DenseMap<const Value *,
  463   DenseMap<int, std::vector<SpilledReg>> SGPRToVGPRSpills;
  467   DenseMap<int, VGPRSpillToAGPR> VGPRToAGPRSpills;

  155   DenseMap<const MachineInstr *, InstrInfo> Instructions;
  156   DenseMap<MachineBasicBlock *, BlockInfo> Blocks;

 4805   DenseMap<unsigned, unsigned>::const_iterator I = MLxEntryMap.find(Opcode);

  415   DenseMap<unsigned, unsigned> MLxEntryMap;

  112   DenseMap<Value*, SmallVector<Type*, 4>> TruncTysMap;

  180     DenseMap<int, int> JumpTableEntryIndices;
  184     DenseMap<int, int> JumpTableUserIndices;

  668   DenseMap<const AllocaInst*, int>::iterator SI =
  802       DenseMap<const AllocaInst*, int>::iterator SI =

 7160   DenseMap<SDValue, unsigned> ValueCounts;
 9478   DenseMap<unsigned, SmallVector<MachineBasicBlock*, 2>> CallSiteNumToLPad;
 9839       DenseMap<unsigned, bool> DefRegs;
16798   DenseMap<ShuffleVectorInst *, SmallVector<Value *, 4>> SubVecs;

 2067                        DenseMap<MachineInstr*, unsigned> &MI2LocMap);
 2218                                  DenseMap<MachineInstr*, unsigned> &MI2LocMap) {
 2386   DenseMap<MachineInstr*, unsigned> MI2LocMap;
 2387   using MapIt = DenseMap<unsigned, SmallVector<MachineInstr *, 4>>::iterator;
 2388   using Base2InstMap = DenseMap<unsigned, SmallVector<MachineInstr *, 4>>;

  114   DenseMap<unsigned, unsigned> CPEClones;
  122   DenseMap<const MachineBasicBlock*, unsigned> CoalescedWeights;
  222     DenseMap<unsigned, unsigned>::const_iterator I = CPEClones.find(CloneIdx);
  229   DenseMap<const MachineBasicBlock*, unsigned>::iterator getCoalescedWeight(
  254   DenseMap<unsigned, unsigned> EHPrologueRemappedRegs;

 1111   DenseMap<unsigned, int> RegOffsets;

  692   DenseMap<const MCSection *, std::unique_ptr<ElfMappingSymbolInfo>>

  400 static void Cleanup(DenseMap<Instruction*, Instruction*> &NewPredicates,
  453   DenseMap<Instruction*, Instruction*> NewPredicates;

  181     DenseMap<unsigned, unsigned> ReduceOpcodeMap;
 1007   DenseMap<unsigned, unsigned>::iterator OPI = ReduceOpcodeMap.find(Opcode);

   99       Cmp(DenseMap<const MachineInstr*,unsigned> &Map) : Dist(Map) {}
  101       DenseMap<const MachineInstr*,unsigned> &Dist;
  105     DenseMap<const MachineInstr*,unsigned> Dist;

 3068   DenseMap<unsigned,unsigned> RegMap;

   71   using RegExtMap = DenseMap<unsigned, ExtType>;

   73           DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
   75           DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
   77           DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset);
  104       DenseMap<MachineBasicBlock*, unsigned> &OffsetMap) {
  133   DenseMap<MachineBasicBlock*, unsigned> BlockToInstOffset;
  144       DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset) {
  194       DenseMap<MachineBasicBlock*, unsigned> &BlockToInstOffset) {

  396   DenseMap<unsigned, MachineInstr *> LastDef;

  192     using ReferenceMap = DenseMap<unsigned, unsigned>;
 1161   using ValueInfoMap = DenseMap<VNInfo *, VNInfo *>;

  110   DenseMap<const MachineBasicBlock *, unsigned> BlockToInstOffset;

  411   using UnsignedMap = DenseMap<unsigned, unsigned>;

  196   struct UnsignedMap : public DenseMap<unsigned,unsigned> {
  200     using BaseType = DenseMap<unsigned, unsigned>;
  522     using PairMapType = DenseMap<std::pair<unsigned, unsigned>, unsigned>;
  559     using IFMapType = DenseMap<unsigned, IFListType>; // vreg -> IFListType
  814   using LRSMapType = DenseMap<unsigned, RSListType>;

  119     using InstrIndexMap = DenseMap<MachineInstr *, unsigned>;
  120     using DefUseInfoMap = DenseMap<unsigned, DefUseInfo>;
  230   using CondsetMap = DenseMap<unsigned, CondsetInfo>;

 1345     DenseMap<SDNode*, SDNode**> Refs;

  201       using ValueMapType = DenseMap<Value *, Value *>;

   79   using InstrEvalMap = DenseMap<MachineInstr *, bool>;

  117   DenseMap<unsigned, unsigned> PeepholeMap;
  118   DenseMap<unsigned, std::pair<unsigned, unsigned> > PeepholeDoubleRegsMap;
  221             DenseMap<unsigned, std::pair<unsigned, unsigned> >::iterator DI =

  156   using RefToInstrMap = DenseMap<NodeId, NodeId>;
  197   DenseMap<NodeId,unsigned> OpMap;

  196   DenseMap<unsigned, unsigned> VRegHoldingReg;
  199   DenseMap<unsigned, SUnit *> LastVRegUse;

   48   using DefsIterator = DenseMap<unsigned, PredSet>::iterator;
   49   DenseMap<unsigned, PredSet> Defs;

   68   using TypeUnitsAndLanes = DenseMap<unsigned, UnitsAndLanes>;

  113     using NodeBlockMap = DenseMap<NodeId, MachineBasicBlock *>;

  341   DenseMap<const AllocaInst *, int>::iterator SI =
  532     DenseMap<const AllocaInst *, int>::iterator SI =

  110     DenseMap<const MachineInstr *, SmallVector<const MachineInstr *, 2>>
  113     DenseMap<const MachineInstr *, InstType> Types;

  288     DenseMap<unsigned, unsigned> &RegMap = VRegMapping[RC];
  586   const DenseMap<unsigned, unsigned> &RegMap = I->second;
  682                         DenseMap<const Function *, bool> &seenMap) {
  702   DenseMap<const Function *, bool> seenMap;
 1656     DenseMap<unsigned, unsigned> &regmap = VRegMapping[RC];
 1675     DenseMap<unsigned, unsigned> &regmap = VRegMapping[RC];

  251   typedef DenseMap<unsigned, unsigned> VRegMap;
  252   typedef DenseMap<const TargetRegisterClass *, VRegMap> VRegRCMap;

  178   typedef DenseMap<Value *, Value *> B2IMap;

  392       DenseMap<const AllocaInst*, int>::iterator SI =
 2272   DenseMap<const AllocaInst*, int>::iterator SI =

 1208       DenseMap<SDValue, std::unique_ptr<ValueBitsMemoizedValue>>;
 2393   DenseMap<std::pair<SDValue, unsigned>, ValueRotInfo> ValueRots;

12371   DenseMap<SDNode *, EVT> SelectTruncOp[2];

   58   DenseMap<unsigned, unsigned> ImmToIdxMap;

  108   DenseMap<MachineInstr*, int> SwapMap;

 6586   DenseMap<unsigned, std::pair<unsigned, unsigned>> RegRewriteTable;

   83   DenseMap<const MachineLoop *, std::unique_ptr<Region>> LoopMap;
   84   DenseMap<const WebAssemblyException *, std::unique_ptr<Region>> ExceptionMap;

   69   DenseMap<const MachineInstr *, MachineInstr *> BeginToEnd;
   71   DenseMap<const MachineInstr *, MachineInstr *> EndToBegin;
   73   DenseMap<const MachineInstr *, MachineBasicBlock *> TryToEHPad;
   75   DenseMap<const MachineBasicBlock *, MachineInstr *> EHPadToTry;
  863   DenseMap<MachineBasicBlock *, SmallVector<TryRange, 4>> UnwindDestToTryRanges;
  865   DenseMap<MachineBasicBlock *, SmallVector<TryRange, 4>> BrDestToTryRanges;
  867   DenseMap<MachineBasicBlock *, unsigned> BrDestToExnReg;

  119   DenseMap<const MachineBasicBlock *, WebAssemblyException *> BBMap;

   73 static unsigned getLocalId(DenseMap<unsigned, unsigned> &Reg2Local,
  201   DenseMap<unsigned, unsigned> Reg2Local;

  320     DenseMap<const AllocaInst *, int>::iterator SI =
  598   DenseMap<const AllocaInst *, int>::iterator SI =

  274   DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;

  117   DenseMap<MachineBasicBlock *, BlockSet> LoopEnterers;
  122   DenseMap<MachineBasicBlock *, BlockSet> Reachable;
  367   DenseMap<MachineBasicBlock *, unsigned> Indices;

  246   DenseMap<int, Function *> FindMatchingCatches;

   69   DenseMap<const MCSymbol *, std::unique_ptr<FPOData>> AllFPOData;

  384   DenseMap<MachineInstr *, DepthInfo> DepthMap;
  388   DenseMap<unsigned, MachineInstr *> RegDefMaps[RegTypeNum];
  391   DenseMap<MachineOperand *, MachineInstr *> OperandToDefMap;
  707   DenseMap<unsigned, unsigned> FalseBBRegRewriteTable;
  810   DenseMap<unsigned, std::pair<unsigned, unsigned>> RegRewriteTable;

  101   DenseMap<Location, unsigned> MemOpDiscriminators;
  124   DenseMap<Location, DenseSet<unsigned>> Seen;

  286 typedef DenseMap<InstrConverterBaseKeyTy, InstrConverterBase *>
  384   DenseMap<MachineInstr *, unsigned> EnclosedInstrs;

  763       DenseMap<const Value *, unsigned>::iterator I = LocalValueMap.find(V);
  875     DenseMap<const AllocaInst *, int>::iterator SI =

19897   DenseMap<SDValue, APInt> SrcOpMap;
19928     DenseMap<SDValue, APInt>::iterator M = SrcOpMap.find(Src);
19948   for (DenseMap<SDValue, APInt>::const_iterator I = SrcOpMap.begin(),
29680   DenseMap<unsigned, std::pair<unsigned, unsigned>> RegRewriteTable;
30944   DenseMap<unsigned, SmallVector<MachineBasicBlock *, 2>> CallSiteNumToLPad;
31135       DenseMap<unsigned, bool> DefRegs;

   41   DenseMap<int, unsigned> WinEHXMMSlotInfo;
  127   DenseMap<int, unsigned>& getWinEHXMMSlotInfo() { return WinEHXMMSlotInfo; }
  128   const DenseMap<int, unsigned>& getWinEHXMMSlotInfo() const {

  251   using MemOpMap = DenseMap<MemOpKey, SmallVector<MachineInstr *, 16>>;
  295   DenseMap<const MachineInstr *, unsigned> InstrPos;

   79     DenseMap<MachineBasicBlock*, unsigned int> ReturnBBs;
   82     DenseMap<MachineBasicBlock*, VisitedBBInfo> VisitedBBs;
  116   for (DenseMap<MachineBasicBlock*, unsigned int>::iterator I = ReturnBBs.begin();
  171   DenseMap<MachineBasicBlock*, VisitedBBInfo>::iterator it

  137   DenseMap<MachineBasicBlock *, int64_t> OutOffset;

   72   int getBaseStateForBB(DenseMap<BasicBlock *, ColorVector> &BlockColors,
   74   int getStateForCallSite(DenseMap<BasicBlock *, ColorVector> &BlockColors,
  516     DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
  535     DenseMap<BasicBlock *, ColorVector> &BlockColors, WinEHFuncInfo &FuncInfo,
  549 static int getPredState(DenseMap<BasicBlock *, int> &FinalStates, Function &F,
  590 static int getSuccState(DenseMap<BasicBlock *, int> &InitialStates, Function &F,
  662   DenseMap<BasicBlock *, ColorVector> BlockColors = colorEHFunclets(F);
  666   DenseMap<BasicBlock *, int> InitialStates;
  668   DenseMap<BasicBlock *, int> FinalStates;

  891                           DenseMap<Value *, Value *> &ResolvedValues) {
  908   DenseMap<Value *, Value *> ResolvedValues;

  854   DenseMap<const CallBase *, unsigned> NumReturnedValuesPerKnownAA;
 3626   DenseMap<Instruction *, SmallPtrSet<Instruction *, 4>> FreesForMalloc;

  170       Instruction &I, DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  241                    DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  257                      DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  302                    DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  315                  DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  331                   DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,
  345                  DenseMap<CVPLatticeKey, CVPLatticeVal> &ChangedValues,

  141   DenseMap<Constant *, GlobalVariable *> CMap;

 1154               DenseMap<Value *, std::vector<Value *>> &InsertedScalarizedValues,
 1198               DenseMap<Value *, std::vector<Value *>> &InsertedScalarizedValues,
 1261               DenseMap<Value *, std::vector<Value *>> &InsertedScalarizedValues,
 1392   DenseMap<Value *, std::vector<Value *>> InsertedScalarizedValues;
 1441   for (DenseMap<Value *, std::vector<Value *>>::iterator
 1451   for (DenseMap<Value *, std::vector<Value *>>::iterator
 2484 static void BatchCommitValueTo(const DenseMap<Constant*, Constant*> &Mem) {

  139 using InlinedArrayAllocasTy = DenseMap<ArrayType *, std::vector<AllocaInst *>>;

  408   DenseMap<Metadata *, TypeIdUserInfo> TypeIdUsers;
  451               const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout);
  458       const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout);
  554     const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout) {
  824   DenseMap<GlobalTypeMember *, uint64_t> GlobalLayout;
 1108     const DenseMap<GlobalTypeMember *, uint64_t> &GlobalLayout) {
 1483   DenseMap<GlobalTypeMember *, uint64_t> GlobalLayout;
 1564   DenseMap<GlobalTypeMember *, uint64_t> GlobalLayout;
 1592   DenseMap<Metadata *, uint64_t> TypeIdIndices;
 1600   DenseMap<GlobalTypeMember *, uint64_t> GlobalIndices;
 1828   DenseMap<Metadata *, TIInfo> TypeIdInfo;
 1840   DenseMap<StringRef, ExportedFunctionInfo> ExportedFunctions;
 1941   DenseMap<GlobalObject *, GlobalTypeMember *> GlobalTypeMembers;
 2049     DenseMap<GlobalValue::GUID, TinyPtrVector<Metadata *>> MetadataByGUID;

  297   DenseMap<AssertingVH<Function>, FnTreeType::iterator> FNodesInTree;

  298                                      DenseMap<User *, uint64_t> &SiteCountMap);
  466   DenseMap<BasicBlock *, bool> VisitedMap;
  926     DenseMap<User *, uint64_t> &CallSiteToProfCountMap) {
 1383   DenseMap<User *, uint64_t> CallSiteToProfCountMap;

  141 using BlockWeightMap = DenseMap<const BasicBlock *, uint64_t>;
  142 using EquivalenceClassMap = DenseMap<const BasicBlock *, const BasicBlock *>;
  144 using EdgeWeightMap = DenseMap<Edge, uint64_t>;
  146     DenseMap<const BasicBlock *, SmallVector<const BasicBlock *, 8>>;
  173       DenseMap<const FunctionSamples *, BodySampleCoverageMap>;
  205                         DenseMap<uint64_t, StringRef> &GUIDToFuncNameMap)
  245   void SetGUIDToFuncNameMapForAll(DenseMap<uint64_t, StringRef> *Map) {
  267   DenseMap<uint64_t, StringRef> &CurrentGUIDToFuncNameMap;
  303   mutable DenseMap<const DILocation *, const FunctionSamples *> DILocation2SampleMap;
  417   DenseMap<Function *, NotInlinedProfileInfo> notInlinedCallInfo;
  421   DenseMap<uint64_t, StringRef> GUIDToFuncNameMap;
  912   DenseMap<Instruction *, const FunctionSamples *> localNotInlinedCallSites;

  101   DenseMap<Function *, Scaled64> Counts;

   38   DenseMap<const Comdat *, Comdat *> RenamedComdats;
   87   DenseMap<Metadata *, Metadata *> LocalToGlobal;

  494       DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap);
  780     DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) {
  781   DenseMap<GlobalVariable *, VTableBits *> GVToBits;
 1805   DenseMap<Metadata *, std::set<TypeMemberInfo>> TypeIdMap;
 1812     DenseMap<GlobalValue::GUID, TinyPtrVector<Metadata *>> MetadataByGUID;
 1934   DenseMap<GlobalValue::GUID, std::vector<StringRef>> NameByGUID;

  656   DenseMap<Value *, Value *> NewInsts;

 1031   DenseMap<BasicBlock*, Value*> PredValues;
 1035   DenseMap<LoweredPHIRecord, PHINode*> ExtractedVals;

 2005     DenseMap<Type *, Value *> NewBCs;

 3379   DenseMap<Constant *, Constant *> FoldedConstants;

  696   DenseMap<const AllocaInst *, bool> ProcessedAllocas;
  906   using AllocaForValueMapTy = DenseMap<Value *, AllocaInst *>;
 3031   DenseMap<const AllocaInst *, ASanStackVariableDescription *> AllocaToSVDMap;

   46   DenseMap<const BasicBlock *, std::unique_ptr<BBInfo>> BBInfos;

  169 typedef DenseMap<Region *, DenseSet<Instruction *>> HoistStopMapTy;
  419   DenseMap<Region *, BranchProbability> BranchBiasMap;
  421   DenseMap<SelectInst *, BranchProbability> SelectBiasMap;
  517     DenseMap<Value *, std::set<Value *>> &Visited) {
  558                 DenseMap<Instruction *, bool> &Visited) {
  662                               DenseMap<Region *, BranchProbability> &BranchBiasMap) {
  694     DenseMap<SelectInst *, BranchProbability> &SelectBiasMap) {
  912       DenseMap<Instruction *, bool> Visited;
  933       DenseMap<Instruction *, bool> Visited;
  966       DenseMap<Instruction *, bool> Visited;
  974       DenseMap<Instruction *, bool> Visited;
 1077     DenseMap<Instruction *, bool> Visited;
 1089     DenseMap<Value *, std::set<Value *>> Visited;
 1408       DenseMap<Instruction *, bool> Visited;
 1420       DenseMap<Instruction *, bool> Visited;

  355   DenseMap<Value *, Function *> UnwrappedFnMap;
  393   DenseMap<Value *, Value *> ValShadowMap;
  394   DenseMap<AllocaInst *, AllocaInst *> AllocaShadowMap;
  404   DenseMap<std::pair<Value *, Value *>, CachedCombinedShadow>
  406   DenseMap<Value *, std::set<Value *>> ShadowElements;
 1549   DenseMap<Value *, Function *>::iterator i =

  448     DenseMap<BasicBlock *, GCOVBlock> Blocks;
  786       DenseMap<std::pair<BasicBlock *, BasicBlock *>, unsigned> EdgeToCounter;

  224       DenseMap<AllocaInst *, std::vector<DbgDeclareInst *>> &AllocaDeclareMap,
 1043     DenseMap<AllocaInst *, std::vector<DbgDeclareInst *>> &AllocaDeclareMap,
 1116   DenseMap<AllocaInst *, std::vector<DbgDeclareInst *>> AllocaDeclareMap;
 1182   DenseMap<AllocaInst *, AllocaInst *> AllocaToPaddedAllocaMap;

  185       DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCands,
  229   DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCandidates;
  239       DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCands,
  365   DenseMap<Loop *, SmallVector<LoadStorePair, 8>> &LoopToCandidates;
  446   DenseMap<Loop *, SmallVector<LoadStorePair, 8>> LoopPromotionCandidates;

 2584     DenseMap<Value *, AllocaInst *> AllocaForValue;

  223 static Value *getPoisonFor(DenseMap<Value *, Value *> &ValToPoison, Value *V) {
  259   DenseMap<Value *, Value *> ValToPoison;

   24   using MapTy = DenseMap<KeyT, size_t>;

  322                const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
  338                const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
  560   DenseMap<BasicBlock *, ColorVector> BlockColors;
  582   DenseMap<const BasicBlock *, unsigned> BBSizeMap;

  510                             DenseMap<const BasicBlock *, BBState> &BBStates,
  516                        DenseMap<const BasicBlock *, BBState> &BBStates,
  519                                  DenseMap<Value *, RRInfo> &Releases,
  522                       DenseMap<const BasicBlock *, BBState> &BBStates,
  523                       DenseMap<Value *, RRInfo> &Releases);
  524     bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates,
  526                DenseMap<Value *, RRInfo> &Releases);
  530                    DenseMap<Value *, RRInfo> &Releases,
  534     PairUpRetainsAndReleases(DenseMap<const BasicBlock *, BBState> &BBStates,
  536                              DenseMap<Value *, RRInfo> &Releases, Module *M,
  543     bool PerformCodePlacement(DenseMap<const BasicBlock *, BBState> &BBStates,
  545                               DenseMap<Value *, RRInfo> &Releases, Module *M);
  721                    const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
  750   DenseMap<BasicBlock *, ColorVector> BlockColors;
 1108                                DenseMap<const BasicBlock *, BBState> &BBStates,
 1134       const DenseMap<const BasicBlock *, BBState>::iterator BBI =
 1265                                DenseMap<const BasicBlock *, BBState> &BBStates,
 1278     DenseMap<const BasicBlock *, BBState>::iterator I = BBStates.find(Succ);
 1331                                     DenseMap<Value *, RRInfo> &Releases,
 1401                          DenseMap<const BasicBlock *, BBState> &BBStates,
 1402                          DenseMap<Value *, RRInfo> &Releases) {
 1413     DenseMap<const BasicBlock *, BBState>::iterator I = BBStates.find(Pred);
 1455                   DenseMap<const BasicBlock *, BBState> &BBStates) {
 1531                        DenseMap<const BasicBlock *, BBState> &BBStates,
 1533                        DenseMap<Value *, RRInfo> &Releases) {
 1568                            DenseMap<Value *, RRInfo> &Releases,
 1622     DenseMap<const BasicBlock *, BBState> &BBStates,
 1624     DenseMap<Value *, RRInfo> &Releases, Module *M,
 1821     DenseMap<const BasicBlock *, BBState> &BBStates,
 1823     DenseMap<Value *, RRInfo> &Releases, Module *M) {
 2045   DenseMap<Value *, RRInfo> Releases;
 2050   DenseMap<const BasicBlock *, BBState> BBStates;

   55   using CachedResultsTy = DenseMap<ValuePairTy, bool>;
   59   DenseMap<const Value *, WeakTrackingVH> UnderlyingObjCPtrCache;

  128   DenseMap<Instruction *, InstInfoType> InstInfo;
  256     using StatusMap = DenseMap<BasicBlock *, bool>;

  264   DenseMap<BasicBlock *, InsertPtsCostPair> InsertPtsMap;

  353   DenseMap<BasicBlock*, int> SuccessorsCount;

   92 using InstOverlapIntervalsTy = DenseMap<Instruction *, OverlapIntervalsTy>;

  123   DenseMap<DivRemMapKey, Instruction *> DivMap;

  482   DenseMap<Value*, uint32_t>::iterator VI = valueNumbering.find(V);
  558   DenseMap<Value*, uint32_t>::const_iterator VI = valueNumbering.find(V);
  601   for (DenseMap<Value*, uint32_t>::const_iterator
  636 LLVM_DUMP_METHOD void GVN::dump(DenseMap<uint32_t, Value*>& d) const {
  638   for (DenseMap<uint32_t, Value*>::iterator I = d.begin(),
  658                             DenseMap<BasicBlock*, char> &FullyAvailableBlocks,
  665   std::pair<DenseMap<BasicBlock*, char>::iterator, bool> IV =
 1086   DenseMap<BasicBlock*, char> FullyAvailableBlocks;
 2506   for (DenseMap<uint32_t, LeaderTableEntry>::const_iterator

  117 using BBSideEffectsSet = DenseMap<const BasicBlock *, bool>;
  130 using VNtoInsns = DenseMap<VNType, SmallVector<Instruction *, 4>>;
  157 using OutValuesType = DenseMap<BasicBlock *, SmallVector<CHIArg, 2>>;
  159     DenseMap<BasicBlock *, SmallVector<std::pair<VNType, Instruction *>, 2>>;
  336   DenseMap<const Value *, unsigned> DFSNumber;
  614   using RenameStackType = DenseMap<VNType, SmallVector<Instruction *, 2>>;

  384   DenseMap<Value *, uint32_t> ValueNumbering;
  385   DenseMap<GVNExpression::Expression *, uint32_t> ExpressionNumbering;
  386   DenseMap<size_t, uint32_t> HashNumbering;
  638   DenseMap<uint32_t, unsigned> VNums;

  310   DenseMap<BasicBlock *, SmallVector<Instruction *, 8>> GuardsInBlock;

  995   DenseMap<AssertingVH<Instruction>, ExtendKind> ExtendKindMap;
 1003   DenseMap<DefUserPair, ConstantRange> PostIncRangeInfos;

  140 using ValueToAddrSpaceMapTy = DenseMap<const Value *, unsigned>;

 1540   DenseMap<BasicBlock*, unsigned> DestPopularity;
 1549   DenseMap<BasicBlock*, unsigned>::iterator DPI = DestPopularity.begin();
 1906                                      DenseMap<Instruction*, Value*> &ValueMap) {
 1914       DenseMap<Instruction*, Value*>::iterator I = ValueMap.find(Inst);
 1983   DenseMap<Instruction*, Value*> ValueMapping;
 2018         DenseMap<Instruction*, Value*>::iterator I = ValueMapping.find(Inst);
 2110   DenseMap<BasicBlock *, BlockFrequency> FreqMap;
 2318   DenseMap<Instruction*, Value*> ValueMapping;
 2331         DenseMap<Instruction*, Value*>::iterator I = ValueMapping.find(Inst);

  169   using ASTrackerMapTy = DenseMap<Loop *, std::unique_ptr<AliasSetTracker>>;
  579   DenseMap<BasicBlock *, BasicBlock *> HoistDestinationMap;
  583   DenseMap<BranchInst *, BasicBlock *> HoistableBranches;

  279   using InstToPartitionIdT = DenseMap<Instruction *, int>;
  352     using LoadToPartitionT = DenseMap<Instruction *, InstPartition *>;

  262         DenseMap<LoadInst *, const StoreToLoadForwardingCandidate *>;
  585   DenseMap<Instruction *, unsigned> InstOrder;

  190     DenseMap<Instruction *, int64_t> IVToIncMap;
  298         DenseMap<Instruction *, int>::iterator J1I = PossibleRedIdx.find(J1);
  300           DenseMap<Instruction *, int>::iterator J2I = PossibleRedIdx.find(J2);
  336       DenseMap<Instruction *, int> PossibleRedIdx;
  337       DenseMap<Instruction *, int> PossibleRedIter;
  382                      DenseMap<Instruction *, int64_t> &IncrMap,
  463       DenseMap<Instruction *, int64_t> &IVToIncMap;
 1216     DenseMap<Value *, Value *> BaseMap;
 1359           DenseMap<Value *, Value *>::iterator BMI = BaseMap.find(Op2);

  190     DenseMap<const BasicBlock *, unsigned> RPO;

  234   using RegUsesTy = DenseMap<const SCEV *, RegSortData>;
 1971   using UseMapTy = DenseMap<LSRUse::SCEVUseKindPair, size_t>;
 4105   DenseMap<const SCEV *, ImmMapTy> Map;
 4106   DenseMap<const SCEV *, SmallBitVector> UsedByIndicesMap;
 4320       DenseMap<SmallVector<const SCEV *, 4>, size_t, UniquifierDenseMapInfo>;
 4592   using BestFormulaeTy = DenseMap<std::pair<const SCEV *, int64_t>, size_t>;
 4730   DenseMap <const SCEV *, float> RegNumMap;
 5308   DenseMap<BasicBlock *, Value *> Inserted;
 5356       std::pair<DenseMap<BasicBlock *, Value *>::iterator, bool> Pair =

  356   DenseMap<Value *, Constant *> SimplifiedValues;

  104         DenseMap<const SwitchInst *, SmallPtrSet<const Value *, 8>>;
  423                                    DenseMap<Value *, Value *> &Cache,
  507   DenseMap<Value *, Value *> Cache;

  135   DenseMap<const Value*, int> BaseToIndex;

  245   DenseMap<const Value *, unsigned int> Root;
  252   DenseMap<const Value *, unsigned> ValueToComponent;
  511   DenseMap<const DomTreeNode *, unsigned> RPOOrdering;
  524   DenseMap<Value *, CongruenceClass *> ValueToClass;
  525   DenseMap<Value *, const Expression *> ValueToExpression;
  533   DenseMap<const Value *, bool> OpSafeForPHIOfOps;
  536   DenseMap<const Value *, BasicBlock *> TempToBlock;
  540   DenseMap<const Value *, PHINode *> RealToTemp;
  550   mutable DenseMap<const Value *, SmallPtrSet<Value *, 2>> AdditionalUsers;
  551   DenseMap<const Expression *, SmallPtrSet<Instruction *, 2>>
  555   DenseMap<const Instruction *, MemoryUseOrDef *> TempToMemory;
  570   DenseMap<BasicBlock *, SparseBitVector<>> RevisitOnReachabilityChange;
  576   mutable DenseMap<const Value *, SmallPtrSet<Instruction *, 2>>
  581   mutable DenseMap<const MemoryAccess *, SmallPtrSet<MemoryAccess *, 2>>
  589   DenseMap<const MemoryAccess *, CongruenceClass *> MemoryAccessToClass;
  602   DenseMap<const MemoryPhi *, MemoryPhiState> MemoryPhiState;
  605   mutable DenseMap<const Instruction *, InstCycleState> InstCycleState;
  608   using ExpressionClassMap = DenseMap<const Expression *, CongruenceClass *>;
  637   DenseMap<const BasicBlock *, std::pair<unsigned, unsigned>> BlockInstRange;
  641   DenseMap<const Value *, unsigned> ProcessedCount;
  648   DenseMap<const Value *, unsigned> InstrDFS;
  788                                 DenseMap<const Value *, unsigned int> &,
 3561     DenseMap<const Value *, unsigned int> &UseCounts,
 3854   DenseMap<const BasicBlock *, unsigned> ReachablePredCount;
 3871   DenseMap<const Value *, unsigned int> UseCounts;

  490   using LeafMap = DenseMap<Value *, APInt>;
 1525   DenseMap<Value*, unsigned> FactorOccurrences;

 1305   DenseMap<Type *, Function *> TypeToDeclMap;
 1631                        DenseMap<Value *, AllocaInst *> &AllocaMap,
 1666     DenseMap<Value *, AllocaInst *> &AllocaMap,
 1699   DenseMap<Value *, AllocaInst *> AllocaMap;

  196   DenseMap<Value *, LatticeVal> ValueState;  // The state each value is in.
  198   DenseMap<Value *, ValueLatticeElement> ParamState;
  202   DenseMap<std::pair<Value *, unsigned>, LatticeVal> StructValueState;
  208   DenseMap<GlobalVariable *, LatticeVal> TrackedGlobals;
  250   DenseMap<Function *, AnalysisResultsForFn> AnalysisResults;
  251   DenseMap<Value *, SmallPtrSet<User *, 2>> AdditionalUsers;
  369     DenseMap<Value *, LatticeVal>::const_iterator I = ValueState.find(V);
  382   const DenseMap<GlobalVariable*, LatticeVal> &getTrackedGlobals() {
  492     std::pair<DenseMap<Value*, LatticeVal>::iterator, bool> I =
  512     std::pair<DenseMap<Value*, ValueLatticeElement>::iterator, bool>
  529     std::pair<DenseMap<std::pair<Value*, unsigned>, LatticeVal>::iterator,
 1138   DenseMap<GlobalVariable*, LatticeVal>::iterator I = TrackedGlobals.find(GV);
 1177       DenseMap<GlobalVariable*, LatticeVal>::iterator It =
 2215   const DenseMap<GlobalVariable*, LatticeVal> &TG = Solver.getTrackedGlobals();
 2216   for (DenseMap<GlobalVariable*, LatticeVal>::const_iterator I = TG.begin(),

 1285   DenseMap<BasicBlock*, Value*> InjectedLoads;

  458   DenseMap<const SCEV *, SmallVector<Instruction *, 2>> DominatingExprs;

   84 using BBPhiMap = DenseMap<BasicBlock *, PhiMap>;
   85 using BBPredicates = DenseMap<BasicBlock *, Value *>;
   86 using PredMap = DenseMap<BasicBlock *, BBPredicates>;
   87 using BB2BBMap = DenseMap<BasicBlock *, BasicBlock *>;

  216   DenseMap<BasicBlock *, VisitType> Visited;

  178   using LocationBBMap = DenseMap<Location, BBSet>;
  179   using LocationDiscriminatorMap = DenseMap<Location, unsigned>;

   63 using DivCacheTy = DenseMap<DivRemMapKey, QuotRemPair>;
   64 using BypassWidthsTy = DenseMap<unsigned, unsigned>;

   44   DenseMap<const MDNode *, MDNode *> Cache;
  759   DenseMap<Loop *, Loop *> LMap;

 1017   DenseMap<Value *, Value *> Bitcasts;
 1342     DenseMap<BasicBlock *, BlockFrequency> &ExitWeights,
 1423   DenseMap<BasicBlock *, BlockFrequency> ExitWeights;

   69       DenseMap<BasicBlock*, Value*> Loads;

  216     DenseMap<Constant *, Constant *>::const_iterator I =

  224 using UnwindDestMemoTy = DenseMap<Instruction *, Value *>;
  847   DenseMap<const MDNode *, TrackingMDNodeRef> MDMap;
  945   DenseMap<const Argument *, MDNode *> NewScopes;
 1352                                DenseMap<const MDNode *, MDNode *> &IANodes) {
 1362                             DenseMap<const MDNode *, MDNode *> &IANodes) {
 1406   DenseMap<const MDNode *, MDNode *> IANodes;

  817 using IncomingValueMap = DenseMap<BasicBlock *, Value *>;
 2955 using AllocaForValueMapTy = DenseMap<Value *, AllocaInst *>;

  316     DenseMap<Value *, Value *> PrevItValueMap;

  593   DenseMap<BasicBlock *, BasicBlock *> ExitIDom;

  195   DenseMap<const RuntimePointerChecking::CheckingPtrGroup *,

  517     DenseMap<BasicBlock *, unsigned> Popularity;

  186   DenseMap<const Instruction *, unsigned> InstNumbers;
  202     DenseMap<const Instruction *, unsigned>::iterator It = InstNumbers.find(I);
  238   DenseMap<AllocaInst *, unsigned> AllocaLookup;
  246   DenseMap<std::pair<unsigned, unsigned>, PHINode *> NewPhiNodes;
  250   DenseMap<PHINode *, unsigned> PhiToAllocaMap;
  262   DenseMap<BasicBlock *, unsigned> BBNumbers;
  265   DenseMap<const BasicBlock *, unsigned> BBNumPreds;
  687     for (DenseMap<std::pair<unsigned, unsigned>, PHINode *>::iterator
  710   for (DenseMap<std::pair<unsigned, unsigned>, PHINode *>::iterator
  940       DenseMap<AllocaInst *, unsigned>::iterator AI = AllocaLookup.find(Src);
  963       DenseMap<AllocaInst *, unsigned>::iterator ai = AllocaLookup.find(Dest);

   40 using AvailableValsTy = DenseMap<BasicBlock *, Value *>;
  356   DenseMap<BasicBlock *, TinyPtrVector<Instruction *>> UsesByBlock;
  365   DenseMap<Value *, Value *> ReplacedLoads;
  475       DenseMap<Value*, Value*>::iterator RLI = ReplacedLoads.find(NewVal);

 1447     DenseMap<Instruction *, SmallVector<Value *, 4>> &PHIOperands) {
 1769   DenseMap<Instruction*, SmallVector<Value*,4>> PHIOperands;
 2235     DenseMap<Value *, Value *> TranslateMap; // Track translated values.
 2248         DenseMap<Value *, Value *>::iterator PI = TranslateMap.find(*i);
 4549   using ForwardingNodesMap = DenseMap<PHINode *, SmallVector<int, 4>>;

   56 using ComdatMembersType = DenseMap<const Comdat *, const GlobalValue *>;
   57 using ClusterIDMapType = DenseMap<const GlobalValue *, unsigned>;

  763   DenseMap<PHINode *, Value *> IVEndValues;
 1373   using ScalarCostsTy = DenseMap<Instruction *, unsigned>;
 1395   DenseMap<unsigned, ScalarCostsTy> InstsToScalarize;
 1399   DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> Uniforms;
 1403   DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> Scalars;
 1407   DenseMap<unsigned, SmallPtrSet<Instruction *, 4>> ForcedScalars;
 1437   using DecisionList = DenseMap<std::pair<Instruction *, unsigned>,
 3116   DenseMap<Value *, Value *> MissingVals;
 5323   using IntervalMap = DenseMap<Instruction *, unsigned>;
 5362   DenseMap<unsigned, InstrList> TransposeEnds;
 5544     Instruction *PredInst, DenseMap<Instruction *, unsigned> &ScalarCosts,
 6940     DenseMap<Instruction *, VPReplicateRecipe *> &PredInst2Recipe,
 7096   DenseMap<Instruction *, VPReplicateRecipe *> PredInst2Recipe;
 7098   DenseMap<Instruction *, Instruction *> &SinkAfter = Legal->getSinkAfter();
 7099   DenseMap<Instruction *, Instruction *> SinkAfterInverse;

 1502   DenseMap<AliasCacheKey, Optional<bool>> AliasCache;
 1517   DenseMap<Instruction *, bool> DeletedInstructions;
 1868     DenseMap<Value *, ScheduleData *> ScheduleDataMap;
 1871     DenseMap<Value *, SmallDenseMap<Value *, ScheduleData *>>
 1947   DenseMap<OrdersType, unsigned, OrdersTypeDenseMapInfo> NumOpsWantToKeepOrder;
 2273   DenseMap<Value *, unsigned> UniquePositions;
 3684     DenseMap<Value *, unsigned> UniquePositions;

   45       DenseMap<std::pair<BasicBlock *, BasicBlock *>, VPValue *>;
   46   using BlockMaskCacheTy = DenseMap<BasicBlock *, VPValue *>;
  121       DenseMap<Instruction *, VPReplicateRecipe *> &PredInst2Recipe,

  255     DenseMap<VPValue *, PerPartValuesTy> PerPartOutput;
 1554   DenseMap<VPInstruction *, InterleaveGroup<VPInstruction> *>
 1559   using Old2NewTy = DenseMap<InterleaveGroup<Instruction> *,
 1622   DenseMap<SmallVector<VPValue *, 4>, VPInstruction *, BundleDenseMapInfo>

   55   DenseMap<BasicBlock *, VPBasicBlock *> BB2VPBB;
   57   DenseMap<Value *, VPValue *> IRDef2VPValue;

  124 typedef DenseMap<Value *, VPValue *> Value2VPValueTy;
  125 typedef DenseMap<VPValue *, Value *> VPValue2ValueTy;

   50 using RelocMap = DenseMap<uint64_t, uint64_t>;

  195   using PathDataMap = DenseMap<Profile::PathID, Profile::Data>;
  198   using ThreadProfileIndexMap = DenseMap<Profile::ThreadID, PathDataMapPtr>;
  234   using PathDataMap = DenseMap<Profile::PathID, Profile::Data>;
  333   DenseMap<Profile::ThreadID, std::vector<StackEntry>> ThreadStacks;
  334   DenseMap<Profile::ThreadID, DenseMap<Profile::PathID, Profile::Data>>
  334   DenseMap<Profile::ThreadID, DenseMap<Profile::PathID, Profile::Data>>

   35   typedef llvm::DenseMap<const FileEntry *, Target> MappingsTy;
   38   llvm::DenseMap<const FileEntry *, const FileEntry *> ToFromMappings;

  247   mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
  249   mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>
  253   using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
  259   using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;
  263   llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;
  266   llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;
  270   llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;
  273   llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;
  278   llvm::DenseMap<const MaterializeTemporaryExpr *, APValue *>
  403   llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;
  408   llvm::DenseMap<Decl*, Decl*> MergedDecls;
  413   llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;
  425   llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;
  470   llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
  496   llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;
  498   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  501   llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;
  510   llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;
  515   llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
  517   llvm::DenseMap<const Decl *, std::unique_ptr<MangleNumberingContext>>
  527   using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
  749   mutable llvm::DenseMap<const Decl *, const RawComment *> DeclRawComments;
  756   mutable llvm::DenseMap<const Decl *, const Decl *> RedeclChainComments;
  765   mutable llvm::DenseMap<const Decl *, const Decl *> CommentlessRedeclChains;
  769   mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;

   89         llvm::DenseMap<const CXXBaseSpecifier *, CXXBaseSpecifier *>;
  248     llvm::DenseMap<const Type *, const Type *> ImportedTypes;
  252     llvm::DenseMap<Decl *, Decl *> ImportedDecls;
  260     llvm::DenseMap<Decl *, ImportError> ImportDeclErrors;
  264     llvm::DenseMap<Decl *, Decl *> ImportedFromDecls;
  268     llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
  272     llvm::DenseMap<FileID, FileID> ImportedFileIDs;

   55   using DCMap = llvm::DenseMap<DeclContext *, NameMap>;

   41   llvm::DenseMap<Decl *, ImportError> ImportErrors;

  236   mutable llvm::DenseMap<char, ComparisonCategoryInfo> Data;

 1015   void getCaptureFields(llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,

 1103       llvm::DenseMap<std::pair<IdentifierInfo *, unsigned/*isClassProperty*/>,

  302       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
  303       llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
  304       llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets);

   57   llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds;
   58   llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds;
   59   llvm::DenseMap<const NamedDecl*, uint64_t> AnonStructIds;
   78     llvm::DenseMap<const BlockDecl *, unsigned> &BlockIds
   80     std::pair<llvm::DenseMap<const BlockDecl *, unsigned>::iterator, bool>
   86     std::pair<llvm::DenseMap<const NamedDecl *, uint64_t>::iterator, bool>

   44   llvm::DenseMap<DeclarationName, unsigned> DeclNameMap;

  215   llvm::DenseMap<FileID, std::map<unsigned, RawComment *>> OrderedComments;
  216   mutable llvm::DenseMap<RawComment *, unsigned> CommentBeginLine;
  217   mutable llvm::DenseMap<RawComment *, unsigned> CommentEndOffset;

   59   using VBaseOffsetsMapTy = llvm::DenseMap<const CXXRecordDecl *, VBaseInfo>;
  128     using BaseOffsetsMapTy = llvm::DenseMap<const CXXRecordDecl *, CharUnits>;

   92   using AddressPointsMapTy = llvm::DenseMap<BaseSubobject, uint64_t>;
   95   llvm::DenseMap<BaseSubobject, uint64_t> SubVTTIndicies;
   99   llvm::DenseMap<BaseSubobject, uint64_t> SecondaryVirtualPointerIndices;
  151   const llvm::DenseMap<BaseSubobject, uint64_t> &getSubVTTIndicies() const {
  156   const llvm::DenseMap<BaseSubobject, uint64_t> &

  238   typedef llvm::DenseMap<BaseSubobject, AddressPointLocation>
  317   typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
  352   typedef llvm::DenseMap<GlobalDecl, int64_t> MethodVTableIndicesTy;
  355   typedef llvm::DenseMap<const CXXRecordDecl *,
  367   typedef llvm::DenseMap<ClassPairTy, CharUnits>
  467   llvm::DenseMap<const CXXRecordDecl *, unsigned> VBTableIndices;
  514   typedef llvm::DenseMap<GlobalDecl, MethodVFTableLocation>
  518   typedef llvm::DenseMap<const CXXRecordDecl *, std::unique_ptr<VPtrInfoVector>>
  523   typedef llvm::DenseMap<VFTableIdTy, std::unique_ptr<const VTableLayout>>
  527   llvm::DenseMap<const CXXRecordDecl *, std::unique_ptr<VirtualBaseInfo>>

   33   using ReachableMap = llvm::DenseMap<unsigned, ReachableSet>;

  143     using VarMapType = llvm::DenseMap<const VarDecl *, ConsumedState>;
  145         llvm::DenseMap<const CXXBindTemporaryExpr *, ConsumedState>;

  225   llvm::DenseMap<CFGBlock *, CFGBlockVector> ControlDepenencyMap;

   44   using ResultMap = llvm::DenseMap<const Expr *, const Stmt *>;
   70   llvm::DenseMap<const FunctionDecl *,
   90   llvm::DenseMap<const ParmVarDecl *, const Stmt *> Results;

   76   using BlockOrderTy = llvm::DenseMap<const CFGBlock *, unsigned>;

  426   using StatementMap = llvm::DenseMap<const Stmt *, til::SExpr *>;
  429   using LVarIndexMap = llvm::DenseMap<const ValueDecl *, unsigned>;

   89   llvm::DenseMap<const BlockDecl *,void *> *ReferencedBlockVars = nullptr;
  441       llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>;

   45   typedef llvm::DenseMap<const Decl *, Optional<Stmt *>> BodyMap;

 1236     using ForcedBlkExprs = llvm::DenseMap<const Stmt *, const CFGBlock *>;
 1352       llvm::DenseMap<const DeclStmt *, const DeclStmt *>::const_iterator;
 1447   llvm::DenseMap<const DeclStmt *, const DeclStmt *> SyntheticDeclStmts;

   45       llvm::DenseMap<const Decl *, std::unique_ptr<CallGraphNode>>;

  390   typedef llvm::DenseMap<ObjCSummaryKey, const RetainSummary *> MapTy;
  450   typedef llvm::DenseMap<const FunctionDecl*, const RetainSummary *>

   26 using ParsedSubjectMatchRuleSet = llvm::DenseMap<int, SourceRange>;

  258     llvm::DenseMap<unsigned, DiagnosticMapping> DiagMap;
  286     using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;
  288         llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;

  226   llvm::DenseMap<const DirectoryEntry *, llvm::StringRef> CanonicalDirNames;

   25 using FIDMap = llvm::DenseMap<FileID, unsigned>;

  610   llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*> FileInfos;
  628     llvm::DenseMap<const FileEntry *, const FileEntry *> OverriddenFiles;
  719   mutable llvm::DenseMap<FileID, std::pair<FileID, unsigned>> IncludedLocMap;
  727       llvm::DenseMap<IsBeforeInTUCacheKey, InBeforeInTUCacheEntry>;
  746   mutable llvm::DenseMap<FileID, std::unique_ptr<MacroArgsMap>>
 1663       llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::const_iterator;

  181       llvm::DenseMap<FileID, std::pair<FileID, ASTUnit *>>;
  197       llvm::DenseMap<TranslationUnitDecl *, std::unique_ptr<ASTImporter>>;

   23   typedef llvm::DenseMap<const JobAction*, const char*> ArgStringMap;

   65   llvm::DenseMap<unsigned, SmallVector<MacroArgUse, 2>> ExpansionToArgMap;

  175   using FileDeclsTy = llvm::DenseMap<FileID, LocDeclsTy *>;

  131   llvm::DenseMap<const IdentifierInfo *, Module *> KnownModules;

   52        llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
   53        llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
   54        llvm::DenseMap<const CXXRecordDecl *,

  288   using ParsedFilesMap = llvm::DenseMap<FileID, const FileEntry *>;
  289   using UnparsedFilesMap = llvm::DenseMap<FileID, UnparsedFileStatus>;

  235   llvm::DenseMap<const DirectoryEntry *, bool> DirectoryHasModuleMap;
  239   llvm::DenseMap<const FileEntry *, bool> LoadedModuleMaps;

  194       llvm::DenseMap<const FileEntry *, SmallVector<KnownHeader, 1>>;
  201   mutable llvm::DenseMap<off_t, llvm::TinyPtrVector<Module*>> LazyHeadersBySize;
  204   mutable llvm::DenseMap<time_t, llvm::TinyPtrVector<Module*>>
  213   llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
  222   llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;
  265   llvm::DenseMap<const DirectoryEntry *, InferredDirectory> InferredDirectories;
  269   llvm::DenseMap<const Module *, const FileEntry *> InferredModuleAllowedBy;
  271   llvm::DenseMap<const Module *, AdditionalModMapsSet> AdditionalModMaps;
  275   llvm::DenseMap<const FileEntry *, bool> ParsedModuleMap;

  355     llvm::DenseMap<const MacroInfo *, MacroDefinitionRecord *> MacroDefinitions;

  697   using MacroMap = llvm::DenseMap<const IdentifierInfo *, MacroState>;
  755   llvm::DenseMap<const IdentifierInfo *, llvm::TinyPtrVector<ModuleMacro *>>
  776   llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>
 1843   llvm::DenseMap<IdentifierInfo*,unsigned> PoisonReasons;

   21 using PreprocessorSkippedRangeMapping = llvm::DenseMap<unsigned, unsigned>;
   26     llvm::DenseMap<const llvm::MemoryBuffer *,

   51   llvm::DenseMap<const FunctionDecl*, VisitFlag> VisitedFD;

  646   llvm::DenseMap<const DeclContext *, StringRef> ParentNames;

  186                    llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
  187                  llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
  188                  llvm::DenseMap<const CXXRecordDecl *,

  643   llvm::DenseMap<VarDecl*, unsigned> CaptureMap;
  702     llvm::DenseMap<VarDecl*, unsigned>::const_iterator Known
  872   llvm::DenseMap<unsigned, SourceRange> ExplicitCaptureRanges;

  254   llvm::DenseMap<FileID, FileNullability> Map;
  870   llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
 1151   mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
 1167   typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
 1181   llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
 1202   typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
 2135   llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
 6312   llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
 7844   llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
 7912   typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
 8176   typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
 9180   llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;
 9182   llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap;
10740   llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
10761   llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
10772   llvm::DenseMap</* Caller = */ CanonicalDeclPtr<FunctionDecl>,
11445   std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>

  505       llvm::DenseMap<serialization::DeclID, FileOffsetsTy>;
  531   llvm::DenseMap<void *, PendingFakeDefinitionKind> PendingFakeDefinitionData;
  546   llvm::DenseMap<std::pair<DeclContext *, IdentifierInfo *>, NamedDecl *>
  551   llvm::DenseMap<Decl*, llvm::SmallVector<NamedDecl*, 2>>
  564   llvm::DenseMap<FileID, FileDeclsInfo> FileDeclIDs;
  571   llvm::DenseMap<const DeclContext*, std::pair<ModuleFile*, LexicalContents>>
  578   llvm::DenseMap<const DeclContext *,
  593   llvm::DenseMap<serialization::DeclID, DeclContextVisibleUpdates>
  678   using HiddenNamesMapType = llvm::DenseMap<Module *, HiddenNames>;
  725   llvm::DenseMap<Selector, unsigned> SelectorGeneration;
  729   llvm::DenseMap<Selector, bool> SelectorOutOfDate;
  882   llvm::DenseMap<const Type *, std::set<std::string>> OpenCLTypeExtMap;
  885   llvm::DenseMap<const Decl *, std::set<std::string>> OpenCLDeclExtMap;
  945   using SwitchCaseMapTy = llvm::DenseMap<unsigned, SwitchCase *>;
 1040   llvm::DenseMap<IdentifierInfo *, unsigned> IdentifierGeneration;
 1130       llvm::DenseMap<Decl *, SmallVector<serialization::DeclID, 2>>;
 1142   llvm::DenseMap<DeclContext *, DeclContext *> MergedDeclContexts;
 1146   llvm::DenseMap<EnumDecl *, EnumDecl *> EnumDefinitions;
 1202   llvm::DenseMap<const Decl *, bool> DefinitionSource;

  125   using TypeIdxMap = llvm::DenseMap<QualType, serialization::TypeIdx,
  171   llvm::DenseMap<const FileEntry *, uint32_t> InputFileIDs;
  212   llvm::DenseMap<const Decl *, serialization::DeclID> DeclIDs;
  228   using FileDeclIDsTy = llvm::DenseMap<FileID, DeclIDInFileInfo *>;
  278   llvm::DenseMap<MacroInfo *, serialization::MacroID> MacroIDs;
  289   llvm::DenseMap<const IdentifierInfo *, uint64_t> IdentMacroDirectivesOffsetMap;
  299   llvm::DenseMap<Stmt *, uint64_t> SubStmtEntries;
  330   llvm::DenseMap<const MacroDefinitionRecord *,
  335   llvm::DenseMap<const Decl *, unsigned> AnonymousDeclarationNumbers;
  382   using FirstLatestDeclMap = llvm::DenseMap<Decl *, Decl *>;
  426   llvm::DenseMap<const Decl *, const Decl *> FirstLocalDeclCache;
  429   llvm::DenseMap<SwitchCase *, unsigned> SwitchCaseIDs;
  447   llvm::DenseMap<Module *, unsigned> SubmoduleIDs;

  101   llvm::DenseMap<ModuleFile *, unsigned> ModulesByFile;

  427   llvm::DenseMap<ModuleFile *, serialization::DeclID> GlobalToLocalDeclIDs;

   63   llvm::DenseMap<const FileEntry *, ModuleFile *> Modules;
   79   llvm::DenseMap<const FileEntry *, std::unique_ptr<llvm::MemoryBuffer>>

   71     llvm::DenseMap<PathDiagnosticConsumer *, std::unique_ptr<PathDiagnostic>>;
  311   llvm::DenseMap<SymbolRef, bugreporter::TrackingKind> InterestingSymbols;
  318   llvm::DenseMap<const MemRegion *, bugreporter::TrackingKind>

  585   llvm::DenseMap<CheckerTag, CheckerRef> CheckerTags;
  598   using CachedDeclCheckersMapTy = llvm::DenseMap<unsigned, CachedDeclCheckers>;
  609   using CachedStmtCheckersMapTy = llvm::DenseMap<unsigned, CachedStmtCheckers>;
  661   using EventsTy = llvm::DenseMap<EventTag, EventInfo>;

  302     llvm::DenseMap<const ExplodedNode *, const ExplodedNode *>;
  427   using NodeMap = llvm::DenseMap<const ExplodedNode *, ExplodedNode *>;

   57   using MapTy = llvm::DenseMap<const Decl *, FunctionSummary>;

 1253   llvm::DenseMap<const StackFrameContext *, StackLocalsSpaceRegion *>
 1255   llvm::DenseMap<const StackFrameContext *, StackArgumentsSpaceRegion *>
 1257   llvm::DenseMap<const CodeTextRegion *, StaticGlobalSpaceRegion *>
 1448   llvm::DenseMap<const MemRegion *, StorageTypeForKinds> MRTraitsMap;
 1449   llvm::DenseMap<SymbolRef, StorageTypeForKinds> SymTraitsMap;
 1452       llvm::DenseMap<const MemRegion *, StorageTypeForKinds>::const_iterator;
 1454       llvm::DenseMap<SymbolRef, StorageTypeForKinds>::const_iterator;

  469   typedef llvm::DenseMap<void*,std::pair<void*,void (*)(void*)> > GDMContextsTy;

  353   mutable llvm::DenseMap<unsigned, ConditionTruthVal> Cached;

  462   using SymbolDependTy = llvm::DenseMap<SymbolRef, SymbolRefSmallVectorTy *>;
  555   using SymbolMapTy = llvm::DenseMap<SymbolRef, SymbolStatus>;
  567   llvm::DenseMap<const MemRegion *, unsigned> includedRegionCache;

  301   llvm::DenseMap<FileID, MarkedFile> Files;
  351   using PPExpansions = llvm::DenseMap</*SourceLocation*/ int, SourceLocation>;

   61   llvm::DenseMap<FileID, std::vector<syntax::Token>> ExtraTokens;

  234   llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator

 2245   typedef llvm::DenseMap<const FileEntry *, std::vector<EditEntry> >

  300   llvm::DenseMap<unsigned, IndivPropsTy> AtProps;
  315   for (llvm::DenseMap<unsigned, IndivPropsTy>::iterator

   70   llvm::DenseMap<IdentifierInfo *, PropActionKind> ActionOnProp;

   31   llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
   57     for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
  174       for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator

  536   llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
  859   for (llvm::DenseMap<const ObjCContainerDecl*,
  866   for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
  873   for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
  896   using ParentMapPointers = llvm::DenseMap<
  903   using ParentMapOtherNodes = llvm::DenseMap<
 1406   llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
 1423   llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
 1474   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
 1490   llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
 1526   llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
 2601   llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
 2611   llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator

 7874   llvm::DenseMap<const Type *, const Type *>::iterator Pos
 8130   llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
 8413   llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
 8762   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
 8794   llvm::DenseMap<const Type *, const Type *>::iterator Pos =

  583   llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCount;
  586   llvm::DenseMap<const CXXRecordDecl *, CXXFinalOverriderMap *> VirtualOverriders;
  723   for (llvm::DenseMap<const CXXRecordDecl *, CXXFinalOverriderMap *>::iterator

 1448        llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,

  546     llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
  799     llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase>

  108   llvm::DenseMap<Decl *, Decl *> ToOrigin;

   76     llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
   77     llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
   78     llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets) {

   29   llvm::DenseMap<unsigned, Function::ParamDescriptor> ParamDescriptors;

   72   llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
   88   llvm::DenseMap<LabelTy, unsigned> LabelOffsets;
   90   llvm::DenseMap<LabelTy, llvm::SmallVector<unsigned, 5>> LabelRelocs;

  218   llvm::DenseMap<const ValueDecl *, Scope::Local> Locals;
  221   llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;

   44   using CaseMap = llvm::DenseMap<const SwitchCase *, LabelTy>;

   79   llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
   94   llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Locals;

  115            llvm::DenseMap<unsigned, ParamDescriptor> &&Params);
  150   llvm::DenseMap<unsigned, ParamDescriptor> Params;

  147   llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Params;

  139   llvm::DenseMap<const FunctionDecl *, std::unique_ptr<Function>> Funcs;
  144   llvm::DenseMap<const FunctionDecl *, std::vector<unsigned>> Relocs;
  179   llvm::DenseMap<const void *, unsigned> GlobalIndices;
  182   llvm::DenseMap<const RecordDecl *, Record *> Records;
  185   llvm::DenseMap<const ParmVarDecl *, unsigned> DummyParams;

  106   llvm::DenseMap<const RecordDecl *, Base *> BaseMap;
  108   llvm::DenseMap<const FieldDecl *, Field *> FieldMap;
  110   llvm::DenseMap<const RecordDecl *, Base *> VirtualBaseMap;

  134   llvm::DenseMap<const IdentifierInfo *, unsigned> VarManglingNumbers;
  135   llvm::DenseMap<const IdentifierInfo *, unsigned> TagManglingNumbers;
  136   llvm::DenseMap<DecompositionDeclName, unsigned>

  122   llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
  123   llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
  379   llvm::DenseMap<uintptr_t, unsigned> Substitutions;
  380   llvm::DenseMap<StringRef, unsigned> ModuleSubstitutions;
 4704   llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr);

   30   llvm::DenseMap<const Type *, unsigned> ManglingNumbers;

  127   llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
  128   llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier;
  129   llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds;
  130   llvm::DenseMap<const NamedDecl *, unsigned> SEHFilterIds;
  131   llvm::DenseMap<const NamedDecl *, unsigned> SEHFinallyIds;
  238     std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
  268   typedef llvm::DenseMap<const void *, unsigned> ArgBackRefMap;
  272   typedef llvm::DenseMap<const void *, StringRef> TemplateArgStringMap;

   22 typedef llvm::DenseMap<Stmt*, Stmt*> MapTy;

   69   llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsets;
   72   llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsets;
   75   llvm::DenseMap<const CXXRecordDecl *, CharUnits> VirtualBaseOffsets;
  113   typedef llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;
  654   typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
  709   typedef llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *>
 2302   typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;

  103   typedef llvm::DenseMap<MethodBaseOffsetPairTy,
  113   typedef llvm::DenseMap<std::pair<const CXXRecordDecl *, unsigned>,
  116   typedef llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCountMapTy;
  534   typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
  777   typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
  782   typedef llvm::DenseMap<GlobalDecl, int64_t> MethodVTableIndicesTy;
  813   llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases;
  853   typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
  863   typedef llvm::DenseMap<uint64_t, ThunkInfo> VTableThunksMapTy;
  870   typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
 2369   typedef llvm::DenseMap<GlobalDecl, MethodVFTableLocation>
 2430   typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
 2436   typedef llvm::DenseMap<uint64_t, ThunkInfo> VTableThunksMapTy;
 2443   typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
 2864   typedef llvm::DenseMap<DeclarationName, unsigned> VisitedGroupIndicesTy;

  809   llvm::DenseMap<ast_type_traits::ASTNodeKind, std::vector<unsigned short>>
  816   llvm::DenseMap<const Type*, std::set<const TypedefNameDecl*> > TypeAliases;
  819   llvm::DenseMap<const ObjCInterfaceDecl *,

   53 using ManagedAnalysisMap = llvm::DenseMap<const void *, ManagedAnalysis *>;
  655     ReferencedBlockVars = new llvm::DenseMap<const BlockDecl*,void*>();

  495   using LabelMapTy = llvm::DenseMap<LabelDecl *, JumpTarget>;
  510   llvm::DenseMap<Expr *, const ConstructionContextLayer *>
  528   using CachedBoolEvalsTy = llvm::DenseMap<Expr *, TryResult>;
 5063   using StmtMapTy = llvm::DenseMap<const Stmt *, std::pair<unsigned, unsigned>>;
 5064   using DeclMapTy = llvm::DenseMap<const Decl *, std::pair<unsigned, unsigned>>;

   21 typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap;

  460   using MapType = llvm::DenseMap<const Stmt *, PropagationInfo>;

   80   llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksEndToLiveness;
   81   llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksBeginToLiveness;
   82   llvm::DenseMap<const Stmt *, LiveVariables::LivenessValues> stmtsToLiveness;
   83   llvm::DenseMap<const DeclRefExpr *, unsigned> inAssignment;
  624   for (llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator

  288       llvm::DenseMap<const ValueDecl *, std::unique_ptr<BeforeInfo>>;
  289   using CycleMap = llvm::DenseMap<const ValueDecl *, bool>;

   60   llvm::DenseMap<const VarDecl *, unsigned> map;
   89   llvm::DenseMap<const VarDecl *, unsigned>::const_iterator I = map.find(d);
  337   llvm::DenseMap<const DeclRefExpr *, Class> Classification;
  358     llvm::DenseMap<const DeclRefExpr*, Class>::const_iterator I

  548   llvm::DenseMap<const DirectoryEntry *, llvm::StringRef>::iterator Known

  365   for (llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::iterator
  437     llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator

 1371   StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>>

  691   llvm::DenseMap<unsigned, llvm::BasicBlock *> BB;

  242   llvm::DenseMap<const VarDecl*, Capture> Captures;
  274     llvm::DenseMap<const VarDecl*, Capture>::iterator

 1407   static llvm::DenseMap<QualType, const char *> Types;

 4644     llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> &SPDefCache,
 4645     llvm::DenseMap<const ParmVarDecl *, llvm::TrackingMDRef> &ParamCache) {

   84   llvm::DenseMap<const void *, llvm::TrackingMDRef> TypeCache;
  105   llvm::DenseMap<const ObjCInterfaceDecl *, std::vector<llvm::DISubprogram *>>
  109   llvm::DenseMap<const Module *, llvm::TrackingMDRef> ModuleCache;
  124   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> RegionMap;
  135   llvm::DenseMap<const char *, llvm::TrackingMDRef> DIFileCache;
  136   llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPCache;
  139   llvm::DenseMap<const FunctionDecl *, llvm::TrackingMDRef> SPDefCache;
  140   llvm::DenseMap<const ParmVarDecl *, llvm::TrackingMDRef> ParamCache;
  143   llvm::DenseMap<const Decl *, llvm::TrackingMDRef> DeclCache;
  144   llvm::DenseMap<const NamespaceDecl *, llvm::TrackingMDRef> NamespaceCache;
  145   llvm::DenseMap<const NamespaceAliasDecl *, llvm::TrackingMDRef>
  147   llvm::DenseMap<const Decl *, llvm::TypedTrackingMDRef<llvm::DIDerivedType>>

 4460   llvm::DenseMap<const OpaqueValueExpr*,LValue>::iterator
 4474   llvm::DenseMap<const OpaqueValueExpr*,RValue>::iterator

 1448     llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses;
 1451     llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations;

  374   typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >

  864   llvm::DenseMap<Selector, llvm::GlobalVariable*> MethodVarNames;
  875   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
  878   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> PropertyNames;
  881   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> ClassReferences;
  884   llvm::DenseMap<Selector, llvm::GlobalVariable*> SelectorReferences;
  889   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> Protocols;
 1402   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> SuperClassReferences;
 1405   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> MetaClassReferences;
 1408   llvm::DenseMap<IdentifierInfo*, llvm::GlobalVariable*> EHTypeReferences;
 5149   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator

   49   llvm::DenseMap<const Expr *, EnqueuedBlockInfo> EnqueuedBlockMap;

  397   llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
 4671   llvm::DenseMap<const VarDecl *, unsigned> PrivateVarsPos;
 7161   llvm::DenseMap<CanonicalDeclPtr<const VarDecl>, bool> FirstPrivateDecls;
 7165   llvm::DenseMap<
 8177     llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
 8225       const llvm::DenseMap<llvm::Value *, llvm::Value *> &LambdaPointers,
 9324     llvm::DenseMap<llvm::Value *, llvm::Value *> LambdaPointers;
10674   llvm::DenseMap<const Decl *, unsigned> ParamPositions;

  325   using OpenMPDefaultLocMapTy = llvm::DenseMap<FlagsTy, llvm::Value *>;
  332   typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
  346   typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
  350   typedef llvm::DenseMap<const OMPDeclareReductionDecl *,
  355   typedef llvm::DenseMap<llvm::Function *,
  361   llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
  364       llvm::DenseMap<llvm::Function *,
  629     typedef llvm::DenseMap<unsigned, OffloadEntryInfoTargetRegion>
  633     typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
  635     typedef llvm::DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
 1531     llvm::DenseMap<const ValueDecl *, Address> CaptureDeviceAddrMap;

 4869     llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;

  429   llvm::DenseMap<llvm::Function *, llvm::Function *> WrapperFunctionsMap;

  125   llvm::DenseMap<const FieldDecl *, unsigned> FieldInfo;
  129   llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields;
  133   llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases;
  136   llvm::DenseMap<const CXXRecordDecl *, unsigned> CompleteObjectVirtualBases;
  206     llvm::DenseMap<const FieldDecl *, CGBitFieldInfo>::const_iterator

  203   llvm::DenseMap<const FieldDecl *, unsigned> Fields;
  204   llvm::DenseMap<const FieldDecl *, CGBitFieldInfo> BitFields;
  205   llvm::DenseMap<const CXXRecordDecl *, unsigned> NonVirtualBases;
  206   llvm::DenseMap<const CXXRecordDecl *, unsigned> VirtualBases;
  871   for (llvm::DenseMap<const FieldDecl*, CGBitFieldInfo>::const_iterator

  387     llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>>
  568   llvm::DenseMap<const Decl *, std::pair<const Expr *, llvm::Value *>> VLASizes;
 1048   llvm::DenseMap<const VarDecl *, const Expr *> LoopCountersAndUpdates;
 2938   llvm::DenseMap<const VarDecl *, const DeclRefExpr *> LastprivateDstsOrigs;
 4635     const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap) {

  139   for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =
  166   for (llvm::DenseMap<BaseSubobject, uint64_t>::const_iterator I =

   41   typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t> SubVTTIndiciesMapTy;
   46   typedef llvm::DenseMap<BaseSubobjectPairTy, uint64_t>

  490   llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
  495   llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
  820   typedef llvm::DenseMap<const Decl *, Address> DeclMapTy;
 1229   llvm::DenseMap<const ParmVarDecl *, EHScopeStack::stable_iterator>
 1240   llvm::DenseMap<llvm::AllocaInst *, int> EscapedLocals;
 1243   llvm::DenseMap<const LabelDecl*, JumpDest> LabelMap;
 1381   llvm::DenseMap<const OpaqueValueExpr *, LValue> OpaqueLValues;
 1382   llvm::DenseMap<const OpaqueValueExpr *, RValue> OpaqueRValues;
 1390   llvm::DenseMap<const Expr*, llvm::Value*> VLASizeMap;
 1570   llvm::DenseMap<const ValueDecl *, BlockByrefInfo> BlockByrefInfos;
 3031       const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap);

  367   llvm::DenseMap<const VarDecl*, llvm::GlobalVariable*> InitializerConstants;
  413   llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *> ConstantStringMap;
  414   llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap;
  415   llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap;
  416   llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap;
  418   llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap;
  419   llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap;
  422   llvm::DenseMap<QualType, llvm::Constant *> TypeDescriptorMap;
  446   llvm::DenseMap<const Decl*, unsigned> DelayedCXXInitPosition;
  503   llvm::DenseMap<const CompoundLiteralExpr *, llvm::GlobalVariable *>
  508   llvm::DenseMap<const BlockExpr *, llvm::Constant *> EmittedGlobalBlocks;
  545   typedef llvm::DenseMap<QualType, llvm::Metadata *> MetadataTypeMap;

  158   llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
  161                     llvm::DenseMap<const Stmt *, unsigned> &CounterMap)
  355   llvm::DenseMap<const Stmt *, uint64_t> &CountMap;
  365   ComputeRegionCounts(llvm::DenseMap<const Stmt *, uint64_t> &CountMap,
  803   RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
  870   StmtCountMap.reset(new llvm::DenseMap<const Stmt *, uint64_t>);

   36   std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap;
   37   std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap;

  129   llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache;
  131   llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache;
  133   llvm::DenseMap<TBAAAccessInfo, llvm::MDNode *> AccessTagMetadataCache;
  137   llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache;

  102   llvm::DenseMap<const Type*, llvm::StructType *>::const_iterator I =
  391   llvm::DenseMap<const Type *, llvm::Type *>::iterator TCI = TypeCache.find(Ty);

   75   llvm::DenseMap<const ObjCInterfaceType*, llvm::Type *> InterfaceTypes;
   78   llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts;
   81   llvm::DenseMap<const Type*, llvm::StructType *> RecordDeclTypes;
  102   llvm::DenseMap<const Type *, llvm::Type *> TypeCache;

  436   llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
  839       llvm::DenseMap<const Stmt *, unsigned> &CounterMap, SourceManager &SM,

   88   llvm::DenseMap<const Stmt *, unsigned> *CounterMap;
   97                      llvm::DenseMap<const Stmt *, unsigned> *CounterMap)

   44   llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> VTables;

  764   typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy;
  765   typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy;
  775   llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap;
  787   llvm::DenseMap<const DeclContext *, GuardInfo> GuardVariableMap;
  788   llvm::DenseMap<const DeclContext *, GuardInfo> ThreadLocalGuardVariableMap;
  789   llvm::DenseMap<const DeclContext *, unsigned> ThreadSafeGuardNumMap;
  791   llvm::DenseMap<size_t, llvm::StructType *> TypeDescriptorTypeMap;
  796   llvm::DenseMap<QualType, llvm::GlobalVariable *> CatchableTypeArrays;
  799   llvm::DenseMap<uint32_t, llvm::StructType *> CatchableTypeArrayTypeMap;
 1942   llvm::DenseMap<const CXXRecordDecl*, VBTableGlobals>::iterator Entry;

   46   llvm::DenseMap<const Stmt *, unsigned> ToScopes;

  382   llvm::DenseMap<CanQualType, unsigned> CompletionTypes;

 1641   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known

   33   typedef llvm::DenseMap<const FileEntry *,

  157   llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
  158   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
  159   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets)

  143     llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;
  147     llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
  148     llvm::DenseMap<ObjCInterfaceDecl *,
  153     llvm::DenseMap<const ObjCIvarDecl* , unsigned> IvarGroupNumber;
  156     llvm::DenseMap<std::pair<const ObjCInterfaceDecl*, unsigned>, QualType> GroupRecordType;
  162     llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
  187     llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;

  114     llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
  134     llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;
  138     llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
  143     llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;

   34   llvm::DenseMap<unsigned, unsigned> Abbrevs;
   88 typedef llvm::DenseMap<unsigned, unsigned> AbbrevLookup;
  273     llvm::DenseMap<const char *, unsigned> Files;
  275     typedef llvm::DenseMap<const void *, std::pair<unsigned, StringRef> >

   65   llvm::DenseMap<const Type *, unsigned> TypeSubstitutions;
  769     llvm::DenseMap<const Type *, unsigned>::iterator Substitution

  713     llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir
  950         llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
 2969   llvm::DenseMap<const FileEntry *, bool>::iterator Known

  196   llvm::DenseMap<ModuleMacro *, int> NumHiddenOverrides;

  632   llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =

  384   llvm::DenseMap<const MacroInfo *, MacroDefinitionRecord *>::iterator Pos =

  751   llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =

   65   llvm::DenseMap<Stmt*, unsigned> LabelAndGotoScopes;
  685     llvm::DenseMap<unsigned, Stmt*> JumpScopesMap;
  697     for (llvm::DenseMap<unsigned, Stmt *>::iterator I = JumpScopesMap.begin(),
  706   llvm::DenseMap<unsigned, LabelDecl*> TargetScopes;
  727   for (llvm::DenseMap<unsigned,LabelDecl*>::iterator

  183                       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
  184                   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
  185           llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){

  771 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;

14463     const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData>
14494   llvm::DenseMap<Sema::TypeTagMagicValue,
14510         new llvm::DenseMap<TypeTagMagicValue, TypeTagData>);

  136   typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
  168   llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry>
 7419 typedef llvm::DenseMap<Selector,

 7023     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
 8928     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
13729   llvm::DenseMap<const BlockDecl *, bool> EscapeInfo;

 4753   llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
 4755   llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;
 5263 typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
 5321   llvm::DenseMap<const void *, CXXCtorInitializer *> Members;
 6569   llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>
12740   typedef llvm::DenseMap<CXXRecordDecl*, CXXBaseSpecifier*> VBaseMap;
15572     llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
15608   std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>

 1749   llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
 3907   llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
 3908   llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;

  814                    llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
  844   llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;

 3615   typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;

   77       llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>;
   99       llvm::DenseMap<const ValueDecl *, MappedExprComponentTy>;
 3610         llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
 4137   llvm::DenseMap<CanonicalDeclPtr<Decl>, CanonicalDeclPtr<VarDecl>>
 4748   llvm::DenseMap<const Decl *, const Expr *> UniformedArgs;
 4775   llvm::DenseMap<const Decl *, const Expr *> AlignedArgs;
 4842   llvm::DenseMap<const Decl *, const Expr *> LinearArgs;
15591   llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
15603     llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious;
15843   llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes;
15855     llvm::DenseMap<OMPDeclareMapperDecl *, bool> UsedAsPrevious;

 4022   const llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> &TypesToCheck;
 4031       const llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> &T, bool C)
 4085   llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> HandledTypes;

  187     llvm::DenseMap<const MacroQualifiedType *, SourceLocation> LocsForMacros;

  119   llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
  428     llvm::DenseMap<Decl *, Decl *>::iterator Known

  452 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
 7892   llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
 8013   llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
 9798     llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
 9861         llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;

 4108     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;

 2442   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;

 2431     llvm::DenseMap<int, int> FilenameMap;
 2578     llvm::DenseMap<ModuleMacro*, unsigned> Visits;
 2820   llvm::DenseMap<Module *, unsigned>::iterator Known = SubmoduleIDs.find(Mod);
 4337   const llvm::DenseMap<const Type *, std::set<std::string>> &OpenCLTypeExtMap =
 4370   const llvm::DenseMap<const Decl *, std::set<std::string>> &OpenCLDeclExtMap =

 2404   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);

  296   llvm::DenseMap<ModuleFile *, unsigned>::iterator Known

   75     llvm::DenseMap<internal_key_type, data_type> Data;

   91   typedef llvm::DenseMap<Selector,ObjCMethodDecl*> MapTy;

  484     llvm::DenseMap<const VarDecl *, FieldDecl *> CaptureFields;

   54   typedef llvm::DenseMap<const ObjCIvarDecl*,

   33   mutable llvm::DenseMap<const CallExpr *, ReachedStat> ReachedStats;

   57   typedef llvm::DenseMap<const ObjCMethodDecl*,
   59   typedef llvm::DenseMap<const ObjCPropertyDecl*,
   61   typedef llvm::DenseMap<const ObjCIvarDecl*,
   94   typedef llvm::DenseMap<const ObjCIvarDecl*, InvalidationInfo> IvarSet;

   66   mutable llvm::DenseMap<const IdentifierInfo *,
   67                          llvm::DenseMap<Selector, uint8_t>> UIMethods;

   30 typedef llvm::DenseMap<const ObjCIvarDecl*,IVarState> IvarUsageMap;

  101     llvm::DenseMap<const ExplodedNode *, std::vector<PathDiagnosticPieceRef>>;
  106     llvm::DenseMap<const PathPieces *, const LocationContext *>;
 2177     llvm::DenseMap<T, bugreporter::TrackingKind> &InterestingnessMap, T Val,
 2435   using PriorityMapTy = llvm::DenseMap<const ExplodedNode *, unsigned>;
 2941     llvm::DenseMap<const ExplodedNode *, unsigned> Visited;

 1272             llvm::DenseMap<PrivateMethodKey, Optional<const ObjCMethodDecl *>>;

 2442       llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;

  359   typedef llvm::DenseMap<const LazyCompoundValData *,
  708   typedef llvm::DenseMap<const MemRegion *, const ClusterBindings *> ClusterMap;

 1242     llvm::DenseMap<SymbolRef, SVal> Cached;

  200   using VisitedTimesMap = llvm::DenseMap<LocIdentifier, int>;
  262   using VisitedTimesMap = llvm::DenseMap<LocIdentifier, int>;

  377   DenseMap<size_t, int> scoreCandidates(StringRef Filename) const {
  393     DenseMap<size_t, int> Candidates; // Index -> score.
  414   std::pair<size_t, int> pickWinner(const DenseMap<size_t, int> &Candidates,

  546   llvm::DenseMap<FileID, unsigned> NextSpelled;

  182   llvm::DenseMap<const RefactoringOption *,

   44 typedef llvm::DenseMap<const clang::FileEntry *,

  139 static llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
  143   llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
  148   llvm::DenseMap<const FileEntry *, std::set<tooling::Replacement>>

  165     llvm::DenseMap<unsigned, unsigned> Abbrevs;

   50   llvm::DenseMap<llvm::StringRef, double> Score;

   71   typedef llvm::DenseMap<const Decl *, std::unique_ptr<CallGraphNode>>

  230   llvm::DenseMap<unsigned, std::string>::const_iterator I =

  199   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;

   49   llvm::DenseMap<const CXXMethodDecl *, bool> PossibleMap;
   54   llvm::DenseMap<std::pair<const CXXMethodDecl *, const CXXRecordDecl *>, bool>

   46       llvm::DenseMap<ClassDefId,

   29   llvm::DenseMap<const NamedDecl *, CharSourceRange> FoundDecls;

   32 typedef llvm::DenseMap<const clang::Stmt *, const clang::Stmt *> StmtParentMap;
   36 typedef llvm::DenseMap<const clang::VarDecl *, const clang::DeclStmt *>
   41 typedef llvm::DenseMap<const clang::ForStmt *, const clang::VarDecl *>
   45 typedef llvm::DenseMap<const clang::Stmt *, std::string>

   39   llvm::DenseMap<const FunctionDecl *, FunctionParmMutationAnalyzer>

   90   typedef llvm::DenseMap<NamingCheckId, NamingCheckFailure>

   98   llvm::DenseMap<const Stmt *, const Stmt *> SyntheticStmtSourceMap;
  117   llvm::DenseMap<const Stmt *, const CFGBlock *> Map;

   74   llvm::DenseMap<FileID, std::unique_ptr<IncludeSorter>> IncludeSorterByFile;
   75   llvm::DenseMap<FileID, std::set<std::string>> InsertedHeaders;

   43   llvm::DenseMap<const FunctionDecl *, llvm::StringMap<std::string>>

  852     llvm::DenseMap<SymbolID, std::string> FetchedDocs;
 1523     llvm::DenseMap<size_t, size_t> BundleLookup;

   61   llvm::DenseMap<llvm::hash_code, llvm::SmallVector<llvm::hash_code, 4>>

   86   llvm::DenseMap<llvm::hash_code, unsigned> Cache;
  109   llvm::DenseMap<llvm::hash_code, unsigned> Cache;

  135   llvm::DenseMap<unsigned, SmallVector<unsigned, 8>> IncludeChildren;

   88   mutable llvm::DenseMap<SymbolID, SymbolSlab> LookupCache;

  469   llvm::DenseMap<FileID, SourceLocation> BeginExpansions;

  286   llvm::DenseMap<SymbolID, size_t> ResultIndex;

  245   llvm::DenseMap<SymbolID, File *> SymbolIDToFile;
  267   llvm::DenseMap<const Ref *, SymbolID> RefToIDs;

  140     llvm::DenseMap<SymbolID, Symbol> Merged;
  179   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> AllRefs;
  181     llvm::DenseMap<SymbolID, llvm::SmallVector<Ref, 4>> MergedRefs;

   69   llvm::DenseMap<SymbolID, const Symbol *> Index;
   71   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
   75   llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;

  104     llvm::DenseMap<SymbolID, std::set<Ref>> Refs;

  153   llvm::DenseMap<std::pair<const char *, size_t>, unsigned> Index;

  224     llvm::DenseMap<SymbolID, Symbol> Symbols;

  504   llvm::DenseMap<FileID, std::string> URICache;

  138   llvm::DenseMap<SymbolID, FileID> IncludeFiles;
  158   llvm::DenseMap<const NamedDecl *, std::vector<DeclRef>> DeclRefs;
  164   llvm::DenseMap<const Decl *, const Decl *> CanonicalDecls;
  166   llvm::DenseMap<FileID, bool> FilesToIndexCache;
  167   llvm::DenseMap<FileID, bool> HeaderIsSelfContainedCache;

   90   llvm::DenseMap<Token, std::vector<DocID>> TempInvertedIndex;

  101   llvm::DenseMap<SymbolID, const Symbol *> LookupTable;
  108   llvm::DenseMap<Token, PostingList> InvertedIndex;
  110   llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
  113   llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;

  372   llvm::DenseMap<const Decl *, DeclInformation> DeclInfoMap;

  671   llvm::DenseMap<SymbolID, std::vector<Ref>> Refs;

  130   llvm::DenseMap<int, std::vector<HighlightingToken>> ExpectedLines;

  487   DenseMap<const FileEntry *, HeaderContents> HeaderContentMismatches;
  507     for (DenseMap<const FileEntry *, HeaderContents>::iterator
  515       DenseMap<const FileEntry *, HeaderContents>::iterator KnownH =
  538   DenseMap<const FileEntry *, HeaderContents> CurHeaderContents;
  539   DenseMap<const FileEntry *, HeaderContents> AllHeaderContents;
  973   for (DenseMap<const FileEntry *, HeaderContents>::iterator

 1368 typedef llvm::DenseMap<CXCursor, unsigned> CXCursorSet_Impl;

  282   typedef llvm::DenseMap<const FileEntry *, CXIdxClientFile> FileMapTy;
  283   typedef llvm::DenseMap<const DeclContext *, CXIdxClientContainer>
  285   typedef llvm::DenseMap<const Decl *, CXIdxClientEntity> EntityMapTy;

   32 typedef llvm::DenseMap<unsigned, const char *> Strings;
   47   llvm::DenseMap<unsigned, const FileEntry *> Files;

  196     llvm::DenseMap<ImporterKey, std::unique_ptr<ASTImporter>> Importers;

 1796   llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;

  272   typedef llvm::DenseMap<const Record*,

  525   DenseMap<Record *, ClassKind> ClassMap;

  116     DenseMap<KeyTy, ObjectEntry> MemberCache;

  204   DenseMap<uint64_t, DebugMapEntry *> AddressToMapping;

 2022   DenseMap<uint64_t, StringRef> LocalCIES;

  212   DenseMap<unsigned, size_t> UniqueIdToCuMap;

  121 static DenseMap<int, void *> FDToLeaderHandle;
  992   DenseMap<void *, std::unique_ptr<PluginInputFile>> HandleToInputFile;

  649   DenseMap<StringRef, Export *> map(config->exports.size());

  348     COFFSymbolRef sym, DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
  366     const DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
  410   DenseMap<StringRef, uint32_t> prevailingSectionMap;

  240       llvm::DenseMap<StringRef, uint32_t> &prevailingSectionMap);
  244       const llvm::DenseMap<StringRef, uint32_t> &prevailingSectionMap);

   36     DenseMap<const SectionChunk *, SmallVector<DefinedRegular *, 4>>;
   75 static DenseMap<DefinedRegular *, std::string>
   84   DenseMap<DefinedRegular *, std::string> ret;
  102   DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(syms);

 1725     DenseMap<uint32_t, uint32_t> secrels;

  312                      const DenseMap<Symbol *, Symbol *> *localImports,
  331   DenseMap<Symbol *, int> firstDiag;
  396   DenseMap<Symbol *, Symbol *> localImports;

  130   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> symMap;

  368 getThunk(DenseMap<uint64_t, Defined *> &lastThunks, Defined *target, uint64_t p,
  402   DenseMap<uint64_t, Defined *> lastThunks;
  403   DenseMap<std::pair<ObjFile *, Defined *>, uint32_t> thunkSymtabIndices;

   43   llvm::DenseMap<InputSection *, std::vector<const Defined *>> sectionMap;

   82   DenseMap<const InputSectionBase *, int> run();
  105   DenseMap<const InputSectionBase *, int> secToCluster;
  182 DenseMap<const InputSectionBase *, int> CallGraphSort::run() {
  225   DenseMap<const InputSectionBase *, int> orderMap;
  268 DenseMap<const InputSectionBase *, int> computeCallGraphProfileOrder() {

   18 llvm::DenseMap<const InputSectionBase *, int> computeCallGraphProfileOrder();

  711   DenseMap<StringRef, Symbol *> map;
 1641   DenseMap<Symbol *, Symbol *> map;

 1219   DenseMap<StringRef, SharedFile *>::iterator it;

  212     DenseMap<const Defined *, std::pair<SectionBase *, uint64_t>>;

  227   llvm::DenseMap<StringRef, OutputSection *> nameToOutputSection;
  310   llvm::DenseMap<StringRef, std::vector<BaseCommand *>> insertAfterCommands;
  311   llvm::DenseMap<StringRef, std::vector<BaseCommand *>> insertBeforeCommands;

   39 using SymbolMapTy = DenseMap<const SectionBase *, SmallVector<Defined *, 4>>;
   84 static DenseMap<Symbol *, std::string>
   96   DenseMap<Symbol *, std::string> ret;
  156   DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);

   72   DenseMap<StringRef, std::vector<InputSectionBase *>> cNamedSections;

  704   DenseMap<StringRef, const Symbol *> map;
  828   DenseMap<Symbol *, UndefinedDiag *> firstRef;

  154   llvm::DenseMap<std::pair<SectionBase *, uint64_t>, std::vector<Thunk *>>
  156   llvm::DenseMap<Symbol *, std::vector<Thunk *>> thunkedSymbols;
  160   llvm::DenseMap<Symbol *, Thunk *> thunks;
  166   llvm::DenseMap<InputSection *, ThunkSection *> thunkedSections;

   55   llvm::DenseMap<StringRef, SharedFile *> soNames;
   60   llvm::DenseMap<llvm::CachedHashStringRef, const InputFile *> comdatGroups;
   78   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;

 2649   std::vector<DenseMap<CachedHashStringRef, size_t>> map(numShards);

   95   llvm::DenseMap<size_t, CieRecord *> offsetToCie;
  115   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, Symbol *>, CieRecord *> cieMap;
  416   llvm::DenseMap<StringRef, unsigned> stringMap;
  598   llvm::DenseMap<Symbol *, size_t> symbolIndexMap;
  599   llvm::DenseMap<OutputSection *, size_t> sectionIndexMap;

 1199 static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
 1200   DenseMap<const InputSectionBase *, int> sectionOrder;
 1216   DenseMap<StringRef, SymbolOrderEntry> symbolOrder;
 1262                       const DenseMap<const InputSectionBase *, int> &order) {
 1325                         const DenseMap<const InputSectionBase *, int> &order) {
 1377   DenseMap<const InputSectionBase *, int> order = buildSectionOrder();

   42   llvm::DenseMap<StringRef, VarLoc> variableLoc;

   61   typedef llvm::DenseMap<const Atom *, const Atom *> AtomToAtom;
   73   typedef llvm::DenseMap<StringRef, const Atom *,

  264   typedef llvm::DenseMap<const normalized::Section *,

  174   llvm::DenseMap<const Atom*, const GOTEntryAtom*> _targetToGOT;

   53 typedef llvm::DenseMap<const DefinedAtom *, const DefinedAtom *> AtomToAtomT;

   83   typedef llvm::DenseMap<const DefinedAtom *, const DefinedAtom *> AtomToAtomT;
   84   typedef llvm::DenseMap<const DefinedAtom *, uint64_t> AtomToOrdinalT;

  150   typedef llvm::DenseMap<const Atom*, uint64_t> AtomToAddress;
  177   typedef llvm::DenseMap<const Atom*, uint32_t> AtomToIndex;

 1009 typedef llvm::DenseMap<const MachODefinedAtom*, CIEInfo> CIEInfoMap;

  118   llvm::DenseMap<const Atom*, const DefinedAtom*> _targetToShim;

  362   typedef llvm::DenseMap<const Atom*,

  131   llvm::DenseMap<const Atom*, const TLVPEntryAtom*> _targetToTLVP;

  162   typedef llvm::DenseMap<const lld::Atom *, std::string> AtomToRefName;

  626   DenseMap<Symbol *, Symbol *> map;

  127   llvm::DenseMap<uint32_t, InputSection *> customSectionsByIndex;

  103   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
  108   llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> symVariants;

   96   llvm::DenseMap<WasmSignature, int32_t> typeIndices;

   24   typedef llvm::DenseMap<_KeyType, _ValueType> LLVMMapType;

  249   typedef llvm::DenseMap<const char *, lldb::addr_t> SymbolMap;

  101   llvm::DenseMap<IOObject::WaitableHandle, Callback> m_read_fds;
  102   llvm::DenseMap<int, SignalInfo> m_signals;

  444       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
  445       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  447       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

   92     llvm::DenseMap<const clang::FieldDecl *, uint64_t> field_offsets;
   93     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
   94     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  126       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
  127       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  129       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  391   typedef llvm::DenseMap<const clang::RecordDecl *, LayoutInfo>

   35       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
   36       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
   38       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
   98       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
   99       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  101       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

  136   typedef llvm::DenseMap<const void *, ClangASTMetadata> MetadataMap;

  393   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions_by_uid;

   65   typedef llvm::DenseMap<const Section *, lldb::addr_t> sect_to_addr_collection;

  284   llvm::DenseMap<const void *, std::unique_ptr<ProviderBase>> m_providers;

  230   llvm::DenseMap<unsigned, void *> m_mapping;
  542   llvm::DenseMap<const void *, unsigned> m_mapping;

   67   llvm::DenseMap<lldb::socket_t, FDInfo> m_fd_map;

   43   using Map = llvm::DenseMap<id_t, llvm::Optional<std::string>>;

  122       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
  123       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  125       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  415       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
  416       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  418       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

 1654 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap;
 1655 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
 1658 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
 1659                             llvm::DenseMap<const D *, O> &source_map,
 1666   typedef llvm::DenseMap<const D *, O> MapType;

  136       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
  137       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  139       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  239         llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
  240         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  242         llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

   83   typedef llvm::DenseMap<const char *, clang::NamedDecl *> PersistentDeclMap;

  134       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
  135       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  137       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

   46   typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA,

 2481   typedef llvm::DenseMap<uint32_t, uint32_t> NListIndexToSymbolIndexMap;
 2482   typedef llvm::DenseMap<const char *, uint32_t> ConstNameToSymbolIndexMap;
 3665     typedef llvm::DenseMap<ConstString, uint16_t> UndefinedNameToDescMap;
 3666     typedef llvm::DenseMap<uint32_t, ConstString> SymbolIndexToName;

  238   llvm::DenseMap<lldb::tid_t, ProcessorTraceMonitorUP>

  448   llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>

  149   llvm::DenseMap<size_t, size_t> m_map;
  324   llvm::DenseMap<addr_t, Symbol> symbols;

 2117               llvm::DenseMap<const clang::FieldDecl *, uint64_t>::const_iterator
 2132               llvm::DenseMap<const clang::CXXRecordDecl *,
 2146               llvm::DenseMap<const clang::CXXRecordDecl *,

   77   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
   81   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
   83   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;

  307   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
  309   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
  311   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
  314   typedef llvm::DenseMap<lldb::opaque_compiler_type_t, lldb::user_id_t>
  493   llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList>

   99   typedef llvm::DenseMap<const char *, UniqueDWARFASTTypeList> collection;

   78   llvm::DenseMap<uint16_t, std::unique_ptr<CompilandIndexItem>> m_comp_units;

  274   llvm::DenseMap<TypeIndex, TypeIndex> forward_to_full;
  275   llvm::DenseMap<TypeIndex, TypeIndex> full_to_forward;
  312                        llvm::DenseMap<TypeIndex, TypeIndex> &parents)
  317       llvm::DenseMap<TypeIndex, TypeIndex> &parents;

  136   llvm::DenseMap<TypeIndex, TypeIndex> m_parent_types;
  137   llvm::DenseMap<clang::Decl *, DeclStatus> m_decl_to_status;
  138   llvm::DenseMap<lldb::user_id_t, clang::Decl *> m_uid_to_decl;
  139   llvm::DenseMap<lldb::user_id_t, clang::QualType> m_uid_to_type;

  226   llvm::DenseMap<lldb::user_id_t, lldb::VariableSP> m_global_vars;
  227   llvm::DenseMap<lldb::user_id_t, lldb::VariableSP> m_local_variables;
  228   llvm::DenseMap<lldb::user_id_t, lldb::BlockSP> m_blocks;
  229   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions;
  230   llvm::DenseMap<lldb::user_id_t, lldb::CompUnitSP> m_compilands;
  231   llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;

   68   typedef llvm::DenseMap<clang::CXXRecordDecl *, lldb::user_id_t>
   70   typedef llvm::DenseMap<lldb::user_id_t, clang::Decl *> UidToDeclMap;
   72   typedef llvm::DenseMap<clang::DeclContext *, NamespacesSet>
   74   typedef llvm::DenseMap<clang::DeclContext *, lldb::user_id_t>

 1775   llvm::DenseMap<uint32_t, uint32_t> index_map;
 1872     llvm::DenseMap<uint32_t, uint32_t> &index_map) const {

  183       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
  237   llvm::DenseMap<uint32_t, lldb::CompUnitSP> m_comp_units;
  238   llvm::DenseMap<uint32_t, lldb::TypeSP> m_types;
  239   llvm::DenseMap<uint32_t, lldb::VariableSP> m_variables;
  240   llvm::DenseMap<uint64_t, std::string> m_public_names;

 9864     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
 9865     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
 9867     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

  573     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
  574     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
  576     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

   77     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
   78     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &BaseOffsets,
   79     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>

   18 typedef llvm::DenseMap<clang::ExternalASTSource *,

   20   llvm::DenseMap<lldb::addr_t, int64_t> addr_to_line;

   62 typedef llvm::DenseMap<uint32_t, SourceBreakpoint> SourceBreakpointMap;
   80   llvm::DenseMap<lldb::addr_t, int64_t> addr_to_source_ref;
   81   llvm::DenseMap<int64_t, SourceReference> source_map;

   25 typedef llvm::DenseMap<uint64_t, ThreadInfo> ThreadInfoMap;
   26 typedef llvm::DenseMap<unsigned int, lldb_private::RegisterValue> RegisterMap;

   52   typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;

  226   DenseMap<uint64_t, std::vector<uint64_t>> StaticBranchTargetings;

   74   DenseMap<uint64_t, uint64_t> IntermediateNodes;

   86   DenseMap<SymbolRemappingReader::Key, StringRef> MappedNames;

   20 static void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering){

   64       DenseMap<Value*,unsigned> LNumbering;
   65       DenseMap<Value*,unsigned> RNumbering;

  117   DenseMap<Value*, Value*> Values;
  120   DenseMap<BasicBlock*, BasicBlock*> Blocks;
  336       DenseMap<ConstantInt*,BasicBlock*> LCases;
  354         for (DenseMap<ConstantInt*,BasicBlock*>::iterator

   35   DenseMap<const char *, uint32_t, CStrDenseMapInfo> Pool;

   73   DenseMap<uint64_t, uint32_t> OffsetRemapping;

  244     using AllocationMap = DenseMap<unsigned, sys::MemoryBlock>;

  587   DenseMap<uint64_t, const Binary *> CPUIds;

  127   DenseMap<unsigned, InstructionPressureInfo> IPI;

   80   llvm::DenseMap<unsigned, unsigned> Resource2VecIndex;

  140   DenseMap<size_t, Symbol *> SymbolMap;
  145   DenseMap<ssize_t, Section *> SectionMap;

  326   DenseMap<SectionBase *, SectionBase *> FromTo;

   67     const DenseMap<SectionBase *, SectionBase *> &) {}
  711     const DenseMap<SectionBase *, SectionBase *> &FromTo) {
  910     const DenseMap<SectionBase *, SectionBase *> &FromTo) {
  982     const DenseMap<SectionBase *, SectionBase *> &FromTo) {

  419   replaceSectionReferences(const DenseMap<SectionBase *, SectionBase *> &);
  695       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
  762       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
  799       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;

 1272 typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;

   61   DenseMap<uint32_t, Stat> Individual;

   76   DenseMap<uint16_t, IndexedModuleDescriptor> ModStreams;
   77   DenseMap<uint16_t, std::string> NamedStreams;

  141   DenseMap<StringRef, StringRef> RemappingTable;

  175   typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;

 2875 DenseMap<uint64_t, const GroupSection *>
 2877   DenseMap<uint64_t, const GroupSection *> Ret;
 2888   DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V);
 5209   DenseMap<uint64_t, const GroupSection *> Map = mapSectionsToGroups(V);

   31   mutable llvm::DenseMap<int32_t, std::string> CachedNames;

   63   llvm::DenseMap<int32_t, TrieNode<T> *> LeftCalleesByFuncId;

  214     DenseMap<uint32_t, SmallVector<StackTrieNode *, 4>> &StackRootsByThreadId,
  279   DenseMap<uint32_t, StackTrieNode *> StackCursorByThreadId{};
  280   DenseMap<uint32_t, SmallVector<StackTrieNode *, 4>> StackRootsByThreadId{};
  281   DenseMap<unsigned, StackTrieNode *> StacksByStackId{};

   81   using PerThreadFunctionStackMap = DenseMap<uint32_t, FunctionStack>;

  324   DenseMap<uint32_t, RootVector> Roots;
  330   DenseMap<uint32_t, SmallVector<std::pair<StackTrieNode *, uint64_t>, 8>>

   36   DenseMap<StringRef, uint32_t> UsedSectionNames;
   39   DenseMap<StringRef, uint32_t> UsedSymbolNames;

   75   DenseMap<uint64_t, DIType *> TypeCache;

   37   using AllocaMapTy = DenseMap<const ScopArrayInfo *, AssertingVH<AllocaInst>>;
  806   DenseMap<BasicBlock *, BasicBlock *> StartBlockMap;
  810   DenseMap<BasicBlock *, BasicBlock *> EndBlockMap;
  815   DenseMap<BasicBlock *, ValueMapT> RegionMaps;
  819   DenseMap<BasicBlock *, SmallVector<PHINodePairTy, 4>> IncompletePHINodeMap;

   75       llvm::DenseMap<llvm::AssertingVH<llvm::Value>,
  113   llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::MDNode *>
  117   llvm::DenseMap<const llvm::SCEV *, llvm::MDNode *> SecondLevelAliasScopeMap;
  120   llvm::DenseMap<const llvm::SCEV *, llvm::MDNode *>
  126   llvm::DenseMap<llvm::AssertingVH<llvm::Value>, llvm::AssertingVH<llvm::Value>>

   51   using ReductionDependencesMapTy = DenseMap<MemoryAccess *, isl_map *>;
   54   using StatementToIslMapTy = DenseMap<ScopStmt *, isl::map>;
  297   using ScopToDepsMapTy = DenseMap<Scop *, std::unique_ptr<Dependences>>;

  141                     DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  152       Region *R, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  161                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
  174                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
  184                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
  198       DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
  210       Region *R, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  238       DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  253       Region *R, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  275       Loop *L, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
  289   getPwAff(BasicBlock *BB, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
  613                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);