| /* |
| * Copyright 2010, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "slang_backend.h" |
| |
| #include <string> |
| #include <vector> |
| |
| #include "bcinfo/BitcodeWrapper.h" |
| |
| #include "clang/AST/ASTContext.h" |
| #include "clang/AST/Decl.h" |
| #include "clang/AST/DeclGroup.h" |
| |
| #include "clang/Basic/Diagnostic.h" |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/Basic/TargetOptions.h" |
| |
| #include "clang/CodeGen/ModuleBuilder.h" |
| |
| #include "clang/Frontend/CodeGenOptions.h" |
| #include "clang/Frontend/FrontendDiagnostic.h" |
| |
| #include "llvm/Assembly/PrintModulePass.h" |
| |
| #include "llvm/Bitcode/ReaderWriter.h" |
| |
| #include "llvm/CodeGen/RegAllocRegistry.h" |
| #include "llvm/CodeGen/SchedulerRegistry.h" |
| |
| #include "llvm/LLVMContext.h" |
| #include "llvm/Module.h" |
| #include "llvm/Metadata.h" |
| |
| #include "llvm/Transforms/IPO/PassManagerBuilder.h" |
| |
| #include "llvm/Target/TargetData.h" |
| #include "llvm/Target/TargetMachine.h" |
| #include "llvm/Target/TargetOptions.h" |
| #include "llvm/Support/TargetRegistry.h" |
| |
| #include "llvm/MC/SubtargetFeature.h" |
| |
| #include "slang_assert.h" |
| #include "BitWriter_2_9/ReaderWriter_2_9.h" |
| #include "BitWriter_2_9_func/ReaderWriter_2_9_func.h" |
| |
| namespace slang { |
| |
| void Backend::CreateFunctionPasses() { |
| if (!mPerFunctionPasses) { |
| mPerFunctionPasses = new llvm::FunctionPassManager(mpModule); |
| mPerFunctionPasses->add(new llvm::TargetData(mpModule)); |
| |
| llvm::PassManagerBuilder PMBuilder; |
| PMBuilder.OptLevel = mCodeGenOpts.OptimizationLevel; |
| PMBuilder.populateFunctionPassManager(*mPerFunctionPasses); |
| } |
| return; |
| } |
| |
| void Backend::CreateModulePasses() { |
| if (!mPerModulePasses) { |
| mPerModulePasses = new llvm::PassManager(); |
| mPerModulePasses->add(new llvm::TargetData(mpModule)); |
| |
| llvm::PassManagerBuilder PMBuilder; |
| PMBuilder.OptLevel = mCodeGenOpts.OptimizationLevel; |
| PMBuilder.SizeLevel = mCodeGenOpts.OptimizeSize; |
| PMBuilder.SizeLevel = mCodeGenOpts.OptimizeSize; |
| if (mCodeGenOpts.UnitAtATime) { |
| PMBuilder.DisableUnitAtATime = 0; |
| } else { |
| PMBuilder.DisableUnitAtATime = 1; |
| } |
| |
| if (mCodeGenOpts.UnrollLoops) { |
| PMBuilder.DisableUnrollLoops = 0; |
| } else { |
| PMBuilder.DisableUnrollLoops = 1; |
| } |
| |
| PMBuilder.DisableSimplifyLibCalls = false; |
| PMBuilder.populateModulePassManager(*mPerModulePasses); |
| } |
| return; |
| } |
| |
| bool Backend::CreateCodeGenPasses() { |
| if ((mOT != Slang::OT_Assembly) && (mOT != Slang::OT_Object)) |
| return true; |
| |
| // Now we add passes for code emitting |
| if (mCodeGenPasses) { |
| return true; |
| } else { |
| mCodeGenPasses = new llvm::FunctionPassManager(mpModule); |
| mCodeGenPasses->add(new llvm::TargetData(mpModule)); |
| } |
| |
| // Create the TargetMachine for generating code. |
| std::string Triple = mpModule->getTargetTriple(); |
| |
| std::string Error; |
| const llvm::Target* TargetInfo = |
| llvm::TargetRegistry::lookupTarget(Triple, Error); |
| if (TargetInfo == NULL) { |
| mDiagEngine.Report(clang::diag::err_fe_unable_to_create_target) << Error; |
| return false; |
| } |
| |
| llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim; |
| |
| // Use hardware FPU. |
| // |
| // FIXME: Need to detect the CPU capability and decide whether to use softfp. |
| // To use softfp, change following 2 lines to |
| // |
| // llvm::FloatABIType = llvm::FloatABI::Soft; |
| // llvm::UseSoftFloat = true; |
| llvm::FloatABIType = llvm::FloatABI::Hard; |
| llvm::UseSoftFloat = false; |
| |
| // BCC needs all unknown symbols resolved at compilation time. So we don't |
| // need any relocation model. |
| llvm::Reloc::Model RM = llvm::Reloc::Static; |
| |
| // This is set for the linker (specify how large of the virtual addresses we |
| // can access for all unknown symbols.) |
| llvm::CodeModel::Model CM; |
| if (mpModule->getPointerSize() == llvm::Module::Pointer32) { |
| CM = llvm::CodeModel::Small; |
| } else { |
| // The target may have pointer size greater than 32 (e.g. x86_64 |
| // architecture) may need large data address model |
| CM = llvm::CodeModel::Medium; |
| } |
| |
| // Setup feature string |
| std::string FeaturesStr; |
| if (mTargetOpts.CPU.size() || mTargetOpts.Features.size()) { |
| llvm::SubtargetFeatures Features; |
| |
| for (std::vector<std::string>::const_iterator |
| I = mTargetOpts.Features.begin(), E = mTargetOpts.Features.end(); |
| I != E; |
| I++) |
| Features.AddFeature(*I); |
| |
| FeaturesStr = Features.getString(); |
| } |
| |
| llvm::TargetMachine *TM = |
| TargetInfo->createTargetMachine(Triple, mTargetOpts.CPU, FeaturesStr, |
| RM, CM); |
| |
| // Register scheduler |
| llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler); |
| |
| // Register allocation policy: |
| // createFastRegisterAllocator: fast but bad quality |
| // createGreedyRegisterAllocator: not so fast but good quality |
| llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ? |
| llvm::createFastRegisterAllocator : |
| llvm::createGreedyRegisterAllocator); |
| |
| llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default; |
| if (mCodeGenOpts.OptimizationLevel == 0) { |
| OptLevel = llvm::CodeGenOpt::None; |
| } else if (mCodeGenOpts.OptimizationLevel == 3) { |
| OptLevel = llvm::CodeGenOpt::Aggressive; |
| } |
| |
| llvm::TargetMachine::CodeGenFileType CGFT = |
| llvm::TargetMachine::CGFT_AssemblyFile; |
| if (mOT == Slang::OT_Object) { |
| CGFT = llvm::TargetMachine::CGFT_ObjectFile; |
| } |
| if (TM->addPassesToEmitFile(*mCodeGenPasses, FormattedOutStream, |
| CGFT, OptLevel)) { |
| mDiagEngine.Report(clang::diag::err_fe_unable_to_interface_with_target); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| Backend::Backend(clang::DiagnosticsEngine *DiagEngine, |
| const clang::CodeGenOptions &CodeGenOpts, |
| const clang::TargetOptions &TargetOpts, |
| PragmaList *Pragmas, |
| llvm::raw_ostream *OS, |
| Slang::OutputType OT) |
| : ASTConsumer(), |
| mCodeGenOpts(CodeGenOpts), |
| mTargetOpts(TargetOpts), |
| mpModule(NULL), |
| mpOS(OS), |
| mOT(OT), |
| mGen(NULL), |
| mPerFunctionPasses(NULL), |
| mPerModulePasses(NULL), |
| mCodeGenPasses(NULL), |
| mLLVMContext(llvm::getGlobalContext()), |
| mDiagEngine(*DiagEngine), |
| mPragmas(Pragmas) { |
| FormattedOutStream.setStream(*mpOS, |
| llvm::formatted_raw_ostream::PRESERVE_STREAM); |
| mGen = CreateLLVMCodeGen(mDiagEngine, "", mCodeGenOpts, mLLVMContext); |
| return; |
| } |
| |
| void Backend::Initialize(clang::ASTContext &Ctx) { |
| mGen->Initialize(Ctx); |
| |
| mpModule = mGen->GetModule(); |
| |
| return; |
| } |
| |
| // Encase the Bitcode in a wrapper containing RS version information. |
| void Backend::WrapBitcode(llvm::raw_string_ostream &Bitcode) { |
| struct bcinfo::BCWrapperHeader header; |
| header.Magic = 0x0B17C0DE; |
| header.Version = 0; |
| header.BitcodeOffset = sizeof(header); |
| header.BitcodeSize = Bitcode.str().length(); |
| header.HeaderVersion = 0; |
| header.TargetAPI = getTargetAPI(); |
| |
| // Write out the bitcode wrapper. |
| FormattedOutStream.write((const char*) &header, sizeof(header)); |
| |
| // Write out the actual encoded bitcode. |
| FormattedOutStream << Bitcode.str(); |
| return; |
| } |
| |
| bool Backend::HandleTopLevelDecl(clang::DeclGroupRef D) { |
| return mGen->HandleTopLevelDecl(D); |
| } |
| |
| void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) { |
| HandleTranslationUnitPre(Ctx); |
| |
| mGen->HandleTranslationUnit(Ctx); |
| |
| // Here, we complete a translation unit (whole translation unit is now in LLVM |
| // IR). Now, interact with LLVM backend to generate actual machine code (asm |
| // or machine code, whatever.) |
| |
| // Silently ignore if we weren't initialized for some reason. |
| if (!mpModule) |
| return; |
| |
| llvm::Module *M = mGen->ReleaseModule(); |
| if (!M) { |
| // The module has been released by IR gen on failures, do not double free. |
| mpModule = NULL; |
| return; |
| } |
| |
| slangAssert(mpModule == M && |
| "Unexpected module change during LLVM IR generation"); |
| |
| // Insert #pragma information into metadata section of module |
| if (!mPragmas->empty()) { |
| llvm::NamedMDNode *PragmaMetadata = |
| mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName); |
| for (PragmaList::const_iterator I = mPragmas->begin(), E = mPragmas->end(); |
| I != E; |
| I++) { |
| llvm::SmallVector<llvm::Value*, 2> Pragma; |
| // Name goes first |
| Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first)); |
| // And then value |
| Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second)); |
| |
| // Create MDNode and insert into PragmaMetadata |
| PragmaMetadata->addOperand( |
| llvm::MDNode::get(mLLVMContext, Pragma)); |
| } |
| } |
| |
| HandleTranslationUnitPost(mpModule); |
| |
| // Create passes for optimization and code emission |
| |
| // Create and run per-function passes |
| CreateFunctionPasses(); |
| if (mPerFunctionPasses) { |
| mPerFunctionPasses->doInitialization(); |
| |
| for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end(); |
| I != E; |
| I++) |
| if (!I->isDeclaration()) |
| mPerFunctionPasses->run(*I); |
| |
| mPerFunctionPasses->doFinalization(); |
| } |
| |
| // Create and run module passes |
| CreateModulePasses(); |
| if (mPerModulePasses) |
| mPerModulePasses->run(*mpModule); |
| |
| switch (mOT) { |
| case Slang::OT_Assembly: |
| case Slang::OT_Object: { |
| if (!CreateCodeGenPasses()) |
| return; |
| |
| mCodeGenPasses->doInitialization(); |
| |
| for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end(); |
| I != E; |
| I++) |
| if (!I->isDeclaration()) |
| mCodeGenPasses->run(*I); |
| |
| mCodeGenPasses->doFinalization(); |
| break; |
| } |
| case Slang::OT_LLVMAssembly: { |
| llvm::PassManager *LLEmitPM = new llvm::PassManager(); |
| LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream)); |
| LLEmitPM->run(*mpModule); |
| break; |
| } |
| case Slang::OT_Bitcode: { |
| llvm::PassManager *BCEmitPM = new llvm::PassManager(); |
| std::string BCStr; |
| llvm::raw_string_ostream Bitcode(BCStr); |
| unsigned int TargetAPI = getTargetAPI(); |
| switch (TargetAPI) { |
| case SLANG_HC_TARGET_API: |
| case SLANG_HC_MR1_TARGET_API: |
| case SLANG_HC_MR2_TARGET_API: { |
| // Pre-ICS targets must use the LLVM 2.9 BitcodeWriter |
| BCEmitPM->add(llvm_2_9::createBitcodeWriterPass(Bitcode)); |
| break; |
| } |
| case SLANG_ICS_TARGET_API: |
| case SLANG_ICS_MR1_TARGET_API: { |
| // ICS targets must use the LLVM 2.9_func BitcodeWriter |
| BCEmitPM->add(llvm_2_9_func::createBitcodeWriterPass(Bitcode)); |
| break; |
| } |
| default: { |
| if (TargetAPI < SLANG_MINIMUM_TARGET_API || |
| TargetAPI > SLANG_MAXIMUM_TARGET_API) { |
| slangAssert(false && "Invalid target API value"); |
| } |
| BCEmitPM->add(llvm::createBitcodeWriterPass(Bitcode)); |
| break; |
| } |
| } |
| |
| BCEmitPM->run(*mpModule); |
| WrapBitcode(Bitcode); |
| break; |
| } |
| case Slang::OT_Nothing: { |
| return; |
| } |
| default: { |
| slangAssert(false && "Unknown output type"); |
| } |
| } |
| |
| FormattedOutStream.flush(); |
| |
| return; |
| } |
| |
| void Backend::HandleTagDeclDefinition(clang::TagDecl *D) { |
| mGen->HandleTagDeclDefinition(D); |
| return; |
| } |
| |
| void Backend::CompleteTentativeDefinition(clang::VarDecl *D) { |
| mGen->CompleteTentativeDefinition(D); |
| return; |
| } |
| |
| Backend::~Backend() { |
| delete mpModule; |
| delete mGen; |
| delete mPerFunctionPasses; |
| delete mPerModulePasses; |
| delete mCodeGenPasses; |
| return; |
| } |
| |
| } // namespace slang |