Lines Matching defs:module
5 #include "src/wasm/module-compiler.h"
29 #include "src/wasm/module-decoder.h"
98 // Keep the native module alive while in this scope.
192 const WasmModule* module) {
217 size_t func_size = module->functions[unit.func_index()].code.length();
572 // Initialize recompilation of the whole module: Setup compilation progress
601 void FinalizeJSToWasmWrappers(Isolate* isolate, const WasmModule* module,
670 bool lazy_function, NativeModule* module,
728 // Features detected to be used in this module. Features can be detected
729 // as a module is being compiled.
908 const WasmCompilationHint* GetCompilationHint(const WasmModule* module,
910 DCHECK_LE(module->num_imported_functions, func_index);
911 uint32_t hint_index = declared_function_index(module, func_index);
913 module->compilation_hints;
920 CompileStrategy GetCompileStrategy(const WasmModule* module,
927 auto* hint = GetCompilationHint(module, func_index);
949 const WasmModule* module = native_module->module();
952 result.baseline_tier = WasmCompilationUnit::GetBaselineExecutionTier(module);
958 if (module->origin != kWasmOrigin || !tier_up_enabled ||
971 const WasmCompilationHint* hint = GetCompilationHint(module, func_index);
998 if (func_index < native_module_->module()->num_imported_functions) {
1006 // down when the module is fully compiled. Synchronization would be pretty
1057 const WasmModule* module() { return native_module_->module(); }
1072 const WasmFunction* func, const WasmModule* module,
1074 WasmName name = wire_bytes.GetNameOrNull(func, module);
1088 DecodeResult ValidateSingleFunction(const WasmModule* module, int func_index,
1093 const WasmFunction* func = &module->functions[func_index];
1098 return VerifyWasmCode(allocator, enabled_features, module, &detected, body);
1107 const WasmModule* module, NativeModule* native_module, Counters* counters,
1111 uint32_t start = module->num_imported_functions;
1112 uint32_t end = start + module->num_declared_functions;
1118 GetCompileStrategy(module, enabled_features, func_index, lazy_module);
1126 const WasmFunction* func = &module->functions[func_index];
1129 module, func_index, code, counters, allocator, enabled_features);
1131 SetCompileError(thrower, wire_bytes, func, module, result.error());
1136 bool IsLazyModule(const WasmModule* module) {
1138 (FLAG_asm_wasm_lazy_compilation && is_asmjs_module(module));
1147 const WasmModule* module = native_module->module();
1190 // {--wasm-lazy-validation} is enabled. Otherwise, the module was fully
1193 const WasmFunction* func = &module->functions[func_index];
1199 ValidateSingleFunction(module, func_index, code, counters,
1203 func, module, decode_result.error());
1213 declared_function_index(module, func_index), *vector);
1236 const bool lazy_module = IsLazyModule(module);
1237 if (GetCompileStrategy(module, enabled_features, func_index, lazy_module) ==
1249 TransitiveTypeFeedbackProcessor(const WasmModule* module,
1253 feedback_for_function_(module->type_feedback.feedback_for_function) {
1254 base::MutexGuard mutex_guard(&module->type_feedback.mutex);
1290 int which_vector = declared_function_index(instance_->module(), func_index);
1296 static_cast<int>(instance_->module()->num_imported_functions);
1304 // if it's defined in the same module.
1338 // - it was not defined in this module.
1398 const WasmModule* module = native_module->module();
1401 base::MutexGuard mutex_guard(&module->type_feedback.mutex);
1403 module->type_feedback.feedback_for_function[func_index].tierup_priority;
1405 module->type_feedback.feedback_for_function[func_index].tierup_priority =
1418 // of the same module have collected different feedback. If that ever
1420 TransitiveTypeFeedbackProcessor process(module, instance, func_index);
1484 static_cast<int>(env.module->num_imported_functions)) {
1511 std::shared_ptr<const WasmModule> module;
1533 module = compile_scope.native_module()->shared_module();
1621 for (auto exp : native_module->module()->export_table) {
1623 auto& function = native_module->module()->functions[exp.index];
1627 isolate, function.sig, native_module->module(), function.imported,
1645 const FunctionSig* sig = native_module->module()->functions[func_index].sig;
1646 if (!IsJSCompatibleSignature(sig, native_module->module(),
1665 const bool lazy_module = IsLazyModule(native_module->module());
1666 auto* module = native_module->module();
1668 uint32_t start = module->num_imported_functions;
1669 uint32_t end = start + module->num_declared_functions;
1673 module, native_module->enabled_features(), func_index, lazy_module);
1691 const bool lazy_module = IsLazyModule(native_module->module());
1701 bool MayCompriseLazyFunctions(const WasmModule* module,
1706 int start = module->num_imported_functions;
1707 int end = start + module->num_declared_functions;
1709 SLOW_DCHECK(GetCompileStrategy(module, enabled_features, func_index,
1822 // On error: Return and leave the module in an unexecutable state.
1826 DCHECK_GE(kMaxInt, native_module->module()->num_declared_functions);
1852 compilation_state->FinalizeJSToWasmWrappers(isolate, native_module->module(),
1904 std::shared_ptr<const WasmModule> module, const ModuleWireBytes& wire_bytes,
1907 const WasmModule* wasm_module = module.get();
1912 // cache key. When we eventually install the module in the cache, the wire
1932 const bool include_liftoff = module->origin == kWasmOrigin && FLAG_liftoff;
1938 module.get(), include_liftoff, dynamic_tiering);
1940 engine->NewNativeModule(isolate, enabled, module, code_size_estimate);
2130 std::shared_ptr<const WasmModule> module, size_t code_size_estimate) {
2132 if (module->has_shared_memory) {
2136 // TODO(wasm): Improve efficiency of storing module wire bytes. Only store
2139 // Create the module object and populate with compiled functions and
2143 isolate_, enabled_features_, std::move(module), code_size_estimate);
2149 std::shared_ptr<const WasmModule> module, size_t code_size_estimate) {
2151 module->origin, wire_bytes_.module_bytes(), isolate_);
2153 CreateNativeModule(std::move(module), code_size_estimate);
2160 // Create heap objects for script and module bytes to be stored in the
2161 // module object. Asm.js is not compiled asynchronously.
2213 const WasmModule* module = module_object_->module();
2215 module->debug_symbols.type == WasmDebugSymbols::Type::SourceMap &&
2216 !module->debug_symbols.external_url.is_empty()) {
2219 wire_bytes.GetNameOrNull(module->debug_symbols.external_url),
2235 CompileJsToWasmWrappers(isolate_, module, &export_wrappers);
2237 compilation_state->FinalizeJSToWasmWrappers(isolate_, module,
2245 // We might need to recompile the module for debugging, if the debugger was
2248 // the module.
2269 DCHECK_EQ(native_module_->module()->origin, kWasmOrigin);
2271 ValidateSequentially(native_module_->module(), native_module_.get(),
2285 // the module's start function calls out to Blink.
2308 // Install the native module in the cache, or reuse a conflicting one.
2309 // If we get a conflicting module, wait until we are back in the
2482 // Step 1: (async) Decode the module.
2495 // Decode the module bytes.
2496 TRACE_COMPILE("(1) Decoding module...\n");
2507 const WasmModule* module = result.value().get();
2508 DCHECK_EQ(module->origin, kWasmOrigin);
2510 if (MayCompriseLazyFunctions(module, enabled_features, lazy_module)) {
2512 int start = module->num_imported_functions;
2513 int end = start + module->num_declared_functions;
2516 const WasmFunction* func = &module->functions[func_index];
2521 module, enabled_features, func_index, lazy_module);
2527 ValidateSingleFunction(module, func_index, code, counters_,
2543 std::shared_ptr<WasmModule> module = std::move(result).value();
2547 module.get(), include_liftoff, job->dynamic_tiering_);
2548 job->DoSync<PrepareAndStartCompile>(std::move(module), true,
2559 // Step 1b: (sync) Fail decoding the module.
2580 PrepareAndStartCompile(std::shared_ptr<const WasmModule> module,
2582 : module_(std::move(module)),
2692 // Then finalize and publish the generated module.
2700 TRACE_COMPILE("(4) Finish module...\n");
2756 // Process the module header.
2759 TRACE_STREAMING("Process module header...\n");
2842 static_cast<int>(decoder_.module()->num_imported_functions);
2843 DCHECK_EQ(kWasmOrigin, decoder_.module()->origin);
2854 DCHECK_EQ(job_->native_module_->module()->origin, kWasmOrigin);
2872 const WasmModule* module = decoder_.module();
2875 num_functions_ + decoder_.module()->num_imported_functions;
2876 DCHECK_EQ(module->origin, kWasmOrigin);
2879 GetCompileStrategy(module, enabled_features, func_index, lazy_module);
2885 // The native module does not own the wire bytes until {SetWireBytes} is
2888 ValidateSingleFunction(module, func_index, bytes, async_counters_.get(),
2947 // {PrepareAndStartCompile} will get the native module from the cache.
2971 // We are processing a WebAssembly module without code section. Create the
2972 // native module now (would otherwise happen in {PrepareAndStartCompile} or
3078 native_module->module(), enabled_features, func_index, lazy_function);
3108 auto* module = native_module_->module();
3114 compilation_progress_.reserve(module->num_declared_functions);
3115 int start = module->num_imported_functions;
3116 int end = start + module->num_declared_functions;
3141 // Trigger callbacks if module needs no baseline or top tier compilation. This
3142 // can be the case for an empty or fully lazy module.
3161 // Besides, module serialization currently requires that all functions
3168 uint32_t size = builder->module()->functions[function_index].code.length();
3193 int offset = native_module_->module()->num_imported_functions;
3218 int offset = native_module_->module()->num_imported_functions;
3250 auto* module = native_module_->module();
3252 const bool lazy_module = IsLazyModule(module);
3269 // The {kFinishedBaselineCompilation} event is needed for module
3280 compilation_progress_.assign(module->num_declared_functions,
3285 compilation_progress_[declared_function_index(module, func_index)] =
3296 compilation_progress_[declared_function_index(module, func_index)],
3298 compilation_progress_[declared_function_index(module, func_index)] =
3349 // the module is complete. In any case, we don't need to recompile here.
3353 const WasmModule* module = native_module_->module();
3354 DCHECK_EQ(module->num_declared_functions, compilation_progress_.size());
3355 DCHECK_GE(module->num_declared_functions,
3365 int imported = module->num_imported_functions;
3376 // Trigger callback if module needs no recompilation.
3427 native_module_->module());
3464 Isolate* isolate, const WasmModule* module,
3467 MaxNumExportWrappers(module), AllocationType::kOld);
3480 GetExportWrapperIndex(module, unit->sig(), unit->is_import());
3520 native_module_->module()->num_declared_functions);
3543 declared_function_index(native_module_->module(), code->index());
3703 native_module_->module()->functions[func_index].sig;
3886 void CompileJsToWasmWrappers(Isolate* isolate, const WasmModule* module,
3890 MaxNumExportWrappers(module), AllocationType::kOld);
3897 for (auto exp : module->export_table) {
3899 auto& function = module->functions[exp.index];
3903 isolate, function.sig, module, function.imported, enabled_features,
3938 int wrapper_index = GetExportWrapperIndex(module, &key.second, key.first);
3954 bool source_positions = is_asmjs_module(native_module->module());