2003-06-20 15:49:04 +00:00
|
|
|
//===-- llc.cpp - Implement the LLVM Native Code Generator ----------------===//
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:44:31 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-09-07 22:20:50 +00:00
|
|
|
//
|
2004-03-16 21:47:20 +00:00
|
|
|
// This is the llc code generator driver. It provides a convenient
|
2005-04-22 00:00:37 +00:00
|
|
|
// command-line interface for generating native assembly-language code
|
2007-07-05 17:07:56 +00:00
|
|
|
// or C code, given LLVM bitcode.
|
2001-09-07 22:20:50 +00:00
|
|
|
//
|
2001-10-04 01:40:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-07-21 12:42:29 +00:00
|
|
|
|
2013-06-19 02:26:00 +00:00
|
|
|
|
2015-03-01 21:28:53 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2009-08-03 04:03:51 +00:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2015-01-15 02:16:27 +00:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
2012-10-18 23:22:48 +00:00
|
|
|
#include "llvm/CodeGen/CommandFlags.h"
|
2009-08-03 04:03:51 +00:00
|
|
|
#include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
|
|
|
|
#include "llvm/CodeGen/LinkAllCodegenComponents.h"
|
2015-05-21 20:54:45 +00:00
|
|
|
#include "llvm/CodeGen/MIR/MIRParser.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-01-13 08:04:33 +00:00
|
|
|
#include "llvm/IR/IRPrintingPasses.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2015-02-13 10:01:29 +00:00
|
|
|
#include "llvm/IR/LegacyPassManager.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Module.h"
|
2015-03-27 22:04:28 +00:00
|
|
|
#include "llvm/IR/Verifier.h"
|
2013-03-26 02:25:37 +00:00
|
|
|
#include "llvm/IRReader/IRReader.h"
|
2011-06-29 01:14:12 +00:00
|
|
|
#include "llvm/MC/SubtargetFeature.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Pass.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2010-01-05 01:30:21 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2014-04-29 23:26:49 +00:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2009-07-14 20:18:05 +00:00
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/Host.h"
|
2006-12-06 01:18:01 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/PluginLoader.h"
|
2009-03-06 05:34:10 +00:00
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Signals.h"
|
2013-03-26 02:25:37 +00:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2011-08-24 18:08:43 +00:00
|
|
|
#include "llvm/Support/TargetRegistry.h"
|
|
|
|
#include "llvm/Support/TargetSelect.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/ToolOutputFile.h"
|
2009-08-03 04:03:51 +00:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2014-08-04 21:25:23 +00:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2004-07-04 12:20:55 +00:00
|
|
|
#include <memory>
|
2003-11-11 22:41:34 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2002-09-16 16:35:34 +00:00
|
|
|
// General options for llc. Other pass-specific options are specified
|
|
|
|
// within the corresponding llc passes, and target-specific options
|
|
|
|
// and back-end code generation options are specified with the target machine.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-04-25 05:26:11 +00:00
|
|
|
static cl::opt<std::string>
|
2007-07-05 17:07:56 +00:00
|
|
|
InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
|
2002-07-22 02:10:13 +00:00
|
|
|
|
2003-04-25 05:26:11 +00:00
|
|
|
static cl::opt<std::string>
|
2002-07-22 02:10:13 +00:00
|
|
|
OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
|
|
|
|
|
2012-11-30 21:42:47 +00:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
TimeCompilations("time-compilations", cl::Hidden, cl::init(1u),
|
|
|
|
cl::value_desc("N"),
|
|
|
|
cl::desc("Repeat compilation N times for timing"));
|
|
|
|
|
2014-02-21 03:13:54 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
NoIntegratedAssembler("no-integrated-as", cl::Hidden,
|
|
|
|
cl::desc("Disable integrated assembler"));
|
|
|
|
|
2009-05-04 23:05:19 +00:00
|
|
|
// Determine optimization level.
|
2009-04-29 23:29:43 +00:00
|
|
|
static cl::opt<char>
|
2009-04-29 00:15:41 +00:00
|
|
|
OptLevel("O",
|
2009-05-04 23:05:19 +00:00
|
|
|
cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
|
|
|
|
"(default = '-O2')"),
|
2009-04-29 00:15:41 +00:00
|
|
|
cl::Prefix,
|
|
|
|
cl::ZeroOrMore,
|
2009-04-29 23:29:43 +00:00
|
|
|
cl::init(' '));
|
2005-11-08 02:12:17 +00:00
|
|
|
|
2005-12-16 04:59:57 +00:00
|
|
|
static cl::opt<std::string>
|
2005-12-16 05:19:55 +00:00
|
|
|
TargetTriple("mtriple", cl::desc("Override target triple for module"));
|
2005-11-08 02:12:17 +00:00
|
|
|
|
2014-05-21 21:05:05 +00:00
|
|
|
static cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
|
|
|
|
cl::desc("Do not verify input module"));
|
2005-07-28 02:25:30 +00:00
|
|
|
|
2014-05-21 21:05:05 +00:00
|
|
|
static cl::opt<bool> DisableSimplifyLibCalls("disable-simplify-libcalls",
|
|
|
|
cl::desc("Disable simplify-libcalls"));
|
2012-08-21 16:15:24 +00:00
|
|
|
|
2014-05-21 21:05:09 +00:00
|
|
|
static cl::opt<bool> ShowMCEncoding("show-mc-encoding", cl::Hidden,
|
|
|
|
cl::desc("Show encoding in .s output"));
|
|
|
|
|
|
|
|
static cl::opt<bool> EnableDwarfDirectory(
|
|
|
|
"enable-dwarf-directory", cl::Hidden,
|
|
|
|
cl::desc("Use .file directives with an explicit directory."));
|
|
|
|
|
|
|
|
static cl::opt<bool> AsmVerbose("asm-verbose",
|
|
|
|
cl::desc("Add comments to directives."),
|
|
|
|
cl::init(true));
|
|
|
|
|
|
|
|
static int compileModule(char **, LLVMContext &);
|
2012-11-30 21:42:47 +00:00
|
|
|
|
2014-12-11 07:04:46 +00:00
|
|
|
static std::unique_ptr<tool_output_file>
|
|
|
|
GetOutputStream(const char *TargetName, Triple::OSType OS,
|
|
|
|
const char *ProgName) {
|
2010-08-18 17:55:15 +00:00
|
|
|
// If we don't yet have an output filename, make one.
|
|
|
|
if (OutputFilename.empty()) {
|
|
|
|
if (InputFilename == "-")
|
|
|
|
OutputFilename = "-";
|
|
|
|
else {
|
2014-08-30 16:48:22 +00:00
|
|
|
// If InputFilename ends in .bc or .ll, remove it.
|
|
|
|
StringRef IFN = InputFilename;
|
|
|
|
if (IFN.endswith(".bc") || IFN.endswith(".ll"))
|
|
|
|
OutputFilename = IFN.drop_back(3);
|
2015-05-21 20:54:45 +00:00
|
|
|
else if (IFN.endswith(".mir"))
|
|
|
|
OutputFilename = IFN.drop_back(4);
|
2014-08-30 16:48:22 +00:00
|
|
|
else
|
|
|
|
OutputFilename = IFN;
|
2010-08-18 17:55:15 +00:00
|
|
|
|
|
|
|
switch (FileType) {
|
|
|
|
case TargetMachine::CGFT_AssemblyFile:
|
|
|
|
if (TargetName[0] == 'c') {
|
|
|
|
if (TargetName[1] == 0)
|
|
|
|
OutputFilename += ".cbe.c";
|
|
|
|
else if (TargetName[1] == 'p' && TargetName[2] == 'p')
|
|
|
|
OutputFilename += ".cpp";
|
|
|
|
else
|
|
|
|
OutputFilename += ".s";
|
|
|
|
} else
|
|
|
|
OutputFilename += ".s";
|
|
|
|
break;
|
|
|
|
case TargetMachine::CGFT_ObjectFile:
|
|
|
|
if (OS == Triple::Win32)
|
|
|
|
OutputFilename += ".obj";
|
|
|
|
else
|
|
|
|
OutputFilename += ".o";
|
|
|
|
break;
|
|
|
|
case TargetMachine::CGFT_Null:
|
|
|
|
OutputFilename += ".null";
|
|
|
|
break;
|
|
|
|
}
|
2008-08-21 15:33:45 +00:00
|
|
|
}
|
2006-09-04 04:14:57 +00:00
|
|
|
}
|
|
|
|
|
2010-08-18 17:55:15 +00:00
|
|
|
// Decide if we need "binary" output.
|
2008-11-13 05:01:07 +00:00
|
|
|
bool Binary = false;
|
2006-09-04 04:14:57 +00:00
|
|
|
switch (FileType) {
|
2010-02-02 21:06:45 +00:00
|
|
|
case TargetMachine::CGFT_AssemblyFile:
|
2006-09-04 04:14:57 +00:00
|
|
|
break;
|
2010-02-02 21:06:45 +00:00
|
|
|
case TargetMachine::CGFT_ObjectFile:
|
2010-02-03 05:55:08 +00:00
|
|
|
case TargetMachine::CGFT_Null:
|
2008-11-13 05:01:07 +00:00
|
|
|
Binary = true;
|
2006-09-04 04:14:57 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-01-16 06:53:46 +00:00
|
|
|
|
2010-08-18 17:55:15 +00:00
|
|
|
// Open the file.
|
2014-08-25 18:16:47 +00:00
|
|
|
std::error_code EC;
|
2013-07-16 19:44:17 +00:00
|
|
|
sys::fs::OpenFlags OpenFlags = sys::fs::F_None;
|
2014-02-24 18:20:12 +00:00
|
|
|
if (!Binary)
|
|
|
|
OpenFlags |= sys::fs::F_Text;
|
2014-12-11 07:04:46 +00:00
|
|
|
auto FDOut = llvm::make_unique<tool_output_file>(OutputFilename, EC,
|
|
|
|
OpenFlags);
|
2014-08-25 18:16:47 +00:00
|
|
|
if (EC) {
|
|
|
|
errs() << EC.message() << '\n';
|
2014-04-25 04:24:47 +00:00
|
|
|
return nullptr;
|
2006-09-04 04:14:57 +00:00
|
|
|
}
|
2009-01-16 06:53:46 +00:00
|
|
|
|
2010-09-01 14:20:41 +00:00
|
|
|
return FDOut;
|
2006-09-04 04:14:57 +00:00
|
|
|
}
|
2001-09-18 17:04:18 +00:00
|
|
|
|
2003-06-20 15:49:04 +00:00
|
|
|
// main - Entry point for the llc compiler.
|
|
|
|
//
|
|
|
|
int main(int argc, char **argv) {
|
2007-05-06 04:55:19 +00:00
|
|
|
sys::PrintStackTraceOnErrorSignal();
|
2009-03-06 05:34:10 +00:00
|
|
|
PrettyStackTraceProgram X(argc, argv);
|
2010-01-05 01:30:21 +00:00
|
|
|
|
|
|
|
// Enable debug stream buffering.
|
|
|
|
EnableDebugBuffering = true;
|
|
|
|
|
2009-07-15 22:16:10 +00:00
|
|
|
LLVMContext &Context = getGlobalContext();
|
2009-03-06 05:34:10 +00:00
|
|
|
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
|
2004-07-11 04:03:24 +00:00
|
|
|
|
2009-09-03 05:47:22 +00:00
|
|
|
// Initialize targets first, so that --version shows registered targets.
|
2009-06-17 16:42:19 +00:00
|
|
|
InitializeAllTargets();
|
2011-07-22 21:58:54 +00:00
|
|
|
InitializeAllTargetMCs();
|
2009-06-17 16:42:19 +00:00
|
|
|
InitializeAllAsmPrinters();
|
add .o file writing for inline asm in llc. Here's a silly
demo:
$ clang asm.c -S -o - -emit-llvm | llc -filetype=obj -o t.o
<inline asm>:1:2: error: unrecognized instruction
abc incl %eax
^
LLVM ERROR: Error parsing inline asm
Only problem seems to be that the parser finalizes OutStreamer
at the end of the first inline asm, which isn't what we want.
For example:
$ cat asm.c
int foo(int X) {
__asm__ ("incl %0" : "+r" (X));
return X;
}
$ clang asm.c -S -o - -emit-llvm | llc
...
subq $8, %rsp
movl %edi, (%rsp)
movl %edi, %eax
## InlineAsm Start
incl %eax
## InlineAsm End
movl %eax, (%rsp)
movl %eax, 4(%rsp)
addq $8, %rsp
ret
$ clang asm.c -S -o - -emit-llvm | llc -filetype=obj -o t.o
$ otool -tv t.o
t.o:
(__TEXT,__text) section
_foo:
0000000000000000 subq $0x08,%rsp
0000000000000004 movl %edi,(%rsp)
0000000000000007 movl %edi,%eax
0000000000000009 incl %eax
$
don't stop at inc!
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100491 91177308-0d34-0410-b5e6-96231b3b80d8
2010-04-05 23:11:24 +00:00
|
|
|
InitializeAllAsmParsers();
|
2009-07-16 02:04:54 +00:00
|
|
|
|
2012-07-02 19:48:45 +00:00
|
|
|
// Initialize codegen and IR passes used by llc so that the -print-after,
|
|
|
|
// -print-before, and -stop-after options work.
|
|
|
|
PassRegistry *Registry = PassRegistry::getPassRegistry();
|
|
|
|
initializeCore(*Registry);
|
|
|
|
initializeCodeGen(*Registry);
|
|
|
|
initializeLoopStrengthReducePass(*Registry);
|
|
|
|
initializeLowerIntrinsicsPass(*Registry);
|
|
|
|
initializeUnreachableBlockElimPass(*Registry);
|
2012-06-26 21:33:36 +00:00
|
|
|
|
2011-07-22 07:50:48 +00:00
|
|
|
// Register the target printer for --version.
|
|
|
|
cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
|
|
|
|
|
2009-07-16 02:04:54 +00:00
|
|
|
cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
|
2011-04-05 18:41:31 +00:00
|
|
|
|
2012-11-30 21:42:47 +00:00
|
|
|
// Compile the module TimeCompilations times to give better compile time
|
|
|
|
// metrics.
|
|
|
|
for (unsigned I = TimeCompilations; I; --I)
|
|
|
|
if (int RetVal = compileModule(argv, Context))
|
|
|
|
return RetVal;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compileModule(char **argv, LLVMContext &Context) {
|
2007-05-06 04:55:19 +00:00
|
|
|
// Load the module to be compiled...
|
2009-09-02 19:35:19 +00:00
|
|
|
SMDiagnostic Err;
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<Module> M;
|
2012-06-27 16:23:48 +00:00
|
|
|
Triple TheTriple;
|
|
|
|
|
|
|
|
bool SkipModule = MCPU == "help" ||
|
|
|
|
(!MAttrs.empty() && MAttrs.front() == "help");
|
|
|
|
|
|
|
|
// If user just wants to list available options, skip module loading
|
|
|
|
if (!SkipModule) {
|
2015-05-21 20:54:45 +00:00
|
|
|
if (StringRef(InputFilename).endswith_lower(".mir"))
|
|
|
|
M = parseMIRFile(InputFilename, Err, Context);
|
|
|
|
else
|
|
|
|
M = parseIRFile(InputFilename, Err, Context);
|
2014-12-11 07:04:52 +00:00
|
|
|
if (!M) {
|
2012-06-27 16:23:48 +00:00
|
|
|
Err.print(argv[0], errs());
|
|
|
|
return 1;
|
|
|
|
}
|
2009-01-16 06:53:46 +00:00
|
|
|
|
2015-03-27 22:04:28 +00:00
|
|
|
// Verify module immediately to catch problems before doInitialization() is
|
|
|
|
// called on any passes.
|
|
|
|
if (!NoVerify && verifyModule(*M, &errs())) {
|
|
|
|
errs() << argv[0] << ": " << InputFilename
|
2015-03-31 03:07:23 +00:00
|
|
|
<< ": error: input module is broken!\n";
|
2015-03-27 22:04:28 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-06-27 16:23:48 +00:00
|
|
|
// If we are supposed to override the target triple, do so now.
|
|
|
|
if (!TargetTriple.empty())
|
2014-12-11 07:04:52 +00:00
|
|
|
M->setTargetTriple(Triple::normalize(TargetTriple));
|
|
|
|
TheTriple = Triple(M->getTargetTriple());
|
2012-06-27 16:23:48 +00:00
|
|
|
} else {
|
|
|
|
TheTriple = Triple(Triple::normalize(TargetTriple));
|
2007-05-06 04:55:19 +00:00
|
|
|
}
|
2009-01-16 06:53:46 +00:00
|
|
|
|
2009-08-03 04:03:51 +00:00
|
|
|
if (TheTriple.getTriple().empty())
|
2011-11-01 21:32:20 +00:00
|
|
|
TheTriple.setTriple(sys::getDefaultTargetTriple());
|
2009-08-03 04:03:51 +00:00
|
|
|
|
2012-05-08 23:38:45 +00:00
|
|
|
// Get the target specific parser.
|
|
|
|
std::string Error;
|
|
|
|
const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
|
|
|
|
Error);
|
|
|
|
if (!TheTarget) {
|
|
|
|
errs() << argv[0] << ": " << Error;
|
|
|
|
return 1;
|
2007-05-06 04:55:19 +00:00
|
|
|
}
|
2005-09-01 21:38:21 +00:00
|
|
|
|
2015-05-06 23:49:24 +00:00
|
|
|
std::string CPUStr = getCPUStr(), FeaturesStr = getFeaturesStr();
|
2015-03-31 05:52:57 +00:00
|
|
|
|
2011-11-16 08:38:26 +00:00
|
|
|
CodeGenOpt::Level OLvl = CodeGenOpt::Default;
|
|
|
|
switch (OptLevel) {
|
|
|
|
default:
|
|
|
|
errs() << argv[0] << ": invalid optimization level.\n";
|
|
|
|
return 1;
|
|
|
|
case ' ': break;
|
|
|
|
case '0': OLvl = CodeGenOpt::None; break;
|
|
|
|
case '1': OLvl = CodeGenOpt::Less; break;
|
|
|
|
case '2': OLvl = CodeGenOpt::Default; break;
|
|
|
|
case '3': OLvl = CodeGenOpt::Aggressive; break;
|
|
|
|
}
|
|
|
|
|
2014-02-19 17:09:35 +00:00
|
|
|
TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
|
2014-02-21 03:13:54 +00:00
|
|
|
Options.DisableIntegratedAS = NoIntegratedAssembler;
|
2014-05-21 21:05:09 +00:00
|
|
|
Options.MCOptions.ShowMCEncoding = ShowMCEncoding;
|
|
|
|
Options.MCOptions.MCUseDwarfDirectory = EnableDwarfDirectory;
|
|
|
|
Options.MCOptions.AsmVerbose = AsmVerbose;
|
2014-05-20 23:59:50 +00:00
|
|
|
|
2014-12-12 07:52:06 +00:00
|
|
|
std::unique_ptr<TargetMachine> Target(
|
2015-05-06 23:49:24 +00:00
|
|
|
TheTarget->createTargetMachine(TheTriple.getTriple(), CPUStr, FeaturesStr,
|
2014-03-06 05:51:42 +00:00
|
|
|
Options, RelocModel, CMModel, OLvl));
|
2015-05-06 23:49:24 +00:00
|
|
|
|
2014-12-12 07:52:06 +00:00
|
|
|
assert(Target && "Could not allocate target machine!");
|
2014-05-06 16:29:50 +00:00
|
|
|
|
|
|
|
// If we don't have a module then just exit now. We do this down
|
|
|
|
// here since the CPU/Feature help is underneath the target machine
|
|
|
|
// creation.
|
|
|
|
if (SkipModule)
|
|
|
|
return 0;
|
|
|
|
|
2014-12-11 07:04:52 +00:00
|
|
|
assert(M && "Should have exited if we didn't have a module!");
|
2015-05-12 01:26:05 +00:00
|
|
|
if (FloatABIForCalls != FloatABI::Default)
|
|
|
|
Options.FloatABIType = FloatABIForCalls;
|
2011-12-02 22:16:29 +00:00
|
|
|
|
2012-07-19 00:11:45 +00:00
|
|
|
// Figure out where we are going to send the output.
|
2014-12-12 07:52:00 +00:00
|
|
|
std::unique_ptr<tool_output_file> Out =
|
|
|
|
GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0]);
|
2010-08-20 01:07:01 +00:00
|
|
|
if (!Out) return 1;
|
2009-01-16 06:53:46 +00:00
|
|
|
|
2010-05-11 19:57:55 +00:00
|
|
|
// Build up all of the passes that we want to do to the module.
|
2015-02-13 10:01:29 +00:00
|
|
|
legacy::PassManager PM;
|
2010-05-11 19:57:55 +00:00
|
|
|
|
2012-08-03 21:26:18 +00:00
|
|
|
// Add an appropriate TargetLibraryInfo pass for the module's triple.
|
[PM] Rework how the TargetLibraryInfo pass integrates with the new pass
manager to support the actual uses of it. =]
When I ported instcombine to the new pass manager I discover that it
didn't work because TLI wasn't available in the right places. This is
a somewhat surprising and/or subtle aspect of the new pass manager
design that came up before but I think is useful to be reminded of:
While the new pass manager *allows* a function pass to query a module
analysis, it requires that the module analysis is already run and cached
prior to the function pass manager starting up, possibly with
a 'require<foo>' style utility in the pass pipeline. This is an
intentional hurdle because using a module analysis from a function pass
*requires* that the module analysis is run prior to entering the
function pass manager. Otherwise the other functions in the module could
be in who-knows-what state, etc.
A somewhat surprising consequence of this design decision (at least to
me) is that you have to design a function pass that leverages
a module analysis to do so as an optional feature. Even if that means
your function pass does no work in the absence of the module analysis,
you have to handle that possibility and remain conservatively correct.
This is a natural consequence of things being able to invalidate the
module analysis and us being unable to re-run it. And it's a generally
good thing because it lets us reorder passes arbitrarily without
breaking correctness, etc.
This ends up causing problems in one case. What if we have a module
analysis that is *definitionally* impossible to invalidate. In the
places this might come up, the analysis is usually also definitionally
trivial to run even while other transformation passes run on the module,
regardless of the state of anything. And so, it follows that it is
natural to have a hard requirement on such analyses from a function
pass.
It turns out, that TargetLibraryInfo is just such an analysis, and
InstCombine has a hard requirement on it.
The approach I've taken here is to produce an analysis that models this
flexibility by making it both a module and a function analysis. This
exposes the fact that it is in fact safe to compute at any point. We can
even make it a valid CGSCC analysis at some point if that is useful.
However, we don't want to have a copy of the actual target library info
state for each function! This state is specific to the triple. The
somewhat direct and blunt approach here is to turn TLI into a pimpl,
with the state and mutators in the implementation class and the query
routines primarily in the wrapper. Then the analysis can lazily
construct and cache the implementations, keyed on the triple, and
on-demand produce wrappers of them for each function.
One minor annoyance is that we will end up with a wrapper for each
function in the module. While this is a bit wasteful (one pointer per
function) it seems tolerable. And it has the advantage of ensuring that
we pay the absolute minimum synchronization cost to access this
information should we end up with a nice parallel function pass manager
in the future. We could look into trying to mark when analysis results
are especially cheap to recompute and more eagerly GC-ing the cached
results, or we could look at supporting a variant of analyses whose
results are specifically *not* cached and expected to just be used and
discarded by the consumer. Either way, these seem like incremental
enhancements that should happen when we start profiling the memory and
CPU usage of the new pass manager and not before.
The other minor annoyance is that if we end up using the TLI in both
a module pass and a function pass, those will be produced by two
separate analyses, and thus will point to separate copies of the
implementation state. While a minor issue, I dislike this and would like
to find a way to cleanly allow a single analysis instance to be used
across multiple IR unit managers. But I don't have a good solution to
this today, and I don't want to hold up all of the work waiting to come
up with one. This too seems like a reasonable thing to incrementally
improve later.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226981 91177308-0d34-0410-b5e6-96231b3b80d8
2015-01-24 02:06:09 +00:00
|
|
|
TargetLibraryInfoImpl TLII(Triple(M->getTargetTriple()));
|
2015-01-15 10:41:28 +00:00
|
|
|
|
|
|
|
// The -disable-simplify-libcalls flag actually disables all builtin optzns.
|
2012-08-08 20:31:37 +00:00
|
|
|
if (DisableSimplifyLibCalls)
|
[PM] Rework how the TargetLibraryInfo pass integrates with the new pass
manager to support the actual uses of it. =]
When I ported instcombine to the new pass manager I discover that it
didn't work because TLI wasn't available in the right places. This is
a somewhat surprising and/or subtle aspect of the new pass manager
design that came up before but I think is useful to be reminded of:
While the new pass manager *allows* a function pass to query a module
analysis, it requires that the module analysis is already run and cached
prior to the function pass manager starting up, possibly with
a 'require<foo>' style utility in the pass pipeline. This is an
intentional hurdle because using a module analysis from a function pass
*requires* that the module analysis is run prior to entering the
function pass manager. Otherwise the other functions in the module could
be in who-knows-what state, etc.
A somewhat surprising consequence of this design decision (at least to
me) is that you have to design a function pass that leverages
a module analysis to do so as an optional feature. Even if that means
your function pass does no work in the absence of the module analysis,
you have to handle that possibility and remain conservatively correct.
This is a natural consequence of things being able to invalidate the
module analysis and us being unable to re-run it. And it's a generally
good thing because it lets us reorder passes arbitrarily without
breaking correctness, etc.
This ends up causing problems in one case. What if we have a module
analysis that is *definitionally* impossible to invalidate. In the
places this might come up, the analysis is usually also definitionally
trivial to run even while other transformation passes run on the module,
regardless of the state of anything. And so, it follows that it is
natural to have a hard requirement on such analyses from a function
pass.
It turns out, that TargetLibraryInfo is just such an analysis, and
InstCombine has a hard requirement on it.
The approach I've taken here is to produce an analysis that models this
flexibility by making it both a module and a function analysis. This
exposes the fact that it is in fact safe to compute at any point. We can
even make it a valid CGSCC analysis at some point if that is useful.
However, we don't want to have a copy of the actual target library info
state for each function! This state is specific to the triple. The
somewhat direct and blunt approach here is to turn TLI into a pimpl,
with the state and mutators in the implementation class and the query
routines primarily in the wrapper. Then the analysis can lazily
construct and cache the implementations, keyed on the triple, and
on-demand produce wrappers of them for each function.
One minor annoyance is that we will end up with a wrapper for each
function in the module. While this is a bit wasteful (one pointer per
function) it seems tolerable. And it has the advantage of ensuring that
we pay the absolute minimum synchronization cost to access this
information should we end up with a nice parallel function pass manager
in the future. We could look into trying to mark when analysis results
are especially cheap to recompute and more eagerly GC-ing the cached
results, or we could look at supporting a variant of analyses whose
results are specifically *not* cached and expected to just be used and
discarded by the consumer. Either way, these seem like incremental
enhancements that should happen when we start profiling the memory and
CPU usage of the new pass manager and not before.
The other minor annoyance is that if we end up using the TLI in both
a module pass and a function pass, those will be produced by two
separate analyses, and thus will point to separate copies of the
implementation state. While a minor issue, I dislike this and would like
to find a way to cleanly allow a single analysis instance to be used
across multiple IR unit managers. But I don't have a good solution to
this today, and I don't want to hold up all of the work waiting to come
up with one. This too seems like a reasonable thing to incrementally
improve later.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226981 91177308-0d34-0410-b5e6-96231b3b80d8
2015-01-24 02:06:09 +00:00
|
|
|
TLII.disableAllFunctions();
|
|
|
|
PM.add(new TargetLibraryInfoWrapperPass(TLII));
|
2012-08-03 21:26:18 +00:00
|
|
|
|
2010-05-11 19:57:55 +00:00
|
|
|
// Add the target data from the target machine, if it exists, or the module.
|
2015-01-26 19:03:15 +00:00
|
|
|
if (const DataLayout *DL = Target->getDataLayout())
|
2015-03-04 18:43:29 +00:00
|
|
|
M->setDataLayout(*DL);
|
2010-05-11 19:57:55 +00:00
|
|
|
|
2015-05-06 23:54:14 +00:00
|
|
|
// Override function attributes.
|
|
|
|
overrideFunctionAttributes(CPUStr, FeaturesStr, *M);
|
|
|
|
|
2014-05-15 01:10:50 +00:00
|
|
|
if (RelaxAll.getNumOccurrences() > 0 &&
|
|
|
|
FileType != TargetMachine::CGFT_ObjectFile)
|
|
|
|
errs() << argv[0]
|
2010-07-31 19:57:02 +00:00
|
|
|
<< ": warning: ignoring -mc-relax-all because filetype != obj";
|
|
|
|
|
2010-09-01 14:20:41 +00:00
|
|
|
{
|
2015-04-14 22:14:34 +00:00
|
|
|
raw_pwrite_stream *OS = &Out->os();
|
|
|
|
std::unique_ptr<buffer_ostream> BOS;
|
|
|
|
if (FileType != TargetMachine::CGFT_AssemblyFile &&
|
|
|
|
!Out->os().supportsSeeking()) {
|
|
|
|
BOS = make_unique<buffer_ostream>(*OS);
|
|
|
|
OS = BOS.get();
|
|
|
|
}
|
|
|
|
|
2014-04-25 04:24:47 +00:00
|
|
|
AnalysisID StartAfterID = nullptr;
|
|
|
|
AnalysisID StopAfterID = nullptr;
|
2012-07-02 19:48:45 +00:00
|
|
|
const PassRegistry *PR = PassRegistry::getPassRegistry();
|
|
|
|
if (!StartAfter.empty()) {
|
|
|
|
const PassInfo *PI = PR->getPassInfo(StartAfter);
|
|
|
|
if (!PI) {
|
|
|
|
errs() << argv[0] << ": start-after pass is not registered.\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
StartAfterID = PI->getTypeInfo();
|
|
|
|
}
|
|
|
|
if (!StopAfter.empty()) {
|
|
|
|
const PassInfo *PI = PR->getPassInfo(StopAfter);
|
|
|
|
if (!PI) {
|
|
|
|
errs() << argv[0] << ": stop-after pass is not registered.\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
StopAfterID = PI->getTypeInfo();
|
|
|
|
}
|
|
|
|
|
2010-09-01 14:20:41 +00:00
|
|
|
// Ask the target to add backend passes as necessary.
|
2015-04-14 22:14:34 +00:00
|
|
|
if (Target->addPassesToEmitFile(PM, *OS, FileType, NoVerify, StartAfterID,
|
|
|
|
StopAfterID)) {
|
2010-09-01 14:20:41 +00:00
|
|
|
errs() << argv[0] << ": target does not support generation of this"
|
|
|
|
<< " file type!\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-04-05 18:54:36 +00:00
|
|
|
// Before executing passes, print the final values of the LLVM options.
|
|
|
|
cl::PrintOptionValues();
|
|
|
|
|
2014-12-11 07:04:52 +00:00
|
|
|
PM.run(*M);
|
2010-09-01 14:20:41 +00:00
|
|
|
}
|
2010-05-11 19:57:55 +00:00
|
|
|
|
2010-08-20 01:07:01 +00:00
|
|
|
// Declare success.
|
|
|
|
Out->keep();
|
2001-10-18 01:31:22 +00:00
|
|
|
|
2007-05-06 04:55:19 +00:00
|
|
|
return 0;
|
2001-10-14 23:29:28 +00:00
|
|
|
}
|