Remove ExternalArray, derived types, and element kinds

src/hydrogen-instructions.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/base/bits.h"
 #include "src/double.h"
 #include "src/elements.h"
 #include "src/factory.h"
@@ skipping 3189 matching lines @@
   }
   if (access().IsStringLength()) {
     return new(zone) Range(0, String::kMaxLength);
   }
   return HValue::InferRange(zone);
 }
 
 
 Range* HLoadKeyed::InferRange(Zone* zone) {
   switch (elements_kind()) {
-    case EXTERNAL_INT8_ELEMENTS:
     case INT8_ELEMENTS:
       return new(zone) Range(kMinInt8, kMaxInt8);
-    case EXTERNAL_UINT8_ELEMENTS:
-    case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
     case UINT8_ELEMENTS:
     case UINT8_CLAMPED_ELEMENTS:
       return new(zone) Range(kMinUInt8, kMaxUInt8);
-    case EXTERNAL_INT16_ELEMENTS:
     case INT16_ELEMENTS:
       return new(zone) Range(kMinInt16, kMaxInt16);
-    case EXTERNAL_UINT16_ELEMENTS:
     case UINT16_ELEMENTS:
       return new(zone) Range(kMinUInt16, kMaxUInt16);
     default:
       return HValue::InferRange(zone);
   }
 }
 
 
 std::ostream& HCompareGeneric::PrintDataTo(std::ostream& os) const {  // NOLINT
   os << Token::Name(token()) << " ";
@@ skipping 222 matching lines @@
 
 
 std::ostream& HLoadNamedGeneric::PrintDataTo(
     std::ostream& os) const {  // NOLINT
   Handle<String> n = Handle<String>::cast(name());
   return os << NameOf(object()) << "." << n->ToCString().get();
 }
 
 
 std::ostream& HLoadKeyed::PrintDataTo(std::ostream& os) const {  // NOLINT
-  if (!is_external()) {
+  if (!is_fixed_typed_array()) {
     os << NameOf(elements());
   } else {
-    DCHECK(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
-           elements_kind() <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND);
+    DCHECK(elements_kind() >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
+           elements_kind() <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND);
     os << NameOf(elements()) << "." << ElementsKindToString(elements_kind());
   }
 
   os << "[" << NameOf(key());
   if (IsDehoisted()) os << " + " << base_offset();
   os << "]";
 
   if (HasDependency()) os << " " << NameOf(dependency());
   if (RequiresHoleCheck()) os << " check_hole";
   return os;
@@ skipping 14 matching lines @@
   bit_field_ = BaseOffsetField::update(bit_field_, base_offset);
   return true;
 }
 
 
 bool HLoadKeyed::UsesMustHandleHole() const {
   if (IsFastPackedElementsKind(elements_kind())) {
     return false;
   }
 
-  if (IsExternalArrayElementsKind(elements_kind())) {
+  if (IsFixedTypedArrayElementsKind(elements_kind())) {
     return false;
   }
 
   if (hole_mode() == ALLOW_RETURN_HOLE) {
     if (IsFastDoubleElementsKind(elements_kind())) {
       return AllUsesCanTreatHoleAsNaN();
     }
     return true;
   }
 
@@ skipping 19 matching lines @@
   return IsFastDoubleElementsKind(elements_kind()) &&
       CheckUsesForFlag(HValue::kAllowUndefinedAsNaN);
 }
 
 
 bool HLoadKeyed::RequiresHoleCheck() const {
   if (IsFastPackedElementsKind(elements_kind())) {
     return false;
   }
 
-  if (IsExternalArrayElementsKind(elements_kind())) {
+  if (IsFixedTypedArrayElementsKind(elements_kind())) {
     return false;
   }
 
   if (hole_mode() == CONVERT_HOLE_TO_UNDEFINED) {
     return false;
   }
 
   return !UsesMustHandleHole();
 }
 
@@ skipping 54 matching lines @@
 
 std::ostream& HStoreNamedField::PrintDataTo(std::ostream& os) const {  // NOLINT
   os << NameOf(object()) << access_ << " = " << NameOf(value());
   if (NeedsWriteBarrier()) os << " (write-barrier)";
   if (has_transition()) os << " (transition map " << *transition_map() << ")";
   return os;
 }
 
 
 std::ostream& HStoreKeyed::PrintDataTo(std::ostream& os) const {  // NOLINT
-  if (!is_external()) {
+  if (!is_fixed_typed_array()) {
     os << NameOf(elements());
   } else {
-    DCHECK(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
-           elements_kind() <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND);
+    DCHECK(elements_kind() >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
+           elements_kind() <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND);
     os << NameOf(elements()) << "." << ElementsKindToString(elements_kind());
   }
 
   os << "[" << NameOf(key());
   if (IsDehoisted()) os << " + " << base_offset();
   return os << "] = " << NameOf(value());
 }
 
 
 std::ostream& HStoreKeyedGeneric::PrintDataTo(
@@ skipping 343 matching lines @@
   if (!addition_result.IsValid()) return false;
   base_offset_ = addition_result.ValueOrDie();
   return true;
 }
 
 
 bool HStoreKeyed::NeedsCanonicalization() {
   switch (value()->opcode()) {
     case kLoadKeyed: {
       ElementsKind load_kind = HLoadKeyed::cast(value())->elements_kind();
-      return IsExternalFloatOrDoubleElementsKind(load_kind) ||
-             IsFixedFloatElementsKind(load_kind);
+      return IsFixedFloatElementsKind(load_kind);
     }
     case kChange: {
       Representation from = HChange::cast(value())->from();
       return from.IsTagged() || from.IsHeapObject();
     }
     case kLoadNamedField:
     case kPhi: {
       // Better safe than sorry...
       return true;
     }
@@ skipping 744 matching lines @@
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 }  // namespace internal
 }  // namespace v8