[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

src/code-stubs.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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 3478 matching lines @@
   typedef compiler::Node Node;
   Node* context = assembler->Parameter(3);
   Node* receiver = assembler->Parameter(0);
   // For now we only support receiver_is_holder.
   DCHECK(receiver_is_holder());
   Node* holder = receiver;
   Node* map = assembler->LoadMap(receiver);
   Node* descriptors = assembler->LoadMapDescriptors(map);
   Node* offset =
       assembler->Int32Constant(DescriptorArray::ToValueIndex(index()));
-  Node* callback =
-      assembler->LoadFixedArrayElementInt32Index(descriptors, offset);
+  Node* callback = assembler->LoadFixedArrayElement(descriptors, offset);
   assembler->TailCallStub(CodeFactory::ApiGetter(isolate()), context, receiver,
                           holder, callback);
 }
 
 void LessThanStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   GenerateAbstractRelationalComparison(assembler, kLessThan);
 }
 
 void LessThanOrEqualStub::GenerateAssembly(CodeStubAssembler* assembler) const {
   GenerateAbstractRelationalComparison(assembler, kLessThanOrEqual);
@@ skipping 355 matching lines @@
     CodeStubAssembler* assembler, compiler::CodeAssembler::Label* call_runtime,
     compiler::Node* closure, compiler::Node* literals_index,
     compiler::Node* properties_count) {
   typedef compiler::Node Node;
   typedef compiler::CodeAssembler::Label Label;
   typedef compiler::CodeAssembler::Variable Variable;
 
   Node* undefined = assembler->UndefinedConstant();
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
-  Node* allocation_site = assembler->LoadFixedArrayElementSmiIndex(
+  Node* allocation_site = assembler->LoadFixedArrayElement(
       literals_array, literals_index,
-      LiteralsArray::kFirstLiteralIndex * kPointerSize);
+      LiteralsArray::kFirstLiteralIndex * kPointerSize,
+      CodeStubAssembler::SMI_PARAMETERS);
   assembler->GotoIf(assembler->WordEqual(allocation_site, undefined),
                     call_runtime);
 
   // Calculate the object and allocation size based on the properties count.
   Node* object_size = assembler->IntPtrAdd(
       assembler->WordShl(properties_count, kPointerSizeLog2),
       assembler->IntPtrConstant(JSObject::kHeaderSize));
   Node* allocation_size = object_size;
   if (FLAG_allocation_site_pretenuring) {
     allocation_size = assembler->IntPtrAdd(
@@ skipping 577 matching lines @@
   bool track_allocation_site =
       AllocationSite::GetMode(elements_kind()) == TRACK_ALLOCATION_SITE &&
       override_mode() != DISABLE_ALLOCATION_SITES;
   Node* allocation_site =
       track_allocation_site
           ? assembler->Parameter(
                 ArrayNoArgumentConstructorDescriptor::kAllocationSiteIndex)
           : nullptr;
   Node* array_map =
       assembler->LoadJSArrayElementsMap(elements_kind(), native_context);
-  Node* array = assembler->AllocateJSArray(elements_kind(), array_map,
-                                           JSArray::kPreallocatedArrayElements,
-                                           0, allocation_site);
+  Node* array = assembler->AllocateJSArray(
+      elements_kind(), array_map,
+      assembler->IntPtrConstant(JSArray::kPreallocatedArrayElements),
+      assembler->IntPtrConstant(0), allocation_site);
   assembler->Return(array);
 }
 
 void InternalArrayNoArgumentConstructorStub::GenerateAssembly(
     CodeStubAssembler* assembler) const {
   typedef compiler::Node Node;
   Node* array_map = assembler->LoadObjectField(
       assembler->Parameter(
           ArrayNoArgumentConstructorDescriptor::kFunctionIndex),
       JSFunction::kPrototypeOrInitialMapOffset);
-  Node* array = assembler->AllocateJSArray(elements_kind(), array_map,
-                                           JSArray::kPreallocatedArrayElements,
-                                           0, nullptr);
+  Node* array = assembler->AllocateJSArray(
+      elements_kind(), array_map,
+      assembler->IntPtrConstant(JSArray::kPreallocatedArrayElements),
+      assembler->IntPtrConstant(0), nullptr);
   assembler->Return(array);
 }
 
 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
     : PlatformCodeStub(isolate) {
   minor_key_ = ArgumentCountBits::encode(ANY);
   ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
@@ skipping 31 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8