Add a basic TargetARM32 skeleton which knows nothing.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the skeleton of the TargetLowering class,
 // specifically invoking 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 "assembler_arm32.h"
 #include "assembler_ia32.h"
 #include "IceCfg.h" // setError()
 #include "IceCfgNode.h"
 #include "IceOperand.h"
 #include "IceRegAlloc.h"
 #include "IceTargetLowering.h"
+#include "IceTargetLoweringARM32.h"
 #include "IceTargetLoweringX8632.h"
 
 namespace Ice {
 
 void LoweringContext::init(CfgNode *N) {
   Node = N;
   End = getNode()->getInsts().end();
   rewind();
   advanceForward(Next);
 }
@@ skipping 21 matching lines @@
     skipDeleted(I);
   }
 }
 
 Inst *LoweringContext::getLastInserted() const {
   assert(LastInserted);
   return LastInserted;
 }
 
 TargetLowering *TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
-  // These statements can be #ifdef'd to specialize the code generator
-  // to a subset of the available targets.  TODO: use CRTP.
-  if (Target == Target_X8632)
-    return TargetX8632::create(Func);
-#if 0
-  if (Target == Target_X8664)
-    return IceTargetX8664::create(Func);
-  if (Target == Target_ARM32)
-    return IceTargetARM32::create(Func);
-  if (Target == Target_ARM64)
-    return IceTargetARM64::create(Func);
-#endif
+#define SUBZERO_TARGET(X)                                                      \
+  if (Target == Target_##X)                                                    \
+    return Target##X::create(Func);
+#include "llvm/Config/SZTargets.def"
+
   Func->setError("Unsupported target");
   return nullptr;
 }
 
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()), HasComputedFrame(false),
-      CallsReturnsTwice(false), StackAdjustment(0), Context(),
-      SnapshotStackAdjustment(0) {}
+      CallsReturnsTwice(false), StackAdjustment(0), NextLabelNumber(0),
+      Context(), SnapshotStackAdjustment(0) {}
 
 std::unique_ptr<Assembler> TargetLowering::createAssembler(TargetArch Target,
                                                            Cfg *Func) {
   // These statements can be #ifdef'd to specialize the assembler
   // to a subset of the available targets.  TODO: use CRTP.
+  // TODO(jvoung): use SZTargets.def (rename AssemblerX86 -> AssemblerX8632),
+  // and make the namespaces consistent.
   if (Target == Target_X8632)
     return std::unique_ptr<Assembler>(new x86::AssemblerX86());
-  Func->setError("Unsupported target");
+
+  if (Target == Target_ARM32)
+    return std::unique_ptr<Assembler>(new AssemblerARM32());
+
+  Func->setError("Unsupported target assembler");
   return nullptr;
 }
 
 void TargetLowering::doAddressOpt() {
   if (llvm::isa<InstLoad>(*Context.getCur()))
     doAddressOptLoad();
   else if (llvm::isa<InstStore>(*Context.getCur()))
     doAddressOptStore();
   Context.advanceCur();
   Context.advanceNext();
@@ skipping 119 matching lines @@
   RegSetMask RegExclude = RegSet_None;
   RegInclude |= RegSet_CallerSave;
   RegInclude |= RegSet_CalleeSave;
   if (hasFramePointer())
     RegExclude |= RegSet_FramePointer;
   LinearScan.init(Kind);
   llvm::SmallBitVector RegMask = getRegisterSet(RegInclude, RegExclude);
   LinearScan.scan(RegMask, Ctx->getFlags().shouldRandomizeRegAlloc());
 }
 
+InstCall *TargetLowering::makeHelperCall(const IceString &Name, Variable *Dest,
+                                         SizeT MaxSrcs) {
+  const bool HasTailCall = false;
+  Constant *CallTarget = Ctx->getConstantExternSym(Name);
+  InstCall *Call =
+      InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
+  return Call;
+}
+
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
-  // These statements can be #ifdef'd to specialize the code generator
-  // to a subset of the available targets.  TODO: use CRTP.
   TargetArch Target = Ctx->getFlags().getTargetArch();
-  if (Target == Target_X8632)
-    return std::unique_ptr<TargetDataLowering>(TargetDataX8632::create(Ctx));
-#if 0
-  if (Target == Target_X8664)
-    return std::unique_ptr<TargetDataLowering>(TargetDataX8664::create(Ctx));
-  if (Target == Target_ARM32)
-    return std::unique_ptr<TargetDataLowering>(TargetDataARM32::create(Ctx));
-  if (Target == Target_ARM64)
-    return std::unique_ptr<TargetDataLowering>(TargetDataARM64::create(Ctx));
-#endif
-  llvm_unreachable("Unsupported target");
+#define SUBZERO_TARGET(X)                                                      \
+  if (Target == Target_##X)                                                    \
+    return std::unique_ptr<TargetDataLowering>(TargetData##X::create(Ctx));
+#include "llvm/Config/SZTargets.def"
+
+  llvm_unreachable("Unsupported target data lowering");
   return nullptr;
 }
 
 TargetDataLowering::~TargetDataLowering() {}
 
 } // end of namespace Ice