Lines Matching defs:BB
180 const BlockCacheEntry *getBlockEntry(BasicBlock *BB) const {
181 auto It = BlockCache.find_as(BB);
187 BlockCacheEntry *getOrCreateBlockEntry(BasicBlock *BB) {
188 auto It = BlockCache.find_as(BB);
190 It = BlockCache.insert({BB, std::make_unique<BlockCacheEntry>()}).first;
202 void insertResult(Value *Val, BasicBlock *BB,
204 BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);
217 BasicBlock *BB) const {
218 const BlockCacheEntry *Entry = getBlockEntry(BB);
233 isNonNullAtEndOfBlock(Value *V, BasicBlock *BB,
235 BlockCacheEntry *Entry = getOrCreateBlockEntry(BB);
237 Entry->NonNullPointers = InitFn(BB);
256 void eraseBlock(BasicBlock *BB);
284 void LazyValueInfoCache::eraseBlock(BasicBlock *BB) {
285 BlockCache.erase(BB);
356 void emitBasicBlockStartAnnot(const BasicBlock *BB,
398 std::optional<ValueLatticeElement> getBlockValue(Value *Val, BasicBlock *BB,
407 bool solveBlockValue(Value *Val, BasicBlock *BB);
409 BasicBlock *BB);
411 BasicBlock *BB);
413 BasicBlock *BB);
415 BasicBlock *BB);
417 BasicBlock *BB);
419 Instruction *I, BasicBlock *BB,
423 solveBlockValueBinaryOp(BinaryOperator *BBI, BasicBlock *BB);
425 BasicBlock *BB);
427 solveBlockValueOverflowIntrinsic(WithOverflowInst *WO, BasicBlock *BB);
429 BasicBlock *BB);
431 solveBlockValueInsertElement(InsertElementInst *IEI, BasicBlock *BB);
433 solveBlockValueExtractValue(ExtractValueInst *EVI, BasicBlock *BB);
434 bool isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB);
467 ValueLatticeElement getValueInBlock(Value *V, BasicBlock *BB,
501 void eraseBlock(BasicBlock *BB) {
502 TheCache.eraseBlock(BB);
573 LazyValueInfoImpl::getBlockValue(Value *Val, BasicBlock *BB,
580 TheCache.getCachedValueInfo(Val, BB)) {
586 if (!pushBlockValue({ BB, Val }))
614 bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
616 assert(!TheCache.getCachedValueInfo(Val, BB) &&
621 std::optional<ValueLatticeElement> Res = solveBlockValueImpl(Val, BB);
626 TheCache.insertResult(Val, BB, *Res);
631 LazyValueInfoImpl::solveBlockValueImpl(Value *Val, BasicBlock *BB) {
633 if (!BBI || BBI->getParent() != BB)
634 return solveBlockValueNonLocal(Val, BB);
637 return solveBlockValuePHINode(PN, BB);
640 return solveBlockValueSelect(SI, BB);
657 return solveBlockValueCast(CI, BB);
660 return solveBlockValueBinaryOp(BO, BB);
663 return solveBlockValueInsertElement(IEI, BB);
666 return solveBlockValueExtractValue(EVI, BB);
669 return solveBlockValueIntrinsic(II, BB);
672 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
702 bool LazyValueInfoImpl::isNonNullAtEndOfBlock(Value *Val, BasicBlock *BB) {
703 if (NullPointerIsDefined(BB->getParent(),
708 return TheCache.isNonNullAtEndOfBlock(Val, BB, [](BasicBlock *BB) {
710 for (Instruction &I : *BB)
717 LazyValueInfoImpl::solveBlockValueNonLocal(Value *Val, BasicBlock *BB) {
721 if (BB->isEntryBlock()) {
737 for (BasicBlock *Pred : predecessors(BB)) {
738 std::optional<ValueLatticeElement> EdgeResult = getEdgeValue(Val, Pred, BB);
748 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
761 LazyValueInfoImpl::solveBlockValuePHINode(PHINode *PN, BasicBlock *BB) {
774 getEdgeValue(PhiVal, PhiBB, BB, PN);
784 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
804 BasicBlock *BB = BBI->getParent();
813 if (I->getParent() != BB || !isValidAssumeForContext(I, BBI))
823 BBI->getIterator() != BB->begin()) {
825 make_range(std::next(BBI->getIterator().getReverse()), BB->rend())) {
838 if (PTy && BB->getTerminator() == BBI &&
839 isNonNullAtEndOfBlock(Val, BB))
845 LazyValueInfoImpl::solveBlockValueSelect(SelectInst *SI, BasicBlock *BB) {
848 getBlockValue(SI->getTrueValue(), BB, SI);
854 getBlockValue(SI->getFalseValue(), BB, SI);
932 LazyValueInfoImpl::getRangeFor(Value *V, Instruction *CxtI, BasicBlock *BB) {
933 std::optional<ValueLatticeElement> OptVal = getBlockValue(V, BB, CxtI);
940 LazyValueInfoImpl::solveBlockValueCast(CastInst *CI, BasicBlock *BB) {
951 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
959 std::optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB);
976 Instruction *I, BasicBlock *BB,
983 std::optional<ConstantRange> LHSRes = getRangeFor(I->getOperand(0), I, BB);
987 std::optional<ConstantRange> RHSRes = getRangeFor(I->getOperand(1), I, BB);
997 LazyValueInfoImpl::solveBlockValueBinaryOp(BinaryOperator *BO, BasicBlock *BB) {
1003 BO, BB,
1010 BO, BB, [BO](const ConstantRange &CR1, const ConstantRange &CR2) {
1017 BasicBlock *BB) {
1019 WO, BB, [WO](const ConstantRange &CR1, const ConstantRange &CR2) {
1025 LazyValueInfoImpl::solveBlockValueIntrinsic(IntrinsicInst *II, BasicBlock *BB) {
1028 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
1035 std::optional<ConstantRange> Range = getRangeFor(Op, II, BB);
1048 BasicBlock *BB) {
1050 getBlockValue(IEI->getOperand(1), BB, IEI);
1056 getBlockValue(IEI->getOperand(0), BB, IEI);
1066 BasicBlock *BB) {
1069 return solveBlockValueOverflowIntrinsic(WO, BB);
1076 return getBlockValue(V, BB, EVI);
1078 LLVM_DEBUG(dbgs() << " compute BB '" << BB->getName()
1529 ValueLatticeElement LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
1532 << BB->getName() << "'\n");
1535 std::optional<ValueLatticeElement> OptResult = getBlockValue(V, BB, CxtI);
1538 OptResult = getBlockValue(V, BB, CxtI);
1728 BasicBlock *BB = CxtI->getParent();
1730 getOrCreateImpl(BB->getModule()).getValueInBlock(V, BB, CxtI);
1744 BasicBlock *BB = CxtI->getParent();
1746 getOrCreateImpl(BB->getModule()).getValueInBlock(V, BB, CxtI);
1885 // We limit the search to one step backwards from the current BB and value.
1889 BasicBlock *BB = CxtI->getParent();
1893 pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
1902 if (PHI->getParent() == BB) {
1907 // Note that PredBB may be BB itself.
1909 getPredicateOnEdge(Pred, Incoming, C, PredBB, BB, CxtI);
1926 if (!isa<Instruction>(V) || cast<Instruction>(V)->getParent() != BB) {
1930 Constant *Baseline = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
1934 Constant *Ret = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
1986 void LazyValueInfo::eraseBlock(BasicBlock *BB) {
1988 Impl->eraseBlock(BB);
2003 const BasicBlock *BB, formatted_raw_ostream &OS) {
2005 auto *F = BB->getParent();
2008 const_cast<Argument *>(&Arg), const_cast<BasicBlock *>(BB));
2029 auto printResult = [&](const BasicBlock *BB) {
2030 if (!BlocksContainingLVI.insert(BB).second)
2033 const_cast<Instruction *>(I), const_cast<BasicBlock *>(BB));
2034 OS << "; LatticeVal for: '" << *I << "' in BB: '";
2035 BB->printAsOperand(OS, false);