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

References

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  506       auto *NewA = cast<GlobalAlias>(VMap[&A]);
lib/CodeGen/CodeGenPrepare.cpp
 4769   WeakTrackingVH SunkAddrVH = SunkAddrs[Addr];
 5005   SunkAddrs[Addr] = WeakTrackingVH(SunkAddr);
lib/CodeGen/PseudoSourceValue.cpp
  139       GlobalCallEntries[GV];
lib/CodeGen/WinEHPrepare.cpp
  757       VMap[BB] = CBB;
lib/ExecutionEngine/Orc/IndirectionUtils.cpp
  294     (*VMap)[&F] = NewF;
  298       (*VMap)[&*ArgI] = &*NewArgI;
  309     NewF = cast<Function>(VMap[&OrigF]);
  311     assert(VMap[&OrigF] == NewF && "Incorrect function mapping in VMap.");
  331     (*VMap)[&GV] = NewGV;
  341     NewGV = cast<GlobalVariable>(VMap[&OrigGV]);
  343     assert(VMap[&OrigGV] == NewGV &&
  360   VMap[&OrigA] = NewA;
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp
  207   AMDGPUPerfHintAnalysis::FuncInfo &FI = FIM[&F];
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp
  312       VMap[&Arg] = &(*NewFArgIt++);
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp
   89       GVMap[GV] = NewGV;
  126     VM[I->first] = I->second;
  191   ConstantToValueMap[C] = NewValue;
lib/Transforms/Coroutines/CoroSplit.cpp
  374   auto *Switch = cast<SwitchInst>(VMap[Shape.SwitchLowering.ResumeSwitch]);
  418   auto NewS = VMap[ActiveSuspend];
  482     auto *MappedCS = cast<AnyCoroSuspendInst>(VMap[CS]);
  492     auto NewCE = cast<CoroEndInst>(VMap[CE]);
  527     auto MappedOp = VMap ? cast<CallInst>((*VMap)[Op]) : Op;
  565   auto *Entry = cast<BasicBlock>(VMap[Shape.AllocaSpillBlock]);
  590       cast<BasicBlock>(VMap[Shape.SwitchLowering.ResumeEntryBlock]);
  600     auto MappedCS = cast<CoroSuspendRetconInst>(VMap[ActiveSuspend]);
  650     VMap[&A] = UndefValue::get(A.getType());
  728   Value *OldFramePtr = VMap[Shape.FramePtr];
  735   Value *OldVFrame = cast<Value>(VMap[Shape.CoroBegin]);
  769     coro::replaceCoroFree(cast<CoroIdInst>(VMap[Shape.CoroBegin->getId()]),
lib/Transforms/IPO/PartialInlining.cpp
  975   ClonedOI->ReturnBlock = cast<BasicBlock>(VMap[OI->ReturnBlock]);
  976   ClonedOI->NonReturnBlock = cast<BasicBlock>(VMap[OI->NonReturnBlock]);
  978     ClonedOI->Entries.push_back(cast<BasicBlock>(VMap[BB]));
  981     BasicBlock *NewE = cast<BasicBlock>(VMap[E]);
 1006       Region.push_back(cast<BasicBlock>(VMap[BB]));
 1008     BasicBlock *NewEntryBlock = cast<BasicBlock>(VMap[RegionInfo.EntryBlock]);
 1009     BasicBlock *NewExitBlock = cast<BasicBlock>(VMap[RegionInfo.ExitBlock]);
 1012       NewReturnBlock = cast<BasicBlock>(VMap[RegionInfo.ReturnBlock]);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
 1779       VMap[BB] = NewBB;
 1808           PN.addIncoming(V, cast<BasicBlock>(VMap[Pred]));
 1831                                          cast<BasicBlock>(VMap[NewEntryBlock]),
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1515     ShadowMap[V] = PropagateShadow ? SV : getCleanShadow(V);
 1523     OriginMap[V] = Origin;
 1583       Value *Shadow = ShadowMap[V];
 1599       Value **ShadowPtr = &ShadowMap[V];
 1689     Value *Origin = OriginMap[V];
lib/Transforms/Scalar/CallSiteSplitting.cpp
  405         NewPN->addIncoming(Mapping[CurrentI],
  406                            cast<Instruction>(Mapping[CurrentI])->getParent());
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
 1133     Result.Map[BB] = Clone;
 1156     assert(Result.Map[OriginalBB] == ClonedBB && "invariant!");
 1377       New.addBasicBlockToLoop(cast<BasicBlock>(VM[BB]), LI);
lib/Transforms/Scalar/InferAddressSpaces.cpp
  884       ValueWithNewAddrSpace[V] = cloneValueWithNewAddressSpace(
lib/Transforms/Scalar/JumpThreading.cpp
 2748       NewPN->addIncoming(UnguardedMapping[Inst], UnguardedBlock);
 2749       NewPN->addIncoming(GuardedMapping[Inst], GuardedBlock);
lib/Transforms/Scalar/LoopDistribute.cpp
  223             NewInst = cast<Instruction>(VMap[NewInst]);
  472       Part->getVMap()[ExitBlock] = TopPH;
lib/Transforms/Scalar/LoopUnswitch.cpp
  920       New.addBasicBlockToLoop(cast<BasicBlock>(VM[*I]), *LI);
 1284     VMap[LoopBlocks[i]] = NewBB;  // Keep the BB mapping.
 1309     BasicBlock *NewExit = cast<BasicBlock>(VMap[ExitBlocks[i]]);
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
  989     VMap[OldBB] = NewBB;
lib/Transforms/Utils/CloneFunction.cpp
   61     VMap[&I] = NewInst; // Add instruction map to value.
  116     if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) {
  173     VMap[&BB] = CBB;
  184       VMap[OldBBAddr] = BlockAddress::get(NewFunc, CBB);
  205            cast<BasicBlock>(VMap[&OldFunc->front()])->getIterator(),
  261       VMap[&I] = &*DestI++;        // Add mapping to VMap
  304   WeakTrackingVH &BBEntry = VMap[BB];
  326     VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
  356           VMap[&*II] = V;
  365     VMap[&*II] = NewInst; // Add instruction map to value.
  398         VMap[OldTI] = BranchInst::Create(Dest, NewBB);
  413       VMap[OldTI] = BranchInst::Create(Dest, NewBB);
  424     VMap[OldTI] = NewInst;             // Add instruction map to value.
  506       if (isa<PHINode>(VMap[&PN]))
  525     BasicBlock *NewBB = cast<BasicBlock>(VMap[OldBB]);
  532       PHINode *PN = cast<PHINode>(VMap[OPN]);
  592         assert(VMap[&*OldI] == PN && "VMap mismatch");
  593         VMap[&*OldI] = NV;
  610     if (isa<PHINode>(VMap[PHIToResolve[Idx]]))
  644       VMap[OrigV] = I;
  651   Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator();
  711   for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB])->getIterator(),
  772   VMap[OrigPH] = NewPH;
  803     VMap[BB] = NewBB;
  820     DT->changeImmediateDominator(cast<BasicBlock>(VMap[BB]),
  821                                  cast<BasicBlock>(VMap[IDomBB]));
  846     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
  866     ValueMapping[&*BI] = New;
lib/Transforms/Utils/CloneModule.cpp
   71     VMap[&*I] = GV;
   80     VMap[&I] = NF;
  101       VMap[&*I] = GV;
  111     VMap[&*I] = GA;
  123     GlobalVariable *GV = cast<GlobalVariable>(VMap[&*I]);
  147     Function *F = cast<Function>(VMap[&I]);
  160       VMap[&*J] = &*DestI++;
  178     GlobalAlias *GA = cast<GlobalAlias>(VMap[&*I]);
lib/Transforms/Utils/InlineFunction.cpp
 1701       VMap[&*I] = ActualArg;
lib/Transforms/Utils/LoopRotationUtils.cpp
  303     ValueMap[PN] = PN->getIncomingValueForBlock(OrigPreheader);
  361       ValueMap[Inst] = V;
  367       ValueMap[Inst] = C;
  379       ValueMapMSSA[Inst] = C;
  399     ValueMapMSSA[OrigHeader] = OrigPreheader;
lib/Transforms/Utils/LoopUnroll.cpp
  622           PHINode *NewPHI = cast<PHINode>(VMap[OrigPHI]);
  626               InVal = LastValueMap[InValI];
  627           VMap[OrigPHI] = InVal;
  632       LastValueMap[*BB] = New;
  635         LastValueMap[VI->first] = VI->second;
  678               New, cast<BasicBlock>(LastValueMap[cast<Value>(OriginalBBIDom)]));
  705           InVal = LastValueMap[InVal];
  707       assert(Latches.back() == LastValueMap[LatchBlock] && "bad last latch");
lib/Transforms/Utils/LoopUnrollAndJam.cpp
  349       PrevItValueMap[New] = (It == 1 ? *BB : LastValueMap[*BB]);
  350       LastValueMap[*BB] = New;
  354             const_cast<Value *>(It == 1 ? VI->first : LastValueMap[VI->first]);
  355         LastValueMap[VI->first] = VI->second;
  374         assert(LastValueMap[cast<Value>(OriginalBBIDom)]);
  376             New, cast<BasicBlock>(LastValueMap[cast<Value>(OriginalBBIDom)]));
  427           if (Value *LastValue = LastValueMap[OldValue])
lib/Transforms/Utils/LoopUnrollPeel.cpp
  492     VMap[*BB] = NewBB;
  501         DT->addNewBlock(NewBB, cast<BasicBlock>(VMap[IDom->getBlock()]));
  510   InsertTop->getTerminator()->setSuccessor(0, cast<BasicBlock>(VMap[Header]));
  517   BasicBlock *NewLatch = cast<BasicBlock>(VMap[Latch]);
  536     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
  538       VMap[&*I] = NewPHI->getIncomingValueForBlock(PreHeader);
  543         VMap[&*I] = LVMap[LatchInst];
  543         VMap[&*I] = LVMap[LatchInst];
  545         VMap[&*I] = LatchVal;
  547     cast<BasicBlock>(VMap[Header])->getInstList().erase(NewPHI);
  559         LatchVal = VMap[LatchVal];
  560       PHI.addIncoming(LatchVal, cast<BasicBlock>(VMap[Edge.first]));
  566     LVMap[KV.first] = KV.second;
  709                                        cast<BasicBlock>(LVMap[Exit.second]));
  715     auto *LatchBRCopy = cast<BranchInst>(VMap[LatchBR]);
  737       NewVal = LVMap[LatchInst];
lib/Transforms/Utils/LoopUnrollRuntime.cpp
   85   BasicBlock *PrologLatch = cast<BasicBlock>(VMap[Latch]);
  189   BasicBlock *EpilogLatch = cast<BasicBlock>(VMap[Latch]);
  265       PHINode *VPN = cast<PHINode>(VMap[&PN]);
  329     VMap[*BB] = NewBB;
  343         DT->addNewBlock(NewBB, cast<BasicBlock>(VMap[IDomBB]));
  351       BasicBlock *FirstLoopBB = cast<BasicBlock>(VMap[Header]);
  376     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
  383         VMap[&*I] = NewPHI->getIncomingValueForBlock(Preheader);
  384         cast<BasicBlock>(VMap[Header])->getInstList().erase(NewPHI);
  389       BasicBlock *NewLatch = cast<BasicBlock>(VMap[Latch]);
  821          VMap[Phi->getIncomingValue(i)] = Phi->getIncomingValue(i);
  824                            cast<BasicBlock>(VMap[Phi->getIncomingBlock(i)]));
lib/Transforms/Utils/SimplifyCFG.cpp
 2737       VMap[&*BonusInst] = NewBonusInst;
lib/Transforms/Utils/ValueMapper.cpp
  351       getVM()[V] = NewV;
  361     return getVM()[V] = const_cast<Value *>(V);
  375     return getVM()[V] = const_cast<Value *>(V);
  400       return getVM()[V] = const_cast<Value *>(V);
  405       return getVM()[V] = const_cast<Value *>(V);
  406     return getVM()[V] = MetadataAsValue::get(V->getContext(), MappedMD);
  447     return getVM()[V] = C;
  474     return getVM()[V] = CE->getWithOperands(Ops, NewTy, false, NewSrcTy);
  476     return getVM()[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops);
  478     return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops);
  480     return getVM()[V] = ConstantVector::get(Ops);
  483     return getVM()[V] = UndefValue::get(NewTy);
  485     return getVM()[V] = ConstantAggregateZero::get(NewTy);
  487   return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy));
  504   return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());
tools/bugpoint/CrashDebugger.cpp
  154     GlobalVariable *CMGV = cast<GlobalVariable>(VMap[GVs[i]]);
  247     Function *CMF = cast<Function>(VMap[Funcs[i]]);
  450     Blocks.insert(cast<BasicBlock>(VMap[BBs[i]]));
  569     Blocks.insert(cast<BasicBlock>(VMap[BB]));
  673     Blocks.insert(cast<BasicBlock>(VMap[BB]));
  766     Instructions.insert(cast<Instruction>(VMap[Insts[i]]));
tools/bugpoint/ExtractFunction.cpp
  279           F = cast<Function>(VMap[F]);
  325     Function *TNOF = cast<Function>(VMap[F[i]]);
  329     TestFunctions.insert(cast<Function>(NewVMap[TNOF]));
  340     GlobalVariable *GV = cast<GlobalVariable>(NewVMap[&I]);
tools/bugpoint/Miscompilation.cpp
  272     Function *F = cast<Function>(VMap[Funcs[i]]);
  345       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
  375       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
  507     Function *F = cast<Function>(VMap[FunctionsBeingTested[i]]);
  511     BasicBlock *BB = cast<BasicBlock>(VMap[BBs[i]]);
tools/llvm-reduce/deltas/ReduceArguments.cpp
   68         VMap[&A] = UndefValue::get(A.getType());
unittests/IR/ValueMapTest.cpp
   42   VM1[nullptr] = 7;
   48   VM[this->BitcastV.get()] = 7;
   67   VM[this->BitcastV.get()] = 7;
  124   VM[this->BitcastV.get()] = 2;
  125   VM[this->AddV.get()] = 3;
  143   EXPECT_EQ(5, VM[this->BitcastV.get()]);
  144   EXPECT_EQ(6, VM[this->AddV.get()]);
  168   VM[this->BitcastV.get()] = 7;
  169   VM[this->AddV.get()] = 9;
  204   VM[this->BitcastV.get()] = 7;
  219   VM[this->BitcastV.get()] = 7;
  253   VM[this->BitcastV.get()] = 7;
  285   VM[this->BitcastV.get()] = 7;
  289   VM[this->AddV.get()] = 7;
unittests/Transforms/Utils/CloningTest.cpp
  177   VMap[A] = UndefValue::get(A->getType());
  200   VMap[&*F1->arg_begin()] = &*F2->arg_begin();
  240   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
  246   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
  290   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
  296   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
  302   auto SubSplit = dyn_cast<Instruction>(Mapping[SubInst]);
  342   auto AddSplit = dyn_cast<Instruction>(Mapping[AddInst]);
  348   auto MulSplit = dyn_cast<Instruction>(Mapping[MulInst]);
  700   VMap[ImplFunction] = DeclFunction;
unittests/Transforms/Utils/ValueMapperTest.cpp
   95   VM[G0.get()] = G1.get();
  257   VM[F.get()] = F2.get();
  314   VM[MAV] = MAV;
  320   VM[MAV] = &A;
  338   VM[&A] = &C;