2002-10-29 22:37:54 +00:00
|
|
|
//===-- X86TargetMachine.cpp - Define TargetMachine for the X86 -----------===//
|
2005-04-21 23:38:14 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:38:14 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2005-04-21 23:38:14 +00:00
|
|
|
//
|
2002-10-29 22:37:54 +00:00
|
|
|
// This file defines the X86 specific subclass of TargetMachine.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-09-07 23:39:26 +00:00
|
|
|
#include "X86TargetAsmInfo.h"
|
2002-10-29 22:37:54 +00:00
|
|
|
#include "X86TargetMachine.h"
|
2002-12-24 00:04:01 +00:00
|
|
|
#include "X86.h"
|
2003-08-24 19:49:48 +00:00
|
|
|
#include "llvm/Module.h"
|
2003-04-23 16:24:55 +00:00
|
|
|
#include "llvm/PassManager.h"
|
2002-10-30 00:47:49 +00:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2003-01-13 00:51:23 +00:00
|
|
|
#include "llvm/CodeGen/Passes.h"
|
2008-08-21 00:14:44 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2004-07-11 04:17:10 +00:00
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2004-07-11 02:48:49 +00:00
|
|
|
#include "llvm/Target/TargetMachineRegistry.h"
|
2003-12-20 01:22:19 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2005-01-03 16:34:19 +00:00
|
|
|
/// X86TargetMachineModule - Note that this is used on hosts that cannot link
|
|
|
|
/// in a library unless there are references into the library. In particular,
|
|
|
|
/// it seems that it is not possible to get things to work on Win32 without
|
|
|
|
/// this. Though it is unused, do not remove it.
|
|
|
|
extern "C" int X86TargetMachineModule;
|
|
|
|
int X86TargetMachineModule = 0;
|
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
// Register the target.
|
|
|
|
static RegisterTarget<X86_32TargetMachine>
|
2008-10-14 20:25:08 +00:00
|
|
|
X("x86", "32-bit X86: Pentium-Pro and above");
|
2008-05-13 00:00:25 +00:00
|
|
|
static RegisterTarget<X86_64TargetMachine>
|
2008-10-14 20:25:08 +00:00
|
|
|
Y("x86-64", "64-bit X86: EM64T and AMD64");
|
2002-12-16 16:15:51 +00:00
|
|
|
|
2009-06-23 23:59:40 +00:00
|
|
|
// Force static initialization.
|
|
|
|
extern "C" void LLVMInitializeX86Target() { }
|
2009-06-16 20:12:29 +00:00
|
|
|
|
2008-08-17 13:53:59 +00:00
|
|
|
// No assembler printer by default
|
|
|
|
X86TargetMachine::AsmPrinterCtorFn X86TargetMachine::AsmPrinterCtor = 0;
|
|
|
|
|
2006-09-07 23:39:26 +00:00
|
|
|
const TargetAsmInfo *X86TargetMachine::createTargetAsmInfo() const {
|
2008-07-09 13:20:48 +00:00
|
|
|
if (Subtarget.isFlavorIntel())
|
|
|
|
return new X86WinTargetAsmInfo(*this);
|
|
|
|
else
|
|
|
|
switch (Subtarget.TargetType) {
|
|
|
|
case X86Subtarget::isDarwin:
|
|
|
|
return new X86DarwinTargetAsmInfo(*this);
|
|
|
|
case X86Subtarget::isELF:
|
|
|
|
return new X86ELFTargetAsmInfo(*this);
|
|
|
|
case X86Subtarget::isMingw:
|
|
|
|
case X86Subtarget::isCygwin:
|
|
|
|
return new X86COFFTargetAsmInfo(*this);
|
|
|
|
case X86Subtarget::isWindows:
|
|
|
|
return new X86WinTargetAsmInfo(*this);
|
|
|
|
default:
|
2008-09-25 21:00:33 +00:00
|
|
|
return new X86GenericTargetAsmInfo(*this);
|
2008-07-09 13:20:48 +00:00
|
|
|
}
|
2006-09-07 23:39:26 +00:00
|
|
|
}
|
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
unsigned X86_32TargetMachine::getJITMatchQuality() {
|
2004-10-18 15:54:17 +00:00
|
|
|
#if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
|
2004-07-11 02:48:49 +00:00
|
|
|
return 10;
|
2006-09-08 06:48:29 +00:00
|
|
|
#endif
|
2004-07-11 02:48:49 +00:00
|
|
|
return 0;
|
2006-09-08 06:48:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned X86_64TargetMachine::getJITMatchQuality() {
|
2008-03-23 13:43:47 +00:00
|
|
|
#if defined(__x86_64__) || defined(_M_AMD64)
|
2006-09-08 06:48:29 +00:00
|
|
|
return 10;
|
2004-07-11 02:48:49 +00:00
|
|
|
#endif
|
2006-09-08 06:48:29 +00:00
|
|
|
return 0;
|
2004-07-11 02:48:49 +00:00
|
|
|
}
|
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
unsigned X86_32TargetMachine::getModuleMatchQuality(const Module &M) {
|
2004-12-12 17:40:28 +00:00
|
|
|
// We strongly match "i[3-9]86-*".
|
|
|
|
std::string TT = M.getTargetTriple();
|
|
|
|
if (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
|
|
|
|
TT[4] == '-' && TT[1] - '3' < 6)
|
|
|
|
return 20;
|
2007-07-09 17:25:29 +00:00
|
|
|
// If the target triple is something non-X86, we don't match.
|
|
|
|
if (!TT.empty()) return 0;
|
2004-12-12 17:40:28 +00:00
|
|
|
|
2004-07-11 02:48:49 +00:00
|
|
|
if (M.getEndianness() == Module::LittleEndian &&
|
|
|
|
M.getPointerSize() == Module::Pointer32)
|
2004-12-12 17:40:28 +00:00
|
|
|
return 10; // Weak match
|
2004-07-11 02:48:49 +00:00
|
|
|
else if (M.getEndianness() != Module::AnyEndianness ||
|
|
|
|
M.getPointerSize() != Module::AnyPointerSize)
|
|
|
|
return 0; // Match for some other target
|
|
|
|
|
|
|
|
return getJITMatchQuality()/2;
|
|
|
|
}
|
2002-10-29 22:37:54 +00:00
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
unsigned X86_64TargetMachine::getModuleMatchQuality(const Module &M) {
|
|
|
|
// We strongly match "x86_64-*".
|
|
|
|
std::string TT = M.getTargetTriple();
|
|
|
|
if (TT.size() >= 7 && TT[0] == 'x' && TT[1] == '8' && TT[2] == '6' &&
|
|
|
|
TT[3] == '_' && TT[4] == '6' && TT[5] == '4' && TT[6] == '-')
|
|
|
|
return 20;
|
|
|
|
|
2006-12-19 19:40:09 +00:00
|
|
|
// We strongly match "amd64-*".
|
|
|
|
if (TT.size() >= 6 && TT[0] == 'a' && TT[1] == 'm' && TT[2] == 'd' &&
|
|
|
|
TT[3] == '6' && TT[4] == '4' && TT[5] == '-')
|
|
|
|
return 20;
|
|
|
|
|
2007-07-09 17:25:29 +00:00
|
|
|
// If the target triple is something non-X86-64, we don't match.
|
|
|
|
if (!TT.empty()) return 0;
|
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
if (M.getEndianness() == Module::LittleEndian &&
|
|
|
|
M.getPointerSize() == Module::Pointer64)
|
|
|
|
return 10; // Weak match
|
|
|
|
else if (M.getEndianness() != Module::AnyEndianness ||
|
|
|
|
M.getPointerSize() != Module::AnyPointerSize)
|
|
|
|
return 0; // Match for some other target
|
|
|
|
|
|
|
|
return getJITMatchQuality()/2;
|
|
|
|
}
|
|
|
|
|
2009-06-01 19:57:37 +00:00
|
|
|
X86_32TargetMachine::X86_32TargetMachine(const Module &M, const std::string &FS)
|
2006-09-08 06:48:29 +00:00
|
|
|
: X86TargetMachine(M, FS, false) {
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
X86_64TargetMachine::X86_64TargetMachine(const Module &M, const std::string &FS)
|
|
|
|
: X86TargetMachine(M, FS, true) {
|
|
|
|
}
|
|
|
|
|
2002-10-29 22:37:54 +00:00
|
|
|
/// X86TargetMachine ctor - Create an ILP32 architecture model
|
|
|
|
///
|
2007-02-23 03:03:16 +00:00
|
|
|
X86TargetMachine::X86TargetMachine(const Module &M, const std::string &FS,
|
|
|
|
bool is64Bit)
|
2006-09-08 06:48:29 +00:00
|
|
|
: Subtarget(M, FS, is64Bit),
|
2007-08-06 21:48:35 +00:00
|
|
|
DataLayout(Subtarget.getDataLayout()),
|
2005-07-12 01:41:54 +00:00
|
|
|
FrameInfo(TargetFrameInfo::StackGrowsDown,
|
2006-09-08 06:48:29 +00:00
|
|
|
Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4),
|
2009-06-11 19:16:03 +00:00
|
|
|
InstrInfo(*this), JITInfo(*this), TLInfo(*this), ELFWriterInfo(*this) {
|
2007-12-22 09:40:20 +00:00
|
|
|
DefRelocModel = getRelocationModel();
|
2008-03-23 13:41:18 +00:00
|
|
|
// FIXME: Correctly select PIC model for Win64 stuff
|
2008-02-20 11:22:39 +00:00
|
|
|
if (getRelocationModel() == Reloc::Default) {
|
2008-03-23 13:41:18 +00:00
|
|
|
if (Subtarget.isTargetDarwin() ||
|
|
|
|
(Subtarget.isTargetCygMing() && !Subtarget.isTargetWin64()))
|
2006-02-22 20:19:42 +00:00
|
|
|
setRelocationModel(Reloc::DynamicNoPIC);
|
|
|
|
else
|
2006-12-04 18:07:10 +00:00
|
|
|
setRelocationModel(Reloc::Static);
|
2008-02-20 11:22:39 +00:00
|
|
|
}
|
Teach DAGCombine to fold constant offsets into GlobalAddress nodes,
and add a TargetLowering hook for it to use to determine when this
is legal (i.e. not in PIC mode, etc.)
This allows instruction selection to emit folded constant offsets
in more cases, such as the included testcase, eliminating the need
for explicit arithmetic instructions.
This eliminates the need for the C++ code in X86ISelDAGToDAG.cpp
that attempted to achieve the same effect, but wasn't as effective.
Also, fix handling of offsets in GlobalAddressSDNodes in several
places, including changing GlobalAddressSDNode's offset from
int to int64_t.
The Mips, Alpha, Sparc, and CellSPU targets appear to be
unaware of GlobalAddress offsets currently, so set the hook to
false on those targets.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@57748 91177308-0d34-0410-b5e6-96231b3b80d8
2008-10-18 02:06:02 +00:00
|
|
|
|
|
|
|
// ELF doesn't have a distinct dynamic-no-PIC model. Dynamic-no-PIC
|
|
|
|
// is defined as a model for code which may be used in static or
|
|
|
|
// dynamic executables but not necessarily a shared library. On ELF
|
|
|
|
// implement this by using the Static model.
|
|
|
|
if (Subtarget.isTargetELF() &&
|
|
|
|
getRelocationModel() == Reloc::DynamicNoPIC)
|
|
|
|
setRelocationModel(Reloc::Static);
|
|
|
|
|
2006-09-08 06:48:29 +00:00
|
|
|
if (Subtarget.is64Bit()) {
|
|
|
|
// No DynamicNoPIC support under X86-64.
|
|
|
|
if (getRelocationModel() == Reloc::DynamicNoPIC)
|
|
|
|
setRelocationModel(Reloc::PIC_);
|
|
|
|
// Default X86-64 code model is small.
|
|
|
|
if (getCodeModel() == CodeModel::Default)
|
|
|
|
setCodeModel(CodeModel::Small);
|
|
|
|
}
|
2007-01-12 19:20:47 +00:00
|
|
|
|
2007-01-18 22:27:12 +00:00
|
|
|
if (Subtarget.isTargetCygMing())
|
2008-11-28 09:29:37 +00:00
|
|
|
Subtarget.setPICStyle(PICStyles::WinPIC);
|
2008-02-20 11:22:39 +00:00
|
|
|
else if (Subtarget.isTargetDarwin()) {
|
2007-01-18 22:27:12 +00:00
|
|
|
if (Subtarget.is64Bit())
|
2008-11-28 09:29:37 +00:00
|
|
|
Subtarget.setPICStyle(PICStyles::RIPRel);
|
2007-01-12 19:20:47 +00:00
|
|
|
else
|
2008-11-28 09:29:37 +00:00
|
|
|
Subtarget.setPICStyle(PICStyles::Stub);
|
2008-02-20 11:22:39 +00:00
|
|
|
} else if (Subtarget.isTargetELF()) {
|
2007-01-18 22:27:12 +00:00
|
|
|
if (Subtarget.is64Bit())
|
2008-11-28 09:29:37 +00:00
|
|
|
Subtarget.setPICStyle(PICStyles::RIPRel);
|
2007-01-12 19:20:47 +00:00
|
|
|
else
|
2008-11-28 09:29:37 +00:00
|
|
|
Subtarget.setPICStyle(PICStyles::GOT);
|
2008-02-20 11:22:39 +00:00
|
|
|
}
|
2006-02-03 18:59:39 +00:00
|
|
|
}
|
2002-10-29 22:37:54 +00:00
|
|
|
|
2006-09-04 04:14:57 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pass Pipeline Configuration
|
|
|
|
//===----------------------------------------------------------------------===//
|
2003-08-05 16:34:44 +00:00
|
|
|
|
2009-04-29 23:29:43 +00:00
|
|
|
bool X86TargetMachine::addInstSelector(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel) {
|
2005-08-18 23:53:15 +00:00
|
|
|
// Install an instruction selector.
|
2009-04-29 00:15:41 +00:00
|
|
|
PM.add(createX86ISelDag(*this, OptLevel));
|
2008-10-25 17:46:52 +00:00
|
|
|
|
|
|
|
// If we're using Fast-ISel, clean up the mess.
|
|
|
|
if (EnableFastISel)
|
|
|
|
PM.add(createDeadMachineInstructionElimPass());
|
|
|
|
|
2008-11-12 22:55:05 +00:00
|
|
|
// Install a pass to insert x87 FP_REG_KILL instructions, as needed.
|
|
|
|
PM.add(createX87FPRegKillInserterPass());
|
|
|
|
|
2006-09-04 04:14:57 +00:00
|
|
|
return false;
|
2003-06-18 21:43:21 +00:00
|
|
|
}
|
|
|
|
|
2009-04-29 23:29:43 +00:00
|
|
|
bool X86TargetMachine::addPreRegAlloc(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel) {
|
2008-04-23 18:23:30 +00:00
|
|
|
// Calculate and set max stack object alignment early, so we can decide
|
|
|
|
// whether we will need stack realignment (and thus FP).
|
2008-04-23 18:23:05 +00:00
|
|
|
PM.add(createX86MaxStackAlignmentCalculatorPass());
|
|
|
|
return false; // -print-machineinstr shouldn't print after this.
|
|
|
|
}
|
|
|
|
|
2009-04-29 23:29:43 +00:00
|
|
|
bool X86TargetMachine::addPostRegAlloc(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel) {
|
2003-01-13 00:51:23 +00:00
|
|
|
PM.add(createX86FloatingPointStackifierPass());
|
2006-09-04 04:14:57 +00:00
|
|
|
return true; // -print-machineinstr should print after this.
|
|
|
|
}
|
2003-01-13 00:51:23 +00:00
|
|
|
|
2009-04-29 00:15:41 +00:00
|
|
|
bool X86TargetMachine::addAssemblyEmitter(PassManagerBase &PM,
|
2009-04-29 23:29:43 +00:00
|
|
|
CodeGenOpt::Level OptLevel,
|
2009-04-29 00:15:41 +00:00
|
|
|
bool Verbose,
|
|
|
|
raw_ostream &Out) {
|
2009-06-03 21:13:54 +00:00
|
|
|
// FIXME: Move this somewhere else!
|
|
|
|
// On Darwin, override 64-bit static relocation to pic_ since the
|
|
|
|
// assembler doesn't support it.
|
|
|
|
if (DefRelocModel == Reloc::Static &&
|
Reimplement rip-relative addressing in the X86-64 backend. The new
implementation primarily differs from the former in that the asmprinter
doesn't make a zillion decisions about whether or not something will be
RIP relative or not. Instead, those decisions are made by isel lowering
and propagated through to the asm printer. To achieve this, we:
1. Represent RIP relative addresses by setting the base of the X86 addr
mode to X86::RIP.
2. When ISel Lowering decides that it is safe to use RIP, it lowers to
X86ISD::WrapperRIP. When it is unsafe to use RIP, it lowers to
X86ISD::Wrapper as before.
3. This removes isRIPRel from X86ISelAddressMode, representing it with
a basereg of RIP instead.
4. The addressing mode matching logic in isel is greatly simplified.
5. The asmprinter is greatly simplified, notably the "NotRIPRel" predicate
passed through various printoperand routines is gone now.
6. The various symbol printing routines in asmprinter now no longer infer
when to emit (%rip), they just print the symbol.
I think this is a big improvement over the previous situation. It does have
two small caveats though: 1. I implemented a horrible "no-rip" modifier for
the inline asm "P" constraint modifier. This is a short term hack, there is
a much better, but more involved, solution. 2. I had to xfail an
-aggressive-remat testcase because it isn't handling the use of RIP in the
constant-pool reading instruction. This specific test is easy to fix without
-aggressive-remat, which I intend to do next.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74372 91177308-0d34-0410-b5e6-96231b3b80d8
2009-06-27 04:16:01 +00:00
|
|
|
Subtarget.isTargetDarwin() && Subtarget.is64Bit() &&
|
|
|
|
getCodeModel() == CodeModel::Small)
|
2009-06-03 21:13:54 +00:00
|
|
|
setRelocationModel(Reloc::PIC_);
|
|
|
|
|
2008-08-17 13:53:59 +00:00
|
|
|
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
|
|
|
|
if (AsmPrinterCtor)
|
2009-07-01 01:48:54 +00:00
|
|
|
PM.add(AsmPrinterCtor(Out, *this, Verbose));
|
2006-09-04 04:14:57 +00:00
|
|
|
return false;
|
|
|
|
}
|
2002-10-29 22:37:54 +00:00
|
|
|
|
2009-04-29 23:29:43 +00:00
|
|
|
bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel,
|
2009-06-01 19:57:37 +00:00
|
|
|
bool DumpAsm,
|
|
|
|
MachineCodeEmitter &MCE) {
|
2006-09-04 18:48:41 +00:00
|
|
|
// FIXME: Move this to TargetJITInfo!
|
2008-08-12 21:02:08 +00:00
|
|
|
// On Darwin, do not override 64-bit setting made in X86TargetMachine().
|
|
|
|
if (DefRelocModel == Reloc::Default &&
|
|
|
|
(!Subtarget.isTargetDarwin() || !Subtarget.is64Bit()))
|
2007-12-22 09:40:20 +00:00
|
|
|
setRelocationModel(Reloc::Static);
|
2007-01-12 19:20:47 +00:00
|
|
|
|
2008-08-11 23:46:25 +00:00
|
|
|
// 64-bit JIT places everything in the same buffer except external functions.
|
2008-08-12 21:02:08 +00:00
|
|
|
// On Darwin, use small code model but hack the call instruction for
|
|
|
|
// externals. Elsewhere, do not assume globals are in the lower 4G.
|
|
|
|
if (Subtarget.is64Bit()) {
|
|
|
|
if (Subtarget.isTargetDarwin())
|
|
|
|
setCodeModel(CodeModel::Small);
|
|
|
|
else
|
|
|
|
setCodeModel(CodeModel::Large);
|
|
|
|
}
|
2006-12-20 01:03:20 +00:00
|
|
|
|
2006-07-25 20:40:54 +00:00
|
|
|
PM.add(createX86CodeEmitterPass(*this, MCE));
|
2008-08-17 13:53:59 +00:00
|
|
|
if (DumpAsm) {
|
|
|
|
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
|
|
|
|
if (AsmPrinterCtor)
|
2009-07-01 01:48:54 +00:00
|
|
|
PM.add(AsmPrinterCtor(errs(), *this, true));
|
2008-08-17 13:53:59 +00:00
|
|
|
}
|
2007-07-20 21:56:13 +00:00
|
|
|
|
2005-07-11 05:17:48 +00:00
|
|
|
return false;
|
|
|
|
}
|
2007-02-08 01:39:44 +00:00
|
|
|
|
2009-05-30 20:51:52 +00:00
|
|
|
bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel,
|
2009-06-01 19:57:37 +00:00
|
|
|
bool DumpAsm,
|
|
|
|
JITCodeEmitter &JCE) {
|
2009-05-30 20:51:52 +00:00
|
|
|
// FIXME: Move this to TargetJITInfo!
|
|
|
|
// On Darwin, do not override 64-bit setting made in X86TargetMachine().
|
|
|
|
if (DefRelocModel == Reloc::Default &&
|
|
|
|
(!Subtarget.isTargetDarwin() || !Subtarget.is64Bit()))
|
|
|
|
setRelocationModel(Reloc::Static);
|
|
|
|
|
|
|
|
// 64-bit JIT places everything in the same buffer except external functions.
|
|
|
|
// On Darwin, use small code model but hack the call instruction for
|
|
|
|
// externals. Elsewhere, do not assume globals are in the lower 4G.
|
|
|
|
if (Subtarget.is64Bit()) {
|
|
|
|
if (Subtarget.isTargetDarwin())
|
|
|
|
setCodeModel(CodeModel::Small);
|
|
|
|
else
|
|
|
|
setCodeModel(CodeModel::Large);
|
|
|
|
}
|
|
|
|
|
|
|
|
PM.add(createX86JITCodeEmitterPass(*this, JCE));
|
|
|
|
if (DumpAsm) {
|
|
|
|
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
|
|
|
|
if (AsmPrinterCtor)
|
2009-07-01 01:48:54 +00:00
|
|
|
PM.add(AsmPrinterCtor(errs(), *this, true));
|
2009-05-30 20:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-04-29 00:15:41 +00:00
|
|
|
bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
|
2009-04-29 23:29:43 +00:00
|
|
|
CodeGenOpt::Level OptLevel,
|
|
|
|
bool DumpAsm,
|
2009-04-29 00:15:41 +00:00
|
|
|
MachineCodeEmitter &MCE) {
|
2007-02-08 01:39:44 +00:00
|
|
|
PM.add(createX86CodeEmitterPass(*this, MCE));
|
2008-08-17 13:53:59 +00:00
|
|
|
if (DumpAsm) {
|
|
|
|
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
|
|
|
|
if (AsmPrinterCtor)
|
2009-07-01 01:48:54 +00:00
|
|
|
PM.add(AsmPrinterCtor(errs(), *this, true));
|
2008-08-17 13:53:59 +00:00
|
|
|
}
|
|
|
|
|
2007-02-08 01:39:44 +00:00
|
|
|
return false;
|
|
|
|
}
|
2008-09-26 19:15:30 +00:00
|
|
|
|
2009-05-30 20:51:52 +00:00
|
|
|
bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,
|
|
|
|
CodeGenOpt::Level OptLevel,
|
|
|
|
bool DumpAsm,
|
|
|
|
JITCodeEmitter &JCE) {
|
|
|
|
PM.add(createX86JITCodeEmitterPass(*this, JCE));
|
|
|
|
if (DumpAsm) {
|
|
|
|
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
|
|
|
|
if (AsmPrinterCtor)
|
2009-07-01 01:48:54 +00:00
|
|
|
PM.add(AsmPrinterCtor(errs(), *this, true));
|
2009-05-30 20:51:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|