Enable Local CSE by default

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 554 matching lines @@
           return false;
       }
       // Does not enter loop if different kind or number of operands
       for (SizeT i = 0; i < InstrA->getSrcSize(); ++i) {
         if (!srcEq(InstrA->getSrc(i), InstrB->getSrc(i)))
           return false;
       }
       return true;
     }
   };
-
+  bool NoSSA = getFlags().getLocalCSENoSSA();

[John, 2016/07/28 14:21:50]

const bool

[manasijm, 2016/07/28 19:43:34]

Done.

   for (CfgNode *Node : getNodes()) {
     CfgUnorderedSet<Inst *, InstHash, InstEq> Seen;
 
     CfgUnorderedMap<Variable *, Variable *, VariableHash> Replacements;
     // Combining the above two into a single data structure might consume less
     // memory but will be slower i.e map of Instruction -> Set of Variables
 
     CfgUnorderedMap<Variable *, std::vector<Inst *>, VariableHash> Dependency;
-    // Not necessary for SSA, still keeping it in case this pass is not run at
-    // the beginning. Remove to improve performace.
+    // Not necessary for SSA
 
     int IterCount = getFlags().getLocalCseMaxIterations();
 
     while (IterCount--) {
       // TODO : Stats on IterCount -> performance

[John, 2016/07/28 14:21:50]

TODO(manasijm):

[manasijm, 2016/07/28 19:43:33]

Done.

       for (Inst &Instr : Node->getInsts()) {
         if (Instr.isDeleted() || !llvm::isa<InstArithmetic>(&Instr))
           continue;
+        if (NoSSA) {

[John, 2016/07/28 14:21:50]

document what's going on here. why is this needed for non-SSA IR?

[manasijm, 2016/07/28 15:24:44]

This is needed if this pass is moved to a point later in the pipeline.
If Variables have a single definition in the block, CSE can work just on the
basis of an equality compare on instructions (sans Dest). When variables can be
updated (hence, non-SSA) the result of a previous instruction which used that
variable can not be reused.
(Will put this as a comment here.)

[manasijm, 2016/07/28 19:43:33]

Done.

+          // Invalidate replacements
+          auto Iter = Replacements.find(Instr.getDest());
+          if (Iter != Replacements.end()) {
+            Replacements.erase(Iter);
+          }
 
-        // Invalidate replacements
-        auto Iter = Replacements.find(Instr.getDest());
-        if (Iter != Replacements.end()) {
-          Replacements.erase(Iter);
+          // Invalidate 'seen' instructions whose operands were just updated.
+          auto DepIter = Dependency.find(Instr.getDest());
+          if (DepIter != Dependency.end()) {
+            for (auto DepInst : DepIter->second) {

[John, 2016/07/28 14:21:50]

auto *

[manasijm, 2016/07/28 19:43:34]

Done.

+              Seen.erase(DepInst);
+            }
+          }
         }
 
-        // Invalidate 'seen' instructions whose operands were just updated.
-        auto DepIter = Dependency.find(Instr.getDest());
-        if (DepIter != Dependency.end()) {
-          for (auto DepInst : DepIter->second) {
-            Seen.erase(DepInst);
-          }
-        }
-        // The above two can be removed if SSA is assumed.
-
         // Replace - doing this before checking for repetitions might enable
-        // more
-        // optimizations
+        // more optimizations
         for (SizeT i = 0; i < Instr.getSrcSize(); ++i) {
           auto *Opnd = Instr.getSrc(i);
           if (auto *Var = llvm::dyn_cast<Variable>(Opnd)) {
             if (Replacements.find(Var) != Replacements.end()) {
               Instr.replaceSource(i, Replacements[Var]);
             }
           }
         }
 
         // Check for repetitions
         auto SeenIter = Seen.find(&Instr);
         if (SeenIter != Seen.end()) { // seen before
           const Inst *Found = *SeenIter;
           Replacements[Instr.getDest()] = Found->getDest();
         } else { // new
           Seen.insert(&Instr);
 
-          // Update dependencies
-          for (SizeT i = 0; i < Instr.getSrcSize(); ++i) {
-            auto *Opnd = Instr.getSrc(i);
-            if (auto *Var = llvm::dyn_cast<Variable>(Opnd)) {
-              Dependency[Var].push_back(&Instr);
+          if (NoSSA) {
+            // Update dependencies
+            for (SizeT i = 0; i < Instr.getSrcSize(); ++i) {
+              auto *Opnd = Instr.getSrc(i);
+              if (auto *Var = llvm::dyn_cast<Variable>(Opnd)) {
+                Dependency[Var].push_back(&Instr);
+              }
             }
           }
         }
       }
     }
   }
 }
 
 void Cfg::loopInvariantCodeMotion() {
   TimerMarker T(TimerStack::TT_loopInvariantCodeMotion, this);
@@ skipping 1122 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice