Revert of Remove ExternalArray, derived types, and element kinds

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 <cstring>
 #include <iosfwd>
 
@@ skipping 6230 matching lines @@
   static HObjectAccess ForJSArrayBufferBitField() {
     return HObjectAccess::ForObservableJSObjectOffset(
         JSArrayBuffer::kBitFieldOffset, Representation::Integer32());
   }
 
   static HObjectAccess ForJSArrayBufferBitFieldSlot() {
     return HObjectAccess::ForObservableJSObjectOffset(
         JSArrayBuffer::kBitFieldSlot, Representation::Smi());
   }
 
+  static HObjectAccess ForExternalArrayExternalPointer() {
+    return HObjectAccess::ForObservableJSObjectOffset(
+        ExternalArray::kExternalPointerOffset, Representation::External());
+  }
+
   static HObjectAccess ForJSArrayBufferViewBuffer() {
     return HObjectAccess::ForObservableJSObjectOffset(
         JSArrayBufferView::kBufferOffset);
   }
 
   static HObjectAccess ForJSArrayBufferViewByteOffset() {
     return HObjectAccess::ForObservableJSObjectOffset(
         JSArrayBufferView::kByteOffsetOffset);
   }
 
@@ skipping 349 matching lines @@
 class HLoadKeyed final : public HTemplateInstruction<3>,
                          public ArrayInstructionInterface {
  public:
   DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind);
   DECLARE_INSTRUCTION_FACTORY_P5(HLoadKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind, LoadKeyedHoleMode);
   DECLARE_INSTRUCTION_FACTORY_P6(HLoadKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind, LoadKeyedHoleMode, int);
 
+  bool is_external() const {
+    return IsExternalArrayElementsKind(elements_kind());
+  }
   bool is_fixed_typed_array() const {
     return IsFixedTypedArrayElementsKind(elements_kind());
   }
+  bool is_typed_elements() const {
+    return is_external() || is_fixed_typed_array();
+  }
   HValue* elements() const { return OperandAt(0); }
   HValue* key() const { return OperandAt(1); }
   HValue* dependency() const {
     DCHECK(HasDependency());
     return OperandAt(2);
   }
   bool HasDependency() const { return OperandAt(0) != OperandAt(2); }
   uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); }
   bool TryIncreaseBaseOffset(uint32_t increase_by_value) override;
   HValue* GetKey() override { return key(); }
@@ skipping 10 matching lines @@
   LoadKeyedHoleMode hole_mode() const {
     return HoleModeField::decode(bit_field_);
   }
 
   Representation RequiredInputRepresentation(int index) override {
     // kind_fast:                 tagged[int32] (none)
     // kind_double:               tagged[int32] (none)
     // kind_fixed_typed_array:    external[int32] (none)
     // kind_external:             external[int32] (none)
     if (index == 0) {
-      return is_fixed_typed_array() ? Representation::External()
-                                    : Representation::Tagged();
+      return is_typed_elements() ? Representation::External()
+                                 : Representation::Tagged();
     }
     if (index == 1) {
       return ArrayInstructionInterface::KeyedAccessIndexRequirement(
           OperandAt(1)->representation());
     }
     return Representation::None();
   }
 
   Representation observed_input_representation(int index) override {
     return RequiredInputRepresentation(index);
@@ skipping 28 matching lines @@
         ? GetDefaultHeaderSizeForElementsKind(elements_kind)
         : offset;
     bit_field_ = ElementsKindField::encode(elements_kind) |
         HoleModeField::encode(mode) |
         BaseOffsetField::encode(offset);
 
     SetOperandAt(0, obj);
     SetOperandAt(1, key);
     SetOperandAt(2, dependency != NULL ? dependency : obj);
 
-    if (!is_fixed_typed_array()) {
+    if (!is_typed_elements()) {
       // I can detect the case between storing double (holey and fast) and
       // smi/object by looking at elements_kind_.
       DCHECK(IsFastSmiOrObjectElementsKind(elements_kind) ||
              IsFastDoubleElementsKind(elements_kind));
 
       if (IsFastSmiOrObjectElementsKind(elements_kind)) {
         if (IsFastSmiElementsKind(elements_kind) &&
             (!IsHoleyElementsKind(elements_kind) ||
              mode == NEVER_RETURN_HOLE)) {
           set_type(HType::Smi());
           if (SmiValuesAre32Bits() && !RequiresHoleCheck()) {
             set_representation(Representation::Integer32());
           } else {
             set_representation(Representation::Smi());
           }
         } else {
           set_representation(Representation::Tagged());
         }
 
         SetDependsOnFlag(kArrayElements);
       } else {
         set_representation(Representation::Double());
         SetDependsOnFlag(kDoubleArrayElements);
       }
     } else {
-      if (elements_kind == FLOAT32_ELEMENTS ||
+      if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
+          elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
+          elements_kind == FLOAT32_ELEMENTS ||
           elements_kind == FLOAT64_ELEMENTS) {
         set_representation(Representation::Double());
       } else {
         set_representation(Representation::Integer32());
       }
 
-      if (is_fixed_typed_array()) {
+      if (is_external()) {
         SetDependsOnFlag(kExternalMemory);
+      } else if (is_fixed_typed_array()) {
         SetDependsOnFlag(kTypedArrayElements);
       } else {
         UNREACHABLE();
       }
       // Native code could change the specialized array.
       SetDependsOnFlag(kCalls);
     }
 
     SetFlag(kUseGVN);
   }
@@ skipping 354 matching lines @@
   DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind, StoreFieldOrKeyedMode, int);
 
   Representation RequiredInputRepresentation(int index) override {
     // kind_fast:               tagged[int32] = tagged
     // kind_double:             tagged[int32] = double
     // kind_smi   :             tagged[int32] = smi
     // kind_fixed_typed_array:  tagged[int32] = (double | int32)
     // kind_external:           external[int32] = (double | int32)
     if (index == 0) {
-      return is_fixed_typed_array() ? Representation::External()
-                                    : Representation::Tagged();
+      return is_typed_elements() ? Representation::External()
+                                 : Representation::Tagged();
     } else if (index == 1) {
       return ArrayInstructionInterface::KeyedAccessIndexRequirement(
           OperandAt(1)->representation());
     }
 
     DCHECK_EQ(index, 2);
     return RequiredValueRepresentation(elements_kind(), store_mode());
   }
 
   static Representation RequiredValueRepresentation(
       ElementsKind kind, StoreFieldOrKeyedMode mode) {
     if (IsDoubleOrFloatElementsKind(kind)) {
       return Representation::Double();
     }
 
     if (kind == FAST_SMI_ELEMENTS && SmiValuesAre32Bits() &&
         mode == STORE_TO_INITIALIZED_ENTRY) {
       return Representation::Integer32();
     }
 
     if (IsFastSmiElementsKind(kind)) {
       return Representation::Smi();
     }
 
-    if (IsFixedTypedArrayElementsKind(kind)) {
-      return Representation::Integer32();
-    }
-    return Representation::Tagged();
+    return IsExternalArrayElementsKind(kind) ||
+                   IsFixedTypedArrayElementsKind(kind)
+               ? Representation::Integer32()
+               : Representation::Tagged();
+  }
+
+  bool is_external() const {
+    return IsExternalArrayElementsKind(elements_kind());
   }
 
   bool is_fixed_typed_array() const {
     return IsFixedTypedArrayElementsKind(elements_kind());
   }
 
+  bool is_typed_elements() const {
+    return is_external() || is_fixed_typed_array();
+  }
+
   Representation observed_input_representation(int index) override {
     if (index < 2) return RequiredInputRepresentation(index);
     if (IsUninitialized()) {
       return Representation::None();
     }
     Representation r =
         RequiredValueRepresentation(elements_kind(), store_mode());
     // For fast object elements kinds, don't assume anything.
     if (r.IsTagged()) return Representation::None();
     return r;
@@ skipping 69 matching lines @@
                    ElementsKindField::encode(elements_kind)),
         dominator_(NULL) {
     SetOperandAt(0, obj);
     SetOperandAt(1, key);
     SetOperandAt(2, val);
 
     if (IsFastObjectElementsKind(elements_kind)) {
       SetFlag(kTrackSideEffectDominators);
       SetDependsOnFlag(kNewSpacePromotion);
     }
-    if (IsFastDoubleElementsKind(elements_kind)) {
+    if (is_external()) {
+      SetChangesFlag(kExternalMemory);
+      SetFlag(kAllowUndefinedAsNaN);
+    } else if (IsFastDoubleElementsKind(elements_kind)) {
       SetChangesFlag(kDoubleArrayElements);
     } else if (IsFastSmiElementsKind(elements_kind)) {
       SetChangesFlag(kArrayElements);
     } else if (is_fixed_typed_array()) {
       SetChangesFlag(kTypedArrayElements);
-      SetChangesFlag(kExternalMemory);
       SetFlag(kAllowUndefinedAsNaN);
     } else {
       SetChangesFlag(kArrayElements);
     }
 
-    // {UNSIGNED_,}{BYTE,SHORT,INT}_ELEMENTS are truncating.
-    if (elements_kind >= UINT8_ELEMENTS && elements_kind <= INT32_ELEMENTS) {
+    // EXTERNAL_{UNSIGNED_,}{BYTE,SHORT,INT}_ELEMENTS are truncating.
+    if ((elements_kind >= EXTERNAL_INT8_ELEMENTS &&
+        elements_kind <= EXTERNAL_UINT32_ELEMENTS) ||
+        (elements_kind >= UINT8_ELEMENTS &&
+        elements_kind <= INT32_ELEMENTS)) {
       SetFlag(kTruncatingToInt32);
     }
   }
 
   class IsDehoistedField : public BitField<bool, 0, 1> {};
   class IsUninitializedField : public BitField<bool, 1, 1> {};
   class StoreModeField : public BitField<StoreFieldOrKeyedMode, 2, 1> {};
   class ElementsKindField : public BitField<ElementsKind, 3, 5> {};
 
   uint32_t base_offset_;
@@ skipping 807 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_