[wasm] Add UTF-8 validation

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 568 matching lines @@
                        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<String> name = factory->InternalizeUtf8String(str);
     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);
     } 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, name, code, instance.js_object, i);
+            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.
       desc.set_value(function);
       Maybe<bool> status = JSReceiver::DefineOwnProperty(
-          isolate, instance.js_object, name, &desc, Object::THROW_ON_ERROR);
+          isolate, instance.js_object, function_name, &desc,
+          Object::THROW_ON_ERROR);
       if (!status.IsJust())
         thrower.Error("export of %.*s failed.", str.length(), str.start());
     }
   }
   return true;
 }
 }  // namespace
 
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
@@ skipping 364 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