zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 1 | #include "slang_backend.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 2 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 3 | #include "llvm/Module.h" |
| 4 | #include "llvm/Metadata.h" |
| 5 | #include "llvm/LLVMContext.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 6 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 7 | #include "llvm/Target/TargetMachine.h" |
| 8 | #include "llvm/Target/TargetOptions.h" |
| 9 | #include "llvm/Target/TargetRegistry.h" |
| 10 | #include "llvm/Target/SubtargetFeature.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 11 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 12 | #include "llvm/CodeGen/RegAllocRegistry.h" |
| 13 | #include "llvm/CodeGen/SchedulerRegistry.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 14 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 15 | #include "llvm/Assembly/PrintModulePass.h" |
| 16 | #include "llvm/Bitcode/ReaderWriter.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 17 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 18 | #include "clang/AST/Decl.h" |
| 19 | #include "clang/AST/DeclGroup.h" |
| 20 | #include "clang/AST/ASTContext.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 21 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 22 | #include "clang/Basic/TargetInfo.h" |
| 23 | #include "clang/Basic/Diagnostic.h" |
| 24 | #include "clang/Basic/TargetOptions.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 25 | |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 26 | #include "clang/Frontend/CodeGenOptions.h" |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 27 | #include "clang/Frontend/FrontendDiagnostic.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 28 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 29 | #include "clang/CodeGen/ModuleBuilder.h" |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 30 | |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 31 | #include "slang.h" |
| 32 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 33 | using namespace slang; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 34 | |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 35 | void Backend::CreateFunctionPasses() { |
| 36 | if (!mPerFunctionPasses) { |
| 37 | mPerFunctionPasses = new llvm::FunctionPassManager(mpModule); |
| 38 | mPerFunctionPasses->add(new llvm::TargetData(*mpTargetData)); |
| 39 | |
| 40 | llvm::createStandardFunctionPasses(mPerFunctionPasses, |
| 41 | mCodeGenOpts.OptimizationLevel); |
| 42 | } |
| 43 | return; |
| 44 | } |
| 45 | |
| 46 | void Backend::CreateModulePasses() { |
| 47 | if (!mPerModulePasses) { |
| 48 | mPerModulePasses = new llvm::PassManager(); |
| 49 | mPerModulePasses->add(new llvm::TargetData(*mpTargetData)); |
| 50 | |
| 51 | llvm::createStandardModulePasses(mPerModulePasses, |
| 52 | mCodeGenOpts.OptimizationLevel, |
| 53 | mCodeGenOpts.OptimizeSize, |
| 54 | mCodeGenOpts.UnitAtATime, |
| 55 | mCodeGenOpts.UnrollLoops, |
| 56 | /* SimplifyLibCalls = */true, |
| 57 | /* HaveExceptions = */false, |
| 58 | /* InliningPass = */NULL); |
| 59 | } |
| 60 | return; |
| 61 | } |
| 62 | |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 63 | bool Backend::CreateCodeGenPasses() { |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 64 | if ((mOT != Slang::OT_Assembly) && (mOT != Slang::OT_Object)) |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 65 | return true; |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 66 | |
| 67 | // Now we add passes for code emitting |
| 68 | if (mCodeGenPasses) { |
| 69 | return true; |
| 70 | } else { |
| 71 | mCodeGenPasses = new llvm::FunctionPassManager(mpModule); |
| 72 | mCodeGenPasses->add(new llvm::TargetData(*mpTargetData)); |
| 73 | } |
| 74 | |
| 75 | // Create the TargetMachine for generating code. |
| 76 | std::string Triple = mpModule->getTargetTriple(); |
| 77 | |
| 78 | std::string Error; |
| 79 | const llvm::Target* TargetInfo = |
| 80 | llvm::TargetRegistry::lookupTarget(Triple, Error); |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 81 | if (TargetInfo == NULL) { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 82 | mDiags.Report(clang::diag::err_fe_unable_to_create_target) << Error; |
| 83 | return false; |
| 84 | } |
| 85 | |
| 86 | llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim; |
| 87 | |
| 88 | // Use hardware FPU. |
| 89 | // |
| 90 | // FIXME: Need to detect the CPU capability and decide whether to use softfp. |
| 91 | // To use softfp, change following 2 lines to |
| 92 | // |
| 93 | // llvm::FloatABIType = llvm::FloatABI::Soft; |
| 94 | // llvm::UseSoftFloat = true; |
| 95 | llvm::FloatABIType = llvm::FloatABI::Hard; |
| 96 | llvm::UseSoftFloat = false; |
| 97 | |
| 98 | // BCC needs all unknown symbols resolved at compilation time. So we don't |
| 99 | // need any relocation model. |
| 100 | llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static); |
| 101 | |
| 102 | |
| 103 | // The target with pointer size greater than 32 (e.g. x86_64 architecture) may |
| 104 | // need large data address model |
| 105 | if (mpTargetData->getPointerSizeInBits() > 32) |
| 106 | llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium); |
| 107 | else |
| 108 | // This is set for the linker (specify how large of the virtual addresses we |
| 109 | // can access for all unknown symbols.) |
| 110 | |
| 111 | llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small); |
| 112 | |
| 113 | // Setup feature string |
| 114 | std::string FeaturesStr; |
| 115 | if (mTargetOpts.CPU.size() || mTargetOpts.Features.size()) { |
| 116 | llvm::SubtargetFeatures Features; |
| 117 | |
| 118 | Features.setCPU(mTargetOpts.CPU); |
| 119 | |
| 120 | for (std::vector<std::string>::const_iterator |
| 121 | I = mTargetOpts.Features.begin(), E = mTargetOpts.Features.end(); |
| 122 | I != E; |
| 123 | I++) |
| 124 | Features.AddFeature(*I); |
| 125 | |
| 126 | FeaturesStr = Features.getString(); |
| 127 | } |
| 128 | llvm::TargetMachine *TM = |
| 129 | TargetInfo->createTargetMachine(Triple, FeaturesStr); |
| 130 | |
| 131 | // Register scheduler |
| 132 | llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler); |
| 133 | |
| 134 | // Register allocation policy: |
| 135 | // createFastRegisterAllocator: fast but bad quality |
| 136 | // createLinearScanRegisterAllocator: not so fast but good quality |
| 137 | llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ? |
| 138 | llvm::createFastRegisterAllocator : |
| 139 | llvm::createLinearScanRegisterAllocator); |
| 140 | |
| 141 | llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default; |
| 142 | if (mCodeGenOpts.OptimizationLevel == 0) |
| 143 | OptLevel = llvm::CodeGenOpt::None; |
| 144 | else if (mCodeGenOpts.OptimizationLevel == 3) |
| 145 | OptLevel = llvm::CodeGenOpt::Aggressive; |
| 146 | |
| 147 | llvm::TargetMachine::CodeGenFileType CGFT = |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 148 | llvm::TargetMachine::CGFT_AssemblyFile; |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 149 | if (mOT == Slang::OT_Object) |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 150 | CGFT = llvm::TargetMachine::CGFT_ObjectFile; |
| 151 | if (TM->addPassesToEmitFile(*mCodeGenPasses, FormattedOutStream, |
| 152 | CGFT, OptLevel)) { |
| 153 | mDiags.Report(clang::diag::err_fe_unable_to_interface_with_target); |
| 154 | return false; |
| 155 | } |
| 156 | |
| 157 | return true; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 160 | Backend::Backend(clang::Diagnostic &Diags, |
| 161 | const clang::CodeGenOptions &CodeGenOpts, |
| 162 | const clang::TargetOptions &TargetOpts, |
| 163 | const PragmaList &Pragmas, |
| 164 | llvm::raw_ostream *OS, |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 165 | Slang::OutputType OT) |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 166 | : ASTConsumer(), |
| 167 | mCodeGenOpts(CodeGenOpts), |
| 168 | mTargetOpts(TargetOpts), |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 169 | mpOS(OS), |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 170 | mOT(OT), |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 171 | mpTargetData(NULL), |
| 172 | mGen(NULL), |
| 173 | mPerFunctionPasses(NULL), |
| 174 | mPerModulePasses(NULL), |
| 175 | mCodeGenPasses(NULL), |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 176 | mLLVMContext(llvm::getGlobalContext()), |
| 177 | mDiags(Diags), |
| 178 | mpModule(NULL), |
| 179 | mPragmas(Pragmas) { |
| 180 | FormattedOutStream.setStream(*mpOS, |
| 181 | llvm::formatted_raw_ostream::PRESERVE_STREAM); |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 182 | mGen = CreateLLVMCodeGen(mDiags, "", mCodeGenOpts, mLLVMContext); |
| 183 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 184 | } |
| 185 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 186 | void Backend::Initialize(clang::ASTContext &Ctx) { |
| 187 | mGen->Initialize(Ctx); |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 188 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 189 | mpModule = mGen->GetModule(); |
| 190 | mpTargetData = new llvm::TargetData(Slang::TargetDescription); |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 191 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 192 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 193 | } |
| 194 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 195 | void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 196 | mGen->HandleTopLevelDecl(D); |
| 197 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 200 | void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) { |
| 201 | mGen->HandleTranslationUnit(Ctx); |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 202 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 203 | // Here, we complete a translation unit (whole translation unit is now in LLVM |
| 204 | // IR). Now, interact with LLVM backend to generate actual machine code (asm |
| 205 | // or machine code, whatever.) |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 206 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 207 | // Silently ignore if we weren't initialized for some reason. |
| 208 | if (!mpModule || !mpTargetData) |
| 209 | return; |
| 210 | |
| 211 | llvm::Module *M = mGen->ReleaseModule(); |
| 212 | if (!M) { |
| 213 | // The module has been released by IR gen on failures, do not double free. |
| 214 | mpModule = NULL; |
| 215 | return; |
| 216 | } |
| 217 | |
| 218 | assert(mpModule == M && "Unexpected module change during LLVM IR generation"); |
| 219 | |
| 220 | // Insert #pragma information into metadata section of module |
| 221 | if (!mPragmas.empty()) { |
| 222 | llvm::NamedMDNode *PragmaMetadata = |
| 223 | mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName); |
| 224 | for (PragmaList::const_iterator I = mPragmas.begin(), E = mPragmas.end(); |
| 225 | I != E; |
| 226 | I++) { |
| 227 | llvm::SmallVector<llvm::Value*, 2> Pragma; |
| 228 | // Name goes first |
| 229 | Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first)); |
| 230 | // And then value |
| 231 | Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second)); |
| 232 | // Create MDNode and insert into PragmaMetadata |
| 233 | PragmaMetadata->addOperand( |
| 234 | llvm::MDNode::get(mLLVMContext, Pragma.data(), Pragma.size())); |
| 235 | } |
| 236 | } |
| 237 | |
| 238 | HandleTranslationUnitEx(Ctx); |
| 239 | |
| 240 | // Create passes for optimization and code emission |
| 241 | |
| 242 | // Create and run per-function passes |
| 243 | CreateFunctionPasses(); |
| 244 | if (mPerFunctionPasses) { |
| 245 | mPerFunctionPasses->doInitialization(); |
| 246 | |
| 247 | for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end(); |
| 248 | I != E; |
| 249 | I++) |
| 250 | if (!I->isDeclaration()) |
| 251 | mPerFunctionPasses->run(*I); |
| 252 | |
| 253 | mPerFunctionPasses->doFinalization(); |
| 254 | } |
| 255 | |
| 256 | // Create and run module passes |
| 257 | CreateModulePasses(); |
| 258 | if (mPerModulePasses) |
| 259 | mPerModulePasses->run(*mpModule); |
| 260 | |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 261 | switch (mOT) { |
| 262 | case Slang::OT_Assembly: |
| 263 | case Slang::OT_Object: { |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 264 | if (!CreateCodeGenPasses()) |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 265 | return; |
| 266 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 267 | mCodeGenPasses->doInitialization(); |
| 268 | |
| 269 | for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end(); |
| 270 | I != E; |
| 271 | I++) |
zonr | 6315f76 | 2010-10-05 15:35:14 +0800 | [diff] [blame] | 272 | if (!I->isDeclaration()) |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 273 | mCodeGenPasses->run(*I); |
| 274 | |
| 275 | mCodeGenPasses->doFinalization(); |
| 276 | break; |
| 277 | } |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 278 | case Slang::OT_LLVMAssembly: { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 279 | llvm::PassManager *LLEmitPM = new llvm::PassManager(); |
| 280 | LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream)); |
| 281 | LLEmitPM->run(*mpModule); |
| 282 | break; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 283 | } |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 284 | case Slang::OT_Bitcode: { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 285 | llvm::PassManager *BCEmitPM = new llvm::PassManager(); |
| 286 | BCEmitPM->add(llvm::createBitcodeWriterPass(FormattedOutStream)); |
| 287 | BCEmitPM->run(*mpModule); |
| 288 | break; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 289 | } |
Zonr Chang | 3a9ca1f | 2010-10-06 17:52:56 +0800 | [diff] [blame] | 290 | case Slang::OT_Nothing: { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 291 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 292 | } |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 293 | default: { |
| 294 | assert(false && "Unknown output type"); |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 295 | } |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 296 | } |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 297 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 298 | FormattedOutStream.flush(); |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 299 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 300 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 301 | } |
| 302 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 303 | void Backend::HandleTagDeclDefinition(clang::TagDecl *D) { |
| 304 | mGen->HandleTagDeclDefinition(D); |
| 305 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 306 | } |
| 307 | |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 308 | void Backend::CompleteTentativeDefinition(clang::VarDecl *D) { |
| 309 | mGen->CompleteTentativeDefinition(D); |
| 310 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | Backend::~Backend() { |
Shih-wei Liao | 9ef2f78 | 2010-10-01 12:31:37 -0700 | [diff] [blame] | 314 | delete mpModule; |
| 315 | delete mpTargetData; |
| 316 | delete mGen; |
| 317 | delete mPerFunctionPasses; |
| 318 | delete mPerModulePasses; |
| 319 | delete mCodeGenPasses; |
| 320 | return; |
Shih-wei Liao | 462aefd | 2010-06-04 15:32:04 -0700 | [diff] [blame] | 321 | } |