Experimental: use the Result class to manage the lifetime of registers...

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.
-  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() {
-    if (is_register()) {
-      Unuse();
-    }
-  }
-
-  void Unuse();
-
-  bool is_register() const { return type() == REGISTER; }
-  bool is_constant() const { return type() == CONSTANT; }
-  bool is_valid() const { return type() != INVALID; }
-
-  Register reg() const {
-    ASSERT(type() == REGISTER);
-    return data_.reg_;
-  }
-
-  Handle<Object> handle() const {
-    ASSERT(type() == CONSTANT);
-    return Handle<Object>(data_.handle_);
-  }
-
-  // Change a result to a register result.  If the result is not already
-  // in a register, allocate a register from the code generator, and emit
-  // code to move the value into that register.
-  void ToRegister();
- private:
-  enum Type {
-    REGISTER,
-    CONSTANT,
-    INVALID
-  };
-
-  Type type_;
-
-  Type type() const { return type_; }
-
-  union {
-    Register reg_;
-    Object** handle_;
-  } data_;
-
-  CodeGenerator* cgen_;
-};
-
-
 // -------------------------------------------------------------------------
 // Virtual frame elements
 //
 // The internal elements of the virtual frames.  There are several kinds of
 // elements:
 //   * Invalid: elements that are uninitialized or not actually part
 //     of the virtual frame.  They should not be read.
 //   * 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.
@@ skipping 286 matching lines @@
   // 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);
 
   // Push an element on the virtual frame.
   void Push(Register reg);
   void Push(Handle<Object> value);
 
+  // Pushing a result invalidates it (its contents become owned by the
+  // frame).
+  void Push(Result* result);
+
 #ifdef DEBUG
   bool IsSpilled();
 #endif
 
  private:
   // An illegal index into the virtual frame.
   static const int kIllegalIndex = -1;
 
   static const int kLocal0Offset = JavaScriptFrameConstants::kLocal0Offset;
   static const int kFunctionOffset = JavaScriptFrameConstants::kFunctionOffset;
@@ skipping 115 matching lines @@
   // Called after all register-to-memory and register-to-register
   // moves have been made.  After this function returns, the frames
   // should be equal.
   void MergeMoveMemoryToRegisters(VirtualFrame *expected);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_