A first stab at using the top of stack as the...

src/virtual-frame-ia32.h

 // Copyright 2008 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_VIRTUAL_FRAME_IA32_H_
 #define V8_VIRTUAL_FRAME_IA32_H_
 
 #include "macro-assembler.h"
 #include "register-allocator.h"
 
 namespace v8 { namespace internal {
 
+
+// The code generator's view of a frame element, when it wants to use it.
+//
+// A Result can be a register or a constant.
+class Result BASE_EMBEDDED {
+ public:
+  // Construct a register Result.
+  explicit Result(Register reg, CodeGenerator* cgen);
+
+  // Construct a Result whose value is a compile-time constant.
+  Result(Handle<Object> value, CodeGenerator * cgen) :
+      type_(CONSTANT),
+      cgen_(cgen) {
+    data_.handle_ = value.location();
+  }
+
+  ~Result() {
+    // We have called Unuse() before Result goes out of scope.
+    ASSERT(reg_.is(no_reg));
+  }
+
+  void Unuse();
+
+  bool is_register() const { return type() == REGISTER; }
+  bool is_constant() const { return type() == CONSTANT; }
+
+  Register reg() const {
+    ASSERT(type() == REGISTER);
+    return data_.reg_;
+  }
+
+  Handle<Object> handle() const {
+    ASSERT(type() == CONSTANT);
+    return Handle<Object>(data_.handle_);
+  }
+
+ private:
+  enum Type { REGISTER, CONSTANT };
+
+  Type type_;
+
+  Type type() const { return type_; }
+
+  union {
+    Register reg_;
+    Object** handle_;
+  } data_;
+
+  CodeGenerator* cgen_;
+};
+
+
+// A result in a register just means that the value can be read from the register
+
+
 // -------------------------------------------------------------------------
 // Virtual frame elements
 //
 // The internal elements of the virtual frames.  There are several kinds of
 // elements:
 //   * Memory: an element that resides in the actual frame.  Its address is
 //     given by its position in the virtual frame.
 //   * Register: an element that resides in a register.
 //   * Constant: an element whose value is known at compile time.
 
@@ skipping 198 matching lines @@
                       int frame_arg_count);
 
   // Drop a number of elements from the top of the expression stack.  May
   // emit code to affect the physical frame.  Does not clobber any registers
   // excepting possibly the stack pointer.
   void Drop(int count);
 
   // Drop one element.
   void Drop();
 
+  // Pop an element from the top of the expression stack.
+  // Returns a Result, which may be a constant or a register.
+  Result Pop();
+
   // Pop and save an element from the top of the expression stack and emit a
   // corresponding pop instruction.
   void EmitPop(Register reg);
   void EmitPop(Operand operand);
 
   // Push an element on top of the expression stack and emit a corresponding
   // push instruction.
   void EmitPush(Register reg);
   void EmitPush(Operand operand);
   void EmitPush(Immediate immediate);
@@ skipping 100 matching lines @@
 
   // Spill the topmost elements of the frame to memory (eg, they are the
   // arguments to a call) and all registers.
   void PrepareForCall(int count);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_