[LLVM up] Add basic -S option to clang.
- Split backend related consumer out into Backend.cpp, replaces
LLVMCodeGenWriter.
- Structure follows llvm-gcc to some extent.
- Still need to implement all the options which impact code
generation and the optimization passes which llvm-gcc uses at
various levels.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@57936 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/Driver/Backend.cpp b/Driver/Backend.cpp
new file mode 100644
index 0000000..32dbbf2
--- /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);
+}