[builtins] remove redundant list of generator declarations.

src/builtins/builtins.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/builtins/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/base/once.h"
@@ skipping 6211 matching lines @@
 BUILTIN(HandleApiCallAsFunction) {
   return HandleApiCallAsFunctionOrConstructor(isolate, false, args);
 }
 
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a construct call.
 BUILTIN(HandleApiCallAsConstructor) {
   return HandleApiCallAsFunctionOrConstructor(isolate, true, args);
 }
 
-namespace {
-
-void Generate_LoadIC_Miss(CodeStubAssembler* assembler) {
+void Builtins::Generate_LoadIC_Miss(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* name = assembler->Parameter(1);
   Node* slot = assembler->Parameter(2);
   Node* vector = assembler->Parameter(3);
   Node* context = assembler->Parameter(4);
 
   assembler->TailCallRuntime(Runtime::kLoadIC_Miss, context, receiver, name,
                              slot, vector);
 }
 
-void Generate_LoadGlobalIC_Miss(CodeStubAssembler* assembler) {
+void Builtins::Generate_LoadGlobalIC_Miss(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* slot = assembler->Parameter(0);
   Node* vector = assembler->Parameter(1);
   Node* context = assembler->Parameter(2);
 
   assembler->TailCallRuntime(Runtime::kLoadGlobalIC_Miss, context, slot,
                              vector);
 }
 
-void Generate_LoadIC_Normal(MacroAssembler* masm) {
+void Builtins::Generate_LoadIC_Normal(MacroAssembler* masm) {
   LoadIC::GenerateNormal(masm);
 }
 
-void Generate_LoadIC_Getter_ForDeopt(MacroAssembler* masm) {
+void Builtins::Generate_LoadIC_Getter_ForDeopt(MacroAssembler* masm) {
   NamedLoadHandlerCompiler::GenerateLoadViaGetterForDeopt(masm);
 }
 
-void Generate_LoadIC_Slow(CodeStubAssembler* assembler) {
+void Builtins::Generate_LoadIC_Slow(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* name = assembler->Parameter(1);
   // Node* slot = assembler->Parameter(2);
   // Node* vector = assembler->Parameter(3);
   Node* context = assembler->Parameter(4);
 
   assembler->TailCallRuntime(Runtime::kGetProperty, context, receiver, name);
 }
 
+namespace {
 void Generate_LoadGlobalIC_Slow(CodeStubAssembler* assembler, TypeofMode mode) {
   typedef compiler::Node Node;
 
   Node* slot = assembler->Parameter(0);
   Node* vector = assembler->Parameter(1);
   Node* context = assembler->Parameter(2);
   Node* typeof_mode = assembler->SmiConstant(Smi::FromInt(mode));
 
   assembler->TailCallRuntime(Runtime::kGetGlobal, context, slot, vector,
                              typeof_mode);
 }
+}  // anonymous namespace
 
-void Generate_LoadGlobalIC_SlowInsideTypeof(CodeStubAssembler* assembler) {
+void Builtins::Generate_LoadGlobalIC_SlowInsideTypeof(
+    CodeStubAssembler* assembler) {
   Generate_LoadGlobalIC_Slow(assembler, INSIDE_TYPEOF);
 }
 
-void Generate_LoadGlobalIC_SlowNotInsideTypeof(CodeStubAssembler* assembler) {
+void Builtins::Generate_LoadGlobalIC_SlowNotInsideTypeof(
+    CodeStubAssembler* assembler) {
   Generate_LoadGlobalIC_Slow(assembler, NOT_INSIDE_TYPEOF);
 }
 
-void Generate_KeyedLoadIC_Slow(MacroAssembler* masm) {
+void Builtins::Generate_KeyedLoadIC_Slow(MacroAssembler* masm) {
   KeyedLoadIC::GenerateRuntimeGetProperty(masm);
 }
 
-void Generate_KeyedLoadIC_Miss(MacroAssembler* masm) {
+void Builtins::Generate_KeyedLoadIC_Miss(MacroAssembler* masm) {
   KeyedLoadIC::GenerateMiss(masm);
 }
 
-void Generate_KeyedLoadIC_Megamorphic(MacroAssembler* masm) {
+void Builtins::Generate_KeyedLoadIC_Megamorphic(MacroAssembler* masm) {
   KeyedLoadIC::GenerateMegamorphic(masm);
 }
 
-void Generate_StoreIC_Miss(CodeStubAssembler* assembler) {
+void Builtins::Generate_StoreIC_Miss(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* name = assembler->Parameter(1);
   Node* value = assembler->Parameter(2);
   Node* slot = assembler->Parameter(3);
   Node* vector = assembler->Parameter(4);
   Node* context = assembler->Parameter(5);
 
   assembler->TailCallRuntime(Runtime::kStoreIC_Miss, context, receiver, name,
                              value, slot, vector);
 }
 
-void Generate_StoreIC_Normal(MacroAssembler* masm) {
+void Builtins::Generate_StoreIC_Normal(MacroAssembler* masm) {
   StoreIC::GenerateNormal(masm);
 }
 
+namespace {
 void Generate_StoreIC_Slow(CodeStubAssembler* assembler,
                            LanguageMode language_mode) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* name = assembler->Parameter(1);
   Node* value = assembler->Parameter(2);
   // Node* slot = assembler->Parameter(3);
   // Node* vector = assembler->Parameter(4);
   Node* context = assembler->Parameter(5);
   Node* lang_mode = assembler->SmiConstant(Smi::FromInt(language_mode));
 
   // The slow case calls into the runtime to complete the store without causing
   // an IC miss that would otherwise cause a transition to the generic stub.
   assembler->TailCallRuntime(Runtime::kSetProperty, context, receiver, name,
                              value, lang_mode);
 }
+}  // anonymous namespace
 
-void Generate_StoreIC_SlowSloppy(CodeStubAssembler* assembler) {
+void Builtins::Generate_StoreIC_SlowSloppy(CodeStubAssembler* assembler) {
   Generate_StoreIC_Slow(assembler, SLOPPY);
 }
 
-void Generate_StoreIC_SlowStrict(CodeStubAssembler* assembler) {
+void Builtins::Generate_StoreIC_SlowStrict(CodeStubAssembler* assembler) {
   Generate_StoreIC_Slow(assembler, STRICT);
 }
 
+namespace {
 // 7.1.1.1 OrdinaryToPrimitive ( O, hint )
 void Generate_OrdinaryToPrimitive(CodeStubAssembler* assembler,
                                   OrdinaryToPrimitiveHint hint) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
   Node* input = assembler->Parameter(0);
   Node* context = assembler->Parameter(1);
 
@@ skipping 50 matching lines @@
     // Just continue with the next {name} if the {method} is not callable.
     assembler->Goto(&if_methodisnotcallable);
     assembler->Bind(&if_methodisnotcallable);
   }
 
   assembler->TailCallRuntime(Runtime::kThrowCannotConvertToPrimitive, context);
 
   assembler->Bind(&return_result);
   assembler->Return(var_result.value());
 }
+}  // anonymous namespace
 
-void Generate_OrdinaryToPrimitive_Number(CodeStubAssembler* assembler) {
+void Builtins::Generate_OrdinaryToPrimitive_Number(
+    CodeStubAssembler* assembler) {
   Generate_OrdinaryToPrimitive(assembler, OrdinaryToPrimitiveHint::kNumber);
 }
 
-void Generate_OrdinaryToPrimitive_String(CodeStubAssembler* assembler) {
+void Builtins::Generate_OrdinaryToPrimitive_String(
+    CodeStubAssembler* assembler) {
   Generate_OrdinaryToPrimitive(assembler, OrdinaryToPrimitiveHint::kString);
 }
 
+namespace {
 // ES6 section 7.1.1 ToPrimitive ( input [ , PreferredType ] )
 void Generate_NonPrimitiveToPrimitive(CodeStubAssembler* assembler,
                                       ToPrimitiveHint hint) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* input = assembler->Parameter(0);
   Node* context = assembler->Parameter(1);
 
   // Lookup the @@toPrimitive property on the {input}.
@@ skipping 48 matching lines @@
   // Convert using the OrdinaryToPrimitive algorithm instead.
   assembler->Bind(&ordinary_to_primitive);
   {
     Callable callable = CodeFactory::OrdinaryToPrimitive(
         assembler->isolate(), (hint == ToPrimitiveHint::kString)
                                   ? OrdinaryToPrimitiveHint::kString
                                   : OrdinaryToPrimitiveHint::kNumber);
     assembler->TailCallStub(callable, context, input);
   }
 }
+}  // anonymous namespace
 
-void Generate_NonPrimitiveToPrimitive_Default(CodeStubAssembler* assembler) {
+void Builtins::Generate_NonPrimitiveToPrimitive_Default(
+    CodeStubAssembler* assembler) {
   Generate_NonPrimitiveToPrimitive(assembler, ToPrimitiveHint::kDefault);
 }
 
-void Generate_NonPrimitiveToPrimitive_Number(CodeStubAssembler* assembler) {
+void Builtins::Generate_NonPrimitiveToPrimitive_Number(
+    CodeStubAssembler* assembler) {
   Generate_NonPrimitiveToPrimitive(assembler, ToPrimitiveHint::kNumber);
 }
 
-void Generate_NonPrimitiveToPrimitive_String(CodeStubAssembler* assembler) {
+void Builtins::Generate_NonPrimitiveToPrimitive_String(
+    CodeStubAssembler* assembler) {
   Generate_NonPrimitiveToPrimitive(assembler, ToPrimitiveHint::kString);
 }
 
 // ES6 section 7.1.3 ToNumber ( argument )
-void Generate_NonNumberToNumber(CodeStubAssembler* assembler) {
+void Builtins::Generate_NonNumberToNumber(CodeStubAssembler* assembler) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
   Node* input = assembler->Parameter(0);
   Node* context = assembler->Parameter(1);
 
   // We might need to loop once here due to ToPrimitive conversions.
   Variable var_input(assembler, MachineRepresentation::kTagged);
   Label loop(assembler, &var_input);
@@ skipping 76 matching lines @@
       // Note: We cannot tail call to the runtime here, as js-to-wasm
       // trampolines also use this code currently, and they declare all
       // outgoing parameters as untagged, while we would push a tagged
       // object here.
       Node* result = assembler->CallRuntime(Runtime::kToNumber, context, input);
       assembler->Return(result);
     }
   }
 }
 
-void Generate_KeyedStoreIC_Slow(MacroAssembler* masm) {
+void Builtins::Generate_KeyedStoreIC_Slow(MacroAssembler* masm) {
   ElementHandlerCompiler::GenerateStoreSlow(masm);
 }
 
-void Generate_StoreIC_Setter_ForDeopt(MacroAssembler* masm) {
+void Builtins::Generate_StoreIC_Setter_ForDeopt(MacroAssembler* masm) {
   NamedStoreHandlerCompiler::GenerateStoreViaSetterForDeopt(masm);
 }
 
-void Generate_KeyedStoreIC_Megamorphic(MacroAssembler* masm) {
+void Builtins::Generate_KeyedStoreIC_Megamorphic(MacroAssembler* masm) {
   KeyedStoreIC::GenerateMegamorphic(masm, SLOPPY);
 }
 
-void Generate_KeyedStoreIC_Megamorphic_Strict(MacroAssembler* masm) {
+void Builtins::Generate_KeyedStoreIC_Megamorphic_Strict(MacroAssembler* masm) {
   KeyedStoreIC::GenerateMegamorphic(masm, STRICT);
 }
 
-void Generate_KeyedStoreIC_Miss(MacroAssembler* masm) {
+void Builtins::Generate_KeyedStoreIC_Miss(MacroAssembler* masm) {
   KeyedStoreIC::GenerateMiss(masm);
 }
 
-void Generate_Return_DebugBreak(MacroAssembler* masm) {
+void Builtins::Generate_Return_DebugBreak(MacroAssembler* masm) {
   DebugCodegen::GenerateDebugBreakStub(masm,
                                        DebugCodegen::SAVE_RESULT_REGISTER);
 }
 
-void Generate_Slot_DebugBreak(MacroAssembler* masm) {
+void Builtins::Generate_Slot_DebugBreak(MacroAssembler* masm) {
   DebugCodegen::GenerateDebugBreakStub(masm,
                                        DebugCodegen::IGNORE_RESULT_REGISTER);
 }
 
-void Generate_FrameDropper_LiveEdit(MacroAssembler* masm) {
+void Builtins::Generate_FrameDropper_LiveEdit(MacroAssembler* masm) {
   DebugCodegen::GenerateFrameDropperLiveEdit(masm);
 }
 
-}  // namespace
-
 Builtins::Builtins() : initialized_(false) {
   memset(builtins_, 0, sizeof(builtins_[0]) * builtin_count);
 }
 
 Builtins::~Builtins() {}
 
 namespace {
 void PostBuildProfileAndTracing(Isolate* isolate, Code* code,
                                 const char* name) {
   PROFILE(isolate, CodeCreateEvent(CodeEventListener::BUILTIN_TAG,
@@ skipping 404 matching lines @@
   a->Bind(&u32);
   a->AtomicStore(MachineRepresentation::kWord32, backing_store,
                  a->WordShl(index_word, 2), value_word32);
   a->Return(value_integer);
 
   // This shouldn't happen, we've already validated the type.
   a->Bind(&other);
   a->Return(a->Int32Constant(0));
 }
 
+void Builtins::Generate_CallFunction_ReceiverIsNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kNullOrUndefined,
+                        TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_CallFunction_ReceiverIsNotNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kNotNullOrUndefined,
+                        TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_CallFunction_ReceiverIsAny(MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kAny,
+                        TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_TailCallFunction_ReceiverIsNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kNullOrUndefined,
+                        TailCallMode::kAllow);
+}
+
+void Builtins::Generate_TailCallFunction_ReceiverIsNotNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kNotNullOrUndefined,
+                        TailCallMode::kAllow);
+}
+
+void Builtins::Generate_TailCallFunction_ReceiverIsAny(MacroAssembler* masm) {
+  Generate_CallFunction(masm, ConvertReceiverMode::kAny, TailCallMode::kAllow);
+}
+
+void Builtins::Generate_CallBoundFunction(MacroAssembler* masm) {
+  Generate_CallBoundFunctionImpl(masm, TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_TailCallBoundFunction(MacroAssembler* masm) {
+  Generate_CallBoundFunctionImpl(masm, TailCallMode::kAllow);
+}
+
+void Builtins::Generate_Call_ReceiverIsNullOrUndefined(MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kNullOrUndefined,
+                TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_Call_ReceiverIsNotNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kNotNullOrUndefined,
+                TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_Call_ReceiverIsAny(MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kAny, TailCallMode::kDisallow);
+}
+
+void Builtins::Generate_TailCall_ReceiverIsNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kNullOrUndefined,
+                TailCallMode::kAllow);
+}
+
+void Builtins::Generate_TailCall_ReceiverIsNotNullOrUndefined(
+    MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kNotNullOrUndefined,
+                TailCallMode::kAllow);
+}
+
+void Builtins::Generate_TailCall_ReceiverIsAny(MacroAssembler* masm) {
+  Generate_Call(masm, ConvertReceiverMode::kAny, TailCallMode::kAllow);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kDisallow,
+                                                 CallableType::kAny);
+}
+void Builtins::Generate_InterpreterPushArgsAndTailCall(MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kAllow,
+                                                 CallableType::kAny);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndCallFunction(
+    MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kDisallow,
+                                                 CallableType::kJSFunction);
+}
+
+void Builtins::Generate_InterpreterPushArgsAndTailCallFunction(
+    MacroAssembler* masm) {
+  return Generate_InterpreterPushArgsAndCallImpl(masm, TailCallMode::kAllow,
+                                                 CallableType::kJSFunction);
+}
+
+void Builtins::Generate_MathMax(MacroAssembler* masm) {
+  Generate_MathMaxMin(masm, MathMaxMinKind::kMax);
+}
+
+void Builtins::Generate_MathMin(MacroAssembler* masm) {
+  Generate_MathMaxMin(masm, MathMaxMinKind::kMin);
+}
+
 #define DEFINE_BUILTIN_ACCESSOR(Name, ...)                                    \
   Handle<Code> Builtins::Name() {                                             \
     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##Name)); \
     return Handle<Code>(code_address);                                        \
   }
 BUILTIN_LIST_ALL(DEFINE_BUILTIN_ACCESSOR)
 #undef DEFINE_BUILTIN_ACCESSOR
 
 }  // namespace internal
 }  // namespace v8