[turbofan] Initial support for keyed access to fast JSArrays.

src/compiler/access-info.h

 // Copyright 2015 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_COMPILER_PROPERTY_ACCESS_INFO_H_
-#define V8_COMPILER_PROPERTY_ACCESS_INFO_H_
+#ifndef V8_COMPILER_ACCESS_INFO_H_
+#define V8_COMPILER_ACCESS_INFO_H_
 
 #include <iosfwd>
 
 #include "src/field-index.h"
 #include "src/objects.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class CompilationDependencies;
 class Factory;
 class TypeCache;
 
 
 namespace compiler {
 
 // Whether we are loading a property or storing to a property.
-enum class PropertyAccessMode { kLoad, kStore };
+enum class AccessMode { kLoad, kStore };
 
-std::ostream& operator<<(std::ostream&, PropertyAccessMode);
+std::ostream& operator<<(std::ostream&, AccessMode);
+
+
+// This class encapsulates all information required to access a certain element.
+class ElementAccessInfo final {
+ public:
+  ElementAccessInfo();
+  ElementAccessInfo(Type* receiver_type, ElementsKind elements_kind,
+                    MaybeHandle<JSObject> holder)
+      : elements_kind_(elements_kind),
+        holder_(holder),
+        receiver_type_(receiver_type) {}
+
+  MaybeHandle<JSObject> holder() const { return holder_; }
+  ElementsKind elements_kind() const { return elements_kind_; }
+  Type* receiver_type() const { return receiver_type_; }
+
+ private:
+  ElementsKind elements_kind_;
+  MaybeHandle<JSObject> holder_;
+  Type* receiver_type_;
+};
 
 
 // This class encapsulates all information required to access a certain
 // object property, either on the object itself or on the prototype chain.
 class PropertyAccessInfo final {
  public:
   enum Kind { kInvalid, kNotFound, kDataConstant, kDataField };
 
   static PropertyAccessInfo NotFound(Type* receiver_type,
                                      MaybeHandle<JSObject> holder);
@@ skipping 32 matching lines @@
   Kind kind_;
   Type* receiver_type_;
   Handle<Object> constant_;
   MaybeHandle<Map> transition_map_;
   MaybeHandle<JSObject> holder_;
   FieldIndex field_index_;
   Type* field_type_;
 };
 
 
-// Factory class for {PropertyAccessInfo}s.
-class PropertyAccessInfoFactory final {
+// Factory class for {ElementAccessInfo}s and {PropertyAccessInfo}s.
+class AccessInfoFactory final {
  public:
-  PropertyAccessInfoFactory(CompilationDependencies* dependencies,
-                            Handle<Context> native_context, Zone* zone);
+  AccessInfoFactory(CompilationDependencies* dependencies,
+                    Handle<Context> native_context, Zone* zone);
 
+  bool ComputeElementAccessInfo(Handle<Map> map, AccessMode access_mode,
+                                ElementAccessInfo* access_info);
+  bool ComputeElementAccessInfos(MapHandleList const& maps,
+                                 AccessMode access_mode,
+                                 ZoneVector<ElementAccessInfo>* access_infos);
   bool ComputePropertyAccessInfo(Handle<Map> map, Handle<Name> name,
-                                 PropertyAccessMode access_mode,
+                                 AccessMode access_mode,
                                  PropertyAccessInfo* access_info);
   bool ComputePropertyAccessInfos(MapHandleList const& maps, Handle<Name> name,
-                                  PropertyAccessMode access_mode,
+                                  AccessMode access_mode,
                                   ZoneVector<PropertyAccessInfo>* access_infos);
 
  private:
   bool LookupSpecialFieldAccessor(Handle<Map> map, Handle<Name> name,
                                   PropertyAccessInfo* access_info);
   bool LookupTransition(Handle<Map> map, Handle<Name> name,
                         MaybeHandle<JSObject> holder,
                         PropertyAccessInfo* access_info);
 
   CompilationDependencies* dependencies() const { return dependencies_; }
   Factory* factory() const;
   Isolate* isolate() const { return isolate_; }
   Handle<Context> native_context() const { return native_context_; }
   Zone* zone() const { return zone_; }
 
   CompilationDependencies* const dependencies_;
   Handle<Context> const native_context_;
   Isolate* const isolate_;
   TypeCache const& type_cache_;
   Zone* const zone_;
 
-  DISALLOW_COPY_AND_ASSIGN(PropertyAccessInfoFactory);
+  DISALLOW_COPY_AND_ASSIGN(AccessInfoFactory);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
-#endif  // V8_COMPILER_PROPERTY_ACCESS_INFO_H_
+#endif  // V8_COMPILER_ACCESS_INFO_H_