MergedLoadStoreMotion.cpp revision 274955
1221337Sdim//===- MergedLoadStoreMotion.cpp - merge and hoist/sink load/stores -------===// 2221337Sdim// 3221337Sdim// The LLVM Compiler Infrastructure 4221337Sdim// 5221337Sdim// This file is distributed under the University of Illinois Open Source 6221337Sdim// License. See LICENSE.TXT for details. 7221337Sdim// 8221337Sdim//===----------------------------------------------------------------------===// 9221337Sdim// 10221337Sdim//! \file 11221337Sdim//! \brief This pass performs merges of loads and stores on both sides of a 12221337Sdim// diamond (hammock). It hoists the loads and sinks the stores. 13221337Sdim// 14221337Sdim// The algorithm iteratively hoists two loads to the same address out of a 15221337Sdim// diamond (hammock) and merges them into a single load in the header. Similar 16221337Sdim// it sinks and merges two stores to the tail block (footer). The algorithm 17221337Sdim// iterates over the instructions of one side of the diamond and attempts to 18221337Sdim// find a matching load/store on the other side. It hoists / sinks when it 19221337Sdim// thinks it safe to do so. This optimization helps with eg. hiding load 20221337Sdim// latencies, triggering if-conversion, and reducing static code size. 21221337Sdim// 22221337Sdim//===----------------------------------------------------------------------===// 23221337Sdim// 24221337Sdim// 25221337Sdim// Example: 26221337Sdim// Diamond shaped code before merge: 27221337Sdim// 28221337Sdim// header: 29221337Sdim// br %cond, label %if.then, label %if.else 30221337Sdim// / \ 31221337Sdim// / \ 32221337Sdim// / \ 33221337Sdim// if.then: if.else: 34221337Sdim// %lt = load %addr_l %le = load %addr_l 35221337Sdim// <use %lt> <use %le> 36221337Sdim// <...> <...> 37221337Sdim// store %st, %addr_s store %se, %addr_s 38221337Sdim// br label %if.end br label %if.end 39221337Sdim// \ / 40221337Sdim// \ / 41221337Sdim// \ / 42221337Sdim// if.end ("footer"): 43221337Sdim// <...> 44221337Sdim// 45221337Sdim// Diamond shaped code after merge: 46221337Sdim// 47221337Sdim// header: 48221337Sdim// %l = load %addr_l 49221337Sdim// br %cond, label %if.then, label %if.else 50221337Sdim// / \ 51221337Sdim// / \ 52221337Sdim// / \ 53221337Sdim// if.then: if.else: 54221337Sdim// <use %l> <use %l> 55223017Sdim// <...> <...> 56221337Sdim// br label %if.end br label %if.end 57221337Sdim// \ / 58221337Sdim// \ / 59221337Sdim// \ / 60221337Sdim// if.end ("footer"): 61221337Sdim// %s.sink = phi [%st, if.then], [%se, if.else] 62221337Sdim// <...> 63223017Sdim// store %s.sink, %addr_s 64221337Sdim// <...> 65221337Sdim// 66221337Sdim// 67221337Sdim//===----------------------- TODO -----------------------------------------===// 68221337Sdim// 69221337Sdim// 1) Generalize to regions other than diamonds 70221337Sdim// 2) Be more aggressive merging memory operations 71221337Sdim// Note that both changes require register pressure control 72221337Sdim// 73221337Sdim//===----------------------------------------------------------------------===// 74221337Sdim 75221337Sdim#include "llvm/Transforms/Scalar.h" 76221337Sdim#include "llvm/ADT/SetVector.h" 77221337Sdim#include "llvm/ADT/SmallPtrSet.h" 78221337Sdim#include "llvm/ADT/Statistic.h" 79221337Sdim#include "llvm/Analysis/AliasAnalysis.h" 80221337Sdim#include "llvm/Analysis/CFG.h" 81221337Sdim#include "llvm/Analysis/Loads.h" 82221337Sdim#include "llvm/Analysis/MemoryBuiltins.h" 83221337Sdim#include "llvm/Analysis/MemoryDependenceAnalysis.h" 84221337Sdim#include "llvm/IR/Metadata.h" 85221337Sdim#include "llvm/IR/PatternMatch.h" 86221337Sdim#include "llvm/Support/Allocator.h" 87221337Sdim#include "llvm/Support/CommandLine.h" 88#include "llvm/Support/Debug.h" 89#include "llvm/Target/TargetLibraryInfo.h" 90#include "llvm/Transforms/Utils/BasicBlockUtils.h" 91#include "llvm/Transforms/Utils/SSAUpdater.h" 92#include <vector> 93using namespace llvm; 94 95#define DEBUG_TYPE "mldst-motion" 96 97//===----------------------------------------------------------------------===// 98// MergedLoadStoreMotion Pass 99//===----------------------------------------------------------------------===// 100static cl::opt<bool> 101EnableMLSM("mlsm", cl::desc("Enable motion of merged load and store"), 102 cl::init(true)); 103 104namespace { 105class MergedLoadStoreMotion : public FunctionPass { 106 AliasAnalysis *AA; 107 MemoryDependenceAnalysis *MD; 108 109public: 110 static char ID; // Pass identification, replacement for typeid 111 explicit MergedLoadStoreMotion(void) 112 : FunctionPass(ID), MD(nullptr), MagicCompileTimeControl(250) { 113 initializeMergedLoadStoreMotionPass(*PassRegistry::getPassRegistry()); 114 } 115 116 bool runOnFunction(Function &F) override; 117 118private: 119 // This transformation requires dominator postdominator info 120 void getAnalysisUsage(AnalysisUsage &AU) const override { 121 AU.addRequired<TargetLibraryInfo>(); 122 AU.addRequired<MemoryDependenceAnalysis>(); 123 AU.addRequired<AliasAnalysis>(); 124 AU.addPreserved<AliasAnalysis>(); 125 } 126 127 // Helper routines 128 129 /// 130 /// \brief Remove instruction from parent and update memory dependence 131 /// analysis. 132 /// 133 void removeInstruction(Instruction *Inst); 134 BasicBlock *getDiamondTail(BasicBlock *BB); 135 bool isDiamondHead(BasicBlock *BB); 136 // Routines for hoisting loads 137 bool isLoadHoistBarrier(Instruction *Inst); 138 LoadInst *canHoistFromBlock(BasicBlock *BB, LoadInst *LI); 139 void hoistInstruction(BasicBlock *BB, Instruction *HoistCand, 140 Instruction *ElseInst); 141 bool isSafeToHoist(Instruction *I) const; 142 bool hoistLoad(BasicBlock *BB, LoadInst *HoistCand, LoadInst *ElseInst); 143 bool mergeLoads(BasicBlock *BB); 144 // Routines for sinking stores 145 StoreInst *canSinkFromBlock(BasicBlock *BB, StoreInst *SI); 146 PHINode *getPHIOperand(BasicBlock *BB, StoreInst *S0, StoreInst *S1); 147 bool isStoreSinkBarrier(Instruction *Inst); 148 bool sinkStore(BasicBlock *BB, StoreInst *SinkCand, StoreInst *ElseInst); 149 bool mergeStores(BasicBlock *BB); 150 // The mergeLoad/Store algorithms could have Size0 * Size1 complexity, 151 // where Size0 and Size1 are the #instructions on the two sides of 152 // the diamond. The constant chosen here is arbitrary. Compiler Time 153 // Control is enforced by the check Size0 * Size1 < MagicCompileTimeControl. 154 const int MagicCompileTimeControl; 155}; 156 157char MergedLoadStoreMotion::ID = 0; 158} 159 160/// 161/// \brief createMergedLoadStoreMotionPass - The public interface to this file. 162/// 163FunctionPass *llvm::createMergedLoadStoreMotionPass() { 164 return new MergedLoadStoreMotion(); 165} 166 167INITIALIZE_PASS_BEGIN(MergedLoadStoreMotion, "mldst-motion", 168 "MergedLoadStoreMotion", false, false) 169INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis) 170INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo) 171INITIALIZE_AG_DEPENDENCY(AliasAnalysis) 172INITIALIZE_PASS_END(MergedLoadStoreMotion, "mldst-motion", 173 "MergedLoadStoreMotion", false, false) 174 175/// 176/// \brief Remove instruction from parent and update memory dependence analysis. 177/// 178void MergedLoadStoreMotion::removeInstruction(Instruction *Inst) { 179 // Notify the memory dependence analysis. 180 if (MD) { 181 MD->removeInstruction(Inst); 182 if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) 183 MD->invalidateCachedPointerInfo(LI->getPointerOperand()); 184 if (Inst->getType()->getScalarType()->isPointerTy()) { 185 MD->invalidateCachedPointerInfo(Inst); 186 } 187 } 188 Inst->eraseFromParent(); 189} 190 191/// 192/// \brief Return tail block of a diamond. 193/// 194BasicBlock *MergedLoadStoreMotion::getDiamondTail(BasicBlock *BB) { 195 assert(isDiamondHead(BB) && "Basic block is not head of a diamond"); 196 BranchInst *BI = (BranchInst *)(BB->getTerminator()); 197 BasicBlock *Succ0 = BI->getSuccessor(0); 198 BasicBlock *Tail = Succ0->getTerminator()->getSuccessor(0); 199 return Tail; 200} 201 202/// 203/// \brief True when BB is the head of a diamond (hammock) 204/// 205bool MergedLoadStoreMotion::isDiamondHead(BasicBlock *BB) { 206 if (!BB) 207 return false; 208 if (!isa<BranchInst>(BB->getTerminator())) 209 return false; 210 if (BB->getTerminator()->getNumSuccessors() != 2) 211 return false; 212 213 BranchInst *BI = (BranchInst *)(BB->getTerminator()); 214 BasicBlock *Succ0 = BI->getSuccessor(0); 215 BasicBlock *Succ1 = BI->getSuccessor(1); 216 217 if (!Succ0->getSinglePredecessor() || 218 Succ0->getTerminator()->getNumSuccessors() != 1) 219 return false; 220 if (!Succ1->getSinglePredecessor() || 221 Succ1->getTerminator()->getNumSuccessors() != 1) 222 return false; 223 224 BasicBlock *Tail = Succ0->getTerminator()->getSuccessor(0); 225 // Ignore triangles. 226 if (Succ1->getTerminator()->getSuccessor(0) != Tail) 227 return false; 228 return true; 229} 230 231/// 232/// \brief True when instruction is a hoist barrier for a load 233/// 234/// Whenever an instruction could possibly modify the value 235/// being loaded or protect against the load from happening 236/// it is considered a hoist barrier. 237/// 238bool MergedLoadStoreMotion::isLoadHoistBarrier(Instruction *Inst) { 239 // FIXME: A call with no side effects should not be a barrier. 240 // Aren't all such calls covered by mayHaveSideEffects() below? 241 // Then this check can be removed. 242 if (isa<CallInst>(Inst)) 243 return true; 244 if (isa<TerminatorInst>(Inst)) 245 return true; 246 // FIXME: Conservatively let a store instruction block the load. 247 // Use alias analysis instead. 248 if (isa<StoreInst>(Inst)) 249 return true; 250 // Note: mayHaveSideEffects covers all instructions that could 251 // trigger a change to state. Eg. in-flight stores have to be executed 252 // before ordered loads or fences, calls could invoke functions that store 253 // data to memory etc. 254 if (Inst->mayHaveSideEffects()) { 255 return true; 256 } 257 DEBUG(dbgs() << "No Hoist Barrier\n"); 258 return false; 259} 260 261/// 262/// \brief Decide if a load can be hoisted 263/// 264/// When there is a load in \p BB to the same address as \p LI 265/// and it can be hoisted from \p BB, return that load. 266/// Otherwise return Null. 267/// 268LoadInst *MergedLoadStoreMotion::canHoistFromBlock(BasicBlock *BB, 269 LoadInst *LI) { 270 LoadInst *I = nullptr; 271 assert(isa<LoadInst>(LI)); 272 if (LI->isUsedOutsideOfBlock(LI->getParent())) 273 return nullptr; 274 275 for (BasicBlock::iterator BBI = BB->begin(), BBE = BB->end(); BBI != BBE; 276 ++BBI) { 277 Instruction *Inst = BBI; 278 279 // Only merge and hoist loads when their result in used only in BB 280 if (isLoadHoistBarrier(Inst)) 281 break; 282 if (!isa<LoadInst>(Inst)) 283 continue; 284 if (Inst->isUsedOutsideOfBlock(Inst->getParent())) 285 continue; 286 287 AliasAnalysis::Location LocLI = AA->getLocation(LI); 288 AliasAnalysis::Location LocInst = AA->getLocation((LoadInst *)Inst); 289 if (AA->isMustAlias(LocLI, LocInst) && LI->getType() == Inst->getType()) { 290 I = (LoadInst *)Inst; 291 break; 292 } 293 } 294 return I; 295} 296 297/// 298/// \brief Merge two equivalent instructions \p HoistCand and \p ElseInst into 299/// \p BB 300/// 301/// BB is the head of a diamond 302/// 303void MergedLoadStoreMotion::hoistInstruction(BasicBlock *BB, 304 Instruction *HoistCand, 305 Instruction *ElseInst) { 306 DEBUG(dbgs() << " Hoist Instruction into BB \n"; BB->dump(); 307 dbgs() << "Instruction Left\n"; HoistCand->dump(); dbgs() << "\n"; 308 dbgs() << "Instruction Right\n"; ElseInst->dump(); dbgs() << "\n"); 309 // Hoist the instruction. 310 assert(HoistCand->getParent() != BB); 311 312 // Intersect optional metadata. 313 HoistCand->intersectOptionalDataWith(ElseInst); 314 HoistCand->dropUnknownMetadata(); 315 316 // Prepend point for instruction insert 317 Instruction *HoistPt = BB->getTerminator(); 318 319 // Merged instruction 320 Instruction *HoistedInst = HoistCand->clone(); 321 322 // Notify AA of the new value. 323 if (isa<LoadInst>(HoistCand)) 324 AA->copyValue(HoistCand, HoistedInst); 325 326 // Hoist instruction. 327 HoistedInst->insertBefore(HoistPt); 328 329 HoistCand->replaceAllUsesWith(HoistedInst); 330 removeInstruction(HoistCand); 331 // Replace the else block instruction. 332 ElseInst->replaceAllUsesWith(HoistedInst); 333 removeInstruction(ElseInst); 334} 335 336/// 337/// \brief Return true if no operand of \p I is defined in I's parent block 338/// 339bool MergedLoadStoreMotion::isSafeToHoist(Instruction *I) const { 340 BasicBlock *Parent = I->getParent(); 341 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) { 342 Instruction *Instr = dyn_cast<Instruction>(I->getOperand(i)); 343 if (Instr && Instr->getParent() == Parent) 344 return false; 345 } 346 return true; 347} 348 349/// 350/// \brief Merge two equivalent loads and GEPs and hoist into diamond head 351/// 352bool MergedLoadStoreMotion::hoistLoad(BasicBlock *BB, LoadInst *L0, 353 LoadInst *L1) { 354 // Only one definition? 355 Instruction *A0 = dyn_cast<Instruction>(L0->getPointerOperand()); 356 Instruction *A1 = dyn_cast<Instruction>(L1->getPointerOperand()); 357 if (A0 && A1 && A0->isIdenticalTo(A1) && isSafeToHoist(A0) && 358 A0->hasOneUse() && (A0->getParent() == L0->getParent()) && 359 A1->hasOneUse() && (A1->getParent() == L1->getParent()) && 360 isa<GetElementPtrInst>(A0)) { 361 DEBUG(dbgs() << "Hoist Instruction into BB \n"; BB->dump(); 362 dbgs() << "Instruction Left\n"; L0->dump(); dbgs() << "\n"; 363 dbgs() << "Instruction Right\n"; L1->dump(); dbgs() << "\n"); 364 hoistInstruction(BB, A0, A1); 365 hoistInstruction(BB, L0, L1); 366 return true; 367 } else 368 return false; 369} 370 371/// 372/// \brief Try to hoist two loads to same address into diamond header 373/// 374/// Starting from a diamond head block, iterate over the instructions in one 375/// successor block and try to match a load in the second successor. 376/// 377bool MergedLoadStoreMotion::mergeLoads(BasicBlock *BB) { 378 bool MergedLoads = false; 379 assert(isDiamondHead(BB)); 380 BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator()); 381 BasicBlock *Succ0 = BI->getSuccessor(0); 382 BasicBlock *Succ1 = BI->getSuccessor(1); 383 // #Instructions in Succ1 for Compile Time Control 384 int Size1 = Succ1->size(); 385 int NLoads = 0; 386 for (BasicBlock::iterator BBI = Succ0->begin(), BBE = Succ0->end(); 387 BBI != BBE;) { 388 389 Instruction *I = BBI; 390 ++BBI; 391 if (isLoadHoistBarrier(I)) 392 break; 393 394 // Only move non-simple (atomic, volatile) loads. 395 if (!isa<LoadInst>(I)) 396 continue; 397 398 LoadInst *L0 = (LoadInst *)I; 399 if (!L0->isSimple()) 400 continue; 401 402 ++NLoads; 403 if (NLoads * Size1 >= MagicCompileTimeControl) 404 break; 405 if (LoadInst *L1 = canHoistFromBlock(Succ1, L0)) { 406 bool Res = hoistLoad(BB, L0, L1); 407 MergedLoads |= Res; 408 // Don't attempt to hoist above loads that had not been hoisted. 409 if (!Res) 410 break; 411 } 412 } 413 return MergedLoads; 414} 415 416/// 417/// \brief True when instruction is sink barrier for a store 418/// 419bool MergedLoadStoreMotion::isStoreSinkBarrier(Instruction *Inst) { 420 // FIXME: Conservatively let a load instruction block the store. 421 // Use alias analysis instead. 422 if (isa<LoadInst>(Inst)) 423 return true; 424 if (isa<CallInst>(Inst)) 425 return true; 426 if (isa<TerminatorInst>(Inst) && !isa<BranchInst>(Inst)) 427 return true; 428 // Note: mayHaveSideEffects covers all instructions that could 429 // trigger a change to state. Eg. in-flight stores have to be executed 430 // before ordered loads or fences, calls could invoke functions that store 431 // data to memory etc. 432 if (!isa<StoreInst>(Inst) && Inst->mayHaveSideEffects()) { 433 return true; 434 } 435 DEBUG(dbgs() << "No Sink Barrier\n"); 436 return false; 437} 438 439/// 440/// \brief Check if \p BB contains a store to the same address as \p SI 441/// 442/// \return The store in \p when it is safe to sink. Otherwise return Null. 443/// 444StoreInst *MergedLoadStoreMotion::canSinkFromBlock(BasicBlock *BB, 445 StoreInst *SI) { 446 StoreInst *I = 0; 447 DEBUG(dbgs() << "can Sink? : "; SI->dump(); dbgs() << "\n"); 448 for (BasicBlock::reverse_iterator RBI = BB->rbegin(), RBE = BB->rend(); 449 RBI != RBE; ++RBI) { 450 Instruction *Inst = &*RBI; 451 452 // Only move loads if they are used in the block. 453 if (isStoreSinkBarrier(Inst)) 454 break; 455 if (isa<StoreInst>(Inst)) { 456 AliasAnalysis::Location LocSI = AA->getLocation(SI); 457 AliasAnalysis::Location LocInst = AA->getLocation((StoreInst *)Inst); 458 if (AA->isMustAlias(LocSI, LocInst)) { 459 I = (StoreInst *)Inst; 460 break; 461 } 462 } 463 } 464 return I; 465} 466 467/// 468/// \brief Create a PHI node in BB for the operands of S0 and S1 469/// 470PHINode *MergedLoadStoreMotion::getPHIOperand(BasicBlock *BB, StoreInst *S0, 471 StoreInst *S1) { 472 // Create a phi if the values mismatch. 473 PHINode *NewPN = 0; 474 Value *Opd1 = S0->getValueOperand(); 475 Value *Opd2 = S1->getValueOperand(); 476 if (Opd1 != Opd2) { 477 NewPN = PHINode::Create(Opd1->getType(), 2, Opd2->getName() + ".sink", 478 BB->begin()); 479 NewPN->addIncoming(Opd1, S0->getParent()); 480 NewPN->addIncoming(Opd2, S1->getParent()); 481 if (NewPN->getType()->getScalarType()->isPointerTy()) { 482 // Notify AA of the new value. 483 AA->copyValue(Opd1, NewPN); 484 AA->copyValue(Opd2, NewPN); 485 // AA needs to be informed when a PHI-use of the pointer value is added 486 for (unsigned I = 0, E = NewPN->getNumIncomingValues(); I != E; ++I) { 487 unsigned J = PHINode::getOperandNumForIncomingValue(I); 488 AA->addEscapingUse(NewPN->getOperandUse(J)); 489 } 490 if (MD) 491 MD->invalidateCachedPointerInfo(NewPN); 492 } 493 } 494 return NewPN; 495} 496 497/// 498/// \brief Merge two stores to same address and sink into \p BB 499/// 500/// Also sinks GEP instruction computing the store address 501/// 502bool MergedLoadStoreMotion::sinkStore(BasicBlock *BB, StoreInst *S0, 503 StoreInst *S1) { 504 // Only one definition? 505 Instruction *A0 = dyn_cast<Instruction>(S0->getPointerOperand()); 506 Instruction *A1 = dyn_cast<Instruction>(S1->getPointerOperand()); 507 if (A0 && A1 && A0->isIdenticalTo(A1) && A0->hasOneUse() && 508 (A0->getParent() == S0->getParent()) && A1->hasOneUse() && 509 (A1->getParent() == S1->getParent()) && isa<GetElementPtrInst>(A0)) { 510 DEBUG(dbgs() << "Sink Instruction into BB \n"; BB->dump(); 511 dbgs() << "Instruction Left\n"; S0->dump(); dbgs() << "\n"; 512 dbgs() << "Instruction Right\n"; S1->dump(); dbgs() << "\n"); 513 // Hoist the instruction. 514 BasicBlock::iterator InsertPt = BB->getFirstInsertionPt(); 515 // Intersect optional metadata. 516 S0->intersectOptionalDataWith(S1); 517 S0->dropUnknownMetadata(); 518 519 // Create the new store to be inserted at the join point. 520 StoreInst *SNew = (StoreInst *)(S0->clone()); 521 Instruction *ANew = A0->clone(); 522 AA->copyValue(S0, SNew); 523 SNew->insertBefore(InsertPt); 524 ANew->insertBefore(SNew); 525 526 assert(S0->getParent() == A0->getParent()); 527 assert(S1->getParent() == A1->getParent()); 528 529 PHINode *NewPN = getPHIOperand(BB, S0, S1); 530 // New PHI operand? Use it. 531 if (NewPN) 532 SNew->setOperand(0, NewPN); 533 removeInstruction(S0); 534 removeInstruction(S1); 535 A0->replaceAllUsesWith(ANew); 536 removeInstruction(A0); 537 A1->replaceAllUsesWith(ANew); 538 removeInstruction(A1); 539 return true; 540 } 541 return false; 542} 543 544/// 545/// \brief True when two stores are equivalent and can sink into the footer 546/// 547/// Starting from a diamond tail block, iterate over the instructions in one 548/// predecessor block and try to match a store in the second predecessor. 549/// 550bool MergedLoadStoreMotion::mergeStores(BasicBlock *T) { 551 552 bool MergedStores = false; 553 assert(T && "Footer of a diamond cannot be empty"); 554 555 pred_iterator PI = pred_begin(T), E = pred_end(T); 556 assert(PI != E); 557 BasicBlock *Pred0 = *PI; 558 ++PI; 559 BasicBlock *Pred1 = *PI; 560 ++PI; 561 // tail block of a diamond/hammock? 562 if (Pred0 == Pred1) 563 return false; // No. 564 if (PI != E) 565 return false; // No. More than 2 predecessors. 566 567 // #Instructions in Succ1 for Compile Time Control 568 int Size1 = Pred1->size(); 569 int NStores = 0; 570 571 for (BasicBlock::reverse_iterator RBI = Pred0->rbegin(), RBE = Pred0->rend(); 572 RBI != RBE;) { 573 574 Instruction *I = &*RBI; 575 ++RBI; 576 if (isStoreSinkBarrier(I)) 577 break; 578 // Sink move non-simple (atomic, volatile) stores 579 if (!isa<StoreInst>(I)) 580 continue; 581 StoreInst *S0 = (StoreInst *)I; 582 if (!S0->isSimple()) 583 continue; 584 585 ++NStores; 586 if (NStores * Size1 >= MagicCompileTimeControl) 587 break; 588 if (StoreInst *S1 = canSinkFromBlock(Pred1, S0)) { 589 bool Res = sinkStore(T, S0, S1); 590 MergedStores |= Res; 591 // Don't attempt to sink below stores that had to stick around 592 // But after removal of a store and some of its feeding 593 // instruction search again from the beginning since the iterator 594 // is likely stale at this point. 595 if (!Res) 596 break; 597 else { 598 RBI = Pred0->rbegin(); 599 RBE = Pred0->rend(); 600 DEBUG(dbgs() << "Search again\n"; Instruction *I = &*RBI; I->dump()); 601 } 602 } 603 } 604 return MergedStores; 605} 606/// 607/// \brief Run the transformation for each function 608/// 609bool MergedLoadStoreMotion::runOnFunction(Function &F) { 610 MD = &getAnalysis<MemoryDependenceAnalysis>(); 611 AA = &getAnalysis<AliasAnalysis>(); 612 613 bool Changed = false; 614 if (!EnableMLSM) 615 return false; 616 DEBUG(dbgs() << "Instruction Merger\n"); 617 618 // Merge unconditional branches, allowing PRE to catch more 619 // optimization opportunities. 620 for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) { 621 BasicBlock *BB = FI++; 622 623 // Hoist equivalent loads and sink stores 624 // outside diamonds when possible 625 // Run outside core GVN 626 if (isDiamondHead(BB)) { 627 Changed |= mergeLoads(BB); 628 Changed |= mergeStores(getDiamondTail(BB)); 629 } 630 } 631 return Changed; 632} 633