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

References

   44     return MemoryBuffer::getMemBuffer(I->second->getMemBufferRef());

  133     auto &I = Result.first->second;
  150                             (Vector.begin() + Pos->second);

 1139     delete V.second;

  138   const ValueTy &getValue() const { return second; }
  139   ValueTy &getValue() { return second; }
  141   void setValue(const ValueTy &V) { second = V; }
  372       return it->second;
  378   ValueTy &operator[](StringRef Key) { return try_emplace(Key).first->second; }
  423       Ret.first->second = std::forward<V>(Val);

  212   assert(Iter->second.Name == Name);
  213   Iter->second.Values.push_back(

  340         Features.AddFeature(F.first(), F.second);
  360         Features.AddFeature(F.first(), F.second);

   47     assert(getMapEntry()->second.Symbol && "No symbol available!");
   48     return getMapEntry()->second.Symbol;
   50   unsigned getOffset() const { return getMapEntry()->second.Offset; }
   55     return getMapEntry()->second.Index;

  214       return JITEvaluatedSymbol(I->second, JITSymbolFlags::Exported);

  312       createStubInternal(Entry.first(), Entry.second.first,
  313                          Entry.second.second);
  323     auto Key = I->second.first;
  328     auto StubSymbol = JITEvaluatedSymbol(StubTargetAddr, I->second.second);
  339     auto Key = I->second.first;
  344     return JITEvaluatedSymbol(PtrTargetAddr, I->second.second);
  353     auto Key = I->second.first;

  115         auto GV = VI->second;

  356         if (auto Err = createStubInternal(Entry.first(), Entry.second.first,
  357                                           Entry.second.second))
  367       auto Key = I->second.first;
  368       auto Flags = I->second.second;
  379       auto Key = I->second.first;
  380       auto Flags = I->second.second;
  387       auto Key = I->second.first;

  168       if (!SymEntry->second.getFlags().isExported() && ExportedSymbolsOnly)
  172                          SymEntry->second.getFlags());
  173       return JITSymbol(SymEntry->second);

  162     if (Tmp->second == 0)

 1880       if (BOI.Tag->second == LLVMContext::OB_deopt ||
 1881           BOI.Tag->second == LLVMContext::OB_funclet)

 1230     return It->second.second;

  262       SortedTargets.emplace(I.first(), I.second);
  272       MergeResult(Result, addCalledTarget(I.first(), I.second, Weight));

  371       return &It->second;

   41     return IterBool.first->second;

  113         std::make_pair(I.getKey(), std::make_pair(I.second, LocTy())));
  196     if (I->second.second.isValid())
  197       return Error(I->second.second,
  263     Slots->NamedTypes.insert(std::make_pair(I.getKey(), I.second.first));
  656     C = &I->second;
 1470     return &I->second;

 5582           auto &Hash = getThisModule()->second.second;
 6235         LastSeenModule->second.second[Pos++] = Val;

   39     Uniques.push_back(E.second.HashValue);
   58     llvm::stable_sort(E.second.Values,
   62     E.second.Values.erase(
   63         std::unique(E.second.Values.begin(), E.second.Values.end()),
   63         std::unique(E.second.Values.begin(), E.second.Values.end()),
   64         E.second.Values.end());
   76     uint32_t Bucket = E.second.HashValue % BucketCount;
   77     Buckets[Bucket].push_back(&E.second);
   78     E.second.Sym = Asm->createTempSymbol(Prefix);
  667     for (auto *V : Entry.second.Values)
  678     E.second.print(OS);

 2098     const DIE *Entity = GI.second;

   29   auto &Entry = I.first->second;

  205   Index = IndexInfo->second;
  227   Flag = FlagInfo->second;
  249   Flag = FlagInfo->second;
  270   Flag = FlagInfo->second;
  341     I.first->second = Info;
  343   return *I.first->second;

  603     const VRegInfo &Info = *I->second;

 1391       FnCountBefore = It->second;

   67     Size += sizeof(support::ulittle32_t) * Item.second.size();

   57   return P.first->second;
  100   return Iter->second;

 1491         *SectionData = SecIt.second->getBuffer();
 1495         InfoSections[SectionRef()].Data = SecIt.second->getBuffer();
 1497         InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
 1499         TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
 1501         TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();

  735       else if (It->second != FileIndex) {
  740                << "] is a duplicate of file_names[" << It->second << "]\n";

  223     Name.second = NameBufferWriter.getOffset();
  234       if (auto EC = MetadataWriter.writeInteger(Result->second))

  183     GlobalAddressReverseMap.erase(I->second);
  184     OldVal = I->second;
  283     Address = I->second;
  309       uint64_t Addr = I->second;

  527       auto &Parse = HI->second;

   35     SubtargetFeatures.AddFeature(Feature.first(), Feature.second);

  402           auto &GSTEntry = GSTMapEntry.second;
  925     const auto &SymInfo = Loc->second;
 1081       RelocationList &Relocs = i->second;
 1090         Addr = RRI->second.getAddress();
 1091         Flags = RRI->second.getFlags();
 1102         const auto &SymInfo = Loc->second;
 1126         RelocationList &Relocs = i->second;

 1031     const auto &SymInfo = Loc->second;
 1150     const auto &SymInfo = gsi->second;
 1365         RE.SymOffset = i->second;

  498     const auto &SymInfo = pos->second;
  509     return GSTItr->second.getSectionID();
  518     const auto &SymEntry = pos->second;
  536       auto SectionID = KV.second.getSectionID();
  541         JITEvaluatedSymbol(SectionAddr + KV.second.getOffset(), KV.second.getFlags());
  541         JITEvaluatedSymbol(SectionAddr + KV.second.getOffset(), KV.second.getFlags());

  118       const auto &SymInfo = SI->second;

  497     unsigned SectionBID = SubtrahendI->second.getSectionID();
  498     uint64_t SectionBOffset = SubtrahendI->second.getOffset();
  507     unsigned SectionAID = MinuendI->second.getSectionID();
  508     uint64_t SectionAOffset = MinuendI->second.getOffset();

   54       auto &Entry = KV.second;
  128           EntryItr->second.getFlags().getTargetFlags() &

  186       SectionBID = SubtrahendI->second.getSectionID();
  187       SectionBOffset = SubtrahendI->second.getOffset();
  212       SectionAID = MinuendI->second.getSectionID();
  213       SectionAOffset = MinuendI->second.getOffset();

 1028     ModuleIdToPathMap[ModPath.second.first] = ModPath.first();
 1140   return I == ModulePathMap.end() ? -1 : (int)I->second;
 1158   return I == TypeIdMap.end() ? -1 : (int)I->second;
 2685         ModPath.second.first == -1u ? RegularLTOModuleName
 2687         ModPath.second.second);

 2503   ConstantDataSequential **Entry = &Slot.second;

   51   assert(DeoptEntry->second == LLVMContext::OB_deopt &&
   56   assert(FuncletEntry->second == LLVMContext::OB_funclet &&
   61   assert(GCTransitionEntry->second == LLVMContext::OB_gc_transition &&
   66   assert(CFGuardTargetEntry->second == LLVMContext::OB_cfguardtarget &&
  252       .first->second;
  261     Names[I->second] = I->first();

  103     delete CDSConstant.second;
  207     Tags[T.second] = T.first();
  213   return I->second;
  220   return SSC.insert(std::make_pair(SSN, SyncScope::ID(NewSSID))).first->second;
  227     SSNs[SSE.second] = SSE.first();

  195         It->second.second = FnSize;

  484   Entry.second.Name = &Entry;
  485   return &Entry.second;

   50   return I != PassInfoStringMap.end() ? I->second : nullptr;

  160     AddUint64(Entry.second.size());
  161     for (auto &Fn : Entry.second)
  231     for (auto &ImpF : ImpM.second) {
  904     if (Res.second.IRName.empty())
  908         GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
  910     if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
  910     if (Res.second.VisibleOutsideSummary && Res.second.Prevailing)
  914         Res.second.Prevailing ? PrevailingType::Yes : PrevailingType::No;
  989       if (!R.second.isPrevailingIRSymbol())
  991       if (R.second.Partition != 0 &&
  992           R.second.Partition != GlobalResolution::External)
  996           RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
 1001       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
 1003       if (EnableLTOInternalization && R.second.Partition == 0)
 1125         ModuleToDefinedGVSummaries.find(ModulePath)->second;
 1317     if (Res.second.Partition != GlobalResolution::External ||
 1318         !Res.second.isPrevailingIRSymbol())
 1321         GlobalValue::dropLLVMManglingEscape(Res.second.IRName));
 1336             ExportList->second.count(GUID)) ||

  490     GV.setLinkage(I->second);

  274       NameAndAttributes &info = IterBool.first->second;
  313   NameAndAttributes &info = IterBool.first->second;
  332   NameAndAttributes &info = IterBool.first->second;
  528   NameAndAttributes &info = IterBool.first->second;
  551   NameAndAttributes &info = IterBool.first->second;

  595             ExportList->second.count(GUID)) ||

  234   const Comdat *DstC = &DstCI->second;
  480     const Comdat *DstC = &DstCI->second;

  153       std::make_pair(Insertion.first->first(), Insertion.first->second);
  167   return I->second;

  198     if (NameEntry.second || !NameEntry.first->second) {
  201       NameEntry.first->second = true;

  585       return IterBool.first->second;

  227       Insertion.first->second = StringTable.tell();
  230     NamePos = Insertion.first->second;

  133       RecordStreamer::State Value = KV.second;

  123   return SI->second;
  192           GV = MI->second;

  147     return i->second;

 1227       SampleMap.insert({Key, &Sample.second});
 1373     const FunctionSamples &Profile = I.second;

   49     V.push_back(std::make_pair(I.getKey(), &I.second));
  182     addNames(I.second);
  384     addNames(I.second);
  617     const FunctionSamples &Profile = I.second;

   38   return {KV.first->second, KV.first->first()};
   68     Strings[KV.second] = KV.first();

  365         Option *O = E.second;
  524     return I != Sub.OptionsMap.end() ? I->second : nullptr;
  534   auto O = I->second;
  540   return I->second;
  580     Option *O = it->second;
  723   if (OMI != OptionsMap.end() && Pred(OMI->second)) {
  725     return OMI->second; // Found one!
  751     assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);
 1251       O.second->reset();
 1561     switch (Opt.second->getNumOccurrencesFlag()) {
 1564       if (Opt.second->getNumOccurrences() == 0) {
 1565         Opt.second->error("must be specified at least once!");
 2020     if (I->second->getOptionHiddenFlag() == ReallyHidden)
 2024     if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)
 2028     if (!OptionSet.insert(I->second).second)
 2032         std::pair<const char *, Option *>(I->getKey().data(), I->second));
 2468     for (auto &Cat : I.second->Categories) {
 2471         I.second->setHiddenFlag(cl::ReallyHidden);
 2479     for (auto &Cat : I.second->Categories) {
 2481         I.second->setHiddenFlag(cl::ReallyHidden);

  188         return i->second;

  144     DefinedNumericVariable = VarTableIter->second;
  171     NumericVariable = VarTableIter->second;
  834   return VarIter->second;

   56     RealPath = DirWithSymlink->second;

   63     return It->second;
  225   StringMap<Matcher>::const_iterator II = I->second.find(Category);
  226   if (II == I->second.end()) return 0;

  194       delete I->second.first;

  639       return I->second.get();
  645         .first->second.get();
  657       Result += Entry.second->toString(Indent + 2);
  896       llvm::sys::path::append(Path, I->second->getFileName());
  898       switch (I->second->getKind()) {

  199       setError(NN.second.get(), Twine("unknown key '") + NN.first() + "'");

  537   if (!Entry.second)
  538     Entry.second = new(Allocator) StringInit(Entry.getKey());
  539   return Entry.second;

  305   I->second->apply(*this, DagExpr, Elts, Loc);
  325       I->second->expand(*this, Set, Elts);

 5433   if (RegisterReqs.insert(std::make_pair(Name, pair)).first->second != pair)

 1011     Id = toFuncId(Loc->second);

10735   if (RegisterReqs.insert(std::make_pair(Name, Reg)).first->second != Reg)

  263       Features.AddFeature(F.first(), F.second);

  899   return getLibcallSignature(Subtarget, Val->second, Rets, Params);

  128       int64_t D = static_cast<int64_t>(S_V.second);

  628     ComputeImportForModule(DefinedGVSummaries.second, Index,
  641     for (auto EI = ELI.second.begin(); EI != ELI.second.end();) {
  641     for (auto EI = ELI.second.begin(); EI != ELI.second.end();) {
  643         EI = ELI.second.erase(EI);
  658                       << " vars. Imports from " << ModuleImports.second.size()
  660     for (auto &Src : ModuleImports.second) {
  662       unsigned NumGVSPerMod = numGlobalVarSummaries(Index, Src.second);
  663       LLVM_DEBUG(dbgs() << " - " << Src.second.size() - NumGVSPerMod
  680     unsigned NumGVSPerMod = numGlobalVarSummaries(Index, Src.second);
  681     LLVM_DEBUG(dbgs() << " - " << Src.second.size() - NumGVSPerMod
  884     for (auto &GI : ILI.second) {
 1104     auto &ImportGUIDs = FunctionsToImportPerModule->second;

  248       FSToUpdate.push(&IFS.second);
  813       Sum += T_C.second;
 1725     TotalCollectedSamples += I.second.getTotalSamples();
 1743         r.first->second = nullptr;

  287       return LinesByFile.try_emplace(Filename, Filename, os).first->second;
  298         Len += I.second.length();
  490     return It->second;

  107     assert(Node->second->NumberOfInlines >= Node->second->NumberOfRealInlines);
  107     assert(Node->second->NumberOfInlines >= Node->second->NumberOfRealInlines);
  108     if (Node->second->NumberOfInlines == 0)
  111     if (Node->second->Imported) {
  114           int(Node->second->NumberOfRealInlines > 0);
  118           int(Node->second->NumberOfRealInlines > 0);
  123               << (Node->second->Imported ? "imported " : "not imported ")
  125               << ": #inlines = " << Node->second->NumberOfInlines
  127               << Node->second->NumberOfRealInlines << "\n";
  194     if (Lhs->second->NumberOfInlines != Rhs->second->NumberOfInlines)
  194     if (Lhs->second->NumberOfInlines != Rhs->second->NumberOfInlines)
  195       return Lhs->second->NumberOfInlines > Rhs->second->NumberOfInlines;
  195       return Lhs->second->NumberOfInlines > Rhs->second->NumberOfInlines;
  196     if (Lhs->second->NumberOfRealInlines != Rhs->second->NumberOfRealInlines)
  196     if (Lhs->second->NumberOfRealInlines != Rhs->second->NumberOfRealInlines)
  197       return Lhs->second->NumberOfRealInlines >
  198              Rhs->second->NumberOfRealInlines;

  521     IdentifierInfo *&II = Entry.second;
  558     IdentifierInfo *&II = Entry.second;

   40     return OptMap.find(Ext)->second.Enabled;
  108       if (I.second.Supported)
  120       I->second.Supported = On;
  126       I->second.Enabled = false;
  133         I->second.Enabled = true;

  318       return Iter->second;

   36       for (auto &Replacement : Replacements.second)

  537              : it->second.get();

  103   if (NamedDirEnt.second)
  109   NamedDirEnt.second = *UDE.get();
  143     if (SeenDirInsertResult.first->second)
  145     return llvm::errorCodeToError(SeenDirInsertResult.first->second.getError());
  151   assert(!NamedDirEnt.second && "should be newly-created");
  164       NamedDirEnt.second = statError;
  176   NamedDirEnt.second = UDE;
  210     if (!SeenFileInsertResult.first->second)
  212           SeenFileInsertResult.first->second.getError());
  215     SeenFileEntryOrRedirect Value = *SeenFileInsertResult.first->second;
  225   assert(!NamedFileEnt.second && "should be newly-created");
  239       NamedFileEnt.second = DirInfoOrErr.getError();
  258       NamedFileEnt.second = statError;
  271   NamedFileEnt.second = &UFE;
  278     assert((*NewNamedFileEnt.second).get<FileEntry *>() == &UFE &&
  284     NamedFileEnt.second = Redirect;
  339   if (NamedFileEnt.second) {
  340     SeenFileEntryOrRedirect Value = *NamedFileEnt.second;
  371     NamedFileEnt.second = UFE;
  389     NamedFileEnt.second = UFE;

  234   return IterBool.first->second;

 1987   if (auto *C = Entry.second)
 2039   Entry.second = GV;

 3140   if (Elem.second) {
 3141     assert(Elem.second->getType()->getPointerElementType() == Ty &&
 3143     return &*Elem.second;
 3146   return Elem.second = new llvm::GlobalVariable(
 3938   auto PerLine = PerParentName->second.find(LineNum);
 3939   if (PerLine == PerParentName->second.end())
 3953         for (const auto &L : P.second)

  232     llvm::Constant *Replacement = I.second;
 4624   if (auto *C = Entry.second)
 4802   Entry.second = GV;

  401     return ASTCacheEntry->second.get();
  439     return ASTCacheEntry->second;

  683                 << Val << Duplicate->second;

  378             Args.MakeArgString((F.second ? "+" : "-") + F.first()));

  119               Args.MakeArgString((F.second ? "+" : "-") + F.first()));

  261     if (OptionIter->second == true) {
  268     OptionIter->second = true;

 1478     unsigned Last = LastI->second;

  212   return It->second;
  221   return It->second;

 2101           if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)

 2094       Module *TheModule = I->second;

  397   return Config.insert({OptionName, DefaultVal}).first->second;

  175     if (NumFields >= Known->second.FieldOffsets.size())
  178     FieldOffsets[*F] = Known->second.FieldOffsets[NumFields];
  182   if (NumFields != Known->second.FieldOffsets.size())
  185   Size = Known->second.Size;
  186   Alignment = Known->second.Align;
  196     OS << "  Size:" << L->second.Size << '\n';
  197     OS << "  Alignment:" << L->second.Align << '\n';
  199     for (unsigned I = 0, N = L->second.FieldOffsets.size(); I != N; ++I) {
  202       OS << L->second.FieldOffsets[I];

  175     RealPath = DirWithSymLink->second;

  477       if (OverridenFileBuffer->second != F.second)
  477       if (OverridenFileBuffer->second != F.second)
  494       if (Overridden->second != F.second)
  501     if (Status.getSize() != uint64_t(F.second.Size) ||
  503             F.second.ModTime)

  346     Marker &M = InsertResult.first->second;
  354         for (auto &UD : Deferred->second) {
  368       Marker &M = MarkerIt->second;
  381       Marker &M = MarkerInfo.second;
  390       Diags.Report(DeferredPair.second.front().DirectivePos,

 1060   if (CacheLookup.second.Directory &&
 1067   if (!CacheLookup.second.Directory) {
 1077     CacheLookup.second.Directory = *Dir;

   61     for (auto &Name : PendingLinkAs->second) {

  474   if (Section->second.SectionFlags == SectionFlags ||
  475       !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
  477   auto OtherDecl = Section->second.Decl;
  496     if (Section->second.SectionFlags == SectionFlags)
  498     if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
  501       Diag(Section->second.PragmaSectionLocation,

 1963         for (auto *MD : it->second) {

 3385       ArgIdx = It->second;

 4330     if (RI->second.empty()) {
 4336     TypoCorrection TC = RI->second.pop_back_val();

  412       return I->second;

  666     if (Existing.second != Known->second.second) {
  669           << MacroName << Known->second.second;
  676     if (Existing.second || Existing.first == Known->second.first)
  682         << MacroName << Known->second.first << Existing.first;
 4302       Id->second->setOutOfDate(true);
 4784       if (auto Reader = Known->second->createExtensionReader(Metadata, *this,

 2074           Offset = Pos->second;
 2543     if (Id.second->hadMacroDefinition() &&
 2544         (!Id.second->isFromAST() ||
 2545          Id.second->hasChangedSinceDeserialization()))
 2546       MacroIdentifiers.push_back(Id.second);
 3788       IIs.push_back(ID.second);
 4969       const IdentifierInfo *II = ID.second;

  345   ModuleInfo &Info = Modules[Known->second];
  353     ModulesByFile[File] = Known->second;
  821       Generator.insert(I->first(), I->second, Trait);

   19   if (I->second.IsFinal)
   21   return I->second.Buffer ? Tentative : ToBuild;
   29   return *Insertion.first->second.Buffer;
   48   return I->second.Buffer.get();
   63   auto &PCM = I->second;
   77   auto &PCM = I->second;

  282                    << (Keys[I]->second.empty() ? "\"\"" : Keys[I]->second)
  282                    << (Keys[I]->second.empty() ? "\"\"" : Keys[I]->second)

  462   const FunctionVariantsTy &SpecVariants = FSMI->second;

  134                                   FileAndContent.second);

  291   Iter->second.push_back(std::move(IncludeToAdd));
  292   auto &CurInclude = Iter->second.back();
  313     for (const auto &Inc : It->second)
  352   for (const auto &Inc : Iter->second) {

  314     OS.write(FC.data() + CurBundleInfo->second.Offset,
  315              CurBundleInfo->second.Size);
  767     raw_fd_ostream OutputFile(Output->second, EC, sys::fs::OF_None);
  769       return createFileError(Output->second, EC);
  786       raw_fd_ostream OutputFile(E.second, EC, sys::fs::OF_None);
  788         return createFileError(E.second, EC);
  806     raw_fd_ostream OutputFile(E.second, EC, sys::fs::OF_None);
  808       return createFileError(E.second, EC);

  175           for (const tooling::Replacement &R : Fix.second)

  262         R.first->second.emplace_back(Value);

   29     return Iter->second;

  780     llvm::StringRef Code = SM.getBufferData(SI->second);

  135           for (const auto &Repl : FileAndReplacements.second) {
  206             format::cleanupAroundReplacements(Code, FileAndReplacements.second,
  252       for (const auto &Repl : FileAndReplacements.second) {

  647       for (const auto &Replace : FileAndReplaces.second)
  657       for (const auto &Replace : FileAndReplace.second) {

  249       Result = Iter->second;

  250   return ScaleIter->second;
  266   return ScaleIter->second;

  119     const auto &Declarations = KeyValuePair.second;

   47   isInterface = Pair->second;

   58     return It->second;

  117       if (!It.second.canApplyTo(*Draft)) {
  394       It->second.first(); // Invoke the canceler.
  421       if (It != RequestCancelers.end() && It->second.second == Cookie)
  714             It.second.asTextEdits();
 1258   const auto &DiagToFixItsMap = DiagToFixItsIter->second;

  409           Edit &E = It.second;

 1359       ID.References = IDAndCount.second;

   23   return It->second;
   53   std::string Contents = EntryIt->second;
  107   EntryIt->second = Contents;

   67     dlog("Source {0} = {1}, MaxUp = {2}", Canonical, S.second.Cost,
   68          S.second.MaxUpTraversals);

  149     CachedCDB &Entry = R.first->second;
  154   return R.first->second;
  228         It.first->second = Entry.CDB != nullptr;
  283       Cmd = It->second;

  116     if (It->second > Best->second)
  116     if (It->second > Best->second)
  118     else if (It->second == Best->second && It->first() < Best->first())
  118     else if (It->second == Best->second && It->first() < Best->first())

  144     CurrentLevel.push_back(It->second);
  145     Seen.insert(It->second);

  408     return &I->second;
  423   return &E.first->second;

  927       for (const auto &Used : It->second)

  916   return It->second->Contents;
  940   It->second->Worker->runWithAST(Name, std::move(Action));
  958         It->second->Worker->getPossiblyStalePreamble();
  959     Action(InputsAndPreamble{It->second->Contents,
  960                              It->second->Worker->getCurrentCompileCommand(),
  970     It->second->Worker->getCurrentPreamble(
  977   std::shared_ptr<const ASTWorker> Worker = It->second->Worker.lock();
  979                Contents = It->second->Contents,
 1014         {PathAndFile.first(), PathAndFile.second->Worker->getUsedBytes()});
 1021     if (!PathAndFile.second->Worker->isASTCached())

   78       I.first->second = *Path;
   80     return I.first->second;
  251         FileIt->second.Symbols.insert(&Sym);
  252         SymbolIDToFile[Sym.ID] = &FileIt->second;
  264         FileIt->second.Symbols.insert(&Sym);
  291     for (const auto *S : FileIt.second.Symbols)
  293     for (const auto *R : FileIt.second.Refs)
  295     for (const auto *Rel : FileIt.second.Relations)
  324       auto Hash = FileIt.second.Digest;
  326       ShardVersion &SV = DigestIt.first->second;
  392     if (D != ShardVersionsSnapshot.end() && D->second.Digest == Digest &&
  393         !D->second.HadErrors)
  435       It.second.Flags |= IncludeGraphNode::SourceFlag::HadErrors;

   38       return SE->second;
   43     return MapIt->second;
   57       return MappingIt->second;

  127       SymbolSlabs.push_back(FileAndSymbols.second);
  129       RefSlabs.push_back(FileAndRefs.second.Slab);
  130       if (FileAndRefs.second.CountReferences)
  134       RelationSlabs.push_back(FileAndRelations.second);

  100       Result.emplace_back(It.first(), It.second);

   31         llvm::MemoryBuffer::getMemBufferCopy(FileAndContents.second, File));

  116     auto NewText = It.second.apply();

   52   return arg.first() == FileName && arg.second == Contents;

  200     collectModuleHeaders(*I->second);

  926     if (E->second.size() == 1)
  935     for (unsigned I = 0, N = E->second.size(); I != N; ++I) {
  936       EntryBins[E->second[I].Kind].push_back(E->second[I].Loc);
  936       EntryBins[E->second[I].Kind].push_back(E->second[I].Loc);

  329     if (!collectModuleHeaders(*I->second))

  424         R.first->second = Filter.second;
  426   DisableTrace = !R.first->second;

  145         for (const auto &Fix : FileAndFixes.second) {

  119         RemappedFile.second, RemappedFile.first());

  127       for (auto &Replacement : Replacements.second) {

  594       llvm::StringRef Name = I->second;
  615         TemporaryFiles.insert(std::make_pair(Name, Path.str())).first->second;

   80         TemporaryFiles.insert(std::make_pair(Name, Path.str())).first->second;

  633     return It->second.Root;

  200       const Record &R = *I->second;

 2189     if (!Quiet && Options.Verbose && (Cached->second != DwoId))

  514   return Sym->second;
  522     if (Entry.second == Value)

   21   auto &Entry = I.first->second;

 1025       ObjFilename.first->second = true;

  147         res.insert(res.end(), p.second.begin(), p.second.end());
  147         res.insert(res.end(), p.second.begin(), p.second.end());

 1828       sec->addrExpr = [=] { return i->second; };

  171     return pos->second;

  697     return pos->second;
  729     return pos->second->currentVersion();
  737     return pos->second->compatVersion();

 1251       pos->second.hasWeak = false;
 1252       pos->second.hasNonWeak = !pos->second.hasWeak;
 1252       pos->second.hasNonWeak = !pos->second.hasWeak;

  128       const lld::Atom *prevAtom = pos->second;
  188       return pos->second;

  131     OutputSection *sec = make<CustomSection>(name, pair.second);

   79     return (KeyValue.first() + "=" + KeyValue.second).str();
   90       Stream << "env[" << KV.first() << "] = " << KV.second << "\n";

 1175       log_stream_sp = pos->second.lock();

  563       Value *nsstring_value = value_symbol.second;
  736       GlobalVariable *gv = dyn_cast<GlobalVariable>(value_symbol.second);

 2837   llvm::StringRef buffer = buffer_it->second->getBuffer();

  309       auto dup_module = filtered_modules[iter->second];
  311         filtered_modules[iter->second] = &module;

 3428                     OptionValueSP(new OptionValueString(KV.second.c_str())),

  108       entry.second = mangled_ccstr;

   33     *Next++ = make_entry(KV.first(), KV.second);
   46     try_emplace(first->first(), first->second);

   45   for (const auto &category : entry.second.m_channel.categories)
   68       flags |= entry.second.m_channel.default_flags;
   72         entry.second.m_channel.categories,
   74     if (cat != entry.second.m_channel.categories.end()) {
  197   iter->second.Disable(UINT32_MAX);
  211                        ? iter->second.m_channel.default_flags
  213   iter->second.Enable(log_stream_sp, log_options, flags);
  228   iter->second.Disable(flags);
  245     entry.second.Disable(UINT32_MAX);
  354     c.second.m_channel.log_ptr.store(nullptr, std::memory_order_relaxed);

 1602     for (auto &pair: old_src_bp_pos->second) {
 1619      old_src_bp_pos->second.erase(line);
 1629       old_src_bp_pos->second[pair.first] = std::move(pair.second);
 1826       g_vsc.target.BreakpointDelete(pair.second.bp.GetID());
 1831       pair.second.UpdateBreakpoint(request_pos->second);
 1831       pair.second.UpdateBreakpoint(request_pos->second);
 1836       AppendBreakpoint(pair.second.bp, response_breakpoints);
 1846     pair.second.SetBreakpoint();
 1848     AppendBreakpoint(pair.second.bp, response_breakpoints);
 1849     g_vsc.function_breakpoints[pair.first()] = std::move(pair.second);

   28   EXPECT_EQ("", Environment(Envp4).find("FOO")->second);
   29   EXPECT_EQ("", Environment(Envp4).find("BAR")->second);

  281     if (Elements.insert({Field, {""}}).first->second.size() != 1)

  237       SourceFile = Loc->second;
  422       Filename = CovFileName->second;

  428   if (DWARFSectionKind Kind = SectionPair->second.second) {
  448   MCSection *OutSection = SectionPair->second.first;

  103       return Iter->second;
  169       return Iter->second;

  133     OS << "  \"" << SKV.first() << "\" " << SKV.second << "\n";
  140     OS << "  Section \"" << SIKV.first() << "\": " << SIKV.second << "\n";
  142     OS << "  GOT \"" << GOTKV.first() << "\": " << GOTKV.second << "\n";
  144     OS << "  Stub \"" << StubKV.first() << "\": " << StubKV.second << "\n";
  151     OS << "File \"" << FIKV.first() << "\":\n" << FIKV.second;
  465   return FileInfoItr->second;
  479   return SecInfoItr->second;
  493   return StubInfoItr->second;
  507   return GOTInfoItr->second;
  521   return SymInfoItr->second;

  168     std::unique_ptr<Module> Ret = std::move(I->second);

  346                   Twine(1 << Entry.first->second) + ", " +
  604       Slice.setP2Alignment(Alignment->second);
  759                   Entry.first->second.getBinary()->getFileName() + ", " +
  793       Slice = It->second;

   45       const CodeRegion &R = *Regions[It->second];
   77       Regions[It->second]->setEndLocation(Loc);
   92     Regions[It->second]->setEndLocation(Loc);

  569     const SectionRename &SR = E.second;

  620         const SectionRename &SR = Iter->second;
  677         Sec.Align = I->second;
  685         const SectionFlagsUpdate &SFU = Iter->second;

  893     NamespacedStatsSorted.push_back({Stat.getKey(), Stat.second});

   92       if (NSE.second != kInvalidStreamIndex)
   93         NamedStreams[NSE.second] = NSE.first();

  395                                     Remapper(Target.first()), Target.second);
  502           Remapper ? remapSamples(I->second, *Remapper, Result)
  504       FunctionSamples &Samples = Remapper ? Remapped : I->second;

  166     for (auto &KV2 : KV.second)
  167       llvm::dbgs() << "  \"" << KV2.first() << "\" -> " << KV2.second << "\n";
  177   auto &SectionIDs = I->second;
  183   return J->second;

  151       It->second = false;

   57     EXPECT_EQ(testValue, it->second);
  214     ss << "key_" << it->second;
  216     visited[it->second] = true;
  231   EXPECT_EQ(1u, entry->second);
  254   EXPECT_EQ(testValue, NewIt->second);
  279   EXPECT_EQ(42u, It->second);
  291   EXPECT_EQ(1, try1.first->second.v);
  292   EXPECT_EQ(1, try1.first->second.move);
  296   EXPECT_EQ(2, try2.first->second.v);
  297   EXPECT_EQ(2, try1.first->second.move);
  300   EXPECT_EQ(0, try1.first->second.copy);
  329   ASSERT_EQ(iter->second.i, 123);
  417   ASSERT_EQ(I->second.Number, 42);
  425   ASSERT_EQ(I->second.Number, 42);

  156       LookupResult[Symbol] = I->second;

   59     return it->second;

   88     return BIt->second;

  148       return R->second;

  983     cl::Option *O = OM.second;

 2930       SmallVectorImpl<TreePatternNode*> &Nodes = Entry.second;
 2942           InNamedTypes->find(Entry.getKey())->second;
 2968       if (Entry.second.size() > 1) {

   84   return F->second;
  104     dbgs() << "  " << P.first() << " -> " << P.second << '\n';

  457     PrintNote(It->second->getLoc(),

  359   return I->second;

  938     return I->second;
 3047   return *I->second;