Subzero: Set the correct target arch in the browser hookup.

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 136 matching lines @@
   size_t Pos = RegName.find(Separator);
   if (Pos == std::string::npos) {
     *SplitRegClass = "";
     *SplitRegName = RegName;
   } else {
     *SplitRegClass = RegName.substr(0, Pos);
     *SplitRegName = RegName.substr(Pos + SeparatorWidth);
   }
 }
 
+LLVM_ATTRIBUTE_NORETURN void badTargetFatalError(TargetArch Target) {
+  llvm::report_fatal_error("Unsupported target: " +
+                           std::string(targetArchString(Target)));
+}
+
 } // end of anonymous namespace
 
 void TargetLowering::filterTypeToRegisterSet(
     GlobalContext *Ctx, int32_t NumRegs,
     llvm::SmallBitVector TypeToRegisterSet[], size_t TypeToRegisterSetSize,
     std::function<IceString(RegNumT)> getRegName,
     std::function<IceString(RegClass)> getRegClassName) {
   std::vector<llvm::SmallBitVector> UseSet(TypeToRegisterSetSize,
                                            llvm::SmallBitVector(NumRegs));
   std::vector<llvm::SmallBitVector> ExcludeSet(TypeToRegisterSetSize,
@@ skipping 69 matching lines @@
                        IndentTwice);
     }
     Str << "\n";
   }
 }
 
 std::unique_ptr<TargetLowering>
 TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
   switch (Target) {
   default:
-    llvm::report_fatal_error("Unsupported target");
+    badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetLowering(Func);
 #include "llvm/Config/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:
-    llvm::report_fatal_error("Unsupported target");
+    badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
     ::X::staticInit(Ctx);                                                      \
   } break;
 #include "llvm/Config/SZTargets.def"
@@ skipping 464 matching lines @@
       Str << "+";
     Str << Offset;
   }
 }
 
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
   switch (Target) {
   default:
-    llvm::report_fatal_error("Unsupported target");
+    badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetDataLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetDataLowering::~TargetDataLowering() = default;
 
@@ skipping 111 matching lines @@
   }
 
   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");
+    badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice