[turbofan] small cleanups to aid register allocator debugging

src/compiler/register-allocator.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/linkage.h"
 #include "src/compiler/pipeline-statistics.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 1107 matching lines @@
 
 bool RegisterAllocator::Allocate(PipelineStatistics* stats) {
   assigned_registers_ = new (code_zone())
       BitVector(config()->num_general_registers(), code_zone());
   assigned_double_registers_ = new (code_zone())
       BitVector(config()->num_aliased_double_registers(), code_zone());
   {
     PhaseScope phase_scope(stats, "meet register constraints");
     MeetRegisterConstraints();
   }
-  if (!AllocationOk()) return false;
   {
     PhaseScope phase_scope(stats, "resolve phis");
     ResolvePhis();
   }
   {
     PhaseScope phase_scope(stats, "build live ranges");
     BuildLiveRanges();
   }
+  if (FLAG_trace_turbo) {
+    OFStream os(stdout);
+    PrintableInstructionSequence printable = {config(), code()};
+    os << "----- Instruction sequence before register allocation -----\n"
+       << printable;
+  }
+  // This can be triggered in debug mode.
+  DCHECK(!ExistsUseWithoutDefinition());
   {
     PhaseScope phase_scope(stats, "allocate general registers");
     AllocateGeneralRegisters();
   }
   if (!AllocationOk()) return false;
   {
     PhaseScope phase_scope(stats, "allocate double registers");
     AllocateDoubleRegisters();
   }
   if (!AllocationOk()) return false;
@@ skipping 333 matching lines @@
         range->EnsureInterval(start, end, local_zone());
         iterator.Advance();
       }
 
       // Insert all values into the live in sets of all blocks in the loop.
       for (int i = block->rpo_number().ToInt() + 1;
            i < block->loop_end().ToInt(); ++i) {
         live_in_sets_[i]->Union(*live);
       }
     }
-
-#ifdef DEBUG
-    if (block_id == 0) {
-      BitVector::Iterator iterator(live);
-      bool found = false;
-      while (!iterator.Done()) {
-        found = true;
-        int operand_index = iterator.Current();
-        PrintF("Register allocator error: live v%d reached first block.\n",
-               operand_index);
-        LiveRange* range = LiveRangeFor(operand_index);
-        PrintF("  (first use is at %d)\n", range->first_pos()->pos().Value());
-        if (debug_name() == nullptr) {
-          PrintF("\n");
-        } else {
-          PrintF("  (function: %s)\n", debug_name());
-        }
-        iterator.Advance();
-      }
-      DCHECK(!found);
-    }
-#endif
   }
 
   for (int i = 0; i < live_ranges_.length(); ++i) {
     if (live_ranges_[i] != NULL) {
       live_ranges_[i]->kind_ = RequiredRegisterKind(live_ranges_[i]->id());
 
       // TODO(bmeurer): This is a horrible hack to make sure that for constant
       // live ranges, every use requires the constant to be in a register.
       // Without this hack, all uses with "any" policy would get the constant
       // operand assigned.
@@ skipping 10 matching lines @@
                    ->IsGapMoves()) {
             pos->requires_reg_ = true;
           }
         }
       }
     }
   }
 }
 
 
+bool RegisterAllocator::ExistsUseWithoutDefinition() {
+  bool found = false;
+  BitVector::Iterator iterator(live_in_sets_[0]);
+  while (!iterator.Done()) {
+    found = true;
+    int operand_index = iterator.Current();
+    PrintF("Register allocator error: live v%d reached first block.\n",
+           operand_index);
+    LiveRange* range = LiveRangeFor(operand_index);
+    PrintF("  (first use is at %d)\n", range->first_pos()->pos().Value());
+    if (debug_name() == nullptr) {
+      PrintF("\n");
+    } else {
+      PrintF("  (function: %s)\n", debug_name());
+    }
+    iterator.Advance();
+  }
+  return found;
+}
+
+
 bool RegisterAllocator::SafePointsAreInOrder() const {
   int safe_point = 0;
   const PointerMapDeque* pointer_maps = code()->pointer_maps();
   for (PointerMapDeque::const_iterator it = pointer_maps->begin();
        it != pointer_maps->end(); ++it) {
     PointerMap* map = *it;
     if (safe_point > map->instruction_position()) return false;
     safe_point = map->instruction_position();
   }
   return true;
@@ skipping 766 matching lines @@
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg, code_zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler