Don't reference transitioned elements in loop pre header

src/hydrogen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1494 matching lines @@
       HBasicBlock* dominator,
       HBasicBlock* dominated);
   void AnalyzeGraph();
   void ComputeBlockSideEffects();
   void LoopInvariantCodeMotion();
   void ProcessLoopBlock(HBasicBlock* block,
                         HBasicBlock* before_loop,
                         GVNFlagSet loop_kills,
                         GVNFlagSet* accumulated_first_time_depends,
                         GVNFlagSet* accumulated_first_time_changes);
+  void PostProcessLoopPreHeader(HBasicBlock* pre_header);
   bool AllowCodeMotion();
   bool ShouldMove(HInstruction* instr, HBasicBlock* loop_header);
 
   HGraph* graph() { return graph_; }
   CompilationInfo* info() { return info_; }
   Zone* zone() const { return graph_->zone(); }
 
   HGraph* graph_;
   CompilationInfo* info_;
   bool removed_side_effects_;
@@ skipping 159 matching lines @@
       GVNFlagSet accumulated_first_time_depends;
       GVNFlagSet accumulated_first_time_changes;
       HBasicBlock* last = block->loop_information()->GetLastBackEdge();
       for (int j = block->block_id(); j <= last->block_id(); ++j) {
         ProcessLoopBlock(graph_->blocks()->at(j), block, side_effects,
                          &accumulated_first_time_depends,
                          &accumulated_first_time_changes);
       }
     }
   }
+  for (int i = graph_->blocks()->length() - 1; i >= 0; --i) {
+    HBasicBlock* block = graph_->blocks()->at(i);
+    if (block->IsLoopHeader()) {
+      PostProcessLoopPreHeader(block->predecessors()->at(0));
+    }
+  }
 }
 
 
 void HGlobalValueNumberer::ProcessLoopBlock(
     HBasicBlock* block,
     HBasicBlock* loop_header,
     GVNFlagSet loop_kills,
     GVNFlagSet* first_time_depends,
     GVNFlagSet* first_time_changes) {
   HBasicBlock* pre_header = loop_header->predecessors()->at(0);
@@ skipping 90 matching lines @@
       }
       if (!(previous_changes == *first_time_changes)) {
         TRACE_GVN_1("Updated first-time accumulated %s\n",
                     *GetGVNFlagsString(*first_time_changes));
       }
     }
     instr = next;
   }
 }
 
+void HGlobalValueNumberer::PostProcessLoopPreHeader(HBasicBlock* pre_header) {
+  HInstruction* instr = pre_header->first();
+  while (instr != NULL) {
+    HInstruction* next = instr->next();
+    if (instr->IsTransitionElementsKind()) {
+      HValue* old_elems = instr->OperandAt(0), *new_elems = instr;
+      HInstruction* current = next;
+      while (current != NULL) {
+        for (int i = 0; i < current->OperandCount(); ++i) {
+          if (current->OperandAt(i) == old_elems) {
+            current->SetOperandAt(i, new_elems);
+          }
+        }
+        current = current->next();
+      }
+    }

[danno, 2012/06/19 15:45:05]

This is potentially a n^2 algorithm with respect to the number of instructions
in the pre header. This is not the right way to do this.

+    instr = next;
+  }
+}
+
 
 bool HGlobalValueNumberer::AllowCodeMotion() {
   return info()->shared_info()->opt_count() + 1 < Compiler::kDefaultMaxOptCount;
 }
 
 
 bool HGlobalValueNumberer::ShouldMove(HInstruction* instr,
                                       HBasicBlock* loop_header) {
   // If we've disabled code motion or we're in a block that unconditionally
   // deoptimizes, don't move any instructions.
@@ skipping 7375 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal