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

src/lithium.h

 // Copyright 2011 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 470 matching lines @@
   }
 
   void SetSpilledRegisters(LOperand** registers,
                            LOperand** double_registers) {
     spilled_registers_ = registers;
     spilled_double_registers_ = double_registers;
   }
 
   void PrintTo(StringStream* stream);
 
+  class ShallowIterator BASE_EMBEDDED {
+   public:
+    explicit ShallowIterator(LEnvironment* env) : env_(env), current_(0) {
+      Advance();
+    }
+    inline bool HasNext() {
+      return env_ != NULL && current_ < env_->values()->length();
+    }
+
+    inline LOperand* Next() {
+      ASSERT(env_ != NULL);

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

In normal use, should one ever call Next on an environment that is not known to
HasNext()?

In other words, I would expect ASSERT(HasNext()) rather than checking for it.

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

Done.

+      LOperand* elem = HasNext() ? env_->values()->at(current_++) : NULL;
+      Advance();
+      return elem;
+    }
+
+   private:
+    inline void Advance() {
+      while (HasNext() &&
+             (env_->values()->at(current_) == NULL ||
+              env_->values()->at(current_)->IsConstantOperand())) {
+        current_++;
+      }
+    }
+
+    LEnvironment* env_;
+    int current_;
+  };
+
+  // Iterates over the non-null, non-constant operands in this environment.
+  ShallowIterator shallow_iterator() { return ShallowIterator(this); }

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

This function (and deep_iterator) probably shouldn't have hacker_style_naming. 
It returns a fresh object on each call so it's not just an accessor, and the
object has a non-trivial constructor.

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

Done.

+
+  class DeepIterator BASE_EMBEDDED {
+   public:
+    explicit DeepIterator(LEnvironment* env)
+        : current_env_(env), current_iterator_(env) { }
+
+    inline bool HasNext() {
+      if (current_env_ == NULL) return false;

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

I think you can simplify this class's implementation a bit.  The current_env_ is
the environment where Next() will be found if HasNext() and NULL otherwise.  The
current_iterator_ is always a shallow iterator for the current environment.  The
shallow iterator for the NULL environment does not HasNext().

So:

inline bool HasNext() { return current_iterator_.HasNext(); }

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

Done.

+      if (current_iterator_.HasNext()) return true;
+      if (current_env_->outer() == NULL) return false;
+      Advance();
+      return  current_iterator_.HasNext();
+    }
+
+    inline LOperand* Next() {

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

inline LOperand* Next() {
  ASSERT(current_iterator_.HasNext());
  LOperand* operand = current_iterator_.Next();
  Advance();
  return operand;
}

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

Done.

+      if (current_iterator_.HasNext()) return current_iterator_.Next();
+      if (current_env_->outer() == NULL) return NULL;
+      Advance();
+      return current_iterator_.Next();
+    }
+
+   private:
+    inline void Advance() {

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

inline void Advance() {
  while (!current_iterator_.HasNext() && current_env_ != NULL) {
    current_env_ = current_env_->outer();
    current_iterator_ = ShallowIterator(current_env_);
  }
}

Then add to the constructor a call to Advance();

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

Done.

+      current_iterator_ = LEnvironment::ShallowIterator(current_env_->outer());
+      current_env_ = current_env_->outer();
+    }
+
+    LEnvironment* current_env_;
+    ShallowIterator current_iterator_;
+  };
+
+  // Iterator for non-null, non-constant operands incl. outer environments.
+  DeepIterator deep_iterator() { return DeepIterator(this); }
+
  private:
   Handle<JSFunction> closure_;
   int arguments_stack_height_;
   int deoptimization_index_;
   int translation_index_;
   int ast_id_;
   int parameter_count_;
   ZoneList<LOperand*> values_;
   ZoneList<Representation> representations_;
 
   // Allocation index indexed arrays of spill slot operands for registers
   // that are also in spill slots at an OSR entry.  NULL for environments
   // that do not correspond to an OSR entry.
   LOperand** spilled_registers_;
   LOperand** spilled_double_registers_;
 
   LEnvironment* outer_;
 
   friend class LCodegen;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_LITHIUM_H_