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

References

gen/lib/Target/AArch64/AArch64GenAsmMatcher.inc

27439   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/AMDGPU/AMDGPUGenAsmMatcher.inc

23964   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/ARM/ARMGenAsmMatcher.inc

15097   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/AVR/AVRGenAsmMatcher.inc

 1292   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/BPF/BPFGenAsmMatcher.inc

  937   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/Hexagon/HexagonGenAsmMatcher.inc

10283   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/Lanai/LanaiGenAsmMatcher.inc

 1076   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/MSP430/MSP430GenAsmMatcher.inc

 1134   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/Mips/MipsGenAsmMatcher.inc

 8110   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/PowerPC/PPCGenAsmMatcher.inc

 7039   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/RISCV/RISCVGenAsmMatcher.inc

 2428   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/Sparc/SparcGenAsmMatcher.inc

 4172   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/SystemZ/SystemZGenAsmMatcher.inc

 5367   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/WebAssembly/WebAssemblyGenAsmMatcher.inc

 1136   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/lib/Target/X86/X86GenAsmMatcher.inc

36967   std::distance(MnemonicRange.first, MnemonicRange.second) <<

gen/tools/clang/include/clang/AST/StmtDataCollectors.inc

   95     auto numDecls = std::distance(S->decl_begin(), S->decl_end());

include/llvm/ADT/DenseMap.h

  714     init(std::distance(I, E));
  893     init(NextPowerOf2(std::distance(I, E)));

include/llvm/ADT/Hashing.h

  450   const size_t length = std::distance(s_begin, s_end);

include/llvm/ADT/STLExtras.h

 1151     -> decltype(std::distance(Range.begin(), Range.end())) {
 1152   return std::distance(Range.begin(), Range.end());

include/llvm/ADT/SetVector.h

  180     std::advance(NI, std::distance<iterator>(NI, I));

include/llvm/ADT/SmallVector.h

  388     size_type NumInputs = std::distance(in_start, in_end);
  593     size_t NumToInsert = std::distance(From, To);

include/llvm/ADT/StringExtras.h

  319   size_t Len = (std::distance(Begin, End) - 1) * Separator.size();

include/llvm/ADT/simple_ilist.h

  135     return std::distance(begin(), end());

include/llvm/CodeGen/SelectionDAGNodes.h

  751   size_t use_size() const { return std::distance(use_begin(), use_end()); }

include/llvm/DebugInfo/GSYM/GsymReader.h

  186     return std::distance(Begin, Iter);

include/llvm/IR/CFG.h

  122   return std::distance(pred_begin(BB), pred_end(BB));
  257   return std::distance(succ_begin(I), succ_end(I));
  282   return std::distance(succ_begin(BB), succ_end(BB));

include/llvm/IR/CallSite.h

  268     return std::distance(data_operands_begin(), data_operands_end());

include/llvm/IR/InstrTypes.h

 1185     return std::distance(data_operands_begin(), data_operands_end());
 1740     return std::distance(bundle_op_info_begin(), bundle_op_info_end());

include/llvm/IR/PredIteratorCache.h

   61     return BlockToPredCountMap[BB] = std::distance(pred_begin(BB), pred_end(BB));

include/llvm/Support/Allocator.h

  348       TotalMemory += computeSlabSize(std::distance(Slabs.begin(), I));
  420           computeSlabSize(std::distance(Slabs.begin(), I));
  477           std::distance(Allocator.Slabs.begin(), I));

include/llvm/Support/BinaryItemStream.h

   93     size_t Idx = std::distance(ItemEndOffsets.begin(), Iter);

include/llvm/Support/BranchProbability.h

  237     BranchProbability BP(1, std::distance(Begin, End));

include/llvm/Support/GenericDomTree.h

  775     assert(std::distance(GraphT::child_begin(NewBB),

include/llvm/Support/GraphWriter.h

  246           (unsigned)std::distance(GTraits::child_begin(TargetNode), TargetIt);

include/llvm/Support/Parallel.h

   86   RandomAccessIterator Mid = Start + (std::distance(Start, End) / 2);
   98   if (std::distance(Start, End) < detail::MinParallelSize || Depth == 0) {
  125                       llvm::Log2_64(std::distance(Start, End)) + 1);
  134   ptrdiff_t TaskSize = std::distance(Begin, End) / 1024;
  139   while (TaskSize < std::distance(Begin, End)) {

lib/Analysis/AliasAnalysis.cpp

  215         unsigned ArgIdx = std::distance(Call->arg_begin(), AI);
  297       unsigned Call2ArgIdx = std::distance(Call2->arg_begin(), I);
  348       unsigned Call1ArgIdx = std::distance(Call1->arg_begin(), I);

lib/Analysis/BranchProbabilityInfo.cpp

  913   uint32_t succ_num = std::distance(succ_begin(Src), succ_end(Src));

lib/Analysis/ScalarEvolutionExpander.cpp

 1296   PHINode *PN = Builder.CreatePHI(ExpandTy, std::distance(HPB, HPE),
 1565     CanonicalIV = PHINode::Create(Ty, std::distance(HPB, HPE), "indvar",

lib/CodeGen/AsmPrinter/AccelTable.cpp

   44   UniqueHashCount = std::distance(Uniques.begin(), P);

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

  939   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
 1398     size_t Index = std::distance(EB, EI);

lib/CodeGen/DFAPacketizer.cpp

  236                              std::distance(BeginItr, EndItr));

lib/CodeGen/GlobalISel/RegisterBankInfo.cpp

  344   Res = std::make_unique<ValueMapping[]>(std::distance(Begin, End));

lib/CodeGen/LiveDebugVariables.cpp

 1202     unsigned NewLocNo = std::distance(NewLocations.begin(), InsertResult.first);
 1215       unsigned NewLocNo = std::distance(&*NewLocations.begin(), &Pair);

lib/CodeGen/MIRPrinter.cpp

  480         std::distance(CallI->getParent()->instr_begin(), CallI);

lib/CodeGen/MachineBasicBlock.cpp

 1364   const size_t index = std::distance(Successors.begin(), I);
 1373   const size_t index = std::distance(Successors.begin(), I);

lib/CodeGen/MachineLoopUtils.cpp

   21   unsigned Offset = std::distance(PB->instr_begin(), MachineBasicBlock::instr_iterator(MI));

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

17424     unsigned Idx = std::distance(

lib/CodeGen/SelectionDAG/FastISel.cpp

  546   assert(I.isValid() && E.isValid() && std::distance(I, E) > 0 &&

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

 1446       unsigned NumFastIselRemaining = std::distance(Begin, End);
 1535           unsigned RemainingNow = std::distance(Begin, BI);

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

  251   const int Offset = std::distance(StatepointSlots.begin(), SlotIt);

lib/DebugInfo/PDB/Native/GSIStreamBuilder.cpp

  271     ptrdiff_t Idx = std::distance(Records.data(), Sym.first);

lib/IR/BasicBlock.cpp

  113   return std::distance(instructionsWithoutDebug().begin(),

lib/IR/Function.cpp

  212     NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),

lib/IR/Value.cpp

  161   return (unsigned)std::distance(use_begin(), use_end());

lib/MCA/HardwareUnits/RegisterFile.cpp

  385     Writes.resize(std::distance(Writes.begin(), It));

lib/MCA/Stages/EntryStage.cpp

   66   NumRetired = std::distance(Instructions.begin(), It);

lib/MCA/Stages/InstructionTables.cpp

   32     unsigned Index = std::distance(

lib/ObjectYAML/MinidumpEmitter.cpp

   86   size_t Num = std::distance(Range.begin(), Range.end());

lib/ProfileData/Coverage/CoverageMapping.cpp

  477             std::distance(ActiveRegions.begin(), CompletedRegions);
  561     return Regions.drop_back(std::distance(++Active, End));

lib/Support/CodeGenCoverage.cpp

   64       if (std::distance(CurPtr, Buffer.getBufferEnd()) < 8)

lib/Target/AMDGPU/GCNRegPressure.h

  205   Indexes.reserve(std::distance(R.begin(), R.end()));

lib/Target/AMDGPU/GCNSchedStrategy.cpp

  564       unsigned NumRegionInstrs = std::distance(begin(), end());

lib/Target/AMDGPU/SIInsertWaitcnts.cpp

 1496       unsigned Idx = std::distance(&*BlockInfos.begin(), &BI);

lib/Target/AMDGPU/SILowerSGPRSpills.cpp

  108         assert(std::distance(MIS.begin(), I) == 1);

lib/Target/Hexagon/BitTracker.cpp

  788     unsigned D = std::distance(I, E);

lib/Target/Hexagon/HexagonCommonGEP.cpp

  663   Nodes.resize(std::distance(Nodes.begin(), NewE));
  744       if (std::distance(FirstUse, BEnd) < std::distance(It, BEnd))
  744       if (std::distance(FirstUse, BEnd) < std::distance(It, BEnd))

lib/Target/Hexagon/HexagonConstExtenders.cpp

  199         Pos = std::distance(B->begin(), It);
  745       return std::distance(F.begin(), ThisB->getIterator()) <
  746              std::distance(F.begin(), OtherB->getIterator());

lib/Target/Hexagon/HexagonGenInsert.cpp

  787     return std::distance(FromI, ToI);
  788   unsigned D1 = std::distance(TB->begin(), ToI);
  790   unsigned D3 = std::distance(FromI, FB->end());

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  625   if (std::distance(PI, PE) != 2)

lib/Target/Hexagon/HexagonStoreWidening.cpp

  310   if (std::distance(Begin, End) <= 1)
  552     assert(distance(I, E)+1 >= int(OG.size()) && "Too many elements");

lib/Target/Hexagon/RDFLiveness.cpp

  263   RDefs.resize(std::distance(RDefs.begin(), llvm::remove_if(RDefs, DeadP)));

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

  118       LLVM_DEBUG(dbgs() << std::distance(First, I) << " is a match (";

lib/Transforms/IPO/FunctionAttrs.cpp

  381         std::distance(const_cast<const Use *>(CS.arg_begin()), U);
  512       unsigned UseIndex = std::distance(CS.arg_begin(), U);

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 1615         unsigned PredCount = std::distance(pred_begin(ExitBlock),

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  812             std::distance(pred_begin(&BB), pred_end(&BB));

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  228       return std::distance(top_down_ptr_begin(), top_down_ptr_end());
  250       return std::distance(bottom_up_ptr_begin(), bottom_up_ptr_end());

lib/Transforms/Scalar/ConstantHoisting.cpp

  556   if (!OptForSize || std::distance(S,E) > 100) {

lib/Transforms/Scalar/JumpThreading.cpp

 1490   PHINode *PN = PHINode::Create(LoadI->getType(), std::distance(PB, PE), "",

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1571       std::distance(InstWithoutDebugIt.begin(), InstWithoutDebugIt.end());

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

  303   int Size1 = std::distance(InstsNoDbg.begin(), InstsNoDbg.end());

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1279     size_t Index = std::distance(LiveVec.begin(), ValIt);

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 2473                                : std::distance(LI.begin(), LI.end()));

lib/Transforms/Scalar/SimplifyCFGPass.cpp

  126                                     std::distance(PB, PE), "merge",

lib/Transforms/Scalar/TailRecursionElimination.cpp

  634         std::distance(PB, PE) + 1, "accumulator.tr", &OldEntry->front());

lib/Transforms/Utils/InlineFunction.cpp

 2224   if (Returns.size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {

lib/Transforms/Utils/SimplifyCFG.cpp

 3246           Type::getInt1Ty(BB->getContext()), std::distance(PB, PE),

lib/Transforms/Utils/SplitModule.cpp

  180           std::make_pair(std::distance(GVtoClusterMap.member_begin(I),

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2127             std::distance(Entry->ReuseShuffleIndices.begin(),
 3639               std::distance(E->ReuseShuffleIndices.begin(),

projects/compiler-rt/lib/xray/xray_utils.cpp

  138   auto TotalBytes = std::distance(Begin, End);

projects/compiler-rt/lib/xray/xray_x86_64.cpp

   34   auto BytesToRead = std::distance(Begin, End);

tools/bugpoint/ExtractFunction.cpp

   94       RFI, std::distance(PF->getParent()->begin(), Module::const_iterator(PF)));
   97   std::advance(RBI, std::distance(PF->begin(), Function::const_iterator(PBB)));
  100   std::advance(RI, std::distance(PBB->begin(), BasicBlock::const_iterator(I)));

tools/clang/include/clang/AST/ASTVector.h

  185     size_type NumInputs = std::distance(in_start, in_end);
  298     size_t NumToInsert = std::distance(From, To);

tools/clang/include/clang/AST/DeclCXX.h

 3388     return std::distance(shadow_begin(), shadow_end());

tools/clang/include/clang/AST/DeclObjC.h

 1476     return std::distance(ivar_begin(), ivar_end());
 2405     return std::distance(ivar_begin(), ivar_end());
 2713     return std::distance(ivar_begin(), ivar_end());

tools/clang/include/clang/ASTMatchers/ASTMatchers.h

 3736   return std::distance(Node.decl_begin(), Node.decl_end()) == (ptrdiff_t)N;
 3760   const unsigned NumDecls = std::distance(Node.decl_begin(), Node.decl_end());

tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h

 1608     return std::distance(Predecessors.cbegin(), I);

tools/clang/lib/AST/ComparisonCategories.cpp

   30   if (std::distance(Record->field_begin(), Record->field_end()) != 1 ||

tools/clang/lib/AST/ExprConstant.cpp

 4240                    std::distance(RD->field_begin(), RD->field_end()));
 5593                      std::distance(RD->field_begin(), RD->field_end()));
 6401                       std::distance(RD->field_begin(), RD->field_end()));
 8798                    std::distance(RD->field_begin(), RD->field_end()));
 8936                      std::distance(RD->field_begin(), RD->field_end()));
 9122       std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
 9124   assert(NumFields == (size_t)std::distance(E->capture_init_begin(),

tools/clang/lib/CodeGen/CGDebugInfo.cpp

  459     if (std::distance(llvm::sys::path::begin(CurDir), CurDirIt) == 1) {

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

 5097     unsigned NumMethods = std::distance(PDecl->instmeth_begin(),
 5131   unsigned NumMethods = std::distance(PDecl->classmeth_begin(),
 5751   unsigned NumMethods = std::distance(MethodBegin, MethodEnd);

tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp

  866   return std::distance(diag_begin, diag_end);

tools/clang/lib/Lex/PreprocessingRecord.cpp

  101   int Pos = std::distance(iterator(this, 0), PPEI);

tools/clang/lib/Sema/SemaChecking.cpp

12315         unsigned ParamNo = std::distance(FD->param_begin(), ParamIter);

tools/clang/lib/Sema/SemaDeclCXX.cpp

 9589   if (std::distance(FIt, FEnd) != 1 ||

tools/clang/lib/Sema/SemaOpenMP.cpp

 1351                 D, std::distance(ParentIterTarget, End),

tools/clang/lib/Sema/SemaOverload.cpp

 5907       (std::distance(Conversions.begin(), Conversions.end()) > 1);
 9818     unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;

tools/clang/lib/Serialization/ASTReader.cpp

 9044   if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {

tools/clang/lib/Serialization/ASTWriterStmt.cpp

  412   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));

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

   72       std::distance(ED->enumerator_begin(), ED->enumerator_end()));

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

 1507       std::distance(ReferencedBlockVars.begin(), ReferencedBlockVars.end());

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

  138   auto Index = static_cast<unsigned>(std::distance(Artifacts.begin(), I));

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

  202             << static_cast<int>(std::distance(BeginCurrent, EndCurrent));

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

   54   return std::distance(EnumDec->enumerator_begin(), EnumDec->enumerator_end());

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

   22   return std::distance(Node.method_begin(), Node.method_end()) != 0;

tools/clang/tools/extra/clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

   31   if (std::distance(Decls.begin(), Decls.end()) != 1)

tools/clang/tools/extra/clang-tidy/readability/IsolateDeclarationCheck.cpp

  111   std::size_t DeclCount = std::distance(DS->decl_begin(), DS->decl_end());

tools/clang/tools/extra/clangd/index/CanonicalIncludes.cpp

  763     return std::distance(
  769            return std::distance(llvm::sys::path::begin(

tools/clang/unittests/AST/ASTImporterTest.cpp

 5268   unsigned ToLSize = std::distance(ToL->decls().begin(), ToL->decls().end());
 5270       std::distance(FromL->decls().begin(), FromL->decls().end());
 5287   unsigned ToLSize = std::distance(ToL->decls().begin(), ToL->decls().end());
 5289       std::distance(FromL->decls().begin(), FromL->decls().end());

tools/lldb/include/lldb/Utility/RangeMap.h

  273         return std::distance(begin, pos);
  277           return std::distance(begin, pos);
  508         return std::distance(begin, pos);
  512           return std::distance(begin, pos);
  718       return std::distance(m_entries.begin(), entry);

tools/lldb/source/Core/ModuleList.cpp

  588                 (uint32_t)std::distance(begin, pos),
  661         return std::distance(begin, pos);

tools/lldb/source/Core/Section.cpp

  452       return std::distance(begin, sect_iter);

tools/lldb/source/DataFormatters/StringPrinter.cpp

  137   if (1u + std::distance(buffer, buffer_end) < utf8_encoded_len) {

tools/lldb/source/DataFormatters/TypeCategoryMap.cpp

  107       pos = std::distance(sorted_categories.begin(), iter);

tools/lldb/source/Interpreter/Options.cpp

  915   return std::distance(original.begin(), FindOriginalIter(arg, original));

tools/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

  236     bool is_system_module = (std::distance(path_begin, path_end) >=
  237                              std::distance(sysroot_begin, sysroot_end)) &&

tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

  733   return std::distance(m_section_headers.begin(), I);
  737   return std::distance(m_section_headers.begin(), I);

tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

  654       return std::distance(m_set_names.begin(), pos);
  670       return std::distance(m_regs.begin(), pos);

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

   23       return std::distance(beg, pos);

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

  131   uint32_t idx = std::distance(m_units.begin(), pos);

tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 1113           1 + std::distance(cci->m_file_list.begin(), fn_iter);

tools/lldb/source/Symbol/ClangASTContext.cpp

 4546           num_functions = std::distance(cxx_record_decl->method_begin(),
 4562           num_functions = std::distance(class_interface_decl->meth_begin(),
 4578             num_functions = std::distance(class_interface_decl->meth_begin(),
 4638               static_cast<size_t>(std::distance(method_iter, method_end))) {
 4675               static_cast<size_t>(std::distance(method_iter, method_end))) {
 4705                 static_cast<size_t>(std::distance(method_iter, method_end))) {

tools/lldb/source/Symbol/LineTable.cpp

  231           uint32_t match_idx = std::distance(begin_pos, pos);

tools/lldb/source/Symbol/Symtab.cpp

  100         pos->Dump(s, target, std::distance(begin, pos));
  869         entry.data = std::distance(begin, pos);

tools/lldb/source/Symbol/UnwindPlan.cpp

  543     s.Printf("row[%u]: ", (uint32_t)std::distance(begin, pos));

tools/lldb/source/Symbol/UnwindTable.cpp

  168     s.Printf("[%u] 0x%16.16" PRIx64 "\n", (unsigned)std::distance(begin, pos),

tools/lldb/source/Symbol/VariableList.cpp

   67       return std::distance(m_variables.begin(), pos);
  152       return std::distance(begin, pos);

tools/lldb/source/Target/PathMappingList.cpp

  314       return std::distance(begin, pos);

tools/lldb/source/Target/StackFrameList.cpp

  633       s->Printf("frame #%u", (uint32_t)std::distance(begin, pos));
  782       m_selected_frame_idx = std::distance(begin, pos);

tools/lldb/source/Target/TargetList.cpp

  607       m_selected_target_idx = std::distance(begin, pos);

tools/llvm-diff/DifferenceEngine.cpp

  522   unsigned NL = std::distance(LStart, LE);

tools/llvm-exegesis/lib/Clustering.cpp

  293       assert(std::distance(it, OldCluster.PointIndices.end()) > 0 &&

tools/llvm-lipo/llvm-lipo.cpp

  359           static_cast<size_t>(std::distance(ReplacementArgsRange.begin(),

tools/llvm-mca/Views/BottleneckAnalysis.cpp

  278   unsigned IID = std::distance(Nodes.begin(), It);

tools/llvm-objcopy/ELF/Object.cpp

  200   StringRef S(Line.data() + 1, std::distance(Line.begin() + 1, Iter));
 1832   RemoveSections.reserve(std::distance(Iter, std::end(Sections)));

tools/llvm-objdump/COFFDump.cpp

  623         std::distance(RFs.begin(), &RF) * sizeof(RuntimeFunction);

tools/llvm-pdbutil/ExplainOutputStyle.cpp

  238   uint32_t StreamBlockIndex = std::distance(StreamBlocks.begin(), Iter);

tools/llvm-readobj/ELFDumper.cpp

 2211   unsigned NumSyms = std::distance(Syms.begin(), Syms.end());
 2494   int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry);
 2500   int64_t Offset = std::distance(GotEntries.data(), E) * sizeof(Entry);
 2507   int64_t Offset = std::distance(GotEntries.data(), E);
 2533   int64_t Offset = std::distance(PltEntries.data(), E) * sizeof(Entry);
 2540   int64_t Offset = std::distance(getPltEntries().data(), E);

tools/llvm-xray/xray-extract.cpp

   58   YAMLSleds.reserve(std::distance(Sleds.begin(), Sleds.end()));

tools/polly/lib/Analysis/ScopGraphPrinter.cpp

  214     return std::distance(SD.getSD().begin(), SD.getSD().end()) > 0;

tools/polly/lib/Support/ScopHelper.cpp

  500   return std::distance(R->block_begin(), R->block_end());

unittests/ADT/IntervalMapTest.cpp

  152   EXPECT_EQ(0, std::distance(map.begin(), map.end()));
  194   EXPECT_EQ(1, std::distance(map.begin(), map.end()));
  200   EXPECT_EQ(1, std::distance(map.begin(), map.end()));
  206   EXPECT_EQ(2, std::distance(map.begin(), map.end()));
  225   EXPECT_EQ(3, std::distance(map.begin(), map.end()));
  233   EXPECT_EQ(2, std::distance(map.begin(), map.end()));
  239   EXPECT_EQ(1, std::distance(map.begin(), map.end()));
  246   EXPECT_EQ(3, std::distance(map.begin(), map.end()));
  248   EXPECT_EQ(1, std::distance(map.begin(), map.end()));
  264   EXPECT_EQ(4, std::distance(map.begin(), map.end()));
  609   EXPECT_EQ(1, std::distance(map.begin(), map.end()));

unittests/ADT/IteratorTest.cpp

   99     EXPECT_EQ(i, std::distance(Begin, I));
  141     EXPECT_EQ(i, std::distance(Begin, I));
  448   EXPECT_EQ(std::distance(v1.begin(), v1.end()), size(v1));
  449   EXPECT_EQ(std::distance(v2.begin(), v2.end()), size(v2));

unittests/ADT/SparseMultiSetTest.cpp

  135   EXPECT_EQ(5, std::distance(Set.getHead(8), Set.end()));
  137   EXPECT_EQ(0, std::distance(Set.getHead(8), Set.end()));
  177   EXPECT_EQ(3, std::distance(B, E));

unittests/Analysis/LazyCallGraphTest.cpp

  423   EXPECT_EQ(2, std::distance(A->begin(), A->end()));
  425   EXPECT_EQ(0, std::distance(B->begin(), B->end()));
  430   EXPECT_EQ(1, std::distance(B->begin(), B->end()));
  431   EXPECT_EQ(0, std::distance(C->begin(), C->end()));
  434   EXPECT_EQ(1, std::distance(C->begin(), C->end()));
  438   EXPECT_EQ(2, std::distance(C->begin(), C->end()));
  443   EXPECT_EQ(1, std::distance(C->begin(), C->end()));
  447   EXPECT_EQ(0, std::distance(C->begin(), C->end()));
  450   EXPECT_EQ(0, std::distance(B->begin(), B->end()));
  640   EXPECT_EQ(2, std::distance(A->begin(), A->end()));
  642   EXPECT_EQ(3, std::distance(A->begin(), A->end()));
  710   EXPECT_EQ(2, std::distance(A->begin(), A->end()));
  781   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
  873   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
 1119   ASSERT_EQ(1, std::distance(D2->begin(), D2->end()));
 1254   EXPECT_EQ(2, std::distance(A->begin(), A->end()));
 1366   EXPECT_EQ(1, std::distance(ARC.begin(), ARC.end()));
 1432   EXPECT_EQ(1, std::distance(BRC.begin(), BRC.end()));
 1580   EXPECT_EQ(1, std::distance(NewCs.begin(), NewCs.end()));
 1596   EXPECT_EQ(1, std::distance(NewCs.begin(), NewCs.end()));

unittests/CodeGen/MachineInstrTest.cpp

  356   ASSERT_TRUE(std::distance(MIS.begin(), MII) == 1);
  372   ASSERT_TRUE(std::distance(MIS.begin(), MII) == 1);

unittests/IR/BasicBlockTest.cpp

   75   EXPECT_EQ(std::distance(Phis.begin(), Phis.end()), 3);
   77   EXPECT_EQ(std::distance(ReversedPhis.begin(), ReversedPhis.end()), 3);

unittests/IR/InstructionsTest.cpp

  729   EXPECT_EQ(3, std::distance(CI, SI->case_end()));
  748   EXPECT_EQ(3, std::distance(CCI, CCE));

unittests/IR/UserTest.cpp

   84   EXPECT_EQ(10, std::distance(P.value_op_begin(), P.value_op_end()));
  100   EXPECT_EQ(10, std::distance(IP->value_op_begin(), IP->value_op_end()));

unittests/Object/MinidumpTest.cpp

  592     ASSERT_EQ(1u, std::distance(ExpectedInfo->begin(), ExpectedInfo->end()));

unittests/ProfileData/CoverageMappingTest.cpp

  351   EXPECT_EQ(2, std::distance(FunctionRecords.begin(), FunctionRecords.end()));
  887   unsigned NumFuncs = std::distance(Funcs.begin(), Funcs.end());

unittests/Support/YAMLParserTest.cpp

  231   EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));

unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp

   61   EXPECT_EQ(1, std::distance(VPLI.begin(), VPLI.end()));

usr/include/c++/7.4.0/bits/basic_string.tcc

  215 	size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

usr/include/c++/7.4.0/bits/deque.tcc

  444         const size_type __n = std::distance(__first, __last);
  589         const size_type __n = std::distance(__first, __last);

usr/include/c++/7.4.0/bits/hashtable_policy.h

   74     { return std::distance(__first, __last); }

usr/include/c++/7.4.0/bits/list.tcc

  408 	      const size_t __dist = std::distance(__first2, __last2);
  456 		const size_t __dist = std::distance(__first2, __last2);

usr/include/c++/7.4.0/bits/regex_executor.tcc

  404 		      || std::distance(_M_begin,
  406 			 < std::distance(_M_begin, _M_current))

usr/include/c++/7.4.0/bits/stl_algo.h

  617       _DistanceType __len = std::distance(__first, __last);
 1605       std::advance(__left_split, std::distance(__middle, __right_split));
 2045       _DistanceType __len = std::distance(__first, __last);
 2131       _DistanceType __len = std::distance(__first, __last);
 2406 	  std::advance(__first, std::distance(__middle, __last));
 2447 	      __len22 = std::distance(__middle, __second_cut);
 2456 	      __len11 = std::distance(__first, __first_cut);
 2503 	  __len22 = std::distance(__middle, __second_cut);
 2512 	  __len11 = std::distance(__first, __first_cut);
 2517       std::advance(__new_middle, std::distance(__middle, __second_cut));
 2539       const _DistanceType __len1 = std::distance(__first, __middle);
 2540       const _DistanceType __len2 = std::distance(__middle, __last);
 3509       std::advance(__last2, std::distance(__first1, __last1));

usr/include/c++/7.4.0/bits/stl_algobase.h

  952       _DistanceType __len = std::distance(__first, __last);

usr/include/c++/7.4.0/bits/stl_bvector.h

 1148 	const size_type __n = std::distance(__first, __last);

usr/include/c++/7.4.0/bits/stl_heap.h

  551       const auto __dist = std::distance(__first, __last);

usr/include/c++/7.4.0/bits/stl_tempbuf.h

  245     : _M_original_len(std::distance(__first, __last)),

usr/include/c++/7.4.0/bits/stl_tree.h

 2549       const size_type __n = std::distance(__p.first, __p.second);

usr/include/c++/7.4.0/bits/stl_vector.h

 1327 	  const size_type __n = std::distance(__first, __last);

usr/include/c++/7.4.0/bits/vector.tcc

  282 	const size_type __len = std::distance(__first, __last);
  636 	    const size_type __n = std::distance(__first, __last);

utils/TableGen/AsmMatcherEmitter.cpp

 2846   OS << "    " << getMinimalTypeForRange(std::distance(
 3405                       std::distance(Info.Classes.begin(), Info.Classes.end()))

utils/TableGen/CodeGenDAGPatterns.cpp

 3688     ResultIndices.push_back(std::distance(InstResults.begin(), InstResultIter));

utils/TableGen/CodeGenSchedule.cpp

  728   return I == RWVec.end() ? 0 : std::distance(RWVec.begin(), I);
  841   return I == RWVec.end() ? 0 : std::distance(RWVec.begin(), I);
 1018   unsigned Idx = I == schedClassEnd() ? 0 : std::distance(schedClassBegin(), I);

utils/TableGen/RegisterInfoEmitter.cpp

  711       std::distance(SubRegIndices.begin(), SubRegIndices.end());
 1117      << (std::distance(SubRegIndices.begin(), SubRegIndices.end()) + 1) << ",\n"
 1451       std::distance(SubRegIndices.begin(), SubRegIndices.end());

utils/TableGen/SubtargetEmitter.cpp

  731         1 + std::distance(ProcModel.ProcResourceDefs.begin(),
  742         1 + std::distance(ProcModel.ProcResourceDefs.begin(),