Skip canonicalization of packed arrays in HStoreKeyedFastDoubleElement

src/hydrogen-instructions.h

 // Copyright 2012 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 4284 matching lines @@
   uint32_t index_offset_;
   bool is_dehoisted_;
 };
 
 
 class HStoreKeyedFastDoubleElement
     : public HTemplateInstruction<3>, public ArrayInstructionInterface {
  public:
   HStoreKeyedFastDoubleElement(HValue* elements,
                                HValue* key,
-                               HValue* val)
-      : index_offset_(0), is_dehoisted_(false) {
+                               HValue* val,
+                               ElementsKind element_kind)

[Jakob Kummerow, 2012/06/05 09:05:40]

nit: for consistency, "elements_kind" (with 's') please.

+      : index_offset_(0), bit_field_(0) {
+    bit_field_ = IsDehoisted::encode(false) |
+        SkipCanonicalization::encode(IsFastPackedElementsKind(element_kind));
     SetOperandAt(0, elements);
     SetOperandAt(1, key);
     SetOperandAt(2, val);
     SetGVNFlag(kChangesDoubleArrayElements);
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     if (index == 1) {
       return Representation::Integer32();
     } else if (index == 2) {
       return Representation::Double();
     } else {
       return Representation::Tagged();
     }
   }
 
   HValue* elements() { return OperandAt(0); }
   HValue* key() { return OperandAt(1); }
   HValue* value() { return OperandAt(2); }
   uint32_t index_offset() { return index_offset_; }
   void SetIndexOffset(uint32_t index_offset) { index_offset_ = index_offset; }
   HValue* GetKey() { return key(); }
   void SetKey(HValue* key) { SetOperandAt(1, key); }
-  bool IsDehoisted() { return is_dehoisted_; }
-  void SetDehoisted(bool is_dehoisted) { is_dehoisted_ = is_dehoisted; }
+  bool IsDehoisted() { return IsDehoisted::decode(bit_field_); }
+  void SetDehoisted(bool is_dehoisted) {
+    bit_field_ = IsDehoisted::update(bit_field_, is_dehoisted);
+  }
 
   bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
   bool NeedsCanonicalization();
 
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(StoreKeyedFastDoubleElement)
 
  private:
+  class IsDehoisted:           public BitField<bool, 0, 1> {};
+  class SkipCanonicalization:  public BitField<bool, 1, 2> {};

[Jakob Kummerow, 2012/06/05 09:05:40]

not that it matters, but why use two bits to store this bool?
(the syntax is Bitfield<type, shift, size>)

[Vyacheslav Egorov (Google), 2012/06/05 09:13:24]

why not 

bool is_dehoisted_ : 1;
bool skip_canonicalization_ : 1;

?

+
   uint32_t index_offset_;
-  bool is_dehoisted_;
+  uint32_t bit_field_;
 };
 
 
 class HStoreKeyedSpecializedArrayElement
     : public HTemplateInstruction<3>, public ArrayInstructionInterface {
  public:
   HStoreKeyedSpecializedArrayElement(HValue* external_elements,
                                      HValue* key,
                                      HValue* val,
                                      ElementsKind elements_kind)
@@ skipping 701 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_