Revert of Remove ExternalArray, derived types, and element kinds

src/code-stubs-hydrogen.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/bailout-reason.h"
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
@@ skipping 1969 matching lines @@
                                    HValue* bit_field2,
                                    ElementsKind kind);
 
   void BuildFastElementLoad(HGraphBuilder::IfBuilder* if_builder,
                             HValue* receiver,
                             HValue* key,
                             HValue* instance_type,
                             HValue* bit_field2,
                             ElementsKind kind);
 
+  void BuildExternalElementLoad(HGraphBuilder::IfBuilder* if_builder,
+                                HValue* receiver,
+                                HValue* key,
+                                HValue* instance_type,
+                                HValue* bit_field2,
+                                ElementsKind kind);
+
   KeyedLoadGenericStub* casted_stub() {
     return static_cast<KeyedLoadGenericStub*>(stub());
   }
 };
 
 
 void CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildElementsKindLimitCheck(
     HGraphBuilder::IfBuilder* if_builder, HValue* bit_field2,
     ElementsKind kind) {
   ElementsKind next_kind = static_cast<ElementsKind>(kind + 1);
   HValue* kind_limit = Add<HConstant>(
       static_cast<int>(Map::ElementsKindBits::encode(next_kind)));
 
   if_builder->If<HCompareNumericAndBranch>(bit_field2, kind_limit, Token::LT);
   if_builder->Then();
 }
 
 
 void CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildFastElementLoad(
     HGraphBuilder::IfBuilder* if_builder, HValue* receiver, HValue* key,
     HValue* instance_type, HValue* bit_field2, ElementsKind kind) {
+  DCHECK(!IsExternalArrayElementsKind(kind));
+
   BuildElementsKindLimitCheck(if_builder, bit_field2, kind);
 
   IfBuilder js_array_check(this);
   js_array_check.If<HCompareNumericAndBranch>(
       instance_type, Add<HConstant>(JS_ARRAY_TYPE), Token::EQ);
   js_array_check.Then();
   Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                               true, kind,
                                               LOAD, NEVER_RETURN_HOLE,
                                               STANDARD_STORE));
   js_array_check.Else();
   Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
                                               false, kind,
                                               LOAD, NEVER_RETURN_HOLE,
                                               STANDARD_STORE));
   js_array_check.End();
 }
 
 
+void CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildExternalElementLoad(
+    HGraphBuilder::IfBuilder* if_builder, HValue* receiver, HValue* key,
+    HValue* instance_type, HValue* bit_field2, ElementsKind kind) {
+  DCHECK(IsExternalArrayElementsKind(kind));
+
+  BuildElementsKindLimitCheck(if_builder, bit_field2, kind);
+
+  Push(BuildUncheckedMonomorphicElementAccess(receiver, key, NULL,
+                                              false, kind,
+                                              LOAD, NEVER_RETURN_HOLE,
+                                              STANDARD_STORE));
+}
+
+
 HValue* CodeStubGraphBuilder<KeyedLoadGenericStub>::BuildCodeStub() {
   HValue* receiver = GetParameter(LoadDescriptor::kReceiverIndex);
   HValue* key = GetParameter(LoadDescriptor::kNameIndex);
   // Split into a smi/integer case and unique string case.
   HIfContinuation index_name_split_continuation(graph()->CreateBasicBlock(),
                                                 graph()->CreateBasicBlock());
 
   BuildKeyedIndexCheck(key, &index_name_split_continuation);
 
   IfBuilder index_name_split(this, &index_name_split_continuation);
@@ skipping 41 matching lines @@
     // The SLOW_SLOPPY_ARGUMENTS_ELEMENTS check generates a "kind_if.Then"
     STATIC_ASSERT(FAST_SLOPPY_ARGUMENTS_ELEMENTS <
                   SLOW_SLOPPY_ARGUMENTS_ELEMENTS);
     BuildElementsKindLimitCheck(&kind_if, bit_field2,
                                 SLOW_SLOPPY_ARGUMENTS_ELEMENTS);
     // Non-strict elements are not handled.
     Add<HDeoptimize>(Deoptimizer::kNonStrictElementsInKeyedLoadGenericStub,
                      Deoptimizer::EAGER);
     Push(graph()->GetConstant0());
 
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_INT8_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_UINT8_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_INT16_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_UINT16_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_INT32_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_UINT32_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_FLOAT32_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_FLOAT64_ELEMENTS);
+
+    kind_if.Else();
+    BuildExternalElementLoad(&kind_if, receiver, key, instance_type, bit_field2,
+                             EXTERNAL_UINT8_CLAMPED_ELEMENTS);
+
     kind_if.ElseDeopt(
         Deoptimizer::kElementsKindUnhandledInKeyedLoadGenericStub);
 
     kind_if.End();
   }
   index_name_split.Else();
   {
     // Key is a unique string.
     key = Pop();
 
@@ skipping 67 matching lines @@
           lookup_if->Then();
           {
             ExternalReference cache_field_offsets_ref =
                 ExternalReference::keyed_lookup_cache_field_offsets(isolate());
             HValue* cache_field_offsets =
                 Add<HConstant>(cache_field_offsets_ref);
             HValue* index = AddUncasted<HAdd>(hash, Add<HConstant>(probe));
             index->ClearFlag(HValue::kCanOverflow);
             HValue* property_index =
                 Add<HLoadKeyed>(cache_field_offsets, index, nullptr,
-                                INT32_ELEMENTS, NEVER_RETURN_HOLE, 0);
+                                EXTERNAL_INT32_ELEMENTS, NEVER_RETURN_HOLE, 0);
             Push(property_index);
           }
           lookup_if->Else();
         }
         for (int i = 0; i < KeyedLookupCache::kEntriesPerBucket; ++i) {
           lookup_ifs[i].JoinContinuation(&inline_or_runtime_continuation);
         }
       }
 
       IfBuilder inline_or_runtime(this, &inline_or_runtime_continuation);
@@ skipping 22 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8