[wasm] Remove the use of the "external" bit on OldFunctions section.

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 "src/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 486 matching lines @@
     Isolate* isolate, std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
   // Create a placeholder code object for all functions.
   // TODO(ahaas): Maybe we could skip this for external functions.
   for (uint32_t i = 0; i < functions.size(); i++) {
     module_env.linker->GetFunctionCode(i);
   }
 
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
-    if (!functions[i].external) {
-      compilation_units[i] = compiler::CreateWasmCompilationUnit(
-          &thrower, isolate, &module_env, &functions[i], i);
-    } else {
-      compilation_units[i] = nullptr;
-    }
+    compilation_units[i] = compiler::CreateWasmCompilationUnit(
+        &thrower, isolate, &module_env, &functions[i], i);
   }
 }
 
 uint32_t* StartCompilationTasks(
     Isolate* isolate,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     std::queue<compiler::WasmCompilationUnit*>& executed_units,
     const base::SmartPointer<base::Semaphore>& pending_tasks,
     base::Mutex& result_mutex, base::AtomicNumber<size_t>& next_unit) {
   const size_t num_tasks =
@@ skipping 34 matching lines @@
     compiler::WasmCompilationUnit* unit = nullptr;
     {
       base::LockGuard<base::Mutex> guard(&result_mutex);
       if (executed_units.empty()) {
         break;
       }
       unit = executed_units.front();
       executed_units.pop();
     }
     int j = compiler::GetIndexOfWasmCompilationUnit(unit);
-    if (!module->functions[j].external) {
-      results[j] = compiler::FinishCompilation(unit);
-    }
+    results[j] = compiler::FinishCompilation(unit);
   }
 }
 
 bool FinishCompilation(Isolate* isolate, WasmModule* module,
                        const Handle<JSReceiver> ffi,
                        const std::vector<Handle<Code>>& results,
                        const WasmModuleInstance& instance,
                        const Handle<FixedArray>& code_table,
                        ErrorThrower& thrower, Factory* factory,
                        ModuleEnv& module_env, uint32_t& total_code_size,
                        PropertyDescriptor& desc) {
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
        i < module->functions.size(); i++) {
     const WasmFunction& func = module->functions[i];
     if (thrower.error()) break;
 
     DCHECK_EQ(i, func.func_index);
     WasmName str = module->GetName(func.name_offset, func.name_length);
-    WasmName str_null = {nullptr, 0};
     Handle<Code> code = Handle<Code>::null();
     Handle<JSFunction> function = Handle<JSFunction>::null();
     Handle<String> function_name = Handle<String>::null();
-    if (func.external) {
-      // Lookup external function in FFI object.
-      MaybeHandle<JSFunction> function =
-          LookupFunction(thrower, factory, ffi, i, str, str_null);
-      if (function.is_null()) {
-        return false;
-      }
-      code = compiler::CompileWasmToJSWrapper(isolate, &module_env,
-                                              function.ToHandleChecked(),
-                                              func.sig, str, str_null);
+    if (FLAG_wasm_num_compilation_tasks != 0) {
+      code = results[i];
     } else {
-      if (FLAG_wasm_num_compilation_tasks != 0) {
-        code = results[i];
-      } else {
-        // Compile the function.
-        code = compiler::CompileWasmFunction(&thrower, isolate, &module_env,
-                                             &func);
-      }
-      if (code.is_null()) {
-        thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
-                      str.start());
-        return false;
-      }
-      if (func.exported) {
-        function_name = factory->InternalizeUtf8String(str);
-        function = compiler::CompileJSToWasmWrapper(
-            isolate, &module_env, function_name, code, instance.js_object, i);
-        record_code_size(total_code_size, function->code());
-      }
+      // Compile the function.
+      code =
+          compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
+    }
+    if (code.is_null()) {
+      thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
+                    str.start());
+      return false;
+    }
+    if (func.exported) {
+      function_name = factory->InternalizeUtf8String(str);
+      function = compiler::CompileJSToWasmWrapper(
+          isolate, &module_env, function_name, code, instance.js_object, i);
+      record_code_size(total_code_size, function->code());
     }
     if (!code.is_null()) {
       // Install the code into the linker table.
       module_env.linker->Finish(i, code);
       code_table->set(i, *code);
       record_code_size(total_code_size, *code);
     }
     if (func.exported) {
       // Exported functions are installed as read-only properties on the
       // module.
@@ skipping 316 matching lines @@
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = module->origin;
 
   // Compile all functions.
   Handle<Code> main_code = Handle<Code>::null();  // record last code.
   uint32_t index = 0;
   int main_index = 0;
   for (const WasmFunction& func : module->functions) {
     DCHECK_EQ(index, func.func_index);
-    if (!func.external) {
-      // Compile the function and install it in the code table.
-      Handle<Code> code =
-          compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
-      if (!code.is_null()) {
-        if (func.exported) {
-          main_code = code;
-          main_index = index;
-        }
-        linker.Finish(index, code);
+    // Compile the function and install it in the code table.
+    Handle<Code> code =
+        compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
+    if (!code.is_null()) {
+      if (func.exported) {
+        main_code = code;
+        main_index = index;
       }
-      if (thrower.error()) return -1;
+      linker.Finish(index, code);
     }
+    if (thrower.error()) return -1;
     index++;
   }
 
   if (main_code.is_null()) {
     thrower.Error("WASM.compileRun() failed: no main code found");
     return -1;
   }
 
   linker.Link(instance.function_table, instance.module->function_table);
 
@@ skipping 29 matching lines @@
       wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
   if (func_names_arr_obj->IsUndefined())
     return func_names_arr_obj;  // Return undefined.
   return GetWasmFunctionNameFromTable(
       Handle<ByteArray>::cast(func_names_arr_obj), func_index);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8