Subzero: Refactor some common TargetLowering initializations.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 87 matching lines @@
 TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return Target##X::create(Func);
 #include "llvm/Config/SZTargets.def"
 
   Func->setError("Unsupported target");
   return nullptr;
 }
 
+void TargetLowering::staticInit(TargetArch Target) {
+  static bool InitGuard = false;

[John, 2015/11/04 21:35:23]

Not that this matter, but if in the future we allow multiple targets to be
loaded at the same time, this will prevent all but the first target to
initialize.

why not invoking staticInit() on everything, and letting SZTargets.def handle
things a bit?

[Jim Stichnoth, 2015/11/04 23:51:39]

I did something like that originally, by duplicating the init guard stuff across
all the target source files, decided I didn't like the duplication, and
refactored it here.

But you're right, that does unnecessarily constrain the number of active targets
during a run.

Done.

+  if (InitGuard)
+    return;
+  InitGuard = true;
+
+  // Call the specified target's static initializer.
+  switch (Target) {
+  default:
+    llvm::report_fatal_error("Unsupported target");
+    break;
+#define SUBZERO_TARGET(X)                                                      \
+  case Target_##X:                                                             \
+    Target##X::staticInit();                                                   \
+    break;
+#include "llvm/Config/SZTargets.def"
+  }
+}
+
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), Context() {}
 
 std::unique_ptr<Assembler> TargetLowering::createAssembler(TargetArch Target,
                                                            Cfg *Func) {
 #define SUBZERO_TARGET(X)                                                      \
   if (Target == Target_##X)                                                    \
     return std::unique_ptr<Assembler>(new X::Assembler##X());
 #include "llvm/Config/SZTargets.def"
 
@@ skipping 507 matching lines @@
   if (Target == Target_##X)                                                    \
     return TargetHeader##X::create(Ctx);
 #include "llvm/Config/SZTargets.def"
 
   llvm::report_fatal_error("Unsupported target header lowering");
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice