Subzero: Add basic ELFObjectWriter (text section, symtab, strtab, headers)

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver that uses LLVM capabilities to parse a
 // bitcode file and build the LLVM IR, and then convert the LLVM basic
 // blocks, instructions, and operands into their Subzero equivalents.
 //
 //===----------------------------------------------------------------------===//
 
 #include <fstream>
 #include <iostream>
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/SourceMgr.h"
 
 #include "IceCfg.h"
 #include "IceClFlags.h"
 #include "IceConverter.h"
 #include "PNaClTranslator.h"
 
 using namespace llvm;
 
@@ skipping 133 matching lines @@
                 cl::init(true));
 
 static cl::opt<bool>
     UseIntegratedAssembler("integrated-as",
                            cl::desc("Use integrated assembler (default yes)"),
                            cl::init(true));
 
 static cl::alias UseIas("ias", cl::desc("Alias for -integrated-as"),
                         cl::NotHidden, cl::aliasopt(UseIntegratedAssembler));
 
+static cl::opt<bool>
+    UseELFWriter("elf-writer",
+                 cl::desc("Use ELF writer with the integrated assembler"),
+                 cl::init(false));
+
 static cl::opt<bool> AlwaysExitSuccess(
     "exit-success", cl::desc("Exit with success status, even if errors found"),
     cl::init(false));
 
 static cl::opt<bool>
 GenerateBuildAtts("build-atts",
                   cl::desc("Generate list of build attributes associated with "
                            "this executable."),
                   cl::init(false));
 
 static int GetReturnValue(int Val) {
   if (AlwaysExitSuccess)
     return 0;
   return Val;
 }
 
 static struct {
   const char *FlagName;
   int FlagValue;
 } ConditionalBuildAttributes[] = {{"dump", ALLOW_DUMP},
                                   {"llvm_cl", ALLOW_LLVM_CL},
                                   {"llvm_ir", ALLOW_LLVM_IR},
                                   {"llvm_ir_as_input", ALLOW_LLVM_IR_AS_INPUT},
                                   {"disable_ir_gen", ALLOW_DISABLE_IR_GEN}};
 
 // Validates values of build attributes. Prints them to Stream if
 // Stream is non-null.
-static void ValidateAndGenerateBuildAttributes(raw_os_ostream *Stream) {
+static void ValidateAndGenerateBuildAttributes(Ice::Ostream *Stream) {
 
   if (Stream)
     *Stream << TargetArch << "\n";
 
   for (size_t i = 0; i < array_lengthof(ConditionalBuildAttributes); ++i) {
     switch (ConditionalBuildAttributes[i].FlagValue) {
     case 0:
       if (Stream)
         *Stream << "no_" << ConditionalBuildAttributes[i].FlagName << "\n";
       break;
@@ skipping 21 matching lines @@
     DisableTranslation = true;
 
   Ice::VerboseMask VMask = Ice::IceV_None;
   // Don't generate verbose messages if routines
   // to dump messages are not available.
   if (ALLOW_DUMP) {
     for (unsigned i = 0; i != VerboseList.size(); ++i)
       VMask |= VerboseList[i];
   }
 
-  std::ofstream Ofs;
-  if (OutputFilename != "-") {
-    Ofs.open(OutputFilename.c_str(), std::ofstream::out);
+  std::ofstream Lfs;
+  std::unique_ptr<Ice::Ostream> Ls;
+  if (LogFilename != "-") {
+    Lfs.open(LogFilename.c_str(), std::ofstream::out);
+    Ls.reset(new raw_os_ostream(Lfs));
+  } else {
+    Ls.reset(new raw_os_ostream(std::cout));
   }
-  raw_os_ostream *Os =
-      new raw_os_ostream(OutputFilename == "-" ? std::cout : Ofs);
-  Os->SetUnbuffered();
+  Ls->SetUnbuffered();
 
-  ValidateAndGenerateBuildAttributes(GenerateBuildAtts ? Os : nullptr);
+  ValidateAndGenerateBuildAttributes(GenerateBuildAtts ? Ls.get() : nullptr);
   if (GenerateBuildAtts)
     return GetReturnValue(0);
 
-  std::ofstream Lfs;
-  if (LogFilename != "-") {
-    Lfs.open(LogFilename.c_str(), std::ofstream::out);
-  }
-  raw_os_ostream *Ls = new raw_os_ostream(LogFilename == "-" ? std::cout : Lfs);
-  Ls->SetUnbuffered();
-
   if (!ALLOW_DISABLE_IR_GEN && DisableIRGeneration) {
     *Ls << "Error: Build doesn't allow --no-ir-gen when not "
         << "ALLOW_DISABLE_IR_GEN!\n";
     return GetReturnValue(1);
   }
 
   Ice::ClFlags Flags;
   Flags.DisableInternal = DisableInternal;
   Flags.SubzeroTimingEnabled = SubzeroTimingEnabled;
   Flags.DisableTranslation = DisableTranslation;
   Flags.FunctionSections = FunctionSections;
   Flags.DataSections = DataSections;
   Flags.UseIntegratedAssembler = UseIntegratedAssembler;
+  Flags.UseELFWriter = UseELFWriter;
   Flags.UseSandboxing = UseSandboxing;
   Flags.PhiEdgeSplit = EnablePhiEdgeSplit;
   Flags.DecorateAsm = DecorateAsm;
   Flags.DumpStats = DumpStats;
   Flags.AllowUninitializedGlobals = AllowUninitializedGlobals;
   Flags.TimeEachFunction = TimeEachFunction;
   Flags.DefaultGlobalPrefix = DefaultGlobalPrefix;
   Flags.DefaultFunctionPrefix = DefaultFunctionPrefix;
   Flags.TimingFocusOn = TimingFocusOn;
   Flags.VerboseFocusOn = VerboseFocusOn;
   Flags.TranslateOnly = TranslateOnly;
   Flags.DisableIRGeneration = DisableIRGeneration;
 
   // Force -build-on-read=0 for .ll files.
   const std::string LLSuffix = ".ll";
   if (IRFilename.length() >= LLSuffix.length() &&
       IRFilename.compare(IRFilename.length() - LLSuffix.length(),
                          LLSuffix.length(), LLSuffix) == 0)
     BuildOnRead = false;
 
-  Ice::GlobalContext Ctx(Ls, Os, VMask, TargetArch, OptLevel, TestPrefix,
-                         Flags);
+  // With the ELF writer, use a raw_fd_ostream to allow seeking.
+  // Also don't buffer, otherwise it gets pretty slow.
+  std::unique_ptr<Ice::Ostream> Os;
+  std::unique_ptr<Ice::ELFStreamer> ELFStr;
+  std::ofstream Ofs;
+  if (UseELFWriter) {
+    if (OutputFilename == "-") {
+      *Ls << "Error: writing binary ELF to stdout is unsupported\n";
+      return GetReturnValue(1);
+    }
+    std::string ErrorInfo;
+    raw_fd_ostream *FdOs =
+        new raw_fd_ostream(OutputFilename.c_str(), ErrorInfo, sys::fs::F_None);
+    Os.reset(FdOs);
+    if (!ErrorInfo.empty()) {
+      *Ls << "Failed to open output file: " << OutputFilename << ":\n"
+          << ErrorInfo << "\n";
+      return GetReturnValue(1);
+    }
+    ELFStr.reset(new Ice::ELFStreamer(*FdOs));
+  } else {
+    if (OutputFilename != "-") {
+      Ofs.open(OutputFilename.c_str(), std::ofstream::out);
+      Os.reset(new raw_os_ostream(Ofs));
+    } else {
+      Os.reset(new raw_os_ostream(std::cout));
+    }
+    Os->SetUnbuffered();
+  }
+
+  Ice::GlobalContext Ctx(Ls.get(), Os.get(), ELFStr.get(), VMask, TargetArch,
+                         OptLevel, TestPrefix, Flags);
 
   Ice::TimerMarker T(Ice::TimerStack::TT_szmain, &Ctx);
 
+  if (UseELFWriter) {
+    Ctx.getObjectWriter()->writeInitialELFHeader();
+  }
+
   int ErrorStatus = 0;
   if (BuildOnRead) {
     Ice::PNaClTranslator Translator(&Ctx, Flags);
     Translator.translate(IRFilename);
     ErrorStatus = Translator.getErrorStatus();
   } else if (ALLOW_LLVM_IR) {
     // Parse the input LLVM IR file into a module.
     SMDiagnostic Err;
     Ice::TimerMarker T1(Ice::TimerStack::TT_parse, &Ctx);
     Module *Mod =
         NaClParseIRFile(IRFilename, InputFileFormat, Err, getGlobalContext());
 
     if (!Mod) {
       Err.print(argv[0], errs());
       return GetReturnValue(1);
     }
 
     Ice::Converter Converter(Mod, &Ctx, Flags);
     Converter.convertToIce();
     ErrorStatus = Converter.getErrorStatus();
   } else {
     *Ls << "Error: Build doesn't allow LLVM IR, "
         << "--build-on-read=0 not allowed\n";
     return GetReturnValue(1);
   }
+  if (UseELFWriter) {
+    Ctx.getObjectWriter()->writeNonUserSections();
+  }
   if (SubzeroTimingEnabled)
     Ctx.dumpTimers();
   if (TimeEachFunction) {
     const bool DumpCumulative = false;
     Ctx.dumpTimers(Ice::GlobalContext::TSK_Funcs, DumpCumulative);
   }
   const bool FinalStats = true;
   Ctx.dumpStats("_FINAL_", FinalStats);
   return GetReturnValue(ErrorStatus);
 }