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

References

  663     if (I == RHS.end() || I->second != KV.second)

  120     ValueT &operator*() { return I->getFirst(); }
  121     const ValueT &operator*() const { return I->getFirst(); }
  147     const ValueT &operator*() const { return I->getFirst(); }

  101     auto &I = Result.first->second;
  114     return Pos == Map.end()? ValueT() : Vector[Pos->second].second;
  120     auto &I = Result.first->second;
  133     auto &I = Result.first->second;
  150                             (Vector.begin() + Pos->second);
  156                             (Vector.begin() + Pos->second);

  100     auto &Index = InsertResult.first->second;
  131       ptrdiff_t &Index = InsertResult.first->second;
  168     assert(V[I->second] == X && "Value not actually at index in map!");
  169     if (I->second == (ptrdiff_t)(V.size() - 1)) {
  174       V[I->second] = T();

  168     unsigned childNum = Visited->second;

  189       return I->second->getValue();

  146     return AVI->second;

  675   IrrNode &Irr = *L->second;

  592                 .first->second;
  674             const auto &CallCountOld = CountIt->second;

  264       auto &E = Edges[EdgeIndexMap.find(&N)->second];
  273       auto &E = Edges[EI->second];
  627       return SCCs.begin() + SCCIndices.find(&C)->second;
  924       RC = getRC(*G, G->RefSCCIndices.find(RC)->second + 1);
 1205     assert(PostOrderRefSCCs[IndexIt->second] == &RC &&
 1207     return IndexIt->second;

  990       for (LoopT *L = I->second; L; L = L->getParentLoop())

  148     return I != PostNumbers.end() && I->second;
  155     assert(I->second && "block not finished by DFS");
  156     return I->second;

  805     return It == PerBlockAccesses.end() ? nullptr : It->second.get();
  811     return It == PerBlockDefs.end() ? nullptr : It->second.get();

  633     BlockT *BB = e->second;
  646   return PDT->getNode(e->second)->getIDom();
  761     RegionT *newRegion = it->second;
  821   return I != BBtoRegion.end() ? I->second : nullptr;

 1437       Pair.first->second = std::move(CR);
 1438     return Pair.first->second;

  665         return It->second;
  669       return Result.first->second;

  152     return I != ValueState.end() ? I->second : LatticeFunc->getUntrackedVal();
  231     return I->second; // Common case, in the map
  247   if (I != ValueState.end() && I->second == LV)

  300     return Impl->CustomNames.find(F)->second;

  453     return Member->second;
  567       return InterleaveGroupMap.find(Instr)->second;

  114         V = DuplIt->second;
  264     unsigned Reg = It->second;

   92     Worklist[It->second] = nullptr;

   87         return It->second;
   95         return It->second;
  602       return RemappedEdge->second;

  213       const int64_t TypeID = TyI->second;

  273       return It->second.first;

  135     return I == Stage.end() ? -1 : I->second;
  141     return I == Cycle.end() ? -1 : I->second;

  154     return VRegItr->second;

  399     return I->second;

  193       return I->second;
 1698       return std::move(I->second).CSInfo;
 1711     return It->second.HeapAllocSite;

  401       return itr->second;
  435           return MapItr->second;
  452           return MapItr->second;
  595       SlotIndex replaceBaseIndex = mi2iItr->second;

   77                       Result.first->second.isSimple())) {
   84         Result.first->getSecond() = TypeIndex(SimpleTypeKind::NotTranslated);
   87       if (Result.first->second.isSimple()) {
   88         assert(Result.first->second.getIndex() ==
   94         Result.first->second = nextTypeIndex();
  100     return Result.first->second;

  125       SymId = Result.first->second;

   55       return Position->getSecond();
   87       CandidateSet = It->getSecond();

  124     auto &EdgesForBB = It->second;
  135     return make_range(It->second.begin(), It->second.end());
  135     return make_range(It->second.begin(), It->second.end());

  695         return IMapI->second;
  704       auto &Result = static_cast<ResultT &>(*RI->second->second);
  716       return IMapI->second;
  755     for (auto &IDAndResult : ResultsListI->second)
  927     return *PI->second;
  935     return *PI->second;
  970       RI->second = std::prev(ResultList.end());
  973     return *RI->second->second;
  980     return RI == AnalysisResults.end() ? nullptr : &*RI->second->second;
  993     AnalysisResultLists[&IR].erase(RI->second);

   60       return Result->second;

  129     return Where->second.get();
  167     return I != Map.end() ? I->second : ValueT();
  289         ValueT Target(std::move(I->second));
  354     ValueTypeProxy Result = {I->first.Unwrap(), I->second};
  354     ValueTypeProxy Result = {I->first.Unwrap(), I->second};
  406     ValueTypeProxy Result = {I->first.Unwrap(), I->second};
  406     ValueTypeProxy Result = {I->first.Unwrap(), I->second};

  280     return *Groups.find(Index)->second;
  285     return *Groups.find(Index)->second;

  539     return iter->second;

   80       auto &CounterInfo = Result->second;
  110     return Result->second.Count;

  313       DomTreeNodeBase<NodeT> &OtherNd = *OI->second;
  331       return I->second.get();

  141       for (auto ChildAndKind : FCIt->second) {
  173     return InfoIt->second.IDom;
  241         if (SIT != NodeToInfo.end() && SIT->second.DFSNum != 0) {
  242           if (Succ != BB) SIT->second.ReverseChildren.push_back(BB);

  552       R.first->getSecond().moveFrom(std::move(P.V));

  350     reference operator*() const { return I->second; }
  351     pointer operator->() const { return I->second; }

   74     Worklist[It->second] = nullptr;

   56     return (Pos != Entries.end()) ? Pos->second : Entry();

  216       return iterator(It->second.begin(), &M, A);
  223       return const_iterator(It->second.begin(), &M, A);
  232       return iterator(It->second.end(), &M, A);
  238       return const_iterator(It->second.end(), &M, A);
  248         return I->second.size();
  404     return It->second;
  413     return It->second;
  423     return It->second;
  432     return It->second;

  292     I->second->eraseFromList();
  564   AliasSet::PointerRec *PtrValEnt = I->second;
  591   assert(I->second->hasAliasSet() && "Dead entry?");
  599   AliasSet *AS = I->second->getAliasSet(*this);
  600   AS->addPointer(*this, Entry, I->second->getSize(), I->second->getAAInfo(),
  600   AS->addPointer(*this, Entry, I->second->getSize(), I->second->getAAInfo(),

   49     return AVI->second;
   53   return AVIP.first->second;
  152   for (auto &A : AVI->second)
  254     return *I->second;
  261   return *IP.first->second;
  267     return I->second.get();

  128       return CacheIt->second;
  140       CacheIt->second = Ret;
  154         CacheIt->second = Ret;
  850     return CacheIt->second;
  854     return CacheIt->second;
 1613         OrigAliasResult = CacheIt->second;
 1614         CacheIt->second = NoAlias;
 1632         Pair.first->second = OrigAliasResult;
 1832     return Pair.first->second;
 1848       ItInsPair.first->second = Result;
 1865       return Pair.first->second = Result;
 1881       return Pair.first->second = Result;
 1893       return Pair.first->second = PartialAlias;
 1902   return Pair.first->second = Result;

  658   IrrNode &SuccIrr = *L->second;
  695     auto &Irr = *I->first;
  701       I->second = true;

  438   return SccIt->second;
  459     HeaderMapIt->second = IsHeader;
  462     return HeaderMapIt->second;
  887     return I->second;
  910         Prob += MapI->second;
  943     auto Key = I->first;

  189     return make_range<const_valuestate_iterator>(Itr->second.begin(),
  190                                                  Itr->second.end());
  220     return &Itr->second;
  246       Attr = Itr->second;
  515     return Itr->second;
  556     auto RangePair = std::equal_range(Itr->second.begin(), Itr->second.end(),
  556     auto RangePair = std::equal_range(Itr->second.begin(), Itr->second.end(),
  834     assert(Iter->second.hasValue());
  836   return Iter->second;

  104     if (Itr == ValueImpls.end() || Itr->second.getNumLevels() <= N.DerefLevel)
  106     return &Itr->second.getNodeInfoAtLevel(N.DerefLevel);
  138     if (Itr == ValueImpls.end() || Itr->second.getNumLevels() <= N.DerefLevel)
  140     return &Itr->second.getNodeInfoAtLevel(N.DerefLevel);

  141         if (CurrValue != Itr->second)
  143               ExternalRelation{CurrValue, Itr->second, UnknownOffset});
  252     assert(Iter->second.hasValue());
  254   return Iter->second;

  300           CallGraphNode *ExistingNode = ExistingIt->second;

 1098         NewC = It->second;

  407           if (Res.second || (AB |= Res.first->second) != Res.first->second) {
  407           if (Res.second || (AB |= Res.first->second) != Res.first->second) {
  408             Res.first->second = std::move(AB);
  424     return Found->second;
  456     if (Found != AliveBits.end() && Found->second.isNullValue())

   94           DstNode = IMap.find(UI)->second;

  165         GlobalMRI = unionModRef(GlobalMRI, I->second);
  223           if (I->second == GV)
  278     return &I->second;

  342   Arg = ArgIt->second;
  354   addCost(CostIt->second);
  355   SROACostSavings -= CostIt->second;
  356   SROACostSavingsLost += CostIt->second;
  372   CostIt->second += InstructionCost;

   85       assert(It->second == &Insn &&
   90   assert(It->second == nullptr &&

   49   Edges[EdgeIndexMap.find(&TargetN)->second].setKind(EK);
   57   Edges[IndexMapI->second] = Edge();
  342           assert(SCCIndices.find(&TargetSCC)->second <= i &&
  480     SCCIndices.find(SCCs[i])->second = i;
  515       SCCIndices.find(SCCs[i])->second = i;
  611           if (SCCIndices.find(&EdgeC)->second <= SourceIdx)
 1403     Edge &E = SourceN->Edges[InsertResult.first->second];
 1508   Node &N = *NI->second;
 1526   SCC &C = *CI->second;
 1537   int RCIndex = RCIndexI->second;

  195         It->second->BlockVals[BB] = Result;
  205       return ODI->second.count(V);
  216       return I->second->BlockVals.count(BB);
  226       auto BBI = I->second->BlockVals.find(BB);
  227       if (BBI == I->second->BlockVals.end())
  229       return BBI->second;
  260     SmallPtrSetImpl<Value *> &ValueSet = Iter->second;
  308   SmallVector<Value *, 4> ValsToClear(I->second.begin(), I->second.end());
  308   SmallVector<Value *, 4> ValsToClear(I->second.begin(), I->second.end());
  325     SmallPtrSetImpl<Value *> &ValueSet = OI->second;
 1317     return I->second;

  154     Value *StrideVal = SI->second;
  924               DepCands.unionSets(Access, Prev->second);
 1714   auto &IndexVector = Accesses.find(Access)->second;

  797     NearLoop = SubloopParents.insert({Subloop, &Unloop}).first->second;

  100   ConstantInt *SimplifiedAddrOp = AddressIt->second.Offset;
  102   auto *GV = dyn_cast<GlobalVariable>(AddressIt->second.Base);
  182         SimplifiedAddress &LHSAddr = SimplifiedLHS->second;
  183         SimplifiedAddress &RHSAddr = SimplifiedRHS->second;

  141     const DepSet &InstDeps = DI->second;

  849       if (CacheIt != CacheMap.end() && anyKnown(CacheIt->second))
  877     return CacheIt->second;

  104   bool Found = InstIt->second.erase(Val);
  107   if (InstIt->second.empty())
  928       Result.push_back(NonLocalDefIt->second);
  929       ReverseNonLocalDefsCache[NonLocalDefIt->second.getResult().getInst()]
 1112   NonLocalPointerInfo *CacheInfo = &Pair.first->second;
 1182         if (VI == Visited.end() || VI->second == Pointer.getAddr())
 1295         if (InsertRes.first->second != Pointer.getAddr()) {
 1356         if (InsertRes.first->second == PredPtrVal)
 1489                            it->second.getResult().getInst(), P.getPointer());
 1496         for (const auto &entry : toRemoveIt->second)
 1509   NonLocalDepInfo &PInfo = It->second.NonLocalDeps;
 1546     NonLocalDepInfo &BlockMap = NLDI->second.first;
 1557     if (Instruction *Inst = LocalDepEntry->second.getInst())
 1591     assert(!ReverseDepIt->second.empty() && !RemInst->isTerminator() &&
 1594     for (Instruction *InstDependingOnRemInst : ReverseDepIt->second) {
 1621     for (Instruction *I : ReverseDepIt->second) {
 1658     for (ValueIsLoadPair P : ReversePtrDepIt->second) {

 1092     if (It == PerBlockAccesses.end() || !isa<MemoryPhi>(It->second->front()))
 1094     AccessList *Accesses = It->second.get();
 1118     AccessList *Accesses = It->second.get();
 1200     if (It == PerBlockAccesses.end() || !isa<MemoryPhi>(It->second->front()))
 1202     AccessList *Accesses = It->second.get();
 1211   auto &Accesses = It->second;
 1252     Res.first->second = std::make_unique<AccessList>();
 1253   return Res.first->second.get();
 1260     Res.first->second = std::make_unique<DefsList>();
 1261   return Res.first->second.get();
 1824   if (VMA->second == MA)
 1840     std::unique_ptr<DefsList> &Defs = DefsIt->second;
 1849   std::unique_ptr<AccessList> &Accesses = AccessIt->second;
 1948       unsigned long ThisNumber = ThisNumberIter->second;

   48     return Cached->second;

   80     return NAI->second < NBI->second;
   80     return NAI->second < NBI->second;
  107   NumberedInsts.insert({New, OI->second});

   25   return OBB->second->dominates(InstA, InstB);

   96             Reachable.insert(It->second.begin(), It->second.end());
   96             Reachable.insert(It->second.begin(), It->second.end());
  161       else if (It->second.empty())
  164         for (Value *V : It->second)

  266     return iter->second;

 2307           NewOps.push_back(Pair.first->first);
 2309           Pair.first->second += NewScale;
 2320         NewOps.push_back(Pair.first->first);
 2322         Pair.first->second += Scale;
 2590         MulOpLists[M.find(NewOp)->second].push_back(NewOp);
 3814     return I->second;
 3849     for (const auto &VE : SI->second)
 3853   return &SI->second;
 3862     const SCEV *S = I->second;
 3936     const SCEV *S = I->second;
 4204       const SCEV *Old = It->second;
 4221         eraseValueFromMap(It->first);
 4905         I->second;
 5516     return I->second;
 5521   return InsertPair.first->second;
 5549     return I->second;
 6131   return Itr->second;
 6654     return Pair.first->second;
 6659   return PredicatedBackedgeTakenCounts.find(L)->second = std::move(Result);
 6672     return Pair.first->second;
 6713         const SCEV *Old = It->second;
 6722           eraseValueFromMap(It->first);
 6762   return BackedgeTakenCounts.find(L)->second = std::move(Result);
 6793           BTCPos->second.clear();
 6812       std::pair<const SCEV *, const Loop *> Entry = I->first;
 6821       for (auto *S : LoopUsersItr->second)
 6837         eraseValueFromMap(It->first);
 6838         forgetMemoizedResults(It->second);
 6876       eraseValueFromMap(It->first);
 6877       forgetMemoizedResults(It->second);
 7191   return Itr->second;
 7880     return I->second;
11868     std::pair<const SCEV *, const Loop *> Entry = I->first;
11878           BackedgeTakenInfo &BEInfo = I->second;
12335   return I->second;
12346   auto &SCEVPreds = ScevPredsIt->second;
12500       if (II->second.second == Expr)
12505       OS.indent(Depth + 2) << "--> " << *II->second.second << "\n";

  622     return Pair.first->second;
  629       return Pair.first->second = SE.LI.getLoopFor(I->getParent());
 1870     return I->second;

   98     return Iter->second;
  284         Link.Above = Iter->second;
  291         Link.Below = Iter->second;
  300       Info.Index = Iter->second;
  404     auto &IterSet = linksAt(Iter->second.Index);
  551     return &Result->second;
  558     return &Result->second;

 3804         auto &BBRefs = BBFRI->second;
 5195   while (DeferredFunctionInfoIterator->second == 0) {
 5231   if (DFII->second == 0)
 5240   if (Error JumpFailed = Stream.JumpToBit(DFII->second))
 5453       auto Linkage = VLI->second;
 5467       auto Linkage = VLI->second;

 1971     GO.addMetadata(K->second, *MD);
 2030         if (I->second == LLVMContext::MD_tbaa && StripTBAA)
 2051         if (HasSeenOldLoopTags && I->second == LLVMContext::MD_loop)
 2054         if (I->second == LLVMContext::MD_tbaa) {
 2058         Inst->setMetadata(I->second, MD);

  444   return I->second;
  463   return I->second-1;
  481     const Value *V = I->first;
  508     const Metadata *MD = I->first;
  509     OS << "Metadata: slot = " << I->second.ID << "\n";
  510     OS << "Metadata: function = " << I->second.F << "\n";
  666   MDIndex &Entry = Insertion.first->second;

  170     return I->second-1;
  180     return I->second;
  188     return I->second;

  712       assert(P.first->second == EHScope && "MBB is part of two scopes!");

  481   Asm->EmitULEB128(AbbrevIt->first, "Abbreviation code");
  482   for (const auto &AttrEnc : AbbrevIt->second) {

   23   return IterBool.first->second.Number;

 3060     return GCPI->second.get();
 3071       return IterBool.first->second.get();

  262   return Insertion.first->second;
  365     return I->second;
  380     return I->second;
  448     return I->second;
 2216     if (I != CompleteTypeIndices.end() && I->second == TypeIndex())
 2468     return I->second;
 2494     return I->second;
 2557     return InsertResult.first->second;
 2757       LI != ScopeVariables.end() ? &LI->second : nullptr;
 2760       GI != ScopeGlobals.end() ? GI->second.get() : nullptr;
 3015           Insertion.first->second = std::make_unique<GlobalVariableList>();
 3016         VariableList = Insertion.first->second.get();

  295   if (I->second)
  302   I->second = PrevLabel;
  326   if (I->second)
  334   I->second = PrevLabel;

 1071     return I->second.get();

  560   for (auto ArgReg : CallFwdRegsInfo->second) {
  610         FwdReg = EntryValReg->second;
  679           FwdReg = EntryValReg->second;
 2887     CU.addDIETypeSignature(RefDie, Ins.first->second);
 2905   Ins.first->second = Signature;
 3037   return SectionLabels.find(S)->second;

 1437     DIE &SPDie = *CI->first;
 1438     const DINode *D = CI->second;

  262       const PadRange &P = L->second;

  484       auto &StateAndEnd = InvokeMapIter->second;
  914       BaseState = FuncInfo.FuncletBaseStateMap.find(FuncletPad)->second;

  486     auto n = EHScopeI->second;
  560     return I->second;
  651     if (EHScope1->second != EHScope2->second)
  651     if (EHScope1->second != EHScope2->second)
 1405     SameEHScope = MBBEHScope->second == FallThroughEHScope->second;
 1405     SameEHScope = MBBEHScope->second == FallThroughEHScope->second;

  908     RelocateInstMap[MaybeBase->second].push_back(I);
 2943       if (it != NodeMap.end() && it->second == CurrentIndex)
 2996       V = SV->second;
 3270     auto *Result = ST.Get(Map.find(Original)->second);
 3596       if (It->second.getInt() == ExtTy)
 3616     if (It != PromotedInsts.end() && It->second.getInt() == ExtTy)
 3617       return It->second.getPointer();
 5527       if (AlreadySeen->second != nullptr)
 5528         UnhandledExts.insert(AlreadySeen->second);

   56     return FuncletX->second < FuncletY->second;
   56     return FuncletX->second < FuncletY->second;

   72     return *I->second;

  176     return *VRegsIt->second;

  161       LLVM_DEBUG(dbgs() << "Update use with: " << printReg(NewVRegIt->second)
  164       MOUse.setReg(NewVRegIt->second);

  103     return *RegRCIt->second;
  281     return *It->second;
  315     return *It->second;
  389     return *It->second;

 1166   VNInfo *OrigVNI = It->second->getVNInfoAt(Idx.getRegSlot());

  599       unsigned ID = It->second;
  616     for (auto Fragment : MapIt->second) {
 1092   auto &ThisFragmentsOverlaps = IsInOLapMap.first->second;
 1093   auto &AllSeenFragments = SeenIt->second;
 1109       ASeenFragmentsOverlaps->second.push_back(ThisFragment);
 1163       InLocsT = OL->second;
 1165       InLocsT &= OL->second;

  595     return &Itr->getSecond();
 1350     unsigned SpillOffset = Spilled ? SpillIt->second : 0;

  458     Entry->second.first.resize(N);
  459     Entry->second.second.resize(N);
  461   BitVector &DefOnEntry = Entry->second.first;
  462   BitVector &UndefOnEntry = Entry->second.second;

   84   unsigned OrderOld = M.find(Old)->second;
   85   unsigned OrderNew = NewIter->second;
   90   for (MachineInstr *I = Old->getNextNode(); M.find(I)->second == OrderNew;

  329     I.first->second = Info;
  331   return *I.first->second;
 1662   MBB = MBBInfo->second;
 1691           MF.getFrameInfo().getObjectAllocation(ObjectInfo->second))
 1697   FI = ObjectInfo->second;
 1719   FI = ObjectInfo->second;
 1792   Dest = MachineOperand::CreateJTI(JumpTableEntryInfo->second);
 2980   return BlockInfo->second;
 3025   return ValueInfo->second;

  420       const FrameIndexOperand &StackObject = StackObjectInfo->second;
  437     const FrameIndexOperand &StackObject = StackObjectInfo->second;
  456     const FrameIndexOperand &StackObject = StackObjectInfo->second;
  813   const FrameIndexOperand &Operand = ObjectInfo->second;
  862       OS << StringRef(TRI->getRegMaskNames()[RegMaskInfo->second]).lower();

 1218       TriangleChain Chain = std::move(Found->second);
 1488     MachineBasicBlock *Succ = FoundEdge->second.BB;
 1493       return FoundEdge->second;

  506   delete SI->second;

  181         assert(II->second < InstrDepth.size() && "Bad Index");
  182         MachineInstr *DefInstr = InsInstrs[II->second];
  185         DepthOp = InstrDepth[II->second];

   95           CI->second.Avail = false;
  107         markRegsUnavailable(I->second.DefRegs, TRI);
  110         if (MachineInstr *MI = I->second.MI)
  133       auto &Copy = I.first->second;
  148     if (MustBeAvailable && !CI->second.Avail)
  150     return CI->second.MI;

  834   CallSiteInfo CSInfo = std::move(CSIt->second);
  854   CallSiteInfo CSInfo = CSIt->second;

 1369   if (const MachineInstr *Dup = LookForDuplicate(MI, CI->second)) {
 1429   return LookForDuplicate(MI, CI->second) != nullptr;
 1491       CI->second.push_back(MI);

  133   std::swap(Result, I->second);
  267   return I != MachineFunctions.end() ? I->second.get() : nullptr;
  285     I.first->second.reset(MF);
  287     MF = I.first->second.get();

  669     unsigned MINumber = ResultIt->second;

 1156           BackEdge = Dep->second;
 2155     std::pair<unsigned, int64_t> RegAndOffset = It->second;
 2781                 MI->getOperand(OffsetPos).getImm() - It->second.second;
 2875     for (SUnit *CI : cycleInstrs->second) {

 1621     StoreChainDependents[Result.first->second].push_back(&SU);

  969   if (I->second < UseHeight)
  970     I->second = UseHeight;
 1100         Cycle = HeightI->second;

  201           if (addRequired(I->first))

 1004     std::pair<unsigned, int64_t> RegAndOffset = It->second;
 1159     MachineInstr *OrigMI = OrigInstr->second;
 1454       return I->second;
 1466     Register R = I->second;

 1368     if (TII->FoldImmediate(MI, *II->second, Reg, MRI)) {
 1409   MachineInstr *PrevCopy = CopyMIs.find(SrcReg)->second;
 1468   Register PrevDstReg = PrevCopy->second->getOperand(0).getReg();

  409       G.addEdgeBypassingCostAllocator(NId, MId, I->second);

   68     return makeArrayRef<uint32_t>(It->second);

   44   return LiveRanges[IT->second];
  143       ProcessMarker(BlockMarkerSet.begin()->getFirst(),
  144                     BlockMarkerSet.begin()->getSecond());
  151         ProcessMarker(&I, It->getSecond());
  176         LocalLiveIn |= I->second.LiveOut;

  263       Worklist[It->second] = nullptr;
15364         RootCount->second.first == RootNode &&
15365         RootCount->second.second > StoreMergeDependenceLimit)

  161     FuncInfo.ValueMap[&*I] = VI->second;
  284     unsigned UseOrder = I->second;
  482     return I->second;
  777         Ops.push_back(MachineOperand::CreateFI(SI->second));
 1772     ResultReg = I->second;

  118           CatchObjects.insert({AI, {}}).first->second.push_back(
  165             for (int *CatchObjPtr : Iter->second)
  513     return I->second;
  522   unsigned &VReg = I.first->second;

  283   return I->second;

  103           NewValId = I->second;
  561     assert(Id != I->second && "Id is mapped to itself.");
  564     RemapId(I->second);
  565     Id = I->second;

  142       RemapId(I->second);
  143       assert(I->second && "All Ids should be nonzero");
  144       return I->second;
  481     SDValue SoftenedOp = getSDValue(Iter->second);

  233   if (I != LegalizedNodes.end()) return I->second;

  694       if (DI != GluedMap.end() && DI->second != N)
  696         OpN = DI->second;

 1440       SmallVectorImpl<unsigned> &LRegs = LRegsPos->second;
 1483         LRegsPair.first->second = LRegs;

  807         .addReg(VRI->second);

  766   for (auto &Val: I->second)

 1286           DAG.getFrameIndexDbgValue(Var, Expr, SI->second,
 1320       unsigned Reg = VMI->second;
 1375     unsigned InReg = It->second;
 1561       return DAG.getFrameIndex(SI->second,
 1939     CopyValueToVirtualRegister(V, VMI->second);
 5554       RegsForValue RFV(V->getContext(), TLI, DAG.getDataLayout(), VMI->second,
 5561       Op = MachineOperand::CreateReg(VMI->second, false);
 5831           FI = I->second;
 6593       const int FrameIndex = SI->second;
 9438     return &Iter.first->second;
 9529   const AllocaInst *AI = ArgCopyIter->second.first;
 9567   const StoreInst *SI = ArgCopyIter->second.second;
 9912         VI.Slot = I->second;
 9972           Reg = I->second;

  517     unsigned From = I->first;
  518     unsigned To = I->second;
  525       To = J->second;
  593       MachineInstr *Def = RegInfo->getVRegDef(LDI->second);
  606               IsIndirect, LDI->second, Variable, Expr);
  613            UI = RegInfo->use_instr_begin(LDI->second),
  664     unsigned From = I->first;
  665     unsigned To = I->second;
  671       To = J->second;
 1320           FI = SI->second;

  160     return It->second;
  297       SSM.DuplicateMap[Ptrs[i]] = SeenIt->second;
 1010   Optional<int> DerivedPtrLocation = SlotIt->second;

   56     return I->second;

  111   SlotIndex MIIndex = mi2iItr->second;
  124   SlotIndex MIIndex = mi2iItr->second;

  480   if (VNInfo *OldVNI = InsP.first->second.getPointer()) {
  485     InsP.first->second = ValueForcePair(nullptr, Force);

  542   const BlockLifetimeInfo &BlockInfo = BI->second;
  648         BetweenStartEnd |= I->second;
  771       BlockLifetimeInfo &BlockInfo = BI->second;
  782           LocalLiveIn |= I->second.LiveOut;

  564     MFI.setObjectSSPLayout(I, LI->second);

   42     return It->second;
   55     return It->second;
   70     return It->second;
  165       Register UUseVReg = UpwardsUse ? UUseIt->second : Register();
  197           UUseVReg = UUseIt->second;

  202       for (unsigned j = 0, ee = LI->second.size(); j != ee; ++j) {
  203         MachineBasicBlock *SrcBB = LI->second[j].first;
  204         unsigned SrcReg = LI->second[j].second;
  327     LI->second.push_back(std::make_pair(BB, NewReg));
  404           auto *MappedRC = MRI->getRegClass(VI->second.Reg);
  406           if (VI->second.SubReg != 0) {
  408                                                      VI->second.SubReg);
  413               MRI->setRegClass(VI->second.Reg, ConstrRC);
  418             ConstrRC = MRI->constrainRegClass(VI->second.Reg, OrigRC);
  424             MO.setReg(VI->second.Reg);
  428                                                    VI->second.SubReg));
  439                 .addReg(VI->second.Reg, 0, VI->second.SubReg);
  439                 .addReg(VI->second.Reg, 0, VI->second.SubReg);
  502         for (unsigned j = 0, ee = LI->second.size(); j != ee; ++j) {
  503           MachineBasicBlock *SrcBB = LI->second[j].first;
  511           unsigned SrcReg = LI->second[j].second;

  503   return I->second;

  395     if (MO.isUse() && DI->second < LastUse)
  396       LastUse = DI->second;
  397     if (MO.isDef() && DI->second > LastDef)
  398       LastDef = DI->second;
  552     Reg = SI->second;
 1034     unsigned DefDist = DDI->second;
 1099       if (isDefTooClose(MOReg, DI->second, MI))
 1738           = TiedOperands.begin()->second;

  203         BaseState = BaseStateI->second;

  114   return Iter->second;

  106   return Iter->second;

  100     Result.first->first.RecordData = RecordData;
  105   TypeIndex ActualTI = Result.first->second;

 1676             RelocAddrEntry &entry = I.first->getSecond();
 1709     return AI->second;

  944       if (Iter->second != NotIndexed) {
  947                            NI.getUnitOffset(), Offset, Iter->second);
  950       Iter->second = NI.getUnitOffset();

   40   return R.first->second;

  100     for (auto &Entry : CacheIter->second) {
  156     CacheIter->second.emplace_back(WriteBuffer, Size);

  146     return Entry->second;
  261     return Iter->second;

  193   jit_code_entry*& JITCodeEntry = I->second.Entry;

   52     return *GOTEntryI->second;
   66     return *StubI->second;

  292   auto &CIEInfo = CIEInfoItr->second;

   43       void *SlabStart = SegBlocks.begin()->second.base();

  171     return I->second;
  182     return I->second;

  310   assert(I->second.getAddress() == 0 && "Redundantly resolving symbol Name");
  311   I->second = std::move(Sym);
  346   assert(QRI->second.count(Name) && "No dependency on Name in JD");
  347   QRI->second.erase(Name);
  348   if (QRI->second.empty())
  385     assert((KV.second.getFlags() & ~WeakFlags) == (I->second & ~WeakFlags) &&
  462     DelegatedFlags[Name] = std::move(I->second);
  540     RequestedAliases[Name] = std::move(I->second);
  623       auto &SrcJDDeps = Deps.find(&SrcJD)->second;
  760         EntryItr->second.setState(SymbolState::Materializing);
  785           assert(SymI->second.isInMaterializationPhase() &&
  787           assert(!SymI->second.hasMaterializerAttached() &&
  799             if (MII->second.hasQueriesPending())
  808           assert(SymI->second.getState() == SymbolState::Materializing &&
  810           assert(!SymI->second.hasMaterializerAttached() &&
  814           SymI->second.setAddress(SymI->second.getAddress());
  814           SymI->second.setAddress(SymI->second.getAddress());
  815           SymI->second.setMaterializerAttached(true);
  833       assert(Symbols.find(KV.first)->second.isInMaterializationPhase() &&
  840       if (I->second.hasQueriesPending())
  880              (OtherSymI->second.getState() != SymbolState::Ready &&
  884       auto &OtherSymEntry = OtherSymI->second;
  939       assert(!SymI->second.hasMaterializerAttached() &&
  941       assert(SymI->second.getState() == SymbolState::Materializing &&
  943       assert(SymI->second.getAddress() == 0 &&
  946       if (SymI->second.getFlags().hasError())
  951         assert(Flags == (SymI->second.getFlags() &
  969       auto &Name = SymI->first;
  973       SymI->second.setAddress(ResolvedSym.getAddress());
  974       SymI->second.setFlags(ResolvedFlags);
  975       SymI->second.setState(SymbolState::Resolved);
 1020       if (SymI->second.getFlags().hasError())
 1035       auto &Name = SymI->first;
 1036       auto &SymEntry = SymI->second;
 1046       auto &MI = MII->second;
 1059           auto &DependantMI = DependantMII->second;
 1079           auto &DependantSymEntry = DependantSymI->second;
 1095                   DependantName, DependantSymI->second.getSymbol());
 1108         SymI->second.setState(SymbolState::Ready);
 1110           Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1174       auto &MI = MII->second;
 1193           assert(UnemittedDepI->second.count(Name) &&
 1195           UnemittedDepI->second.erase(Name);
 1196           if (UnemittedDepI->second.empty())
 1219           assert(UnemittedDepMII->second.Dependants.count(&JD) &&
 1221           assert(UnemittedDepMII->second.Dependants[&JD].count(Name) &&
 1223           UnemittedDepMII->second.Dependants[&JD].erase(Name);
 1224           if (UnemittedDepMII->second.Dependants[&JD].empty())
 1225             UnemittedDepMII->second.Dependants.erase(&JD);
 1231       for (auto &Q : MII->second.pendingQueries()) {
 1312       if (I->second.isInMaterializationPhase()) {
 1317       auto UMII = I->second.hasMaterializerAttached()
 1337         UMII->second->MU->doDiscard(*this, UMII->first);
 1337         UMII->second->MU->doDiscard(*this, UMII->first);
 1392       Flags[Name] = I->second.getFlags();
 1455     if (!SymI->second.getFlags().isExported() && !MatchNonExported)
 1464     if (SymI->second.getFlags().hasError()) {
 1472     if (SymI->second.getState() >= Q->getRequiredState()) {
 1473       Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1479     if (SymI->second.hasMaterializerAttached()) {
 1480       assert(SymI->second.getAddress() == 0 &&
 1485       auto MU = std::move(UMII->second->MU);
 1492         SymK->second.setMaterializerAttached(false);
 1493         SymK->second.setState(SymbolState::Materializing);
 1502     assert(SymI->second.isInMaterializationPhase() &&
 1595     if (SymI->second.getState() >= Q->getRequiredState()) {
 1596       Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
 1603     if (SymI->second.hasMaterializerAttached()) {
 1604       assert(SymI->second.getAddress() == 0 &&
 1609       auto MU = std::move(UMII->second->MU);
 1617         SymK->second.setState(SymbolState::Materializing);
 1618         SymK->second.setMaterializerAttached(false);
 1627     assert(SymI->second.isInMaterializationPhase() &&
 1667         OS << I->second->MU.get() << ")\n";
 1743         if (I->second.getFlags().isStrong() ||
 1744             I->second.getState() > SymbolState::NeverSearched)
 1747           assert(I->second.getState() == SymbolState::NeverSearched &&
 1771     UMII->second->MU->doDiscard(*this, S);
 2088     return std::move(ResultMap->begin()->second);

  148     RequestedAliases[I->first] = std::move(I->second);
  148     RequestedAliases[I->first] = std::move(I->second);

  220             for (auto &S : I->second)
  280             for (const auto &S : I->second)
  376     Alloc = std::move(AllocItr->second);
  435   auto EHFrameRange = EHFrameRangeItr->second;
  453   auto EHFrameRange = EHFrameRangeItr->second;

  172         Flags = I->second;

  156     if (!Itr->second.Upward)
  158     Itr->second.Upward = false;
  199     if (!Itr->second.Downward)
  201     Itr->second.Downward = false;

  603       OS << '%' << I->second;
 1101   return MI == mMap.end() ? -1 : (int)MI->second;
 1111   return MI == mdnMap.end() ? -1 : (int)MI->second;
 1122   return FI == fMap.end() ? -1 : (int)FI->second;
 1131   return AI == asMap.end() ? -1 : (int)AI->second;
 1149   return I == GUIDMap.end() ? -1 : (int)I->second;
 4119     Nodes[I->second] = cast<MDNode>(I->first);
 4119     Nodes[I->second] = cast<MDNode>(I->first);
 4136     asVec[I->second] = *I;

   57     RetainedNodes.append(PV->second.begin(), PV->second.end());
   57     RetainedNodes.append(PV->second.begin(), PV->second.end());
   61     RetainedNodes.append(PL->second.begin(), PL->second.end());
   61     RetainedNodes.append(PL->second.begin(), PL->second.end());

  414       return Replacement->second;
  461       if (OrigLinkage->second == OldLinkageName)

  287   It->second = std::move(GCName);

  659   SmallPtrSet<Pass *, 8> &LU = DMI->second;
  670     AnUsage = DMI->second;
  978     if (Info->second->getAsImmutablePass() == nullptr &&
  979         !is_contained(PreservedSet, Info->first)) {
  982         Pass *S = Info->second;
 1001       if (Info->second->getAsImmutablePass() == nullptr &&
 1002           !is_contained(PreservedSet, Info->first)) {
 1005           Pass *S = Info->second;
 1060       if (Pos != AvailableAnalysis.end() && Pos->second == P)
 1193     return I->second;

  218   auto OwnerAndIndex = I->second;
  381   ValueAsMetadata *MD = I->second;
  408   ValueAsMetadata *MD = I->second;
 1295   const auto &Info = getContext().pImpl->InstructionMetadata.find(this)->second;
 1306   const auto &Info = getContext().pImpl->InstructionMetadata.find(this)->second;

   44   return I != PassInfoMap.end() ? I->second : nullptr;

  181   return *(Pair.first->second.get());

  563   return it != BlockMap.end() ? it->second : nullptr;

  194   return I->second;
  838     assert(I->second && I->first == I->second->getValPtr() &&
  838     assert(I->second && I->first == I->second->getValPtr() &&
  838     assert(I->second && I->first == I->second->getValPtr() &&
  840     I->second->setPrevPtr(&I->second);
  840     I->second->setPrevPtr(&I->second);

 5214     return Itr->second;
 5360     return ResultIt->second;

  921     return It->second;

  476     return Prevailing->second == S;
  611     return Prevailing->second == S;

  150     return JurisdictionLocation->second;
  180   return InsertionResult.first->second;
  187     return MaxFragmentSizeLocation->second;
  204   return InsertionResult.first->second;

  291           MCCVFunctionInfo::LineInfo &IA = I->second;
  530         CurSourceLoc = I->second;

  871   unsigned UniqueID = It.first->second;

  112   return I->second;
  123   return I->second;

  184   return I->second;
  195     P.first->second = Start;
  198   return P.first->second;

  485       SectionSymbol = SectionFunctions.find(&SecA)->second;
 1058   TypeIndices[&Symbol] = Pair.first->second;
 1062   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 1079   TypeIndices[&Symbol] = Pair.first->second;
 1083   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 1329         Index = WasmIndices.find(&WS)->second;
 1373                         << WasmIndices.find(&WS)->second << "\n");
 1390       LLVM_DEBUG(dbgs() << "  -> event index: " << WasmIndices.find(&WS)->second
 1416       uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
 1423           DataLocations.find(ResolvedSym)->second;
 1464       Info.ElementIndex = WasmIndices.find(&WS)->second;
 1467       Info.DataRef = DataLocations.find(&WS)->second;
 1483       uint32_t FunctionIndex = WasmIndices.find(&WS)->second;

  166   It->second->onInstructionExecuted();
  167   if (It->second->isExecuted())

  447           Relocation.getSymbol()->getRawDataRefImpl(), PltEntryIter->second));

  178         P.first->second = -1;
  192   return P.first->second;

   21     return getRawStream(Streams[It->second]);

   40         OptRanges.insert(std::make_pair(O.getID(), emptyRange())).first->second;
   63       R.first = std::min(R.first, I->second.first);
   64       R.second = std::max(R.second, I->second.second);

   50     return Counter::getExpression(It->second);
  203   return RecordIt->second;

  442     size_t OldRecordIndex = InsertResult.first->second;

  745           printFunctionSummary(CovOS, FuncsIt->second);
  754         const BlockVector &Blocks = BlocksIt->second;

  214   InstrProfRecord &Dest = Where->second;
  233   InstrProfRecord &Dest = Where->second;

  659       OffsetsToUse.push_back(iter->second);

   18   return try_emplace(K, nullptr).first->getSecond();
   21   return try_emplace(std::move(K), nullptr).first->getSecond();
   27   return &I->second;
   33   return &I->second;
   85     if (R == RHS.end() || L.second != R->second)

   21     delete IT->second;

 2376   Init *I = It->second.V;
 2378   if (!It->second.Resolved && Map.size() > 1) {

   57     const uint64_t ChunkVal = Chunk->first;
   58     const unsigned Count = Chunk->second;

  371         .addFrameIndex(SI->second)
  675       Addr.setFI(SI->second);

  250       return It->second.first;
  254     return JumpTableEntryInfo.find(Idx)->second.second;

  211     IPI->second.emplace_back(User, OpNo);
  216     Instruction *OldInstr = IPI->first;
  217     Uses OldUses = std::move(IPI->second);
  352     Converted.first->second.ShouldConvert = shouldConvertImpl(&C);
  353   return Converted.first->second.ShouldConvert;
  405     BasicBlock *CurBB = IPI->first->getParent();
  411       LLVM_DEBUG(IPI->first->print(dbgs()));
  433     LLVM_DEBUG(IPI->first->print(dbgs()));

  185     return I->second;

  445     SIFunctionResourceInfo &Info = I.first->second;
  892           MaxSGPR = std::max(I->second.NumExplicitSGPR - 1, MaxSGPR);
  893           MaxVGPR = std::max(I->second.NumVGPR - 1, MaxVGPR);
  894           MaxAGPR = std::max(I->second.NumAGPR - 1, MaxAGPR);
  896             = std::max(I->second.PrivateSegmentSize, CalleeFrameSize);
  897           Info.UsesVCC |= I->second.UsesVCC;
  898           Info.UsesFlatScratch |= I->second.UsesFlatScratch;
  899           Info.HasDynamicallySizedStack |= I->second.HasDynamicallySizedStack;
  900           Info.HasRecursion |= I->second.HasRecursion;

   48     return Entry.first->second;
   59   Entry.first->second = Offset;

   75     if (I == S2.end() || I->second != P.second)
  338     auto &LiveMask = I->second;
  454     else if (I->second != P.second) {
  457         << PrintLaneMask(I->second)
  503     if (It != LiveRegs.end() && It->second.any())
  505          << PrintLaneMask(It->second);

  463     auto LiveIn = std::move(LiveInIt->second);

  142         MI.getOperand(OperandIdx).setReg(It->second);

  234     if ((Conflict->second.second & Mask).any())
  282       Loc->second.first |= State;
  283       Loc->second.second |= Mask;

  148     return ReachableMap.find(&MBB)->second;
  347     if (DomIt != Visited.end() && DomIt->second <= LoopLevel)

  489       ArrayRef<SpilledReg>() : makeArrayRef(I->second);
  507                                          : I->second.Lanes[Lane];
  880     return PSV.first->second.get();
  889     return PSV.first->second.get();

  241       dbgs() << "  " << MI << "    Needs = " << PrintState(III->second.Needs)
  242              << ", OutNeeds = " << PrintState(III->second.OutNeeds) << '\n';
  696   const BlockInfo &BI = BII->second;
  745           if (III->second.Needs & StateWWM)
  747           else if (III->second.Needs & StateWQM)
  750             Needs &= ~III->second.Disabled;
  751           OutNeeds = III->second.OutNeeds;

 4809   const ARM_MLxEntry &Entry = ARM_MLxTable[I->second];

  876                     << It->second << "\n");
  888   if (It->second < NewRCWeight.WeightLimit * SizeMultiplier) {
  889     It->second += NewRCWeight.RegWeight;

  681                             .addFrameIndex(SI->second)
  806         Addr.Base.FI = SI->second;

 7183     Value = ValueCounts.begin()->first;

 2428         for (unsigned i = 0, e = BI->second.size(); i != e; ++i) {
 2429           if (Offset == getMemoryOpOffset(*BI->second[i])) {
 2435           BI->second.push_back(&MI);

  224       return I->second;

 1224     int RegOffset = Offset->second;
 1265     } else if (Offset->second != CurOffset - 8) {
 1269                                    << " saved at " << Offset->second

  478       LastEMSInfo = std::move(LastMappingSymbol->second);

 1010   const ReduceEntry &Entry = ReduceTable[OPI->second];

  785       return F->second;

 1229   uint16_t EW = F->second.Width;
 1238   if (F->second.Type == ExtType::SExt)
 1240   else if (F->second.Type == ExtType::ZExt)

  300     F->second |= Mask;
  309   if (Mask & F->second)
 1170       NewVN = F->second;

  214       return F->second;
  584     dbgs() << "  " << printReg(I->first, HRI) << ":\n";
  585     const IFListType &LL = I->second;
  633     VRs.push_back(I->first);
  758     return F->second;
  864       dbgs() << "  L=" << I->first << ':';
  865       const RSListType &LL = I->second;
  897       RSListType &LL = F->second;
 1041     IFListType &LL = I->second;
 1043       findRemovableRegisters(I->first, LL[i].first, LL[i].second);
 1053     if (I->second.empty())
 1063   IFListType &LL = F->second;
 1151   IFListType &LL = F->second;
 1172   IFListType &LL = F->second;
 1188     pruneCoveredSets(I->first);
 1202     pruneUsesTooFar(I->first, RPO, Memo);
 1207     pruneRegCopies(I->first);
 1270     unsigned UC = F->second;
 1290     const IFListType &LL = I->second;
 1327     IFListType &LL = I->second;
 1346     const MachineInstr *DefI = MRI->getVRegDef(I->first);
 1379     const IFListType &LL = I->second;
 1384     IFListType &LL = I->second;
 1400     unsigned VR = I->first;
 1410     MachineInstr *MI = MRI->getVRegDef(I->first);
 1413     unsigned NewR = RegMap[I->first];
 1417     IFRecord IF = I->second[0].first;
 1444     MachineInstr *DefI = MRI->getVRegDef(I->first);
 1445     MRI->replaceRegWith(I->first, RegMap[I->first]);
 1445     MRI->replaceRegWith(I->first, RegMap[I->first]);
 1541       unsigned VR = I->first, Pos = I->second;
 1541       unsigned VR = I->first, Pos = I->second;
 1600       unsigned Idx = Register::virtReg2Index(I->first);

  256     if (F != CM.end() && F->second.PredR != PR) {
  263       F->second.PredR = PR;
  265     CondsetInfo &CI = F->second;

 1355         *F->second = nullptr;

  337         U->setOperand(i, F->second);
  343   Root = R->second;

  224               std::pair<unsigned,unsigned> PeepholeSrc = DI->second;

  924     return F->second;

  316     if (I->second) {
  317       MIBundleBuilder(I->second).append(MF->CloneMachineInstr(&*Filler));
  320       I->first->insert(I->first->end(), MF->CloneMachineInstr(&*Filler));
  320       I->first->insert(I->first->end(), MF->CloneMachineInstr(&*Filler));

  348         .addFrameIndex(SI->second)
  536       Addr.setFI(SI->second);

  146       return Types.find(MI)->getSecond();
  152       Types.find(MI)->getSecond() = InstTy;
  159       return WaitingQueues.find(MI)->getSecond();
  166       WaitingQueues.find(MI)->getSecond().push_back(WaitingForMI);

  586   const DenseMap<unsigned, unsigned> &RegMap = I->second;
  590   unsigned MappedVR = VI->second;

  396         Addr.Base.FI = SI->second;
 2278             ResultReg).addFrameIndex(SI->second).addImm(0);

12546         Ops[0] = DAG.getNode(ISD::TRUNCATE, dl, SI0->second, Ops[0]);
12549         Ops[1] = DAG.getNode(ISD::TRUNCATE, dl, SI1->second, Ops[1]);

 1123     unsigned NewOpcode = ImmToIdxMap.find(OpC)->second;

   70     return ImmToIdxMap.find(ImmOpcode)->second;

   78   return P.first->second;
  374     if (RL == Reg2Local.end() || RL->second < MFI.getParams().size())
  377     MFI.setLocal(RL->second - MFI.getParams().size(),

  327       Addr.setFI(SI->second);
  608         .addFrameIndex(SI->second);

  290       Pair.first->second = createWrapper(F, Ty);
  292     Function *Wrapper = Pair.first->second;

   94     return I->second.count(To);
  109     return I->second;
  373     Pair.first->second = Index;

  395   const FPOData *FPO = I->second.get();

  720         FalseReg = FRIt->second;
  788         MOp.setReg(It->second);
  825       Op1Reg = Op1Itr->second.first;
  829       Op2Reg = Op2Itr->second.second;

  459     if (I->second != C.getID())

  765       if (I != LocalValueMap.end() && I->second != 0) {
  766         LoadReg = I->second;
  879       AM.Base.FrameIndex = SI->second;

 1865   return alignTo(MFI.getMaxCallFrameSize(), getStackAlignment()) + it->second;

19933           VT != SrcOpMap.begin()->first.getValueType())
19942     if (M->second[CIdx])
19944     M->second.setBit(CIdx);
19951     if (!I->second.isAllOnesValue())

  494   MachineBasicBlock *MBB = (*LEAs.begin()->second.begin())->getParent();
  523     if (!chooseBestLEA(Insns->second, MI, DefMI, AddrDispShift, Dist))

  118     MachineBasicBlock *MBB = I->first;
  119     unsigned Cycles = I->second;
  174     VisitedBBInfo BBInfo = it->second;

 2012     Op->setReg(It->second);

  527       BaseState = BaseStateI->second;
  573     int PredState = PredEndState->second;
  609     int SuccState = SuccStartState->second;
  759       if (EndState->second != PrevState)
  760         insertStateNumberStore(BB->getTerminator(), EndState->second);

  116     result.first->second = new (Allocator) Symbol{Kind, Name, Targets, Flags};
  119       result.first->second->addTarget(Target);

  898       V = VI->second;
  928         V = it->second;

  219       GlobalVariable *Slot = Found->second;

  393     auto &ProcessedThreshold = std::get<0>(IT.first->second);
  394     auto &CalleeSummary = std::get<1>(IT.first->second);
  395     auto &FailureInfo = std::get<2>(IT.first->second);
  888       SummariesForIndex[GI] = DS->second;
  951     auto NewLinkage = GS->second->linkage();
  981           GS->second->canAutoHide()) {
 1039     return !GlobalValue::isLocalLinkage(GS->second->linkage());

 1444     if (PHINode *PN = dyn_cast<PHINode>(I->first))
 1446     else if (LoadInst *LI = dyn_cast<LoadInst>(I->first))
 1454     if (PHINode *PN = dyn_cast<PHINode>(I->first))
 1456     else if (LoadInst *LI = dyn_cast<LoadInst>(I->first))

 1606         TypeMembers[I->second].insert(GlobalIndex);
 1881         if (!P.second && P.first->second.Linkage != CFL_Definition)
 1882           P.first->second = {Linkage, FuncMD};
 1995     return Ins.first->second;

  873   FnTreeType::iterator IterToFNInFnTree = I->second;
  938     FnTree.erase(I->second);

  533   unsigned Count = (I != SampleCoverage.end()) ? I->second.size() : 0;
  643   uint64_t W = (I == BlockWeights.end() ? 0 : I->second);
  849     it.first->second = Samples->findFunctionSamples(DIL);
  850   return it.first->second;
 1012     pair.first->second.entryCount += FS->getEntrySamples();

   77           GO.setComdat(Replacement->second);
  133           *MDNode::get(M.getContext(), {MD->getOperand(0), I->second}));

 1324     return PreviouslySeenAllocaInfo->getSecond();

   83     assert(It->second.get() != nullptr);
   84     return *It->second.get();
   92     return It->second.get();
  260       Iter->second = std::move(std::make_unique<BBInfo>(Index));
  266       Iter->second = std::move(std::make_unique<BBInfo>(Index));

 1456   DenseSet<Instruction *> &HoistStops = IT->second;

 1095     if (std::includes(V1Elems->second.begin(), V1Elems->second.end(),
 1095     if (std::includes(V1Elems->second.begin(), V1Elems->second.end(),
 1096                       V2Elems->second.begin(), V2Elems->second.end())) {
 1096                       V2Elems->second.begin(), V2Elems->second.end())) {
 1098     } else if (std::includes(V2Elems->second.begin(), V2Elems->second.end(),
 1098     } else if (std::includes(V2Elems->second.begin(), V2Elems->second.end(),
 1099                              V1Elems->second.begin(), V1Elems->second.end())) {
 1099                              V1Elems->second.begin(), V1Elems->second.end())) {
 1103     if (V1Elems->second.count(V2))
 1106     if (V2Elems->second.count(V1))
 1148     UnionElems = V1Elems->second;
 1153     UnionElems.insert(V2Elems->second.begin(), V2Elems->second.end());
 1153     UnionElems.insert(V2Elems->second.begin(), V2Elems->second.end());
 1189       return IRB.CreateLoad(DFS.ShadowTy, i->second);
 1333       IRB.CreateStore(Shadow, i->second);
 1552     Function *F = i->second;

  368       return Blocks.find(BB)->second;
  378       Function *F = Blocks.begin()->first->getParent();
  421       Function *F = Blocks.begin()->first->getParent();
  821             const unsigned Edge = It->second;
  837             const unsigned Edge = It->second;

  592   } else if (It->second.NumValueSites[ValueKind] <= Index)
  593     It->second.NumValueSites[ValueKind] = Index + 1;
  599   assert(It != ProfileDataMap.end() && It->second.DataVar &&
  602   GlobalVariable *DataVar = It->second.DataVar;
  606     Index += It->second.NumValueSites[Kind];
  738     if (It->second.RegionCounters)
  739       return It->second.RegionCounters;
  740     PD = It->second;

  226     return Itr->second;

   60       Pair.first->second = Num;
   64     return Vector[Pair.first->second].second;
   72       Pair.first->second = Num;
   76     return std::make_pair(Vector.begin() + Pair.first->second, false);
   83     return Vector.begin() + It->second;
   90     return Vector.begin() + It->second;
  100     Vector[It->second].first = KeyT();

  325     const ColorVector &CV = BlockColors.find(InsertBefore->getParent())->second;
  591       BBSize = I->second;

  732     const ColorVector &CV = BlockColors.find(&BB)->second;
 1137       const BottomUpPtrState &SuccS = BBI->second.getPtrBottomUpState(Arg);
 1280     MyStates.InitFromSucc(I->second);
 1286       MyStates.MergeSucc(I->second);
 1415     MyStates.InitFromPred(I->second);
 1421       MyStates.MergePred(I->second);
 1656         const RRInfo &NewRetainReleaseRRI = Jt->second;
 1721       const RRInfo &NewReleaseRRI = It->second;

  179     return Pair.first->second;

  271         return Iter != end() && Iter->second;

  378       Itr->second = ConstIntCandVec.size() - 1;
  380     ConstIntCandVec[Itr->second].addUser(Inst, Idx, Cost);
  428     Itr->second = ExprCandVec.size() - 1;
  430   ExprCandVec[Itr->second].addUser(Inst, Idx, Cost);

  484     return VI->second;
  561     return VI->second;
  563   return (VI != valueNumbering.end()) ? VI->second : 0;
  603     assert(I->first != V && "Inst still occurs in value numbering map!");
  640       errs() << I->first << "\n";
  641       I->second->dump();
  672     if (IV.first->second == 2)
  673       IV.first->second = 3;
  674     return IV.first->second != 0;
 1597     return FindRes->second;
 2508     const LeaderTableEntry *Node = &I->second;

  349       return It->second;
  622       for (std::pair<VNType, Instruction *> &VI : reverse(it1->second)) {
  641       auto &VCHI = P->second;
  649           if (si != RenameStack.end() && si->second.size() &&
  650               DT->properlyDominates(Pred, si->second.back()->getParent())) {
  652             C.I = si->second.pop_back_val(); // Assign the argument

  426       return VI->second;
  499         e = I->second;
  515     return VI->second;
  652           ->first;

  382     const auto &GuardsInCurBB = GuardsInBlock.find(CurBB)->second;

 1011                : Optional<ConstantRange>(It->second);
 1023       It->second = R.intersectWith(It->second);
 1023       It->second = R.intersectWith(It->second);
 1234   return It->second;

  686       if (Pos->second == FlatAddrSpace)
  709       I->second : Src0->getType()->getPointerAddressSpace();
  713       J->second : Src1->getType()->getPointerAddressSpace();
  735         I->second : PtrOperand->getType()->getPointerAddressSpace();

 1550   BasicBlock *MostPopularDest = DPI->first;
 1551   unsigned Popularity = DPI->second;
 1557     if (DPI->second < Popularity)
 1559     else if (DPI->second == Popularity) {
 1561       SamePopularity.push_back(DPI->first);
 1565       MostPopularDest = DPI->first;
 1566       Popularity = DPI->second;
 1916         IV = I->second;
 2020           New->setOperand(i, I->second);
 2333           New->setOperand(i, I->second);

  709     BranchInst *BI = It->first;
 1343             BlockColors.find(const_cast<BasicBlock *>(BB))->second.size() != 1)
 1379       const ColorVector &CV = BlockColors.find(&ExitBlock)->second;
 1465     New = It->second;
 2170     std::unique_ptr<AliasSetTracker> InnerAST = std::move(MapI->second);
 2215   ASTIt->second->copyValue(From, To);
 2225   ASTIt->second->deleteValue(V);

  378                        << "partitions: " << PartI << ", " << LoadToPart->second
  386             } while (&*PartJ != LoadToPart->second);
  426           Iter->second = -1;

  235     return I->second;
  272         const StoreToLoadForwardingCandidate *&OtherCand = Iter->second;

  301           if (J2I != PossibleRedIdx.end() && J1I->second == J2I->second)
  301           if (J2I != PossibleRedIdx.end() && J1I->second == J2I->second)
 1361             Op2 = BMI->second;

  218     return LoopBlockNumber.find(A)->second < LoopBlockNumber.find(B)->second;
  218     return LoopBlockNumber.find(A)->second < LoopBlockNumber.find(B)->second;
  225     assert(LoopBlockNumber.find(N)->second >
  226                LoopBlockNumber.find(MoveBB)->second &&

  265   RegSortData &RSD = Pair.first->second;
  276   RegSortData &RSD = It->second;
  301   const SmallBitVector &UsedByIndices = I->second.UsedByIndices;
  311   return I->second.UsedByIndices;
 2581     size_t LUIdx = P.first->second;
 2590   P.first->second = LUIdx;
 4114     Pair.first->second.insert(std::make_pair(Imm, Use));
 4124     const ImmMapTy &Imms = Map.find(Reg)->second;
 4372         Formula &Best = LU.Formulae[P.first->second];
 4646       Formula &Best = LU.Formulae[P.first->second];
 5359         PN->setIncomingValue(i, Pair.first->second);
 5374         Pair.first->second = FullV;

  377     const SwitchInst *OldInst = I->first;
  427     return CacheIt->second;

  130     return Insertion.first->second;

  530   auto &Candidates = Pos->second;

 1674     auto *OldClass = LookupResult->second;
 1696       LookupResult->second = NewClass;
 2059     for (const typename Map::mapped_type::value_type Mapped : Result->second)
 2354       place->second = NewClass;
 2381       EClass = lookupResult.first->second;
 2591     return OISIt->second;
 2612       if (!OISIt->second) {

  537         IncorporateWeight(It->second, Weight, Opcode);
  564         Weight = It->second;
  611     APInt Weight = It->second;
  616     It->second = 0;
 2299           if (it->second.isValid())
 2300             Score += it->second.Score;
 2376             assert(res.first->second.isValid() && "WeakVH invalidated");
 2377             ++res.first->second.Score;

 2008     BasicBlock *CurrentIncomingBB = CIVI->second;

  262     return A->second.PredInfo->getPredicateInfoFor(I);
  268     return {A->second.DT, A->second.PDT, DomTreeUpdater::UpdateStrategy::Lazy};
  268     return {A->second.DT, A->second.PDT, DomTreeUpdater::UpdateStrategy::Lazy};
  361       StructValues.push_back(I->second);
  372     return I->second;
  494     LatticeVal &LV = I.first->second;
  514     ValueLatticeElement &LV = PI.first->second;
  532     LatticeVal &LV = I.first->second;
  586     Iter.first->second.insert(U);
  597       for (User *U : Iter->second)
 1074                                     ? V1Param->second
 1079                                     ? V2Param->second
 1139   if (I == TrackedGlobals.end() || I->second.isOverdefined()) return;
 1142   mergeInValue(I->second, GV, getValueState(SI.getOperand(0)));
 1143   if (I->second.isOverdefined())
 1180         mergeInValue(IV, &I, It->second);
 2218     GlobalVariable *GV = I->first;
 2219     assert(!I->second.isOverdefined() &&

  879         AS.Slices[MTPI->second].kill();
  902     unsigned PrevIdx = MTPI->second;
 3731       auto &Offsets = SplitOffsetsMapI->second;
 3765                         auto &LoadOffsets = LoadOffsetsI->second;
 3982       SplitLoads = &SplitLoadsMapI->second;

 1148   auto &Candidates = Pos->second;

  998     return It != DominatingSucc.end() && It->second != UnswitchedSuccBB;
 2049       BasicBlock *ClonedPH = ClonedPHs.begin()->second;
 2064           Case.setSuccessor(ClonedPHs.find(Case.getCaseSuccessor())->second);
 2071             {DominatorTree::Insert, SplitBB, ClonedPHs.find(SuccBB)->second});
 2138     BasicBlock *ClonedPH = ClonedPHs.begin()->second;
 2201     BasicBlock *ClonedPH = ClonedPHs.begin()->second;
 2339     return DTCostIt->second;
 2344       N.begin(), N.end(), BBCostIt->second, [&](int Sum, DomTreeNode *ChildN) {

  229     ++InsertResult.first->second.Count;
  234     int &MatCost = InsertResult.first->second.MatCost;
  439       UserToPNMap.insert({UI, {}}).first->second.push_back(PN);
  466               Cost += CostMapIt->second;
  478         auto &UserPNs = UserPNsIt->second;
  481               int &PNUserCount = PNUserCountMap.find(UserPN)->second;
  496                 SpecCostMap.find(cast<Instruction>(U.getUser()))->second;
  501           int CostSavings = CostSavingsMap.find(PN)->second;
  519             if (CostMapIt->second == 0)
  522             CostMapIt->second = 0;
  531           assert(SpecCostMap.find(SpecI)->second == 0 &&
  540             if (CostMapIt == SpecCostMap.end() || CostMapIt->second == 0)
  542             CostMapIt->second = 0;
  636       auto &SpeculatedVals = InsertResult.first->second;
  648         SpeculatedVals.push_back(IncomingValueMap.find(PredBB)->second);
  672         const auto &SpeculatedVals = MapIt->second;
  707       auto &SpeculatedVals = SpeculatedValueMap.find(OrigI)->second;

  137   IntegerType *BT = IntegerType::get(I->getContext(), BI->second);
  171   QuotRemPair &Value = CacheI->second;

  367     return It->second.count(Addr);

  218     return I != MutatedMemory.end() ? I->second : nullptr;

  758   return cmpNumbers(LeftSN.first->second, RightSN.first->second);
  758   return cmpNumbers(LeftSN.first->second, RightSN.first->second);

  306           GO.setComdat(Replacement->second);

  272             Value *ChildUnwindDestToken = Memo->second;
  310           ChildUnwindDestToken = Memo->second;
  390     return Memo->second;
  428       UnwindDestToken = AncestorMemo->second;
  456     if (Memo != MemoMap.end() && Memo->second) {
  464       assert(getParentPad(Memo->second) == getParentPad(UselessPad));

  835             IncomingValues.find(BB)->second == OldVal) &&
  843   if (It != IncomingValues.end()) return It->second;
  883     PN->setIncomingValue(i, It->second);
 2964     return I->second;

  134     return I->second;

  239             MDNode::get(Context, GroupToScope[Group->second])));
  242     auto NonAliasingScopeList = GroupToNonAliasingScopeList.find(Group->second);
  248               NonAliasingScopeList->second));

  208     if (CI->second > 0) {
  209       CI->second -= 1;

  729     return ValueInfos[InsertResult.first->second];
  731   return ValueInfos[OIN->second];

  204       return It->second;
  217     return It->second;
  621       return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
  621       return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
  691       PHINode *PN = I->second;
  716     PHINode *SomePHI = I->second;
  734       return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
  734       return BBNumbers.find(A)->second < BBNumbers.find(B)->second;
  944       Value *V = IncomingVals[AI->second];
  968       unsigned AllocaNo = ai->second;
  973       for (DbgVariableIntrinsic *DII : AllocaDbgDeclares[ai->second])

   68   return (AVI != getAvailableVals(AV).end()) ? AVI->second : nullptr;
  477         NewVal = RLI->second;

 2036     if (I->first->hasNUses(I->second)) {
 2036     if (I->first->hasNUses(I->second)) {
 2250           *i = PI->second;

  586   auto &OpD = Where->second;
  688             return Where != Info.end() && Where->second.HasChanged;

 1044     return Scalars->second.find(I) != Scalars->second.end();
 1044     return Scalars->second.find(I) != Scalars->second.end();
 1060     return UniformsPerVF->second.find(I) != UniformsPerVF->second.end();
 1060     return UniformsPerVF->second.find(I) != UniformsPerVF->second.end();
 1076     return ScalarsPerVF->second.find(I) != ScalarsPerVF->second.end();
 1076     return ScalarsPerVF->second.find(I) != ScalarsPerVF->second.end();
 1137     return Itr->second.first;
 4477     for (auto *I : ForcedScalar->second)
 5895     auto InstSet = ForcedScalar->second;
 6649     return ECEntryIt->second;
 6678     return BCEntryIt->second;
 7147           Ingredients.push_back(SinkCandidate->second);
 7156         LLVM_DEBUG(dbgs() << "Sinking" << *SAIt->first << " after"
 7157                           << *SAIt->second
 7159         SinkAfterInverse[SAIt->second] = Instr;
 7169         Ingredients.push_back(SAInvIt->second);

  585         I->getSecond() <= NumOpsWantToKeepOriginalOrder)
  588     return makeArrayRef(I->getFirst());
 1442       return I->second;
 1449       return I->second;
 1512     It->getSecond() = It->getSecond() && ReplaceOpsWithUndef;
 1512     It->getSecond() = It->getSecond() && ReplaceOpsWithUndef;
 1717         ScheduleData *SD = I->second[Key];
 1801         for (auto &P : I->second)
 2276     ReuseShuffleIndicies.emplace_back(Res.first->second);
 2381         ++StoredCurrentOrderAndNum->getSecond();
 2384                      StoredCurrentOrderAndNum->getFirst());
 2462             ++I->getSecond();
 2465                              ReuseShuffleIndicies, I->getFirst());
 3687       ReuseShuffleIndicies.emplace_back(Res.first->second);

 1589       return InterleaveGroupMap.find(Instr)->second;

  113     return BlockIt->second;
  170     return VPValIt->second;

  379     return I->second;

   86   It->second.push_back({CurrentBlock.ProcessID, CurrentBlock.ThreadID,

  127         return R->second;

  138   for (auto Node = It->second; Node; Node = Node->Caller)
  213         std::tie(PathDataIt, Inserted) = It->second->insert({NewPathID, Data});
  215           auto &ExistingData = PathDataIt->second;
  248           auto &ExistingData = PathDataIt->second;

  994     return MergedIt->second;

  190         return Pos != Aux.end() && Pos->second > 1;
  395       auto *FromD = dyn_cast<DeclT>(FromI->second);

   70       return Pos->second;

   43   DeclarationName getLookupName() const { return It->first; }
   45   reference operator*() const { return It->second.getLookupResult(); }
   46   pointer operator->() const { return It->second.getLookupResult(); }
   55              It->first == DeclarationName::getUsingDirectiveName());

   82     return Result.first->second;
   88     return Result.first->second;

  273     return AddressPoints.find(Base)->second;
  341     return &I->second;

  247     return It->second;

  402       return I->second;
  422     const RetainSummary *Summ = I->second;
  435     return I == M.end() ? nullptr : I->second;

   31     return I->second;
   47   return I->second;

  600     return &I->second;

 1031     auto *MD = J->second.getLatest();
 1123       return I->second;

  705     return Captures[Known->second - 1];

  341         const Decl *D = I->first;
  344         if (I->second.is<Decl *>()) {
  345           Stored = I->second.get<Decl *>();
  347           DeclArgumentPack *OldPack = I->second.get<DeclArgumentPack *>();

 1238     if (I == KeyDecls.end() || I->second.empty())
 1240     return GetExistingDecl(I->second[0]);
 1255       for (auto ID : It->second)

  623             I->second >= serialization::NUM_PREDEF_DECL_IDS);

  569     const EventInfo &info = I->second;

   75     I->second.InlineChecked = 1;
   76     I->second.MayInline = 1;
   81     I->second.InlineChecked = 1;
   82     I->second.MayInline = 0;
   91     if (I != Map.end() && I->second.InlineChecked)
   92       return I->second.MayInline;
   98     llvm::SmallBitVector &Blocks = I->second.VisitedBasicBlocks;
  102       I->second.TotalBasicBlocks = TotalIDs;
  110       return I->second.VisitedBasicBlocks.count();
  117       return I->second.TimesInlined;
  123     I->second.TimesInlined++;
  130         return ((I->second.VisitedBasicBlocks.count() * 100) /
  131                  I->second.TotalBasicBlocks);

  337       return I->second;

   33     resetTarget(I->second);
  131     const FileEntry *origFE = I->first;
  137     if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
  151       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
  173     const FileEntry *origFE = I->first;
  174     assert(I->second.is<llvm::MemoryBuffer *>());
  184     llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
  196     if (const FileEntry *FE = I->second.dyn_cast<const FileEntry *>()) {
  197       PPOpts.addRemappedFile(I->first->getName(), FE->getName());
  199       llvm::MemoryBuffer *mem = I->second.get<llvm::MemoryBuffer *>();
  200       PPOpts.addRemappedFile(I->first->getName(), mem);
  237     file = I->second;

 2273     std::string TempFile = applyEditsToTemp(I->first, I->second,
 2273     std::string TempFile = applyEditsToTemp(I->first, I->second,
 2280     remap.emplace_back(I->first->getName(), TempFile);

  317     SourceLocation AtLoc = SourceLocation::getFromRawEncoding(I->first);
  318     IndivPropsTy &IndProps = I->second;

   60       ObjCPropertyDecl *PropDecl = P->first;
  177         ObjCPropertyImplDecl *PropImpDecl = P->second;

  382       return DeclComment->second;
  395         *OriginalDecl = RedeclComment->second;
  396       auto CommentAtRedecl = DeclRawComments.find(RedeclComment->second);
  399       return CommentAtRedecl->second;
  408       return LookupRes->second;
  541       comments::FullComment *FC = Pos->second;
  545     return Pos->second;
  863     if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
  869     if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
  876     A->second->~AttrVec();
  928     if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
  931     return getSingleDynTypedNodeFromParentMap(I->second);
 1049   auto &Merged = It->second;
 1085     auto &Imported = *It->second;
 1113   auto *Inits = It->second;
 1408     Pos->second->~AttrVec();
 1428   return Pos->second;
 1455   return Pos->second;
 1479   return Pos->second;
 1495   return Pos->second;
 1530   return overridden_method_range(Pos->second.begin(), Pos->second.end());
 1530   return overridden_method_range(Pos->second.begin(), Pos->second.end());
 1784     return I->second;
 2216     return I->second;
 2604     return cast<ObjCImplementationDecl>(I->second);
 2614     return cast<ObjCCategoryImplDecl>(I->second);
 2664     return I->second;
 8455       LHS = KnownLHS->second;
10324   return I->second;

 7877     return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
 7920     return Pos->second;
 7929   return FromDPos->second->getTranslationUnitDecl();
 7973       auto *ToD = Pos->second;
 8006       SharedState->setImportDeclError(Pos->second, ErrOut);
 8017           SharedState->setImportDeclError(Ii->second, ErrOut);
 8132     return Pos->second;
 8415     return Pos->second;
 8564     return Pos->second;
 8763   assert((Pos == ImportedDecls.end() || Pos->second == To) &&
 8766     return Pos->second;
 8779     return Pos->second;
 8789   assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);

  108   const auto &FoundNameMap = DCI->second;
  113   return NamesI->second;
  120   const auto &FoundNameMap = DCI->second;

  727     delete VO->second;

   94     return &It->second;
   98       return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
  132       return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;

 1487         StoredDeclsList::DeclsTy *Vec = Pos->second.getAsVector();
 1488         if ((Vec && is_contained(*Vec, ND)) || Pos->second.getAsDecl() == ND)
 1489           Pos->second.remove(ND);
 1644     if (!R.second && !R.first->second.hasExternalDecls())
 1645       return R.first->second.getLookupResult();
 1651           return I->second.getLookupResult();
 1670   return I->second.getLookupResult();
 1689   return I != Map->end() ? I->second.getLookupResult()
 1726                        Pos->second.getLookupResult().begin(),
 1727                        Pos->second.getLookupResult().end());

  192       return It->second;

   92     for (unsigned Reloc : It->second) {
  111     return It->second - Position;

  288     unsigned Idx = It->second;
  330     const auto &L = It->second;

  202   S.Stk.push<Pointer>(reinterpret_cast<Block *>(It->second.get()));
  215   auto *B = reinterpret_cast<Block *>(It->second.get());
  229   auto *B = reinterpret_cast<Block *>(It->second.get());
  241     S.deallocate(reinterpret_cast<Block *>(It->second.get()));

   31   return It->second;

  165     return Pointer(reinterpret_cast<Block *>(Pt->second.get()));

   84       return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();

   90     return It->second;
   97       Index = It->second;
  132     return It->second;
  191   return It == Funcs.end() ? nullptr : It->second.get();
  216     return It->second;

   33   return It->second;
   39   return It->second;
   45   return It->second;

  917     if (It->second < 10)
  918       Out << '_' << static_cast<char>('0' + It->second);
  920       Out << 'W' << (It->second - 10) << '_';
 4708   unsigned SeqID = I->second;

   98     return Iter->second;

  240     return Result.first->second;
  849         Out << Found->second << '@'; // Outputs a StringRef.
  852       Out << Found->second; // Outputs a back reference (an int).
 1789     Out << Found->second;
 1812     Out << Found->second;

   49   ID.AddInteger(Result.first->second);

  137   return I == M->end() ? nullptr : I->second;

  333   return &CommentsInFile->second;
  342     return Cached->second;
  351     return Cached->second;

   89     BaseOffset = Known->second;
   97     BaseOffset = Known->second;
  241   const ClassVectorTy &Classes = I->second;
 3151   LazyDeclPtr Ptr = I->second;
 3397       if (VtorDisps.find(VBase)->second.hasVtorDisp()) {

 2227     return I->second;
 2235   return I->second;
 2246     return I->second;
 2263   return I->second;
 2825   if (!VBaseMapEntry->second.hasVtorDisp() ||
 2831   CharUnits OffsetOfVBaseWithVFPtr = VBaseMapEntry->second.VBaseOffset;
 2878         Groups[J->second].push_back(MD->getCanonicalDecl());
 2972       MethodInfo &OverriddenMethodInfo = OverriddenMDIterator->second;
 3589         MethodVFTableLocation &OldLoc = Insert.first->second;
 3704   return VBInfo.VBTableIndices.find(VBase)->second;
 3741     return I->second;
 3749   return I->second;

  566         it != MatcherFiltersMap.end() ? it->second : getFilterForKind(Kind);
  767     for (const TypedefNameDecl *Alias : Aliases->second) {
  784     for (const ObjCCompatibleAliasDecl *Alias : Aliases->second) {

  197   return itr->second;
  209     PM.setParent(I->first, PM.getParent(I->second));
  209     PM.setParent(I->first, PM.getParent(I->second));

 1188           return I->second; // already in map;
 1556       JumpTarget JT = LI->second;
 1574         JumpTarget JT = LI->second;
 1595       addSuccessor(B, LI->second.block);
 3252     JumpTarget JT = I->second;
 5143     if (currentBlock >= 0 && I->second.first == (unsigned) currentBlock
 5144                           && I->second.second == currStmt) {
 5148     OS << "[B" << I->second.first << "." << I->second.second << "]";
 5148     OS << "[B" << I->second.first << "." << I->second.second << "]";
 5158     if (currentBlock >= 0 && I->second.first == (unsigned) currentBlock
 5159                           && I->second.second == currStmt) {
 5163     OS << "[B" << I->second.first << "." << I->second.second << "]";
 5163     OS << "[B" << I->second.first << "." << I->second.second << "]";

   35       CFGBlock *B = I->second;

  196   return I->second.get();

  523       return Entry->second;
  539     insertInfo(To, Entry->second);
  548     PropagationInfo& PInfo = Entry->second;
  561     PropagationInfo& PInfo = Entry->second;
  571     PropagationInfo& PInfo = Entry->second;
  628     if (Entry == PropagationMap.end() || Entry->second.isTest())
  630     PropagationInfo PInfo = Entry->second;
  643     if (!(Entry->second.isVar() || Entry->second.isTmp()))
  643     if (!(Entry->second.isVar() || Entry->second.isTmp()))
  663     PropagationInfo PInfo = Entry->second;
  710     if (LEntry != PropagationMap.end() && LEntry->second.isVarTest()) {
  711       LTest = LEntry->second.getVarTest();
  717     if (REntry != PropagationMap.end() && REntry->second.isVarTest()) {
  718       RTest = REntry->second.getVarTest();
  765   if (Entry != PropagationMap.end() && !Entry->second.isTest()) {
  766     StateMap->setState(Temp, Entry->second.getAsState(StateMap));
  883       ConsumedState RetState = Entry->second.getAsState(StateMap);
  902     PropagationMap.insert(PairType(UOp, Entry->second));
  906     if (Entry->second.isTest())
  907       PropagationMap.insert(PairType(UOp, Entry->second.invertTest()));
  921         PropagationInfo PInfo = VIT->second;
 1117     return Entry->second;
 1127     return Entry->second;

  126     return Memoized->second;
  456     return Memoized->second;

  627     vec.push_back(it->first);

   46   unsigned b1V = (b1It == POV.BlockOrder.end()) ? 0 : b1It->second;
   47   unsigned b2V = (b2It == POV.BlockOrder.end()) ? 0 : b2It->second;

  539     return I->second;

 1132     Info = It->second.get();

   74     return It->second;
  652     assert(CurrentLVarMap[It->second].first == VD);
  653     return CurrentLVarMap[It->second].second;
  687   CurrentLVarMap.elem(It->second).second = E;

   92   return I->second;
  361       return I->second;

  219     Result.first->second = GetDefaultDiagMapping(Diag);
  221   return Result.first->second;

  551     return Known->second;

  367     if (I->second) {
  368       I->second->~ContentCache();
  369       ContentCacheAlloc.Deallocate(I->second);
  443                                                               : overI->second,
  444                                overI->second);
 1878   DecompTy &DecompLoc = InsertOp.first->second;
 1932     return I->second;
 2065     NumLineNumsComputed += I->second->SourceLineCache != nullptr;
 2066     NumFileBytesMapped  += I->second->getSizeBytesMapped();

 1072         src = I->second;
 1323   if (capture.isConstant()) return LocalDeclMap.find(variable)->second;
 1532     const auto *var = dyn_cast<VarDecl>(i->first);
 1534       setAddrOfLocalVar(var, i->second);
 1662           auto addr = LocalDeclMap.find(variable)->second;
 2733     return it->second;
 2813   return pair.first->second;

  277     return it->second;

  588       const ImplicitParamDecl *D = Iter->second;
  592       return EmitLoadOfScalar(DIter->second, /*Volatile=*/false,

  365       SavedLocals.insert({ PD, it->second });
  369       it->second = copyIt->getSecond();
  369       it->second = copyIt->getSecond();

  212     llvm::Metadata *V = I->second;
  423     if (llvm::Metadata *V = It->second)
 1440           assert(MI->second &&
 1442           elements.push_back(MI->second);
 1678                          : static_cast<llvm::Metadata *>(MI->second));
 2070   if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
 2145   if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
 2376     return cast<llvm::DIModule>(ModRef->second);
 2617     Subscript = DBuilder.getOrCreateSubrange(0, SizeExpr->getSecond());
 2679           DBuilder.getOrCreateSubrange(0, SizeNode->getSecond()));
 2921     if (llvm::Metadata *V = It->second)
 3412     auto N = I->second;
 3447     auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
 3455       auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
 3560       auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
 3640             cast<llvm::DICompositeType>(It->second);
 3737     SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
 4345     assert(MI->second && "Static data member declaration should still exist");
 4346     return MI->second;
 4392         cast<llvm::DIGlobalVariableExpression>(Cached->second));
 4625     return cast<llvm::DINamespace>(I->second);
 4657       auto *DIParm = cast<llvm::DILocalVariable>(I->second);
 4685           cast<llvm::DICompositeType>(It->second);
 4704     assert(It->second);
 4707                               cast<llvm::DIType>(It->second));
 4722       Repl = It->second;

  439     LocalDeclMap.find(&D)->second = Address(castedAddr, alignment);

  451   if (I != DelayedCXXInitPosition.end() && I->second == ~0U)
  514     } else if (I->second != ~0U) {
  515       assert(I->second < CXXGlobalInits.size() &&
  516              CXXGlobalInits[I->second] == nullptr);
  517       CXXGlobalInits[I->second] = Fn;

 1721     int FrameEscapeIdx = InsertPair.first->second;
 1816     Address ParentVar = I->second;

  915   const ImplicitParamDecl *PassedSizeDecl = PassedSizeIt->second;
  917   Address AddrOfSize = LocalDeclMap.find(PassedSizeDecl)->second;
 2572             return EmitLoadOfReferenceLValue(I->second, VD->getType(),
 2574           return MakeAddrLValue(I->second, T);
 2614       addr = iter->second;
 4464     return it->second;
 4478     return it->second;

 1516           setLocation(it->second);

 5152     return I->second;

 1434     return I->second;
 1640     LocValue = Address(I->second.DebugLoc, Align);
 1695     ThreadID = I->second.ThreadID;
 1755     for(auto *D : I->second)
 3932   auto PerFile = PerDevice->second.find(FileID);
 3933   if (PerFile == PerDevice->second.end())
 3935   auto PerParentName = PerFile->second.find(ParentName);
 3936   if (PerParentName == PerFile->second.end())
 3942   if (PerLine->second.getAddress() || PerLine->second.getID())
 3942   if (PerLine->second.getAddress() || PerLine->second.getID())
 4106           if (I->getFirst()->getUniqueID().getDevice() == DeviceID &&
 4107               I->getFirst()->getUniqueID().getFile() == FileID) {
 4109                 I->getFirst(), Line, 1);
 8201       LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);
 8203         LValue VarLValVal = CGF.EmitLValueForField(VDLVal, It->second);
 8501         IsImplicit = I->getSecond();
 8538         IsImplicit = I->getSecond();

  598     return I->getSecond();
 2077         I->getSecond().GlobalRecord = GlobalizedRD;
 2078         I->getSecond().MappedParams =
 2080         DeclToAddrMapTy &Data = I->getSecond().LocalVarData;
 2120   if (const RecordDecl *GlobalizedVarsRecord = I->getSecond().GlobalRecord) {
 2144       if (I->getSecond().SecondaryGlobalRecord.hasValue()) {
 2166               I->getSecond().SecondaryGlobalRecord.getValueOr(nullptr)) {
 2198       I->getSecond().GlobalRecordAddr = Phi;
 2199       I->getSecond().IsInSPMDModeFlag = IsSPMD;
 2266       I->getSecond().GlobalRecordAddr = GlobalRecValue;
 2267       I->getSecond().IsInSPMDModeFlag = nullptr;
 2282       I->getSecond().GlobalRecordAddr = GlobalRecValue;
 2283       I->getSecond().IsInSPMDModeFlag = nullptr;
 2291     decltype(I->getSecond().LocalVarData)::const_iterator SecIt;
 2293       SecIt = I->getSecond().SecondaryLocalVarData->begin();
 2298               I->getSecond().GlobalRecordAddr, SecGlobalRecPtrTy),
 2301     for (auto &Rec : I->getSecond().LocalVarData) {
 2302       bool EscapedParam = I->getSecond().EscapedParameters.count(Rec.first);
 2329         assert(I->getSecond().IsInSPMDModeFlag &&
 2344             Bld.CreateSelect(I->getSecond().IsInSPMDModeFlag,
 2351         I->getSecond().MappedParams->setVarAddr(CGF, VD, VarAddr.getAddress());
 2357   for (const ValueDecl *VD : I->getSecond().EscapedVariableLengthDecls) {
 2384     I->getSecond().MappedParams->setVarAddr(CGF, cast<VarDecl>(VD),
 2386     I->getSecond().EscapedVariableLengthDeclsAddrs.emplace_back(GlobalRecValue);
 2388   I->getSecond().MappedParams->apply(CGF);
 2399     I->getSecond().MappedParams->restore(CGF);
 2403          llvm::reverse(I->getSecond().EscapedVariableLengthDeclsAddrs)) {
 2408     if (I->getSecond().GlobalRecordAddr) {
 2415         Bld.CreateCondBr(I->getSecond().IsInSPMDModeFlag, ExitBB, NonSPMDBB);
 2422             CGF.EmitCastToVoidPtr(I->getSecond().GlobalRecordAddr));
 2449                             I->getSecond().GlobalRecordAddr);
 4692   I->getSecond().MappedParams =
 4694   I->getSecond().GlobalRecord = GlobalizedVarsRecord;
 4695   I->getSecond().EscapedParameters.insert(
 4698   I->getSecond().EscapedVariableLengthDecls.append(
 4700   DeclToAddrMapTy &Data = I->getSecond().LocalVarData;
 4709     I->getSecond().SecondaryGlobalRecord =
 4711     I->getSecond().SecondaryLocalVarData.emplace();
 4712     DeclToAddrMapTy &Data = I->getSecond().SecondaryLocalVarData.getValue();
 4795   auto VDI = I->getSecond().LocalVarData.find(VD);
 4796   if (VDI != I->getSecond().LocalVarData.end())
 4802       auto VDI = I->getSecond().LocalVarData.find(
 4805       if (VDI != I->getSecond().LocalVarData.end())
 4886       LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);

  209     return it->second;

  548     if (Layout.getVBaseOffsetsMap().find(BaseDecl)->second.hasVtorDisp())
  874     const RecordDecl *RD = it->first->getParent();
  877            it2 = RD->field_begin(); *it2 != it->first; ++it2)
  879     BFIs.push_back(std::make_pair(Index, &it->second));

  578     JumpDest &dest = CGF.LabelMap.find(*i)->second;

  620         CallArg = EI->second.second;
 4674       Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy);

  135     return I->second;
  143     BaseSubobjectPairTy ClassSubobjectPair(RD, I->first);
  145     SubVTTIndicies.insert(std::make_pair(ClassSubobjectPair, I->second));
  151   return I->second;
  161     return I->second;
  170       std::make_pair(RD, I->first);
  172     SecondaryVirtualPointerIndices.insert(std::make_pair(Pair, I->second));
  178   return I->second;

  847         SavedLocals.try_emplace(LocalVD, it->second);
  892           I->second = Pair.second;
 2365     return it->second;

   68     return I->second;

  104   return I != RecordDeclTypes.end() && !I->second->isOpaque();
  394     return TCI->second;

  266       return Mapping->second.first;
 1465     return It->second;

 1181     if (!I->second.hasVtorDisp())
 1186     uint64_t ConstantVBaseOffset = I->second.VBaseOffset.getQuantity();
 1643       Offset = VBI->second.VBaseOffset;
 1730     return I->second;
 1732   llvm::GlobalVariable *&VTable = I->second;
 1946   VBTableGlobals &VBGlobals = Entry->second;
 3717       ->second.hasVtorDisp())

  555     return *I->second;
  579   FileID FromID = I->second.first;
  580   clang::ASTUnit *Unit = I->second.second;

   87         find_if(I->second, [&](const MacroArgUse &U) {
   91         }) != I->second.end()) {

 2467   LocDeclsTy &LocDecls = *I->second;

 1645     Module = Known->second;

  130     for (unsigned I = 0, N = F->second.size(); I != N; ++I) {
  132       writeNodeReference(OS, F->first);
  134       writeNodeReference(OS, F->second[I]);

  840     auto *MD = I->second.getLatest();
  842       MacrosByID.push_back(id_macro_pair(I->first, MD->getMacroInfo()));

  772       Out << 'S' << Substitution->second << '_';

 1533     return AddResult.first->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;
 1612     return KnownDir->second ? LMM_AlreadyLoaded : LMM_InvalidModuleMap;

  423       return KnownHeader(KnownDir->second, NormalHeader);
  489     for (const KnownHeader &Header : Known->second) {
  576     for (KnownHeader &H : Known->second) {
  667   return It->second;
  681              I = Known->second.begin(),
  682              E = Known->second.end();
  716       Module *Found = KnownDir->second;
  967         if (inferred->second.InferModules) {
  971           canInfer = std::find(inferred->second.ExcludedModules.begin(),
  972                                inferred->second.ExcludedModules.end(),
  973                                Name) == inferred->second.ExcludedModules.end();
  975           Attrs.IsSystem |= inferred->second.Attrs.IsSystem;
  976           Attrs.IsExternC |= inferred->second.Attrs.IsExternC;
  977           Attrs.IsExhaustive |= inferred->second.Attrs.IsExhaustive;
  979               inferred->second.Attrs.NoUndeclaredIncludes;
  980           ModuleMapFile = inferred->second.ModuleMapFile;
 1162     for (auto *M : BySize->second)
 1169     for (auto *M : ByModTime->second)
 1235     return InferredModuleAllowedBy.find(M)->second;
 1255     llvm::errs() << "  \"" << H->first->getName() << "\" -> ";
 1256     for (SmallVectorImpl<KnownHeader>::const_iterator I = H->second.begin(),
 1257                                                       E = H->second.end();
 1259       if (I != H->second.begin())
 2972     return Known->second;

  387   const PreprocessorSkippedRangeMapping &SkippedRanges = *It->getSecond();
  393   unsigned BytesToSkip = MappingIt->getSecond();

  759     auto &Macro = MacroIt->second;
  774         OldMD = OldMacroIt->second.getLatest();

   65                                                 : Pos->second.getLatest();
  202   for (auto *LeafMM : Leaf->second) {
  261     Leaf = LeafIt->second;
  265     State = &Pos->second;

  643     MacroInfo *MacroToReInstall = iter->second.back();
  650     iter->second.pop_back();
  651     if (iter->second.empty())

  389   return Pos->second;

  358       Def = I->second.findDirectiveAtLoc(Loc, SourceMgr);
  371       BestSpelling = I->first->getName();
  756     Diag(Identifier,it->second) << Identifier.getIdentifierInfo();

  951           Tok.setKind(Known->second);

 1361     const WeakUseVector &Uses = I->second;
 1388         const WeakObjectProfileTy &Profile = I->first;
 1441     const WeakObjectProfileTy &Key = P.second->first;
 1442     const WeakUseVector &Uses = P.second->second;

  729     unsigned TargetScope = TI->first;
  730     LabelDecl *TargetLabel = TI->second;

  212       llvm::find(llvm::reverse(Uses->second), WeakUseTy(E, true));
  213   if (ThisUse == Uses->second.rend())

  782     return Cache->second;
  825     return Cache->second;
 1402         S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
 1403     Builder << FnIt->second.FD;
 1406     FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
 1417   for (PartialDiagnosticAt &PDAt : It->second) {
 1554          CGIt->second) {
 2236   for (auto const& I : Loc->second) {
 2249   for (auto &I : Loc->second) {
 2265   for (auto &I : Loc->second) {

  685             << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
  705           It->second != Rule) {
  708             It->second.second.getBegin(),
  712                    attr::SubjectMatchRule(It->second.first))
  715                    replacementRangeForListElement(*this, It->second.second));

14500   TypeInfo = I->second;

 1089     I = NamePos->second.begin();
 1090     IEnd = NamePos->second.end();
 1114       I = NamePos->second.begin();
 1115       IEnd = NamePos->second.end();
 3846     auto MD = PP.getMacroDefinition(M->first);
 3853           Result(M->first, MI,
 3854                  getMacroUsagePriority(M->first->getName(), PP.getLangOpts(),
 6786       for (ObjCMethodList *MethList = &M->second.second;
 6958       for (ObjCMethodList *MethList = &M->second.first;
 7034     Selector Sel = M->first;
 8204     ObjCMethodDecl *Method = M->second.getPointer();
 8286     if (!M->second.getInt())
 8301       KnownSelectors.insert(M->first);
 8355     for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first
 8356                                                      : &M->second.second;
 8588           Builder.getAllocator().CopyString(M->first->getName()));

 1912       if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
 7027         NewVD->addAttr(I->second);
 7407   const NamedDecl *ShadowedDecl = I->second;
 8932         NewFD->addAttr(I->second);
17324   llvm::APInt &FlagBits = R.first->second;

  285     for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
  286       InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
 6633     if (It->second)
 6635           S.findInheritingConstructor(UseLoc, Ctor, It->second),
 6636           It->second->constructsVirtualBase());
12777                 .first->second;
15576       if (!Pos->second && VTables[I].DefinitionRequired)
15577         Pos->second = true;
15614     if (DefinitionRequired && !Pos.first->second) {
15615       Pos.first->second = true;

  789         << SourceRange(known->second->getLocation());
 3413   ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
 3413   ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
 3483   ObjCMethodList &MethList = InstanceFirst ? Pos->second.first :
 3484                              Pos->second.second;
 3499   ObjCMethodList &MethList2 = InstanceFirst ? Pos->second.second :
 3500                               Pos->second.first;
 3531     BestMethod->isInstanceMethod() ? Pos->second.first : Pos->second.second;
 3531     BestMethod->isInstanceMethod() ? Pos->second.first : Pos->second.second;
 3546   ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
 3546   ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
 3614   GlobalMethods &Methods = Pos->second;
 3689     for (ObjCMethodList *M = &b->second.first; M; M=M->getNext())
 3701     for (ObjCMethodList *M = &b->second.second; M; M=M->getNext())
 4194       method->isInstanceMethod() ? it->second.first : it->second.second;
 4194       method->isInstanceMethod() ? it->second.first : it->second.second;
 4349             ObjCMethod->isInstanceMethod()? It->second.first: It->second.second;
 4349             ObjCMethod->isInstanceMethod()? It->second.first: It->second.second;

  222       for (const PartialDiagnosticAt &Suppressed : Pos->second)
  229       Pos->second.clear();

 1164     ObjCMethodList &InstMethList = b->second.first;
 1170     ObjCMethodList &ClsMethList = b->second.second;

  534         ExistingI = UniqueResult.first->second;
  544         ExistingI = UniqueResult.first->second;
 3676     for (auto *D : Pos->second) {
 4835       locs->second.count(TypoName.getLoc()))

 2065     ObjCPropertyDecl *Prop = P->second;
 2125     const ObjCPropertyDecl *Property = I->second;

  753              MI->second.Components)
  754           if (Check(L, MI->second.Kind))
  775            MI->second.Components)
  776         if (Check(L, MI->second.Kind))
 1022   assert(It->second && "Unexpected nullptr expr in the aligned map");
 1023   return It->second;
 1041     return It->second;
 1052     return It->second;
 1295     DVar.RefExpr = TI->getSecond().RefExpr.getPointer();
 1344             isOpenMPPrivate(DSAIter->getSecond().Attributes)) {
 1345           DVar.RefExpr = DSAIter->getSecond().RefExpr.getPointer();
 1382       const DSAInfo &Data = It->getSecond();
 1428     const DSAInfo &Data = It->getSecond();
 1504       I->getSecond().RefExpr.getPointer() &&
 1505       CPred(I->getSecond().Attributes) &&
 1506       (!NotLastprivate || !I->getSecond().RefExpr.getInt()))
15641       Diag(I->second, diag::note_previous_definition);
15892     Diag(I->second, diag::note_previous_definition);

 4044         FoundHandler = I->second;
 4137       const CXXCatchStmt *Problem = R.first->second;

 3005         return &Found->second;

  307       return FoundLoc->second;

  431       return Known->second;

 3972   ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
 3973                                                     : Known->second.second;
 7897   return GlobalID - Owner->BaseDeclID + Pos->second;
 7969       Visit(I->second.first, I->second.second);
 7969       Visit(I->second.first, I->second.second);
 8017   FileDeclsInfo &DInfo = I->second;
 8065   for (DeclID ID : It->second.Table.find(Name)) {
 8086   for (DeclID ID : It->second.Table.findAll()) {
 8094     SetExternalVisibleDeclsForName(DC, I->first, I->second);
 8094     SetExternalVisibleDeclsForName(DC, I->first, I->second);
 8102   return I == Lookups.end() ? nullptr : &I->second;
 8618   Pos->second.first.setBits(Visitor.getInstanceBits());
 8619   Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
 8620   Pos->second.second.setBits(Visitor.getFactoryBits());
 8621   Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
 8626   addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
 8627   addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
 9058   return I->second ? EK_Never : EK_Always;
 9904       IdentifierInfo *II = TLD->first;
 9905       for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
 9906         pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);

 1740       PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
 1744     PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
 3305       if (isSameEntity(It->second, D))
 3306         return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
 3373       MergedDCIt->second == D->getDeclContext())
 3972     auto UpdateOffsets = std::move(UpdI->second);
 4035     auto VisibleUpdates = std::move(I->second);

 2339           Record.push_back(FDI->second->FirstDeclIndex);
 2340           Record.push_back(FDI->second->DeclIDs.size());
 2822     return Known->second;
 3469         Data.Instance = F->second.first;
 3470         Data.Factory = F->second.second;
 5669     return I->second;
 5821   return It->second;

 2406     Record.push_back(I->second);

  303   ArrayRef<unsigned> StoredDependencies = Modules[Known->second].Dependencies;

   66   return Known->second;

  243         Result = It->second;

  258     Arg = I->second;

  108       if (MI == IMeths.end() || MI->second == nullptr)
  112       ObjCMethodDecl *MethDerived = MI->second;
  113       MI->second = nullptr;

  178       const ObjCPropertyDecl *PD = I->second;

  323     const ObjCIvarDecl *Iv = I->first;
  387     const ObjCPropertyDecl *PD = I->second;
  507         reportIvarNeedsInvalidation(I->first, IvarToPopertyMap, D);
  518         reportIvarNeedsInvalidation(I->first, IvarToPopertyMap, nullptr);
  584     if (!InvalidationMethod || I->second.hasMethod(InvalidationMethod))
  611       markInvalidated(IvI->second);
  624         markInvalidated(IvI->second);
  635         markInvalidated(IvI->second);
  707       markInvalidated(IvI->second);

  789   auto argumentIterator = method->getSecond().find(S);
  791   if (argumentIterator == method->getSecond().end())
  794   int argumentNumber = argumentIterator->getSecond();

   40       I->second = Used;
   74     I->second = Used;
  138     if (I->second == Unused) {
  156     if (I->second == Unused) {
  159       os << "Instance variable '" << *I->first << "' in class '" << *ID
  164         PathDiagnosticLocation::create(I->first, BR.getSourceManager());

  149     return LCM.find(&PD->getActivePath())->getSecond();
  179     return LCM.find(Path)->getSecond();
 2005     assert(!EndNotes->second.empty());
 2006     LastPiece = EndNotes->second[0];
 2028     for (const PathDiagnosticPieceRef &Note : VisitorNotes->second) {
 2192       Result.first->getSecond() = bugreporter::TrackingKind::Thorough;
 2273   return It->getSecond();
 2284     return It->getSecond();
 2466       return Descending ? LI->second > RI->second
 2466       return Descending ? LI->second > RI->second
 2467                         : LI->second < RI->second;
 2467                         : LI->second < RI->second;
 2533       assert(PriorityEntry->second <= Priority);

   84     checkers = &(CCI->second);
  896     return CCI->second;

  520       NewN->addPredecessor(const_cast<ExplodedNode *>(PI->second), *G);
  531         const_cast<ExplodedNode *>(PI->second)->addPredecessor(NewN, *G);

 1603     return I->second & IK;
 1618     return I->second & IK;

   91     I->second.second(I->second.first);
   91     I->second.second(I->second.first);

 2055     return I->second;

 1276         return I->second;
 1308         return I->second;

  371     dependencies = I->second;
  381   return I->second;
  388   if (LI->second == HaveMarkedDependents)
  390   LI->second = HaveMarkedDependents;

  132   const MarkedFile &File = FileIt->second;
  160   return It->second.SpelledTokens;
  192   const MarkedFile &File = Files.find(FID)->second;
  216   auto &File = FileIt->second;
  239   auto &File = FileIt->second;
  443       TokenBuffer::MarkedFile &File = It.first->second;
  529         return Mapping->second; // found a mapping before the offset.
  605     const MarkedFile &File = Files.find(ID)->second;

   30   return {FID, It.first->second};

  178     return *It->second;

   23     const CallGraphNode *N = (I->second).get();
   68   return I == DeclMap.end() ? nullptr : I->second.get();

  233     return I->second;

  126     Recorder->recordFileContent(It->getFirst(), *It->getSecond(), *InMemoryFs);
  126     Recorder->recordFileContent(It->getFirst(), *It->getSecond(), *InMemoryFs);

  301     if (It->first->getName() == LengthExprStr)
  801       if (It->first->getName() == "__STDC_WANT_LIB_EXT1__") {
  802         const auto *MI = PP->getMacroInfo(It->first);

  186     return Iter->second;
  201     return Iter->second;

  107   if (I != GeneratedDecls->end() && I->second == Name) {
  891     if (I != GeneratedDecls->end() && I->second == Symbol)

  101           .first->second;

   87     if (FunctionAliases->second.count(Namespace) != 0) {
   88       return FunctionAliases->second.find(Namespace)->getValue();

  905         SS.Signature.documentation = IndexDocIt->second;
 1544         Bundles[Ret.first->second].push_back(std::move(C));

   86           if (Cost < R.first->second) {
   87             R.first->second = Cost;
  109             Cache.try_emplace(Child, Unreachable).first->getSecond();
  133       Cost = It->second;
  152     return R.first->getSecond();
  155     R.first->second = forScheme(U->scheme()).distance(U->body());
  159   return R.first->second;

  433     return &I->second;
  452   return &E.first->second;

  485       if (SM.getFileOffset(It->second) > SM.getFileOffset(End))
  487       return {It->second, End};

  282       FileIt->second->Relations.insert(&Rel);

  147           I.first->second = mergeSymbol(I.first->second, Sym);
  147           I.first->second = mergeSymbol(I.first->second, Sym);
  156         It->getSecond().References += Sym.second.size();

   66       Callback(*I->second);
   79     for (const auto &O : SymRefs->second) {
   98       for (const auto &Obj : It->second) {

  189     return Index.find({S.data(), S.size()})->second;

  213       return I == Symbols.end() ? nullptr : &I->second;

  270     D = CanonicalDecls.try_emplace(D, ASTNode.OrigD).first->second;
  518     return Found->second;
  694     R.first->second = Compute();
  695   return R.first->second;
  734     I.first->second = Opts.FileFilter(ASTCtx->getSourceManager(), FID);
  735   return I.first->second;

  106                                    : It->second.iterator(&It->first);
  106                                    : It->second.iterator(&It->first);
  248       Callback(*I->second);
  277       for (const auto &Object : It->second) {

  390   return &InsertionResult.first->second;
  399   return &Iter->second;

  139       It->second.push_back(Token);

  512       std::sort(H->second.begin(), H->second.end());
  512       std::sort(H->second.begin(), H->second.end());
  516           AllHeaderContents.find(H->first);
  524       if (H->second == KnownH->second)
  524       if (H->second == KnownH->second)
  529           H->second.begin(), H->second.end(), KnownH->second.begin(),
  529           H->second.begin(), H->second.end(), KnownH->second.begin(),
  529           H->second.begin(), H->second.end(), KnownH->second.begin(),
  530           KnownH->second.end(),
  531           std::back_inserter(HeaderContentMismatches[H->first]));
  679       Location Loc(SM, M->second.getLatest()->getLocation());
  683       Entities.add(M->first->getName().str(), Entry::EK_Macro, Loc);
  977     if (H->second.empty()) {
  983     ModUtil->addUniqueProblemFile(H->first->getName());
  984     errs() << "error: header '" << H->first->getName()
  986     for (unsigned I = 0, N = H->second.size(); I != N; ++I) {
  987       errs() << "note: '" << H->second[I].Name << "' in "
  988              << H->second[I].Loc.File->getName() << " at "
  989              << H->second[I].Loc.Line << ":" << H->second[I].Loc.Column
  989              << H->second[I].Loc.Line << ":" << H->second[I].Loc.Column

  956     I->second = container;
  967   return I->second;
 1078   return I->second;
 1087     return FI->second;

 4026   StoredDeclsList &L = I->second;

 1866         if (!It->second.isRule() || It->second.getRule().isSubRule())
 1866         if (!It->second.isRule() || It->second.getRule().isSubRule())
 1868         Rules.push_back(It->second.getRule());
 1986     for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
 4141           Support.SubjectsToRules.find(Subject.value())->getSecond();

  105   return Mapping->getSecond();

  556   cf.leader_handle = LeaderHandle->second;

  658     Export *existing = pair.first->second;

  375       readAssociativeDefinition(sym, def, parentSym->second);

 1769         uint32_t offsetInC = i->second + linesTmp.header()->RelocOffset;

  345           undefDiags[it->second].files.push_back({file, symIndex});

  460       uint32_t &thunkSymbolIndex = insertion.first->second;

   81   if (!it->second.lt->getFileNameByIndex(
   82           it->second.file, {},
   86   return std::make_pair(fileName, it->second.line);

  113     return res.first->second;

 1227   it->second->isNeeded |= isNeeded;

   64   int &symIndex = p.first->second;
  100   Symbol *sym = symVector[it->second];

 1169       return r.first->second;

 1226     SymbolOrderEntry &ent = it->second;
 1274     orderedSections.push_back({isec, i->second});

  260   return pos->second;
  270     atom = pos->second;

  146     const auto &vec = pos->second;
  191     auto vec = pos->second;

  168     return pos->second;

  121   const DefinedAtom *ap = i->second;
  278     atom = targetFollowOnAtomsIter->second;
  301     atom = targetFollowOnAtomsIter->second;
  315     targetAtom = targetFollowOnAtomsIter->second;
  368       if (iter->second == targetAtom) {
  413     for (const DefinedAtom *nextAtom = start->second; nextAtom;
  428     const auto *root = (ri == _followOnRoots.end()) ? atom.get() : ri->second;
  429     uint64_t override = (oi == _ordinalOverrideMap.end()) ? 0 : oi->second;

  660     return pos->second;
 1300     return pos->second;
 1312     return pos->second;

 1271   const CIEInfo &cieInfo = cieInfos.find(cie)->second;

  103       assert(pos->second != nullptr);
  104       return pos->second;

  116       return pos->second;

  157     return _refNames.find(atom)->second;

   85   if (it == symMap.end() || it->second == -1)
   87   return symVector[it->second];
   92   symVector[it->second] = sym;
   98   int &symIndex = p.first->second;

   76   return pair.first->second;
   85   return it->second;

  262     return static_cast<T *>(it->second.get());

   37     return si->second;

  359   sigaction(signo, &it->second.old_action, nullptr);
  364   int ret = pthread_sigmask(it->second.was_blocked ? SIG_BLOCK : SIG_UNBLOCK,
  401     it->second.callback(*this); // Do the work
  407     it->second(*this); // Do the work

  428         lookup->get(mi->first->getName());
  431         ii = mi->first;
  467       macro_expansion.append(mi->first->getName().str());

  104     return i->second;

  173     return iter->second;

 4420                 const uint32_t GSYM_sym_idx = pos->second;
 4491             llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
 4611                 stub_symbol = symtab->SymbolAtIndex(index_pos->second);

 1984   if (iter->second->GetTraceID() == m_pt_proces_trace_id) {
 2058   if (iter->second->GetTraceID() != traceid) {

 4246     module_spec = cached->second;

  140     return m_map.try_emplace(file, m_map.size() + 1).first->second;

 2126                     static_cast<uint32_t>(pos->second),
 2127                     pos->first->getNameAsString().c_str());
 2141                     (uint32_t)base_pos->second.getQuantity(),
 2142                     base_pos->first->getNameAsString().c_str());
 2155                     static_cast<uint32_t>(vbase_pos->second.getQuantity()),
 2156                     vbase_pos->first->getNameAsString().c_str());
 3327     return cache_pos->second;
 3606       return pos->second;

  892   FileSpecList &list = iter_bool.first->second;
 1426   DWARFDIE dwarf_die = GetDIE(die_it->getSecond());

   92       return pos->second.Find(die, decl, byte_size, entry);

  118     return *result.first->second;
  129   std::unique_ptr<CompilandIndexItem>& cci = result.first->second;
  179   return iter->second.get();
  186   return iter->second.get();

  265   clang::QualType parent_qt = GetOrCreateType(parent_iter->second);
  362       entry.second = iter->second;
  596     return GetOrCreateDeclContextForUid(PdbTypeSymId(iter->second));
  650   DeclStatus &status = status_iter->second;
  802     return iter->second;
  954     return iter->second;
 1309     PdbCompilandSymId block_id = PdbSymUid(iter->second.uid).asCompilandSym();

  702         TypeSP result = full_iter->second;
  735     return iter->second;
  850     emplace_result.first->second = CreateGlobalVariable(var_id);
  852   return emplace_result.first->second;
  863     emplace_result.first->second = CreateFunction(func_id, comp_unit);
  865   return emplace_result.first->second;
  874     emplace_result.first->second = CreateCompileUnit(cci);
  876   lldbassert(emplace_result.first->second);
  877   return emplace_result.first->second;
  883     return *iter->second;
 1369     return iter->second;
 1395     return iter->second;
 1542     return &*iter->second;

  793       symbol_file->GetPDBSession().getSymbolById(uid_it->getSecond());
  820     return it->second;
 1110     set = &pit->second;

  555     return find_result->second.get();
  920     return result->second;
 1042         variable_list->AddVariableIfUnique(result->second);
 1510       types.Insert(iter->second);
 1560     types.Insert(iter->second);
 1728     return found_cu->second;

  584     bit_size = pos->second.bit_size;
  585     alignment = pos->second.alignment;
  586     field_offsets.swap(pos->second.field_offsets);
  587     base_offsets.swap(pos->second.base_offsets);
  588     vbase_offsets.swap(pos->second.vbase_offsets);

   39     return iter->second;

  126   return it->second;

   58       section_load_addr = pos->second;
   82       if (load_addr == sta_pos->second)
   85         sta_pos->second = load_addr;
  160       addr_t load_addr = sta_pos->second;

  158   return e.first->getSecond().get();

   64     return pos->second.read_is_set;
   72     return pos->second.write_is_set;
   80     return pos->second.error_is_set;

   23     iter_bool.first->second = (this->*do_get)(id);
   24   if (iter_bool.first->second)
   25     return llvm::StringRef(*iter_bool.first->second);

  493       object.try_emplace("sourceReference", addr_srcref->second);
  494       disasm_line = g_vsc.GetLineForPC(addr_srcref->second, pc);
  506         object.try_emplace("sourceReference", addr_srcref->second);
  507         disasm_line = g_vsc.GetLineForPC(addr_srcref->second, pc);

   25       return addr_line->second;

   60     return pos->second.GetLineForPC(pc);

 1609         pair.second.UpdateBreakpoint(request_pos->second);
 1926     EmplaceSafeString(body, "content", pos->second.content);

   66   return Iter == m_registers.end() ? nullptr : &Iter->getSecond();

  393       return i->second;
  436         auto I = i->second;
  782         return i->second;

  242   for (uint64_t SourceInstrAddress : TargetRefsKV->second) {

   65     Addresses.push_back(It->second);
   66     It = IntermediateNodes.find(It->second);

  100         ItAndIsNew.first->second != Symbol) {
  102                ItAndIsNew.first->second,

  357             Engine.logf("left switch has extra case %l") << I->first;

   51     return Pair.first->second;

  591       reportError(Entry.first->second->getFileName() + " and " +

  148     const InstructionPressureInfo &Info = IPI.find(IID)->second;
  154     const InstructionPressureInfo &Info = IPI.find(IID)->second;
  160     const InstructionPressureInfo &Info = IPI.find(IID)->second;

   37   return It->second;
   57       It->second->Referenced = true;
   84   return It->second;

   58       Iter.first->second.update(RecordSize);

  174             moduleStream(ModIter->second.Descriptor.getModuleName(), StreamIdx,
  175                          ModIter->second.Modi);
  178             stream(StreamPurpose::NamedStream, NSIter->second, StreamIdx);

   23     return CacheIt->second;

   76           mergeTrieNodes(*(iter->second), *Callee, Node, NodeStore, MergeFn));

  109     Ret = (Name + " [" + Twine(++It.first->second) + "]").str();
  141           (Name + " [" + Twine(++It.first->second) + "]").str();

 1415     if (It->second.empty())
 1417     return &It->second;
 1432     for (auto Access : It->getSecond()) {

  656       StmtScat = Lookup->second;
  914     if (It->second) {
  915       if (It->second->getDependenceLevel() == Level)
  916         return *It->second.get();
  926   return *Inserted.first->second;

  411     DetectionContext &Context = It.first->second;
 1399     DetectionContext &Context = It.first->second;
 1468   DetectionContext &Context = It.first->second;
 1828   return &DCMIt->second;

 1350     It->second.remove(MA);
 1351     if (It->second.empty())
 1677     return DIt->getSecond();
 1729       StmtMapIt->second.erase(std::remove(StmtMapIt->second.begin(),
 1729       StmtMapIt->second.erase(std::remove(StmtMapIt->second.begin(),
 1730                                           StmtMapIt->second.end(), &Stmt),
 1731                               StmtMapIt->second.end());
 2425   return StmtMapIt->second;
 2526   return It->second;
 2544   return It->second;

 1244     Value *NewVector = VecOp->second;
 1516     ValueMapT &RegionMap = Inserted.first->second;

  381   return It->second;

  542     return It->second;

  145   EXPECT_EQ(this->getKey(), it->first);
  146   EXPECT_EQ(this->getValue(), it->second);
  313     visited[visitedIndex[it->first]] = true;
  538   EXPECT_EQ(1u, map.find(0)->second);
  539   EXPECT_EQ(2u, map.find(1)->second);
  540   EXPECT_EQ(3u, map.find(2)->second);
  544   EXPECT_EQ(1u, map.find_as("a")->second);
  545   EXPECT_EQ(2u, map.find_as("b")->second);
  546   EXPECT_EQ(3u, map.find_as("c")->second);

   68   EXPECT_EQ(R.first->second, Index1);
   71   EXPECT_EQ(R.first->second, Index1);
   74   EXPECT_EQ(R.first->second, Index2);
   77   EXPECT_EQ(R.first->second, Index2);

   33     EXPECT_EQ(I->second.getAddress(), FooAddr)
  865     EXPECT_EQ(I->second.getAddress(), FooSym.getAddress())
 1007           EXPECT_EQ(F.getSymbols().find(&JD)->second, Names)

  164       return R->second;

   54     ASSERT_EQ(iter->first, IterKeys[i]);
  108     ASSERT_EQ(iter->second, Keys[i]->value);

   69   EXPECT_THAT(T1Blocks->second,
   74   EXPECT_THAT(T2Blocks->second, ElementsAre(Field(&BlockIndexer::Block::Records,

   71   ASSERT_THAT(T1Blocks->second.size(), Eq(2u));
   74   ASSERT_THAT(T2Blocks->second.size(), Eq(1u));

  217   EXPECT_EQ(1u, G.vertices().begin()->second.VA);
  218   EXPECT_EQ(0u, G.vertices().begin()->first);
  245   EXPECT_EQ(EI(0u, 0u), G.edges().begin()->first);
  246   EXPECT_EQ(2u, G.edges().begin()->second.EA);

 1842         SrcOp2 = findAsmOperandNamed(Name, Insert.first->second);
 1847           Insert.first->second = SrcOp2;

  374     if (Ins->second == SubReg.first)
  382                   SubReg.first->getName() + " and " + Ins->second->getName());
 1073   for (CodeGenRegisterClass *RC : FindI->second)

  251     PrintNote(It->second->getLoc(), "Previous declaration was here.");
  333     unsigned ProcIndex = ProcModelMap.find(SchedModel)->second;
  418     STIPredicateFunction &PreviousDef = STIPredicates[It->second];
 1058     unsigned SCIdx = Pos->second;
 1209     ProcModels[I->second].ItinRWDefs.push_back(RWDef);

  483     return ProcModels[I->second];
  489     return ProcModels[I->second];

  419   return I->second.get();

  151     return *I->second;

 2469           i, IndexOfInstruction.find(Def)->second);

  569     return I->second;
 1673                                     VI->second);
 3037   return *I->second;
 3764   OM.addPredicate<ComplexPatternOperandMatcher>(OM, *ComplexPattern->second);
 3947         DstMIBuilder.addRenderer<CustomRenderer>(*I->second, Child->getName());
 4062           *ComplexPattern->second, DstChild->getName(),

  714     GenericTable &Table = *It->second;