1 //===-- SafepointIRVerifier.cpp - Verify gc.statepoint invariants ---------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // Run a sanity check on the IR to ensure that Safepoints - if they've been
10 // inserted - were inserted correctly. In particular, look for use of
11 // non-relocated values after a safepoint. It's primary use is to check the
12 // correctness of safepoint insertion immediately after insertion, but it can
13 // also be used to verify that later transforms have not found a way to break
14 // safepoint semenatics.
16 // In its current form, this verify checks a property which is sufficient, but
17 // not neccessary for correctness. There are some cases where an unrelocated
18 // pointer can be used after the safepoint. Consider this example:
22 // (a',b') = safepoint(a,b)
26 // Because it is valid to reorder 'c' above the safepoint, this is legal. In
27 // practice, this is a somewhat uncommon transform, but CodeGenPrep does create
28 // idioms like this. The verifier knows about these cases and avoids reporting
31 //===----------------------------------------------------------------------===//
33 #include "llvm/IR/SafepointIRVerifier.h"
34 #include "llvm/ADT/DenseSet.h"
35 #include "llvm/ADT/PostOrderIterator.h"
36 #include "llvm/ADT/SetOperations.h"
37 #include "llvm/ADT/SetVector.h"
38 #include "llvm/IR/BasicBlock.h"
39 #include "llvm/IR/Dominators.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/IR/Instructions.h"
42 #include "llvm/IR/IntrinsicInst.h"
43 #include "llvm/IR/Intrinsics.h"
44 #include "llvm/IR/Module.h"
45 #include "llvm/IR/Statepoint.h"
46 #include "llvm/IR/Value.h"
47 #include "llvm/InitializePasses.h"
48 #include "llvm/Support/Allocator.h"
49 #include "llvm/Support/CommandLine.h"
50 #include "llvm/Support/Debug.h"
51 #include "llvm/Support/raw_ostream.h"
53 #define DEBUG_TYPE "safepoint-ir-verifier"
57 /// This option is used for writing test cases. Instead of crashing the program
58 /// when verification fails, report a message to the console (for FileCheck
59 /// usage) and continue execution as if nothing happened.
60 static cl::opt<bool> PrintOnly("safepoint-ir-verifier-print-only",
65 /// This CFG Deadness finds dead blocks and edges. Algorithm starts with a set
66 /// of blocks unreachable from entry then propagates deadness using foldable
67 /// conditional branches without modifying CFG. So GVN does but it changes CFG
68 /// by splitting critical edges. In most cases passes rely on SimplifyCFG to
69 /// clean up dead blocks, but in some cases, like verification or loop passes
70 /// it's not possible.
72 const DominatorTree *DT = nullptr;
73 SetVector<const BasicBlock *> DeadBlocks;
74 SetVector<const Use *> DeadEdges; // Contains all dead edges from live blocks.
77 /// Return the edge that coresponds to the predecessor.
78 static const Use& getEdge(const_pred_iterator &PredIt) {
79 auto &PU = PredIt.getUse();
80 return PU.getUser()->getOperandUse(PU.getOperandNo());
83 /// Return true if there is at least one live edge that corresponds to the
84 /// basic block InBB listed in the phi node.
85 bool hasLiveIncomingEdge(const PHINode *PN, const BasicBlock *InBB) const {
86 assert(!isDeadBlock(InBB) && "block must be live");
87 const BasicBlock* BB = PN->getParent();
89 for (const_pred_iterator PredIt(BB), End(BB, true); PredIt != End; ++PredIt) {
90 if (InBB == *PredIt) {
91 if (!isDeadEdge(&getEdge(PredIt)))
97 assert(Listed && "basic block is not found among incoming blocks");
102 bool isDeadBlock(const BasicBlock *BB) const {
103 return DeadBlocks.count(BB);
106 bool isDeadEdge(const Use *U) const {
107 assert(cast<Instruction>(U->getUser())->isTerminator() &&
108 "edge must be operand of terminator");
109 assert(cast_or_null<BasicBlock>(U->get()) &&
110 "edge must refer to basic block");
111 assert(!isDeadBlock(cast<Instruction>(U->getUser())->getParent()) &&
112 "isDeadEdge() must be applied to edge from live block");
113 return DeadEdges.count(U);
116 bool hasLiveIncomingEdges(const BasicBlock *BB) const {
117 // Check if all incoming edges are dead.
118 for (const_pred_iterator PredIt(BB), End(BB, true); PredIt != End; ++PredIt) {
119 auto &PU = PredIt.getUse();
120 const Use &U = PU.getUser()->getOperandUse(PU.getOperandNo());
121 if (!isDeadBlock(*PredIt) && !isDeadEdge(&U))
122 return true; // Found a live edge.
127 void processFunction(const Function &F, const DominatorTree &DT) {
130 // Start with all blocks unreachable from entry.
131 for (const BasicBlock &BB : F)
132 if (!DT.isReachableFromEntry(&BB))
133 DeadBlocks.insert(&BB);
135 // Top-down walk of the dominator tree
136 ReversePostOrderTraversal<const Function *> RPOT(&F);
137 for (const BasicBlock *BB : RPOT) {
138 const Instruction *TI = BB->getTerminator();
139 assert(TI && "blocks must be well formed");
141 // For conditional branches, we can perform simple conditional propagation on
142 // the condition value itself.
143 const BranchInst *BI = dyn_cast<BranchInst>(TI);
144 if (!BI || !BI->isConditional() || !isa<Constant>(BI->getCondition()))
147 // If a branch has two identical successors, we cannot declare either dead.
148 if (BI->getSuccessor(0) == BI->getSuccessor(1))
151 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
155 addDeadEdge(BI->getOperandUse(Cond->getZExtValue() ? 1 : 2));
160 void addDeadBlock(const BasicBlock *BB) {
161 SmallVector<const BasicBlock *, 4> NewDead;
162 SmallSetVector<const BasicBlock *, 4> DF;
164 NewDead.push_back(BB);
165 while (!NewDead.empty()) {
166 const BasicBlock *D = NewDead.pop_back_val();
170 // All blocks dominated by D are dead.
171 SmallVector<BasicBlock *, 8> Dom;
172 DT->getDescendants(const_cast<BasicBlock*>(D), Dom);
173 // Do not need to mark all in and out edges dead
174 // because BB is marked dead and this is enough
176 DeadBlocks.insert(Dom.begin(), Dom.end());
178 // Figure out the dominance-frontier(D).
179 for (BasicBlock *B : Dom)
180 for (BasicBlock *S : successors(B))
181 if (!isDeadBlock(S) && !hasLiveIncomingEdges(S))
182 NewDead.push_back(S);
186 void addDeadEdge(const Use &DeadEdge) {
187 if (!DeadEdges.insert(&DeadEdge))
190 BasicBlock *BB = cast_or_null<BasicBlock>(DeadEdge.get());
191 if (hasLiveIncomingEdges(BB))
199 static void Verify(const Function &F, const DominatorTree &DT,
200 const CFGDeadness &CD);
203 PreservedAnalyses SafepointIRVerifierPass::run(Function &F,
204 FunctionAnalysisManager &AM) {
205 const auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
207 CD.processFunction(F, DT);
209 return PreservedAnalyses::all();
215 struct SafepointIRVerifier : public FunctionPass {
216 static char ID; // Pass identification, replacement for typeid
217 SafepointIRVerifier() : FunctionPass(ID) {
218 initializeSafepointIRVerifierPass(*PassRegistry::getPassRegistry());
221 bool runOnFunction(Function &F) override {
222 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
224 CD.processFunction(F, DT);
226 return false; // no modifications
229 void getAnalysisUsage(AnalysisUsage &AU) const override {
230 AU.addRequiredID(DominatorTreeWrapperPass::ID);
231 AU.setPreservesAll();
234 StringRef getPassName() const override { return "safepoint verifier"; }
238 void llvm::verifySafepointIR(Function &F) {
239 SafepointIRVerifier pass;
240 pass.runOnFunction(F);
243 char SafepointIRVerifier::ID = 0;
245 FunctionPass *llvm::createSafepointIRVerifierPass() {
246 return new SafepointIRVerifier();
249 INITIALIZE_PASS_BEGIN(SafepointIRVerifier, "verify-safepoint-ir",
250 "Safepoint IR Verifier", false, false)
251 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
252 INITIALIZE_PASS_END(SafepointIRVerifier, "verify-safepoint-ir",
253 "Safepoint IR Verifier", false, false)
255 static bool isGCPointerType(Type *T) {
256 if (auto *PT = dyn_cast<PointerType>(T))
257 // For the sake of this example GC, we arbitrarily pick addrspace(1) as our
258 // GC managed heap. We know that a pointer into this heap needs to be
259 // updated and that no other pointer does.
260 return (1 == PT->getAddressSpace());
264 static bool containsGCPtrType(Type *Ty) {
265 if (isGCPointerType(Ty))
267 if (VectorType *VT = dyn_cast<VectorType>(Ty))
268 return isGCPointerType(VT->getScalarType());
269 if (ArrayType *AT = dyn_cast<ArrayType>(Ty))
270 return containsGCPtrType(AT->getElementType());
271 if (StructType *ST = dyn_cast<StructType>(Ty))
272 return llvm::any_of(ST->elements(), containsGCPtrType);
276 // Debugging aid -- prints a [Begin, End) range of values.
277 template<typename IteratorTy>
278 static void PrintValueSet(raw_ostream &OS, IteratorTy Begin, IteratorTy End) {
280 while (Begin != End) {
281 OS << **Begin << " ";
287 /// The verifier algorithm is phrased in terms of availability. The set of
288 /// values "available" at a given point in the control flow graph is the set of
289 /// correctly relocated value at that point, and is a subset of the set of
290 /// definitions dominating that point.
292 using AvailableValueSet = DenseSet<const Value *>;
294 /// State we compute and track per basic block.
295 struct BasicBlockState {
296 // Set of values available coming in, before the phi nodes
297 AvailableValueSet AvailableIn;
299 // Set of values available going out
300 AvailableValueSet AvailableOut;
302 // AvailableOut minus AvailableIn.
303 // All elements are Instructions
304 AvailableValueSet Contribution;
306 // True if this block contains a safepoint and thus AvailableIn does not
307 // contribute to AvailableOut.
308 bool Cleared = false;
311 /// A given derived pointer can have multiple base pointers through phi/selects.
312 /// This type indicates when the base pointer is exclusively constant
313 /// (ExclusivelySomeConstant), and if that constant is proven to be exclusively
314 /// null, we record that as ExclusivelyNull. In all other cases, the BaseType is
317 NonConstant = 1, // Base pointers is not exclusively constant.
319 ExclusivelySomeConstant // Base pointers for a given derived pointer is from a
320 // set of constants, but they are not exclusively
324 /// Return the baseType for Val which states whether Val is exclusively
325 /// derived from constant/null, or not exclusively derived from constant.
326 /// Val is exclusively derived off a constant base when all operands of phi and
327 /// selects are derived off a constant base.
328 static enum BaseType getBaseType(const Value *Val) {
330 SmallVector<const Value *, 32> Worklist;
331 DenseSet<const Value *> Visited;
332 bool isExclusivelyDerivedFromNull = true;
333 Worklist.push_back(Val);
334 // Strip through all the bitcasts and geps to get base pointer. Also check for
335 // the exclusive value when there can be multiple base pointers (through phis
337 while(!Worklist.empty()) {
338 const Value *V = Worklist.pop_back_val();
339 if (!Visited.insert(V).second)
342 if (const auto *CI = dyn_cast<CastInst>(V)) {
343 Worklist.push_back(CI->stripPointerCasts());
346 if (const auto *GEP = dyn_cast<GetElementPtrInst>(V)) {
347 Worklist.push_back(GEP->getPointerOperand());
350 // Push all the incoming values of phi node into the worklist for
352 if (const auto *PN = dyn_cast<PHINode>(V)) {
353 append_range(Worklist, PN->incoming_values());
356 if (const auto *SI = dyn_cast<SelectInst>(V)) {
357 // Push in the true and false values
358 Worklist.push_back(SI->getTrueValue());
359 Worklist.push_back(SI->getFalseValue());
362 if (isa<Constant>(V)) {
363 // We found at least one base pointer which is non-null, so this derived
364 // pointer is not exclusively derived from null.
365 if (V != Constant::getNullValue(V->getType()))
366 isExclusivelyDerivedFromNull = false;
367 // Continue processing the remaining values to make sure it's exclusively
371 // At this point, we know that the base pointer is not exclusively
373 return BaseType::NonConstant;
375 // Now, we know that the base pointer is exclusively constant, but we need to
376 // differentiate between exclusive null constant and non-null constant.
377 return isExclusivelyDerivedFromNull ? BaseType::ExclusivelyNull
378 : BaseType::ExclusivelySomeConstant;
381 static bool isNotExclusivelyConstantDerived(const Value *V) {
382 return getBaseType(V) == BaseType::NonConstant;
386 class InstructionVerifier;
388 /// Builds BasicBlockState for each BB of the function.
389 /// It can traverse function for verification and provides all required
392 /// GC pointer may be in one of three states: relocated, unrelocated and
394 /// Relocated pointer may be used without any restrictions.
395 /// Unrelocated pointer cannot be dereferenced, passed as argument to any call
396 /// or returned. Unrelocated pointer may be safely compared against another
397 /// unrelocated pointer or against a pointer exclusively derived from null.
398 /// Poisoned pointers are produced when we somehow derive pointer from relocated
399 /// and unrelocated pointers (e.g. phi, select). This pointers may be safely
400 /// used in a very limited number of situations. Currently the only way to use
401 /// it is comparison against constant exclusively derived from null. All
402 /// limitations arise due to their undefined state: this pointers should be
403 /// treated as relocated and unrelocated simultaneously.
404 /// Rules of deriving:
405 /// R + U = P - that's where the poisoned pointers come from
410 /// Where "+" - any operation that somehow derive pointer, U - unrelocated,
411 /// R - relocated and P - poisoned, C - constant, X - U or R or P or C or
412 /// nothing (in case when "+" is unary operation).
413 /// Deriving of pointers by itself is always safe.
414 /// NOTE: when we are making decision on the status of instruction's result:
415 /// a) for phi we need to check status of each input *at the end of
416 /// corresponding predecessor BB*.
417 /// b) for other instructions we need to check status of each input *at the
420 /// FIXME: This works fairly well except one case
422 /// p = *some GC-ptr def*
423 /// p1 = gep p, offset
431 /// p2 = phi [p, bb2] [p1, bb1]
432 /// p3 = phi [p, bb2] [p, bb1]
433 /// here p and p1 is unrelocated
434 /// p2 and p3 is poisoned (though they shouldn't be)
436 /// This leads to some weird results:
437 /// cmp eq p, p2 - illegal instruction (false-positive)
438 /// cmp eq p1, p2 - illegal instruction (false-positive)
439 /// cmp eq p, p3 - illegal instruction (false-positive)
440 /// cmp eq p, p1 - ok
441 /// To fix this we need to introduce conception of generations and be able to
442 /// check if two values belong to one generation or not. This way p2 will be
443 /// considered to be unrelocated and no false alarm will happen.
446 const CFGDeadness &CD;
447 SpecificBumpPtrAllocator<BasicBlockState> BSAllocator;
448 DenseMap<const BasicBlock *, BasicBlockState *> BlockMap;
449 // This set contains defs of unrelocated pointers that are proved to be legal
450 // and don't need verification.
451 DenseSet<const Instruction *> ValidUnrelocatedDefs;
452 // This set contains poisoned defs. They can be safely ignored during
454 DenseSet<const Value *> PoisonedDefs;
457 GCPtrTracker(const Function &F, const DominatorTree &DT,
458 const CFGDeadness &CD);
460 bool hasLiveIncomingEdge(const PHINode *PN, const BasicBlock *InBB) const {
461 return CD.hasLiveIncomingEdge(PN, InBB);
464 BasicBlockState *getBasicBlockState(const BasicBlock *BB);
465 const BasicBlockState *getBasicBlockState(const BasicBlock *BB) const;
467 bool isValuePoisoned(const Value *V) const { return PoisonedDefs.count(V); }
469 /// Traverse each BB of the function and call
470 /// InstructionVerifier::verifyInstruction for each possibly invalid
472 /// It destructively modifies GCPtrTracker so it's passed via rvalue reference
473 /// in order to prohibit further usages of GCPtrTracker as it'll be in
474 /// inconsistent state.
475 static void verifyFunction(GCPtrTracker &&Tracker,
476 InstructionVerifier &Verifier);
478 /// Returns true for reachable and live blocks.
479 bool isMapped(const BasicBlock *BB) const {
480 return BlockMap.find(BB) != BlockMap.end();
484 /// Returns true if the instruction may be safely skipped during verification.
485 bool instructionMayBeSkipped(const Instruction *I) const;
487 /// Iterates over all BBs from BlockMap and recalculates AvailableIn/Out for
488 /// each of them until it converges.
489 void recalculateBBsStates();
491 /// Remove from Contribution all defs that legally produce unrelocated
492 /// pointers and saves them to ValidUnrelocatedDefs.
493 /// Though Contribution should belong to BBS it is passed separately with
494 /// different const-modifier in order to emphasize (and guarantee) that only
495 /// Contribution will be changed.
496 /// Returns true if Contribution was changed otherwise false.
497 bool removeValidUnrelocatedDefs(const BasicBlock *BB,
498 const BasicBlockState *BBS,
499 AvailableValueSet &Contribution);
501 /// Gather all the definitions dominating the start of BB into Result. This is
502 /// simply the defs introduced by every dominating basic block and the
503 /// function arguments.
504 void gatherDominatingDefs(const BasicBlock *BB, AvailableValueSet &Result,
505 const DominatorTree &DT);
507 /// Compute the AvailableOut set for BB, based on the BasicBlockState BBS,
508 /// which is the BasicBlockState for BB.
509 /// ContributionChanged is set when the verifier runs for the first time
510 /// (in this case Contribution was changed from 'empty' to its initial state)
511 /// or when Contribution of this BB was changed since last computation.
512 static void transferBlock(const BasicBlock *BB, BasicBlockState &BBS,
513 bool ContributionChanged);
515 /// Model the effect of an instruction on the set of available values.
516 static void transferInstruction(const Instruction &I, bool &Cleared,
517 AvailableValueSet &Available);
520 /// It is a visitor for GCPtrTracker::verifyFunction. It decides if the
521 /// instruction (which uses heap reference) is legal or not, given our safepoint
523 class InstructionVerifier {
524 bool AnyInvalidUses = false;
527 void verifyInstruction(const GCPtrTracker *Tracker, const Instruction &I,
528 const AvailableValueSet &AvailableSet);
530 bool hasAnyInvalidUses() const { return AnyInvalidUses; }
533 void reportInvalidUse(const Value &V, const Instruction &I);
535 } // end anonymous namespace
537 GCPtrTracker::GCPtrTracker(const Function &F, const DominatorTree &DT,
538 const CFGDeadness &CD) : F(F), CD(CD) {
539 // Calculate Contribution of each live BB.
540 // Allocate BB states for live blocks.
541 for (const BasicBlock &BB : F)
542 if (!CD.isDeadBlock(&BB)) {
543 BasicBlockState *BBS = new (BSAllocator.Allocate()) BasicBlockState;
544 for (const auto &I : BB)
545 transferInstruction(I, BBS->Cleared, BBS->Contribution);
549 // Initialize AvailableIn/Out sets of each BB using only information about
551 for (auto &BBI : BlockMap) {
552 gatherDominatingDefs(BBI.first, BBI.second->AvailableIn, DT);
553 transferBlock(BBI.first, *BBI.second, true);
556 // Simulate the flow of defs through the CFG and recalculate AvailableIn/Out
557 // sets of each BB until it converges. If any def is proved to be an
558 // unrelocated pointer, it will be removed from all BBSs.
559 recalculateBBsStates();
562 BasicBlockState *GCPtrTracker::getBasicBlockState(const BasicBlock *BB) {
563 return BlockMap.lookup(BB);
566 const BasicBlockState *GCPtrTracker::getBasicBlockState(
567 const BasicBlock *BB) const {
568 return const_cast<GCPtrTracker *>(this)->getBasicBlockState(BB);
571 bool GCPtrTracker::instructionMayBeSkipped(const Instruction *I) const {
572 // Poisoned defs are skipped since they are always safe by itself by
573 // definition (for details see comment to this class).
574 return ValidUnrelocatedDefs.count(I) || PoisonedDefs.count(I);
577 void GCPtrTracker::verifyFunction(GCPtrTracker &&Tracker,
578 InstructionVerifier &Verifier) {
579 // We need RPO here to a) report always the first error b) report errors in
580 // same order from run to run.
581 ReversePostOrderTraversal<const Function *> RPOT(&Tracker.F);
582 for (const BasicBlock *BB : RPOT) {
583 BasicBlockState *BBS = Tracker.getBasicBlockState(BB);
587 // We destructively modify AvailableIn as we traverse the block instruction
589 AvailableValueSet &AvailableSet = BBS->AvailableIn;
590 for (const Instruction &I : *BB) {
591 if (Tracker.instructionMayBeSkipped(&I))
592 continue; // This instruction shouldn't be added to AvailableSet.
594 Verifier.verifyInstruction(&Tracker, I, AvailableSet);
596 // Model the effect of current instruction on AvailableSet to keep the set
597 // relevant at each point of BB.
598 bool Cleared = false;
599 transferInstruction(I, Cleared, AvailableSet);
605 void GCPtrTracker::recalculateBBsStates() {
606 SetVector<const BasicBlock *> Worklist;
607 // TODO: This order is suboptimal, it's better to replace it with priority
608 // queue where priority is RPO number of BB.
609 for (auto &BBI : BlockMap)
610 Worklist.insert(BBI.first);
612 // This loop iterates the AvailableIn/Out sets until it converges.
613 // The AvailableIn and AvailableOut sets decrease as we iterate.
614 while (!Worklist.empty()) {
615 const BasicBlock *BB = Worklist.pop_back_val();
616 BasicBlockState *BBS = getBasicBlockState(BB);
618 continue; // Ignore dead successors.
620 size_t OldInCount = BBS->AvailableIn.size();
621 for (const_pred_iterator PredIt(BB), End(BB, true); PredIt != End; ++PredIt) {
622 const BasicBlock *PBB = *PredIt;
623 BasicBlockState *PBBS = getBasicBlockState(PBB);
624 if (PBBS && !CD.isDeadEdge(&CFGDeadness::getEdge(PredIt)))
625 set_intersect(BBS->AvailableIn, PBBS->AvailableOut);
628 assert(OldInCount >= BBS->AvailableIn.size() && "invariant!");
630 bool InputsChanged = OldInCount != BBS->AvailableIn.size();
631 bool ContributionChanged =
632 removeValidUnrelocatedDefs(BB, BBS, BBS->Contribution);
633 if (!InputsChanged && !ContributionChanged)
636 size_t OldOutCount = BBS->AvailableOut.size();
637 transferBlock(BB, *BBS, ContributionChanged);
638 if (OldOutCount != BBS->AvailableOut.size()) {
639 assert(OldOutCount > BBS->AvailableOut.size() && "invariant!");
640 Worklist.insert(succ_begin(BB), succ_end(BB));
645 bool GCPtrTracker::removeValidUnrelocatedDefs(const BasicBlock *BB,
646 const BasicBlockState *BBS,
647 AvailableValueSet &Contribution) {
648 assert(&BBS->Contribution == &Contribution &&
649 "Passed Contribution should be from the passed BasicBlockState!");
650 AvailableValueSet AvailableSet = BBS->AvailableIn;
651 bool ContributionChanged = false;
652 // For explanation why instructions are processed this way see
653 // "Rules of deriving" in the comment to this class.
654 for (const Instruction &I : *BB) {
655 bool ValidUnrelocatedPointerDef = false;
656 bool PoisonedPointerDef = false;
657 // TODO: `select` instructions should be handled here too.
658 if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
659 if (containsGCPtrType(PN->getType())) {
660 // If both is true, output is poisoned.
661 bool HasRelocatedInputs = false;
662 bool HasUnrelocatedInputs = false;
663 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
664 const BasicBlock *InBB = PN->getIncomingBlock(i);
665 if (!isMapped(InBB) ||
666 !CD.hasLiveIncomingEdge(PN, InBB))
667 continue; // Skip dead block or dead edge.
669 const Value *InValue = PN->getIncomingValue(i);
671 if (isNotExclusivelyConstantDerived(InValue)) {
672 if (isValuePoisoned(InValue)) {
673 // If any of inputs is poisoned, output is always poisoned too.
674 HasRelocatedInputs = true;
675 HasUnrelocatedInputs = true;
678 if (BlockMap[InBB]->AvailableOut.count(InValue))
679 HasRelocatedInputs = true;
681 HasUnrelocatedInputs = true;
684 if (HasUnrelocatedInputs) {
685 if (HasRelocatedInputs)
686 PoisonedPointerDef = true;
688 ValidUnrelocatedPointerDef = true;
691 } else if ((isa<GetElementPtrInst>(I) || isa<BitCastInst>(I)) &&
692 containsGCPtrType(I.getType())) {
693 // GEP/bitcast of unrelocated pointer is legal by itself but this def
694 // shouldn't appear in any AvailableSet.
695 for (const Value *V : I.operands())
696 if (containsGCPtrType(V->getType()) &&
697 isNotExclusivelyConstantDerived(V) && !AvailableSet.count(V)) {
698 if (isValuePoisoned(V))
699 PoisonedPointerDef = true;
701 ValidUnrelocatedPointerDef = true;
705 assert(!(ValidUnrelocatedPointerDef && PoisonedPointerDef) &&
706 "Value cannot be both unrelocated and poisoned!");
707 if (ValidUnrelocatedPointerDef) {
708 // Remove def of unrelocated pointer from Contribution of this BB and
709 // trigger update of all its successors.
710 Contribution.erase(&I);
711 PoisonedDefs.erase(&I);
712 ValidUnrelocatedDefs.insert(&I);
713 LLVM_DEBUG(dbgs() << "Removing urelocated " << I
714 << " from Contribution of " << BB->getName() << "\n");
715 ContributionChanged = true;
716 } else if (PoisonedPointerDef) {
717 // Mark pointer as poisoned, remove its def from Contribution and trigger
718 // update of all successors.
719 Contribution.erase(&I);
720 PoisonedDefs.insert(&I);
721 LLVM_DEBUG(dbgs() << "Removing poisoned " << I << " from Contribution of "
722 << BB->getName() << "\n");
723 ContributionChanged = true;
725 bool Cleared = false;
726 transferInstruction(I, Cleared, AvailableSet);
730 return ContributionChanged;
733 void GCPtrTracker::gatherDominatingDefs(const BasicBlock *BB,
734 AvailableValueSet &Result,
735 const DominatorTree &DT) {
736 DomTreeNode *DTN = DT[const_cast<BasicBlock *>(BB)];
738 assert(DTN && "Unreachable blocks are ignored");
739 while (DTN->getIDom()) {
740 DTN = DTN->getIDom();
741 auto BBS = getBasicBlockState(DTN->getBlock());
742 assert(BBS && "immediate dominator cannot be dead for a live block");
743 const auto &Defs = BBS->Contribution;
744 Result.insert(Defs.begin(), Defs.end());
745 // If this block is 'Cleared', then nothing LiveIn to this block can be
746 // available after this block completes. Note: This turns out to be
747 // really important for reducing memory consuption of the initial available
748 // sets and thus peak memory usage by this verifier.
753 for (const Argument &A : BB->getParent()->args())
754 if (containsGCPtrType(A.getType()))
758 void GCPtrTracker::transferBlock(const BasicBlock *BB, BasicBlockState &BBS,
759 bool ContributionChanged) {
760 const AvailableValueSet &AvailableIn = BBS.AvailableIn;
761 AvailableValueSet &AvailableOut = BBS.AvailableOut;
764 // AvailableOut will change only when Contribution changed.
765 if (ContributionChanged)
766 AvailableOut = BBS.Contribution;
768 // Otherwise, we need to reduce the AvailableOut set by things which are no
769 // longer in our AvailableIn
770 AvailableValueSet Temp = BBS.Contribution;
771 set_union(Temp, AvailableIn);
772 AvailableOut = std::move(Temp);
775 LLVM_DEBUG(dbgs() << "Transfered block " << BB->getName() << " from ";
776 PrintValueSet(dbgs(), AvailableIn.begin(), AvailableIn.end());
778 PrintValueSet(dbgs(), AvailableOut.begin(), AvailableOut.end());
782 void GCPtrTracker::transferInstruction(const Instruction &I, bool &Cleared,
783 AvailableValueSet &Available) {
784 if (isa<GCStatepointInst>(I)) {
787 } else if (containsGCPtrType(I.getType()))
788 Available.insert(&I);
791 void InstructionVerifier::verifyInstruction(
792 const GCPtrTracker *Tracker, const Instruction &I,
793 const AvailableValueSet &AvailableSet) {
794 if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
795 if (containsGCPtrType(PN->getType()))
796 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
797 const BasicBlock *InBB = PN->getIncomingBlock(i);
798 const BasicBlockState *InBBS = Tracker->getBasicBlockState(InBB);
800 !Tracker->hasLiveIncomingEdge(PN, InBB))
801 continue; // Skip dead block or dead edge.
803 const Value *InValue = PN->getIncomingValue(i);
805 if (isNotExclusivelyConstantDerived(InValue) &&
806 !InBBS->AvailableOut.count(InValue))
807 reportInvalidUse(*InValue, *PN);
809 } else if (isa<CmpInst>(I) &&
810 containsGCPtrType(I.getOperand(0)->getType())) {
811 Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
812 enum BaseType baseTyLHS = getBaseType(LHS),
813 baseTyRHS = getBaseType(RHS);
815 // Returns true if LHS and RHS are unrelocated pointers and they are
816 // valid unrelocated uses.
817 auto hasValidUnrelocatedUse = [&AvailableSet, Tracker, baseTyLHS, baseTyRHS,
819 // A cmp instruction has valid unrelocated pointer operands only if
820 // both operands are unrelocated pointers.
821 // In the comparison between two pointers, if one is an unrelocated
822 // use, the other *should be* an unrelocated use, for this
823 // instruction to contain valid unrelocated uses. This unrelocated
824 // use can be a null constant as well, or another unrelocated
826 if (AvailableSet.count(LHS) || AvailableSet.count(RHS))
828 // Constant pointers (that are not exclusively null) may have
829 // meaning in different VMs, so we cannot reorder the compare
830 // against constant pointers before the safepoint. In other words,
831 // comparison of an unrelocated use against a non-null constant
833 if ((baseTyLHS == BaseType::ExclusivelySomeConstant &&
834 baseTyRHS == BaseType::NonConstant) ||
835 (baseTyLHS == BaseType::NonConstant &&
836 baseTyRHS == BaseType::ExclusivelySomeConstant))
839 // If one of pointers is poisoned and other is not exclusively derived
840 // from null it is an invalid expression: it produces poisoned result
841 // and unless we want to track all defs (not only gc pointers) the only
842 // option is to prohibit such instructions.
843 if ((Tracker->isValuePoisoned(LHS) && baseTyRHS != ExclusivelyNull) ||
844 (Tracker->isValuePoisoned(RHS) && baseTyLHS != ExclusivelyNull))
847 // All other cases are valid cases enumerated below:
848 // 1. Comparison between an exclusively derived null pointer and a
849 // constant base pointer.
850 // 2. Comparison between an exclusively derived null pointer and a
851 // non-constant unrelocated base pointer.
852 // 3. Comparison between 2 unrelocated pointers.
853 // 4. Comparison between a pointer exclusively derived from null and a
854 // non-constant poisoned pointer.
857 if (!hasValidUnrelocatedUse()) {
858 // Print out all non-constant derived pointers that are unrelocated
859 // uses, which are invalid.
860 if (baseTyLHS == BaseType::NonConstant && !AvailableSet.count(LHS))
861 reportInvalidUse(*LHS, I);
862 if (baseTyRHS == BaseType::NonConstant && !AvailableSet.count(RHS))
863 reportInvalidUse(*RHS, I);
866 for (const Value *V : I.operands())
867 if (containsGCPtrType(V->getType()) &&
868 isNotExclusivelyConstantDerived(V) && !AvailableSet.count(V))
869 reportInvalidUse(*V, I);
873 void InstructionVerifier::reportInvalidUse(const Value &V,
874 const Instruction &I) {
875 errs() << "Illegal use of unrelocated value found!\n";
876 errs() << "Def: " << V << "\n";
877 errs() << "Use: " << I << "\n";
880 AnyInvalidUses = true;
883 static void Verify(const Function &F, const DominatorTree &DT,
884 const CFGDeadness &CD) {
885 LLVM_DEBUG(dbgs() << "Verifying gc pointers in function: " << F.getName()
888 dbgs() << "Verifying gc pointers in function: " << F.getName() << "\n";
890 GCPtrTracker Tracker(F, DT, CD);
892 // We now have all the information we need to decide if the use of a heap
893 // reference is legal or not, given our safepoint semantics.
895 InstructionVerifier Verifier;
896 GCPtrTracker::verifyFunction(std::move(Tracker), Verifier);
898 if (PrintOnly && !Verifier.hasAnyInvalidUses()) {
899 dbgs() << "No illegal uses found by SafepointIRVerifier in: " << F.getName()