[wasm] Inline test-only method

After https://crrev.com/c/1789294, the {AddAndPublishAnonymousCode} has
only a single caller, {AddCodeForTesting}. Thus inline the method there.

R=mstarzinger@chromium.org

Change-Id: I698b37baa55221b82ead0b0bb8205233693ffced
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1789703
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63614}

src/wasm/wasm-code-manager.cc

@@ -731,81 +731,6 @@ CompilationEnv NativeModule::CreateCompilationEnv() const {
 }
 
 WasmCode* NativeModule::AddCodeForTesting(Handle<Code> code) {
-  return AddAndPublishAnonymousCode(code, WasmCode::kFunction);
-}
-
-void NativeModule::UseLazyStub(uint32_t func_index) {
-  DCHECK_LE(module_->num_imported_functions, func_index);
-  DCHECK_LT(func_index,
-            module_->num_imported_functions + module_->num_declared_functions);
-
-  if (!lazy_compile_table_) {
-    uint32_t num_slots = module_->num_declared_functions;
-    WasmCodeRefScope code_ref_scope;
-    DCHECK_EQ(1, code_space_data_.size());
-    lazy_compile_table_ = CreateEmptyJumpTableInRegion(
-        JumpTableAssembler::SizeForNumberOfLazyFunctions(num_slots),
-        code_space_data_[0].region);
-    JumpTableAssembler::GenerateLazyCompileTable(
-        lazy_compile_table_->instruction_start(), num_slots,
-        module_->num_imported_functions,
-        runtime_stub_entry(WasmCode::kWasmCompileLazy));
-  }
-
-  // Add jump table entry for jump to the lazy compile stub.
-  uint32_t slot_index = func_index - module_->num_imported_functions;
-  DCHECK_NE(runtime_stub_entry(WasmCode::kWasmCompileLazy), kNullAddress);
-  Address lazy_compile_target =
-      lazy_compile_table_->instruction_start() +
-      JumpTableAssembler::LazyCompileSlotIndexToOffset(slot_index);
-  JumpTableAssembler::PatchJumpTableSlot(main_jump_table_->instruction_start(),
-                                         slot_index, lazy_compile_target,
-                                         WasmCode::kFlushICache);
-}
-
-// TODO(mstarzinger): Remove {Isolate} parameter once {V8_EMBEDDED_BUILTINS}
-// was removed and embedded builtins are no longer optional.
-void NativeModule::SetRuntimeStubs(Isolate* isolate) {
-#ifndef V8_EMBEDDED_BUILTINS
-  FATAL(
-      "WebAssembly is not supported in no-embed builds. no-embed builds are "
-      "deprecated. See\n"
-      " - https://groups.google.com/d/msg/v8-users/9F53xqBjpkI/9WmKSbcWBAAJ\n"
-      " - https://crbug.com/v8/8519\n"
-      " - https://crbug.com/v8/8531\n");
-#endif                                                // V8_EMBEDDED_BUILTINS
-  DCHECK_EQ(kNullAddress, runtime_stub_entries_[0]);  // Only called once.
-  WasmCodeRefScope code_ref_scope;
-  DCHECK_EQ(1, code_space_data_.size());
-  WasmCode* jump_table = CreateEmptyJumpTableInRegion(
-      JumpTableAssembler::SizeForNumberOfStubSlots(WasmCode::kRuntimeStubCount),
-      code_space_data_[0].region);
-  Address base = jump_table->instruction_start();
-  EmbeddedData embedded_data = EmbeddedData::FromBlob();
-#define RUNTIME_STUB(Name) Builtins::k##Name,
-#define RUNTIME_STUB_TRAP(Name) RUNTIME_STUB(ThrowWasm##Name)
-  Builtins::Name wasm_runtime_stubs[WasmCode::kRuntimeStubCount] = {
-      WASM_RUNTIME_STUB_LIST(RUNTIME_STUB, RUNTIME_STUB_TRAP)};
-#undef RUNTIME_STUB
-#undef RUNTIME_STUB_TRAP
-  Address builtin_address[WasmCode::kRuntimeStubCount];
-  for (int i = 0; i < WasmCode::kRuntimeStubCount; ++i) {
-    Builtins::Name builtin = wasm_runtime_stubs[i];
-    CHECK(embedded_data.ContainsBuiltin(builtin));
-    builtin_address[i] = embedded_data.InstructionStartOfBuiltin(builtin);
-    runtime_stub_entries_[i] =
-        base + JumpTableAssembler::StubSlotIndexToOffset(i);
-  }
-  JumpTableAssembler::GenerateRuntimeStubTable(base, builtin_address,
-                                               WasmCode::kRuntimeStubCount);
-  DCHECK_NULL(runtime_stub_table_);
-  runtime_stub_table_ = jump_table;
-  DCHECK_NE(kNullAddress, runtime_stub_entries_[0]);
-}
-
-WasmCode* NativeModule::AddAndPublishAnonymousCode(Handle<Code> code,
-                                                   WasmCode::Kind kind,
-                                                   const char* name) {
   // For off-heap builtins, we create a copy of the off-heap instruction stream
   // instead of the on-heap code object containing the trampoline. Ensure that
   // we do not apply the on-heap reloc info to the off-heap instructions.
@@ -872,7 +797,6 @@ WasmCode* NativeModule::AddAndPublishAnonymousCode(Handle<Code> code,
   // Flush the i-cache after relocation.
   FlushInstructionCache(dst_code_bytes.begin(), dst_code_bytes.size());
 
-  DCHECK_NE(kind, WasmCode::Kind::kInterpreterEntry);
   std::unique_ptr<WasmCode> new_code{new WasmCode{
       this,                                     // native_module
       kAnonymousFuncIndex,                      // index
@@ -887,14 +811,83 @@ WasmCode* NativeModule::AddAndPublishAnonymousCode(Handle<Code> code,
       OwnedVector<ProtectedInstructionData>{},  // protected_instructions
       std::move(reloc_info),                    // reloc_info
       std::move(source_pos),                    // source positions
-      kind,                                     // kind
+      WasmCode::kFunction,                      // kind
       ExecutionTier::kNone}};                   // tier
-  new_code->MaybePrint(name);
+  new_code->MaybePrint(nullptr);
   new_code->Validate();
 
   return PublishCode(std::move(new_code));
 }
 
+void NativeModule::UseLazyStub(uint32_t func_index) {
+  DCHECK_LE(module_->num_imported_functions, func_index);
+  DCHECK_LT(func_index,
+            module_->num_imported_functions + module_->num_declared_functions);
+
+  if (!lazy_compile_table_) {
+    uint32_t num_slots = module_->num_declared_functions;
+    WasmCodeRefScope code_ref_scope;
+    DCHECK_EQ(1, code_space_data_.size());
+    lazy_compile_table_ = CreateEmptyJumpTableInRegion(
+        JumpTableAssembler::SizeForNumberOfLazyFunctions(num_slots),
+        code_space_data_[0].region);
+    JumpTableAssembler::GenerateLazyCompileTable(
+        lazy_compile_table_->instruction_start(), num_slots,
+        module_->num_imported_functions,
+        runtime_stub_entry(WasmCode::kWasmCompileLazy));
+  }
+
+  // Add jump table entry for jump to the lazy compile stub.
+  uint32_t slot_index = func_index - module_->num_imported_functions;
+  DCHECK_NE(runtime_stub_entry(WasmCode::kWasmCompileLazy), kNullAddress);
+  Address lazy_compile_target =
+      lazy_compile_table_->instruction_start() +
+      JumpTableAssembler::LazyCompileSlotIndexToOffset(slot_index);
+  JumpTableAssembler::PatchJumpTableSlot(main_jump_table_->instruction_start(),
+                                         slot_index, lazy_compile_target,
+                                         WasmCode::kFlushICache);
+}
+
+// TODO(mstarzinger): Remove {Isolate} parameter once {V8_EMBEDDED_BUILTINS}
+// was removed and embedded builtins are no longer optional.
+void NativeModule::SetRuntimeStubs(Isolate* isolate) {
+#ifndef V8_EMBEDDED_BUILTINS
+  FATAL(
+      "WebAssembly is not supported in no-embed builds. no-embed builds are "
+      "deprecated. See\n"
+      " - https://groups.google.com/d/msg/v8-users/9F53xqBjpkI/9WmKSbcWBAAJ\n"
+      " - https://crbug.com/v8/8519\n"
+      " - https://crbug.com/v8/8531\n");
+#endif                                                // V8_EMBEDDED_BUILTINS
+  DCHECK_EQ(kNullAddress, runtime_stub_entries_[0]);  // Only called once.
+  WasmCodeRefScope code_ref_scope;
+  DCHECK_EQ(1, code_space_data_.size());
+  WasmCode* jump_table = CreateEmptyJumpTableInRegion(
+      JumpTableAssembler::SizeForNumberOfStubSlots(WasmCode::kRuntimeStubCount),
+      code_space_data_[0].region);
+  Address base = jump_table->instruction_start();
+  EmbeddedData embedded_data = EmbeddedData::FromBlob();
+#define RUNTIME_STUB(Name) Builtins::k##Name,
+#define RUNTIME_STUB_TRAP(Name) RUNTIME_STUB(ThrowWasm##Name)
+  Builtins::Name wasm_runtime_stubs[WasmCode::kRuntimeStubCount] = {
+      WASM_RUNTIME_STUB_LIST(RUNTIME_STUB, RUNTIME_STUB_TRAP)};
+#undef RUNTIME_STUB
+#undef RUNTIME_STUB_TRAP
+  Address builtin_address[WasmCode::kRuntimeStubCount];
+  for (int i = 0; i < WasmCode::kRuntimeStubCount; ++i) {
+    Builtins::Name builtin = wasm_runtime_stubs[i];
+    CHECK(embedded_data.ContainsBuiltin(builtin));
+    builtin_address[i] = embedded_data.InstructionStartOfBuiltin(builtin);
+    runtime_stub_entries_[i] =
+        base + JumpTableAssembler::StubSlotIndexToOffset(i);
+  }
+  JumpTableAssembler::GenerateRuntimeStubTable(base, builtin_address,
+                                               WasmCode::kRuntimeStubCount);
+  DCHECK_NULL(runtime_stub_table_);
+  runtime_stub_table_ = jump_table;
+  DCHECK_NE(kNullAddress, runtime_stub_entries_[0]);
+}
+
 std::unique_ptr<WasmCode> NativeModule::AddCode(
     uint32_t index, const CodeDesc& desc, uint32_t stack_slots,
     uint32_t tagged_parameter_slots,

src/wasm/wasm-code-manager.h

@@ -527,10 +527,6 @@ class V8_EXPORT_PRIVATE NativeModule final {
       OwnedVector<const byte> source_position_table, WasmCode::Kind kind,
       ExecutionTier tier, Vector<uint8_t> code_space);
 
-  // Add and publish anonymous code.
-  WasmCode* AddAndPublishAnonymousCode(Handle<Code>, WasmCode::Kind kind,
-                                       const char* name = nullptr);
-
   WasmCode* CreateEmptyJumpTableInRegion(uint32_t jump_table_size,
                                          base::AddressRegion);