Clean up the Result class. Reduce the size of Result from four words...

src/register-allocator.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 85 matching lines @@
     SMI_TYPE         = 0x01,
     HEAP_OBJECT_TYPE = 0x02,
     STRING_TYPE      = 0x04 | HEAP_OBJECT_TYPE
   };
   explicit StaticType(StaticTypeEnum static_type) : static_type_(static_type) {}
 
   // StaticTypeEnum static_type_;
   StaticTypeEnum static_type_;
 
   friend class FrameElement;
+  friend class Result;
 };
 
 
 // -------------------------------------------------------------------------
 // Results
 //
 // Results encapsulate the compile-time values manipulated by the code
 // generator.  They can represent registers or constants.
 
 class Result BASE_EMBEDDED {
  public:
   enum Type {
     INVALID,
     REGISTER,
     CONSTANT
   };
 
   // Construct an invalid result.
-  explicit Result(CodeGenerator* cgen)
-      : static_type_(),
-        type_(INVALID),
-        cgen_(cgen) {}
+  explicit Result() { invalidate(); }

[Kevin Millikin (Chromium), 2009/05/15 10:50:49]

Doesn't need explicit anymore.

[Mads Ager (chromium), 2009/05/15 11:05:25]

Done.

 
   // Construct a register Result.
-  Result(Register reg,
-         CodeGenerator* cgen);
+  explicit Result(Register reg);
 
   // Construct a register Result with a known static type.
-  Result(Register reg,
-         CodeGenerator* cgen,
-         StaticType static_type);
+  Result(Register reg, StaticType static_type);
 
   // Construct a Result whose value is a compile-time constant.
-  Result(Handle<Object> value, CodeGenerator * cgen)
-      : static_type_(StaticType::TypeOf(*value)),
-        type_(CONSTANT),
-        cgen_(cgen) {
-    data_.handle_ = value.location();
+  explicit Result(Handle<Object> value) {
+    value_ = StaticTypeField::encode(StaticType::TypeOf(*value).static_type_)
+        | TypeField::encode(CONSTANT)
+        | DataField::encode(ConstantList()->length());
+    ConstantList()->Add(value);
   }
 
   // The copy constructor and assignment operators could each create a new
   // register reference.
   Result(const Result& other) {
     other.CopyTo(this);
   }
 
   Result& operator=(const Result& other) {
     if (this != &other) {
       Unuse();
       other.CopyTo(this);
     }
     return *this;
   }
 
   inline ~Result();
 
+  // Static indirection table for handles to constants.  If a Result
+  // represents a constant, the data contains an index into this table
+  // of handles to the actual constants.
+  typedef ZoneList<Handle<Object> > ZoneObjectList;
+
+  static ZoneObjectList* ConstantList() {
+    static ZoneObjectList list(10);
+    return &list;
+  }
+
+  // Clear the constants indirection table.
+  static void ClearConstantList() {
+    ConstantList()->Clear();
+  }
+
   inline void Unuse();
 
-  StaticType static_type() const { return static_type_; }
-  void set_static_type(StaticType static_type) { static_type_ = static_type; }
+  StaticType static_type() const {
+    return StaticType(StaticTypeField::decode(value_));
+  }
 
-  Type type() const { return static_cast<Type>(type_); }
+  void set_static_type(StaticType type) {
+    value_ = value_ & ~StaticTypeField::mask();
+    value_ = value_ | StaticTypeField::encode(type.static_type_);
+  }
+
+  Type type() const { return TypeField::decode(value_); }
+
+  void invalidate() { value_ = TypeField::encode(INVALID); }
 
   bool is_valid() const { return type() != INVALID; }
   bool is_register() const { return type() == REGISTER; }
   bool is_constant() const { return type() == CONSTANT; }
 
   Register reg() const {
-    ASSERT(type() == REGISTER);
-    return data_.reg_;
+    ASSERT(is_register());
+    uint32_t reg = DataField::decode(value_);
+    Register result;
+    result.code_ = reg;
+    return result;
   }
 
   Handle<Object> handle() const {
     ASSERT(type() == CONSTANT);
-    return Handle<Object>(data_.handle_);
+    return ConstantList()->at(DataField::decode(value_));
   }
 
   // Move this result to an arbitrary register.  The register is not
   // necessarily spilled from the frame or even singly-referenced outside
   // it.
   void ToRegister();
 
   // Move this result to a specified register.  The register is spilled from
   // the frame, and the register is singly-referenced (by this result)
   // outside the frame.
   void ToRegister(Register reg);
 
  private:
-  StaticType static_type_;
-  byte type_;
+  uint32_t value_;
 
-  union {
-    Register reg_;
-    Object** handle_;
-  } data_;
+  class StaticTypeField: public BitField<StaticType::StaticTypeEnum, 0, 3> {};
+  class TypeField: public BitField<Type, 3, 2> {};
+  class DataField: public BitField<uint32_t, 5, 32 - 6> {};
 
-  CodeGenerator* cgen_;
+  static CodeGenerator* cgen_;
 
-  void CopyTo(Result* destination) const;
+  inline void CopyTo(Result* destination) const;
+
+  friend class CodeGeneratorScope;
 };
 
 
 // -------------------------------------------------------------------------
 // Register file
 //
 // The register file tracks reference counts for the processor registers.
 // It is used by both the register allocator and the virtual frame.
 
 class RegisterFile BASE_EMBEDDED {
@@ skipping 120 matching lines @@
   }
 
  private:
   CodeGenerator* cgen_;
   RegisterFile registers_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_REGISTER_ALLOCATOR_H_