MM Rework for use by Kyle

compiler/AST/bb.cpp

@@ -71,7 +71,10 @@ void BasicBlock::buildBasicBlocks(FnSymbol* fn) {
 
   fn->basicBlocks->push_back(BasicBlock::steal());
 
-  INT_ASSERT(verifyBasicBlocks(fn));
+  removeEmptyBlocks(fn);
+
+  if (fVerify)
+    INT_ASSERT(verifyBasicBlocks(fn));
 }
 
 BasicBlock* BasicBlock::steal() {
@@ -202,9 +205,11 @@ void BasicBlock::buildBasicBlocks(FnSymbol* fn, Expr* stmt, bool mark) {
     LabelSymbol* label = toLabelSymbol(toSymExpr(s->label)->var);
 
     if (BasicBlock* bb = labelMaps.get(label)) {
+      // Thread this block to its destination label.
       thread(basicBlock, bb);
 
     } else {
+      // Set up goto map, so this block's successor can be back-patched later.
       std::vector<BasicBlock*>* vbb = gotoMaps.get(label);
 
       if (!vbb)
@@ -216,6 +221,10 @@ void BasicBlock::buildBasicBlocks(FnSymbol* fn, Expr* stmt, bool mark) {
     }
 
     append(s, mark); // Put the goto at the end of its block.
+
+    // We need a new block, so we can not thread the one containing the goto to
+    // this new one.  There is a break in the flow.  If the new block does not
+    // begin with a label, it is unreachable and can be removed.
     restart(fn);
 
   } else {
@@ -291,9 +300,49 @@ void BasicBlock::thread(BasicBlock* src, BasicBlock* dst) {
   src->outs.push_back(dst);
 }
 
+// Look for and remove empty blocks with no predecessor and whose successor is
+// the next block in sequence.  These blocks get created when a block ends in a
+// goto statement and the enclosing construct calls restart immediately.
+// We have to wait until basic block analysis is done, because we don't know if
+// a block has predecessors until after threading is performed, and this is
+// sometimes delayed.
+void BasicBlock::removeEmptyBlocks(FnSymbol* fn)
+{
+  // Create a new vector that contains just the items we want to preserve.
+  int new_id = 0;
+  BasicBlockVector* new_blocks = new BasicBlockVector();
+  for_vector(BasicBlock, bb, *fn->basicBlocks)
+  {
+    // Skip empty blocks with no predecessors.
+    if (bb->ins.size() == 0 &&
+        bb->exprs.size() == 0)
+    {
+      // This block will be removed.  It is no longer a predecessor of anyone,
+      // so we must update the back links.
+      for_vector(BasicBlock, succ, bb->outs)
+      {
+        BasicBlockVector::iterator i;
+        for (i = succ->ins.begin(); i != succ->ins.end(); ++i)
+          if (*i == bb)
+            break;
+
+        INT_ASSERT(i != succ->ins.end());
+        succ->ins.erase(i);
+      }
+    }
+    else
+    {
+      bb->id = new_id++;
+      new_blocks->push_back(bb);
+    }
+  }
+  delete fn->basicBlocks; fn->basicBlocks = new_blocks;
+}
+
 // Returns true if the basic block structure is OK, false otherwise.
 bool BasicBlock::verifyBasicBlocks(FnSymbol* fn) {
-  for_vector(BasicBlock, bb, *fn->basicBlocks) {
+  for_vector(BasicBlock, bb, *fn->basicBlocks)
+  {
     if (bb->isOK() == false)
       return false;
   }
@@ -307,6 +356,15 @@ bool BasicBlock::isOK() {
   if (exprs.size() != marks.size())
     return false;
 
+  // Every empty interior block must have a predecessor.
+  // Non-empty blocks with no predecessors are dead code, which may be
+  // removed by a client of BB analysis.  These dead blocks cannot be
+  // identified without BB analysis, so non-empty blocks with no
+  // predecessors are valid.
+  if (ins.size() == 0 &&
+      exprs.size() == 0)
+    return false;
+
   // Expressions must be live (non-NULL);
   for_vector(Expr, expr, exprs)
     if (expr == 0)

compiler/AST/build.cpp

@@ -585,13 +585,17 @@ destructureIndices(BlockStmt* block,
     var->addFlag(FLAG_INDEX_VAR);
     if (coforall)
       var->addFlag(FLAG_COFORALL_INDEX_VAR);
+#ifndef HILDE_MM
     var->addFlag(FLAG_INSERT_AUTO_DESTROY);
+#endif
   } else if (SymExpr* sym = toSymExpr(indices)) {
     block->insertAtHead(new CallExpr(PRIM_MOVE, sym->var, init));
     sym->var->addFlag(FLAG_INDEX_VAR);
     if (coforall)
       sym->var->addFlag(FLAG_COFORALL_INDEX_VAR);
+#ifndef HILDE_MM
     sym->var->addFlag(FLAG_INSERT_AUTO_DESTROY);
+#endif
   }
 }
 
@@ -660,6 +664,7 @@ handleArrayTypeCase(FnSymbol* fn, Expr* indices, Expr* iteratorExpr, Expr* expr)
   thenStmt->insertAtTail(new DefExpr(domain));
   // note that we need the below autoCopy until we start reference
   // counting domains within runtime array types
+  // TODO AMM: Check if the explicit insertion of an autoCopy is necessary here.
   thenStmt->insertAtTail(new CallExpr(PRIM_MOVE, domain,
                            new CallExpr("chpl__autoCopy",
                              new CallExpr("chpl__ensureDomainExpr",
@@ -1058,7 +1063,9 @@ buildForallLoopStmt(Expr*      indices,
   followIdx->addFlag(FLAG_INDEX_OF_INTEREST);
 
   leadIdxCopy->addFlag(FLAG_INDEX_VAR);
+#ifndef HILDE_MM
   leadIdxCopy->addFlag(FLAG_INSERT_AUTO_DESTROY);
+#endif
   followIdx->addFlag(FLAG_INDEX_OF_INTEREST);
 
   // ForallLeaderArgs: stash references so we know where things are.
@@ -1456,7 +1463,9 @@ CallExpr* buildReduceExpr(Expr* opExpr, Expr* dataExpr, bool zippered) {
   VarSymbol* localOp     = newTemp();
 
   leadIdxCopy->addFlag(FLAG_INDEX_VAR);
+#ifndef HILDE_MM
   leadIdxCopy->addFlag(FLAG_INSERT_AUTO_DESTROY);
+#endif
 
   ForLoop* followBody = new ForLoop(followIdx, followIter, NULL);
 

compiler/adt/bitVec.cpp

@@ -58,38 +58,30 @@ void BitVec::clear() {
 
 
 bool BitVec::get(size_t i) const {
-#if DEBUG
-  if (i >= in_size) 
-    INT_FATAL("BitVec::get -- operand out of range.");
-#endif
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   return data[j] & (1 << k);
 }
 
 
 void BitVec::unset(size_t i) {
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   data[j] &= ((TYPE)-1) - (1 << k);
 }
 
 
 void BitVec::disjunction(const BitVec& other) {
-#if DEBUG
-  if (other.in_size != in_size)
-    INT_FATAL("BitVec::disjunction -- operand lengths must be equal.");
-#endif
+  INT_ASSERT(other.in_size == in_size);
   for (size_t i = 0; i < ndata; i++)
     data[i] |= other.data[i];
 }
 
 
 void BitVec::intersection(const BitVec& other) {
-#if DEBUG
-  if (other.in_size != in_size)
-    INT_FATAL("BitVec::intersection -- operand lengths must be equal.");
-#endif
+  INT_ASSERT(other.in_size == in_size);
   for (size_t i = 0; i < ndata; i++)
     data[i] &= other.data[i];
 }
@@ -106,10 +98,7 @@ void BitVec::intersection(const BitVec& other) {
 
 
 bool BitVec::equals(const BitVec& other) const {
-#if DEBUG
-  if (other.in_size != in_size)
-    INT_FATAL("BitVec::disjunction -- operand lengths must be equal.");
-#endif
+  INT_ASSERT(other.in_size == in_size);
   for(size_t i = 0; i < ndata; i++) {
     if(data[i] != other.data[i]) {
       return false;
@@ -126,6 +115,7 @@ void BitVec::set() {
 
 
 void BitVec::set(size_t i) {
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   data[j] |= 1 << k;
@@ -139,19 +129,22 @@ void BitVec::reset() {
 
 
 void BitVec::reset(size_t i) {
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   data[j] &= ((size_t)-1) - (1 << k);
 }
 
 
 void BitVec::copy(const BitVec& other) {
+  INT_ASSERT(other.in_size == in_size);
   for (size_t i = 0; i < ndata; ++i)
     data[i] = other.data[i];
 }
 
 
 void BitVec::copy(size_t i, bool value) {
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   data[j] &= ~(1 << k);
@@ -167,6 +160,7 @@ void BitVec::flip() {
 
 
 void BitVec::flip(size_t i) {
+  INT_ASSERT(i < in_size);
   size_t j = i / (sizeof(TYPE)<<3);
   size_t k = i - j*(sizeof(TYPE)<<3);
   data[j] ^= 1 << k;

compiler/include/bb.h

@@ -36,6 +36,13 @@ class SymExpr;
 // The goto and label maps persist only between calls to buildBasicBlocks.
 class BasicBlock
 {
+  //
+  // Typedefs
+  //
+ public:
+  typedef std::vector<BasicBlock*> BasicBlockVector;
+  typedef std::vector<BitVec*> BitVecVector;
+
   //
   // Class methods/variables
   //
@@ -51,16 +58,16 @@ class BasicBlock
                                                  Map<Symbol*,int>&     localMap);
 
   static void               backwardFlowAnalysis(FnSymbol*             fn,
-                                                 std::vector<BitVec*>& GEN,
-                                                 std::vector<BitVec*>& KILL,
-                                                 std::vector<BitVec*>& IN,
-                                                 std::vector<BitVec*>& OUT);
+                                                 BitVecVector& GEN,
+                                                 BitVecVector& KILL,
+                                                 BitVecVector& IN,
+                                                 BitVecVector& OUT);
 
   static void               forwardFlowAnalysis (FnSymbol*             fn,
-                                                 std::vector<BitVec*>& GEN,
-                                                 std::vector<BitVec*>& KILL,
-                                                 std::vector<BitVec*>& IN,
-                                                 std::vector<BitVec*>& OUT,
+                                                 BitVecVector& GEN,
+                                                 BitVecVector& KILL,
+                                                 BitVecVector& IN,
+                                                 BitVecVector& OUT,
                                                  bool                  intersect = true);
 
   static void               printLocalsVector(Vec<Symbol*>      locals,
@@ -69,18 +76,18 @@ class BasicBlock
   static void               printDefsVector(std::vector<SymExpr*> defs,
                                             Map<SymExpr*, int>&   defMap);
 
-  static void               printLocalsVectorSets(std::vector<BitVec*>& sets,
+  static void               printLocalsVectorSets(BitVecVector& sets,
                                                   Vec<Symbol*>          locals);
 
-  static void               printBitVectorSets(std::vector<BitVec*>& sets);
+  static void               printBitVectorSets(BitVecVector& sets);
 
   static BasicBlock*        basicBlock;
 
   static Map<LabelSymbol*,
              BasicBlock*>   labelMaps;
 
   static Map<LabelSymbol*,
-             std::vector<BasicBlock*>*> gotoMaps;
+             BasicBlockVector*> gotoMaps;
 
 private:
   static void               buildBasicBlocks(FnSymbol* fn,
@@ -94,6 +101,7 @@ class BasicBlock
 
   static BasicBlock*        steal();
 
+  static void removeEmptyBlocks(FnSymbol* fn);
   static bool               verifyBasicBlocks(FnSymbol* fn);
 
   static int                nextID;
@@ -109,8 +117,8 @@ class BasicBlock
   std::vector<Expr*>        exprs;
   std::vector<bool>         marks;
 
-  std::vector<BasicBlock*>  ins;
-  std::vector<BasicBlock*>  outs;
+  BasicBlockVector  ins;
+  BasicBlockVector  outs;
 
 private:
   bool                      isOK();

compiler/include/bitVec.h

@@ -36,7 +36,10 @@ class BitVec {
   void disjunction(const BitVec& other);
   void intersection(const BitVec& other);
 
-
+  // Synonyms for disjunction (union) and (conjunction) intersection above.
+  void operator|=(BitVec& other) { this->disjunction(other); }
+  void operator&=(BitVec& other) { this->intersection(other); }
+
   // Added functionality to make this compatible with std::bitset and thus 
   // boosts dynamic bitset if that gets into the STL, or we start using boost
   bool equals(const BitVec& other) const;

compiler/include/passes.h

@@ -50,6 +50,7 @@ void expandExternArrayCalls();
 void flattenClasses();
 void flattenFunctions();
 void inlineFunctions();
+void insertAutoCopyAutoDestroy();
 void insertLineNumbers();
 void insertWideReferences();
 void narrowWideReferences();

compiler/make/Makefile.compiler.head

@@ -34,7 +34,7 @@ endif
 include $(CHPL_MAKE_HOME)/make/Makefile.base
 
 INCL_CFLAGS = -I. -I$(COMPILER_ROOT)/include/$(CHPL_MAKE_HOST_PLATFORM) -I$(COMPILER_ROOT)/include $(LLVM_INCLUDES)
-COMP_CFLAGS += $(INCL_CFLAGS)
+COMP_CFLAGS += $(INCL_CFLAGS) -DHILDE_MM=1
 
 #
 # add gc-related stuff

compiler/optimizations/copyPropagation.cpp

@@ -992,8 +992,10 @@ static void initCopySets(std::vector<BitVec*>& COPY, std::vector<size_t>& ends,
 // When these are corrected and the test becomes true, then we can drop back
 // to the simpler form given here:
 #ifdef INLINING_DOES_NOT_LEAVE_INTERNAL_BASIC_BLOCKS_WITHOUT_PREDECESSORS
-static void initInSets(std::vector<BitVec*>& IN, size_t nbbs)
+static void initInSets(std::vector<BitVec*>& IN, FnSymbol* fn)
 {
+  size_t nbbs = fn->basicBlocks->size();
+
   // Note that we start with i = 1, so that IN[0] is left as all zeroes.
   for (size_t i = 1; i < nbbs; i++)
     IN[i]->set();

compiler/optimizations/removeUnnecessaryAutoCopyCalls.cpp

@@ -439,7 +439,7 @@ static void removePODinitDestroy()
 
 
 void removeUnnecessaryAutoCopyCalls() {
-  if (fNoRemoveCopyCalls)
+  if (fNoRemoveCopyCalls || 1) // Disable this pass for a test.
     return;
 
   //

compiler/passes/Makefile.share

@@ -33,6 +33,7 @@ PASSES_SRCS = \
         filesToAST.cpp \
         flattenClasses.cpp \
         flattenFunctions.cpp \
+        insertAutoCopyAutoDestroy.cpp \
         insertLineNumbers.cpp \
         insertWideReferences.cpp \
         normalize.cpp \