wasm-run-utils.cc | Explore in Territory

// Copyright 2017 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 "test/cctest/wasm/wasm-run-utils.h"

#include <optional>

#include "src/codegen/assembler-inl.h"
#include "src/compiler/pipeline.h"
#include "src/diagnostics/code-tracer.h"
#include "src/heap/heap-inl.h"
#include "src/wasm/baseline/liftoff-compiler.h"
#include "src/wasm/code-space-access.h"
#include "src/wasm/compilation-environment-inl.h"
#include "src/wasm/graph-builder-interface.h"
#include "src/wasm/leb-helper.h"
#include "src/wasm/module-compiler.h"
#include "src/wasm/module-instantiate.h"
#include "src/wasm/wasm-engine.h"
#include "src/wasm/wasm-import-wrapper-cache.h"
#include "src/wasm/wasm-objects-inl.h"
#include "src/wasm/wasm-opcodes.h"
#include "src/wasm/wasm-subtyping.h"

namespace v8 {
namespace internal {
namespace wasm {

// Helper Functions.
bool IsSameNan(uint16_t expected, uint16_t actual) { … }

bool IsSameNan(float expected, float actual) { … }

bool IsSameNan(double expected, double actual) { … }

TestingModuleBuilder::TestingModuleBuilder(
    Zone* zone, ModuleOrigin origin, ManuallyImportedJSFunction* maybe_import,
    TestExecutionTier tier, Isolate* isolate)
    : … { … }

TestingModuleBuilder::~TestingModuleBuilder() { … }

uint8_t* TestingModuleBuilder::AddMemory(uint32_t size, SharedFlag shared,
                                         TestingModuleMemoryType mem_type,
                                         std::optional<size_t> max_size) { … }

uint32_t TestingModuleBuilder::AddFunction(const FunctionSig* sig,
                                           const char* name,
                                           FunctionType type) { … }

void TestingModuleBuilder::InitializeWrapperCache() { … }

Handle<JSFunction> TestingModuleBuilder::WrapCode(uint32_t index) { … }

void TestingModuleBuilder::AddIndirectFunctionTable(
    const uint16_t* function_indexes, uint32_t table_size,
    ValueType table_type) { … }

uint32_t TestingModuleBuilder::AddBytes(base::Vector<const uint8_t> bytes) { … }

uint32_t TestingModuleBuilder::AddException(const FunctionSig* sig) { … }

uint32_t TestingModuleBuilder::AddPassiveDataSegment(
    base::Vector<const uint8_t> bytes) { … }

const WasmGlobal* TestingModuleBuilder::AddGlobal(ValueType type) { … }

Handle<WasmInstanceObject> TestingModuleBuilder::InitInstanceObject() { … }

void TestBuildingGraphWithBuilder(compiler::WasmGraphBuilder* builder,
                                  Zone* zone, const FunctionSig* sig,
                                  const uint8_t* start, const uint8_t* end) { … }

void TestBuildingGraph(Zone* zone, compiler::JSGraph* jsgraph,
                       CompilationEnv* env, const FunctionSig* sig,
                       compiler::SourcePositionTable* source_position_table,
                       const uint8_t* start, const uint8_t* end) { … }

// This struct is just a type tag for Zone::NewArray<T>(size_t) call.
struct WasmFunctionCompilerBuffer { … };

void WasmFunctionCompiler::Build(base::Vector<const uint8_t> bytes) { … }

WasmFunctionCompiler::WasmFunctionCompiler(Zone* zone, const FunctionSig* sig,
                                           TestingModuleBuilder* builder,
                                           const char* name)
    : … { … }

WasmFunctionCompiler::~WasmFunctionCompiler() = default;

/* static */
FunctionSig* WasmRunnerBase::CreateSig(Zone* zone, MachineType return_type,
                                       base::Vector<MachineType> param_types) { … }

}  // namespace wasm
}  // namespace internal
}  // namespace v8
chromium/v8/test/cctest/wasm/wasm-run-utils.cc
