lib/Transforms/Scalar/EarlyCSE.cpp

   1 //===- EarlyCSE.cpp - Simple and fast CSE pass ----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This pass performs a simple dominator tree walk that eliminates trivially
  11 // redundant instructions.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "early-cse"
  16 #include "llvm/Transforms/Scalar.h"
  17 #include "llvm/Instructions.h"
  18 #include "llvm/Pass.h"
  19 #include "llvm/Analysis/Dominators.h"
  20 #include "llvm/Analysis/InstructionSimplify.h"
  21 #include "llvm/Target/TargetData.h"
  22 #include "llvm/Transforms/Utils/Local.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Support/RecyclingAllocator.h"
  25 #include "llvm/ADT/ScopedHashTable.h"
  26 #include "llvm/ADT/Statistic.h"
  27 using namespace llvm;
  28
  29 STATISTIC(NumSimplify, "Number of instructions simplified or DCE'd");
  30 STATISTIC(NumCSE,      "Number of instructions CSE'd");
  31 STATISTIC(NumCSELoad,  "Number of load instructions CSE'd");
  32 STATISTIC(NumCSECall,  "Number of call instructions CSE'd");
  33 STATISTIC(NumDSE,      "Number of trivial dead stores removed");
  34
  35 static unsigned getHash(const void *V) {
  36   return DenseMapInfo<const void*>::getHashValue(V);
  37 }
  38
  39 //===----------------------------------------------------------------------===//
  40 // SimpleValue
  41 //===----------------------------------------------------------------------===//
  42
  43 namespace {
  44   /// SimpleValue - Instances of this struct represent available values in the
  45   /// scoped hash table.
  46   struct SimpleValue {
  47     Instruction *Inst;
  48
  49     SimpleValue(Instruction *I) : Inst(I) {
  50       assert((isSentinel() || canHandle(I)) && "Inst can't be handled!");
  51     }
  52
  53     bool isSentinel() const {
  54       return Inst == DenseMapInfo<Instruction*>::getEmptyKey() ||
  55              Inst == DenseMapInfo<Instruction*>::getTombstoneKey();
  56     }
  57
  58     static bool canHandle(Instruction *Inst) {
  59       return isa<CastInst>(Inst) || isa<BinaryOperator>(Inst) ||
  60              isa<GetElementPtrInst>(Inst) || isa<CmpInst>(Inst) ||
  61              isa<SelectInst>(Inst) || isa<ExtractElementInst>(Inst) ||
  62              isa<InsertElementInst>(Inst) || isa<ShuffleVectorInst>(Inst) ||
  63              isa<ExtractValueInst>(Inst) || isa<InsertValueInst>(Inst);
  64     }
  65   };
  66 }
  67
  68 namespace llvm {
  69 // SimpleValue is POD.
  70 template<> struct isPodLike<SimpleValue> {
  71   static const bool value = true;
  72 };
  73
  74 template<> struct DenseMapInfo<SimpleValue> {
  75   static inline SimpleValue getEmptyKey() {
  76     return DenseMapInfo<Instruction*>::getEmptyKey();
  77   }
  78   static inline SimpleValue getTombstoneKey() {
  79     return DenseMapInfo<Instruction*>::getTombstoneKey();
  80   }
  81   static unsigned getHashValue(SimpleValue Val);
  82   static bool isEqual(SimpleValue LHS, SimpleValue RHS);
  83 };
  84 }
  85
  86 unsigned DenseMapInfo<SimpleValue>::getHashValue(SimpleValue Val) {
  87   Instruction *Inst = Val.Inst;
  88
  89   // Hash in all of the operands as pointers.
  90   unsigned Res = 0;
  91   for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i)
  92     Res ^= getHash(Inst->getOperand(i)) << i;
  93
  94   if (CastInst *CI = dyn_cast<CastInst>(Inst))
  95     Res ^= getHash(CI->getType());
  96   else if (CmpInst *CI = dyn_cast<CmpInst>(Inst))
  97     Res ^= CI->getPredicate();
  98   else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst)) {
  99     for (ExtractValueInst::idx_iterator I = EVI->idx_begin(),
 100          E = EVI->idx_end(); I != E; ++I)
 101       Res ^= *I;
 102   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst)) {
 103     for (InsertValueInst::idx_iterator I = IVI->idx_begin(),
 104          E = IVI->idx_end(); I != E; ++I)
 105       Res ^= *I;
 106   } else {
 107     // nothing extra to hash in.
 108     assert((isa<BinaryOperator>(Inst) || isa<GetElementPtrInst>(Inst) ||
 109             isa<SelectInst>(Inst) || isa<ExtractElementInst>(Inst) ||
 110             isa<InsertElementInst>(Inst) || isa<ShuffleVectorInst>(Inst)) &&
 111            "Invalid/unknown instruction");
 112   }
 113
 114   // Mix in the opcode.
 115   return (Res << 1) ^ Inst->getOpcode();
 116 }
 117
 118 bool DenseMapInfo<SimpleValue>::isEqual(SimpleValue LHS, SimpleValue RHS) {
 119   Instruction *LHSI = LHS.Inst, *RHSI = RHS.Inst;
 120
 121   if (LHS.isSentinel() || RHS.isSentinel())
 122     return LHSI == RHSI;
 123
 124   if (LHSI->getOpcode() != RHSI->getOpcode()) return false;
 125   return LHSI->isIdenticalTo(RHSI);
 126 }
 127
 128 //===----------------------------------------------------------------------===//
 129 // CallValue
 130 //===----------------------------------------------------------------------===//
 131
 132 namespace {
 133   /// CallValue - Instances of this struct represent available call values in
 134   /// the scoped hash table.
 135   struct CallValue {
 136     Instruction *Inst;
 137
 138     CallValue(Instruction *I) : Inst(I) {
 139       assert((isSentinel() || canHandle(I)) && "Inst can't be handled!");
 140     }
 141
 142     bool isSentinel() const {
 143       return Inst == DenseMapInfo<Instruction*>::getEmptyKey() ||
 144              Inst == DenseMapInfo<Instruction*>::getTombstoneKey();
 145     }
 146
 147     static bool canHandle(Instruction *Inst) {
 148       // Don't value number anything that returns void.
 149       if (Inst->getType()->isVoidTy())
 150         return false;
 151
 152       CallInst *CI = dyn_cast<CallInst>(Inst);
 153       if (CI == 0 || !CI->onlyReadsMemory())
 154         return false;
 155       return true;
 156     }
 157   };
 158 }
 159
 160 namespace llvm {
 161   // CallValue is POD.
 162   template<> struct isPodLike<CallValue> {
 163     static const bool value = true;
 164   };
 165
 166   template<> struct DenseMapInfo<CallValue> {
 167     static inline CallValue getEmptyKey() {
 168       return DenseMapInfo<Instruction*>::getEmptyKey();
 169     }
 170     static inline CallValue getTombstoneKey() {
 171       return DenseMapInfo<Instruction*>::getTombstoneKey();
 172     }
 173     static unsigned getHashValue(CallValue Val);
 174     static bool isEqual(CallValue LHS, CallValue RHS);
 175   };
 176 }
 177 unsigned DenseMapInfo<CallValue>::getHashValue(CallValue Val) {
 178   Instruction *Inst = Val.Inst;
 179   // Hash in all of the operands as pointers.
 180   unsigned Res = 0;
 181   for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i) {
 182     assert(!Inst->getOperand(i)->getType()->isMetadataTy() &&
 183            "Cannot value number calls with metadata operands");
 184     Res ^= getHash(Inst->getOperand(i)) << i;
 185   }
 186
 187   // Mix in the opcode.
 188   return (Res << 1) ^ Inst->getOpcode();
 189 }
 190
 191 bool DenseMapInfo<CallValue>::isEqual(CallValue LHS, CallValue RHS) {
 192   Instruction *LHSI = LHS.Inst, *RHSI = RHS.Inst;
 193   if (LHS.isSentinel() || RHS.isSentinel())
 194     return LHSI == RHSI;
 195   return LHSI->isIdenticalTo(RHSI);
 196 }
 197
 198
 199 //===----------------------------------------------------------------------===//
 200 // EarlyCSE pass.
 201 //===----------------------------------------------------------------------===//
 202
 203 namespace {
 204
 205 /// EarlyCSE - This pass does a simple depth-first walk over the dominator
 206 /// tree, eliminating trivially redundant instructions and using instsimplify
 207 /// to canonicalize things as it goes.  It is intended to be fast and catch
 208 /// obvious cases so that instcombine and other passes are more effective.  It
 209 /// is expected that a later pass of GVN will catch the interesting/hard
 210 /// cases.
 211 class EarlyCSE : public FunctionPass {
 212 public:
 213   const TargetData *TD;
 214   DominatorTree *DT;
 215   typedef RecyclingAllocator<BumpPtrAllocator,
 216                       ScopedHashTableVal<SimpleValue, Value*> > AllocatorTy;
 217   typedef ScopedHashTable<SimpleValue, Value*, DenseMapInfo<SimpleValue>,
 218                           AllocatorTy> ScopedHTType;
 219
 220   /// AvailableValues - This scoped hash table contains the current values of
 221   /// all of our simple scalar expressions.  As we walk down the domtree, we
 222   /// look to see if instructions are in this: if so, we replace them with what
 223   /// we find, otherwise we insert them so that dominated values can succeed in
 224   /// their lookup.
 225   ScopedHTType *AvailableValues;
 226
 227   /// AvailableLoads - This scoped hash table contains the current values
 228   /// of loads.  This allows us to get efficient access to dominating loads when
 229   /// we have a fully redundant load.  In addition to the most recent load, we
 230   /// keep track of a generation count of the read, which is compared against
 231   /// the current generation count.  The current generation count is
 232   /// incremented after every possibly writing memory operation, which ensures
 233   /// that we only CSE loads with other loads that have no intervening store.
 234   typedef RecyclingAllocator<BumpPtrAllocator,
 235     ScopedHashTableVal<Value*, std::pair<Value*, unsigned> > > LoadMapAllocator;
 236   typedef ScopedHashTable<Value*, std::pair<Value*, unsigned>,
 237                           DenseMapInfo<Value*>, LoadMapAllocator> LoadHTType;
 238   LoadHTType *AvailableLoads;
 239
 240   /// AvailableCalls - This scoped hash table contains the current values
 241   /// of read-only call values.  It uses the same generation count as loads.
 242   typedef ScopedHashTable<CallValue, std::pair<Value*, unsigned> > CallHTType;
 243   CallHTType *AvailableCalls;
 244
 245   /// CurrentGeneration - This is the current generation of the memory value.
 246   unsigned CurrentGeneration;
 247
 248   static char ID;
 249   explicit EarlyCSE() : FunctionPass(ID) {
 250     initializeEarlyCSEPass(*PassRegistry::getPassRegistry());
 251   }
 252
 253   bool runOnFunction(Function &F);
 254
 255 private:
 256
 257   bool processNode(DomTreeNode *Node);
 258
 259   // This transformation requires dominator postdominator info
 260   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 261     AU.addRequired<DominatorTree>();
 262     AU.setPreservesCFG();
 263   }
 264 };
 265 }
 266
 267 char EarlyCSE::ID = 0;
 268
 269 // createEarlyCSEPass - The public interface to this file.
 270 FunctionPass *llvm::createEarlyCSEPass() {
 271   return new EarlyCSE();
 272 }
 273
 274 INITIALIZE_PASS_BEGIN(EarlyCSE, "early-cse", "Early CSE", false, false)
 275 INITIALIZE_PASS_DEPENDENCY(DominatorTree)
 276 INITIALIZE_PASS_END(EarlyCSE, "early-cse", "Early CSE", false, false)
 277
 278 bool EarlyCSE::processNode(DomTreeNode *Node) {
 279   // Define a scope in the scoped hash table.  When we are done processing this
 280   // domtree node and recurse back up to our parent domtree node, this will pop
 281   // off all the values we install.
 282   ScopedHTType::ScopeTy Scope(*AvailableValues);
 283
 284   // Define a scope for the load values so that anything we add will get
 285   // popped when we recurse back up to our parent domtree node.
 286   LoadHTType::ScopeTy LoadScope(*AvailableLoads);
 287
 288   // Define a scope for the call values so that anything we add will get
 289   // popped when we recurse back up to our parent domtree node.
 290   CallHTType::ScopeTy CallScope(*AvailableCalls);
 291
 292   BasicBlock *BB = Node->getBlock();
 293
 294   // If this block has a single predecessor, then the predecessor is the parent
 295   // of the domtree node and all of the live out memory values are still current
 296   // in this block.  If this block has multiple predecessors, then they could
 297   // have invalidated the live-out memory values of our parent value.  For now,
 298   // just be conservative and invalidate memory if this block has multiple
 299   // predecessors.
 300   if (BB->getSinglePredecessor() == 0)
 301     ++CurrentGeneration;
 302
 303   /// LastStore - Keep track of the last non-volatile store that we saw... for
 304   /// as long as there in no instruction that reads memory.  If we see a store
 305   /// to the same location, we delete the dead store.  This zaps trivial dead
 306   /// stores which can occur in bitfield code among other things.
 307   StoreInst *LastStore = 0;
 308
 309   bool Changed = false;
 310
 311   // See if any instructions in the block can be eliminated.  If so, do it.  If
 312   // not, add them to AvailableValues.
 313   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {
 314     Instruction *Inst = I++;
 315
 316     // Dead instructions should just be removed.
 317     if (isInstructionTriviallyDead(Inst)) {
 318       DEBUG(dbgs() << "EarlyCSE DCE: " << *Inst << '\n');
 319       Inst->eraseFromParent();
 320       Changed = true;
 321       ++NumSimplify;
 322       continue;
 323     }
 324
 325     // If the instruction can be simplified (e.g. X+0 = X) then replace it with
 326     // its simpler value.
 327     if (Value *V = SimplifyInstruction(Inst, TD, DT)) {
 328       DEBUG(dbgs() << "EarlyCSE Simplify: " << *Inst << "  to: " << *V << '\n');
 329       Inst->replaceAllUsesWith(V);
 330       Inst->eraseFromParent();
 331       Changed = true;
 332       ++NumSimplify;
 333       continue;
 334     }
 335
 336     // If this is a simple instruction that we can value number, process it.
 337     if (SimpleValue::canHandle(Inst)) {
 338       // See if the instruction has an available value.  If so, use it.
 339       if (Value *V = AvailableValues->lookup(Inst)) {
 340         DEBUG(dbgs() << "EarlyCSE CSE: " << *Inst << "  to: " << *V << '\n');
 341         Inst->replaceAllUsesWith(V);
 342         Inst->eraseFromParent();
 343         Changed = true;
 344         ++NumCSE;
 345         continue;
 346       }
 347
 348       // Otherwise, just remember that this value is available.
 349       AvailableValues->insert(Inst, Inst);
 350       continue;
 351     }
 352
 353     // If this is a non-volatile load, process it.
 354     if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
 355       // Ignore volatile loads.
 356       if (LI->isVolatile()) {
 357         LastStore = 0;
 358         continue;
 359       }
 360
 361       // If we have an available version of this load, and if it is the right
 362       // generation, replace this instruction.
 363       std::pair<Value*, unsigned> InVal =
 364         AvailableLoads->lookup(Inst->getOperand(0));
 365       if (InVal.first != 0 && InVal.second == CurrentGeneration) {
 366         DEBUG(dbgs() << "EarlyCSE CSE LOAD: " << *Inst << "  to: "
 367               << *InVal.first << '\n');
 368         if (!Inst->use_empty()) Inst->replaceAllUsesWith(InVal.first);
 369         Inst->eraseFromParent();
 370         Changed = true;
 371         ++NumCSELoad;
 372         continue;
 373       }
 374
 375       // Otherwise, remember that we have this instruction.
 376       AvailableLoads->insert(Inst->getOperand(0),
 377                           std::pair<Value*, unsigned>(Inst, CurrentGeneration));
 378       LastStore = 0;
 379       continue;
 380     }
 381
 382     // If this instruction may read from memory, forget LastStore.
 383     if (Inst->mayReadFromMemory())
 384       LastStore = 0;
 385
 386     // If this is a read-only call, process it.
 387     if (CallValue::canHandle(Inst)) {
 388       // If we have an available version of this call, and if it is the right
 389       // generation, replace this instruction.
 390       std::pair<Value*, unsigned> InVal = AvailableCalls->lookup(Inst);
 391       if (InVal.first != 0 && InVal.second == CurrentGeneration) {
 392         DEBUG(dbgs() << "EarlyCSE CSE CALL: " << *Inst << "  to: "
 393                      << *InVal.first << '\n');
 394         if (!Inst->use_empty()) Inst->replaceAllUsesWith(InVal.first);
 395         Inst->eraseFromParent();
 396         Changed = true;
 397         ++NumCSECall;
 398         continue;
 399       }
 400
 401       // Otherwise, remember that we have this instruction.
 402       AvailableCalls->insert(Inst,
 403                          std::pair<Value*, unsigned>(Inst, CurrentGeneration));
 404       continue;
 405     }
 406
 407     // Okay, this isn't something we can CSE at all.  Check to see if it is
 408     // something that could modify memory.  If so, our available memory values
 409     // cannot be used so bump the generation count.
 410     if (Inst->mayWriteToMemory()) {
 411       ++CurrentGeneration;
 412
 413       if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
 414         // We do a trivial form of DSE if there are two stores to the same
 415         // location with no intervening loads.  Delete the earlier store.
 416         if (LastStore &&
 417             LastStore->getPointerOperand() == SI->getPointerOperand()) {
 418           DEBUG(dbgs() << "EarlyCSE DEAD STORE: " << *LastStore << "  due to: "
 419                        << *Inst << '\n');
 420           LastStore->eraseFromParent();
 421           Changed = true;
 422           ++NumDSE;
 423           LastStore = 0;
 424           continue;
 425         }
 426
 427         // Okay, we just invalidated anything we knew about loaded values.  Try
 428         // to salvage *something* by remembering that the stored value is a live
 429         // version of the pointer.  It is safe to forward from volatile stores
 430         // to non-volatile loads, so we don't have to check for volatility of
 431         // the store.
 432         AvailableLoads->insert(SI->getPointerOperand(),
 433          std::pair<Value*, unsigned>(SI->getValueOperand(), CurrentGeneration));
 434
 435         // Remember that this was the last store we saw for DSE.
 436         if (!SI->isVolatile())
 437           LastStore = SI;
 438       }
 439     }
 440   }
 441
 442   unsigned LiveOutGeneration = CurrentGeneration;
 443   for (DomTreeNode::iterator I = Node->begin(), E = Node->end(); I != E; ++I) {
 444     Changed |= processNode(*I);
 445     // Pop any generation changes off the stack from the recursive walk.
 446     CurrentGeneration = LiveOutGeneration;
 447   }
 448   return Changed;
 449 }
 450
 451
 452 bool EarlyCSE::runOnFunction(Function &F) {
 453   TD = getAnalysisIfAvailable<TargetData>();
 454   DT = &getAnalysis<DominatorTree>();
 455
 456   // Tables that the pass uses when walking the domtree.
 457   ScopedHTType AVTable;
 458   AvailableValues = &AVTable;
 459   LoadHTType LoadTable;
 460   AvailableLoads = &LoadTable;
 461   CallHTType CallTable;
 462   AvailableCalls = &CallTable;
 463
 464   CurrentGeneration = 0;
 465   return processNode(DT->getRootNode());
 466 }