Subzero: Use -filetype instead of -ias and -elf-writer.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 140 matching lines @@
   AllThreadContexts.push_back(MyTLS);
   ICE_TLS_SET_FIELD(TLS, MyTLS);
   // Pre-register built-in stack names.
   if (ALLOW_DUMP) {
     // TODO(stichnot): There needs to be a strong relationship between
     // the newTimerStackID() return values and TSK_Default/TSK_Funcs.
     newTimerStackID("Total across all functions");
     newTimerStackID("Per-function summary");
   }
   Timers.initInto(MyTLS->Timers);
-  if (Flags.getUseELFWriter()) {
+  switch (Flags.getOutFileType()) {
+  case FT_Elf:
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
+    break;
+  case FT_Asm:
+  case FT_Iasm:
+    break;
   }
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
@@ skipping 13 matching lines @@
       continue; // Func goes out of scope and gets deleted
     }
     Func->translate();
     EmitterWorkItem *Item = nullptr;
     if (Func->hasError()) {
       getErrorStatus()->assign(EC_Translation);
       OstreamLocker L(this);
       getStrDump() << "ICE translation error: " << Func->getError() << "\n";
       Item = new EmitterWorkItem(Func->getSequenceNumber());
     } else {
-      if (getFlags().getUseIntegratedAssembler()) {
+      switch (getFlags().getOutFileType()) {
+      case FT_Elf:
+      case FT_Iasm: {
         Func->emitIAS();
         // The Cfg has already emitted into the assembly buffer, so
         // stats have been fully collected into this thread's TLS.
         // Dump them before TLS is reset for the next Cfg.
         dumpStats(Func->getFunctionName());
         Assembler *Asm = Func->releaseAssembler();
         // Copy relevant fields into Asm before Func is deleted.
         Asm->setFunctionName(Func->getFunctionName());
         Asm->setInternal(Func->getInternal());
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Asm);
-      } else {
+      } break;
+      case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
+        break;
       }
     }
     Cfg::setCurrentCfg(nullptr);
     assert(Item);
     emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
@@ skipping 55 matching lines @@
     case EmitterWorkItem::WI_Nop:
       break;
     case EmitterWorkItem::WI_GlobalInits: {
       lowerGlobals(this, Item->getGlobalInits(),
                    TargetDataLowering::createLowering(this).get());
     } break;
     case EmitterWorkItem::WI_Asm: {
       std::unique_ptr<Assembler> Asm = Item->getAsm();
       Asm->alignFunction();
       IceString MangledName = mangleName(Asm->getFunctionName());
-      if (getFlags().getUseELFWriter()) {
+      switch (getFlags().getOutFileType()) {
+      case FT_Elf:
         getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
                                              Asm.get());
-      } else {
+        break;
+      case FT_Iasm: {
         OstreamLocker L(this);
         Cfg::emitTextHeader(MangledName, this, Asm.get());
         Asm->emitIASBytes(this);
+      } break;
+      case FT_Asm:
+        llvm::report_fatal_error("Unexpected FT_Asm");
+        break;
       }
     } break;
     case EmitterWorkItem::WI_Cfg: {
       if (!ALLOW_DUMP)
         llvm::report_fatal_error("WI_Cfg work item created inappropriately");
-      assert(!getFlags().getUseIntegratedAssembler());
+      assert(getFlags().getOutFileType() == FT_Asm);
       std::unique_ptr<Cfg> Func = Item->getCfg();
       // Unfortunately, we have to temporarily install the Cfg in TLS
       // because Variable::asType() uses the allocator to create the
       // differently-typed copy.
       Cfg::setCurrentCfg(Func.get());
       Func->emit();
       Cfg::setCurrentCfg(nullptr);
       dumpStats(Func->getFunctionName());
     } break;
     }
@@ skipping 416 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice