Allow non-spilled frames into VisitCompareOperation, and allow them...

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 22 matching lines @@
 
 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);
+  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(!is_register() || reg().is(no_reg));
+    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 };
+  enum Type {
+    REGISTER,
+    CONSTANT,
+    INVALID
+  };
 
   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 367 matching lines @@
   // This is because some new memory-to-register moves are
   // created in order to break cycles of register moves.
   // Used in the implementation of MergeTo().
   void MergeMoveRegistersToRegisters(VirtualFrame *expected);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_