Subzero: Allow Makefile.standalone to build for a single target.

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 "IceBitVector.h"
 #include "IceCfg.h" // setError()
 #include "IceCfgNode.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceInstVarIter.h"
 #include "IceOperand.h"
 #include "IceRegAlloc.h"
 
+#define TARGET_LOWERING_CLASS_FOR(t) Target_##t
+
 // 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(::Ice::GlobalContext *);
 // }
 #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(::Ice::GlobalContext *Ctx);                                  \
   } // end of namespace X
-#include "llvm/Config/SZTargets.def"
+#include "SZTargets.def"
 #undef SUBZERO_TARGET
 
 namespace Ice {
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
 }
 
@@ skipping 177 matching lines @@
     Str << "\n";
   }
 }
 
 std::unique_ptr<TargetLowering>
 TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
-  case Target_##X:                                                             \
+  case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetLowering(Func);
-#include "llvm/Config/SZTargets.def"
+#include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 void TargetLowering::staticInit(GlobalContext *Ctx) {
   const TargetArch Target = Ctx->getFlags().getTargetArch();
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
-  case Target_##X: {                                                           \
+  case TARGET_LOWERING_CLASS_FOR(X): {                                         \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
     ::X::staticInit(Ctx);                                                      \
   } break;
-#include "llvm/Config/SZTargets.def"
+#include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetLowering::SandboxType
 TargetLowering::determineSandboxTypeFromFlags(const ClFlags &Flags) {
   assert(!Flags.getUseSandboxing() || !Flags.getUseNonsfi());
   if (Flags.getUseNonsfi()) {
     return TargetLowering::ST_Nonsfi;
   }
@@ skipping 453 matching lines @@
   }
 }
 
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
-  case Target_##X:                                                             \
+  case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetDataLowering(Ctx);
-#include "llvm/Config/SZTargets.def"
+#include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetDataLowering::~TargetDataLowering() = default;
 
 namespace {
 
 // dataSectionSuffix decides whether to use SectionSuffix or VarName as data
 // section suffix. Essentially, when using separate data sections for globals
@@ skipping 108 matching lines @@
   Str << "\t.size\t" << Name << ", " << Size << "\n";
 }
 
 std::unique_ptr<TargetHeaderLowering>
 TargetHeaderLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
-  case Target_##X:                                                             \
+  case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetHeaderLowering(Ctx);
-#include "llvm/Config/SZTargets.def"
+#include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice