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

References

include/llvm/ADT/BreadthFirstIterator.h

   67     this->Visited.insert(Node);
   89       if (this->Visited.insert(Next).second)

include/llvm/ADT/DepthFirstIterator.h

   73   std::pair<iterator,bool> insert(NodeRef N) { return BaseSet::insert(N); }

include/llvm/ADT/PostOrderIterator.h

   64     return Visited.insert(To).second;
   84     return Visited.insert(To).second;

include/llvm/ADT/SetVector.h

  142     bool result = set_.insert(X).second;

include/llvm/ADT/SmallPtrSet.h

  389       insert(*I);

include/llvm/Analysis/CFG.h

  159     Visited.insert(Node);

include/llvm/Analysis/DominanceFrontierImpl.h

  182     if (visited.insert(currentBB).second) {

include/llvm/Analysis/LazyCallGraph.h

 1105         Visited.insert(BA->getFunction());
 1111         if (Visited.insert(cast<Constant>(Op)).second)

include/llvm/Analysis/LoopInfo.h

  406     DenseBlockSet.insert(BB);
  472     DenseBlockSet.insert(BB);

include/llvm/Analysis/LoopInfoImpl.h

  110         if (Visited.insert(Successor).second)
  333     VisitedBBs.insert(BB);

include/llvm/Analysis/ScalarEvolution.h

 1213       Predicates.insert(P);

include/llvm/Analysis/ScalarEvolutionExpressions.h

  567       if (Visited.insert(S).second && Visitor.follow(S))

include/llvm/Analysis/SparsePropagation.h

  260   if (!BBExecutable.insert(BB).second)

include/llvm/Analysis/VectorUtils.h

  548       DelSet.insert(I.second);
  644     InterleaveGroups.insert(InterleaveGroupMap[Instr]);
  734       Dependences[Dep.getSource(*LAI)].insert(Dep.getDestination(*LAI));

include/llvm/CodeGen/BasicTTIImpl.h

  362         Dests.insert(I.getCaseSuccessor());
  584       if (!isa<Constant>(A) && UniqueOperands.insert(A).second) {

include/llvm/CodeGen/LiveRangeEdit.h

  227     Rematted.insert(ParentVNI);

include/llvm/CodeGen/MachineDominators.h

  245     bool Inserted = NewBBs.insert(NewBB).second;

include/llvm/CodeGen/SelectionDAGNodes.h

  915         if (Visited.insert(Op).second)

include/llvm/IR/PassManager.h

  162     PA.PreservedIDs.insert(&AllAnalysesKey);
  186       PreservedIDs.insert(ID);
  198       PreservedIDs.insert(ID);
  219     NotPreservedAnalysisIDs.insert(ID);
  237       NotPreservedAnalysisIDs.insert(ID);
  259       NotPreservedAnalysisIDs.insert(ID);

include/llvm/MC/MCAssembler.h

  251   void setIsThumbFunc(const MCSymbol *Func) { ThumbFuncs.insert(Func); }

include/llvm/Support/CommandLine.h

  339   void addSubCommand(SubCommand &S) { Subs.insert(&S); }

include/llvm/Support/GenericDomTree.h

  106       OtherChildren.insert(Nd);

include/llvm/Support/GenericDomTreeConstruction.h

  462           ConnectToExitBlock.insert(FurthestAway);

include/llvm/Support/GenericIteratedDominanceFrontier.h

  169     VisitedWorklist.insert(Root);
  183         if (!VisitedPQ.insert(SuccNode).second)
  200         if (VisitedWorklist.insert(DomChild).second)

include/llvm/Transforms/IPO/Attributor.h

  830   void deleteAfterManifest(Instruction &I) { ToBeDeletedInsts.insert(&I); }
  833   void deleteAfterManifest(BasicBlock &BB) { ToBeDeletedBlocks.insert(&BB); }
  836   void deleteAfterManifest(Function &F) { ToBeDeletedFunctions.insert(&F); }

lib/Analysis/AssumptionCache.cpp

  218     assert(AssumptionSet.insert(VH).second &&
  283         AssumptionSet.insert(cast<CallInst>(VH));

lib/Analysis/BasicAliasAnalysis.cpp

  662     if (!Visited.insert(V).second) {
 1588   VisitedPhiBBs.insert(PN->getParent());
 1690       if (UniqueSrc.insert(PV1).second)

lib/Analysis/BranchProbabilityInfo.cpp

  152       PostDominatedByUnreachable.insert(BB);
  160       PostDominatedByUnreachable.insert(BB);
  169   PostDominatedByUnreachable.insert(BB);
  184     PostDominatedByColdCall.insert(BB);
  192       PostDominatedByColdCall.insert(BB);
  201         PostDominatedByColdCall.insert(BB);
  527   VisitedInsts.insert(CmpPHI);
  539         if (VisitedInsts.insert(PN).second)
  567         UnlikelyBlocks.insert(B);

lib/Analysis/CFG.cpp

   37   Visited.insert(BB);
   39   InStack.insert(BB);
   48       if (Visited.insert(BB).second) {
   59       InStack.insert(BB);
  151         LoopsWithHoles.insert(L);
  163     if (!Visited.insert(BB).second)

lib/Analysis/CGSCCPassManager.cpp

  453         if (Visited.insert(Callee).second && !Callee->isDeclaration()) {
  464           bool Inserted = RetainedEdges.insert(&CalleeN).second;
  475         if (Visited.insert(C).second)
  486     bool Inserted = RetainedEdges.insert(&RefereeN).second;
  548     UR.InvalidatedRefSCCs.insert(RC);
  640             UR.InvalidatedSCCs.insert(MergedC);

lib/Analysis/CaptureTracking.cpp

  240       if (!Visited.insert(&U).second)

lib/Analysis/CodeMetrics.cpp

   36     if (Visited.insert(Operand).second)
   61     EphValues.insert(V);
   87     if (EphValues.insert(I).second)
  107     if (EphValues.insert(I).second)

lib/Analysis/DemandedBits.cpp

  343           Visited.insert(J);
  397             DeadUses.insert(&OI);
  412       } else if (I && Visited.insert(I).second) {

lib/Analysis/DependenceGraphBuilder.cpp

  117         if (VisitedTargets.insert(DstNode).second) {

lib/Analysis/DomTreeUpdater.cpp

  181     DeletedBBs.insert(DelBB);
  195     DeletedBBs.insert(DelBB);

lib/Analysis/GlobalsModRef.cpp

  292         NonAddressTakenGlobals.insert(&F);
  293         TrackedFunctions.insert(&F);
  305         NonAddressTakenGlobals.insert(&GV);
  310           if (TrackedFunctions.insert(Reader).second) {
  319             if (TrackedFunctions.insert(Writer).second) {
  354         Readers->insert(LI->getParent()->getParent());
  358           Writers->insert(SI->getParent()->getParent());
  376             Writers->insert(Call->getParent()->getParent());
  461   IndirectGlobals.insert(GV);
  633   Visited.insert(V);
  662       if (Visited.insert(LHS).second)
  664       if (Visited.insert(RHS).second)
  671         if (Visited.insert(Op).second)
  719   Visited.insert(V);
  779       if (Visited.insert(LHS).second)
  781       if (Visited.insert(RHS).second)
  788         if (Visited.insert(Op).second)

lib/Analysis/IVDescriptors.cpp

  102       Visited.insert(Phi);
  103       CI.insert(J);
  171     Visited.insert(Val);
  177         Casts.insert(Cast);
  252   VisitedInsts.insert(Start);
  371       if (VisitedInsts.insert(UI).second) {

lib/Analysis/IVUsers.cpp

  116     SimpleLoopNests.insert(NearestLoop);
  173   if (!Processed.insert(I).second)
  208     if (!UniqueUsers.insert(User).second)
  259           NewUse.PostIncLoops.insert(L);
  418   PostIncLoops.insert(L);

lib/Analysis/InlineCost.cpp

 1141       !LoadAddrSet.insert(I.getPointerOperand()).second && I.isUnordered()) {
 1661   Visited.insert(V);
 1677   } while (Visited.insert(V).second);

lib/Analysis/LazyCallGraph.cpp

  105             if (Callees.insert(Callee).second) {
  106               Visited.insert(Callee);
  113           if (Visited.insert(C).second)
  194       if (Visited.insert(GV.getInitializer()).second)
  288         if (Visited.insert(CalleeC).second)
  317     bool Inserted = SCCSet.insert(C).second;
  375   Visited.insert(this);
  384           if (!ChildRC || !Visited.insert(ChildRC).second)
  572     ConnectedSet.insert(&SourceSCC);
  585         ConnectedSet.insert(C);
  598     ConnectedSet.insert(&TargetSCC);
  615           if (ConnectedSet.insert(&EdgeC).second)
  996     Set.insert(&SourceC);
 1010         Set.insert(C);
 1018     Set.insert(this);
 1031             if (Set.insert(&EdgeRC).second)
 1051   MergeSet.insert(this);

lib/Analysis/LazyValueInfo.cpp

  187         OverDefinedCache[BB].insert(Val);
 2011     if (!BlocksContainingLVI.insert(BB).second)

lib/Analysis/Lint.cpp

  665   if (!Visited.insert(V).second)
  679       if (!VisitedBlocks.insert(BB).second)

lib/Analysis/Loads.cpp

   57   if (!Visited.insert(V).second)

lib/Analysis/LoopAccessAnalysis.cpp

  514       ReadOnlyPtr.insert(Ptr);
 1656       Visited.insert(*AI);
 1933           !UniformStores.insert(Ptr).second;
 1937     if (Seen.insert(Ptr).second) {
 1970     if (Seen.insert(Ptr).second ||
 2341   StrideSet.insert(Stride);

lib/Analysis/LoopInfo.cpp

  551       ParallelAccessGroups.insert(AccGroup);

lib/Analysis/MemDerefPrinter.cpp

   60         DerefAndAligned.insert(PO);

lib/Analysis/MemoryBuiltins.cpp

  586     if (!SeenInsts.insert(I).second)
  829                   [&](Instruction *I) { InsertedInstructions.insert(I); })),
  891   if (!SeenVals.insert(V).second) {

lib/Analysis/MemoryDependenceAnalysis.cpp

  436   ReverseNonLocalDefsCache[ClosestDependency].insert(LI);
  767     ReverseLocalDeps[I].insert(QueryInst);
  839     if (!Visited.insert(DirtyBB).second)
  901         ReverseNonLocalDeps[Inst].insert(QueryCall);
 1038   ReverseNonLocalPtrDeps[Inst].insert(CacheKey);
 1613       ReverseLocalDeps[ReverseDepsToAdd.back().first].insert(
 1644       ReverseNonLocalDeps[ReverseDepsToAdd.back().first].insert(
 1687       ReverseNonLocalPtrDeps[ReversePtrDepsToAdd.back().first].insert(

lib/Analysis/MemorySSA.cpp

 1146   bool AlreadyVisited = !Visited.insert(Root->getBlock()).second;
 1167       AlreadyVisited = !Visited.insert(BB).second;
 1541       DefiningBlocks.insert(&B);
 2102   BlockNumberingValid.insert(B);

lib/Analysis/MemorySSAUpdater.cpp

   55     VisitedBlocks.insert(BB);
   71   if (VisitedBlocks.insert(BB).second) {
  369       DefiningBlocks.insert(MD->getBlock());
  373         DefiningBlocks.insert(RealPHI->getBlock());
  513           if (!Seen.insert(S).second)
  948       NewBlocks.insert(BB);

lib/Analysis/ModuleSummaryAnalysis.cpp

   98     if (!Visited.insert(U).second)
  283           Visited.insert(&I);
  287           Visited.insert(&I);
  663       LocalsUsed.insert(V);

lib/Analysis/MustExecute.cpp

  166     Predecessors.insert(Pred);
  182       if (Predecessors.insert(PredPred).second)
  219       if (CheckedSuccessors.insert(Succ).second &&

lib/Analysis/PhiValues.cpp

   86       Reachable.insert(ComponentPhi);
   98           Reachable.insert(Op);
  108         NonPhi.insert(const_cast<Value*>(V));

lib/Analysis/PtrUseVisitor.cpp

   23     if (VisitedUses.insert(&U).second) {

lib/Analysis/ScalarEvolution.cpp

 4196   Visited.insert(PN);
 4199     if (!Visited.insert(I).second)
 5731       if (PendingPhiRanges.insert(Phi).second) {
 6076   Pushed.insert(I);
 6085         if (Pushed.insert(cast<Instruction>(PoisonUser)).second)
 6751               Discovered.insert(I).second)
 6831       if (!Visited.insert(I).second)
 6870     if (!Visited.insert(I).second)
 9676   if (!PendingLoopPredicates.insert(FoundCondValue).second)
10026       if (!PendingMerges.insert(Phi).second)
10040       if (!PendingMerges.insert(Phi).second)
11379     if (!Visited.insert(U).second)
11900         LoopsUsed.insert(AR->getLoop());
12173     NewPreds->insert(P);
12234     Preds.insert(P);

lib/Analysis/ScalarEvolutionExpander.cpp

 1347     Loops.insert(L);
 1573       if (!PredSeen.insert(HP).second) {
 2156   if (!Processed.insert(S).second)

lib/Analysis/ScopedNoAliasAA.cpp

  137         Nodes.insert(MD);
  150         Domains.insert(Domain);

lib/Analysis/StackSafetyAnalysis.cpp

  357         if (Visited.insert(I).second)

lib/Analysis/SyncDependenceAnalysis.cpp

  187       ReachedLoopExits.insert(&SuccBlock);
  201       if (!JoinBlocks->insert(&SuccBlock).second)
  232         ReachedLoopExits.insert(SuccBlock);
  324           JoinBlocks->insert(ExitBlock);

lib/Analysis/ValueTracking.cpp

  477     if (!Visited.insert(V).second)
  488        EphValues.insert(V);
 1938       if (Visited.insert(CmpU).second)
 1952                 if (Visited.insert(BOU).second)
 3600     if (!PHIs.insert(PN).second)
 3774     if (!Visited.insert(P).second)
 3848       if (!Visited.insert(V).second)
 4403   YieldsPoison.insert(PoisonI);
 4404   Visited.insert(PoisonI->getParent());
 4423             YieldsPoison.insert(User);
 4429       if (Visited.insert(NextBB).second) {

lib/Analysis/VectorUtils.cpp

  386       InstructionSet.insert(&I);
  402         Roots.insert(&I);
  416     Visited.insert(Val);
  515     List.insert(AccGroups);
  522     List.insert(Item);
 1134       DelSet.insert(Group);

lib/AsmParser/LLParser.cpp

 5978     if (!SeenCases.insert(Constant).second)

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 1504       if (!AliasVisited.insert(Cur).second)
 1830         if (!EmittedSets.insert(MBB).second)

lib/CodeGen/BranchFolding.cpp

 1096       TriedMerging.insert(MergePotentials[i].getBlock());
 1158       if (!UniquePreds.insert(PBB).second)
 1207         TriedMerging.insert(MergePotentials[i].getBlock());

lib/CodeGen/CalcSpillWeights.cpp

  220     if (!visited.insert(mi).second)

lib/CodeGen/CodeGenPrepare.cpp

  637       Preheaders.insert(Preheader);
  730       SameIncomingValueBBs.insert(DestBBPred);
  790       BBPreds.insert(BBPN->getIncomingBlock(i));
 1885       InsertedInsts.insert(ExtVal);
 2030       if (!VisitedBBs.insert(*PI).second)
 2591       RemovedInsts.insert(Inst);
 3006       if (!Visited.insert(P).second)
 3046   void insertNewSelect(SelectInst *SI) { AllSelectNodes.insert(SI); }
 3286     MatchedPHIs.insert(PHI);
 3321         if (MatchedPHIs.insert(FirstPhi).second)
 3346       WillNotMatch.insert(PHI);
 3359           WillNotMatch.insert(M.first);
 4425   if (!ConsideredInsts.insert(I).second)
 4691     if (!Visited.insert(V).second)
 5220           RemovedInsts.insert(Pt);
 5232         RemovedInsts.insert(Inst);
 5528         UnhandledExts.insert(AlreadySeen->second);
 5638       InsertedInsts.insert(InsertedTrunc);
 5728     if (!Visited.insert(I).second)
 5804   InsertedInsts.insert(NewAnd);
 6200     InsertedInsts.insert(NI);

lib/CodeGen/EarlyIfConversion.cpp

  274     if (InsertAfter.insert(DefMI).second)

lib/CodeGen/GCRootLowering.cpp

  155         InitedRoots.insert(AI);

lib/CodeGen/GlobalISel/Combiner.cpp

   71     LLVM_DEBUG(CreatedInstrs.insert(&MI));

lib/CodeGen/GlobalISel/GISelChangeObserver.cpp

   22     ChangingAllUsesOfReg.insert(&ChangingMI);

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2069         SeenPreds.insert(Pred);

lib/CodeGen/GlobalISel/Localizer.cpp

  186         Users.insert(&UseMI);

lib/CodeGen/GlobalMerge.cpp

  574       MustKeepGlobalVariables.insert(G);
  591           MustKeepGlobalVariables.insert(GV);

lib/CodeGen/IndirectBrExpandPass.cpp

  105         IndirectBrSuccs.insert(SuccBB);

lib/CodeGen/InlineSpiller.cpp

  339     SnippetCopies.insert(&MI);
  495     if (!UsedValues.insert(VNI).second)
 1011         SnippetCopies.insert(MI);
 1155   MergeableSpills[MIdx].insert(&Spill);
 1270         NodesOnPath.insert(Node);
 1357       SpillsInSubTreeMap[*RIt].first.insert(*RIt);
 1427       SpillsInSubTree.insert(*RIt);

lib/CodeGen/LexicalScopes.cpp

  290       MBBs.insert(&MBB);
  296     MBBs.insert(R.first->getParent());

lib/CodeGen/LiveDebugValues.cpp

 1342       ArtificialBlocks.insert(&MBB);
 1371       MBBJoined |= Visited.insert(MBB).second;
 1392             if (OnPending.insert(s).second) {

lib/CodeGen/LiveInterval.cpp

  536     if (!Seen.insert(VNI).second)

lib/CodeGen/LiveIntervals.cpp

  398           !UsedPHIs.insert(VNI).second)
  402         if (!LiveOut.insert(Pred).second)
  418       if (!LiveOut.insert(Pred).second)
 1022     if (!Updated.insert(&LR).second)

lib/CodeGen/LiveRangeEdit.cpp

   77   Remattable.insert(VNI);
  176   Rematted.insert(RM.ParentVNI);
  368       DeadRemats->insert(MI);

lib/CodeGen/LiveVariables.cpp

  743     Kills.insert(VI.Kills[i]->getParent());

lib/CodeGen/MIRPrinter.cpp

  561       auto RP = Seen.insert(Succ);

lib/CodeGen/MachineBasicBlock.cpp

 1273     if (!SeenMBBs.insert(MBB).second ||

lib/CodeGen/MachineBlockPlacement.cpp

  921       if (!SeenPreds.insert(SuccPred).second)
 1674   if (!UpdatedPreds.insert(&Chain).second)
 2112           BlocksExitingToOuterLoop.insert(MBB);
 2508   UpdatedPreds.insert(&LoopChain);
 2584       BlocksWithUnanalyzableExits.insert(&*BB);
 2616       FunctionBlockSet.insert(&MBB);

lib/CodeGen/MachineCSE.cpp

  442       CSUses.insert(&MI);

lib/CodeGen/MachinePipeliner.cpp

  619         Visited.insert(SuccSU);
 1229         B[W].insert(SV);
 1519   if (!Visited.insert(Cur).second)
 2190     if (!Visited.insert(Def).second)
 2356     Visited.insert(PrevSU);
 2379     Visited.insert(SuccSU);

lib/CodeGen/MachineSink.cpp

 1231       SinkableBBs.insert(SI);

lib/CodeGen/MachineTraceMetrics.cpp

  470     return LB.Visited.insert(To).second;

lib/CodeGen/MachineVerifier.cpp

  587     FunctionBlocks.insert(&MBB);
  639       LandingPadSuccs.insert(*I);
 2149         todo.insert(*SuI);
 2165         todo.insert(*SuI);
 2182         todo.insert(*PrI);
 2198         todo.insert(*PrI);
 2249         seen.insert(&Pre);

lib/CodeGen/ModuloSchedule.cpp

 1062     if (!Visited.insert(Def).second)
 1863       IllegalPhis.insert(&*NI);

lib/CodeGen/OptimizePHIs.cpp

  103   if (!PHIsInCycle.insert(MI).second)
  149   if (!PHIsInCycle.insert(MI).second)

lib/CodeGen/PHIElimination.cpp

  390     if (!MBBsInsertedInto.insert(&opBlock).second)
  412             ImpDefs.insert(DefMI);

lib/CodeGen/PHIEliminationUtils.cpp

   38       DefUsesInMBB.insert(&RI);

lib/CodeGen/PeepholeOptimizer.cpp

  490     ReachedBBs.insert(UI.getParent());
  568         PHIBBs.insert(UI.getParent());
 1298     LocalMIs.insert(&NewCopy);
 1643       LocalMIs.insert(MI);
 1777               LocalMIs.insert(FoldMI);

lib/CodeGen/PrologEpilogInserter.cpp

  479     Visited.insert(Entry);
  481   Visited.insert(Save);
  499       if (Visited.insert(SuccBB).second)

lib/CodeGen/RegAllocGreedy.cpp

 2558       RecoloringCandidates.insert(Intf);

lib/CodeGen/RegisterCoalescer.cpp

  323       ErasedInstrs.insert(MI);
  552   ErasedInstrs.insert(MI);
 1327   ErasedInstrs.insert(CopyMI);
 1681     if (SrcReg == DstReg && !Visited.insert(UseMI).second)
 3197       ErasedInstrs.insert(MI);

lib/CodeGen/SafeStack.cpp

  359         if (Visited.insert(I).second)

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

 1439     CombinedNodes.insert(N);
 1769         if (SeenOps.insert(Op.getNode()).second)
 1823     if (SeenChains.insert(Op).second) {
 4785         NodesWithConsts.insert(N);
 6723     Loads.insert(L);
13815       Visited.insert(Ptr.getNode());
15092     Visited.insert(StoreNodes[i].MemNode);
15097     if (Visited.insert(StoreNodes[i].MemNode->getChain().getNode()).second)
15439     if (!Visited.insert(N).second)
19812     Visited.insert(TheSelect);
20667     if (!Visited.insert(Chain.getNode()).second)

lib/CodeGen/SelectionDAG/FastISel.cpp

 2267     if (!SuccsHandled.insert(SuccMBB).second)

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 1293   Visited.insert(Op.getNode());
 4616       if (LegalizedNodes.insert(N).second) {
 4642   LegalizedNodes.insert(N);

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

  238     if (User == Node || !Visited.insert(User).second)
  343   Visited.insert(DAG->getRoot().getNode());
  351       if (Visited.insert(Op.getNode()).second)

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 7722       DeadNodeSet.insert(Used);
 9608   if (!Visited.insert(N).second) {
 9618   Checked.insert(N);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 2927     bool Inserted = Done.insert(BB).second;
 3034     if (!Visited.insert(User).second)
 9568   ElidedArgCopyInstrs.insert(SI);
 9941     if (!SuccsHandled.insert(SuccMBB).second)

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

  873   if (!once.insert(N).second) // If we've been here before, return now.
  888       once.insert(Op.getNode());

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  749     if (!VisitedNodes.insert(N).second)
 1419       FuncInfo->VisitedBBs.insert(LLVMBB);
 2113   Visited.insert(ImmedUse);
 2120     if (!Visited.insert(N).second)
 2132       if (!Visited.insert(N).second)
 2360     if (!Visited.insert(V.getNode()).second)
 2371     Visited.insert(N);

lib/CodeGen/SjLjEHPrepare.cpp

  123   if (!LiveBBs.insert(BB).second)
  129     LiveBBs.insert(B);
  290       LiveBBs.insert(&BB);
  337       PHIsToDemote.insert(cast<PHINode>(PN));

lib/CodeGen/SplitKit.cpp

  959     EqualVNs[ParentVNI->id].insert(VNI);
  979           DominatedVNIs.insert((*It1)->def < (*It2)->def ? (*It2) : (*It1));
  981           DominatedVNIs.insert(*It2);
  983           DominatedVNIs.insert(*It1);
 1446   Visited.insert(&ParentVNI);
 1464       if (Visited.insert(PredVNI).second)

lib/CodeGen/StackColoring.cpp

  929     MergedAllocas.insert(From);
  930     MergedAllocas.insert(To);

lib/CodeGen/StackProtector.cpp

  198       if (VisitedPHIs.insert(PN).second)

lib/CodeGen/SwiftErrorValueTracking.cpp

  184         if (!Visited.insert(Pred).second)

lib/CodeGen/SwitchLoweringUtils.cpp

  241     Done.insert(Succ);

lib/CodeGen/TwoAddressInstructionPass.cpp

  762     SunkInstrs.insert(NewMI);
  781     if (IsCopy && !Processed.insert(UseMI).second)
  849   Processed.insert(MI);

lib/ExecutionEngine/MCJIT/MCJIT.h

   97       AddedModules.insert(M.release());
  135       LoadedModules.insert(M);
  151       FinalizedModules.insert(M);
  159         FinalizedModules.insert(M);

lib/IR/Constants.cpp

  437       if (NonTrappingOps.insert(Op).second && canTrapImpl(Op, NonTrappingOps))
  469   Visited.insert(C);
  480       if (Visited.insert(ConstOp).second)

lib/IR/DIBuilder.cpp

   84     if (RetainSet.insert(AllRetainTypes[I]).second)

lib/IR/DebugInfo.cpp

  207   if (!NodesSeen.insert(DV).second)
  222   if (!NodesSeen.insert(DV).second)
  232   if (!NodesSeen.insert(DT).second)
  242   if (!NodesSeen.insert(CU).second)
  250   if (!NodesSeen.insert(DIG).second)
  261   if (!NodesSeen.insert(SP).second)
  275   if (!NodesSeen.insert(Scope).second)

lib/IR/DebugInfoMetadata.cpp

   85     InlinedLocationsA.insert(L);

lib/IR/LLVMContext.cpp

   86   pImpl->OwnedModules.insert(M);

lib/IR/LegacyPassManager.cpp

  900     L.insert(LU.first);

lib/IR/Module.cpp

  608     Set.insert(G);

lib/IR/Type.cpp

  486   if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)

lib/IR/Value.cpp

  366   if (!Cache.insert(Expr).second)
  474   Visited.insert(V);
  523   } while (Visited.insert(V).second);
  562   Visited.insert(this);
  599   } while (Visited.insert(V).second);

lib/IR/Verifier.cpp

  557   if (!Visited.insert(User).second)
  718   Visited.insert(&GA);
  729       Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
  791   if (!MDNodes.insert(&MD).second)
  861   if (!MDNodes.insert(MD).second)
 1098   CUVisited.insert(&N);
 1878   if (!ConstantExprVisited.insert(EntryC).second)
 1904       if (!ConstantExprVisited.insert(OpC).second)
 2097     Active.insert(PredPad);
 2116       if (!Visited.insert(SuccPad).second)
 2124       Active.insert(PredPad);
 2338     if (!Seen.insert(DL).second)
 2346     if (Scope && !Seen.insert(Scope).second)
 2353     if (SP && ((Scope != SP) && !Seen.insert(SP).second))
 2475     Assert(Constants.insert(Case.getCaseValue()).second,
 2512         ArgBBs.insert(BA->getBasicBlock());
 3653       Assert(Seen.insert(FromPad).second,
 3772     Assert(Seen.insert(CurrentPad).second,
 4228   InstsInThisBlock.insert(&I);
 5353   return Parent && Visited.insert(Parent).second &&
 5497     if (!StructPath.insert(BaseNode).second) {

lib/LTO/UpdateCompilerUsed.cpp

   77       if (Lowering && TLSet.insert(Lowering).second)

lib/Linker/IRMover.cpp

  148       if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy)).second)
  259     if (!Visited.insert(STy).second) {

lib/MC/MCAssembler.cpp

  161   ThumbFuncs.insert(Symbol); // Cache it.

lib/MC/MCCodePadder.cpp

   29   return CodePaddingPolicies.insert(Policy).second;

lib/Support/CommandLine.cpp

  349     RegisteredOptionCategories.insert(cat);
  359     RegisteredSubCommands.insert(sub);
 2028     if (!OptionSet.insert(I->second).second)

lib/Target/AArch64/AArch64BranchTargets.cpp

   75         JumpTableTargets.insert(MBB);

lib/Target/AArch64/AArch64ISelLowering.cpp

10931     Visited.insert(Addr.getNode());
11024     Visited.insert(Addr.getNode());

lib/Target/AMDGPU/AMDGPUAlwaysInlinePass.cpp

   68     if (!Visited.insert(U).second)
   74         FuncsToAlwaysInline.insert(F);
  137             FuncsToNoInline.insert(&F);
  139           FuncsToAlwaysInline.insert(&F);

lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp

  109   if (!ConstantExprVisited.insert(EntryC).second)
  130       if (!ConstantExprVisited.insert(OpC).second)

lib/Target/AMDGPU/AMDGPUInline.cpp

  140       if (!AI->isStaticAlloca() || !AIVisited.insert(AI).second)

lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp

  251     if (HandledUses.insert(CI).second) {

lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp

  221   PHIInfo.insert(NewElement);
  995 void LinearizedRegion::addMBB(MachineBasicBlock *MBB) { MBBs.insert(MBB); }
 1075   MBBs.insert(MBB);
 1426       PHIs.insert(&Instr);
 2609     MBBs.insert(MBB);

lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp

  150       WorkSet.insert(MO);
  156     if (!Visited.insert(V).second)
  171       WorkSet.insert(P);
  173         WorkSet.insert(GEP->getOperand(I));
  178       WorkSet.insert(U->getOperand(0));
  183       WorkSet.insert(BO->getOperand(0));
  184       WorkSet.insert(BO->getOperand(1));
  189       WorkSet.insert(S->getFalseValue());
  190       WorkSet.insert(S->getTrueValue());
  195       WorkSet.insert(E->getVectorOperand());

lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

  171       Roots.insert(&F);
  177   Roots.insert(&F);
  219           NewRoots.insert(&F);
  233             NewRoots.insert(&F);
  240           NewRoots.insert(NewF);
  244         Replaced.insert(&F);

lib/Target/AMDGPU/AMDGPUSubtarget.cpp

  800       Visited.insert(SU);
  818       if (!Visited.insert(SU).second)

lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp

  111       if (Visited.insert(Pred).second)

lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

 1050     ExitBlkSet.insert(ExitBlks[i]);

lib/Target/AMDGPU/GCNMinRegStrategy.cpp

  193         Set.insert(PSU);
  203           Set.insert(P.getSUnit()).second)

lib/Target/AMDGPU/GCNRegBankReassign.cpp

  578     if (!Visited.insert(&MI).second)

lib/Target/AMDGPU/SIFixSGPRCopies.cpp

  499             MergedInstrs.insert(MI2);
  509             MergedInstrs.insert(MI1);
  531             MergedInstrs.insert(MI1);
  764   Visited.insert(&MI);
  779         if (Visited.insert(UseMI).second)

lib/Target/AMDGPU/SIISelLowering.cpp

10952   if (!Visited.insert(V).second)

lib/Target/AMDGPU/SILoadStoreOptimizer.cpp

 1657     AnchorList.insert(AnchorInst);

lib/Target/ARM/ARMAsmPrinter.cpp

  119     PromotedGlobals.insert(GV);
  880         EmittedPromotedGlobalLabels.insert(GV);

lib/Target/ARM/ARMBaseInstrInfo.cpp

 2285   SeenMIs.insert(NewMI);

lib/Target/ARM/ARMCodeGenPrepare.cpp

  389   SafeWrap.insert(I);
  467       InstsToRemove.insert(I);
  493       NewInsts.insert(NewInst);
  495     InstsToRemove.insert(I);
  519       NewInsts.insert(I);
  537     Promoted.insert(V);
  570       Promoted.insert(I);
  598     NewInsts.insert(Call);
  620       NewInsts.insert(Trunc);
  728       NewInsts.insert(I);
  862     SafeToPromote.insert(I);
  957       Sinks.insert(cast<Instruction>(V));
  960       Sources.insert(V);

lib/Target/ARM/ARMConstantIslandPass.cpp

  949   NewWaterList.insert(OrigBB);
 1479       NewWaterList.insert(NewIsland);
 1499     NewWaterList.insert(NewIsland);

lib/Target/ARM/ARMConstantPoolValue.cpp

  144   GVars.insert(GV);

lib/Target/ARM/ARMFrameLowering.cpp

 2302       if (BeforePrologueRegion.insert(PredBB).second)
 2315     BeforePrologueRegion.insert(B);

lib/Target/ARM/ARMISelLowering.cpp

 2890       Copies.insert(*UI);
 9807     if (SeenMBBs.insert(CurMBB).second)
12896     Visited.insert(Addr.getNode());

lib/Target/ARM/ARMLoadStoreOptimizer.cpp

 2285         MemOps.insert(Ops[i]);

lib/Target/ARM/ARMMachineFunctionInfo.h

  242     PromotedGlobals.insert(GV);

lib/Target/ARM/ARMParallelDSP.cpp

  419         OffsetLoads.insert(Offset);

lib/Target/ARM/MLxExpansionPass.cpp

  227     IgnoreStall.insert(DefMI);

lib/Target/ARM/MVETailPredication.cpp

  432     Dead.insert(I);

lib/Target/Hexagon/HexagonGenInsert.cpp

 1308       UIs.insert(I->getParent());

lib/Target/Hexagon/HexagonInstrInfo.cpp

  162     if (!Visited.insert(PB).second)

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2070   Ignore1.insert(SI);
 2074     Ignore1.insert(LI);
 2117   Ignore2.insert(SI);
 2307     LoopBlocks.insert(B);

lib/Target/Hexagon/HexagonStoreWidening.cpp

  495     InstrSet.insert(I);

lib/Target/Hexagon/HexagonSubtarget.cpp

  553     ExclSrc.insert(Src);
  561     ExclDst.insert(Dst);

lib/Target/Lanai/LanaiInstrInfo.cpp

  537   SeenMIs.insert(NewMI);

lib/Target/Mips/MipsConstantIslandPass.cpp

  894   NewWaterList.insert(OrigBB);
 1336       NewWaterList.insert(NewIsland);
 1362     NewWaterList.insert(NewIsland);

lib/Target/Mips/MipsDelaySlotFiller.cpp

  516     return !Defs.insert(V).second || Uses.count(V) || SeenNoObjStore ||
  519   Uses.insert(V);

lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

  193       UpdateOther.insert(Symbol);

lib/Target/PowerPC/PPCBoolRetToInt.cpp

   76     Defs.insert(V);
   85           if (Defs.insert(Op).second)
  135             Promotable.insert(P);

lib/Target/PowerPC/PPCCTRLoops.cpp

  136     Visited.insert(MBB);
  142   Visited.insert(MBB);

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

 6075     ToPromote.insert(Op32.getNode());
 6082     ToPromote.insert(Op32.getNode());
 6093     ToPromote.insert(Op32.getNode());
 6100     ToPromote.insert(Op32.getNode());
 6107     ToPromote.insert(Op32.getNode());
 6121     ToPromote.insert(Op32.getNode());
 6138     ToPromote.insert(Op32.getNode());
 6154     ToPromote.insert(Op32.getNode());
 6170     ToPromote.insert(Op32.getNode());
 6193     ToPromote.insert(Op32.getNode());

lib/Target/PowerPC/PPCISelLowering.cpp

11887     if (!Visited.insert(ChainNext).second)
11901       LoadRoots.insert(ChainNext);
11918       if (!Visited.insert(LoadRoot).second)
12124     if (!Visited.insert(BinOp.getNode()).second)
12340     if (!Visited.insert(BinOp.getNode()).second)

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  407     BBChanged.insert(IDel->getParent());
  414   NewPtrs.insert(NewBasePtr);
  446       BBChanged.insert(IDel->getParent());
  459     NewPtrs.insert(RealNewPtr);

lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp

  273         AfterSet.insert(&MI);
  276         BeforeSet.insert(&MI);
  284       AfterSet.insert(&MI);
  291       BeforeSet.insert(&MI);
  296       AfterSet.insert(&MI);
  305       AfterSet.insert(&*std::prev(I));
  341       AfterSet.insert(&MI);
  351         BeforeSet.insert(&MI);
  354         AfterSet.insert(&MI);
  399       BeforeSet.insert(&MI);
  402       AfterSet.insert(&MI);
  419       AfterSet.insert(&MI);
  504         AfterSet.insert(&MI);
  507         BeforeSet.insert(&MI);
  515       AfterSet.insert(&MI);
  522       BeforeSet.insert(&MI);
  527       AfterSet.insert(&MI);
  542           AfterSet.insert(&MI);
  548             AfterSet.insert(&*std::prev(MI.getIterator()));
  569       AfterSet.insert(&*std::prev(I));
  589       AfterSet.insert(&MI);
  594       AfterSet.insert(&MI);
  605         BeforeSet.insert(&MI);
  608         AfterSet.insert(&MI);

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

   74     BlockSet.insert(MBB);

lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

   86         auto C = ConstantBCs.insert(cast<Constant>(U.get()));

lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp

  134           Reachable[MBB].insert(Succ);
  148           if (Reachable[Pred].insert(Succ).second) {
  158         Loopers.insert(MBB);
  170           LoopEntries.insert(Looper);
  171           LoopEnterers[Looper].insert(Pred);
  200     Blocks.insert(Entry);
  204         AddedToWorkList.insert(Pred);
  211       if (Blocks.insert(MBB).second) {
  215             AddedToWorkList.insert(Pred);
  273       MutualLoopEntries.insert(LoopEntry);
  278           MutualLoopEntries.insert(OtherLoopEntry);
  352   Blocks.insert(Dispatch);
  438       Blocks.insert(Routing);
  491     AllBlocks.insert(&MBB);

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

   70     Visited.insert(MBB);
  265           TerminatePads.insert(getMatchingEHPad(&MI));

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

  714         SetjmpUsers.insert(UI->getFunction());
  754     LandingPads.insert(II->getLandingPadInst());
  831       LandingPads.insert(LPI);

lib/Target/X86/X86FlagsCopyLowering.cpp

  442       Visited.insert(BeginMBB);
  447           if (!Visited.insert(PredMBB).second)
  646             VisitedBlocks.insert(SuccMBB).second) {

lib/Target/X86/X86ISelLowering.cpp

31105     if (SeenMBBs.insert(LP).second)

lib/Target/X86/X86SpeculativeLoadHardening.cpp

  340         if (!Preds.insert(MI.getOperand(OpIdx + 1).getMBB()).second)
 1039     IndirectTerminatedMBBs.insert(&MBB);
 1043       IndirectTargetMBBs.insert(Succ);
 1748           HardenPostLoad.insert(&MI);
 1755         HardenLoadAddr.insert(&MI);
 1815               HardenPostLoad.insert(SunkMI);

lib/Transforms/Coroutines/CoroElide.cpp

  161       Terminators.insert(TI);
  169         DAs.insert(DA);
  179       ReferencedCoroBegins.insert(CB);

lib/Transforms/Coroutines/CoroFrame.cpp

 1025   if (!VisitedOrFreeBBs.insert(From).second)
 1049       VisitedOrFreeBBs.insert(FI->getParent());

lib/Transforms/Coroutines/CoroSplit.cpp

 1022   Set.insert(SaveBB);
 1030     Set.insert(BB);

lib/Transforms/IPO/ArgumentPromotion.cpp

  816   PtrValues.insert(arg);
  829       if (PtrValues.insert(V).second)
  980           ByValArgsToTransform.insert(PtrArg);
 1006       ArgsToPromote.insert(PtrArg);

lib/Transforms/IPO/Attributor.cpp

  181     if (!Visited.insert(V).second)
 1813     Visited.insert(BB);
 3644       if (!Visited.insert(U).second)
 3674           FreesForMalloc[&I].insert(
 4532     if (!Visited.insert(ChangedAA).second)

lib/Transforms/IPO/CalledValuePropagation.cpp

  266       IndirectCalls.insert(I);

lib/Transforms/IPO/ConstantMerge.cpp

   53     UsedValues.insert(GV);

lib/Transforms/IPO/FunctionAttrs.cpp

  458     Visited.insert(&U);
  474         if (Visited.insert(&UU).second)
  488             if (Visited.insert(&UU).second)
  749         Self.insert(&*A);
  797       ArgumentSCCNodes.insert(I->Definition);

lib/Transforms/IPO/GlobalDCE.cpp

  104     Deps.insert(Parent);
  106     Deps.insert(GV);
  137     GVDependencies[GVU].insert(&GV);
  144   auto const Ret = AliveGlobals.insert(&GV);
  197         VFESafeVTables.insert(&GV);
  227     GVDependencies[Caller].insert(Callee);

lib/Transforms/IPO/GlobalOpt.cpp

  647       if (PHIs.insert(PN).second && !AllUsesOfValueWillTrapIfNull(PN, PHIs))
  991       if (PHIs.insert(PN).second)
 1082       if (!LoadUsingPHIsPerLoad.insert(PN).second)
 1086       if (!LoadUsingPHIs.insert(PN).second)
 2669   bool usedInsert(GlobalValue *GV) { return Used.insert(GV).second; }
 2672     return CompilerUsed.insert(GV).second;
 2927           NotDiscardableComdats.insert(C);
 2931           NotDiscardableComdats.insert(C);
 2935           NotDiscardableComdats.insert(C);

lib/Transforms/IPO/HotColdSplitting.cpp

  270         SuccsOutsideRegion.insert(SuccBB);
  400       RegionBlocks.insert(BB);
  596         return !ColdBlocks.insert(Block.first).second;

lib/Transforms/IPO/Inliner.cpp

  214       if (!UsedAllocas.insert(AvailableAlloca).second)
  262     UsedAllocas.insert(AI);
  541       SCCFunctions.insert(F);
 1223     UR.InvalidatedSCCs.insert(&DeadC);
 1224     UR.InvalidatedRefSCCs.insert(&DeadRC);

lib/Transforms/IPO/PruneEH.cpp

   69     SCCNodes.insert(I);

lib/Transforms/IPO/SampleProfile.cpp

  747       VisitedBlocks.insert(&BB);
 1053         VisitedBlocks.insert(EC);
 1303         VisitedBlocks.insert(EC);
 1326       if (Visited.insert(B2).second)
 1336       if (Visited.insert(B2).second)

lib/Transforms/IPO/StripSymbols.cpp

  145       Operands.insert(cast<Constant>(Op));
  193   UsedValues.insert(LLVMUsed);
  200       UsedValues.insert(GV);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  766     if (!Visited.insert(P).second)

lib/Transforms/InstCombine/InstCombinePHI.cpp

  838   if (!PotentiallyDeadPHIs.insert(PN).second)
  857   if (!ValueEqualPHIs.insert(PN).second)
  964   PHIsInspected.insert(&FirstPhi);
  990         if (PHIsInspected.insert(UserPN).second)
 1156       PotentiallyDeadPHIs.insert(&PN);

lib/Transforms/InstCombine/InstructionCombining.cpp

 2828       if (AlreadyCaught.insert(TypeInfo).second) {
 2924           if (SeenInFilter.insert(TypeInfo).second)
 3385     if (!Visited.insert(BB).second)

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 2670             if (!TempsToInstrument.insert(Addr).second)

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  906         FnsWithNativeABI.insert(&F);

lib/Transforms/Instrumentation/InstrProfiling.cpp

  249       if (BlockSet.insert(ExitBlock).second) {

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 3502     AllocaSet.insert(&I);

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  381       WriteTargets.insert(Addr);

lib/Transforms/ObjCARC/DependencyAnalysis.cpp

  240           DependingInsts.insert(nullptr);
  245             if (Visited.insert(PredBB).second)
  253         DependingInsts.insert(Inst);
  267         DependingInsts.insert(reinterpret_cast<Instruction *>(-1));

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  431   StoreStrongCalls.insert(StoreStrong);

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

 1470   Visited.insert(EntryBB);
 1471   OnStack.insert(EntryBB);
 1479       if (Visited.insert(SuccBB).second) {
 1485         OnStack.insert(SuccBB);
 1513     Visited.insert(&ExitBB);
 1519         if (Visited.insert(BB).second) {
 1666         if (ReleasesToMove.Calls.insert(NewRetainRelease).second) {
 1697               if (ReleasesToMove.ReverseInsertPts.insert(RIP).second) {
 1738         if (RetainsToMove.Calls.insert(NewReleaseRetain).second) {
 1754               if (RetainsToMove.ReverseInsertPts.insert(RIP).second) {

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

   74     if (UniqueSrc.insert(PV1).second && related(PV1, B, DL))
   88   Visited.insert(P);
  106       if (Visited.insert(Ur).second)

lib/Transforms/ObjCARC/PtrState.cpp

  119     Partial |= ReverseInsertPts.insert(Inst).second;

lib/Transforms/ObjCARC/PtrState.h

  157   void InsertCall(Instruction *I) { RRI.Calls.insert(I); }
  159   void InsertReverseInsertPt(Instruction *I) { RRI.ReverseInsertPts.insert(I); }

lib/Transforms/Scalar/ADCE.cpp

  410     NewLiveBlocks.insert(BBInfo.BB);
  420   if (!AliveScopes.insert(&LS).second)
  433   if (!AliveScopes.insert(&DL).second)
  458       NewLiveBlocks.insert(PredBB);
  603         RemovedSuccessors.insert(Succ);

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

  362     Visited.insert(J);

lib/Transforms/Scalar/BDCE.cpp

   52       Visited.insert(J);
   81       if (K && Visited.insert(K).second && K->getType()->isIntOrIntVectorTy() &&

lib/Transforms/Scalar/CallSiteSplitting.cpp

  161     Visited.insert(From);

lib/Transforms/Scalar/ConstantHoisting.cpp

  226       Path.insert(Node);

lib/Transforms/Scalar/ConstantProp.cpp

   78     WorkList.insert(&I);
  101             if (WorkList.insert(cast<Instruction>(U)).second)

lib/Transforms/Scalar/DeadStoreElimination.cpp

  629         if (!Visited.insert(*PredI).second)

lib/Transforms/Scalar/EarlyCSE.cpp

  856           if (SimpleValue::canHandle(OPI) && Visited.insert(OPI).second)

lib/Transforms/Scalar/Float2Int.cpp

  136         Roots.insert(&I);
  141           Roots.insert(&I);

lib/Transforms/Scalar/GVNHoist.cpp

  775           VNBlocks.insert(BBI);
  941         UsePhis.insert(Phi);

lib/Transforms/Scalar/GVNSink.cpp

  600         PHIContents.insert(V);

lib/Transforms/Scalar/GuardWidening.cpp

  508   Visited.insert(Inst);
  618   if (!Visited.insert(CheckCond).second)

lib/Transforms/Scalar/IndVarSimplify.cpp

  554   Visited.insert(I);
  567       if (Visited.insert(UI).second)
 1702     if (!Widened.insert(NarrowUser).second)
 1793   Widened.insert(OrigPhi);
 1903   Visited.insert(OrigPhi);
 1916       if (!Visited.insert(NarrowUser).second)
 2150     if (KnownPoison.insert(I).second)
 2183     if (!Visited.insert(Op).second)
 2198   Visited.insert(V);
 2791     if (!DominatingExitCounts.insert(ExitCount).second) {

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  340   if (!Visited.insert(Condition).second)

lib/Transforms/Scalar/InstSimplifyPass.cpp

   58               Next->insert(cast<Instruction>(U));

lib/Transforms/Scalar/JumpThreading.cpp

  232       Visited.insert(PredBB);
  385       Unreachable.insert(&BB);
  716           LHSKnownBBs.insert(LHSVal.second);
 1365     if (!PredsScanned.insert(PredBB).second)
 1448       AvailablePredSet.insert(AvailablePred.first);
 1628     if (!SeenPreds.insert(Pred).second)

lib/Transforms/Scalar/LICM.cpp

  655       PredecessorBlocks.insert(PredBB);
 1607     VisitedUsers.insert(PN);

lib/Transforms/Scalar/LoopDistribute.cpp

  133     Set.insert(I);
  140   void add(Instruction *I) { Set.insert(I); }
  164       Set.insert(B->getTerminator());
  174         if (I && OrigLoop->contains(I->getParent()) && Set.insert(I).second)

lib/Transforms/Scalar/LoopFuse.cpp

  452   void removeLoop(const Loop *L) { RemovedLoops.insert(L); }

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  775       AdjacentStores.insert(I);
  847   MSIs.insert(MSI);
 1100   Stores.insert(SI);

lib/Transforms/Scalar/LoopInstSimplify.cpp

   88           VisitedPHIs.insert(PI);
  118               Next->insert(UserPI);
  133             ToSimplify->insert(UserI);

lib/Transforms/Scalar/LoopInterchange.cpp

  711         OuterInnerReductions.insert(&PHI);
  712         OuterInnerReductions.insert(InnerRedPhi);

lib/Transforms/Scalar/LoopLoadElimination.cpp

  195           LoadsWithUnknownDepedence.insert(Source);
  197           LoadsWithUnknownDepedence.insert(Destination);
  366         PtrsWrittenOnFwdingPath.insert(S->getPointerOperand());

lib/Transforms/Scalar/LoopPredication.cpp

  742     if (!Visited.insert(Condition).second)

lib/Transforms/Scalar/LoopRerollPass.cpp

  281             PossibleRedLastSet.insert(PossibleReds[i].getReducedValue());
  282             PossibleRedPHISet.insert(PossibleReds[i].getPHI());
  284             PossibleRedSet.insert(PossibleReds[i].getPHI());
  287               PossibleRedSet.insert(J);
  863   SubsumedInsts.insert(I);
  927     SubsumedInsts.insert(IVU);
 1021     Exclude.insert(DRS.BaseInst);
 1061     Exclude.insert(DRS.BaseInst);
 1231         Visited.insert(BaseInst);
 1237         Visited.insert(RootInst);
 1405       Visited.insert(BaseInst);
 1406       Visited.insert(RootInst);

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

  226     LiveLoopBlocks.insert(L.getHeader());
  250             LiveLoopBlocks.insert(Succ);
  252             LiveExitBlocks.insert(Succ);
  267           UniqueDeadExits.insert(ExitBlock).second)
  289     BlocksInLoopAfterFolding.insert(L.getLoopLatch());
  302         BlocksInLoopAfterFolding.insert(BB);
  490           DeadSuccessors.insert(Succ);

lib/Transforms/Scalar/LoopSink.cpp

  142         BBsDominatedByColdestBB.insert(SinkedBB);
  150       BBsToSinkInto.insert(ColdestBB);
  189     BBs.insert(UI->getParent());

lib/Transforms/Scalar/LoopStrengthReduce.cpp

  922   if (!Processed.insert(S).second)
 1315   if (Regs.insert(Reg).second) {
 1318       LoserRegs->insert(Reg);
 1561     Regs.insert(F.ScaledReg);
 1579     if (F.ScaledReg) Regs.insert(F.ScaledReg);
 2497     PostIncs.insert(Cond);
 3007     NearUsers.insert(OtherUse);
 3073         if (UniqueOperands.insert(IVOpInst).second)
 3113     IVIncSet.insert(UseI);
 3397     if (!Visited.insert(S).second)
 4742         UniqRegs.insert(Reg);
 4806       UniqRegs.insert(F.ScaledReg);
 4845     Taken.insert(Best);

lib/Transforms/Scalar/LoopUnswitch.cpp

  341   (*CurLoopInstructions)[SI].insert(V);
 1083     if (!currentLoop->contains(CurrentBB) || !Visited.insert(CurrentBB).second)

lib/Transforms/Scalar/NewGVN.cpp

  224       Component.insert(I);
  226       InComponent.insert(I);
  232         Component.insert(Member);
  233         InComponent.insert(Member);
  339   void insert(MemberType *M) { Members.insert(M); }
  356   void memory_insert(const MemoryMemberType *M) { MemoryMembers.insert(M); }
 2068     AdditionalUsers[To].insert(User);
 2082   MemoryToUsers[To].insert(U);
 2104     PredicateToUsers[PBranch->Condition].insert(I);
 2106     PredicateToUsers[PAssume->Condition].insert(I);
 2126     LeaderChanges.insert(M);
 2435     if (ReachableBlocks.insert(To).second) {
 2572       PHINodeUses.insert(UI);
 2618     if (!Visited.insert(Op).second)
 2674     ExpressionToPhiOfOps[E].insert(OrigInst);
 2692   if (!Visited.insert(I).second)
 2772             CurrentDeps.insert(Op);
 2902               PHINodeUses.insert(UInst);
 3135   Visited.insert(First);
 3462   ReachableBlocks.insert(&F.getEntryBlock());
 3642       ProbablyDead.insert(Def);
 3708   InstructionsToErase.insert(I);
 3909           MembersLeft.insert(Member);
 4033               ProbablyDead.insert(cast<Instruction>(U->get()));
 4075               ProbablyDead.insert(II);
 4094         MembersLeft.insert(Member);

lib/Transforms/Scalar/Reassociate.cpp

  510         assert(Visited.insert(Op).second && "Not first visit!");
  520         assert(Visited.insert(Op).second && "Not first visit!");
  665     NotRewritable.insert(Ops[i].Op);
 1546       if (!Duplicates.insert(Factor).second)
 1561           if (!Duplicates.insert(Factor).second)
 1574           if (!Duplicates.insert(Factor).second)
 1926              Visited.insert(Op).second)

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1884   Vec.erase(remove_if(Vec, [&](const T &V) { return !Seen.insert(V).second; }),

lib/Transforms/Scalar/SCCP.cpp

  280     if (!BBExecutable.insert(BB).second)
  306       MRVFunctionsTracked.insert(F);
  317     MustTailCallees.insert(F);
  327     TrackingIncomingArguments.insert(F);
  586     Iter.first->second.insert(U);

lib/Transforms/Scalar/SROA.cpp

  669     if (VisitedDeadInsts.insert(&I).second)
  951     Visited.insert(Root);
  984         if (Visited.insert(cast<Instruction>(U)).second)
 1583   Visited.insert(Ptr);
 1614       if (!Visited.insert(Ptr).second)
 1654   } while (Visited.insert(Ptr).second);
 3114     Visited.insert(&Root);
 3140         if (Visited.insert(cast<Instruction>(U)).second)
 3251       if (Visited.insert(U.getUser()).second)
 3670           UnsplittableLoads.insert(LI);
 3673             UnsplittableLoads.insert(LI);
 3695           UnsplittableLoads.insert(LI);
 3786                         UnsplittableLoads.insert(LI);
 3935         ResplitPromotableAllocas.insert(OtherAI);
 4052         ResplitPromotableAllocas.insert(OtherAI);
 4518       DeletedAllocas.insert(AI);

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  113   Visited.insert(&Root);
  133       if (Visited.insert(OpI).second)
  692       UnswitchedExitBBs.insert(DefaultExitBB);
  713       if (UnswitchedExitBBs.insert(ExitBB).second)
  869   Visited.insert(CurrentBB);
  941   } while (L.contains(CurrentBB) && Visited.insert(CurrentBB).second);
 1127       if (SuccSet.insert(SuccBB).second)
 1262     if (BlocksInClonedLoop.insert(Pred).second && Pred != ClonedHeader)
 1270     BlocksInClonedLoop.insert(ClonedHeader);
 1284             BlocksInClonedLoop.insert(Pred).second)
 1354     UnloopedBlockSet.insert(ClonedPH);
 1357       UnloopedBlockSet.insert(ClonedBB);
 1589     if (LoopBlockSet.insert(Pred).second && Pred != Header)
 1620         if (!LoopBlockSet.insert(InnerPH).second)
 1637           LoopBlockSet.insert(InnerBB);
 1649       if (L.contains(Pred) && LoopBlockSet.insert(Pred).second)
 1733     UnloopedBlocks.insert(PH);
 1798         bool Inserted = NewExitLoopBlocks.insert(PredBB).second;
 1883   Visited.insert(DT[BB]);
 1894       assert(Visited.insert(ChildN).second &&
 2389     if (Successors.insert(Succ).second)
 2679       if (!Visited.insert(SuccBB).second)

lib/Transforms/Scalar/SimplifyCFGPass.cpp

  156     LoopHeaders.insert(const_cast<BasicBlock *>(Edges[i].second));

lib/Transforms/Scalar/Sink.cpp

   63     Stores.insert(Inst);

lib/Transforms/Scalar/SpeculateAroundPHIs.cpp

   92     Visited.insert(UI);
  140           UnsafeSet.insert(OpI);
  143             UnsafeSet.insert(I);
  149         if (!Visited.insert(OpI).second)
  161       PotentialSpecSet.insert(UI);
  224     if (!IncomingConstantBlocks.insert(PN.getIncomingBlock(i)).second)
  436       UserSet.insert(cast<Instruction>(U.getUser()));
  605                                     SpecSet.insert(I);

lib/Transforms/Scalar/SpeculativeExecution.cpp

  275       NotHoisted.insert(&I);

lib/Transforms/Scalar/StructurizeCFG.cpp

  528     Visited.insert(RN->getEntry());
  806   Visited.insert(Node->getEntry());

lib/Transforms/Scalar/TailRecursionElimination.cpp

  113         if (!Visited.insert(&U).second)
  152           EscapePoints.insert(I);
  162         EscapePoints.insert(I);
  172     AllocaUsers.insert(CS.getInstruction());
  180       EscapePoints.insert(CS.getInstruction());

lib/Transforms/Utils/BasicBlockUtils.cpp

   64       if (Updates && UniqueSuccessors.insert(Succ).second)

lib/Transforms/Utils/BypassSlowDivision.cpp

  218     Visited.insert(I);

lib/Transforms/Utils/CloneFunction.cpp

  222       Visited.insert(Operand);
  225       if (Visited.insert(Unit).second)

lib/Transforms/Utils/CloneModule.cpp

  194         Visited.insert(Operand);
  197         if (Visited.insert(MappedOperand).second)

lib/Transforms/Utils/CodeExtractor.cpp

  102     if (!Visited.insert(Curr).second)
 1434         ExitBlocks.insert(*SI);

lib/Transforms/Utils/Evaluator.cpp

  120   if (!SimpleConstants.insert(C).second)
  534               Invariants.insert(GV);
  717     if (!ExecutedBlocks.insert(NextBB).second)

lib/Transforms/Utils/FunctionComparator.cpp

  858   VisitedBBs.insert(FnLBBs[0]);
  874       if (!VisitedBBs.insert(TermL->getSuccessor(i)).second)
  931   VisitedBBs.insert(BBs[0]);
  942       if (!VisitedBBs.insert(Term->getSuccessor(i)).second)

lib/Transforms/Utils/GlobalStatus.cpp

  150         if (VisitedUsers.insert(I).second)

lib/Transforms/Utils/InlineFunction.cpp

  406   TempMemos.insert(EHPad);
  435     TempMemos.insert(LastUselessPad);
  600       InlinedLPads.insert(II->getLandingPadInst());
 1042           ObjSet.insert(O);
 1462     if (!ClonedBBs.insert(ClonedBB).second) {

lib/Transforms/Utils/Local.cpp

  533     if (!Visited.insert(I).second) {
 1758         DeleteOrSalvage.insert(DII);
 2018   Reachable.insert(BB);
 2169       if (Reachable.insert(Successor).second)

lib/Transforms/Utils/LoopSimplify.cpp

  494         BadPreds.insert(P);

lib/Transforms/Utils/LoopUnrollAndJam.cpp

   62         AftBlocks.insert(BB);
   64         ForeBlocks.insert(BB);

lib/Transforms/Utils/LoopUtils.cpp

  110       if (!Visited.insert(SuccBB).second)

lib/Transforms/Utils/LowerSwitch.cpp

  452     DeleteList.insert(OrigBlock);
  617     DeleteList.insert(OldDefault);

lib/Transforms/Utils/ModuleUtils.cpp

   79       if (InitAsSet.insert(C).second)
   88     if (InitAsSet.insert(C).second)

lib/Transforms/Utils/PredicateInfo.cpp

  758     FunctionPtrs.insert(&*F);

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

  822     if (!LiveInBlocks.insert(BB).second)
  929   if (!Visited.insert(BB).second)
  988   VisitedSuccs.insert(*I);
  994     if (VisitedSuccs.insert(*I).second)

lib/Transforms/Utils/SSAUpdaterBulk.cpp

  109     if (!LiveInBlocks.insert(BB).second)
  142       DefBlocks.insert(Def.first);
  147       UsingBlocks.insert(getUserBB(U));
  177       if (!ProcessedUses.insert(U).second)

lib/Transforms/Utils/SimplifyCFG.cpp

  403   AggressiveInsts.insert(I);
  642     Visited.insert(V);
  651           if (Visited.insert(I->getOperand(1)).second)
  653           if (Visited.insert(I->getOperand(0)).second)
  873       DeadCases.insert(PredCases[i].Value);
 3193         PStoreAddresses.insert(SI->getPointerOperand());
 3200         QStoreAddresses.insert(SI->getPointerOperand());
 5692     if (!Dest->hasAddressTaken() || !Succs.insert(Dest).second) {

lib/Transforms/Utils/SimplifyIndVar.cpp

  812     if (!Simplified.insert(UI).second)

lib/Transforms/Utils/SplitModule.cpp

  202       if (!Visited.insert(*MI).second)
  206       Visited.insert(*MI);

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  524         InstructionsToMove.insert(IM);
  978     InstructionsProcessed->insert(NewChain.front());
 1129     InstructionsProcessed->insert(NewChain.front());

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

  502     InductionCastsToIgnore.insert(*Casts.begin());
  536     AllowedExit.insert(Phi);
  537     AllowedExit.insert(Phi->getIncomingValueForBlock(TheLoop->getLoopLatch()));
  601           AllowedExit.insert(&I);
  618           AllowedExit.insert(RedDes.getLoopExitInstr());
  647           FirstOrderRecurrences.insert(Phi);
  791           AllowedExit.insert(&I);
  898           MaskedOp.insert(LI);
  912       MaskedOp.insert(SI);
  945           SafePointes.insert(Ptr);
  959         SafePointes.insert(LI->getPointerOperand());
 1201     ReductionLiveOuts.insert(Reduction.second.getLoopExitInstr());

lib/Transforms/Vectorize/LoopVectorize.cpp

 3390       Erased.insert(I);
 4421       PossibleNonScalarPtrs.insert(I);
 4725         PossibleNonUniformPtrs.insert(Ptr);
 5349           LoopInvariants.insert(Instr);
 5355         Ends.insert(Instr);
 5454     OpenIntervals.insert(I);
 5538         PredicatedBBsAfterVectorization.insert(BB);
 6048         AddrDefs.insert(PtrDef);
 6060             AddrDefs.insert(InstOp).second)
 6086       ForcedScalars[VF].insert(I);
 6531     DeadInstructions.insert(Cmp);
 6543       DeadInstructions.insert(IndUpdate);
 7058       NeedDef.insert(Branch->getCondition());
 7066     NeedDef.insert(Legal->getPrimaryInduction());
 7068       NeedDef.insert(Reduction.first);
 7069       NeedDef.insert(Reduction.second.getLoopExitInstr());

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3378         LiveValues.insert(cast<Instruction>(&*J));
 3463     if (!ExtractCostCalculated.insert(EU.Scalar).second)
 3776         if (!VisitedBBs.insert(IBB).second) {
 4944     Visited.insert(I);
 6799         if (VisitedInstrs.insert(Op).second)
 6919         VisitedInstrs.insert(*SameTypeIt);
 6954     if (!VisitedInstrs.insert(&*it).second) {

lib/Transforms/Vectorize/VPlan.h

 1228     VPExternalDefs.insert(VPVal);
 1578       DelSet.insert(I.second);

lib/Transforms/Vectorize/VPlanSLP.cpp

  324       Candidates.insert(Ops.second[Lane]);

tools/bugpoint/CrashDebugger.cpp

  397     Visited.insert(BB);
  450     Blocks.insert(cast<BasicBlock>(VMap[BBs[i]]));
  569     Blocks.insert(cast<BasicBlock>(VMap[BB]));
  673     Blocks.insert(cast<BasicBlock>(VMap[BB]));
  766     Instructions.insert(cast<Instruction>(VMap[Insts[i]]));
  904     OldMDNodeOps.insert(NamedMDOps[i]);

tools/clang/include/clang/Lex/ModuleMap.h

  604     AdditionalModMaps[M].insert(ModuleMap);

tools/clang/include/clang/Sema/CodeCompleteConsumer.h

  414     VisitedContexts.insert(Ctx);

tools/clang/include/clang/Sema/Overload.h

 1022       return Functions.insert(Key).second;

tools/clang/include/clang/Sema/Scope.h

  290     DeclsInScope.insert(D);

tools/clang/include/clang/Sema/ScopeInfo.h

  438     Blocks.insert(BD);
  979     NonODRUsedCapturingExprs.insert(CapturingVarExpr);

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

  508     return TrackedConditions.insert(Cond).second;

tools/clang/lib/ARCMigrate/ObjCMT.cpp

 1872         ObjCProtocolDecls.insert(PDecl->getCanonicalDecl());

tools/clang/lib/AST/ASTContext.cpp

 2393     if (!Protocols.insert(

tools/clang/lib/AST/CXXInheritance.cpp

  299             VisitedDependentRecords.insert(BaseRecord);
  774     Bases.insert(Layout.getPrimaryBase());

tools/clang/lib/AST/DeclCXX.cpp

  176         if (!SeenBaseTypes.insert(B).second)
  285       if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
  305       if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
  599           Bases.insert(Base);
  610     if (M.insert(RD).second)
 1540         HiddenTypesBuffer.insert(ConvType);
 1545         HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
 1600     HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));

tools/clang/lib/AST/ExprConstant.cpp

 2066     if (CheckedTemps.insert(MTE).second) {

tools/clang/lib/AST/OpenMPClause.cpp

  895     Cache.insert(VD);

tools/clang/lib/AST/RecordLayoutBuilder.cpp

 1020       IndirectPrimaryBases.insert(PrimaryBase);
 1024       VisitedVirtualBases.insert(PrimaryBase);
 1145           if (!VisitedVirtualBases.insert(BaseDecl).second)
 2964         HasVtordispSet.insert(BaseDecl);
 2976         HasVtordispSet.insert(bi.first);
 2997       Work.insert(MD);
 3003       BasesWithOverriddenMethods.insert(MD->getParent());
 3015       HasVtordispSet.insert(BaseDecl);

tools/clang/lib/AST/VTTBuilder.cpp

  111       if (!VBases.insert(BaseDecl).second)
  163       if (!VBases.insert(BaseDecl).second)

tools/clang/lib/AST/VTableBuilder.cpp

  391       if (!VisitedVirtualBases.insert(BaseDecl).second) {
  748     if (B.isVirtual() && VisitedVirtualBases.insert(BaseDecl).second) {
 1096     return OverriddenMethods.insert(MD).second;
 1805         PrimaryVirtualBases.insert(PrimaryBase);
 1816       if (!VBases.insert(BaseDecl).second)
 1846         VBases.insert(BaseDecl).second) {
 2635       return VisitedOverriddenMethods.insert(OverriddenMD).second;
 3310       VBasesSeen.insert(Base);
 3315       VBasesSeen.insert(VB.getType()->getAsCXXRecordDecl());

tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp

  379     CompatibleAliases[InterfaceDecl].insert(CAD);
 1014   Matchers.AllCallbacks.insert(Action);
 1020   Matchers.AllCallbacks.insert(Action);
 1026   Matchers.AllCallbacks.insert(Action);
 1032   Matchers.AllCallbacks.insert(Action);
 1038   Matchers.AllCallbacks.insert(Action);
 1044   Matchers.AllCallbacks.insert(Action);
 1050   Matchers.AllCallbacks.insert(Action);

tools/clang/lib/Analysis/AnalysisDeclContext.cpp

  602         if (Visited.insert(VD).second)
  610     IgnoredContexts.insert(BR->getBlockDecl());

tools/clang/lib/Analysis/CFG.cpp

  352     ScopesOfL.insert(L.Scope);
 4915     auto IteratorAndFlag = Visited.insert(B);
 5847     Visited.insert(Blk);

tools/clang/lib/CodeGen/CGBuiltin.cpp

 1491   if (!Seen.insert(Record).second)

tools/clang/lib/CodeGen/CGCall.cpp

  763   bool inserted = FunctionsBeingProcessed.insert(FI).second;
 1543   bool Inserted = FunctionsBeingProcessed.insert(&FI).second;

tools/clang/lib/CodeGen/CGClass.cpp

 2549       if (!VBases.insert(BaseDecl).second)

tools/clang/lib/CodeGen/CGCleanup.cpp

  346     if (!CasesAdded.insert(Fixup.Destination).second)
  403     if (!ModifiedOptimisticBlocks.insert(BranchBB).second)

tools/clang/lib/CodeGen/CGCleanup.h

  375     if (ExtInfo.Branches.insert(Block).second)
  410     return getExtInfo().Branches.insert(Block).second;

tools/clang/lib/CodeGen/CGDebugInfo.cpp

 2506         PropertySet.insert(PD->getIdentifier());
 2512       if (!PropertySet.insert(PD->getIdentifier()).second)

tools/clang/lib/CodeGen/CGException.cpp

  846       if (catchTypes.insert(handler.Type.RTTI).second)

tools/clang/lib/CodeGen/CGObjCGNU.cpp

 3298         if (!PropertySet.insert(PD->getIdentifier()).second)
 3309         PropertySet.insert(PD->getIdentifier());
 3322     if (!PropertySet.insert(PD->getIdentifier()).second)

tools/clang/lib/CodeGen/CGObjCMac.cpp

 3224     if (!PropertySet.insert(PD->getIdentifier()).second)
 3264         PropertySet.insert(PD->getIdentifier());
 3273     if (!PropertySet.insert(PD->getIdentifier()).second)

tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

  350           EscapedParameters.insert(VD);

tools/clang/lib/CodeGen/CodeGenModule.cpp

  288     if (!Visited.insert(GIS2).second)
 1960   if (Mod->Parent && Visited.insert(Mod->Parent).second) {
 1966     if (Visited.insert(Mod->Imports[I - 1]).second)
 2024     if (Visited.insert(M).second)
 2042       if (Visited.insert(SM).second) {
 2061     if (Visited.insert(M).second)
 2410   WeakRefReferences.insert(F);
 5412     Visited.insert(Import->getImportedModule());
 5417       if (!EmittedModuleInitializers.insert(Mod).second)
 5432         if (Visited.insert(*Sub).second)

tools/clang/lib/CodeGen/CodeGenTypes.cpp

  120   if (!AlreadyChecked.insert(RD).second)
  339   if (!RecordsBeingLaidOut.insert(Ty).second) {
  665       RecordsWithOpaqueMemberPointers.insert(MPTy->getClass());
  739   bool InsertResult = RecordsBeingLaidOut.insert(Key).second;

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

 3607     if (!Bases.VirtualBases.insert(BaseDecl).second) {
 3617     if (!Bases.NonVirtualBases.insert(BaseDecl).second) {

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 1737   if (DeferredVFTables.insert(RD).second) {
 3546         !VirtualBases.insert(Class->RD).second) {
 3550     if (!UniqueBases.insert(Class->RD).second)
 3551       AmbiguousBases.insert(Class->RD);

tools/clang/lib/Format/TokenAnnotator.cpp

  925         NonTemplateLess.insert(Tok);

tools/clang/lib/Frontend/InitHeaderSearch.cpp

  482       if (SeenDirs.insert(CurEntry.getDir()).second)
  486       if (SeenFrameworkDirs.insert(CurEntry.getFrameworkDir()).second)
  491       if (SeenHeaderMaps.insert(CurEntry.getHeaderMap()).second)

tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

 1393     ObjCWrittenInterfaces.insert(ClassDecl->getCanonicalDecl());
 3592   ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
 3750       GlobalDefinedTags.insert(TD);
 3945   if (!ObjCSynthesizedStructs.insert(CDecl).second)
 4344           BlockByCopyDeclsPtrSet.insert(VD);
 4351         BlockByRefDeclsPtrSet.insert(VD);
 4359         ImportedBlockDecls.insert(VD);
 4480         InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
 4496           ImportedLocalExternalDecls.insert(Var);
 5166           BlockByCopyDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
 5174           BlockByRefDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
 5183         ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
 5215         BlockByCopyDeclsPtrSet.insert(VD);
 5221         BlockByRefDeclsPtrSet.insert(VD);
 5230         ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl());
 5462     InnerContexts.insert(BE->getBlockDecl());
 6981   if (!ObjCSynthesizedProtocols.insert(PDecl->getCanonicalDecl()).second)

tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp

 1211     ObjCForwardDecls.insert(ClassDecl->getCanonicalDecl());
 3052   ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
 3211   if (!ObjCSynthesizedStructs.insert(CDecl).second)
 3556         BlockByCopyDeclsPtrSet.insert(VD);
 3560         BlockByRefDeclsPtrSet.insert(VD);
 3568         ImportedBlockDecls.insert(VD);
 3667         InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
 3683           ImportedLocalExternalDecls.insert(Var);
 4320           BlockByCopyDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
 4328           BlockByRefDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
 4337         ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
 4368         BlockByCopyDeclsPtrSet.insert(VD);
 4374         BlockByRefDeclsPtrSet.insert(VD);
 4383         ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl());
 4584     InnerContexts.insert(BE->getBlockDecl());
 5213   if (!ObjCSynthesizedProtocols.insert(PDecl->getCanonicalDecl()).second)

tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp

 1055         ParsedFileCache.insert(FE);

tools/clang/lib/Lex/ModuleMap.cpp

 2220       UsesRequiresExcludedHack.insert(ActiveModule);

tools/clang/lib/Lex/PPDirectives.cpp

 2795     WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());

tools/clang/lib/Lex/PPLexerChange.cpp

  753     if (!VisitedMacros.insert(II).second)

tools/clang/lib/Parse/ParseDecl.cpp

 6518     if (!ParamsSoFar.insert(ParmII).second) {

tools/clang/lib/Sema/AnalysisBasedWarnings.cpp

  233         if (!Visited.insert(SuccBlock).second)
 1058       ReachableBlocks.insert(&Cfg->getEntry());
 1066         if (L && isa<SwitchCase>(L) && ReachableBlocks.insert(B).second)
 1076           if (*I && ReachableBlocks.insert(*I).second)
 1161         FallthroughStmts.insert(S);

tools/clang/lib/Sema/Sema.cpp

 1114     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)

tools/clang/lib/Sema/SemaChecking.cpp

 7920         Results.insert(FK);
14297     UnmatchedFields.insert(Field2);

tools/clang/lib/Sema/SemaCodeComplete.cpp

  336   void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
 1139   if (!AllDeclsFound.insert(CanonDecl).second)
 1259   if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
 4490     if (!AddedProperties.insert(P->getIdentifier()).second)
 4583       if (!AddedProperties.insert(Name).second)
 5005         Enumerators.Seen.insert(Enumerator);
 5580       InitializedBases.insert(Context.getCanonicalType(
 5583       InitializedFields.insert(
 5660     if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
 5675     if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
 5690     if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
 5735     Known.insert(C.Id);
 5745       if (Known.insert(Var->getIdentifier()).second)
 6209       if (!Selectors.insert(M->getSelector()).second)
 6963         if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
 7229       CategoryNames.insert(Cat->getIdentifier());
 7237       if (CategoryNames.insert(Category->getIdentifier()).second)
 7274           CategoryNames.insert(Cat->getIdentifier()).second)
 7590       KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
 7610     if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
 7629     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 7680     if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
 7702     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 7729     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 7752     if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
 7784     if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
 7814     if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
 7842     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 7863     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 7887     if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
 7918     if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
 7952     if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
 7971     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8001     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8023     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8045     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8067     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8088     if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
 8117     if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
 8138     if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
 8301       KnownSelectors.insert(M->first);

tools/clang/lib/Sema/SemaDecl.cpp

 6648       ParsingInitForAutoVars.insert(NewVD);
 6789       ParsingInitForAutoVars.insert(NewVD);
 7952   TypoCorrectedFunctionDefinitions.insert(F);
 8432     ValidTypes.insert(PT.getTypePtr());
 8463         ValidTypes.insert(Hist->getType().getTypePtr());

tools/clang/lib/Sema/SemaDeclCXX.cpp

  216     if (ExceptionsSeen.insert(Self->Context.getCanonicalType(E)).second)
  847     ParsingInitForAutoVars.insert(BD);
 2224             Inits.insert(FD);
 2611       if (Set.insert(Base).second)
 3812         UninitializedFields.insert(FD);
 3814         UninitializedFields.insert(IFD->getAnonField());
 3820       UninitializedBaseClasses.insert(I.getType().getCanonicalType());
 5001       DirectVBases.insert(&I);
 5430       DirectVirtualBases.insert(RT);
 5572       if (!SeenPureMethods.insert(SO->second.front().Method).second)
 5583   PureVirtualClassDiagSet->insert(RD);
 8255     Methods.insert(MD->getCanonicalDecl());
10931     Bases.insert(Base);
11363     WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D).second;
15865   if (!Current.insert(Canonical).second)

tools/clang/lib/Sema/SemaDeclObjC.cpp

 2816     if (!InsMapSeen.insert(I->getSelector()).second)
 2843     if (!ClsMapSeen.insert(I->getSelector()).second)
 2930     InsMap.insert(Sel);
 2937     ClsMap.insert(Sel);
 2957     InsMap.insert(I->getSelector());
 2968     InsMap.insert(P->getGetterName());
 2970       InsMap.insert(P->getSetterName());
 2988     ClsMap.insert(I->getSelector());

tools/clang/lib/Sema/SemaExceptionSpec.cpp

  579       OldTypes.insert(S.Context.getCanonicalType(I).getUnqualifiedType());
  584         NewTypes.insert(TypePtr);

tools/clang/lib/Sema/SemaExpr.cpp

 4441     LastRecord.PossibleDerefs.insert(E);
 4460       LastRecord.PossibleDerefs.insert(E);
12516       FD->ModifiedNonNullParams.insert(Param);
13663     ExprEvalContexts.back().PossibleDerefs.insert(UO);
16819       SemaRef.MaybeODRUseExprs.insert(E);

tools/clang/lib/Sema/SemaExprCXX.cpp

  824       NewSubobject = VBases.insert(BaseDecl).second;
 6082         if (Found.insert(S.Context.getCanonicalType(E)).second)
 6743     CTypes.insert(Context.getCanonicalType(BaseType));
 6788       if (!CTypes.insert(CBaseType).second) {

tools/clang/lib/Sema/SemaExprMember.cpp

  113       Classes.insert(R->getCanonicalDecl());
  181     Classes.insert(R.getNamingClass()->getCanonicalDecl());
 1750         ExprEvalContexts.back().PossibleDerefs.insert(E);

tools/clang/lib/Sema/SemaLambda.cpp

 1161     if (!CaptureNames.insert(C->Id).second) {

tools/clang/lib/Sema/SemaLookup.cpp

  134       if (!visited.insert(DC).second)
  145       if (!visited.insert(NS).second)
  160           if (SemaRef.isVisible(UD) && visited.insert(NS).second) {
 2061   Visited.insert(StartDC);
 2067     if (S.isVisible(I) && Visited.insert(ND).second)
 2115       if (S.isVisible(I) && Visited.insert(Nom).second)
 2583         TagDecls.insert(TD);
 3629     return !VisitedContexts.insert(Ctx).second;

tools/clang/lib/Sema/SemaModule.cpp

  566       if (!DeferredExportedNamespaces.insert(ND).second)

tools/clang/lib/Sema/SemaObjCProperty.cpp

  113   if (!Known.insert(Proto).second)
 2048     InsMap.insert(I);
 2060           InsMap.insert(I);
 2274       InitSelSet.insert(I->getSelector());

tools/clang/lib/Sema/SemaOverload.cpp

 8215         if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
 8224         if (AddedTypes.insert(NullPtrTy).second) {
 8305         if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
 8319         if (!AddedTypes.insert(CanonType).second ||
 8371           if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
 8520         if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)
 8530         if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
 8564         AddedTypes.insert(S.Context.getCanonicalType(*Ptr));
 8613         if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
 8888         if (!AddedTypes.insert(S.Context.getCanonicalType(*Ptr)).second)
 8899         if (!AddedTypes.insert(S.Context.getCanonicalType(*MemPtr)).second)
 8914           if (!AddedTypes.insert(S.Context.getCanonicalType(*Enum)).second)

tools/clang/lib/Sema/SemaTemplateDeduction.cpp

 1803         if (!Visited.insert(NextT).second)

tools/clang/lib/Sema/SemaTemplateVariadic.cpp

  364     if (Name && NamesKnown.insert(Name).second)

tools/clang/lib/Serialization/ASTReader.cpp

 3930       AdditionalStoredMaps.insert(*F);
 4046       if (Visited.insert(Exported).second)
 4190       LoadedSet.insert(IM.Mod);
10189       DiagnosedOdrMergeFailures.insert(CanonDef);
10241     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11957     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)

tools/clang/lib/Serialization/ASTReaderDecl.cpp

 1155     Reader.PendingDefinitions.insert(ID);
 1216     Reader.PendingDefinitions.insert(PD);
 1235   Reader.CategoriesDeserialized.insert(CD);
 1832     Reader.PendingDefinitions.insert(D);
 2024     Reader.PendingDefinitions.insert(CanonD);
 2471         Reader.PendingDefinitions.insert(DClass);

tools/clang/lib/Serialization/GlobalModuleIndex.cpp

  329       Hits.insert(MF);

tools/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp

   64       reachable.insert(CB);

tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

 2328     Invalidated.insert(MR);
 2330     SuperRegions.insert(MR);
 2333       SuperRegions.insert(MR);

tools/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp

  478         Escaped.insert(VD);
  499         Escaped.insert(VD);

tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

  639   LSF_INSERT("CFDateFormatterCreateStringWithDate");
  640   LSF_INSERT("CFDateFormatterCreateStringWithAbsoluteTime");
  641   LSF_INSERT("CFNumberFormatterCreateStringWithNumber");

tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp

  210   AllocFunctions.insert(&C.Idents.get("alloca"));
  211   AllocFunctions.insert(&C.Idents.get("malloc"));
  212   AllocFunctions.insert(&C.Idents.get("realloc"));
  213   AllocFunctions.insert(&C.Idents.get("calloc"));
  214   AllocFunctions.insert(&C.Idents.get("valloc"));

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

 1195       WhitelistedSymbols.insert(SR->getSymbol());

tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedPointee.cpp

  241   VisitedRegions.insert(R);
  253     if (!VisitedRegions.insert(R).second)

tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp

  114       VforkWhitelist.insert(&AC.Idents.get(*id));

tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp

 2236   InterestingLocationContexts.insert(LC);
 2511     RemainingNodes.insert(NewNode);

tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

  633     FramesModifyingCalculated.insert(N->getLocationContext()->getStackFrame());
  638         auto p = FramesModifyingRegion.insert(SCtx);
 1796   if (!VisitedBlocks.insert(NB).second)

tools/clang/lib/StaticAnalyzer/Core/Environment.cpp

  224           FoundContexts.insert(LCI);

tools/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

  965   AlreadyProcessedTokens.insert(IDInfo);

tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp

  765     if (C && !Visited.insert(C).second)

tools/clang/lib/Tooling/Core/Replacement.cpp

  620     else if (ProcessedFileEntries.insert(*FE).second)

tools/clang/tools/clang-refactor/ClangRefactor.cpp

  228     if (Visited.insert(&Opt).second)

tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp

  537     UsingDecls.insert(Using);
  541     UsingNamespaceDecls.insert(UsingNamespace);
  545     NamespaceAliasDecls.insert(NamespaceAlias);
  623     ProcessedFuncRefs.insert(FuncRef);
  635     ProcessedFuncRefs.insert(CalleeFuncRef);

tools/clang/tools/extra/clang-move/Move.cpp

  662     UnremovedDeclsInOldHeader.insert(D);

tools/clang/tools/extra/clang-tidy/bugprone/ForwardDeclarationNamespaceCheck.cpp

   77       FriendTypes.insert(Desugared.getTypePtr());

tools/clang/tools/extra/clang-tidy/bugprone/SwappedArgumentsCheck.cpp

   95     UsedArgs.insert(RHSCast);

tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp

  126     Visited.insert(Block);
  246             DeclRefs->insert(DeclRef);
  343         Stmts->insert(TheStmt);
  349           DeclRefs->insert(TheDeclRef);

tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

  408       FieldsToInit.insert(F);
  435                [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
  464     if (!F->getParent()->isUnion() || UnionsSeen.insert(F->getParent()).second)
  465       FieldsToFix.insert(F);
  496         BasesToInit.insert(BaseClassDecl);

tools/clang/tools/extra/clang-tidy/misc/UnusedUsingDeclsCheck.cpp

   99         Context.UsingTargetDecls.insert(TargetDecl);

tools/clang/tools/extra/clang-tidy/utils/DeclRefExprUtils.cpp

   37     Nodes.insert(Match.getNodeAs<Node>(ID));

tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.cpp

   19   ThrownExceptions.insert(ExceptionType);
  119     CallStack.insert(Func);
  185           CaughtExceptions.insert(CaughtType);

tools/clang/tools/extra/clangd/XRefs.cpp

  360       CanonicalTargets.insert(D->getCanonicalDecl());
 1138     if (!RPSet.insert(Pattern).second) {

tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp

  185         ImplicitGroups.insert(&GI);

tools/lld/COFF/SymbolTable.cpp

  386     undefs.insert(sym);
  449     undefs.insert(sym);

tools/lld/ELF/Relocations.cpp

  491       ret.insert(alias);

tools/lldb/include/lldb/Utility/SharedCluster.h

   60     m_objects.insert(new_object);

tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 3332     m_decl_to_die[decl].insert(die.GetDIE());
 3340     m_decl_to_die[decl].insert(die.GetDIE());
 3403   m_decl_to_die[decl].insert(die.GetDIE());

tools/lldb/source/Target/StackFrameList.cpp

  309       if (!visited_nodes.insert(&callee).second) {

tools/polly/lib/Analysis/DependenceInfo.cpp

  131           ReductionArrays.insert(MA->getScopArrayInfo());

tools/polly/lib/Analysis/ScopBuilder.cpp

  666   FinishedExitBlocks.insert(ExitBB);
  710       PropagatedRegions.insert(PredR);
 3442       ReadWriteArrays.insert(Array);
 3445       ReadOnlyArrays.insert(Array);

tools/polly/lib/Analysis/ScopDetection.cpp

  510     if (PtrVals.insert(BasePtrVal).second) {

tools/polly/lib/Analysis/ScopDetectionDiagnostic.cpp

  120     if (!Seen.insert(BB).second)

tools/polly/lib/CodeGen/IRBuilder.cpp

  255   InterIterationAliasFreeBasePtrs.insert(BasePtr);

tools/polly/lib/CodeGen/IslAst.cpp

  246       NodeInfo->BrokenReductions.insert(MaRedPair.first);

tools/polly/lib/CodeGen/IslNodeBuilder.cpp

  366     Inserted.insert(I.second);

tools/polly/lib/Transform/DeLICM.cpp

 1060       Closed.insert(SAI);

tools/polly/lib/Transform/MaximalStaticExpansion.cpp

  174     Writes.insert(S.getValueDef(SAI));
  176       Reads.insert(MA);
  248         Writes.insert(MA);
  298         Reads.insert(MA);
  420     Writes.insert(MA);

tools/polly/lib/Transform/Simplify.cpp

  359           TouchedAccesses.insert(MA);

tools/polly/lib/Transform/ZoneAlgo.cpp

  519     Visited.insert(Cur);
 1006         RecursivePHIs.insert(PHI);

unittests/ADT/DepthFirstIteratorTest.cpp

   25     return S.insert(Item);

unittests/ADT/SmallPtrSetTest.cpp

   27   (s2 = s1).insert(&buf[2]);
   30   (s2 = static_cast<SmallPtrSet<int *, 4> &>(s2)).insert(&buf[3]);
   59   s.insert(&buf[0]);
   60   s.insert(&buf[1]);
   61   s.insert(&buf[2]);
   62   s.insert(&buf[3]);
   72   s.insert(&buf[4]);
   73   s.insert(&buf[5]);
   74   s.insert(&buf[6]);
   75   s.insert(&buf[7]);
   96   for(i=0; i<128; ++i) s.insert(&buf[i%8]); // test repeated entires
  110   s1.insert(&buf[0]);
  111   s1.insert(&buf[1]);
  112   s1.insert(&buf[2]);
  113   s1.insert(&buf[3]);
  149   s3.insert(&buf[4]);
  150   s3.insert(&buf[5]);
  151   s3.insert(&buf[6]);
  152   s3.insert(&buf[7]);
  173   a.insert(&buf[0]);
  174   a.insert(&buf[1]);
  175   b.insert(&buf[2]);
  201   b.insert(&buf[3]);
  228   a.insert(&buf[4]);
  229   a.insert(&buf[5]);
  230   a.insert(&buf[6]);
  248   S.insert(&buf[0]);
  249   S.insert(&buf[1]);
  250   S.insert(&buf[2]);
  289     EXPECT_EQ(&I, *S.insert(&I).first);
  313   IntSet.insert(B);
  328   IntSet.insert(Pair);

unittests/Analysis/CFGTest.cpp

   65         ExclusionSet.insert(&*I);

unittests/Analysis/ScalarEvolutionTest.cpp

  539     Loops.insert(S0->getLoop());
  546     Loops.insert(S1->getLoop());
  603         LoopSets.back().insert(L0);
  605         LoopSets.back().insert(L1);
  607         LoopSets.back().insert(L2);

unittests/IR/DominatorTreeTest.cpp

  650         DefBlocks.insert(B);

unittests/IR/PassBuilderCallbacksTest.cpp

  196     UR.InvalidatedSCCs.insert(&C);

unittests/Transforms/Utils/CloningTest.cpp

   40     Orig.insert(V1);
   41     Clones.insert(V2);

utils/TableGen/AsmMatcherEmitter.cpp

  283         if (Visited.insert(Super).second)
  950       SingletonRegisters.insert(Reg);

utils/TableGen/CodeGenRegisters.cpp

  300         Orphans.insert(SR.second);

utils/TableGen/CodeGenRegisters.h

  409       SuperRegClasses[SubIdx].insert(SuperRC);

utils/TableGen/CodeGenSchedule.cpp

  567   if (!RWSet.insert(RWDef).second)

utils/TableGen/GlobalISelEmitter.cpp

 2949   MutatableInsns.insert(Matchers.back().get());

utils/TableGen/RegisterBankEmitter.cpp

  178   VisitedRCs.insert(RC);

utils/TableGen/SubtargetEmitter.cpp

  387     if (!ItinsDefSet.insert(ProcModel.ItinsDef).second)
  566     if (!ItinsDefSet.insert(ItinsDef).second)