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

References

  351         factory->Cache[factory->maskCacheIndex(computeDigest())] = next;
  617     TreeTy *&entry = Cache[maskCacheIndex(digest)];

  442     AliasSet::PointerRec *&Entry = PointerMap[ASTCallbackVH(V, this)];

  986     Node *&N = NodeMap[&F];

  186     Accesses[MemAccessInfo(Ptr, true)].push_back(AccessIdx);
  195     Accesses[MemAccessInfo(Ptr, false)].push_back(AccessIdx);

  965     BBMap[BB] = L;

  251   LIB.BBMap[NewBB] = L;
  632   LoopHeaders[L.getHeader()] = &L;

  804         Value *NV = Map[V];

  131       CustomNames[F] = Name;

  394     Members[0] = Instr;
  734       Dependences[Dep.getSource(*LAI)].insert(Dep.getDestination(*LAI));

  122       ValToVRegs[&V] = VRegList;
  131       TypeToOffsets[V.getType()] = OffsetList;

  860       OutMIs[InsnID].addReg(State.TempRegisters[TempRegID], TempRegFlags);
 1012       State.TempRegisters[TempRegID] =

   37     EHPadUnwindMap[BB] = Dest;
   47     EHPadUnwindMap[MBB] = Dest;

  193       InternedNames[Mangle(NamePair.first)] = std::move(TargetJITNames);

  109         SuccInsert[U.getFrom()].push_back(U.getTo());
  110         PredInsert[U.getTo()].push_back(U.getFrom());
  112         SuccDelete[U.getFrom()].push_back(U.getTo());
  113         PredDelete[U.getTo()].push_back(U.getFrom());

  835     auto &PassPtr = AnalysisPasses[PassT::ID()];
  872     AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
  960       AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
  993     AnalysisResultLists[&IR].erase(RI->second);

  208     return Map[Wrap(Key)];

  428     LineInfo[Filename].Blocks[Line - 1].push_back(Block);
  435     LineInfo[Filename].Functions[Line - 1].push_back(Function);

   80     Operations[{From, To}] += (U.getKind() == UpdateKind::Insert ? 1 : -1);
  102       Operations[{U.getFrom(), U.getTo()}] = int(i);
  104       Operations[{U.getTo(), U.getFrom()}] = int(i);
  109                return Operations[{A.getFrom(), A.getTo()}] >
  110                       Operations[{B.getFrom(), B.getTo()}];

  183     assert(IDom || DT.DomTreeNodes[nullptr]);
  330         unsigned SemiU = NodeToInfo[eval(N, i + 1, EvalStack)].Semi;
  360     auto &BBInfo = NodeToInfo[nullptr];
 1184       BUI.FutureSuccessors[U.getFrom()].push_back({U.getTo(), U.getKind()});
 1185       BUI.FuturePredecessors[U.getTo()].push_back({U.getFrom(), U.getKind()});
 1237     auto &FS = BUI.FutureSuccessors[CurrentUpdate.getFrom()];
 1243     auto &FP = BUI.FuturePredecessors[CurrentUpdate.getTo()];
 1615     BUI.FutureSuccessors[U.getFrom()].push_back({U.getTo(), U.getKind()});
 1616     BUI.FuturePredecessors[U.getTo()].push_back({U.getFrom(), U.getKind()});

  609         SccSize[Node->getFunction()] = I->size();
  620     return FuncInstOpcodeMap[&F];
  628     return FuncRWInstsMap[&F];
  650     return (SccSizeOpt.getValue())[&F];
  792     KindToAbstractAttributeMap[&AAType::ID] = &AA;

  199         BBInfo *SuccInfo = BBMap[*SI];
  409     BBMap[PHI->getParent()]->PHITag = PHI;
  418         BBInfo *PredInfo = BBMap[I.getIncomingBlock()];

  922   Probs[std::make_pair(Src, IndexInSuccessors)] = Prob;

  375     auto &Attr = AttrMap[IVal.Val];
  391     auto &AliasList = AliasMap[Val];
  821   Cache[&Fn] = std::move(FunInfo);

  189     auto &GlobalMRI = P->Map[&GV];
  314           FunctionInfos[Reader].addModRefInfoForGlobal(GV, ModRefInfo::Ref);
  323             FunctionInfos[Writer].addModRefInfoForGlobal(GV, ModRefInfo::Mod);
  456     AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
  477         FunctionToSCCMap[F] = SCCID;
  504     FunctionInfo &FI = FunctionInfos[F];
  620       FunctionInfos[SCC[i]->getFunction()] = CachedFI;

  543     SimplifiedValues[&I] = FirstC;
  549     ConstantOffsetPtrs[&I] = FirstBaseAndOffset;
  554       SROAArgValues[&I] = SROAArg;
  577   ConstantOffsetPtrs[&I] = BaseAndOffset;
  598       SROAArgValues[&I] = SROAArg;
  627   SimplifiedValues[&I] = C;
  643     ConstantOffsetPtrs[&I] = BaseAndOffset;
  649     SROAArgValues[&I] = SROAArg;
  670       ConstantOffsetPtrs[&I] = BaseAndOffset;
  683     SROAArgValues[&I] = SROAArg;
  702       ConstantOffsetPtrs[&I] = BaseAndOffset;
  709     SROAArgValues[&I] = SROAArg;
 1006         SimplifiedValues[&I] = C;
 1018     SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
 1052         SimplifiedValues[&I] = C;
 1082     SimplifiedValues[&I] = C;
 1114     SimplifiedValues[&I] = C;
 1224     SimplifiedValues[&Call] = C;
 1370       SimplifiedValues[&SI] = TrueC;
 1382       ConstantOffsetPtrs[&SI] = TrueBaseAndOffset;
 1387         SROAArgValues[&SI] = SROAArg;
 1404         SimplifiedValues[&SI] = C;
 1413     SimplifiedValues[&SI] = SelectedC;
 1423     ConstantOffsetPtrs[&SI] = BaseAndOffset;
 1428       SROAArgValues[&SI] = SROAArg;
 1792       SimplifiedValues[&*FAI] = C;
 1796       ConstantOffsetPtrs[&*FAI] = std::make_pair(PtrArg, C->getValue());
 1800         SROAArgValues[&*FAI] = PtrArg;

  464   int SourceIdx = SCCIndices[&SourceSCC];
  465   int TargetIdx = SCCIndices[&TargetSCC];
  558   int SourceIdx = SCCIndices[&SourceSCC];
  559   int TargetIdx = SCCIndices[&TargetSCC];
  759   G->SCCMap[&TargetN] = &OldSCC;
  815               G->SCCMap[&N] = &OldSCC;
  865         G->SCCMap[&N] = NewSCCs.back();
  875   int OldIdx = SCCIndices[&OldSCC];
  983   int SourceIdx = G->RefSCCIndices[&SourceC];
  984   int TargetIdx = G->RefSCCIndices[this];
 1067       SCCIndices[&InnerC] = SCCIndex++;
 1069         G->SCCMap[&N] = &InnerC;
 1084     SCCIndices[&InnerC] = SCCIndex++;
 1473   G->NodeMap[&NewF] = &N;
 1691           SCCMap[&N] = RC.SCCs.back();

  187         OverDefinedCache[BB].insert(Val);
  195         It->second->BlockVals[BB] = Result;

  362     PositionMap[Pointers[Index].PointerValue] = Index;
  390       unsigned Pointer = PositionMap[MI->getPointer()];
 2340   SymbolicStrides[Ptr] = Stride;

   33     SimplifiedValues[I] = SC->getValue();
   44     SimplifiedValues[I] = SC->getValue();
   59   SimplifiedAddresses[I] = Address;
   86     SimplifiedValues[&I] = C;
  137   SimplifiedValues[&I] = CV;
  157       SimplifiedValues[&I] = C;
  196           SimplifiedValues[&I] = C;

  105       Deps[Inst].insert(std::make_pair(getInstTypePair(Res),
  111       DepSet &InstDeps = Deps[Inst];
  122       DepSet &InstDeps = Deps[Inst];

  912   CacheMap[V] = Result;
  995   CacheMap[&PHI] = std::make_pair(SizePHI, OffsetPHI);

  789   PerInstNLInfo &CacheP = NonLocalDeps[QueryCall];
  929       ReverseNonLocalDefsCache[NonLocalDefIt->second.getResult().getInst()]

 1696   ValueToMemoryAccess[BB] = Phi;
 1785   ValueToMemoryAccess[I] = MUD;
 2101     BlockNumbering[&I] = ++CurrentNumber;

  931       EdgeCountMap[{Pi, BB}]++;
  993         for (int I = 0, E = EdgeCountMap[{Pred, BB}]; I < E; ++I)
 1024         for (int I = 0, E = EdgeCountMap[{Pred, BB}]; I < E; ++I)
 1028         for (int I = 0, E = EdgeCountMap[{Pred, BB}]; I < E; ++I)

  392           MustExec[&I].push_back(L);
  405           MustExec[&I].push_back(L);

   67       if (!ReachableMap.count(DepthMap[PhiPhiOp]))
   68         DepthMap[Phi] = std::min(DepthMap[Phi], DepthMap[PhiPhiOp]);
   94           auto It = ReachableMap.find(DepthMap[PhiOp]);

 1060     RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
 1066       RewriteMap[cast<SCEVUnknown>(Denominator)->getValue()] =
 4890   PredicatedSCEVRewrites[{SymbolicPHI, L}] = PredRewrite;
 4922     PredicatedSCEVRewrites[{SymbolicPHI, L}] = {SymbolicPHI, Predicates};
 4991   ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
 5113         ValueExprMap[SCEVCallbackVH(PN, this)] = PHISCEV;
 5145         ValueExprMap[SCEVCallbackVH(PN, this)] = Shifted;
 7897       CurrentIterVals[&PHI] = StartCST;
 7913       return RetVal = CurrentIterVals[PN];  // Got exit value!
 7922     NextIterVals[PN] = NextPHI;
 7924     bool StoppedEvolving = NextPHI == CurrentIterVals[PN];
 7939       Constant *&NextPHI = NextIterVals[PHI];
 7951       return RetVal = CurrentIterVals[PN];
 7976       CurrentIterVals[&PHI] = StartCST;
 8011       Constant *&NextPHI = NextIterVals[PHI];
12474   RewriteMap[SE.getSCEV(V)] = {Generation, New};

  639     return RelevantLoops[N] = L;
  643     return RelevantLoops[C] = Result;
  648     return RelevantLoops[D] = Result;
 1909   InsertedExpressions[std::make_pair(S, InsertPt)] = V;
 1998     PHINode *&OrigPhiRef = ExprToIVMap[SE.getSCEV(Phi)];

  430     DBits[I] = V;

 7332     Order[&U] = Indexes[NumUses - 1];

 2884         Order[&U] = Record[NumUses - 1];
 2972       UpgradedIntrinsics[&F] = NewFn;
 2977       RemangledIntrinsics[&F] = Remangled.getValue();
 5386   ValueIdToValueInfoMap[ValueID] = std::make_pair(
 5614             ValueIdToLinkageMap[ValueId++] = Linkage;
 5848       ValueIdToValueInfoMap[ValueID] =

 3075     uint64_t BitcodeIndex = FunctionToBitcodeIndex[&F] - bitcodeStartBit();
 3171   FunctionToBitcodeIndex[&F] = Stream.GetCurrentBitNo();
 3995     SummaryToValueIdMap[S] = *ValueId;
 4116     auto AliasValueId = SummaryToValueIdMap[AS];
 4121     auto AliaseeValueId = SummaryToValueIdMap[&AS->getAliasee()];

  645     MetadataMap[N].ID = MDs.size();
  696   MDIndex &Index = MetadataMap[Local];
  967     ValueMap[&BB] = BasicBlocks.size();
 1024     IDMap[&BB] = ++Counter;

  865     TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
  887   TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];

  198   unsigned &DieNumber = Numbering[&Entry];
  385   Numbering[&Die] = 1;
  408   Numbering[&Die] = 1;

  181         TrackedRegs[Reg] |= !Overlaps;
  190       TrackedRegs[NewReg] = true;

  235         LabelsBeforeInsn[Entries.front().getInstr()] = Asm->getFunctionBegin();
  255           LabelsBeforeInsn[I->getInstr()] = Asm->getFunctionBegin();

  529   DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
  793     for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
  853   DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];

  172     ImportedEntities[LocalScope].push_back(IE);

  664           RegsForEntryValues[RegLoc] = Reg;
  951       GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
  999       auto &GVMapEntry = GVMap[GVE->getVariable()];

 1115     HandlerStates[HandlerBlock] = State;
 1123   HandlerStates[&MF->front()] = NullState;
 1156     int FuncletState = HandlerStates[&*FuncletStart];

  487     EHScopeMembership[NewMBB] = n;

  254     volatile float hweight = Hint[hint] += weight;

 4726         LargeOffsetGEPID[GEP] = LargeOffsetGEPID.size();
 5294           return LargeOffsetGEPID[LHS.first] < LargeOffsetGEPID[RHS.first];
 5294           return LargeOffsetGEPID[LHS.first] < LargeOffsetGEPID[RHS.first];

  456     MISUnitMap[SU->getInstr()] = SU;
  661           const SUnit *SU = MISUnitMap[Q->second->getParent()];

   77   FInfoMap[&F] = GFI;

  225     return FrameIndices[&AI];
  238   int &FI = FrameIndices[&AI];
  277   MachineBasicBlock *&MBB = BBToMBB[&BB];
 2279     auto *&MBB = BBToMBB[&BB];

  105   PhysRegMinimalRCs[Reg] = PhysRC;
  285   auto &PartMapping = MapOfPartialMappings[Hash];
  319   auto &ValMapping = MapOfValueMappings[Hash];
  333   auto &Res = MapOfOperandsMappings[Hash];
  393   auto &InstrMapping = MapOfInstructionMappings[Hash];

  642         BSSGlobals[{AddressSpace, Section}].push_back(&GV);
  644         ConstGlobals[{AddressSpace, Section}].push_back(&GV);
  646         Globals[{AddressSpace, Section}].push_back(&GV);

 1215       SpillBBToSpill[MDT.getBase().getNode(Block)] = SpillToKeep;
 1217       SpillBBToSpill[MDT.getBase().getNode(Block)] = CurrentSpill;
 1262         SpillToRm = SpillBBToSpill[MDT[Block]];
 1282       SpillsToKeep[MDT[Block]] = 0;
 1435       SpillsToIns[Ent.first->getBlock()] = Ent.second;

  719     auto ParamDebugInstr = DebugEntryVals[CurrDebugInstr->getDebugVariable()];
 1046   VarLocSet &VLS = OutLocs[CurMBB];
 1200   VarLocSet &ILS = InLocs[&MBB];
 1201   VarLocSet &Pending = PendingInLocs[&MBB];
 1323       DebugEntryVals[MI.getDebugVariable()] = &MI;
 1327     PendingInLocs[&MBB] = VarLocSet();
 1379         OpenRanges.insertFromLocSet(PendingInLocs[MBB], VarLocIDs);

  104     M[&I] = i++;
  137       unsigned CurrentOrder = IOM[&MI];
  144           UseMap[MO.getReg()] = std::make_pair(CurrentOrder, &MI);
  148           if (Barrier < UseMap[MO.getReg()].first) {
  149             Barrier = UseMap[MO.getReg()].first;
  150             BarrierMI = UseMap[MO.getReg()].second;
  228         unsigned NewOrder = IOM[&*I];
  229         IOM[&MI] = NewOrder;
  239             IOM[&*EndIter] = NewOrder;

  137           LayoutOrderMap[&*MBI] = O;

  239     BlockToChain[BB] = this;
  276       assert(!BlockToChain[BB] &&
  279       BlockToChain[BB] = this;
  290       assert(BlockToChain[ChainBB] == Chain && "Incoming blocks not in chain.");
  291       BlockToChain[ChainBB] = this;
  606     BlockChain &SuccChain = *BlockToChain[Succ];
  655       BlockChain *SuccChain = BlockToChain[Succ];
  796         || BlockToChain[SuccPred] == &Chain
  870       !hasBetterLayoutPredecessor(Succ, PDom, *BlockToChain[PDom], UProb, UProb,
  915       const BlockChain *PredChain = BlockToChain[SuccPred];
  917           PredChain == &Chain || PredChain == BlockToChain[Succ])
 1009             BlockToChain[SuccPred] == &Chain ||
 1010             BlockToChain[SuccPred] == BlockToChain[Succ])
 1010             BlockToChain[SuccPred] == BlockToChain[Succ])
 1056   ComputedEdges[BestB.Src] = { BestB.Dest, false };
 1084         || BlockToChain[Pred] == &Chain)
 1420     if (Pred == Succ || BlockToChain[Pred] == &SuccChain ||
 1422         BlockToChain[Pred] == &Chain ||
 1490     BlockChain *SuccChain = BlockToChain[Succ];
 1512     BlockChain &SuccChain = *BlockToChain[Succ];
 1604     BlockChain &SuccChain = *BlockToChain[MBB];
 1658     if (BlockToChain[&*I] != &PlacedChain) {
 1663       return *BlockToChain[&*I]->begin();
 1681     assert(BlockToChain[ChainBB] == &Chain &&
 1686       if (BlockToChain[Pred] == &Chain)
 1714     assert(BlockToChain[BB] == &Chain && "BlockToChainMap mis-match in loop.");
 1755     BlockChain &SuccChain = *BlockToChain[BestSucc];
 1810     BlockChain *PredChain = BlockToChain[Pred];
 1819         BlockChain *SuccChain = BlockToChain[Succ];
 1880      BlockChain *PredChain = BlockToChain[Pred];
 1900        BlockChain *SuccChain = BlockToChain[Succ];
 1902            (SuccChain == BlockToChain[BestPred]))
 1959   BlockChain &HeaderChain = *BlockToChain[OldTop];
 2037       ComputedEdges[NewTop] = { OldTop, false };
 2059   BlockChain &HeaderChain = *BlockToChain[L.getHeader()];
 2074     BlockChain &Chain = *BlockToChain[MBB];
 2092       BlockChain &SuccChain = *BlockToChain[Succ];
 2174     BlockChain *PredChain = BlockToChain[Pred];
 2183         BlockChain *SuccChain = BlockToChain[Succ];
 2225       BlockChain *SuccChain = BlockToChain[Succ];
 2312     BlockChain *PredChain = BlockToChain[Pred];
 2334       BlockChain *SuccChain = BlockToChain[Succ];
 2500   BlockChain &LoopChain = *BlockToChain[LoopTop];
 2605   BlockChain &FunctionChain = *BlockToChain[&F->front()];
 2706   BlockChain &FunctionChain = *BlockToChain[&F->front()];
 2748   BlockChain &FunctionChain = *BlockToChain[&F->front()];
 2909           BlockChain *Chain = BlockToChain[RemBB];
 2958     BlockChain* PredChain = BlockToChain[Pred];
 2967       BlockChain *NewChain = BlockToChain[NewSucc];

  127       Copies[*RUI] = {MI, {}, true};

  879         Cost[*PS] = RCCost;
  881         Cost[*PS] += RCCost;
 1343     CSEMap[MI.getOpcode()].push_back(&MI);

   54       Register &R = Remaps[OrigR];
   77         MO.setReg(Remaps[MO.getReg()]);
   91         R = Remaps[R];

  105   AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
  141   AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
  157     DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
  163   AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
  167   AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];

  745     MBBFlagsMap[&MBB] = Flags;

  537       Cycles[SU->getInstr()] = Cycle;
  538       Stages[SU->getInstr()] = Schedule.stageScheduled(SU);
  545     NewInstrChanges[KV.first] = InstrChanges[getSUnit(KV.first)];
  897     InstrChanges[&I] = std::make_pair(NewBase, NewOffset);
  988         Resources[PRE.ProcResourceIdx]++;
 2815           ScheduledInstrs[cycle + (stage * InitiationInterval)];

  414   SeenDbgUsers[MO.getReg()].push_back(&MI);
  958     auto &Users = SeenDbgUsers[MO.getReg()];

  808   InstrCycles &MICycles = Cycles[&UseMI];
 1031         unsigned &Height = Heights[MTM.MRI->getVRegDef(LI.Reg)];
 1120       InstrCycles &MICycles = Cycles[&MI];

  588     BBInfo &MInfo = MBBInfoMap[&MBB];
  642     if (!MBBInfoMap[*I].Preds.count(MBB)) {
  654     if (!MBBInfoMap[*I].Succs.count(MBB)) {
 2042         BBInfo &MInfo = MBBInfoMap[MI->getParent()];
 2103   BBInfo &MInfo = MBBInfoMap[MI->getParent()];
 2142     BBInfo &MInfo = MBBInfoMap[&MBB];
 2147       BBInfo &SInfo = MBBInfoMap[*SuI];
 2163       BBInfo &SInfo = MBBInfoMap[*SuI];
 2177     BBInfo &MInfo = MBBInfoMap[&MBB];
 2180       BBInfo &PInfo = MBBInfoMap[*PrI];
 2196       BBInfo &SInfo = MBBInfoMap[*PrI];
 2206   BBInfo &MInfo = MBBInfoMap[&MBB];
 2250         BBInfo &PrInfo = MBBInfoMap[&Pre];
 2281     BBInfo &MInfo = MBBInfoMap[&MBB];
 2293     BBInfo &MInfo = MBBInfoMap[&MF->front()];
 2318       BBInfo &MInfo = MBBInfoMap[&MBB];

  408         VRMap[CurStageNum][Def] = VRMap[CurStageNum][LoopVal];
  495           PhiOp2 = VRMap[PrevStage - np + 1][Def];
  505           PhiOp2 = VRMap[PrevStage - np][Def];
  531               VRMap[CurStageNum - np][Def] = NewReg;
  556         InstrMap[NewPhi] = &*BBI;
  568         unsigned R = VRMap[CurStageNum - np][Def];
  584       VRMap[CurStageNum - np][Def] = NewReg;
  642       unsigned PhiOp2 = VRMap[PrevStage][Def];
  651         unsigned PhiOp1 = VRMap[PrologStage][Def];
  653           PhiOp1 = VRMap[PrologStage - np][Def];
  661           PhiOp2 = VRMap[PrevStage - np][Def];
  672           InstrMap[NewPhi] = &*BBI;
  683           VRMap[PrevStage - np - 1][Def] = NewReg;
  685           VRMap[CurStageNum - np][Def] = NewReg;
 1035       VRMap[CurStageNum][reg] = NewReg;
 1050         MO.setReg(VRMap[StageNum][reg]);
 1494     Phis[{LoopReg, *InitReg}] = R;
 1577     CanonicalMIs[&*I] = &*I;
 1578     CanonicalMIs[&*NI] = &*I;
 1579     BlockMIs[{NewBB, &*I}] = &*NI;
 1580     BlockMIs[{BB, &*I}] = &*I;
 1692     BlockMIs[{NewBB, &MI}] = NI;
 1716   return BlockMIs[{BB, CanonicalMIs[MI]}]->getOperand(OpIdx).getReg();
 1726     if (RMIStage != -1 && !AvailableStages[MI->getParent()].test(RMIStage))
 1738       LiveStages[MI->getParent()].test(Stage))
 1998       parseSymbolString(Sym->getName(), Cycle[&MI], Stage[&MI]);
 1998       parseSymbolString(Sym->getName(), Cycle[&MI], Stage[&MI]);

  369     --VRegPHIUseCount[BBVRegPair(MPhi->getOperand(i+1).getMBB()->getNumber(),
  424         !VRegPHIUseCount[BBVRegPair(opBlock.getNumber(), SrcReg)] &&
  485           !VRegPHIUseCount[BBVRegPair(opBlock.getNumber(), SrcReg)]) {
  557         ++VRegPHIUseCount[BBVRegPair(BBI.getOperand(i+1).getMBB()->getNumber(),

  203       EntryDbgValues[&MBB].push_back(&MI);
  208     for (auto *MI : EntryDbgValues[&MBB])

 1242   LiveDbgValueMap[Reg].push_back(&MI);

   61   RegMasks[&FP] = RegMask;

   90         BBMarkerSet[UI->getParent()][UI] = {AllocaNo, IsStart};
  118       BlockInstRange[BB] = std::make_pair(BBStart, BBEnd);
  156     BlockInstRange[BB] = std::make_pair(BBStart, BBEnd);
  210     std::tie(BBStart, BBEnd) = BlockInstRange[BB];
  266     auto BlockRange = BlockInstRange[BB];

  570     MISUnitMap[&MI] = SU;
  808     SUnit *SU = MISUnitMap[&MI];

15474         auto &RootCount = StoreRootCountMap[StoreNodes[i].MemNode];

  161     FuncInfo.ValueMap[&*I] = VI->second;
  240     Orders[&I] = Order++;
  311     unsigned UseOrder = OrderMap.Orders[&DbgVal];
  499       FuncInfo.RegFixups[AssignedReg + i] = Reg + i;
 2382       FuncInfo.MBBMap[cast<Instruction>(Add)->getParent()] != FuncInfo.MBB)

  223       PreferredExtendType[&I] = getPreferredExtendForValue(&I);
  254     MBBMap[&BB] = MBB;
  278       unsigned PHIReg = ValueMap[&PN];
  300           H.Handler = MBBMap[H.Handler.get<const BasicBlock *>()];
  305         UME.Cleanup = MBBMap[UME.Cleanup.get<const BasicBlock *>()];
  323       NewMap[MBBMap[Src]] = MBBMap[Dst];
  427   unsigned DestReg = ValueMap[PN];
  448     unsigned SrcReg = ValueMap[V];
  483     unsigned SrcReg = ValueMap[V];
  541           VirtReg2Value[Reg++] = P.first;

  691   auto &OpIdEntry = PromotedIntegers[getTableId(Op)];
  705   auto &OpIdEntry = SoftenedFloats[getTableId(Op)];
  716   auto &OpIdEntry = PromotedFloats[getTableId(Op)];
  729   auto &OpIdEntry = ScalarizedVectors[getTableId(Op)];
  736   std::pair<TableId, TableId> &Entry = ExpandedIntegers[getTableId(Op)];
  765   std::pair<TableId, TableId> &Entry = ExpandedIntegers[getTableId(Op)];
  773   std::pair<TableId, TableId> &Entry = ExpandedFloats[getTableId(Op)];
  789   std::pair<TableId, TableId> &Entry = ExpandedFloats[getTableId(Op)];
  797   std::pair<TableId, TableId> &Entry = SplitVectors[getTableId(Op)];
  817   std::pair<TableId, TableId> &Entry = SplitVectors[getTableId(Op)];
  829   auto &OpIdEntry = WidenedVectors[getTableId(Op)];

  250     TableId &PromotedId = PromotedIntegers[getTableId(Op)];
  618     TableId &PromotedId = PromotedFloats[getTableId(Op)];
  659     TableId &ScalarizedId = ScalarizedVectors[getTableId(Op)];
  785     TableId &WidenedId = WidenedVectors[getTableId(Op)];

  269   SDNode *BaseLoad = O2SMap[BaseOff];
  273     SDNode *Load = O2SMap[Offset];

 8415     Degree[&N] = NOps;
 8436     DivergenceMap[&N] = false;
 8439     bool IsDivergent = DivergenceMap[N];
 8443         IsSDNodeDivergent |= DivergenceMap[Op.getNode()];
 8446       DivergenceMap[N] = true;
 8451     assert(DivergenceMap[&N] == N.isDivergent() &&

 1598   MachineBasicBlock *TargetMBB = FuncInfo.MBBMap[I.getSuccessor()];
 2226   MachineBasicBlock *Succ0MBB = FuncInfo.MBBMap[I.getSuccessor(0)];
 2245   MachineBasicBlock *Succ1MBB = FuncInfo.MBBMap[I.getSuccessor(1)];
 2744   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getSuccessor(0)];
 2839   MachineBasicBlock *Return = FuncInfo.MBBMap[I.getDefaultDest()];
 2844     MachineBasicBlock *Target = FuncInfo.MBBMap[I.getIndirectDest(i)];
 2931     MachineBasicBlock *Succ = FuncInfo.MBBMap[BB];
 5959     int FI = FuncInfo.StaticAllocaMap[FnCtx];
 6400     int FI = FuncInfo.StaticAllocaMap[Slot];
 6652       int FI = FuncInfo.StaticAllocaMap[Slot];
 9886         FuncInfo->ValueMap[&Arg] = Reg;
10500     MachineBasicBlock *Succ = FuncInfo.MBBMap[I.getCaseSuccessor()];
10508   MachineBasicBlock *DefaultMBB = FuncInfo.MBBMap[SI.getDefaultDest()];
10561       DefaultMBB == FuncInfo.MBBMap[SI.getDefaultDest()])

 1353   FuncInfo->MBB = FuncInfo->MBBMap[&Fn.getEntryBlock()];
 1516             unsigned &R = FuncInfo->ValueMap[Inst];

  154         Builder.FuncInfo.StatepointSpillMaps[Relocate->getStatepoint()];
  911       FuncInfo.ValueMap[ISP.getInstruction()] = Reg;
 1007   auto &SpillMap = FuncInfo.StatepointSpillMaps[Relocate.getStatepoint()];

  494   ValueForcePair &VFP = Values[std::make_pair(RegIdx, ParentVNI.id)];

  692     BitVector &SeenStart = SeenStartMap[MBB];
  712     BasicBlocks[MBB] = BasicBlockNumbering.size();
  716     BlockLifetimeInfo &BlockInfo = BlockLiveness[MBB];
  826     BlockLifetimeInfo &MBBLiveness = BlockLiveness[&MBB];
 1125       int Target = SlotRemap[i];
 1129         SlotRemap[i] = Target;

   47   VRegDefMap[std::make_pair(MBB, Val)] = VReg;

  703     SrcRegMap[RegA] = FromRegC;
 1494     TiedOperands[SrcReg].push_back(std::make_pair(SrcIdx, DstIdx));
 1609     SrcRegMap[RegA] = RegB;

  181     auto &BBColors = BlockColors[&BB];
  207       FuncInfo.InvokeStateMap[II] = BaseState;
  211       FuncInfo.InvokeStateMap[II] = FuncInfo.EHPadStateMap[PadInst];
  211       FuncInfo.InvokeStateMap[II] = FuncInfo.EHPadStateMap[PadInst];
  251     FuncInfo.EHPadStateMap[CatchSwitch] = TryLow;
  262       FuncInfo.FuncletBaseStateMap[CatchPad] = CatchLow;
  296     FuncInfo.EHPadStateMap[CleanupPad] = CleanupState;
  362     FuncInfo.EHPadStateMap[CatchSwitch] = TryState;
  398     FuncInfo.EHPadStateMap[CleanupPad] = CleanupState;
  545       FuncInfo.EHPadStateMap[Cleanup] = CleanupState;
  569         FuncInfo.EHPadStateMap[Catch] = CatchState;
  573       FuncInfo.EHPadStateMap[CatchSwitch] = CatchState;
  616           int UserState = FuncInfo.EHPadStateMap[ChildCleanup];
  668       UnwindDestState = FuncInfo.EHPadStateMap[UnwindDest->getFirstNonPHI()];
  683     ColorVector &Colors = BlockColors[&BB];
 1023     size_t NumColors = BlockColors[&BB].size();

  477       CIE *Cie = CIEs[IsEH ? (StartStructureOffset - CIEPointer) : CIEPointer];

  922     CUMap[CU->getOffset()] = NotIndexed;

  271   CIEInfos[CIESymbol.getAddress()] = std::move(CIEInfo);

  143     auto &SegLists = Layout[B->getSection().getProtectionFlags()];
  275     Sym->getAddressable().setAddress(Result[Sym->getName()].getAddress());

   30       return {static_cast<char *>(SegBlocks[Seg].base()),
   31               SegBlocks[Seg].allocatedSize()};
   35       return reinterpret_cast<JITTargetAddress>(SegBlocks[Seg].base());

  191     auto *Sym = IndexToSymbol[Index];

  290             SymbolFlags[Mangle(GV->getName())] =

  336   bool Added = QueryRegistrations[&JD].insert(std::move(Name)).second;
  625       auto &PerAliasDeps = PerAliasDepsMap[&SrcJD];
  869     auto &DepsOnOtherJITDylib = MI.UnemittedDependencies[&OtherJITDylib];
  902         OtherMI.Dependants[this].insert(Name);
  993     (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
 1065           assert(DependantMI.UnemittedDependencies[this].count(Name) &&
 1068           DependantMI.UnemittedDependencies[this].erase(Name);
 1069           if (DependantMI.UnemittedDependencies[this].empty())
 1126     (*FailedSymbolsDepMap)[this] = std::move(SymbolsInErrorState);
 1156       (*FailedSymbolsMap)[&JD].insert(Name);
 1221           assert(UnemittedDepMII->second.Dependants[&JD].count(Name) &&
 1223           UnemittedDepMII->second.Dependants[&JD].erase(Name);
 1224           if (UnemittedDepMII->second.Dependants[&JD].empty())
 1466       (*FailedSymbolsMap)[this] = {Name};
 1813             &DependantMI.UnemittedDependencies[&DependencyJD];
 1815       DependencyMI.Dependants[this].insert(DependantName);

  167   RuntimeInterposes[Mangle("__dso_handle")] =
  170   RuntimeInterposes[Mangle("__cxa_atexit")] =

   72           LR[*KV.first] = KV.second;
  248         auto &SymNamedDeps = DepMap[Sym];
  274         auto &SymNamedDeps = DepMap[Sym];
  298         auto &DepsForJD = SymbolDeps[&SourceJD];
  424           InProcessLinks[&MR] = { Addr, Size };

 1168   mMap[V] = DestSlot;
 2706       SummaryToGUIDMap[Summary.get()] = GUID;
 2890     Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);

 1467     F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)];
 1518     getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)];

  690     PreservedVariables[Fn].emplace_back(Node);
  729     PreservedLabels[Fn].emplace_back(Node);

  547     Replacements[N] = doRemap(N);

  415   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
  450   auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];

   93     if (auto *Found = Cache[IA]) {
  108     Cache[MD] = Last = DILocation::getDistinct(

  191   return getContext().pImpl->GlobalValuePartitions[this];
  203   getContext().pImpl->GlobalValuePartitions[this] = S;
  212   return getContext().pImpl->GlobalObjectSections[this];
  224   getContext().pImpl->GlobalObjectSections[this] = S;

  291   return pImpl->GCNames[&Fn];

  851     ImmutablePassMap[ImmPI->getTypeInfo()] = P;
  930     AvailableAnalysis[II[i]->getTypeInfo()] = P;

 1210   auto &Info = InstructionMetadata[this];
 1234     auto &Info = getContext().pImpl->InstructionMetadata[this];
 1249   auto &Info = getContext().pImpl->InstructionMetadata[this];
 1274   auto &Info = getContext().pImpl->InstructionMetadata[this];
 1381     getContext().pImpl->GlobalObjectMetadata[this].get(KindID, MDs);
 1394   getContext().pImpl->GlobalObjectMetadata[this].insert(KindID, MD);
 1406   auto &Store = getContext().pImpl->GlobalObjectMetadata[this];
 1420   getContext().pImpl->GlobalObjectMetadata[this].getAll(MDs);
 1442     return getContext().pImpl->GlobalObjectMetadata[this].lookup(KindID);

  545       BlockMap[&BB] = BBS;

  592     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
  622                                  ->VectorTypes[std::make_pair(ElementType, EC)];
  645      : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];

  211   Ctx.pImpl->ValueNames[this] = VN;
  809     ValueHandleBase *&Entry = pImpl->ValueHandles[getValPtr()];
  823   ValueHandleBase *&Entry = Handles[getValPtr()];

 2293         const Function *&AttachedTo = DISubprogramAttachments[SP];
 4448     FrameEscapeInfo[BB->getParent()].first = Call.getNumArgOperands();
 5100     HasSourceDebugInfo[&U] = HasSource;
 5101   AssertDI(HasSource == HasSourceDebugInfo[&U],

  199     StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]);
 1127     ValueMap.MD()[CU->getRawEnumTypes()].reset(nullptr);
 1128     ValueMap.MD()[CU->getRawMacros()].reset(nullptr);
 1129     ValueMap.MD()[CU->getRawRetainedTypes()].reset(nullptr);
 1139     ValueMap.MD()[CU->getRawGlobalVariables()].reset(nullptr);
 1172         ValueMap.MD()[CU->getRawImportedEntities()].reset(nullptr);
 1551     SharedMDs[MD].reset(const_cast<MDNode *>(MD));

  807   if (OWriter.Relocations[&Sec].empty())
  940   std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
 1134       unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
 1148     SectionIndexMap[&Section] = addToSectionTable(&Section);
 1150       SectionIndexMap[RelSection] = addToSectionTable(RelSection);
 1162     SectionIndexMap[CGProfileSection] = addToSectionTable(CGProfileSection);
 1315     if (Renames.count(&Symbol) && Renames[&Symbol] != Alias) {
 1516     Relocations[&FixupSection].push_back(Rec);
 1531   Relocations[&FixupSection].push_back(Rec);

  405   LastValidFragment[F->getParent()] = F;

  245   MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];

   58   LastValidFragment[F->getParent()] = F->getPrevNode();
   64   if (MCFragment *Cur = LastValidFragment[Sec])

  162   if (LabelSections && !HasSectionLabel[Section] &&
  166     HasSectionLabel[Section] = true;
  488       DefiningSymbolMap[Symbol.getFragment()] = &Symbol;

  397   SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();

  550     SectionIndexMap[&*it] = Index;
  627     for (RelAndSymbol &Rel : Relocations[&Section]) {
  853     std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
  967     std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];

  172     StringIndexMap[CachedHashStringRef("")] = 0;

  516     CustomSectionsRelocations[&FixupSection].push_back(Rec);
  924     auto &Relocations = CustomSectionsRelocations[Sec.Section];
 1029   auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
 1036   return TypeIndices[&Symbol];
 1042   return TypeIndices[&Symbol];
 1058   TypeIndices[&Symbol] = Pair.first->second;
 1079   TypeIndices[&Symbol] = Pair.first->second;
 1168         WasmIndices[&WS] = NumFunctionImports++;
 1180         WasmIndices[&WS] = NumGlobalImports++;
 1193         WasmIndices[&WS] = NumEventImports++;
 1212       GOTIndices[&WS] = NumGlobalImports++;
 1262         WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
 1319         WasmIndices[&WS] = Index;
 1363       DataLocations[&WS] = Ref;
 1384         WasmIndices[&WS] = Index;
 1418       WasmIndices[&WS] = WasmIndex;
 1424       DataLocations[&WS] = Ref;

  323   SectionMap[&MCSec] = Section;
  362     Sec = SectionMap[Base->getFragment()->getParent()];
  627     COFFSection *Sec = SectionMap[&MCSec];
  723   COFFSection *Sec = SectionMap[MCSec];
  759     Reloc.Symb = SectionMap[TargetSection]->Symbol;
  765     Reloc.Symb = SymbolMap[&A];
  900     COFFSection *Sec = SectionMap[&Section];
 1025     COFFSection *AssocSec = SectionMap[AssocMCSec];
 1049       encodeULEB128(SectionMap[TargetSection]->Symbol->getIndex(), OS);

  319       BusyResources[ResourceRef(R.first, R.first)] += CS.size();

  590     Descriptors[MCI.getOpcode()] = std::move(ID);
  591     return *Descriptors[MCI.getOpcode()];
  594   VariantDescriptors[&MCI] = std::move(ID);
  595   return *VariantDescriptors[&MCI];
  601     return *Descriptors[MCI.getOpcode()];
  604     return *VariantDescriptors[&MCI];

  257   if (!RecordProvenance[FilenamesHash].insert(hash_value(OrigFuncName)).second)
  267     auto &RecordIndices = FilenameHash2RecordIndices[hash_value(Filename)];

  443     uint32_t idx = IndexMap[static_cast<uint32_t>(SectionHdrLayout[i].Type)];

   52     ++Counts[getChunk(UImm, Idx)];

  587         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
  739       if (FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
  823       if (FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 1021   return FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB;
 2316   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 2317   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 2423     MachineBasicBlock *MSucc = FuncInfo.MBBMap[BI->getSuccessor(0)];
 2428   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 2429   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];

 3513       CopiedRegs[VA.getLocReg()] = Val;

   88     LastMappingSymbols[getPreviousSection().first] = LastEMS;

  175     ArgInfoMap[&F] = ArgInfo;

  481       SIFunctionResourceInfo &Info = CallGraphResourceInfo[&MF.getFunction()];

  650   RegionMap[RegionInfo->getRegionFor(Exit)]->addChild(ExitMRT);
 2810     FallthroughMap[&MBBI] = MBB;

  483       RegSeqWithOpNos[&OrigMI].push_back(OpNo);

  412     auto &LiveMask = LiveRegs[Reg];

  226         LiveRegMap[SII.getInstructionFromIndex(SI)][Reg] =
  234           LiveRegMap[SII.getInstructionFromIndex(SI)][Reg] |= S.LaneMask;

   83         RegToChan[MO.getReg()] = Chan;
  298     if (PreviousRegSeqByReg[MOp->getReg()].empty())
  300     for (MachineInstr *MI : PreviousRegSeqByReg[MOp->getReg()]) {
  329   PreviousRegSeqByUndefCount[RSI.UndefReg.size()].push_back(RSI.Instr);

   95         Result[Dst] = R600::PS;
  100         Result[Dst] = R600::PV_X;
  123       Result[Dst] = PVReg;

  280       Map[Reg] = std::make_pair(State, Mask);

 1545     Visited[&MI] = MAddr;
 1547     MAddr = Visited[&MI];
 1608       Visited[&MINext] = MAddrNext;
 1610       MAddrNext = Visited[&MINext];

  167         ReachableMap[&DefBlock] = true; // self-loop on DefBlock

  250   InstrInfo &II = Instructions[&MI];
  324     BlockInfo &BBI = Blocks[&MBB];
  328       InstrInfo &III = Instructions[&MI];
  429   InstrInfo II = Instructions[&MI]; // take a copy to prevent dangling references
  436     Instructions[&MI].Needs = StateWQM;
  453       InstrInfo &PrevII = Instructions[PrevMI];
  475   BlockInfo BI = Blocks[&MBB]; // Make a copy to prevent dangling references.
  480     InstrInfo &LastII = Instructions[LastMI];

  633         Type *Ty = TruncTysMap[Call][i];
  644       Type *Ty = TruncTysMap[Switch][0];
  654       Type *Ty = TruncTysMap[I][i];
  720     IntegerType *DestTy = cast<IntegerType>(TruncTysMap[Trunc][0]);
  759         TruncTysMap[Call].push_back(Arg->getType());
  762       TruncTysMap[I].push_back(Switch->getCondition()->getType());
  765         TruncTysMap[I].push_back(I->getOperand(i)->getType());
  772     TruncTysMap[Trunc].push_back(Trunc->getDestTy());

  839             CPI = JumpTableEntryIndices[CPI];
 1123   return JumpTableEntryIndices[CPEMI->getOperand(1).getIndex()];
 2198     CPUser &User = CPUsers[JumpTableUserIndices[JTI]];
 2328         int CPEntryIdx = JumpTableEntryIndices[JTI];

  721         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 1239   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 1240   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];

 9844         DefRegs[OI->getReg()] = true;

 2408         MI2LocMap[&MI] = ++Loc;
 2424           Base2Ops[Base].push_back(&MI);

 1175                         << ", lr save at offset=" << RegOffsets[14] << "\n");

  474     LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);

 3095       unsigned UseR = RegMap[Op.getReg()];

  114     OffsetMap[&B] = InstOffset;
  153   unsigned InstOffset = BlockToInstOffset[&B];

  414         MachineInstr *DefInst = LastDef[Reg];
  448             LastDef[*SubRegs] = &MI;
  450           LastDef[Reg] = &MI;

  124     BlockToInstOffset[&MBB] = InstOffset;
  133     InstOffset = BlockToInstOffset[&MBB];
  149                                            BlockToInstOffset[TargetBB]);

  418     RPO[(*I)->getNumber()] = RPON++;
  424     unsigned BN = RPO[I.getNumber()];
  427       if (RPO[(*SI)->getNumber()] <= BN)

  841           LM[L].push_back(std::make_pair(*I, S));
  843           LM[L].push_back(std::make_pair(*I, S));
  854         LM[L].push_back(std::make_pair(*I, S));
 1197     RPO[(*I)->getNumber()] = RPON++;

 1960       int Weight = RootWeights[Child.getNode()];
 2040   LLVM_DEBUG(dbgs() << "--> Current height=" << NodeHeights[SDValue(N, 0)]
 2104     RootHeights[N] = NodeHeights[SDValue(N, 0)];
 2153     if ((RootWeights.count(V0.getNode()) && RootWeights[V0.getNode()] == -2) ||
 2154         (RootWeights.count(V1.getNode()) && RootWeights[V1.getNode()] == -2)) {
 2226   RootWeights[NewRoot.getNode()] = Leaves.top().Weight;
 2227   RootHeights[NewRoot.getNode()] = Height;
 2277     RootWeights[BasePtr.getNode()] = -1;

  471     InstrEvalResult[&MI] = CanBeReplaced;

  147           PeepholeMap[DstReg] = SrcReg;
  162         PeepholeMap[DstReg] = SrcReg;
  179         PeepholeDoubleRegsMap[DstReg] =
  196           PeepholeMap[DstReg] = SrcReg;

  235         VRegHoldingReg[MI->getOperand(0).getReg()] = MI->getOperand(1).getReg();
  245             LastVRegUse[VRegHoldingReg[MO.getReg()]] = &DAG->SUnits[su];
  250                   LastVRegUse[*AI] != &DAG->SUnits[su])
  252                 DAG->addEdge(&DAG->SUnits[su], SDep(LastVRegUse[*AI], SDep::Barrier));

   44     Defs[Hexagon::SA0].insert(Unconditional); // FIXME: define or change SA0?
   45     Defs[Hexagon::LC0].insert(Unconditional);
   48     Defs[Hexagon::SA1].insert(Unconditional); // FIXME: define or change SA0?
   49     Defs[Hexagon::LC1].insert(Unconditional);
  176         Defs[*SRI].insert(PredSense(PredReg, isTrue));

  109   (*TUL)[HexagonII::TypeCVI_VA] =
  111   (*TUL)[HexagonII::TypeCVI_VA_DV] = UnitsAndLanes(CVI_XLANE | CVI_MPY0, 2);
  112   (*TUL)[HexagonII::TypeCVI_VX] = UnitsAndLanes(CVI_MPY0 | CVI_MPY1, 1);
  113   (*TUL)[HexagonII::TypeCVI_VX_LATE] = UnitsAndLanes(CVI_MPY0 | CVI_MPY1, 1);
  114   (*TUL)[HexagonII::TypeCVI_VX_DV] = UnitsAndLanes(CVI_MPY0, 2);
  115   (*TUL)[HexagonII::TypeCVI_VP] = UnitsAndLanes(CVI_XLANE, 1);
  116   (*TUL)[HexagonII::TypeCVI_VP_VS] = UnitsAndLanes(CVI_XLANE, 2);
  117   (*TUL)[HexagonII::TypeCVI_VS] = UnitsAndLanes(CVI_SHIFT, 1);
  118   (*TUL)[HexagonII::TypeCVI_VS_VX] = UnitsAndLanes(CVI_XLANE | CVI_SHIFT, 1);
  119   (*TUL)[HexagonII::TypeCVI_VINLANESAT] =
  123   (*TUL)[HexagonII::TypeCVI_VM_LD] =
  125   (*TUL)[HexagonII::TypeCVI_VM_TMP_LD] = UnitsAndLanes(CVI_NONE, 0);
  126   (*TUL)[HexagonII::TypeCVI_VM_VP_LDU] = UnitsAndLanes(CVI_XLANE, 1);
  127   (*TUL)[HexagonII::TypeCVI_VM_ST] =
  129   (*TUL)[HexagonII::TypeCVI_VM_NEW_ST] = UnitsAndLanes(CVI_NONE, 0);
  130   (*TUL)[HexagonII::TypeCVI_VM_STU] = UnitsAndLanes(CVI_XLANE, 1);
  131   (*TUL)[HexagonII::TypeCVI_HIST] = UnitsAndLanes(CVI_XLANE, 4);
  132   (*TUL)[HexagonII::TypeCVI_GATHER] =
  134   (*TUL)[HexagonII::TypeCVI_SCATTER] =
  136   (*TUL)[HexagonII::TypeCVI_SCATTER_DV] =
  138   (*TUL)[HexagonII::TypeCVI_SCATTER_NEW_ST] =
  140   (*TUL)[HexagonII::TypeCVI_4SLOT_MPY] = UnitsAndLanes(CVI_XLANE, 4);
  141   (*TUL)[HexagonII::TypeCVI_ZW] = UnitsAndLanes(CVI_ZW, 1);

  904   BrMap[&Pred] = P.second;

  472         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
  954   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
  955   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];

  259           Second->setOperand(i, BoolToIntMap[First->getOperand(i)]);
  262     Value *IntRetVal = BoolToIntMap[U];

  305   return FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB;
  317         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
  611   unsigned AssignedReg = FuncInfo.ValueMap[I];
  772   MachineBasicBlock *TBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
  773   MachineBasicBlock *FBB = FuncInfo.MBBMap[BI->getSuccessor(1)];
 1175   unsigned AssignedReg = FuncInfo.ValueMap[I];
 1280   unsigned AssignedReg = FuncInfo.ValueMap[I];
 1921   unsigned AssignedReg = FuncInfo.ValueMap[I];

 1534       ValueRotInfo &VRI = ValueRots[std::make_pair(BG.V, RLAmtKey)];

   85   ImmToIdxMap[PPC::LD]   = PPC::LDX;    ImmToIdxMap[PPC::STD]  = PPC::STDX;
   85   ImmToIdxMap[PPC::LD]   = PPC::LDX;    ImmToIdxMap[PPC::STD]  = PPC::STDX;
   86   ImmToIdxMap[PPC::LBZ]  = PPC::LBZX;   ImmToIdxMap[PPC::STB]  = PPC::STBX;
   86   ImmToIdxMap[PPC::LBZ]  = PPC::LBZX;   ImmToIdxMap[PPC::STB]  = PPC::STBX;
   87   ImmToIdxMap[PPC::LHZ]  = PPC::LHZX;   ImmToIdxMap[PPC::LHA]  = PPC::LHAX;
   87   ImmToIdxMap[PPC::LHZ]  = PPC::LHZX;   ImmToIdxMap[PPC::LHA]  = PPC::LHAX;
   88   ImmToIdxMap[PPC::LWZ]  = PPC::LWZX;   ImmToIdxMap[PPC::LWA]  = PPC::LWAX;
   88   ImmToIdxMap[PPC::LWZ]  = PPC::LWZX;   ImmToIdxMap[PPC::LWA]  = PPC::LWAX;
   89   ImmToIdxMap[PPC::LFS]  = PPC::LFSX;   ImmToIdxMap[PPC::LFD]  = PPC::LFDX;
   89   ImmToIdxMap[PPC::LFS]  = PPC::LFSX;   ImmToIdxMap[PPC::LFD]  = PPC::LFDX;
   90   ImmToIdxMap[PPC::STH]  = PPC::STHX;   ImmToIdxMap[PPC::STW]  = PPC::STWX;
   90   ImmToIdxMap[PPC::STH]  = PPC::STHX;   ImmToIdxMap[PPC::STW]  = PPC::STWX;
   91   ImmToIdxMap[PPC::STFS] = PPC::STFSX;  ImmToIdxMap[PPC::STFD] = PPC::STFDX;
   91   ImmToIdxMap[PPC::STFS] = PPC::STFSX;  ImmToIdxMap[PPC::STFD] = PPC::STFDX;
   92   ImmToIdxMap[PPC::ADDI] = PPC::ADD4;
   93   ImmToIdxMap[PPC::LWA_32] = PPC::LWAX_32;
   96   ImmToIdxMap[PPC::LHA8] = PPC::LHAX8; ImmToIdxMap[PPC::LBZ8] = PPC::LBZX8;
   96   ImmToIdxMap[PPC::LHA8] = PPC::LHAX8; ImmToIdxMap[PPC::LBZ8] = PPC::LBZX8;
   97   ImmToIdxMap[PPC::LHZ8] = PPC::LHZX8; ImmToIdxMap[PPC::LWZ8] = PPC::LWZX8;
   97   ImmToIdxMap[PPC::LHZ8] = PPC::LHZX8; ImmToIdxMap[PPC::LWZ8] = PPC::LWZX8;
   98   ImmToIdxMap[PPC::STB8] = PPC::STBX8; ImmToIdxMap[PPC::STH8] = PPC::STHX8;
   98   ImmToIdxMap[PPC::STB8] = PPC::STBX8; ImmToIdxMap[PPC::STH8] = PPC::STHX8;
   99   ImmToIdxMap[PPC::STW8] = PPC::STWX8; ImmToIdxMap[PPC::STDU] = PPC::STDUX;
   99   ImmToIdxMap[PPC::STW8] = PPC::STWX8; ImmToIdxMap[PPC::STDU] = PPC::STDUX;
  100   ImmToIdxMap[PPC::ADDI8] = PPC::ADD8;
  103   ImmToIdxMap[PPC::DFLOADf32] = PPC::LXSSPX;
  104   ImmToIdxMap[PPC::DFLOADf64] = PPC::LXSDX;
  105   ImmToIdxMap[PPC::SPILLTOVSR_LD] = PPC::SPILLTOVSR_LDX;
  106   ImmToIdxMap[PPC::SPILLTOVSR_ST] = PPC::SPILLTOVSR_STX;
  107   ImmToIdxMap[PPC::DFSTOREf32] = PPC::STXSSPX;
  108   ImmToIdxMap[PPC::DFSTOREf64] = PPC::STXSDX;
  109   ImmToIdxMap[PPC::LXV] = PPC::LXVX;
  110   ImmToIdxMap[PPC::LXSD] = PPC::LXSDX;
  111   ImmToIdxMap[PPC::LXSSP] = PPC::LXSSPX;
  112   ImmToIdxMap[PPC::STXV] = PPC::STXVX;
  113   ImmToIdxMap[PPC::STXSD] = PPC::STXSDX;
  114   ImmToIdxMap[PPC::STXSSP] = PPC::STXSSPX;
  117   ImmToIdxMap[PPC::EVLDD] = PPC::EVLDDX;
  118   ImmToIdxMap[PPC::EVSTDD] = PPC::EVSTDDX;
  119   ImmToIdxMap[PPC::SPESTW] = PPC::SPESTWX;
  120   ImmToIdxMap[PPC::SPELWZ] = PPC::SPELWZX;

  677         int UseIdx = SwapMap[&UseMI];
  720         int UseIdx = SwapMap[&UseMI];
  762           int UseIdx = SwapMap[&UseMI];

 6600       TrueReg = RegRewriteTable[TrueReg].first;
 6603       FalseReg = RegRewriteTable[FalseReg].second;
 6611     RegRewriteTable[DestReg] = std::make_pair(TrueReg, FalseReg);

  180   BeginToEnd[Begin] = End;
  181   EndToBegin[End] = Begin;
  188   TryToEHPad[Begin] = EHPad;
  189   EHPadToTry[EHPad] = Begin;
  194   MachineInstr *End = BeginToEnd[Begin];
  271       auto *LoopBottom = BeginToEnd[&MI]->getParent()->getPrevNode();
  350       if (EndToBegin[&MI]->getParent()->getNumber() >= Header->getNumber())
  502       auto *LoopBottom = BeginToEnd[&MI]->getParent()->getPrevNode();
  604       if (EndToBegin[&MI]->getParent()->getNumber() > Header->getNumber())
  662     MachineBasicBlock *Cont = BeginToEnd[EHPadToTry[&MBB]]->getParent();
  662     MachineBasicBlock *Cont = BeginToEnd[EHPadToTry[&MBB]]->getParent();
  686       MachineInstr *Try = &MI, *EndTry = BeginToEnd[Try];
  930         UnwindDestToTryRanges[nullptr].push_back(
  953       UnwindDestToTryRanges[nullptr].push_back(TryRange(RangeBegin, RangeEnd));
  972     for (auto Range : UnwindDestToTryRanges[nullptr])
 1030     MachineInstr *BeginTry = EHPadToTry[EHPad];
 1031     MachineInstr *EndTry = BeginToEnd[BeginTry];
 1181         ScopeTops[MBB.getNumber()] = EndToBegin[&MI]->getParent();
 1184         ScopeTops[MBB.getNumber()] = EHPadToTry[&MBB]->getParent();
 1251         EndToBegin[&MI]->getOperand(0).setImm(int32_t(RetType));
 1323         Stack.push_back(EndToBegin[&MI]->getParent());

  156     BBMap[MBB] = WE;

  212     Reg2Local[Reg] = static_cast<unsigned>(MI.getOperand(1).getImm());

  216         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 1272     MachineBasicBlock *MSucc = FuncInfo.MBBMap[Br->getSuccessor(0)];
 1277   MachineBasicBlock *TBB = FuncInfo.MBBMap[Br->getSuccessor(0)];
 1278   MachineBasicBlock *FBB = FuncInfo.MBBMap[Br->getSuccessor(1)];

  355     return FindMatchingCatches[NumClauses];
  362   FindMatchingCatches[NumClauses] = F;

  394   DepthMap[nullptr] = {0, 0};
  442             OperandToDefMap[&MO] = DefMI;
  452               DepthMap[OperandToDefMap.lookup(&MI.getOperand(1))].OptDepth,
  453               DepthMap[OperandToDefMap.lookup(&MI.getOperand(2))].OptDepth);
  460           RegDefMaps[Register::isVirtualRegister(Reg)][Reg] = &MI;
  464         DepthMap[&MI] = {MIDepth += Latency, MIDepthOpt += Latency};
  547           DepthMap[OperandToDefMap.lookup(&MI->getOperand(4))].Depth;
  549           DepthMap[OperandToDefMap.lookup(&MI->getOperand(1))].Depth,
  550           DepthMap[OperandToDefMap.lookup(&MI->getOperand(2))].Depth);
  722       FalseBBRegRewriteTable[MI.getOperand(0).getReg()] = FalseReg;
  801     FalseBBRegRewriteTable[NewCMOV->getOperand(0).getReg()] = TmpReg;
  844     RegRewriteTable[DestReg] = std::make_pair(Op1Reg, Op2Reg);

  102   MemOpDiscriminators[diToLocation(ReferenceDI)] = 0;

  608   Converters[{MaskDomain, TargetOpcode::PHI}] =
  611   Converters[{MaskDomain, TargetOpcode::IMPLICIT_DEF}] =
  614   Converters[{MaskDomain, TargetOpcode::INSERT_SUBREG}] =
  617   Converters[{MaskDomain, TargetOpcode::COPY}] =
  621     Converters[{MaskDomain, From}] = new InstrReplacerDstCOPY(From, To);
  641     Converters[{MaskDomain, From}] = new InstrReplacer(From, To);

  838         FuncInfo.MBBMap[I->getParent()] == FuncInfo.MBB) {
 1628   MachineBasicBlock *TrueMBB = FuncInfo.MBBMap[BI->getSuccessor(0)];
 1629   MachineBasicBlock *FalseMBB = FuncInfo.MBBMap[BI->getSuccessor(1)];

29695       Op1Reg = RegRewriteTable[Op1Reg].first;
29698       Op2Reg = RegRewriteTable[Op2Reg].second;
29707     RegRewriteTable[DestReg] = std::make_pair(Op1Reg, Op2Reg);
31138           DefRegs[MOp.getReg()] = true;

  320   return InstrPos[&Last] - InstrPos[&First];
  320   return InstrPos[&Last] - InstrPos[&First];
  480     InstrPos[&MI] = Pos += 2;
  483       LEAs[getMemOpKey(MI, 1)].push_back(const_cast<MachineInstr *>(&MI));
  535       InstrPos[DefMI] = InstrPos[&MI] - 1;
  535       InstrPos[DefMI] = InstrPos[&MI] - 1;
  538       assert(((InstrPos[DefMI] == 1 &&
  540               InstrPos[DefMI] >
  541                   InstrPos[&*std::prev(MachineBasicBlock::iterator(DefMI))]) &&

  720       ++SuccCounts[CondBr->getOperand(0).getMBB()];
  787       int &SuccCount = SuccCounts[&Succ];
 2138     AddrRegToHardenedReg[Op->getReg()] = TmpReg;
 2622   unsigned &HardenedTargetReg = AddrRegToHardenedReg[OldTargetReg];

  139     OutOffset[&MBB] = INT32_MAX;

  540     return FuncInfo.InvokeStateMap[II];
  778     auto &BBColors = BlockColors[CS->getParent()];

  900     ResolvedValues[&PN] = V;

  889         for (Instruction *RI : OpcodeInstMap[Instruction::Ret])
 1189     unsigned &NumRetAA = NumReturnedValuesPerKnownAA[CB];
 3674           FreesForMalloc[&I].insert(
 4675   auto &ReadOrWriteInsts = InfoCache.FuncRWInstsMap[&F];
 4676   auto &InstOpcodeMap = InfoCache.FuncInstOpcodeMap[&F];
 4706       InstOpcodeMap[I.getOpcode()].push_back(&I);

  227     GVDependencies[Caller].insert(Callee);

 1393   InsertedScalarizedValues[GV] = FieldGlobals;
 1428     PHINode *FieldPN = cast<PHINode>(InsertedScalarizedValues[PN][FieldNo]);

 1955             ExportedFunctions[F->getName()].Linkage == CFL_Definition;
 1969     GlobalTypeMembers[&GO] = GTM;
 1972       auto &Info = TypeIdInfo[Type->getOperand(1)];
 2052         MetadataByGUID[GlobalValue::getGUID(TypeId->getString())].push_back(

  485       if (VisitedMap[*SI])
  487       VisitedMap[*SI] = true;

  746       BlockWeights[&BB] = Weight.get();
 1044   const BasicBlock *EC = EquivalenceClass[BB1];
 1097     EquivalenceClass[BB1] = BB1;
 1322     if (!Predecessors[B1].empty())
 1327         Predecessors[B1].push_back(B2);
 1332     if (!Successors[B1].empty())
 1337         Successors[B1].push_back(B2);
 1382     if (Header && BlockWeights[BB] > BlockWeights[Header]) {
 1382     if (Header && BlockWeights[BB] > BlockWeights[Header]) {
 1383       BlockWeights[Header] = BlockWeights[BB];
 1383       BlockWeights[Header] = BlockWeights[BB];
 1423     if (BlockWeights[BB]) {
 1452                             {static_cast<uint32_t>(BlockWeights[BB])}));

  790     VTableBits *&BitsPtr = GVToBits[&GV];
 1815         MetadataByGUID[GlobalValue::getGUID(TypeId->getString())].push_back(
 1936     NameByGUID[GlobalValue::getGUID(P.first)].push_back(P.first);

  666       NewInsts[PHI] = PHINode::Create(IndexType, PHI->getNumIncomingValues(),
  680       Value *V = NewInsts[CI->getOperand(0)];
  681       NewInsts[CI] = V;
  685       Value *Index = NewInsts[GEP->getOperand(1)] ? NewInsts[GEP->getOperand(1)]
  685       Value *Index = NewInsts[GEP->getOperand(1)] ? NewInsts[GEP->getOperand(1)]
  691           NewInsts[GEP->getOperand(0)]->getType()->getScalarSizeInBits()) {
  693             Index, NewInsts[GEP->getOperand(0)]->getType(),
  697       auto *Op = NewInsts[GEP->getOperand(0)];
  699         NewInsts[GEP] = Index;
  701         NewInsts[GEP] = Builder.CreateNSWAdd(
  718       PHINode *NewPhi = static_cast<PHINode *>(NewInsts[PHI]);

 1047     if ((EltPHI = ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)]) == nullptr) {
 1076           if (Value *Res = ExtractedVals[LoweredPHIRecord(InPHI, Offset, Ty)]) {
 1110       ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)] = EltPHI;

 2043               ? NewBCs[CastSrcTy]
 2046         NewBCs[CastSrcTy] = NewBC;

 1339   ProcessedAllocas[&AI] = IsInteresting;
 2604         ProcessedAllocas[AI] = false;
 3033     AllocaToSVDMap[Desc.AI] = &Desc;
 3042     ASanStackVariableDescription &Desc = *AllocaToSVDMap[APC.AI];
 3171       const ASanStackVariableDescription &Desc = *AllocaToSVDMap[APC.AI];

  702       DFSF.ValShadowMap[&*ValAI] = &*ShadowAI;
  920       UnwrappedFnMap[&F] = &F;
 1063   ValShadowMap[I] = Shadow;
 1454     DFSF.AllocaShadowMap[&I] = IRB.CreateAlloca(DFSF.DFS.ShadowTy);

  791           EdgeToCounter[{&BB, nullptr}] = Edges++;
  794             EdgeToCounter[{&BB, Succ}] = Edges++;

  265     for (auto &Cand : LoopToCandidates[&L]) {

  270       ValToPoison[OldPHI] = NewPHI;
  298       ValToPoison[&I] = buildOrChain(B, Checks);
  306       auto *NewPHI = cast<PHINode>(ValToPoison[OldPHI]);

 1270   BBState &MyStates = BBStates[BB];
 1291                     << BBStates[BB] << "\n"
 1324   LLVM_DEBUG(dbgs() << "\nFinal State:\n" << BBStates[BB] << "\n");
 1364       Releases[Inst] = S.GetRRInfo();
 1405   BBState &MyStates = BBStates[BB];
 1426                     << BBStates[BB] << "\n"
 1444                     << BBStates[BB] << "\n\n");
 1446   LLVM_DEBUG(dbgs() << "Final State:\n" << BBStates[BB] << "\n");
 1466   BBState &MyStates = BBStates[EntryBB];
 1482         BBStates[CurrBB].addSucc(SuccBB);
 1483         BBState &SuccStates = BBStates[SuccBB];
 1490         BBStates[CurrBB].addSucc(SuccBB);
 1491         BBStates[SuccBB].addPred(CurrBB);
 1506     BBState &MyStates = BBStates[&ExitBB];
 1516       BBState::edge_iterator PE = BBStates[PredStack.back().first].pred_end();
 1520           PredStack.push_back(std::make_pair(BB, BBStates[BB].pred_begin()));
 1669           const BBState &NRRBBState = BBStates[NewRetainRelease->getParent()];
 1700                 const BBState &RIPBBState = BBStates[RIP->getParent()];
 1741           const BBState &NRRBBState = BBStates[NewReleaseRetain->getParent()];
 1757                 const BBState &RIPBBState = BBStates[RIP->getParent()];

  182   CachedResults[ValuePairTy(A, B)] = Result;

  236       InstInfo[&I].Block = &BBInfo.second;
  665   InstInfo[NewTerm].Live = true;

  130         DivMap[DivRemMapKey(true, I.getOperand(0), I.getOperand(1))] = &I;
  132         DivMap[DivRemMapKey(false, I.getOperand(0), I.getOperand(1))] = &I;

  379     valueNumbering[C] = e;
  385       valueNumbering[C] = ValNum.first;
  392       valueNumbering[C] =  nextValueNumber;
  400         valueNumbering[C] = nextValueNumber;
  408           valueNumbering[C] = nextValueNumber;
  414       valueNumbering[C] = v;
  450       valueNumbering[C] = nextValueNumber;
  455       valueNumbering[C] = nextValueNumber;
  462         valueNumbering[C] = nextValueNumber;
  468     valueNumbering[C] = v;
  471     valueNumbering[C] = nextValueNumber;
 1752     BlockRPONumber[BB] = NextBlockNumber++;
 2020       ++SwitchEdges[SI->getSuccessor(i)];
 2302     if (BlockRPONumber[P] >= BlockRPONumber[CurrentBlock] &&
 2302     if (BlockRPONumber[P] >= BlockRPONumber[CurrentBlock] &&

  174     VNtoScalars[{V, InvalidVN}].push_back(I);
  189       VNtoLoads[{V, InvalidVN}].push_back(Load);
  209     VNtoStores[{VN.lookupOrAdd(Ptr), VN.lookupOrAdd(Val)}].push_back(Store);
  231       VNtoCallsScalars[Entry].push_back(Call);
  233       VNtoCallsLoads[Entry].push_back(Call);
  235       VNtoCallsStores[Entry].push_back(Call);
  271       DFSNumber[BB] = ++BBI;
  274         DFSNumber[&Inst] = ++I;
  789         InValue[V[i]->getParent()].push_back(std::make_pair(VN, V[i]));
 1055         DFSNumber[Repl] = DFSNumber[Last]++;
 1055         DFSNumber[Repl] = DFSNumber[Last]++;

  494     uint32_t e = ExpressionNumbering[exp];
  502         HashNumbering[H] = e;
  503         ExpressionNumbering[exp] = e;

 1034     ExtendKindMap[OrigPhi] = WI.IsSigned ? SignExtended : ZeroExtended;
 1511     ExtendKindMap[NarrowUse] = SignExtended;
 1513     ExtendKindMap[NarrowUse] = ZeroExtended;
 1687   ExtendKindMap[DU.NarrowUse] = WideAddRec.second;

  656     (*InferredAddrSpace)[V] = UninitializedAddressSpace;
  670     (*InferredAddrSpace)[V] = NewAS.getValue();

 2004     ValueMapping[PN] = NewPN;
 2013     ValueMapping[&*BI] = New;
 2080     SSAUpdate.AddAvailableValue(NewBB, ValueMapping[&I]);
 2322     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
 2342       ValueMapping[&*BI] = IV;
 2348       ValueMapping[&*BI] = New;
 2400     SSAUpdate.AddAvailableValue(PredBB, ValueMapping[&I]);

  285             PossibleRedIdx[PossibleReds[i].getPHI()] = i;
  590         IVToIncMap[&*I] = IncSCEV->getValue()->getSExtValue();
 1555       if (PossibleRedIter[PossibleReds[i][j]] != 0) {

  193       RPO[*I] = Current++;
  198         if (L.contains(Succ) && !LI.isLoopHeader(Succ) && RPO[BB] > RPO[Succ])
  198         if (L.contains(Succ) && !LI.isLoopHeader(Succ) && RPO[BB] > RPO[Succ])

  205     Root[I] = ++DFSNum;
  213           Root[I] = std::min(Root.lookup(I), Root.lookup(Op));
  227       ValueToComponent[I] = ComponentID;
 2068     AdditionalUsers[To].insert(User);
 2104     PredicateToUsers[PBranch->Condition].insert(I);
 2106     PredicateToUsers[PAssume->Condition].insert(I);
 2286   ValueToClass[I] = NewClass;
 2426   ValueToExpression[I] = E;
 2564   InstrDFS[Op] = InstrToDFSNum(ExistingValue);
 2566   TempToBlock[Op] = BB;
 2567   RealToTemp[ExistingValue] = Op;
 2837     TempToBlock[ValuePHI] = PHIBlock;
 2869   MemoryAccessToClass[MSSA->getLiveOnEntryDef()] =
 2881         MemoryAccessToClass[&Def] = TOPClass;
 2908       ValueToClass[&I] = TOPClass;
 2980     InstrDFS[MemPhi] = End++;
 2990       InstrDFS[&I] = 0;
 2997     InstrDFS[&I] = End++;
 3071   MemoryPhiState[MP] = NewState;
 3099       InstrDFS[I] = 0;
 3430     RPOOrdering[Node] = ++Counter;
 3644       UseCounts[Def] = UseCount;
 3856     ReachablePredCount[KV.getEnd()]++;
 4031             auto &UseCount = UseCounts[U->get()];
 4066           auto &LeaderUseCount = UseCounts[DominatingLeader];
 4073             unsigned &IIUseCount = UseCounts[II];

  171     ValueRankMap[&Arg] = ++Rank;
  185         ValueRankMap[&I] = ++BBRank;
  192     if (isa<Argument>(V)) return ValueRankMap[V];   // Function argument.
  196   if (unsigned Rank = ValueRankMap[I])
  203   unsigned Rank = 0, MaxRank = RankMap[I->getParent()];
  216   return ValueRankMap[I] = Rank;

 1998     CurrentIncomingValues[OrigRootPhi.getIncomingValue(i)] =

  979   LatticeVal &IV = ValueState[&I];
 1003   LatticeVal &IV = ValueState[&I];
 1065   if (ValueState[&I].isOverdefined()) return;
 1094       !ValueState[&I].isConstant())
 1103   if (ValueState[&I].isOverdefined()) return;
 1157   LatticeVal &IV = ValueState[&I];
 1204       if (ValueState[I].isOverdefined())
 1214         mergeInValue(ValueState[I], I, getValueState(CopyOf));
 1223         mergeInValue(ValueState[I], I, getValueState(CopyOf));
 1230         mergeInValue(ValueState[I], I, getValueState(CopyOf));
 1239       LatticeVal &IV = ValueState[I];
 1340           pushToWorkList(ValueState[&*AI], &*AI);

 1021     uint64_t &Size = PHIOrSelectSizes[&I];
 3768                         auto &StoreOffsets = SplitOffsetsMap[SI];
 3843     auto &Offsets = SplitOffsetsMap[LI];
 3966     auto &Offsets = SplitOffsetsMap[SI];

  326   CostSavingsMap[&PN] = TotalMatCost - TotalFoldedCost;
  645         IncomingValueMap[OpPN->getIncomingBlock(i)] = OpPN->getIncomingValue(i);

  772   BBPredicates &Preds = Predicates[Node->getEntry()];
  780   BBPredicates &Preds = Predicates[Node->getEntry()];
  851   LoopEnd = Loops[Node->getEntry()];

  310     if (Visited[CI->getParent()] != ESCAPED) {

  134     MD[SP->getUnit()].reset(SP->getUnit());
  135     MD[SP->getType()].reset(SP->getType());
  136     MD[SP->getFile()].reset(SP->getFile());
  140       MD[SP].reset(SP);
  194       VMap.MD()[ISP].reset(ISP);
  197     VMap.MD()[CU].reset(CU);
  200     VMap.MD()[Type].reset(Type);

  340       BaseMemAddrs[&BB].insert(Base);
 1357     uint64_t ExitFreq = ExitWeights[TI->getSuccessor(i)].getFrequency();
 1431           BlockFrequency &BF = ExitWeights[*SI];

   72           Value *&V = Loads[PN->getIncomingBlock(i)];

  688                isa<ConstantTokenNone>(FuncletUnwindMap[CleanupPad]));
  689         FuncletUnwindMap[CleanupPad] =
  735         FuncletUnwindMap[NewCatchSwitch] = UnwindDestToken;
  885       MDNode *NewMD = MDMap[M];
  900       MDNode *NewMD = MDMap[M];

  604     NewLoops[L] = L;

  349       PrevItValueMap[New] = (It == 1 ? *BB : LastValueMap[*BB]);
  353         PrevItValueMap[VI->second] =

  313   NewLoops[ParentLoop] = ParentLoop;
  315     NewLoops[L] = ParentLoop;
  398     Loop *NewLoop = NewLoops[L];

  187     GroupToScope[&Group] = MDB.createAnonymousAliasScope(Domain);
  190       PtrToGroup[RtPtrChecking->getPointerInfo(PtrIdx).PointerValue] = &Group;

  213         InstNumbers[&BBI] = InstNo++;
  588         BBNumbers[&BB] = ID++;
  845   PHINode *&PN = NewPhiNodes[std::make_pair(BBNumbers[BB], AllocaNo)];

   86     if (ValueMapping[PHI->getIncomingBlock(i)] !=
  359     UsesByBlock[User->getParent()].push_back(User);
  423           ReplacedLoads[L] = StoredValue;
  455     ReplacedLoads[ALoad] = NewVal;
  469       Value *NewVal = ReplacedLoads[User];

 2238         TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB);
 2256           TranslateMap[&*BBI] = V;
 2263           TranslateMap[&*BBI] = N;

  633   (void)G.Info[&FirstN];
  646     auto &D = G.Info[WE.N];
  682       auto &D = Info[N];
  701     auto &D = G.Info[N];
  717       assert(G.Info[Old].ID > D.ID && "Expected a forward reference");

 1102     WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, Cost);
 1115           WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, Cost);
 1117           WideningDecisions[std::make_pair(I, VF)] = std::make_pair(W, 0);
 3125       MissingVals[UI] = EndValue;
 3150       MissingVals[UI] = Escape;

 4620     ExtraScheduleDataMap[I][S.OpValue] = SD;
 4687     ScheduleData *SD = ScheduleDataMap[I];
 4690       ScheduleDataMap[I] = SD;

  196   State->CFG.VPBB2IRBB[this] = NewBB;

   96     VPValue *VPVal = IRDef2VPValue[Phi];
  234     IRDef2VPValue[Inst] = NewVPInst;

  339     auto &TSD = ThreadStacks[E.TId];
  362         auto &TPD = ThreadPathData[E.TId][InternedPath];

  443     return M[ ObjCSummaryKey(S) ];

 1023   WeakUseVector &Uses = WeakObjectUses[WeakObjectProfileTy(E)];

10833         Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second

  554     EventInfo &info = Events[&EVENT::Tag];
  560     EventInfo &info = Events[&EVENT::Tag];

  151         ActionOnProp[I->PropD->getIdentifier()] = kind;

  503       ParsedComments[D->getCanonicalDecl()] = FC;
 1041   MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
 1444   assert(!TemplateOrInstantiation[Inst] &&
 1446   TemplateOrInstantiation[Inst] = TSI;
 2622   ObjCImpls[IFaceD] = ImplD;
 2629   ObjCImpls[CatD] = ImplD;
 8403     LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
10317   ParamIndices[D] = index;
10441       auto &NodeOrVector = (*Parents)[MapNode];

 7792   ImportedDecls[FromContext.getTranslationUnitDecl()] =

   72   DeclList &Decls = LookupTable[DC][ND->getDeclName()];
   78   DeclList &Decls = LookupTable[DC][ND->getDeclName()];

   65   IsVirtBaseAndNumberNonVirtBases Subobjects = ClassSubobjects[BaseType];
  607       = ++SubobjectCount[cast<CXXRecordDecl>(RD->getCanonicalDecl())];

 1875   StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];

 1460       Captures[C->getCapturedVar()] = *Field;

  395     PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
  401       PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;

  104     GlobalIndices[VD] = *Index;
  116     GlobalIndices[VD] = *Idx;
  152       GlobalIndices[P] = *Idx;

  180     return ++TagManglingNumbers[TD->getIdentifier()];

  199       discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];

  102     CachedLinkageInfo[makeCacheKey(ND, Kind)] = Info;

  228       discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
  842           TemplateArgBackReferences[ND] =
  845           TemplateArgStrings[ND] =
 1786       FunArgBackReferences[TypePtr] = Size;

   40     if (M[POE->getSyntacticForm()])
   44     M[POE->getSyntacticForm()] = S;
   50       M[*I] = S;
   59     M[BCO->getCommon()] = S;
   62     M[BCO->getCond()] = S;
   65     M[BCO->getTrueExpr()] = S;
   68     M[BCO->getFalseExpr()] = S;
   80     if (OVMode == OV_Transparent || !M[OVE->getSourceExpr()]) {
   81       M[OVE->getSourceExpr()] = S;

  189       CharUnits BaseOffset = SubobjectOffsets[std::make_pair(MD->getParent(),
  200         SubobjectLayoutClassOffsets[std::make_pair(OverriderRD,
  203       OverriderInfo& Overrider = OverridersMap[std::make_pair(MD, BaseOffset)];
  341   SubobjectOffsets[std::make_pair(RD, SubobjectNumber)] = Base.getBaseOffset();
  342   SubobjectLayoutClassOffsets[std::make_pair(RD, SubobjectNumber)] =
 1140       VTableThunks[VTableIndex + 1].This = ThisAdjustment;
 1307       VTableThunks[Components.size()].Return = ReturnAdjustment;
 1639     VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()];
 1672         MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)]
 1674         MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)]
 1677         MethodVTableIndices[MD] = MI.VTableIndex - AddressPoint;
 2174       IndicesMap[MethodVTableIndices[MD]] = MethodName;
 2471       VTableThunks[Components.size()] = TI;
 2513         MethodVFTableLocations[GlobalDecl(DD, Dtor_Deleting)] = Loc;
 2515         MethodVFTableLocations[MD] = Loc;

  668   Optional<Stmt *> &Val = Bodies[D];
  812   Optional<Stmt *> &Val = Bodies[D];

 3194   LabelMap[L->getDecl()] = JumpTarget(LabelBlock, ScopePos);
 5088               DeclMap[cast<DeclStmt>(stmt)->getSingleDecl()] = P;
 5093                 DeclMap[var] = P;
 5099                 DeclMap[var] = P;
 5106                 DeclMap[var] = P;
 5113                 DeclMap[var] = P;
 5120                 DeclMap[var] = P;

   46   ReachableSet &DstReachability = reachable[Dst->getBlockID()];

   38         (*SM)[X] = B;
   56     CFGBlock *&Entry = SM[CS->getStmt()];
   68     SM[Label] = B;
   74     SM[Term] = B;

  203   std::unique_ptr<CallGraphNode> &Node = FunctionMap[F];

  412   bool InAssignment = LV.inAssignment[DR];
  531     getImpl(impl).runOnBlock(*it, getImpl(impl).blocksEndToLiveness[*it], &obs);
  674     for (auto S : blocksEndToLiveness[I].liveStmts) {

 1409     Types[Context.CharTy] = "%c";
 1410     Types[Context.BoolTy] = "%d";
 1411     Types[Context.SignedCharTy] = "%hhd";
 1412     Types[Context.UnsignedCharTy] = "%hhu";
 1413     Types[Context.IntTy] = "%d";
 1414     Types[Context.UnsignedIntTy] = "%u";
 1415     Types[Context.LongTy] = "%ld";
 1416     Types[Context.UnsignedLongTy] = "%lu";
 1417     Types[Context.LongLongTy] = "%lld";
 1418     Types[Context.UnsignedLongLongTy] = "%llu";
 1419     Types[Context.ShortTy] = "%hd";
 1420     Types[Context.UnsignedShortTy] = "%hu";
 1421     Types[Context.VoidPtrTy] = "%p";
 1422     Types[Context.FloatTy] = "%f";
 1423     Types[Context.DoubleTy] = "%f";
 1424     Types[Context.LongDoubleTy] = "%Lf";
 1425     Types[Context.getPointerType(Context.CharTy)] = "%s";
 1426     Types[Context.getPointerType(Context.getConstType(Context.CharTy))] = "%s";
 1461                              ? Types[Context.VoidPtrTy]

   70     DebugPrefixMap[KV.first] = KV.second;
  475   DIFileCache[FileName.data()].reset(F);
 1368   StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
 1499     TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
 1507     TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
 1639   SPCache[Method->getCanonicalDecl()].reset(SP);
 2074   TypeCache[TyPtr].reset(Res);
 2149   TypeCache[TyPtr].reset(Res);
 2254   RegionMap[Ty->getDecl()].reset(FwdDecl);
 2285   RegionMap[Ty->getDecl()].reset(FwdDecl);
 2465   TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
 2469   RegionMap[Ty->getDecl()].reset(RealDecl);
 2959   TypeCache[TyPtr].reset(Res);
 3104   TypeCache[QTy.getAsOpaquePtr()].reset(Res);
 3184   RegionMap[Ty->getDecl()].reset(RealDecl);
 3185   TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
 3620     DeclCache[D->getCanonicalDecl()].reset(SP);
 4440   DeclCache[D->getCanonicalDecl()].reset(GVE);
 4505   auto &GV = DeclCache[VD];
 4597   auto &VH = NamespaceAliasCache[&NA];
 4732     if (auto MD = TypeCache[RT])

  224   if (llvm::Constant *ExistingGV = StaticLocalDeclMap[&D])
 1100   llvm::GlobalVariable *&CacheEntry = InitializerConstants[&D];
 1467           NRVOFlags[&D] = NRVOFlag.getPointer();
 2407         CalleeDestructedParamCleanups[cast<ParmVarDecl>(&D)] =

  522   DelayedCXXInitPosition[D] = ~0U;

 3046   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
 3085     Protocols[PD->getIdentifier()] = Entry;
 3093   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
 6864   llvm::GlobalVariable *&Entry = Protocols[PD->getIdentifier()];
 6906   llvm::GlobalVariable *Entry = Protocols[PD->getIdentifier()];
 6971     Protocols[PD->getIdentifier()] = Entry;
 7369   llvm::GlobalVariable *&Entry = SuperClassReferences[ID->getIdentifier()];
 7394   llvm::GlobalVariable * &Entry = MetaClassReferences[ID->getIdentifier()];
 7686   llvm::GlobalVariable * &Entry = EHTypeReferences[ID->getIdentifier()];

  151   EnqueuedBlockMap[E].InvokeFunc = InvokeF;
  152   EnqueuedBlockMap[E].BlockArg = Block;
  153   EnqueuedBlockMap[E].Kernel = nullptr;
  157   return EnqueuedBlockMap[getBlockExpr(E)].InvokeFunc;
  172   if (EnqueuedBlockMap[Block].Kernel) {
  173     return EnqueuedBlockMap[Block];
  177       CGF, EnqueuedBlockMap[Block].InvokeFunc,
  178       EnqueuedBlockMap[Block].BlockArg->stripPointerCasts());
  184   EnqueuedBlockMap[Block].Kernel = F;
  185   return EnqueuedBlockMap[Block];

 1676     OpenMPDebugLocMap[Loc.getRawEncoding()] = OMPDebugLoc;
10690           Pos = ParamPositions[FD];
10694           Pos = ParamPositions[PVD];
10705           Pos = ParamPositions[FD];
10710           Pos = ParamPositions[PVD];
10728           Pos = ParamPositions[FD];
10732           Pos = ParamPositions[PVD];
10744                     ParamPositions[StridePVD->getCanonicalDecl()]);

  226   CGBitFieldInfo &Info = BitFields[FD->getCanonicalDecl()];
  304     Fields[Field->getCanonicalDecl()] = 0;
  682         Fields[Member->FD->getCanonicalDecl()] = FieldTypes.size() - 1;

 1095     if (llvm::Value *NRVOFlag = NRVOFlags[S.getNRVOCandidate()])
 2364       EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
 2439       VLASizeMap[VAT->getSizeExpr()] = ExprArg;

  295       llvm::Value *Val = VLASizeMap[VAT->getSizeExpr()];

  124   VMap.MD()[DIS].reset(NewDIS);

  979           VLASizeMap[VAT->getSizeExpr()] = ExprArg;
 1117       SizeArguments[Param] = Implicit;
 1824     llvm::Value *vlaSize = VLASizeMap[type->getSizeExpr()];
 1849   llvm::Value *VlaSize = VLASizeMap[Vla->getSizeExpr()];

  362           CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
  364           CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
 1861     EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);

 2544     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
 5016   if (llvm::Constant *Slot = MaterializedGlobalTemporaryMap[E])
 5096   MaterializedGlobalTemporaryMap[E] = CV;
 5766   llvm::Metadata *&InternalId = Map[T.getCanonicalType()];

  611     return StaticLocalDeclMap[D];
  615     StaticLocalDeclMap[D] = C;
  623     return StaticLocalDeclGuardMap[D];
  627     StaticLocalDeclGuardMap[D] = C;

  187       CounterMap[D->getBody()] = NextCounter++;
  198       CounterMap[S] = NextCounter++;
  392     CountMap[D->getBody()] = BodyCount;
  404     CountMap[D->getBody()] = BodyCount;
  411     CountMap[D->getBody()] = BodyCount;
  418     CountMap[D->getBody()] = BodyCount;
  448     CountMap[S] = BlockCount;
  476     CountMap[S->getBody()] = CurrentCount;
  487     CountMap[S->getCond()] = CondCount;
  500     CountMap[S->getBody()] = BodyCount;
  508     CountMap[S->getCond()] = CondCount;
  525     CountMap[S->getBody()] = BodyCount;
  534       CountMap[S->getInc()] = IncCount;
  542       CountMap[S->getCond()] = CondCount;
  563     CountMap[S->getBody()] = BodyCount;
  571     CountMap[S->getInc()] = IncCount;
  577     CountMap[S->getCond()] = CondCount;
  590     CountMap[S->getBody()] = BodyCount;
  626     CountMap[S] = CaseCount;
  641     CountMap[S->getThen()] = ThenCount;
  648       CountMap[S->getElse()] = ElseCount;
  671     CountMap[S] = CatchCount;
  683     CountMap[E->getTrueExpr()] = TrueCount;
  688     CountMap[E->getFalseExpr()] = FalseCount;
  702     CountMap[E->getRHS()] = RHSCount;
  714     CountMap[E->getRHS()] = RHSCount;

  624     llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(Ty)];

  255       FileIDMapping[SM.getFileID(Loc)] = std::make_pair(Mapping.size(), Loc);

 2564       UnorderedInits[CXXThreadLocalInitVars[I]->getCanonicalDecl()] =

  449         TypeDescriptorTypeMap[TypeInfoString.size()];
 2456     GI = &ThreadLocalGuardVariableMap[D.getDeclContext()];
 2458     GI = &GuardVariableMap[D.getDeclContext()];
 2469     GuardNum = ThreadSafeGuardNumMap[D.getDeclContext()]++;

  142         Detect(from, ToScopes[LS]);
  146         Detect(from, ToScopes[SC]);

  565   ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter);

   62     auto &ArgUses = ExpansionToArgMap[ExpLoc.getRawEncoding()];

 1545         CI.KnownModules[II] = CI.getPreprocessor()
 1753           KnownModules[Path[0].first] = nullptr;
 1767         KnownModules[Path[0].first] = nullptr;
 1812         KnownModules[Path[0].first] = nullptr;
 1835       KnownModules[Path[0].first] = nullptr;
 1841       KnownModules[Path[0].first] = nullptr;

  178     FieldOffsets[*F] = Known->second.FieldOffsets[NumFields];

  902   ReferencedIvars[const_cast<ObjCInterfaceDecl *>(ClassDecl)].insert(D);
 3757     return IvarGroupNumber[IV];
 3775   return IvarGroupNumber[IV];
 3815         GroupRecordType[std::make_pair(CDecl, GroupNo)] =
 3824     GroupRecordType[std::make_pair(CDecl, GroupNo)] =

 5774   Result += MethodInternalNames[*MethodBegin];
 5784     Result += MethodInternalNames[*MethodBegin];

  777       TypeSubstitutions[T.getTypePtr()] = Number;

  620         InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
  638       InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
 1006   InferredModuleAllowedBy[Result] = ModuleMapFile;
 1109   UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
 1242   InferredModuleAllowedBy[M] = ModMap;

   72   MacroState &StoredMD = CurSubmoduleState->Macros[II];
  106   MacroState &StoredMD = CurSubmoduleState->Macros[II];
  153   auto &LeafMacros = LeafModuleMacros[II];

  346   MacroDefinitions[Macro] = Def;

  890           REVERTIBLE_TYPE_TRAIT(__is_abstract);
  891           REVERTIBLE_TYPE_TRAIT(__is_aggregate);
  892           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
  893           REVERTIBLE_TYPE_TRAIT(__is_array);
  894           REVERTIBLE_TYPE_TRAIT(__is_assignable);
  895           REVERTIBLE_TYPE_TRAIT(__is_base_of);
  896           REVERTIBLE_TYPE_TRAIT(__is_class);
  897           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
  898           REVERTIBLE_TYPE_TRAIT(__is_compound);
  899           REVERTIBLE_TYPE_TRAIT(__is_const);
  900           REVERTIBLE_TYPE_TRAIT(__is_constructible);
  901           REVERTIBLE_TYPE_TRAIT(__is_convertible);
  902           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
  903           REVERTIBLE_TYPE_TRAIT(__is_destructible);
  904           REVERTIBLE_TYPE_TRAIT(__is_empty);
  905           REVERTIBLE_TYPE_TRAIT(__is_enum);
  906           REVERTIBLE_TYPE_TRAIT(__is_floating_point);
  907           REVERTIBLE_TYPE_TRAIT(__is_final);
  908           REVERTIBLE_TYPE_TRAIT(__is_function);
  909           REVERTIBLE_TYPE_TRAIT(__is_fundamental);
  910           REVERTIBLE_TYPE_TRAIT(__is_integral);
  911           REVERTIBLE_TYPE_TRAIT(__is_interface_class);
  912           REVERTIBLE_TYPE_TRAIT(__is_literal);
  913           REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
  914           REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
  915           REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
  916           REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
  917           REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
  918           REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
  919           REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
  920           REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
  921           REVERTIBLE_TYPE_TRAIT(__is_object);
  922           REVERTIBLE_TYPE_TRAIT(__is_pod);
  923           REVERTIBLE_TYPE_TRAIT(__is_pointer);
  924           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
  925           REVERTIBLE_TYPE_TRAIT(__is_reference);
  926           REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
  927           REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
  928           REVERTIBLE_TYPE_TRAIT(__is_same);
  929           REVERTIBLE_TYPE_TRAIT(__is_scalar);
  930           REVERTIBLE_TYPE_TRAIT(__is_sealed);
  931           REVERTIBLE_TYPE_TRAIT(__is_signed);
  932           REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
  933           REVERTIBLE_TYPE_TRAIT(__is_trivial);
  934           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
  935           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
  936           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
  937           REVERTIBLE_TYPE_TRAIT(__is_union);
  938           REVERTIBLE_TYPE_TRAIT(__is_unsigned);
  939           REVERTIBLE_TYPE_TRAIT(__is_void);
  940           REVERTIBLE_TYPE_TRAIT(__is_volatile);

  713     unsigned LabelScope = LabelAndGotoScopes[TheLabel->getStmt()];

  153     WeakObjectUses[WeakObjectProfileTy(Msg->getInstanceReceiver(), Prop)];

 1473     auto &Diags = S.DeviceDeferredDiags[Fn];
 1533     S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
 2202     OpenCLDeclExtMap[FD].insert(I.str());

  693       DeviceCallGraph[Caller].insert({Callee, Loc});

 1167   SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
 1322         auto &OverloadSet = OverloadMap[std::make_pair(
 7505       KnownMethods[M->getSelector()] =

 4978       Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
 4980       Info.AllBaseFields[Member->getAnyMember()->getCanonicalDecl()] = Member;

 1751     MethodMap[MD->getSelector()] = MD;
 1756     const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
 3917       const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
 3935         InsMap[Method->getSelector()] = Method;
 3941       const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
 3959         ClsMap[Method->getSelector()] = Method;

 1066         LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
 1218       LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;

 3645     ShadowMaps.back()[ND->getDeclName()].push_back(ND);

 1709       PropMap[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] =
 1729       PropMap[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] =
 1744           SuperPropMap[std::make_pair(Prop->getIdentifier(),
 1751             PropMap[std::make_pair(Prop->getIdentifier(),
 1870         SuperPropMap[std::make_pair(Prop->getIdentifier(),
 2029         if ((*LazyMap)[std::make_pair(PropDecl->getIdentifier(),
 2032         PropMap[std::make_pair(PropDecl->getIdentifier(),
 2118     PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
 2121       PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;

 1091       DSAInfo &Data = getTopOfStack().SharingMap[PrivateCopy->getDecl()];
 1658     DeviceCallGraph[Caller].insert({Callee, Loc});
 1700       DeviceCallGraph[Caller].insert({Callee, Loc});
 2828         VarsWithInheritedDSA[VD] = E;
 4224       VarDecl *PrivateVD = DeclToCopy[VD];
 4790             Diag(AlignedArgs[CanonPVD]->getExprLoc(),
 4795           AlignedArgs[CanonPVD] = E;
 4861             Diag(LinearArgs[CanonPVD]->getExprLoc(),
 4871             Diag(UniformedArgs[CanonPVD]->getExprLoc(),
 4876           LinearArgs[CanonPVD] = E;
15614       PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
15630       PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] =
15644     PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second;
15866       PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] =
15882       PreviousRedeclTypes[PrevDMDInScope->getType().getCanonicalType()] =

 3414             DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}];
 3441         SuppressedDiagnostics[Specialization->getCanonicalDecl()]

 1182   auto &Lex = LexicalDecls[DC];
 2061     PriorGeneration = IdentifierGeneration[&II];
 3138         F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
 3620           OpenCLDeclExtMap[Decl].insert(Ext);
 7844       auto &Merged = KeyDecls[D->getCanonicalDecl()];
 8088     Decls[ND->getDeclName()].push_back(ND);

  510     Reader.DefinitionSource[FD] = Loc.F->Kind == ModuleKind::MK_MainFile;
  757     EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
 1408     Reader.DefinitionSource[VD] = Loc.F->Kind == ModuleKind::MK_MainFile;
 1668     Reader.DefinitionSource[D] = Loc.F->Kind == ModuleKind::MK_MainFile;
 1892       C.KeyFunctions[D] = KeyFn;
 2526       Reader.KeyDecls[ExistingCanon].push_back(Redecl.getFirstID());
 4040       Lookups[DC].Table.add(
 4119         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
 4162           NameCategoryMap[Cat->getDeclName()] = Cat;

 3551       StmtEntries[Cursor.GetCurrentBitNo()] = S;

 2432     FilenameMap[-1] = -1; // For unspecified filenames.
 2659       Record.push_back(MacroDefinitions[PPRec->findMacroDefinition(MI)]);
 2738       MacroDefinitions[MD] = NextPreprocessorEntityID;
 2750         Record.push_back(MacroDefinitions[ME->getDefinition()]);
 4757       DeclIDs[D] = ID;
 5201       Imports.push_back(ModuleInfo(SubmoduleIDs[I->getImportedModule()],
 5813       AnonymousDeclarationNumbers[ND] = Number;
 6318   MacroDefinitions[MD] = ID;

 2353   serialization::DeclID &IDR = DeclIDs[D];

   96     IMeths[M->getSelector()] = M;

  493       const FieldDecl *FD = CaptureFields[VD];

 1972   LCM[&PD->getActivePath()] = ErrorNode->getLocationContext();

 1275         Optional<const ObjCMethodDecl *> &Val = PMC[std::make_pair(IDecl, Sel)];

  503     if (InverseMap) (*InverseMap)[NewN] = N;

 2067     return (LazyBindingsMap[LCV.getCVData()] = std::move(List));
 2089   return (LazyBindingsMap[LCV.getCVData()] = std::move(List));

  552       const_cast<SymbolReaper *>(this)->includedRegionCache[VR];

  296       NumVisited = NumReached[BE->getBlock()]++;

   87     Mapping[Range.Offset] = Range.Length;
  250     (*PPSkipMappings)[Result->getBufferPtr()] =

  300     Collector->Expansions[Range.getBegin().getRawEncoding()] = Range.getEnd();
  376     fillGapUntil(Result.Files[SM.getMainFileID()],
  379     Result.Files[SM.getMainFileID()].EndExpanded = Result.ExpandedTokens.size();

  172     StringOptions[&Option] = std::move(CLOption);

  246   Abbrevs[RID] = AbbrevID;

   56     double &S = Score[Symbol.Symbol.getFilePath()];
   63               auto AS = Score[A.Symbol.getFilePath()];
   64               auto BS = Score[B.Symbol.getFilePath()];

   58   std::unique_ptr<CallGraphNode> &Node = DeclMap[F];

   70     IncludeDirectives[SM.getFileID(HashLoc)].emplace_back(

   47       FoundDecls[AliasDecl] = CharSourceRange();

  870       NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(

   69     SyntheticStmtSourceMap[SyntheticStmt.first] = SyntheticStmt.second;
  191         Map[S->getStmt()] = B;

  474     BeginExpansions[SM.getFileID(Begin)] = Begin;

  274         RefToIDs[&R] = SymRefs.first;

   30       this->Relations[std::make_pair(R.Subject,

   53       this->Relations[std::make_pair(Rel.Subject,

  215       std::unique_ptr<ASTImporter> &ImporterRef = Importers[{From, To}];

 2058     StringRef CIEData = LocalCIES[CIEId];

  224         return UniqueIdToCuMap[Entry.getCUIndex()];

   62     ret[s->getChunk()].push_back(s);
  120       for (DefinedRegular *sym : sectionSyms[sc])

 1733           secrels[r.VirtualAddress] = s->getValue();

  459   Symbol *&sym = symMap[CachedHashStringRef(name)];

  370   Defined *&lastThunk = lastThunks[target->getRVA()];
  801     OutputSection *&sec = sections[{name, outChars}];

  714       map[sym->getName()] = sym;

   69     ret[dr->section].push_back(dr);
   98     ret[syms[i]] = std::move(str[i]);
  190           for (Symbol *sym : sectionSyms[isec])

  263       cNamedSections[saver.save("__start_" + sec->name)].push_back(sec);
  264       cNamedSections[saver.save("__stop_" + sec->name)].push_back(sec);

 1712       thunkVec = &thunkedSymbolsBySection[{d->section->repl, d->value}];
 1808               thunks[t->getThunkTargetSym()] = t;

  551       dest = &script->insertAfterCommands[next()];
  553       dest = &script->insertBeforeCommands[next()];

   36   int &idx1 = symMap[CachedHashStringRef(sym->getName())];
   37   int &idx2 = symMap[CachedHashStringRef(real->getName())];
   38   int &idx3 = symMap[CachedHashStringRef(wrap->getName())];

  360   CieRecord *&rec = cieMap[{cie.data(), personality}];
  417     CieRecord *rec = offsetToCie[cieOffset];
 2073         sectionIndexMap[e.sym->getOutputSection()] = ++i;

 1233         int &priority = sectionOrder[cast<InputSectionBase>(sec->repl)];

  208     _replacedAtoms[&newAtom] = existing;
  252   _replacedAtoms[&newAtom] = existing;

  732       nFile.entryAddress = (_atomToAddress[_entryAtom] | 1);
  734       nFile.entryAddress = _atomToAddress[_entryAtom];
  744       _atomToAddress[info.atom] = sect->address + info.offsetInSection;
  752                       << llvm::format("0x%016X", _atomToAddress[info.atom])
 1075           sym.value = _atomToAddress[atom];
 1076           _atomToSymbolIndex[atom] = file.localSymbols.size();
 1091         sym.value = _atomToAddress[atom];
 1092         _atomToSymbolIndex[atom] = file.localSymbols.size();
 1346         addr = _atomToAddress[info.atom];
 1356       uint64_t nextAddr = _atomToAddress[info.atom];
 1435         uint64_t segmentOffset = _atomToAddress[atom] + ref->offsetInAtom()
 1548       exprt.offset = _atomToAddress[atom] - _ctx.baseAddress();

 1170   cieInfos[atom] = std::move(cieInfo);

  109        _targetToShim[&target] = shim;

  122       _refNames[&atom] = newName;

  570   auto &variants = symVariants[CachedHashStringRef(sym->getName())];
  604   int &origIdx = symMap[CachedHashStringRef(sym->getName())];
  605   int &realIdx= symMap[CachedHashStringRef(real->getName())];
  606   int &wrapIdx = symMap[CachedHashStringRef(wrap->getName())];

   55       m_symbol_map[jitted_function.m_name.GetCString()] =
   73       m_symbol_map[global_var.m_name.GetCString()] = global_var.m_remote_addr;

 1828                 fi->getNameAsString().c_str(), field_offsets[*fi]);
 1854                  ? virtual_base_offsets[base_cxx_record.decl].getQuantity()
 1855                  : base_offsets[base_cxx_record.decl].getQuantity()));

 4274       m_cached_module_specs[ModuleCacheKey(spec.GetPath(),
 4277       m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),

  195   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
  396   dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
  403       dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
  631     dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
  679         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
  895                 type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
 1051                   dwarf->GetDIEToType()[die.GetDIE()] = NULL;
 1061                   type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
 1307   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
 1347         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
 1423         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
 1480       dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
 1656       dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
 1659           [ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType()] =
 3331     m_die_to_decl[die.GetDIE()] = decl;
 3332     m_decl_to_die[decl].insert(die.GetDIE());
 3339     m_die_to_decl[die.GetDIE()] = decl;
 3340     m_decl_to_die[decl].insert(die.GetDIE());
 3402   m_die_to_decl[die.GetDIE()] = decl;
 3403   m_decl_to_die[decl].insert(die.GetDIE());
 3517         llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
 3540         static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
 3613   m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
 3744           src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
 3758           dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
 3765         dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
 3788               src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
 3802               dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
 3809             dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] =
 3843             src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
 3857             dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
 3864           dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;

 2731                 GetDIEToType()[die.GetDIE()] = resolved_type;
 3143   var_sp = GetDIEToVariable()[die.GetDIE()];
 3513     GetDIEToVariable()[die.GetDIE()] = var_sp;
 3515       GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
 3581     VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];

   83     m_collection[name.GetCString()].Append(entry);

  481   m_uid_to_decl[toOpaqueUid(uid)] = result;
  839   m_uid_to_decl[toOpaqueUid(uid)] = var_decl;
  963     m_uid_to_type[toOpaqueUid(type)] = qt;
  970   m_uid_to_type[toOpaqueUid(type)] = qt;
  975     DeclStatus &status = m_decl_to_status[tag];
 1021   m_uid_to_decl[toOpaqueUid(func_id)] = function_decl;
 1090     m_uid_to_decl[toOpaqueUid(param_uid)] = param;
 1281         skipFunctionParameters(*m_uid_to_decl[toOpaqueUid(block_id)], symbols);

  705         m_types[toOpaqueUid(type_id)] = result;
  724     m_types[toOpaqueUid(type_id)] = result;
 1361   m_local_variables[toOpaqueUid(var_id)] = var_sp;

  428       m_uid_to_decl[type.getSymIndexId()] = record_decl;
  513       m_uid_to_decl[type.getSymIndexId()] = enum_decl;
  567       m_uid_to_decl[type.getSymIndexId()] = typedef_decl;
  875         m_uid_to_decl[sym_id] = decl;
  914     m_uid_to_decl[sym_id] = decl;
  959     m_uid_to_decl[sym_id] = decl;
 1170   m_uid_to_decl[enum_value.getSymIndexId()] = enum_constant_decl;
 1256       m_uid_to_decl[member->getSymIndexId()] = decl;
 1272       m_uid_to_decl[member->getSymIndexId()] = decl;
 1338       m_uid_to_decl[method->getSymIndexId()] = decl;

   49   GetSourceMap(guard)[this] = this;

  119   m_functions_by_uid[funcSP->GetID()] = funcSP;

   87       m_sect_to_addr[section.get()] = load_addr;

  315     ThreadPcs[Id] = std::move(*PcOr);

   27       Numbering[&*AI] = IN++;
   32       Numbering[&*FI] = IN++;
   38         Numbering[&*BI] = IN++;

  180       Values[L] = R;
  338         LCases[Case.getCaseValue()] = Case.getCaseSuccessor();
  407       return Blocks[cast<BlockAddress>(L)->getBasicBlock()]
  476       return Blocks[cast<BasicBlock>(L)] != R;
  498       Values[&*LI] = &*RI;
  644       Values[LCall] = RInvoke;
  657       Values[LInvoke] = RCall;

   92     auto NewOffset = OffsetRemapping[OldOffset];

  252         return {static_cast<char *>(SegBlocks[Seg].base()),
  253                 SegBlocks[Seg].allocatedSize()};
  257         return reinterpret_cast<JITTargetAddress>(SegBlocks[Seg].base());

   60     unsigned R2VIndex = Resource2VecIndex[RR.first];

   93         NamedStreams[NSE.second] = NSE.first();

  230     StacksByStackId[*id_counter - 1] = CurrentStack;

 2074       ValueDefAccs[Access->getAccessValue()] = Access;

  813     LoadInst *&ClassRep = EquivClasses[std::make_pair(PointerSCEV, Ty)];
 3372         PtrToAcc[cast<MemTransferInst>(Acc)->getRawSource()] = MA;
 3374         PtrToAcc[Acc.getPointerOperand()] = MA;
 3385       AG.push_back(PtrToAcc[PR.getValue()]);
 3675       Stmt.setInvalidDomain(InvalidDomainMap[Stmt.getEntryBlock()]);
 3677       Stmt.setInvalidDomain(InvalidDomainMap[getRegionNodeBasicBlock(

 1729     BBColorMap[BB] = WHITE;
 1732   BBColorMap[CurrBB] = GREY;
 1753       if (BBColorMap[SuccBB] == WHITE) {
 1759         BBColorMap[SuccBB] = GREY;
 1761       } else if (BBColorMap[SuccBB] == GREY) {
 1776       BBColorMap[CurrBB] = BLACK;

 1148     MemoryAccessList &MAL = InstructionToAccess[AccessInst];
 2401       InstStmtMap[&Inst] = Stmt;
 2498     auto &Uses = ValueUseAccs[Access->getScopArrayInfo()];
 2505     auto &Incomings = PHIIncomingAccs[Access->getScopArrayInfo()];

   93   BBMap[Old] = Expanded;
  240   BBMap[Inst] = NewInst;
  372     BBMap[Load] = NewLoad;
  577     BBMap[MA->getAccessValue()] =
 1034   VectorMap[Old] = Vector;
 1128     VectorMap[Load] = Builder.CreateVectorSplat(getVectorWidth(), PreloadLoad,
 1135       ScalarMaps[i][Load] =
 1156   VectorMap[Load] = NewLoad;
 1170   VectorMap[Inst] = Builder.CreateCast(Cast->getOpcode(), NewOperand, DestType);
 1186   VectorMap[Inst] = NewInst;
 1255       SM[Operand] =
 1283     Vector = Builder.CreateInsertElement(Vector, ScalarMaps[i][Inst],
 1286   VectorMap[Inst] = Vector;
 1350     VectorBlockMap[MA->getAccessValue()] = VectorVal;
 1487       StartBlockMap[*PI] = EntryBBCopy;
 1488       EndBlockMap[*PI] = EntryBBCopy;
 1545   StartBlockMap[R->getExit()] = ExitBBCopy;
 1546   EndBlockMap[R->getExit()] = ExitBBCopy;
 1607     LTS[L] = SE.getUnknown(LoopPHI);
 1792   BBMap[PHI] = PHICopy;

   94     OtherAliasScopeListMap[Array->getBasePtr()] = AliasScopeList;
  240   auto *OtherAliasScopeList = OtherAliasScopeListMap[BasePtr];

  917     LTS[Stmt->getLoopForDimension(i)] = SE->getUnknown(V);
 1387     ValueMap[MAAccInst] = PreloadVal;
 1403   PreloadedPointer[PreloadVal] = AccInst;
 1421         ScalarMap[DerivedSAI] = Alloca;

  250     Map[OldValues[i]] = NewValue;

  313     NewSchedule[&Stmt] = isl::manage(Map);
  327       ScheduleMap = ScheduleMap.add_map(NewSchedule[&Stmt]);

  652   isl::map &Result = DefToTargetCache[std::make_pair(TargetStmt, DefStmt)];

  403       [&Order](const Use &L, const Use &R) { return Order[&L] < Order[&R]; };
  403       [&Order](const Use &L, const Use &R) { return Order[&L] < Order[&R]; };
  407       Order[&U] = I;

  136   this->Map[this->getKey()] = this->getValue();
  154   EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
  159   this->Map[this->getKey()] = this->getValue();
  169   this->Map[this->getKey()] = this->getValue();
  179   this->Map[this->getKey()] = this->getValue();
  191   EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
  196   this->Map[this->getKey()] = this->getValue();
  200   EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
  206     this->Map[this->getKey(Key)] = this->getValue(Key);
  211     EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
  224     this->Map[this->getKey(Key)] = this->getValue(Key);
  233   this->Map[this->getKey()] = this->getValue();
  237   EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
  242   EXPECT_EQ(this->getValue(), copyMap[this->getKey()]);
  247     this->Map[this->getKey(Key)] = this->getValue(Key);
  252     EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
  258     EXPECT_EQ(this->getValue(Key), copyMap[this->getKey(Key)]);
  263   this->Map[this->getKey()] = this->getValue();
  270   EXPECT_EQ(this->getValue(), otherMap[this->getKey()]);
  276   EXPECT_EQ(this->getValue(), this->Map[this->getKey()]);
  280     this->Map[this->getKey(i)] = this->getValue(i);
  287     EXPECT_EQ(this->getValue(i), otherMap[this->getKey(i)]);
  294     EXPECT_EQ(this->getValue(i), this->Map[this->getKey(i)]);
  307     this->Map[this->getKey(i)] = this->getValue(i);
  360   EXPECT_EQ(0, M[0]);
  362   EXPECT_EQ(2, M[1]);
  488   M["a"] = 1;
  489   M["b"] = 2;
  490   M["c"] = 3;
  503   M[""] = 42;
  529   map[0] = 1;
  530   map[1] = 2;
  531   map[2] = 3;

  139   VM.MD()[Old].reset(New);
  195   VM.MD()[S1].reset(S2);
  249     VM.MD()[CAM].reset(N);

  409       SuperRegClasses[SubIdx].insert(SuperRC);

  406     Instructions[Insts[i]] = std::make_unique<CodeGenInstruction>(Insts[i]);

  118         Entry = NodePredicateMap[SameCodePreds.front()];
  140     unsigned &Entry = ComplexPatternMap[&P];

  420       unsigned &Entry = TypeEntry[CTMTy];

   63     unsigned &Entry = ImmIDs[Pred.getOrigPatFragRecord()];

 3400     NodeEquivs[Equiv->getValueAsDef("Node")] = Equiv;
 3407     ComplexPatternEquivs[SelDAGEquiv] = Equiv;
 3415    SDNodeXFormEquivs[SelDAGEquiv] = Equiv;
 4530   RuleMatcherScores[M.getRuleID()] = Score;
 5256     int ScoreA = RuleMatcherScores[A.getRuleID()];
 5257     int ScoreB = RuleMatcherScores[B.getRuleID()];

  488   unsigned Entry = MCOpPredicateMap[Rec];
  495     MCOpPredicateMap[Rec] = Entry;

  123       return Field.Enum->EntryMap[cast<DefInit>(I)->getDef()]->first;