Fix loop side-effects of deoptimizing loops with a nested live OSR loop.

src/hydrogen-gvn.cc

 // Copyright 2013 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 388 matching lines @@
     GVNFlagSet side_effects;
     if (block->IsReachable() && !block->IsDeoptimizing()) {
       int id = block->block_id();
       for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
         HInstruction* instr = it.Current();
         side_effects.Add(instr->ChangesFlags());
       }
       block_side_effects_[id].Add(side_effects);
 
       // Loop headers are part of their loop.
       if (block->IsLoopHeader()) {

[titzer, 2013/12/05 17:52:09]

Can you turn this whole thing into a do {} while() ?

         loop_side_effects_[id].Add(side_effects);
       }
 
       // Propagate loop side effects upwards.
       if (block->HasParentLoopHeader()) {
-        int header_id = block->parent_loop_header()->block_id();
-        loop_side_effects_[header_id].Add(block->IsLoopHeader()
-                                          ? loop_side_effects_[id]
-                                          : side_effects);
+        HBasicBlock* with_parent = block;
+        if (block->IsLoopHeader()) side_effects = loop_side_effects_[id];
+        while (with_parent->HasParentLoopHeader()) {
+          HBasicBlock* parent_block = with_parent->parent_loop_header();
+          loop_side_effects_[parent_block->block_id()].Add(side_effects);
+          with_parent = parent_block;
+        }
       }
     }
   }
 }
 
 
 SmartArrayPointer<char> GetGVNFlagsString(GVNFlagSet flags) {
   char underlying_buffer[kLastFlag * 128];
   Vector<char> buffer(underlying_buffer, sizeof(underlying_buffer));
 #if DEBUG
@@ skipping 131 matching lines @@
 
       if (can_hoist) {
         bool inputs_loop_invariant = true;
         for (int i = 0; i < instr->OperandCount(); ++i) {
           if (instr->OperandAt(i)->IsDefinedAfter(pre_header)) {
             inputs_loop_invariant = false;
           }
         }
 
         if (inputs_loop_invariant && ShouldMove(instr, loop_header)) {
-          TRACE_GVN_1("Hoisting loop invariant instruction %d\n", instr->id());
+          TRACE_GVN_3("Hoisting loop invariant instruction %d %d %s\n",

[titzer, 2013/12/05 17:52:09]

would like to see

"Hoisting loop invariant instruction i%d to block B%d" and I think you can drop
the loop kills for now.

+                      instr->id(), pre_header->block_id(),
+                      *GetGVNFlagsString(loop_kills));
           // Move the instruction out of the loop.
           instr->Unlink();
           instr->InsertBefore(pre_header->end());
           if (instr->HasSideEffects()) removed_side_effects_ = true;
           hoisted = true;
         }
       }
     }
     if (!hoisted) {
       // If an instruction is not hoisted, we have to account for its side
@@ skipping 263 matching lines @@
                                                       dominated);
         successor_map->Kill(side_effects_on_all_paths);
         successor_dominators->Kill(side_effects_on_all_paths);
       }
     }
     current = next;
   }
 }
 
 } }  // namespace v8::internal