Store offset between fixed typed array base and data start in object

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 4877 matching lines @@
   Representation RequiredInputRepresentation(int index) override;
 
   bool IsConsistentExternalRepresentation() {
     return left()->representation().IsExternal() &&
            ((external_add_type_ == AddOfExternalAndInt32 &&
              right()->representation().IsInteger32()) ||
             (external_add_type_ == AddOfExternalAndTagged &&
              right()->representation().IsTagged()));
   }
 
+  ExternalAddType external_add_type() const { return external_add_type_; }
+
   DECLARE_CONCRETE_INSTRUCTION(Add)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
   HAdd(HValue* context, HValue* left, HValue* right, Strength strength,
        ExternalAddType external_add_type = NoExternalAdd)
       : HArithmeticBinaryOperation(context, left, right, strength),
         external_add_type_(external_add_type) {
     SetFlag(kCanOverflow);
     switch (external_add_type_) {
       case AddOfExternalAndTagged:
         DCHECK(left->representation().IsExternal());
         DCHECK(right->representation().IsTagged());
         SetDependsOnFlag(kNewSpacePromotion);
+        ClearFlag(HValue::kCanOverflow);
+        SetFlag(kHasNoObservableSideEffects);
         break;
 
       case NoExternalAdd:
         // This is a bit of a hack: The call to this constructor is generated
         // by a macro that also supports sub and mul, so it doesn't pass in
         // a value for external_add_type but uses the default.
         if (left->representation().IsExternal()) {
           external_add_type_ = AddOfExternalAndInt32;
         }
         break;
@@ skipping 1095 matching lines @@
         kArrayLengths,
         FixedArray::kLengthOffset,
         Representation::Smi());
   }
 
   static HObjectAccess ForFixedTypedArrayBaseBasePointer() {
     return HObjectAccess(kInobject, FixedTypedArrayBase::kBasePointerOffset,
                          Representation::Tagged());
   }
 
+  static HObjectAccess ForFixedTypedArrayBaseExternalPointer() {
+    return HObjectAccess::ForObservableJSObjectOffset(
+        FixedTypedArrayBase::kExternalPointerOffset,
+        Representation::External());
+  }
+
   static HObjectAccess ForStringHashField() {
     return HObjectAccess(kInobject,
                          String::kHashFieldOffset,
                          Representation::Integer32());
   }
 
   static HObjectAccess ForStringLength() {
     STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
     return HObjectAccess(
         kStringLengths,
@@ skipping 600 matching lines @@
   ElementsKind elements_kind() const override {
     return ElementsKindField::decode(bit_field_);
   }
   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:    tagged[int32] (none)
+    // kind_fixed_typed_array:    external[int32] (none)
     // kind_external:             external[int32] (none)
     if (index == 0) {
-      return is_external() ? 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 440 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_external() ? 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(
@@ skipping 957 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_