[X86] Initialize FMA3Info directly in its constructor instead of relying on std::call_once

[craig.topper]

Summary

FMA3Info only exists as a managed static. As far as I know the ManagedStatic construction proccess is thread safe. It doesn't look like we ever access the ManagedStatic object without immediately doing a query on it that would require the map to be populated. So I don't think we're ever deferring the calculation of the tables from the construction of the object.

So I think we should be able to just populate the FMA3Info map directly in the constructor and get rid of all of the initGroupsOnce stuff.

[craig.topper]

Rebase after r334925 which changes how the DenseMap is initialized and deleted.

[RKSimon]

LGTM

llvm/trunk/lib/Target/X86/X86InstrFMA3Info.h

 /// This class provides information about all existing FMA3 opcodes
 ///
 class X86InstrFMA3Info final {
 private:
   /// A map that is used to find the group of FMA opcodes using any FMA opcode
   /// from the group.
   DenseMap<unsigned, const X86InstrFMA3Group *> OpcodeToGroup;
 
-  /// Creates groups of FMA opcodes and initializes Opcode-to-Group map.
-  /// This method can be called many times, but the actual initialization is
-  /// called only once.
-  static void initGroupsOnce();
-
-  /// Creates groups of FMA opcodes and initializes Opcode-to-Group map.
-  /// This method must be called ONLY from initGroupsOnce(). Otherwise, such
-  /// call is not thread safe.
-  void initGroupsOnceImpl();
-
 public:
   /// Returns the reference to an object of this class. It is assumed that
   /// only one object may exist.
   static X86InstrFMA3Info *getX86InstrFMA3Info();
 
   /// Constructor. Just creates an object of the class.
-  X86InstrFMA3Info() = default;
+  X86InstrFMA3Info();
 
   /// Returns a reference to a group of FMA3 opcodes to where the given
   /// \p Opcode is included. If the given \p Opcode is not recognized as FMA3
   /// and not included into any FMA3 group, then nullptr is returned.
   static const X86InstrFMA3Group *getFMA3Group(unsigned Opcode) {
-    // Ensure that the groups of opcodes are initialized.
-    initGroupsOnce();
-
     // Find the group including the given opcode.
     const X86InstrFMA3Info *FMA3Info = getX86InstrFMA3Info();
     auto I = FMA3Info->OpcodeToGroup.find(Opcode);
     if (I == FMA3Info->OpcodeToGroup.end())
       return nullptr;
 
     return I->second;
   }
 
   /// Returns true iff the given \p Opcode is recognized as FMA3 by this class.
   static bool isFMA3(unsigned Opcode) {
     return getFMA3Group(Opcode) != nullptr;
   }
-
-  /// Iterator that is used to walk on FMA register opcodes having memory
-  /// form equivalents.
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_X86_UTILS_X86INSTRFMA3INFO_H

llvm/trunk/lib/Target/X86/X86InstrFMA3Info.cpp

 #include "X86InstrInfo.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
-/// This flag is used in the method llvm::call_once() used below to make the
-/// initialization of the map 'OpcodeToGroup' thread safe.
-static llvm::once_flag InitGroupsOnceFlag;
-
 static ManagedStatic<X86InstrFMA3Info> X86InstrFMA3InfoObj;
 X86InstrFMA3Info *X86InstrFMA3Info::getX86InstrFMA3Info() {
   return &*X86InstrFMA3InfoObj;
 }
 
 #define FMA3BASE(R132, R213, R231, M132, M213, M231, Attrs)                    \
   { { R132, R213, R231 }, { M132, M213, M231 }, Attrs },
 
static const X86InstrFMA3Group Groups[] = {
   FMA3_AVX512_FULL_GROUP(VFMSUB)
   FMA3_AVX512_FULL_GROUP(VFNMADD)
   FMA3_AVX512_FULL_GROUP(VFNMSUB)
 
   FMA3_AVX512_VECTOR_GROUP(VFMADDSUB)
   FMA3_AVX512_VECTOR_GROUP(VFMSUBADD)
 };
 
-void X86InstrFMA3Info::initGroupsOnceImpl() {
+X86InstrFMA3Info::X86InstrFMA3Info() {
   for (const X86InstrFMA3Group &G : Groups) {
     if (G.RegOpcodes[0])
       OpcodeToGroup[G.RegOpcodes[0]] = &G;
     if (G.RegOpcodes[1])
       OpcodeToGroup[G.RegOpcodes[1]] = &G;
     if (G.RegOpcodes[2])
       OpcodeToGroup[G.RegOpcodes[2]] = &G;
     if (G.MemOpcodes[0])
       OpcodeToGroup[G.MemOpcodes[0]] = &G;
     if (G.MemOpcodes[1])
       OpcodeToGroup[G.MemOpcodes[1]] = &G;
     if (G.MemOpcodes[2])
       OpcodeToGroup[G.MemOpcodes[2]] = &G;
   }
 }
-
-void X86InstrFMA3Info::initGroupsOnce() {
-  llvm::call_once(InitGroupsOnceFlag,
-                  []() { getX86InstrFMA3Info()->initGroupsOnceImpl(); });
-}