1 files changed, 297 insertions, 0 deletions
diff --git a/Driver/Backend.cpp b/Driver/Backend.cpp
new file mode 100644
index 0000000000..32dbbf21a4
--- /dev/null
+++ b/Driver/Backend.cpp
@@ -0,0 +1,297 @@
+//===--- Backend.cpp - Interface to LLVM backend technologies -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ASTConsumers.h"
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/TranslationUnit.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/CodeGen/ModuleBuilder.h"
+#include "llvm/Module.h"
+#include "llvm/ModuleProvider.h"
+#include "llvm/PassManager.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/Assembly/PrintModulePass.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/CodeGen/RegAllocRegistry.h"
+#include "llvm/CodeGen/SchedulerRegistry.h"
+#include "llvm/CodeGen/ScheduleDAG.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Streams.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/System/Path.h"
+#include "llvm/System/Program.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include <fstream> // FIXME: Remove
+
+using namespace clang;
+using namespace llvm;
+
+namespace {
+  class VISIBILITY_HIDDEN BackendConsumer  : public ASTConsumer {
+    BackendAction Action;
+    const std::string &InputFile;
+    std::string OutputFile;
+    llvm::OwningPtr<CodeGenerator> Gen;
+    
+    llvm::Module *TheModule;
+    llvm::TargetData *TheTargetData;
+    llvm::raw_ostream *AsmOutStream;
+
+    mutable FunctionPassManager *CodeGenPasses;
+    mutable PassManager *PerModulePasses;
+    mutable FunctionPassManager *PerFunctionPasses;
+
+    FunctionPassManager *getCodeGenPasses() const;
+    PassManager *getPerModulePasses() const;
+    FunctionPassManager *getPerFunctionPasses() const;
+
+    void CreatePasses();
+
+    /// AddEmitPasses - Add passes necessary to emit assembly or LLVM
+    /// IR.
+    ///
+    /// \arg Fast - Whether "fast" native compilation should be
+    /// used. This implies local register allocation and fast
+    /// instruction selection.
+    /// \return True on success. On failure \arg Error will be set to
+    /// a user readable error message.
+    bool AddEmitPasses(bool Fast, std::string &Error);
+
+    void EmitAssembly();
+    
+  public:  
+    BackendConsumer(BackendAction action, Diagnostic &Diags, 
+                    const LangOptions &Features,
+                    const std::string& infile, const std::string& outfile,
+                    bool GenerateDebugInfo)  :
+      Action(action), 
+      InputFile(infile), 
+      OutputFile(outfile), 
+      Gen(CreateLLVMCodeGen(Diags, Features, InputFile, GenerateDebugInfo)),
+      TheModule(0), TheTargetData(0), AsmOutStream(0),
+      CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
+
+    ~BackendConsumer() {
+      // FIXME: Move out of destructor.
+      EmitAssembly();
+
+      delete AsmOutStream;
+      delete TheTargetData;
+      delete TheModule;
+      delete CodeGenPasses;
+      delete PerModulePasses;
+      delete PerFunctionPasses;
+    }
+
+    virtual void InitializeTU(TranslationUnit& TU) {
+      Gen->InitializeTU(TU);
+
+      TheModule = Gen->GetModule();
+      TheTargetData = 
+        new llvm::TargetData(TU.getContext().Target.getTargetDescription());
+    }
+    
+    virtual void HandleTopLevelDecl(Decl *D) {
+      Gen->HandleTopLevelDecl(D);
+    }
+    
+    virtual void HandleTranslationUnit(TranslationUnit& TU) {
+      Gen->HandleTranslationUnit(TU);
+    }
+    
+    virtual void HandleTagDeclDefinition(TagDecl *D) {
+      Gen->HandleTagDeclDefinition(D);
+    }
+  };  
+}
+
+FunctionPassManager *BackendConsumer::getCodeGenPasses() const {
+  if (!CodeGenPasses) {
+    CodeGenPasses = 
+      new FunctionPassManager(new ExistingModuleProvider(TheModule));
+    CodeGenPasses->add(new TargetData(*TheTargetData));
+  }
+
+  return CodeGenPasses;
+}
+
+PassManager *BackendConsumer::getPerModulePasses() const {
+  if (!PerModulePasses) {
+    PerModulePasses = new PassManager();
+    PerModulePasses->add(new TargetData(*TheTargetData));
+  }
+
+  return PerModulePasses;
+}
+
+FunctionPassManager *BackendConsumer::getPerFunctionPasses() const {
+  if (!PerFunctionPasses) {
+    PerFunctionPasses = 
+      new FunctionPassManager(new ExistingModuleProvider(TheModule));
+    PerFunctionPasses->add(new TargetData(*TheTargetData));
+  }
+
+  return PerFunctionPasses;
+}
+
+bool BackendConsumer::AddEmitPasses(bool Fast, std::string &Error) {
+  // Create the TargetMachine for generating code.
+  const TargetMachineRegistry::entry *TME = 
+    TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, Error);
+  if (!TME) {
+    Error = std::string("Unable to get target machine: ") + Error;
+    return false;
+  }
+      
+  // FIXME: Support features?
+  std::string FeatureStr;
+  TargetMachine *TM = TME->CtorFn(*TheModule, FeatureStr);
+  
+  // Set register scheduler & allocation policy.
+  RegisterScheduler::setDefault(createDefaultScheduler);
+  RegisterRegAlloc::setDefault(Fast ? createLocalRegisterAllocator : 
+                               createLinearScanRegisterAllocator);  
+
+  // This is ridiculous.
+  // FIXME: These aren't being release for now. I'm just going to fix
+  // things to use raw_ostream instead.
+  std::ostream *AsmStdOutStream = 0;
+  OStream *AsmLLVMOutStream = 0;
+  if (OutputFile == "-" || (InputFile == "-" && OutputFile.empty())) {
+    AsmStdOutStream = llvm::cout.stream();
+    AsmLLVMOutStream = &llvm::cout;
+    AsmOutStream = new raw_stdout_ostream();
+    sys::Program::ChangeStdoutToBinary();
+  } else {
+    if (OutputFile.empty()) {
+      llvm::sys::Path Path(InputFile);
+      Path.eraseSuffix();
+      if (Action == Backend_EmitBC) {
+        Path.appendSuffix("bc");
+      } else if (Action == Backend_EmitLL) {
+        Path.appendSuffix("ll");
+      } else {
+        Path.appendSuffix("s");
+      }
+      OutputFile = Path.toString();
+    }
+
+    // FIXME: raw_fd_ostream should specify its non-error condition
+    // better.
+    Error = "";
+    AsmStdOutStream = new std::ofstream(OutputFile.c_str(),
+                                        (std::ios_base::binary | 
+                                         std::ios_base::out));
+    AsmLLVMOutStream = new OStream(AsmStdOutStream);
+    AsmOutStream = new raw_os_ostream(*AsmStdOutStream);
+    if (!Error.empty())
+      return false;
+  }
+
+  if (Action == Backend_EmitBC) {
+    getPerModulePasses()->add(CreateBitcodeWriterPass(*AsmStdOutStream));
+  } else if (Action == Backend_EmitLL) {
+    getPerModulePasses()->add(createPrintModulePass(AsmLLVMOutStream));
+  } else {
+    // From llvm-gcc:
+    // If there are passes we have to run on the entire module, we do codegen
+    // as a separate "pass" after that happens.
+    // FIXME: This is disabled right now until bugs can be worked out.  Reenable
+    // this for fast -O0 compiles!
+    FunctionPassManager *PM = getCodeGenPasses();
+    
+    // Normal mode, emit a .s file by running the code generator.
+    // Note, this also adds codegenerator level optimization passes.
+    switch (TM->addPassesToEmitFile(*PM, *AsmOutStream,
+                                    TargetMachine::AssemblyFile, Fast)) {
+    default:
+    case FileModel::Error:
+      Error = "Unable to interface with target machine!\n";
+      return false;
+    case FileModel::AsmFile:
+      break;
+    }
+    
+    if (TM->addPassesToEmitFileFinish(*CodeGenPasses, 0, Fast)) {
+      Error = "Unable to interface with target machine!\n";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void BackendConsumer::CreatePasses() {
+  
+}
+
+/// EmitAssembly - Handle interaction with LLVM backend to generate
+/// actual machine code. 
+void BackendConsumer::EmitAssembly() {
+  // Silently ignore if we weren't initialized for some reason.
+  if (!TheModule || !TheTargetData)
+    return;
+
+  bool Optimize = false; // FIXME
+
+  // Make sure IR generation is happy with the module.
+  // FIXME: Release this.
+  Module *M = Gen->ReleaseModule();
+  if (!M) {
+    TheModule = 0;
+    return;
+  }
+
+  assert(TheModule == M && "Unexpected module change during IR generation");
+
+  CreatePasses();
+
+  std::string Error;
+  if (!AddEmitPasses(!Optimize, Error)) {
+    // FIXME: Don't fail this way.
+    llvm::cerr << "ERROR: " << Error << "\n";
+    ::exit(1);
+  }
+
+  // Run passes. For now we do all passes at once, but eventually we
+  // would like to have the option of streaming code generation.
+
+  if (PerFunctionPasses) {
+    PerFunctionPasses->doInitialization();
+    for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
+      if (!I->isDeclaration())
+        PerFunctionPasses->run(*I);
+    PerFunctionPasses->doFinalization();
+  }
+  
+  if (PerModulePasses)
+    PerModulePasses->run(*M);
+  
+  if (CodeGenPasses) {
+    CodeGenPasses->doInitialization();
+    for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
+      if (!I->isDeclaration())
+        CodeGenPasses->run(*I);
+    CodeGenPasses->doFinalization();
+  }
+}
+
+ASTConsumer *clang::CreateBackendConsumer(BackendAction Action,
+                                          Diagnostic &Diags,
+                                          const LangOptions &Features,
+                                          const std::string& InFile,
+                                          const std::string& OutFile,
+                                          bool GenerateDebugInfo) {
+  return new BackendConsumer(Action, Diags, Features, InFile, OutFile,
+                             GenerateDebugInfo);  
+}