Hide WasmModule.origin field behind readable accessors.

src/wasm/wasm-module.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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 272 matching lines @@
   }
   DCHECK_LE(this_idx + 2, deopt_data->length());
   DCHECK(deopt_data->get(this_idx)->IsUndefined(isolate));
   DCHECK(deopt_data->get(this_idx + 1)->IsUndefined(isolate));
   deopt_data->set(this_idx, *export_table);
   deopt_data->set(this_idx + 1, Smi::FromInt(export_index));
   return code;
 }
 
 bool compile_lazy(const WasmModule* module) {
-  return FLAG_wasm_lazy_compilation || (FLAG_asm_wasm_lazy_compilation &&
-                                        module->origin == wasm::kAsmJsOrigin);
+  return FLAG_wasm_lazy_compilation ||
+         (FLAG_asm_wasm_lazy_compilation && module->is_asm_js());
 }
 
 // A helper for compiling an entire module.
 class CompilationHelper {
  public:
   CompilationHelper(Isolate* isolate, WasmModule* module)
       : isolate_(isolate), module_(module) {}
 
   // The actual runnable task that performs compilations in the background.
   class CompilationTask : public CancelableTask {
@@ skipping 202 matching lines @@
     Handle<FixedArray> signature_tables =
         factory->NewFixedArray(function_table_count, TENURED);
     for (int i = 0; i < function_table_count; ++i) {
       temp_instance.function_tables[i] = factory->NewFixedArray(1, TENURED);
       temp_instance.signature_tables[i] = factory->NewFixedArray(1, TENURED);
       function_tables->set(i, *temp_instance.function_tables[i]);
       signature_tables->set(i, *temp_instance.signature_tables[i]);
     }
 
     HistogramTimerScope wasm_compile_module_time_scope(
-        module_->origin == ModuleOrigin::kWasmOrigin
+        module_->is_wasm()
             ? isolate_->counters()->wasm_compile_wasm_module_time()
             : isolate_->counters()->wasm_compile_asm_module_time());
 
     ModuleBytesEnv module_env(module_, &temp_instance, wire_bytes);
 
     // The {code_table} array contains import wrappers and functions (which
     // are both included in {functions.size()}, and export wrappers.
     int code_table_size = static_cast<int>(module_->functions.size() +
                                            module_->num_exported_functions);
     Handle<FixedArray> code_table =
@@ skipping 622 matching lines @@
     // Check that an imports argument was provided, if the module requires it.
     // No point in continuing otherwise.
     if (!module_->import_table.empty() && ffi_.is_null()) {
       thrower_->TypeError(
           "Imports argument must be present and must be an object");
       return {};
     }
 
     // Record build time into correct bucket, then build instance.
     HistogramTimerScope wasm_instantiate_module_time_scope(
-        module_->origin == ModuleOrigin::kWasmOrigin
+        module_->is_wasm()
             ? isolate_->counters()->wasm_instantiate_wasm_module_time()
             : isolate_->counters()->wasm_instantiate_asm_module_time());
     Factory* factory = isolate_->factory();
 
     //--------------------------------------------------------------------------
     // Reuse the compiled module (if no owner), otherwise clone.
     //--------------------------------------------------------------------------
     Handle<FixedArray> code_table;
     Handle<FixedArray> old_code_table;
     MaybeHandle<WasmInstanceObject> owner;
@@ skipping 141 matching lines @@
     //--------------------------------------------------------------------------
     MaybeHandle<JSArrayBuffer> old_memory;
 
     uint32_t min_mem_pages = module_->min_mem_pages;
     isolate_->counters()->wasm_min_mem_pages_count()->AddSample(min_mem_pages);
 
     if (!memory_.is_null()) {
       // Set externally passed ArrayBuffer non neuterable.
       memory_->set_is_neuterable(false);
 
-      DCHECK_IMPLIES(EnableGuardRegions(), module_->origin == kAsmJsOrigin ||
-                                               memory_->has_guard_region());
+      DCHECK_IMPLIES(EnableGuardRegions(),
+                     module_->is_asm_js() || memory_->has_guard_region());
     } else if (min_mem_pages > 0) {
       memory_ = AllocateMemory(min_mem_pages);
       if (memory_.is_null()) return {};  // failed to allocate memory
     }
 
     //--------------------------------------------------------------------------
     // Check that indirect function table segments are within bounds.
     //--------------------------------------------------------------------------
     for (WasmTableInit& table_init : module_->table_inits) {
       DCHECK(table_init.table_index < table_instances_.size());
@@ skipping 365 matching lines @@
           // Function imports must be callable.
           if (!value->IsCallable()) {
             ReportLinkError("function import requires a callable", index,
                             module_name, import_name);
             return -1;
           }
 
           Handle<Code> import_wrapper = CompileImportWrapper(
               isolate_, index, module_->functions[import.index].sig,
               Handle<JSReceiver>::cast(value), module_name, import_name,
-              module_->origin);
+              module_->get_origin());
           if (import_wrapper.is_null()) {
             ReportLinkError(
                 "imported function does not match the expected type", index,
                 module_name, import_name);
             return -1;
           }
           code_table->set(num_imported_functions, *import_wrapper);
           RecordStats(isolate_, *import_wrapper);
           num_imported_functions++;
           break;
@@ skipping 213 matching lines @@
   void ProcessExports(Handle<FixedArray> code_table,
                       Handle<WasmInstanceObject> instance,
                       Handle<WasmCompiledModule> compiled_module) {
     if (NeedsWrappers()) {
       // Fill the table to cache the exported JSFunction wrappers.
       js_wrappers_.insert(js_wrappers_.begin(), module_->functions.size(),
                           Handle<JSFunction>::null());
     }
 
     Handle<JSObject> exports_object;
-    if (module_->origin == kWasmOrigin) {
+    if (module_->is_wasm()) {
       // Create the "exports" object.
       exports_object = isolate_->factory()->NewJSObjectWithNullProto();
-    } else if (module_->origin == kAsmJsOrigin) {
+    } else if (module_->is_asm_js()) {
       Handle<JSFunction> object_function = Handle<JSFunction>(
           isolate_->native_context()->object_function(), isolate_);
       exports_object = isolate_->factory()->NewJSObject(object_function);
     } else {
       UNREACHABLE();
     }
     Handle<String> exports_name =
         isolate_->factory()->InternalizeUtf8String("exports");
     JSObject::AddProperty(instance, exports_name, exports_object, NONE);
 
     Handle<String> foreign_init_name =
         isolate_->factory()->InternalizeUtf8String(
             wasm::AsmWasmBuilder::foreign_init_name);
     Handle<String> single_function_name =
         isolate_->factory()->InternalizeUtf8String(
             wasm::AsmWasmBuilder::single_function_name);
 
     PropertyDescriptor desc;
-    desc.set_writable(module_->origin == kAsmJsOrigin);
+    desc.set_writable(module_->is_asm_js());
     desc.set_enumerable(true);
 
     // Count up export indexes.
     int export_index = 0;
     for (auto exp : module_->export_table) {
       if (exp.kind == kExternalFunction) {
         ++export_index;
       }
     }
 
     // Store weak references to all exported functions.
     Handle<FixedArray> weak_exported_functions;
     if (compiled_module->has_weak_exported_functions()) {
       weak_exported_functions = compiled_module->weak_exported_functions();
     } else {
       weak_exported_functions =
           isolate_->factory()->NewFixedArray(export_index);
       compiled_module->set_weak_exported_functions(weak_exported_functions);
     }
     DCHECK_EQ(export_index, weak_exported_functions->length());
 
     // Process each export in the export table (go in reverse so asm.js
     // can skip duplicates).
     for (auto exp : base::Reversed(module_->export_table)) {
       Handle<String> name =
           WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
               isolate_, compiled_module_, exp.name_offset, exp.name_length)
               .ToHandleChecked();
       Handle<JSObject> export_to;
-      if (module_->origin == kAsmJsOrigin && exp.kind == kExternalFunction &&
+      if (module_->is_asm_js() && exp.kind == kExternalFunction &&
           (String::Equals(name, foreign_init_name) ||
            String::Equals(name, single_function_name))) {
         export_to = instance;
       } else {
         export_to = exports_object;
       }
 
       switch (exp.kind) {
         case kExternalFunction: {
           // Wrap and export the code as a JSFunction.
           WasmFunction& function = module_->functions[exp.index];
           int func_index =
               static_cast<int>(module_->functions.size() + --export_index);
           Handle<JSFunction> js_function = js_wrappers_[exp.index];
           if (js_function.is_null()) {
             // Wrap the exported code as a JSFunction.
             Handle<Code> export_code =
                 code_table->GetValueChecked<Code>(isolate_, func_index);
             MaybeHandle<String> func_name;
-            if (module_->origin == kAsmJsOrigin) {
+            if (module_->is_asm_js()) {
               // For modules arising from asm.js, honor the names section.
               func_name = WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
                               isolate_, compiled_module_, function.name_offset,
                               function.name_length)
                               .ToHandleChecked();
             }
             js_function = WasmExportedFunction::New(
                 isolate_, instance, func_name, function.func_index,
                 static_cast<int>(function.sig->parameter_count()), export_code);
             js_wrappers_[exp.index] = js_function;
@@ skipping 62 matching lines @@
           }
           desc.set_value(isolate_->factory()->NewNumber(num));
           break;
         }
         default:
           UNREACHABLE();
           break;
       }
 
       // Skip duplicates for asm.js.
-      if (module_->origin == kAsmJsOrigin) {
+      if (module_->is_asm_js()) {
         v8::Maybe<bool> status = JSReceiver::HasOwnProperty(export_to, name);
         if (status.FromMaybe(false)) {
           continue;
         }
       }
       v8::Maybe<bool> status = JSReceiver::DefineOwnProperty(
           isolate_, export_to, name, &desc, Object::THROW_ON_ERROR);
       if (!status.IsJust()) {
         thrower_->LinkError("export of %.*s failed.", name->length(),
                             name->ToCString().get());
         return;
       }
     }
 
-    if (module_->origin == kWasmOrigin) {
+    if (module_->is_wasm()) {
       v8::Maybe<bool> success = JSReceiver::SetIntegrityLevel(
           exports_object, FROZEN, Object::DONT_THROW);
       DCHECK(success.FromMaybe(false));
       USE(success);
     }
   }
 
   void InitializeTables(Handle<FixedArray> code_table,
                         Handle<WasmInstanceObject> instance,
                         CodeSpecialization* code_specialization) {
@@ skipping 114 matching lines @@
             if (js_wrappers_[func_index].is_null()) {
               // No JSFunction entry yet exists for this function. Create one.
               // TODO(titzer): We compile JS->WASM wrappers for functions are
               // not exported but are in an exported table. This should be done
               // at module compile time and cached instead.
 
               Handle<Code> wrapper_code =
                   js_to_wasm_cache_.CloneOrCompileJSToWasmWrapper(
                       isolate_, module_, wasm_code, func_index);
               MaybeHandle<String> func_name;
-              if (module_->origin == kAsmJsOrigin) {
+              if (module_->is_asm_js()) {
                 // For modules arising from asm.js, honor the names section.
                 func_name =
                     WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
                         isolate_, compiled_module_, function->name_offset,
                         function->name_length)
                         .ToHandleChecked();
               }
               Handle<WasmExportedFunction> js_function =
                   WasmExportedFunction::New(
                       isolate_, instance, func_name, func_index,
@@ skipping 950 matching lines @@
                                      callee_compiled->instruction_start());
     }
     DCHECK_EQ(non_compiled_functions.size(), idx);
   }
 
   Code* ret =
       Code::cast(compiled_module->code_table()->get(func_to_return_idx));
   DCHECK_EQ(Code::WASM_FUNCTION, ret->kind());
   return handle(ret, isolate);
 }