Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 1 | //===--- Backend.cpp - Interface to LLVM backend technologies -------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #include "ASTConsumers.h" |
| 11 | |
| 12 | #include "clang/AST/ASTContext.h" |
| 13 | #include "clang/AST/ASTConsumer.h" |
| 14 | #include "clang/AST/TranslationUnit.h" |
| 15 | #include "clang/Basic/TargetInfo.h" |
| 16 | #include "clang/CodeGen/ModuleBuilder.h" |
| 17 | #include "llvm/Module.h" |
| 18 | #include "llvm/ModuleProvider.h" |
| 19 | #include "llvm/PassManager.h" |
| 20 | #include "llvm/ADT/OwningPtr.h" |
| 21 | #include "llvm/Assembly/PrintModulePass.h" |
| 22 | #include "llvm/Bitcode/ReaderWriter.h" |
| 23 | #include "llvm/CodeGen/RegAllocRegistry.h" |
| 24 | #include "llvm/CodeGen/SchedulerRegistry.h" |
| 25 | #include "llvm/CodeGen/ScheduleDAG.h" |
| 26 | #include "llvm/Support/raw_ostream.h" |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Compiler.h" |
| 28 | #include "llvm/System/Path.h" |
| 29 | #include "llvm/System/Program.h" |
| 30 | #include "llvm/Target/TargetData.h" |
| 31 | #include "llvm/Target/TargetMachine.h" |
| 32 | #include "llvm/Target/TargetMachineRegistry.h" |
| 33 | #include <fstream> // FIXME: Remove |
| 34 | |
| 35 | using namespace clang; |
| 36 | using namespace llvm; |
| 37 | |
| 38 | namespace { |
| 39 | class VISIBILITY_HIDDEN BackendConsumer : public ASTConsumer { |
| 40 | BackendAction Action; |
| 41 | const std::string &InputFile; |
| 42 | std::string OutputFile; |
| 43 | llvm::OwningPtr<CodeGenerator> Gen; |
| 44 | |
| 45 | llvm::Module *TheModule; |
| 46 | llvm::TargetData *TheTargetData; |
| 47 | llvm::raw_ostream *AsmOutStream; |
| 48 | |
| 49 | mutable FunctionPassManager *CodeGenPasses; |
| 50 | mutable PassManager *PerModulePasses; |
| 51 | mutable FunctionPassManager *PerFunctionPasses; |
| 52 | |
| 53 | FunctionPassManager *getCodeGenPasses() const; |
| 54 | PassManager *getPerModulePasses() const; |
| 55 | FunctionPassManager *getPerFunctionPasses() const; |
| 56 | |
| 57 | void CreatePasses(); |
| 58 | |
| 59 | /// AddEmitPasses - Add passes necessary to emit assembly or LLVM |
| 60 | /// IR. |
| 61 | /// |
| 62 | /// \arg Fast - Whether "fast" native compilation should be |
| 63 | /// used. This implies local register allocation and fast |
| 64 | /// instruction selection. |
| 65 | /// \return True on success. On failure \arg Error will be set to |
| 66 | /// a user readable error message. |
| 67 | bool AddEmitPasses(bool Fast, std::string &Error); |
| 68 | |
| 69 | void EmitAssembly(); |
| 70 | |
| 71 | public: |
| 72 | BackendConsumer(BackendAction action, Diagnostic &Diags, |
| 73 | const LangOptions &Features, |
| 74 | const std::string& infile, const std::string& outfile, |
| 75 | bool GenerateDebugInfo) : |
| 76 | Action(action), |
| 77 | InputFile(infile), |
| 78 | OutputFile(outfile), |
| 79 | Gen(CreateLLVMCodeGen(Diags, Features, InputFile, GenerateDebugInfo)), |
Daniel Dunbar | ed2cb28 | 2008-10-22 17:40:45 +0000 | [diff] [blame^] | 80 | TheModule(0), TheTargetData(0), AsmOutStream(0), |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 81 | CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {} |
| 82 | |
| 83 | ~BackendConsumer() { |
| 84 | // FIXME: Move out of destructor. |
| 85 | EmitAssembly(); |
| 86 | |
| 87 | delete AsmOutStream; |
| 88 | delete TheTargetData; |
| 89 | delete TheModule; |
| 90 | delete CodeGenPasses; |
| 91 | delete PerModulePasses; |
| 92 | delete PerFunctionPasses; |
| 93 | } |
| 94 | |
| 95 | virtual void InitializeTU(TranslationUnit& TU) { |
| 96 | Gen->InitializeTU(TU); |
| 97 | |
| 98 | TheModule = Gen->GetModule(); |
| 99 | TheTargetData = |
| 100 | new llvm::TargetData(TU.getContext().Target.getTargetDescription()); |
| 101 | } |
| 102 | |
| 103 | virtual void HandleTopLevelDecl(Decl *D) { |
| 104 | Gen->HandleTopLevelDecl(D); |
| 105 | } |
| 106 | |
| 107 | virtual void HandleTranslationUnit(TranslationUnit& TU) { |
| 108 | Gen->HandleTranslationUnit(TU); |
| 109 | } |
| 110 | |
| 111 | virtual void HandleTagDeclDefinition(TagDecl *D) { |
| 112 | Gen->HandleTagDeclDefinition(D); |
| 113 | } |
| 114 | }; |
| 115 | } |
| 116 | |
| 117 | FunctionPassManager *BackendConsumer::getCodeGenPasses() const { |
| 118 | if (!CodeGenPasses) { |
| 119 | CodeGenPasses = |
| 120 | new FunctionPassManager(new ExistingModuleProvider(TheModule)); |
| 121 | CodeGenPasses->add(new TargetData(*TheTargetData)); |
| 122 | } |
| 123 | |
| 124 | return CodeGenPasses; |
| 125 | } |
| 126 | |
| 127 | PassManager *BackendConsumer::getPerModulePasses() const { |
| 128 | if (!PerModulePasses) { |
| 129 | PerModulePasses = new PassManager(); |
| 130 | PerModulePasses->add(new TargetData(*TheTargetData)); |
| 131 | } |
| 132 | |
| 133 | return PerModulePasses; |
| 134 | } |
| 135 | |
| 136 | FunctionPassManager *BackendConsumer::getPerFunctionPasses() const { |
| 137 | if (!PerFunctionPasses) { |
| 138 | PerFunctionPasses = |
| 139 | new FunctionPassManager(new ExistingModuleProvider(TheModule)); |
| 140 | PerFunctionPasses->add(new TargetData(*TheTargetData)); |
| 141 | } |
| 142 | |
| 143 | return PerFunctionPasses; |
| 144 | } |
| 145 | |
| 146 | bool BackendConsumer::AddEmitPasses(bool Fast, std::string &Error) { |
| 147 | // Create the TargetMachine for generating code. |
| 148 | const TargetMachineRegistry::entry *TME = |
| 149 | TargetMachineRegistry::getClosestStaticTargetForModule(*TheModule, Error); |
| 150 | if (!TME) { |
| 151 | Error = std::string("Unable to get target machine: ") + Error; |
| 152 | return false; |
| 153 | } |
| 154 | |
| 155 | // FIXME: Support features? |
| 156 | std::string FeatureStr; |
| 157 | TargetMachine *TM = TME->CtorFn(*TheModule, FeatureStr); |
| 158 | |
| 159 | // Set register scheduler & allocation policy. |
| 160 | RegisterScheduler::setDefault(createDefaultScheduler); |
| 161 | RegisterRegAlloc::setDefault(Fast ? createLocalRegisterAllocator : |
| 162 | createLinearScanRegisterAllocator); |
| 163 | |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 164 | if (OutputFile == "-" || (InputFile == "-" && OutputFile.empty())) { |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 165 | AsmOutStream = new raw_stdout_ostream(); |
| 166 | sys::Program::ChangeStdoutToBinary(); |
| 167 | } else { |
| 168 | if (OutputFile.empty()) { |
| 169 | llvm::sys::Path Path(InputFile); |
| 170 | Path.eraseSuffix(); |
| 171 | if (Action == Backend_EmitBC) { |
| 172 | Path.appendSuffix("bc"); |
| 173 | } else if (Action == Backend_EmitLL) { |
| 174 | Path.appendSuffix("ll"); |
| 175 | } else { |
| 176 | Path.appendSuffix("s"); |
| 177 | } |
| 178 | OutputFile = Path.toString(); |
| 179 | } |
| 180 | |
Daniel Dunbar | ed2cb28 | 2008-10-22 17:40:45 +0000 | [diff] [blame^] | 181 | // FIXME: Should be binary. |
| 182 | AsmOutStream = new raw_fd_ostream(OutputFile.c_str(), Error); |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 183 | if (!Error.empty()) |
| 184 | return false; |
| 185 | } |
| 186 | |
| 187 | if (Action == Backend_EmitBC) { |
Daniel Dunbar | ed2cb28 | 2008-10-22 17:40:45 +0000 | [diff] [blame^] | 188 | getPerModulePasses()->add(createBitcodeWriterPass(*AsmOutStream)); |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 189 | } else if (Action == Backend_EmitLL) { |
Daniel Dunbar | 11292b0 | 2008-10-22 03:28:13 +0000 | [diff] [blame] | 190 | getPerModulePasses()->add(createPrintModulePass(AsmOutStream)); |
Daniel Dunbar | d69bacc | 2008-10-21 23:49:24 +0000 | [diff] [blame] | 191 | } else { |
| 192 | // From llvm-gcc: |
| 193 | // If there are passes we have to run on the entire module, we do codegen |
| 194 | // as a separate "pass" after that happens. |
| 195 | // FIXME: This is disabled right now until bugs can be worked out. Reenable |
| 196 | // this for fast -O0 compiles! |
| 197 | FunctionPassManager *PM = getCodeGenPasses(); |
| 198 | |
| 199 | // Normal mode, emit a .s file by running the code generator. |
| 200 | // Note, this also adds codegenerator level optimization passes. |
| 201 | switch (TM->addPassesToEmitFile(*PM, *AsmOutStream, |
| 202 | TargetMachine::AssemblyFile, Fast)) { |
| 203 | default: |
| 204 | case FileModel::Error: |
| 205 | Error = "Unable to interface with target machine!\n"; |
| 206 | return false; |
| 207 | case FileModel::AsmFile: |
| 208 | break; |
| 209 | } |
| 210 | |
| 211 | if (TM->addPassesToEmitFileFinish(*CodeGenPasses, 0, Fast)) { |
| 212 | Error = "Unable to interface with target machine!\n"; |
| 213 | return false; |
| 214 | } |
| 215 | } |
| 216 | |
| 217 | return true; |
| 218 | } |
| 219 | |
| 220 | void BackendConsumer::CreatePasses() { |
| 221 | |
| 222 | } |
| 223 | |
| 224 | /// EmitAssembly - Handle interaction with LLVM backend to generate |
| 225 | /// actual machine code. |
| 226 | void BackendConsumer::EmitAssembly() { |
| 227 | // Silently ignore if we weren't initialized for some reason. |
| 228 | if (!TheModule || !TheTargetData) |
| 229 | return; |
| 230 | |
| 231 | bool Optimize = false; // FIXME |
| 232 | |
| 233 | // Make sure IR generation is happy with the module. |
| 234 | // FIXME: Release this. |
| 235 | Module *M = Gen->ReleaseModule(); |
| 236 | if (!M) { |
| 237 | TheModule = 0; |
| 238 | return; |
| 239 | } |
| 240 | |
| 241 | assert(TheModule == M && "Unexpected module change during IR generation"); |
| 242 | |
| 243 | CreatePasses(); |
| 244 | |
| 245 | std::string Error; |
| 246 | if (!AddEmitPasses(!Optimize, Error)) { |
| 247 | // FIXME: Don't fail this way. |
| 248 | llvm::cerr << "ERROR: " << Error << "\n"; |
| 249 | ::exit(1); |
| 250 | } |
| 251 | |
| 252 | // Run passes. For now we do all passes at once, but eventually we |
| 253 | // would like to have the option of streaming code generation. |
| 254 | |
| 255 | if (PerFunctionPasses) { |
| 256 | PerFunctionPasses->doInitialization(); |
| 257 | for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) |
| 258 | if (!I->isDeclaration()) |
| 259 | PerFunctionPasses->run(*I); |
| 260 | PerFunctionPasses->doFinalization(); |
| 261 | } |
| 262 | |
| 263 | if (PerModulePasses) |
| 264 | PerModulePasses->run(*M); |
| 265 | |
| 266 | if (CodeGenPasses) { |
| 267 | CodeGenPasses->doInitialization(); |
| 268 | for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) |
| 269 | if (!I->isDeclaration()) |
| 270 | CodeGenPasses->run(*I); |
| 271 | CodeGenPasses->doFinalization(); |
| 272 | } |
| 273 | } |
| 274 | |
| 275 | ASTConsumer *clang::CreateBackendConsumer(BackendAction Action, |
| 276 | Diagnostic &Diags, |
| 277 | const LangOptions &Features, |
| 278 | const std::string& InFile, |
| 279 | const std::string& OutFile, |
| 280 | bool GenerateDebugInfo) { |
| 281 | return new BackendConsumer(Action, Diags, Features, InFile, OutFile, |
| 282 | GenerateDebugInfo); |
| 283 | } |