--------------------------------------------------------------------------------
I1 cache:         65536 B, 64 B, 4-way associative
D1 cache:         32768 B, 64 B, 8-way associative
LL cache:         67108864 B, 64 B, 64-way associative
Command:          /usr/home/liquid/.rustup/toolchains/w-profiling/bin/rustc --crate-name rustfix --edition=2018 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --crate-type lib --emit=dep-info,metadata,link -C opt-level=3 -C embed-bitcode=no -C metadata=34e8fd66a16802fc -C extra-filename=-34e8fd66a16802fc --out-dir /usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps -L dependency=/usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps --extern anyhow=/usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps/libanyhow-d22e57df0fd48b36.rmeta --extern log=/usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps/liblog-d7e4c4a4654191eb.rmeta --extern serde=/usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps/libserde-fc05f8c3c891b92a.rmeta --extern serde_json=/usr/home/liquid/tmp/.tmpcCzNsS/target/release/deps/libserde_json-8a3c2629cc7d15ff.rmeta -Adeprecated -Aunknown-lints -Zincremental-verify-ich
Data file:        results/cgout-w-profiling-rustfix-0.6.0-Opt-Full
Events recorded:  Ir
Events shown:     Ir
Event sort order: Ir
Thresholds:       0.1
Include dirs:     
User annotated:   
Auto-annotation:  on

--------------------------------------------------------------------------------
Ir                     
--------------------------------------------------------------------------------
6,706,019,493 (100.0%)  PROGRAM TOTALS

--------------------------------------------------------------------------------
Ir                    file:function
--------------------------------------------------------------------------------
243,208,925 ( 3.63%)  ./malloc/malloc.c:_int_free
212,966,397 ( 3.18%)  ./malloc/malloc.c:_int_malloc
154,886,184 ( 2.31%)  ./malloc/malloc.c:malloc
149,439,836 ( 2.23%)  ???:llvm::FPPassManager::runOnFunction(llvm::Function&)
107,921,770 ( 1.61%)  ???:llvm::AnalysisManager<llvm::Function>::getResultImpl(llvm::AnalysisKey*, llvm::Function&)
101,460,085 ( 1.51%)  ???:llvm::AnalysisManager<llvm::Function>::invalidate(llvm::Function&, llvm::PreservedAnalyses const&)
101,279,802 ( 1.51%)  ???:llvm::InstCombinerImpl::run()
 80,741,969 ( 1.20%)  ./malloc/malloc.c:free
 72,258,467 ( 1.08%)  ???:combineInstructionsOverFunction(llvm::Function&, llvm::InstCombineWorklist&, llvm::AAResults*, llvm::AssumptionCache&, llvm::TargetLibraryInfo&, llvm::TargetTransformInfo&, llvm::DominatorTree&, llvm::OptimizationRemarkEmitter&, llvm::BlockFrequencyInfo*, llvm::ProfileSummaryInfo*, unsigned int, llvm::LoopInfo*)
 59,983,592 ( 0.89%)  ???:llvm::SelectionDAG::Combine(llvm::CombineLevel, llvm::AAResults*, llvm::CodeGenOpt::Level)
 49,255,294 ( 0.73%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::CalculateFromScratch(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::BatchUpdateInfo*)
 47,558,830 ( 0.71%)  ???:llvm::AttributeList::addAttributes(llvm::LLVMContext&, unsigned int, llvm::AttrBuilder const&) const
 46,298,592 ( 0.69%)  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S:__memcpy_avx_unaligned_erms
 46,056,017 ( 0.69%)  ???:runCVP(llvm::Module&) [clone .llvm.11785992503873176614]
 44,457,777 ( 0.66%)  ???:llvm::BitstreamCursor::readRecord(unsigned int, llvm::SmallVectorImpl<unsigned long>&, llvm::StringRef*)
 41,158,418 ( 0.61%)  ./string/../sysdeps/x86_64/multiarch/memcmp-avx2-movbe.S:__memcmp_avx2_movbe
 39,407,848 ( 0.59%)  ???:llvm::TargetLibraryInfoImpl::getLibFunc(llvm::Function const&, llvm::LibFunc&) const
 39,333,655 ( 0.59%)  ???:llvm::ValueHandleBase::AddToUseList()
 34,796,139 ( 0.52%)  ???:computeKnownBits(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&) [clone .llvm.15619146473165121143]
 33,996,390 ( 0.51%)  ???:bool llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> >, (anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> >::LookupBucketFor<(anonymous namespace)::SimpleValue>((anonymous namespace)::SimpleValue const&, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value*>*> const*&) const
 33,358,948 ( 0.50%)  ./malloc/malloc.c:malloc_consolidate
 31,579,152 ( 0.47%)  ???:llvm::removeUnreachableBlocks(llvm::Function&, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*)
 31,570,036 ( 0.47%)  ???:llvm::coro::declaresIntrinsics(llvm::Module const&, std::initializer_list<llvm::StringRef>)
 30,802,858 ( 0.46%)  ???:SimplifyICmpInst(unsigned int, llvm::Value*, llvm::Value*, llvm::SimplifyQuery const&, unsigned int) [clone .llvm.1619516508949622737]
 29,291,911 ( 0.44%)  ???:(anonymous namespace)::LazyValueInfoImpl::solve() [clone .llvm.4316243980339171764]
 28,893,617 ( 0.43%)  ./string/../sysdeps/x86_64/multiarch/strcmp-avx2.S:__strncmp_avx2
 28,406,996 ( 0.42%)  ???:llvm::DataLayout::getAlignment(llvm::Type*, bool) const
 27,764,292 ( 0.41%)  ???:llvm::BasicAAResult::alias(llvm::MemoryLocation const&, llvm::MemoryLocation const&, llvm::AAQueryInfo&)
 26,194,380 ( 0.39%)  ???:llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&)
 25,511,360 ( 0.38%)  ???:llvm::InstCombinerImpl::visitCallInst(llvm::CallInst&)
 25,007,038 ( 0.37%)  ???:llvm::DataLayout::getTypeSizeInBits(llvm::Type*) const
 24,941,688 ( 0.37%)  ???:llvm::InlineFunction(llvm::CallBase&, llvm::InlineFunctionInfo&, llvm::AAResults*, bool, llvm::Function*)
 24,441,755 ( 0.36%)  ???:computeKnownBitsFromOperator(llvm::Operator const*, llvm::APInt const&, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
 24,136,803 ( 0.36%)  ???:llvm::LiveVariables::runOnBlock(llvm::MachineBasicBlock*, unsigned int)
 24,101,649 ( 0.36%)  /tmp/gcc-build/x86_64-unknown-linux-gnu/libstdc++-v3/libsupc++/../../../../gcc-5.5.0/libstdc++-v3/libsupc++/new_op.cc:operator new(unsigned long)
 23,935,353 ( 0.36%)  ???:llvm::PMDataManager::verifyPreservedAnalysis(llvm::Pass*)
 23,576,796 ( 0.35%)  ???:llvm::SimplifyInstruction(llvm::Instruction*, llvm::SimplifyQuery const&, llvm::OptimizationRemarkEmitter*)
 22,898,252 ( 0.34%)  ./malloc/malloc.c:unlink_chunk.constprop.0
 22,425,983 ( 0.33%)  ???:llvm::AttributeList::get(llvm::LLVMContext&, llvm::ArrayRef<llvm::AttributeList>)
 21,014,011 ( 0.31%)  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S:__memset_avx2_erms
 20,863,174 ( 0.31%)  ???:(anonymous namespace)::LazyValueInfoImpl::getEdgeValue(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::Instruction*) [clone .llvm.4316243980339171764]
 20,508,336 ( 0.31%)  ???:llvm::InstCombinerImpl::visitICmpInst(llvm::ICmpInst&)
 20,300,280 ( 0.30%)  ???:computeKnownBits(llvm::Value const*, llvm::APInt const&, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
 19,546,224 ( 0.29%)  ???:llvm::simplifyCFG(llvm::BasicBlock*, llvm::TargetTransformInfo const&, llvm::DomTreeUpdater*, llvm::SimplifyCFGOptions const&, llvm::ArrayRef<llvm::WeakVH>)
 19,150,471 ( 0.29%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false> >::runSemiNCA(llvm::DominatorTreeBase<llvm::BasicBlock, false>&, unsigned int)
 19,013,379 ( 0.28%)  ???:llvm::isNonEscapingLocalObject(llvm::Value const*, llvm::SmallDenseMap<llvm::Value const*, bool, 8u, llvm::DenseMapInfo<llvm::Value const*>, llvm::detail::DenseMapPair<llvm::Value const*, bool> >*)
 18,670,571 ( 0.28%)  ???:(anonymous namespace)::MachineCopyPropagation::runOnMachineFunction(llvm::MachineFunction&)
 18,644,974 ( 0.28%)  ???:llvm::AttributeSetNode::get(llvm::LLVMContext&, llvm::AttrBuilder const&)
 18,265,348 ( 0.27%)  ???:llvm::AttributeList::addAttribute(llvm::LLVMContext&, unsigned int, llvm::Attribute::AttrKind) const
 18,038,597 ( 0.27%)  ???:llvm::FindFunctionBackedges(llvm::Function const&, llvm::SmallVectorImpl<std::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> >&)
 18,038,363 ( 0.27%)  ???:(anonymous namespace)::EarlyCSE::run() [clone .llvm.7062997131228810369]
 17,923,211 ( 0.27%)  ???:computeKnownBitsFromAssume(llvm::Value const*, llvm::KnownBits&, unsigned int, (anonymous namespace)::Query const&)
 17,805,720 ( 0.27%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::CalculateFromScratch(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::BatchUpdateInfo*)
 17,436,145 ( 0.26%)  ???:isKnownNonZero(llvm::Value const*, llvm::APInt const&, unsigned int, (anonymous namespace)::Query const&) [clone .llvm.15619146473165121143]
 15,899,453 ( 0.24%)  ???:llvm::MemorySSA::buildMemorySSA(llvm::BatchAAResults&)
 15,804,152 ( 0.24%)  ./elf/dl-lookup.c:_dl_lookup_symbol_x
 15,535,340 ( 0.23%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::FindRoots(llvm::DominatorTreeBase<llvm::BasicBlock, true> const&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::BatchUpdateInfo*)
 14,624,258 ( 0.22%)  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S:__memset_avx2_unaligned_erms
 14,420,217 ( 0.22%)  /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs:rustc_expand::mbe::macro_parser::parse_tt
 14,128,727 ( 0.21%)  ???:llvm::SelectionDAGISel::SelectCodeCommon(llvm::SDNode*, unsigned char const*, unsigned int)
 13,315,794 ( 0.20%)  ???:(anonymous namespace)::CVPLatticeFunc::ComputeInstructionState(llvm::Instruction&, llvm::DenseMap<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal, llvm::DenseMapInfo<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > > >, llvm::detail::DenseMapPair<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal> >&, llvm::SparseSolver<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > >, (anonymous namespace)::CVPLatticeVal, llvm::LatticeKeyInfo<llvm::PointerIntPair<llvm::Value*, 2u, (anonymous namespace)::IPOGrouping, llvm::PointerLikeTypeTraits<llvm::Value*>, llvm::PointerIntPairInfo<llvm::Value*, 2u, llvm::PointerLikeTypeTraits<llvm::Value*> > > > >&)
 13,239,422 ( 0.20%)  ???:llvm::LiveVariables::HandleRegMask(llvm::MachineOperand const&)
 13,136,687 ( 0.20%)  ???:llvm::SimplifyGEPInst(llvm::Type*, llvm::ArrayRef<llvm::Value*>, llvm::SimplifyQuery const&)
 12,926,426 ( 0.19%)  ???:(anonymous namespace)::PruningFunctionCloner::CloneBlock(llvm::BasicBlock const*, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, true, false, void>, false, true>, std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> >&)
 12,710,300 ( 0.19%)  ???:???
 12,706,024 ( 0.19%)  ???:llvm::InstCombinerImpl::SimplifyDemandedUseBits(llvm::Value*, llvm::APInt, llvm::KnownBits&, unsigned int, llvm::Instruction*)
 12,685,699 ( 0.19%)  ???:llvm::SROA::runOnAlloca(llvm::AllocaInst&)
 12,595,700 ( 0.19%)  ???:(anonymous namespace)::DeadMachineInstructionElim::eliminateDeadMI(llvm::MachineFunction&)
 12,540,593 ( 0.19%)  ???:llvm::GVN::processBlock(llvm::BasicBlock*)
 12,403,337 ( 0.18%)  ???:llvm::MD5::final(llvm::MD5::MD5Result&)
 12,289,488 ( 0.18%)  ???:(anonymous namespace)::AggressiveDeadCodeElimination::performDeadCodeElimination()
 12,113,939 ( 0.18%)  ???:llvm::ScalarEvolution::getAddExpr(llvm::SmallVectorImpl<llvm::SCEV const*>&, llvm::SCEV::NoWrapFlags, unsigned int)
 12,085,738 ( 0.18%)  ./string/../sysdeps/x86_64/multiarch/strlen-avx2.S:__strlen_avx2
 12,008,823 ( 0.18%)  ???:(anonymous namespace)::SimplifyCFGOpt::simplifyCondBranch(llvm::BranchInst*, llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&)
 11,669,983 ( 0.17%)  ???:llvm::LivePhysRegs::stepBackward(llvm::MachineInstr const&)
 11,438,582 ( 0.17%)  ???:(anonymous namespace)::eliminateDeadStores(llvm::Function&, llvm::AAResults&, llvm::MemorySSA&, llvm::DominatorTree&, llvm::PostDominatorTree&, llvm::TargetLibraryInfo const&, llvm::LoopInfo const&) [clone .llvm.5769264623867638418]
 11,371,748 ( 0.17%)  ???:llvm::BlockFrequencyInfoImpl<llvm::BasicBlock>::initializeRPOT()
 11,222,176 ( 0.17%)  ???:(anonymous namespace)::LazyValueInfoImpl::getValueInBlock(llvm::Value*, llvm::BasicBlock*, llvm::Instruction*) [clone .llvm.4316243980339171764]
 11,158,943 ( 0.17%)  /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.12.0/src/raw/mod.rs:<hashbrown::map::RawEntryBuilderMut<rustc_middle::ty::context::Interned<rustc_middle::ty::TyS>, (), core::hash::BuildHasherDefault<rustc_hash::FxHasher>>>::from_hash::<hashbrown::map::equivalent<rustc_middle::ty::sty::TyKind, rustc_middle::ty::context::Interned<rustc_middle::ty::TyS>>::{closure#0}>
 11,158,359 ( 0.17%)  ???:llvm::PMDataManager::removeNotPreservedAnalysis(llvm::Pass*)
 11,146,274 ( 0.17%)  /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs:rustc_expand::mbe::macro_parser::parse_tt
 10,952,187 ( 0.16%)  ???:llvm::LoopInfoBase<llvm::BasicBlock, llvm::Loop>::analyze(llvm::DominatorTreeBase<llvm::BasicBlock, false> const&)
 10,949,654 ( 0.16%)  ???:llvm::PopulateLoopsDFS<llvm::BasicBlock, llvm::Loop>::traverse(llvm::BasicBlock*)
 10,820,461 ( 0.16%)  ???:llvm::FoldingSetBase::FindNodeOrInsertPos(llvm::FoldingSetNodeID const&, void*&, llvm::FoldingSetBase::FoldingSetInfo const&)
 10,644,027 ( 0.16%)  ???:updateCGAndAnalysisManagerForPass(llvm::LazyCallGraph&, llvm::LazyCallGraph::SCC&, llvm::LazyCallGraph::Node&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::CGSCCUpdateResult&, llvm::AnalysisManager<llvm::Function>&, bool) [clone .llvm.5426518467876156712]
 10,613,114 ( 0.16%)  ???:llvm::Value::stripAndAccumulateConstantOffsets(llvm::DataLayout const&, llvm::APInt&, bool, llvm::function_ref<bool (llvm::Value&, llvm::APInt&)>) const
 10,603,692 ( 0.16%)  ???:llvm::DemandedBits::isInstructionDead(llvm::Instruction*)
 10,373,557 ( 0.15%)  ???:llvm::LoopBase<llvm::BasicBlock, llvm::Loop>::verifyLoop() const
 10,363,736 ( 0.15%)  ???:llvm::InstCombinerImpl::visitLoadInst(llvm::LoadInst&)
 10,283,248 ( 0.15%)  ???:llvm::PassRegistry::enumerateWith(llvm::PassRegistrationListener*)
 10,243,542 ( 0.15%)  ???:(anonymous namespace)::DAGCombiner::combine(llvm::SDNode*)
 10,217,954 ( 0.15%)  ???:llvm::Type::isSizedDerivedType(llvm::SmallPtrSetImpl<llvm::Type*>*) const
 10,102,006 ( 0.15%)  ./elf/dl-lookup.c:do_lookup_x
  9,958,724 ( 0.15%)  ???:llvm::TargetLoweringBase::getTypeConversion(llvm::LLVMContext&, llvm::EVT) const
  9,806,189 ( 0.15%)  ???:llvm::SCCPInstVisitor::solve()
  9,729,836 ( 0.15%)  ???:llvm::DenseMapBase<llvm::DenseMap<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> >, llvm::DenseMapInfo<llvm::PoisoningVH<llvm::BasicBlock> >, llvm::detail::DenseMapPair<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> > > >, llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> >, llvm::DenseMapInfo<llvm::PoisoningVH<llvm::BasicBlock> >, llvm::detail::DenseMapPair<llvm::PoisoningVH<llvm::BasicBlock>, std::unique_ptr<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry, std::default_delete<(anonymous namespace)::LazyValueInfoCache::BlockCacheEntry> > > >::destroyAll() [clone .llvm.4316243980339171764]
  9,599,051 ( 0.14%)  ???:llvm::detail::AnalysisResultModel<llvm::Function, llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Module>, llvm::Function>, llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Module>, llvm::Function>::Result, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function>::Invalidator, true>::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&)
  9,598,145 ( 0.14%)  ???:llvm::ScheduleDAGSDNodes::BuildSchedUnits()
  9,574,901 ( 0.14%)  ???:(anonymous namespace)::BitcodeReader::parseModule(unsigned long, bool, llvm::function_ref<llvm::Optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > (llvm::StringRef)>)
  9,277,830 ( 0.14%)  ???:llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&>::run(llvm::LazyCallGraph::SCC&, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>&, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&)
  9,213,937 ( 0.14%)  ???:runImpl(llvm::Function&, llvm::LazyValueInfo*, llvm::DominatorTree*, llvm::SimplifyQuery const&) [clone .llvm.16011871802505272439]
  9,128,961 ( 0.14%)  ???:llvm::InstCombinerImpl::visitBitCast(llvm::BitCastInst&)
  8,999,248 ( 0.13%)  ???:llvm::ConstantFoldTerminator(llvm::BasicBlock*, bool, llvm::TargetLibraryInfo const*, llvm::DomTreeUpdater*)
  8,920,455 ( 0.13%)  ???:llvm::MemorySSA::OptimizeUses::optimizeUses()
  8,906,606 ( 0.13%)  ???:llvm::X86TargetMachine::getTargetTransformInfo(llvm::Function const&)
  8,861,525 ( 0.13%)  ???:llvm::JumpThreadingPass::processBlock(llvm::BasicBlock*)
  8,857,336 ( 0.13%)  ./stdlib/msort.c:msort_with_tmp.part.0
  8,855,048 ( 0.13%)  ???:llvm::BasicAAResult::getModRefInfo(llvm::CallBase const*, llvm::MemoryLocation const&, llvm::AAQueryInfo&)
  8,742,357 ( 0.13%)  ???:(anonymous namespace)::Verifier::visitInstruction(llvm::Instruction&)
  8,628,011 ( 0.13%)  ???:int llvm::array_pod_sort_comparator<llvm::Attribute>(void const*, void const*)
  8,605,423 ( 0.13%)  ???:llvm::MachineInstr::addOperand(llvm::MachineFunction&, llvm::MachineOperand const&)
  8,588,984 ( 0.13%)  ???:llvm::IDFCalculatorBase<llvm::BasicBlock, false>::calculate(llvm::SmallVectorImpl<llvm::BasicBlock*>&)
  8,574,935 ( 0.13%)  ???:llvm::detail::AnalysisResultModel<llvm::Function, llvm::DominatorTreeAnalysis, llvm::DominatorTree, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function>::Invalidator, true>::~AnalysisResultModel()
  8,527,997 ( 0.13%)  ???:simplifyFunctionCFGImpl(llvm::Function&, llvm::TargetTransformInfo const&, llvm::DominatorTree*, llvm::SimplifyCFGOptions const&) [clone .llvm.11597842506770977528]
  8,365,031 ( 0.12%)  ???:llvm::SmallPtrSetImplBase::insert_imp_big(void const*)
  8,325,256 ( 0.12%)  ???:std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > std::__copy_move_a2<false, llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > > >(llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, llvm::po_iterator<llvm::Function const*, llvm::SmallPtrSet<llvm::BasicBlock const*, 8u>, false, llvm::GraphTraits<llvm::Function const*> >, std::back_insert_iterator<std::vector<llvm::BasicBlock const*, std::allocator<llvm::BasicBlock const*> > >)
  8,282,442 ( 0.12%)  ???:llvm::BlockFrequencyInfoImplBase::finalizeMetrics()
  8,263,321 ( 0.12%)  ???:llvm::ReassociatePass::BuildRankMap(llvm::Function&, llvm::ReversePostOrderTraversal<llvm::Function*, llvm::GraphTraits<llvm::Function*> >&)
  8,188,372 ( 0.12%)  ???:bool llvm::detail::UniqueFunctionBase<bool, llvm::StringRef, llvm::Any>::CallImpl<llvm::OptNoneInstrumentation::registerCallbacks(llvm::PassInstrumentationCallbacks&)::$_4>(void*, llvm::StringRef, llvm::Any&)
  8,153,937 ( 0.12%)  ./string/../sysdeps/x86_64/multiarch/memchr-avx2.S:__memchr_avx2
  8,102,056 ( 0.12%)  ???:llvm::X86TargetMachine::getSubtargetImpl(llvm::Function const&) const
  8,016,830 ( 0.12%)  ???:llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&)
  7,992,359 ( 0.12%)  ???:llvm::ConstantRange::makeExactICmpRegion(llvm::CmpInst::Predicate, llvm::APInt const&)
  7,885,888 ( 0.12%)  ???:llvm::MemoryDependenceResults::getNonLocalPointerDepFromBB(llvm::Instruction*, llvm::PHITransAddr const&, llvm::MemoryLocation const&, bool, llvm::BasicBlock*, llvm::SmallVectorImpl<llvm::NonLocalDepResult>&, llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*> >&, bool, bool)
  7,783,949 ( 0.12%)  ???:llvm::InstCombinerImpl::visitStoreInst(llvm::StoreInst&)
  7,648,634 ( 0.11%)  ???:llvm::Value::~Value()
  7,641,241 ( 0.11%)  ???:llvm::GlobalValue::isInterposable() const
  7,636,576 ( 0.11%)  ???:llvm::Instruction::~Instruction()
  7,554,087 ( 0.11%)  ???:llvm::AAResults::getModRefInfo(llvm::Instruction const*, llvm::Optional<llvm::MemoryLocation> const&, llvm::AAQueryInfo&)
  7,546,779 ( 0.11%)  ???:llvm::AAResults::Model<llvm::BasicAAResult>::getModRefBehavior(llvm::CallBase const*)
  7,534,987 ( 0.11%)  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S:__memcpy_sse2_unaligned_erms
  7,332,985 ( 0.11%)  ???:llvm::ScalarEvolution::~ScalarEvolution()
  7,331,322 ( 0.11%)  ???:llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, true> >::runSemiNCA(llvm::DominatorTreeBase<llvm::BasicBlock, true>&, unsigned int)
  7,261,025 ( 0.11%)  ???:llvm::FoldBranchToCommonDest(llvm::BranchInst*, llvm::DomTreeUpdater*, llvm::MemorySSAUpdater*, llvm::TargetTransformInfo const*, unsigned int)
  7,195,993 ( 0.11%)  ???:llvm::BasicAAResult::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&)
  7,195,542 ( 0.11%)  ???:llvm_regexec
  7,194,318 ( 0.11%)  ???:llvm::ScalarEvolution::getRangeRef(llvm::SCEV const*, llvm::ScalarEvolution::RangeSignHint)
  7,174,718 ( 0.11%)  ???:llvm::AAResults::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&)
  7,159,091 ( 0.11%)  ???:llvm::SROA::runImpl(llvm::Function&, llvm::DominatorTree&, llvm::AssumptionCache&)
  7,155,970 ( 0.11%)  ???:llvm::ReassociatePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&)
  7,147,119 ( 0.11%)  ./malloc/malloc.c:realloc
  7,137,696 ( 0.11%)  ???:llvm::X86TargetLowering::X86TargetLowering(llvm::X86TargetMachine const&, llvm::X86Subtarget const&)
  7,060,904 ( 0.11%)  ???:llvm::AAResults::Model<llvm::BasicAAResult>::pointsToConstantMemory(llvm::MemoryLocation const&, llvm::AAQueryInfo&, bool)
  7,031,646 ( 0.10%)  ???:llvm::ScalarEvolution::getSCEV(llvm::Value*)
  6,971,508 ( 0.10%)  ???:llvm::Type::getPrimitiveSizeInBits() const
  6,907,413 ( 0.10%)  ???:llvm::Intrinsic::getDeclaration(llvm::Module*, unsigned int, llvm::ArrayRef<llvm::Type*>)
  6,826,016 ( 0.10%)  ???:llvm::FoldingSet<llvm::AttributeImpl>::NodeEquals(llvm::FoldingSetBase const*, llvm::FoldingSetBase::Node*, llvm::FoldingSetNodeID const&, unsigned int, llvm::FoldingSetNodeID&)

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs
--------------------------------------------------------------------------------
Ir                 

-- line 294 ----------------------------------------
        .           #[allow(deprecated)]
        .           impl From<LayoutErr> for CollectionAllocErr {
        .               fn from(_: LayoutErr) -> Self {
        .                   CollectionAllocErr::CapacityOverflow
        .               }
        .           }
        .           
        .           fn infallible<T>(result: Result<T, CollectionAllocErr>) -> T {
  405,269 ( 0.01%)      match result {
        .                   Ok(x) => x,
        .                   Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
        .                   Err(CollectionAllocErr::AllocErr { layout }) => alloc::alloc::handle_alloc_error(layout),
        .               }
        .           }
        .           
        .           /// FIXME: use `Layout::array` when we require a Rust version where it’s stable
        .           /// https://github.com/rust-lang/rust/issues/55724
-- line 310 ----------------------------------------
-- line 376 ----------------------------------------
        .               fn len(&self) -> usize {
        .                   self.iter.len()
        .               }
        .           }
        .           
        .           impl<'a, T: Array> FusedIterator for Drain<'a, T> {}
        .           
        .           impl<'a, T: 'a + Array> Drop for Drain<'a, T> {
   17,318 ( 0.00%)      fn drop(&mut self) {
        .                   self.for_each(drop);
        .           
    7,422 ( 0.00%)          if self.tail_len > 0 {
        .                       unsafe {
        .                           let source_vec = self.vec.as_mut();
        .           
        .                           // memmove back untouched tail, update to new length
        .                           let start = source_vec.len();
        .                           let tail = self.tail_start;
        .                           if tail != start {
        .                               let src = source_vec.as_ptr().add(tail);
        .                               let dst = source_vec.as_mut_ptr().add(start);
        .                               ptr::copy(src, dst, self.tail_len);
        .                           }
        .                           source_vec.set_len(start + self.tail_len);
        .                       }
        .                   }
   17,318 ( 0.00%)      }
        .           }
        .           
        .           #[cfg(feature = "union")]
        .           union SmallVecData<A: Array> {
        .               inline: core::mem::ManuallyDrop<MaybeUninit<A>>,
        .               heap: (*mut A::Item, usize),
        .           }
        .           
-- line 410 ----------------------------------------
-- line 422 ----------------------------------------
        .           #[cfg(feature = "union")]
        .           impl<A: Array> SmallVecData<A> {
        .               #[inline]
        .               unsafe fn inline(&self) -> *const A::Item {
        .                   self.inline.as_ptr() as *const A::Item
        .               }
        .               #[inline]
        .               unsafe fn inline_mut(&mut self) -> *mut A::Item {
   37,524 ( 0.00%)          self.inline.as_mut_ptr() as *mut A::Item
        .               }
        .               #[inline]
        .               fn from_inline(inline: MaybeUninit<A>) -> SmallVecData<A> {
        .                   SmallVecData {
        .                       inline: core::mem::ManuallyDrop::new(inline),
        .                   }
        .               }
        .               #[inline]
        .               unsafe fn into_inline(self) -> MaybeUninit<A> {
        .                   core::mem::ManuallyDrop::into_inner(self.inline)
        .               }
        .               #[inline]
        .               unsafe fn heap(&self) -> (*mut A::Item, usize) {
   24,321 ( 0.00%)          self.heap
        .               }
        .               #[inline]
        .               unsafe fn heap_mut(&mut self) -> &mut (*mut A::Item, usize) {
        .                   &mut self.heap
        .               }
        .               #[inline]
        .               fn from_heap(ptr: *mut A::Item, len: usize) -> SmallVecData<A> {
        .                   SmallVecData { heap: (ptr, len) }
-- line 452 ----------------------------------------
-- line 557 ----------------------------------------
        .               #[inline]
        .               pub fn new() -> SmallVec<A> {
        .                   // Try to detect invalid custom implementations of `Array`. Hopefully,
        .                   // this check should be optimized away entirely for valid ones.
        .                   assert!(
        .                       mem::size_of::<A>() == A::size() * mem::size_of::<A::Item>()
        .                           && mem::align_of::<A>() >= mem::align_of::<A::Item>()
        .                   );
  599,042 ( 0.01%)          SmallVec {
        .                       capacity: 0,
        .                       data: SmallVecData::from_inline(MaybeUninit::uninit()),
        .                   }
        .               }
        .           
        .               /// Construct an empty vector with enough capacity pre-allocated to store at least `n`
        .               /// elements.
        .               ///
-- line 573 ----------------------------------------
-- line 597 ----------------------------------------
        .               ///
        .               /// let vec = vec![1, 2, 3, 4, 5];
        .               /// let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);
        .               ///
        .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
        .               /// ```
        .               #[inline]
        .               pub fn from_vec(mut vec: Vec<A::Item>) -> SmallVec<A> {
      606 ( 0.00%)          if vec.capacity() <= Self::inline_capacity() {
        .                       unsafe {
        .                           let mut data = SmallVecData::<A>::from_inline(MaybeUninit::uninit());
        .                           let len = vec.len();
        .                           vec.set_len(0);
        .                           ptr::copy_nonoverlapping(vec.as_ptr(), data.inline_mut(), len);
        .           
        .                           SmallVec {
        .                               capacity: len,
        .                               data,
        .                           }
        .                       }
        .                   } else {
        .                       let (ptr, cap, len) = (vec.as_mut_ptr(), vec.capacity(), vec.len());
        .                       mem::forget(vec);
        .           
      987 ( 0.00%)              SmallVec {
        .                           capacity: cap,
        .                           data: SmallVecData::from_heap(ptr, len),
        .                       }
        .                   }
        .               }
        .           
        .               /// Constructs a new `SmallVec` on the stack from an `A` without
        .               /// copying elements.
-- line 629 ----------------------------------------
-- line 635 ----------------------------------------
        .               /// let small_vec: SmallVec<_> = SmallVec::from_buf(buf);
        .               ///
        .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
        .               /// ```
        .               #[inline]
        .               pub fn from_buf(buf: A) -> SmallVec<A> {
        .                   SmallVec {
        .                       capacity: A::size(),
    2,009 ( 0.00%)              data: SmallVecData::from_inline(MaybeUninit::new(buf)),
        .                   }
        .               }
        .           
        .               /// Constructs a new `SmallVec` on the stack from an `A` without
        .               /// copying elements. Also sets the length, which must be less or
        .               /// equal to the size of `buf`.
        .               ///
        .               /// ```rust
-- line 651 ----------------------------------------
-- line 653 ----------------------------------------
        .               ///
        .               /// let buf = [1, 2, 3, 4, 5, 0, 0, 0];
        .               /// let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);
        .               ///
        .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
        .               /// ```
        .               #[inline]
        .               pub fn from_buf_and_len(buf: A, len: usize) -> SmallVec<A> {
   20,298 ( 0.00%)          assert!(len <= A::size());
   60,894 ( 0.00%)          unsafe { SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), len) }
        .               }
        .           
        .               /// Constructs a new `SmallVec` on the stack from an `A` without
        .               /// copying elements. Also sets the length. The user is responsible
        .               /// for ensuring that `len <= A::size()`.
        .               ///
        .               /// ```rust
        .               /// use smallvec::SmallVec;
-- line 670 ----------------------------------------
-- line 674 ----------------------------------------
        .               /// let small_vec: SmallVec<_> = unsafe {
        .               ///     SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)
        .               /// };
        .               ///
        .               /// assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);
        .               /// ```
        .               #[inline]
        .               pub unsafe fn from_buf_and_len_unchecked(buf: MaybeUninit<A>, len: usize) -> SmallVec<A> {
   10,149 ( 0.00%)          SmallVec {
        .                       capacity: len,
        .                       data: SmallVecData::from_inline(buf),
        .                   }
        .               }
        .           
        .               /// Sets the length of a vector.
        .               ///
        .               /// This will explicitly set the size of the vector, without actually
        .               /// modifying its buffers, so it is up to the caller to ensure that the
        .               /// vector is actually the specified size.
        .               pub unsafe fn set_len(&mut self, new_len: usize) {
        .                   let (_, len_ptr, _) = self.triple_mut();
   62,500 ( 0.00%)          *len_ptr = new_len;
        .               }
        .           
        .               /// The maximum number of elements this vector can hold inline
        .               #[inline]
        .               fn inline_capacity() -> usize {
        .                   if mem::size_of::<A::Item>() > 0 {
        4 ( 0.00%)              A::size()
        .                   } else {
        .                       // For zero-size items code like `ptr.add(offset)` always returns the same pointer.
        .                       // Therefore all items are at the same address,
        .                       // and any array size has capacity for infinitely many items.
        .                       // The capacity is limited by the bit width of the length field.
        .                       //
        .                       // `Vec` also does this:
        .                       // https://github.com/rust-lang/rust/blob/1.44.0/src/liballoc/raw_vec.rs#L186
-- line 710 ----------------------------------------
-- line 725 ----------------------------------------
        .               #[inline]
        .               pub fn len(&self) -> usize {
        .                   self.triple().1
        .               }
        .           
        .               /// Returns `true` if the vector is empty
        .               #[inline]
        .               pub fn is_empty(&self) -> bool {
  199,510 ( 0.00%)          self.len() == 0
        .               }
        .           
        .               /// The number of items the vector can hold without reallocating
        .               #[inline]
        .               pub fn capacity(&self) -> usize {
        .                   self.triple().2
        .               }
        .           
        .               /// Returns a tuple with (data ptr, len, capacity)
        .               /// Useful to get all SmallVec properties with a single check of the current storage variant.
        .               #[inline]
        .               fn triple(&self) -> (*const A::Item, usize, usize) {
        .                   unsafe {
2,794,888 ( 0.04%)              if self.spilled() {
        .                           let (ptr, len) = self.data.heap();
        .                           (ptr, len, self.capacity)
        .                       } else {
        .                           (self.data.inline(), self.capacity, Self::inline_capacity())
        .                       }
        .                   }
        .               }
        .           
        .               /// Returns a tuple with (data ptr, len ptr, capacity)
        .               #[inline]
        .               fn triple_mut(&mut self) -> (*mut A::Item, &mut usize, usize) {
        .                   unsafe {
9,256,008 ( 0.14%)              if self.spilled() {
    9,950 ( 0.00%)                  let &mut (ptr, ref mut len_ptr) = self.data.heap_mut();
        .                           (ptr, len_ptr, self.capacity)
        .                       } else {
        .                           (
        .                               self.data.inline_mut(),
        .                               &mut self.capacity,
        .                               Self::inline_capacity(),
        .                           )
        .                       }
        .                   }
        .               }
        .           
        .               /// Returns `true` if the data has spilled into a separate heap-allocated buffer.
        .               #[inline]
        .               pub fn spilled(&self) -> bool {
6,961,968 ( 0.10%)          self.capacity > Self::inline_capacity()
        .               }
        .           
        .               /// Creates a draining iterator that removes the specified range in the vector
        .               /// and yields the removed items.
        .               ///
        .               /// Note 1: The element range is removed even if the iterator is only
        .               /// partially consumed or not consumed at all.
        .               ///
        .               /// Note 2: It is unspecified how many elements are removed from the vector
        .               /// if the `Drain` value is leaked.
        .               ///
        .               /// # Panics
        .               ///
        .               /// Panics if the starting point is greater than the end point or if
        .               /// the end point is greater than the length of the vector.
    2,474 ( 0.00%)      pub fn drain<R>(&mut self, range: R) -> Drain<'_, A>
        .               where
        .                   R: RangeBounds<usize>,
        .               {
        .                   use core::ops::Bound::*;
        .           
        .                   let len = self.len();
        .                   let start = match range.start_bound() {
        .                       Included(&n) => n,
-- line 800 ----------------------------------------
-- line 810 ----------------------------------------
        .                   assert!(start <= end);
        .                   assert!(end <= len);
        .           
        .                   unsafe {
        .                       self.set_len(start);
        .           
        .                       let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start), end - start);
        .           
   12,370 ( 0.00%)              Drain {
        .                           tail_start: end,
        .                           tail_len: len - end,
        .                           iter: range_slice.iter(),
        .                           vec: NonNull::from(self),
        .                       }
        .                   }
    2,474 ( 0.00%)      }
        .           
        .               /// Append an item to the vector.
        .               #[inline]
   47,075 ( 0.00%)      pub fn push(&mut self, value: A::Item) {
        .                   unsafe {
        .                       let (mut ptr, mut len, cap) = self.triple_mut();
1,451,624 ( 0.02%)              if *len == cap {
      808 ( 0.00%)                  self.reserve(1);
   14,318 ( 0.00%)                  let &mut (heap_ptr, ref mut heap_len) = self.data.heap_mut();
        .                           ptr = heap_ptr;
        .                           len = heap_len;
        .                       }
   17,070 ( 0.00%)              ptr::write(ptr.add(*len), value);
2,106,861 ( 0.03%)              *len += 1;
        .                   }
   37,660 ( 0.00%)      }
        .           
        .               /// Remove an item from the end of the vector and return it, or None if empty.
        .               #[inline]
        .               pub fn pop(&mut self) -> Option<A::Item> {
        .                   unsafe {
        .                       let (ptr, len_ptr, _) = self.triple_mut();
  712,689 ( 0.01%)              if *len_ptr == 0 {
        .                           return None;
        .                       }
  195,022 ( 0.00%)              let last_index = *len_ptr - 1;
  243,623 ( 0.00%)              *len_ptr = last_index;
   36,523 ( 0.00%)              Some(ptr::read(ptr.add(last_index)))
        .                   }
        9 ( 0.00%)      }
        .           
        .               /// Moves all the elements of `other` into `self`, leaving `other` empty.
        .               ///
        .               /// # Example
        .               ///
        .               /// ```
        .               /// # use smallvec::{SmallVec, smallvec};
        .               /// let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];
-- line 863 ----------------------------------------
-- line 879 ----------------------------------------
        .               /// or if the capacity computation overflows `usize`.
        .               pub fn grow(&mut self, new_cap: usize) {
        .                   infallible(self.try_grow(new_cap))
        .               }
        .           
        .               /// Re-allocate to set the capacity to `max(new_cap, inline_size())`.
        .               ///
        .               /// Panics if `new_cap` is less than the vector's length
    2,165 ( 0.00%)      pub fn try_grow(&mut self, new_cap: usize) -> Result<(), CollectionAllocErr> {
        .                   unsafe {
      211 ( 0.00%)              let (ptr, &mut len, cap) = self.triple_mut();
        .                       let unspilled = !self.spilled();
   27,112 ( 0.00%)              assert!(new_cap >= len);
   27,112 ( 0.00%)              if new_cap <= self.inline_size() {
        .                           if unspilled {
        .                               return Ok(());
        .                           }
        .                           self.data = SmallVecData::from_inline(MaybeUninit::uninit());
        .                           ptr::copy_nonoverlapping(ptr, self.data.inline_mut(), len);
        .                           self.capacity = len;
        .                           deallocate(ptr, cap);
   27,112 ( 0.00%)              } else if new_cap != cap {
   25,633 ( 0.00%)                  let layout = layout_array::<A::Item>(new_cap)?;
        .                           debug_assert!(layout.size() > 0);
        .                           let new_alloc;
   13,556 ( 0.00%)                  if unspilled {
        .                               new_alloc = NonNull::new(alloc::alloc::alloc(layout))
        .                                   .ok_or(CollectionAllocErr::AllocErr { layout })?
        .                                   .cast()
        .                                   .as_ptr();
        .                               ptr::copy_nonoverlapping(ptr, new_alloc, len);
        .                           } else {
        .                               // This should never fail since the same succeeded
        .                               // when previously allocating `ptr`.
    8,934 ( 0.00%)                      let old_layout = layout_array::<A::Item>(cap)?;
        .           
        .                               let new_ptr = alloc::alloc::realloc(ptr as *mut u8, old_layout, layout.size());
        .                               new_alloc = NonNull::new(new_ptr)
        .                                   .ok_or(CollectionAllocErr::AllocErr { layout })?
        .                                   .cast()
        .                                   .as_ptr();
        .                           }
   27,112 ( 0.00%)                  self.data = SmallVecData::from_heap(new_alloc, len);
   37,812 ( 0.00%)                  self.capacity = new_cap;
        .                       }
        .                       Ok(())
        .                   }
    2,376 ( 0.00%)      }
        .           
        .               /// Reserve capacity for `additional` more elements to be inserted.
        .               ///
        .               /// May reserve more space to avoid frequent reallocations.
        .               ///
        .               /// Panics if the capacity computation overflows `usize`.
        .               #[inline]
  166,458 ( 0.00%)      pub fn reserve(&mut self, additional: usize) {
  431,119 ( 0.01%)          infallible(self.try_reserve(additional))
  187,104 ( 0.00%)      }
        .           
        .               /// Reserve capacity for `additional` more elements to be inserted.
        .               ///
        .               /// May reserve more space to avoid frequent reallocations.
1,648,148 ( 0.02%)      pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
        .                   // prefer triple_mut() even if triple() would work
        .                   // so that the optimizer removes duplicated calls to it
        .                   // from callers like insert()
   13,911 ( 0.00%)          let (_, &mut len, cap) = self.triple_mut();
1,364,488 ( 0.02%)          if cap - len >= additional {
        .                       return Ok(());
        .                   }
        .                   let new_cap = len
        .                       .checked_add(additional)
        .                       .and_then(usize::checked_next_power_of_two)
        .                       .ok_or(CollectionAllocErr::CapacityOverflow)?;
      612 ( 0.00%)          self.try_grow(new_cap)
1,822,666 ( 0.03%)      }
        .           
        .               /// Reserve the minimum capacity for `additional` more elements to be inserted.
        .               ///
        .               /// Panics if the new capacity overflows `usize`.
        .               pub fn reserve_exact(&mut self, additional: usize) {
        .                   infallible(self.try_reserve_exact(additional))
        .               }
        .           
        .               /// Reserve the minimum capacity for `additional` more elements to be inserted.
        .               pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
        .                   let (_, &mut len, cap) = self.triple_mut();
   67,864 ( 0.00%)          if cap - len >= additional {
        .                       return Ok(());
        .                   }
        .                   let new_cap = len
        .                       .checked_add(additional)
        .                       .ok_or(CollectionAllocErr::CapacityOverflow)?;
        5 ( 0.00%)          self.try_grow(new_cap)
        5 ( 0.00%)      }
        .           
        .               /// Shrink the capacity of the vector as much as possible.
        .               ///
        .               /// When possible, this will move data from an external heap buffer to the vector's inline
        .               /// storage.
        .               pub fn shrink_to_fit(&mut self) {
        .                   if !self.spilled() {
        .                       return;
-- line 981 ----------------------------------------
-- line 999 ----------------------------------------
        .               /// If `len` is greater than or equal to the vector's current length, this has no
        .               /// effect.
        .               ///
        .               /// This does not re-allocate.  If you want the vector's capacity to shrink, call
        .               /// `shrink_to_fit` after truncating.
        .               pub fn truncate(&mut self, len: usize) {
        .                   unsafe {
        .                       let (ptr, len_ptr, _) = self.triple_mut();
   23,454 ( 0.00%)              while len < *len_ptr {
        .                           let last_index = *len_ptr - 1;
        .                           *len_ptr = last_index;
        .                           ptr::drop_in_place(ptr.add(last_index));
        .                       }
        .                   }
        .               }
        .           
        .               /// Extracts a slice containing the entire vector.
-- line 1015 ----------------------------------------
-- line 1044 ----------------------------------------
        .               pub fn clear(&mut self) {
        .                   self.truncate(0);
        .               }
        .           
        .               /// Remove and return the element at position `index`, shifting all elements after it to the
        .               /// left.
        .               ///
        .               /// Panics if `index` is out of bounds.
    1,500 ( 0.00%)      pub fn remove(&mut self, index: usize) -> A::Item {
        .                   unsafe {
        .                       let (mut ptr, len_ptr, _) = self.triple_mut();
    1,761 ( 0.00%)              let len = *len_ptr;
    7,695 ( 0.00%)              assert!(index < len);
   12,450 ( 0.00%)              *len_ptr = len - 1;
        .                       ptr = ptr.add(index);
        .                       let item = ptr::read(ptr);
    5,130 ( 0.00%)              ptr::copy(ptr.add(1), ptr, len - index - 1);
        .                       item
        .                   }
    1,875 ( 0.00%)      }
        .           
        .               /// Insert an element at position `index`, shifting all elements after it to the right.
        .               ///
        .               /// Panics if `index` is out of bounds.
   32,261 ( 0.00%)      pub fn insert(&mut self, index: usize, element: A::Item) {
        .                   self.reserve(1);
        .           
        .                   unsafe {
        .                       let (mut ptr, len_ptr, _) = self.triple_mut();
    2,989 ( 0.00%)              let len = *len_ptr;
    5,922 ( 0.00%)              assert!(index <= len);
   11,844 ( 0.00%)              *len_ptr = len + 1;
        .                       ptr = ptr.add(index);
    5,922 ( 0.00%)              ptr::copy(ptr, ptr.add(1), len - index);
        .                       ptr::write(ptr, element);
        .                   }
   20,532 ( 0.00%)      }
        .           
        .               /// Insert multiple elements at position `index`, shifting all following elements toward the
        .               /// back.
        .               pub fn insert_many<I: IntoIterator<Item = A::Item>>(&mut self, index: usize, iterable: I) {
        .                   let mut iter = iterable.into_iter();
        .                   if index == self.len() {
        .                       return self.extend(iter);
        .                   }
-- line 1088 ----------------------------------------
-- line 1201 ----------------------------------------
        .                   }
        .               }
        .           
        .               /// Retains only the elements specified by the predicate.
        .               ///
        .               /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
        .               /// This method operates in place and preserves the order of the retained
        .               /// elements.
   52,551 ( 0.00%)      pub fn retain<F: FnMut(&mut A::Item) -> bool>(&mut self, mut f: F) {
        .                   let mut del = 0;
        .                   let len = self.len();
        .                   for i in 0..len {
   22,928 ( 0.00%)              if !f(&mut self[i]) {
      156 ( 0.00%)                  del += 1;
    6,770 ( 0.00%)              } else if del > 0 {
       27 ( 0.00%)                  self.swap(i - del, i);
        .                       }
        .                   }
   11,678 ( 0.00%)          self.truncate(len - del);
   46,712 ( 0.00%)      }
        .           
        .               /// Removes consecutive duplicate elements.
        .               pub fn dedup(&mut self)
        .               where
        .                   A::Item: PartialEq<A::Item>,
        .               {
        .                   self.dedup_by(|a, b| a == b);
        .               }
-- line 1228 ----------------------------------------
-- line 1418 ----------------------------------------
        .                           capacity: len,
        .                           data: SmallVecData::from_inline(unsafe {
        .                               let mut data: MaybeUninit<A> = MaybeUninit::uninit();
        .                               ptr::copy_nonoverlapping(
        .                                   slice.as_ptr(),
        .                                   data.as_mut_ptr() as *mut A::Item,
        .                                   len,
        .                               );
    1,137 ( 0.00%)                      data
        .                           }),
        .                       }
        .                   } else {
        .                       let mut b = slice.to_vec();
        .                       let (ptr, cap) = (b.as_mut_ptr(), b.capacity());
        .                       mem::forget(b);
        .                       SmallVec {
        .                           capacity: cap,
-- line 1434 ----------------------------------------
-- line 1436 ----------------------------------------
        .                       }
        .                   }
        .               }
        .           
        .               /// Copy elements from a slice into the vector at position `index`, shifting any following
        .               /// elements toward the back.
        .               ///
        .               /// For slices of `Copy` types, this is more efficient than `insert`.
  288,184 ( 0.00%)      pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item]) {
        .                   self.reserve(slice.len());
        .           
        .                   let len = self.len();
   90,702 ( 0.00%)          assert!(index <= len);
        .           
        .                   unsafe {
        .                       let slice_ptr = slice.as_ptr();
        .                       let ptr = self.as_mut_ptr().add(index);
        .                       ptr::copy(ptr, ptr.add(slice.len()), len - index);
        .                       ptr::copy_nonoverlapping(slice_ptr, ptr, slice.len());
   60,468 ( 0.00%)              self.set_len(len + slice.len());
        .                   }
  241,872 ( 0.00%)      }
        .           
        .               /// Copy elements from a slice and append them to the vector.
        .               ///
        .               /// For slices of `Copy` types, this is more efficient than `extend`.
        .               #[inline]
        .               pub fn extend_from_slice(&mut self, slice: &[A::Item]) {
        .                   let len = self.len();
   87,308 ( 0.00%)          self.insert_from_slice(len, slice);
        .               }
        .           }
        .           
        .           impl<A: Array> SmallVec<A>
        .           where
        .               A::Item: Clone,
        .           {
        .               /// Resizes the vector so that its length is equal to `len`.
-- line 1473 ----------------------------------------
-- line 1489 ----------------------------------------
        .               /// Creates a `SmallVec` with `n` copies of `elem`.
        .               /// ```
        .               /// use smallvec::SmallVec;
        .               ///
        .               /// let v = SmallVec::<[char; 128]>::from_elem('d', 2);
        .               /// assert_eq!(v, SmallVec::from_buf(['d', 'd']));
        .               /// ```
        .               pub fn from_elem(elem: A::Item, n: usize) -> Self {
    5,034 ( 0.00%)          if n > Self::inline_capacity() {
        .                       vec![elem; n].into()
        .                   } else {
        .                       let mut v = SmallVec::<A>::new();
        .                       unsafe {
        .                           let (ptr, len_ptr, _) = v.triple_mut();
        .                           let mut local_len = SetLenOnDrop::new(len_ptr);
        .           
        .                           for i in 0..n {
        .                               ::core::ptr::write(ptr.add(i), elem.clone());
        .                               local_len.increment_len(1);
        .                           }
        .                       }
    7,473 ( 0.00%)              v
        .                   }
        .               }
        .           }
        .           
        .           impl<A: Array> ops::Deref for SmallVec<A> {
        .               type Target = [A::Item];
        .               #[inline]
        .               fn deref(&self) -> &[A::Item] {
-- line 1518 ----------------------------------------
-- line 1522 ----------------------------------------
        .                   }
        .               }
        .           }
        .           
        .           impl<A: Array> ops::DerefMut for SmallVec<A> {
        .               #[inline]
        .               fn deref_mut(&mut self) -> &mut [A::Item] {
        .                   unsafe {
   29,632 ( 0.00%)              let (ptr, &mut len, _) = self.triple_mut();
        .                       slice::from_raw_parts_mut(ptr, len)
        .                   }
        .               }
        .           }
        .           
        .           impl<A: Array> AsRef<[A::Item]> for SmallVec<A> {
        .               #[inline]
        .               fn as_ref(&self) -> &[A::Item] {
-- line 1538 ----------------------------------------
-- line 1716 ----------------------------------------
        .                   SmallVec::extend_from_slice(self, other)
        .               }
        .           }
        .           
        .           impl<A: Array> FromIterator<A::Item> for SmallVec<A> {
        .               #[inline]
        .               fn from_iter<I: IntoIterator<Item = A::Item>>(iterable: I) -> SmallVec<A> {
        .                   let mut v = SmallVec::new();
  526,332 ( 0.01%)          v.extend(iterable);
        .                   v
        .               }
        .           }
        .           
        .           impl<A: Array> Extend<A::Item> for SmallVec<A> {
2,164,847 ( 0.03%)      fn extend<I: IntoIterator<Item = A::Item>>(&mut self, iterable: I) {
  136,006 ( 0.00%)          let mut iter = iterable.into_iter();
        .                   let (lower_size_bound, _) = iter.size_hint();
   34,604 ( 0.00%)          self.reserve(lower_size_bound);
        .           
        .                   unsafe {
        .                       let (ptr, len_ptr, cap) = self.triple_mut();
        .                       let mut len = SetLenOnDrop::new(len_ptr);
  998,412 ( 0.01%)              while len.get() < cap {
  245,789 ( 0.00%)                  if let Some(out) = iter.next() {
        .                               ptr::write(ptr.add(len.get()), out);
        .                               len.increment_len(1);
        .                           } else {
        .                               return;
        .                           }
        .                       }
        .                   }
        .           
   76,941 ( 0.00%)          for elem in iter {
    8,062 ( 0.00%)              self.push(elem);
        .                   }
1,807,550 ( 0.03%)      }
        .           }
        .           
        .           impl<A: Array> fmt::Debug for SmallVec<A>
        .           where
        .               A::Item: fmt::Debug,
        .           {
        .               fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        .                   f.debug_list().entries(self.iter()).finish()
-- line 1759 ----------------------------------------
-- line 1764 ----------------------------------------
        .               #[inline]
        .               fn default() -> SmallVec<A> {
        .                   SmallVec::new()
        .               }
        .           }
        .           
        .           #[cfg(feature = "may_dangle")]
        .           unsafe impl<#[may_dangle] A: Array> Drop for SmallVec<A> {
1,838,344 ( 0.03%)      fn drop(&mut self) {
        .                   unsafe {
1,273,878 ( 0.02%)              if self.spilled() {
        .                           let (ptr, len) = self.data.heap();
        .                           Vec::from_raw_parts(ptr, len, self.capacity);
        .                       } else {
        .                           ptr::drop_in_place(&mut self[..]);
        .                       }
        .                   }
1,892,649 ( 0.03%)      }
        .           }
        .           
        .           #[cfg(not(feature = "may_dangle"))]
        .           impl<A: Array> Drop for SmallVec<A> {
        .               fn drop(&mut self) {
        .                   unsafe {
        .                       if self.spilled() {
        .                           let (ptr, len) = self.data.heap();
-- line 1789 ----------------------------------------
-- line 1888 ----------------------------------------
        .               A::Item: Clone,
        .           {
        .               fn clone(&self) -> IntoIter<A> {
        .                   SmallVec::from(self.as_slice()).into_iter()
        .               }
        .           }
        .           
        .           impl<A: Array> Drop for IntoIter<A> {
      919 ( 0.00%)      fn drop(&mut self) {
   38,112 ( 0.00%)          for _ in self {}
      872 ( 0.00%)      }
        .           }
        .           
        .           impl<A: Array> Iterator for IntoIter<A> {
        .               type Item = A::Item;
        .           
        .               #[inline]
        .               fn next(&mut self) -> Option<A::Item> {
  210,944 ( 0.00%)          if self.current == self.end {
      654 ( 0.00%)              None
        .                   } else {
        .                       unsafe {
        .                           let current = self.current;
  113,572 ( 0.00%)                  self.current += 1;
    3,738 ( 0.00%)                  Some(ptr::read(self.data.as_ptr().add(current)))
        .                       }
        .                   }
        .               }
        .           
        .               #[inline]
        .               fn size_hint(&self) -> (usize, Option<usize>) {
    6,259 ( 0.00%)          let size = self.end - self.current;
        .                   (size, Some(size))
        .               }
        .           }
        .           
        .           impl<A: Array> DoubleEndedIterator for IntoIter<A> {
        .               #[inline]
        .               fn next_back(&mut self) -> Option<A::Item> {
        .                   if self.current == self.end {
-- line 1927 ----------------------------------------
-- line 1955 ----------------------------------------
        .           impl<A: Array> IntoIterator for SmallVec<A> {
        .               type IntoIter = IntoIter<A>;
        .               type Item = A::Item;
        .               fn into_iter(mut self) -> Self::IntoIter {
        .                   unsafe {
        .                       // Set SmallVec len to zero as `IntoIter` drop handles dropping of the elements
        .                       let len = self.len();
        .                       self.set_len(0);
   15,451 ( 0.00%)              IntoIter {
  119,744 ( 0.00%)                  data: self,
        .                           current: 0,
        .                           end: len,
        .                       }
        .                   }
        .               }
        .           }
        .           
        .           impl<'a, A: Array> IntoIterator for &'a SmallVec<A> {
-- line 1972 ----------------------------------------
-- line 2000 ----------------------------------------
        .               len: &'a mut usize,
        .               local_len: usize,
        .           }
        .           
        .           impl<'a> SetLenOnDrop<'a> {
        .               #[inline]
        .               fn new(len: &'a mut usize) -> Self {
        .                   SetLenOnDrop {
  236,681 ( 0.00%)              local_len: *len,
        .                       len,
        .                   }
        .               }
        .           
        .               #[inline]
        .               fn get(&self) -> usize {
        .                   self.local_len
        .               }
        .           
        .               #[inline]
        .               fn increment_len(&mut self, increment: usize) {
  146,957 ( 0.00%)          self.local_len += increment;
        .               }
        .           }
        .           
        .           impl<'a> Drop for SetLenOnDrop<'a> {
        .               #[inline]
        .               fn drop(&mut self) {
  303,094 ( 0.00%)          *self.len = self.local_len;
        .               }
        .           }
        .           
        .           #[cfg(feature = "const_new")]
        .           impl<T, const N: usize> SmallVec<[T; N]> {
        .               /// Construct an empty vector.
        .               ///
        .               /// This is a `const` version of [`SmallVec::new`] that is enabled by the feature `const_new`, with the limitation that it only works for arrays.
-- line 2035 ----------------------------------------

3,884,330 ( 0.06%)  <counts for unidentified lines in /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/smallvec-1.7.0/src/lib.rs>

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs
--------------------------------------------------------------------------------
Ir                 

-- line 90 ----------------------------------------
        .           use std::collections::hash_map::Entry::{Occupied, Vacant};
        .           use std::mem;
        .           use std::ops::{Deref, DerefMut};
        .           
        .           // To avoid costly uniqueness checks, we require that `MatchSeq` always has a nonempty body.
        .           
        .           /// Either a sequence of token trees or a single one. This is used as the representation of the
        .           /// sequence of tokens that make up a matcher.
  585,791 ( 0.01%)  #[derive(Clone)]
        .           enum TokenTreeOrTokenTreeSlice<'tt> {
    2,622 ( 0.00%)      Tt(TokenTree),
  144,220 ( 0.00%)      TtSeq(&'tt [TokenTree]),
        .           }
        .           
        .           impl<'tt> TokenTreeOrTokenTreeSlice<'tt> {
        .               /// Returns the number of constituent top-level token trees of `self` (top-level in that it
        .               /// will not recursively descend into subtrees).
        .               fn len(&self) -> usize {
1,026,105 ( 0.02%)          match *self {
   10,820 ( 0.00%)              TtSeq(ref v) => v.len(),
        .                       Tt(ref tt) => tt.len(),
        .                   }
        .               }
        .           
        .               /// The `index`-th token tree of `self`.
        .               fn get_tt(&self, index: usize) -> TokenTree {
  198,649 ( 0.00%)          match *self {
   21,876 ( 0.00%)              TtSeq(ref v) => v[index].clone(),
  548,582 ( 0.01%)              Tt(ref tt) => tt.get_tt(index),
        .                   }
        .               }
        .           }
        .           
        .           /// An unzipping of `TokenTree`s... see the `stack` field of `MatcherPos`.
        .           ///
        .           /// This is used by `inner_parse_loop` to keep track of delimited submatchers that we have
        .           /// descended into.
   97,198 ( 0.00%)  #[derive(Clone)]
        .           struct MatcherTtFrame<'tt> {
        .               /// The "parent" matcher that we are descending into.
        .               elts: TokenTreeOrTokenTreeSlice<'tt>,
        .               /// The position of the "dot" in `elts` at the time we descended.
   48,599 ( 0.00%)      idx: usize,
        .           }
        .           
        .           type NamedMatchVec = SmallVec<[NamedMatch; 4]>;
        .           
        .           /// Represents a single "position" (aka "matcher position", aka "item"), as
        .           /// described in the module documentation.
        .           ///
        .           /// Here:
-- line 140 ----------------------------------------
-- line 147 ----------------------------------------
        .           ///   position refers to.
        .           ///
        .           /// It is important to distinguish these two lifetimes because we have a
        .           /// `SmallVec<TokenTreeOrTokenTreeSlice<'tt>>` below, and the destructor of
        .           /// that is considered to possibly access the data from its elements (it lacks
        .           /// a `#[may_dangle]` attribute). As a result, the compiler needs to know that
        .           /// all the elements in that `SmallVec` strictly outlive the root stack slot
        .           /// lifetime. By separating `'tt` from `'root`, we can show that.
2,292,190 ( 0.03%)  #[derive(Clone)]
        .           struct MatcherPos<'root, 'tt> {
        .               /// The token or sequence of tokens that make up the matcher
        .               top_elts: TokenTreeOrTokenTreeSlice<'tt>,
        .           
        .               /// The position of the "dot" in this matcher
   48,770 ( 0.00%)      idx: usize,
        .           
        .               /// For each named metavar in the matcher, we keep track of token trees matched against the
        .               /// metavar by the black box parser. In particular, there may be more than one match per
        .               /// metavar if we are in a repetition (each repetition matches each of the variables).
        .               /// Moreover, matchers and repetitions can be nested; the `matches` field is shared (hence the
        .               /// `Rc`) among all "nested" matchers. `match_lo`, `match_cur`, and `match_hi` keep track of
        .               /// the current position of the `self` matcher position in the shared `matches` list.
        .               ///
        .               /// Also, note that while we are descending into a sequence, matchers are given their own
        .               /// `matches` vector. Only once we reach the end of a full repetition of the sequence do we add
        .               /// all bound matches from the submatcher into the shared top-level `matches` vector. If `sep`
        .               /// and `up` are `Some`, then `matches` is _not_ the shared top-level list. Instead, if one
        .               /// wants the shared `matches`, one should use `up.matches`.
  195,080 ( 0.00%)      matches: Box<[Lrc<NamedMatchVec>]>,
        .               /// The position in `matches` corresponding to the first metavar in this matcher's sequence of
        .               /// token trees. In other words, the first metavar in the first token of `top_elts` corresponds
        .               /// to `matches[match_lo]`.
   48,770 ( 0.00%)      match_lo: usize,
        .               /// The position in `matches` corresponding to the metavar we are currently trying to match
        .               /// against the source token stream. `match_lo <= match_cur <= match_hi`.
        .               match_cur: usize,
        .               /// Similar to `match_lo` except `match_hi` is the position in `matches` of the _last_ metavar
        .               /// in this matcher.
   48,770 ( 0.00%)      match_hi: usize,
        .           
        .               // The following fields are used if we are matching a repetition. If we aren't, they should be
        .               // `None`.
        .               /// The KleeneOp of this sequence if we are in a repetition.
   48,770 ( 0.00%)      seq_op: Option<mbe::KleeneOp>,
        .           
        .               /// The separator if we are in a repetition.
        .               sep: Option<Token>,
        .           
        .               /// The "parent" matcher position if we are in a repetition. That is, the matcher position just
        .               /// before we enter the sequence.
   97,540 ( 0.00%)      up: Option<MatcherPosHandle<'root, 'tt>>,
        .           
        .               /// Specifically used to "unzip" token trees. By "unzip", we mean to unwrap the delimiters from
        .               /// a delimited token tree (e.g., something wrapped in `(` `)`) or to get the contents of a doc
        .               /// comment...
        .               ///
        .               /// When matching against matchers with nested delimited submatchers (e.g., `pat ( pat ( .. )
        .               /// pat ) pat`), we need to keep track of the matchers we are descending into. This stack does
        .               /// that where the bottom of the stack is the outermost matcher.
        .               /// Also, throughout the comments, this "descent" is often referred to as "unzipping"...
        .               stack: SmallVec<[MatcherTtFrame<'tt>; 1]>,
        .           }
        .           
        .           impl<'root, 'tt> MatcherPos<'root, 'tt> {
        .               /// Adds `m` as a named match for the `idx`-th metavar.
        .               fn push_match(&mut self, idx: usize, m: NamedMatch) {
  388,592 ( 0.01%)          let matches = Lrc::make_mut(&mut self.matches[idx]);
        .                   matches.push(m);
        .               }
        .           }
        .           
        .           // Lots of MatcherPos instances are created at runtime. Allocating them on the
        .           // heap is slow. Furthermore, using SmallVec<MatcherPos> to allocate them all
        .           // on the stack is also slow, because MatcherPos is quite a large type and
        .           // instances get moved around a lot between vectors, which requires lots of
-- line 221 ----------------------------------------
-- line 226 ----------------------------------------
        .           // and this type is used to encapsulate both cases.
        .           enum MatcherPosHandle<'root, 'tt> {
        .               Ref(&'root mut MatcherPos<'root, 'tt>),
        .               Box(Box<MatcherPos<'root, 'tt>>),
        .           }
        .           
        .           impl<'root, 'tt> Clone for MatcherPosHandle<'root, 'tt> {
        .               // This always produces a new Box.
  195,080 ( 0.00%)      fn clone(&self) -> Self {
   97,540 ( 0.00%)          MatcherPosHandle::Box(match *self {
  129,249 ( 0.00%)              MatcherPosHandle::Ref(ref r) => Box::new((**r).clone()),
        .                       MatcherPosHandle::Box(ref b) => b.clone(),
        .                   })
  292,620 ( 0.00%)      }
        .           }
        .           
        .           impl<'root, 'tt> Deref for MatcherPosHandle<'root, 'tt> {
        .               type Target = MatcherPos<'root, 'tt>;
        .               fn deref(&self) -> &Self::Target {
        .                   match *self {
        .                       MatcherPosHandle::Ref(ref r) => r,
        .                       MatcherPosHandle::Box(ref b) => b,
-- line 247 ----------------------------------------
-- line 272 ----------------------------------------
        .           
        .           /// A `ParseResult` where the `Success` variant contains a mapping of
        .           /// `MacroRulesNormalizedIdent`s to `NamedMatch`es. This represents the mapping
        .           /// of metavars to the token trees they bind to.
        .           crate type NamedParseResult = ParseResult<FxHashMap<MacroRulesNormalizedIdent, NamedMatch>>;
        .           
        .           /// Count how many metavars are named in the given matcher `ms`.
        .           pub(super) fn count_names(ms: &[TokenTree]) -> usize {
  102,160 ( 0.00%)      ms.iter().fold(0, |count, elt| {
   51,080 ( 0.00%)          count
  153,240 ( 0.00%)              + match *elt {
   15,108 ( 0.00%)                  TokenTree::Sequence(_, ref seq) => seq.num_captures,
    6,151 ( 0.00%)                  TokenTree::Delimited(_, ref delim) => count_names(&delim.tts),
        .                           TokenTree::MetaVar(..) => 0,
        .                           TokenTree::MetaVarDecl(..) => 1,
        .                           TokenTree::Token(..) => 0,
        .                       }
  127,700 ( 0.00%)      })
        .           }
        .           
        .           /// `len` `Vec`s (initially shared and empty) that will store matches of metavars.
        .           fn create_matches(len: usize) -> Box<[Lrc<NamedMatchVec>]> {
    8,748 ( 0.00%)      if len == 0 {
        .                   vec![]
        .               } else {
        .                   let empty_matches = Lrc::new(SmallVec::new());
        .                   vec![empty_matches; len]
        .               }
        .               .into_boxed_slice()
        .           }
        .           
        .           /// Generates the top-level matcher position in which the "dot" is before the first token of the
        .           /// matcher `ms`.
        .           fn initial_matcher_pos<'root, 'tt>(ms: &'tt [TokenTree]) -> MatcherPos<'root, 'tt> {
        .               let match_idx_hi = count_names(ms);
        .               let matches = create_matches(match_idx_hi);
   25,740 ( 0.00%)      MatcherPos {
        .                   // Start with the top level matcher given to us
        .                   top_elts: TtSeq(ms), // "elts" is an abbr. for "elements"
        .                   // The "dot" is before the first token of the matcher
        .                   idx: 0,
        .           
        .                   // Initialize `matches` to a bunch of empty `Vec`s -- one for each metavar in `top_elts`.
        .                   // `match_lo` for `top_elts` is 0 and `match_hi` is `matches.len()`. `match_cur` is 0 since
        .                   // we haven't actually matched anything yet.
-- line 316 ----------------------------------------
-- line 340 ----------------------------------------
        .           /// particular token tree.
        .           ///
        .           /// The width of each `MatchedSeq` in the `NamedMatch`, and the identity of
        .           /// the `MatchedNonterminal`s, will depend on the token tree it was applied
        .           /// to: each `MatchedSeq` corresponds to a single `TTSeq` in the originating
        .           /// token tree. The depth of the `NamedMatch` structure will therefore depend
        .           /// only on the nesting depth of `ast::TTSeq`s in the originating
        .           /// token tree it was derived from.
      322 ( 0.00%)  #[derive(Debug, Clone)]
        .           crate enum NamedMatch {
        .               MatchedSeq(Lrc<NamedMatchVec>),
        .               MatchedNonterminal(Lrc<Nonterminal>),
        .           }
        .           
        .           /// Takes a sequence of token trees `ms` representing a matcher which successfully matched input
        .           /// and an iterator of items that matched input and produces a `NamedParseResult`.
        .           fn nameize<I: Iterator<Item = NamedMatch>>(
-- line 356 ----------------------------------------
-- line 357 ----------------------------------------
        .               sess: &ParseSess,
        .               ms: &[TokenTree],
        .               mut res: I,
        .           ) -> NamedParseResult {
        .               // Recursively descend into each type of matcher (e.g., sequences, delimited, metavars) and make
        .               // sure that each metavar has _exactly one_ binding. If a metavar does not have exactly one
        .               // binding, then there is an error. If it does, then we insert the binding into the
        .               // `NamedParseResult`.
    8,393 ( 0.00%)      fn n_rec<I: Iterator<Item = NamedMatch>>(
        .                   sess: &ParseSess,
        .                   m: &TokenTree,
        .                   res: &mut I,
        .                   ret_val: &mut FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
        .               ) -> Result<(), (rustc_span::Span, String)> {
    4,563 ( 0.00%)          match *m {
        .                       TokenTree::Sequence(_, ref seq) => {
      178 ( 0.00%)                  for next_m in &seq.tts {
    1,494 ( 0.00%)                      n_rec(sess, next_m, res.by_ref(), ret_val)?
        .                           }
        .                       }
        .                       TokenTree::Delimited(_, ref delim) => {
       69 ( 0.00%)                  for next_m in &delim.tts {
      684 ( 0.00%)                      n_rec(sess, next_m, res.by_ref(), ret_val)?;
        .                           }
        .                       }
        .                       TokenTree::MetaVarDecl(span, _, None) => {
        .                           if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
        .                               return Err((span, "missing fragment specifier".to_string()));
        .                           }
        .                       }
    2,244 ( 0.00%)              TokenTree::MetaVarDecl(sp, bind_name, _) => match ret_val
    1,496 ( 0.00%)                  .entry(MacroRulesNormalizedIdent::new(bind_name))
        .                       {
        .                           Vacant(spot) => {
        .                               spot.insert(res.next().unwrap());
        .                           }
        .                           Occupied(..) => return Err((sp, format!("duplicated bind name: {}", bind_name))),
        .                       },
        .                       TokenTree::MetaVar(..) | TokenTree::Token(..) => (),
        .                   }
        .           
      763 ( 0.00%)          Ok(())
    6,104 ( 0.00%)      }
        .           
        .               let mut ret_val = FxHashMap::default();
        .               for m in ms {
    4,090 ( 0.00%)          match n_rec(sess, m, res.by_ref(), &mut ret_val) {
        .                       Ok(_) => {}
        .                       Err((sp, msg)) => return Error(sp, msg),
        .                   }
        .               }
        .           
    1,647 ( 0.00%)      Success(ret_val)
        .           }
        .           
        .           /// Performs a token equality check, ignoring syntax context (that is, an unhygienic comparison)
        .           fn token_name_eq(t1: &Token, t2: &Token) -> bool {
  265,595 ( 0.00%)      if let (Some((ident1, is_raw1)), Some((ident2, is_raw2))) = (t1.ident(), t2.ident()) {
    1,502 ( 0.00%)          ident1.name == ident2.name && is_raw1 == is_raw2
  360,969 ( 0.01%)      } else if let (Some(ident1), Some(ident2)) = (t1.lifetime(), t2.lifetime()) {
        .                   ident1.name == ident2.name
        .               } else {
  154,497 ( 0.00%)          t1.kind == t2.kind
        .               }
        .           }
        .           
        .           /// Process the matcher positions of `cur_items` until it is empty. In the process, this will
        .           /// produce more items in `next_items`, `eof_items`, and `bb_items`.
        .           ///
        .           /// For more info about the how this happens, see the module-level doc comments and the inline
        .           /// comments of this function.
-- line 427 ----------------------------------------
-- line 443 ----------------------------------------
        .               sess: &ParseSess,
        .               cur_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
        .               next_items: &mut Vec<MatcherPosHandle<'root, 'tt>>,
        .               eof_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
        .               bb_items: &mut SmallVec<[MatcherPosHandle<'root, 'tt>; 1]>,
        .               token: &Token,
        .           ) -> ParseResult<()> {
        .               // Pop items from `cur_items` until it is empty.
  616,464 ( 0.01%)      while let Some(mut item) = cur_items.pop() {
        .                   // When unzipped trees end, remove them. This corresponds to backtracking out of a
        .                   // delimited submatcher into which we already descended. In backtracking out again, we need
        .                   // to advance the "dot" past the delimiters in the outer matcher.
1,953,897 ( 0.03%)          while item.idx >= item.top_elts.len() {
    3,058 ( 0.00%)              match item.stack.pop() {
        .                           Some(MatcherTtFrame { elts, idx }) => {
   13,761 ( 0.00%)                      item.top_elts = elts;
    6,116 ( 0.00%)                      item.idx = idx + 1;
        .                           }
        .                           None => break,
        .                       }
        .                   }
        .           
        .                   // Get the current position of the "dot" (`idx`) in `item` and the number of token trees in
        .                   // the matcher (`len`).
        .                   let idx = item.idx;
        .                   let len = item.top_elts.len();
        .           
        .                   // If `idx >= len`, then we are at or past the end of the matcher of `item`.
  359,957 ( 0.01%)          if idx >= len {
        .                       // We are repeating iff there is a parent. If the matcher is inside of a repetition,
        .                       // then we could be at the end of a sequence or at the beginning of the next
        .                       // repetition.
   48,203 ( 0.00%)              if item.up.is_some() {
        .                           // At this point, regardless of whether there is a separator, we should add all
        .                           // matches from the complete repetition of the sequence to the shared, top-level
        .                           // `matches` list (actually, `up.matches`, which could itself not be the top-level,
        .                           // but anyway...). Moreover, we add another item to `cur_items` in which the "dot"
        .                           // is at the end of the `up` matcher. This ensures that the "dot" in the `up`
        .                           // matcher is also advanced sufficiently.
        .                           //
        .                           // NOTE: removing the condition `idx == len` allows trailing separators.
   94,518 ( 0.00%)                  if idx == len {
        .                               // Get the `up` matcher
        .                               let mut new_pos = item.up.clone().unwrap();
        .           
        .                               // Add matches from this repetition to the `matches` of `up`
   94,152 ( 0.00%)                      for idx in item.match_lo..item.match_hi {
  235,395 ( 0.00%)                          let sub = item.matches[idx].clone();
  141,237 ( 0.00%)                          new_pos.push_match(idx, MatchedSeq(sub));
        .                               }
        .           
        .                               // Move the "dot" past the repetition in `up`
   93,953 ( 0.00%)                      new_pos.match_cur = item.match_hi;
  282,456 ( 0.00%)                      new_pos.idx += 1;
        .                               cur_items.push(new_pos);
        .                           }
        .           
        .                           // Check if we need a separator.
   47,076 ( 0.00%)                  if idx == len && item.sep.is_some() {
        .                               // We have a separator, and it is the current token. We can advance past the
        .                               // separator token.
      408 ( 0.00%)                      if item.sep.as_ref().map_or(false, |sep| token_name_eq(token, sep)) {
    1,281 ( 0.00%)                          item.idx += 1;
        .                                   next_items.push(item);
        .                               }
        .                           }
        .                           // We don't need a separator. Move the "dot" back to the beginning of the matcher
        .                           // and try to match again UNLESS we are only allowed to have _one_ repetition.
   47,055 ( 0.00%)                  else if item.seq_op != Some(mbe::KleeneOp::ZeroOrOne) {
   94,078 ( 0.00%)                      item.match_cur = item.match_lo;
  188,156 ( 0.00%)                      item.idx = 0;
        .                               cur_items.push(item);
        .                           }
        .                       }
        .                       // If we are not in a repetition, then being at the end of a matcher means that we have
        .                       // reached the potential end of the input.
        .                       else {
        .                           eof_items.push(item);
        .                       }
        .                   }
        .                   // We are in the middle of a matcher.
        .                   else {
        .                       // Look at what token in the matcher we are trying to match the current token (`token`)
        .                       // against. Depending on that, we may generate new items.
1,065,679 ( 0.02%)              match item.top_elts.get_tt(idx) {
        .                           // Need to descend into a sequence
    8,741 ( 0.00%)                  TokenTree::Sequence(sp, seq) => {
        .                               // Examine the case where there are 0 matches of this sequence. We are
        .                               // implicitly disallowing OneOrMore from having 0 matches here. Thus, that will
        .                               // result in a "no rules expected token" error by virtue of this matcher not
        .                               // working.
    3,618 ( 0.00%)                      if seq.kleene.op == mbe::KleeneOp::ZeroOrMore
        .                                   || seq.kleene.op == mbe::KleeneOp::ZeroOrOne
        .                               {
    3,388 ( 0.00%)                          let mut new_item = item.clone();
    6,776 ( 0.00%)                          new_item.match_cur += seq.num_captures;
    8,470 ( 0.00%)                          new_item.idx += 1;
   10,164 ( 0.00%)                          for idx in item.match_cur..item.match_cur + seq.num_captures {
    4,404 ( 0.00%)                              new_item.push_match(idx, MatchedSeq(Lrc::new(smallvec![])));
        .                                   }
        .                                   cur_items.push(new_item);
        .                               }
        .           
    1,809 ( 0.00%)                      let matches = create_matches(item.matches.len());
   21,708 ( 0.00%)                      cur_items.push(MatcherPosHandle::Box(Box::new(MatcherPos {
    1,809 ( 0.00%)                          stack: smallvec![],
        .                                   sep: seq.separator.clone(),
    1,809 ( 0.00%)                          seq_op: Some(seq.kleene.op),
        .                                   idx: 0,
    9,045 ( 0.00%)                          matches,
    3,618 ( 0.00%)                          match_lo: item.match_cur,
        .                                   match_cur: item.match_cur,
    3,618 ( 0.00%)                          match_hi: item.match_cur + seq.num_captures,
        .                                   up: Some(item),
   12,663 ( 0.00%)                          top_elts: Tt(TokenTree::Sequence(sp, seq)),
        .                               })));
        .                           }
        .           
        .                           // We need to match a metavar (but the identifier is invalid)... this is an error
        .                           TokenTree::MetaVarDecl(span, _, None) => {
        .                               if sess.missing_fragment_specifiers.borrow_mut().remove(&span).is_some() {
        .                                   return Error(span, "missing fragment specifier".to_string());
        .                               }
-- line 565 ----------------------------------------
-- line 568 ----------------------------------------
        .                           // We need to match a metavar with a valid ident... call out to the black-box
        .                           // parser by adding an item to `bb_items`.
        .                           TokenTree::MetaVarDecl(_, _, Some(kind)) => {
        .                               // Built-in nonterminals never start with these tokens, so we can eliminate
        .                               // them from consideration.
        .                               //
        .                               // We use the span of the metavariable declaration to determine any
        .                               // edition-specific matching behavior for non-terminals.
  250,880 ( 0.00%)                      if Parser::nonterminal_may_begin_with(kind, token) {
        .                                   bb_items.push(item);
        .                               }
        .                           }
        .           
        .                           // We need to descend into a delimited submatcher or a doc comment. To do this, we
        .                           // push the current matcher onto a stack and push a new item containing the
        .                           // submatcher onto `cur_items`.
        .                           //
        .                           // At the beginning of the loop, if we reach the end of the delimited submatcher,
        .                           // we pop the stack to backtrack out of the descent.
    8,165 ( 0.00%)                  seq @ (TokenTree::Delimited(..)
        .                           | TokenTree::Token(Token { kind: DocComment(..), .. })) => {
        .                               let lower_elts = mem::replace(&mut item.top_elts, Tt(seq));
    1,633 ( 0.00%)                      let idx = item.idx;
   11,431 ( 0.00%)                      item.stack.push(MatcherTtFrame { elts: lower_elts, idx });
    6,532 ( 0.00%)                      item.idx = 0;
        .                               cur_items.push(item);
        .                           }
        .           
        .                           // We just matched a normal token. We can just advance the parser.
  124,551 ( 0.00%)                  TokenTree::Token(t) if token_name_eq(&t, token) => {
   30,555 ( 0.00%)                      item.idx += 1;
        .                               next_items.push(item);
        .                           }
        .           
        .                           // There was another token that was not `token`... This means we can't add any
        .                           // rules. NOTE that this is not necessarily an error unless _all_ items in
        .                           // `cur_items` end up doing this. There may still be some other matchers that do
        .                           // end up working out.
        .                           TokenTree::Token(..) | TokenTree::MetaVar(..) => {}
        .                       }
  573,695 ( 0.01%)          }
  208,560 ( 0.00%)      }
        .           
        .               // Yay a successful parse (so far)!
        .               Success(())
        .           }
        .           
        .           /// Use the given sequence of token trees (`ms`) as a matcher. Match the token
        .           /// stream from the given `parser` against it and return the match.
   17,160 ( 0.00%)  pub(super) fn parse_tt(
        .               parser: &mut Cow<'_, Parser<'_>>,
        .               ms: &[TokenTree],
        .               macro_name: Ident,
        .           ) -> NamedParseResult {
        .               // A queue of possible matcher positions. We initialize it with the matcher position in which
        .               // the "dot" is before the first token of the first token tree in `ms`. `inner_parse_loop` then
        .               // processes all of these possible matcher positions and produces possible next positions into
        .               // `next_items`. After some post-processing, the contents of `next_items` replenish `cur_items`
        .               // and we start over again.
        .               //
        .               // This MatcherPos instance is allocated on the stack. All others -- and
        .               // there are frequently *no* others! -- are allocated on the heap.
        .               let mut initial = initial_matcher_pos(ms);
    8,580 ( 0.00%)      let mut cur_items = smallvec![MatcherPosHandle::Ref(&mut initial)];
        .               let mut next_items = Vec::new();
        .           
        .               loop {
        .                   // Matcher positions black-box parsed by parser.rs (`parser`)
        .                   let mut bb_items = SmallVec::new();
        .           
        .                   // Matcher positions that would be valid if the macro invocation was over now
        .                   let mut eof_items = SmallVec::new();
   54,682 ( 0.00%)          assert!(next_items.is_empty());
        .           
        .                   // Process `cur_items` until either we have finished the input or we need to get some
        .                   // parsing from the black-box parser done. The result is that `next_items` will contain a
        .                   // bunch of possible next matcher positions in `next_items`.
        .                   match inner_parse_loop(
        .                       parser.sess,
        .                       &mut cur_items,
        .                       &mut next_items,
-- line 648 ----------------------------------------
-- line 652 ----------------------------------------
        .                   ) {
        .                       Success(_) => {}
        .                       Failure(token, msg) => return Failure(token, msg),
        .                       Error(sp, msg) => return Error(sp, msg),
        .                       ErrorReported => return ErrorReported,
        .                   }
        .           
        .                   // inner parse loop handled all cur_items, so it's empty
   54,682 ( 0.00%)          assert!(cur_items.is_empty());
        .           
        .                   // We need to do some post processing after the `inner_parser_loop`.
        .                   //
        .                   // Error messages here could be improved with links to original rules.
        .           
        .                   // If we reached the EOF, check that there is EXACTLY ONE possible matcher. Otherwise,
        .                   // either the parse is ambiguous (which should never happen) or there is a syntax error.
  273,410 ( 0.00%)          if parser.token == token::Eof {
      734 ( 0.00%)              if eof_items.len() == 1 {
        .                           let matches =
      740 ( 0.00%)                      eof_items[0].matches.iter_mut().map(|dv| Lrc::make_mut(dv).pop().unwrap());
      549 ( 0.00%)                  return nameize(parser.sess, ms, matches);
        .                       } else if eof_items.len() > 1 {
        .                           return Error(
        .                               parser.token.span,
        .                               "ambiguity: multiple successful parses".to_string(),
        .                           );
        .                       } else {
        9 ( 0.00%)                  return Failure(
        3 ( 0.00%)                      Token::new(
        .                                   token::Eof,
        4 ( 0.00%)                          if parser.token.span.is_dummy() {
        .                                       parser.token.span
        .                                   } else {
        .                                       parser.token.span.shrink_to_hi()
        .                                   },
        .                               ),
        .                               "missing tokens in macro arguments",
        .                           );
        .                       }
        .                   }
        .                   // Performance hack: eof_items may share matchers via Rc with other things that we want
        .                   // to modify. Dropping eof_items now may drop these refcounts to 1, preventing an
        .                   // unnecessary implicit clone later in Rc::make_mut.
  217,992 ( 0.00%)          drop(eof_items);
        .           
        .                   // If there are no possible next positions AND we aren't waiting for the black-box parser,
        .                   // then there is a syntax error.
  169,391 ( 0.00%)          if bb_items.is_empty() && next_items.is_empty() {
   19,916 ( 0.00%)              return Failure(parser.token.clone(), "no rules expected this token in macro call");
        .                   }
        .                   // Another possibility is that we need to call out to parse some rust nonterminal
        .                   // (black-box) parser. However, if there is not EXACTLY ONE of these, something is wrong.
  194,404 ( 0.00%)          else if (!bb_items.is_empty() && !next_items.is_empty()) || bb_items.len() > 1 {
        .                       let nts = bb_items
        .                           .iter()
        .                           .map(|item| match item.top_elts.get_tt(item.idx) {
        .                               TokenTree::MetaVarDecl(_, bind, Some(kind)) => format!("{} ('{}')", kind, bind),
        .                               _ => panic!(),
        .                           })
        .                           .collect::<Vec<String>>()
        .                           .join(" or ");
-- line 712 ----------------------------------------
-- line 721 ----------------------------------------
        .                                   n => format!("built-in NTs {} or {} other options.", nts, n),
        .                               }
        .                           ),
        .                       );
        .                   }
        .                   // Dump all possible `next_items` into `cur_items` for the next iteration.
        .                   else if !next_items.is_empty() {
        .                       // Now process the next token
   13,095 ( 0.00%)              cur_items.extend(next_items.drain(..));
    4,365 ( 0.00%)              parser.to_mut().bump();
        .                   }
        .                   // Finally, we have the case where we need to call the black-box parser to get some
        .                   // nonterminal.
        .                   else {
        .                       assert_eq!(bb_items.len(), 1);
        .           
   97,202 ( 0.00%)              let mut item = bb_items.pop().unwrap();
  385,799 ( 0.01%)              if let TokenTree::MetaVarDecl(span, _, Some(kind)) = item.top_elts.get_tt(item.idx) {
   48,601 ( 0.00%)                  let match_cur = item.match_cur;
        .                           // We use the span of the metavariable declaration to determine any
        .                           // edition-specific matching behavior for non-terminals.
  291,776 ( 0.00%)                  let nt = match parser.to_mut().parse_nonterminal(kind) {
        .                               Err(mut err) => {
        .                                   err.span_label(
        .                                       span,
        .                                       format!("while parsing argument for this `{}` macro fragment", kind),
        .                                   )
        .                                   .emit();
        .                                   return ErrorReported;
        .                               }
  291,606 ( 0.00%)                      Ok(nt) => nt,
        .                           };
  194,404 ( 0.00%)                  item.push_match(match_cur, MatchedNonterminal(Lrc::new(nt)));
  194,404 ( 0.00%)                  item.idx += 1;
  291,606 ( 0.00%)                  item.match_cur += 1;
        .                       } else {
        .                           unreachable!()
        .                       }
        .                       cur_items.push(item);
        .                   }
        .           
  105,932 ( 0.00%)          assert!(!cur_items.is_empty());
        .               }
   15,444 ( 0.00%)  }

1,913,339 ( 0.03%)  <counts for unidentified lines in /usr/home/liquid/rust/worktree-benchmarking/compiler/rustc_expand/src/mbe/macro_parser.rs>

--------------------------------------------------------------------------------
-- Auto-annotated source: /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.12.0/src/raw/mod.rs
--------------------------------------------------------------------------------
Ir                  

-- line 111 ----------------------------------------
         .           const EMPTY: u8 = 0b1111_1111;
         .           
         .           /// Control byte value for a deleted bucket.
         .           const DELETED: u8 = 0b1000_0000;
         .           
         .           /// Checks whether a control byte represents a full bucket (top bit is clear).
         .           #[inline]
         .           fn is_full(ctrl: u8) -> bool {
 1,524,610 ( 0.02%)      ctrl & 0x80 == 0
         .           }
         .           
         .           /// Checks whether a control byte represents a special value (top bit is set).
         .           #[inline]
         .           fn is_special(ctrl: u8) -> bool {
         .               ctrl & 0x80 != 0
         .           }
         .           
         .           /// Checks whether a special control value is EMPTY (just check 1 bit).
         .           #[inline]
         .           fn special_is_empty(ctrl: u8) -> bool {
         .               debug_assert!(is_special(ctrl));
   112,412 ( 0.00%)      ctrl & 0x01 != 0
         .           }
         .           
         .           /// Primary hash function, used to select the initial bucket to probe from.
         .           #[inline]
         .           #[allow(clippy::cast_possible_truncation)]
         .           fn h1(hash: u64) -> usize {
         .               // On 32-bit platforms we simply ignore the higher hash bits.
         .               hash as usize
-- line 140 ----------------------------------------
-- line 143 ----------------------------------------
         .           /// Secondary hash function, saved in the low 7 bits of the control byte.
         .           #[inline]
         .           #[allow(clippy::cast_possible_truncation)]
         .           fn h2(hash: u64) -> u8 {
         .               // Grab the top 7 bits of the hash. While the hash is normally a full 64-bit
         .               // value, some hash functions (such as FxHash) produce a usize result
         .               // instead, which means that the top 32 bits are 0 on 32-bit platforms.
         .               let hash_len = usize::min(mem::size_of::<usize>(), mem::size_of::<u64>());
27,830,026 ( 0.42%)      let top7 = hash >> (hash_len * 8 - 7);
         .               (top7 & 0x7f) as u8 // truncation
         .           }
         .           
         .           /// Probe sequence based on triangular numbers, which is guaranteed (since our
         .           /// table size is a power of two) to visit every group of elements exactly once.
         .           ///
         .           /// A triangular probe has us jump by 1 more group every time. So first we
         .           /// jump by 1 group (meaning we just continue our linear scan), then 2 groups
-- line 159 ----------------------------------------
-- line 170 ----------------------------------------
         .               #[inline]
         .               fn move_next(&mut self, bucket_mask: usize) {
         .                   // We should have found an empty bucket by now and ended the probe.
         .                   debug_assert!(
         .                       self.stride <= bucket_mask,
         .                       "Went past end of probe sequence"
         .                   );
         .           
   218,614 ( 0.00%)          self.stride += Group::WIDTH;
   218,614 ( 0.00%)          self.pos += self.stride;
   183,095 ( 0.00%)          self.pos &= bucket_mask;
         .               }
         .           }
         .           
         .           /// Returns the number of buckets needed to hold the given number of items,
         .           /// taking the maximum load factor into account.
         .           ///
         .           /// Returns `None` if an overflow occurs.
         .           // Workaround for emscripten bug emscripten-core/emscripten-fastcomp#258
         .           #[cfg_attr(target_os = "emscripten", inline(never))]
         .           #[cfg_attr(not(target_os = "emscripten"), inline)]
         .           fn capacity_to_buckets(cap: usize) -> Option<usize> {
         .               debug_assert_ne!(cap, 0);
         .           
         .               // For small tables we require at least 1 empty bucket so that lookups are
         .               // guaranteed to terminate if an element doesn't exist in the table.
    86,616 ( 0.00%)      if cap < 8 {
         .                   // We don't bother with a table size of 2 buckets since that can only
         .                   // hold a single element. Instead we skip directly to a 4 bucket table
         .                   // which can hold 3 elements.
   180,055 ( 0.00%)          return Some(if cap < 4 { 4 } else { 8 });
         .               }
         .           
         .               // Otherwise require 1/8 buckets to be empty (87.5% load)
         .               //
         .               // Be careful when modifying this, calculate_layout relies on the
         .               // overflow check here.
    43,782 ( 0.00%)      let adjusted_cap = cap.checked_mul(8)? / 7;
         .           
         .               // Any overflows will have been caught by the checked_mul. Also, any
         .               // rounding errors from the division above will be cleaned up by
         .               // next_power_of_two (which can't overflow because of the previous division).
         .               Some(adjusted_cap.next_power_of_two())
         .           }
         .           
         .           /// Returns the maximum effective capacity for the given bucket mask, taking
         .           /// the maximum load factor into account.
         .           #[inline]
         .           fn bucket_mask_to_capacity(bucket_mask: usize) -> usize {
   238,793 ( 0.00%)      if bucket_mask < 8 {
         .                   // For tables with 1/2/4/8 buckets, we always reserve one empty slot.
         .                   // Keep in mind that the bucket mask is one less than the bucket count.
         .                   bucket_mask
         .               } else {
         .                   // For larger tables we reserve 12.5% of the slots as empty.
    59,550 ( 0.00%)          ((bucket_mask + 1) / 8) * 7
         .               }
         .           }
         .           
         .           /// Helper which allows the max calculation for ctrl_align to be statically computed for each T
         .           /// while keeping the rest of `calculate_layout_for` independent of `T`
         .           #[derive(Copy, Clone)]
         .           struct TableLayout {
         .               size: usize,
-- line 233 ----------------------------------------
-- line 246 ----------------------------------------
         .           
         .               #[inline]
         .               fn calculate_layout_for(self, buckets: usize) -> Option<(Layout, usize)> {
         .                   debug_assert!(buckets.is_power_of_two());
         .           
         .                   let TableLayout { size, ctrl_align } = self;
         .                   // Manual layout calculation since Layout methods are not yet stable.
         .                   let ctrl_offset =
   169,389 ( 0.00%)              size.checked_mul(buckets)?.checked_add(ctrl_align - 1)? & !(ctrl_align - 1);
   232,295 ( 0.00%)          let len = ctrl_offset.checked_add(buckets + Group::WIDTH)?;
         .           
         .                   Some((
         .                       unsafe { Layout::from_size_align_unchecked(len, ctrl_align) },
         .                       ctrl_offset,
         .                   ))
         .               }
         .           }
         .           
-- line 263 ----------------------------------------
-- line 337 ----------------------------------------
         .                   }
         .               }
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub unsafe fn drop(&self) {
         .                   self.as_ptr().drop_in_place();
         .               }
         .               #[inline]
         .               pub unsafe fn read(&self) -> T {
     1,132 ( 0.00%)          self.as_ptr().read()
         .               }
         .               #[inline]
         .               pub unsafe fn write(&self, val: T) {
         .                   self.as_ptr().write(val);
         .               }
         .               #[inline]
         .               pub unsafe fn as_ref<'a>(&self) -> &'a T {
         .                   &*self.as_ptr()
-- line 353 ----------------------------------------
-- line 422 ----------------------------------------
         .               /// Creates a new empty hash table without allocating any memory, using the
         .               /// given allocator.
         .               ///
         .               /// In effect this returns a table with exactly 1 bucket. However we can
         .               /// leave the data pointer dangling since that bucket is never written to
         .               /// due to our load factor forcing us to always have at least 1 free bucket.
         .               #[inline]
         .               pub fn new_in(alloc: A) -> Self {
     2,637 ( 0.00%)          Self {
         .                       table: RawTableInner::new_in(alloc),
         .                       marker: PhantomData,
         .                   }
         .               }
         .           
         .               /// Allocates a new hash table with the given number of buckets.
         .               ///
         .               /// The control bytes are left uninitialized.
-- line 438 ----------------------------------------
-- line 440 ----------------------------------------
         .               unsafe fn new_uninitialized(
         .                   alloc: A,
         .                   buckets: usize,
         .                   fallibility: Fallibility,
         .               ) -> Result<Self, TryReserveError> {
         .                   debug_assert!(buckets.is_power_of_two());
         .           
         .                   Ok(Self {
        85 ( 0.00%)              table: RawTableInner::new_uninitialized(
         .                           alloc,
         .                           TableLayout::new::<T>(),
         .                           buckets,
         .                           fallibility,
         .                       )?,
         .                       marker: PhantomData,
         .                   })
         .               }
-- line 456 ----------------------------------------
-- line 458 ----------------------------------------
         .               /// Attempts to allocate a new hash table with at least enough capacity
         .               /// for inserting the given number of elements without reallocating.
         .               fn fallible_with_capacity(
         .                   alloc: A,
         .                   capacity: usize,
         .                   fallibility: Fallibility,
         .               ) -> Result<Self, TryReserveError> {
         .                   Ok(Self {
     6,319 ( 0.00%)              table: RawTableInner::fallible_with_capacity(
         .                           alloc,
         .                           TableLayout::new::<T>(),
         .                           capacity,
         .                           fallibility,
         .                       )?,
         .                       marker: PhantomData,
         .                   })
         .               }
-- line 474 ----------------------------------------
-- line 527 ----------------------------------------
         .                   debug_assert_ne!(self.table.bucket_mask, 0);
         .                   debug_assert!(index < self.buckets());
         .                   Bucket::from_base_index(self.data_end(), index)
         .               }
         .           
         .               /// Erases an element from the table without dropping it.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               #[deprecated(since = "0.8.1", note = "use erase or remove instead")]
    15,021 ( 0.00%)      pub unsafe fn erase_no_drop(&mut self, item: &Bucket<T>) {
    15,021 ( 0.00%)          let index = self.bucket_index(item);
         .                   self.table.erase(index);
    30,042 ( 0.00%)      }
         .           
         .               /// Erases an element from the table, dropping it in place.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               #[allow(clippy::needless_pass_by_value)]
         .               #[allow(deprecated)]
         .               pub unsafe fn erase(&mut self, item: Bucket<T>) {
         .                   // Erase the element from the table first since drop might panic.
     9,528 ( 0.00%)          self.erase_no_drop(&item);
         .                   item.drop();
         .               }
         .           
         .               /// Finds and erases an element from the table, dropping it in place.
         .               /// Returns true if an element was found.
         .               #[cfg(feature = "raw")]
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub fn erase_entry(&mut self, hash: u64, eq: impl FnMut(&T) -> bool) -> bool {
-- line 554 ----------------------------------------
-- line 563 ----------------------------------------
         .                   }
         .               }
         .           
         .               /// Removes an element from the table, returning it.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               #[allow(clippy::needless_pass_by_value)]
         .               #[allow(deprecated)]
         .               pub unsafe fn remove(&mut self, item: Bucket<T>) -> T {
    20,514 ( 0.00%)          self.erase_no_drop(&item);
       135 ( 0.00%)          item.read()
         .               }
         .           
         .               /// Finds and removes an element from the table, returning it.
         .               #[cfg_attr(feature = "inline-more", inline)]
   513,871 ( 0.01%)      pub fn remove_entry(&mut self, hash: u64, eq: impl FnMut(&T) -> bool) -> Option<T> {
         .                   // Avoid `Option::map` because it bloats LLVM IR.
     1,846 ( 0.00%)          match self.find(hash, eq) {
     3,542 ( 0.00%)              Some(bucket) => Some(unsafe { self.remove(bucket) }),
    87,161 ( 0.00%)              None => None,
         .                   }
   710,332 ( 0.01%)      }
         .           
         .               /// Marks all table buckets as empty without dropping their contents.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub fn clear_no_drop(&mut self) {
         .                   self.table.clear_no_drop();
         .               }
         .           
         .               /// Removes all elements from the table without freeing the backing memory.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub fn clear(&mut self) {
         .                   // Ensure that the table is reset even if one of the drops panic
         .                   let mut self_ = guard(self, |self_| self_.clear_no_drop());
         .                   unsafe {
         1 ( 0.00%)              self_.drop_elements();
         .                   }
         .               }
         .           
         7 ( 0.00%)      unsafe fn drop_elements(&mut self) {
     9,856 ( 0.00%)          if mem::needs_drop::<T>() && !self.is_empty() {
         .                       for item in self.iter() {
         .                           item.drop();
         .                       }
         .                   }
         8 ( 0.00%)      }
         .           
         .               /// Shrinks the table to fit `max(self.len(), min_size)` elements.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub fn shrink_to(&mut self, min_size: usize, hasher: impl Fn(&T) -> u64) {
         .                   // Calculate the minimal number of elements that we need to reserve
         .                   // space for.
         .                   let min_size = usize::max(self.table.items, min_size);
         .                   if min_size == 0 {
-- line 615 ----------------------------------------
-- line 642 ----------------------------------------
         .                       }
         .                   }
         .               }
         .           
         .               /// Ensures that at least `additional` items can be inserted into the table
         .               /// without reallocation.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub fn reserve(&mut self, additional: usize, hasher: impl Fn(&T) -> u64) {
   285,507 ( 0.00%)          if additional > self.table.growth_left {
         .                       // Avoid `Result::unwrap_or_else` because it bloats LLVM IR.
   149,864 ( 0.00%)              if self
         .                           .reserve_rehash(additional, hasher, Fallibility::Infallible)
         .                           .is_err()
         .                       {
         .                           unsafe { hint::unreachable_unchecked() }
         .                       }
         .                   }
         .               }
         .           
-- line 660 ----------------------------------------
-- line 671 ----------------------------------------
         .                   } else {
         .                       Ok(())
         .                   }
         .               }
         .           
         .               /// Out-of-line slow path for `reserve` and `try_reserve`.
         .               #[cold]
         .               #[inline(never)]
   344,212 ( 0.01%)      fn reserve_rehash(
         .                   &mut self,
         .                   additional: usize,
         .                   hasher: impl Fn(&T) -> u64,
         .                   fallibility: Fallibility,
         .               ) -> Result<(), TryReserveError> {
         .                   unsafe {
         .                       self.table.reserve_rehash_inner(
         .                           additional,
-- line 687 ----------------------------------------
-- line 690 ----------------------------------------
         .                           TableLayout::new::<T>(),
         .                           if mem::needs_drop::<T>() {
         .                               Some(mem::transmute(ptr::drop_in_place::<T> as unsafe fn(*mut T)))
         .                           } else {
         .                               None
         .                           },
         .                       )
         .                   }
   234,888 ( 0.00%)      }
         .           
         .               /// Allocates a new table of a different size and moves the contents of the
         .               /// current table into it.
         .               fn resize(
         .                   &mut self,
         .                   capacity: usize,
         .                   hasher: impl Fn(&T) -> u64,
         .                   fallibility: Fallibility,
-- line 706 ----------------------------------------
-- line 714 ----------------------------------------
         .                       )
         .                   }
         .               }
         .           
         .               /// Inserts a new element into the table, and returns its raw bucket.
         .               ///
         .               /// This does not check if the given element already exists in the table.
         .               #[cfg_attr(feature = "inline-more", inline)]
 1,995,010 ( 0.03%)      pub fn insert(&mut self, hash: u64, value: T, hasher: impl Fn(&T) -> u64) -> Bucket<T> {
         .                   unsafe {
         .                       let mut index = self.table.find_insert_slot(hash);
         .           
         .                       // We can avoid growing the table once we have reached our load
         .                       // factor if we are replacing a tombstone. This works since the
         .                       // number of EMPTY slots does not change in this case.
     4,205 ( 0.00%)              let old_ctrl = *self.table.ctrl(index);
 1,424,877 ( 0.02%)              if unlikely(self.table.growth_left == 0 && special_is_empty(old_ctrl)) {
         .                           self.reserve(1, hasher);
         .                           index = self.table.find_insert_slot(hash);
         .                       }
         .           
         .                       self.table.record_item_insert_at(index, old_ctrl, hash);
         .           
         .                       let bucket = self.bucket(index);
         4 ( 0.00%)              bucket.write(value);
         .                       bucket
         .                   }
 1,475,556 ( 0.02%)      }
         .           
         .               /// Attempts to insert a new element without growing the table and return its raw bucket.
         .               ///
         .               /// Returns an `Err` containing the given element if inserting it would require growing the
         .               /// table.
         .               ///
         .               /// This does not check if the given element already exists in the table.
         .               #[cfg(feature = "raw")]
-- line 749 ----------------------------------------
-- line 760 ----------------------------------------
         .                       }
         .                   }
         .               }
         .           
         .               /// Inserts a new element into the table, and returns a mutable reference to it.
         .               ///
         .               /// This does not check if the given element already exists in the table.
         .               #[cfg_attr(feature = "inline-more", inline)]
   622,264 ( 0.01%)      pub fn insert_entry(&mut self, hash: u64, value: T, hasher: impl Fn(&T) -> u64) -> &mut T {
       257 ( 0.00%)          unsafe { self.insert(hash, value, hasher).as_mut() }
   466,698 ( 0.01%)      }
         .           
         .               /// Inserts a new element into the table, without growing the table.
         .               ///
         .               /// There must be enough space in the table to insert the new element.
         .               ///
         .               /// This does not check if the given element already exists in the table.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               #[cfg(any(feature = "raw", feature = "rustc-internal-api"))]
     5,894 ( 0.00%)      pub unsafe fn insert_no_grow(&mut self, hash: u64, value: T) -> Bucket<T> {
   318,011 ( 0.00%)          let (index, old_ctrl) = self.table.prepare_insert_slot(hash);
     9,506 ( 0.00%)          let bucket = self.table.bucket(index);
         .           
         .                   // If we are replacing a DELETED entry then we don't need to update
         .                   // the load counter.
   662,479 ( 0.01%)          self.table.growth_left -= special_is_empty(old_ctrl) as usize;
         .           
         .                   bucket.write(value);
   524,302 ( 0.01%)          self.table.items += 1;
         .                   bucket
     8,923 ( 0.00%)      }
         .           
         .               /// Temporary removes a bucket, applying the given function to the removed
         .               /// element and optionally put back the returned value in the same bucket.
         .               ///
         .               /// Returns `true` if the bucket still contains an element
         .               ///
         .               /// This does not check if the given bucket is actually occupied.
         .               #[cfg_attr(feature = "inline-more", inline)]
-- line 798 ----------------------------------------
-- line 813 ----------------------------------------
         .                       true
         .                   } else {
         .                       false
         .                   }
         .               }
         .           
         .               /// Searches for an element in the table.
         .               #[inline]
    67,142 ( 0.00%)      pub fn find(&self, hash: u64, mut eq: impl FnMut(&T) -> bool) -> Option<Bucket<T>> {
     5,969 ( 0.00%)          let result = self.table.find_inner(hash, &mut |index| unsafe {
    25,252 ( 0.00%)              eq(self.bucket(index).as_ref())
     1,956 ( 0.00%)          });
         .           
         .                   // Avoid `Option::map` because it bloats LLVM IR.
         .                   match result {
       745 ( 0.00%)              Some(index) => Some(unsafe { self.bucket(index) }),
         .                       None => None,
         .                   }
    76,448 ( 0.00%)      }
         .           
         .               /// Gets a reference to an element in the table.
         .               #[inline]
         .               pub fn get(&self, hash: u64, eq: impl FnMut(&T) -> bool) -> Option<&T> {
         .                   // Avoid `Option::map` because it bloats LLVM IR.
    37,661 ( 0.00%)          match self.find(hash, eq) {
         .                       Some(bucket) => Some(unsafe { bucket.as_ref() }),
         .                       None => None,
         .                   }
         .               }
         .           
         .               /// Gets a mutable reference to an element in the table.
         .               #[inline]
     3,486 ( 0.00%)      pub fn get_mut(&mut self, hash: u64, eq: impl FnMut(&T) -> bool) -> Option<&mut T> {
         .                   // Avoid `Option::map` because it bloats LLVM IR.
    28,648 ( 0.00%)          match self.find(hash, eq) {
         .                       Some(bucket) => Some(unsafe { bucket.as_mut() }),
         .                       None => None,
         .                   }
     3,984 ( 0.00%)      }
         .           
         .               /// Attempts to get mutable references to `N` entries in the table at once.
         .               ///
         .               /// Returns an array of length `N` with the results of each query.
         .               ///
         .               /// At most one mutable reference will be returned to any entry. `None` will be returned if any
         .               /// of the hashes are duplicates. `None` will be returned if the hash is not found.
         .               ///
-- line 859 ----------------------------------------
-- line 920 ----------------------------------------
         .               #[inline]
         .               pub fn len(&self) -> usize {
         .                   self.table.items
         .               }
         .           
         .               /// Returns `true` if the table contains no elements.
         .               #[inline]
         .               pub fn is_empty(&self) -> bool {
   706,693 ( 0.01%)          self.len() == 0
         .               }
         .           
         .               /// Returns the number of buckets in the table.
         .               #[inline]
         .               pub fn buckets(&self) -> usize {
         .                   self.table.bucket_mask + 1
         .               }
         .           
         .               /// Returns an iterator over every element in the table. It is up to
         .               /// the caller to ensure that the `RawTable` outlives the `RawIter`.
         .               /// Because we cannot make the `next` method unsafe on the `RawIter`
         .               /// struct, we have to make the `iter` method unsafe.
         .               #[inline]
         .               pub unsafe fn iter(&self) -> RawIter<T> {
         1 ( 0.00%)          let data = Bucket::from_base_index(self.data_end(), 0);
         .                   RawIter {
         .                       iter: RawIterRange::new(self.table.ctrl.as_ptr(), data, self.table.buckets()),
    74,431 ( 0.00%)              items: self.table.items,
         .                   }
         .               }
         .           
         .               /// Returns an iterator over occupied buckets that could match a given hash.
         .               ///
         .               /// `RawTable` only stores 7 bits of the hash value, so this iterator may
         .               /// return items that have a hash value different than the one provided. You
         .               /// should always validate the returned values before using them.
-- line 954 ----------------------------------------
-- line 995 ----------------------------------------
         .               /// Iteration starts at the provided iterator's current location.
         .               ///
         .               /// It is up to the caller to ensure that the iterator is valid for this
         .               /// `RawTable` and covers all items that remain in the table.
         .               pub unsafe fn into_iter_from(self, iter: RawIter<T>) -> RawIntoIter<T, A> {
         .                   debug_assert_eq!(iter.len(), self.len());
         .           
         .                   let alloc = self.table.alloc.clone();
     3,828 ( 0.00%)          let allocation = self.into_allocation();
     2,871 ( 0.00%)          RawIntoIter {
     4,785 ( 0.00%)              iter,
         .                       allocation,
         .                       marker: PhantomData,
         .                       alloc,
         .                   }
         .               }
         .           
         .               /// Converts the table into a raw allocation. The contents of the table
         .               /// should be dropped using a `RawIter` before freeing the allocation.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               pub(crate) fn into_allocation(self) -> Option<(NonNull<u8>, Layout)> {
     1,771 ( 0.00%)          let alloc = if self.table.is_empty_singleton() {
         .                       None
         .                   } else {
         .                       // Avoid `Option::unwrap_or_else` because it bloats LLVM IR.
         .                       let (layout, ctrl_offset) = match calculate_layout::<T>(self.table.buckets()) {
         .                           Some(lco) => lco,
         .                           None => unsafe { hint::unreachable_unchecked() },
         .                       };
         .                       Some((
       366 ( 0.00%)                  unsafe { NonNull::new_unchecked(self.table.ctrl.as_ptr().sub(ctrl_offset)) },
         .                           layout,
         .                       ))
         .                   };
         .                   mem::forget(self);
         .                   alloc
         .               }
         .           }
         .           
-- line 1033 ----------------------------------------
-- line 1042 ----------------------------------------
         .               T: Sync,
         .               A: Sync,
         .           {
         .           }
         .           
         .           impl<A> RawTableInner<A> {
         .               #[inline]
         .               const fn new_in(alloc: A) -> Self {
   495,429 ( 0.01%)          Self {
         .                       // Be careful to cast the entire slice to a raw pointer.
         .                       ctrl: unsafe { NonNull::new_unchecked(Group::static_empty() as *const _ as *mut u8) },
         .                       bucket_mask: 0,
         .                       items: 0,
         .                       growth_left: 0,
         .                       alloc,
         .                   }
         .               }
         .           }
         .           
         .           impl<A: Allocator + Clone> RawTableInner<A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
   288,977 ( 0.00%)      unsafe fn new_uninitialized(
         .                   alloc: A,
         .                   table_layout: TableLayout,
         .                   buckets: usize,
         .                   fallibility: Fallibility,
         .               ) -> Result<Self, TryReserveError> {
         .                   debug_assert!(buckets.is_power_of_two());
         .           
         .                   // Avoid `Option::ok_or_else` because it bloats LLVM IR.
-- line 1071 ----------------------------------------
-- line 1078 ----------------------------------------
         .                   // exceed `isize::MAX`. We can skip this check on 64-bit systems since
         .                   // such allocations will never succeed anyways.
         .                   //
         .                   // This mirrors what Vec does in the standard library.
         .                   if mem::size_of::<usize>() < 8 && layout.size() > isize::MAX as usize {
         .                       return Err(fallibility.capacity_overflow());
         .                   }
         .           
    70,270 ( 0.00%)          let ptr: NonNull<u8> = match do_alloc(&alloc, layout) {
         .                       Ok(block) => block.cast(),
         .                       Err(_) => return Err(fallibility.alloc_err(layout)),
         .                   };
         .           
         .                   let ctrl = NonNull::new_unchecked(ptr.as_ptr().add(ctrl_offset));
   162,456 ( 0.00%)          Ok(Self {
         .                       ctrl,
    70,401 ( 0.00%)              bucket_mask: buckets - 1,
         .                       items: 0,
         .                       growth_left: bucket_mask_to_capacity(buckets - 1),
         .                       alloc,
         .                   })
   210,702 ( 0.00%)      }
         .           
         .               #[inline]
    20,809 ( 0.00%)      fn fallible_with_capacity(
         .                   alloc: A,
         .                   table_layout: TableLayout,
         .                   capacity: usize,
         .                   fallibility: Fallibility,
         .               ) -> Result<Self, TryReserveError> {
     5,326 ( 0.00%)          if capacity == 0 {
     2,688 ( 0.00%)              Ok(Self::new_in(alloc))
         .                   } else {
         .                       unsafe {
         .                           let buckets =
         .                               capacity_to_buckets(capacity).ok_or_else(|| fallibility.capacity_overflow())?;
         .           
   131,259 ( 0.00%)                  let result = Self::new_uninitialized(alloc, table_layout, buckets, fallibility)?;
         .                           result.ctrl(0).write_bytes(EMPTY, result.num_ctrl_bytes());
         .           
    12,555 ( 0.00%)                  Ok(result)
         .                       }
         .                   }
    20,809 ( 0.00%)      }
         .           
         .               /// Searches for an empty or deleted bucket which is suitable for inserting
         .               /// a new element and sets the hash for that slot.
         .               ///
         .               /// There must be at least 1 empty bucket in the table.
         .               #[inline]
   108,668 ( 0.00%)      unsafe fn prepare_insert_slot(&self, hash: u64) -> (usize, u8) {
         .                   let index = self.find_insert_slot(hash);
   108,668 ( 0.00%)          let old_ctrl = *self.ctrl(index);
         .                   self.set_ctrl_h2(index, hash);
         .                   (index, old_ctrl)
   217,336 ( 0.00%)      }
         .           
         .               /// Searches for an empty or deleted bucket which is suitable for inserting
         .               /// a new element.
         .               ///
         .               /// There must be at least 1 empty bucket in the table.
         .               #[inline]
         .               fn find_insert_slot(&self, hash: u64) -> usize {
         .                   let mut probe_seq = self.probe_seq(hash);
         .                   loop {
         .                       unsafe {
         .                           let group = Group::load(self.ctrl(probe_seq.pos));
   988,831 ( 0.01%)                  if let Some(bit) = group.match_empty_or_deleted().lowest_set_bit() {
 2,883,371 ( 0.04%)                      let result = (probe_seq.pos + bit) & self.bucket_mask;
         .           
         .                               // In tables smaller than the group width, trailing control
         .                               // bytes outside the range of the table are filled with
         .                               // EMPTY entries. These will unfortunately trigger a
         .                               // match, but once masked may point to a full bucket that
         .                               // is already occupied. We detect this situation here and
         .                               // perform a second scan starting at the beginning of the
         .                               // table. This second scan is guaranteed to find an empty
         .                               // slot (due to the load factor) before hitting the trailing
         .                               // control bytes (containing EMPTY).
 1,316,982 ( 0.02%)                      if unlikely(is_full(*self.ctrl(result))) {
         .                                   debug_assert!(self.bucket_mask < Group::WIDTH);
         .                                   debug_assert_ne!(probe_seq.pos, 0);
         .                                   return Group::load_aligned(self.ctrl(0))
         .                                       .match_empty_or_deleted()
         .                                       .lowest_set_bit_nonzero();
         .                               }
         .           
         .                               return result;
-- line 1165 ----------------------------------------
-- line 1171 ----------------------------------------
         .           
         .               /// Searches for an element in the table. This uses dynamic dispatch to reduce the amount of
         .               /// code generated, but it is eliminated by LLVM optimizations.
         .               #[inline]
         .               fn find_inner(&self, hash: u64, eq: &mut dyn FnMut(usize) -> bool) -> Option<usize> {
         .                   let h2_hash = h2(hash);
         .                   let mut probe_seq = self.probe_seq(hash);
         .           
   106,200 ( 0.00%)          loop {
         .                       let group = unsafe { Group::load(self.ctrl(probe_seq.pos)) };
         .           
 3,034,046 ( 0.05%)              for bit in group.match_byte(h2_hash) {
 5,906,814 ( 0.09%)                  let index = (probe_seq.pos + bit) & self.bucket_mask;
         .           
 4,026,661 ( 0.06%)                  if likely(eq(index)) {
         .                               return Some(index);
         .                           }
         .                       }
         .           
   930,597 ( 0.01%)              if likely(group.match_empty().any_bit_set()) {
         .                           return None;
         .                       }
         .           
         .                       probe_seq.move_next(self.bucket_mask);
         .                   }
         .               }
         .           
         .               #[allow(clippy::mut_mut)]
-- line 1198 ----------------------------------------
-- line 1225 ----------------------------------------
         .                   Bucket::from_base_index(self.data_end(), index)
         .               }
         .           
         .               #[inline]
         .               unsafe fn bucket_ptr(&self, index: usize, size_of: usize) -> *mut u8 {
         .                   debug_assert_ne!(self.bucket_mask, 0);
         .                   debug_assert!(index < self.buckets());
         .                   let base: *mut u8 = self.data_end().as_ptr();
 3,716,592 ( 0.06%)          base.sub((index + 1) * size_of)
         .               }
         .           
         .               #[inline]
         .               unsafe fn data_end<T>(&self) -> NonNull<T> {
         .                   NonNull::new_unchecked(self.ctrl.as_ptr().cast())
         .               }
         .           
         .               /// Returns an iterator-like object for a probe sequence on the table.
         .               ///
         .               /// This iterator never terminates, but is guaranteed to visit each bucket
         .               /// group exactly once. The loop using `probe_seq` must terminate upon
         .               /// reaching a group containing an empty bucket.
         .               #[inline]
         .               fn probe_seq(&self, hash: u64) -> ProbeSeq {
         .                   ProbeSeq {
17,234,991 ( 0.26%)              pos: h1(hash) & self.bucket_mask,
         .                       stride: 0,
         .                   }
         .               }
         .           
         .               /// Returns the index of a bucket for which a value must be inserted if there is enough rooom
         .               /// in the table, otherwise returns error
         .               #[cfg(feature = "raw")]
         .               #[inline]
-- line 1257 ----------------------------------------
-- line 1263 ----------------------------------------
         .                   } else {
         .                       self.record_item_insert_at(index, old_ctrl, hash);
         .                       Ok(index)
         .                   }
         .               }
         .           
         .               #[inline]
         .               unsafe fn record_item_insert_at(&mut self, index: usize, old_ctrl: u8, hash: u64) {
 1,780,270 ( 0.03%)          self.growth_left -= special_is_empty(old_ctrl) as usize;
         .                   self.set_ctrl_h2(index, hash);
 1,424,172 ( 0.02%)          self.items += 1;
         .               }
         .           
         .               #[inline]
         .               fn is_in_same_group(&self, i: usize, new_i: usize, hash: u64) -> bool {
         .                   let probe_seq_pos = self.probe_seq(hash).pos;
         .                   let probe_index =
         .                       |pos: usize| (pos.wrapping_sub(probe_seq_pos) & self.bucket_mask) / Group::WIDTH;
         .                   probe_index(i) == probe_index(new_i)
-- line 1281 ----------------------------------------
-- line 1312 ----------------------------------------
         .                   // replicate the buckets at the end of the trailing group. For example
         .                   // with 2 buckets and a group size of 4, the control bytes will look
         .                   // like this:
         .                   //
         .                   //     Real    |             Replicated
         .                   // ---------------------------------------------
         .                   // | [A] | [B] | [EMPTY] | [EMPTY] | [A] | [B] |
         .                   // ---------------------------------------------
 2,801,807 ( 0.04%)          let index2 = ((index.wrapping_sub(Group::WIDTH)) & self.bucket_mask) + Group::WIDTH;
         .           
   933,029 ( 0.01%)          *self.ctrl(index) = ctrl;
   934,950 ( 0.01%)          *self.ctrl(index2) = ctrl;
         .               }
         .           
         .               /// Returns a pointer to a control byte.
         .               #[inline]
         .               unsafe fn ctrl(&self, index: usize) -> *mut u8 {
         .                   debug_assert!(index < self.num_ctrl_bytes());
         .                   self.ctrl.as_ptr().add(index)
         .               }
         .           
         .               #[inline]
         .               fn buckets(&self) -> usize {
   226,129 ( 0.00%)          self.bucket_mask + 1
         .               }
         .           
         .               #[inline]
         .               fn num_ctrl_bytes(&self) -> usize {
   180,495 ( 0.00%)          self.bucket_mask + 1 + Group::WIDTH
         .               }
         .           
         .               #[inline]
         .               fn is_empty_singleton(&self) -> bool {
   906,287 ( 0.01%)          self.bucket_mask == 0
         .               }
         .           
         .               #[allow(clippy::mut_mut)]
         .               #[inline]
         .               unsafe fn prepare_resize(
         .                   &self,
         .                   table_layout: TableLayout,
         .                   capacity: usize,
         .                   fallibility: Fallibility,
         .               ) -> Result<crate::scopeguard::ScopeGuard<Self, impl FnMut(&mut Self)>, TryReserveError> {
         .                   debug_assert!(self.items <= capacity);
         .           
         .                   // Allocate and initialize the new table.
     3,126 ( 0.00%)          let mut new_table = RawTableInner::fallible_with_capacity(
         .                       self.alloc.clone(),
         .                       table_layout,
         .                       capacity,
         .                       fallibility,
         .                   )?;
    95,234 ( 0.00%)          new_table.growth_left -= self.items;
         .                   new_table.items = self.items;
         .           
         .                   // The hash function may panic, in which case we simply free the new
         .                   // table without dropping any elements that may have been copied into
         .                   // it.
         .                   //
         .                   // This guard is also used to free the old table on success, see
         .                   // the comment at the bottom of this function.
         .                   Ok(guard(new_table, move |self_| {
    42,257 ( 0.00%)              if !self_.is_empty_singleton() {
         .                           self_.free_buckets(table_layout);
         .                       }
         .                   }))
         .               }
         .           
         .               /// Reserves or rehashes to make room for `additional` more elements.
         .               ///
         .               /// This uses dynamic dispatch to reduce the amount of
-- line 1383 ----------------------------------------
-- line 1388 ----------------------------------------
         .                   &mut self,
         .                   additional: usize,
         .                   hasher: &dyn Fn(&mut Self, usize) -> u64,
         .                   fallibility: Fallibility,
         .                   layout: TableLayout,
         .                   drop: Option<fn(*mut u8)>,
         .               ) -> Result<(), TryReserveError> {
         .                   // Avoid `Option::ok_or_else` because it bloats LLVM IR.
    84,523 ( 0.00%)          let new_items = match self.items.checked_add(additional) {
         .                       Some(new_items) => new_items,
         .                       None => return Err(fallibility.capacity_overflow()),
         .                   };
    84,514 ( 0.00%)          let full_capacity = bucket_mask_to_capacity(self.bucket_mask);
   180,083 ( 0.00%)          if new_items <= full_capacity / 2 {
         .                       // Rehash in-place without re-allocating if we have plenty of spare
         .                       // capacity that is locked up due to DELETED entries.
         .                       self.rehash_in_place(hasher, layout.size, drop);
         .                       Ok(())
         .                   } else {
         .                       // Otherwise, conservatively resize to at least the next size up
         .                       // to avoid churning deletes into frequent rehashes.
         .                       self.resize_inner(
    42,257 ( 0.00%)                  usize::max(new_items, full_capacity + 1),
         .                           hasher,
         .                           fallibility,
         .                           layout,
         .                       )
         .                   }
         .               }
         .           
         .               /// Allocates a new table of a different size and moves the contents of the
-- line 1418 ----------------------------------------
-- line 1424 ----------------------------------------
         .               #[inline(always)]
         .               unsafe fn resize_inner(
         .                   &mut self,
         .                   capacity: usize,
         .                   hasher: &dyn Fn(&mut Self, usize) -> u64,
         .                   fallibility: Fallibility,
         .                   layout: TableLayout,
         .               ) -> Result<(), TryReserveError> {
     7,737 ( 0.00%)          let mut new_table = self.prepare_resize(layout, capacity, fallibility)?;
         .           
         .                   // Copy all elements to the new table.
         .                   for i in 0..self.buckets() {
   563,671 ( 0.01%)              if !is_full(*self.ctrl(i)) {
         .                           continue;
         .                       }
         .           
         .                       // This may panic.
         .                       let hash = hasher(self, i);
         .           
         .                       // We can use a simpler version of insert() here since:
         .                       // - there are no DELETED entries.
-- line 1444 ----------------------------------------
-- line 1454 ----------------------------------------
         .                   }
         .           
         .                   // We successfully copied all elements without panicking. Now replace
         .                   // self with the new table. The old table will have its memory freed but
         .                   // the items will not be dropped (since they have been moved into the
         .                   // new table).
         .                   mem::swap(self, &mut new_table);
         .           
    42,257 ( 0.00%)          Ok(())
         .               }
         .           
         .               /// Rehashes the contents of the table in place (i.e. without changing the
         .               /// allocation).
         .               ///
         .               /// If `hasher` panics then some the table's contents may be lost.
         .               ///
         .               /// This uses dynamic dispatch to reduce the amount of
-- line 1470 ----------------------------------------
-- line 1554 ----------------------------------------
         .               #[inline]
         .               unsafe fn free_buckets(&mut self, table_layout: TableLayout) {
         .                   // Avoid `Option::unwrap_or_else` because it bloats LLVM IR.
         .                   let (layout, ctrl_offset) = match table_layout.calculate_layout_for(self.buckets()) {
         .                       Some(lco) => lco,
         .                       None => hint::unreachable_unchecked(),
         .                   };
         .                   self.alloc.deallocate(
    27,933 ( 0.00%)              NonNull::new_unchecked(self.ctrl.as_ptr().sub(ctrl_offset)),
         .                       layout,
         .                   );
         .               }
         .           
         .               /// Marks all table buckets as empty without dropping their contents.
         .               #[inline]
         .               fn clear_no_drop(&mut self) {
     9,127 ( 0.00%)          if !self.is_empty_singleton() {
         .                       unsafe {
         .                           self.ctrl(0).write_bytes(EMPTY, self.num_ctrl_bytes());
         .                       }
         .                   }
    10,839 ( 0.00%)          self.items = 0;
     9,145 ( 0.00%)          self.growth_left = bucket_mask_to_capacity(self.bucket_mask);
         .               }
         .           
         .               #[inline]
         .               unsafe fn erase(&mut self, index: usize) {
         .                   debug_assert!(is_full(*self.ctrl(index)));
    92,022 ( 0.00%)          let index_before = index.wrapping_sub(Group::WIDTH) & self.bucket_mask;
         .                   let empty_before = Group::load(self.ctrl(index_before)).match_empty();
         .                   let empty_after = Group::load(self.ctrl(index)).match_empty();
         .           
         .                   // If we are inside a continuous block of Group::WIDTH full or deleted
         .                   // cells then a probe window may have seen a full block when trying to
         .                   // insert. We therefore need to keep that block non-empty so that
         .                   // lookups will continue searching to the next probe window.
         .                   //
         .                   // Note that in this context `leading_zeros` refers to the bytes at the
         .                   // end of a group, while `trailing_zeros` refers to the bytes at the
         .                   // beginning of a group.
   368,088 ( 0.01%)          let ctrl = if empty_before.leading_zeros() + empty_after.trailing_zeros() >= Group::WIDTH {
         .                       DELETED
         .                   } else {
   457,605 ( 0.01%)              self.growth_left += 1;
         .                       EMPTY
         .                   };
         .                   self.set_ctrl(index, ctrl);
   368,088 ( 0.01%)          self.items -= 1;
         .               }
         .           }
         .           
         .           impl<T: Clone, A: Allocator + Clone> Clone for RawTable<T, A> {
     7,048 ( 0.00%)      fn clone(&self) -> Self {
       896 ( 0.00%)          if self.table.is_empty_singleton() {
         .                       Self::new_in(self.table.alloc.clone())
         .                   } else {
         .                       unsafe {
         .                           let mut new_table = ManuallyDrop::new(
         .                               // Avoid `Result::ok_or_else` because it bloats LLVM IR.
         .                               match Self::new_uninitialized(
         .                                   self.table.alloc.clone(),
         .                                   self.table.buckets(),
-- line 1615 ----------------------------------------
-- line 1624 ----------------------------------------
         .                               // We need to free the memory allocated for the new table.
         .                               new_table.free_buckets();
         .                           });
         .           
         .                           // Return the newly created table.
         .                           ManuallyDrop::into_inner(new_table)
         .                       }
         .                   }
     7,929 ( 0.00%)      }
         .           
         .               fn clone_from(&mut self, source: &Self) {
         .                   if source.table.is_empty_singleton() {
         .                       *self = Self::new_in(self.table.alloc.clone());
         .                   } else {
         .                       unsafe {
         .                           // First, drop all our elements without clearing the control bytes.
         .                           self.drop_elements();
-- line 1640 ----------------------------------------
-- line 1687 ----------------------------------------
         .                       .table
         .                       .ctrl(0)
         .                       .copy_to_nonoverlapping(self.table.ctrl(0), self.table.num_ctrl_bytes());
         .                   source
         .                       .data_start()
         .                       .copy_to_nonoverlapping(self.data_start(), self.table.buckets());
         .           
         .                   self.table.items = source.table.items;
        34 ( 0.00%)          self.table.growth_left = source.table.growth_left;
         .               }
         .           }
         .           
         .           impl<T: Clone, A: Allocator + Clone> RawTable<T, A> {
         .               /// Common code for clone and clone_from. Assumes `self.buckets() == source.buckets()`.
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               unsafe fn clone_from_impl(&mut self, source: &Self, mut on_panic: impl FnMut(&mut Self)) {
         .                   // Copy the control bytes unchanged. We do this in a single pass
-- line 1703 ----------------------------------------
-- line 1790 ----------------------------------------
         .               fn default() -> Self {
         .                   Self::new_in(Default::default())
         .               }
         .           }
         .           
         .           #[cfg(feature = "nightly")]
         .           unsafe impl<#[may_dangle] T, A: Allocator + Clone> Drop for RawTable<T, A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
   467,202 ( 0.01%)      fn drop(&mut self) {
   394,084 ( 0.01%)          if !self.table.is_empty_singleton() {
         .                       unsafe {
         .                           self.drop_elements();
         .                           self.free_buckets();
         .                       }
         .                   }
   499,578 ( 0.01%)      }
         .           }
         .           #[cfg(not(feature = "nightly"))]
         .           impl<T, A: Allocator + Clone> Drop for RawTable<T, A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               fn drop(&mut self) {
         .                   if !self.table.is_empty_singleton() {
         .                       unsafe {
         .                           self.drop_elements();
-- line 1813 ----------------------------------------
-- line 1817 ----------------------------------------
         .               }
         .           }
         .           
         .           impl<T, A: Allocator + Clone> IntoIterator for RawTable<T, A> {
         .               type Item = T;
         .               type IntoIter = RawIntoIter<T, A>;
         .           
         .               #[cfg_attr(feature = "inline-more", inline)]
     3,828 ( 0.00%)      fn into_iter(self) -> RawIntoIter<T, A> {
         .                   unsafe {
         .                       let iter = self.iter();
         .                       self.into_iter_from(iter)
         .                   }
     4,785 ( 0.00%)      }
         .           }
         .           
         .           /// Iterator over a sub-range of a table. Unlike `RawIter` this iterator does
         .           /// not track an item count.
         .           pub(crate) struct RawIterRange<T> {
         .               // Mask of full buckets in the current group. Bits are cleared from this
         .               // mask as each element is processed.
         .               current_group: BitMask,
-- line 1838 ----------------------------------------
-- line 1934 ----------------------------------------
         .           
         .           impl<T> Iterator for RawIterRange<T> {
         .               type Item = Bucket<T>;
         .           
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               fn next(&mut self) -> Option<Bucket<T>> {
         .                   unsafe {
         .                       loop {
   207,290 ( 0.00%)                  if let Some(index) = self.current_group.lowest_set_bit() {
    34,208 ( 0.00%)                      self.current_group = self.current_group.remove_lowest_bit();
    55,273 ( 0.00%)                      return Some(self.data.next_n(index));
         .                           }
         .           
   177,856 ( 0.00%)                  if self.next_ctrl >= self.end {
         .                               return None;
         .                           }
         .           
         .                           // We might read past self.end up to the next group boundary,
         .                           // but this is fine because it only occurs on tables smaller
         .                           // than the group size where the trailing control bytes are all
         .                           // EMPTY. On larger tables self.end is guaranteed to be aligned
         .                           // to the group size (since tables are power-of-two sized).
     5,806 ( 0.00%)                  self.current_group = Group::load_aligned(self.next_ctrl).match_full();
     5,562 ( 0.00%)                  self.data = self.data.next_n(Group::WIDTH);
    11,167 ( 0.00%)                  self.next_ctrl = self.next_ctrl.add(Group::WIDTH);
         .                       }
         .                   }
         .               }
         .           
         .               #[inline]
         .               fn size_hint(&self) -> (usize, Option<usize>) {
         .                   // We don't have an item count, so just guess based on the range size.
         .                   (
-- line 1966 ----------------------------------------
-- line 2102 ----------------------------------------
         .                           }
         .                       } else {
         .                           // We must have already iterated past the removed item.
         .                       }
         .                   }
         .               }
         .           
         .               unsafe fn drop_elements(&mut self) {
     1,231 ( 0.00%)          if mem::needs_drop::<T>() && self.len() != 0 {
         .                       for item in self {
         .                           item.drop();
         .                       }
         .                   }
         .               }
         .           }
         .           
         .           impl<T> Clone for RawIter<T> {
-- line 2118 ----------------------------------------
-- line 2124 ----------------------------------------
         .                   }
         .               }
         .           }
         .           
         .           impl<T> Iterator for RawIter<T> {
         .               type Item = Bucket<T>;
         .           
         .               #[cfg_attr(feature = "inline-more", inline)]
    39,439 ( 0.00%)      fn next(&mut self) -> Option<Bucket<T>> {
    88,096 ( 0.00%)          if let Some(b) = self.iter.next() {
   317,818 ( 0.00%)              self.items -= 1;
         .                       Some(b)
         .                   } else {
         .                       // We don't check against items == 0 here to allow the
         .                       // compiler to optimize away the item count entirely if the
         .                       // iterator length is never queried.
         .                       debug_assert_eq!(self.items, 0);
         .                       None
         .                   }
    78,878 ( 0.00%)      }
         .           
         .               #[inline]
         .               fn size_hint(&self) -> (usize, Option<usize>) {
         .                   (self.items, Some(self.items))
         .               }
         .           }
         .           
         .           impl<T> ExactSizeIterator for RawIter<T> {}
-- line 2151 ----------------------------------------
-- line 2177 ----------------------------------------
         .               T: Sync,
         .               A: Sync,
         .           {
         .           }
         .           
         .           #[cfg(feature = "nightly")]
         .           unsafe impl<#[may_dangle] T, A: Allocator + Clone> Drop for RawIntoIter<T, A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
     1,854 ( 0.00%)      fn drop(&mut self) {
         .                   unsafe {
         .                       // Drop all remaining elements
         .                       self.iter.drop_elements();
         .           
         .                       // Free the table
     8,292 ( 0.00%)              if let Some((ptr, layout)) = self.allocation {
         .                           self.alloc.deallocate(ptr, layout);
         .                       }
         .                   }
       296 ( 0.00%)      }
         .           }
         .           #[cfg(not(feature = "nightly"))]
         .           impl<T, A: Allocator + Clone> Drop for RawIntoIter<T, A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               fn drop(&mut self) {
         .                   unsafe {
         .                       // Drop all remaining elements
         .                       self.iter.drop_elements();
-- line 2203 ----------------------------------------
-- line 2209 ----------------------------------------
         .                   }
         .               }
         .           }
         .           
         .           impl<T, A: Allocator + Clone> Iterator for RawIntoIter<T, A> {
         .               type Item = T;
         .           
         .               #[cfg_attr(feature = "inline-more", inline)]
     2,712 ( 0.00%)      fn next(&mut self) -> Option<T> {
     1,038 ( 0.00%)          unsafe { Some(self.iter.next()?.read()) }
     7,343 ( 0.00%)      }
         .           
         .               #[inline]
         .               fn size_hint(&self) -> (usize, Option<usize>) {
         4 ( 0.00%)          self.iter.size_hint()
         .               }
         .           }
         .           
         .           impl<T, A: Allocator + Clone> ExactSizeIterator for RawIntoIter<T, A> {}
         .           impl<T, A: Allocator + Clone> FusedIterator for RawIntoIter<T, A> {}
         .           
         .           /// Iterator which consumes elements without freeing the table storage.
         .           pub struct RawDrain<'a, T, A: Allocator + Clone = Global> {
-- line 2231 ----------------------------------------
-- line 2259 ----------------------------------------
         .           where
         .               T: Sync,
         .               A: Sync,
         .           {
         .           }
         .           
         .           impl<T, A: Allocator + Clone> Drop for RawDrain<'_, T, A> {
         .               #[cfg_attr(feature = "inline-more", inline)]
     1,192 ( 0.00%)      fn drop(&mut self) {
         .                   unsafe {
         .                       // Drop all remaining elements. Note that this may panic.
         .                       self.iter.drop_elements();
         .           
         .                       // Reset the contents of the table now that all elements have been
         .                       // dropped.
         .                       self.table.clear_no_drop();
         .           
         .                       // Move the now empty table back to its original location.
       149 ( 0.00%)              self.orig_table
         .                           .as_ptr()
         .                           .copy_from_nonoverlapping(&*self.table, 1);
         .                   }
     1,192 ( 0.00%)      }
         .           }
         .           
         .           impl<T, A: Allocator + Clone> Iterator for RawDrain<'_, T, A> {
         .               type Item = T;
         .           
         .               #[cfg_attr(feature = "inline-more", inline)]
         .               fn next(&mut self) -> Option<T> {
         .                   unsafe {
-- line 2289 ----------------------------------------

 9,631,968 ( 0.14%)  <counts for unidentified lines in /usr/home/liquid/.cargo/registry/src/github.com-1ecc6299db9ec823/hashbrown-0.12.0/src/raw/mod.rs>

--------------------------------------------------------------------------------
The following files chosen for auto-annotation could not be found:
--------------------------------------------------------------------------------
  ./elf/dl-lookup.c
  ./malloc/malloc.c
  ./stdlib/msort.c
  ./string/../sysdeps/x86_64/multiarch/memchr-avx2.S
  ./string/../sysdeps/x86_64/multiarch/memcmp-avx2-movbe.S
  ./string/../sysdeps/x86_64/multiarch/memmove-vec-unaligned-erms.S
  ./string/../sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
  ./string/../sysdeps/x86_64/multiarch/strcmp-avx2.S
  ./string/../sysdeps/x86_64/multiarch/strlen-avx2.S
  /tmp/gcc-build/x86_64-unknown-linux-gnu/libstdc++-v3/libsupc++/../../../../gcc-5.5.0/libstdc++-v3/libsupc++/new_op.cc

--------------------------------------------------------------------------------
Ir                   
--------------------------------------------------------------------------------
160,362,046 ( 2.39%)  events annotated