Remove instruction summaries and provide a LIR-interface for the register all...

src/ia32/lithium-ia32.cc

Index: src/ia32/lithium-ia32.cc
===================================================================
--- src/ia32/lithium-ia32.cc	(revision 6414)
+++ src/ia32/lithium-ia32.cc	(working copy)
@@ -29,6 +29,7 @@
 
 #if defined(V8_TARGET_ARCH_IA32)
 
+#include "lithium-allocator-inl.h"
 #include "ia32/lithium-ia32.h"
 #include "ia32/lithium-codegen-ia32.h"
 
@@ -68,12 +69,42 @@
 }
 
 
+TempIterator LInstruction::GetTempIterator() { return TempIterator(this); }
+
+
+UseIterator LInstruction::GetUseIterator() { return UseIterator(this); }
+
+
+#ifdef DEBUG
+void LInstruction::VerifyCall() {
+  // Call instructions can use only fixed registers as
+  // temporaries and outputs because all registers
+  // are blocked by the calling convention.
+  // Inputs can use either fixed register or have a short lifetime (be
+  // used at start of the instruction).
+  ASSERT(Output() == NULL ||
+         LUnallocated::cast(Output())->HasFixedPolicy() ||
+         !LUnallocated::cast(Output())->HasRegisterPolicy());
+  for (UseIterator it = GetUseIterator(); it.HasNext(); ) {

[Kevin Millikin (Chromium), 2011/01/20 12:20:30]

I don't think the GetUseIterator/GetTempIterator functions add much.  You could
just use constructor syntax here:

for (UseIterator it(this); it.HasNext(); ) { ... }

You might also consider separating the functions for getting the current thing
and advancing to the next thing so you can write:

for (UseIterator it(this); it.HasNext(); it.Advance()) { ... }

so it reads better as a for loop (or keep HasNext's advancing semantics and
write it as a while loop?

{ UseIterator it(this);
  while (it.HasNext()) { ... }
}

).

[fschneider, 2011/01/20 17:13:08]

Done.

+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           LUnallocated::cast(operand)->IsUsedAtStart() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
+  }
+  for (TempIterator it = GetTempIterator(); it.HasNext(); ) {
+    LOperand* operand = it.Next();
+    ASSERT(LUnallocated::cast(operand)->HasFixedPolicy() ||
+           !LUnallocated::cast(operand)->HasRegisterPolicy());
+  }
+}
+#endif
+
+
 void LInstruction::PrintTo(StringStream* stream) {
   stream->Add("%s ", this->Mnemonic());
-  if (HasResult()) {
-    PrintOutputOperandTo(stream);
-  }
 
+  PrintOutputOperandTo(stream);
+
   PrintDataTo(stream);
 
   if (HasEnvironment()) {
@@ -669,7 +700,10 @@
 LInstruction* LChunkBuilder::MarkAsCall(LInstruction* instr,
                                         HInstruction* hinstr,
                                         CanDeoptimize can_deoptimize) {
-  allocator_->MarkAsCall();
+#ifdef DEBUG
+  instr->VerifyCall();
+#endif
+  instr->MarkAsCall();
   instr = AssignPointerMap(instr);
 
   if (hinstr->HasSideEffects()) {
@@ -694,7 +728,7 @@
 
 
 LInstruction* LChunkBuilder::MarkAsSaveDoubles(LInstruction* instr) {
-  allocator_->MarkAsSaveDoubles();
+  instr->MarkAsSaveDoubles();
   return instr;
 }
 
@@ -883,7 +917,6 @@
 void LChunkBuilder::VisitInstruction(HInstruction* current) {
   HInstruction* old_current = current_instruction_;
   current_instruction_ = current;
-  allocator_->BeginInstruction();
   if (current->has_position()) position_ = current->position();
   LInstruction* instr = current->CompileToLithium(this);
 
@@ -909,12 +942,9 @@
       instr->set_hydrogen_value(current);
     }
 
-    int index = chunk_->AddInstruction(instr, current_block_);
-    allocator_->SummarizeInstruction(index);
-  } else {
-    // This instruction should be omitted.
-    allocator_->OmitInstruction();
+    chunk_->AddInstruction(instr, current_block_);

[Kevin Millikin (Chromium), 2011/01/20 12:20:30]

Since you now always ignore the return value, you can AddInstruction a void
function (and simplify its implementation a bit).

[fschneider, 2011/01/20 17:13:08]

Done.

[Kevin Millikin (Chromium), 2011/02/04 11:48:09]

I mean "make AddInstruction a void function".

   }
+
   current_instruction_ = old_current;
 }