AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[wasm] Fix capitalization of "Wasm"

Browse Source 
If we want external people to stop shouting WASM, we should start
by avoiding that in our own code base.
This CL replaces almost all occurrences of "WASM" by "Wasm". The
last remaining ones (in frames.cc) are in capitalized contexts where
WASM fits.

TBR=ecmziegler@chromium.org

Bug: v8:10155
Change-Id: I905b92220768b99bb5e1165255691ffe4498dba3
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2126917
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Emanuel Ziegler <ecmziegler@chromium.org>
Cr-Commit-Position: refs/heads/master@{#66917}
This commit is contained in:
Clemens Backes 2020-03-30 18:15:05 +02:00 committed by Commit Bot
parent deb490dcae
commit e7cb911a93
38 changed files with 66 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/v8.h
View File

@ -7522,7 +7522,7 @@ typedef void (*WasmStreamingCallback)(const FunctionCallbackInfo<Value>&);
// --- Callback for checking if WebAssembly threads are enabled ---
typedef bool (*WasmThreadsEnabledCallback)(Local<Context> context);
// --- Callback for loading source map file for WASM profiling support
// --- Callback for loading source map file for Wasm profiling support
typedef Local<String> (*WasmLoadSourceMapCallback)(Isolate* isolate,
const char* name);

2
src/builtins/ia32/builtins-ia32.cc
View File

@ -2670,7 +2670,7 @@ void Builtins::Generate_WasmCompileLazy(MacroAssembler* masm) {
offset += kSimd128Size;
}
// Push the WASM instance as an explicit argument to WasmCompileLazy.
// Push the Wasm instance as an explicit argument to WasmCompileLazy.
__ Push(kWasmInstanceRegister);
// Push the function index as second argument.
__ Push(kWasmCompileLazyFuncIndexRegister);

2
src/builtins/x64/builtins-x64.cc
View File

@ -2849,7 +2849,7 @@ void Builtins::Generate_WasmCompileLazy(MacroAssembler* masm) {
offset += kSimd128Size;
}
// Push the WASM instance as an explicit argument to WasmCompileLazy.
// Push the Wasm instance as an explicit argument to WasmCompileLazy.
__ Push(kWasmInstanceRegister);
// Push the function index as second argument.
__ Push(r11);

2
src/codegen/arm64/macro-assembler-arm64.cc
View File

@ -1734,7 +1734,7 @@ void TurboAssembler::JumpHelper(int64_t offset, RelocInfo::Mode rmode,
namespace {
// The calculated offset is either:
// * the 'target' input unmodified if this is a WASM call, or
// * the 'target' input unmodified if this is a Wasm call, or
// * the offset of the target from the current PC, in instructions, for any
// other type of call.
static int64_t CalculateTargetOffset(Address target, RelocInfo::Mode rmode,

2
src/codegen/assembler.h
View File

@ -143,7 +143,7 @@ enum class CodeObjectRequired { kNo, kYes };
struct V8_EXPORT_PRIVATE AssemblerOptions {
// Recording reloc info for external references and off-heap targets is
// needed whenever code is serialized, e.g. into the snapshot or as a WASM
// needed whenever code is serialized, e.g. into the snapshot or as a Wasm
// module. This flag allows this reloc info to be disabled for code that
// will not survive process destruction.
bool record_reloc_info_for_serialization = true;

2
src/compiler/backend/arm/code-generator-arm.cc
View File

@ -3539,7 +3539,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ Push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/ia32/code-generator-ia32.cc
View File

@ -4614,7 +4614,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/mips/code-generator-mips.cc
View File

@ -3752,7 +3752,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ Push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/mips64/code-generator-mips64.cc
View File

@ -3850,7 +3850,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ Push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/ppc/code-generator-ppc.cc
View File

@ -2387,7 +2387,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ Push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/s390/code-generator-s390.cc
View File

@ -4407,7 +4407,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ Push(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

2
src/compiler/backend/x64/code-generator-x64.cc
View File

@ -4364,7 +4364,7 @@ void CodeGenerator::AssembleConstructFrame() {
__ pushq(kWasmInstanceRegister);
} else if (call_descriptor->IsWasmImportWrapper() ||
call_descriptor->IsWasmCapiFunction()) {
// WASM import wrappers are passed a tuple in the place of the instance.
// Wasm import wrappers are passed a tuple in the place of the instance.
// Unpack the tuple into the instance and the target callable.
// This must be done here in the codegen because it cannot be expressed
// properly in the graph.

3
src/compiler/verifier.cc
View File

@ -151,8 +151,7 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
// If this node has any effect outputs, make sure that it is
// consumed as an effect input somewhere else.
// TODO(mvstanton): support this kind of verification for WASM
// compiles, too.
// TODO(mvstanton): support this kind of verification for Wasm compiles, too.
if (code_type != kWasm && node->op()->EffectOutputCount() > 0) {
int effect_edges = 0;
for (Edge edge : node->use_edges()) {

6
src/compiler/wasm-compiler.cc
View File

@ -5752,7 +5752,7 @@ class WasmWrapperGraphBuilder : public WasmGraphBuilder {
return false;
}
// The callable is passed as the last parameter, after WASM arguments.
// The callable is passed as the last parameter, after Wasm arguments.
Node* callable_node = Param(wasm_count + 1);
Node* undefined_node = BuildLoadUndefinedValueFromInstance();
@ -5937,7 +5937,7 @@ class WasmWrapperGraphBuilder : public WasmGraphBuilder {
control()));
offset += type.element_size_bytes();
}
// The function is passed as the last parameter, after WASM arguments.
// The function is passed as the last parameter, after Wasm arguments.
Node* function_node = Param(param_count + 1);
Node* shared = gasm_->Load(
MachineType::AnyTagged(), function_node,
@ -6470,7 +6470,7 @@ wasm::WasmCompilationResult CompileWasmMathIntrinsic(
Zone zone(wasm_engine->allocator(), ZONE_NAME);
// Compile a WASM function with a single bytecode and let TurboFan
// Compile a Wasm function with a single bytecode and let TurboFan
// generate either inlined machine code or a call to a helper.
SourcePositionTable* source_positions = nullptr;
MachineGraph* mcgraph = new (&zone) MachineGraph(

22
src/compiler/wasm-compiler.h
View File

@ -58,16 +58,16 @@ wasm::WasmCompilationResult ExecuteInterpreterEntryCompilation(
wasm::WasmEngine*, wasm::CompilationEnv*, const wasm::FunctionBody&,
int func_index, Counters*, wasm::WasmFeatures* detected);
// Calls to WASM imports are handled in several different ways, depending on the
// Calls to Wasm imports are handled in several different ways, depending on the
// type of the target function/callable and whether the signature matches the
// argument arity.
enum class WasmImportCallKind : uint8_t {
kLinkError, // static WASM->WASM type error
kRuntimeTypeError, // runtime WASM->JS type error
kWasmToCapi, // fast WASM->C-API call
kWasmToWasm, // fast WASM->WASM call
kJSFunctionArityMatch, // fast WASM->JS call
kJSFunctionArityMismatch, // WASM->JS, needs adapter frame
kLinkError, // static Wasm->Wasm type error
kRuntimeTypeError, // runtime Wasm->JS type error
kWasmToCapi, // fast Wasm->C-API call
kWasmToWasm, // fast Wasm->Wasm call
kJSFunctionArityMatch, // fast Wasm->JS call
kJSFunctionArityMismatch, // Wasm->JS, needs adapter frame
// Math functions imported from JavaScript that are intrinsified
kFirstMathIntrinsic,
kF64Acos = kFirstMathIntrinsic,
@ -109,12 +109,12 @@ V8_EXPORT_PRIVATE std::pair<WasmImportCallKind, Handle<JSReceiver>>
ResolveWasmImportCall(Handle<JSReceiver> callable, const wasm::FunctionSig* sig,
const wasm::WasmFeatures& enabled_features);
// Compiles an import call wrapper, which allows WASM to call imports.
// Compiles an import call wrapper, which allows Wasm to call imports.
V8_EXPORT_PRIVATE wasm::WasmCompilationResult CompileWasmImportCallWrapper(
wasm::WasmEngine*, wasm::CompilationEnv* env, WasmImportCallKind,
const wasm::FunctionSig*, bool source_positions);
// Compiles a host call wrapper, which allows WASM to call host functions.
// Compiles a host call wrapper, which allows Wasm to call host functions.
wasm::WasmCode* CompileWasmCapiCallWrapper(wasm::WasmEngine*,
wasm::NativeModule*,
const wasm::FunctionSig*,
@ -150,9 +150,9 @@ enum CWasmEntryParameters {
// which knows how to feed it its parameters.
MaybeHandle<Code> CompileCWasmEntry(Isolate*, const wasm::FunctionSig*);
// Values from the instance object are cached between WASM-level function calls.
// Values from the instance object are cached between Wasm-level function calls.
// This struct allows the SSA environment handling this cache to be defined
// and manipulated in wasm-compiler.{h,cc} instead of inside the WASM decoder.
// and manipulated in wasm-compiler.{h,cc} instead of inside the Wasm decoder.
// (Note that currently, the globals base is immutable, so not cached here.)
struct WasmInstanceCacheNodes {
Node* mem_start;

6
src/diagnostics/objects-printer.cc
View File

@ -1307,12 +1307,12 @@ void JSFunction::JSFunctionPrint(std::ostream& os) { // NOLINT
}
if (WasmExportedFunction::IsWasmExportedFunction(*this)) {
WasmExportedFunction function = WasmExportedFunction::cast(*this);
os << "\n - WASM instance: " << Brief(function.instance());
os << "\n - WASM function index: " << function.function_index();
os << "\n - Wasm instance: " << Brief(function.instance());
os << "\n - Wasm function index: " << function.function_index();
}
if (WasmJSFunction::IsWasmJSFunction(*this)) {
WasmJSFunction function = WasmJSFunction::cast(*this);
os << "\n - WASM wrapper around: " << Brief(function.GetCallable());
os << "\n - Wasm wrapper around: " << Brief(function.GetCallable());
}
shared().PrintSourceCode(os);
JSObjectPrintBody(os, *this);

2
src/diagnostics/unwinding-info-win64.cc
View File

@ -517,7 +517,7 @@ void RegisterNonABICompliantCodeRange(void* start, size_t size_in_bytes) {
// When the --win64-unwinding-info flag is set, we call
// RtlAddGrowableFunctionTable to register unwinding info for the whole code
// range of an isolate or WASM module. This enables the Windows OS stack
// range of an isolate or Wasm module. This enables the Windows OS stack
// unwinder to work correctly with V8-generated code, enabling stack walking
// in Windows debuggers and performance tools. However, the
// RtlAddGrowableFunctionTable API is only supported on Windows 8 and above.

6
src/diagnostics/unwinding-info-win64.h
View File

@ -32,7 +32,7 @@ bool CanEmitUnwindInfoForBuiltins();
/**
* Returns true if V8 if we can register unwinding data for the whole code range
* of an isolate or WASM module. The first page of the code range is reserved
* of an isolate or Wasm module. The first page of the code range is reserved
* and writable, to be used to store unwind data, as documented in:
* https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64.
* In jitless mode V8 does not allocate any executable memory itself so the only
@ -52,9 +52,9 @@ void UnregisterNonABICompliantCodeRange(void* start);
/**
* Default count of RUNTIME_FUNCTION needed. For Windows X64, 1 RUNTIME_FUNCTION
* covers 4GB range which is sufficient to cover the whole code range of an
* isolate or WASM module. For Windows ARM64, 1 RUNTIME_FUNCTION covers
* isolate or Wasm module. For Windows ARM64, 1 RUNTIME_FUNCTION covers
* kMaxFunctionLength bytes so multiple RUNTIME_FUNCTION structs could be needed
* to cover the whole code range of an isolate or WASM module. The extra
* to cover the whole code range of an isolate or Wasm module. The extra
* RUNTIME_FUNCTIONs are assumed following the first one in the reserved page.
*/
static const uint32_t kDefaultRuntimeFunctionCount = 1;

4
src/execution/isolate.cc
View File

@ -970,13 +970,13 @@ Handle<Object> CaptureStackTrace(Isolate* isolate, Handle<Object> caller,
builder.AppendJavaScriptFrame(java_script);
} else if (summary.IsWasmCompiled()) {
//=========================================================
// Handle a WASM compiled frame.
// Handle a Wasm compiled frame.
//=========================================================
auto const& wasm_compiled = summary.AsWasmCompiled();
builder.AppendWasmCompiledFrame(wasm_compiled);
} else if (summary.IsWasmInterpreted()) {
//=========================================================
// Handle a WASM interpreted frame.
// Handle a Wasm interpreted frame.
//=========================================================
auto const& wasm_interpreted = summary.AsWasmInterpreted();
builder.AppendWasmInterpretedFrame(wasm_interpreted);

2
src/flags/flag-definitions.h
View File

@ -736,7 +736,7 @@ DEFINE_DEBUG_BOOL(dump_wasm_module, false, "dump wasm module bytes")
DEFINE_STRING(dump_wasm_module_path, nullptr,
"directory to dump wasm modules to")
// Declare command-line flags for WASM features. Warning: avoid using these
// Declare command-line flags for Wasm features. Warning: avoid using these
// flags directly in the implementation. Instead accept wasm::WasmFeatures
// for configurability.
#include "src/wasm/wasm-feature-flags.h"

2
src/init/bootstrapper.cc
View File

@ -4997,7 +4997,7 @@ bool Genesis::InstallSpecialObjects(Isolate* isolate,
WasmJs::Install(isolate, true);
} else if (FLAG_validate_asm) {
// Install the internal data structures only; these are needed for asm.js
// translated to WASM to work correctly.
// translated to Wasm to work correctly.
WasmJs::Install(isolate, false);
}

2
src/inspector/v8-debugger-agent-impl.cc
View File

@ -1498,7 +1498,7 @@ void V8DebuggerAgentImpl::didParseSource(
return;
}
// TODO(herhut, dgozman): Report correct length for WASM if needed for
// TODO(herhut, dgozman): Report correct length for Wasm if needed for
// coverage. Or do not send the length at all and change coverage instead.
if (scriptRef->isSourceLoadedLazily()) {
m_frontend.scriptParsed(

2
src/objects/backing-store.cc
View File

@ -635,7 +635,7 @@ void GlobalBackingStoreRegistry::Register(
// BackingStore per buffer_start() because the destructor of
// of the BackingStore will be a no-op in that case.
// All WASM memory has to be registered.
// All Wasm memory has to be registered.
CHECK(!backing_store->is_wasm_memory());
return;
}

2
src/wasm/module-compiler.cc
View File

@ -989,7 +989,7 @@ bool ExecuteCompilationUnits(
TRACE_COMPILE("Compiling (task %d)...\n", task_id);
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.wasm"), "ExecuteCompilationUnits");
// Execute JS to WASM wrapper units first, so that they are ready to be
// Execute JS to Wasm wrapper units first, so that they are ready to be
// finalized by the main thread when the kFinishedBaselineCompilation event is
// triggered.
if (!ExecuteJSToWasmWrapperCompilationUnits(token)) {

2
src/wasm/module-instantiate.cc
View File

@ -844,7 +844,7 @@ bool InstanceBuilder::ProcessImportedFunction(
import_index, module_name, import_name);
return false;
case compiler::WasmImportCallKind::kWasmToWasm: {
// The imported function is a WASM function from another instance.
// The imported function is a Wasm function from another instance.
auto imported_function = Handle<WasmExportedFunction>::cast(js_receiver);
Handle<WasmInstanceObject> imported_instance(
imported_function->instance(), isolate_);

12
src/wasm/wasm-engine.h
View File

@ -131,13 +131,13 @@ class NativeModuleCache {
};
// The central data structure that represents an engine instance capable of
// loading, instantiating, and executing WASM code.
// loading, instantiating, and executing Wasm code.
class V8_EXPORT_PRIVATE WasmEngine {
public:
WasmEngine();
~WasmEngine();
// Synchronously validates the given bytes that represent an encoded WASM
// Synchronously validates the given bytes that represent an encoded Wasm
// module.
bool SyncValidate(Isolate* isolate, const WasmFeatures& enabled,
const ModuleWireBytes& bytes);
@ -152,14 +152,14 @@ class V8_EXPORT_PRIVATE WasmEngine {
Isolate* isolate, Handle<AsmWasmData> asm_wasm_data,
Handle<Script> script);
// Synchronously compiles the given bytes that represent an encoded WASM
// Synchronously compiles the given bytes that represent an encoded Wasm
// module.
MaybeHandle<WasmModuleObject> SyncCompile(Isolate* isolate,
const WasmFeatures& enabled,
ErrorThrower* thrower,
const ModuleWireBytes& bytes);
// Synchronously instantiate the given WASM module with the given imports.
// Synchronously instantiate the given Wasm module with the given imports.
// If the module represents an asm.js module, then the supplied {memory}
// should be used as the memory of the instance.
MaybeHandle<WasmInstanceObject> SyncInstantiate(
@ -168,7 +168,7 @@ class V8_EXPORT_PRIVATE WasmEngine {
MaybeHandle<JSArrayBuffer> memory);
// Begin an asynchronous compilation of the given bytes that represent an
// encoded WASM module.
// encoded Wasm module.
// The {is_shared} flag indicates if the bytes backing the module could
// be shared across threads, i.e. could be concurrently modified.
void AsyncCompile(Isolate* isolate, const WasmFeatures& enabled,
@ -176,7 +176,7 @@ class V8_EXPORT_PRIVATE WasmEngine {
const ModuleWireBytes& bytes, bool is_shared,
const char* api_method_name_for_errors);
// Begin an asynchronous instantiation of the given WASM module.
// Begin an asynchronous instantiation of the given Wasm module.
void AsyncInstantiate(Isolate* isolate,
std::unique_ptr<InstantiationResultResolver> resolver,
Handle<WasmModuleObject> module_object,

2
src/wasm/wasm-linkage.h
View File

@ -15,7 +15,7 @@ namespace internal {
namespace wasm {
// TODO(wasm): optimize calling conventions to be both closer to C++ (to
// reduce adapter costs for fast WASM <-> C++ calls) and to be more efficient
// reduce adapter costs for fast Wasm <-> C++ calls) and to be more efficient
// in general.
#if V8_TARGET_ARCH_IA32

6
src/wasm/wasm-module-sourcemap.h
View File

@ -18,7 +18,7 @@ namespace wasm {
// toolchain (e.g. Emscripten). This implementation mostly complies with the
// specification (https://sourcemaps.info/spec.html), with the following
// accommodations:
// 1. "names" field is an empty array in current source maps of WASM, hence it
// 1. "names" field is an empty array in current source maps of Wasm, hence it
// is not handled;
// 2. The semicolons divides "mappings" field into groups, each of which
// represents a line in the generated code. As *.wasm is in binary format, there
@ -37,13 +37,13 @@ class V8_EXPORT_PRIVATE WasmModuleSourceMap {
// and can be correctly decoded.
bool IsValid() const { return valid_; }
// Given a function located at [start, end) in WASM Module, this function
// Given a function located at [start, end) in Wasm Module, this function
// checks if this function has its corresponding source code.
bool HasSource(size_t start, size_t end) const;
// Given a function's base address start and an address addr within, this
// function checks if the address can be mapped to an offset in this function.
// For example, we have the following memory layout for WASM functions, foo
// For example, we have the following memory layout for Wasm functions, foo
// and bar, and O1, O2, O3 and O4 are the decoded offsets of source map:
//
// O1 --- O2 ----- O3 ----- O4

2
src/wasm/wasm-objects.cc
View File

@ -1091,7 +1091,7 @@ void ImportedFunctionEntry::SetWasmToJs(
void ImportedFunctionEntry::SetWasmToWasm(WasmInstanceObject instance,
Address call_target) {
TRACE_IFT("Import WASM 0x%" PRIxPTR "[%d] = {instance=0x%" PRIxPTR
TRACE_IFT("Import Wasm 0x%" PRIxPTR "[%d] = {instance=0x%" PRIxPTR
", target=0x%" PRIxPTR "}\n",
instance_->ptr(), index_, instance.ptr(), call_target);
instance_->imported_function_refs().set(index_, instance);

8
src/wasm/wasm-objects.h
View File

@ -93,21 +93,21 @@ class IndirectFunctionTableEntry {
// The underlying storage in the instance is used by generated code to
// call imported functions at runtime.
// Each entry is either:
// - WASM to JS, which has fields
// - Wasm to JS, which has fields
// - object = a Tuple2 of the importing instance and the callable
// - target = entrypoint to import wrapper code
// - WASM to WASM, which has fields
// - Wasm to Wasm, which has fields
// - object = target instance
// - target = entrypoint for the function
class ImportedFunctionEntry {
public:
inline ImportedFunctionEntry(Handle<WasmInstanceObject>, int index);
// Initialize this entry as a WASM to JS call. This accepts the isolate as a
// Initialize this entry as a Wasm to JS call. This accepts the isolate as a
// parameter, since it must allocate a tuple.
V8_EXPORT_PRIVATE void SetWasmToJs(Isolate*, Handle<JSReceiver> callable,
const wasm::WasmCode* wasm_to_js_wrapper);
// Initialize this entry as a WASM to WASM call.
// Initialize this entry as a Wasm to Wasm call.
void SetWasmToWasm(WasmInstanceObject target_instance, Address call_target);
WasmInstanceObject instance();

2
src/wasm/wasm-serialization.cc
View File

@ -30,7 +30,7 @@ namespace wasm {
namespace {
// TODO(bbudge) Try to unify the various implementations of readers and writers
// in WASM, e.g. StreamProcessor and ZoneBuffer, with these.
// in Wasm, e.g. StreamProcessor and ZoneBuffer, with these.
class Writer {
public:
explicit Writer(Vector<byte> buffer)

2
src/wasm/wasm-tier.h
View File

@ -11,7 +11,7 @@ namespace v8 {
namespace internal {
namespace wasm {
// All the tiers of WASM execution.
// All the tiers of Wasm execution.
enum class ExecutionTier : int8_t {
kNone,
kInterpreter,

4
test/cctest/cctest.status
View File

@ -215,8 +215,8 @@
##############################################################################
['byteorder == big', {
# Skip WASM atomic tests on big-endian machines.
# There is no support to emulate atomic WASM operations on big-endian
# Skip Wasm atomic tests on big-endian machines.
# There is no support to emulate atomic Wasm operations on big-endian
# platforms, since this would require bit swapping as a part of atomic
# operations.
'test-run-wasm-atomics/*': [SKIP],

2
test/cctest/wasm/test-grow-memory.cc
View File

@ -113,7 +113,7 @@ TEST(Run_WasmModule_Buffer_Externalized_GrowMem) {
ManuallyExternalizedBuffer external2(
handle(memory_object->array_buffer(), isolate));
// Grow using an internal WASM bytecode.
// Grow using an internal Wasm bytecode.
result = testing::RunWasmModuleForTesting(isolate, instance, 0, nullptr);
CHECK_EQ(26, result);
CHECK(external2.buffer_->was_detached()); // growing always detaches

2
test/mjsunit/wasm/memory-external-call.js
View File

@ -302,7 +302,7 @@ function assertMemoryIndependence(load_a, store_a, load_b, store_b) {
assertMemoryIndependence(a.exports.load, table.get(1),
b.exports.load, table.get(0));
// Check that calling (from WASM) through the table maintains independence.
// Check that calling (from Wasm) through the table maintains independence.
builder = new WasmModuleBuilder();
builder.addImportedTable("m", "table", kTableSize, kTableSize);
var sig_index = builder.addType(kSig_v_ii);

2
test/mjsunit/wasm/user-properties-exported.js
View File

@ -22,7 +22,7 @@ load("test/mjsunit/wasm/user-properties-common.js");
testProperties(g);
// The WASM-internal fields of {g} are only inspected when {g} is
// The Wasm-internal fields of {g} are only inspected when {g} is
// used as an import into another instance.
print(" instance 2, importing");
var builder = new WasmModuleBuilder();

2
test/mjsunit/wasm/user-properties-module.js
View File

@ -45,7 +45,7 @@ load("test/mjsunit/wasm/user-properties-common.js");
assertEquals(f(j), g(j));
}
verifyHeap();
// The WASM-internal fields of {g} are only inspected when {g} is
// The Wasm-internal fields of {g} are only inspected when {g} is
// used as an import into another instance. Use {g} as the import
// the next time through the loop.
f = g;

2
test/mjsunit/wasm/user-properties-reexport.js
View File

@ -23,7 +23,7 @@ load("test/mjsunit/wasm/user-properties-common.js");
testProperties(g);
printName(" after", g);
// The WASM-internal fields of {g} are only inspected when {g} is
// The Wasm-internal fields of {g} are only inspected when {g} is
// used as an import into another instance. Use {g} as the import
// the next time through the loop.
f = g;