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

References

  367         Args.push_back(std::move(Arg));
  487     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  827     ArgsV.push_back(Args[i]->codegen());

  367         Args.push_back(std::move(Arg));
  487     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  827     ArgsV.push_back(Args[i]->codegen());

  367         Args.push_back(std::move(Arg));
  487     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  826     ArgsV.push_back(Args[i]->codegen());

  352         Args.push_back(std::move(Arg));
  472     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  812     ArgsV.push_back(Args[i]->codegen());

  369         Args.push_back(std::move(Arg));
  489     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  685     PEArgs.push_back(std::move(E));
  836     ArgsV.push_back(Args[i]->codegen());

  235         Args.push_back(std::move(Arg));

  261         Args.push_back(std::move(Arg));
  458     ArgsV.push_back(Args[i]->codegen());

  271         Args.push_back(std::move(Arg));
  486     ArgsV.push_back(Args[i]->codegen());

  316         Args.push_back(std::move(Arg));
  613     ArgsV.push_back(Args[i]->codegen());

  350         Args.push_back(std::move(Arg));
  725     ArgsV.push_back(Args[i]->codegen());

  372         Args.push_back(std::move(Arg));
  492     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  832     ArgsV.push_back(Args[i]->codegen());

  373         Args.push_back(std::move(Arg));
  493     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  831     ArgsV.push_back(Args[i]->codegen());

  482         Args.push_back(std::move(Arg));
  604     VarNames.push_back(std::make_pair(Name, std::move(Init)));
  992     ArgsV.push_back(Args[i]->codegen());
 1253   KSDbgInfo.LexicalBlocks.push_back(SP);

  181   ArgV.push_back(argv[0]);
  183     ArgV.push_back(InputArg.data());
  184   ArgV.push_back(nullptr);

13796           Ret.Features.push_back("-" + Feature.split("-").second.str());
13798           Ret.Features.push_back("+" + Feature.str());

  103     VisitStack.push_back(StackElement(Node, None));
  111       VisitStack.push_back(StackElement(Node, None));
  135           VisitStack.push_back(StackElement(Next, None));

  357     factory->freeNodes.push_back(this);

  103       Vector.push_back(std::make_pair(Key, ValueT()));
  122       Vector.push_back(std::make_pair(KV.first, KV.second));
  135       Vector.push_back(std::move(KV));

  108     VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));
  117       VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));
  131         VisitStack.push_back(std::make_pair(BB, GT::child_begin(BB)));

  147   VisitStack.push_back(StackElement(N, GT::child_begin(N), visitNum));

  153         vector_.push_back(*Start);

   47     Result.push_back(*Strings++);

  168   workList.push_back(DFCalculateWorkObject<BlockT>(BB, nullptr, Node, nullptr));
  201         workList.push_back(DFCalculateWorkObject<BlockT>(

   26       IndirectCalls.push_back(&Call);

  188     IntStack.push_back(std::make_pair(Int, succ_begin(Int)));

   72   RegionQueue.push_back(static_cast<RegionT *>(this));
   80         RegionQueue.push_back(Child.get());
   90   RegionQueue.push_back(static_cast<RegionT *>(this));
   98         RegionQueue.push_back(Child.get());
  387     To->children.push_back(std::move(R));
  402   children.push_back(std::unique_ptr<RegionT>(SubRegion));
  423       SubRegion->children.push_back(std::move(R));
  425       Keep.push_back(std::move(R));

  335     Maps.push_back(std::unique_ptr<DocNode::MapTy>(new DocNode::MapTy));
  343     Arrays.push_back(std::unique_ptr<DocNode::ArrayTy>(new DocNode::ArrayTy));
  364     Strings.push_back(std::unique_ptr<char[]>(new char[S.size()]));

  492     CurAbbrevs.push_back(std::move(Abbv));
  538     Info.Abbrevs.push_back(std::move(Abbv));

  213   Iter->second.Values.push_back(

  175     CurrentPacketMIs.push_back(&MI);

  114     Roots.push_back(GCRoot(Num, Metadata));

  203       getVarInfo(IncomingReg).Kills.push_back(&MI);
  239       getVarInfo(IncomingReg).Kills.push_back(&MI);

  317     LiveIns.push_back(RegisterMaskPair(PhysReg, LaneMask));

  953     CodeViewAnnotations.push_back({Label, MD});

  205       Mutations.push_back(std::make_unique<CopyToPhiMutation>());
  278     Mutations.push_back(std::move(Mutation));

  927     LiveIns.push_back(std::make_pair(Reg, vreg));

  316       Mutations.push_back(std::move(Mutation));

  200         Nodes.push_back(std::move(N));
  215         Edges.push_back(std::move(E));

   59       Constraints.push_back(std::move(C));

   56   void addRVA(uint32_t RVA) { RVAs.push_back(support::ulittle32_t(RVA)); }

   57     Pipeline.push_back(&Callbacks);

   54       Hashes.push_back(hashType(Type.RecordData));
  150       IdHashes.push_back(hashType(R, TypeHashes, IdHashes));
  159       Hashes.push_back(hashType(Type.RecordData, Hashes, Hashes));

   82     Pipeline.push_back(&Callbacks);

   85     Instructions.push_back(Instruction(Opcode));
   90     Instructions.push_back(Instruction(Opcode));
   96     Instructions.push_back(Instruction(Opcode));

   57     Cache.push_back(nullptr);
   95     Cache.push_back(std::move(Result));

  217     Edges.push_back(Edge(K, Offset, Target, Addend));
  727     Sections.push_back(std::move(Sec));

  215       SourceModules.push_back(SourceModuleEntry());

  948       [&]() { DefGenerators.push_back(std::move(DefGenerator)); });

  163       this->AvailableTrampolines.push_back(
  172     TrampolineBlocks.push_back(std::move(TrampolineBlock));
  372       FreeStubs.push_back(std::make_pair(NewBlockId, I));
  373     IndirectStubsInfos.push_back(std::move(ISI));

   97     Plugins.push_back(std::move(P));

  112       Unmapped.push_back(ObjectAllocs());
  154       UnfinalizedEHFrames.push_back({LoadAddr, Size});
  174         Unfinalized.push_back(std::move(ObjAllocs));
  415       RemoteIndirectStubsInfos.push_back({StubBase, PtrBase, NumStubsEmitted});
  418         FreeStubs.push_back(std::make_pair(NewBlockId, I));
  479         this->AvailableTrampolines.push_back(BlockAddr + (I * TrampolineSize));

  277     BlockList.push_back(std::move(IS));
  319     TrampolineBlocks.push_back(std::move(TrampolineBlock));

  137       Result.push_back(UndefValue::get(PointerType::getUnqual(T)));
  157         Result.push_back(UndefValue::get(PointerType::getUnqual(T)));

 1051       Edges.push_back(std::make_pair(P.first, CalleeInfo{}));
 1159         ->second.SummaryList.push_back(std::move(Summary));
 1424     G.SummaryList.push_back(std::move(Root));

  221         Refs.push_back(ValueInfo(/*IsAnalysis=*/false, &*V.find(RefGUID)));
  223       Elem.SummaryList.push_back(std::make_unique<FunctionSummary>(
  242             Refs.push_back(VI.getGUID());
  243           FSums.push_back(FunctionSummaryYaml{

  446       FileNames.push_back(FileName);

  782         Offsets.push_back(Dynamic->d_un.d_val);

  286       ComdatTable.push_back(str(C.Name));
  298       Specifiers.push_back(str(S));

  472       MD5NameMap.push_back(std::make_pair(
  482     AddrToMD5Map.push_back(std::make_pair(Addr, MD5Val));

  387     Payloads.push_back(std::move(Payload1));
  388     Payloads.push_back(std::move(Payload2));
  402           E1List.Payloads.push_back(std::move(Payload));
  404         E1List.Payloads.push_back(E2.takePayload());

   89     Children.push_back(C.get());
  129     IDom->Children.push_back(this);

  364     NumToNode.push_back(nullptr);  // NumToNode[1] = nullptr;

  189   void push_back(Value &&E) { V.push_back(std::move(E)); }

  158     Buffers.push_back(std::move(NB));

  606       Contents.push_back(std::move(Content));

  614     ASVector.push_back(&*I);

  395         AliasList.push_back(OffsetValue{InnerMapping.first.Val, UnknownOffset});
  602     WorkList.push_back(WorkListItem{From, To, State});

  132     FromInfo->Edges.push_back(Edge{To, Offset});
  133     ToInfo->ReverseEdges.push_back(Edge{From, Offset});

  219         Worklist.push_back(&Phi);
  257     Worklist.push_back(&Phi);

  194     Callbacks.push_back(CallBackOnDeletion(DelBB, Callback));

  132       Worklist.push_back(&I);
  138       Worklist.push_back(&Arg);
  174       Worklist.push_back(&*I);
  222         Worklist.push_back(UserInst);
  261       Worklist.push_back(U);

  893       Cache.push_back(NonLocalDepEntry(DirtyBB, Dep));
 1025     Cache->push_back(NonLocalDepEntry(BB, Dep));

  153     Args.push_back(CI->getZExtValue());
  284           NonVolatileLoads.push_back(&I);
  288           NonVolatileStores.push_back(&I);
  495       VTableFuncs.push_back({Index.getOrInsertValueInfo(Fn), StartingOffset});
  564           .push_back({Offset, Index.getOrInsertValueInfo(&V)});

 7517       Indexes.push_back(CI);
 7522       Indexes.push_back(nullptr);

  588     Links.push_back(BuilderLink(Link));

  491     MDs.push_back({MDK, N});
  985     NumberedVals.push_back(GA.get());
 1096     NumberedVals.push_back(GV);
 2836       NumberedVals.push_back(&A);
 2978     NumberedVals.push_back(Inst);
 3050     NumberedVals.push_back(BB);
 5487     NumberedVals.push_back(Fn);
 6073       ParamTypes.push_back(ArgList[i].V->getType());
 6400       ParamTypes.push_back(ArgList[i].V->getType());
 6802       ParamTypes.push_back(ArgList[i].V->getType());
 7590       IdToIndexMap[GVId].push_back(std::make_pair(TI.size(), Loc));
 7591     TI.push_back({Offset, VI});
 7605       FwdRef.first->second.push_back(
 8220     FwdRef.first->second.push_back(std::make_pair(AS.get(), Loc));
 8343       IdToIndexMap[GVId].push_back(std::make_pair(Calls.size(), Loc));
 8344     Calls.push_back(FunctionSummary::EdgeTy{VI, CalleeInfo(Hotness, RelBF)});
 8358       FwdRef.first->second.push_back(
 8430       IdToIndexMap[GVId].push_back(std::make_pair(VTableFuncs.size(), Loc));
 8431     VTableFuncs.push_back({VI, Offset});
 8445       FwdRef.first->second.push_back(
 8494       IdToIndexMap[VC.GVId].push_back(std::make_pair(Refs.size(), VC.Loc));
 8506       FwdRef.first->second.push_back(std::make_pair(&Refs[P.first], P.second));
 8586       IdToIndexMap[ID].push_back(std::make_pair(TypeTests.size(), Loc));
 8601       FwdRef.first->second.push_back(
 8642       FwdRef.first->second.push_back(
 8681       FwdRef.first->second.push_back(
 8726     IdToIndexMap[ID].push_back(std::make_pair(Index, Loc));

  688           FreqPairs.push_back(std::make_pair(Freq, i));

 1396       MAttributes.push_back(AttributeList::get(Context, Attrs));
 1403       MAttributes.push_back(AttributeList::get(Context, Attrs));
 3163     GlobalInits.push_back(std::make_pair(NewGV, InitID - 1));
 3269     FunctionPrologues.push_back(std::make_pair(Func, Record[10] - 1));
 3287     FunctionPrefixes.push_back(std::make_pair(Func, Record[13] - 1));
 3290     FunctionPersonalityFns.push_back(std::make_pair(Func, Record[14] - 1));
 3398   IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
 5633     Ret.push_back(getValueInfoFromValueId(RefValueId).first);
 5655     Ret.push_back(FunctionSummary::EdgeTy{Callee, CalleeInfo(Hotness, RelBF)});
 5715   TypeId.push_back({Offset, Callee});
 5985         VTableFuncs.push_back({Callee, Offset});
 6131         PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});
 6137         PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});
 6141       PendingTypeTestAssumeConstVCalls.push_back(
 6146       PendingTypeCheckedLoadConstVCalls.push_back(
 6375         F.Mods.push_back({Stream.getBitcodeBytes().slice(

 1483       CUSubprograms.push_back({CU, SPs});

   89     ResolveConstants.push_back(std::make_pair(PHC, Idx));

 2016       IndexPos->push_back(Stream.GetCurrentBitNo());
 4440   Mods.push_back(const_cast<Module *>(&M));
 4651   Mods.push_back(const_cast<Module *>(&M));

  644     MDs.push_back(N);
  702   MDs.push_back(Local);
  842       Values.push_back(std::make_pair(V, 1U));
  849   Values.push_back(std::make_pair(V, 1U));
  966     BasicBlocks.push_back(&BB);

  426   CurAbbrevs.push_back(std::move(Abbv));
  468       CurBlockInfo->Abbrevs.push_back(std::move(CurAbbrevs.back()));
  504         CurBlockInfo->RecordNames.push_back(std::make_pair((unsigned)Record[0],

  271         Edges.push_back(&*P);

   77     Buckets[Bucket].push_back(&E.second);
  565     CompUnits.push_back(MainCU->getLabelBegin());

  535         RestrRegs.push_back(TRI->getName(MI->getOperand(I + 1).getReg()));

   91       Comments.push_back(Comment.str());
   97       Comments.push_back(Comment.str());
  101         Comments.push_back("");
  109       Comments.push_back(Comment.str());
  113         Comments.push_back("");

 2130     Info.Members.push_back({DDTy, 0});
 2162     Info.Members.push_back(
 2181         Info.Inheritance.push_back(DDTy);
 2186         Info.NestedTypes.push_back(DDTy);
 2192       Info.NestedTypes.push_back(Composite);
 2409       Methods.push_back(OneMethodRecord(
 2861         CurFn->HeapAllocSites.push_back(std::make_tuple(getLabelBeforeInsn(&MI),

 2345     SectionRanges[&Range.Begin->getSection()].push_back(&Range);

   49       Functions.push_back(&F);

  757           SameTails.push_back(SameTailElt(CurMPIter, TrialBBI1));
  761           SameTails.push_back(SameTailElt(I, TrialBBI2));
 1089       MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(MBB), &MBB));
 1199         MergePotentials.push_back(MergePotentialsElt(HashEndOfMBB(*PBB), PBB));

  190       UndefReads.push_back(std::make_pair(MI, OpNum));

  166     Mutations.push_back(std::move(Mutation));

   75   Functions.push_back(std::make_unique<GCFunctionInfo>(F, *S));

  449     Clusters.push_back(CaseCluster::range(CaseVal, CaseVal, Succ, Prob));

  305           AddressSpace2SpecifiedActions[Type.getAddressSpace()].push_back(
  309               .push_back(SizeAction);
  311           ScalarSpecifiedActions.push_back(SizeAction);
  343         ElementSizesSeen.push_back({ElementSize, Legal});
  353           NumElementsActions.push_back({NumElements, BitsizeAndAction.second});
  533     result.push_back({1, IncreaseAction});
  538       result.push_back({LargestSizeSoFar + 1, IncreaseAction});
  542   result.push_back({LargestSizeSoFar + 1, DecreaseAction});
  552     result.push_back({1, IncreaseAction});
  556       result.push_back({v[i].first + 1, DecreaseAction});

  473         Tys.push_back(ArrayType::get(Int8Ty, Padding));
  474         Inits.push_back(ConstantAggregateZero::get(Tys.back()));
  478       Inits.push_back(Globals[j]->getInitializer());
  479       StructIdxs.push_back(CurIdx++);

 1315           Tokens.push_back(std::make_unique<IfcvtToken>(
 1333           Tokens.push_back(std::make_unique<IfcvtToken>(
 1352       Tokens.push_back(
 1361       Tokens.push_back(
 1377       Tokens.push_back(
 1390         Tokens.push_back(std::make_unique<IfcvtToken>(BBI, ICTriangleFalse,
 1401         Tokens.push_back(
 1411         Tokens.push_back(

   40     ParamTys.push_back((*I)->getType());

  174     VRInfo.Kills.push_back(&MI);
  187     VRInfo.Kills.push_back(&MI);

  115     StringInstrMap.push_back({(i == std::string::npos) ? S : S.substr(i), II});
  159     Instructions.push_back(&MI);
  179       PhysRegDefs.push_back(MO.getReg());
  313       Copies.push_back(&MI);
  342       Uses.push_back(&*UI);
  403   bbNames.push_back(MBB->getName());
  434       RenameMOs.push_back(&MO);

  535       Entry.Blocks.push_back(StrOS.str());

   96       VRegs.push_back(TypedVReg(RSE_FrameIndex));
  113         VRegs.push_back(TypedVReg(Reg));
  117       VRegs.push_back(TypedVReg(Reg));
  234     renamedInOtherBB.push_back(Rename);
  238       RenameMOs.push_back(&MO);
  266     VRegs.push_back(TypedVReg(RSE_NewCandidate));

 1000           LV->getVarInfo(Reg).Kills.push_back(&*I);

   56   Objects.push_back(StackObject(Size, Alignment, 0, false, IsSpillSlot, Alloca,
   77   Objects.push_back(StackObject(0, Alignment, 0, false, false, Alloca, true));

  641   LandingPads.push_back(LandingPadInfo(LandingPad));
  703     LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1]));
  712   LP.TypeIds.push_back(getFilterIDFor(IdsInFilter));
  763   LP.TypeIds.push_back(0);
  821   FilterEnds.push_back(FilterIds.size());
  822   FilterIds.push_back(0); // terminator
  907   JumpTables.push_back(MachineJumpTableEntry(DestBBs));
 1076   Constants.push_back(MachineConstantPoolEntry(C, Alignment));
 1094   Constants.push_back(MachineConstantPoolEntry(V, Alignment));

 1343     CSEMap[MI.getOpcode()].push_back(&MI);
 1491       CI->second.push_back(MI);
 1493       CSEMap[Opcode].push_back(MI);

  536       OrderedInsts.push_back(SU->getInstr());
 2675     Indices.push_back(std::make_pair(NodeOrder[i], i));

 1056       RegionCriticalPSets.push_back(PressureChange(i));

 1995     Instrs.push_back(&MI);

  516   Sequence.push_back(nullptr);   // NULL here means noop

  394       CSI.push_back(CalleeSavedInfo(Reg));

 3643     MBBs.push_back(MBBPriorityInfo(MBB, Loops->getLoopDepth(MBB),

  490       WorkList.push_back(&SU);
  592         WorkList.push_back(SuccDep.getSUnit());
  618   WorkList.push_back(&StartSU);
  652   WorkList.push_back(&TargetSU);
  669         Nodes.push_back(s);

  797       DbgValues.push_back(std::make_pair(DbgMI, &MI));
 1311     ConnectionPairs.push_back(std::make_pair(PredDep.getSUnit(), Succ));
 1411     DFSStack.push_back(std::make_pair(SU, SU->Preds.begin()));

 2308       FuncInfo.PHINodesToUpdate.push_back(std::make_pair(&*MBBI++, Reg));

  257       Sequence.push_back(nullptr);   // NULL here means noop

 8417       Order.push_back(&N);
 8862         VTs.push_back(MVT((MVT::SimpleValueType)i));

  974       Ops.push_back(DAG.getRegister(Regs[I], RegVTs[I]));
  989       Ops.push_back(DAG.getRegister(TheReg, RegisterVT));
 8176   AsmNodeOperands.push_back(SDValue());  // reserve space for input chain
 8177   AsmNodeOperands.push_back(DAG.getTargetExternalSymbol(
 8184   AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
 8188   AsmNodeOperands.push_back(DAG.getTargetConstant(
 8215         AsmNodeOperands.push_back(DAG.getTargetConstant(OpFlags, getCurSDLoc(),
 8299         AsmNodeOperands.push_back(DAG.getTargetConstant(
 8332         AsmNodeOperands.push_back(DAG.getTargetConstant(
 8352         AsmNodeOperands.push_back(DAG.getTargetConstant(ResOpType,
 9991           FuncInfo.PHINodesToUpdate.push_back(
10505     Clusters.push_back(CaseCluster::range(CaseVal, CaseVal, Succ, Prob));

 2077       Ops.push_back(CurDAG->getTargetConstant(NewFlags, DL, MVT::i32));

 4069         Ops.push_back(DAG.getTargetGlobalAddress(GA->getGlobal(), SDLoc(Op),
 4084         Ops.push_back(DAG.getTargetConstant(Offset + ExtVal,
 4089         Ops.push_back(DAG.getTargetBlockAddress(

  158   EltTys.push_back(StackEntryTy);
  160     EltTys.push_back(Roots[I].second->getAllocatedType());
  185   EltTys.push_back(Type::getInt32Ty(M.getContext()));
  187   EltTys.push_back(Type::getInt32Ty(M.getContext()));
  200   EltTys.push_back(PointerType::getUnqual(StackEntryTy));
  201   EltTys.push_back(FrameMapPtrTy);

  228     SSIntervals.push_back(&li);

  420       CBV.push_back(

  327     LI->second.push_back(std::make_pair(BB, NewReg));
  330     Vals.push_back(std::make_pair(BB, NewReg));

  685       FuncletBlocks[Color].push_back(&BB);

  233     Types.push_back(createSegmentRecord(Offset, End, RefersTo));

   79     Ids.push_back(&M);

  111   Entry.ExtraFiles.push_back(ulittle32_t(Offset));

  471       Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));
  473         Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));

 1519       SectionNames.push_back({ Name, true });

   45     Decls.push_back(std::move(AbbrDecl));

  135       Addrs.push_back(Data.getU32(OffsetPtr));
  137       Addrs.push_back(Data.getU64(OffsetPtr));

   28     Sets.push_back({});
   42       SetData.Entries.push_back(

   85     Offsets.push_back(Data.getRelocatedValue(OffsetByteSize, OffsetPtr));

  169         OffsetLookup.push_back(&Rows[i]);

  140         AddrInfoOffsets.push_back(OffsetOrErr.get());

  177   StreamData.push_back(std::make_pair(Size, Blocks));
  187   StreamData.push_back(std::make_pair(Size, NewBlocks));

   72     FL.Blocks.push_back(support::ulittle32_t(FpmBlock));

   86   SourceFiles.push_back(Path);
  183   C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(
  189   C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(

  116   ModiList.push_back(

  146     TmpBuckets[BucketIdx].push_back(std::make_pair(Name, HR));
  259     DeserializedPublics.push_back(
  273     AddrMap.push_back(ulittle32_t(SymOffsets[Idx]));

   78       Result.push_back(std::make_pair(Off, std::move(Record)));

  120   NamesBuffer.push_back('\0');

   67   Cache.push_back(nullptr);

  156     HashMap[HV].push_back(TIB++);

   50     TypeIndexOffsets.push_back(

   43         Args.push_back(std::move(Child));

  179         VirtualBaseSyms.push_back(std::move(Base));
  181         Bases.push_back(std::move(Base));
  185         Members.push_back(std::move(Data));
  187         Other.push_back(std::move(Data));
  189       VTables.push_back(std::move(VT));
  191       Funcs.push_back(std::move(Func));
  193       Other.push_back(std::move(Child));
  211     AllBases.push_back(BL.get());
  254     AllBases.push_back(BL.get());
  301   ChildStorage.push_back(std::move(Child));

  137     ExportSyms.push_back(OffsetNamePair{Offset, Name});

  295   DsymPaths.push_back(getDarwinDWARFResourceForPath(ExePath, Filename));
  297     DsymPaths.push_back(getDarwinDWARFResourceForPath(Path, Filename));

  360     Values.push_back(std::move(Dest));
  457       GVArgs.push_back(PTOGV(CArgv.reset(Fn->getContext(), this, argv)));
  465         GVArgs.push_back(PTOGV(CEnv.reset(Fn->getContext(), this, EnvVars)));
 1235             NonCanonicalGlobals.push_back(&GV);

 1000     ResultValues.push_back(getOperandValue(IncomingValue, SF));
 1168     ArgVals.push_back(getOperandValue(V, SF));

  421   NewArgs.push_back(PTOGV((void*)&Buffer[0]));
  464   NewArgs.push_back(PTOGV(Buffer));

  325         Worklist.push_back(&E.getTarget());

  172     Sections.push_back(&KV.second);
  336       SecIndexToSymbols[NSym.Sect - 1].push_back(&NSym);

  682       Config.PrePrunePasses.push_back(std::move(MarkLive));
  684       Config.PrePrunePasses.push_back(markAllSymbolsLive);
  687     Config.PostPrunePasses.push_back([](LinkGraph &G) -> Error {

  571       Config.PrePrunePasses.push_back(std::move(MarkLive));
  573       Config.PrePrunePasses.push_back(markAllSymbolsLive);
  576     Config.PostPrunePasses.push_back([](LinkGraph &G) -> Error {

  221       GVsToAdd.push_back(
  228       GVsToAdd.push_back(&A);
  232       GVsToAdd.push_back(&G);

  428     Worklist.push_back(std::make_pair(&JD, KV.first));
  602     QueryInfos.push_back(
  955         Worklist.push_back(
 1205             Worklist.push_back(std::make_pair(&DependantJD, DependantName));
 1266     SearchOrder.push_back({&JD, MatchNonExported});
 1320       SymbolsToRemove.push_back(std::make_pair(I, UMII));
 1498       MUs.push_back(std::move(MU));
 1567       ES.OutstandingMUs.push_back(make_pair(this, std::move(MU)));
 1623       MUs.push_back(std::move(MU));
 1721     Result.push_back(std::move(PendingQueries.back()));
 1730   SearchOrder.push_back({this, true});
 1824   JDs.push_back(std::unique_ptr<JITDylib>(new JITDylib(*this, "<main>")));
 1844     JDs.push_back(
 2019         OutstandingMUs.push_back(std::make_pair(KV.first, std::move(MU)));
 2101     FullSearchOrder.push_back({JD, false});

  113     CtorDtorsByPriority[CtorDtor.Priority].push_back(
  160   CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));

  246     CallArgs.push_back(&A);
  280       PromotedGlobals.push_back(&GV);

  158     Config.PrePrunePasses.push_back(
  160     Config.PostPrunePasses.push_back(
  263           Worklist.push_back(WorklistEntry(Sym, std::move(SymAnonDeps)));
  359     UntrackedAllocs.push_back(std::move(Alloc));
  398       Allocs.push_back(std::move(KV.second));
  420   PassConfig.PostFixupPasses.push_back(

  299       CtorNames.push_back(mangle(Ctor.Func->getName()));
  301       DtorNames.push_back(mangle(Dtor.Func->getName()));

  278         CtorNames.push_back(mangle(NewCtorName));
  286         DtorNames.push_back(mangle(NewDtorName));
  311     Archives.push_back(std::move(A));

  130     MemMgrs.push_back(std::move(Tmp));

  140   EHFrames.push_back({Addr, Size});

  586     RWSectionSizes.push_back(GotSize);

   26   CLArgs.push_back(ArgV[0]);
   33     CLArgs.push_back(ArgV[I++]);
   49       Args.push_back("-global-isel");
   51       Args.push_back("-O0");
   53       Args.push_back("-" + Opt.str());
   55       Args.push_back("-mtriple=" + Opt.str());
   69     CLArgs.push_back(S.c_str());
   86       Args.push_back("-passes=instcombine");
   88       Args.push_back("-passes=early-cse");
   90       Args.push_back("-passes=simplify-cfg");
   92       Args.push_back("-passes=gvn");
   94       Args.push_back("-passes=sccp");
   97       Args.push_back("-passes=loop-predication");
   99       Args.push_back("-passes=guard-widening");
  101       Args.push_back("-passes=loop(rotate)");
  103       Args.push_back("-passes=loop(unswitch)");
  105       Args.push_back("-passes=unroll");
  107       Args.push_back("-passes=loop-vectorize");
  109       Args.push_back("-passes=licm");
  111       Args.push_back("-passes=indvars");
  113       Args.push_back("-passes=strength-reduce");
  115       Args.push_back("-passes=irce");
  118       Args.push_back("-mtriple=" + Opt.str());
  133     CLArgs.push_back(S.c_str());

   58     Types.push_back(Getter(M.getContext()));

   18     Cs.push_back(ConstantInt::get(IntTy, APInt::getMaxValue(W)));
   19     Cs.push_back(ConstantInt::get(IntTy, APInt::getMinValue(W)));
   20     Cs.push_back(ConstantInt::get(IntTy, APInt::getSignedMaxValue(W)));
   21     Cs.push_back(ConstantInt::get(IntTy, APInt::getSignedMinValue(W)));
   22     Cs.push_back(ConstantInt::get(IntTy, APInt::getOneBitSet(W, W / 2)));
   26     Cs.push_back(ConstantFP::get(Ctx, APFloat::getZero(Sem)));
   27     Cs.push_back(ConstantFP::get(Ctx, APFloat::getLargest(Sem)));
   28     Cs.push_back(ConstantFP::get(Ctx, APFloat::getSmallest(Sem)));
   30     Cs.push_back(UndefValue::get(T));

   19   Ops.push_back(binOpDescriptor(1, Instruction::Add));
   20   Ops.push_back(binOpDescriptor(1, Instruction::Sub));
   21   Ops.push_back(binOpDescriptor(1, Instruction::Mul));
   22   Ops.push_back(binOpDescriptor(1, Instruction::SDiv));
   23   Ops.push_back(binOpDescriptor(1, Instruction::UDiv));
   24   Ops.push_back(binOpDescriptor(1, Instruction::SRem));
   25   Ops.push_back(binOpDescriptor(1, Instruction::URem));
   26   Ops.push_back(binOpDescriptor(1, Instruction::Shl));
   27   Ops.push_back(binOpDescriptor(1, Instruction::LShr));
   28   Ops.push_back(binOpDescriptor(1, Instruction::AShr));
   29   Ops.push_back(binOpDescriptor(1, Instruction::And));
   30   Ops.push_back(binOpDescriptor(1, Instruction::Or));
   31   Ops.push_back(binOpDescriptor(1, Instruction::Xor));
   33   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_EQ));
   34   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_NE));
   35   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_UGT));
   36   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_UGE));
   37   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_ULT));
   38   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_ULE));
   39   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_SGT));
   40   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_SGE));
   41   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_SLT));
   42   Ops.push_back(cmpOpDescriptor(1, Instruction::ICmp, CmpInst::ICMP_SLE));
   46   Ops.push_back(binOpDescriptor(1, Instruction::FAdd));
   47   Ops.push_back(binOpDescriptor(1, Instruction::FSub));
   48   Ops.push_back(binOpDescriptor(1, Instruction::FMul));
   49   Ops.push_back(binOpDescriptor(1, Instruction::FDiv));
   50   Ops.push_back(binOpDescriptor(1, Instruction::FRem));
   52   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_FALSE));
   53   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_OEQ));
   54   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_OGT));
   55   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_OGE));
   56   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_OLT));
   57   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_OLE));
   58   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_ONE));
   59   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_ORD));
   60   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_UNO));
   61   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_UEQ));
   62   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_UGT));
   63   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_UGE));
   64   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_ULT));
   65   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_ULE));
   66   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_UNE));
   67   Ops.push_back(cmpOpDescriptor(1, Instruction::FCmp, CmpInst::FCMP_TRUE));
   72   Ops.push_back(splitBlockDescriptor(1));
   76   Ops.push_back(gepDescriptor(1));
   81   Ops.push_back(extractValueDescriptor(1));
   82   Ops.push_back(insertValueDescriptor(1));
   86   Ops.push_back(extractElementDescriptor(1));
   87   Ops.push_back(insertElementDescriptor(1));
   88   Ops.push_back(shuffleVectorDescriptor(1));
  201     Result.push_back(ConstantInt::get(Int32Ty, 0));
  203       Result.push_back(ConstantInt::get(Int32Ty, N - 1));
  205       Result.push_back(ConstantInt::get(Int32Ty, N / 2));
  260         Result.push_back(ConstantInt::get(Int32Ty, I));

  585   Args.push_back(B.getInt64(ID));
  586   Args.push_back(B.getInt32(NumPatchBytes));
  588   Args.push_back(B.getInt32(CallArgs.size()));
  589   Args.push_back(B.getInt32(Flags));
  591   Args.push_back(B.getInt32(TransitionArgs.size()));
  593   Args.push_back(B.getInt32(DeoptArgs.size()));

  139       pCodes->push_back(StringRef(I, ConstraintEnd+1 - I));
  146       pCodes->push_back(StringRef(NumStart, I - NumStart));
  182       pCodes->push_back(StringRef(I+1, 2));
  192       pCodes->push_back(StringRef(I, N));
  196       pCodes->push_back(StringRef(I, 1));

  855   getContext().pImpl->DistinctMDNodes.push_back(this);

  420         CrossModuleEdges.push_back({ModId, Hotness, IdFrom, IdTo});
  485       ModList.push_back(-1);

   70     ToFree.push_back(std::unique_ptr<const PassInfo>(&PI));
  115     ToFree.push_back(std::unique_ptr<const PassInfo>(&Registeree));

   56     Entries.push_back(MDTuple::get(Context, EntryMD));

  449         File->Symbols.push_back(Sym);
  450     File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
  624   RegularLTO.ModsWithSummaries.push_back(std::move(*ModOrErr));
  683       Mod.Keep.push_back(&GV);

  466         DeadGVs.push_back(&GV);

  400     Used.push_back(&GV);
  630     CodegenOptions.push_back(o.first);
  639       CodegenArgv.push_back(Arg.c_str());

  520   _asm_undefines.push_back(IterBool.first->first());

  109       LLVMUsed.push_back(&GV);
  116       LLVMUsed.push_back(&GV);

  935     RAUWWorklist.push_back(
 1038     RAUWWorklist.push_back(std::make_pair(

  504         LazyComdatMembers[SC].push_back(&GV);
  509         LazyComdatMembers[SC].push_back(&SF);
  514         LazyComdatMembers[SC].push_back(&GA);

  376       ShndxIndexes.push_back(0);
 1143       Members.push_back(&Section);
 1145         Members.push_back(RelSection);

  129   Sections.push_back(&Section);
  458     Symbols.push_back(&Symbol);

  299             FilteredLines.push_back(MCCVLoc(

  331   getAssembler().Symvers.push_back({AliasName, Aliasee});
  365   getAssembler().CGProfile.push_back({From, To, Count});

  248   getAssembler().getLinkerOptions().push_back(Options);

 3888     Ranges.push_back({GapStartSym, GapEndSym});
 4426     Parameters.push_back(std::move(Parameter));

  138       Strings.push_back(&P);

   43     Features.push_back(hasFlag(String) ? String.lower()

  242   Symbols.push_back(std::make_unique<COFFSymbol>(Name));
  559     Arr.push_back(Section.get());

  452   Parent->ThinBuffers.push_back(std::move(*Buf));

  380     Ret.push_back(SymNames.tell());
  498     Ret.push_back({std::move(*Symbols), std::move(Header), Data, Padding});

  579   Members.push_back(OF.createImportDescriptor(ImportDescriptor));
  582   Members.push_back(OF.createNullImportDescriptor(NullImportDescriptor));
  585   Members.push_back(OF.createNullThunk(NullThunk));
  610       Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, false));
  611       Members.push_back(OF.createWeakExternal(E.AliasTarget, *Name, true));
  615     Members.push_back(

 1772     Relocs.push_back(&R);

  446       Result.push_back(std::make_pair(

  128     Mods.push_back(std::move(*MOrErr));

  359     Mods.push_back(MOrErr->get());
  360     OwnedMods.push_back(std::move(*MOrErr));

   63     SymTab.push_back(&GV);
   66     SymTab.push_back(new (AsmSymbols.Allocate()) AsmSymbol(Name, Flags));

   48       Ret.push_back({Sym, Sym.getSize()});
   59     Addresses.push_back({I, Value, SymNum, getSymbolSectionID(O, Sym)});
   65     Addresses.push_back(

  336     DylinkInfo.Needed.push_back(readString(Ctx));
  367         DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
  888     Signatures.push_back(std::move(Sig));
  961     Tables.push_back(readTable(Ctx));
  977     Memories.push_back(readLimits(Ctx));
 1190       Segment.Functions.push_back(readVaruint32(Ctx));

  301   Duplicates.push_back(
  349   InputFilenames.push_back(WR->getFileName());
  357         Duplicates.push_back(makeDuplicateResourceError(
  371   InputFilenames.push_back(Filename);
  408         Context.push_back(StringOrID(NameString));
  411         Context.push_back(StringOrID(Entry.Identifier.ID));
  431       Context.push_back(StringOrID(Entry.Identifier.ID));
  437         Data.push_back(ArrayRef<uint8_t>(
  442           Duplicates.push_back(makeDuplicateResourceError(
  508     Data.push_back(Entry.getData());
  543     StringTable.push_back(NameRef);
  906         DataEntriesTreeOrder.push_back(Child.second.get());
  925         DataEntriesTreeOrder.push_back(Child.second.get());

  192     Builders.push_back(std::move(B));

  741     Result->RVAs.push_back(RVA);
  758     Result.push_back(std::move(CVS));

  477     Records.push_back(MemberRecord{Impl});

  228     ImplicitSections.push_back(".symtab");
  243     Doc.Sections.push_back(std::move(Sec));
  660       Sections.push_back(&SHeaders[Index]);

  881       Ret.push_back({P.first});
  886       Ret.push_back({UnknownFlagsHolder});

  398       WriteQueue.push_back(
  400       WriteQueue.push_back(
  405       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->rebase_off,
  407       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->bind_off,
  409       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off,
  411       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off,
  413       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off,

   37     Callbacks.push_back(std::move(Callback));

  492       Ranges.push_back({MD, *ExpectedContent});
  511       Modules.push_back(
  544       Threads.push_back({T, *ExpectedStack, *ExpectedContext});
  559     Streams.push_back(std::move(*ExpectedStream));

  222         Result.push_back(Val);
  572       GroupedOptionHelp[HelpGroup].push_back({OptName, HelpText});

 1759     Pipeline.push_back({Text.substr(0, Pos), {}});

  260   Functions.push_back(std::move(Function));
  360     Functions.push_back(&Function);

  743     Readers.push_back(std::move(ReaderOrErr.get()));
  786         Readers.push_back(std::move(Reader));
  804   Readers.push_back(std::move(ReaderOrErr.get()));

  430     NameStrs.push_back(getPGOFuncNameVarInitializer(NameVar));

  232         CurrentValues.push_back({Value, TakenCount});
  434       Record.Counts.push_back(swap(Count));
  560       CounterBuffer.push_back(endian::readNext<uint64_t, little, unaligned>(D));

  717     NameTable.push_back(std::to_string(*FID));
  744   SecHdrTable.push_back(std::move(Entry));
 1046     Names.push_back(Str);

   49     V.push_back(std::make_pair(I.getKey(), &I.second));
  125   SecHdrTable.push_back({Type, Entry.Flags, SectionStart - FileStart,

   31     Offsets.push_back(Split.first.data() - Buffer.data());

   68     Features.push_back("+fp-armv8");
   70     Features.push_back("+neon");
   72     Features.push_back("+crc");
   74     Features.push_back("+crypto");
   76     Features.push_back("+dotprod");
   78     Features.push_back("+fp16fml");
   80     Features.push_back("+fullfp16");
   82     Features.push_back("+spe");
   84     Features.push_back("+ras");
   86     Features.push_back("+lse");
   88     Features.push_back("+rdm");
   90     Features.push_back("+sve");
   92     Features.push_back("+sve2");
   94     Features.push_back("+sve2-aes");
   96     Features.push_back("+sve2-sm4");
   98     Features.push_back("+sve2-sha3");
  100     Features.push_back("+sve2-bitperm");
  102     Features.push_back("+rcpc");
  110     Features.push_back("+v8.1a");
  112     Features.push_back("+v8.2a");
  114     Features.push_back("+v8.3a");
  116     Features.push_back("+v8.4a");
  118     Features.push_back("+v8.5a");

  202       Features.push_back(Info.PlusName);
  204       Features.push_back(Info.MinusName);
  217       Features.push_back(Info.PlusName);
  219       Features.push_back(Info.MinusName);
  392     Features.push_back("+hwdiv-arm");
  394     Features.push_back("-hwdiv-arm");
  397     Features.push_back("+hwdiv");
  399     Features.push_back("-hwdiv");
  412       Features.push_back(AE.Feature);
  414       Features.push_back(AE.NegFeature);
  511       Features.push_back(AE.NegFeature);
  513       Features.push_back(AE.Feature);
  523         Features.push_back("-fp64");

 2187       SortedCategories.push_back(*I);

   75     CurrentDebugType->push_back(Types[T]);
  108       CurrentDebugType->push_back(dbgType);

  840   NumericVariables.push_back(
  848   Substitutions.push_back(
  856   Substitutions.push_back(std::make_unique<FileCheckNumericSubstitution>(
 1155     ImplicitNegativeChecks.push_back(
 1624       NotStrings.push_back(&Pat);
 1753     Req.CheckPrefixes.push_back("CHECK");

  170     args.push_back(ViewerPath);
  171     args.push_back(Filename);
  180     args.push_back(ViewerPath);
  181     args.push_back(Filename);
  190     args.push_back(ViewerPath);
  191     args.push_back(Filename);
  193     args.push_back("-f");
  194     args.push_back(getProgramName(program));
  231     args.push_back(GeneratorPath);
  233       args.push_back("-Tpdf");
  235       args.push_back("-Tps");
  236     args.push_back("-Nfontname=Courier");
  237     args.push_back("-Gsize=7.5,10");
  238     args.push_back(Filename);
  239     args.push_back("-o");
  240     args.push_back(OutputFilename);
  252     args.push_back(ViewerPath);
  255       args.push_back("-W");
  256       args.push_back(OutputFilename);
  260       args.push_back(OutputFilename);
  263       args.push_back("--spartan");
  264       args.push_back(OutputFilename);
  267       args.push_back("/S");
  268       args.push_back("/C");
  271       args.push_back(StartArg);
  284     args.push_back(ViewerPath);
  285     args.push_back(Filename);

  524     Elements.push_back(&E);

   85         Offsets->push_back(static_cast<T>(N));

  121     Targets.push_back(std::make_pair(T.getName(), &T));

  171     Result.push_back(Saver.save(S).data());
  172   Result.push_back(nullptr);

 1245       FS->Roots.push_back(std::move(E));
 1369             EntryArrayContents.push_back(std::move(E));
 1472       Entries.push_back(std::move(Result));
 1526             RootEntries.push_back(std::move(E));

  148     Ret.push_back(P.first());
  390       SQHNode->Entries.push_back(std::move(Entry));

 2214       Defs.push_back(DI->getDef());
 2242       Ints.push_back(II->getValue());
 2258       Strings.push_back(SI->getValue());
 2366       Defs.push_back(D.second.get());

  139     MatchesByLength[Matches[i].first.size()].push_back(&Matches[i]);

   53   PrepIncludeStack.push_back(
  395   PrepIncludeStack.push_back(
  696     PrepIncludeStack.back()->push_back(
  737     PrepIncludeStack.back()->push_back(

  348     Loops.back()->Entries.push_back(std::move(E));
  359     CurMultiClass->Entries.push_back(std::move(E));
  426         Dest->push_back(std::move(Rec));
 2502       Values.push_back(IntInit::get(R));
 2786   Loops.push_back(std::make_unique<ForeachLoop>(Loc, IterName, ListValue));
 2914   LetStack.push_back(std::move(LetInfo));

  374     V.push_back(std::move(Cs));
  560           ToErase.push_back(OrigReg);
  621     AllChains.push_back(std::move(G));
  666     AllChains.push_back(std::move(G));

 4068     Ops.push_back(DAG.getTargetConstant(FPDiff, DL, MVT::i32));
 4074     Ops.push_back(DAG.getRegister(RegToPass.first,
 4111   Ops.push_back(DAG.getRegisterMask(Mask));
11128       NewResults.push_back(SDValue(UpdN.getNode(), i));
11130     NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs + 1));

  354         Result.push_back(std::make_pair(PltSectionVA + Byte, Imm));

   96       AliasesToRemove.push_back(&A);

  268     DisasmLines.push_back(MF->getName().str() + ":");
  270     HexLines.push_back("");
  279     DisasmLines.push_back(
  283     HexLines.push_back("");

  206     Dims.push_back(mdconst::extract<ConstantInt>(Op)->getZExtValue());
  262       Printf.push_back(cast<MDString>(Op->getOperand(0))->getString());
  277   Kernel.mLanguageVersion.push_back(
  279   Kernel.mLanguageVersion.push_back(
  367   HSAMetadata.mKernels.back().mArgs.push_back(Kernel::Arg::Metadata());
  474   HSAMetadata.mKernels.push_back(Kernel::Metadata());

  920     Args.push_back(getIntrinsicParamType(C, P, true));

  390       WorkList.push_back(AllocaUser);
  409       WorkList.push_back(GEPUser);
  534       WorkList.push_back(User);
  571       WorkList.push_back(ICmp);
  579       WorkList.push_back(User);
  616     WorkList.push_back(User);

  890   Mutations.push_back(std::make_unique<MemOpClusterMutation>(&InstrInfo));
  891   Mutations.push_back(std::make_unique<FillMFMAShadowMutation>(&InstrInfo));

  343     Schedule.push_back(SU);

  305     Regions.push_back(
  346     Res.push_back(SU->getInstr());

  209     Indexes.push_back(After ? SI.getDeadSlot() : SI.getBaseIndex());

  333     Unsched.push_back(&I);

  198   LoopStack.push_back(CFStack::ENTRY);
  350       ClauseContent.push_back(&*I);
  389         Lits.push_back(&Operand);
  433           ClauseContent.push_back(&*BI);
  439         ClauseContent.push_back(&*I);
  460         ClauseContent.push_back(MILit);
  535           FetchClauses.push_back(MakeFetchClause(MBB, I));
  565           AluClauses.push_back(MakeALUClause(MBB, I));
  577           LoopStack.push_back(std::move(Pair));
  595           LastAlu.push_back(nullptr);

  151         UsedKCache.push_back(std::pair<unsigned, unsigned>(0, KCacheIndex));
  155         UsedKCache.push_back(std::pair<unsigned, unsigned>(0, KCacheIndex));
  160         UsedKCache.push_back(std::pair<unsigned, unsigned>(1, KCacheIndex));
  164         UsedKCache.push_back(std::pair<unsigned, unsigned>(1, KCacheIndex));

 2141           Consts.push_back(Cst->getZExtValue());
 2147     Consts.push_back(Cst->getZExtValue());

  353       Result.push_back(std::make_pair(Index, 0U));
  357       Result.push_back(std::make_pair(255, 0U));
  366     Result.push_back(std::make_pair(Index, Chan));
  547     IGSrcs.push_back(ExtractSrcs(*IG[i], PV, ConstCount));
  550     ValidSwizzle.push_back( (R600InstrInfo::BankSwizzle)
  623         Consts.push_back(Src.second);
  628         Consts.push_back((Index << 2) | Chan);

  323     InstructionsGroupCandidate.push_back(SU->getInstr());
  443           InstructionsGroupCandidate.push_back(SU->getInstr());

  173       Remap.push_back(std::pair<unsigned, unsigned>
  179     Remap.push_back(std::pair<unsigned, unsigned>

  250     CurrentPacketMIs.push_back(&MI);

 2926   Ops.push_back(DAG.getTargetGlobalAddress(GV, DL, MVT::i64));
 2932     Ops.push_back(DAG.getTargetConstant(FPDiff, DL, MVT::i32));
 2940     Ops.push_back(DAG.getRegister(RegToPass.first,
 2949   Ops.push_back(DAG.getRegisterMask(Mask));

  602       DomBlocks.push_back(Use.getParent());
  715         DomBlocks.push_back(Use.getParent());

  213         CSI.push_back(CalleeSavedInfo(Reg, JunkFI));

  315     SpillLanes.push_back(SpilledReg(LaneVGPR, VGPRIndex));

  570   Succs.push_back(std::make_pair(Succ, Kind));
 1231       BlockPtrs.push_back(std::make_unique<SIScheduleBlock>(DAG, this, ID));
 1232       CurrentBlocks.push_back(BlockPtrs.rbegin()->get());
 1301       WorkList.push_back(i);
 1314         WorkList.push_back(Pred->getID());

  111       RegsToRewrite.push_back(Reg);

  266   Worklist.push_back(&MI);
  377           Worklist.push_back(&MBB);
  445       Worklist.push_back(MBB);
  456         Worklist.push_back(PrevMI);
  483       Worklist.push_back(LastMI);
  495     Worklist.push_back(Pred);
  505     Worklist.push_back(Succ);

  163         Branches.push_back(&MI);

  706       WaterList.push_back(&MBB);
  757         ImmBranches.push_back(ImmBranch(&I, MaxOffs, isCond, UOpc));
  844           CPUsers.push_back(CPUser(&I, CPEMI, MaxOffs, NegOk, IsSoImm));
 1303       ImmBranches.push_back(ImmBranch(&UserMBB->back(),
 1528   CPEntries[CPI].push_back(CPEntry(U.CPEMI, ID, 1));
 1729   ImmBranches.push_back(ImmBranch(&MBB->back(), MaxDisp, false, Br.UncondBr));

 1972     ResTys.push_back(MVT::i32);
 1973   ResTys.push_back(MVT::Other);
 2104     ResTys.push_back(MVT::i32);
 2105   ResTys.push_back(MVT::Other);
 2270     ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(),
 2274     ResTys.push_back(MVT::i32);
 2275   ResTys.push_back(MVT::Other);
 2559     ResTys.push_back(MVT::i32);
 2560   ResTys.push_back(MVT::Other);
 3849         ResTys.push_back(MVT::i32);
 3850         ResTys.push_back(MVT::i32);
 3852         ResTys.push_back(MVT::Untyped);
 3853       ResTys.push_back(MVT::Other);
 4309       Ops.push_back(CurDAG->getTargetConstant(IntField, DL, MVT::i32));
 4440     Ops.push_back(getAL(CurDAG, DL));
 4441     Ops.push_back(CurDAG->getRegister(0, MVT::i32));
 4555     Ops.push_back(getAL(CurDAG, DL));
 4556     Ops.push_back(CurDAG->getRegister(0, MVT::i32));
 4738       Ops.push_back(T1.getValue(1));

 2398     Ops.push_back(DAG.getRegister(RegsToPass[i].first,
 2419     Ops.push_back(DAG.getRegisterMask(Mask));
13170     VLDDupResults.push_back(SDValue(VLDDup.getNode(), n));
13171   VLDDupResults.push_back(SDValue(VLDDup.getNode(), NumVecs));

   43       result.push_back({v[i].first + 1, Unsupported});
   58   result.push_back({Largest + 1, Unsupported});

   72             ToRemove.push_back(&MI);

   79           ITStates.push_back(CCBits ^ Else);

  126       GPR32LiveDefs.push_back(MO.getReg());
  133       GPR64DeadDefs.push_back(MO.getReg());

  376   Table.push_back(S);
  393   TypeEntries.push_back(std::move(TypeEntry));
  400   TypeEntries.push_back(std::move(TypeEntry));
  466   StructTypes.push_back(TypeEntry.get());
  572           Fixup.second.push_back(TypeEntry.get());
  651   StructTypes.push_back(TypeEntry.get());
  688       Content.push_back(*I);

  184     Vars.push_back(std::make_tuple(Id, Sym, Size));

  997     Instrs.push_back(&*I);
 1223         Pending.push_back(DefR);
 1719     Instrs.push_back(&*I);
 2302       NewMIs.push_back(NewBS);
 3127     Phis.push_back(PhiInfo(I, *C.LB));
 3194     ShufIns.push_back(&*I);
 3350     Cand.push_back(LoopCand(&B, PB, EB));

  108       push_back(IndexRange(Start, End, Fixed, TiedEnd));

  328   Order.push_back(Root);
  781       Bs.push_back(PB);
  884       Bs.push_back(PIn->getParent());
  889     Bs.push_back(IIn->getParent());
 1152         Values.push_back((*I)->getUser());
 1246   BO.push_back(&Fn->front());
 1251       BO.push_back(DTN->getBlock());
 1262       Ins.push_back(&*I);

 1860       RegOps.push_back({&UI, getOperandIndex(UI, Op)});

 1519     CSI.push_back(CalleeSavedInfo(S->Reg, FI));
 1536     CSI.push_back(CalleeSavedInfo(R, FI));

  841           LM[L].push_back(std::make_pair(*I, S));
  843           LM[L].push_back(std::make_pair(*I, S));
  854         LM[L].push_back(std::make_pair(*I, S));
 1120     LL.push_back(std::make_pair(MaxIF, RegisterSet()));
 1461     Instrs.push_back(&*I);

  929   OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
 1213       T.push_back(&N);

  998         Ops.push_back(ISel.selectUndef(dl, MVT(SVT)));
 1024     Output.push_back(SDValue(ResN, 0));

  171       Rules.push_back(Rule(N, F));

  540       DP.push_back(R);

  216     AllInsns.push_back(&I);

  377   Mutations.push_back(std::make_unique<UsrOverflowMutation>());
  378   Mutations.push_back(std::make_unique<HVXMemLatencyMutation>());
  379   Mutations.push_back(std::make_unique<BankConflictMutation>());
  384   Mutations.push_back(std::make_unique<UsrOverflowMutation>());
  385   Mutations.push_back(std::make_unique<HVXMemLatencyMutation>());

 1479       IgnoreDepMIs.push_back(&I);
 1699     CurrentPacketMIs.push_back(&MI);
 1742     CurrentPacketMIs.push_back(&MI);
 1743     CurrentPacketMIs.push_back(&NvjMI);
 1760   CurrentPacketMIs.push_back(&MI);
 1789       OldPacketMIs.push_back(&I);

  145             VecPrintList.push_back((&*MII));
  153           VecPrintList.push_back(&MI);

  244           AppliedRestrictions.push_back(std::make_pair(
  247           AppliedRestrictions.push_back(
  274           AppliedRestrictions.push_back(std::make_pair(
  282       AppliedRestrictions.push_back(std::make_pair(

  282     Ns.push_back(B->getNumber());
  289     Ns.push_back(B->getNumber());
  697   Stack.push_back(NodeAddr<DefNode*>(nullptr, N));
 1448     MaxRefs.push_back(MaxCoverIn(I, AllRefs));

  813         LV.push_back(RegisterRef(I->PhysReg, I->LaneMask));
  824         LV.push_back(*I);
  840       T.push_back(I->PhysReg);

  657       WaterList.push_back(&MBB);
  732         ImmBranches.push_back(ImmBranch(&MI, MaxOffs, isCond, UOpc));
  772           CPUsers.push_back(CPUser(&MI, CPEMI, MaxOffs, NegOk, LongFormMaxOffs,
 1241       ImmBranches.push_back(ImmBranch(&UserMBB->back(),
 1390   CPEntries[CPI].push_back(CPEntry(U.CPEMI, ID, 1));
 1630   ImmBranches.push_back(ImmBranch(&MBB->back(), MaxDisp, false, Br.UncondBr));

 3576       OutChains.push_back(ArgValue.getValue(1));

 1283     OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
 1293     OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
 1307     OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
 1334     OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));

 3700       OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));

 2485     theArgs.push_back(&I);
 2486     argTypes.push_back(I.getType());

   63       retval[keyname].push_back(Val->getZExtValue());
   66       tmp.push_back(Val->getZExtValue());

 4959   NodeTys.push_back(MVT::Other);   // Returns a chain
 4960   NodeTys.push_back(MVT::Glue);    // Returns a flag for retval copy to use.
 5108     NodeTys.push_back(MVT::Other);
 5109     NodeTys.push_back(MVT::Glue);

  204     LiveInAttrs.push_back(std::make_pair(VReg, Flags));

 2694           Ops.push_back(
 2702           Ops.push_back(
 2710           Ops.push_back(

  253       Ops.push_back(T1.getValue(1));

  563       OutChains.push_back(

 1161           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),
 1168           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),
 1175           Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), SDLoc(Op),
 1182           Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), SDLoc(Op),
 1189           Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), SDLoc(Op),

  227     Signatures.push_back(std::move(Sig));
  586             Op->BrL.List.push_back(Lexer.getTok().getIntVal());

   42     Signatures.push_back(std::move(Sig));

  901   SetjmpTableSizeInsts.push_back(SetjmpTableSize);
  954     BBs.push_back(&BB);

  478       Result.push_back(
  485       Result.push_back(std::make_pair(PltSectionVA + Byte, Imm));
  503       Result.push_back(

  770       Closures.push_back(std::move(C));

  123     TargetMBBs.push_back({ThenMBB, Target});

 5657       Table.push_back({Entry.DstOp, Entry.KeyOp,

 5665     VTs.push_back(*TRI.legalclasstypes_begin(*DstRC));
 5673     BeforeOps.push_back(SDValue(Load, 0));
 5705     AddrOps.push_back(SDValue(NewNode, 0));

   42       result.push_back({v[i].first + 1, Unsupported});
   54   result.push_back({Largest + 1, Unsupported});

  380   Mutations.push_back(createX86MacroFusionDAGMutation());

  445       XFI->getSpillLabels().push_back(std::make_pair(Store, *it));

   75   Ret.push_back("");
   79     Ret.push_back(Arg->getValue());
  351     MBs.push_back(std::move(*MOrErr));

  151       Params.push_back(I->getType());
  181           Indices.push_back(cast<ConstantInt>(*II)->getSExtValue());
  198         Params.push_back(GetElementPtrInst::getIndexedType(
  292               Ops.push_back(ConstantInt::get(IdxTy, II));
  443           Operands.push_back(cast<ConstantInt>(*II)->getSExtValue());
  638               Indices.push_back(CI->getSExtValue());
  675       Operands.push_back(0);
  697           Operands.push_back(C->getSExtValue());

 4708       ReadOrWriteInsts.push_back(&I);

  756       Params.push_back(I->getType());
  803         RetTypes.push_back(getRetComponentType(F, i));
  898         Args.push_back(*I);
  918       Args.push_back(*I);

  358       DeadGlobalVars.push_back(&GV);         // Keep track of dead globals
  371       DeadFunctions.push_back(&F);         // Keep track of dead globals
  380       DeadAliases.push_back(&GA);
  388       DeadIFuncs.push_back(&GIF);

 1189     PHIsToRewrite.push_back(std::make_pair(PN, FieldNo));
 1308     FieldGlobals.push_back(NGV);

  364         FunctionAliases.push_back({&GIS, F});
  838       GlobalInits.push_back(
  842     GlobalInits.push_back(GV->getInitializer());
 2107         TypeIds.push_back(MI->get<Metadata *>());
 2109         Globals.push_back(MI->get<GlobalTypeMember *>());
 2111         ICallBranchFunnels.push_back(MI->get<ICallBranchFunnel *>());

  400       HashedFuncs.push_back({FunctionComparator::functionHash(Func), &Func});
  412       Deferred.push_back(WeakTrackingVH(I->second));
  534     WorklistBB.push_back(&*BBI);

  488       DFS.push_back(*SI);
 1207       ToExtract.push_back(&BB);
 1458       Worklist.push_back(&F);

  203   Extensions.push_back(std::make_pair(Ty, std::move(Fn)));

  820       R.push_back(&NameFS.second);

  180       V.push_back(&GV);

  180       Used.push_back(VTUsed.slice(Offset));
  430     Args.push_back(CI->getZExtValue());
  439   CSI.CallSites.push_back({VTable, CS, NumUnsafeUses});
  833     TargetsForSlot.push_back({Fn, &TM});
 1066   JTArgs.push_back(JT->arg_begin());
 1068     JTArgs.push_back(getMemberAddr(T.TM));
 1069     JTArgs.push_back(T.Fn);
 1109       NewArgs.push_back(Int8PtrTy);
 1119       Args.push_back(IRB.CreateBitCast(VCallSite.VTable, Int8PtrTy));
 1121         Args.push_back(CS.getArgOperand(I));
 1135       NewArgAttrs.push_back(AttributeSet::get(
 1139         NewArgAttrs.push_back(Attrs.getParamAttributes(I));
 1936     NameByGUID[GlobalValue::getGUID(P.first)].push_back(P.first);

 4753           NewArgs.push_back(*I);
 4754           NewArgAttrs.push_back(Attrs.getParamAttributes(ArgNo));

   94     Nodes.push_back(MDNode::get(Context, Vals));

  269     ArgumentAttributes.push_back(CallSiteAttrs.getParamAttributes(i));
  521       ArgumentIndexMapping.push_back(ArgTypes.size());
  525       ArgumentIndexMapping.push_back(ArgTypes.size());
  669       Args.push_back(&*ai);
  691       Args.push_back(&*AI);
  793       FnsToInstrument.push_back(&i);
  913         FnsToInstrument.push_back(&F);
 1603             Args.push_back(T);
 1604             Args.push_back(
 1607             Args.push_back(*i);
 1614           Args.push_back(DFSF.getShadow(*i));
 1628           Args.push_back(IRB.CreateStructGEP(LabelVATy, LabelVAAlloca, 0));
 1638           Args.push_back(DFSF.LabelReturnAlloca);
 1642           Args.push_back(*i);
 1701       DFSF.NonZeroChecks.push_back(LI);
 1715       Args.push_back(*i);
 1719       Args.push_back(DFSF.getShadow(*i));
 1727       Args.push_back(IRB.CreateConstGEP2_32(VarArgArrayTy, VarArgShadow, 0, 0));
 1732         Args.push_back(*i);
 1756       DFSF.NonZeroChecks.push_back(ExShadow);
 1776   DFSF.PHIFixups.push_back(std::make_pair(&PN, ShadowPN));

 1418     Globals.push_back(&GV);
 1448       PersonalityFns[F.getPersonalityFn()->stripPointerCasts()].push_back(&F);
 1450       PersonalityFns[nullptr].push_back(&F);

  290     Ret.push_back(PromotionCandidate(TargetFunction, Count));

  852   UsedVars.push_back(Data);
  907   UsedVars.push_back(VNodesVar);
  935   UsedVars.push_back(NamesVar);
 1012   UsedVars.push_back(User);

  623         Indexes.push_back((uint8_t)(Index >> (J * 8)));
  727     EdgeList.push_back(E.get());
 1579         ColdFunctions.push_back(&F);
 1588       ColdFunctions.push_back(&F);
 1590       HotFunctions.push_back(&F);

  168     WorkList.push_back(&MI);
  387       Updates.push_back({DominatorTree::Insert, CaseBB, MergeBB});
  388       Updates.push_back({DominatorTree::Insert, BB, CaseBB});

   61       Vector.push_back(std::make_pair(Arg, ValueT()));

  377       ConstIntCandVec.push_back(ConstantCandidate(ConstInt));
  425     ExprCandVec.push_back(ConstantCandidate(

   63     Blocks.push_back(&BB);

  317       PostorderStack.push_back(std::make_pair(CE, false));
  325       PostorderStack.push_back(std::make_pair(V, false));
  396         Postorder.push_back(TopVal);

 1104       Updates.push_back({DominatorTree::Delete, BB, Succ});
 1688           Updates.push_back({DominatorTree::Delete, BB, SuccBB});
 2129     Updates.push_back({DominatorTree::Insert, NewBB, BB});
 2131       Updates.push_back({DominatorTree::Delete, Pred, BB});
 2132       Updates.push_back({DominatorTree::Insert, Pred, NewBB});
 2294   Updates.push_back({DominatorTree::Delete, PredBB, BB});
 2310     Updates.push_back({DominatorTree::Insert, OldPredBB, PredBB});
 2311     Updates.push_back({DominatorTree::Insert, PredBB, BB});
 2312     Updates.push_back({DominatorTree::Delete, OldPredBB, BB});
 2357           Updates.push_back({DominatorTree::Insert, PredBB, SuccBB});
 2619     Updates.push_back({DominatorTree::Insert, BB, SplitBB});
 2620     Updates.push_back({DominatorTree::Insert, BB, NewBB});
 2621     Updates.push_back({DominatorTree::Insert, NewBB, SplitBB});
 2624       Updates.push_back({DominatorTree::Delete, BB, Succ});
 2625       Updates.push_back({DominatorTree::Insert, SplitBB, Succ});

  166           Dep.push_back('I');
 1330       DTUpdates.push_back(
 1332       DTUpdates.push_back(

 1427     Worklist.push_back(cast<Instruction>(U));
 1635             Worklist.push_back(cast<Instruction>(U));

  402   Comparisons.push_back(std::move(Comparison));

  686     ParsePointsNeeded.push_back(CI);

 1564     Replacements.push_back(

 1763       ConstVals.push_back(V.isConstant()

 3721       Offsets.Splits.push_back(P.endOffset() - S.beginOffset());
 3743         Offsets.Splits.push_back(P.endOffset() - Offsets.S->beginOffset());

  240         Updates.push_back({DominatorTree::Insert, PredBB, *I});
  242       Updates.push_back({DominatorTree::Delete, BB, *I});
  243     Updates.push_back({DominatorTree::Delete, PredBB, BB});

   58     Ops.push_back(canonicalizeAlias(cast<Constant>(U), Changed));

  246       ArgTypes.push_back(I.getType());
  372           CodeInfo->OperandBundleCallSites.push_back(NewInst);
  399         ToClone.push_back(Dest);
  414       ToClone.push_back(Dest);
  429           CodeInfo->OperandBundleCallSites.push_back(NewInst);

  789     paramTy.push_back(value->getType());
  796       paramTy.push_back(output->getType());
  798       paramTy.push_back(PointerType::getUnqual(output->getType()));
  812     paramTy.push_back(PointerType::getUnqual(StructTy));
 1096       ReloadOutputs.push_back(alloca);
 1097       params.push_back(alloca);
 1107       ArgTypes.push_back((*v)->getType());
 1114     params.push_back(Struct);
 1168     Reloads.push_back(load);

   73     Result.push_back(dyn_cast<Function>(CS->getOperand(1)));

   57     NonImportedCallers.push_back(It->first());
  190     SortedNodes.push_back(&Node);

  250             Updates.push_back({DominatorTree::Delete, BB, Succ});
  321             Updates.push_back({DominatorTree::Delete, ParentBB, DestBB});
 1914       Updates.push_back({DominatorTree::Delete, BB, Successor});
 2245         Updates.push_back({DominatorTree::Delete, BB, Successor});

  547     OrigPHINode.push_back(cast<PHINode>(I));
  560       HeaderSucc.push_back(Term->getSuccessor(0));
  563       HeaderSucc.push_back(Term->getSuccessor(1));

  276   ForeBlocksLast.push_back(SubLoop->getLoopPreheader());
  277   SubLoopBlocksFirst.push_back(SubLoop->getHeader());
  278   SubLoopBlocksLast.push_back(SubLoop->getExitingBlock());
  279   AftBlocksFirst.push_back(SubLoop->getExitBlock());
  280   AftBlocksLast.push_back(L->getExitingBlock());

  406     Cases.push_back(CaseRange(Case.getCaseValue(), Case.getCaseValue(),

   49   Inits.push_back(ConstantArray::get(

  731       Cases.push_back(ValueEqualityComparisonCase(Case.getCaseValue(),
  739   Cases.push_back(ValueEqualityComparisonCase(
 1157           PredCases.push_back(ValueEqualityComparisonCase(I, BBDefault));

   53       ReturningBlocks.push_back(&I);
   55       UnreachableBlocks.push_back(&I);

 4126           OpVecs.push_back(CEI->getArgOperand(j));
 4598     ScheduleDataChunks.push_back(std::make_unique<ScheduleData[]>(ChunkSize));

   21   CurrentBlock.Records.push_back(&R);
   27   CurrentBlock.Records.push_back(&R);
   32   CurrentBlock.Records.push_back(&R);
   37   CurrentBlock.Records.push_back(&R);
   42   CurrentBlock.Records.push_back(&R);
   47   CurrentBlock.Records.push_back(&R);
   52   CurrentBlock.Records.push_back(&R);
   58   CurrentBlock.Records.push_back(&R);
   68   CurrentBlock.Records.push_back(&R);
   73   CurrentBlock.Records.push_back(&R);
   78   CurrentBlock.Records.push_back(&R);
   86   It->second.push_back({CurrentBlock.ProcessID, CurrentBlock.ThreadID,

   85   CurrentRecord.CallArgs.push_back(R.arg());

  138     Sleds.push_back({});
  200     Sleds.push_back(

   18   Records.push_back(std::move(R));

   32       B.PathData.push_back({internPath(cantFail(O.expandPath(PathData.first))),
  345       TSD.push_back({E.TSC, E.FuncId});

  325   MapperComponentsPtr->Components.push_back(

  279         RTLs.UsedRTLs.push_back(&R);

   79   void addPass(std::string p) { PassesToRun.push_back(std::move(p)); }

  225       Used.push_back(cast<Constant>(V));
  284       ToRemove.push_back(&Alias);
  292         ToRemove.push_back(&I);
  504   Passes.push_back("verify");
  524         BBs.push_back(cast<BasicBlock>(V));
  611   Passes.push_back("verify");
  631         BBs.push_back(cast<BasicBlock>(V));
  703   Passes.push_back("verify");
  723         BBs.push_back(cast<BasicBlock>(V));
  801       Insts.push_back(Inst);
  858       ToDelete.push_back(&NamedMD);
  939       NamedMDOps.push_back(cast<MDNode>(*VMap.getMappedMD(Node)));
  986       GVs.push_back(&GV);
 1013             Insts.push_back(&I);
 1102       Functions.push_back(&F);
 1121     FunctionNames.push_back(F.getName());
 1156         Blocks.push_back(&BB);
 1178         Blocks.push_back(&BB);
 1191         Blocks.push_back(&BB);
 1229         NamedMDNames.push_back(NamedMD.getName().str());
 1242           NamedMDOps.push_back(op);

  217       SafeToolArgs.push_back("--relocation-model=pic");
  225       SafeToolArgs.push_back("--relocation-model=pic");
  236     SafeToolArgs.push_back("--relocation-model=pic");

  115     Passes.push_back("dce");
  117     Passes.push_back("simplifycfg"); // Delete dead control flow
  119   Passes.push_back("verify");
  136   CleanupPasses.push_back("globaldce");
  139     CleanupPasses.push_back("deadarghaX0r");
  141     CleanupPasses.push_back("deadargelim");
  153   LoopExtractPasses.push_back("loop-extract-single");
  237     ArrayElts.push_back(ConstantStruct::get(STy, Elts));
  276           M1Tors.push_back(std::make_pair(F, Priority));
  280           M2Tors.push_back(std::make_pair(F, Priority));
  412   PI.push_back("extract-blocks");

  546       Blocks.push_back(&BB);
  624       MiscompiledFunctions.push_back(&F);
  811         args.push_back(&*I);
  911             Args.push_back(&A);

  213     pass_args.push_back(std::string("-load"));
  219     pass_args.push_back(std::string("-") + (*I));

  173   LLIArgs.push_back(LLIPath);
  174   LLIArgs.push_back("-force-interpreter=true");
  179     LLIArgs.push_back("-load");
  180     LLIArgs.push_back(*i);
  185     LLIArgs.push_back(ToolArgs[i]);
  187   LLIArgs.push_back(Bitcode);
  190     LLIArgs.push_back(Args[i]);
  269   ProgramArgs.push_back(CompilerCommand);
  272     ProgramArgs.push_back(Arg);
  273   ProgramArgs.push_back(Bitcode);
  277     ProgramArgs.push_back(Arg);
  318   ProgramArgs.push_back(ExecutionCommand);
  321     ProgramArgs.push_back(ExecutorArgs[i]);
  322   ProgramArgs.push_back(Bitcode);
  326     ProgramArgs.push_back(Args[i]);
  447   LLCArgs.push_back(LLCPath);
  451     LLCArgs.push_back(ToolArgs[i]);
  453   LLCArgs.push_back("-o");
  454   LLCArgs.push_back(OutputAsmFile); // Output to the Asm file
  455   LLCArgs.push_back(Bitcode);       // This is the input bitcode
  458     LLCArgs.push_back("-filetype=obj");
  562   JITArgs.push_back(LLIPath);
  563   JITArgs.push_back("-force-interpreter=false");
  567     JITArgs.push_back(ToolArgs[i]);
  570     JITArgs.push_back("-load");
  571     JITArgs.push_back(SharedLibs[i]);
  573   JITArgs.push_back(Bitcode);
  576     JITArgs.push_back(Args[i]);
  631   CCArgs.push_back(CCPath);
  634     CCArgs.push_back("-m32");
  639     CCArgs.push_back(*I);
  643     CCArgs.push_back("-x");
  645       CCArgs.push_back("c");
  646       CCArgs.push_back("-fno-strict-aliasing");
  648       CCArgs.push_back("assembler");
  654         CCArgs.push_back("-force_cpusubtype_ALL");
  658   CCArgs.push_back(ProgramFile); // Specify the input filename.
  660   CCArgs.push_back("-x");
  661   CCArgs.push_back("none");
  662   CCArgs.push_back("-o");
  671   CCArgs.push_back(OutputBinary); // Output to the right file...
  678     CCArgs.push_back(ArgsForCC[i]);
  680   CCArgs.push_back("-lm"); // Hard-code the math library...
  681   CCArgs.push_back("-O2"); // Optimize the program a bit...
  683     CCArgs.push_back("-mcpu=v9");
  701     ProgramArgs.push_back(OutputBinary);
  703     ProgramArgs.push_back(RemoteClientPath);
  704     ProgramArgs.push_back(RemoteHost);
  706       ProgramArgs.push_back("-l");
  707       ProgramArgs.push_back(RemoteUser);
  710       ProgramArgs.push_back("-p");
  711       ProgramArgs.push_back(RemotePort);
  714       ProgramArgs.push_back(RemoteExtra);
  724     ProgramArgs.push_back(Exec);
  729     ProgramArgs.push_back(Args[i]);
  779   CCArgs.push_back(CCPath);
  782     CCArgs.push_back("-m32");
  787     CCArgs.push_back(*I);
  791     CCArgs.push_back("-x");
  792     CCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
  794   CCArgs.push_back("-fno-strict-aliasing");
  795   CCArgs.push_back(InputFile); // Specify the input filename.
  796   CCArgs.push_back("-x");
  797   CCArgs.push_back("none");
  799     CCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc
  805     CCArgs.push_back("-single_module");
  806     CCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC
  807     CCArgs.push_back("-undefined");
  808     CCArgs.push_back("dynamic_lookup");
  810     CCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others
  813     CCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC
  816     CCArgs.push_back("-mcpu=v9");
  818   CCArgs.push_back("-o");
  819   CCArgs.push_back(OutputFile);         // Output to the right filename.
  820   CCArgs.push_back("-O2");              // Optimize the program a bit.
  827     CCArgs.push_back(ArgsForCC[i]);

  428     ranges.push_back(SourceRange(B,E));
  604     LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));
  610     LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos));

  440     Parent->SubModules.push_back(this);
  509     TopHeaderNames.push_back(Filename);

  198     AllActions.push_back(std::unique_ptr<Action>(RawPtr));

   94     Flags.push_back(F);

  812     DependencyCollectors.push_back(std::move(Listener));

  242     VFSOverlayFiles.push_back(Name);
  246     PrebuiltModulePaths.push_back(Name);

  254     ExtraDiagnostics.push_back(std::move(PD));

  768       Tags.push_back(std::move(T));

  168     CheckerDtors.push_back(CheckerDtor(checker, destruct<CHECKER>));

  168     blocksAborted.push_back(std::make_pair(block, node));

  123       PartStrings.push_back(Part.toString());

  208   WarnOpts.push_back("error=arc-unsafe-retained-assign");
  442       ARCMTMacroLocs.push_back(MacroNameTok.getLocation());

  100     pairs.push_back(std::make_pair(*origFE, *newFE));

  210   Consumers.push_back(WrapperFrontendAction::CreateASTConsumer(CI, InFile));
  211   Consumers.push_back(std::make_unique<ObjCMigrateASTConsumer>(
 2013       Filenames.push_back(filename(DI->path()));

  109     MigrateCtx.GCAttrs.push_back(MigrationContext::GCAttrOccurrence());

  495   IndentationRanges.push_back(

  588     transforms.push_back(GCRewriteFinalize);
  589   transforms.push_back(independentTransforms);
  591   transforms.push_back(removeEmptyStatementsAndDeallocFinalize);

  194   Values.push_back(CCR::Equivalent);
  197     Values.push_back(CCR::Equal);
  200     Values.push_back(CCR::Less);
  201     Values.push_back(CCR::Greater);
  203     Values.push_back(CCR::Nonequivalent);
  205       Values.push_back(CCR::Nonequal);
  208     Values.push_back(CCR::Unordered);

  417     Importers.push_back(std::make_unique<LazyASTImporter>(

 3299   RecordTypeList.push_back(this);

  593         Filter.push_back(I);

   61   Out->push_back(Arg.str());

  314   Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
  341   RetTypes.push_back(
  361     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  368     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  702     Kinds.push_back(ThisKind);
  802   Out.push_back(makeMatcherAutoMarshall(

  320     P->ContextStack.push_back(std::make_pair(C, 0u));

 3250     BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
 3275   BackpatchBlocks.push_back(JumpSource(Block, ScopePos));
 3278   BackpatchBlocks.push_back(JumpSource(Succ, ScopePos));

  289           StmtsByHash.push_back(std::make_pair(
  297   StmtsByHash.push_back(std::make_pair(HashCode, StmtSequence(S, D)));

  396     BatchDiags.push_back(&D);
  442   Entry->files.push_back(std::make_pair(ConsumerName,

  163     Facts.push_back(std::move(Entry));
  424     VarDefinitions.push_back(VarDefinition(nullptr, 0u, getEmptyContext()));
  523     SavedContexts.push_back(std::make_pair(S, C));
  532     VarDefinitions.push_back(VarDefinition(D, Exp, Ctx));
  540     VarDefinitions.push_back(VarDefinition(D, i, Ctx));
  551       VarDefinitions.push_back(VarDefinition(D, Exp, Ctx));

  106   DiagStateOnPushStack.push_back(GetCurDiagState());

  541     Res.push_back("-W" + Diag);
  542     Res.push_back("-Wno-" + Diag);
  593       Diags.push_back(StaticDiagInfo[i].DiagID);

   62     Parent->SubModules.push_back(this);

  233     FilenamesByID.push_back(&*IterBool.first);
  272   Entries.push_back(LineEntry::get(Offset, LineNo, FilenameID, FileKind,

  657     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());

  240     TargetOpts.Features.push_back(
  246     TargetOpts.Features.push_back("+fp64-fp16-denormals");

  367     TargetFeatures.push_back(ArchFeature);
  405     UpdatedFeaturesVec.push_back(FixedFeature.str());
  519     Features.push_back("+neonfp");
  521     Features.push_back("-neonfp");

 1419     OwnedImports.push_back(std::move(*MBOrErr));

 3903       Args.push_back(ConstantInt::get(Int32Ty, NumArgs - 7));
 3904       ArgTys.push_back(Int32Ty);
 3910       ArgTys.push_back(ElemPtr->getType());

 2046   RetainedTypes.push_back(D.getAsOpaquePtr());
 2942   RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
 3543   FnBeginRegionCount.push_back(LexicalBlockStack.size());
 3740   FnBeginRegionCount.push_back(LexicalBlockStack.size());
 4492     RetainedTypes.push_back(

 3169   Categories.push_back(llvm::ConstantExpr::getBitCast(
 3270   Categories.push_back(llvm::ConstantExpr::getBitCast(

 6443   DefinedMetaClasses.push_back(MetaTClass);

  277   Members.push_back(StorageInfo(Size, getIntNType(8)));
  357       Members.push_back(MemberInfo(
  398         Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
  402       Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
  472     Members.push_back(StorageInfo(bitsToCharUnits(StartBitOffset), Type));
  474       Members.push_back(MemberInfo(bitsToCharUnits(StartBitOffset),
  485     Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base,
  498       Members.push_back(MemberInfo(Layout.getBaseClassOffset(BaseDecl),
  505     Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr,
  509     Members.push_back(MemberInfo(Layout.getVBPtrOffset(), MemberInfo::VBPtr,
  531   Members.push_back(MemberInfo(ScissorOffset, MemberInfo::Scissor, nullptr,
  543       Members.push_back(MemberInfo(Offset, MemberInfo::VBase, nullptr,
  549       Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4),
  551     Members.push_back(MemberInfo(Offset, MemberInfo::VBase,
  661       Padding.push_back(std::make_pair(Size, Offset - Size));
  670     Members.push_back(StorageInfo(Pad->first, getByteArrayType(Pad->second)));
  879     BFIs.push_back(std::make_pair(Index, &it->second));

 1952     RegResults.push_back(&Result);
 2042       ResultRegQualTys.push_back(OutExpr->getType());
 2044       ResultTruncRegTypes.push_back(ConvertTypeForMem(OutExpr->getType()));
 2090       ArgTypes.push_back(Dest.getAddress().getType());
 2091       Args.push_back(Dest.getPointer());
 2119       InOutArgTypes.push_back(Arg->getType());
 2202     ArgTypes.push_back(Arg->getType());
 2226         Args.push_back(BA);
 2227         ArgTypes.push_back(BA->getType());

 1078     AddressPoints.push_back(std::make_pair(

 1135   GlobalCtors.push_back(Structor(Priority, Ctor, AssociatedData));
 1147   GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
 1674       Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
 2228     Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
 2545     CXXGlobalInits.push_back(nullptr);

 1338   FunctionRecords.push_back(llvm::ConstantStruct::get(
 1341     FunctionNames.push_back(

 1216     ResultRegTypes.push_back(CGF.Int32Ty);
 1220     ResultRegTypes.push_back(CGF.Int64Ty);

 1590     Flags.push_back(std::string(CurFlag));
 1633         SuggestedCompletions.push_back(S);

  313   Environment.push_back(nullptr);

  147       Opposite.flags().push_back(("-" + Flag.substr(1)).str());

  145       BlacklistFiles.push_back(Path.str());

   45     Features.push_back("-wavefrontsize16");
   46     Features.push_back("-wavefrontsize32");
   47     Features.push_back("+wavefrontsize64");
   50     Features.push_back("-wavefrontsize16");
   51     Features.push_back("+wavefrontsize32");
   52     Features.push_back("-wavefrontsize64");

   83     Features.push_back("+neon");
  143     Features.push_back("+zcm");
  144     Features.push_back("+zcz");
  169   Features.push_back("+neon");
  193     Features.push_back("-fp-armv8");
  194     Features.push_back("-crypto");
  195     Features.push_back("-neon");
  201       Features.push_back("+tpidr-el3");
  203       Features.push_back("+tpidr-el2");
  205       Features.push_back("+tpidr-el1");
  213       Features.push_back("+crc");
  215       Features.push_back("-crc");
  229         Features.push_back("+fp16fml");
  238       Features.push_back("-fp16fml");
  240       Features.push_back("+fullfp16");
  275         Features.push_back("+sm4");
  277         Features.push_back("+sha3");
  279         Features.push_back("+sha2");
  281         Features.push_back("+aes");
  291         Features.push_back("-sm4");
  293         Features.push_back("-sha3");
  295         Features.push_back("-sha2");
  297         Features.push_back("-aes");
  304         Features.push_back("+sha2");
  306         Features.push_back("+aes");
  314         Features.push_back("-sha2");
  316         Features.push_back("-aes");
  318         Features.push_back("-sm4");
  319         Features.push_back("-sha3");
  327       Features.push_back("+strict-align");
  330     Features.push_back("+reserve-x1");
  333     Features.push_back("+reserve-x2");
  336     Features.push_back("+reserve-x3");
  339     Features.push_back("+reserve-x4");
  342     Features.push_back("+reserve-x5");
  345     Features.push_back("+reserve-x6");
  348     Features.push_back("+reserve-x7");
  351     Features.push_back("+reserve-x9");
  354     Features.push_back("+reserve-x10");
  357     Features.push_back("+reserve-x11");
  360     Features.push_back("+reserve-x12");
  363     Features.push_back("+reserve-x13");
  366     Features.push_back("+reserve-x14");
  369     Features.push_back("+reserve-x15");
  372     Features.push_back("+reserve-x18");
  375     Features.push_back("+reserve-x20");
  378     Features.push_back("+reserve-x21");
  381     Features.push_back("+reserve-x22");
  384     Features.push_back("+reserve-x23");
  387     Features.push_back("+reserve-x24");
  390     Features.push_back("+reserve-x25");
  393     Features.push_back("+reserve-x26");
  396     Features.push_back("+reserve-x27");
  399     Features.push_back("+reserve-x28");
  402     Features.push_back("+call-saved-x8");
  405     Features.push_back("+call-saved-x9");
  408     Features.push_back("+call-saved-x10");
  411     Features.push_back("+call-saved-x11");
  414     Features.push_back("+call-saved-x12");
  417     Features.push_back("+call-saved-x13");
  420     Features.push_back("+call-saved-x14");
  423     Features.push_back("+call-saved-x15");
  426     Features.push_back("+call-saved-x18");
  429     Features.push_back("+no-neg-immediates");

  315       Features.push_back("+soft-float");
  319       Features.push_back("+soft-float-abi");
  339     Features.push_back("+read-tp-hard");
  377         Features.push_back(
  436         Features.push_back("+fp16fml");
  446       Features.push_back("-fp16fml");
  448       Features.push_back("+fullfp16");
  471       Features.push_back(Args.MakeArgString("-" + Feature));
  477       Features.push_back("+crc");
  479       Features.push_back("-crc");
  496           Features.push_back("+sha2");
  499           Features.push_back("+aes");
  509           Features.push_back("-crypto");
  516     Features.push_back("+8msecext");
  524       Features.push_back("+long-calls");
  527       Features.push_back("+long-calls");
  549         Features.push_back("+execute-only");
  556     Features.push_back("+strict-align");
  568       Features.push_back("+strict-align");
  587         Features.push_back("+strict-align");
  590         Features.push_back("+strict-align");
  592       Features.push_back("+strict-align");
  599     Features.push_back("+reserve-r9");
  603     Features.push_back("+no-movt");
  606     Features.push_back("+no-neg-immediates");

  262     Features.push_back("+noabicalls");
  264     Features.push_back("-noabicalls");
  269       Features.push_back("-long-calls");
  271       Features.push_back("+long-calls");
  278       Features.push_back("+xgot");
  280       Features.push_back("-xgot");
  288     Features.push_back("+soft-float");
  295         Features.push_back("+nan2008");
  297         Features.push_back("-nan2008");
  302         Features.push_back("-nan2008");
  304         Features.push_back("+nan2008");
  316         Features.push_back("+abs2008");
  318         Features.push_back("-abs2008");
  323         Features.push_back("-abs2008");
  325         Features.push_back("+abs2008");
  353       Features.push_back("-fp64");
  355       Features.push_back("+fpxx");
  356       Features.push_back("+nooddspreg");
  358       Features.push_back("+fp64");
  360     Features.push_back("+fpxx");
  361     Features.push_back("+nooddspreg");
  363     Features.push_back("+fp64");
  364     Features.push_back("+nooddspreg");
  393         Features.push_back("+use-indirect-jump-hazard");

  108     Features.push_back("-hard-float");
  112     Features.push_back("+secure-plt");

  189     Features.push_back(Args.MakeArgString("+" + Ext));
  242     Features.push_back("+m");
  243     Features.push_back("+a");
  244     Features.push_back("+f");
  245     Features.push_back("+d");
  318       Features.push_back("+m");
  321       Features.push_back("+a");
  324       Features.push_back("+f");
  328       Features.push_back("+d");
  332       Features.push_back("+c");
  372     Features.push_back("+reserve-x1");
  374     Features.push_back("+reserve-x2");
  376     Features.push_back("+reserve-x3");
  378     Features.push_back("+reserve-x4");
  380     Features.push_back("+reserve-x5");
  382     Features.push_back("+reserve-x6");
  384     Features.push_back("+reserve-x7");
  386     Features.push_back("+reserve-x8");
  388     Features.push_back("+reserve-x9");
  390     Features.push_back("+reserve-x10");
  392     Features.push_back("+reserve-x11");
  394     Features.push_back("+reserve-x12");
  396     Features.push_back("+reserve-x13");
  398     Features.push_back("+reserve-x14");
  400     Features.push_back("+reserve-x15");
  402     Features.push_back("+reserve-x16");
  404     Features.push_back("+reserve-x17");
  406     Features.push_back("+reserve-x18");
  408     Features.push_back("+reserve-x19");
  410     Features.push_back("+reserve-x20");
  412     Features.push_back("+reserve-x21");
  414     Features.push_back("+reserve-x22");
  416     Features.push_back("+reserve-x23");
  418     Features.push_back("+reserve-x24");
  420     Features.push_back("+reserve-x25");
  422     Features.push_back("+reserve-x26");
  424     Features.push_back("+reserve-x27");
  426     Features.push_back("+reserve-x28");
  428     Features.push_back("+reserve-x29");
  430     Features.push_back("+reserve-x30");
  432     Features.push_back("+reserve-x31");
  436     Features.push_back("+relax");
  438     Features.push_back("-relax");

  113     Features.push_back("+soft-float");

   29       Features.push_back("+transactional-execution");
   31       Features.push_back("-transactional-execution");
   36       Features.push_back("+vector");
   38       Features.push_back("-vector");

  118           Features.push_back(
  126     Features.push_back("-rdrnd");
  127     Features.push_back("-aes");
  128     Features.push_back("-pclmul");
  129     Features.push_back("-rtm");
  130     Features.push_back("-fsgsbase");
  137       Features.push_back("+sse4.2");
  138       Features.push_back("+popcnt");
  139       Features.push_back("+cx16");
  141       Features.push_back("+ssse3");
  155       Features.push_back("+retpoline-indirect-calls");
  156       Features.push_back("+retpoline-indirect-branches");
  162       Features.push_back("+retpoline-indirect-calls");
  168     Features.push_back("+retpoline-indirect-calls");
  169     Features.push_back("+retpoline-indirect-branches");

   85     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
  202       Features.push_back(Args.MakeArgString("+" + FeatureName));
  204       Features.push_back(Args.MakeArgString("-" + FeatureName));
 1393   Flags.push_back(std::string(Enabled ? "+" : "-") + Flag);

  183         FP.push_back(P.str());

  995                 Dirs.push_back(
  998                 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
 1176                 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
 1178                 Dirs.push_back("/../../../../sysroot/usr/include");

  108   Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
  274     OsLibs.push_back("standalone");

  246     ExtraOpts.push_back("-z");
  247     ExtraOpts.push_back("now");
  252     ExtraOpts.push_back("-z");
  253     ExtraOpts.push_back("relro");
  260     ExtraOpts.push_back("-z");
  261     ExtraOpts.push_back("max-page-size=4096");
  274     ExtraOpts.push_back("-X");
  282     ExtraOpts.push_back("--sysroot=" + SysRoot);
  294       ExtraOpts.push_back("--hash-style=gnu");
  300       ExtraOpts.push_back("--hash-style=both");
  308     ExtraOpts.push_back("--enable-new-dtags");

   81     Features.push_back("-hwmult16");
   82     Features.push_back("-hwmult32");
   83     Features.push_back("-hwmultf5");
   95     Features.push_back("+hwmult16");
   98     Features.push_back("+hwmult32");
  101     Features.push_back("+hwmultf5");

  172             Modes.push_back(M);

  254   State.Stack.push_back(ParenState(/*Tok=*/nullptr, FirstIndent, FirstIndent,
 1417   State.Stack.push_back(
 1480   State.Stack.push_back(ParenState(State.NextToken, NewIndent,

  766   LLVMStyle.ForEachMacros.push_back("foreach");
  767   LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
  768   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
  824   LLVMStyle.StatementMacros.push_back("Q_UNUSED");
  825   LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");

   45       IndentForLevel.push_back(Style.IndentWidth * i + AdditionalIndent);
   58       IndentForLevel.push_back(-1);
   73       IndentForLevel.push_back(Indent);

 1035       TopLevelDeclIDs.push_back(Writer.getDeclID(D));
 1274     OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts));
 1276     OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt));
 1632       Consumers.push_back(Clang->takeASTConsumer());
 1633     Consumers.push_back(std::make_unique<TopLevelDeclTrackerConsumer>(

  205     CIs.push_back(std::move(Clang));

  173       Diagnostics.push_back(A->getOption().getName().drop_front(1));
  176       Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
 1070         Opts.CmdArgs.push_back('\0');
 1450       Opts.ExtraDeps.push_back(Val);
 1596     Opts.VerifyPrefixes.push_back("expected");
 1823     Opts.ModuleFileExtensions.push_back(
 1865       Opts.ModuleFiles.push_back(Val);
 2006     Inputs.push_back("-");
 2290         PPOpts.Includes.push_back("opencl-c-base.h");
 2292         PPOpts.Includes.push_back("opencl-c.h");
 3504       Res.getDiagnosticOpts().Warnings.push_back("no-stdlibcxx-not-found");
 3509     Res.FrontendOpts.LLVMArgs.push_back("-pgo-warn-misexpect");
 3541     Res.getDiagnosticOpts().Warnings.push_back("spir-compat");

  149     Dependencies.push_back(Filename);

  206         Consumers.push_back(std::move(PluginConsumer));
  208         AfterConsumers.push_back(std::move(PluginConsumer));
  214   Consumers.push_back(std::move(Consumer));
  216     Consumers.push_back(std::move(C));
  596         CI.getFrontendOpts().ModuleMapFiles.push_back(FE->getName());

  112   Consumers.push_back(std::make_unique<PCHGenerator>(
  117   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
  175   Consumers.push_back(std::make_unique<PCHGenerator>(
  183   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
  269     ModuleHeaders.push_back(FIF.getFile());
  276   Inputs.push_back(FrontendInputFile(Buffer.get(), Kind, /*IsSystem*/false));
  487   CI.getSema().TemplateInstCallbacks.push_back(

  159     IncludePath.push_back(
  170         IncludePath.push_back(

  116       RewrittenFiles->push_back(std::make_pair(Entry->getName(), Filename));

  309   UD.DL->push_back(std::move(D));
  951         LeftOnly.push_back(&D);

  186     Result.push_back(Token());

 2613     ActiveModule->ConfigMacros.push_back(Tok.getString().str());
 2632       ActiveModule->ConfigMacros.push_back(Tok.getString().str());

 1045   MacroExpandingLexersStack.push_back(std::make_pair(tokLexer, newIndex));

  557           Tags.push_back("Hidden");
  559           Tags.push_back("InBase");
  562           Tags.push_back("Inaccessible");

  911   Stack->push_back(std::make_pair(type, loc));

 1950     Overrides[Method->getName()].push_back(Method);

  108           Hints.push_back(FixItHint::CreateRemoval(
  112         Hints.push_back(FixItHint::CreateInsertion(Begin, "*("));
  113         Hints.push_back(FixItHint::CreateInsertion(End, ")"));
  115         Hints.push_back(FixItHint::CreateInsertion(Begin, "*"));
  142           Hints.push_back(FixItHint::CreateRemoval(
  146         Hints.push_back(FixItHint::CreateInsertion(Begin, "&("));
  147         Hints.push_back(FixItHint::CreateInsertion(End, ")"));
  149         Hints.push_back(FixItHint::CreateInsertion(Begin, "&"));

  737     FunctionList.push_back(Context.getFunctionType(

  955         CaseRanges.push_back(std::make_pair(LoVal, CS));

 1301       Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
 3151       TULexicalDecls.push_back(std::make_pair(&F, Contents));
 4786         F.ExtensionReaders.push_back(std::move(Reader));
 5635       CurrentModule->ConfigMacros.push_back(Blob.str());
 5691     LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
 5701     LangOpts.CommentOpts.BlockCommandNames.push_back(
 5708     LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
 5726     TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
 5729     TargetOpts.Features.push_back(ReadString(Record, Idx));
 5746     DiagOpts->Warnings.push_back(ReadString(Record, Idx));
 5748     DiagOpts->Remarks.push_back(ReadString(Record, Idx));
 5813     PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
 5818     PPOpts.Includes.push_back(ReadString(Record, Idx));
 5823     PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
 9791         Comments.push_back(new (Context) RawComment(

 1857     InputFileOffsets.push_back(Stream.GetCurrentBitNo());
 2302     SLocEntryOffsets.push_back(Stream.GetCurrentBitNo());
 2629       MacroOffsets.push_back(Stream.GetCurrentBitNo());
 3211     TypeOffsets.push_back(Offset);
 4676       ModuleFileExtensionWriters.push_back(std::move(Writer));

 2374     DeclOffsets.push_back(DeclOffset(Loc, Offset));

   62       Calls.push_back(CallRecord(Parent, cast<Expr>(S), AllocCall.first,

 2673         Pieces.push_back(NewGroup);
 2677       MacroStack.push_back(std::make_pair(MacroGroup, InstantiationLoc));
 2737         (*Notes)[NextNode].push_back(std::move(P));

 1977     Engine.blocksExhausted.push_back(std::make_pair(L, Sink));

  141   C.push_back(new HTMLDiagnostics(AnalyzerOpts, prefix, PP, true));
  148   C.push_back(new HTMLDiagnostics(AnalyzerOpts, prefix, PP, false));

  587   C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP, CTU,
  595   C.push_back(new PlistDiagnostics(AnalyzerOpts, s, PP, CTU,

   50   C.push_back(new SarifDiagnostics(AnalyzerOpts, Output));

  260       PathConsumers.push_back(clangDiags);
  459     CheckerRegistrationFns.push_back(std::move(Fn));

   37       AdjustedArgs.push_back("-fsyntax-only");

   57   Adjusters.push_back(std::move(Adjuster));

  289   Args.push_back("-c");
  295   Args.push_back("placeholder.cpp");
  390   Result[0].CommandLine.push_back(FilePath);

  541     ChangedRanges.push_back(Range(Offset, Length));

   31       Dependencies.push_back(File);

   23   KVResults.push_back({Strings.save(Key), Strings.save(Value)});

  147       Results.push_back(StringRef(Path));

  219           Result.CommandLine.push_back(Flag);
  221         Result.CommandLine.push_back("-x");
  222         Result.CommandLine.push_back(types::getTypeName(TargetType));
  232     Result.CommandLine.push_back(Filename);
  330       Types.push_back(foldType(guessType(Path)));

  248     Result.push_back(CommandRef.first().str());
  306       Arguments.push_back(Node->getValue(Storage));

   49     SelectionStack.push_back(
   97     SelectionStack.push_back(
  125     SelectionStack.push_back(
  137       SelectionStack.back().Children.push_back(std::move(Node));

  287   InsertedHeaders.push_back(Header);
  291   RemovedHeaders.push_back(Header);

   41     Rules.push_back(createRefactoringActionRule<ExtractFunction>(
   86     Rules.push_back(createRefactoringActionRule<RenameOccurrences>(
   89     Rules.push_back(createRefactoringActionRule<QualifiedRenameRule>(
  101   Actions.push_back(std::make_unique<LocalRename>());
  102   Actions.push_back(std::make_unique<ExtractRefactoring>());

  161     Changes.push_back(std::move(Change));

  233         SpellingNames.push_back(std::string());
  234         USRList.push_back(std::vector<std::string>());
  246     SpellingNames.push_back(FoundDecl->getNameAsString());
  248     USRList.push_back(Finder.Find());

  219       RenameInfos.push_back({StartLoc, EndLoc,
  238           RenameInfos.push_back({Loc, Loc,
  269         RenameInfos.push_back({EndLoc, EndLoc,
  530     AtomicChanges.push_back(std::move(ReplaceChange));

  165         ParsedTemplate.push_back(
  177         ParsedTemplate.push_back(
  188       ParsedTemplate.push_back(

  262     Tokens.push_back(syntax::Token(T));
  335     Expanded.push_back(syntax::Token(T));

  170   Args.push_back(ToolName.str());
  171   Args.push_back("-fsyntax-only");
  173   Args.push_back(FileName.str());
  318     Argv.push_back(Str.c_str());
  425   MappedFileContents.push_back(std::make_pair(FilePath, Content));
  444   Args.push_back("-resource-dir=" +
  476     AbsolutePaths.push_back(std::move(*AbsPath));
  589     ASTs.push_back(std::move(AST));

   98     Matchers.push_back(*std::move(M));
  135     Matchers.push_back(*M.tryBind(RewriteRule::RootID));

  263     Parts.push_back(std::move(Part));

  216       Ranges.push_back(tooling::Range(Offset, Length));
  249     Ranges.push_back(tooling::Range(Offset, Length));

  312   ASTConsumers.push_back(
  317     ASTConsumers.push_back(
  361     ImportCIs.push_back(std::move(*ImportCI));
  367       IndirectCIs.push_back(std::move(IndirectCI));
  372       IndirectCIs.push_back(std::move(ImportCI));

  364       SubCommands.push_back(std::make_unique<RefactoringActionSubcommand>(

  114     Results.push_back({});
  142     Results.back().push_back(std::move(Result));
  152       Results.push_back({});
  386     TestRanges.GroupedRanges.push_back({Group.first, std::move(Group.second)});

  174         AdjustedArgs.push_back("-o");
  175         AdjustedArgs.push_back("/dev/null");
  177           AdjustedArgs.push_back("-M");
  178           AdjustedArgs.push_back("-MT");
  183             AdjustedArgs.push_back(!LastO.empty() ? LastO
  186             AdjustedArgs.push_back(FileName);
  189         AdjustedArgs.push_back("-Xclang");
  190         AdjustedArgs.push_back("-Eonly");
  191         AdjustedArgs.push_back("-Xclang");
  192         AdjustedArgs.push_back("-sys-header-deps");
  193         AdjustedArgs.push_back("-Wno-error");
  213     WorkerTools.push_back(std::make_unique<DependencyScanningTool>(

   45     toolNames.push_back(it->getKey());

   49   Args.push_back("diagtool find-diagnostic-id");

  131     Active.push_back(PrettyDiag(DR.getName(), WarningOpt, DiagLevel));

  179     DriverArgs.push_back(Arg.c_str());

   94     Patterns.push_back(Line.trim());

   62       Children.push_back(std::move(ChildToMerge));
   74       Children.push_back(std::move(ChildToMerge));
   86       Children.push_back(std::move(ChildToMerge));

   74       Result.push_back(Text.substr(Start, End - Start).lower());

  110   Contexts.push_back(ScopedToolAction->getIncludeFixerContext(
  355       QuerySymbolInfos.push_back({Query.str(), ScopedQualifiers, Range});
  370   QuerySymbolInfos.push_back({Query.str(), ScopedQualifiers, Range});

   99     HeaderInfos.push_back(

  142         MatchedSymbols.push_back(std::move(SymAndSig));
  153     Res.push_back(std::move(SymAndSig.Symbol));

   41     SymbolIndices.push_back(std::async(Strategy, F));

  180         Symbols.push_back(

  246       MoveTool->getMovedDecls().push_back(CMD);
  265       MoveTool->getMovedDecls().push_back(TC);
  267       MoveTool->getMovedDecls().push_back(CD);
  361       Namespaces.push_back(ND->getName().str());
  488     CCIncludes.push_back("#include \"" + Context->Spec.NewHeader + "\"\n");
  613   MatchCallbacks.push_back(std::make_unique<ClassDeclarationMatch>(this));
  632   MatchCallbacks.push_back(std::make_unique<FunctionDeclarationMatch>(this));
  637   MatchCallbacks.push_back(std::make_unique<VarDeclarationMatch>(this));
  644   MatchCallbacks.push_back(std::make_unique<EnumDeclarationMatch>(this));
  653   MatchCallbacks.push_back(std::make_unique<TypeAliasMatch>(this));
  668         MovedDecls.push_back(DCT);
  670         MovedDecls.push_back(FWD);

   81       P->Completions.push_back(LineEditor::Completion(
  170     Completions.push_back(LineEditor::Completion(I->TypedText, I->MatcherDecl));

  420     Consumers.push_back(Finder->newASTConsumer());
  436     Consumers.push_back(std::move(AnalysisConsumer));
  454     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);

   50     Items.push_back(std::move(Item));

   53   CheckResult->Hints.push_back(
   57   CheckResult->Hints.push_back(

   49     Locs.push_back(

   91   IncludeDirectives[SM.getFileID(HashLoc)].push_back(std::move(ID));
  113     Blocks.push_back(FileDirectives.size()); // Sentinel value.

  426         StarRemovals.push_back(FixItHint::CreateRemoval(Q.getStarLoc()));

   52     Vec.push_back(Factory.CreateASTConsumer(Compiler, File));

   75       Info.NestingThresholders.push_back(Node->getBeginLoc());

  187       NamingStyles.push_back(NamingStyle(caseOptional, prefix, postfix));
  189       NamingStyles.push_back(llvm::None);

  179       FixIts.push_back(FixItHint::CreateReplacement(
  183       FixIts.push_back(FixItHint::CreateReplacement(
  199       FixIts.push_back(FixItHint::CreateReplacement(

  257         Fixes.push_back(FixItHint::CreateReplacement(
  268     Fixes.push_back(FixItHint::CreateReplacement(

   25       Result.push_back(Name);

  102     LookupTable.push_back({toTextMateScope((HighlightingKind)(KindValue))});
  859         Results.push_back(std::move(SI));
  916       FixIts.push_back(toCodeAction(F, Params.textDocument.uri));
  932           Actions.push_back(toCodeAction(T, File, Selection));
  939             Commands.push_back(std::move(*Command));
  966                            LSPList.items.push_back(std::move(C));
 1023           Defs.push_back(S.Definition.getValueOr(S.PreferredDeclaration));
 1042           Decls.push_back(std::move(S.PreferredDeclaration));
 1328                  LSPDiagnostics.push_back(std::move(Diag));

  136       MergedIdx.push_back(std::make_unique<MergedIndex>(Idx, this->Index));
  300     Result.push_back(replacementToEdit(Code, R));
  355       Edits.push_back(replacementToEdit(InpAST->Inputs.Contents, Rep));
  384       Res.push_back({T->id(), T->title(), T->intent()});

  281         Completion.FixIts.push_back(toTextEdit(
  551       Scopes.AccessibleScopes.push_back(""); // global namespace
  553       Scopes.AccessibleScopes.push_back(printNamespaceScope(*Context));
  577         EnclosingAtFront.push_back(std::move(S));
  587   Scopes.AccessibleScopes.push_back(""); // Make sure global scope is included.
  843       ScoredSignatures.push_back(processOverloadCandidate(
  907       SigHelp.signatures.push_back(std::move(SS.Signature));
  930     Signature.parameters.push_back(std::move(Info));
 1364         IdentifierResults.push_back(std::move(ID));
 1464       Output.Completions.push_back(toCodeCompletion(C.first));
 1486     Req.ProximityPaths.push_back(FileName);
 1488       Req.PreferredTypes.push_back(PreferredType->raw());

   48     ArgStrs.push_back(S.c_str());

  345       Main.codeActions->push_back(toCodeAction(Fix, File));
  363       Main.relatedInformation->push_back(std::move(RelInfo));
  582     LastDiag->Fixes.push_back(Fix{Message.str(), std::move(Edits)});
  637       LastDiag->Notes.push_back(std::move(N));
  649     Output.push_back(std::move(*LastDiag));

   31     ResultVector.push_back(DraftIt->getKey());

  126     Result.push_back(std::move(R.second));
  209     Results.push_back(std::move(*Sym));

   34         Brackets.push_back(')');
   37         Brackets.push_back('}');
   40         Brackets.push_back(']');
  175     Result.FormatRanges.push_back(
  180   Result.FormatRanges.push_back(
  219       Result.push_back(tooling::Replacement(
  222       Result.push_back(tooling::Replacement(
  280   RangesToFormat.push_back(

  103   Chunks.push_back(std::move(C));
  110   Chunks.push_back(std::move(C));

   77     Listeners.push_back({std::move(L), ++ListenerCount});

   46     Cmd.CommandLine.push_back(("-resource-dir=" + ResourceDir).str());
   84     Argv.push_back("-xobjective-c++-header");
   85   Argv.push_back(File);
  242           GovernedFiles.push_back(removeDots(File));

  145     Results.push_back(D);

  176             Fixes.push_back(
  314   Scopes.push_back("");
  317       Scopes.push_back(printNamespaceScope(*Ctx));

  170       Heap.push_back(std::move(V));

   82     SystemIncludes.push_back(Line.trim().str());
  153     Cmd.CommandLine.push_back("-isystem");
  154     Cmd.CommandLine.push_back(Include.str());
  190     RegTexts.push_back(convertGlobToRegex(Glob));

  132       Tokens.push_back({HighlightingKind::Macro, M});
  297     Tokens.push_back({Kind, R.getValue()});
  444       DiffedLines.push_back({LineNumber, NewLine});
  487     Lines.push_back({Line.Line, encodeBase64(LineByteTokens)});

  625     Edits.push_back(replacementToEdit(Code, R));
  924     Found.push_back(Enclosing);
  928         Found.push_back(Used.getKey());

 1013     Result.push_back(
 1023     Result.push_back(PathAndFile.first());

  275       Result.push_back(std::move(Macro));
  386       References.push_back({Loc, Roles});
  437       Result.push_back(std::move(DH));
  472       Scopes.push_back(GetName(TD));
  474       Scopes.push_back(FD->getNameAsString());
  564     TempParameters.push_back(std::move(P));
  953       Results.push_back(std::move(Result));
  977         Results.push_back(std::move(*LSPLoc));
 1010     Results.push_back(std::move(NewSymbol));
 1022     Results.push_back(std::move(NewMacro));
 1297     Output.push_back(*P.Type);
 1299     Output.push_back(*P.Name);

  179       Tasks.push_back(indexFileTask(std::move(Cmd)));

  117     Result.push_back(std::move(It.getValue()));

   71     Queue.push_back(std::move(T));

  131         MainFileRefs.push_back(RefSlabs.back().get());
  160       SymsStorage.push_back(std::move(Sym.second));
  161       AllSymbols.push_back(&SymsStorage.back());
  172           AllSymbols.push_back(&Sym);

  222     Table.Strings.push_back(Saver.save(R.consume(Len)));
  529   RIFF.Chunks.push_back({riff::fourCC("meta"), Meta});
  582   RIFF.Chunks.push_back({riff::fourCC("stri"), StringSection});
  590   RIFF.Chunks.push_back({riff::fourCC("symb"), SymbolSection});
  599     RIFF.Chunks.push_back({riff::fourCC("refs"), RefsSection});
  609     RIFF.Chunks.push_back({riff::fourCC("rela"), RelationSection});
  619     RIFF.Chunks.push_back({riff::fourCC("srcs"), SrcsSection});
  628     RIFF.Chunks.push_back({riff::fourCC("cmdl"), CmdlSection});

   59     SortedSymbols.push_back(std::move(Entry.second));

  138       BoostingIterators.push_back(
  142   BoostingIterators.push_back(Corpus.all());
  154     BoostingIterators.push_back(
  156   BoostingIterators.push_back(Corpus.all());
  180     TrigramIterators.push_back(iterator(Trigram));
  181   Criteria.push_back(Corpus.intersect(move(TrigramIterators)));
  186     ScopeIterators.push_back(iterator(Token(Token::Kind::Scope, Scope)));
  188     ScopeIterators.push_back(
  190   Criteria.push_back(Corpus.unionOf(move(ScopeIterators)));
  193   Criteria.push_back(createFileProximityIterator(Req.ProximityPaths));
  195   Criteria.push_back(createTypeBoostingIterator(Req.PreferredTypes));
  198     Criteria.push_back(iterator(RestrictedForCodeCompletion));

   49       this->Symbols.push_back(&Sym);

  374       RealChildren.push_back(std::move(Child));
  404       RealChildren.push_back(std::move(Child));

  128   Children.push_back(move(Head));

   68     Available.push_back(std::move(T));

  559     ExtractedFunc.Parameters.push_back(

   77       ReferencedDecls.push_back(DeclRef->getDecl());

   59     Results.push_back(D);

   25     Ps.push_back(offsetToPosition(code(), O));
   47     Rs.push_back(toLSPRange(code(), R));

  583     FilePaths.push_back(testPath(Name));
  873   CDB.ExtraClangFlags.push_back("-xc++");
  874   CDB.ExtraClangFlags.push_back("-isystem" + testPath("headers"));

 1540   CDB.ExtraClangFlags.push_back("-fno-delayed-template-parsing");

  359     Tokens.push_back(Token(Kind, TokenData));
  691       .refs(Req, [&](const Ref &R) { Files.push_back(R.Location.FileURI); });
  697       .refs(Req, [&](const Ref &R) { Files.push_back(R.Location.FileURI); });

  474                LSPDiags.push_back(
  493                LSPDiags.push_back(
  727   TU.ExtraArgs.push_back("-fno-ms-compatibility");
  753   TU.ExtraArgs.push_back("-fno-ms-compatibility");
  959   TU.ExtraArgs.push_back("--include=a.h");

   70     Changes.push_back({

   58       Elements.push_back(Field(&MapEntry::second, Cls));

  526     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
  537       Refs.push_back(std::move(R));

  149   Cmd.CommandLine.push_back("-MF");
  150   Cmd.CommandLine.push_back("random-dependency");
  153   Cmd.CommandLine.push_back("-Xclang");
  154   Cmd.CommandLine.push_back("-load");
  155   Cmd.CommandLine.push_back("-Xclang");
  156   Cmd.CommandLine.push_back("random-plugin");
  158   Cmd.CommandLine.push_back("-DA=5");

  177     TU.ExtraArgs.push_back("-xc++-header"); // inform clang this is a header.

   88     Args.push_back(MainFilePath);
  103     FilePaths.push_back(Path);

  149   TU.ExtraArgs.push_back("-fno-delayed-template-parsing");

   45       TemplateArgsAtPoints.push_back(printTemplateSpecializationArgs(*ND));

  176       TU.ExtraArgs.push_back("-xobjective-c++-header");
  196         Expected.push_back(RenameRange(TU.Code, R));

  298     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
  376         Complete.push_back(nodeRange(N, AST));
  378         Partial.push_back(nodeRange(N, AST));

  110   TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
  142     ExpectedLinePairHighlighting.push_back(

  163     Result.push_back(toYAML(Sym));
  169     Result.push_back(toYAML(Refs));
  176     Result.push_back(toYAML(Rel));
  249   Cmd.CommandLine.push_back("cmd1");
  250   Cmd.CommandLine.push_back("cmd2");

  508   TU.ExtraArgs.push_back("-DHeader=Header3");
  509   TU.ExtraArgs.push_back("-DMain=Main3");

 1122   TU.ExtraArgs.push_back("-DSECRET"); // *we're* able to include it.

  383       Files.push_back(testPath(Name));
  641   CDB.ExtraClangFlags.push_back("-DSOMETHING");

   60     CommandLine.push_back(File);
   65     CommandLine.push_back(RelativeFilePath.str());

   86     Names.push_back(std::to_string(i));
   98     Matches.push_back(clang::clangd::getQualifiedName(Sym));
  112     Results.push_back(getQualifiedName(Sym));

   40     Cmd.push_back("-include");
   41     Cmd.push_back(ImplicitHeaderGuard ? ImportThunk.c_str()
   46       Cmd.push_back("-fno-ms-compatibility");
   51   Cmd.push_back(FullFilename.c_str());

  144     Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
  149     Cases.push_back((Code.substr(0, Begin) + "[[" +

  540   ExtraArgs.push_back("-fno-delayed-template-parsing");
 1039   ExtraArgs.push_back("-fno-delayed-template-parsing");
 1293   ExtraArgs.push_back("-fno-delayed-template-parsing");
 1379   ExtraArgs.push_back("-fno-delayed-template-parsing");

  402   TU.ExtraArgs.push_back("-ftemplate-depth=10");

  470     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
 1011     TU.ExtraArgs.push_back("-std=c++17");
 1842     TU.ExtraArgs.push_back("-std=c++17");
 2053       ExpectedLocations.push_back(RangeIs(R));
 2113       ExpectedLocations.push_back(RangeIs(R));
 2285         Names.push_back(ND->getQualifiedNameAsString());

  285   HeaderPath.push_back(UmbrellaHeaderName);
  391     FileSystemHeaders.push_back(ModularizeUtilities::getCanonicalPath(file));

  363         NewArgs.push_back("-include");

  310   ModuleMaps.push_back(std::move(ModMap));

  624     MacroExpansionInstances.push_back(
  712     ConditionalExpansionInstances.push_back(
  966       HeaderPaths.push_back(addString(CanonicalPath));
 1026       InclusionPaths.push_back(HeaderInclusionPath(Path));

  429   CallbackCalls.push_back(CallbackCall(Name));
  449   CallbackCalls.back().Arguments.push_back(Argument{Name, Value});

   26   TUs.push_back({MainSourceFile,

  172   OneParagraphComment->Children.push_back(std::move(OneTextComment));
  173   OneFullComment->Children.push_back(std::move(OneParagraphComment));
  192   TwoParagraphComment->Children.push_back(std::move(TwoTextComment));
  193   TwoFullComment->Children.push_back(std::move(TwoParagraphComment));
  219   ExpectedParagraphComment->Children.push_back(std::move(ExpectedTextComment));
  220   ExpectedFullComment->Children.push_back(std::move(ExpectedParagraphComment));

  486   Args.push_back("-fmodules-ts");

   99   Args.push_back("-fsyntax-only");
  102     Args.push_back("-fobjc-abi-version=2");
  103     Args.push_back("-fobjc-arc");
  106     Args.push_back("-std=c++11");
  108   Args.push_back("-Iinclude");
  110   Args.push_back(Filename.str());

 3469     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
 3508     Args->push_back("-Xclang");
 3509     Args->push_back("-detailed-preprocessing-record");
 3513   Args->push_back("-fallow-editor-placeholders");
 3557       TU->Arguments.push_back(Arg);
 4119     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));

  751     CArgs.push_back(Arg.c_str());

   34   Diagnostics.push_back(std::move(D));

  370   CurrentDiags.back()->FixIts.push_back(

  149   TU->StringPool->Pool.push_back(this);

  370     Consumers.push_back(std::make_unique<IndexingConsumer>(
  372     Consumers.push_back(createIndexingASTConsumer(

  160   Args.push_back("-fno-delayed-template-parsing");

   34   Args.push_back("-fno-ms-extensions");

   90     Args.push_back("-fno-delayed-template-parsing");

   92     Args.push_back("-std=c99");
   96     Args.push_back("-std=c89");
  100     Args.push_back("-std=c++98");
  104     Args.push_back("-std=c++11");
  108     Args.push_back("-std=c++14");
  112     Args.push_back("-std=c++2a");

   63     Events.push_back(VisitEvent::StartTraverseFunction);
   65     Events.push_back(VisitEvent::EndTraverseFunction);
   71     Events.push_back(VisitEvent::StartTraverseAttr);
   73     Events.push_back(VisitEvent::EndTraverseAttr);

  370   Args.push_back("-fno-delayed-template-parsing");
  710   Args.push_back("-fms-extensions");

  191   M.push_back(std::make_pair("/other", "class X {};"));
  199   M.push_back(std::make_pair("/other", "class X {};"));
  213   M.push_back(std::make_pair("/foo", "class A {};"));
  214   M.push_back(std::make_pair("/bar", "class B {};"));

   40     Errors.push_back(Error.toStringFull());

   94     Context.push_back(std::make_pair(*Ctor, ArgNo1));
  105     Context.push_back(std::make_pair(*Ctor, ArgNo1));
  109     Context.push_back(std::make_pair(*Ctor, ArgNo2));

  341     Macros.push_back(MacroAction(MD->getLocation(),
  348     Macros.push_back(
  356     Macros.push_back(MacroAction(MacroNameTok.getLocation(),

  289   FlagM64.push_back("+m64");
  297   FlagNoM64.push_back("-m64");
  315       Flags.push_back("+EL");
  317       Flags.push_back("-EL");
  320       Flags.push_back("+SF");
  322       Flags.push_back("-SF");
  359   Flags1.push_back("+foo");
  360   Flags1.push_back("-bar");
  368   Flags2.push_back("+foo");
  369   Flags2.push_back("+bar");

   42       Ranges.push_back(tooling::Range(Offset, 0));

 2110   Style.NamespaceMacros.push_back("TESTSUITE");
 2203   Style.NamespaceMacros.push_back("FOOBAR");
 2218   Style.NamespaceMacros.push_back("TESTSUITE");
 3103   Style.StatementMacros.push_back("FOO");
12751   BoostForeach.push_back("BOOST_FOREACH");
12754   BoostAndQForeach.push_back("BOOST_FOREACH");
12755   BoostAndQForeach.push_back("Q_FOREACH");

  773   Style.RawStringFormats[0].EnclosingFunctions.push_back(
  775   Style.RawStringFormats[0].EnclosingFunctions.push_back("ParseTextProto");
  871   Style.RawStringFormats[0].EnclosingFunctions.push_back(

  292   Style.NamespaceMacros.push_back("TESTSUITE");
  504   Style.NamespaceMacros.push_back("TESTSUITE");
  618   Style.NamespaceMacros.push_back("TESTSUITE");
  685   CompactNamespacesStyle.NamespaceMacros.push_back("TESTSUITE");
  751   Style.NamespaceMacros.push_back("TESTSUITE");

   48   Invocation->getFrontendOpts().Inputs.push_back(

   71       decl_names_.push_back(Decl->getQualifiedNameAsString());
   87   invocation->getFrontendOpts().Inputs.push_back(
  107   invocation->getFrontendOpts().Inputs.push_back(
  134   invocation->getFrontendOpts().Inputs.push_back(
  180   Invocation->getFrontendOpts().Inputs.push_back(
  241   Invocation->getFrontendOpts().Inputs.push_back(
  273     Invocation->getFrontendOpts().Inputs.push_back(

   28   Invocation->getFrontendOpts().Inputs.push_back(
   52   Invocation->getFrontendOpts().Inputs.push_back(
   81     Invocation->getFrontendOpts().Inputs.push_back(

   82     CI->getFrontendOpts().Inputs.push_back(

   90     Symbols.push_back(std::move(S));
  103     Symbols.push_back(std::move(S));

  116   ExpectedTokens.push_back(tok::identifier);
  117   ExpectedTokens.push_back(tok::l_paren);
  118   ExpectedTokens.push_back(tok::identifier);
  119   ExpectedTokens.push_back(tok::r_paren);
  130   ExpectedTokens.push_back(tok::identifier);
  131   ExpectedTokens.push_back(tok::identifier);
  142   ExpectedTokens.push_back(tok::identifier);
  143   ExpectedTokens.push_back(tok::identifier);
  144   ExpectedTokens.push_back(tok::identifier);
  155   ExpectedTokens.push_back(tok::identifier);
  156   ExpectedTokens.push_back(tok::identifier);
  157   ExpectedTokens.push_back(tok::identifier);
  168   ExpectedTokens.push_back(tok::identifier);
  169   ExpectedTokens.push_back(tok::identifier);
  170   ExpectedTokens.push_back(tok::identifier);
  171   ExpectedTokens.push_back(tok::identifier);
  182   ExpectedTokens.push_back(tok::identifier);
  183   ExpectedTokens.push_back(tok::l_paren);
  184   ExpectedTokens.push_back(tok::identifier);
  185   ExpectedTokens.push_back(tok::r_paren);
  197   ExpectedTokens.push_back(tok::identifier);
  198   ExpectedTokens.push_back(tok::l_paren);
  199   ExpectedTokens.push_back(tok::identifier);
  200   ExpectedTokens.push_back(tok::r_paren);
  210   ExpectedTokens.push_back(tok::identifier);
  211   ExpectedTokens.push_back(tok::l_paren);
  212   ExpectedTokens.push_back(tok::identifier);
  213   ExpectedTokens.push_back(tok::r_paren);
  223   ExpectedTokens.push_back(tok::identifier);
  224   ExpectedTokens.push_back(tok::l_paren);
  225   ExpectedTokens.push_back(tok::identifier);
  226   ExpectedTokens.push_back(tok::r_paren);
  237   ExpectedTokens.push_back(tok::identifier);
  238   ExpectedTokens.push_back(tok::l_paren);
  239   ExpectedTokens.push_back(tok::identifier);
  240   ExpectedTokens.push_back(tok::identifier);
  241   ExpectedTokens.push_back(tok::r_paren);
  252   ExpectedTokens.push_back(tok::identifier);
  253   ExpectedTokens.push_back(tok::identifier);
  254   ExpectedTokens.push_back(tok::l_paren);
  255   ExpectedTokens.push_back(tok::identifier);
  256   ExpectedTokens.push_back(tok::r_paren);
  267   ExpectedTokens.push_back(tok::l_square);
  268   ExpectedTokens.push_back(tok::identifier);
  269   ExpectedTokens.push_back(tok::r_square);
  270   ExpectedTokens.push_back(tok::l_square);
  271   ExpectedTokens.push_back(tok::identifier);
  272   ExpectedTokens.push_back(tok::r_square);
  273   ExpectedTokens.push_back(tok::identifier);
  274   ExpectedTokens.push_back(tok::identifier);
  275   ExpectedTokens.push_back(tok::identifier);
  276   ExpectedTokens.push_back(tok::identifier);
  553     GeneratedByNextToken.push_back(getSourceText(*T, *T));

   67         NSNames.push_back(NS->getQualifiedNameAsString());

   51     Comments.push_back(Comment(C, CLine, CCol));

   90   expected_files.push_back(PathStorage.str());
   92   expected_files.push_back(PathStorage.str());
   94   expected_files.push_back(PathStorage.str());
  518   CommandLine.push_back("one");
  519   CommandLine.push_back("two");
  527   CommandLine.push_back("one");
  528   CommandLine.push_back("two");
  657       Result.push_back(Entry.first());
  827   CCTest.CommandLine.push_back("c");

   90   TUD.Diagnostics.push_back(makeDiagnostic("diagnostic#1", "message #1", 55,
   96   TUD.Diagnostics.push_back(makeDiagnostic("diagnostic#2", "message #2", 60,
   99   TUD.Diagnostics.push_back(makeDiagnostic("diagnostic#3", "message #3", 72,

  292       [&](StringRef Name, StringRef) { Results.push_back(Name); });

   34     VisitedNodes.push_back(Op->getOpcodeStr(Op->getOpcode()));
   39     VisitedNodes.push_back(Op->getOpcodeStr());
   44     VisitedNodes.push_back(Lit->getValue().toString(10, false));
   49     VisitedNodes.push_back(D->getNameAsString());
   54     VisitedNodes.push_back(D->getQualifiedNameAsString());
   59     VisitedNodes.push_back("return");
   65       VisitedNodes.push_back(D->getQualifiedNameAsString());
   70     VisitedNodes.push_back(T->getDecl()->getQualifiedNameAsString());

  213       Occurrences.push_back(SymbolOccurrence(SymbolName("test"),

  774     ExpectedMacroRanges.push_back(
  778     ActualMacroRanges.push_back(Expansion->range(SM));

   58         Args.push_back("-x");
   59         Args.push_back("c");
   61       case Lang_CXX98: Args.push_back("-std=c++98"); break;
   62       case Lang_CXX11: Args.push_back("-std=c++11"); break;
   63       case Lang_CXX14: Args.push_back("-std=c++14"); break;
   64       case Lang_CXX17: Args.push_back("-std=c++17"); break;
   65       case Lang_CXX2a: Args.push_back("-std=c++2a"); break;
   67         Args.push_back("-ObjC");
   68         Args.push_back("-fobjc-runtime=macosx-10.12.0");
   71         Args.push_back("-ObjC++");
   72         Args.push_back("-std=c++11");
   73         Args.push_back("-fblocks");
  135     DisallowedMatches.push_back(MatchCandidate(Match, Line, Column));
  146     ExpectedMatches.push_back(ExpectedMatch(Match, Line, Column, Times));

  159   Args.push_back("tool-executable");
  160   Args.push_back("-Idef");
  161   Args.push_back("-fsyntax-only");
  162   Args.push_back("test.cpp");
  185   Args.push_back("tool-executable");
  186   Args.push_back("-Idef");
  187   Args.push_back("-fsyntax-only");
  188   Args.push_back("test.cpp");
  223   Sources.push_back("/a.cc");
  224   Sources.push_back("/b.cc");
  323   Args.push_back("-MMD");
  324   Args.push_back("-MT");
  325   Args.push_back(DepFilePath.str());
  326   Args.push_back("-MF");
  327   Args.push_back(DepFilePath.str());
  595   Sources.push_back("/a.cc");
  596   Sources.push_back("/b.cc");

  111         Changes.push_back(std::move(*C));

   71     UnsavedFiles.push_back({

   95       Ret.push_back(FlattenedSpelling(*Spelling));
  176             Dupes->push_back(std::make_pair(AN, Attr));
  183       R.push_back(std::make_pair(AN, Attr));
 2694           SuperClass->SubClasses.push_back(Class.get());
 3337         DiagList.push_back(Str.trim());
 3783           Matches->push_back(StringMatcher::StringPair(
 3786           Matches->push_back(StringMatcher::StringPair(
 4098         SplitDocs[Category].push_back(DocumentationData(

  104       CategoryStrings.push_back("");
  195       GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
  407       V->push_back(R);
  438       V->push_back(Group);
  650       AllocatedPieces.push_back(Mem);
  700       NewMappings.push_back(mapIndex(Idx, Mappings));
  819     Pieces.push_back(std::make_pair(OrigP, CurrentMappings));
  824       RST.push_back("");
  874     RST.push_back("");
  901     RST.push_back(std::string(":placeholder:`") +
  907     SeparatorIndexes.push_back(RST.size());
  911       SeparatorIndexes.push_back(RST.size());
 1016       Parsed.push_back(New<TextPiece>(Text.slice(0, End), "diagtext"));
 1052         Select->Options.push_back(parseDiagText(Text, true));
 1058       Parsed.push_back(Select);
 1070         Plural->OptionPrefixes.push_back(
 1073         Plural->Options.push_back(parseDiagText(Text, true));
 1079       Parsed.push_back(Plural);
 1095           Sub->Modifiers.push_back(parseModifier(Text));
 1103       Parsed.push_back(Sub);
 1117       Parsed.push_back(Diff);
 1122       Select->Options.push_back(New<TextPiece>(""));
 1123       Select->Options.push_back(New<TextPiece>("s", "diagtext"));
 1125       Parsed.push_back(Select);
 1133       Parsed.push_back(New<PlaceholderPiece>(ModType, parseModifier(Text)));
 1590     Index.push_back(RecordIndexElement(R));
 1717       PedDiags.SubGroups.push_back(Group->getValueAsString("GroupName"));

  354       SignaturesList.push_back(std::make_pair(Signature, CumulativeSignIndex));
  360     FctOverloadMap[BName].push_back(std::make_pair(B, SignIndex));
  434     ValidBuiltins.push_back(StringMatcher::StringPair(i.first, RetStmt));

  132       D.Options.push_back(DocumentationForOption(O));
  250     Args.push_back(Option->getValueAsString("MetaVarName"));
  252     Args.push_back("<arg>");
  261       Args.push_back(("<arg" + Twine(Args.size() + 1) + ">").str());
  319       SphinxOptionIDs.push_back(

  423       ParamTypes->push_back(Type);
  425       ParamValues->push_back(Value);
  798         SemaChecks.push_back("SemaBuiltinConstantArg(TheCall, " + Index + ")");
  800         SemaChecks.push_back("SemaBuiltinConstantArgRange(TheCall, " + Index +
  808         SemaChecks.push_back((Twine("SemaBuiltinConstantArg") +
 1024       Args.push_back(getCodeForDagArg(D, i, Scope, Param));
 1037         ParamTypes.push_back(getType(RParam, Param));
 1325           ArgTypeNames.push_back(ArgTypePtr->cName());
 1417       conditions.push_back("(__ARM_FEATURE_MVE & 2)");
 1419       conditions.push_back("(!defined __ARM_MVE_PRESERVE_USER_NAMESPACE)");
 1563         ParamNumbers.push_back(-1);

  124         Ret.push_back(TypeSpec(Acc));
 1500       Lines.push_back(replaceParamsIn(SI->getAsString()));
 1503       Lines.push_back(DE.emitDag(DI).second + ";");
 2034       GoodVec.push_back(&I);
 2076         NewTypeSpecs.push_back(std::make_pair(TS, SrcTS));
 2079       NewTypeSpecs.push_back(std::make_pair(TS, TS));

   66     ArchiveBuffers.push_back(MemBuffer->getMemBufferRef());
   80     Archives.push_back(std::move(*ErrOrArchive));
  105     ObjectBuffers.push_back(MemBuffer->getMemBufferRef());
  118     Objects.push_back(std::move(*ErrOrObjectFile));
  129     Result.push_back(Object.get());
  195           OE.Objects.push_back(std::move(*ErrOrObjectFile));

   64     Entries.push_back(std::make_pair(Sym.getKey(), Sym.getValue()));
  144   Result.push_back(std::move(Res));
  231     Entries.push_back(std::make_pair(Entry.getKey(), Entry.getValue()));

  186   void addWarning(StringRef Warning) { Warnings.push_back(Warning); }

 1003     Abbreviations.push_back(
 2351   CompileUnits.push_back(std::move(Unit));
 2717         LinkContext.CompileUnits.push_back(std::make_unique<CompileUnit>(

  174   EmittedUnits.push_back({Unit.getUniqueID(), Unit.getLabelBegin()});
  321     Ranges.push_back(std::make_pair(Range.start() + Range.value(),

  391       Results.push_back(parseOneBinary(*Object, BinaryPath));
  500       CommonSymbols.push_back(*Name);
  523       Names.push_back(Entry.first());

  109     InputFiles.push_back(File->getValue());
  244     Options.Archs.push_back(Arch->getValue());

  303         extra.push_back("LLVMgold");
  569     cf.syms.push_back(ld_plugin_symbol());

  173       RunPassNames->push_back(PassName);

  155     v.push_back(std::move(syms));
  577         lookups.push_back(make<OrdinalOnlyChunk>(ord));
  578         addresses.push_back(make<OrdinalOnlyChunk>(ord));
  582       lookups.push_back(make<LookupChunk>(c));
  583       addresses.push_back(make<LookupChunk>(c));
  584       hints.push_back(c);
  587     lookups.push_back(make<NullChunk>(config->wordsize));
  588     addresses.push_back(make<NullChunk>(config->wordsize));
  594     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
  598     dirs.push_back(dir);
  601   dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
  631     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
  639       addresses.push_back(a);
  643         names.push_back(make<OrdinalOnlyChunk>(s->getOrdinal()));
  646         names.push_back(make<LookupChunk>(c));
  647         hintNames.push_back(c);
  652     addresses.push_back(make<NullChunk>(8));
  653     names.push_back(make<NullChunk>(8));
  659     moduleHandles.push_back(mh);
  665     dirs.push_back(dir);
  668   dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry)));
  712       names.push_back(make<StringChunk>(e.exportName));
  719     forwards.push_back(e.forwardChunk);
  726   chunks.push_back(dir);
  727   chunks.push_back(dllName);
  728   chunks.push_back(addressTab);
  729   chunks.push_back(nameTab);
  730   chunks.push_back(ordinalTab);

   97   GC.push_back(std::unique_ptr<TpiSource>(this));

 1113   v.push_back("lld-link (LLVM option parsing)");
 1115     v.push_back(arg->getValue());
 1174   searchPaths.push_back("");
 1176     searchPaths.push_back(arg->getValue());
 1494     config->manifestInput.push_back(arg->getValue());

   51   void add(StringRef s) { args.push_back(saver.save(s)); }
   52   void add(std::string &s) { args.push_back(saver.save(s)); }
   53   void add(Twine s) { args.push_back(saver.save(s)); }
   54   void add(const char *s) { args.push_back(saver.save(s)); }
  870       exports.push_back(tok.substr(strlen("/export:")));

  293     chunks.push_back(c);
  587     chunks.push_back(c);

  205       ret.push_back(file->getBuffer());

 1029       newFpoFrames.push_back(std::move(fds));
 1296       publics.push_back(createPublic(def));
 1432   ebs.Fields.push_back("cwd");
 1438   ebs.Fields.push_back(cwd);
 1439   ebs.Fields.push_back("exe");
 1442   ebs.Fields.push_back(exe);
 1443   ebs.Fields.push_back("pdb");
 1445   ebs.Fields.push_back("cmd");
 1446   ebs.Fields.push_back(argStr);

  156         locations.push_back({sym, *fileLine});
  158         locations.push_back({sym, {"", 0}});
  343           undefDiags.push_back({sym, {{file, symIndex}}});
  345           undefDiags[it->second].files.push_back({file, symIndex});
  431         localImportChunks.push_back(cast<DefinedLocalImport>(sym)->getChunk());

  139     timeDateStamps.push_back(&d->TimeDateStamp);
  463       relocReplacements.push_back({j, thunkSymbolIndex});
  934     debugRecords.push_back(buildId);
 1079   strtab.push_back('\0');

   47     v.push_back(arg->getValue());

   33     parent->children.push_back(this);

  452           sectionMap[sec].push_back(def);
  566     ps->relocations.push_back(
  570     isec->relocations.push_back(makeRelToPatch(patcheeOffset, ps->patchSym));

  329           sectionMap[sec].push_back(def);
  443     psec->relocations.push_back(
  462     isec->relocations.push_back(

  300     v.push_back({f, cast<ObjFile<ELFT>>(f)->getObj().getHeader()->e_flags});

  175     v.push_back(std::make_pair(mbref, c.getChildOffset()));
  198     files.push_back(make<BinaryFile>(mbref));
  210         files.push_back(createObjectFile(p.first, path, p.second));
  233         files.push_back(make<LazyObjFile>(p.first, path, p.second));
  238     files.push_back(make<ArchiveFile>(std::move(file)));
  257     files.push_back(
  263       files.push_back(make<LazyObjFile>(mbref, "", 0));
  265       files.push_back(createObjectFile(mbref));
 1045   config->versionDefinitions.push_back({"local", (uint16_t)VER_NDX_LOCAL, {}});
 1046   config->versionDefinitions.push_back(
 1052     config->versionDefinitions[VER_NDX_LOCAL].patterns.push_back(
 1056         config->versionDefinitions[VER_NDX_GLOBAL].patterns.push_back(
 1069       config->dynamicList.push_back(
 1078     config->undefined.push_back(arg->getValue());
 1203         files.push_back(createObjectFile(*mb));
 1424     inputSections.push_back(bss);
 1621     v.push_back({sym, real, wrap});
 1860       inputSections.push_back(cast<InputSection>(s));
 1913     inputSections.push_back(createCommentSection());

 1209       dtNeeded.push_back(this->stringTable.data() + val);
 1231   sharedFiles.push_back(this);
 1437     symbols.push_back(createBitcodeSymbol<ELFT>(keptComdats, objSym, *this));
 1447   sections.push_back(section);

  487         sec->relocations.push_back({R_ABS, type, rel.r_offset, addend, &sym});
 1055         morestackCalls.push_back(&rel);

  299       ret.push_back(createObjectFile(MemoryBufferRef(buf[i], "lto.tmp")));
  303       ret.push_back(createObjectFile(*file));

   99     sectionCommands.push_back(make<InputSectionDescription>(""));
  172         cmd->sections.push_back(cast<InputSection>(s));
  201         cmd->sections.push_back(syn);
  222     v.push_back({order(s), s});

  138     c.relocations.push_back({expr, type, offset, addend, &sym});
  143     c.relocations.push_back({expr, type, offset, addend, &sym});
  175       c.relocations.push_back({expr, type, offset, addend, &sym});
  198       c.relocations.push_back(
  207         in.got->relocations.push_back(
  213     c.relocations.push_back({expr, type, offset, addend, &sym});
  219     c.relocations.push_back(
  231       in.got->relocations.push_back(
  234     c.relocations.push_back({expr, type, offset, addend, &sym});
  246           in.got->relocations.push_back(
  258           in.got->relocations.push_back(
  261       c.relocations.push_back({expr, type, offset, addend, &sym});
  268       c.relocations.push_back(
  277       c.relocations.push_back(
  289     c.relocations.push_back({R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym});
  575     osec->sectionCommands.push_back(make<InputSectionDescription>(""));
  577   isd->sections.push_back(sec);
  868   undefs.push_back({&sym, {{&sec, offset}}, isWarning});
  945     isec->relocations.push_back({expr, type, offsetInSec, addend, sym});
  946     part.relrDyn->relocs.push_back({isec, offsetInSec});
  978     in.got->relocations.push_back({expr, target->symbolicRel, off, 0, &sym});
 1039     sec.relocations.push_back({expr, type, offset, addend, &sym});
 1095       sec.relocations.push_back({expr, type, offset, addend, &sym});
 1138       sec.relocations.push_back({expr, type, offset, addend, &sym});
 1691   isd->thunkSections.push_back({ts, pass});