[wasm] Use a LazyInstance in wasm-linkage.cc to avoid a data race.

src/compiler/wasm-linkage.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/assembler.h"
+#include "src/base/lazy-instance.h"
 #include "src/macro-assembler.h"
 #include "src/register-configuration.h"
 
 #include "src/wasm/wasm-module.h"
 
 #include "src/compiler/linkage.h"
 
 #include "src/zone.h"
 
 namespace v8 {
@@ skipping 183 matching lines @@
   }
   int Words(LocalType type) {
     if (kPointerSize < 8 && (type == kAstI64 || type == kAstF64)) {
       return 2;
     }
     return 1;
   }
 };
 }  // namespace
 
-static Allocator GetReturnRegisters() {
+struct ParameterRegistersCreateTrait {
+  static void Construct(Allocator* allocated_ptr) {
+#ifdef GP_PARAM_REGISTERS
+    static const Register kGPParamRegisters[] = {GP_PARAM_REGISTERS};
+    static const int kGPParamRegistersCount =
+        static_cast<int>(arraysize(kGPParamRegisters));
+#else
+    static const Register* kGPParamRegisters = nullptr;
+    static const int kGPParamRegistersCount = 0;
+#endif
+
+#ifdef FP_PARAM_REGISTERS
+    static const DoubleRegister kFPParamRegisters[] = {FP_PARAM_REGISTERS};
+    static const int kFPParamRegistersCount =
+        static_cast<int>(arraysize(kFPParamRegisters));
+#else
+    static const DoubleRegister* kFPParamRegisters = nullptr;
+    static const int kFPParamRegistersCount = 0;
+#endif
+
+    new (allocated_ptr) Allocator(kGPParamRegisters, kGPParamRegistersCount,
+                                  kFPParamRegisters, kFPParamRegistersCount);
+  }
+};
+
+static base::LazyInstance<Allocator, ParameterRegistersCreateTrait>::type
+    parameter_registers = LAZY_INSTANCE_INITIALIZER;
+
+struct ReturnRegistersCreateTrait {
+  static void Construct(Allocator* allocated_ptr) {
 #ifdef GP_RETURN_REGISTERS
-  static const Register kGPReturnRegisters[] = {GP_RETURN_REGISTERS};
-  static const int kGPReturnRegistersCount =
-      static_cast<int>(arraysize(kGPReturnRegisters));
+    static const Register kGPReturnRegisters[] = {GP_RETURN_REGISTERS};
+    static const int kGPReturnRegistersCount =
+        static_cast<int>(arraysize(kGPReturnRegisters));
 #else
-  static const Register* kGPReturnRegisters = nullptr;
-  static const int kGPReturnRegistersCount = 0;
+    static const Register* kGPReturnRegisters = nullptr;
+    static const int kGPReturnRegistersCount = 0;
 #endif
 
 #ifdef FP_RETURN_REGISTERS
-  static const DoubleRegister kFPReturnRegisters[] = {FP_RETURN_REGISTERS};
-  static const int kFPReturnRegistersCount =
-      static_cast<int>(arraysize(kFPReturnRegisters));
+    static const DoubleRegister kFPReturnRegisters[] = {FP_RETURN_REGISTERS};
+    static const int kFPReturnRegistersCount =
+        static_cast<int>(arraysize(kFPReturnRegisters));
 #else
-  static const DoubleRegister* kFPReturnRegisters = nullptr;
-  static const int kFPReturnRegistersCount = 0;
+    static const DoubleRegister* kFPReturnRegisters = nullptr;
+    static const int kFPReturnRegistersCount = 0;
 #endif
 
-  Allocator rets(kGPReturnRegisters, kGPReturnRegistersCount,
-                 kFPReturnRegisters, kFPReturnRegistersCount);
+    new (allocated_ptr) Allocator(kGPReturnRegisters, kGPReturnRegistersCount,
+                                  kFPReturnRegisters, kFPReturnRegistersCount);
+  }
+};
 
-  return rets;
-}
-
-static Allocator GetParameterRegisters() {
-#ifdef GP_PARAM_REGISTERS
-  static const Register kGPParamRegisters[] = {GP_PARAM_REGISTERS};
-  static const int kGPParamRegistersCount =
-      static_cast<int>(arraysize(kGPParamRegisters));
-#else
-  static const Register* kGPParamRegisters = nullptr;
-  static const int kGPParamRegistersCount = 0;
-#endif
-
-#ifdef FP_PARAM_REGISTERS
-  static const DoubleRegister kFPParamRegisters[] = {FP_PARAM_REGISTERS};
-  static const int kFPParamRegistersCount =
-      static_cast<int>(arraysize(kFPParamRegisters));
-#else
-  static const DoubleRegister* kFPParamRegisters = nullptr;
-  static const int kFPParamRegistersCount = 0;
-#endif
-
-  Allocator params(kGPParamRegisters, kGPParamRegistersCount, kFPParamRegisters,
-                   kFPParamRegistersCount);
-
-  return params;
-}
+static base::LazyInstance<Allocator, ReturnRegistersCreateTrait>::type
+    return_registers = LAZY_INSTANCE_INITIALIZER;
 
 // General code uses the above configuration data.
 CallDescriptor* ModuleEnv::GetWasmCallDescriptor(Zone* zone,
                                                  FunctionSig* fsig) {
   LocationSignature::Builder locations(zone, fsig->return_count(),
                                        fsig->parameter_count());
 
-  Allocator rets = GetReturnRegisters();
+  Allocator rets = return_registers.Get();
 
   // Add return location(s).
   const int return_count = static_cast<int>(locations.return_count_);
   for (int i = 0; i < return_count; i++) {
     LocalType ret = fsig->GetReturn(i);
     locations.AddReturn(rets.Next(ret));
   }
 
-  Allocator params = GetParameterRegisters();
+  Allocator params = parameter_registers.Get();
 
   // Add register and/or stack parameter(s).
   const int parameter_count = static_cast<int>(fsig->parameter_count());
   for (int i = 0; i < parameter_count; i++) {
     LocalType param = fsig->GetParam(i);
     locations.AddParam(params.Next(param));
   }
 
   const RegList kCalleeSaveRegisters = 0;
   const RegList kCalleeSaveFPRegisters = 0;
@@ skipping 33 matching lines @@
   }
   if (parameter_count == descriptor->ParameterCount() &&
       return_count == descriptor->ReturnCount()) {
     // If there is no int64 parameter or return value, we can just return the
     // original descriptor.
     return descriptor;
   }
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
 
-  Allocator rets = GetReturnRegisters();
+  Allocator rets = return_registers.Get();
 
   for (size_t i = 0; i < descriptor->ReturnCount(); i++) {
     if (descriptor->GetReturnType(i) == MachineType::Int64()) {
       // For each int64 return we get two int32 returns.
       locations.AddReturn(rets.Next(MachineRepresentation::kWord32));
       locations.AddReturn(rets.Next(MachineRepresentation::kWord32));
     } else {
       locations.AddReturn(
           rets.Next(descriptor->GetReturnType(i).representation()));
     }
   }
 
-  Allocator params = GetParameterRegisters();
+  Allocator params = parameter_registers.Get();
 
   for (size_t i = 0; i < descriptor->ParameterCount(); i++) {
     if (descriptor->GetParameterType(i) == MachineType::Int64()) {
       // For each int64 input we get two int32 inputs.
       locations.AddParam(params.Next(MachineRepresentation::kWord32));
       locations.AddParam(params.Next(MachineRepresentation::kWord32));
     } else {
       locations.AddParam(
           params.Next(descriptor->GetParameterType(i).representation()));
     }
@@ skipping 10 matching lines @@
       descriptor->CalleeSavedFPRegisters(),  // callee-saved fp regs
       descriptor->flags(),                   // flags
       descriptor->debug_name());
 
   return descriptor;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8