|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/ADT/MapVector.h 221 Map[O->first] = O - Vector.begin();
include/llvm/ADT/PriorityWorklist.h 201 M[*I] = I - V.begin();
include/llvm/ADT/SCCIterator.h 137 nodeVisitNumbers[New] = nodeVisitNumbers[Old];
137 nodeVisitNumbers[New] = nodeVisitNumbers[Old];
145 nodeVisitNumbers[N] = visitNum;
195 if (minVisitNum != nodeVisitNumbers[visitingN])
205 nodeVisitNumbers[CurrentSCC.back()] = ~0U;
include/llvm/ADT/ScopedHashTable.h 218 ScopedHashTableVal<K, V> *&KeyEntry = TopLevelMap[Key];
244 assert(HT.TopLevelMap[ThisEntry->getKey()] == ThisEntry &&
248 ScopedHashTableVal<K, V> *&KeyEntry = HT.TopLevelMap[ThisEntry->getKey()];
include/llvm/Analysis/BlockFrequencyInfoImpl.h 665 StartIrr = Lookup[Start.Index];
1057 Nodes[BB] = NewNode;
1077 Nodes[*I] = Node;
include/llvm/Analysis/LoopAccessAnalysis.h 248 OrderMap[InstMap[I]] = I;
include/llvm/Analysis/LoopIterator.h 243 DFS.PostNumbers[BB] = DFS.PostBlocks.size();
include/llvm/Analysis/MustExecute.h 392 auto *&It = InstructionIteratorMap[PP];
include/llvm/Analysis/ObjCARCAnalysisUtils.h 97 Cache[V] = const_cast<Value *>(Computed);
include/llvm/Analysis/RegionInfoImpl.h 628 (*ShortCut)[entry] = exit;
634 (*ShortCut)[entry] = BB;
765 BBtoRegion[BB] = region;
826 BBtoRegion[BB] = R;
include/llvm/Analysis/ScalarEvolutionExpressions.h 845 return Rec->evaluateAtIteration(Map[L], SE);
include/llvm/Analysis/SparsePropagation.h 240 return ValueState[Key] = std::move(LV);
252 ValueState[Key] = std::move(LV);
include/llvm/Analysis/VectorUtils.h 440 Members[Key] = Instr;
642 InterleaveGroupMap[Instr] =
644 InterleaveGroups.insert(InterleaveGroupMap[Instr]);
645 return InterleaveGroupMap[Instr];
include/llvm/CodeGen/FunctionLoweringInfo.h 212 unsigned &R = ValueMap[V];
include/llvm/CodeGen/GlobalISel/InstructionSelector.h 430 TypeIDMap[TypeObjects[I]] = I;
include/llvm/CodeGen/GlobalISel/LegalizerInfo.h 973 SpecifiedActions[OpcodeIdx][Aspect.Idx][Aspect.Type] = Action;
include/llvm/CodeGen/MachineFunction.h 908 WasmLPadToIndexMap[LPad] = Index;
926 return LPadToCallSiteMap[Sym];
931 return !LPadToCallSiteMap[Sym].empty();
936 CallSiteMap[BeginLabel] = Site;
987 CallSitesInfo[CallI] = std::move(CallInfo);
include/llvm/CodeGen/MachineModuleInfoImpls.h 45 return GVStubs[Sym];
50 return ThreadLocalGVStubs[Sym];
74 return GVStubs[Sym];
96 return GVStubs[Sym];
include/llvm/CodeGen/MachinePipeliner.h 575 return ScheduledInstrs[cycle];
include/llvm/CodeGen/ModuloSchedule.h 126 int getFirstCycle() { return Cycle[ScheduledInstrs.front()]; }
130 int getFinalCycle() { return Cycle[ScheduledInstrs.back()]; }
342 MI = CanonicalMIs[MI];
include/llvm/CodeGen/RegAllocPBQP.h 147 VRegToNodeId[VReg] = NId;
include/llvm/CodeGen/SelectionDAG.h 165 DbgValMap[Node].push_back(V);
1692 SDCallSiteDbgInfo[CallNode].CSInfo = std::move(CallInfo);
1703 SDCallSiteDbgInfo[Node].HeapAllocSite = MD;
include/llvm/CodeGen/TargetLowering.h 2013 BypassSlowDivWidths[SlowBitWidth] = FastBitWidth;
include/llvm/ExecutionEngine/Orc/Core.h 968 UnmaterializedInfos[KV.first] = UMI;
985 UnmaterializedInfos[KV.first] = UMI;
include/llvm/ExecutionEngine/Orc/Speculation.h 99 auto &SymbolsInJD = SpeculativeLookUpImpls[ImplJD];
148 auto RAddr = (*ReadySymbol)[Target].getAddress();
include/llvm/IR/ModuleSummaryIndex.h 1340 ModuleToDefinedGVSummaries[Summary->modulePath()][GUID] = Summary.get();
include/llvm/IR/PassManager.h 1203 auto &InvalidatedIDList = OuterAnalysisInvalidationMap[OuterID];
include/llvm/IR/PredIteratorCache.h 43 BasicBlock **&Entry = BlockToPredsMap[BB];
50 BlockToPredCountMap[BB] = PredCache.size() - 1;
61 return BlockToPredCountMap[BB] = std::distance(pred_begin(BB), pred_end(BB));
include/llvm/MC/MCMachObjectWriter.h 230 Relocations[Sec].push_back(P);
include/llvm/MC/MCRegisterInfo.h 311 L2SEHRegs[LLVMReg] = SEHReg;
315 L2CVRegs[LLVMReg] = CVReg;
include/llvm/MCA/HardwareUnits/LSUnit.h 304 Groups[GroupID]->onInstructionIssued(IR);
include/llvm/Support/DebugCounter.h 102 return instance().Counters[ID].IsSet;
116 Us.Counters[ID].Count = Count;
163 Counters[Result] = {};
164 Counters[Result].Desc = Desc;
include/llvm/Support/GenericDomTree.h 573 return (DomTreeNodes[BB] = IDomNode->addChild(
587 DomTreeNodeBase<NodeT> *NewNode = (DomTreeNodes[BB] =
594 auto &OldNode = DomTreeNodes[OldRoot];
595 OldNode = NewNode->addChild(std::move(DomTreeNodes[OldRoot]));
include/llvm/Support/GenericDomTreeConstruction.h 188 return (DT.DomTreeNodes[BB] = IDomNode->addChild(
223 if (NodeToInfo.count(V) != 0) NodeToInfo[V].Parent = AttachToNum;
227 auto &BBInfo = NodeToInfo[BB];
250 auto &SuccInfo = NodeToInfo[Succ];
275 InfoRec *VInfo = &NodeToInfo[V];
283 VInfo = &NodeToInfo[NumToNode[VInfo->Parent]];
289 const InfoRec *PLabelInfo = &NodeToInfo[PInfo->Label];
293 const InfoRec *VLabelInfo = &NodeToInfo[VInfo->Label];
309 auto &VInfo = NodeToInfo[V];
317 auto &WInfo = NodeToInfo[W];
341 auto &WInfo = NodeToInfo[W];
342 const unsigned SDomNum = NodeToInfo[NumToNode[WInfo.Semi]].DFSNum;
344 while (NodeToInfo[WIDomCandidate].DFSNum > SDomNum)
345 WIDomCandidate = NodeToInfo[WIDomCandidate].IDom;
588 DT.RootNode = (DT.DomTreeNodes[Root] =
596 NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
604 if (DT.DomTreeNodes[W]) continue; // Haven't calculated this node yet?
613 DT.DomTreeNodes[W] = IDomNode->addChild(
619 NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
624 const TreeNodePtr NewIDom = DT.getNode(NodeToInfo[N].IDom);
665 (DT.DomTreeNodes[From] = VirtualRoot->addChild(
include/llvm/TableGen/Record.h 1912 void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; }
include/llvm/Transforms/IPO/Attributor.h 789 auto &KindToAbstractAttributeMap = AAMap[IRP];
include/llvm/Transforms/Scalar/GVN.h 204 LeaderTableEntry &Curr = LeaderTable[N];
222 LeaderTableEntry *Curr = &LeaderTable[N];
include/llvm/Transforms/Utils/Evaluator.h 73 ValueStack.back()[V] = C;
include/llvm/Transforms/Utils/SSAUpdaterImpl.h 100 (*AvailableVals)[BB] = V;
108 return BBMap[BB]->DefBB->AvailableVal;
120 BBMap[BB] = Info;
199 BBInfo *SuccInfo = BBMap[*SI];
257 (*AvailableVals)[Pred->BB] = Pred->AvailableVal;
349 (*AvailableVals)[Info->BB] = PHI;
361 (*AvailableVals)[Info->BB] = Info->DefBB->AvailableVal;
457 (*AvailableVals)[BB] = PHIVal;
458 BBMap[BB]->AvailableVal = PHIVal;
include/llvm/XRay/Graph.h 392 InNeighbors[I.second].insert(I.first);
393 OutNeighbors[I.first].insert(I.second);
484 InNeighbors[EI.second].insert(EI.first);
485 OutNeighbors[EI.first].insert(EI.second);
lib/Analysis/BlockFrequencyInfoImpl.cpp 183 combineWeight(Combined[W.TargetNode.Index], W);
648 Lookup[I.Node.Index] = &I;
692 InSCC[I] = false;
lib/Analysis/BranchProbabilityInfo.cpp 973 SccI.SccNums[BB] = SccNum;
lib/Analysis/CFLAndersAliasAnalysis.cpp 173 auto &States = ReachMap[To][From];
173 auto &States = ReachMap[To][From];
213 return MemMap[LHS].insert(RHS).second;
234 auto &OldAttr = AttrMap[V];
447 ValueMap[SrcIVal.Val].FromRecords.push_back(
450 ValueMap[SrcIVal.Val].ToRecords.push_back(
lib/Analysis/CFLGraph.h 114 auto &ValInfo = ValueImpls[N.Val];
lib/Analysis/CFLSteensAliasAnalysis.cpp 236 Cache[Fn] = std::move(FunInfo);
lib/Analysis/CodeMetrics.cpp 194 NumBBInsts[BB] = NumInsts - NumInstsBeforeThisBB;
lib/Analysis/DemandedBits.cpp 341 AliveBits[J] = APInt::getAllOnesValue(T->getScalarSizeInBits());
361 AOut = AliveBits[UserI];
lib/Analysis/EHPersonalities.cpp 110 ColorVector &Colors = BlockColors[Visiting];
lib/Analysis/IVDescriptors.cpp 709 SinkAfter[I] = Previous;
lib/Analysis/InlineCost.cpp 490 BasicBlock *KnownSuccessor = KnownSuccessors[Pred];
1695 (KnownSuccessors[Pred] && KnownSuccessors[Pred] != Succ));
1695 (KnownSuccessors[Pred] && KnownSuccessors[Pred] != Succ));
1801 SROAArgCosts[PtrArg] = 0;
1869 KnownSuccessors[BB] = NextBB;
1880 KnownSuccessors[BB] = NextBB;
lib/Analysis/InstructionPrecedenceTracking.cpp 49 return FirstSpecialInsts[BB];
68 FirstSpecialInsts[BB] = &I;
73 FirstSpecialInsts[BB] = nullptr;
lib/Analysis/LazyCallGraph.cpp 659 G->SCCMap[N] = &TargetSCC;
669 SCCIndices[C] -= IndexOffset;
881 SCCIndices[SCCs[Idx]] = Idx;
1095 G->RefSCCIndices[RC] -= IndexOffset;
1328 G->RefSCCIndices[G->PostOrderRefSCCs[i]] = i;
1344 RC.SCCIndices[C] = SCCIndex;
1541 RefSCCIndices[PostOrderRefSCCs[i]] = i;
1697 RC.SCCIndices[RC.SCCs[i]] = i;
lib/Analysis/LazyValueInfo.cpp 191 ValueCache[Val] = std::make_unique<ValueCacheEntryTy>(Val, this);
1320 Visited[Cond] = Result;
lib/Analysis/LoopAccessAnalysis.cpp 679 unsigned &LeaderId = DepSetId[Leader];
926 ObjToLastAccess[UnderlyingObj] = Access;
1664 for (std::vector<unsigned>::iterator I1 = Accesses[*AI].begin(),
1665 I1E = Accesses[*AI].end(); I1 != I1E; ++I1)
1669 I2 = (OI == AI ? std::next(I1) : Accesses[*OI].begin()),
1670 I2E = (OI == AI ? I1E : Accesses[*OI].end());
2401 auto &LAI = LoopAccessInfoMap[L];
lib/Analysis/LoopInfo.cpp 751 OuterParent = SubloopParents[OuterParent];
770 if (Loop *Parent = SubloopParents[Subloop])
825 L = SubloopParents[L];
840 SubloopParents[Subloop] = NearLoop;
lib/Analysis/MemoryDependenceAnalysis.cpp 436 ReverseNonLocalDefsCache[ClosestDependency].insert(LI);
719 MemDepResult &LocalCache = LocalDeps[QueryInst];
767 ReverseLocalDeps[I].insert(QueryInst);
901 ReverseNonLocalDeps[Inst].insert(QueryCall);
1038 ReverseNonLocalPtrDeps[Inst].insert(CacheKey);
1411 NonLocalPointerInfo &NLPI = NonLocalPointerDeps[CacheKey];
1418 CacheInfo = &NonLocalPointerDeps[CacheKey];
1437 CacheInfo = &NonLocalPointerDeps[CacheKey];
1598 LocalDeps[InstDependingOnRemInst] = NewDirtyVal;
1613 ReverseLocalDeps[ReverseDepsToAdd.back().first].insert(
1624 PerInstNLInfo &INLD = NonLocalDeps[I];
1644 ReverseNonLocalDeps[ReverseDepsToAdd.back().first].insert(
1662 NonLocalDepInfo &NLPDI = NonLocalPointerDeps[P].NonLocalDeps;
1665 NonLocalPointerDeps[P].Pair = BBSkipFirstBlockPair();
1687 ReverseNonLocalPtrDeps[ReversePtrDepsToAdd.back().first].insert(
lib/Analysis/MemorySSA.cpp 1362 auto &LocInfo = LocStackInfo[UseMLOC];
lib/Analysis/MemorySSAUpdater.cpp 714 MPhiMap[MPhi] = NewPhi;
741 MPhiMap[MPhi] = MPhi->getIncomingValueForBlock(P1);
916 auto &AddedBlockSet = PredMap[BB].Added;
984 LastDefAddedPred[AddedPred] = DefPn;
992 auto *LastDefForPred = LastDefAddedPred[Pred];
1023 auto *LastDefForPred = LastDefAddedPred[Pred];
lib/Analysis/MustExecute.cpp 35 ColorVector &ColorsForNewBlock = BlockColors[New];
36 ColorVector &ColorsForOldBlock = BlockColors[Old];
lib/Analysis/OrderedBasicBlock.cpp 51 NumberedInsts[Inst] = NextInstPos++;
lib/Analysis/PhiValues.cpp 55 DepthMap[Phi] = DepthNumber;
68 DepthMap[Phi] = std::min(DepthMap[Phi], DepthMap[PhiPhiOp]);
68 DepthMap[Phi] = std::min(DepthMap[Phi], DepthMap[PhiPhiOp]);
79 if (DepthMap[Phi] == DepthNumber) {
84 while (!Stack.empty() && DepthMap[Stack.back()] >= DepthNumber) {
87 DepthMap[ComponentPhi] = DepthNumber;
120 return NonPhiReachableMap[DepthMap[PN]];
120 return NonPhiReachableMap[DepthMap[PN]];
131 for (const Value *V : ReachableMap[N])
lib/Analysis/ProfileSummaryInfo.cpp 272 ThresholdCache[PercentileCutoff] = CountThreshold;
lib/Analysis/ScalarEvolution.cpp 3911 ExprValueMap[S].insert({V, nullptr});
3925 ExprValueMap[Stripped].insert({V, Offset});
7768 PHIMap[OpInst] = P;
7831 Vals[Operand] = C;
7883 return ConstantEvolutionLoopExitValue[PN] = nullptr; // Not going to evaluate it.
7885 Constant *&RetVal = ConstantEvolutionLoopExitValue[PN];
8026 ValuesAtScopes[V];
8036 for (auto &LS : reverse(ValuesAtScopes[V]))
11645 auto &Values = LoopDispositions[S];
11652 auto &Values2 = LoopDispositions[S];
11752 auto &Values = BlockDispositions[S];
11759 auto &Values2 = BlockDispositions[S];
11915 LoopUsers[L].push_back(S);
12373 SCEVToPreds[Key].push_back(N);
12383 RewriteEntry &Entry = RewriteMap[Expr];
lib/Analysis/ScalarEvolutionExpander.cpp 2007 ExprToIVMap[TruncExpr] = Phi;
lib/Analysis/StackSafetyAnalysis.cpp 493 for (auto &CallerID : Callers[Callee])
519 Callers[Callee].push_back(F.first);
lib/Analysis/SyntheticCountsUtils.cpp 61 AdditionalCounts[Callee] += OptProfCount.getValue();
lib/Analysis/VectorUtils.cpp 429 DBits[Leader] |= V;
443 DBits[Leader] |= ~0ULL;
453 if (DBits[Leader] == ~0ULL)
469 DBits[ECs.getOrInsertLeaderValue(I.first)] |= ~0ULL;
474 LeaderDemandedBits |= DBits[*MI];
1041 InterleaveGroupMap[A] = Group;
lib/Bitcode/Reader/BitcodeReader.cpp 2060 DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta;
2808 auto &FwdBBs = BasicBlockFwdRefs[Fn];
2950 (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&
2950 (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&
2952 DeferredFunctionInfo[Fn] = CurBit;
3225 FunctionTypes[Func] = cast<FunctionType>(FullFTy);
3313 DeferredFunctionInfo[Func] = 0;
3708 FunctionType *FullFTy = FunctionTypes[F];
5365 auto VGI = ValueIdToValueInfoMap[ValueId];
5478 ValueIdToValueInfoMap[ValueID] =
6060 FS->setModulePath(ModuleIdMap[ModuleId]);
6075 AS->setModulePath(ModuleIdMap[ModuleId]);
6104 FS->setModulePath(ModuleIdMap[ModuleId]);
6221 ModuleIdMap[ModuleId] = LastSeenModule->first();
lib/Bitcode/Reader/MetadataLoader.cpp 323 auto &Ref = OldTypeRefs.Unknown[UUID];
1580 FunctionsWithSPs[F] = SP;
lib/Bitcode/Writer/ValueEnumerator.cpp 72 std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
81 IDs[V].first = ID;
454 InstructionMap[I] = InstructionCount++;
543 ValueMap[Values[CstStart].first] = CstStart+1;
758 MetadataMap[MD].ID = I + 1;
787 MetadataMap[MD].ID = ++ID;
809 unsigned &ValueID = ValueMap[V];
843 ValueMap[V] = Values.size();
855 unsigned *TypeID = &TypeMap[Ty];
874 TypeID = &TypeMap[Ty];
922 unsigned &Entry = AttributeListMap[PAL];
935 unsigned &Entry = AttributeGroupMap[Pair];
1031 unsigned &Idx = GlobalBasicBlockIDs[BB];
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 484 ScopeVariables[LS].emplace_back(Var);
2576 CompleteTypeIndices[CTy] = TI;
2987 GlobalMap[GVE] = &GV;
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp 768 WorkList.push_back({DbgVar[Dep], 0});
1078 auto &Entity = getAbstractEntities()[Node];
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 1008 CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
2520 Spans[Cur.CU].push_back(Span);
2554 Spans[Prev.CU].push_back(Span);
2580 std::vector<ArangeSpan> &List = Spans[CU];
2625 uint64_t Size = SymSize[Span.Start];
lib/CodeGen/AsmPrinter/DwarfDebug.h 642 SymSize[Sym] = Size;
lib/CodeGen/AsmPrinter/DwarfFile.cpp 105 auto &ScopeVars = ScopeVariables[LS];
122 SmallVectorImpl<DbgLabel *> &Labels = ScopeLabels[LS];
lib/CodeGen/AsmPrinter/EHStreamer.cpp 212 PadMap[BeginLabel] = P;
lib/CodeGen/BranchFolding.cpp 567 MergedBBFreq[MBB] = F;
lib/CodeGen/CodeGenPrepare.cpp 908 RelocateInstMap[MaybeBase->second].push_back(I);
1109 CastInst *&InsertedCast = InsertedCasts[UserBB];
1383 CmpInst *&InsertedCmp = InsertedCmps[UserBB];
1562 BinaryOperator *&InsertedShift = InsertedShifts[TruncUserBB];
1563 CastInst *&InsertedTrunc = InsertedTruncs[TruncUserBB];
1664 BinaryOperator *&InsertedShift = InsertedShifts[UserBB];
3206 Map[AM.OriginalValue] = DV;
3213 Map[V] = Constant::getNullValue(CommonType);
3386 Value *V = Map[Current];
3393 Select->setTrueValue(ST.Get(Map[TrueValue]));
3396 Select->setFalseValue(ST.Get(Map[FalseValue]));
3404 PHI->addIncoming(ST.Get(Map[PV]), B);
3407 Map[Current] = ST.Simplify(V);
3439 Map[Current] = Select;
3450 Map[Current] = PHI;
3604 PromotedInsts[ExtOpnd] = TypeIsSExt(ExtOpnd->getType(), ExtTy);
5540 SeenChainsForSExt[HeadOfChain] = nullptr;
5541 ValToSExtendedUses[HeadOfChain].push_back(I);
5551 SeenChainsForSExt[HeadOfChain] = Inst;
5571 SeenChainsForSExt[HeadOfChain] = nullptr;
5572 ValToSExtendedUses[HeadOfChain].push_back(I);
5632 Instruction *&InsertedTrunc = InsertedTruncs[UserBB];
6144 Instruction *&InsertedShuffle = InsertedShuffles[UserBB];
6195 NewInstructions[UI] = NI;
6207 NewInstructions[OldI]->setOperand(U->getOperandNo(), NI);
lib/CodeGen/GlobalISel/CSEInfo.cpp 131 InstrMapping[UMI->MI] = MaybeNewNode;
162 OpcodeHitTable[Opc] += 1;
164 OpcodeHitTable[Opc] = 1;
lib/CodeGen/GlobalISel/CombinerHelper.cpp 445 EmittedInsns[InsertIntoBB] = NewMI;
lib/CodeGen/GlobalISel/IRTranslator.cpp 284 MachinePreds[Edge].push_back(NewPred);
lib/CodeGen/GlobalMerge.cpp 336 size_t UGSIdx = GlobalUsesByFunction[ParentFn];
349 GlobalUsesByFunction[ParentFn] = CurGVOnlySetIdx;
366 GlobalUsesByFunction[ParentFn] = ExpandedIdx;
372 GlobalUsesByFunction[ParentFn] = EncounteredUGS[UGSIdx] =
lib/CodeGen/InlineSpiller.cpp 1150 StackSlotToOrigLI[StackSlot] = std::move(LI);
1153 VNInfo *OrigVNI = StackSlotToOrigLI[StackSlot]->getVNInfoAt(Idx.getRegSlot());
1182 SmallSetVector<unsigned, 16> &Siblings = Virt2SiblingsMap[OrigReg];
1208 MachineInstr *PrevSpill = SpillBBToSpill[Node];
1261 if (Node != MDT[Block] && SpillBBToSpill[Node]) {
1356 if (SpillsToKeep.find(*RIt) != SpillsToKeep.end() && !SpillsToKeep[*RIt]) {
1357 SpillsInSubTreeMap[*RIt].first.insert(*RIt);
1359 SpillsInSubTreeMap[*RIt].second = MBFI.getBlockFreq(Block);
1377 SpillsInSubTreeMap[*RIt].first;
1378 BlockFrequency &SubTreeCost = SpillsInSubTreeMap[*RIt].second;
1379 SubTreeCost += SpillsInSubTreeMap[Child].second;
1380 auto BI = SpillsInSubTreeMap[Child].first.begin();
1381 auto EI = SpillsInSubTreeMap[Child].first.end();
1387 SpillsInSubTreeMap[*RIt].first;
1388 BlockFrequency &SubTreeCost = SpillsInSubTreeMap[*RIt].second;
1409 !SpillsToKeep[SpillBB]) {
1410 MachineInstr *SpillToRm = SpillBBToSpill[SpillBB];
1418 SpillsToKeep[*RIt] = LiveReg;
1463 Virt2SiblingsMap[Original].insert(Reg);
1469 LiveInterval &OrigLI = *StackSlotToOrigLI[Slot];
lib/CodeGen/InterleavedAccessPass.cpp 388 ReplacementMap[Extract] = std::make_pair(Shuffle, I);
lib/CodeGen/LexicalScopes.cpp 100 MI2ScopeMap[RangeBeginMI] = getOrCreateLexicalScope(PrevDL);
116 MI2ScopeMap[RangeBeginMI] = getOrCreateLexicalScope(PrevDL);
lib/CodeGen/LiveDebugValues.cpp 1350 OrderToBB[RPONumber] = *RI;
1351 BBToOrder[*RI] = RPONumber;
1367 MachineBasicBlock *MBB = OrderToBB[Worklist.top()];
1393 Pending.push(BBToOrder[s]);
lib/CodeGen/LiveDebugVariables.cpp 576 UserValue *&UVEntry = UserVarMap[Ident];
589 VirtRegToUserVals[VirtReg].push_back(UV);
1216 SpillOffsets[NewLocNo] = SpillOffset;
lib/CodeGen/LiveRangeShrink.cpp 210 for (MachineInstr *I = Insert; I && IOM[I] == Barrier;
217 if (DefMO && Insert && NumEligibleUse > 1 && Barrier <= IOM[Insert]) {
lib/CodeGen/LiveVariables.cpp 202 unsigned Dist = DistanceMap[Def];
288 unsigned LastRefOrPartRefDist = DistanceMap[LastRefOrPartRef];
296 unsigned Dist = DistanceMap[Def];
300 unsigned Dist = DistanceMap[Use];
318 unsigned LastRefOrPartRefDist = DistanceMap[LastRefOrPartRef];
345 unsigned Dist = DistanceMap[Def];
356 unsigned Dist = DistanceMap[Use];
lib/CodeGen/MachineBlockFrequencyInfo.cpp 140 layout_order = LayoutOrderMap[Node];
lib/CodeGen/MachineBlockPlacement.cpp 1673 BlockChain &Chain = *BlockToChain[MBB];
1706 assert(BlockToChain[HeadBB] == &Chain && "BlockToChainMap mis-match.\n");
lib/CodeGen/MachineCSE.cpp 499 ScopeMap[MBB] = Scope;
721 if (OpenChildren[Node])
729 unsigned Left = --OpenChildren[Parent];
750 OpenChildren[Node] = Children.size();
802 PREMap[MI] = MBB;
806 auto MBB1 = PREMap[MI];
835 PREMap[MI] = CMBB;
lib/CodeGen/MachineCopyPropagation.cpp 251 CopyDbgUsers[Copy].push_back(&Reader);
627 MRI->updateDbgUsersToReg(SrcReg, CopyDbgUsers[MaybeDead]);
lib/CodeGen/MachineFunction.cpp 721 (!LPMap || (*LPMap)[LandingPad.LandingPadLabel] == 0))
735 if ((BeginLabel->isDefined() || (LPMap && (*LPMap)[BeginLabel] != 0)) &&
736 (EndLabel->isDefined() || (LPMap && (*LPMap)[EndLabel] != 0)))
787 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());
836 CallSitesInfo[New] = CSInfo;
855 CallSitesInfo[New] = CSInfo;
lib/CodeGen/MachineLICM.cpp 650 if (OpenChildren[Node])
657 while (MachineDomTreeNode *Parent = ParentMap[Node]) {
658 unsigned Left = --OpenChildren[Parent];
707 OpenChildren[Node] = NumChildren;
713 ParentMap[Child] = Node;
1493 CSEMap[Opcode].push_back(MI);
lib/CodeGen/MachineOutliner.cpp 282 Parent.Children[Edge] = N;
306 Parent->Children[Edge] = N;
379 SuffixTreeNode *NextNode = Active.Node->Children[FirstChar];
437 SplitNode->Children[Str[NextNode->StartIdx]] = NextNode;
1057 Mapper.MBBFlagsMap[MBB]);
lib/CodeGen/MachinePipeliner.cpp 543 Cycles[KV.first] = Cycles[KV.second];
543 Cycles[KV.first] = Cycles[KV.second];
544 Stages[KV.first] = Stages[KV.second];
544 Stages[KV.first] = Stages[KV.second];
545 NewInstrChanges[KV.first] = InstrChanges[getSUnit(KV.first)];
971 Resources[FuncUnits]++;
1159 OutputDeps[N] = BackEdge;
2177 MISUnitMap[NewMI] = SU;
2178 NewMIs[MI] = NewMI;
2303 std::deque<SUnit *> &cycleInstrs = ScheduledInstrs[checkCycle];
2322 ScheduledInstrs[curCycle].push_back(SU);
2784 MISUnitMap[NewMI] = SU;
2785 NewMIs[MI] = NewMI;
2819 ScheduledInstrs[cycle].push_front(*I);
2838 std::deque<SUnit *> &cycleInstrs = ScheduledInstrs[Cycle];
lib/CodeGen/MachineSSAUpdater.cpp 73 getAvailableVals(AV)[BB] = V;
94 AVals[PredValues[i].first] = PredValues[i].second;
100 if (AVals[SrcBB] != SrcReg) {
356 if (unsigned V = AvailableVals[BB])
lib/CodeGen/MachineSink.cpp 1267 SeenDbgInstrs[Reg].push_back(MI);
lib/CodeGen/MachineTraceMetrics.cpp 775 unsigned Len = LIR.Height + Cycles[DefMI].Depth;
lib/CodeGen/MachineVerifier.cpp 567 BBInfo &MInfo = MBBInfoMap[MBB];
2120 MBBInfoMap[MBB].regsLiveOut = regsLive;
2158 BBInfo &MInfo = MBBInfoMap[MBB];
2191 BBInfo &MInfo = MBBInfoMap[MBB];
lib/CodeGen/ModuloSchedule.cpp 139 InstrMap[NewMI] = CI;
150 InstrMap[NewMI] = &*I;
223 InstrMap[NewMI] = &*BBI;
300 InstrMap[NewMI] = In;
396 PhiOp2 = VRMap[LastStageNum][LoopVal];
404 unsigned NewReg = VRMap[PrevStage][LoopVal];
408 VRMap[CurStageNum][Def] = VRMap[CurStageNum][LoopVal];
443 PhiOp1 = VRMap[PrologStage - StageDiff - np][LoopVal];
463 PhiOp1 = VRMap[PrologStage - StageAdj - Indirects - np][PhiOp1];
490 PhiOp2 = VRMap[PrevStage - StageDiffAdj][LoopVal];
499 PhiOp2 = VRMap[PrevStage - StageDiffAdj - np][LoopVal];
526 NewReg = VRMap[ReuseStage - np][LoopVal];
534 PhiOp2 = VRMap[LastStageNum - np - 1][LoopVal];
544 PhiOp2 = VRMap[CurStageNum - StageDiff - np][LoopVal];
563 PrevReg = VRMap[PrevStage - np][LoopVal];
595 replaceRegUsesAfterLoop(Def, VRMap[CurStageNum][LoopVal], BB, MRI, LIS);
1082 PrevVal = VRMap[StageNum - 1][LoopVal];
1086 PrevVal = VRMap[StageNum][LoopVal];
1492 UndefPhis[LoopReg] = R;
1499 Register &R = Undefs[RC];
1588 LiveStages[BB] = LS;
1589 AvailableStages[BB] = AS;
1596 LiveStages[Prologs.back()] = LS;
1597 AvailableStages[Prologs.back()] = LS;
1624 LiveStages[Epilogs.back()] = LS;
1625 AvailableStages[Epilogs.back()] = AS;
1693 CanonicalMIs[NI] = &MI;
1716 return BlockMIs[{BB, CanonicalMIs[MI]}]->getOperand(OpIdx).getReg();
lib/CodeGen/PHIElimination.cpp 272 unsigned &entry = LoweredPHIs[MPhi];
lib/CodeGen/ReachingDefAnalysis.cpp 120 InstIds[MI] = CurInstr;
175 int InstId = InstIds[MI];
194 return InstIds[MI] - getReachingDef(MI, PhysReg);
lib/CodeGen/RegAllocFast.cpp 328 SmallVectorImpl<MachineInstr *> &LRIDbgValues = LiveDbgValueMap[VirtReg];
lib/CodeGen/RegAllocGreedy.cpp 324 Evictees[Evictee].first = Evictor;
325 Evictees[Evictee].second = PhysReg;
334 return Evictees[Evictee];
2671 VirtRegToPhysReg[ItVirtReg] = VRM->getPhys(ItVirtReg);
2721 unsigned ItPhysReg = VirtRegToPhysReg[ItVirtReg];
lib/CodeGen/RegAllocPBQP.cpp 430 C[K] = G.getEdgeCostsPtr(EId);
lib/CodeGen/RegisterCoalescer.cpp 3294 auto &Counter = LargeLIVisitCounter[LI.reg];
lib/CodeGen/SafeStackColoring.cpp 90 BBMarkerSet[UI->getParent()][UI] = {AllocaNo, IsStart};
109 BlockLifetimeInfo &BlockInfo = BlockLiveness[BB];
115 auto &BlockMarkerSet = BBMarkerSet[BB];
127 BBMarkers[BB].push_back({InstNo, M});
129 InstructionNumbering[I] = InstNo++;
167 BlockLifetimeInfo &BlockInfo = BlockLiveness[BB];
226 for (auto &It : BBMarkers[BB]) {
265 BlockLifetimeInfo &BlockInfo = BlockLiveness[BB];
287 AllocaNumbering[Allocas[I]] = I;
lib/CodeGen/SafeStackLayout.cpp 44 ObjectAlignments[V] = Alignment;
61 ObjectOffsets[Obj.Handle] = End;
133 ObjectOffsets[Obj.Handle] = End;
lib/CodeGen/SafeStackLayout.h 65 unsigned getObjectOffset(const Value *V) { return ObjectOffsets[V]; }
68 unsigned getObjectAlignment(const Value *V) { return ObjectAlignments[V]; }
lib/CodeGen/SelectionDAG/FastISel.cpp 469 LocalValueMap[V] = Reg;
483 return LocalValueMap[V];
488 LocalValueMap[I] = Reg;
492 unsigned &AssignedReg = FuncInfo.ValueMap[I];
1846 MachineBasicBlock *MSucc = FuncInfo.MBBMap[LLVMSucc];
2263 MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB];
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 162 StaticAllocaMap[AI] = FrameIndex;
308 UME.Handler = MBBMap[BB];
312 CME.Handler = MBBMap[BB];
323 NewMap[MBBMap[Src]] = MBBMap[Dst];
323 NewMap[MBBMap[Src]] = MBBMap[Dst];
504 ByValArgFrameIndexMap[A] = FI;
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 86 auto ResId = (ValueToIdMap.count(Res)) ? ValueToIdMap[Res] : 0;
100 auto NewValId = ReplacedValues[ResId];
640 ReplacedValues[FromId] = ToId;
674 ReplacedValues[OldValId] = NewValId;
lib/CodeGen/SelectionDAG/LegalizeTypes.h 158 return IdToValueMap[Id];
180 ReplacedValues[OldId] = NewId;
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp 212 DAG.setRoot(LegalizedNodes[OldRoot]);
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp 568 SmallVectorImpl<unsigned> &LRegs = LRegsMap[TrySU];
743 SDNode *GUser = GluedMap[Glue];
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp 588 CallSeqEndForStart[Def] = SU;
859 SUnit *SeqEnd = CallSeqEndForStart[SU];
1501 SmallVectorImpl<unsigned> &LRegs = LRegsMap[TrySU];
1552 SmallVectorImpl<unsigned> &LRegs = LRegsMap[TrySU];
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1531 SDNode *&N = MCSymbols[Sym];
8422 unsigned &UnsortedOps = Degree[U];
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 1297 SDValue N = NodeMap[V];
1299 N = UnusedArgNodeMap[V];
1394 SDValue &N = NodeMap[V];
1404 NodeMap[V] = Val;
1419 SDValue &N = NodeMap[V];
1433 NodeMap[V] = Val;
1466 SDValue N1 = NodeMap[V];
1500 return NodeMap[V] = DAG.getBuildVector(VT, getCurSDLoc(), Ops);
1552 return NodeMap[V] = DAG.getBuildVector(VT, getCurSDLoc(), Ops);
1624 MachineBasicBlock *SuccessorColorMBB = FuncInfo.MBBMap[SuccessorColor];
1658 UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
1665 UnwindDests.emplace_back(FuncInfo.MBBMap[CatchPadBB], Prob);
1707 UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
1712 UnwindDests.emplace_back(FuncInfo.MBBMap[EHPadBB], Prob);
1719 UnwindDests.emplace_back(FuncInfo.MBBMap[CatchPadBB], Prob);
5850 SDValue &N = NodeMap[Address];
5853 N = UnusedArgNodeMap[Address];
7040 LPadToCallSiteMap[FuncInfo.MBBMap[EHPadBB]].push_back(CallSiteIndex);
7040 LPadToCallSiteMap[FuncInfo.MBBMap[EHPadBB]].push_back(CallSiteIndex);
7089 MF.addInvoke(FuncInfo.MBBMap[EHPadBB], BeginLabel, EndLabel);
8077 OpInfo.CallOperand = DAG.getBasicBlock(FuncInfo.MBBMap[BB]);
9387 : FuncInfo.PreferredExtendType[V];
9531 int &AllocaIndex = FuncInfo->StaticAllocaMap[AI];
9937 MachineBasicBlock *SuccMBB = FuncInfo.MBBMap[SuccBB];
9962 unsigned &RegOut = ConstantsOut[C];
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 507 return NodeMap[V].getNode();
514 SDValue &N = NodeMap[V];
520 SDValue &N = UnusedArgNodeMap[V];
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 1267 MF->setCallSiteLandingPad(Label, SDB->LPadToCallSiteMap[MBB]);
1427 FuncInfo->MBB = FuncInfo->MBBMap[LLVMBB];
1573 SDB->SPDescriptor.initialize(LLVMBB, FuncInfo->MBBMap[LLVMBB],
lib/CodeGen/SelectionDAG/StatepointLowering.cpp 294 Seen[SD] = Ptrs[i];
297 SSM.DuplicateMap[Ptrs[i]] = SeenIt->second;
604 auto &SpillMap = Builder.FuncInfo.StatepointSpillMaps[StatepointInstr];
612 SpillMap.SlotMap[V] = cast<FrameIndexSDNode>(Loc)->getIndex();
620 SpillMap.SlotMap[V] = None;
657 FuncInfo.StatepointSpillMaps[SI.StatepointInstr]);
lib/CodeGen/SelectionDAG/StatepointLowering.h 62 Locations[Val] = Location;
lib/CodeGen/StackColoring.cpp 898 VI.Slot = SlotRemap[VI.Slot];
913 Allocas[From] = To;
980 MMO->setValue(Allocas[AI]);
1018 int ToSlot = SlotRemap[FromSlot];
1070 H.CatchObj.FrameIndex = SlotRemap[H.CatchObj.FrameIndex];
1128 Target = SlotRemap[Target];
1267 SlotRemap[SecondSlot] = FirstSlot;
lib/CodeGen/SwiftErrorValueTracking.cpp 38 VRegDefMap[Key] = VReg;
39 VRegUpwardsUse[Key] = VReg;
60 VRegDefUses[Key] = VReg;
73 VRegDefUses[Key] = VReg;
lib/CodeGen/SwitchLoweringUtils.cpp 199 JTProbs[Clusters[I].MBB] = BranchProbability::getZero();
218 JTProbs[Clusters[I].MBB] += Clusters[I].Prob;
240 addSuccessorWithProb(JumpTableMBB, Succ, JTProbs[Succ]);
lib/CodeGen/TargetPassConfig.cpp 495 Impl->TargetPasses[StandardID] = TargetID;
lib/CodeGen/TwoAddressInstructionPass.cpp 795 assert(SrcRegMap[NewReg] == Reg && "Can't map to two src registers!");
808 assert(DstRegMap[FromReg] == ToReg &&"Can't map to two dst registers!");
813 assert(DstRegMap[DstReg] == ToReg && "Can't map to two dst registers!");
843 assert(SrcRegMap[DstReg] == SrcReg &&
1575 DistanceMap[MI] = ++Dist;
lib/CodeGen/WinEHPrepare.cpp 738 ColorVector &ColorsForBB = BlockColors[BB];
774 ColorVector &NewColors = BlockColors[NewBlock];
786 ColorVector &OldColors = BlockColors[OldBlock];
832 ColorVector &IncomingColors = BlockColors[IncomingBlock];
905 ColorVector &ColorsForUserBB = BlockColors[UserBB];
1214 ColorVector &ColorsForNewBlock = BlockColors[NewBlock];
1215 ColorVector &ColorsForPHIBlock = BlockColors[PHIBlock];
1222 Value *&Load = Loads[IncomingBlock];
1244 LabelToStateMap[InvokeBegin] = std::make_pair(InvokeStateMap[II], InvokeEnd);
1244 LabelToStateMap[InvokeBegin] = std::make_pair(InvokeStateMap[II], InvokeEnd);
lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp 83 OffsetMap[Entry.FileNameOffset] = SerializedSize;
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp 469 CIEs[StartOffset] = Cie.get();
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp 98 NamedStreamData[*ExpectedIndex] = Data;
lib/DebugInfo/PDB/Native/SymbolCache.cpp 152 TypeIndexToSymbolId[Index] = Result;
176 TypeIndexToSymbolId[Index] = Result;
225 TypeIndexToSymbolId[Index] = Id;
278 GlobalOffsetToSymbolId[Offset] = Id;
lib/ExecutionEngine/GDBRegistrationListener.cpp 174 ObjectBufferMap[K] =
lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp 211 Segments[Prot] = {SegAlign, SegContentSize,
lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp 125 Blocks[KV.first] = std::move(SegMem);
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp 275 IndexToSymbol[SymbolIndex] =
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp 149 Callables[Name] = SymbolAliasMapEntry(Name, Flags);
151 NonCallables[Name] = SymbolAliasMapEntry(Name, Flags);
lib/ExecutionEngine/Orc/Core.cpp 302 ResolvedSymbols[S] = nullptr;
462 DelegatedFlags[Name] = std::move(I->second);
509 Flags[KV.first] = KV.second.getFlags();
540 RequestedAliases[Name] = std::move(I->second);
591 QueryAliases[KV.first] = std::move(KV.second);
641 ResolutionMap[KV.first] = JITEvaluatedSymbol(
642 (*Result)[KV.second.Aliasee].getAddress(), KV.second.AliasFlags);
677 SymbolFlags[KV.first] = KV.second.AliasFlags;
699 Result[Name] = SymbolAliasMapEntry(Name, (*Flags)[Name]);
699 Result[Name] = SymbolAliasMapEntry(Name, (*Flags)[Name]);
724 AliasMap[KV.first] = SymbolAliasMapEntry(KV.first, KV.second);
816 UnmaterializedInfos[KV.first] = UMI;
851 assert(Symbols[Name].isInMaterializationPhase() &&
855 if (Symbols[Name].getFlags().hasError())
858 auto &MI = MaterializingInfos[Name];
859 assert(Symbols[Name].getState() != SymbolState::Emitted &&
897 auto &OtherMI = OtherJITDylib.MaterializingInfos[OtherSymbol];
914 Symbols[Name].setFlags(Symbols[Name].getFlags() | JITSymbolFlags::HasError);
914 Symbols[Name].setFlags(Symbols[Name].getFlags() | JITSymbolFlags::HasError);
977 auto &MI = MaterializingInfos[Name];
1159 auto &Sym = JD.Symbols[Name];
1182 auto &DependantSym = DependantJD.Symbols[DependantName];
1188 auto &DependantMI = DependantJD.MaterializingInfos[DependantName];
1392 Flags[Name] = I->second.getFlags();
1504 auto &MI = MaterializingInfos[Name];
1629 auto &MI = MaterializingInfos[Name];
1776 auto &SymEntry = Symbols[KV.first];
1790 auto &MI = MaterializingInfos[QuerySymbol];
1803 auto &DependencyMI = DependencyJD.MaterializingInfos[DependencyName];
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 138 static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
215 NewSymbols[Name] = JITEvaluatedSymbol(
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 39 Result[Name] = JITEvaluatedSymbol(Compile(), JITSymbolFlags::Exported);
lib/ExecutionEngine/Orc/Layer.cpp 38 SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(G);
178 SymbolFlags[InternedName] = std::move(*SymFlags);
lib/ExecutionEngine/Orc/LazyReexports.cpp 148 RequestedAliases[I->first] = std::move(I->second);
184 Stubs[Alias.first] = ISManager.findStub(*Alias.first, false);
204 SymbolFlags[KV.first] = KV.second.AliasFlags;
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp 100 InternedResult[InternedName] =
105 ExtraSymbolsToClaim[InternedName] = Flags;
118 InternedResult[InternedName] =
123 ExtraSymbolsToClaim[InternedName] = Flags;
208 SymbolNameSet &SymDeps = NamedSymbolDeps[SymName];
441 TrackedEHFrameRanges[Key] = EHFrameRange;
lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp 174 ExtraSymbolsToClaim[InternedName] = Flags;
177 Symbols[InternedName] = JITEvaluatedSymbol(KV.second.getAddress(), Flags);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 1887 SectionToGOTMap[i->second] = GOTSectionID;
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldELFMips.cpp 136 uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]);
154 getSectionAddress(SectionToGOTMap[SectionID]) + SymOffset;
174 uint64_t GOTAddr = getSectionLoadAddress(SectionToGOTMap[SectionID]);
lib/IR/AsmWriter.cpp 104 std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
113 IDs[V].first = ID;
547 Type2Number[STy] = NextNumber++;
1184 fMap[V] = DestSlot;
1218 asMap[AS] = DestSlot;
1228 GUIDMap[GUID] = GUIDNext++;
lib/IR/Constants.cpp 643 std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
814 std::unique_ptr<ConstantFP> &Slot = pImpl->FPConstants[V];
1368 Ty->getContext().pImpl->CAZConstants[Ty];
1434 Ty->getContext().pImpl->CPNConstants[Ty];
1447 std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
lib/IR/DataLayout.cpp 595 return LayoutInfo[STy];
lib/IR/DebugInfo.cpp 342 NewLoopID = LoopIDsMap[LoopID] = stripDebugLocFromLoopID(LoopID);
lib/IR/LegacyPassManager.cpp 609 LastUser[AP] = P;
646 LastUser[LU.first] = P;
693 AnUsageMap[P] = &Node->AU;
826 const PassInfo *&PI = AnalysisPassInfos[AID];
844 ImmutablePassMap[AID] = P;
899 SmallPtrSet<Pass *, 8> &L = InversedLastUser[LU.second];
920 AvailableAnalysis[PI] = P;
lib/IR/Mangler.cpp 125 unsigned &ID = AnonGlobalIDs[GV];
lib/IR/Metadata.cpp 107 auto *&Entry = Context.pImpl->MetadataAsValues[MD];
131 auto *&Entry = Store[MD];
352 auto *&Entry = Context.pImpl->ValuesAsMetadata[V];
434 auto *&Entry = Store[To];
lib/IR/ModuleSummaryIndex.cpp 78 GVSummaryMap[GUID] = Summary;
427 NodeMap[SummaryIt.first].push_back(ModId);
480 auto &ModList = NodeMap[E.Dst];
lib/IR/PassTimingInfo.cpp 134 std::unique_ptr<Timer> &T = TimingData[Pass];
lib/IR/SafepointIRVerifier.cpp 678 if (BlockMap[InBB]->AvailableOut.count(InValue))
lib/IR/Type.cpp 260 IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
644 PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
lib/IR/Value.cpp 876 ValueHandleBase *Entry = pImpl->ValueHandles[V];
914 if (pImpl->ValueHandles[V]->getKind() == Assert)
932 ValueHandleBase *Entry = pImpl->ValueHandles[Old];
965 for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next)
lib/IR/Verifier.cpp 4460 auto &Entry = FrameEscapeInfo[Fn];
lib/LTO/LTO.cpp 822 ThinLTO.PrevailingModuleForGUID[GUID] = BM.getModuleIdentifier();
913 GUIDPrevailingResolutions[GUID] =
1347 return ThinLTO.PrevailingModuleForGUID[GUID] == S->modulePath();
lib/LTO/ThinLTOCodeGenerator.cpp 137 PrevailingCopy[I.first] =
lib/Linker/IRMover.cpp 120 Type *&Entry = MappedTypes[SrcTy];
235 Type **Entry = &MappedTypes[Ty];
283 Entry = &MappedTypes[Ty];
1219 Flags[ID] = std::make_pair(Op, I);
1247 Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands());
1259 Flags[ID].first = SrcOp;
1289 Flags[ID].first = Flag;
1360 MDNode *Op = Flags[Flag].first;
lib/Linker/LinkModules.cpp 409 for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
504 LazyComdatMembers[SC].push_back(&GV);
509 LazyComdatMembers[SC].push_back(&SF);
514 LazyComdatMembers[SC].push_back(&GA);
535 for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
lib/MC/MCCodeView.cpp 124 Info->InlinedAtMap[FuncId] = InlinedAt;
lib/MC/MCContext.cpp 230 MCLabel *&Label = Instances[LocalLabelVal];
237 MCLabel *&Label = Instances[LocalLabelVal];
lib/MC/MCDwarf.cpp 1882 const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey;
lib/MC/MachObjectWriter.cpp 647 SectionAddress[Sec] = StartAddress;
lib/MC/WasmObjectWriter.cpp 540 return GOTIndices[RelEntry.Symbol];
550 return TableIndices[Sym];
560 return WasmIndices[RelEntry.Symbol];
576 const wasm::WasmDataReference &Ref = DataLocations[Sym];
630 return TypeIndices[RelEntry.Symbol];
lib/MC/WinCOFFObjectWriter.cpp 247 COFFSymbol *&Ret = SymbolMap[Symbol];
lib/MC/XCOFFObjectWriter.cpp 291 WrapperMap[MCSec] = &Group.Csects.back();
306 WrapperMap[ContainingCsect]->Syms.emplace_back(XSym);
lib/MCA/HardwareUnits/ResourceManager.cpp 311 BusyResources[Pipe] += CS.size();
lib/MCA/InstrBuilder.cpp 92 SuperResources[Super] += PRE->Cycles;
135 B.second.CS.subtract(A.second.size() - SuperResources[A.first]);
lib/Object/RecordStreamer.cpp 128 SymverAliasMap[Aliasee].push_back(AliasName);
lib/ProfileData/Coverage/CoverageMapping.cpp 53 ExpressionIndices[E] = I;
lib/ProfileData/GCOV.cpp 782 LineExecs[Function] = true;
784 LineExecs[Function] = false;
787 } else if (!LineExecs[Function] && Block->getCount()) {
789 LineExecs[Function] = true;
lib/ProfileData/SampleProfReader.cpp 172 TargetCountMap[Target] = count;
527 FuncOffsetTable[*FName] = *Offset;
878 FuncOffsetTable[*FName] = *Offset;
lib/Support/DebugCounter.cpp 97 CounterInfo &Counter = Counters[CounterID];
110 CounterInfo &Counter = Counters[CounterID];
129 << Us.Counters[CounterID].Count << "," << Us.Counters[CounterID].Skip
129 << Us.Counters[CounterID].Count << "," << Us.Counters[CounterID].Skip
130 << "," << Us.Counters[CounterID].StopAfter << "}\n";
lib/Support/VirtualFileSystem.cpp 1194 KeyStatus &S = Keys[Key];
lib/TableGen/Record.cpp 1477 VarInit *&I = ThePool[TheKey];
1506 VarBitInit *&I = ThePool[TheKey];
1531 VarListElementInit *&I = ThePool[TheKey];
1713 FieldInit *&I = ThePool[TheKey];
2383 Map[VarName] = {I, true};
2408 Cache[VarName] = Val;
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp 687 TagMap[*Tag].push_back(&MI);
728 auto &OldCollisions = TagMap[*OptOldTag];
802 TagMap[NewTag].push_back(&MI);
lib/Target/AArch64/AArch64FastISel.cpp 2563 FuncInfo.MBB->addSuccessor(FuncInfo.MBBMap[Succ]);
lib/Target/AArch64/AArch64ISelLowering.cpp 8867 SubVecs[SVI].push_back(SubVec);
8876 auto &SubVec = SubVecs[SVI];
lib/Target/AArch64/AArch64MachineFunctionInfo.h 257 JumpTableEntryInfo[Idx] = std::make_pair(Size, PCRelSym);
lib/Target/AArch64/AArch64PromoteConstant.cpp 218 InsertPts[NewPt] = std::move(OldUses);
465 InsertPts[InsertionPoint].emplace_back(User, OpNo);
534 auto &Promotion = PromotionCache[C];
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp 139 PtrI = noClobberClones[Ptr];
lib/Target/AMDGPU/AMDGPUMachineCFGStructurizer.cpp 642 RegionMap[TopLevelRegion] = Result;
668 RegionMap[Region] = NewMRTRegion;
676 RegionMap[Parent] = NewMRTParent;
680 RegionMap[Parent]->addChild(NewMRTRegion);
681 NewMRTRegion->setParent(RegionMap[Parent]);
685 RegionMap[Region]->addChild(NewMBB);
686 NewMBB->setParent(RegionMap[Region]);
687 RegionMap[Region]->setSucc(Region->getExit());
1907 MachineBasicBlock *FallthroughBB = FallthroughMap[CodeBB];
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp 326 auto &ValVec = Replacements[Store.first];
lib/Target/AMDGPU/GCNRegPressure.cpp 285 LiveRegs[Reg] = LiveMask;
324 auto LiveMask = LiveRegs[U.RegUnit];
346 auto &LiveMask = LiveRegs[U.RegUnit];
lib/Target/AMDGPU/GCNRegPressure.h 226 LiveRegMap[SII.getInstructionFromIndex(SI)][Reg] =
234 LiveRegMap[SII.getInstructionFromIndex(SI)][Reg] |= S.LaneMask;
lib/Target/AMDGPU/GCNSchedStrategy.cpp 499 MBBLiveIns[OnlySucc] = RPTracker.moveLiveRegs();
lib/Target/AMDGPU/R600ISelLowering.cpp 1705 RemapSwizzle[i] = 7; // SEL_MASK_WRITE
1708 RemapSwizzle[i] = 4; // SEL_0
1711 RemapSwizzle[i] = 5; // SEL_1
1727 RemapSwizzle[i] = j;
1751 RemapSwizzle[i] = i;
1768 std::swap(RemapSwizzle[i], RemapSwizzle[Idx]);
1768 std::swap(RemapSwizzle[i], RemapSwizzle[Idx]);
1787 Swz[i] = DAG.getConstant(SwizzleRemap[Idx], DL, MVT::i32);
1795 Swz[i] = DAG.getConstant(SwizzleRemap[Idx], DL, MVT::i32);
lib/Target/AMDGPU/R600OptimizeVectorRegisters.cpp 220 UpdatedRegToChan[SubReg] = Chan;
301 CompatibleRSI = PreviousRegSeq[MI];
315 if (PreviousRegSeqByUndefCount[NeededUndefs].empty())
318 PreviousRegSeqByUndefCount[NeededUndefs];
319 CompatibleRSI = PreviousRegSeq[MIs.back()];
327 PreviousRegSeqByReg[(*It).first].push_back(RSI.Instr);
330 PreviousRegSeq[RSI.Instr] = RSI;
lib/Target/AMDGPU/SIFoldOperands.cpp 743 Vgpr = VGPRCopies[CopyToVGPR];
747 VGPRCopies[CopyToVGPR] = Vgpr;
lib/Target/AMDGPU/SIInsertWaitcnts.cpp 1482 RpotIdxMap[MBB] = BlockInfos.size();
1516 unsigned SuccIdx = RpotIdxMap[Succ];
lib/Target/AMDGPU/SILowerI1Copies.cpp 213 ReachableMap[MBB] = true;
385 Visited[MBB] = Level;
lib/Target/AMDGPU/SIMachineFunctionInfo.cpp 263 std::vector<SpilledReg> &SpillLanes = SGPRToVGPRSpills[FI];
333 auto &Spill = VGPRToAGPRSpills[FI];
lib/Target/AMDGPU/SIWholeQuadMode.cpp 430 BlockInfo &BI = Blocks[MBB];
489 BlockInfo &PredBI = Blocks[Pred];
500 BlockInfo &SuccBI = Blocks[Succ];
lib/Target/ARM/ARMAsmPrinter.cpp 1226 AFI->EHPrologueRemappedRegs[DstReg] = SrcReg;
lib/Target/ARM/ARMFastISel.cpp 1345 FuncInfo.MBB->addSuccessor(FuncInfo.MBBMap[SuccBB]);
lib/Target/ARM/ARMISelLowering.cpp 7172 unsigned &Count = ValueCounts[V];
9497 CallSiteNumToLPad[*CSI].push_back(&*BB);
9509 SmallVectorImpl<MachineBasicBlock*> &MBBList = CallSiteNumToLPad[I];
9859 if (!DefRegs[Reg])
16828 SubVecs[SV].push_back(SubVec);
16837 auto &SubVec = SubVecs[SVI];
lib/Target/ARM/ARMLoadStoreOptimizer.cpp 2268 unsigned Loc = MI2LocMap[Op];
2454 SmallVectorImpl<MachineInstr *> &Lds = Base2LdsMap[Base];
2462 SmallVectorImpl<MachineInstr *> &Sts = Base2StsMap[Base];
lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp 1131 RegOffsets[Reg] = Inst.getOffset();
1133 RegOffsets[Reg] = Inst.getOffset();
lib/Target/ARM/MVETailPredication.cpp 496 NewPredicates[Predicate] = cast<Instruction>(TailPredicate);
lib/Target/Hexagon/HexagonBitSimplify.cpp 3101 HBS::replaceReg(OldPhiR, RegMap[G.Out.Reg], *MRI);
lib/Target/Hexagon/HexagonBranchRelaxation.cpp 173 Distance = std::abs((long long)InstOffset - BlockToInstOffset[TBB])
186 Distance = std::abs((long long)InstOffset - BlockToInstOffset[FBB])
lib/Target/Hexagon/HexagonCopyToCombine.cpp 454 LastDef[Reg] = &MI;
lib/Target/Hexagon/HexagonGenInsert.cpp 919 IFMap[VR].push_back(RR);
1295 RemC[R]++;
1312 unsigned D = RemC[R];
1313 UseC[R] = (C > D) ? C-D : 0; // doz
1353 if (UseC[R] == 0)
1362 if (UseC[R] != 0)
1403 RegMap[VR] = NewVR;
1413 unsigned NewR = RegMap[I->first];
1445 MRI->replaceRegWith(I->first, RegMap[I->first]);
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 1619 assert(RootWeights[N] != -1 && "Cannot get weight of unvisited root!");
1620 assert(RootWeights[N] != -2 && "Cannot get weight of RAWU'd root!");
1621 return RootWeights[N];
1627 assert(RootWeights.count(N) && RootWeights[N] >= 0 &&
1629 return RootHeights[N];
1857 return GAUsesInFunction[V];
1867 GAUsesInFunction[V] = Result;
1879 assert(RootWeights[N] != -2 && "This node was RAUW'd!");
1883 if (RootWeights[N] != -1)
1896 if (isOpcodeHandled(Op0N) && RootWeights[Op0N] == -1) {
1903 if (isOpcodeHandled(Op1N) && RootWeights[Op1N] == -1) {
1909 RootWeights[N] = Weight;
1910 RootHeights[N] = std::max(getHeight(N->getOperand(0).getNode()),
1914 << " Height=" << RootHeights[N] << "): ");
1973 NodeHeights[Child] = 1;
2002 NodeHeights[Child] = getHeight(Child.getNode());
2031 if (std::abs(NodeHeights[Op1] - NodeHeights[Child->getOperand(0)]) > 1)
2031 if (std::abs(NodeHeights[Op1] - NodeHeights[Child->getOperand(0)]) > 1)
2034 NodeHeights[Child] = std::max(NodeHeights[Op1],
2034 NodeHeights[Child] = std::max(NodeHeights[Op1],
2035 NodeHeights[Child->getOperand(0)]) + 1;
2050 int Height = std::max(NodeHeights[Mul1.Value], NodeHeights[Mul2.Value]) + 1;
2050 int Height = std::max(NodeHeights[Mul1.Value], NodeHeights[Mul2.Value]) + 1;
2059 NodeHeights[New] = Height;
2094 NodeHeights[GA.Value] = getHeight(GA.Value.getNode());
2103 RootWeights[N] = CurrentWeight;
2104 RootHeights[N] = NodeHeights[SDValue(N, 0)];
2113 int Height = std::max(NodeHeights[GA.Value], NodeHeights[SHL.Value]) + 1;
2113 int Height = std::max(NodeHeights[GA.Value], NodeHeights[SHL.Value]) + 1;
2118 NodeHeights[GA.Value] = Height;
2172 int Height = std::max(NodeHeights[V0], NodeHeights[V1]) + 1;
2172 int Height = std::max(NodeHeights[V0], NodeHeights[V1]) + 1;
2184 NodeHeights[NewNode] = Height;
2198 int Height = NodeHeights[NewRoot];
2221 RootWeights[N] = -2;
2273 RootWeights[N] = -1;
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp 1349 Refs[N] = &N;
lib/Target/Hexagon/HexagonOptAddrMode.cpp 766 if (UseMOnum >= 0 && InstrEvalResult[UseMI])
lib/Target/Hexagon/HexagonRDFOpt.cpp 206 unsigned N = OpMap[RA.Id];
lib/Target/Hexagon/HexagonSubtarget.cpp 245 LastVRegUse[VRegHoldingReg[MO.getReg()]] = &DAG->SUnits[su];
lib/Target/Hexagon/MCTargetDesc/HexagonMCChecker.cpp 124 Defs[R].insert(PredSense(PredReg, isTrue));
586 if (!isPredicateRegister(R) && Defs[R].size() > 1) {
588 PredSet &PM = Defs[R];
lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.cpp 153 setUnits((*TUL)[T].first);
154 setLanes((*TUL)[T].second);
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 288 DenseMap<unsigned, unsigned> &RegMap = VRegMapping[RC];
289 unsigned RegNum = RegMap[Reg];
754 seenMap[F] = true;
1656 DenseMap<unsigned, unsigned> ®map = VRegMapping[RC];
1675 DenseMap<unsigned, unsigned> ®map = VRegMapping[RC];
lib/Target/PowerPC/PPCBoolRetToInt.cpp 247 BoolToIntMap[V] = translate(V);
lib/Target/PowerPC/PPCFastISel.cpp 1867 FuncInfo.MBB->addSuccessor(FuncInfo.MBBMap[SuccBB]);
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 1217 auto &ValueEntry = Memoizer[V];
lib/Target/PowerPC/PPCVSXSwapRemoval.cpp 542 SwapMap[MI] = SwapEntry.VSEId;
620 int DefIdx = SwapMap[DefMI];
701 int DefIdx = SwapMap[DefMI];
777 int DefIdx = SwapMap[DefMI];
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp 99 return LoopMap[ML].get();
100 LoopMap[ML] = std::make_unique<ConcreteRegion<MachineLoop>>(ML);
101 return LoopMap[ML].get();
105 return ExceptionMap[WE].get();
106 ExceptionMap[WE] =
108 return ExceptionMap[WE].get();
lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp 901 UnwindDestToTryRanges[UnwindDest].push_back(TryRange(&MI, &MI));
973 BrDestToTryRanges[AppendixBB].push_back(Range);
974 BrDestToExnReg[AppendixBB] = ExnReg;
1046 for (auto Range : UnwindDestToTryRanges[EHPad])
1047 BrDestToTryRanges[BrDest].push_back(Range);
1048 BrDestToExnReg[BrDest] = ExnReg;
1106 unsigned ExnReg = BrDestToExnReg[BrDest];
lib/Target/WebAssembly/WebAssemblyFixIrreducibleControlFlow.cpp 134 Reachable[MBB].insert(Succ);
148 if (Reachable[Pred].insert(Succ).second) {
171 LoopEnterers[Looper].insert(Pred);
443 .addImm(Indices[Entry]);
lib/Target/X86/X86DiscriminateMemOps.cpp 116 MemOpDiscriminators[Loc] =
117 std::max(MemOpDiscriminators[Loc], DI->getBaseDiscriminator());
139 DenseSet<unsigned> &Set = Seen[L];
146 MemOpDiscriminators[L] + 1, DF, CI);
161 ++MemOpDiscriminators[L];
lib/Target/X86/X86DomainReassignment.cpp 466 EnclosedInstrs[MI] = C.getID();
lib/Target/X86/X86FastISel.cpp 799 LocalValueMap[V] = LoadReg;
2774 MFI.setStackProtectorIndex(FuncInfo.StaticAllocaMap[Slot]);
lib/Target/X86/X86FrameLowering.cpp 2056 WinEHXMMSlotInfo[SlotIndex] = XMMCalleeSavedFrameSize;
lib/Target/X86/X86ISelLowering.cpp14252 LaneMap[I] = I;
14273 LaneMap[MovingInputs[i]] = 2 * j + MovingInputs[i] % 2;
14295 int MappedMask = LaneMap[Mask[i]] - (TargetLo ? 0 : 8);
30964 CallSiteNumToLPad[CSI].push_back(&MBB);
30975 for (auto &LP : CallSiteNumToLPad[CSI]) {
31143 if (!DefRegs[Reg])
lib/Target/X86/X86PadShortFunction.cpp 151 ReturnBBs[MBB] = std::max(ReturnBBs[MBB], Cycles);
151 ReturnBBs[MBB] = std::max(ReturnBBs[MBB], Cycles);
186 VisitedBBs[MBB] = VisitedBBInfo(true, CyclesToEnd);
194 VisitedBBs[MBB] = VisitedBBInfo(false, CyclesToEnd);
lib/Target/X86/X86SpeculativeLoadHardening.cpp 718 ++SuccCounts[UncondSucc];
816 assert(SuccCounts[UncondSucc] == 1 &&
1823 AddrRegToHardenedReg[HardenedReg] = HardenedReg;
lib/Target/X86/X86WinAllocaExpander.cpp 151 Offset = std::max(Offset, OutOffset[Pred]);
187 OutOffset[MBB] = Offset;
lib/Target/X86/X86WinEHState.cpp 519 auto &BBColors = BlockColors[BB];
736 auto &BBColors = BlockColors[BB];
lib/Transforms/IPO/Attributor.cpp 3563 for (Instruction *FreeCall : FreesForMalloc[MallocCall]) {
4370 for (Instruction *I : OpcodeInstMap[Opcode]) {
lib/Transforms/IPO/CalledValuePropagation.cpp 248 ChangedValues[RetF] =
274 ChangedValues[RegI] = getOverdefinedVal();
286 ChangedValues[RegFormal] =
295 ChangedValues[RegI] =
307 ChangedValues[RegI] =
320 ChangedValues[RegI] =
323 ChangedValues[RegI] = getOverdefinedVal();
338 ChangedValues[MemGV] =
351 ChangedValues[RegI] = getOverdefinedVal();
lib/Transforms/IPO/ConstantMerge.cpp 184 GlobalVariable *&Slot = CMap[Init];
lib/Transforms/IPO/FunctionImport.cpp 888 SummariesForIndex[GI] = DS->second;
lib/Transforms/IPO/GlobalDCE.cpp 137 GVDependencies[GVU].insert(&GV);
185 TypeIdMap[TypeID].insert(std::make_pair(&GV, Offset));
205 for (auto &VTableInfo : TypeIdMap[TypeId]) {
253 for (auto &VTableInfo : TypeIdMap[TypeId]) {
346 for (auto *GVD : GVDependencies[LGV])
lib/Transforms/IPO/GlobalOpt.cpp 1156 std::vector<Value *> &FieldVals = InsertedScalarizedValues[V];
lib/Transforms/IPO/Inliner.cpp 195 std::vector<AllocaInst *> &AllocasForType = InlinedArrayAllocas[ATy];
lib/Transforms/IPO/LowerTypeTests.cpp 835 GlobalLayout[G] = GVOffset;
1150 TypeIdUserInfo &TIUI = TypeIdUsers[TypeId];
1486 GlobalLayout[Functions[I]] = I * EntrySize;
1580 GlobalLayout[GTM] = IndirectIndex++;
1594 TypeIdIndices[TypeIds[I]] = I;
1608 GlobalIndices[GTM] = GlobalIndex;
1616 TMSet.insert(GlobalIndices[T]);
1990 for (GlobalTypeMember *GTM : TypeIdInfo[TypeId].RefGlobals)
2031 GlobalTypeMember *GTM = GlobalTypeMembers[Base];
2062 for (Metadata *MD : MetadataByGUID[G])
2085 MaxUniqueId = std::max(MaxUniqueId, TypeIdInfo[MD].UniqueId);
2117 return TypeIdInfo[M1].UniqueId < TypeIdInfo[M2].UniqueId;
2117 return TypeIdInfo[M1].UniqueId < TypeIdInfo[M2].UniqueId;
2143 ExportedFunctions[Aliasee].Linkage != CFL_Definition ||
lib/Transforms/IPO/PartialInlining.cpp 468 VisitedMap[CurrEntry] = true;
532 VisitedMap[BB] = true;
959 CallSiteToProfCountMap[User] = *Count;
961 CallSiteToProfCountMap[User] = 0;
1420 uint64_t CallSiteCount = CallSiteToProfCountMap[User];
lib/Transforms/IPO/SampleProfile.cpp 516 unsigned &Count = SampleCoverage[FS][Loc];
622 << "]: " << EdgeWeights[E] << "\n";
631 const BasicBlock *Equiv = EquivalenceClass[BB];
633 << "]: " << ((Equiv) ? EquivalenceClass[BB]->getName() : "NONE") << "\n";
1045 uint64_t Weight = BlockWeights[EC];
1050 EquivalenceClass[BB2] = EC;
1064 Weight = std::max(Weight, BlockWeights[BB2]);
1068 BlockWeights[EC] = Samples->getHeadSamples() + 1;
1070 BlockWeights[EC] = Weight;
1126 const BasicBlock *EquivBB = EquivalenceClass[BB];
1128 BlockWeights[BB] = BlockWeights[EquivBB];
1128 BlockWeights[BB] = BlockWeights[EquivBB];
1151 return EdgeWeights[E];
1173 const BasicBlock *EC = EquivalenceClass[BB];
1187 NumTotalEdges = Predecessors[BB].size();
1188 for (auto *Pred : Predecessors[BB]) {
1195 SingleEdge = std::make_pair(Predecessors[BB][0], BB);
1199 NumTotalEdges = Successors[BB].size();
1200 for (auto *Succ : Successors[BB]) {
1205 SingleEdge = std::make_pair(BB, Successors[BB][0]);
1233 uint64_t &BBWeight = BlockWeights[EC];
1247 EdgeWeights[SingleEdge] < BlockWeights[EC]) {
1247 EdgeWeights[SingleEdge] < BlockWeights[EC]) {
1250 EdgeWeights[SingleEdge] = BlockWeights[EC];
1250 EdgeWeights[SingleEdge] = BlockWeights[EC];
1257 EdgeWeights[UnknownEdge] = BBWeight - TotalWeight;
1259 EdgeWeights[UnknownEdge] = 0;
1262 OtherEC = EquivalenceClass[UnknownEdge.first];
1264 OtherEC = EquivalenceClass[UnknownEdge.second];
1267 EdgeWeights[UnknownEdge] > BlockWeights[OtherEC])
1267 EdgeWeights[UnknownEdge] > BlockWeights[OtherEC])
1268 EdgeWeights[UnknownEdge] = BlockWeights[OtherEC];
1268 EdgeWeights[UnknownEdge] = BlockWeights[OtherEC];
1274 } else if (VisitedBlocks.count(EC) && BlockWeights[EC] == 0) {
1277 for (auto *Pred : Predecessors[BB]) {
1279 EdgeWeights[E] = 0;
1283 for (auto *Succ : Successors[BB]) {
1285 EdgeWeights[E] = 0;
1290 uint64_t &BBWeight = BlockWeights[BB];
1293 EdgeWeights[SelfReferentialEdge] = BBWeight - TotalWeight;
1295 EdgeWeights[SelfReferentialEdge] = 0;
1302 BlockWeights[EC] = TotalWeight;
1473 uint64_t Weight = EdgeWeights[E];
lib/Transforms/IPO/SyntheticCountsPropagation.cpp 104 M, [&](Function *F, uint64_t Count) { Counts[F] = Scaled64(Count, 0); });
124 BBCount *= Counts[Caller];
136 Counts[F] += New;
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 93 Metadata *&GlobalMD = LocalToGlobal[MD];
lib/Transforms/IPO/WholeProgramDevirt.cpp 807 TypeIdMap[TypeID].insert({BitsPtr, Offset});
1826 for (Metadata *MD : MetadataByGUID[VF.GUID]) {
1831 for (Metadata *MD : MetadataByGUID[VF.GUID]) {
1837 for (Metadata *MD : MetadataByGUID[VC.VFunc.GUID]) {
1845 for (Metadata *MD : MetadataByGUID[VC.VFunc.GUID]) {
1863 if (tryFindVirtualCallTargets(TargetsForSlot, TypeIdMap[S.first.TypeID],
1947 for (StringRef Name : NameByGUID[VF.GUID]) {
1952 for (StringRef Name : NameByGUID[VF.GUID]) {
1958 for (StringRef Name : NameByGUID[VC.VFunc.GUID]) {
1966 for (StringRef Name : NameByGUID[VC.VFunc.GUID]) {
lib/Transforms/InstCombine/InstCombineCasts.cpp 2225 NewPNodes[OldPN] = NewPN;
2230 PHINode *NewPN = NewPNodes[OldPN];
2243 NewV = NewPNodes[PrevPN];
2261 PHINode *NewPN = NewPNodes[OldPN];
lib/Transforms/InstCombine/InstCombineCompares.cpp 657 NewInsts[Base] = ConstantInt::getNullValue(IndexType);
723 NewIncoming = NewInsts[NewIncoming];
746 makeArrayRef(NewInsts[Val]), Val->getName() + ".ptr");
756 return NewInsts[Start];
lib/Transforms/InstCombine/InstCombinePHI.cpp 258 Instruction *&CI = Casts[IncomingVal];
1057 Value *&PredVal = PredValues[Pred];
lib/Transforms/InstCombine/InstructionCombining.cpp 3422 Constant *&FoldRes = FoldedConstants[C];
lib/Transforms/Instrumentation/AddressSanitizer.cpp 1142 Entry &E = Entries[GV];
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 519 return Visited[V];
562 return Visited[I];
568 Visited[I] = false;
575 Visited[I] = true;
595 Visited[I] = true;
599 Visited[I] = false;
647 BiasMap[Key] = TrueProb;
651 BiasMap[Key] = FalseProb;
1429 OutermostScope->HoistStopMap[R] = HoistStops;
1892 BranchProbability Bias = BranchBiasMap[R];
1935 BranchProbability Bias = SelectBiasMap[SI];
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 898 UnwrappedFnMap[WrappedFnCst] = &F;
1026 Value *&Shadow = ValShadowMap[V];
1113 CachedCombinedShadow &CCS = CachedCombinedShadows[Key];
1157 ShadowElements[CCS.Shadow] = std::move(UnionElems);
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 1132 AllocaDeclareMap[Alloca].push_back(DDI);
1206 AllocaToPaddedAllocaMap[AI] = NewAI;
lib/Transforms/Instrumentation/InstrProfiling.cpp 219 LoopToCandidates[TargetLoop].emplace_back(OldVal, NewStore);
357 unsigned PendingCandsInTarget = LoopToCandidates[TargetLoop].size();
462 LoopPromotionCandidates[ParentLoop].emplace_back(CounterLoad, CounterStore);
591 ProfileDataMap[Name] = PD;
849 ProfileDataMap[NamePtr] = PD;
lib/Transforms/ObjCARC/ObjCARCContract.cpp 593 BBSize = BBSizeMap[BB] = BB->size();
lib/Transforms/Scalar/ADCE.cpp 129 bool isLive(Instruction *I) { return InstInfo[I].Live; }
241 BBInfo.second.TerminatorLiveInfo = &InstInfo[BBInfo.second.Terminator];
265 void completed(BasicBlock *BB) { (*this)[BB] = false; }
378 auto &Info = InstInfo[I];
576 InstInfo[Info.Terminator].Live = true;
658 InstInfo[PredTerm].Live = true;
lib/Transforms/Scalar/ConstantHoisting.cpp 269 auto &InsertPts = InsertPtsMap[Node].first;
270 BlockFrequency &InsertPtsFreq = InsertPtsMap[Node].second;
286 auto &ParentInsertPts = InsertPtsMap[Parent].first;
287 BlockFrequency &ParentPtsFreq = InsertPtsMap[Parent].second;
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 355 SuccessorsCount[Succ]++;
406 if (--SuccessorsCount[Succ] == 0)
lib/Transforms/Scalar/DeadStoreElimination.cpp 429 auto &IM = IOL[DepWrite];
lib/Transforms/Scalar/DivRemPairs.cpp 150 Instruction *DivInst = DivMap[RemPair.first];
lib/Transforms/Scalar/GVN.cpp 372 NumberingPhi[num] = PN;
487 valueNumbering[V] = nextValueNumber;
542 valueNumbering[V] = nextValueNumber;
543 NumberingPhi[nextValueNumber] = cast<PHINode>(V);
546 valueNumbering[V] = nextValueNumber;
551 valueNumbering[V] = e;
697 char &BBVal = FullyAvailableBlocks[BB];
715 char &EntryVal = FullyAvailableBlocks[Entry];
1088 FullyAvailableBlocks[AV.BB] = true;
1090 FullyAvailableBlocks[UnavailableBB] = false;
1569 uint32_t &e = expressionNumbering[Exp];
1585 LeaderTableEntry *Vals = &Gvn.LeaderTable[Num];
1609 LeaderTableEntry *Vals = &Gvn.LeaderTable[Num];
1643 if (PHINode *PN = NumberingPhi[Num]) {
1684 if (uint32_t NewNum = expressionNumbering[Exp]) {
1709 LeaderTableEntry Vals = LeaderTable[num];
lib/Transforms/Scalar/GVNHoist.cpp 352 BBSideEffects[BB] = true;
357 BBSideEffects[BB] = true;
361 BBSideEffects[BB] = false;
625 RenameStack[VI.first].push_back(VI.second);
798 OutValue[IDFB].push_back(C);
lib/Transforms/Scalar/GVNSink.cpp 429 ValueNumbering[V] = nextValueNumber;
490 ValueNumbering[V] = nextValueNumber;
506 ValueNumbering[V] = e;
644 VNums[N]++;
654 if (VNums[VNumToSink] == 1)
lib/Transforms/Scalar/GuardWidening.cpp 325 auto &CurrentList = GuardsInBlock[BB];
lib/Transforms/Scalar/JumpThreading.cpp 1543 DestPopularity[PredToDest.second]++;
lib/Transforms/Scalar/LICM.cpp 479 LoopToAliasSetMap[L] = std::move(CurAST);
643 HoistableBranches[BI] = CommonSucc;
689 return HoistDestinationMap[BB];
706 HoistDestinationMap[BB] = InitialPreheader;
717 BasicBlock *CommonSucc = HoistableBranches[BI];
723 return HoistDestinationMap[Orig];
726 HoistDestinationMap[Orig] = New;
785 return HoistDestinationMap[BB];
1467 New = SunkCopies[ExitBlock] = CloneInstructionInExitBlock(
lib/Transforms/Scalar/LoopDistribute.cpp 522 int ThisPartition = this->InstToPartitionId[Inst];
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 746 ConsecutiveChain[SL[i]] = SL[k];
779 I = ConsecutiveChain[I];
lib/Transforms/Scalar/LoopLoadElimination.cpp 292 if (LoadToSingleCand[Cand.Load] != &Cand) {
lib/Transforms/Scalar/LoopRerollPass.cpp 288 PossibleRedIdx[J] = i;
316 PossibleRedIter[J1] = 0;
317 PossibleRedIter[J2] = i;
319 int Idx = PossibleRedIdx[J1];
320 assert(Idx == PossibleRedIdx[J2] &&
966 Inc = IVToIncMap[IV];
1514 int Iter = PossibleRedIter[J];
lib/Transforms/Scalar/LoopSink.cpp 288 LoopBlockNumber[B] = ++i;
lib/Transforms/Scalar/LoopStrengthReduce.cpp 4115 UsedByIndicesMap[Reg] |= RegUses.getUsedByIndices(Use);
4145 UsedByIndicesMap[Reg].count() == 1) {
4769 FRegNum += RegNumMap[BaseReg] / LU.getNotSelectedProbability(BaseReg);
4772 RegNumMap[BaseReg] / LU.getNotSelectedProbability(BaseReg);
4777 RegNumMap[ScaledReg] / LU.getNotSelectedProbability(ScaledReg);
4780 RegNumMap[ScaledReg] / LU.getNotSelectedProbability(ScaledReg);
lib/Transforms/Scalar/LoopUnswitch.cpp 341 (*CurLoopInstructions)[SI].insert(V);
346 return (*CurLoopInstructions)[SI].count(V);
382 NewLoopProps.UnswitchedVals[NewInst] = OldLoopProps.UnswitchedVals[OldInst];
382 NewLoopProps.UnswitchedVals[NewInst] = OldLoopProps.UnswitchedVals[OldInst];
443 Cache[Cond] = Cond;
483 Cache[Cond] = LHS;
491 Cache[Cond] = RHS;
497 Cache[Cond] = nullptr;
lib/Transforms/Scalar/NaryReassociate.cpp 258 SeenExprs[NewSCEV].push_back(WeakTrackingVH(&*I));
278 SeenExprs[OldSCEV].push_back(WeakTrackingVH(&*I));
lib/Transforms/Scalar/NewGVN.cpp 234 ValueToComponent[Member] = ComponentID;
717 ValueToClass[Member] = CClass;
2082 MemoryToUsers[To].insert(U);
2456 for (auto InstNum : RevisitOnReachabilityChange[To])
2674 ExpressionToPhiOfOps[E].insert(OrigInst);
2750 RevisitOnReachabilityChange[PHIBlock].reset(InstrToDFSNum(I));
2806 RevisitOnReachabilityChange[PHIBlock].set(InstrToDFSNum(I));
2845 RevisitOnReachabilityChange[PHIBlock].set(InstrToDFSNum(I));
2996 RevisitOnReachabilityChange[B].set(End);
3012 ++ProcessedCount[V];
3013 assert(ProcessedCount[V] < 100 &&
3438 return RPOOrdering[A] < RPOOrdering[B];
3438 return RPOOrdering[A] < RPOOrdering[B];
lib/Transforms/Scalar/Reassociate.cpp 178 unsigned BBRank = RankMap[BB] = ++Rank << 16;
527 Leaves[Op] = Weight;
598 Leaves[Op] = Weight;
1549 unsigned Occ = ++FactorOccurrences[Factor];
1563 unsigned Occ = ++FactorOccurrences[Factor];
1576 unsigned Occ = ++FactorOccurrences[Factor];
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 1315 TypeToDeclMap[Ty] = getGCRelocateDecl(Ty);
1316 Function *GCRelocateDecl = TypeToDeclMap[Ty];
1640 Value *Alloca = AllocaMap[OriginalValue];
1674 Value *Alloca = AllocaMap[OriginalValue];
1712 AllocaMap[LiveValue] = Alloca;
lib/Transforms/Scalar/SCCP.cpp 294 LatticeVal &IV = TrackedGlobals[GV];
405 markOverdefined(ValueState[V], V);
442 return markConstant(ValueState[V], V, C);
447 LatticeVal &IV = ValueState[V];
483 return mergeInValue(ValueState[V], V, MergeWithV);
lib/Transforms/Scalar/SROA.cpp 1310 InjectedLoads[Pred] = Load;
3717 auto &Offsets = SplitOffsetsMap[I];
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 1192 DominatingExprs[Key].push_back(I);
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 700 DefaultExitBB = SplitExitBBMap[DefaultExitBB] = SplitBB;
720 BasicBlock *&SplitExitBB = SplitExitBBMap[ExitBB];
1222 ExitLoopMap[ClonedExitBB] = ExitL;
2008 DominatingSucc[BB] = SuccBB;
2029 ClonedPHs[SuccBB] = buildClonedLoopBlocks(
2651 BBCostMap[BB] = Cost;
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 437 PNUserCountMap[PN] = UserSet.size();
689 SpeculatedValueMap[OrigI].push_back(NewI);
690 assert(SpeculatedValueMap[OrigI][PredIdx] == NewI &&
lib/Transforms/Scalar/StructurizeCFG.cpp 342 ++LoopBlocks[Loop];
359 while (unsigned &BlockCount = LoopBlocks[CurrentLoop]) {
370 LoopBlocks[CurrentLoop]--;
389 Loops[Exit] = N->getEntry();
398 Loops[Succ] = BB;
452 BBPredicates &Pred = Predicates[BB];
453 BBPredicates &LPred = LoopPreds[BB];
477 Pred[Other] = BoolFalse;
478 Pred[P] = BoolTrue;
482 Pred[P] = buildCondition(Term, i, false);
485 LPred[P] = buildCondition(Term, i, true);
499 Pred[Entry] = BoolTrue;
501 LPred[Entry] = BoolFalse;
552 BBPredicates &Preds = Loops ? LoopPreds[SuccFalse] : Predicates[SuccTrue];
552 BBPredicates &Preds = Loops ? LoopPreds[SuccFalse] : Predicates[SuccTrue];
584 PhiMap &Map = DeletedPhis[To];
613 PhiMap &Map = DeletedPhis[To];
lib/Transforms/Scalar/TailRecursionElimination.cpp 283 auto &State = Visited[SuccBB];
300 if (Visited[NextBB] == UNESCAPED) {
lib/Transforms/Utils/AddDiscriminators.cpp 202 auto &BBMap = LBM[L];
210 unsigned Discriminator = R.second ? ++LDM[L] : LDM[L];
210 unsigned Discriminator = R.second ? ++LDM[L] : LDM[L];
247 unsigned Discriminator = ++LDM[L];
lib/Transforms/Utils/CloneFunction.cpp 762 LMap[OrigLoop] = NewLoop;
783 Loop *&NewLoop = LMap[CurLoop];
790 Loop *NewParentLoop = LMap[OrigParent];
799 Loop *&NewLoop = LMap[CurLoop];
lib/Transforms/Utils/CodeExtractor.cpp 1027 Value *&MemAsI8Ptr = Bitcasts[Mem];
lib/Transforms/Utils/Evaluator.cpp 397 MutatedMemory[Ptr] = Val;
lib/Transforms/Utils/InlineFunction.cpp 348 MemoMap[ExitedPad] = UnwindDestToken;
403 MemoMap[EHPad] = nullptr;
423 assert(!MemoMap.count(AncestorPad) || MemoMap[AncestorPad]);
433 MemoMap[LastUselessPad] = nullptr;
484 MemoMap[UselessPad] = UnwindDestToken;
567 (*FuncletUnwindMap)[MemoKey] == UnwindDestToken &&
850 MDMap[I].reset(DummyNodes.back().get());
861 NewOps.push_back(MDMap[M]);
867 MDTuple *TempM = cast<MDTuple>(MDMap[I]);
1101 NoAliases.push_back(NewScopes[A]);
1127 Scopes.push_back(NewScopes[A]);
lib/Transforms/Utils/LCSSA.cpp 97 L->getExitBlocks(LoopExitBlocks[L]);
99 const SmallVectorImpl<BasicBlock *> &ExitBlocks = LoopExitBlocks[L];
lib/Transforms/Utils/Local.cpp 2967 AllocaForValue[V] = nullptr;
2989 AllocaForValue[V] = Res;
lib/Transforms/Utils/LoopUnroll.cpp 138 Loop *&NewLoop = NewLoops[OldLoop];
616 LoopsToSimplify.insert(NewLoops[OldLoop]);
lib/Transforms/Utils/LoopUnrollAndJam.cpp 396 if (Value *PrevValue = PrevItValueMap[OldValue])
lib/Transforms/Utils/LoopUnrollPeel.cpp 140 IterationsToInvariance[Phi] = InfiniteIterationsToInvariance;
159 IterationsToInvariance[Phi] = ToInvariance;
620 ExitIDom[Edge.second] = BB;
lib/Transforms/Utils/LoopVersioning.cpp 200 GroupToNonAliasingScopes[Check.first].push_back(GroupToScope[Check.second]);
200 GroupToNonAliasingScopes[Check.first].push_back(GroupToScope[Check.second]);
206 GroupToNonAliasingScopeList[Pair.first] = MDNode::get(Context, Pair.second);
239 MDNode::get(Context, GroupToScope[Group->second])));
lib/Transforms/Utils/LowerSwitch.cpp 544 unsigned &Pop = Popularity[I.BB];
lib/Transforms/Utils/ModuleUtils.cpp 198 ComdatEntriesCovered[C] += 1;
lib/Transforms/Utils/PredicateInfo.cpp 471 ++SwitchEdges[TargetBlock];
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 285 unsigned &NP = BBNumPreds[BB];
596 AllocaLookup[Allocas[AllocaNum]] = AllocaNum;
845 PHINode *&PN = NewPhiNodes[std::make_pair(BBNumbers[BB], AllocaNo)];
857 PhiToAllocaMap[PN] = AllocaNo;
901 unsigned AllocaNo = PhiToAllocaMap[APN];
lib/Transforms/Utils/SSAUpdater.cpp 75 getAvailableVals(AV)[BB] = V;
325 if (Value *V = AvailableVals[BB])
369 TinyPtrVector<Instruction *> &BlockUses = UsesByBlock[BB];
lib/Transforms/Utils/SSAUpdaterBulk.cpp 56 Rewrites[Var].Defines[BB] = V;
82 R.Defines[BB] = V;
84 R.Defines[BB] = UndefValue::get(R.Ty);
86 return R.Defines[BB];
161 R.Defines[FrontierBB] = PN;
lib/Transforms/Utils/SimplifyCFG.cpp 1535 PHIOperands[I].push_back(I->getOperand(OI));
1783 for (auto *V : PHIOperands[I])
2025 ++SinkCandidateUseCounts[OpI];
4586 ForwardingNodes[Phi].push_back(PhiIdx);
5351 ResultLists[PHI].push_back(std::make_pair(CaseVal, Value));
5357 ResultTypes[PHI] = ResultLists[PHI][0].second->getType();
5357 ResultTypes[PHI] = ResultLists[PHI][0].second->getType();
5360 uint64_t NumResults = ResultLists[PHIs[0]].size();
5384 DefaultResults[PHI] = Result;
5448 const ResultListTy &ResultList = ResultLists[PHIs[0]];
5480 const ResultListTy &ResultList = ResultLists[PHI];
5483 Constant *DV = NeedMask ? ResultLists[PHI][0].second : DefaultResults[PHI];
5483 Constant *DV = NeedMask ? ResultLists[PHI][0].second : DefaultResults[PHI];
lib/Transforms/Utils/SimplifyIndVar.cpp 207 CheapExpansions[S] = ICmp->getOperand(IVOperIdx);
208 CheapExpansions[X] = ICmp->getOperand(1 - IVOperIdx);
217 CheapExpansions[IncomingS] = Incoming;
220 Value *NewLHS = CheapExpansions[InvariantLHS];
221 Value *NewRHS = CheapExpansions[InvariantRHS];
lib/Transforms/Utils/SplitModule.cpp 120 auto &Member = ComdatMembers[C];
207 ClusterIDMap[*MI] = CurrentClusterID;
276 return (ClusterIDMap[GV] == I);
lib/Transforms/Utils/ValueMapper.cpp 508 getVM().MD()[Key].reset(Val);
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 619 Reductions[Phi] = RedDes;
lib/Transforms/Vectorize/LoopVectorize.cpp 1147 return WideningDecisions[InstOnVF].second;
3011 Value *&EndValue = IVEndValues[OrigPhi];
3216 CSEMap[In] = In;
3447 IVEndValues[Entry.first], LoopMiddleBlock);
3647 RecurrenceDescriptor RdxDesc = (*Legal->getReductionVars())[Phi];
4432 Worklist.insert(Uniforms[VF].begin(), Uniforms[VF].end());
4432 Worklist.insert(Uniforms[VF].begin(), Uniforms[VF].end());
4542 Scalars[VF].insert(Worklist.begin(), Worklist.end());
4655 Uniforms[VF].clear();
4818 Uniforms[VF].insert(Worklist.begin(), Worklist.end());
5093 RecurrenceDescriptor RdxDesc = (*Legal->getReductionVars())[PN];
5354 EndPoint[Instr] = IdxToInstr.size();
5366 TransposeEnds[Interval.second].push_back(Interval.first);
5395 InstrList &List = TransposeEnds[i];
5521 ScalarCostsTy &ScalarCostsVF = InstsToScalarize[VF];
5643 ScalarCosts[I] = ScalarCost;
5890 return VectorizationCostTy(InstsToScalarize[VF][I], false);
5890 return VectorizationCostTy(InstsToScalarize[VF][I], false);
6086 ForcedScalars[VF].insert(I);
6658 return EdgeMaskCache[Edge] = SrcMask;
6669 return EdgeMaskCache[Edge] = EdgeMask;
6686 return BlockMaskCache[BB] = BlockMask; // Loop incoming mask is all-one.
6693 return BlockMaskCache[BB] = BlockMask;
6700 return BlockMaskCache[BB] = EdgeMask;
6710 return BlockMaskCache[BB] = BlockMask;
6957 PredInst2Recipe[PredInst]->setAlsoPack(false);
6969 PredInst2Recipe[I] = Recipe;
7159 SinkAfterInverse[SAIt->second] = Instr;
lib/Transforms/Vectorize/SLPVectorizer.cpp 1403 ScalarToTreeEntry[VL[i]] = Last;
1483 Optional<bool> &result = AliasCache[key];
1706 ScheduleData *SD = ScheduleDataMap[V];
1717 ScheduleData *SD = I->second[Key];
4620 ExtraScheduleDataMap[I][S.OpValue] = SD;
5410 ConsecutiveChain[Stores[K]] = Stores[Idx];
5441 I = ConsecutiveChain[I];
lib/Transforms/Vectorize/VPlan.cpp 126 BasicBlock *PredBB = CFG.VPBB2IRBB[PredVPBB];
380 Value2VPValue[TCMO] = BackedgeTakenCount;
385 State->VPValue2Value[Entry.second] = Entry.first;
418 BasicBlock *BB = State->CFG.VPBB2IRBB[VPBB];
426 BBTerminator->setSuccessor(Idx, State->CFG.VPBB2IRBB[SuccVPBB]);
744 Old2New[IG] = new InterleaveGroup<VPInstruction>(
748 Old2New[IG]->setInsertPos(VPInst);
750 InterleaveGroupMap[VPInst] = Old2New[IG];
750 InterleaveGroupMap[VPInst] = Old2New[IG];
751 InterleaveGroupMap[VPInst]->insertMember(
lib/Transforms/Vectorize/VPlan.h 266 return Data.PerPartOutput[Def][Part];
268 return Callback.getOrCreateVectorValues(VPValue2Value[Def], Part);
275 Data.PerPartOutput[Def] = Entry;
277 Data.PerPartOutput[Def][Part] = V;
1239 Value2VPValue[V] = new VPValue();
1245 return Value2VPValue[V];
1296 return BlockID.count(Block) ? BlockID[Block] : BlockID[Block] = BID++;
1296 return BlockID.count(Block) ? BlockID[Block] : BlockID[Block] = BID++;
lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp 118 BB2VPBB[BB] = VPBB;
185 IRDef2VPValue[IRVal] = NewVPVal;
296 VPValue *VPCondBit = IRDef2VPValue[BrCond];
312 VPBasicBlock *LoopExitVPBB = BB2VPBB[LoopExitBB];
lib/XRay/Profile.cpp 362 auto &TPD = ThreadPathData[E.TId][InternedPath];
tools/clang/include/clang/AST/ASTContext.h 975 MergedDecls[D] = Primary;
tools/clang/include/clang/AST/ASTImporter.h 177 ++Aux[D];
183 --Aux[Nodes.back()];
tools/clang/include/clang/AST/ASTImporterSharedState.h 76 ImportErrors[To] = Error;
tools/clang/include/clang/AST/RecordLayout.h 236 return CXXInfo->BaseOffsets[Base];
244 return CXXInfo->VBaseOffsets[VBase].VBaseOffset;
tools/clang/include/clang/AST/VTableBuilder.h 381 return *VTableLayouts[RD];
tools/clang/include/clang/Analysis/CFG.h 1348 SyntheticDeclStmts[Synthetic] = Source;
tools/clang/include/clang/Analysis/RetainSummaryManager.h 423 M[K] = Summ;
439 return M[K];
tools/clang/include/clang/Basic/Diagnostic.h 291 DiagMap[Diag] = Info;
tools/clang/include/clang/Basic/PlistSupport.h 33 FIDs[FID] = NewValue;
tools/clang/include/clang/Driver/Compilation.h 240 ResultFiles[JA] = Name;
247 FailureResultFiles[JA] = Name;
tools/clang/include/clang/Lex/HeaderSearch.h 332 DirectoryHasModuleMap[Dir] = true;
tools/clang/include/clang/Lex/ModuleMap.h 567 return ModuleScopeIDs[ExistingModule] < CurrentModuleScopeID;
604 AdditionalModMaps[M].insert(ModuleMap);
tools/clang/include/clang/Lex/Preprocessor.h 1039 MacroState &S = CurSubmoduleState->Macros[II];
1053 MacroState &S = CurSubmoduleState->Macros[II];
tools/clang/include/clang/Sema/ScopeInfo.h 665 CaptureMap[Var] = Captures.size();
698 return Captures[CaptureMap[Var] - 1];
tools/clang/include/clang/Sema/Sema.h 270 Map[Cache.File] = Cache.Nullability;
275 Cache.Nullability = Map[file];
3951 TypoCorrectionFailures[Typo].insert(TypoLoc);
tools/clang/include/clang/Sema/Template.h 343 newScope->LocalDecls[D];
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 163 CheckerRef &ref = CheckerTags[tag];
180 return static_cast<CHECKER *>(CheckerTags[tag]);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h 344 Cached[hash] = ConditionTruthVal();
346 Cached[hash] = ConditionTruthVal(res.getValue());
348 return Cached[hash];
tools/clang/lib/ARCMigrate/FileRemapper.cpp 215 Target &targ = FromToMappings[file];
222 Target &targ = FromToMappings[file];
225 ToFromMappings[newfile] = file;
tools/clang/lib/ARCMigrate/ObjCMT.cpp 2267 FileEditEntries[Entry.File].push_back(Entry);
tools/clang/lib/ARCMigrate/TransGCAttrs.cpp 311 AtProps[RawAt].push_back(PD);
tools/clang/lib/ARCMigrate/TransZeroOutPropsInDealloc.cpp 127 SynthesizedProperties[PD] = PID;
tools/clang/lib/AST/ASTContext.cpp 428 CommentlessRedeclChains[CanonicalD] = Redecl;
631 ParsedComments[Canonical] = FC;
1094 auto *&Inits = ModuleInitializers[M];
1101 auto *&Inits = ModuleInitializers[M];
1395 AttrVec *&Result = DeclAttrs[D];
1468 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
1469 InstantiatedFromUsingDecl[Inst] = Pattern;
1485 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
1486 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1502 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1505 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1536 OverriddenMethods[Method].push_back(Overridden);
1788 MemoizedTypeInfo[T] = TI;
2230 MemoizedUnadjustedAlign[T] = UnadjustedAlign;
2640 ObjCMethodRedecls[MD] = Redecl;
2674 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
9217 ObjCLayouts[CD] = nullptr;
10263 std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
10273 ExtraMangleNumberingContexts[D];
10333 APValue *&MTVI = MaterializedTemporaryValues[E];
10441 auto &NodeOrVector = (*Parents)[MapNode];
tools/clang/lib/AST/ASTImporter.cpp 7886 ImportedTypes[FromTy] = (*ToTOrErr).getTypePtr();
7960 SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
8010 for (const auto &Path : SavedImportPaths[FromD])
8021 SavedImportPaths[FromD].clear();
8054 SavedImportPaths[FromD].clear();
8154 ImportedStmts[FromS] = *ToSOrErr;
8488 ImportedFileIDs[FromID] = ToID;
8578 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
8767 ImportedDecls[From] = To;
8770 ImportedFromDecls[To] = From;
tools/clang/lib/AST/ASTImporterLookupTable.cpp 72 DeclList &Decls = LookupTable[DC][ND->getDeclName()];
78 DeclList &Decls = LookupTable[DC][ND->getDeclName()];
tools/clang/lib/AST/CXXInheritance.cpp 217 IsVirtBaseAndNumberNonVirtBases &Subobjects = ClassSubobjects[BaseType];
630 CXXFinalOverriderMap *&MyVirtualOverriders = VirtualOverriders[BaseDecl];
tools/clang/lib/AST/DeclBase.cpp 1332 (*Map)[Name].removeExternalDecls();
1348 StoredDeclsList &List = (*Map)[Name];
tools/clang/lib/AST/ExprConstant.cpp 824 EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases;
842 EI.ObjectsUnderConstruction[Object] =
tools/clang/lib/AST/ExternalASTMerger.cpp 199 ToOrigin[To] = From;
tools/clang/lib/AST/Interp/ByteCodeEmitter.cpp 115 LabelRelocs[Label].push_back(Position);
tools/clang/lib/AST/Interp/Program.cpp 135 DummyParams[PD] = *Idx;
tools/clang/lib/AST/Interp/Record.cpp 23 BaseMap[B.Decl] = &B;
25 FieldMap[F.Decl] = &F;
27 VirtualBaseMap[V.Decl] = &V;
tools/clang/lib/AST/ItaniumCXXABI.cpp 167 return ++DecompsitionDeclManglingNumbers[Name];
176 return ++VarManglingNumbers[Identifier];
tools/clang/lib/AST/ItaniumMangle.cpp 196 unsigned &discriminator = Uniquifier[ND];
4869 Substitutions[Ptr] = SeqID++;
tools/clang/lib/AST/MicrosoftCXXABI.cpp 46 return ++ManglingNumbers[Ty];
94 return RecordToCopyCtor[RD];
101 assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
101 assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
102 RecordToCopyCtor[RD] = CD;
109 TypedefNameDecl *&I = UnnamedTagDeclToTypedefNameDecl[TD];
123 DeclaratorDecl *&I = UnnamedTagDeclToDeclaratorDecl[TD];
tools/clang/lib/AST/MicrosoftMangle.cpp 226 unsigned &discriminator = Uniquifier[ND];
1809 FunArgBackReferences[TypePtr] = Size;
3293 Mangler.getStream() << "?filt$" << SEHFilterIds[EnclosingDecl]++ << "@0@";
3305 Mangler.getStream() << "?fin$" << SEHFinallyIds[EnclosingDecl]++ << "@0@";
tools/clang/lib/AST/ParentMap.cpp 42 M[SubStmt] = nullptr;
89 M[SubStmt] = S;
94 M[SubStmt] = S;
101 M[SubStmt] = S;
tools/clang/lib/AST/RawCommentList.cpp 290 if (OrderedComments[CommentFile].empty()) {
291 OrderedComments[CommentFile][CommentOffset] =
296 const RawComment &C1 = *OrderedComments[CommentFile].rbegin()->second;
319 *OrderedComments[CommentFile].rbegin()->second =
322 OrderedComments[CommentFile][CommentOffset] =
344 CommentBeginLine[C] = Line;
354 CommentEndOffset[C] = Offset;
tools/clang/lib/AST/RecordLayoutBuilder.cpp 82 return FieldOffsets[FD];
257 ClassVectorTy &Classes = EmptyClassOffsets[Offset];
891 BaseSubobjectInfo *&InfoSlot = VirtualBaseInfo[RD];
2613 VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize();
2624 VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize();
2631 VBPtrOffset = Bases[SharedVBPtrBase] + Layout.getVBPtrOffset();
3040 const ASTRecordLayout *Entry = ASTRecordLayouts[D];
3102 ASTRecordLayouts[D] = NewEntry;
3124 LazyDeclPtr Entry = KeyFunctions[RD];
3130 KeyFunctions[RD] = const_cast<Decl*>(Result);
3230 if (const ASTRecordLayout *Entry = ObjCLayouts[Key])
3256 ObjCLayouts[Key] = NewEntry;
tools/clang/lib/AST/VTTBuilder.cpp 48 SecondaryVirtualPointerIndices[Base] = VTTComponents.size();
192 SubVTTIndicies[Base] = VTTComponents.size();
tools/clang/lib/AST/VTableBuilder.cpp 333 SubobjectNumber = ++SubobjectCounts[RD];
1062 SmallVectorImpl<ThunkInfo> &ThunksVector = Thunks[MD];
1136 VTableThunks[VTableIndex].This = ThisAdjustment;
1269 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Offset.VirtualBase];
1503 MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD];
2107 ThunkInfoVectorTy ThunksVector = Thunks[MD];
2169 uint64_t VTableIndex = MethodVTableIndices[GD];
2278 std::unique_ptr<const VTableLayout> &Entry = VTableLayouts[RD];
2451 SmallVector<ThunkInfo, 1> &ThunksVector = Thunks[MD];
3190 ThunkInfoVectorTy ThunksVector = Thunks[MD];
3568 VFPtrLocations[RD] = std::move(VFPtrs);
3572 for (const std::unique_ptr<VPtrInfo> &VFPtr : *VFPtrLocations[RD]) {
3579 VFTableLayouts[id] = std::make_unique<VTableLayout>(
3668 std::unique_ptr<VirtualBaseInfo> &Entry = VBaseInfo[RD];
3694 VBI->VBTableIndices[CurVBase] = VBTableIndex++;
3717 return *VFPtrLocations[RD];
3727 return *VFTableLayouts[id];
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 373 TypeAliases[CanonicalType].insert(DeclNode);
379 CompatibleAliases[InterfaceDecl].insert(CAD);
588 auto &Filter = MatcherFiltersMap[Kind];
tools/clang/lib/Analysis/AnalysisDeclContext.cpp 186 (void) (*forcedBlkExprs)[stmt];
303 std::unique_ptr<AnalysisDeclContext> &AC = Contexts[D];
658 LazyInitializeReferencedDecls(BD, (*ReferencedBlockVars)[BD], A);
666 return (*M)[tag];
tools/clang/lib/Analysis/CFG.cpp 1192 CachedBoolEvals[S] = Result; // update or insert
1353 ConstructionContextMap[E] = Layer;
5084 StmtMap[stmt] = P;
tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp 37 return reachable[DstBlockID][Src->getBlockID()];
tools/clang/lib/Analysis/Consumed.cpp 1147 VarMap[DM.first] = CS_Unknown;
1165 VarMap[DM.first] = CS_Unknown;
1179 VarMap[Var] = State;
1184 TmpMap[Tmp] = State;
tools/clang/lib/Analysis/ExprMutationAnalyzer.cpp 129 return MemoizedResults[Exp] = nullptr;
133 return MemoizedResults[Exp] = S;
136 return MemoizedResults[Exp] = nullptr;
420 FuncParmAnalyzer[Func];
446 Results[Parm] = S;
459 return Results[Parm] = S;
461 return Results[Parm] = nullptr;
tools/clang/lib/Analysis/LiveVariables.cpp 184 return isAlwaysAlive(D) || getImpl(impl).blocksEndToLiveness[B].isLive(D);
188 return isAlwaysAlive(D) || getImpl(impl).stmtsToLiveness[S].isLive(D);
192 return getImpl(impl).stmtsToLiveness[Loc].isLive(S);
523 stmtsToLiveness[S] = val;
579 LV->inAssignment[DR] = 1;
590 LivenessValues &prevVal = LV->blocksEndToLiveness[block];
597 val = LV->merge(val, LV->blocksBeginToLiveness[succ]);
609 LV->blocksBeginToLiveness[block] = LV->runOnBlock(block, val);
640 LiveVariables::LivenessValues vals = blocksEndToLiveness[*it];
tools/clang/lib/Analysis/PostOrderCFGView.cpp 27 BlockOrder[*I] = Blocks.size() + 1;
tools/clang/lib/Analysis/RetainSummaryManager.cpp 549 FuncSummaries[FD] = S;
tools/clang/lib/Analysis/ThreadSafety.cpp 1077 std::unique_ptr<BeforeInfo> &InfoPtr = BMap[Vd];
tools/clang/lib/Analysis/UninitializedValues.cpp 84 map[vd] = count++;
428 Classification[DRE] = std::max(Classification[DRE], C);
428 Classification[DRE] = std::max(Classification[DRE], C);
436 Classification[DRE] = SelfInit;
tools/clang/lib/Basic/SourceManager.cpp 413 SrcMgr::ContentCache *&Slot = FileInfos[FileInfo.first];
428 ContentCache *&Entry = FileInfos[FileEnt];
679 getOverriddenFilesInfo().OverriddenFiles[SourceFile] = NewFile;
1851 std::unique_ptr<MacroArgsMap> &MacroArgsCache = MacroArgsCacheMap[FID];
1927 return IBTUCache[Key];
tools/clang/lib/CodeGen/CGAtomic.cpp 693 BB[S] = CGF.createBasicBlock(getAsString(ScopeModel->map(S)), CGF.CurFn);
702 llvm::SwitchInst *SI = Builder.CreateSwitch(SC, BB[FallBack]);
704 auto *B = BB[S];
tools/clang/lib/CodeGen/CGBlocks.cpp 593 info.Captures[variable] = CGBlockInfo::Capture::makeConstant(constant);
tools/clang/lib/CodeGen/CGBuiltin.cpp 1462 : Types[CanonicalType];
tools/clang/lib/CodeGen/CGClass.cpp 2215 auto *POSParam = SizeArguments[Param];
tools/clang/lib/CodeGen/CGDebugInfo.cpp 2440 ModuleCache[M].reset(DIMod);
3563 RegionMap[D].reset(SP);
3629 SPDefCache[FD].reset(SP);
3646 ObjCMethodCache[ID].push_back(FD);
3655 RegionMap[D].reset(SP);
4038 ParamCache[PD].reset(D);
4631 NamespaceCache[NSDecl].reset(NS);
tools/clang/lib/CodeGen/CGDebugInfo.h 353 SizeExprCache[Ty] = SizeExpr;
tools/clang/lib/CodeGen/CGObjCGNU.cpp 2318 SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
3673 for (TypedSelector &sel : table[untypedSel]) {
tools/clang/lib/CodeGen/CGObjCMac.cpp 5088 llvm::GlobalVariable *&Entry = ClassReferences[II];
5127 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
5492 llvm::GlobalVariable *&Entry = MethodVarNames[Sel];
5527 llvm::GlobalVariable *&Entry = PropertyNames[Ident];
7321 llvm::GlobalVariable *&Entry = ClassReferences[II];
7487 llvm::GlobalVariable *&Entry = SelectorReferences[Sel];
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1595 OpenMPDefaultLocMap[FlagsKey] = Entry = DefaultOpenMPLocation;
1749 for(auto *D : FunctionUDRMap[CGF.CurFn])
3892 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] =
3892 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] =
3892 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] =
3914 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum];
3914 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum];
3914 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum];
3921 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] = Entry;
3921 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] = Entry;
3921 OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] = Entry;
4681 PrivateVarsPos[VD] = Counter;
4692 PrivateVarsPos[VD] = Counter;
4703 PrivateVarsPos[VD] = Counter;
4734 const VarDecl *VD = Args[PrivateVarsPos[Privates[Counter].second.Original]];
7869 DevPointersMap[L.first].push_back(L.second);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1989 WrapperFunctionsMap[OutlinedFun] = WrapperFun;
2532 llvm::Function *WFn = WrapperFunctionsMap[Fn];
tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp 687 NonVirtualBases[Member->RD] = FieldTypes.size() - 1;
689 VirtualBases[Member->RD] = FieldTypes.size() - 1;
tools/clang/lib/CodeGen/CGStmt.cpp 521 JumpDest &Dest = LabelMap[D];
538 JumpDest &Dest = LabelMap[D];
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 588 VLASizeMap[VLASizePair.second.first] = VLASizePair.second.second;
1057 LoopCountersAndUpdates[D] = F;
tools/clang/lib/CodeGen/CodeGenFunction.cpp 1932 llvm::Value *&entry = VLASizeMap[size];
tools/clang/lib/CodeGen/CodeGenModule.cpp 4917 Entry = &ConstantStringMap[C];
4980 Entry = &ConstantStringMap[C];
tools/clang/lib/CodeGen/CodeGenModule.h 637 return AtomicSetterHelperFnMap[Ty];
641 AtomicSetterHelperFnMap[Ty] = Fn;
645 return AtomicGetterHelperFnMap[Ty];
649 AtomicGetterHelperFnMap[Ty] = Fn;
653 return TypeDescriptorMap[Ty];
656 TypeDescriptorMap[Ty] = C;
tools/clang/lib/CodeGen/CodeGenPGO.cpp 371 CountMap[S] = CurrentCount;
899 unsigned Counter = (*RegionCounterMap)[S];
tools/clang/lib/CodeGen/CodeGenPGO.h 112 return RegionCounts[(*RegionCounterMap)[S]];
tools/clang/lib/CodeGen/CodeGenTBAA.cpp 207 if (llvm::MDNode *N = MetadataCache[Ty])
214 return MetadataCache[Ty] = TypeNode;
285 if (llvm::MDNode *N = StructMetadataCache[Ty])
293 return StructMetadataCache[Ty] = nullptr;
308 return BaseTypeMetadataCache[Ty] = nullptr;
348 if (llvm::MDNode *N = BaseTypeMetadataCache[Ty])
355 return BaseTypeMetadataCache[Ty] = TypeNode;
370 llvm::MDNode *&N = AccessTagMetadataCache[Info];
tools/clang/lib/CodeGen/CodeGenTypes.cpp 699 TypeCache[Ty] = ResultType;
717 llvm::StructType *&Entry = RecordDeclTypes[Key];
753 CGRecordLayouts[Key] = Layout;
tools/clang/lib/CodeGen/CoverageMappingGen.cpp 474 return Counter::getCounter(CounterMap[S]);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 1744 llvm::GlobalVariable *&VTable = VTables[RD];
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 699 CatchableTypeArrayTypeMap[NumEntries];
1709 return VFTablesMap[ID];
1760 VFTablesMap[ID] = nullptr;
1786 VFTablesMap[ID] = VFTable;
1852 VFTablesMap[ID] = VFTable;
4089 llvm::GlobalVariable *&CTA = CatchableTypeArrays[T];
tools/clang/lib/CodeGen/VarBypassDetector.cpp 124 ToScopes[SubStmt] = ParentScope;
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp 563 ImportedFileIDs[ToID] = std::make_pair(FromID, Unit);
tools/clang/lib/Frontend/ASTUnit.cpp 413 unsigned &TypeValue = CompletionTypes[CanUsageType];
2435 LocDeclsTy *&Decls = FileDecls[FID];
tools/clang/lib/Frontend/DependencyGraph.cpp 88 Dependencies[FromFile].push_back(File);
tools/clang/lib/Frontend/DiagnosticRenderer.cpp 378 BeginLocsMap[BeginFileID] = Begin;
392 Begin = BeginLocsMap[EndFileID];
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 257 Stmt *ReplacingStmt = ReplacedNodes[Old];
279 ReplacedNodes[Old] = New;
1262 MethodInternalNames[OMD] = NameStr;
3767 IvarGroupNumber[IVars[i++]] = ++GroupNo;
3769 IvarGroupNumber[IVars[i++]] = GroupNo;
3804 return GroupRecordType[tuple];
3827 QualType RetQT = GroupRecordType[tuple];
3955 llvm::SmallSetVector<ObjCIvarDecl *, 8> Ivars = ReferencedIvars[CDecl];
4028 "_" + utostr(BlockByRefDeclNo[VD]) ;
4125 std::string RewrittenStr = RewrittenBlockExprs[CE];
5484 RewrittenBlockExprs[BE] = Str;
5595 BlockByRefDeclNo[ND] = uniqueByrefDeclCount++;
6341 Result += RewriteObj.MethodInternalNames[MD];
7469 ReferencedIvars[clsDeclared].insert(D);
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 208 Stmt *ReplacingStmt = ReplacedNodes[Old];
230 ReplacedNodes[Old] = New;
1094 MethodInternalNames[OMD] = NameStr;
3242 "_" + utostr(BlockByRefDeclNo[VD]) ;
3335 std::string RewrittenStr = RewrittenBlockExprs[CE];
4606 RewrittenBlockExprs[BE] = Str;
4697 BlockByRefDeclNo[ND] = uniqueByrefDeclCount++;
5774 Result += MethodInternalNames[*MethodBegin];
5784 Result += MethodInternalNames[*MethodBegin];
tools/clang/lib/Frontend/SerializedDiagnosticPrinter.cpp 41 Abbrevs[recordID] = abbrevID;
47 return Abbrevs[recordID];
375 unsigned &entry = State->Files[FileName];
553 std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
810 RECORD_SOURCE_RANGE, FileLookup[Start.FileID], Start.Line, Start.Col,
811 Start.Offset, FileLookup[End.FileID], End.Line, End.Col, End.Offset};
821 RECORD_DIAG, Severity, FileLookup[Location.FileID], Location.Line,
822 Location.Col, Location.Offset, CategoryLookup[Category],
823 Flag ? DiagFlagLookup[Flag] : 0, Message.size()};
834 RecordData::value_type Record[] = {RECORD_FIXIT, FileLookup[Start.FileID],
836 FileLookup[End.FileID], End.Line, End.Col,
847 FileLookup[ID] = Writer.getEmitFile(Name.str().c_str());
852 CategoryLookup[ID] = Writer.getEmitCategory(ID);
857 DiagFlagLookup[ID] = Writer.getEmitDiagnosticFlag(Name);
tools/clang/lib/Lex/HeaderSearch.cpp 1372 DirectoryHasModuleMap[FixUpDirectories[I]] = true;
1536 LoadedModuleMaps[File] = false;
1543 LoadedModuleMaps[File] = false;
1621 DirectoryHasModuleMap[Dir] = true;
1623 DirectoryHasModuleMap[Dir] = false;
tools/clang/lib/Lex/ModuleMap.cpp 258 if (Module *UmbrellaMod = UmbrellaDirs[UmbrellaDir])
624 UmbrellaDirs[SkippedDirs[I-1]] = Result;
650 UmbrellaDirs[SkippedDirs[I]] = Result;
654 Headers[File].push_back(Header);
810 ModuleScopeIDs[Result] = CurrentModuleScopeID;
856 Headers[MainFile].push_back(KnownHeader(Result, PrivateHeader));
1012 ModuleScopeIDs[Result] = CurrentModuleScopeID;
1098 ModuleScopeIDs[Result] = CurrentModuleScopeID;
1106 Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
1120 UmbrellaDirs[UmbrellaDir] = Mod;
1147 LazyHeadersByModTime[*Header.ModTime].push_back(Mod);
1149 LazyHeadersBySize[*Header.Size].push_back(Mod);
1191 auto &HeaderList = Headers[Header.Entry];
1218 (void) Headers[Header.Entry];
2439 if (Module *OwningModule = Map.UmbrellaDirs[Dir]) {
2759 Map.InferredDirectories[Directory].InferModules = true;
2760 Map.InferredDirectories[Directory].Attrs = Attrs;
2761 Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile;
2797 Map.InferredDirectories[Directory].ExcludedModules
2984 return ParsedModuleMap[File] = true;
2997 ParsedModuleMap[File] = Result;
tools/clang/lib/Lex/PPMacroExpansion.cpp 198 NumHiddenOverrides[O] = -1;
216 if ((unsigned)++NumHiddenOverrides[O] == O->getNumOverridingMacros())
tools/clang/lib/Lex/Pragma.cpp 615 PragmaPushMacroInfo[IdentInfo].push_back(MI);
tools/clang/lib/Lex/PreprocessingRecord.cpp 451 MacroDefinitions[MI] = Def;
tools/clang/lib/Lex/Preprocessor.cpp 731 PoisonReasons[II] = DiagID;
tools/clang/lib/Parse/ParseDeclCXX.cpp 4120 << AttrName << SourceRange(SeenAttrs[AttrName]);
tools/clang/lib/Sema/CodeCompleteConsumer.cpp 363 StringRef &CachedParentName = ParentNames[DC];
tools/clang/lib/Sema/JumpDiagnostics.cpp 316 LabelAndGotoScopes[S] = ParentScope;
321 LabelAndGotoScopes[S] = ParentScope;
341 LabelAndGotoScopes[S] = ParentScope;
350 LabelAndGotoScopes[S] = ParentScope;
564 LabelAndGotoScopes[S] = ParentScope;
591 LabelAndGotoScopes[SubStmt] = ParentScope;
692 unsigned IGScope = LabelAndGotoScopes[IG];
693 Stmt *&Entry = JumpScopesMap[IGScope];
714 LabelDecl *&Target = TargetScopes[LabelScope];
877 unsigned FromScope = LabelAndGotoScopes[From];
878 unsigned ToScope = LabelAndGotoScopes[To];
tools/clang/lib/Sema/Sema.cpp 809 MNCComplete[RD] = Complete;
847 RecordsComplete[RD] = Complete;
2193 OpenCLTypeExtMap[CanT].insert(I.str());
tools/clang/lib/Sema/SemaChecking.cpp12607 UsageInfo &U = Self.UsageMap[M.first];
12708 UsageInfo &U = UsageMap[O];
12714 UsageInfo &U = UsageMap[O];
12720 UsageInfo &U = UsageMap[O];
12727 UsageInfo &U = UsageMap[O];
14513 (*TypeTagForDatatypeMagicValues)[Magic] =
tools/clang/lib/Sema/SemaDecl.cpp13733 return EscapeInfo[BD];
13745 return EscapeInfo[BD] = R;
tools/clang/lib/Sema/SemaDeclCXX.cpp 352 UnparsedDefaultArgLocs[Param] = ArgLoc;
406 SR = UnparsedDefaultArgLocs[Param];
5274 UnionEntry &En = Unions[Parent];
5335 if (CheckRedundantInit(*this, Init, Members[Key]) ||
5340 if (CheckRedundantInit(*this, Init, Members[Key]))
15581 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
15720 if (VTablesUsed[Canonical])
tools/clang/lib/Sema/SemaExpr.cpp 4810 Diag(UnparsedDefaultArgLocs[Param],
tools/clang/lib/Sema/SemaExprCXX.cpp 829 ++SubobjectsSeen[BaseDecl];
847 SubobjectsSeen[RD] = 1;
854 if (SubobjectsSeen[PublicSubobject] > 1)
7637 ExprResult Replacement = IsAmbiguous ? ExprError() : TransformCache[TE];
7676 E = OverloadResolution[OE];
7859 OverloadResolution[OE] = CE->getCallee();
7885 auto &CacheEntry = TransformCache[E];
tools/clang/lib/Sema/SemaLambda.cpp 1700 SourceRange CaptureRange = LSI->ExplicitCaptureRanges[I];
tools/clang/lib/Sema/SemaOpenMP.cpp 787 MappedExprComponentTy &MEC = getTopOfStack().MappedExprComponents[VD];
1019 StackElem.AlignedMap[D] = NewDE;
1071 DSAInfo &Data = Threadprivates[D];
1076 DSAInfo &Data = getTopOfStack().SharingMap[D];
1136 getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&
1138 ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
1159 getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&
1161 ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
4672 VarsWithInheritedDSA[P.getFirst()] = P.getSecond();
15610 UsedAsPrevious[PrevDecl] = false;
15612 UsedAsPrevious[D] = true;
15862 UsedAsPrevious[PrevDecl] = false;
15864 UsedAsPrevious[D] = true;
tools/clang/lib/Sema/SemaTemplate.cpp 8477 ConvertedTemplateArgs[Specialization] = std::move(Args);
8596 ExplicitTemplateArgs ? &ConvertedTemplateArgs[Specialization] : nullptr);
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp 1868 UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
3045 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
3067 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
3081 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
tools/clang/lib/Sema/SemaType.cpp 312 LocsForMacros[MQT] = Loc;
tools/clang/lib/Sema/TreeTransform.h 461 TransformedLocalDecls[Old] = New.front();
tools/clang/lib/Serialization/ASTReader.cpp 1229 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1536 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
2088 IdentifierGeneration[II] = getGeneration();
3160 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3535 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3608 OpenCLTypeExtMap[Type].insert(Ext);
3857 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
4306 SelectorOutOfDate[Sel.first] = true;
8595 unsigned &Generation = SelectorGeneration[Sel];
8598 SelectorOutOfDate[Sel] = false;
8631 if (SelectorOutOfDate[Sel])
9725 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9727 (*CurrSwitchCaseStmts)[ID] = SC;
9732 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9733 return (*CurrSwitchCaseStmts)[ID];
9806 Context.Comments.OrderedComments[Loc.first].emplace(Loc.second, C);
9870 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
10037 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
10043 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
tools/clang/lib/Serialization/ASTReaderDecl.cpp 622 Reader.HiddenNamesMap[Owner].push_back(D);
773 Reader.PendingEnumOdrMergeFailures[OldDef].push_back(ED);
1791 Reader.PendingOdrMergeFailures[DD.Definition].push_back(
3256 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3280 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
tools/clang/lib/Serialization/ASTReaderStmt.cpp 2491 S = StmtEntries[Record.readInt()];
tools/clang/lib/Serialization/ASTWriter.cpp 1852 uint32_t &InputFileID = InputFileIDs[Entry.File];
2332 assert(InputFileIDs[Content->OrigEntry] != 0 && "Missed file entry");
2333 Record.push_back(InputFileIDs[Content->OrigEntry]);
2458 Record.push_back(FilenameMap[LE.FilenameID]);
2594 if (++Visits[M] == M->getNumOverridingMacros())
2603 IdentMacroDirectivesOffsetMap[Name] = StartOffset;
2830 return SubmoduleIDs[Mod] = NextSubmoduleID++;
2962 assert(SubmoduleIDs[Mod->Parent] && "Submodule parent not written?");
2963 ParentID = SubmoduleIDs[Mod->Parent];
3128 unsigned &DiagStateID = DiagStateIDMap[State];
3194 TypeIdx &IdxRef = TypeIdxs[T];
4826 VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
5528 MacroID &ID = MacroIDs[MI];
5542 return MacroIDs[MI];
5644 TypeIdx &Idx = TypeIdxs[T];
5690 DeclID &ID = DeclIDs[D];
5716 return DeclIDs[D];
5747 DeclIDInFileInfo *&Info = FileDeclIDs[FID];
6292 MacroID &StoredID = MacroIDs[MI];
6303 TypeIdx &StoredIdx = TypeIdxs[T];
6323 SubmoduleIDs[Mod] = ID;
tools/clang/lib/Serialization/ASTWriterDecl.cpp 1710 const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
tools/clang/lib/Serialization/ASTWriterStmt.cpp 2378 SwitchCaseIDs[S] = NextID;
2385 return SwitchCaseIDs[S];
2433 SubStmtEntries[S] = Offset;
tools/clang/lib/Serialization/GlobalModuleIndex.cpp 353 ModulesByFile[File] = Known->second;
tools/clang/lib/Serialization/ModuleManager.cpp 75 return std::move(InMemoryBuffers[*Entry]);
209 Module = Modules[Entry] = NewModule.get();
278 InMemoryBuffers[Entry] = std::move(Buffer);
tools/clang/lib/Serialization/MultiOnDiskHashTable.h 162 data_type_builder ValueBuilder(Merged->Data[Key]);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 253 StringSelectors[KnownSel] = 0;
tools/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp 134 IvarToPropMap[ID] = PD;
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 174 ++ReachedStats[CE].NumTimesReached;
175 if (!ReachedStats[CE].ExampleNode) {
177 ReachedStats[CE].ExampleNode = C.generateNonFatalErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp 291 TrackedIvars[I] = Info;
398 PropertyToIvarMap[PD] = ID;
399 IvarToPopertyMap[ID] = PD;
405 PropSetterToIvarMap[SetterD] = ID;
411 PropGetterToIvarMap[GetterD] = ID;
tools/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp 126 M[Ivar] = Unused;
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 173 LCM[Path] = LC;
2728 (*Notes)[ErrorNode].push_back(LastPiece);
2737 (*Notes)[NextNode].push_back(std::move(P));
2814 (*Out)[PC] = std::move(PD);
2945 Visited[errorNode] = 1;
2968 unsigned &mark = Visited[Succ];
3125 (*Out)[Consumer] = generateDiagnosticForBasicReport(basicReport);
tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp 87 checkers = &CachedDeclCheckersMap[DeclKind];
899 CachedStmtCheckers &Checkers = CachedStmtCheckersMap[Key];
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 500 Pass2[N] = NewN;
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 2448 if (const FieldDecl *FD = LambdaCaptureFields[VD]) {
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp 743 StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC];
756 StackArgumentsSpaceRegion *&R = StackArgumentsSpaceRegions[STC];
779 StaticGlobalSpaceRegion *&R = StaticsGlobalSpaceRegions[CR];
1587 SymTraitsMap[Sym] |= IK;
1596 MRTraitsMap[MR] |= IK;
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp 497 std::pair<void*, void (*)(void*)>& p = GDMContexts[K];
tools/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp 1249 Cached[Sym] = V;
tools/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp 369 SymbolDependencies[Primary] = dependencies;
402 TheLiving[sym] = NotProcessed;
tools/clang/lib/StaticAnalyzer/Core/WorkList.cpp 237 NumVisited = NumReached[LocId]++;
tools/clang/lib/Tooling/InterpolatingCompilationDatabase.cpp 396 Candidates[Entry.second] += Points;
tools/clang/lib/Tooling/Syntax/Tokens.cpp 400 TokenBuffer::MarkedFile &File = Result.Files[FID];
405 assert(File.SpelledTokens[NextSpelled[FID]].location() == L &&
407 ++NextSpelled[FID];
419 TokenBuffer::MarkedFile &File = Result.Files[FID];
433 EndExpanded, NextSpelled[FID]);
494 unsigned &SpelledIndex = NextSpelled[FID];
tools/clang/tools/extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp 156 auto &Replaces = DiagReplacements[*Entry];
160 GroupedReplacements[*Entry].push_back(R);
tools/clang/tools/extra/clang-tidy/bugprone/VirtualNearMissCheck.cpp 192 PossibleMap[BaseMD] = IsPossible;
213 OverriddenMap[Key] = IsOverridden;
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.cpp 110 ClassWithSpecialMembers[ID];
tools/clang/tools/extra/clang-tidy/misc/UnusedAliasDeclsCheck.cpp 35 FoundDecls[AliasDecl] = CharSourceRange::getCharRange(
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp 690 auto &Failure = Failures[Decl];
908 NamingCheckFailure &Failure = NamingCheckFailures[ID];
tools/clang/tools/extra/clang-tidy/utils/IncludeInserter.cpp 53 if (!InsertedHeaders[FileID].insert(Header).second)
66 return IncludeSorterByFile[FileID]->CreateIncludeInsertion(Header, IsAngled);
79 IncludeSorterByFile[FileID]->AddInclude(FileName, IsAngled, HashLocation,
tools/clang/tools/extra/clang-tidy/utils/NamespaceAliaser.cpp 37 if (AddedAliases[Function].count(Namespace.str()) != 0)
53 AddedAliases[Function][Namespace.str()] = ExistingAlias->getName().str();
74 AddedAliases[Function][Namespace.str()] = Abbreviation;
tools/clang/tools/extra/clangd/CodeComplete.cpp 862 FetchedDocs[S.ID] = S.Documentation;
tools/clang/tools/extra/clangd/FileDistance.cpp 75 auto &Down = DownEdges[NextHash];
tools/clang/tools/extra/clangd/FindTarget.cpp 128 Decls[D] |= Flags;
tools/clang/tools/extra/clangd/Headers.cpp 125 IncludeChildren[Parent].push_back(Child);
tools/clang/tools/extra/clangd/XRefs.cpp 306 ResultIndex[*ID] = Result.size() - 1;
tools/clang/tools/extra/clangd/index/Background.cpp 252 SymbolIDToFile[Sym.ID] = &FileIt->second;
294 Refs.insert(RefToIDs[R], *R);
tools/clang/tools/extra/clangd/index/FileIndex.cpp 185 MergedRefs[Sym.first].append(Sym.second.begin(), Sym.second.end());
tools/clang/tools/extra/clangd/index/MemIndex.h 26 Index[S.ID] = &S;
tools/clang/tools/extra/clangd/index/Ref.cpp 36 auto &M = Refs[ID];
tools/clang/tools/extra/clangd/index/Symbol.cpp 51 own(Symbols[S.ID] = S, UniqueStrings);
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp 315 DeclRefs[ND].emplace_back(SpellingLoc, Roles);
453 IncludeFiles[S.ID] =
tools/clang/tools/extra/clangd/index/dex/Dex.cpp 73 LookupTable[Sym->ID] = Sym;
94 TempInvertedIndex[Token].push_back(SymbolRank);
tools/clang/tools/extra/clangd/unittests/DexTests.cpp 673 auto &SymbolRefs = Refs[Sym.ID];
tools/clang/tools/extra/clangd/unittests/SemanticHighlightingTests.cpp 132 ExpectedLines[Point.line]; // Default initialize to an empty line. Tokens
tools/clang/tools/extra/modularize/Modularize.cpp 492 CurHeaderContents[Loc.File].push_back(HE);
531 std::back_inserter(HeaderContentMismatches[H->first]));
tools/clang/tools/libclang/CXCursor.cpp 1421 unsigned &entry = (*setImpl)[cursor];
tools/clang/tools/libclang/CXIndexDataConsumer.cpp 456 FileMap[File] = idxFile;
475 FileMap[File] = idxFile;
950 ContainerMap[DC] = container;
973 EntityMap[D] = client;
tools/clang/tools/libclang/CXLoadedDiagnostic.cpp 278 LoadedLoc.file = const_cast<FileEntry *>(TopDiags->Files[FileID]);
326 TopDiags->Categories[ID] = TopDiags->copyString(Name);
334 TopDiags->WarningFlags[ID] = TopDiags->copyString(Name);
344 TopDiags->FileNames[ID] = TopDiags->copyString(Name);
345 TopDiags->Files[ID] =
383 D.DiagOption = Flag ? TopDiags->WarningFlags[Flag] : "";
384 D.CategoryText = Category ? TopDiags->Categories[Category] : "";
tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp 344 GMap::mapped_type &V = GroupCount[Group];
tools/clang/utils/TableGen/NeonEmitter.cpp 554 ClassMap[SI] = ClassS;
555 ClassMap[II] = ClassI;
556 ClassMap[WI] = ClassW;
557 ClassMap[SOpI] = ClassS;
558 ClassMap[IOpI] = ClassI;
559 ClassMap[WOpI] = ClassW;
560 ClassMap[LOpI] = ClassL;
561 ClassMap[NoTestOpI] = ClassNoTest;
2065 CK = ClassMap[R->getSuperClasses()[1].first];
tools/dsymutil/BinaryHolder.cpp 159 return MemberCache[Key];
208 return MemberCache[Key];
tools/dsymutil/DebugMap.cpp 52 AddressToMapping[*ObjectAddress] = &*InsertResult.first;
tools/dsymutil/DwarfLinker.cpp 2034 LocalCIES[EntryOffset] = CIEData;
tools/dsymutil/DwarfStreamer.cpp 217 UniqueIdToCuMap[CU.ID] = Id++;
tools/lld/COFF/InputFiles.cpp 360 prevailingSectionMap[name] = sectionNumber;
tools/lld/COFF/MapFile.cpp 86 ret[syms[i]] = std::move(str[i]);
121 os << symStr[sym] << '\n';
tools/lld/COFF/SymbolTable.cpp 342 firstDiag[sym] = undefDiags.size();
432 localImports[sym] = d;
tools/lld/ELF/ARMErrataFix.cpp 329 sectionMap[sec].push_back(def);
484 std::vector<const Defined *> &mapSyms = sectionMap[isec];
tools/lld/ELF/CallGraphSort.cpp 229 orderMap[sections[i]] = curOrder++;
tools/lld/ELF/Driver.cpp 1643 map[w.sym] = w.wrap;
1644 map[w.real] = w.sym;
tools/lld/ELF/LinkerScript.cpp 81 OutputSection *&secRef = nameToOutputSection[name];
96 OutputSection *&cmdRef = nameToOutputSection[name];
260 insert(insertBeforeCommands[os->name]);
262 insert(insertAfterCommands[os->name]);
tools/lld/ELF/MapFile.cpp 191 os << symStr[sym] << '\n';
tools/lld/ELF/Relocations.cpp 835 firstRef[undef.sym] = &undef;
1629 thunkedSections[isec] = ts;
1714 thunkVec = &thunkedSymbols[rel.sym];
tools/lld/ELF/SyntheticSections.cpp 412 offsetToCie[offset] = addCie<ELFT>(piece, rels);
2075 symbolIndexMap[e.sym] = ++i;
2663 size_t &idx = map[shardId][ent.name];
tools/lld/lib/Core/SymbolTable.cpp 120 _nameTable[name] = &newAtom;
203 _nameTable[name] = &newAtom;
205 _replacedAtoms[existing] = &newAtom;
tools/lld/lib/ReaderWriter/MachO/File.h 260 _sectionAtoms[inSection].push_back(offAndAtom);
tools/lld/lib/ReaderWriter/MachO/GOTPass.cpp 161 _targetToGOT[target] = gotEntry;
tools/lld/lib/ReaderWriter/MachO/LayoutPass.cpp 88 atom = followOnNexts[atom];
100 const DefinedAtom *hare = followOnNexts[root];
106 tortoise = followOnNexts[tortoise];
107 hare = followOnNexts[followOnNexts[hare]];
107 hare = followOnNexts[followOnNexts[hare]];
123 const DefinedAtom *next = followOnRoots[ap];
272 const DefinedAtom *atom = _followOnRoots[targetAtom];
290 const DefinedAtom *atom = _followOnRoots[targetAtom];
310 _followOnRoots[targetAtom] = root;
346 _followOnNexts[ai] = targetAtom;
351 _followOnRoots[ai] = ai;
364 const DefinedAtom *tmp = _followOnRoots[ai];
365 _followOnRoots[targetAtom] = tmp;
372 setChainRoot(targetAtom, _followOnRoots[ai]);
385 _followOnNexts[targetPrevAtom] = ai;
386 const DefinedAtom *tmp = _followOnRoots[targetPrevAtom];
387 _followOnRoots[ai] = tmp;
392 _followOnNexts[ai] = _followOnRoots[targetAtom];
392 _followOnNexts[ai] = _followOnRoots[targetAtom];
393 setChainRoot(_followOnRoots[targetAtom], _followOnRoots[ai]);
393 setChainRoot(_followOnRoots[targetAtom], _followOnRoots[ai]);
414 nextAtom = _followOnNexts[nextAtom]) {
417 _ordinalOverrideMap[nextAtom] = index++;
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp 768 _atomToAddress[atom] = _ctx.baseAddress();
773 << llvm::format("0x%016X", _atomToAddress[atom])
787 << llvm::format("0x%016X", _atomToAddress[atom])
1046 sym.value = _atomToAddress[stab.atom];
1108 sym.value = _atomToAddress[ai.atom];
1109 _atomToSymbolIndex[ai.atom] = globalStartIndex + file.globalSymbols.size();
1141 _atomToSymbolIndex[ai.atom] = file.undefinedSymbols.size() + start;
1181 uint32_t index = _atomToSymbolIndex[target];
1200 uint32_t index = _atomToSymbolIndex[target];
1209 uint32_t index = _atomToSymbolIndex[target];
1284 uint64_t address = _atomToAddress[atom];
tools/lld/lib/ReaderWriter/MachO/StubsPass.cpp 232 _targetToUses[target].push_back(ref);
240 _targetToUses[target].push_back(ref);
314 for (const Reference *ref : _targetToUses[target]) {
tools/lld/lib/ReaderWriter/MachO/TLVPass.cpp 120 _targetToTLVP[target] = tlvpEntry;
tools/lld/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp 92 _refNames[target] = newName;
136 _refNames[prevAtom] = newName2;
tools/lld/wasm/Driver.cpp 628 map[w.sym] = w.wrap;
629 map[w.real] = w.sym;
tools/lld/wasm/InputFiles.cpp 299 customSectionsByIndex[sectionIndex] = customSections.back();
423 InputSection *section = customSectionsByIndex[sym.Info.ElementIndex];
tools/lld/wasm/Writer.cpp 666 OutputSegment *&s = segmentMap[name];
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp 201 m_isa_to_interface[isa] = new_iface_decl;
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp 3883 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
3925 m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
4081 reexport_shlib_needs_fixup[sym_idx] = reexport_name;
4092 undefined_name_to_desc[undefined_name] = nlist.n_desc;
4297 N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
4363 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4399 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
4421 m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp 4265 m_cached_module_specs[key] = module_spec;
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp 299 forward_to_full[indices.forward] = indices.full;
300 full_to_forward[indices.full] = indices.forward;
337 parents[Record.Type] = parent;
371 TypeIndex full = forward_to_full[fwd];
372 m_parent_types[full] = m_parent_types[fwd];
372 m_parent_types[full] = m_parent_types[fwd];
375 TypeIndex fwd = full_to_forward[full];
376 m_parent_types[fwd] = m_parent_types[full];
376 m_parent_types[fwd] = m_parent_types[full];
440 PdbCompilandSymId scope_id(id.modi, m_decl_to_status[scope_decl].uid);
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp 720 m_types[best_uid] = result;
tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp 449 m_forward_decl_to_uid[record_decl] = type.getSymIndexId();
981 m_decl_context_to_uid[result] = symbol.getSymIndexId();
998 m_decl_context_to_uid[result] = symbol.getSymIndexId();
1067 m_parent_to_namespaces[curr_context].insert(namespace_decl);
tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp 907 m_public_names[addr] = symbol_up->getRawSymbol().getName();
1808 uint32_t source_idx = index_map[source_id];
1887 index_map[source_id] = index++;
tools/lldb/source/Symbol/ClangExternalASTSourceCommon.cpp 61 return &m_metadata[object];
69 m_metadata[object] = metadata;
tools/lldb/source/Utility/ReproducerInstrumentation.cpp 21 m_mapping[idx] = object;
100 m_mapping[object] = index;
101 return m_mapping[object];
tools/lldb/source/Utility/SelectHelper.cpp 50 m_fd_map[fd].read_set = true;
54 m_fd_map[fd].write_set = true;
58 m_fd_map[fd].error_set = true;
tools/lldb/tools/lldb-vscode/JSONUtils.cpp 550 source.addr_to_line[inst_addr] = i + 1;
555 g_vsc.source_map[sourceReference] = std::move(source);
556 g_vsc.addr_to_source_ref[low_pc] = sourceReference;
tools/lldb/tools/lldb-vscode/lldb-vscode.cpp 1583 request_bps[src_bp.line] = std::move(src_bp);
1629 old_src_bp_pos->second[pair.first] = std::move(pair.second);
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp 90 Result[Register] = std::move(*RegValOr);
126 jthreads_info.m_thread_infos[tid] =
261 Result[Reg] = std::move(*RegValOr);
tools/lldb/unittests/tools/lldb-server/tests/ThreadIdsInJstopinfoTest.cpp 50 EXPECT_THAT(thread_infos[tid].ReadRegister(pc_reg),
tools/llvm-c-test/echo.cpp 181 VMap[SrcCur] = DstCur;
644 VMap[Src] = Dst = LLVMBuildPhi(Builder, CloneType(Src), Name);
774 return VMap[Src] = Dst;
797 return BBMap[Src] = BB;
tools/llvm-cfi-verify/lib/FileAnalysis.cpp 506 StaticBranchTargetings[Target].push_back(VMAddress);
tools/llvm-cfi-verify/lib/GraphBuilder.cpp 185 Result.IntermediateNodes[CurrentAddress] = NextAddress;
242 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
249 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
262 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
275 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
282 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
291 Result.IntermediateNodes[ParentMeta.VMAddress] = Address;
328 Result.IntermediateNodes[PrevInstr->VMAddress] = Address;
tools/llvm-diff/DiffConsumer.cpp 80 out << '%' << ctxt.LNumbering[V];
85 out << '%' << ctxt.RNumbering[V];
tools/llvm-diff/DifferenceEngine.cpp 155 BasicBlock *&Ref = Blocks[L];
342 BasicBlock *LCase = LCases[CaseValue];
470 return Values[L] == R || TentativeValues.count(std::make_pair(L, R));
473 return Values[L] == R;
tools/llvm-dwp/llvm-dwp.cpp 79 OffsetRemapping[PrevOffset] =
tools/llvm-jitlink/llvm-jitlink.cpp 325 Blocks[KV.first] = std::move(SegMem);
tools/llvm-mca/Views/BottleneckAnalysis.cpp 126 IPI[IID].ResourcePressureCycles++;
134 IPI[IID].RegisterPressureCycles++;
141 IPI[IID].MemoryPressureCycles++;
tools/llvm-objcopy/COFF/Object.cpp 30 SymbolMap[Sym.UniqueId] = &Sym;
75 SectionMap[S.UniqueId] = &S;
tools/llvm-objcopy/ELF/ELFObjcopy.cpp 328 FromTo[S] = addSection(S);
tools/llvm-objdump/MachODump.cpp 1285 (*AddrMap)[Address] = SymName;
7463 AddrMap[Address] = SymName;
10457 (*info->bindtable)[Address] = name;
tools/llvm-pdbutil/StreamUtil.cpp 87 ModStreams[SN] = IMD;
tools/llvm-readobj/COFFDumper.cpp 261 const auto &Relocations = RelocMap[Section];
333 const auto &Relocations = RelocMap[Section];
593 RelocMap[Section].push_back(Reloc);
596 llvm::sort(RelocMap[Section], [](RelocationRef L, RelocationRef R) {
tools/llvm-readobj/ELFDumper.cpp 2896 const GroupSection *MainGroup = Map[GM.Index];
5221 const GroupSection *MainGroup = Map[GM.Index];
tools/llvm-xray/func-id-helper.cpp 49 CachedNames[FuncId] = S;
tools/llvm-xray/trie-node.h 65 LeftCalleesByFuncId[Callee->FuncId] = Callee;
tools/llvm-xray/xray-converter.cpp 218 Parent == nullptr ? StackRootsByThreadId[TId] : Parent->Callees;
299 StackTrieNode *&StackCursor = StackCursorByThreadId[R.TId];
tools/llvm-xray/xray-graph.cpp 201 auto &ThreadStack = PerThreadFunctionStack[Record.TId];
tools/llvm-xray/xray-stacks.cpp 339 Roots[ThreadId].push_back(Node);
344 const auto &RootsByThread = Roots[ThreadId];
366 auto &TS = ThreadStackMap[R.TId];
tools/opt/Debugify.cpp 78 DIType *&DTy = TypeCache[Size];
tools/polly/include/polly/ScopInfo.h 2079 PHIReadAccs[PHI] = Access;
2095 InvEquivClassVMap[LoadInst] = ClassRep;
2614 isl::set &getOrInitEmptyDomain(BasicBlock *BB) { return DomainMap[BB]; }
2620 void setDomain(BasicBlock *BB, isl::set &Domain) { DomainMap[BB] = Domain; }
tools/polly/lib/Analysis/DependenceInfo.cpp 814 ReductionDependences[MA] = D;
tools/polly/lib/Analysis/ScopBuilder.cpp 348 InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(PWAC.second);
348 InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(PWAC.second);
664 InvalidDomainMap[ExitBB] = ExitDomain.empty(ExitDomain.get_space());
834 InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
972 InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
1013 isl::set InvalidDomain = InvalidDomainMap[BB];
1029 InvalidDomainMap[BB] = InvalidDomain;
1053 isl::set SuccInvalidDomain = InvalidDomainMap[SuccBB];
1057 InvalidDomainMap[SuccBB] = SuccInvalidDomain;
1069 InvalidDomainMap[BB] = InvalidDomain;
tools/polly/lib/Analysis/ScopInfo.cpp 1154 ValueWrites[AccessVal] = Access;
1159 ValueReads[AccessVal] = Access;
1164 PHIWrites[PHI] = Access;
1169 PHIReads[PHI] = Access;
1524 ParameterIds[Parameter] = Id;
2374 StmtMap[BB].push_back(Stmt);
2378 InstStmtMap[Inst] = Stmt;
2391 InstStmtMap[Inst] = Stmt;
2395 StmtMap[BB].push_back(Stmt);
2489 ValueUseAccs[SAI].push_back(Access);
2491 PHIIncomingAccs[SAI].push_back(Access);
tools/polly/lib/CodeGen/BlockGenerators.cpp 478 auto &Addr = ScalarMap[Array];
1481 ValueMapT &EntryBBMap = RegionMaps[EntryBBCopy];
1512 InitBBMap = &RegionMaps[BBCopyIDom];
1523 StartBlockMap[BB] = BBCopy;
1524 EndBlockMap[BB] = Builder.GetInsertBlock();
1527 for (const PHINodePairTy &PHINodePair : IncompletePHINodeMap[BB])
1529 IncompletePHINodeMap[BB].clear();
1558 BasicBlock *BBCopyStart = StartBlockMap[BB];
1559 BasicBlock *BBCopyEnd = EndBlockMap[BB];
1570 ValueMapT &RegionMap = RegionMaps[BBCopyStart];
1585 BasicBlock *BBCopy = StartBlockMap[BB];
1598 LoopPHI->addIncoming(LoopPHIInc, EndBlockMap[PredBB]);
1600 LoopPHI->addIncoming(NullVal, EndBlockMap[PredBB]);
1651 ValueMapT *LocalBBMap = &RegionMaps[NewIncomingBlockStart];
1709 NewExitScalars[MA] = NewVal;
1742 BasicBlock *BBCopyStart = StartBlockMap[IncomingBB];
1743 BasicBlock *BBCopyEnd = EndBlockMap[IncomingBB];
1748 IncompletePHINodeMap[IncomingBB].push_back(std::make_pair(PHI, PHICopy));
1754 ValueMapT &BBCopyMap = RegionMaps[BBCopyStart];
tools/polly/lib/CodeGen/IRBuilder.cpp 178 SecondLevelAliasScopeMap[PtrSCEV] = SecondLevelAliasScope;
182 SecondLevelAliasScopeMap[BasePtrSCEV] = MDNode::concatenate(
187 SecondLevelOtherAliasScopeListMap[PtrSCEV] = SecondLevelOtherAliasScopeList;
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 365 IDToValue[I.first] = NewValues[I.second];
373 ValueMap[I.first] = I.second;
711 NewValuesReverse[P.second] = P.first;
tools/polly/lib/Support/SCEVAffinator.cpp 193 PWACtx PWAC = CachedExpressions[Key];
237 CachedExpressions[Key] = PWAC;
tools/polly/lib/Support/ScopHelper.cpp 253 return SCEVCache[E];
255 SCEVCache[E] = Result;
tools/polly/lib/Transform/Simplify.cpp 232 isl::set &Result = ValueSets[V];
399 isl::set &Result = ValueSets[V];
tools/polly/lib/Transform/ZoneAlgo.cpp 700 auto &Result = ScalarReachDefZone[Stmt];
728 auto &Id = ValueIds[V];
tools/verify-uselistorder/verify-uselistorder.cpp 244 IDs[V] = Values.size();
unittests/ADT/DenseMapTest.cpp 567 map[i] = i + 1;
571 map[i] = i + 1;
unittests/Analysis/SparsePropagation.cpp 168 ChangedValues[RegI] = getOverdefinedVal();
176 ChangedValues[RegFormal] =
180 ChangedValues[RegI] =
194 ChangedValues[RetF] =
210 ChangedValues[MemPtr] =
220 ChangedValues[RegI] = getOverdefinedVal();
unittests/ExecutionEngine/JITLink/JITLinkTestCommon.cpp 156 LookupResult[Symbol] = I->second;
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp 209 EXPECT_EQ(Result[Bar].getAddress(), QuxSym.getAddress())
236 EXPECT_EQ(SymbolFlags[Foo], FooSym.getFlags())
240 EXPECT_EQ(SymbolFlags[Bar], BarSym.getFlags())
276 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
278 EXPECT_EQ((*Result)[Qux].getAddress(), QuxSym.getAddress())
291 EXPECT_EQ((*Result)[Bar].getAddress(), FooSym.getAddress())
293 EXPECT_EQ((*Result)[Baz].getAddress(), FooSym.getAddress())
351 EXPECT_EQ(Flags[Foo], FooSym.getFlags()) << "Unexpected flags for Foo";
965 NewDefs[Name] = Symbols[Name];
965 NewDefs[Name] = Symbols[Name];
983 EXPECT_EQ(Result[Bar].getAddress(), BarSym.getAddress())
1194 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
1196 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp 53 EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
55 EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
106 EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
107 EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
109 EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
110 EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
unittests/Support/ReverseIterationTest.cpp 40 Map[Key] = 0;
94 Map[Key] = Key->value;
utils/TableGen/AsmWriterEmitter.cpp 908 unsigned Entry = MCOpPredicateMap[Rec];
913 MCOpPredicateMap[Rec] = Entry;
utils/TableGen/CodeGenMapTable.cpp 303 MapTable[CurKeyInstr] = ColInstrVec;
386 std::vector<Record*> ColInstrs = MapTable[CurInstr];
utils/TableGen/CodeGenRegisters.cpp 1218 CodeGenSubRegIndex *&Idx = Def2SubRegIdx[Def];
1227 CodeGenRegister *&Reg = Def2Reg[Def];
1263 if (CodeGenRegisterClass *RC = Def2RC[Def])
utils/TableGen/CodeGenRegisters.h 398 SubClassWithSubReg[SubIdx] = SubRC;
utils/TableGen/CodeGenSchedule.cpp 246 Declarations[Name] = R;
304 Predicate2Index[Pred] = NumUniquePredicates++;
309 Opcode2Index[Opcode] = OpcodeMappings.size();
346 PredMask.setBit(Predicate2Index[Pred]);
349 unsigned OpcodeIdx = Opcode2Index[Opcode];
369 unsigned LhsIdx = Opcode2Index[Lhs.first];
370 unsigned RhsIdx = Opcode2Index[Rhs.first];
411 Decl2Index[Decl] = STIPredicates.size();
534 ProcModelMap[NoModelDef] = 0;
883 InstrClassMap[Inst->TheDef] = SCIdx;
1074 return InstrClassMap[OIDef] == OldSCIdx;
1138 InstrClassMap[InstDef] = SCIdx;
1277 if (InstrClassMap[*II] == SCIdx)
utils/TableGen/DAGISelMatcherEmitter.cpp 103 unsigned &Entry = NodePredicateMap[TP];
149 unsigned &Entry = NodeXFormMap[Rec];
utils/TableGen/FixedLenDecoderEmitter.cpp 2394 IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
2412 IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
utils/TableGen/GlobalISelEmitter.cpp 1655 OpcodeValues[I] = OpcodeValue++;
3014 PhysRegOperands[Reg] = &OM;
utils/TableGen/SearchableTableEmitter.cpp 135 std::unique_ptr<CodeGenIntrinsic> &Intr = Intrinsics[I];
200 return Index.Fields[0].Enum->EntryMap[EnumEntry]->second;
250 int64_t LHSv = Field.Enum->EntryMap[LHSr]->second;
251 int64_t RHSv = Field.Enum->EntryMap[RHSr]->second;
531 Field.Enum = EnumMap[TypeRec];
utils/TableGen/SubtargetEmitter.cpp 169 FeatureMap[Def] = i;