forked from OSchip/llvm-project
Frontend: Factor clang::EmitBackendOutput out of CodeGenAction.
llvm-svn: 105575
This commit is contained in:
Daniel Dunbar
parent
6d5824f5bf
commit
f976d1b205
|
|
@ -0,0 +1,34 @@
|
|||
//===--- BackendUtil.h - LLVM Backend Utilities -----------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
namespace llvm {
|
||||
class Module;
|
||||
class TargetData;
|
||||
class raw_ostream;
|
||||
}
|
||||
|
||||
namespace clang {
|
||||
class Diagnostic;
|
||||
class CodeGenOptions;
|
||||
class TargetOptions;
|
||||
|
||||
enum BackendAction {
|
||||
Backend_EmitAssembly, ///< Emit native assembly files
|
||||
Backend_EmitBC, ///< Emit LLVM bitcode files
|
||||
Backend_EmitLL, ///< Emit human-readable LLVM assembly
|
||||
Backend_EmitNothing, ///< Don't emit anything (benchmarking mode)
|
||||
Backend_EmitMCNull, ///< Run CodeGen, but don't emit anything
|
||||
Backend_EmitObj ///< Emit native object files
|
||||
};
|
||||
|
||||
void EmitBackendOutput(Diagnostic &Diags, const CodeGenOptions &CGOpts,
|
||||
const TargetOptions &TOpts,
|
||||
llvm::Module *M, llvm::TargetData *TD,
|
||||
BackendAction Action, llvm::raw_ostream *OS);
|
||||
}
|
||||
|
|
@ -0,0 +1,328 @@
|
|||
//===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/Frontend/BackendUtil.h"
|
||||
#include "clang/Basic/Diagnostic.h"
|
||||
#include "clang/Basic/TargetOptions.h"
|
||||
#include "clang/CodeGen/CodeGenOptions.h"
|
||||
#include "clang/Frontend/FrontendDiagnostic.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "llvm/Bitcode/ReaderWriter.h"
|
||||
#include "llvm/CodeGen/RegAllocRegistry.h"
|
||||
#include "llvm/CodeGen/SchedulerRegistry.h"
|
||||
#include "llvm/Support/CommandLine.h"
|
||||
#include "llvm/Support/FormattedStream.h"
|
||||
#include "llvm/Support/PrettyStackTrace.h"
|
||||
#include "llvm/Support/StandardPasses.h"
|
||||
#include "llvm/Support/Timer.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Target/SubtargetFeature.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Target/TargetMachine.h"
|
||||
#include "llvm/Target/TargetOptions.h"
|
||||
#include "llvm/Target/TargetRegistry.h"
|
||||
using namespace clang;
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
|
||||
class EmitAssemblyHelper {
|
||||
Diagnostic &Diags;
|
||||
const CodeGenOptions &CodeGenOpts;
|
||||
const TargetOptions &TargetOpts;
|
||||
Module *TheModule;
|
||||
TargetData *TheTargetData;
|
||||
|
||||
Timer CodeGenerationTime;
|
||||
|
||||
mutable FunctionPassManager *CodeGenPasses;
|
||||
mutable PassManager *PerModulePasses;
|
||||
mutable FunctionPassManager *PerFunctionPasses;
|
||||
|
||||
private:
|
||||
FunctionPassManager *getCodeGenPasses() const {
|
||||
if (!CodeGenPasses) {
|
||||
CodeGenPasses = new FunctionPassManager(TheModule);
|
||||
CodeGenPasses->add(new TargetData(*TheTargetData));
|
||||
}
|
||||
return CodeGenPasses;
|
||||
}
|
||||
|
||||
PassManager *getPerModulePasses() const {
|
||||
if (!PerModulePasses) {
|
||||
PerModulePasses = new PassManager();
|
||||
PerModulePasses->add(new TargetData(*TheTargetData));
|
||||
}
|
||||
return PerModulePasses;
|
||||
}
|
||||
|
||||
FunctionPassManager *getPerFunctionPasses() const {
|
||||
if (!PerFunctionPasses) {
|
||||
PerFunctionPasses = new FunctionPassManager(TheModule);
|
||||
PerFunctionPasses->add(new TargetData(*TheTargetData));
|
||||
}
|
||||
return PerFunctionPasses;
|
||||
}
|
||||
|
||||
void CreatePasses();
|
||||
|
||||
/// AddEmitPasses - Add passes necessary to emit assembly or LLVM IR.
|
||||
///
|
||||
/// \return True on success.
|
||||
bool AddEmitPasses(BackendAction Action, formatted_raw_ostream &OS);
|
||||
|
||||
public:
|
||||
EmitAssemblyHelper(Diagnostic &_Diags,
|
||||
const CodeGenOptions &CGOpts, const TargetOptions &TOpts,
|
||||
Module *M, TargetData *TD)
|
||||
: Diags(_Diags), CodeGenOpts(CGOpts), TargetOpts(TOpts),
|
||||
TheModule(M), TheTargetData(TD),
|
||||
CodeGenerationTime("Code Generation Time"),
|
||||
CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {}
|
||||
|
||||
~EmitAssemblyHelper() {
|
||||
delete CodeGenPasses;
|
||||
delete PerModulePasses;
|
||||
delete PerFunctionPasses;
|
||||
}
|
||||
|
||||
void EmitAssembly(BackendAction Action, raw_ostream *OS);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
void EmitAssemblyHelper::CreatePasses() {
|
||||
unsigned OptLevel = CodeGenOpts.OptimizationLevel;
|
||||
CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
|
||||
|
||||
// Handle disabling of LLVM optimization, where we want to preserve the
|
||||
// internal module before any optimization.
|
||||
if (CodeGenOpts.DisableLLVMOpts) {
|
||||
OptLevel = 0;
|
||||
Inlining = CodeGenOpts.NoInlining;
|
||||
}
|
||||
|
||||
// In -O0 if checking is disabled, we don't even have per-function passes.
|
||||
if (CodeGenOpts.VerifyModule)
|
||||
getPerFunctionPasses()->add(createVerifierPass());
|
||||
|
||||
// Assume that standard function passes aren't run for -O0.
|
||||
if (OptLevel > 0)
|
||||
llvm::createStandardFunctionPasses(getPerFunctionPasses(), OptLevel);
|
||||
|
||||
llvm::Pass *InliningPass = 0;
|
||||
switch (Inlining) {
|
||||
case CodeGenOptions::NoInlining: break;
|
||||
case CodeGenOptions::NormalInlining: {
|
||||
// Set the inline threshold following llvm-gcc.
|
||||
//
|
||||
// FIXME: Derive these constants in a principled fashion.
|
||||
unsigned Threshold = 225;
|
||||
if (CodeGenOpts.OptimizeSize)
|
||||
Threshold = 75;
|
||||
else if (OptLevel > 2)
|
||||
Threshold = 275;
|
||||
InliningPass = createFunctionInliningPass(Threshold);
|
||||
break;
|
||||
}
|
||||
case CodeGenOptions::OnlyAlwaysInlining:
|
||||
InliningPass = createAlwaysInlinerPass(); // Respect always_inline
|
||||
break;
|
||||
}
|
||||
|
||||
// For now we always create per module passes.
|
||||
llvm::createStandardModulePasses(getPerModulePasses(), OptLevel,
|
||||
CodeGenOpts.OptimizeSize,
|
||||
CodeGenOpts.UnitAtATime,
|
||||
CodeGenOpts.UnrollLoops,
|
||||
CodeGenOpts.SimplifyLibCalls,
|
||||
/*HaveExceptions=*/true,
|
||||
InliningPass);
|
||||
}
|
||||
|
||||
bool EmitAssemblyHelper::AddEmitPasses(BackendAction Action,
|
||||
formatted_raw_ostream &OS) {
|
||||
// Create the TargetMachine for generating code.
|
||||
std::string Error;
|
||||
std::string Triple = TheModule->getTargetTriple();
|
||||
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
|
||||
if (!TheTarget) {
|
||||
Diags.Report(diag::err_fe_unable_to_create_target) << Error;
|
||||
return false;
|
||||
}
|
||||
|
||||
// FIXME: Expose these capabilities via actual APIs!!!! Aside from just
|
||||
// being gross, this is also totally broken if we ever care about
|
||||
// concurrency.
|
||||
llvm::NoFramePointerElim = CodeGenOpts.DisableFPElim;
|
||||
if (CodeGenOpts.FloatABI == "soft")
|
||||
llvm::FloatABIType = llvm::FloatABI::Soft;
|
||||
else if (CodeGenOpts.FloatABI == "hard")
|
||||
llvm::FloatABIType = llvm::FloatABI::Hard;
|
||||
else {
|
||||
assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
|
||||
llvm::FloatABIType = llvm::FloatABI::Default;
|
||||
}
|
||||
NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
|
||||
llvm::UseSoftFloat = CodeGenOpts.SoftFloat;
|
||||
UnwindTablesMandatory = CodeGenOpts.UnwindTables;
|
||||
|
||||
TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
|
||||
|
||||
TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
|
||||
TargetMachine::setDataSections (CodeGenOpts.DataSections);
|
||||
|
||||
// FIXME: Parse this earlier.
|
||||
if (CodeGenOpts.RelocationModel == "static") {
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::Static);
|
||||
} else if (CodeGenOpts.RelocationModel == "pic") {
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::PIC_);
|
||||
} else {
|
||||
assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
|
||||
"Invalid PIC model!");
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::DynamicNoPIC);
|
||||
}
|
||||
// FIXME: Parse this earlier.
|
||||
if (CodeGenOpts.CodeModel == "small") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Small);
|
||||
} else if (CodeGenOpts.CodeModel == "kernel") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Kernel);
|
||||
} else if (CodeGenOpts.CodeModel == "medium") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Medium);
|
||||
} else if (CodeGenOpts.CodeModel == "large") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Large);
|
||||
} else {
|
||||
assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Default);
|
||||
}
|
||||
|
||||
std::vector<const char *> BackendArgs;
|
||||
BackendArgs.push_back("clang"); // Fake program name.
|
||||
if (!CodeGenOpts.DebugPass.empty()) {
|
||||
BackendArgs.push_back("-debug-pass");
|
||||
BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
|
||||
}
|
||||
if (!CodeGenOpts.LimitFloatPrecision.empty()) {
|
||||
BackendArgs.push_back("-limit-float-precision");
|
||||
BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
|
||||
}
|
||||
if (llvm::TimePassesIsEnabled)
|
||||
BackendArgs.push_back("-time-passes");
|
||||
BackendArgs.push_back(0);
|
||||
llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
|
||||
const_cast<char **>(&BackendArgs[0]));
|
||||
|
||||
std::string FeaturesStr;
|
||||
if (TargetOpts.CPU.size() || TargetOpts.Features.size()) {
|
||||
SubtargetFeatures Features;
|
||||
Features.setCPU(TargetOpts.CPU);
|
||||
for (std::vector<std::string>::const_iterator
|
||||
it = TargetOpts.Features.begin(),
|
||||
ie = TargetOpts.Features.end(); it != ie; ++it)
|
||||
Features.AddFeature(*it);
|
||||
FeaturesStr = Features.getString();
|
||||
}
|
||||
TargetMachine *TM = TheTarget->createTargetMachine(Triple, FeaturesStr);
|
||||
|
||||
if (CodeGenOpts.RelaxAll)
|
||||
TM->setMCRelaxAll(true);
|
||||
|
||||
// Create the code generator passes.
|
||||
FunctionPassManager *PM = getCodeGenPasses();
|
||||
CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
|
||||
|
||||
switch (CodeGenOpts.OptimizationLevel) {
|
||||
default: break;
|
||||
case 0: OptLevel = CodeGenOpt::None; break;
|
||||
case 3: OptLevel = CodeGenOpt::Aggressive; break;
|
||||
}
|
||||
|
||||
// Normal mode, emit a .s or .o file by running the code generator. Note,
|
||||
// this also adds codegenerator level optimization passes.
|
||||
TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
|
||||
if (Action == Backend_EmitObj)
|
||||
CGFT = TargetMachine::CGFT_ObjectFile;
|
||||
else if (Action == Backend_EmitMCNull)
|
||||
CGFT = TargetMachine::CGFT_Null;
|
||||
else
|
||||
assert(Action == Backend_EmitAssembly && "Invalid action!");
|
||||
if (TM->addPassesToEmitFile(*PM, OS, CGFT, OptLevel,
|
||||
/*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
|
||||
Diags.Report(diag::err_fe_unable_to_interface_with_target);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void EmitAssemblyHelper::EmitAssembly(BackendAction Action, raw_ostream *OS) {
|
||||
TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
|
||||
llvm::formatted_raw_ostream FormattedOS;
|
||||
|
||||
CreatePasses();
|
||||
switch (Action) {
|
||||
case Backend_EmitNothing:
|
||||
break;
|
||||
|
||||
case Backend_EmitBC:
|
||||
getPerModulePasses()->add(createBitcodeWriterPass(*OS));
|
||||
break;
|
||||
|
||||
case Backend_EmitLL:
|
||||
FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
|
||||
getPerModulePasses()->add(createPrintModulePass(&FormattedOS));
|
||||
break;
|
||||
|
||||
default:
|
||||
FormattedOS.setStream(*OS, formatted_raw_ostream::PRESERVE_STREAM);
|
||||
if (!AddEmitPasses(Action, FormattedOS))
|
||||
return;
|
||||
}
|
||||
|
||||
// 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) {
|
||||
PrettyStackTraceString CrashInfo("Per-function optimization");
|
||||
|
||||
PerFunctionPasses->doInitialization();
|
||||
for (Module::iterator I = TheModule->begin(),
|
||||
E = TheModule->end(); I != E; ++I)
|
||||
if (!I->isDeclaration())
|
||||
PerFunctionPasses->run(*I);
|
||||
PerFunctionPasses->doFinalization();
|
||||
}
|
||||
|
||||
if (PerModulePasses) {
|
||||
PrettyStackTraceString CrashInfo("Per-module optimization passes");
|
||||
PerModulePasses->run(*TheModule);
|
||||
}
|
||||
|
||||
if (CodeGenPasses) {
|
||||
PrettyStackTraceString CrashInfo("Code generation");
|
||||
|
||||
CodeGenPasses->doInitialization();
|
||||
for (Module::iterator I = TheModule->begin(),
|
||||
E = TheModule->end(); I != E; ++I)
|
||||
if (!I->isDeclaration())
|
||||
CodeGenPasses->run(*I);
|
||||
CodeGenPasses->doFinalization();
|
||||
}
|
||||
}
|
||||
|
||||
void clang::EmitBackendOutput(Diagnostic &Diags, const CodeGenOptions &CGOpts,
|
||||
const TargetOptions &TOpts, Module *M,
|
||||
TargetData *TD, BackendAction Action,
|
||||
raw_ostream *OS) {
|
||||
EmitAssemblyHelper AsmHelper(Diags, CGOpts, TOpts, M, TD);
|
||||
|
||||
AsmHelper.EmitAssembly(Action, OS);
|
||||
}
|
||||
|
|
@ -5,6 +5,7 @@ add_clang_library(clangFrontend
|
|||
ASTMerge.cpp
|
||||
ASTUnit.cpp
|
||||
AnalysisConsumer.cpp
|
||||
BackendUtil.cpp
|
||||
BoostConAction.cpp
|
||||
CacheTokens.cpp
|
||||
CodeGenAction.cpp
|
||||
|
|
|
|||
|
|
@ -10,82 +10,40 @@
|
|||
#include "clang/Frontend/CodeGenAction.h"
|
||||
#include "clang/Basic/SourceManager.h"
|
||||
#include "clang/Basic/TargetInfo.h"
|
||||
#include "clang/Basic/TargetOptions.h"
|
||||
#include "clang/AST/ASTConsumer.h"
|
||||
#include "clang/AST/ASTContext.h"
|
||||
#include "clang/AST/DeclGroup.h"
|
||||
#include "clang/CodeGen/CodeGenOptions.h"
|
||||
#include "clang/CodeGen/ModuleBuilder.h"
|
||||
#include "clang/Frontend/ASTConsumers.h"
|
||||
#include "clang/Frontend/BackendUtil.h"
|
||||
#include "clang/Frontend/CompilerInstance.h"
|
||||
#include "clang/Frontend/FrontendDiagnostic.h"
|
||||
#include "llvm/LLVMContext.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/ADT/OwningPtr.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "llvm/Analysis/CallGraph.h"
|
||||
#include "llvm/Analysis/Verifier.h"
|
||||
#include "llvm/Bitcode/ReaderWriter.h"
|
||||
#include "llvm/CodeGen/RegAllocRegistry.h"
|
||||
#include "llvm/CodeGen/SchedulerRegistry.h"
|
||||
#include "llvm/Support/FormattedStream.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Support/SourceMgr.h"
|
||||
#include "llvm/Support/StandardPasses.h"
|
||||
#include "llvm/Support/Timer.h"
|
||||
#include "llvm/Target/SubtargetFeature.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Target/TargetMachine.h"
|
||||
#include "llvm/Target/TargetOptions.h"
|
||||
#include "llvm/Target/TargetRegistry.h"
|
||||
using namespace clang;
|
||||
using namespace llvm;
|
||||
|
||||
namespace {
|
||||
enum BackendAction {
|
||||
Backend_EmitAssembly, ///< Emit native assembly files
|
||||
Backend_EmitBC, ///< Emit LLVM bitcode files
|
||||
Backend_EmitLL, ///< Emit human-readable LLVM assembly
|
||||
Backend_EmitNothing, ///< Don't emit anything (benchmarking mode)
|
||||
Backend_EmitMCNull, ///< Run CodeGen, but don't emit anything
|
||||
Backend_EmitObj ///< Emit native object files
|
||||
};
|
||||
|
||||
class BackendConsumer : public ASTConsumer {
|
||||
Diagnostic &Diags;
|
||||
BackendAction Action;
|
||||
const CodeGenOptions &CodeGenOpts;
|
||||
const TargetOptions &TargetOpts;
|
||||
llvm::raw_ostream *AsmOutStream;
|
||||
llvm::formatted_raw_ostream FormattedOutStream;
|
||||
ASTContext *Context;
|
||||
|
||||
Timer LLVMIRGeneration;
|
||||
Timer CodeGenerationTime;
|
||||
|
||||
llvm::OwningPtr<CodeGenerator> Gen;
|
||||
|
||||
llvm::OwningPtr<llvm::Module> TheModule;
|
||||
llvm::TargetData *TheTargetData;
|
||||
|
||||
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.
|
||||
///
|
||||
/// \return True on success.
|
||||
bool AddEmitPasses();
|
||||
|
||||
void EmitAssembly();
|
||||
|
||||
public:
|
||||
BackendConsumer(BackendAction action, Diagnostic &_Diags,
|
||||
const CodeGenOptions &compopts,
|
||||
|
|
@ -98,23 +56,13 @@ namespace {
|
|||
TargetOpts(targetopts),
|
||||
AsmOutStream(OS),
|
||||
LLVMIRGeneration("LLVM IR Generation Time"),
|
||||
CodeGenerationTime("Code Generation Time"),
|
||||
Gen(CreateLLVMCodeGen(Diags, infile, compopts, C)),
|
||||
TheTargetData(0),
|
||||
CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) {
|
||||
|
||||
if (AsmOutStream)
|
||||
FormattedOutStream.setStream(*AsmOutStream,
|
||||
formatted_raw_ostream::PRESERVE_STREAM);
|
||||
|
||||
TheTargetData(0) {
|
||||
llvm::TimePassesIsEnabled = TimePasses;
|
||||
}
|
||||
|
||||
~BackendConsumer() {
|
||||
delete TheTargetData;
|
||||
delete CodeGenPasses;
|
||||
delete PerModulePasses;
|
||||
delete PerFunctionPasses;
|
||||
}
|
||||
|
||||
llvm::Module *takeModule() { return TheModule.take(); }
|
||||
|
|
@ -160,12 +108,35 @@ namespace {
|
|||
LLVMIRGeneration.stopTimer();
|
||||
}
|
||||
|
||||
// EmitAssembly times and registers crash info itself.
|
||||
EmitAssembly();
|
||||
// Silently ignore if we weren't initialized for some reason.
|
||||
if (!TheModule || !TheTargetData)
|
||||
return;
|
||||
|
||||
// Force a flush here in case we never get released.
|
||||
if (AsmOutStream)
|
||||
FormattedOutStream.flush();
|
||||
// Make sure IR generation is happy with the module. This is released by
|
||||
// the module provider.
|
||||
Module *M = Gen->ReleaseModule();
|
||||
if (!M) {
|
||||
// The module has been released by IR gen on failures, do not double
|
||||
// free.
|
||||
TheModule.take();
|
||||
return;
|
||||
}
|
||||
|
||||
assert(TheModule.get() == M &&
|
||||
"Unexpected module change during IR generation");
|
||||
|
||||
// Install an inline asm handler so that diagnostics get printed through
|
||||
// our diagnostics hooks.
|
||||
LLVMContext &Ctx = TheModule->getContext();
|
||||
void *OldHandler = Ctx.getInlineAsmDiagnosticHandler();
|
||||
void *OldContext = Ctx.getInlineAsmDiagnosticContext();
|
||||
Ctx.setInlineAsmDiagnosticHandler((void*)(intptr_t)InlineAsmDiagHandler,
|
||||
this);
|
||||
|
||||
EmitBackendOutput(Diags, CodeGenOpts, TargetOpts,
|
||||
TheModule.get(), TheTargetData, Action, AsmOutStream);
|
||||
|
||||
Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
|
||||
}
|
||||
|
||||
virtual void HandleTagDeclDefinition(TagDecl *D) {
|
||||
|
|
@ -194,274 +165,6 @@ namespace {
|
|||
};
|
||||
}
|
||||
|
||||
FunctionPassManager *BackendConsumer::getCodeGenPasses() const {
|
||||
if (!CodeGenPasses) {
|
||||
CodeGenPasses = new FunctionPassManager(&*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(&*TheModule);
|
||||
PerFunctionPasses->add(new TargetData(*TheTargetData));
|
||||
}
|
||||
|
||||
return PerFunctionPasses;
|
||||
}
|
||||
|
||||
bool BackendConsumer::AddEmitPasses() {
|
||||
if (Action == Backend_EmitNothing)
|
||||
return true;
|
||||
|
||||
if (Action == Backend_EmitBC) {
|
||||
getPerModulePasses()->add(createBitcodeWriterPass(FormattedOutStream));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (Action == Backend_EmitLL) {
|
||||
getPerModulePasses()->add(createPrintModulePass(&FormattedOutStream));
|
||||
return true;
|
||||
}
|
||||
|
||||
// Create the TargetMachine for generating code.
|
||||
std::string Error;
|
||||
std::string Triple = TheModule->getTargetTriple();
|
||||
const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
|
||||
if (!TheTarget) {
|
||||
Diags.Report(diag::err_fe_unable_to_create_target) << Error;
|
||||
return false;
|
||||
}
|
||||
|
||||
// FIXME: Expose these capabilities via actual APIs!!!! Aside from just
|
||||
// being gross, this is also totally broken if we ever care about
|
||||
// concurrency.
|
||||
llvm::NoFramePointerElim = CodeGenOpts.DisableFPElim;
|
||||
if (CodeGenOpts.FloatABI == "soft")
|
||||
llvm::FloatABIType = llvm::FloatABI::Soft;
|
||||
else if (CodeGenOpts.FloatABI == "hard")
|
||||
llvm::FloatABIType = llvm::FloatABI::Hard;
|
||||
else {
|
||||
assert(CodeGenOpts.FloatABI.empty() && "Invalid float abi!");
|
||||
llvm::FloatABIType = llvm::FloatABI::Default;
|
||||
}
|
||||
NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
|
||||
llvm::UseSoftFloat = CodeGenOpts.SoftFloat;
|
||||
UnwindTablesMandatory = CodeGenOpts.UnwindTables;
|
||||
|
||||
TargetMachine::setAsmVerbosityDefault(CodeGenOpts.AsmVerbose);
|
||||
|
||||
TargetMachine::setFunctionSections(CodeGenOpts.FunctionSections);
|
||||
TargetMachine::setDataSections (CodeGenOpts.DataSections);
|
||||
|
||||
// FIXME: Parse this earlier.
|
||||
if (CodeGenOpts.RelocationModel == "static") {
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::Static);
|
||||
} else if (CodeGenOpts.RelocationModel == "pic") {
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::PIC_);
|
||||
} else {
|
||||
assert(CodeGenOpts.RelocationModel == "dynamic-no-pic" &&
|
||||
"Invalid PIC model!");
|
||||
TargetMachine::setRelocationModel(llvm::Reloc::DynamicNoPIC);
|
||||
}
|
||||
// FIXME: Parse this earlier.
|
||||
if (CodeGenOpts.CodeModel == "small") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Small);
|
||||
} else if (CodeGenOpts.CodeModel == "kernel") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Kernel);
|
||||
} else if (CodeGenOpts.CodeModel == "medium") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Medium);
|
||||
} else if (CodeGenOpts.CodeModel == "large") {
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Large);
|
||||
} else {
|
||||
assert(CodeGenOpts.CodeModel.empty() && "Invalid code model!");
|
||||
TargetMachine::setCodeModel(llvm::CodeModel::Default);
|
||||
}
|
||||
|
||||
std::vector<const char *> BackendArgs;
|
||||
BackendArgs.push_back("clang"); // Fake program name.
|
||||
if (!CodeGenOpts.DebugPass.empty()) {
|
||||
BackendArgs.push_back("-debug-pass");
|
||||
BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
|
||||
}
|
||||
if (!CodeGenOpts.LimitFloatPrecision.empty()) {
|
||||
BackendArgs.push_back("-limit-float-precision");
|
||||
BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
|
||||
}
|
||||
if (llvm::TimePassesIsEnabled)
|
||||
BackendArgs.push_back("-time-passes");
|
||||
BackendArgs.push_back(0);
|
||||
llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
|
||||
const_cast<char **>(&BackendArgs[0]));
|
||||
|
||||
std::string FeaturesStr;
|
||||
if (TargetOpts.CPU.size() || TargetOpts.Features.size()) {
|
||||
SubtargetFeatures Features;
|
||||
Features.setCPU(TargetOpts.CPU);
|
||||
for (std::vector<std::string>::const_iterator
|
||||
it = TargetOpts.Features.begin(),
|
||||
ie = TargetOpts.Features.end(); it != ie; ++it)
|
||||
Features.AddFeature(*it);
|
||||
FeaturesStr = Features.getString();
|
||||
}
|
||||
TargetMachine *TM = TheTarget->createTargetMachine(Triple, FeaturesStr);
|
||||
|
||||
if (CodeGenOpts.RelaxAll)
|
||||
TM->setMCRelaxAll(true);
|
||||
|
||||
// Create the code generator passes.
|
||||
FunctionPassManager *PM = getCodeGenPasses();
|
||||
CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
|
||||
|
||||
switch (CodeGenOpts.OptimizationLevel) {
|
||||
default: break;
|
||||
case 0: OptLevel = CodeGenOpt::None; break;
|
||||
case 3: OptLevel = CodeGenOpt::Aggressive; break;
|
||||
}
|
||||
|
||||
// Normal mode, emit a .s or .o file by running the code generator. Note,
|
||||
// this also adds codegenerator level optimization passes.
|
||||
TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
|
||||
if (Action == Backend_EmitObj)
|
||||
CGFT = TargetMachine::CGFT_ObjectFile;
|
||||
else if (Action == Backend_EmitMCNull)
|
||||
CGFT = TargetMachine::CGFT_Null;
|
||||
else
|
||||
assert(Action == Backend_EmitAssembly && "Invalid action!");
|
||||
if (TM->addPassesToEmitFile(*PM, FormattedOutStream, CGFT, OptLevel,
|
||||
/*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
|
||||
Diags.Report(diag::err_fe_unable_to_interface_with_target);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void BackendConsumer::CreatePasses() {
|
||||
unsigned OptLevel = CodeGenOpts.OptimizationLevel;
|
||||
CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
|
||||
|
||||
// Handle disabling of LLVM optimization, where we want to preserve the
|
||||
// internal module before any optimization.
|
||||
if (CodeGenOpts.DisableLLVMOpts) {
|
||||
OptLevel = 0;
|
||||
Inlining = CodeGenOpts.NoInlining;
|
||||
}
|
||||
|
||||
// In -O0 if checking is disabled, we don't even have per-function passes.
|
||||
if (CodeGenOpts.VerifyModule)
|
||||
getPerFunctionPasses()->add(createVerifierPass());
|
||||
|
||||
// Assume that standard function passes aren't run for -O0.
|
||||
if (OptLevel > 0)
|
||||
llvm::createStandardFunctionPasses(getPerFunctionPasses(), OptLevel);
|
||||
|
||||
llvm::Pass *InliningPass = 0;
|
||||
switch (Inlining) {
|
||||
case CodeGenOptions::NoInlining: break;
|
||||
case CodeGenOptions::NormalInlining: {
|
||||
// Set the inline threshold following llvm-gcc.
|
||||
//
|
||||
// FIXME: Derive these constants in a principled fashion.
|
||||
unsigned Threshold = 225;
|
||||
if (CodeGenOpts.OptimizeSize)
|
||||
Threshold = 75;
|
||||
else if (OptLevel > 2)
|
||||
Threshold = 275;
|
||||
InliningPass = createFunctionInliningPass(Threshold);
|
||||
break;
|
||||
}
|
||||
case CodeGenOptions::OnlyAlwaysInlining:
|
||||
InliningPass = createAlwaysInlinerPass(); // Respect always_inline
|
||||
break;
|
||||
}
|
||||
|
||||
// For now we always create per module passes.
|
||||
PassManager *PM = getPerModulePasses();
|
||||
llvm::createStandardModulePasses(PM, OptLevel, CodeGenOpts.OptimizeSize,
|
||||
CodeGenOpts.UnitAtATime,
|
||||
CodeGenOpts.UnrollLoops,
|
||||
CodeGenOpts.SimplifyLibCalls,
|
||||
/*HaveExceptions=*/true,
|
||||
InliningPass);
|
||||
}
|
||||
|
||||
/// 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;
|
||||
|
||||
TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : 0);
|
||||
|
||||
// Make sure IR generation is happy with the module. This is
|
||||
// released by the module provider.
|
||||
Module *M = Gen->ReleaseModule();
|
||||
if (!M) {
|
||||
// The module has been released by IR gen on failures, do not
|
||||
// double free.
|
||||
TheModule.take();
|
||||
return;
|
||||
}
|
||||
|
||||
assert(TheModule.get() == M &&
|
||||
"Unexpected module change during IR generation");
|
||||
|
||||
CreatePasses();
|
||||
if (!AddEmitPasses())
|
||||
return;
|
||||
|
||||
// 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) {
|
||||
PrettyStackTraceString CrashInfo("Per-function optimization");
|
||||
|
||||
PerFunctionPasses->doInitialization();
|
||||
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
|
||||
if (!I->isDeclaration())
|
||||
PerFunctionPasses->run(*I);
|
||||
PerFunctionPasses->doFinalization();
|
||||
}
|
||||
|
||||
if (PerModulePasses) {
|
||||
PrettyStackTraceString CrashInfo("Per-module optimization passes");
|
||||
PerModulePasses->run(*M);
|
||||
}
|
||||
|
||||
if (CodeGenPasses) {
|
||||
PrettyStackTraceString CrashInfo("Code generation");
|
||||
|
||||
// Install an inline asm handler so that diagnostics get printed through our
|
||||
// diagnostics hooks.
|
||||
LLVMContext &Ctx = TheModule->getContext();
|
||||
void *OldHandler = Ctx.getInlineAsmDiagnosticHandler();
|
||||
void *OldContext = Ctx.getInlineAsmDiagnosticContext();
|
||||
Ctx.setInlineAsmDiagnosticHandler((void*)(intptr_t)InlineAsmDiagHandler,
|
||||
this);
|
||||
|
||||
CodeGenPasses->doInitialization();
|
||||
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
|
||||
if (!I->isDeclaration())
|
||||
CodeGenPasses->run(*I);
|
||||
CodeGenPasses->doFinalization();
|
||||
|
||||
Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
|
||||
}
|
||||
}
|
||||
|
||||
/// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
|
||||
/// buffer to be a valid FullSourceLoc.
|
||||
static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
|
||||
|
|
|
|||
Loading…
Reference in New Issue