Add support to the X86 backend for emitting ELF files. To use this, we

currently use: llc t.bc --filetype=obj

This will produce a t.o file which is dumpable with readelf.  Currently
the file produced is empty, but the scaffolding to do more is now in place.

llvm-svn: 22292

lib/Target/X86/X86.h

@@ -69,6 +69,12 @@ FunctionPass *createX86FloatingPointStackifierPass();
 ///
 FunctionPass *createX86CodePrinterPass(std::ostream &o,TargetMachine &tm);
 
+/// createX86ELFObjectWriterPass - Returns a pass that outputs the generated
+/// code as an ELF object file.
+///
+FunctionPass *createX86ELFObjectWriterPass(std::ostream &o, TargetMachine &tm);
+
+
 /// createX86EmitCodeToMemory - Returns a pass that converts a register
 /// allocated function into raw machine code in a dynamically
 /// allocated chunk of memory.

lib/Target/X86/X86ELFWriter.cpp

@@ -0,0 +1,34 @@
+//===-- X86ELFWriter.cpp - Emit an ELF file for the X86 backend -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements an ELF writer for the X86 backend.  The public interface
+// to this file is the createX86ELFObjectWriterPass function.
+//
+//===----------------------------------------------------------------------===//
+
+#include "X86.h"
+#include "llvm/CodeGen/ELFWriter.h"
+using namespace llvm;
+
+namespace {
+  class X86ELFWriter : public ELFWriter {
+  public:
+    X86ELFWriter(std::ostream &O, TargetMachine &TM) : ELFWriter(O, TM) {
+      e_machine = 3;   // EM_386
+    }
+  };
+}
+
+/// createX86ELFObjectWriterPass - Returns a pass that outputs the generated
+/// code as an ELF object file.
+///
+FunctionPass *llvm::createX86ELFObjectWriterPass(std::ostream &O,
+                                                 TargetMachine &TM) {
+  return new X86ELFWriter(O, TM);
+}

lib/Target/X86/X86TargetMachine.cpp

@@ -98,7 +98,8 @@ X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *IL)
 // does to emit statically compiled machine code.
 bool X86TargetMachine::addPassesToEmitFile(PassManager &PM, std::ostream &Out,
                                            CodeGenFileType FileType) {
-  if (FileType != TargetMachine::AssemblyFile) return true;
+  if (FileType != TargetMachine::AssemblyFile && 
+      FileType != TargetMachine::ObjectFile) return true;
 
   // FIXME: Implement efficient support for garbage collection intrinsics.
   PM.add(createLowerGCPass());
@@ -146,7 +147,19 @@ bool X86TargetMachine::addPassesToEmitFile(PassManager &PM, std::ostream &Out,
     PM.add(createX86CodePrinterPass(std::cerr, *this));
 
   if (!DisableOutput)
-    PM.add(createX86CodePrinterPass(Out, *this));
+    switch (FileType) {
+    default:
+      assert(0 && "Unexpected filetype here!");
+    case TargetMachine::AssemblyFile:
+      PM.add(createX86CodePrinterPass(Out, *this));
+      break;
+    case TargetMachine::ObjectFile:
+      // FIXME: We only support emission of ELF files for now, this should check
+      // the target triple and decide on the format to write (e.g. COFF on
+      // win32).
+      PM.add(createX86ELFObjectWriterPass(Out, *this));
+      break;
+    }
 
   // Delete machine code for this function
   PM.add(createMachineCodeDeleter());