[builtins]: Uniformly push argument count in TF-generated builtins

test/cctest/test-code-stub-assembler.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 "src/base/utils/random-number-generator.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/compiler/node.h"
 #include "src/ic/stub-cache.h"
 #include "src/isolate.h"
@@ skipping 1492 matching lines @@
   // Ensure we performed both kind of queries.
   CHECK(queried_existing && queried_non_existing);
 }
 
 TEST(GotoIfException) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 1;
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  // Emulate TFJ builtin
+  CodeStubAssemblerTester m(isolate, kNumParams, Code::BUILTIN);
 
   Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
   Node* to_string_tag =
       m.HeapConstant(isolate->factory()->to_string_tag_symbol());
   Variable exception(&m, MachineRepresentation::kTagged);
 
   Label exception_handler(&m);
   Callable to_string = CodeFactory::ToString(isolate);
   Node* string = m.CallStub(to_string, context, to_string_tag);
   m.GotoIfException(string, &exception_handler, &exception);
   m.Return(string);
 
   m.Bind(&exception_handler);
   m.Return(exception.value());
 
   Handle<Code> code = m.GenerateCode();
   CHECK(!code.is_null());
 
-  // Emulate TFJ builtin
-  code->set_flags(Code::ComputeFlags(Code::BUILTIN));
-
   FunctionTester ft(code, kNumParams);
   Handle<Object> result = ft.Call().ToHandleChecked();
 
   // Should be a TypeError
   CHECK(result->IsJSObject());
 
   Handle<Object> constructor =
       Object::GetPropertyOrElement(result,
                                    isolate->factory()->constructor_string())
           .ToHandleChecked();
   CHECK(constructor->SameValue(*isolate->type_error_function()));
 }
 
 TEST(GotoIfExceptionMultiple) {
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;  // receiver, first, second, third
-  CodeStubAssemblerTester m(isolate, kNumParams);
+  // Emulate TFJ builtin
+  CodeStubAssemblerTester m(isolate, kNumParams, Code::BUILTIN);
 
   Node* context = m.HeapConstant(Handle<Context>(isolate->native_context()));
   Node* first_value = m.Parameter(0);
   Node* second_value = m.Parameter(1);
   Node* third_value = m.Parameter(2);
 
   Label exception_handler1(&m);
   Label exception_handler2(&m);
   Label exception_handler3(&m);
   Variable return_value(&m, MachineRepresentation::kWord32);
@@ skipping 24 matching lines @@
   m.Return(m.SmiFromWord32(
       m.Word32And(return_value.value(),
                   m.Word32Xor(m.Int32Constant(2), m.Int32Constant(-1)))));
 
   m.Bind(&exception_handler3);
   m.Return(error.value());
 
   Handle<Code> code = m.GenerateCode();
   CHECK(!code.is_null());
 
-  // Emulate TFJ builtin
-  code->set_flags(Code::ComputeFlags(Code::BUILTIN));
-
   FunctionTester ft(code, kNumParams);
 
   Handle<Object> result;
   // First handler does not throw, returns result of first value
   result = ft.Call(isolate->factory()->undefined_value(),
                    isolate->factory()->to_string_tag_symbol())
                .ToHandleChecked();
   CHECK(String::cast(*result)->IsOneByteEqualTo(OneByteVector("undefined")));
 
   // First handler returns a number
@@ skipping 157 matching lines @@
   // passed in as a parameter to the function so that it can't be recongized as
   // a constant.
   m.PopAndReturn(m.SmiUntag(m.Parameter(1)), m.SmiConstant(Smi::FromInt(1234)));
 
   Handle<Code> code = m.GenerateCode();
   CHECK(!code.is_null());
 
   FunctionTester ft(code, kNumParams);
   Handle<Object> result;
   for (int test_count = 0; test_count < 100; ++test_count) {
-    result =
-        ft.Call(isolate->factory()->undefined_value(),
-                Handle<Smi>(Smi::FromInt(1234), isolate),
-                isolate->factory()->undefined_value(),
-                Handle<Smi>(Smi::FromInt(kNumProgramaticParams * kPointerSize),
-                            isolate))
-            .ToHandleChecked();
+    result = ft.Call(isolate->factory()->undefined_value(),
+                     Handle<Smi>(Smi::FromInt(1234), isolate),
+                     isolate->factory()->undefined_value(),
+                     Handle<Smi>(Smi::FromInt(kNumProgramaticParams), isolate))
+                 .ToHandleChecked();
     CHECK_EQ(1234, Handle<Smi>::cast(result)->value());
   }
 }
 
 }  // namespace internal
 }  // namespace v8