1 //===- AssumeBundleBuilder.cpp - tools to preserve informations -*- C++ -*-===// 2 // 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 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h" 10 #include "llvm/ADT/DepthFirstIterator.h" 11 #include "llvm/ADT/MapVector.h" 12 #include "llvm/ADT/Statistic.h" 13 #include "llvm/Analysis/AssumeBundleQueries.h" 14 #include "llvm/Analysis/AssumptionCache.h" 15 #include "llvm/Analysis/ValueTracking.h" 16 #include "llvm/IR/Dominators.h" 17 #include "llvm/IR/Function.h" 18 #include "llvm/IR/InstIterator.h" 19 #include "llvm/IR/IntrinsicInst.h" 20 #include "llvm/IR/Module.h" 21 #include "llvm/IR/Operator.h" 22 #include "llvm/Support/CommandLine.h" 23 #include "llvm/Support/DebugCounter.h" 24 #include "llvm/Transforms/Utils/Local.h" 25 26 using namespace llvm; 27 28 namespace llvm { 29 cl::opt<bool> ShouldPreserveAllAttributes( 30 "assume-preserve-all", cl::init(false), cl::Hidden, 31 cl::desc("enable preservation of all attributes. even those that are " 32 "unlikely to be useful")); 33 34 cl::opt<bool> EnableKnowledgeRetention( 35 "enable-knowledge-retention", cl::init(false), cl::Hidden, 36 cl::desc( 37 "enable preservation of attributes throughout code transformation")); 38 } // namespace llvm 39 40 #define DEBUG_TYPE "assume-builder" 41 42 STATISTIC(NumAssumeBuilt, "Number of assume built by the assume builder"); 43 STATISTIC(NumBundlesInAssumes, "Total number of Bundles in the assume built"); 44 STATISTIC(NumAssumesMerged, 45 "Number of assume merged by the assume simplify pass"); 46 STATISTIC(NumAssumesRemoved, 47 "Number of assume removed by the assume simplify pass"); 48 49 DEBUG_COUNTER(BuildAssumeCounter, "assume-builder-counter", 50 "Controls which assumes gets created"); 51 52 namespace { 53 54 bool isUsefullToPreserve(Attribute::AttrKind Kind) { 55 switch (Kind) { 56 case Attribute::NonNull: 57 case Attribute::NoUndef: 58 case Attribute::Alignment: 59 case Attribute::Dereferenceable: 60 case Attribute::DereferenceableOrNull: 61 case Attribute::Cold: 62 return true; 63 default: 64 return false; 65 } 66 } 67 68 /// This function will try to transform the given knowledge into a more 69 /// canonical one. the canonical knowledge maybe the given one. 70 RetainedKnowledge canonicalizedKnowledge(RetainedKnowledge RK, 71 const DataLayout &DL) { 72 switch (RK.AttrKind) { 73 default: 74 return RK; 75 case Attribute::NonNull: 76 RK.WasOn = getUnderlyingObject(RK.WasOn); 77 return RK; 78 case Attribute::Alignment: { 79 Value *V = RK.WasOn->stripInBoundsOffsets([&](const Value *Strip) { 80 if (auto *GEP = dyn_cast<GEPOperator>(Strip)) 81 RK.ArgValue = 82 MinAlign(RK.ArgValue, GEP->getMaxPreservedAlignment(DL).value()); 83 }); 84 RK.WasOn = V; 85 return RK; 86 } 87 case Attribute::Dereferenceable: 88 case Attribute::DereferenceableOrNull: { 89 int64_t Offset = 0; 90 Value *V = GetPointerBaseWithConstantOffset(RK.WasOn, Offset, DL, 91 /*AllowNonInBounds*/ false); 92 if (Offset < 0) 93 return RK; 94 RK.ArgValue = RK.ArgValue + Offset; 95 RK.WasOn = V; 96 } 97 } 98 return RK; 99 } 100 101 /// This class contain all knowledge that have been gather while building an 102 /// llvm.assume and the function to manipulate it. 103 struct AssumeBuilderState { 104 Module *M; 105 106 using MapKey = std::pair<Value *, Attribute::AttrKind>; 107 SmallMapVector<MapKey, uint64_t, 8> AssumedKnowledgeMap; 108 Instruction *InstBeingModified = nullptr; 109 AssumptionCache* AC = nullptr; 110 DominatorTree* DT = nullptr; 111 112 AssumeBuilderState(Module *M, Instruction *I = nullptr, 113 AssumptionCache *AC = nullptr, DominatorTree *DT = nullptr) 114 : M(M), InstBeingModified(I), AC(AC), DT(DT) {} 115 116 bool tryToPreserveWithoutAddingAssume(RetainedKnowledge RK) { 117 if (!InstBeingModified || !RK.WasOn) 118 return false; 119 bool HasBeenPreserved = false; 120 Use* ToUpdate = nullptr; 121 getKnowledgeForValue( 122 RK.WasOn, {RK.AttrKind}, AC, 123 [&](RetainedKnowledge RKOther, Instruction *Assume, 124 const CallInst::BundleOpInfo *Bundle) { 125 if (!isValidAssumeForContext(Assume, InstBeingModified, DT)) 126 return false; 127 if (RKOther.ArgValue >= RK.ArgValue) { 128 HasBeenPreserved = true; 129 return true; 130 } else if (isValidAssumeForContext(InstBeingModified, Assume, DT)) { 131 HasBeenPreserved = true; 132 IntrinsicInst *Intr = cast<IntrinsicInst>(Assume); 133 ToUpdate = &Intr->op_begin()[Bundle->Begin + ABA_Argument]; 134 return true; 135 } 136 return false; 137 }); 138 if (ToUpdate) 139 ToUpdate->set( 140 ConstantInt::get(Type::getInt64Ty(M->getContext()), RK.ArgValue)); 141 return HasBeenPreserved; 142 } 143 144 bool isKnowledgeWorthPreserving(RetainedKnowledge RK) { 145 if (!RK) 146 return false; 147 if (!RK.WasOn) 148 return true; 149 if (RK.WasOn->getType()->isPointerTy()) { 150 Value *UnderlyingPtr = getUnderlyingObject(RK.WasOn); 151 if (isa<AllocaInst>(UnderlyingPtr) || isa<GlobalValue>(UnderlyingPtr)) 152 return false; 153 } 154 if (auto *Arg = dyn_cast<Argument>(RK.WasOn)) { 155 if (Arg->hasAttribute(RK.AttrKind) && 156 (!Attribute::isIntAttrKind(RK.AttrKind) || 157 Arg->getAttribute(RK.AttrKind).getValueAsInt() >= RK.ArgValue)) 158 return false; 159 return true; 160 } 161 if (auto *Inst = dyn_cast<Instruction>(RK.WasOn)) 162 if (wouldInstructionBeTriviallyDead(Inst)) { 163 if (RK.WasOn->use_empty()) 164 return false; 165 Use *SingleUse = RK.WasOn->getSingleUndroppableUse(); 166 if (SingleUse && SingleUse->getUser() == InstBeingModified) 167 return false; 168 } 169 return true; 170 } 171 172 void addKnowledge(RetainedKnowledge RK) { 173 RK = canonicalizedKnowledge(RK, M->getDataLayout()); 174 175 if (!isKnowledgeWorthPreserving(RK)) 176 return; 177 178 if (tryToPreserveWithoutAddingAssume(RK)) 179 return; 180 MapKey Key{RK.WasOn, RK.AttrKind}; 181 auto Lookup = AssumedKnowledgeMap.find(Key); 182 if (Lookup == AssumedKnowledgeMap.end()) { 183 AssumedKnowledgeMap[Key] = RK.ArgValue; 184 return; 185 } 186 assert(((Lookup->second == 0 && RK.ArgValue == 0) || 187 (Lookup->second != 0 && RK.ArgValue != 0)) && 188 "inconsistent argument value"); 189 190 /// This is only desirable because for all attributes taking an argument 191 /// higher is better. 192 Lookup->second = std::max(Lookup->second, RK.ArgValue); 193 } 194 195 void addAttribute(Attribute Attr, Value *WasOn) { 196 if (Attr.isTypeAttribute() || Attr.isStringAttribute() || 197 (!ShouldPreserveAllAttributes && 198 !isUsefullToPreserve(Attr.getKindAsEnum()))) 199 return; 200 uint64_t AttrArg = 0; 201 if (Attr.isIntAttribute()) 202 AttrArg = Attr.getValueAsInt(); 203 addKnowledge({Attr.getKindAsEnum(), AttrArg, WasOn}); 204 } 205 206 void addCall(const CallBase *Call) { 207 auto addAttrList = [&](AttributeList AttrList, unsigned NumArgs) { 208 for (unsigned Idx = 0; Idx < NumArgs; Idx++) 209 for (Attribute Attr : AttrList.getParamAttrs(Idx)) { 210 bool IsPoisonAttr = Attr.hasAttribute(Attribute::NonNull) || 211 Attr.hasAttribute(Attribute::Alignment); 212 if (!IsPoisonAttr || Call->isPassingUndefUB(Idx)) 213 addAttribute(Attr, Call->getArgOperand(Idx)); 214 } 215 for (Attribute Attr : AttrList.getFnAttrs()) 216 addAttribute(Attr, nullptr); 217 }; 218 addAttrList(Call->getAttributes(), Call->arg_size()); 219 if (Function *Fn = Call->getCalledFunction()) 220 addAttrList(Fn->getAttributes(), Fn->arg_size()); 221 } 222 223 AssumeInst *build() { 224 if (AssumedKnowledgeMap.empty()) 225 return nullptr; 226 if (!DebugCounter::shouldExecute(BuildAssumeCounter)) 227 return nullptr; 228 Function *FnAssume = 229 Intrinsic::getOrInsertDeclaration(M, Intrinsic::assume); 230 LLVMContext &C = M->getContext(); 231 SmallVector<OperandBundleDef, 8> OpBundle; 232 for (auto &MapElem : AssumedKnowledgeMap) { 233 SmallVector<Value *, 2> Args; 234 if (MapElem.first.first) 235 Args.push_back(MapElem.first.first); 236 237 /// This is only valid because for all attribute that currently exist a 238 /// value of 0 is useless. and should not be preserved. 239 if (MapElem.second) 240 Args.push_back(ConstantInt::get(Type::getInt64Ty(M->getContext()), 241 MapElem.second)); 242 OpBundle.push_back(OperandBundleDefT<Value *>( 243 std::string(Attribute::getNameFromAttrKind(MapElem.first.second)), 244 Args)); 245 NumBundlesInAssumes++; 246 } 247 NumAssumeBuilt++; 248 return cast<AssumeInst>(CallInst::Create( 249 FnAssume, ArrayRef<Value *>({ConstantInt::getTrue(C)}), OpBundle)); 250 } 251 252 void addAccessedPtr(Instruction *MemInst, Value *Pointer, Type *AccType, 253 MaybeAlign MA) { 254 unsigned DerefSize = MemInst->getModule() 255 ->getDataLayout() 256 .getTypeStoreSize(AccType) 257 .getKnownMinValue(); 258 if (DerefSize != 0) { 259 addKnowledge({Attribute::Dereferenceable, DerefSize, Pointer}); 260 if (!NullPointerIsDefined(MemInst->getFunction(), 261 Pointer->getType()->getPointerAddressSpace())) 262 addKnowledge({Attribute::NonNull, 0u, Pointer}); 263 } 264 if (MA.valueOrOne() > 1) 265 addKnowledge({Attribute::Alignment, MA.valueOrOne().value(), Pointer}); 266 } 267 268 void addInstruction(Instruction *I) { 269 if (auto *Call = dyn_cast<CallBase>(I)) 270 return addCall(Call); 271 if (auto *Load = dyn_cast<LoadInst>(I)) 272 return addAccessedPtr(I, Load->getPointerOperand(), Load->getType(), 273 Load->getAlign()); 274 if (auto *Store = dyn_cast<StoreInst>(I)) 275 return addAccessedPtr(I, Store->getPointerOperand(), 276 Store->getValueOperand()->getType(), 277 Store->getAlign()); 278 // TODO: Add support for the other Instructions. 279 // TODO: Maybe we should look around and merge with other llvm.assume. 280 } 281 }; 282 283 } // namespace 284 285 AssumeInst *llvm::buildAssumeFromInst(Instruction *I) { 286 if (!EnableKnowledgeRetention) 287 return nullptr; 288 AssumeBuilderState Builder(I->getModule()); 289 Builder.addInstruction(I); 290 return Builder.build(); 291 } 292 293 bool llvm::salvageKnowledge(Instruction *I, AssumptionCache *AC, 294 DominatorTree *DT) { 295 if (!EnableKnowledgeRetention || I->isTerminator()) 296 return false; 297 bool Changed = false; 298 AssumeBuilderState Builder(I->getModule(), I, AC, DT); 299 Builder.addInstruction(I); 300 if (auto *Intr = Builder.build()) { 301 Intr->insertBefore(I->getIterator()); 302 Changed = true; 303 if (AC) 304 AC->registerAssumption(Intr); 305 } 306 return Changed; 307 } 308 309 AssumeInst * 310 llvm::buildAssumeFromKnowledge(ArrayRef<RetainedKnowledge> Knowledge, 311 Instruction *CtxI, AssumptionCache *AC, 312 DominatorTree *DT) { 313 AssumeBuilderState Builder(CtxI->getModule(), CtxI, AC, DT); 314 for (const RetainedKnowledge &RK : Knowledge) 315 Builder.addKnowledge(RK); 316 return Builder.build(); 317 } 318 319 RetainedKnowledge llvm::simplifyRetainedKnowledge(AssumeInst *Assume, 320 RetainedKnowledge RK, 321 AssumptionCache *AC, 322 DominatorTree *DT) { 323 AssumeBuilderState Builder(Assume->getModule(), Assume, AC, DT); 324 RK = canonicalizedKnowledge(RK, Assume->getDataLayout()); 325 326 if (!Builder.isKnowledgeWorthPreserving(RK)) 327 return RetainedKnowledge::none(); 328 329 if (Builder.tryToPreserveWithoutAddingAssume(RK)) 330 return RetainedKnowledge::none(); 331 return RK; 332 } 333 334 namespace { 335 336 struct AssumeSimplify { 337 Function &F; 338 AssumptionCache &AC; 339 DominatorTree *DT; 340 LLVMContext &C; 341 SmallDenseSet<IntrinsicInst *> CleanupToDo; 342 StringMapEntry<uint32_t> *IgnoreTag; 343 SmallDenseMap<BasicBlock *, SmallVector<IntrinsicInst *, 4>, 8> BBToAssume; 344 bool MadeChange = false; 345 346 AssumeSimplify(Function &F, AssumptionCache &AC, DominatorTree *DT, 347 LLVMContext &C) 348 : F(F), AC(AC), DT(DT), C(C), 349 IgnoreTag(C.getOrInsertBundleTag(IgnoreBundleTag)) {} 350 351 void buildMapping(bool FilterBooleanArgument) { 352 BBToAssume.clear(); 353 for (Value *V : AC.assumptions()) { 354 if (!V) 355 continue; 356 IntrinsicInst *Assume = cast<IntrinsicInst>(V); 357 if (FilterBooleanArgument) { 358 auto *Arg = dyn_cast<ConstantInt>(Assume->getOperand(0)); 359 if (!Arg || Arg->isZero()) 360 continue; 361 } 362 BBToAssume[Assume->getParent()].push_back(Assume); 363 } 364 365 for (auto &Elem : BBToAssume) { 366 llvm::sort(Elem.second, 367 [](const IntrinsicInst *LHS, const IntrinsicInst *RHS) { 368 return LHS->comesBefore(RHS); 369 }); 370 } 371 } 372 373 /// Remove all asumes in CleanupToDo if there boolean argument is true and 374 /// ForceCleanup is set or the assume doesn't hold valuable knowledge. 375 void RunCleanup(bool ForceCleanup) { 376 for (IntrinsicInst *Assume : CleanupToDo) { 377 auto *Arg = dyn_cast<ConstantInt>(Assume->getOperand(0)); 378 if (!Arg || Arg->isZero() || 379 (!ForceCleanup && 380 !isAssumeWithEmptyBundle(cast<AssumeInst>(*Assume)))) 381 continue; 382 MadeChange = true; 383 if (ForceCleanup) 384 NumAssumesMerged++; 385 else 386 NumAssumesRemoved++; 387 Assume->eraseFromParent(); 388 } 389 CleanupToDo.clear(); 390 } 391 392 /// Remove knowledge stored in assume when it is already know by an attribute 393 /// or an other assume. This can when valid update an existing knowledge in an 394 /// attribute or an other assume. 395 void dropRedundantKnowledge() { 396 struct MapValue { 397 IntrinsicInst *Assume; 398 uint64_t ArgValue; 399 CallInst::BundleOpInfo *BOI; 400 }; 401 buildMapping(false); 402 SmallDenseMap<std::pair<Value *, Attribute::AttrKind>, 403 SmallVector<MapValue, 2>, 16> 404 Knowledge; 405 for (BasicBlock *BB : depth_first(&F)) 406 for (Value *V : BBToAssume[BB]) { 407 if (!V) 408 continue; 409 IntrinsicInst *Assume = cast<IntrinsicInst>(V); 410 for (CallInst::BundleOpInfo &BOI : Assume->bundle_op_infos()) { 411 auto RemoveFromAssume = [&]() { 412 CleanupToDo.insert(Assume); 413 if (BOI.Begin != BOI.End) { 414 Use *U = &Assume->op_begin()[BOI.Begin + ABA_WasOn]; 415 U->set(PoisonValue::get(U->get()->getType())); 416 } 417 BOI.Tag = IgnoreTag; 418 }; 419 if (BOI.Tag == IgnoreTag) { 420 CleanupToDo.insert(Assume); 421 continue; 422 } 423 RetainedKnowledge RK = 424 getKnowledgeFromBundle(cast<AssumeInst>(*Assume), BOI); 425 if (auto *Arg = dyn_cast_or_null<Argument>(RK.WasOn)) { 426 bool HasSameKindAttr = Arg->hasAttribute(RK.AttrKind); 427 if (HasSameKindAttr) 428 if (!Attribute::isIntAttrKind(RK.AttrKind) || 429 Arg->getAttribute(RK.AttrKind).getValueAsInt() >= 430 RK.ArgValue) { 431 RemoveFromAssume(); 432 continue; 433 } 434 if (isValidAssumeForContext( 435 Assume, &*F.getEntryBlock().getFirstInsertionPt()) || 436 Assume == &*F.getEntryBlock().getFirstInsertionPt()) { 437 if (HasSameKindAttr) 438 Arg->removeAttr(RK.AttrKind); 439 Arg->addAttr(Attribute::get(C, RK.AttrKind, RK.ArgValue)); 440 MadeChange = true; 441 RemoveFromAssume(); 442 continue; 443 } 444 } 445 auto &Lookup = Knowledge[{RK.WasOn, RK.AttrKind}]; 446 for (MapValue &Elem : Lookup) { 447 if (!isValidAssumeForContext(Elem.Assume, Assume, DT)) 448 continue; 449 if (Elem.ArgValue >= RK.ArgValue) { 450 RemoveFromAssume(); 451 continue; 452 } else if (isValidAssumeForContext(Assume, Elem.Assume, DT)) { 453 Elem.Assume->op_begin()[Elem.BOI->Begin + ABA_Argument].set( 454 ConstantInt::get(Type::getInt64Ty(C), RK.ArgValue)); 455 MadeChange = true; 456 RemoveFromAssume(); 457 continue; 458 } 459 } 460 Lookup.push_back({Assume, RK.ArgValue, &BOI}); 461 } 462 } 463 } 464 465 using MergeIterator = SmallVectorImpl<IntrinsicInst *>::iterator; 466 467 /// Merge all Assumes from Begin to End in and insert the resulting assume as 468 /// high as possible in the basicblock. 469 void mergeRange(BasicBlock *BB, MergeIterator Begin, MergeIterator End) { 470 if (Begin == End || std::next(Begin) == End) 471 return; 472 /// Provide no additional information so that AssumeBuilderState doesn't 473 /// try to do any punning since it already has been done better. 474 AssumeBuilderState Builder(F.getParent()); 475 476 /// For now it is initialized to the best value it could have 477 BasicBlock::iterator InsertPt = BB->getFirstNonPHIIt(); 478 if (isa<LandingPadInst>(InsertPt)) 479 InsertPt = std::next(InsertPt); 480 for (IntrinsicInst *I : make_range(Begin, End)) { 481 CleanupToDo.insert(I); 482 for (CallInst::BundleOpInfo &BOI : I->bundle_op_infos()) { 483 RetainedKnowledge RK = 484 getKnowledgeFromBundle(cast<AssumeInst>(*I), BOI); 485 if (!RK) 486 continue; 487 Builder.addKnowledge(RK); 488 if (auto *I = dyn_cast_or_null<Instruction>(RK.WasOn)) 489 if (I->getParent() == InsertPt->getParent() && 490 (InsertPt->comesBefore(I) || &*InsertPt == I)) 491 InsertPt = I->getNextNode()->getIterator(); 492 } 493 } 494 495 /// Adjust InsertPt if it is before Begin, since mergeAssumes only 496 /// guarantees we can place the resulting assume between Begin and End. 497 if (InsertPt->comesBefore(*Begin)) 498 for (auto It = (*Begin)->getIterator(), E = InsertPt->getIterator(); 499 It != E; --It) 500 if (!isGuaranteedToTransferExecutionToSuccessor(&*It)) { 501 InsertPt = std::next(It); 502 break; 503 } 504 auto *MergedAssume = Builder.build(); 505 if (!MergedAssume) 506 return; 507 MadeChange = true; 508 MergedAssume->insertBefore(InsertPt); 509 AC.registerAssumption(MergedAssume); 510 } 511 512 /// Merge assume when they are in the same BasicBlock and for all instruction 513 /// between them isGuaranteedToTransferExecutionToSuccessor returns true. 514 void mergeAssumes() { 515 buildMapping(true); 516 517 SmallVector<MergeIterator, 4> SplitPoints; 518 for (auto &Elem : BBToAssume) { 519 SmallVectorImpl<IntrinsicInst *> &AssumesInBB = Elem.second; 520 if (AssumesInBB.size() < 2) 521 continue; 522 /// AssumesInBB is already sorted by order in the block. 523 524 BasicBlock::iterator It = AssumesInBB.front()->getIterator(); 525 BasicBlock::iterator E = AssumesInBB.back()->getIterator(); 526 SplitPoints.push_back(AssumesInBB.begin()); 527 MergeIterator LastSplit = AssumesInBB.begin(); 528 for (; It != E; ++It) 529 if (!isGuaranteedToTransferExecutionToSuccessor(&*It)) { 530 for (; (*LastSplit)->comesBefore(&*It); ++LastSplit) 531 ; 532 if (SplitPoints.back() != LastSplit) 533 SplitPoints.push_back(LastSplit); 534 } 535 SplitPoints.push_back(AssumesInBB.end()); 536 for (auto SplitIt = SplitPoints.begin(); 537 SplitIt != std::prev(SplitPoints.end()); SplitIt++) { 538 mergeRange(Elem.first, *SplitIt, *(SplitIt + 1)); 539 } 540 SplitPoints.clear(); 541 } 542 } 543 }; 544 545 bool simplifyAssumes(Function &F, AssumptionCache *AC, DominatorTree *DT) { 546 AssumeSimplify AS(F, *AC, DT, F.getContext()); 547 548 /// Remove knowledge that is already known by a dominating other assume or an 549 /// attribute. 550 AS.dropRedundantKnowledge(); 551 552 /// Remove assume that are empty. 553 AS.RunCleanup(false); 554 555 /// Merge assume in the same basicblock when possible. 556 AS.mergeAssumes(); 557 558 /// Remove assume that were merged. 559 AS.RunCleanup(true); 560 return AS.MadeChange; 561 } 562 563 } // namespace 564 565 PreservedAnalyses AssumeSimplifyPass::run(Function &F, 566 FunctionAnalysisManager &AM) { 567 if (!EnableKnowledgeRetention) 568 return PreservedAnalyses::all(); 569 if (!simplifyAssumes(F, &AM.getResult<AssumptionAnalysis>(F), 570 AM.getCachedResult<DominatorTreeAnalysis>(F))) 571 return PreservedAnalyses::all(); 572 PreservedAnalyses PA; 573 PA.preserveSet<CFGAnalyses>(); 574 return PA; 575 } 576 577 PreservedAnalyses AssumeBuilderPass::run(Function &F, 578 FunctionAnalysisManager &AM) { 579 AssumptionCache *AC = &AM.getResult<AssumptionAnalysis>(F); 580 DominatorTree* DT = AM.getCachedResult<DominatorTreeAnalysis>(F); 581 bool Changed = false; 582 for (Instruction &I : instructions(F)) 583 Changed |= salvageKnowledge(&I, AC, DT); 584 if (!Changed) 585 PreservedAnalyses::all(); 586 PreservedAnalyses PA; 587 PA.preserveSet<CFGAnalyses>(); 588 return PA; 589 } 590