ARM/ARM64: Optimise HLoadNamedField and HStoreNamedField.

src/hydrogen-instructions.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 1188 matching lines @@
   HInstruction* previous_;
   HPositionInfo position_;
 
   friend class HBasicBlock;
 };
 
 
 template<int V>
 class HTemplateInstruction : public HInstruction {
  public:
-  virtual int OperandCount() V8_FINAL V8_OVERRIDE { return V; }
+  virtual int OperandCount() V8_OVERRIDE { return V; }
   virtual HValue* OperandAt(int i) const V8_FINAL V8_OVERRIDE {
     return inputs_[i];
   }
 
  protected:
   HTemplateInstruction(HType type = HType::Tagged()) : HInstruction(type) {}
 
   virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
     inputs_[i] = value;
   }
@@ skipping 4999 matching lines @@
   friend class HLoadNamedField;
   friend class HStoreNamedField;
   friend class SideEffectsTracker;
 
   inline Portion portion() const {
     return PortionField::decode(value_);
   }
 };
 
 
-class HLoadNamedField V8_FINAL : public HTemplateInstruction<2> {
+class HLoadNamedField V8_FINAL : public HTemplateInstruction<3> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*,
                                  HValue*, HObjectAccess);
+  DECLARE_INSTRUCTION_FACTORY_P4(HLoadNamedField, HValue*,
+                                 HValue*, HObjectAccess, HValue*);
   DECLARE_INSTRUCTION_FACTORY_P5(HLoadNamedField, HValue*, HValue*,
                                  HObjectAccess, const UniqueSet<Map>*, HType);
+  DECLARE_INSTRUCTION_FACTORY_P6(HLoadNamedField, HValue*, HValue*,
+                                 HObjectAccess, const UniqueSet<Map>*, HType,
+                                 HValue*);
+
+  virtual int OperandCount() V8_OVERRIDE {
+    return (object_properties() != NULL) ? 3 : 2;
+  }
 
   HValue* object() { return OperandAt(0); }
   HValue* dependency() {
     ASSERT(HasDependency());
     return OperandAt(1);
   }
   bool HasDependency() const { return OperandAt(0) != OperandAt(1); }
+  HValue* object_properties() { return OperandAt(2); }
   HObjectAccess access() const { return access_; }
   Representation field_representation() const {
       return access_.representation();
   }
 
   const UniqueSet<Map>* maps() const { return maps_; }
 
   virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
   virtual bool HasOutOfBoundsAccess(int size) V8_OVERRIDE {
     return !access().IsInobject() || access().offset() >= size;
@@ skipping 12 matching lines @@
     if (!CheckFlag(HValue::kCantBeReplaced)) return false;
     if (!type().Equals(other->type())) return false;
     if (!representation().Equals(other->representation())) return false;
     if (!other->IsLoadNamedField()) return true;
     HLoadNamedField* that = HLoadNamedField::cast(other);
     if (this->maps_ == that->maps_) return true;
     if (this->maps_ == NULL || that->maps_ == NULL) return false;
     return this->maps_->IsSubset(that->maps_);
   }
 
+  static bool PreferExtractLoadPropertiesPointer() {
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
+    return true;
+#else
+    return false;
+#endif
+  }
+  static bool NeedsPropertiesPointer(HObjectAccess access) {
+    return !(access.IsExternalMemory() ||
+             access.representation().IsDouble() ||
+             access.IsInobject());
+  }
+
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
 
  protected:
   virtual bool DataEquals(HValue* other) V8_OVERRIDE {
     HLoadNamedField* that = HLoadNamedField::cast(other);
     if (!this->access_.Equals(that->access_)) return false;
     if (this->maps_ == that->maps_) return true;
     return (this->maps_ != NULL &&
             that->maps_ != NULL &&
             this->maps_->Equals(that->maps_));
   }
 
  private:
   HLoadNamedField(HValue* object,
                   HValue* dependency,
-                  HObjectAccess access)
+                  HObjectAccess access,
+                  HValue* object_properties = NULL)
       : access_(access), maps_(NULL) {
     ASSERT_NOT_NULL(object);
     SetOperandAt(0, object);
     SetOperandAt(1, dependency ? dependency : object);
+    SetOperandAt(2, object_properties);
 
     Representation representation = access.representation();
     if (representation.IsInteger8() ||
         representation.IsUInteger8() ||
         representation.IsInteger16() ||
         representation.IsUInteger16()) {
       set_representation(Representation::Integer32());
     } else if (representation.IsSmi()) {
       set_type(HType::Smi());
       if (SmiValuesAre32Bits()) {
@@ skipping 11 matching lines @@
     } else {
       set_representation(Representation::Tagged());
     }
     access.SetGVNFlags(this, LOAD);
   }
 
   HLoadNamedField(HValue* object,
                   HValue* dependency,
                   HObjectAccess access,
                   const UniqueSet<Map>* maps,
-                  HType type)
-      : HTemplateInstruction<2>(type), access_(access), maps_(maps) {
+                  HType type,
+                  HValue* object_properties = NULL)
+      : HTemplateInstruction<3>(type), access_(access), maps_(maps) {
     ASSERT_NOT_NULL(maps);
     ASSERT_NE(0, maps->size());
 
     ASSERT_NOT_NULL(object);
     SetOperandAt(0, object);
     SetOperandAt(1, dependency ? dependency : object);
+    SetOperandAt(2, object_properties);
 
     ASSERT(access.representation().IsHeapObject());
     ASSERT(type.IsHeapObject());
     set_representation(Representation::Tagged());
 
     access.SetGVNFlags(this, LOAD);
   }
 
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 
@@ skipping 307 matching lines @@
 // initialized or not.
 enum StoreFieldOrKeyedMode {
   // The entry could be either previously initialized or not.
   INITIALIZING_STORE,
   // At the time of this store it is guaranteed that the entry is already
   // initialized.
   STORE_TO_INITIALIZED_ENTRY
 };
 
 
-class HStoreNamedField V8_FINAL : public HTemplateInstruction<3> {
+class HStoreNamedField V8_FINAL : public HTemplateInstruction<4> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*,
                                  HObjectAccess, HValue*);
   DECLARE_INSTRUCTION_FACTORY_P4(HStoreNamedField, HValue*,
                                  HObjectAccess, HValue*, StoreFieldOrKeyedMode);
+  DECLARE_INSTRUCTION_FACTORY_P5(HStoreNamedField, HValue*,
+                                 HObjectAccess, HValue*, StoreFieldOrKeyedMode,
+                                 HValue*);
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedField)
 
+  virtual int OperandCount() V8_OVERRIDE {
+    return (object_properties() != NULL) ? 4 : 3;
+  }
+
   virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE {
     return index == 1;
   }
   virtual bool HasOutOfBoundsAccess(int size) V8_OVERRIDE {
     return !access().IsInobject() || access().offset() >= size;
   }
   virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
     if (index == 0 && access().IsExternalMemory()) {
       // object must be external in case of external memory access
       return Representation::External();
@@ skipping 22 matching lines @@
     ASSERT(side_effect == kNewSpacePromotion);
     if (!FLAG_use_write_barrier_elimination) return false;
     dominator_ = dominator;
     return false;
   }
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 
   HValue* object() const { return OperandAt(0); }
   HValue* value() const { return OperandAt(1); }
   HValue* transition() const { return OperandAt(2); }
+  HValue* object_properties() { return OperandAt(3); }
 
   HObjectAccess access() const { return access_; }
   HValue* dominator() const { return dominator_; }
   bool has_transition() const { return has_transition_; }
   StoreFieldOrKeyedMode store_mode() const { return store_mode_; }
 
   Handle<Map> transition_map() const {
     if (has_transition()) {
       return Handle<Map>::cast(
           HConstant::cast(transition())->handle(Isolate::Current()));
@@ skipping 17 matching lines @@
     if (field_representation().IsExternal()) return false;
     return StoringValueNeedsWriteBarrier(value()) &&
         ReceiverObjectNeedsWriteBarrier(object(), value(), dominator());
   }
 
   bool NeedsWriteBarrierForMap() {
     return ReceiverObjectNeedsWriteBarrier(object(), transition(),
                                            dominator());
   }
 
+  static bool PreferExtractLoadPropertiesPointer() {
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
+    return true;

[ulan, 2014/06/12 13:39:18]

Could you please port this to other architectures and get rid of this function?

+#else
+    return false;
+#endif
+  }
+  static bool NeedsPropertiesPointer(HObjectAccess access) {
+    return !(access.IsExternalMemory() ||

[ulan, 2014/06/12 13:39:18]

This predicate should be part of HObjectAccess (if Ben doesn't disagree).

+             access.representation().IsDouble() ||
+             access.IsInobject());
+  }
+
   SmiCheck SmiCheckForWriteBarrier() const {
     if (field_representation().IsHeapObject()) return OMIT_SMI_CHECK;
     if (value()->type().IsHeapObject()) return OMIT_SMI_CHECK;
     return INLINE_SMI_CHECK;
   }
 
   PointersToHereCheck PointersToHereCheckForValue() const {
     return PointersToHereCheckForObject(value(), dominator());
   }
 
@@ skipping 15 matching lines @@
       // an initialized entry on 64-bit architectures (with 32-bit smis).
       return false;
     }
     return true;
   }
 
  private:
   HStoreNamedField(HValue* obj,
                    HObjectAccess access,
                    HValue* val,
-                   StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE)
+                   StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE,
+                   HValue* obj_properties = NULL)
       : access_(access),
         dominator_(NULL),
         has_transition_(false),
         store_mode_(store_mode) {
     // Stores to a non existing in-object property are allowed only to the
     // newly allocated objects (via HAllocate or HInnerAllocatedObject).
     ASSERT(!access.IsInobject() || access.existing_inobject_property() ||
            obj->IsAllocate() || obj->IsInnerAllocatedObject());
     SetOperandAt(0, obj);
     SetOperandAt(1, val);
     SetOperandAt(2, obj);
+    SetOperandAt(3, obj_properties);
     access.SetGVNFlags(this, STORE);
   }
 
   HObjectAccess access_;
   HValue* dominator_;
   bool has_transition_ : 1;
   StoreFieldOrKeyedMode store_mode_ : 1;
 };
 
 
@@ skipping 952 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_