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

References

  651     ArgNames.push_back(IdentifierStr);
 1016     OldBindings.push_back(NamedValues[VarName]);

  651     ArgNames.push_back(IdentifierStr);
 1016     OldBindings.push_back(NamedValues[VarName]);

  651     ArgNames.push_back(IdentifierStr);
 1015     OldBindings.push_back(NamedValues[VarName]);

  636     ArgNames.push_back(IdentifierStr);
 1001     OldBindings.push_back(NamedValues[VarName]);

  653     ArgNames.push_back(IdentifierStr);
 1025     OldBindings.push_back(NamedValues[VarName]);

  333     ArgNames.push_back(IdentifierStr);

  359     ArgNames.push_back(IdentifierStr);

  369     ArgNames.push_back(IdentifierStr);

  496     ArgNames.push_back(IdentifierStr);

  583     ArgNames.push_back(IdentifierStr);

  656     ArgNames.push_back(IdentifierStr);
 1021     OldBindings.push_back(NamedValues[VarName]);

  657     ArgNames.push_back(IdentifierStr);
 1020     OldBindings.push_back(NamedValues[VarName]);

  771     ArgNames.push_back(IdentifierStr);
 1185     OldBindings.push_back(NamedValues[VarName]);

   66     ModuleKeys.push_back(K);

40927       Candidates.push_back(T);

80482       Candidates.push_back(T);

16412       Candidates.push_back(T);

11751       Candidates.push_back(T);

 7238       Candidates.push_back(T);

 9274       Candidates.push_back(T);

  474     createdNodes.push_back(T);

   96       V.push_back(X);
  106       V.push_back(X);

  146   SCCNodeStack.push_back(N);
  203       CurrentSCC.push_back(SCCNodeStack.back());

  144       vector_.push_back(X);
  153         vector_.push_back(*Start);

   51     Vector.push_back(Entry);

  332   void addAADependencyID(AnalysisKey *ID) { AADeps.push_back(ID); }

   48     Nodes.push_back(Header);

   73   Int->Nodes.push_back(BB);
  211           Int->Successors.push_back(NodeHeader);
  218             Int->Successors.push_back(NodeHeader);

  186     Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
  195     Accesses[MemAccessInfo(Ptr, false)].push_back(AccessIdx);

  379     SubLoops.push_back(NewChild);
  405     Blocks.push_back(BB);
  471     Blocks.push_back(BB);
  981     TopLevelLoops.push_back(New);

  466           ReverseCFGWorklist.push_back(Pred);
  507       Subloop->getParentLoop()->getSubLoopsVector().push_back(Subloop);

  242     DFS.PostBlocks.push_back(BB);

  229     Array->push_back(N);

  320     LiveIns.push_back(RegMaskPair);

  707     MBBNumbering.push_back(MBB);
  841   void addLongjmpTarget(MCSymbol *Target) { LongjmpTargets.push_back(Target); }

  559     Queue.push_back(SU);

   76         AdjEdgeIds.push_back(EId);

  437         NodeStack.push_back(NId);
  459         NodeStack.push_back(NId);
  468         NodeStack.push_back(NId);

  171         Items.push_back(Item);
  193         Items.push_back(Field);

  132       Item.push_back(Field);

  117       Hashes.push_back(H);

  705     MethodNames.push_back(Name);

  244     void appendRow(const DWARFDebugLine::Row &R) { Rows.push_back(R); }
  247       Sequences.push_back(S);

  231     Entries.push_back(Entry);

  153     Lines.push_back(LE);

  565     LD.BaseLayerVModuleKeys.push_back(LD.K);
  619       LD.BaseLayerVModuleKeys.push_back(PartKey);

  160   void release(ResourceId I) { FreeIds.push_back(I); }

  362       Buffer.push_back(*P++);

  846     FreeSequenceNumbers.push_back(SequenceNumber);

  635   void addCall(EdgeTy E) { CallGraphEdgeList.push_back(E); }
  686     TIdInfo->TypeTests.push_back(Guid);

   77       Args.push_back(Arg);

  416       Result.push_back(Relocate);
  428       Result.push_back(Relocate);

  645       MCGenDwarfLabelEntries.push_back(E);

  181     MCLineDivisions[Sec].push_back(LineEntry);

  230     Relocations[Sec].push_back(P);

  315       StackMapRecordOffsets.push_back(CurrentRecordOffset);

  173     AnalysisImpls.push_back(pir);

  108     ItfImpl.push_back(ItfPI);

   82       ItemEndOffsets.push_back(CurrentOffset);

 1476   void push_back(const DataType &value) { Storage.push_back(value); }
 1477   void push_back(DataType &&value) { Storage.push_back(value); }
 1521   template <class T> void addValue(const T &V) { Storage.push_back(V); }
 1549     Positions.push_back(pos);

  782       PredBlocks.push_back(Pred);

  233       NumToNode.push_back(BB);

  188   void push_back(const Value &E) { V.push_back(E); }

  747       WorkList.push_back(Node);
  761           NextList.push_back(Src);
  768           NextList.push_back(*DstBelow);

  273     Worklist.push_back(UserInst);

  446       AllocRelatedValues.push_back(Ptr);

   50   Intervals.push_back(I);
   65     getBlockInterval(Successor)->Predecessors.push_back(Header);

  303   worklist.push_back(OldSucc);

  235       InfluenceStack.push_back(Succ);

  276       StratLinks.push_back(Link.getLink());

   94     SCCs.push_back(*I);

 1217       FwdRefAttrGrps.push_back(AttrGrpNum);
 2536       Inputs.push_back(Input);
 5424     ParamTypeList.push_back(ArgList[i].Ty);
 7890     Args.push_back(Val);
 7967     NumberedValueInfos.push_back(VI);
 8478     VContexts.push_back(VC);
 8495     Refs.push_back(VC.VI);
 8590     TypeTests.push_back(GUID);
 8628     VFuncIdList.push_back(VFuncId);
 8667     ConstVCallList.push_back(ConstVCall);

 1201   IdentifiedStructTypes.push_back(Ret);
 1207   IdentifiedStructTypes.push_back(Ret);
 2247       GlobalInits.push_back(GlobalInitWorklist.back());
 2260       IndirectSymbolInits.push_back(IndirectSymbolInitWorklist.back());
 2276       FunctionPrefixes.push_back(FunctionPrefixWorklist.back());
 2289       FunctionPrologues.push_back(FunctionPrologueWorklist.back());
 2302       FunctionPersonalityFns.push_back(FunctionPersonalityFnWorklist.back());
 2905   DeferredMetadataInfo.push_back(CurBit);
 3075   ComdatList.push_back(C);
 3312     FunctionsWithBodies.push_back(Func);
 3605       SectionTable.push_back(S);
 3612       GCTable.push_back(S);
 5115         Inputs.push_back(Op);

  725           MDStringRef.push_back(Str);
  770           GlobalMetadataBitPosIndex.push_back(CurrentValue);

  679   MDs.push_back(MD);
  757     MDs.push_back(MD);
  786     FunctionMDs.push_back(MD);
  885   Types.push_back(Ty);
  925     AttributeLists.push_back(PAL);
  937       AttributeGroups.push_back(Pair);

   90       Regs.push_back(Reg);
  114   GroupNodes.push_back(idx);

   39     Uniques.push_back(E.second.HashValue);

  161   Abbreviations.push_back(New);

 2520         Spans[Cur.CU].push_back(Span);
 2554         Spans[Prev.CU].push_back(Span);
 2570     CUs.push_back(CU);

  637   void addArangeLabel(SymbolCU SCU) { ArangeLabels.push_back(SCU); }

  404   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
  412   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.

 6887     UGEPIs.push_back(UGEPI);

  251     LoadCmpBlocks.push_back(BB);
  370       XorList.push_back(Diff);
  381       OutList.push_back(Or);
  384       OutList.push_back(InList.back());

  876     MemOps.push_back(Ty);

  535     result.push_back(v[i]);
  554     result.push_back(v[i]);
  715       FailedOpcodes.push_back(Opcode);
  717       FailedOpcodes.push_back(Opcode);

  477       Tys.push_back(Ty);

   84   Queue.push_back(SU);

   92     RPOList.push_back(MBB);
  215       PseudoIdempotentInstructions.push_back(II);
  274     MultiUsers[UseToBringDefCloserTo].push_back(Def);

  757   CSIInfo.push_back(CSI);
  847       Blocks.push_back(MBB);

  302     MF.VirtualRegisters.push_back(VReg);
  311     MF.LiveIns.push_back(LiveIn);
  321       CalleeSavedRegisters.push_back(Reg);
  379     YMF.FixedStackObjects.push_back(YamlObject);
  405     YMF.StackObjects.push_back(YamlObject);
  489     YMF.CallSitesInfo.push_back(YmlCS);
  519     MF.Constants.push_back(YamlConstant);
  538     YamlJTI.Entries.push_back(Entry);

   75     Candidates.push_back(MI);
  139       VisitedMIs.push_back(Def);

  660     Probs.push_back(Prob);
  661   Successors.push_back(Succ);
  670   Successors.push_back(Succ);
  765   Predecessors.push_back(Pred);

 1155       Edges.push_back(dst);

  280   FrameInstructions.push_back(Inst);
  794   TypeInfos.push_back(TI);

  157     DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
  259   Personalities.push_back(Personality);

  536             ToVisit.push_back(ChildPair.second);
  541             LeafChildren.push_back(ChildPair.second);
  555             RS.StartIndices.push_back(Leaf->SuffixIdx);
  592         ToVisit.push_back(N);
  662     InstrListForMBB.push_back(It);
  675     UnsignedVecForMBB.push_back(MINumber);
  710     InstrListForMBB.push_back(It);
  711     UnsignedVecForMBB.push_back(IllegalInstrNumber);
 1086     FunctionList.push_back(OF);

 3557     ReadyQ.push_back(SU);

  484     PendingQueue.push_back(SuccSU);
  502   Sequence.push_back(SU);
  595       NotReady.push_back(CurSUnit);

  321         FrameSDOps.push_back(I);

  634       VRegAllowed.push_back(PReg);

  479     WorkList.push_back(ExitSU);
  505         WorkList.push_back(SU);
  575   WorkList.push_back(SU);
  635         WorkList.push_back(Succ);
  668         WorkList.push_back(Pred);
  691       L.push_back(w);

 1050       NodeNums.push_back(SU->NodeNum);
 1053       NodeNums.push_back(SU->NodeNum);

  884     Args.push_back(Entry);
 1126     Args.push_back(Entry);
 1271     Args.push_back(Entry);

 2033     Args.push_back(Entry);
 2097     Args.push_back(Entry);
 2214     Args.push_back(Entry);
 2223   Args.push_back(Entry);
 2308   Args.push_back(Entry);
 2316   Args.push_back(Entry);
 2324   Args.push_back(Entry);

 3444     Args.push_back(Entry);
 3452   Args.push_back(Entry);

  505       NewOps.push_back(Op);
  509       NewOps.push_back(Op);
 1019     Args.push_back(Entry);

  234   Queue.push_back(SU);
  303     Packet.push_back(SU);

  187   Sequence.push_back(SU);
  671   Sequence.push_back(N);

  433       PendingQueue.push_back(PredSU);
  755   Sequence.push_back(SU);
  917     PendingQueue.push_back(SU);
 1805     Queue.push_back(U);

  133     PendingQueue.push_back(SuccSU);
  155   Sequence.push_back(SU);
  226       NotReady.push_back(CurSUnit);

 6213   Entry.Node = Dst; Args.push_back(Entry);
 6214   Entry.Node = Src; Args.push_back(Entry);
 6217   Entry.Node = Size; Args.push_back(Entry);
 6246   Args.push_back(Entry);
 6249   Args.push_back(Entry);
 6253   Args.push_back(Entry);
 6317   Entry.Node = Dst; Args.push_back(Entry);
 6318   Entry.Node = Src; Args.push_back(Entry);
 6321   Entry.Node = Size; Args.push_back(Entry);
 6350   Args.push_back(Entry);
 6353   Args.push_back(Entry);
 6357   Args.push_back(Entry);
 6416   Args.push_back(Entry);
 6419   Args.push_back(Entry);
 6422   Args.push_back(Entry);
 6450   Args.push_back(Entry);
 6454   Args.push_back(Entry);
 6458   Args.push_back(Entry);
 8424         Order.push_back(U);

  963   Ops.push_back(Res);
 2057       SL->SwitchCases.push_back(CB);
 2066   SL->SwitchCases.push_back(CB);
 2542     Args.push_back(Entry);
 7141     Args.push_back(Entry);
 7158     Args.push_back(Entry);
 8217         AsmNodeOperands.push_back(OpInfo.CallOperand);
 8301         AsmNodeOperands.push_back(AsmNodeOperands[CurOp+1]);
 8355         AsmNodeOperands.push_back(InOperandVal);
 8402   if (Flag.getNode()) AsmNodeOperands.push_back(Flag);
 8639     Args.push_back(Entry);
10269           SL->SwitchCases.push_back(CB);
10420     SL->SwitchCases.push_back(CB);

 2035   Ops.push_back(InOps[InlineAsm::Op_InputChain]); // 0
 2036   Ops.push_back(InOps[InlineAsm::Op_AsmString]);  // 1
 2037   Ops.push_back(InOps[InlineAsm::Op_MDNode]);     // 2, !srcloc
 2038   Ops.push_back(InOps[InlineAsm::Op_ExtraInfo]);  // 3 (SideEffect, AlignStack)
 2085     Ops.push_back(InOps.back());

  142     Args.push_back(Entry);
  266     MemOps.push_back(VT);
 4049       Ops.push_back(Op);
 6837   Args.push_back(Entry);

  245               Roots.push_back(Pair);

  213         Table.push_back(DefaultMBB);
  217       Table.push_back(Clusters[I].MBB);

  123       DeadBlocks.push_back(BB);

  773       BlocksInFunclet.push_back(NewBlock);
 1218         FuncletBlocks[FuncletPad].push_back(NewBlock);

  266       Value.push_back(S);

   79   Checksums.push_back(Entry);

   60     Result.first->getValue().push_back(Targets[0]);

   60   Frames.push_back(Frame);

   86   B.Lines.push_back(LNE);
  100   B.Columns.push_back(CNE);

   92     Result.push_back(Entry.first);

   31   Records.push_back(Symbol);

  106       Contributions.push_back(C);
  922   Worklist.push_back(Result.FunctionDIE);
  937       Worklist.push_back(Child);
 1065     Result.push_back(Local);

   91         ArangeDescriptors.push_back(arangeDescriptor);

  168     IncludeDirectories.push_back(Dir);
  181     FileNames.push_back(FileEntry);
  258         IncludeDirectories.push_back(Value);
  321     FileNames.push_back(FileEntry);
  372     StandardOpcodeLengths.push_back(OpLen);
  661           Prologue.FileNames.push_back(FileEntry);
 1016       Result.push_back(I);

   55     Entries.push_back(Entry);
   92     Res.push_back(E);

  168     Res.push_back(E);

  391   Worklist.push_back(*this);
  412         Worklist.push_back(D);
  416         Worklist.push_back(D);

  370         Dies.push_back(DIE);
  379       Dies.push_back(DIE);

  255     LT.Lines.push_back(Row);

   77   Symbols.push_back(BulkSymbols);

   85   OldFpoData.push_back(FD);

   75     Records.push_back(Symbol);
  167     HashBuckets.push_back(ChainStartOff);
  181       HashRecords.push_back(Entry.second);
  262     SymOffsets.push_back(SymOffset);

   81     FeatureSignatures.push_back(Sig);

   35   Features.push_back(Sig);

   32     MatchOffsets.push_back(Off);

   34         Matches.push_back(*TI);
   43           Matches.push_back(*TI);

   80   Enumerators.push_back(Record);

  224     ContainerLayout.StreamMap.push_back(Blocks);

  172       Result.push_back(TI);

   57   TypeRecords.push_back(Record);
   59     TypeHashes.push_back(*Hash);

  454     GVArgs.push_back(GVArgc); // Arg #0 = argc.

  247     ArgVec.push_back(*unwrap(Args[I]));

 1204       Dest.AggregateVal.push_back(Result);
 1231       Dest.AggregateVal.push_back(Result);
 1258       Dest.AggregateVal.push_back(Result);
 1571       SrcVec.AggregateVal.push_back(Src);
 1625         TempDst.AggregateVal.push_back(Elt);
 1641           TempDst.AggregateVal.push_back(Elt);

   52   void add(void *Mem) { Allocations.push_back(Mem); }
  180     AtExitHandlers.push_back(F);

  145       SegLists.ContentBlocks.push_back(B);
  147       SegLists.ZeroFillBlocks.push_back(B);
  307       Worklist.push_back(Sym);
  336         SymbolsToRemove.push_back(Sym);
  349         BlocksToRemove.push_back(B);

  636   EventListeners.push_back(L);

  759         AddedSyms.push_back(EntryItr);
 1023         Worklist.push_back(SymI);
 1460     ToRemove.push_back(Name);
 1593     ToRemove.push_back(Name);
 1750           ExistingDefsOverridden.push_back(KV.first);
 1753         MUDefsOverridden.push_back(KV.first);

  443     UntrackedEHFrameRanges.push_back(EHFrameRange);
  468     EHFrameRanges.push_back(KV.second);

  432     EventListeners.push_back(L);

  286         CommonSymbolsToAllocate.push_back(*I);
  571         CodeSectionSizes.push_back(SectionSize);
  574         ROSectionSizes.push_back(SectionSize);
  577         RWSectionSizes.push_back(SectionSize);
  608     RWSectionSizes.push_back(CommonSize);

 2043   ArgVec.push_back(C);
 2052     ArgVec.push_back(Idx);

  587   Args.push_back(ActualCallee);

  234     Result.push_back(Info);

 1930   S.push_back(PM);

  241   Attrs.push_back(A);
  427       NodeMap[SummaryIt.first].push_back(ModId);

  120   Listeners.push_back(L);

  105         StructTypes.push_back(STy);

  722         Mod.Keep.push_back(GV);
  742         Mod.Keep.push_back(GV);
  786       Keep.push_back(GV);
  797     Keep.push_back(GV);

  293     _symbols.push_back(info);
  470   _symbols.push_back(info);
  502     _symbols.push_back(info);
  620     _symbols.push_back(info);

  336     Conf.MAttrs.push_back(TMBuilder.MAttr);

   74       Action.Completions.push_back(I->DisplayText);

  409       Worklist.push_back(GV);

  279     AddrsigSyms.push_back(Sym);
  345   SectionTable.push_back(Sec);
  374       ShndxIndexes.push_back(shndx);
  727       LocalSymbolData.push_back(MSD);
  729       ExternalSymbolData.push_back(MSD);
 1139         Groups.push_back(Group);
 1151       Relocations.push_back(RelSection);
 1516     Relocations[&FixupSection].push_back(Rec);
 1531   Relocations[&FixupSection].push_back(Rec);

   74   InitialFrameState.push_back(Inst);

  271   MCCVLines.push_back(LineEntry);
  285         FilteredLines.push_back(MCCVLines[Idx]);

  219   Regions.push_back(Data);
  303     getAssembler().getIndirectSymbols().push_back(ISD);

 2613           MA.push_back(getTok());
 2639     MA.push_back(getTok());
 2699       FA.Value.push_back(newToken);
 2709       FA.Value.push_back(newToken);
 2804   ActiveMacros.push_back(MI);
 5037   TheCondStack.push_back(TheCondState);
 5081   TheCondStack.push_back(TheCondState);
 5104   TheCondStack.push_back(TheCondState);
 5158   TheCondStack.push_back(TheCondState);
 5170   TheCondStack.push_back(TheCondState);
 5549   ActiveMacros.push_back(MI);

  441   DwarfFrameInfos.push_back(Frame);
  473   CurFrame->Instructions.push_back(Instruction);
  484   CurFrame->Instructions.push_back(Instruction);
  494   CurFrame->Instructions.push_back(Instruction);
  504   CurFrame->Instructions.push_back(Instruction);
  515   CurFrame->Instructions.push_back(Instruction);
  525   CurFrame->Instructions.push_back(Instruction);
  551   CurFrame->Instructions.push_back(Instruction);
  561   CurFrame->Instructions.push_back(Instruction);
  571   CurFrame->Instructions.push_back(Instruction);
  581   CurFrame->Instructions.push_back(Instruction);
  590   CurFrame->Instructions.push_back(Instruction);
  600   CurFrame->Instructions.push_back(Instruction);
  617   CurFrame->Instructions.push_back(Instruction);
  627   CurFrame->Instructions.push_back(Instruction);
  637   CurFrame->Instructions.push_back(Instruction);
  646   CurFrame->Instructions.push_back(Instruction);
  828   CurFrame->Instructions.push_back(Inst);
  850   CurFrame->Instructions.push_back(Inst);
  867   CurFrame->Instructions.push_back(Inst);
  884   CurFrame->Instructions.push_back(Inst);
  899   CurFrame->Instructions.push_back(Inst);
  913   CurFrame->Instructions.push_back(Inst);

  568       AddedEpilogs.push_back(EpilogStart);

  581       UndefinedSymbolData.push_back(MSD);
  584       ExternalSymbolData.push_back(MSD);
  588       ExternalSymbolData.push_back(MSD);
  607       LocalSymbolData.push_back(MSD);
  611       LocalSymbolData.push_back(MSD);

  512     DataRelocations.push_back(Rec);
  514     CodeRelocations.push_back(Rec);
  516     CustomSectionsRelocations[&FixupSection].push_back(Rec);

  213     AddrsigSyms.push_back(Sym);
  825     Sec->Relocations.push_back(Reloc);

  310     WaitSet.push_back(IR);
  317     PendingSet.push_back(IR);
  334     ReadySet.push_back(IR);

  183   void unget() { Stack.push_back(Tok); }
  262           Info.Exports.push_back(E);
  294       Info.Exports.push_back(E);

  325       Relocs.push_back(Rela);
  337         Relocs.push_back(Rela);
  417       Relocs.push_back(R);

  132   Mods.push_back(Mod);
  189     Comdats.push_back(Comdat);

  128   SymverAliasMap[Aliasee].push_back(AliasName);

  283     Sections.push_back(Sec);
  741     TargetFeatures.push_back(Feature);
  836     Section.Relocations.push_back(Reloc);
  932     Imports.push_back(Im);
  949     FunctionTypes.push_back(Type);
  996     Globals.push_back(Global);
 1013     Events.push_back(Event);
 1053     Exports.push_back(Ex);
 1159       Function.Locals.push_back(Decl);
 1168     Functions.push_back(Function);
 1192     ElemSegments.push_back(Segment);
 1231     DataSegments.push_back(Segment);

  677     StringTableOffsets.push_back(CurrentStringOffset);
  698     DataOffsets.push_back(SectionTwoSize);

  574     Result->Checksums.push_back(*ConvertedCS);
  600         Block.Columns.push_back(SCE);
  610       Block.Lines.push_back(SLE);
  612     Result->Lines.Blocks.push_back(Block);
  638         Site.ExtraFiles.push_back(*ExpF2);
  641     Result->InlineeLines.Sites.push_back(Site);
  666     Result->Imports.push_back(YCMI);
  684     Result->Symbols.push_back(*S);
  702     Result->Strings.push_back(S);
  731     Result->Frames.push_back(YF);
  917     Result.push_back(YamlSS);

  791     Result.push_back(CVT);

  296     PHeaders.push_back(Phdr);

  243         Ret.push_back(S);

   52   Expressions.push_back(E);
  662         Regions.push_back(CR);
  709       Regions.push_back(CR);
  728       Regions.push_back(CR);

  103     Filenames.push_back(Filename);
  247     MappingRegions.push_back(CMR);
  267     Filenames.push_back(TranslationUnitFilenames[I]);

  284     Record.Counts.push_back(Count);

   90     DetailedSummary.push_back(PSE);

  650       OffsetsToUse.push_back(FuncEntry.second);
  659       OffsetsToUse.push_back(iter->second);
  702     NameTable.push_back(*Name);

  427   GlobalParser->MoreHelp.push_back(Help);
 2210         CategorizedOptions[Cat].push_back(Opt);
 2451   ExtraVersionPrinters->push_back(func);

  190     Predecessors[it->second].push_back(it->first);
  191     Successors[it->first].push_back(it->second);
  198       Roots.push_back(*it);
  211       Worklist.push_back(*it);

   38     Res.push_back(LHS);
   40     Res.push_back(RHS);

   61       Handles.push_back(Handle);

  570           Substitutions.push_back(Substitution);
 1250       DagNotMatches.push_back(P);

  150       Replacements.push_back(I);

  138     Pat.Tokens.push_back(*BV);

   32     Plugins->push_back(Filename);

   74   void addStatistic(TrackingStatistic *S) { Stats.push_back(S); }

   86   Counts.push_back(Cnt);

   79     MatchesByLetter[Matches[i]->first[CharNo]].push_back(Matches[i]);

  220         Sequences.push_back(CurrInstr);

  564             ToErase.push_back(J.first);

 3607       Args.push_back(Entry);
 4906     Args.push_back(Entry);

  287     OutOps.push_back(NewOp);

 2581   Args.push_back(Entry);
 4061   Ops.push_back(Chain);
 4062   Ops.push_back(Callee);
 4114     Ops.push_back(InFlag);
 6208     Ops.push_back(Result);

 5200         CandidatesWithoutStackFixups.push_back(C);
 5208         CandidatesWithoutStackFixups.push_back(C);
 5216         CandidatesWithoutStackFixups.push_back(C);

   40     Args.push_back(Entry);
   42     Args.push_back(Entry);

   74     CurFrame->EpilogMap[CurrentEpilog].push_back(Inst);
   76     CurFrame->Instructions.push_back(Inst);
  187   CurFrame->EpilogMap[CurrentEpilog].push_back(Inst);

  249   Version.push_back(VersionMajor);
  250   Version.push_back(VersionMinor);

  342     Res.push_back(FirstDbgValue);
  351       Res.push_back(D->first);

  263     Schedule.push_back(SU);

  512     BBStarters.push_back(MI);

  189   BranchStack.push_back(Item);
  600           IfThenElseStack.push_back(MIb);
  615           IfThenElseStack.push_back(MIb);
  623             ToPopAfter.push_back(LastAlu.back());

  150         CachedConsts.push_back(BankLine);
  159         CachedConsts.push_back(BankLine);

  362       Result.push_back(DummyPair);
  369     Result.push_back(DummyPair);
  574       ValidSwizzle.push_back(TransBS);

  196     PhysicalRegCopy.push_back(SU);
  204     Available[IDOther].push_back(SU);
  206     Pending[IK].push_back(SU);
  340     AvailableAlus[AK].push_back(QSrc[i]);

   81         UndefReg.push_back(Chan);
  327     PreviousRegSeqByReg[(*It).first].push_back(RSI.Instr);
  329   PreviousRegSeqByUndefCount[RSI.UndefReg.size()].push_back(RSI.Instr);

 2920   Ops.push_back(Chain);
 2921   Ops.push_back(Callee);
 2934     Ops.push_back(PhysReturnAddrReg);
 2952     Ops.push_back(InFlag);

  199   SUnits.push_back(SU);
  295       TopReadySUs.push_back(SU);
  300     ScheduledSUnits.push_back(SU);
  413       TopReadySUs.push_back(SU);
  418     ScheduledSUnits.push_back(SU);
  495       TopReadySUs.push_back(SuccSU);
  545   Preds.push_back(Pred);
 1364       PosOld.push_back(Pos);
 1366         PosNew.push_back(Pos);
 1379         PosNew.push_back(CurrentTopFastSched);
 1553       ReadyBlocks.push_back(Block);
 1558     BlocksScheduled.push_back(Block);
 1717       ReadyBlocks.push_back(Block.first);
 1793       Res.SUs.push_back(SU->NodeNum);

  253     NewMIs.push_back(MemMI);
  254     NewMIs.push_back(UpdateMI);
  271     NewMIs.push_back(UpdateMI);
  272     NewMIs.push_back(MemMI);
  296               VI.Kills.push_back(NewMI);
  552       Pred.push_back(MO);

  533     CPEMIs.push_back(CPEMI);
  603     CPEMIs.push_back(CPEMI);

 1970   ResTys.push_back(ResTy);
 2557   ResTys.push_back(ResTy);
 4442     Ops.push_back(N->getOperand(0));
 4557     Ops.push_back(N->getOperand(0));
 4652     AsmNodeOperands.push_back(op);
 4670       AsmNodeOperands.push_back(op);
 4692       AsmNodeOperands.push_back(op);
 4776       AsmNodeOperands.push_back(PairedReg);
 4783     AsmNodeOperands.push_back(Glue);
 4818     OutOps.push_back(Op);

 2392   Ops.push_back(Chain);
 2393   Ops.push_back(Callee);
 2423     Ops.push_back(InFlag);
 3203   Args.push_back(Entry);
 8759     Args.push_back(Entry);
 8768   Args.push_back(Entry);
 8825     Args.push_back(Arg);
 9116   Args.push_back(Entry);
 9121   Args.push_back(Entry);
 9512       LPadList.push_back(*II);
15910     Ops.push_back(Result);
15950     Args.push_back(Entry);
16030   RetTyParams.push_back(RetTyElement);
16031   RetTyParams.push_back(RetTyElement);

   40     result.push_back(v[i]);

   78   Args.push_back(Entry);
   81     Args.push_back(Entry);
   87     Args.push_back(Entry);
   98     Args.push_back(Entry);
  101     Args.push_back(Entry);
  104     Args.push_back(Entry);

   81         ITStates.push_back(CCBits);

  220     OutOps.push_back(Op);
  228       OutOps.push_back(Base);
  229       OutOps.push_back(Disp);
  287       OutOps.push_back(Base);
  288       OutOps.push_back(Disp);
  303   OutOps.push_back(CopyFromReg);

  377     Args.push_back(Entry);
 2002     Ops.push_back(Result);

  318           PreserveArrayIndexCalls.push_back(Call);
  320           PreserveUnionIndexCalls.push_back(Call);
  322           PreserveStructIndexCalls.push_back(Call);

  173   OutOps.push_back(Op0);
  174   OutOps.push_back(Op1);
  175   OutOps.push_back(AluOp);

  175     EnumValues.push_back(BTFEnum);
  248     Members.push_back(BTFMember);
  299     Parameters.push_back(Param);
  677   Content.push_back(Line); // Line 0 for empty string
  708   LineInfoTable[SecNameOff].push_back(LineInfo);
  920   FuncInfoTable[SecNameOff].push_back(FuncInfo);
  959   FieldRelocTable[SecNameOff].push_back(FieldReloc);

 1206   Pending.push_back(Reg);
 3215     G.Ins.push_back(SI);
 3231       G.Ins.push_back(MI);
 3248     Groups.push_back(G);

   78       push_back(R);

  111       push_back(Range);

  376   Nodes.push_back(N);
  391     Nodes.push_back(Nx);
  439         Roots.push_back(N);
  443       NCM[PN].push_back(N);
  450     Work.push_back(Root);
  796       Bs.push_back(LF->second);
  886     Bs.push_back(Loc[Node->Parent]);
  964     Nodes.push_back(NewN);
 1141   Work.push_back(Node);
 1190       NA.push_back(Last);
 1226         Roots.push_back(CN);

 1224   Extenders.push_back(ED);
 1906       NewRegs.push_back(DefR.Reg);

  970       POT.push_back(B);

 2203       BlockFIMap[&B].push_back(P.first);

  441     Seq.push_back(VR);
  633     VRs.push_back(I->first);
  919         IFMap[VR].push_back(RR);
 1370       LL.push_back(M);

  923       OutOps.push_back(Res);
  925       OutOps.push_back(Inp);

  229       WorkQ.push_back(N);
  676     List.push_back(Res);
  993         Ops.push_back(R.OpV);
 1017       Ops.push_back(Op);

 1628         Pred.push_back(MO);
 1636         Pred.push_back(MO);

  174   Packet.push_back(SU);

   38   Args.push_back(Entry);
   40   Args.push_back(Entry);
   42   Args.push_back(Entry);

  290     WorkQ.push_back(R);
  300         WorkQ.push_back(*J);
  578     WorkQ.push_back(I);
  581       WorkQ.push_back(I);

  231       StoreGroups.push_back(G);
  244   Group.push_back(BaseStore);
  263         Group.push_back(MI);
  276       Other.push_back(MI);
  339   OG.push_back(FirstMI);
  363     OG.push_back(S2);
  439     NG.push_back(StI);
  447     NG.push_back(TfrI);
  462     NG.push_back(StI);

  329       foundBranches.push_back(ISJ);
  348         foundBranches.push_back(ISJ);
  376       foundBranches.push_back(ISJ);
  396         foundBranches.push_back(ISJ);
  403         foundBranches.push_back(ISJ);
  405         foundBranches.push_back(ISJ);
  407         foundBranches.push_back(ISJ);
  409         foundBranches.push_back(ISJ);

   65   Copies.push_back(SA.Id);

  347   Blocks.push_back(P);
 1482         ClosureIdx.push_back(i);

  711       void push(NodeAddr<DefNode*> DA) { Stack.push_back(DA); }

  543       PhiUQ.push_back(PhiA.Id);
  660           PhiUQ.push_back(P.first);

   50       Map.push_back(Val);

  264   OutOps.push_back(Op0);
  265   OutOps.push_back(Op1);
  266   OutOps.push_back(AluOp);

  355     Ops.push_back(Result);

  296   OutOps.push_back(Op0);
  297   OutOps.push_back(Op1);

  595     FuncOrigArgs.push_back(Entry);

  571     CPEMIs.push_back(CPEMI);

  321     OutOps.push_back(Op);

 2046     Args.push_back(Entry);
 3607     OutChains.push_back(Chain);
 4107     Ops.push_back(Result);
 4221     OutChains.push_back(Store);
 4365     OutChains.push_back(Store);

 1282     OutOps.push_back(Op);
 1288       OutOps.push_back(Base);
 1289       OutOps.push_back(Offset);
 1292     OutOps.push_back(Op);
 1302       OutOps.push_back(Base);
 1303       OutOps.push_back(Offset);
 1306     OutOps.push_back(Op);
 1315         OutOps.push_back(Base);
 1316         OutOps.push_back(Offset);
 1322         OutOps.push_back(Base);
 1323         OutOps.push_back(Offset);
 1328       OutOps.push_back(Base);
 1329       OutOps.push_back(Offset);
 1333     OutOps.push_back(Op);

 1121       localDecls[demotedFunc].push_back(GVar);
 1124       temp.push_back(GVar);

 3699       OutOps.push_back(Op0);
 3704       OutOps.push_back(Op0);
 3705       OutOps.push_back(Op1);

  329         OutOps.push_back(NewOp);
 2616       Ops.push_back(OpToConvToRecForm.getOperand(i));

 3160   Entry.Node = Trmp; Args.push_back(Entry);
 3165   Args.push_back(Entry);
 3167   Entry.Node = FPtr; Args.push_back(Entry);
 3168   Entry.Node = Nest; Args.push_back(Entry);
14458     Ops.push_back(Result);

 1573           Pred.push_back(MO);
 1580             Pred.push_back(MO);

  540   SwapVector.push_back(SwapEntry);

  180     OutOps.push_back(Op);
  183     OutOps.push_back(Op);

  563   Args.push_back(Entry);
 1993       OutChains.push_back(Store);
 2001     OutChains.push_back(Chain);

   40     UsedRegisters.push_back(registerIndex);

  178     AsmNodeOperands.push_back(op);
  196       AsmNodeOperands.push_back(op);
  302       AsmNodeOperands.push_back(PairedReg);
  309     AsmNodeOperands.push_back(Glue);
  391   OutOps.push_back(Op0);
  392   OutOps.push_back(Op1);

  569       OutChains.push_back(Chain);
 2142   Args.push_back(Entry);
 2172     Args.push_back(Entry);
 3248     Ops.push_back(Result);

 1688     OutOps.push_back(Base);
 1689     OutOps.push_back(Disp);
 1690     OutOps.push_back(Index);

  105         LogicOpsWorklist.push_back(LI);

  249   void push(NestingType NT) { NestingStack.push_back(NT); }

  313         Entries.back().Deferred.push_back(Next);
  344           Entries.back().Deferred.push_back(Next);

   69       WE->getParentException()->getSubExceptions().push_back(WE);

   73     Blocks.push_back(MBB);
   92   void addSubException(WebAssemblyException *E) { SubExceptions.push_back(E); }
  161     TopLevelExceptions.push_back(WE);

  227     OutOps.push_back(Op);

  900   SetjmpTableInsts.push_back(SetjmpTable);
  929     SetjmpRetPHIs.push_back(SetjmpRet);
  941     SetjmpTableInsts.push_back(NewSetjmpTable);
  942     SetjmpTableSizeInsts.push_back(NewSetjmpTableSize);
 1044       BBs.push_back(Tail);

   99     DtorFuncs[PriorityValue][Associated].push_back(DtorFunc);

   67   void addParam(MVT VT) { Params.push_back(VT); }
   70   void addResult(MVT VT) { Results.push_back(VT); }
   80   void addLocal(MVT VT) { Locals.push_back(VT); }

 5246   OutOps.push_back(Op0);
 5247   OutOps.push_back(Op1);
 5248   OutOps.push_back(Op2);
 5249   OutOps.push_back(Op3);
 5250   OutOps.push_back(Op4);

25418     Args.push_back(Entry);
27298   Args.push_back(Entry);
30976       LPadList.push_back(LP);
45749     Ops.push_back(Result);

 1275       LegalFPImmediates.push_back(Imm);

  870     LV->getVarInfo(InRegLEA).Kills.push_back(NewMI);
  871     LV->getVarInfo(OutRegLEA).Kills.push_back(ExtMI);
 5623       AddrOps.push_back(Op);
 5625       BeforeOps.push_back(Op);
 5627       AfterOps.push_back(Op);
 5630   AddrOps.push_back(Chain);
 5670       VTs.push_back(VT);
 5706     AddrOps.push_back(Chain);

   39     result.push_back(v[i]);

   83       Args.push_back(Entry);
   85       Args.push_back(Entry);

  791       UncondCodeSeq.push_back(Cond);

  126   OutOps.push_back(Reg);
  127   OutOps.push_back(Op.getOperand(0));

  471   Args.push_back(Entry);
  522   Args.push_back(Entry);
  525   Args.push_back(Entry);

   30     Entry.Node = Dst; Args.push_back(Entry);
   31     Entry.Node = Src; Args.push_back(Entry);
   32     Entry.Node = Size; Args.push_back(Entry);

   89     Ret.push_back(Path);

  494       NewGlobals.push_back(NGV);
  530       NewGlobals.push_back(NGV);
 1318     FieldMallocs.push_back(NMI);
 2259       AllCallsCold.push_back(F);

  261     AllocasForType.push_back(AI);

  192       Fragment.push_back(ObjIndex);
 1091         AliasesToErase.push_back(A);
 1974       Info.RefGlobals.push_back(GTM);
 2006       AddTypeIdUse(TypeId).CallSites.push_back(CI);
 2032         Targets.push_back(GTM);

  644       PDIUnrelatedWL.push_back(I);

  467   DFS.push_back(CurrEntry);
 1202   ToExtract.push_back(ClonedOI->NonReturnBlock);
 1480       Worklist.push_back(Result.second);

  265           DeadConstants.push_back(C);
  271           DeadConstants.push_back(C);

  387     SummaryTypeCheckedLoadUsers.push_back(FS);
  392     SummaryTypeTestAssumeUsers.push_back(FS);
  860       TargetsForSlot.push_back(VTP.FuncVI);
 1015       LocalWPDTargetsMap[TheFn].push_back(SlotSummary);
 1111         NewArgs.push_back(T);

 4745             NewArgs.push_back(NestVal);
 4746             NewArgAttrs.push_back(NestAttr);
 4778             NewTypes.push_back(NestTy);
 4784           NewTypes.push_back(*I);

  816         FnsToInstrument.push_back(NewF);
 1052       NonZeroChecks.push_back(Shadow);
 1322     DFSF.NonZeroChecks.push_back(Shadow);

 1132           AllocaDeclareMap[Alloca].push_back(DDI);

  667     ReferencedNames.push_back(Name);
  858   ReferencedNames.push_back(NamePtr);

  732       InstrumentBBs.push_back(InstrBB);

   73       Vector.push_back(InsertPair);

 1572     Expressions.push_back(Exp);

  744       Ranks.push_back(Entry.first);

 1132     Result.Blocks.push_back(Clone);
 1318     RRI.PHIValuesAtPseudoExit.push_back(NewPHI);

  146             Dep.push_back(Direction);
  149             Dep.push_back(Direction);
  162             Dep.push_back(Direction);
  169         DepMatrix.push_back(Dep);

 1256   LoopBlocks.push_back(NewPreheader);
 1283     NewBlocks.push_back(NewBB);
 1380   LoopProcessWorklist.push_back(NewLoop);
 1423       Worklist.push_back(Use);
 1474       Worklist.push_back(UI);
 1510     Worklist.push_back(UI);
 1594           Worklist.push_back(Use);
 1633               Worklist.push_back(Use);

  273       Calls.push_back(CI);
  285           Worklist.push_back(Succ);
  352     PollLocations.push_back(Term);

  361       StructValues.push_back(I->second);

 3873       SplitLoads.push_back(PLoad);
 4223       PromotableAllocas.push_back(NewAI);

  703   UnlinkedInstructions.push_back(C.Ins);

  130       DeadBlocks.push_back(BB);

  434       ToClone.push_back(Succ);

 1078       StructValues.push_back(input);
 1080       params.push_back(input);
 1090       StructValues.push_back(output);

  373     if (P != Preheader) BackedgeBlocks.push_back(P);

  553   Headers.push_back(Header);
  554   Latches.push_back(LatchBlock);
  652         Headers.push_back(New);
  654         Latches.push_back(New);
  659           HeaderSucc.push_back(New);
  663       NewBlocks.push_back(New);
  664       UnrolledLoopBlocks.push_back(New);

  127                                Visited.push_back(I);
  275   ForeBlocksFirst.push_back(Header);
  327           ForeBlocksFirst.push_back(New);
  329           ForeBlocksLast.push_back(New);
  334           SubLoopBlocksFirst.push_back(New);
  336           SubLoopBlocksLast.push_back(New);
  341           AftBlocksFirst.push_back(New);
  343           AftBlocksLast.push_back(New);
  358       NewBlocks.push_back(New);

  321     NewBlocks.push_back(NewBB);

  523     UnreachableRanges.push_back(R);
  539         UnreachableRanges.push_back(R);

   48           Allocas.push_back(AI);

 1098             PredCases.push_back(BBCases[i]);
 1146             PredCases.push_back(BBCases[i]);

 7147           Ingredients.push_back(SinkCandidate->second);
 7163       Ingredients.push_back(Instr);
 7169         Ingredients.push_back(SAInvIt->second);

 4092         OpVecs.push_back(OpVec);
 4132         OpVecs.push_back(OpVec);

   91     Path.push_back(FuncId);
  139     Path.push_back(Node->Func);
  177       Node->Callees.push_back(NewNode);

  197       Record.CallArgs.push_back(Arg);
  335       auto Adder = [&](const XRayRecord &R) { Records.push_back(R); };

  718       fpArrays.push_back(TgtPtrBegin);
  754     tgt_args.push_back(TgtPtrBegin);
  755     tgt_offsets.push_back(TgtBaseOffset);

  369       Attrs.push_back(A);
 1135         Attrs.push_back(A);

  344     SharedObjs.push_back(SharedObj);

   60   Todo.push_back(I);
   76         Todo.push_back(C);

  273     FuncsOnClone.push_back(F);
  404         MiscompiledFunctions.push_back(NewF);
  435       MiscompiledFunctions.push_back(NewF);
  508     FuncsOnClone.push_back(F);
  512     BBsOnClone.push_back(BB);
  600     MiscompiledFunctions.push_back(NewF);
  858         ResolverArgs.push_back(GEP);

  214     pass_args.push_back(PluginLoader::getPlugin(i));

  381       Args.push_back(Token);

  324     Data->Vect.push_back(Elem);

 1336     TryDispatchBlocks.push_back(block);

  217     Result.push_back(AllClones);

  422     ranges.push_back(R);
  432     fixits.push_back(F);
  635   void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); }

  528     TopLevelDecls.push_back(D);

  430       Checkers.push_back(CheckerName);
  448       Packages.push_back(PackageName);

  372     Roots.push_back(V);
  378     EndNodes.push_back(V);

   37         Fixes.push_back(Replacement);

   61     Callbacks.push_back(Callback);

  206       WarnOpts.push_back(*I);
  256   CInvok->getFrontendOpts().Inputs.push_back(Input);
  356   CInvok.getFrontendOpts().Inputs.push_back(Input);

 2267       FileEditEntries[Entry.File].push_back(Entry);

   53       AllProps.push_back(PropD);

  291   CachedActions.push_back(data);
  301   CachedActions.push_back(data);
  309   CachedActions.push_back(data);
  319   CachedActions.push_back(data);
  336   CachedActions.push_back(data);
  348   CachedActions.push_back(data);
  366   CachedActions.push_back(data);
  379   CachedActions.push_back(data);

  111     Traversers.push_back(traverser);

 3379   VariableArrayTypes.push_back(New);

  532         Results.push_back(ND);
  548       Results.push_back(ND);

   52   Globals.push_back(G);
  183   Globals.push_back(G);

 3311           RecordTypeList.push_back(FieldRecTy);

   49       Dest.Messages.push_back(Error->Errors[i].Messages[0]);

  286     Kinds.push_back(ArgKinds[ArgNo]);
  444     Kinds.push_back(ArgsKind);
  603         Constructed.push_back(SubMatcher);
  692       InnerArgs.push_back(Value.getMatcher());

  475       Args.push_back(ArgValue);

   76     DynMatchers.push_back(*Inner);

  140         IndexesToRemove.push_back(i);
  403       Result.push_back(NewGroup);
  517       Result.push_back(PotentialGroup);
  539   Variables.push_back(VarDecl);

  627     vec.push_back(it->first);
  646       declVec.push_back(*si);

   28     Blocks.push_back(*I);

  642   CurrentInstructions.push_back(E);
  724   CurrentArguments.push_back(Ph);
  726     IncompleteArgs.push_back(Ph);

  301         DiagInfo.push_back(D);

  463   MemBufferInfos.push_back(Entry);

  507       Options.MCOptions.IASSearchPaths.push_back(

 3909       Args.push_back(ElemPtr);

 3646         ObjCMethodCache[ID].push_back(FD);

  478     CXXThreadLocalInits.push_back(Fn);
  479     CXXThreadLocalInitVars.push_back(D);
  513       CXXGlobalInits.push_back(Fn);

 1110     ConstantStrings.push_back(ObjCStr);
 2485   ConstantStrings.push_back(ObjCStr);
 3602   Classes.push_back(ClassStruct);
 3666       allSelectors.push_back(entry.first);

 1956       RegResults.push_back(Tmp);
 2030     OutputConstraints.push_back(OutputConstraint);
 2043       ResultRegDests.push_back(Dest);
 2049         ResultRegTypes.push_back(ConvTy);
 2052         ResultRegTypes.push_back(ResultTruncRegTypes.back());
 2120       InOutArgs.push_back(Arg);
 2203     Args.push_back(Arg);
 2209     ArgTypes.push_back(InOutArgTypes[i]);
 2210     Args.push_back(InOutArgs[i]);

 1001       OpportunisticVTables.push_back(RD);

 3046     MultiVersionFuncs.push_back(GD);
 3507         CXXThreadLocals.push_back(D);
 4081       CXXThreadLocals.push_back(D);
 4452   Aliases.push_back(GD);
 4541   Aliases.push_back(GD);
 5759       CXXGlobalInits.push_back(InitFunction);

 1247     DeferredVTables.push_back(RD);

   32   SkippedRanges.push_back(Range);
  529     RegionStack.push_back(DR);
  623         SourceRegions.push_back(Region);
 1343   CoverageMappings.push_back(CoverageMapping);

  105       VBPtrOffsets.push_back(Offs);
 2326       NonComdatInits.push_back(F);

 1225   ResultTruncRegTypes.push_back(CoerceTy);
 1230   ResultRegDests.push_back(ReturnSlot);

  202           Composed.push_back(MO);
  232 void MultilibSet::push_back(const Multilib &M) { Multilibs.push_back(M); }

  567         BlacklistFiles.push_back(BLPath);
  568         ExtraDeps.push_back(BLPath);

   63       Features.push_back(FeatureName);

   73     Features.push_back(HVXFeature);
   91     Features.push_back(HVXFeature);
  434     RootDirs.push_back(TargetDir);

  133         AlwaysInstrumentFiles.push_back(Filename);
  134         ExtraDeps.push_back(Filename);
  142         NeverInstrumentFiles.push_back(Filename);
  143         ExtraDeps.push_back(Filename);
  151         AttrListFiles.push_back(Filename);
  152         ExtraDeps.push_back(Filename);

 1288     State.Stack.push_back(NewParenState);

 2189       AssociatedCommentLines.push_back(Line);

  423       CachedCompletionResults.push_back(CachedResult);
  460           CachedCompletionResults.push_back(CachedResult);
  496       CachedCompletionResults.push_back(CachedResult);
 1048       TopLevelDecls.push_back(D);
 1439       Resolved.push_back(D);

  138     CInvok->getFrontendOpts().Inputs.push_back(InputFile);

 1147     Opts.LinkBitcodeFiles.push_back(F);
 3061         Opts.OMPTargetTriples.push_back(TT);

  592           CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);

  561       SearchList.push_back(Include.second);
  569       SearchList.push_back(Include.second);
  581       SearchList.push_back(Include.second);
  585       SearchList.push_back(Include.second);

  246       mutationListeners.push_back(mutationListener);
  248       serializationListeners.push_back(serializationListener);

   83     RawTokens.push_back(RawTok);

 6855       OptInstanceMethods.push_back(MD);
 6857       InstanceMethods.push_back(MD);
 6863       OptClassMethods.push_back(MD);
 6865       ClassMethods.push_back(MD);
 6870     AllMethods.push_back(InstanceMethods[i]);
 6872     AllMethods.push_back(ClassMethods[i]);
 6874     AllMethods.push_back(OptInstanceMethods[i]);
 6876     AllMethods.push_back(OptClassMethods[i]);
 7061     RefedProtocols.push_back(*I);

 1301       Mod->Conflicts.push_back(Conflict);
 1303       Mod->UnresolvedConflicts.push_back(UC);
 2685   ActiveModule->UnresolvedConflicts.push_back(Conflict);

   27   BacktrackPositions.push_back(CachedLexPos);

   72   CondDirectiveLocs.push_back(DirLoc);

  615   PragmaPushMacroInfo[IdentInfo].push_back(MI);

  262     PreprocessedEntities.push_back(Entity);
  270     PreprocessedEntities.push_back(Entity);

 1365   CommentHandlers.push_back(Handler);

  565     TokenStream.push_back(Tok);

  315       Atomic64BitTypes.push_back(AtomicLongT);
  316       Atomic64BitTypes.push_back(AtomicULongT);
  317       Atomic64BitTypes.push_back(AtomicDoubleT);
  319         Atomic64BitTypes.push_back(AtomicSizeT);
  320         Atomic64BitTypes.push_back(AtomicIntPtrT);
  321         Atomic64BitTypes.push_back(AtomicUIntPtrT);
  322         Atomic64BitTypes.push_back(AtomicPtrDiffT);

 1045     Results.push_back(R);
 1060     Results.push_back(R);
 1168   Results.push_back(R);
 1233     Results.push_back(R);
 1346   Results.push_back(R);
 1355   Results.push_back(R);

 4357     DiagnosticIdentifiers.push_back(RuleName);
 6176     Sanitizers.push_back(SanitizerName);

11644   RecordTypeList.push_back(Ty);
11670           RecordTypeList.push_back(FieldRecTy);

 1063         HiVals.push_back(HiVal);

   69     DiagnosticIdentifiers.push_back(RuleName);

 4320         Unresolved.Mod->Conflicts.push_back(Conflict);

 5532     MacroInfosToEmit.push_back(Info);

  167       Merged->Files.push_back(ODT->File);

  150           Pairs.push_back(ClonePair);

  131     Sizeofs.push_back(E);

 2629       Pieces.push_back(piece);
 2728           (*Notes)[ErrorNode].push_back(LastPiece);
 2841     EQClassesVector.push_back(EQ);

  780   DeclCheckers.push_back(info);
  784   BodyCheckers.push_back(checkfn);
  794   StmtCheckers.push_back(info);
  800   StmtCheckers.push_back(info);
  804   PreObjCMessageCheckers.push_back(checkfn);
  808   ObjCMessageNilCheckers.push_back(checkfn);
  812   PostObjCMessageCheckers.push_back(checkfn);
  816   PreCallCheckers.push_back(checkfn);
  819   PostCallCheckers.push_back(checkfn);
  823   LocationCheckers.push_back(checkfn);
  827   BindCheckers.push_back(checkfn);
  831   EndAnalysisCheckers.push_back(checkfn);
  835   BeginFunctionCheckers.push_back(checkfn);
  839   EndFunctionCheckers.push_back(checkfn);
  844   BranchConditionCheckers.push_back(checkfn);
  848   NewAllocatorCheckers.push_back(checkfn);
  852   LiveSymbolsCheckers.push_back(checkfn);
  856   DeadSymbolsCheckers.push_back(checkfn);
  860   RegionChangesCheckers.push_back(checkfn);
  864   PointerEscapeCheckers.push_back(checkfn);
  869   PointerEscapeCheckers.push_back(checkfn);
  873   EvalAssumeCheckers.push_back(checkfn);
  877   EvalCallCheckers.push_back(checkfn);
  882   EndOfTranslationUnitCheckers.push_back(checkfn);

  165   FreeNodes.push_back(node);
  420       ChangedNodes.push_back(V);

 3127       Src.push_back(N);

  280     FileIDs.push_back(FID);
  643     PopUpRanges.push_back(Range);

   41     Mgr.freeStates.push_back(s);

 2086     List.push_back(V);

  455     PathConsumers.push_back(Consumer);

  146   void addNode(Node &N) { Nodes.push_back(N); }
  226       Tree.Leaves.push_back(MyId);
  287     Postorder.push_back(Id);
  297   Ids.push_back(Root);
  300       Ids.push_back(Child);
  739       Result.push_back(List.top());

  104       Files.push_back(File);

   32         AdjustedArgs.push_back(Args[i]);
   48         AdjustedArgs.push_back(Args[i]);
   70       AdjustedArgs.push_back(Args[i]);
   84         AdjustedArgs.push_back(Args[i]);
  146       AdjustedArgs.push_back(Args[I]);

  196       NewReplaces.push_back(R);
  202       NewReplaces.push_back(R);
  494       Result.push_back(R);

   61       CommandLine.push_back(Argument);
  387           Command->push_back(Scalar);
  428     IndexByFile[NativeFilePath].push_back(Cmd);
  429     AllCommands.push_back(Cmd);

   93       OverriddenMethods.push_back(MethodDecl);
   95       InstantiatedMethods.push_back(MethodDecl);
  101     PartialSpecs.push_back(PartialSpec);

  208         RenameInfos.push_back(Info);
  317       RenameInfos.push_back(Info);
  326         UsingDecls.push_back(Using);
  346         RenameInfos.push_back(Info);
  396           RenameInfos.push_back(Info);
  433           RenameInfos.push_back(Info);

   35   Callbacks.push_back(Callback);

  245       Expansions.push_back(Token);
  481     File.Mappings.push_back(M);
  503         File.Mappings.push_back(M);
  601     Keys.push_back(F.first);

   51     Args.push_back(A);

   65       Unflagged.push_back(entry);
   67       Flagged.push_back(entry);
   68       flagHistogram[entry.Flag].push_back(diagID);

   58     TUFiles.push_back(I->path());
   77     TUs.push_back(TU);
  102     TUFiles.push_back(I->path());
  121     TUs.push_back(TU);
  160       GroupedReplacements[*Entry].push_back(R);

  714   MoveNamespaces[SM.getFilename(Start)].push_back(MoveNs);
  765   InsertFwdDecls[Insertion.getFilePath()].push_back(InsertFwd);

   35         Results.push_back(E.second);

   19     LookupTable[Symbol.Symbol.getName()].push_back(Symbol);

   54       Results.push_back(Symbol);

  426     FixerReplacements.push_back(*Replacements);

  151   MoveTool->getMovedDecls().push_back(D);
  496   RemovedDecls.push_back(Decl);
  674     MovedDecls.push_back(ND);
  675     HelperDeclarations.push_back(ND);
  679     MovedDecls.push_back(UD);
  709     HeaderIncludes.push_back(IncludeLine);
  716     CCIncludes.push_back(IncludeLine);
  729       UnremovedDecls.push_back(D);
  742         RemovedDecls.push_back(D);
  804       NewHeaderDecls.push_back(MovedDecl);
  806       NewCCDecls.push_back(MovedDecl);
  823     ActualNewCCDecls.push_back(D);

   77     Bindings.push_back(Result.Nodes);

  448       CheckNames.push_back(CheckFactory.first);

  650     Sizes.push_back(Size);

  264       RawOptions.push_back(*Result);
  268   RawOptions.push_back(CommandLineOptions);

   54       DeclNameToDefinitions[DeclName].push_back(RecordDecl);
   60       DeclNameToDeclarations[DeclName].push_back(RecordDecl);

  112         Blocks.push_back(I);
  118       IncludeIndices.push_back(I);

  102       Contexts.push_back(Context);

  574     EnclosingAtFront.push_back(EnclosingScope);
  748       Results.push_back(Result);
 1831       LSP.additionalTextEdits.push_back(FixIt);
 1843     LSP.additionalTextEdits.push_back(*InsertInclude->Insertion);

   84       Out.Ranges.push_back(*Range);

  212       Result.push_back(R);
  227       Result.push_back(R);

   95   Chunks.push_back(C);

  144     CurrentLevel.push_back(It->second);
  156           CurrentLevel.push_back(Child);

   53   void EnteredContext(DeclContext *Ctx) override { Visited.push_back(Ctx); }
  356       Unresolved.Scopes.push_back(*Extracted->ResolvedScope);

   83       TopLevelDecls.push_back(D);

   63       F.Chunks.push_back(*Chunk);

  153         NonConflicting.push_back(TokRef.front());

   24     Result.push_back(R);

  842         Enclosing.push_back(NSName);

  149       Result.push_back(D);
 1208       Result.push_back(ParentDecl);

   63     Requests.push_back(Request);

   79       Edges.push_back(*AbsPath);

  127       SymbolSlabs.push_back(FileAndSymbols.second);
  129       RefSlabs.push_back(FileAndRefs.second.Slab);
  134       RelationSlabs.push_back(FileAndRelations.second);
  205       AllRelations.push_back(R);

  103     NodeForIncluding.first->getValue().DirectIncludes.push_back(NodeForInclude);

   32           .push_back(R.Object);

   73     void insert(const Relation &R) { Relations.push_back(R); }

  541       Sources.push_back(Source.getValue());

   94       TempInvertedIndex[Token].push_back(SymbolRank);

   55           .push_back(Rel.Object);

   69       SymIDs.push_back(Sym.ID);
  182       IDs.push_back(*SID);
  229       IDs.push_back(*SID);

  173       IdentsToQualify.push_back(Loc);

  527   CDB.ExtraClangFlags.push_back(FooCpp);

 1161     Requests.push_back(Req);

  718     Results.push_back(Object.ID);

  433   D.Notes.push_back(NoteInMain);
  442   D.Notes.push_back(NoteInHeader);
  446   D.Fixes.push_back(F);

  131     Changes.push_back(ChangedFiles);
  159   Cmd.CommandLine.push_back(Cmd.Filename);

  278     MacroExpansionPositions.push_back(R.start);

  139       It->second.push_back(Token);

  270     Args.push_back(TestFileName);

  240       Result.push_back(Inclusion.Written);
  317           [&, ID](std::vector<Diag> Diags) { DiagsSeen.push_back(ID); });
  327             ReadsCanceled.push_back(ID);
  334           ReadsSeen.push_back(ID);
  710       AllStatus.push_back(Status);

  488                      Result.push_back(Object.ID);

  418       UnaccountedForHeaders.push_back(*I);

  366         NewArgs.push_back(FileDependents[Index]);
  492     CurHeaderContents[Loc.File].push_back(HE);

  206       CurrentModule->SubModules.push_back(SubModule);
  211   CurrentModule->HeaderFileNames.push_back(FilePath);

  553     InclusionPathHandles.push_back(H);
  570       InclusionPathHandles.push_back(H);
  651     InclusionPathHandles.push_back(H);
  668       InclusionPathHandles.push_back(H);
  845     IncludeDirectives.push_back(IncludeDirectiveItem);
  980     HeaderStack.push_back(H);

  633     Results.push_back(DelPair);

 3504     Args->push_back(source_filename);
 8506   entries.push_back(entry);
 8685       wantedRanges.push_back(*i);
 8687       wantedRanges.push_back(*i);

 1510     pool.AllCursors.push_back(Vec);
 1530     pool.AvailableCursors.push_back(Vec);
 1557   pool.AvailableCursors.push_back(Vec);

  356   CurrentDiags.back()->Ranges.push_back(SR);

  508     Args->push_back(source_filename);

   63       Args.push_back(Arg);

   73     Toks.push_back(Tok);

   39     Values.push_back(Value);
   58     Matchers.push_back(ToStore);

   77     toks.push_back(tok);
  286     toks.push_back(tok);
  408     toks.push_back(tok);

   90     toplevel_decls.push_back(*I);

  131       UnexpectedInitial.push_back(E);
  151         UnexpectedNonInitial.push_back(E);

   76       toks.push_back(tok);
  396       ArgTokens.push_back(Eof);
  400       ArgTokens.push_back(Eof);
  402       ArgTokens.push_back(tok);

   95     toks.push_back(tok);

  127     Types.push_back(Results.PreferredType);

  215     Sources.push_back(Source);
  218   void PushWatcher(DiagnosticWatcher *Watcher) { Watchers.push_back(Watcher); }

  128         Fixes.push_back(Replacement);

  276     Files.push_back(File);
  278     ExpectedSymbols.push_back(Symbol);

  797         uniques.push_back(i);
 1868         Rules.push_back(It->second.getRule());
 2011     SubMatchRules[Rule.MetaSubject].push_back(Rule);
 2657         Attrs.push_back(Attr);
 2776       PragmaAttrs.push_back(Attr);
 3031         GNU.push_back(R);
 3033         Declspec.push_back(R);
 3035         Microsoft.push_back(R);
 3037         CXX[SI.nameSpace()].push_back(R);
 3039         C2x[SI.nameSpace()].push_back(R);
 3041         Pragma.push_back(R);
 3938     Spellings[(size_t)Kind].push_back(Name);

   70     NameToUTF8.push_back(Match);

   46       MatchesEndTagOptional.push_back(Match);
   48       MatchesEndTagForbidden.push_back(Match);

   51         Mapping[SubGroups[j]].push_back(DiagGroups[i]);
  117         CategoryStrings.push_back(Category);
  172     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
 1154     MP->Pieces.push_back(D.Root);

  209       List.push_back(T);

   74     GroupsInGroup[Group].push_back(R);
   79       Aliases[A->getDef()].push_back(R);
   87         Aliases[OptionsByName[Name.substr(3)]].push_back(R);
   91         Aliases[OptionsByName[Name[0] + Name.substr(4)]].push_back(R);
   99     OptionsInGroup[Group].push_back(R);

  205 	MacrosToUndef.push_back(macroName);

  484       ToRet.push_back(Predecessor);
  586     output.push_back(V);
  628       output.push_back(Arg);
 1136     ArgTypes.push_back(ArgType);
 1574       key.push_back(MG.ParamTypes[i]);
 1576         key.push_back(OI.ParamValues[i]);
 1581         ParamNumbers.push_back(Found->second);
 1588       ParamNumbers.push_back(ExistingIndex);

 1580     Types.push_back(R.first);
 1581     Values.push_back(R.second);
 1717           Revved.push_back(Elts2[VI + LI]);

   72         Result.push_back(Derived);

  112     RangeAttributes.push_back(Attr);

 1175     Linker.DIELocs.push_back(Loc);
 1178     Linker.DIEBlocks.push_back(Block);
 1900         Seq.push_back(NextLine);
 2461   DIEBlocks.push_back(String);

  215     CompUnits.push_back(CU.LabelBegin);

  118       Inputs.push_back(Input);
  140       Inputs.push_back(DirIt->path());

  305       extra.push_back(opt_);
  784     Cleanup.push_back(Filename);

  877   mc->sections.push_back(c);

  145     m[sym->getDLLName().lower()].push_back(sym);
  640       thunks.push_back(t);
  650     thunks.push_back(tm);

   24   void add(DefinedImportData *sym) { imports.push_back(sym); }
   41   void add(DefinedImportData *sym) { imports.push_back(sym); }

  175   filePaths.push_back(filename);
  180     resources.push_back(mbref);
  355     config->exports.push_back(exp);
  502     searchPaths.push_back(path);
  510     config->gcroot.push_back(b);
  754     exports.push_back(e2);
  839       config->exports.push_back(e2);
  849     config->exports.push_back(e2);
 1008       resourceObjFiles.push_back(f);
 1067     config->exports.push_back(e);
 1666     config->exports.push_back(e);
 1899         ObjFile::instances.push_back(file);

  655       v.push_back(e);

  135         classes.push_back(c.eqClass[cnt % 2]);
  251         chunks.push_back(sc);

  133     v.push_back(mbref);
  277     debugChunks.push_back(c);
  279     guardFidChunks.push_back(c);
  281     guardLJmpChunks.push_back(c);
  283     sXDataChunks.push_back(c);
  291     resourceChunks.push_back(c);
  437       pendingIndexes.push_back(i);
  931     symbols.push_back(sym);
  933       config->gcroot.push_back(sym);

  160     symbols.push_back(thunk);

   54           v.push_back(sym);

  621   strTableRefs.push_back(index);
 1444   ebs.Fields.push_back(path);

   48     ObjFile::instances.push_back(f);
   50     BitcodeFile::instances.push_back(f);
   52     ImportFile::instances.push_back(f);
  738       syms.push_back(pair.second);
  800     ObjFile::instances.push_back(obj);

  295   chunks.push_back(c);
  331   contribSections.push_back(sec);
  804       outputSections.push_back(sec);
  837     pSec->chunks.push_back(c);
 1163           outputSymtab.push_back(*sym);

   73       ret.push_back(s);

   32     lineTables.push_back(lt);

   40       patterns.push_back(*pat);
   62     hex.push_back(h);

  559   patches.push_back(ps);

  465   patches.push_back(psec);

  110       sections.push_back(isec);
  220       sorted.push_back(i);

 1389       syms.push_back(sym);
 1583     objectFiles.push_back(file);
 1857         inputSections.push_back(s);

  452       sections.push_back(s);

  163     binaryFiles.push_back(f);
  176     lazyObjFiles.push_back(f);
  192     bitcodeFiles.push_back(f);
  198   objectFiles.push_back(file);

  261       v.push_back(base);
  265     v.push_back(base);
  435       ret.push_back(sec);
  690           v.push_back(os);
  996     defPhdrs.push_back(firstPtLoad->name);
 1133     ret.push_back(phdr);
 1198       ret.push_back(*idx);

   61           v.push_back(dr);
  121     pieces.push_back(p);

  263       cNamedSections[saver.save("__start_" + sec->name)].push_back(sec);
  264       cNamedSections[saver.save("__stop_" + sec->name)].push_back(sec);

  101   isd->sectionBases.push_back(isec);
  198         mergeSections.push_back(syn);

  832       canon->locs.push_back(undef.locs[0]);
 1560             newThunks.push_back(ts.first);
 1725   thunkVec->push_back(t);

   88   mbs.push_back(mb);
  186       ret.push_back(s);

  191     config->dynamicList.push_back(v);
  452     script->phdrsCommands.push_back(cmd);
  535         v.push_back(cmd);
  543       v.push_back(cmd);
  702     script->keptSections.push_back(cmd);
 1284   script->referencedSymbols.push_back(tok);
 1348     config->versionDefinitions[VER_NDX_LOCAL].patterns.push_back(pat);
 1350     config->versionDefinitions[VER_NDX_GLOBAL].patterns.push_back(pat);
 1363     config->versionDefinitions[VER_NDX_LOCAL].patterns.push_back(pat);
 1370   config->versionDefinitions.push_back(ver);

   71   symVector.push_back(sym);
  125       (*demangledSyms)[demangleItanium(sym->getName())].push_back(sym);
  153       res.push_back(sym);

  175       sections.push_back(sec);
  232       sections.push_back(sec);
  366     cieRecords.push_back(rec);
  442   sections.push_back(sec);
 1173   strings.push_back(s);
 1554   relocs.push_back(reloc);
 1695       relatives.push_back(r);
 1697       nonRelatives.push_back(r);
 1715       group.push_back(*i++);
 2046     arr[s.sym->file].push_back(s);
 2548         ret.push_back(isec);
 2665           symbols[shardId][idx - 1].cuVector.push_back(v);
 3032   sections.push_back(ms);
 3169         exidxSections.push_back(isec);
 3176     executableSections.push_back(isec);
 3273     selectedSections.push_back(executableSections[0]);
 3279         selectedSections.push_back(executableSections[i]);
 3361   thunks.push_back(t);

  169       newSections.push_back(copy);
 1270       unorderedSections.push_back(isec);
 1317     isd->sections.push_back(isec);
 1319     isd->sections.push_back(p.first);
 1321     isd->sections.push_back(isec);
 1525           sections.push_back(isec);
 1822       outputSections.push_back(sec);
 2155     ret.push_back(tlsHdr);
 2162     ret.push_back(relRo);
 2220   part.phdrs.push_back(entry);
 2673     ret.push_back(arr);

   71     _deadStripRoots.push_back(symbolName);
  134   void appendLLVMOption(const char *opt) { _llvmOptions.push_back(opt); }
  145     _initialUndefinedSymbols.push_back(symbolName);

   68     _messages.push_back(msg);

   74   _kindEntries.push_back(entry);

  285         ret.push_back(undef);

  122   relocs.push_back(reloc);

  392         personalities.push_back(unwindEntry.personalityFunction);
  510           usedDwarfWorklist.push_back(cfiTarget);

  260      _sectionAtoms[inSection].push_back(offAndAtom);

  128       entries.push_back(it.second);

  471   _rpaths.push_back(rpath);
  497       _searchDirs.push_back(libPath);
  527     _frameworkDirs.push_back(fwPath);
  771     _allDylibs.push_back(dylib);
  797   _sectAligns.push_back(entry);
  932   _orderFiles[symbol].push_back(info);

  321           f->sections.push_back(section);
  363           f->sections.push_back(section);
  400             f->stabsSymbols.push_back(sout);
  402             f->undefinedSymbols.push_back(sout);
  404             f->globalSymbols.push_back(sout);
  406             f->localSymbols.push_back(sout);
  432             f->undefinedSymbols.push_back(sout);
  434             f->globalSymbols.push_back(sout);
  436             f->stabsSymbols.push_back(sout);
  438             f->localSymbols.push_back(sout);
  468       f->dependentDylibs.push_back(entry);
  503       f->dataInCode.push_back(entry);
  523         f->exportInfo.push_back(normExport);

 1277         allNodes.push_back(bNode);
 1316   allNodes.push_back(newNode);
 1437   allNodes.push_back(rootNode);

  251   _sectionInfos.push_back(sect);
  336     _sectionInfos.push_back(sect);
  370     _customSections.push_back(sect);
  371     _sectionInfos.push_back(sect);
  394   sect->atomsAndOffsets.push_back(ai);
  433     sectionForAtom(atom)->atomsAndOffsets.push_back(ai);
  478   _segmentInfos.push_back(info);
  533     seg->sections.push_back(si);
  633     file.segments.push_back(seg);
  834           atomsNeedingDebugNotes.push_back(info.atom);
  940       _stabs.push_back(stab);
 1050     file.stabsSymbols.push_back(sym);
 1067           globals.push_back(ai);
 1077           file.localSymbols.push_back(sym);
 1093         file.localSymbols.push_back(sym);
 1110     file.globalSymbols.push_back(sym);
 1118     undefs.push_back(ai);
 1122     undefs.push_back(ai);
 1142     file.undefinedSymbols.push_back(sym);
 1182               normSect.indirectSymbols.push_back(index);
 1201           normSect.indirectSymbols.push_back(index);
 1210           normSect.indirectSymbols.push_back(index);
 1248         nFile.dependentDylibs.push_back(depInfo);
 1402               file.dataInCode.push_back(entry);
 1415         file.dataInCode.push_back(entry);
 1445             nFile.rebasingInfo.push_back(rebase);
 1457             nFile.bindingInfo.push_back(bind);
 1473           nFile.lazyBindingInfo.push_back(bind);
 1556       nFile.exportInfo.push_back(exprt);

  812     stabsList.push_back(stab);

   74       shims.push_back(element.second);

  284       targetsNeedingStubs.push_back(it.first);

  100       entries.push_back(it.second);

  826         _references.push_back(r);

   42   f.sections.push_back(textSection);
   49   f.globalSymbols.push_back(fooSymbol);
   56   f.globalSymbols.push_back(barSymbol);
   60   f.undefinedSymbols.push_back(undefSym);
   67   f.localSymbols.push_back(bazSymbol);

  205     v.push_back(mbref);

  355         symbols.push_back(d);

   27     inputSegments.push_back(inSeg);

   40     sharedFiles.push_back(f);
   50     bitcodeFiles.push_back(f);
   57   objectFiles.push_back(f);
   79     objectFiles.push_back(obj);
  572     variants.push_back(sym);
  586     variants.push_back(variant);

  261   staticGotSymbols.push_back(sym);
  297   inputGlobals.push_back(global);
  317   inputEvents.push_back(event);

  120       customSectionMapping[name].push_back(section);
  315   outputSections.push_back(sec);
  544     out.exportSec->exports.push_back(export_);
  679         segments.push_back(s);

  534       names.push_back(name);

  172       m_files.push_back(file);

  128     void AppendEntry(const Entry &&entry) { children.push_back(entry); }

  511       m_stack.push_back(sp);

  107   void add(const LoadedModuleInfo &mod) { m_list.push_back(mod); }

  335     m_specs.push_back(spec);

   47     m_collection.push_back(object);

   42   void Append(const Entry &e) { m_map.push_back(e); }
  125       values.push_back(entry.value);
  137         values.push_back(pos->value);

  135     m_variables.push_back(var_sp);
  142     m_variables.push_back(var_sp);

   55     m_actions.push_back(action);
  102       m_actions.push_back(default_action);

   40     m_file_actions.push_back(info);

   75       m_values.push_back(value_sp);
   88         m_values.push_back(value_sp);

   77     m_macro_entries.push_back(entry);

  309   void Append(const lldb::TypeImplSP &type) { m_content.push_back(type); }
  505     m_content.push_back(type);

  101           m_scavengers.push_back(scavenger);

  921     m_platforms.push_back(platform_sp);
  965       m_platforms.push_back(platform_sp);

  126     m_pending_items.push_back(item);

  166   void Append(const ProcessInstanceInfo &info) { m_infos.push_back(info); }

  343   void Append(const Entry &entry) { m_entries.push_back(entry); }
  351       m_entries.push_back(entry);
  732         indexes.push_back(entry.data);

   28       m_streams.push_back(stream_sp);
   35       m_streams.push_back(stream_sp);
   37       m_streams.push_back(stream_2_sp);
   78     m_streams.push_back(stream_sp);

  274     void Push(ObjectSP item) { m_items.push_back(item); }
  276     void AddItem(ObjectSP item) { m_items.push_back(item); }

  852     m_break_ids.push_back(id);

   39     m_regions.push_back(sb_region);

  127               m_pending_items.push_back(item);

  928               step_over_until_addrs.push_back(step_addr);

   35   void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); }

  752           old_id_vec.push_back(old_id);
  758               old_id_vec.push_back(tmp_iter->first);
  766               new_id_vec.push_back(tmp_iter->first);

   47   m_breakpoint_ids.push_back(bp_id);
   58   m_breakpoint_ids.push_back(*bp_id);
   93       m_breakpoint_ids.push_back(*bp_id);

   35   m_breakpoints.push_back(bp_sp);

   31     m_break_loc_collection.push_back(bp_loc);

   37   m_locations.push_back(bp_loc_sp);

  129           sc_to_remove.push_back(i);

   35   arg.push_back(search_word_arg);
   38   m_arguments.push_back(arg);

  824     m_arguments.push_back(arg);
  896     m_arguments.push_back(arg);
 1004     m_arguments.push_back(arg);
 1097     arg.push_back(bp_id_arg);
 1100     m_arguments.push_back(arg);
 1382     m_arguments.push_back(arg);
 1652     arg1.push_back(id_arg);
 1653     m_arguments.push_back(arg1);
 1753     arg1.push_back(id_arg);
 1754     m_arguments.push_back(arg1);
 1832     arg1.push_back(id_arg);
 1833     m_arguments.push_back(arg1);
 2019     m_arguments.push_back(arg);
 2137     m_arguments.push_back(arg);

  219     arg.push_back(bp_id_arg);
  222     m_arguments.push_back(arg);
  407             m_bp_options_vec.push_back(bp_options);
  487     arg.push_back(bp_id_arg);
  490     m_arguments.push_back(arg);
  607     arg.push_back(bp_id_arg);
  610     m_arguments.push_back(arg);

  203     arg.push_back(file_arg);
  206     m_arguments.push_back(arg);
  493     arg1.push_back(alias_arg);
  501     arg2.push_back(cmd_arg);
  509     arg3.push_back(options_arg);
  512     m_arguments.push_back(arg1);
  513     m_arguments.push_back(arg2);
  514     m_arguments.push_back(arg3);
  764     arg.push_back(alias_arg);
  767     m_arguments.push_back(arg);
  845     arg.push_back(alias_arg);
  848     m_arguments.push_back(arg);
 1375     arg1.push_back(cmd_arg);
 1378     m_arguments.push_back(arg1);
 1515     arg1.push_back(cmd_arg);
 1518     m_arguments.push_back(arg1);
 1784     arg1.push_back(cmd_arg);
 1787     m_arguments.push_back(arg1);

  354         ranges.push_back(range);
  367           ranges.push_back(range);
  403               ranges.push_back(range);
  420                     ranges.push_back(range);
  429       ranges.push_back(range);
  495         ranges.push_back(range);

  274   arg.push_back(expression_arg);
  277   m_arguments.push_back(arg);

  135     arg.push_back(index_arg);
  138     m_arguments.push_back(arg);
  295     arg.push_back(index_arg);
  298     m_arguments.push_back(arg);
  435     arg.push_back(var_name_arg);
  438     m_arguments.push_back(arg);
 1008     arg.push_back(index_arg);
 1011     m_arguments.push_back(arg);

   60   arg.push_back(command_arg);
   63   m_arguments.push_back(arg);

   71     arg1.push_back(channel_arg);
   76     arg2.push_back(category_arg);
   79     m_arguments.push_back(arg1);
   80     m_arguments.push_back(arg2);
  212     arg1.push_back(channel_arg);
  217     arg2.push_back(category_arg);
  220     m_arguments.push_back(arg1);
  221     m_arguments.push_back(arg2);
  276     arg.push_back(channel_arg);
  279     m_arguments.push_back(arg);

  311     arg1.push_back(start_addr_arg);
  319     arg2.push_back(end_addr_arg);
  322     m_arguments.push_back(arg1);
  323     m_arguments.push_back(arg2);
  975     arg1.push_back(addr_arg);
  983     arg2.push_back(value_arg);
  986     m_arguments.push_back(arg1);
  987     m_arguments.push_back(arg2);
 1261     arg1.push_back(addr_arg);
 1269     arg2.push_back(value_arg);
 1272     m_arguments.push_back(arg1);
 1273     m_arguments.push_back(arg2);
 1616     arg1.push_back(addr_arg);
 1619     m_arguments.push_back(arg1);

  790     arg1.push_back(file_arg_remote);
  797     arg2.push_back(file_arg_host);
  801     m_arguments.push_back(arg1);
  802     m_arguments.push_back(arg2);
  864     arg1.push_back(file_arg_remote);
  867     m_arguments.push_back(arg1);
 1315     arg.push_back(pid_args);
 1318     m_arguments.push_back(arg);

   32     arg1.push_back(cmd_arg);
   35     m_arguments.push_back(arg1);

  122     arg.push_back(run_args_arg);
  125     m_arguments.push_back(arg);
 1030     arg.push_back(signal_arg);
 1033     m_arguments.push_back(arg);
 1302     arg.push_back(signal_arg);
 1304     m_arguments.push_back(arg);

   59     arg.push_back(register_arg);
   62     m_arguments.push_back(arg);
  311     arg1.push_back(register_arg);
  319     arg2.push_back(value_arg);
  322     m_arguments.push_back(arg1);
  323     m_arguments.push_back(arg2);

   43     arg1.push_back(var_name_arg);
   51     arg2.push_back(value_arg);
   54     m_arguments.push_back(arg1);
   55     m_arguments.push_back(arg2);
  260     arg1.push_back(var_name_arg);
  263     m_arguments.push_back(arg1);
  324     arg1.push_back(var_name_arg);
  327     m_arguments.push_back(arg1);
  509     arg.push_back(var_name_arg);
  510     arg.push_back(prefix_name_arg);
  513     m_arguments.push_back(arg);
  582     arg1.push_back(var_name_arg);
  593     arg2.push_back(index_arg);
  594     arg2.push_back(key_arg);
  597     m_arguments.push_back(arg1);
  598     m_arguments.push_back(arg2);
  681     arg1.push_back(var_name_arg);
  692     arg2.push_back(index_arg);
  693     arg2.push_back(key_arg);
  701     arg3.push_back(value_arg);
  704     m_arguments.push_back(arg1);
  705     m_arguments.push_back(arg2);
  706     m_arguments.push_back(arg3);
  779     arg1.push_back(var_name_arg);
  787     arg2.push_back(index_arg);
  795     arg3.push_back(value_arg);
  798     m_arguments.push_back(arg1);
  799     m_arguments.push_back(arg2);
  800     m_arguments.push_back(arg3);
  878     arg1.push_back(var_name_arg);
  886     arg2.push_back(index_arg);
  894     arg3.push_back(value_arg);
  897     m_arguments.push_back(arg1);
  898     m_arguments.push_back(arg2);
  899     m_arguments.push_back(arg3);
  975     arg1.push_back(var_name_arg);
  983     arg2.push_back(value_arg);
  986     m_arguments.push_back(arg1);
  987     m_arguments.push_back(arg2);
 1063     arg.push_back(var_name_arg);
 1066     m_arguments.push_back(arg);

  243     arg.push_back(file_arg);
  246     m_arguments.push_back(arg);
  637             delete_target_list.push_back(target_sp);
  660       delete_target_list.push_back(target_sp);
  725     arg.push_back(var_name_arg);
  728     m_arguments.push_back(arg);
 1051     arg.push_back(old_prefix_arg);
 1052     arg.push_back(new_prefix_arg);
 1054     m_arguments.push_back(arg);
 1140     arg1.push_back(index_arg);
 1156     arg2.push_back(old_prefix_arg);
 1157     arg2.push_back(new_prefix_arg);
 1160     m_arguments.push_back(arg1);
 1161     m_arguments.push_back(arg2);
 1262     arg.push_back(path_arg);
 1265     m_arguments.push_back(arg);
 1810     arg.push_back(file_arg);
 1813     m_arguments.push_back(arg);
 1848     arg.push_back(source_file_arg);
 1851     m_arguments.push_back(arg);
 3705     arg.push_back(file_arg);
 3708     m_arguments.push_back(arg);

   50       m_thread_index_ids.push_back(thread_index_id);
   54       m_thread_index_ids.push_back(thread_index_id);
  543     arg.push_back(thread_id_arg);
  546     m_arguments.push_back(arg);
  821     arg.push_back(thread_idx_arg);
  824     m_arguments.push_back(arg);
  863             resume_threads.push_back(thread);
 1010           m_until_addrs.push_back(tmp_addr);
 1083     arg.push_back(line_num_arg);
 1086     m_arguments.push_back(arg);
 1119             line_numbers.push_back(line_number);
 1210                 address_list.push_back(address);
 1220             address_list.push_back(address);
 1314     arg.push_back(thread_idx_arg);
 1317     m_arguments.push_back(arg);
 1593     arg.push_back(expression_arg);
 1596     m_arguments.push_back(arg);
 1939     arg.push_back(plan_index_arg);
 1942     m_arguments.push_back(arg);

  583     type_arg.push_back(type_style_arg);
  585     m_arguments.push_back(type_arg);
  776     type_arg.push_back(type_style_arg);
  778     m_arguments.push_back(type_arg);
 1018     type_arg.push_back(type_style_arg);
 1020     m_arguments.push_back(type_arg);
 1475   type_arg.push_back(type_style_arg);
 1477   m_arguments.push_back(type_arg);
 1769     type_arg.push_back(type_style_arg);
 1771     m_arguments.push_back(type_arg);
 1865     type_arg.push_back(type_style_arg);
 1867     m_arguments.push_back(type_arg);
 1927     type_arg.push_back(type_style_arg);
 1929     m_arguments.push_back(type_arg);
 2032     type_arg.push_back(type_style_arg);
 2034     m_arguments.push_back(type_arg);
 2089     type_arg.push_back(type_style_arg);
 2091     m_arguments.push_back(type_arg);
 2327   type_arg.push_back(type_style_arg);
 2329   m_arguments.push_back(type_arg);
 2512     type_arg.push_back(type_style_arg);
 2514     m_arguments.push_back(type_arg);
 2753         languages.push_back(lang);

   99       StrRefArgs.push_back(first);
  100     StrRefArgs.push_back(Minus);
  102       StrRefArgs.push_back(second);
  118         wp_ids.push_back(id);
  133     wp_ids.push_back(beg);
  162     m_arguments.push_back(arg);
  292     m_arguments.push_back(arg);
  362     m_arguments.push_back(arg);
  434     m_arguments.push_back(arg);
  512     m_arguments.push_back(arg);
  632     m_arguments.push_back(arg);
  770     arg.push_back(var_name_arg);
  773     m_arguments.push_back(arg);
  956     arg.push_back(expression_arg);
  959     m_arguments.push_back(arg);

  199     arg.push_back(wp_id_arg);
  202     m_arguments.push_back(arg);
  492     arg.push_back(wp_id_arg);
  495     m_arguments.push_back(arg);
  564     arg.push_back(wp_id_arg);
  567     m_arguments.push_back(arg);

   58         m_address_ranges.push_back(new_range);

  156             m_address_ranges.push_back(new_range);
  179           m_address_ranges.push_back(new_range);

  543       m_loaded_plugins.push_back(dynlib);
  631     g_debugger_list_ptr->push_back(debugger_sp);

  535                       source_lines_to_display.lines.push_back(this_line);
  581                           previous_lines.push_back(line);
  593                       source_lines_to_display.lines.push_back(previous_line);
  596                     source_lines_to_display.lines.push_back(this_line);
  610                       source_lines_to_display.lines.push_back(next_line);
 1098     m_instructions.push_back(inst_sp);

   27   m_files.push_back(file_spec);
   37     m_files.push_back(file_spec);

 1017     m_subwindows.push_back(subwindow_sp);
 1460   m_submenus.push_back(menu_sp);

  917       output_local.push_back(addr);
  919       output_extern.push_back(addr);

  139     m_modules.push_back(module_sp);

  233     GetABIInstances().push_back(instance);
  362     GetDisassemblerInstances().push_back(instance);
  448     GetDynamicLoaderInstances().push_back(instance);
  533     GetJITLoaderInstances().push_back(instance);
  612     GetEmulateInstructionInstances().push_back(instance);
  697     GetOperatingSystemInstances().push_back(instance);
  777     GetLanguageInstances().push_back(instance);
  861     GetLanguageRuntimeInstances().push_back(instance);
  959     GetSystemRuntimeInstances().push_back(instance);
 1051     GetObjectFileInstances().push_back(instance);
 1186     GetObjectContainerInstances().push_back(instance);
 1282     GetPlatformInstances().push_back(instance);
 1399     GetProcessInstances().push_back(instance);
 1499   GetScriptInterpreterInstances().push_back(instance);
 1595     GetStructuredDataPluginInstances().push_back(instance);
 1696     GetSymbolFileInstances().push_back(instance);
 1775     GetSymbolVendorInstances().push_back(instance);
 1855     GetUnwindAssemblyInstances().push_back(instance);
 1935     GetMemoryHistoryInstances().push_back(instance);
 2021     GetInstrumentationRuntimeInstances().push_back(instance);
 2120     GetTypeSystemInstances().push_back(instance);
 2219     GetREPLInstances().push_back(instance);

  429     m_sections.push_back(section_sp);

  599       match_lines.push_back(line_no);

  696 void ValueList::PushValue(const Value &value) { m_values.push_back(value); }

   27   m_value_objects.push_back(val_obj_sp);

   90   m_languages.push_back(lang);

   33     m_expression_paths.push_back(path);

  923   stack.push_back(result);
 1039     stack.push_back(*initial_value_ptr);
 1410         stack.push_back(stack.back());
 1436         stack.push_back(stack[stack.size() - 2]);
 1446         stack.push_back(stack[stack.size() - 1 - pick_idx]);
 2041         stack.push_back(tmp);
 2052         stack.push_back(tmp);
 2101         stack.push_back(tmp);
 2120         stack.push_back(tmp);
 2358         stack.push_back(*object_address_ptr);

  215   m_failed_lookups.push_back(name);
  681         param_and_qual_matches.push_back(alternate_mangled_name);
  683         param_matches.push_back(alternate_mangled_name);
  996                   static_initializers.push_back(jitted_function.m_remote_addr);

  208     read_fds.push_back(pfd);
  246       signals.push_back(entry.first);

   40     opts.push_back(opt);

   91       m_arguments.push_back(*cmd_entry);

 2445   m_command_source_flags.push_back(flags);

  423       ret_val.push_back(cmd_arg_entry[i]);
  902   arg.push_back(id_arg);
  903   arg.push_back(id_range_arg);

  186               m_values.push_back(value_sp);
  268               m_values.push_back(value_sp);

  137           remove_indexes.push_back(idx);

  172           remove_indexes.push_back(idx);

   57     m_properties.push_back(property);
   75   m_properties.push_back(property);
  660           matching_properties.push_back(property);

  816     m_option_defs.push_back(group_option_defs[i]);
  835       m_option_defs.push_back(group_option_defs[i]);

  755       aggregate_field_offsets.push_back(field_byte_offset);
  756       aggregate_compiler_types.push_back(field_compiler_type);

 1559       aggregate_field_offsets.push_back(field_byte_offset);
 1560       aggregate_compiler_types.push_back(field_compiler_type);

  607     product.m_children.push_back(index_and_iterator.first);
  608     product.m_children.push_back(multiplier_and_iterator.first);
  612     index.m_children.push_back(base_and_iterator.first);
  613     index.m_children.push_back(product);
  618       offset.m_children.push_back(offset_and_iterator.first);
  619       offset.m_children.push_back(index);
  623       deref.m_children.push_back(offset);
  628       deref.m_children.push_back(index);
  665       offset.m_children.push_back(offset_and_iterator.first);
  666       offset.m_children.push_back(base_and_iterator.first);
  670       deref.m_children.push_back(offset);
  675       deref.m_children.push_back(base_and_iterator.first);
  716     offset.m_children.push_back(offset_and_iterator.first);
  717     offset.m_children.push_back(base_and_iterator.first);
  721     deref.m_children.push_back(offset);
  750     deref.m_children.push_back(base_and_iterator.first);

 1292         m_known_kexts.push_back(image_info);

  444         addrs.push_back(addr);

  473       image_infos[i].segments.push_back(segment);
  618     m_dyld_image_infos.push_back(image_infos[idx]);
  859               addresses.push_back(addr_range.GetBaseAddress());
  887                     addresses.push_back(actual_symbol_addr);
  914               addresses.push_back(addr_range.GetBaseAddress());
  960             load_addrs.push_back(resolved_addr);

  279                 image_load_addresses.push_back(addr);

  854         dylib_info.segments.push_back(segment);
  864         dylib_info.segments.push_back(segment);

  486         addrs.push_back(addr);
  573     module_names.push_back(I->file_spec);

  447   m_decls.push_back(D);

   41     m_fixit_vec.push_back(fixit);

   90     m_file_stack.push_back(file);
  329         modules_for_macros.push_back(module);

  193     exports.push_back(module);
  213     imported_module.push_back(path_component);
  388     decls.push_back(named_decl);
  618     compiler_invocation_arguments.push_back(module_cache_argument);
  629     compiler_invocation_arguments.push_back(search_path_argument);

   70     m_hand_loaded_clang_modules.push_back(module);

  358       modules_for_macros.push_back(module);
  868     args.push_back(object_ptr);
  871       args.push_back(cmd_ptr);
  873     args.push_back(struct_address);
  875     args.push_back(struct_address);

 1409       calls_to_remove.push_back(call);
 1606                   index_vector.push_back(operand);

  604       m_children.push_back(descriptor);
  848       m_children.push_back(descriptor);
 1006       m_children.push_back(descriptor);

  466       m_children.push_back(descriptor);
  633       m_children.push_back(descriptor);

  903         result.push_back(name);

  334     arg.push_back(index_arg);
  337     m_arguments.push_back(arg);
  443     exception_names.push_back(g_catch_name);
  446     exception_names.push_back(g_throw_name1);
  447     exception_names.push_back(g_throw_name2);
  451     exception_names.push_back(g_exception_throw_name);

  555     pcs.push_back(pc);

  568     arg.push_back(index_arg);
  571     m_arguments.push_back(arg);
  687     arg.push_back(index_arg);
  690     m_arguments.push_back(arg);

  118         elements.push_back(element);

 1184       m_scriptGroups.push_back(group);
 1236     group->m_kernels.push_back(kernel);
 1311       allocs.push_back(result);
 1317     allocs.push_back(alloc_out);
 2082     elem.children.push_back(child);
 2761         m_rsmodules.push_back(module_desc);

  136     pcs.push_back(pc);
  147   result.push_back(new_thread_sp);

  157       m_objects.push_back(obj);

  115           fat_archs.push_back(arch);

 2334       m_dynamic_symbols.push_back(symbol);
 2907         new_symbols.push_back(eh_symbol);
 3388     loadables.push_back(loadable);

 1577   m_mach_segments.push_back(load_cmd);
 1641     m_mach_sections.push_back(sect64);
 1662     m_mach_sections.push_back(sect64);
 1977       output.push_back(e);
 3781             N_FUN_indexes.push_back(sym_idx);
 3949           N_INCL_indexes.push_back(sym_idx);
 4007           N_BRAC_indexes.push_back(sym_idx);
 4037           N_COMM_indexes.push_back(sym_idx);
 4465         nlists.push_back(*nlist);
 6094             segment_load_commands.push_back(segment);

 1642         g_executable_dirs.push_back(dir);
 1656         g_executable_dirs.push_back(dir);

  151       m_sdk_directory_infos.push_back(sdk_sysroot_directory_info);
  188           m_sdk_directory_infos.push_back(sdk_directory_info);
  252             m_sdk_directory_infos.push_back(sdk_directory_info);

   55       m_archs.push_back(spec);

  171       library_list.push_back(*info);

  163                       .push_back(i);
  164                   m_value_regs_map[i].push_back(
  166                   m_invalidate_regs_map[i].push_back(
  224                   m_value_regs_map[i].push_back(
  228                       .push_back(i);
  229                   m_invalidate_regs_map[i].push_back(
  288         m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
  362               m_invalidate_regs_map[i].push_back(
  393     m_regs.push_back(reg_info);
  394     m_set_reg_nums[set].push_back(i);
  412       m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]);
  416       m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]);
  420       m_dynamic_reg_size_map[reg_num].push_back(
  427   m_regs.push_back(reg_info);
  432   m_set_reg_nums[set].push_back(reg_num);
  492               extra_invalid_regs.push_back(concrete_invalidate_reg_num);
  657   m_set_names.push_back(set_name);
  660   m_sets.push_back(new_set);

  105   d_register_infos.push_back(orig_ax);

  172   d_register_infos.push_back(orig_ax);

   97   m_frames.push_back(first_cursor_sp);
  342   m_frames.push_back(new_frame);
  367     m_frames.push_back(new_frame);
  373   m_frames.push_back(new_frame_v2);
  389   m_frames.push_back(new_frame);

  100   m_cursors.push_back(cursor);
  112       m_cursors.push_back(cursor);
  191   m_cursors.push_back(cursor);
  203       m_cursors.push_back(cursor);

  533       m_thread_data.push_back(thread_data);
  557       thread_data.notes.push_back(note);
  566   m_thread_data.push_back(thread_data);
  630             m_thread_data.push_back(thread_data);
  648           thread_data.notes.push_back(note);
  656             m_thread_data.push_back(thread_data);
  674           thread_data.notes.push_back(note);
  685     m_thread_data.push_back(thread_data);
  745       thread_data.notes.push_back(note);
  754   m_thread_data.push_back(thread_data);
  783       m_thread_data.push_back(thread_data);
  831         m_nt_file_entries.push_back(entry);
  844       thread_data.notes.push_back(note);
  850     m_thread_data.push_back(thread_data);

  404               supported_compressions.push_back(this_compression);
  789         argv.push_back(arg);
 1641       this->m_qXfer_memory_map.push_back(region);
 1645       this->m_qXfer_memory_map.push_back(region);
 1662       this->m_qXfer_memory_map.push_back(region);
 2763             thread_ids.push_back(tid);
 3679       result.push_back(*module_spec);

 3168     signals.push_back(signal);

  425         regnums.push_back(reg);
 1539       m_thread_ids.push_back(tid);
 1544     m_thread_ids.push_back(tid);
 1557       m_thread_pcs.push_back(pc);
 1562     m_thread_pcs.push_back(pc);
 1582             m_thread_ids.push_back(tid);
 2208         exc_data.push_back(x);
 2226           m_thread_ids.push_back(tid);
 2238           m_thread_pcs.push_back(pc);
 2664     m_stop_packet_stack.push_back(response);
 4526           feature_nodes.push_back(node);
 4558         feature_nodes.push_back(feature_node);

  249         gdb_process->m_continue_c_tids.push_back(tid);
  256         gdb_process->m_continue_s_tids.push_back(tid);

  423       regions.push_back(region);
  461     regions.push_back(region);
  485     regions.push_back(region);
  515     regions.push_back(region);

  714       m_filter_rules.push_back(rule_sp);

 2294   void Push(const DWARFDIE &die) { m_dies.push_back(die); }
 2943       member_function_dies.push_back(die);
 3161             function_param_decls.push_back(param_var_decl);
 3821           failures.push_back(dst_die);
 3885       failures.push_back(dst_die);

   39     m_decls.push_back(abbrevDeclaration);

  112     m_arange_descriptors.push_back(arangeDescriptor);

   88     m_units.push_back(*unit_sp);

   44     dies.push_back(die);
   52     dies.push_back(die);
   64       dies.push_back(die);

  181       m_die_array.push_back(die);
  214         m_die_array.push_back(die);

   72     offsets.push_back(*ref);
  164       incomplete_types.push_back(*ref);
  175       offsets.push_back(*ref);
  178       incomplete_types.push_back(*ref);
  239       dies.push_back(die);

  371             pair.value.push_back(die_info);
  432             pair.value.push_back(die_info);
  510             die_info_array.push_back(die_info);

   39       units_to_index.push_back(unit);
  412         dies.push_back(die);
  423         dies.push_back(die);
  433         dies.push_back(die);
  443         dies.push_back(die);

   48       info_array.push_back(die_ref);

  756       m_lldb_cu_to_dwarf_unit.push_back(i);
  966       imported_modules.push_back(module);

   64     m_collection.push_back(entry);

  169     cci->m_file_list.push_back(file);

  366       fwd_keys.push_back(key);
  368       full_keys.push_back(key);
 1091     params.push_back(param);

  625       arg_list.push_back(arg_ast_type);
  952             params.push_back(param);

 1610         type_collection.push_back(type);

  799               pending_item_refs.item_refs_and_code_addresses.push_back(item);
  810               pending_item_refs.item_refs_and_code_addresses.push_back(item);

  377     m_children.push_back(child_block_sp);

 7177             child_indexes.push_back(child_idx);
 7224                   child_indexes.push_back(child_idx);
 7238                   child_indexes.push_back(child_idx);
 7276                 child_indexes.push_back(child_idx);

  374       m_indexes.push_back(this_index);

   73     sorted_functions.push_back(p.second);
  242     file_indexes.push_back(file_idx);

   58     result.push_back(scope);
   60     result.push_back(sema.TUScope);

  759           stack.push_back(row);

   28         ret.push_back(type);

   93         m_unwind_plan_compact_unwind.push_back(unwind_plan_sp);

   92     entries.push_back(entry);
  509       sequence.m_entries.push_back(sequence.m_entries.back());
  527       sequence.m_entries.push_back(entry);

  669     loadables.push_back(loadable);

  230     blocks.push_back(block);
  234       blocks.push_back(parent_block);
 1204   m_symbol_contexts.push_back(sc);
 1210     m_symbol_contexts.push_back(*pos);
 1255   m_symbol_contexts.push_back(sc);

   57   m_symbols.push_back(symbol);
  455       indexes.push_back(i);
  475       indexes.push_back(i);
  497         indexes.push_back(i);
  630         indexes.push_back(all_name_indexes[i]);
  690           indexes.push_back(i);
  715           indexes.push_back(i);
 1047             symbol_indexes.push_back(temp_symbol_indexes[i]);
 1068         symbol_indexes.push_back(match->value);
 1082         symbol_indexes.push_back(match->value);
 1096         symbol_indexes.push_back(match->value);

   31     m_types.push_back(type_sp);
  181       matching_types.push_back(*pos);
  204       matching_types.push_back(*pos);

  362     m_row_list.push_back(row_sp);

   26   m_variables.push_back(var_sp);
   31     m_variables.push_back(var_sp);

   22   m_jit_loaders_vec.push_back(jit_loader_sp);

   76       m_pairs.push_back(*pos);

  163     GetPlatformList().push_back(platform_sp);
  304     GetPlatformList().push_back(platform_sp);
  344           GetPlatformList().push_back(platform_sp);
  359           GetPlatformList().push_back(platform_sp);

  648   m_notifications.push_back(callbacks);
 4207   m_profile_data.push_back(one_profile_data);
 5754   m_image_tokens.push_back(image_ptr);
 5920         names_to_remove.push_back(type_name);

   46         result.push_back(thread_sp);

   43     m_queues.push_back(queue_sp);

  400     m_frames.push_back(synth_frame);
  471           m_frames.push_back(unwind_frame_sp);
  496       m_frames.push_back(unwind_frame_sp);
  537         m_frames.push_back(frame_sp);

 2592       sym_ctx_with_reasons.push_back(

  186                   platforms.push_back(platform_sp);
  198                   platforms.push_back(host_platform_sp);
  209                 platforms.push_back(fallback_platform_sp);
  432       m_target_list.push_back(target_sp);

  281   m_plan_stack.push_back(null_plan_sp);
 1022     m_plan_stack.push_back(thread_plan_sp);
 1048     m_completed_plan_stack.push_back(plan);
 1061     m_discarded_plan_stack.push_back(plan);

   26   m_threads.push_back(thread_sp);
   34     m_threads.push_back(thread_sp);
   51     m_threads.push_back(thread_sp);

   70   m_expression_tid_stack.push_back(tid);
  255         threads_copy.push_back(thread_sp);

   63     m_stepped_past_frames.push_back(return_frame_sp);

  386             m_address_ranges.push_back(my_range);

   80   m_address_ranges.push_back(new_range);

  320     result.push_back(signo);

  271   m_hijacking_listeners.push_back(listener_sp);
  272   m_hijacking_masks.push_back(event_mask);

   68     m_results.push_back(r);

  448       m_broadcaster_managers.push_back(manager_wp);

   43 void StringList::AppendString(const std::string &s) { m_strings.push_back(s); }
   45 void StringList::AppendString(std::string &&s) { m_strings.push_back(s); }
  131     m_strings.push_back(str);
  138     m_strings.push_back(str);

  137       sorted.push_back(stats);

  118       strs.push_back(strm.str());

 1607         remove_lines.push_back(pair.first);

  316     reported_lines.push_back(line);

  140     Result.push_back(SL[Idx]);

   40       keys.push_back(it.first);

  108     lldb_regnums.push_back(ri);
  127     lldb_regnums.push_back(ri);

  522     recorded.push_back(e);

   19     Result[R->getValueAsString(Name).str()].push_back(R);

  627         Args.push_back(ResultGV);
  855   Args.push_back(InputFile);
  857     Args.push_back(Arg);

  506       StaticBranchTargetings[Target].push_back(VMAddress);

   62   Addresses.push_back(Address);
   65     Addresses.push_back(It->second);
  203     Result.OrphanedNodes.push_back(Address);
  209     Result.OrphanedNodes.push_back(Address);
  220     Result.OrphanedNodes.push_back(Address);
  250       Result.OrphanedNodes.push_back(ParentMeta.VMAddress);
  263       Result.OrphanedNodes.push_back(ParentMeta.VMAddress);
  276         Result.OrphanedNodes.push_back(ParentMeta.VMAddress);
  292       Result.OrphanedNodes.push_back(ParentMeta.VMAddress);
  312     Result.ConditionalBranchNodes.push_back(BranchNode);
  334     Result.OrphanedNodes.push_back(Address);

  114     RequiredLibs.push_back(Name);
  126         Missing->push_back(path);
  577       Components.push_back(Arg);

  478     ArgsV.push_back(Arg);

  334       InstantiationSummaries.push_back(InstantiationSummary);

  554         BundlePaths.push_back(Path);
  562     BundlePaths.push_back(InputPath);

  454     CurTypesSection.push_back(Contents);

  237       Entry.PointIds.push_back(PointId);
  241       Entries[IndexIt->second].PointIds.push_back(PointId);
  338   PointIds.push_back(PointId);

  195     RegistersSetUp.push_back(InitValue.Register);

   51       Neighbors.push_back(P);

   58       AliasingInstructions.push_back(OtherInstr);

   39     Result->Key.Instructions.push_back(Instruction);
   75         Result->LiveIns.push_back(Reg);

   79           BC.LiveIns.push_back(CT.ScratchSpacePointerInReg);

  444     Instructions.push_back(Inst);

  183       Result.push_back(I);
  199       Result.push_back(Opcode);

  294         Workqueue.push_back(F);
  312           Workqueue.push_back(CF);

  307         Res.push_back(I->second.front());

 1246       SymbolList.push_back(S);
 1392           SymbolList.push_back(S);
 1433             SymbolList.push_back(U);
 1493           SymbolList.push_back(B);
 1553           SymbolList.push_back(L);
 1616           SymbolList.push_back(W);
 1713           SymbolList.push_back(F);

  605     Config.AddSection.push_back(ArgValue);

  125     ELFConfig.SymbolsToAdd.push_back(*NSI);

 1651     Records.push_back(*R);
 2138       OrderedSegments.push_back(Sec.ParentSegment);

  634     Indexes.push_back(Index);    
  754   void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }

  106       S.Relocations.push_back(R);

  457       Rels.push_back(Reloc);

  372       Symbols.push_back(Symbol);
  376     Sections.push_back(Section);
 1466       LiteralSections.push_back(Section);
 6116     Sections.push_back(Section);
 6198     Sections.push_back(Section);
 6293     Sections.push_back(Section);
 6451     Sections.push_back(Section);

 1012       V.push_back(R);
 1630     SecToRelSec[**SecOrErr].push_back(Section);

  188     Opts.push_back(Access);
  190     Opts.push_back(Kind);

  122     Obj.StringTable->push_back(*S);
  146     Obj.StreamMap->push_back(BlockList);
  260           DMI.Subsections.push_back(*Converted);
  274           DMI.Modi->Symbols.push_back(*ES);
  297     Obj.TpiStream->Records.push_back(*ExpectedRecord);
  325     Obj.IpiStream->Records.push_back(*ExpectedRecord);
  361     Obj.PublicsStream->PubSyms.push_back(*ES);

  488       StringTableData.BundleList.push_back(Key);
  914     ItemEntries.push_back(*Object);

   52       Output.push_back(Line);

  517     Data.push_back(*Item);
  746       Values.push_back(*ValueResult);

  192     Result.push_back(Token);

  593       RelocMap[Section].push_back(Reloc);
 1610       Libs.push_back(Name);

   64       Ret.push_back(SecRef);

   21   ProgramArgs.push_back(TestName);
   26   ProgramArgs.push_back(Filename);

   67       NewChunks.push_back(C);
  124           CurrentChunks.push_back(C);

   71             InstToDelete.push_back(I);

   33       ChunkSucessors.push_back(Succ);

   40           InstToRemove.push_back(Inst);

  347     PT->push_back(V);
  488     return PT->push_back(V);
  509       Idxs.push_back(CI);
  516     PT->push_back(V);
  532     return PT->push_back(V);
  636     return PT->push_back(V);
  665     return PT->push_back(V);

  305       Opts.DsymHints.push_back(hint);

   48     FunctionLatencies[FuncId].push_back(Latency);

  233         EA.Timings.push_back(D);
  243     EA.Timings.push_back(D);

  546       CodegenArgv.push_back(Arg);

  215       Relocations.push_back(Rel);
  218     YAMLSections.push_back(NewYAMLSection);
  349     Symbols.push_back(Sym);

   42           Abbrv.Attributes.push_back(AttAbrv);
   44         Y.AbbrevDecls.push_back(Abbrv);
   55     Y.DebugStrings.push_back(SymbolPair.first);
   76       Range.Descriptors.push_back(Desc);
   78     Y.ARanges.push_back(Range);
   97     Y.Entries.push_back(NewEntry);
  197                 NewEntry.Values.push_back(NewValue);
  219           NewEntry.Values.push_back(NewValue);
  223       NewUnit.Entries.push_back(NewEntry);
  225     Y.CompileUnits.push_back(NewUnit);
  274           DebugLines.IncludeDirs.push_back(Dir);
  282           DebugLines.Files.push_back(TmpFile);
  342         DebugLines.Opcodes.push_back(NewOp);
  344       Y.DebugLines.push_back(DebugLines);

  370     Symbols.push_back(S);
  620       S->Relocations.push_back(R);
  631       S->Relocations.push_back(R);
  808     S->Entries.push_back(Entry);
  879       Entry.AuxV.push_back(Aux);
  883     S->VerneedV.push_back(Entry);

  187     LC.Tools.push_back(BV);
  288     LEData.RebaseOpcodes.push_back(RebaseOp);
  335       BindOp.SLEBExtraData.push_back(SLEB);
  347     BindOpcodes.push_back(BindOp);
  488     LEData.NameList.push_back(NLE);
  495     LEData.StringTable.push_back(SymbolPair.first);
  528     YAML.FatArchs.push_back(arch);
  538     YAML.Slices.push_back(*YAMLObj.get());

   71       NameSec->FunctionNames.push_back(NameEntry);
   97         LinkingSec->SegmentInfos.push_back(SegmentInfo);
  143       ProducersSec->Languages.push_back(Producer);
  149       ProducersSec->Tools.push_back(Producer);
  155       ProducersSec->SDKs.push_back(Producer);
  165       TargetFeaturesSec->Features.push_back(Feature);
  205         TypeSec->Signatures.push_back(Sig);
  236         ImportSec->Imports.push_back(Im);
  244         FuncSec->FunctionTypes.push_back(Func);
  273         GlobalSec->Globals.push_back(G);
  285         EventSec->Events.push_back(E);
  303         ExportSec->Exports.push_back(Ex);
  315           Seg.Functions.push_back(Func);
  317         ElemSec->Segments.push_back(Seg);
  331           Function.Locals.push_back(LocalDecl);
  334         CodeSec->Functions.push_back(Function);
  348         DataSec->Segments.push_back(Seg);
  369       S->Relocations.push_back(R);

   79     Symbols.push_back(Sym);

   93     Values.push_back(Value);

 2393         Int.push_back(ValInt);
 2410       Int.push_back(ValInt);
 2441       Sizes.push_back(Size);

  839         (*Terms).push_back(Res);

 1578       OutermostSizeIds.push_back(Id);
 2374   StmtMap[BB].push_back(Stmt);
 2395     StmtMap[BB].push_back(Stmt);

   73     Identifiers.push_back(Id);
   89     Identifiers.push_back(Id);
  154     ValuesToPrint.push_back(Val);
  264   Arguments.push_back(FormatString);

  719       BSets.push_back(BSet);

  689       Subscripts.push_back(Expr);
  700     Subscripts.push_back(Expr);

   25     Sets.push_back(BS);

  314         PointsByFn[Loc.FunctionName].push_back(PointPtr);
  445     Coverage->Points.push_back(KV.second);
  588     Result.push_back(Point);
 1037       Result->Points.push_back(NewPoint);
 1099       CoverageByObjFile[Iter->second].push_back(FileName);

  243   Values.push_back(V);

  286     Test.push_back(i);
  293     Test.push_back(i);

  376   BasicBlocks.push_back(BB1);
  377   BasicBlocks.push_back(BB2);

   67     Indices.push_back(Index);
   71     VisitedRecords.push_back(AR);
   72     RawRecords.push_back(CVR);
  105       GlobalState->Records.push_back(AR);
  109       GlobalState->TypeVector.push_back(Type);

   29   AR.ArgIndices.push_back(Q);
   30   AR.ArgIndices.push_back(R);

  279     FI.Inline->Children.push_back(Inline1);
  399   Inline1.Children.push_back(Inline1Sub1);
  400   Inline1.Children.push_back(Inline1Sub2);
  401   Root.Children.push_back(Inline1);
  471   ContainsEmpty.Children.push_back(Empty);
  482   ChildNotContained.Children.push_back(ChildNotContainedChild);

   45       Types.push_back(*First);

  279     UnresolvedExternals.push_back(str);

  279   V.push_back(One);

   48     Init.push_back(SwitchCase1BA);
   51     Init.push_back(SwitchCase2BA);
   56     Init.push_back(OnePtr);

  803     Names.push_back(Func.Name);
  817     Names.push_back(Func.Name);

  934     FuncNames1.push_back(OS.str());
  937     FuncNames1.push_back(OS.str());
  940     FuncNames2.push_back(OS.str());
  943     FuncNames2.push_back(OS.str());

  828       InStrings.push_back(S);

  130       Result.UnicodeScalars.push_back(US0);
  132       Result.UnicodeScalars.push_back(US1);
  134       Result.UnicodeScalars.push_back(US2);
  136       Result.UnicodeScalars.push_back(US3);
  138       Result.UnicodeScalars.push_back(US4);
  140       Result.UnicodeScalars.push_back(US5);
  142       Result.UnicodeScalars.push_back(US6);
  144       Result.UnicodeScalars.push_back(US7);