[turbofan] Introduce LoadFunctionPrototype simplified operator.

src/compiler/access-info.cc

 // 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.
 
 #include <ostream>
 
 #include "src/accessors.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-info.h"
 #include "src/compiler/type-cache.h"
@@ skipping 77 matching lines @@
 }
 
 // static
 PropertyAccessInfo PropertyAccessInfo::AccessorConstant(
     MapList const& receiver_maps, Handle<Object> constant,
     MaybeHandle<JSObject> holder) {
   return PropertyAccessInfo(kAccessorConstant, holder, constant, receiver_maps);
 }
 
 // static
+PropertyAccessInfo PropertyAccessInfo::FunctionPrototype(
+    MapList const& receiver_maps) {
+  return PropertyAccessInfo(kFunctionPrototype, MaybeHandle<JSObject>(),
+                            Handle<Object>(), receiver_maps);
+}
+
+// static
 PropertyAccessInfo PropertyAccessInfo::Generic(MapList const& receiver_maps) {
   return PropertyAccessInfo(kGeneric, MaybeHandle<JSObject>(), Handle<Object>(),
                             receiver_maps);
 }
 
 PropertyAccessInfo::PropertyAccessInfo()
     : kind_(kInvalid),
       field_representation_(MachineRepresentation::kNone),
       field_type_(Type::None()) {}
 
@@ skipping 29 matching lines @@
       field_map_(field_map) {}
 
 bool PropertyAccessInfo::Merge(PropertyAccessInfo const* that) {
   if (this->kind_ != that->kind_) return false;
   if (this->holder_.address() != that->holder_.address()) return false;
 
   switch (this->kind_) {
     case kInvalid:
       break;
 
-    case kNotFound:
-      return true;
-
     case kDataField: {
       // Check if we actually access the same field.
       if (this->transition_map_.address() == that->transition_map_.address() &&
           this->field_index_ == that->field_index_ &&
           this->field_type_->Is(that->field_type_) &&
           that->field_type_->Is(this->field_type_) &&
           this->field_representation_ == that->field_representation_) {
         this->receiver_maps_.insert(this->receiver_maps_.end(),
                                     that->receiver_maps_.begin(),
                                     that->receiver_maps_.end());
         return true;
       }
       return false;
     }
 
     case kDataConstant:
     case kAccessorConstant: {
       // Check if we actually access the same constant.
       if (this->constant_.address() == that->constant_.address()) {
         this->receiver_maps_.insert(this->receiver_maps_.end(),
                                     that->receiver_maps_.begin(),
                                     that->receiver_maps_.end());
         return true;
       }
       return false;
     }
+
+    case kNotFound:
+    case kFunctionPrototype:
     case kGeneric: {
       this->receiver_maps_.insert(this->receiver_maps_.end(),
                                   that->receiver_maps_.begin(),
                                   that->receiver_maps_.end());
       return true;
     }
   }
 
   UNREACHABLE();
   return false;
@@ skipping 256 matching lines @@
       }
       if (!merged) access_infos->push_back(access_info);
     }
   }
   return true;
 }
 
 
 bool AccessInfoFactory::LookupSpecialFieldAccessor(
     Handle<Map> map, Handle<Name> name, PropertyAccessInfo* access_info) {
+  // Check for Function::prototype accessor.
+  if (map->IsJSFunctionMap() && map->is_constructor() &&
+      name.is_identical_to(factory()->prototype_string())) {
+    DCHECK(!map->has_non_instance_prototype());
+    *access_info = PropertyAccessInfo::FunctionPrototype(MapList{map});
+    return true;
+  }
   // Check for special JSObject field accessors.
   int offset;
   if (Accessors::IsJSObjectFieldAccessor(map, name, &offset)) {
     FieldIndex field_index = FieldIndex::ForInObjectOffset(offset);
     Type* field_type = Type::NonInternal();
     MachineRepresentation field_representation = MachineRepresentation::kTagged;
     if (map->IsStringMap()) {
       DCHECK(Name::Equals(factory()->length_string(), name));
       // The String::length property is always a smi in the range
       // [0, String::kMaxLength].
@@ skipping 84 matching lines @@
   }
   return false;
 }
 
 
 Factory* AccessInfoFactory::factory() const { return isolate()->factory(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8