Subzero. Refactoring.

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
 /// \brief Implements the skeleton of the TargetLowering class.
 ///
 /// Specifically this invokes the appropriate lowering method for a given
 /// instruction kind and driving global register allocation. It also implements
 /// the non-deleted instruction iteration in LoweringContext.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceTargetLowering.h"
 
-#include "IceAssemblerARM32.h"
-#include "IceAssemblerMIPS32.h"
-#include "IceAssemblerX8632.h"
-#include "IceAssemblerX8664.h"
 #include "IceCfg.h" // setError()
 #include "IceCfgNode.h"
+#include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceInstVarIter.h"
 #include "IceOperand.h"
 #include "IceRegAlloc.h"
-#include "IceTargetLoweringARM32.h"
-#include "IceTargetLoweringMIPS32.h"
-#include "IceTargetLoweringX8632.h"
-#include "IceTargetLoweringX8664.h"
+
+// We prevent target-specific implementation details from leaking outside their
+// implementations by forbidding #include of target-specific header files
+// anywhere outside their own files. To create target-specific objects
+// (TargetLowering, TargetDataLowering, and TargetHeaderLowering) we use the
+// following named constructors. For reference, each target Foo needs to
+// implement the following named constructors and initializer:
+//
+// namespace Foo {
+//   unique_ptr<Ice::TargetLowering> createTargetLowering(Ice::Cfg *);
+//   unique_ptr<Ice::TargetDataLowering>
+//       createTargetDataLowering(Ice::GlobalContext*);
+//   unique_ptr<Ice::TargetHeaderLowering>
+//       createTargetHeaderLowering(Ice::GlobalContext *);
+//   void staticInit();
+// }
+#define SUBZERO_TARGET(X)                                                      \
+  namespace X {                                                                \
+  std::unique_ptr<::Ice::TargetLowering>                                       \
+  createTargetLowering(::Ice::Cfg *Func);                                      \
+  std::unique_ptr<::Ice::TargetDataLowering>                                   \
+  createTargetDataLowering(::Ice::GlobalContext *Ctx);                         \
+  std::unique_ptr<::Ice::TargetHeaderLowering>                                 \
+  createTargetHeaderLowering(::Ice::GlobalContext *Ctx);                       \
+  void staticInit();                                                           \
+  } // end of namespace X
+#include "llvm/Config/SZTargets.def"
+#undef SUBZERO_TARGET
 
 namespace Ice {
-
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
 }
 
 void LoweringContext::rewind() {
   Begin = getNode()->getInsts().begin();
   Cur = Begin;
@@ skipping 41 matching lines @@
   LastSrc = llvm::cast<Variable>(Instr->getSrc(0));
 }
 
 Variable *LoweringContext::availabilityGet(Operand *Src) const {
   assert(Src);
   if (Src == LastDest)
     return LastSrc;
   return nullptr;
 }
 
-TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
+std::unique_ptr<TargetLowering>
+TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
+  switch (Target) {
+  default:
+    llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
-  if (Target == Target_##X)                                                    \
-    return Target##X::create(Func);
+  case Target_##X:                                                             \
+    return ::X::createTargetLowering(Func);
 #include "llvm/Config/SZTargets.def"
-
-  Func->setError("Unsupported target");
-  return nullptr;
+#undef SUBZERO_TARGET
+  }
 }
 
 void TargetLowering::staticInit(TargetArch Target) {
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     llvm::report_fatal_error("Unsupported target");
-    break;
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
-    if (InitGuard##X)                                                          \
+    if (InitGuard##X) {                                                        \
       return;                                                                  \
+    }                                                                          \
     InitGuard##X = true;                                                       \
-    Target##X::staticInit();                                                   \
-  } break;
+    ::X::staticInit();                                                         \
+  }
 #include "llvm/Config/SZTargets.def"
+#undef SUBZERO_TARGET
   }
 }
 
 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"
-
-  Func->setError("Unsupported target assembler");
-  return nullptr;
-}
-
 void TargetLowering::genTargetHelperCalls() {
   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
     while (!Context.atEnd()) {
       PostIncrLoweringContext _(Context);
       genTargetHelperCallFor(Context.getCur());
     }
   }
 }
 
@@ skipping 381 matching lines @@
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   Str << getConstantPrefix();
   emitWithoutPrefix(C);
 }
 
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
+  switch (Target) {
+  default:
+    llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
-  if (Target == Target_##X)                                                    \
-    return TargetData##X::create(Ctx);
+  case Target_##X:                                                             \
+    return ::X::createTargetDataLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
-
-  llvm::report_fatal_error("Unsupported target data lowering");
+#undef SUBZERO_TARGET
+  }
 }
 
 TargetDataLowering::~TargetDataLowering() = default;
 
 namespace {
 
 // dataSectionSuffix decides whether to use SectionSuffix or MangledVarName as
 // data section suffix. Essentially, when using separate data sections for
 // globals SectionSuffix is not necessary.
 IceString dataSectionSuffix(const IceString &SectionSuffix,
@@ skipping 96 matching lines @@
     // to advance offsets.
     Str << "\t.zero\t" << Size << "\n";
   }
 
   Str << "\t.size\t" << MangledName << ", " << Size << "\n";
 }
 
 std::unique_ptr<TargetHeaderLowering>
 TargetHeaderLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
+  switch (Target) {
+  default:
+    llvm::report_fatal_error("Unsupported target");
 #define SUBZERO_TARGET(X)                                                      \
-  if (Target == Target_##X)                                                    \
-    return TargetHeader##X::create(Ctx);
+  case Target_##X:                                                             \
+    return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
-
-  llvm::report_fatal_error("Unsupported target header lowering");
+#undef SUBZERO_TARGET
+  }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice