2001-09-14 05:34:53 +00:00
|
|
|
//===-- TargetMachine.cpp - General Target Information ---------------------==//
|
2005-04-21 22:55:34 +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 22:55:34 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-09-14 05:34:53 +00:00
|
|
|
//
|
|
|
|
// This file describes the general parts of a Target machine.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2001-07-21 12:42:08 +00:00
|
|
|
|
2010-04-21 03:18:23 +00:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
2009-08-22 20:48:53 +00:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2004-06-21 21:20:23 +00:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2006-02-22 20:19:42 +00:00
|
|
|
#include "llvm/Target/TargetOptions.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2003-12-28 21:23:38 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2004-03-04 19:16:23 +00:00
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Command-line options that tend to be useful on more than one back-end.
|
|
|
|
//
|
|
|
|
|
2004-06-21 21:44:12 +00:00
|
|
|
namespace llvm {
|
2009-03-20 05:06:58 +00:00
|
|
|
bool LessPreciseFPMADOption;
|
2004-06-21 21:44:12 +00:00
|
|
|
bool PrintMachineCode;
|
|
|
|
bool NoFramePointerElim;
|
2010-04-21 03:18:23 +00:00
|
|
|
bool NoFramePointerElimNonLeaf;
|
2005-01-15 06:00:32 +00:00
|
|
|
bool NoExcessFPPrecision;
|
2005-04-30 04:09:52 +00:00
|
|
|
bool UnsafeFPMath;
|
2010-07-15 22:07:12 +00:00
|
|
|
bool NoInfsFPMath;
|
|
|
|
bool NoNaNsFPMath;
|
2007-05-03 00:27:11 +00:00
|
|
|
bool HonorSignDependentRoundingFPMathOption;
|
2006-12-09 02:41:30 +00:00
|
|
|
bool UseSoftFloat;
|
2009-06-08 22:53:56 +00:00
|
|
|
FloatABI::ABIType FloatABIType;
|
2009-03-11 22:30:01 +00:00
|
|
|
bool NoImplicitFloat;
|
2007-01-17 10:33:08 +00:00
|
|
|
bool NoZerosInBSS;
|
2010-05-02 15:36:26 +00:00
|
|
|
bool JITExceptionHandling;
|
Implement the JIT side of the GDB JIT debugging interface. To enable this
feature, either build the JIT in debug mode to enable it by default or pass
-jit-emit-debug to lli.
Right now, the only debug information that this communicates to GDB is call
frame information, since it's already being generated to support exceptions in
the JIT. Eventually, when DWARF generation isn't tied so tightly to AsmPrinter,
it will be easy to push that information to GDB through this interface.
Here's a step-by-step breakdown of how the feature works:
- The JIT generates the machine code and DWARF call frame info
(.eh_frame/.debug_frame) for a function into memory.
- The JIT copies that info into an in-memory ELF file with a symbol for the
function.
- The JIT creates a code entry pointing to the ELF buffer and adds it to a
linked list hanging off of a global descriptor at a special symbol that GDB
knows about.
- The JIT calls a function marked noinline that GDB knows about and has put an
internal breakpoint in.
- GDB catches the breakpoint and reads the global descriptor to look for new
code.
- When sees there is new code, it reads the ELF from the inferior's memory and
adds it to itself as an object file.
- The JIT continues, and the next time we stop the program, we are able to
produce a proper backtrace.
Consider running the following program through the JIT:
#include <stdio.h>
void baz(short z) {
long w = z + 1;
printf("%d, %x\n", w, *((int*)NULL)); // SEGFAULT here
}
void bar(short y) {
int z = y + 1;
baz(z);
}
void foo(char x) {
short y = x + 1;
bar(y);
}
int main(int argc, char** argv) {
char x = 1;
foo(x);
}
Here is a backtrace before this patch:
Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x2aaaabdfbd10 (LWP 25476)]
0x00002aaaabe7d1a8 in ?? ()
(gdb) bt
#0 0x00002aaaabe7d1a8 in ?? ()
#1 0x0000000000000003 in ?? ()
#2 0x0000000000000004 in ?? ()
#3 0x00032aaaabe7cfd0 in ?? ()
#4 0x00002aaaabe7d12c in ?? ()
#5 0x00022aaa00000003 in ?? ()
#6 0x00002aaaabe7d0aa in ?? ()
#7 0x01000002abe7cff0 in ?? ()
#8 0x00002aaaabe7d02c in ?? ()
#9 0x0100000000000001 in ?? ()
#10 0x00000000014388e0 in ?? ()
#11 0x00007fff00000001 in ?? ()
#12 0x0000000000b870a2 in llvm::JIT::runFunction (this=0x1405b70,
F=0x14024e0, ArgValues=@0x7fffffffe050)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/JIT/JIT.cpp:395
#13 0x0000000000baa4c5 in llvm::ExecutionEngine::runFunctionAsMain
(this=0x1405b70, Fn=0x14024e0, argv=@0x13f06f8, envp=0x7fffffffe3b0)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/ExecutionEngine.cpp:377
#14 0x00000000007ebd52 in main (argc=2, argv=0x7fffffffe398,
envp=0x7fffffffe3b0) at /home/rnk/llvm-gdb/tools/lli/lli.cpp:208
And a backtrace after this patch:
Program received signal SIGSEGV, Segmentation fault.
0x00002aaaabe7d1a8 in baz ()
(gdb) bt
#0 0x00002aaaabe7d1a8 in baz ()
#1 0x00002aaaabe7d12c in bar ()
#2 0x00002aaaabe7d0aa in foo ()
#3 0x00002aaaabe7d02c in main ()
#4 0x0000000000b870a2 in llvm::JIT::runFunction (this=0x1405b70,
F=0x14024e0, ArgValues=...)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/JIT/JIT.cpp:395
#5 0x0000000000baa4c5 in llvm::ExecutionEngine::runFunctionAsMain
(this=0x1405b70, Fn=0x14024e0, argv=..., envp=0x7fffffffe3c0)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/ExecutionEngine.cpp:377
#6 0x00000000007ebd52 in main (argc=2, argv=0x7fffffffe3a8,
envp=0x7fffffffe3c0) at /home/rnk/llvm-gdb/tools/lli/lli.cpp:208
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82418 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-20 23:52:43 +00:00
|
|
|
bool JITEmitDebugInfo;
|
|
|
|
bool JITEmitDebugInfoToDisk;
|
2006-07-06 01:53:36 +00:00
|
|
|
CodeModel::Model CMModel;
|
2010-02-08 20:27:50 +00:00
|
|
|
bool GuaranteedTailCallOpt;
|
2011-06-23 18:15:47 +00:00
|
|
|
unsigned StackAlignmentOverride;
|
2008-07-01 23:18:29 +00:00
|
|
|
bool RealignStack;
|
2008-07-31 18:13:12 +00:00
|
|
|
bool DisableJumpTables;
|
2008-10-07 20:22:28 +00:00
|
|
|
bool StrongPHIElim;
|
2011-04-07 00:58:44 +00:00
|
|
|
bool HasDivModLibcall;
|
2009-03-25 01:47:28 +00:00
|
|
|
bool AsmVerbosityDefault(false);
|
2006-05-24 17:04:05 +00:00
|
|
|
}
|
2004-06-21 21:08:45 +00:00
|
|
|
|
2009-03-11 22:30:01 +00:00
|
|
|
static cl::opt<bool, true>
|
|
|
|
PrintCode("print-machineinstrs",
|
2008-05-13 00:00:25 +00:00
|
|
|
cl::desc("Print generated machine code"),
|
|
|
|
cl::location(PrintMachineCode), cl::init(false));
|
|
|
|
static cl::opt<bool, true>
|
2008-05-30 22:39:18 +00:00
|
|
|
DisableFPElim("disable-fp-elim",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Disable frame pointer elimination optimization"),
|
|
|
|
cl::location(NoFramePointerElim),
|
|
|
|
cl::init(false));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
2010-04-21 03:18:23 +00:00
|
|
|
DisableFPElimNonLeaf("disable-non-leaf-fp-elim",
|
|
|
|
cl::desc("Disable frame pointer elimination optimization for non-leaf funcs"),
|
|
|
|
cl::location(NoFramePointerElimNonLeaf),
|
|
|
|
cl::init(false));
|
|
|
|
static cl::opt<bool, true>
|
2008-05-13 00:00:25 +00:00
|
|
|
DisableExcessPrecision("disable-excess-fp-precision",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Disable optimizations that may increase FP precision"),
|
|
|
|
cl::location(NoExcessFPPrecision),
|
|
|
|
cl::init(false));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
2009-03-20 05:06:58 +00:00
|
|
|
EnableFPMAD("enable-fp-mad",
|
|
|
|
cl::desc("Enable less precise MAD instructions to be generated"),
|
|
|
|
cl::location(LessPreciseFPMADOption),
|
|
|
|
cl::init(false));
|
|
|
|
static cl::opt<bool, true>
|
2008-05-13 00:00:25 +00:00
|
|
|
EnableUnsafeFPMath("enable-unsafe-fp-math",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Enable optimizations that may decrease FP precision"),
|
|
|
|
cl::location(UnsafeFPMath),
|
|
|
|
cl::init(false));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
2010-07-15 22:07:12 +00:00
|
|
|
EnableNoInfsFPMath("enable-no-infs-fp-math",
|
|
|
|
cl::desc("Enable FP math optimizations that assume no +-Infs"),
|
|
|
|
cl::location(NoInfsFPMath),
|
|
|
|
cl::init(false));
|
|
|
|
static cl::opt<bool, true>
|
|
|
|
EnableNoNaNsFPMath("enable-no-nans-fp-math",
|
|
|
|
cl::desc("Enable FP math optimizations that assume no NaNs"),
|
|
|
|
cl::location(NoNaNsFPMath),
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::init(false));
|
|
|
|
static cl::opt<bool, true>
|
|
|
|
EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
|
|
|
|
cl::Hidden,
|
|
|
|
cl::desc("Force codegen to assume rounding mode can change dynamically"),
|
|
|
|
cl::location(HonorSignDependentRoundingFPMathOption),
|
|
|
|
cl::init(false));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
|
|
|
GenerateSoftFloatCalls("soft-float",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Generate software floating point library calls"),
|
|
|
|
cl::location(UseSoftFloat),
|
|
|
|
cl::init(false));
|
2009-06-08 22:53:56 +00:00
|
|
|
static cl::opt<llvm::FloatABI::ABIType, true>
|
|
|
|
FloatABIForCalls("float-abi",
|
|
|
|
cl::desc("Choose float ABI type"),
|
|
|
|
cl::location(FloatABIType),
|
|
|
|
cl::init(FloatABI::Default),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(FloatABI::Default, "default",
|
|
|
|
"Target default float ABI type"),
|
|
|
|
clEnumValN(FloatABI::Soft, "soft",
|
|
|
|
"Soft float ABI (implied by -soft-float)"),
|
|
|
|
clEnumValN(FloatABI::Hard, "hard",
|
|
|
|
"Hard float ABI (uses FP registers)"),
|
|
|
|
clEnumValEnd));
|
2009-03-11 22:30:01 +00:00
|
|
|
static cl::opt<bool, true>
|
2008-05-13 00:00:25 +00:00
|
|
|
DontPlaceZerosInBSS("nozero-initialized-in-bss",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Don't place zero-initialized symbols into bss section"),
|
|
|
|
cl::location(NoZerosInBSS),
|
|
|
|
cl::init(false));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
2010-05-02 15:36:26 +00:00
|
|
|
EnableJITExceptionHandling("jit-enable-eh",
|
|
|
|
cl::desc("Emit exception handling information"),
|
|
|
|
cl::location(JITExceptionHandling),
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::init(false));
|
Implement the JIT side of the GDB JIT debugging interface. To enable this
feature, either build the JIT in debug mode to enable it by default or pass
-jit-emit-debug to lli.
Right now, the only debug information that this communicates to GDB is call
frame information, since it's already being generated to support exceptions in
the JIT. Eventually, when DWARF generation isn't tied so tightly to AsmPrinter,
it will be easy to push that information to GDB through this interface.
Here's a step-by-step breakdown of how the feature works:
- The JIT generates the machine code and DWARF call frame info
(.eh_frame/.debug_frame) for a function into memory.
- The JIT copies that info into an in-memory ELF file with a symbol for the
function.
- The JIT creates a code entry pointing to the ELF buffer and adds it to a
linked list hanging off of a global descriptor at a special symbol that GDB
knows about.
- The JIT calls a function marked noinline that GDB knows about and has put an
internal breakpoint in.
- GDB catches the breakpoint and reads the global descriptor to look for new
code.
- When sees there is new code, it reads the ELF from the inferior's memory and
adds it to itself as an object file.
- The JIT continues, and the next time we stop the program, we are able to
produce a proper backtrace.
Consider running the following program through the JIT:
#include <stdio.h>
void baz(short z) {
long w = z + 1;
printf("%d, %x\n", w, *((int*)NULL)); // SEGFAULT here
}
void bar(short y) {
int z = y + 1;
baz(z);
}
void foo(char x) {
short y = x + 1;
bar(y);
}
int main(int argc, char** argv) {
char x = 1;
foo(x);
}
Here is a backtrace before this patch:
Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x2aaaabdfbd10 (LWP 25476)]
0x00002aaaabe7d1a8 in ?? ()
(gdb) bt
#0 0x00002aaaabe7d1a8 in ?? ()
#1 0x0000000000000003 in ?? ()
#2 0x0000000000000004 in ?? ()
#3 0x00032aaaabe7cfd0 in ?? ()
#4 0x00002aaaabe7d12c in ?? ()
#5 0x00022aaa00000003 in ?? ()
#6 0x00002aaaabe7d0aa in ?? ()
#7 0x01000002abe7cff0 in ?? ()
#8 0x00002aaaabe7d02c in ?? ()
#9 0x0100000000000001 in ?? ()
#10 0x00000000014388e0 in ?? ()
#11 0x00007fff00000001 in ?? ()
#12 0x0000000000b870a2 in llvm::JIT::runFunction (this=0x1405b70,
F=0x14024e0, ArgValues=@0x7fffffffe050)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/JIT/JIT.cpp:395
#13 0x0000000000baa4c5 in llvm::ExecutionEngine::runFunctionAsMain
(this=0x1405b70, Fn=0x14024e0, argv=@0x13f06f8, envp=0x7fffffffe3b0)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/ExecutionEngine.cpp:377
#14 0x00000000007ebd52 in main (argc=2, argv=0x7fffffffe398,
envp=0x7fffffffe3b0) at /home/rnk/llvm-gdb/tools/lli/lli.cpp:208
And a backtrace after this patch:
Program received signal SIGSEGV, Segmentation fault.
0x00002aaaabe7d1a8 in baz ()
(gdb) bt
#0 0x00002aaaabe7d1a8 in baz ()
#1 0x00002aaaabe7d12c in bar ()
#2 0x00002aaaabe7d0aa in foo ()
#3 0x00002aaaabe7d02c in main ()
#4 0x0000000000b870a2 in llvm::JIT::runFunction (this=0x1405b70,
F=0x14024e0, ArgValues=...)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/JIT/JIT.cpp:395
#5 0x0000000000baa4c5 in llvm::ExecutionEngine::runFunctionAsMain
(this=0x1405b70, Fn=0x14024e0, argv=..., envp=0x7fffffffe3c0)
at /home/rnk/llvm-gdb/lib/ExecutionEngine/ExecutionEngine.cpp:377
#6 0x00000000007ebd52 in main (argc=2, argv=0x7fffffffe3a8,
envp=0x7fffffffe3c0) at /home/rnk/llvm-gdb/tools/lli/lli.cpp:208
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82418 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-20 23:52:43 +00:00
|
|
|
// In debug builds, make this default to true.
|
|
|
|
#ifdef NDEBUG
|
|
|
|
#define EMIT_DEBUG false
|
|
|
|
#else
|
|
|
|
#define EMIT_DEBUG true
|
|
|
|
#endif
|
|
|
|
static cl::opt<bool, true>
|
|
|
|
EmitJitDebugInfo("jit-emit-debug",
|
|
|
|
cl::desc("Emit debug information to debugger"),
|
|
|
|
cl::location(JITEmitDebugInfo),
|
|
|
|
cl::init(EMIT_DEBUG));
|
|
|
|
#undef EMIT_DEBUG
|
|
|
|
static cl::opt<bool, true>
|
|
|
|
EmitJitDebugInfoToDisk("jit-emit-debug-to-disk",
|
|
|
|
cl::Hidden,
|
|
|
|
cl::desc("Emit debug info objfiles to disk"),
|
|
|
|
cl::location(JITEmitDebugInfoToDisk),
|
|
|
|
cl::init(false));
|
2007-10-11 19:40:01 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<llvm::CodeModel::Model, true>
|
2009-03-11 22:30:01 +00:00
|
|
|
DefCodeModel("code-model",
|
2008-05-13 00:00:25 +00:00
|
|
|
cl::desc("Choose code model"),
|
|
|
|
cl::location(CMModel),
|
|
|
|
cl::init(CodeModel::Default),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(CodeModel::Default, "default",
|
2008-10-14 20:25:08 +00:00
|
|
|
"Target default code model"),
|
2008-05-13 00:00:25 +00:00
|
|
|
clEnumValN(CodeModel::Small, "small",
|
2008-10-14 20:25:08 +00:00
|
|
|
"Small code model"),
|
2008-05-13 00:00:25 +00:00
|
|
|
clEnumValN(CodeModel::Kernel, "kernel",
|
2008-10-14 20:25:08 +00:00
|
|
|
"Kernel code model"),
|
2008-05-13 00:00:25 +00:00
|
|
|
clEnumValN(CodeModel::Medium, "medium",
|
2008-10-14 20:25:08 +00:00
|
|
|
"Medium code model"),
|
2008-05-13 00:00:25 +00:00
|
|
|
clEnumValN(CodeModel::Large, "large",
|
2008-10-14 20:25:08 +00:00
|
|
|
"Large code model"),
|
2008-05-13 00:00:25 +00:00
|
|
|
clEnumValEnd));
|
|
|
|
static cl::opt<bool, true>
|
2010-02-08 20:27:50 +00:00
|
|
|
EnableGuaranteedTailCallOpt("tailcallopt",
|
2010-01-27 00:10:09 +00:00
|
|
|
cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
|
2010-02-08 20:27:50 +00:00
|
|
|
cl::location(GuaranteedTailCallOpt),
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::init(false));
|
2008-07-01 23:18:29 +00:00
|
|
|
static cl::opt<unsigned, true>
|
|
|
|
OverrideStackAlignment("stack-alignment",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Override default stack alignment"),
|
2011-06-23 18:15:47 +00:00
|
|
|
cl::location(StackAlignmentOverride),
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::init(0));
|
2008-05-13 00:00:25 +00:00
|
|
|
static cl::opt<bool, true>
|
|
|
|
EnableRealignStack("realign-stack",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Realign stack if needed"),
|
|
|
|
cl::location(RealignStack),
|
|
|
|
cl::init(true));
|
2008-07-01 23:18:29 +00:00
|
|
|
static cl::opt<bool, true>
|
2008-07-31 18:13:12 +00:00
|
|
|
DisableSwitchTables(cl::Hidden, "disable-jump-tables",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Do not generate jump tables."),
|
|
|
|
cl::location(DisableJumpTables),
|
|
|
|
cl::init(false));
|
2008-10-07 20:22:28 +00:00
|
|
|
static cl::opt<bool, true>
|
|
|
|
EnableStrongPHIElim(cl::Hidden, "strong-phi-elim",
|
2009-03-11 22:30:01 +00:00
|
|
|
cl::desc("Use strong PHI elimination."),
|
|
|
|
cl::location(StrongPHIElim),
|
|
|
|
cl::init(false));
|
2011-04-08 21:37:21 +00:00
|
|
|
static cl::opt<std::string>
|
|
|
|
TrapFuncName("trap-func", cl::Hidden,
|
|
|
|
cl::desc("Emit a call to trap function rather than a trap instruction"),
|
|
|
|
cl::init(""));
|
2010-04-13 00:36:43 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
DataSections("fdata-sections",
|
|
|
|
cl::desc("Emit data into separate sections"),
|
|
|
|
cl::init(false));
|
|
|
|
static cl::opt<bool>
|
|
|
|
FunctionSections("ffunction-sections",
|
|
|
|
cl::desc("Emit functions into separate sections"),
|
|
|
|
cl::init(false));
|
2001-07-21 12:42:08 +00:00
|
|
|
//---------------------------------------------------------------------------
|
2003-12-28 21:23:38 +00:00
|
|
|
// TargetMachine Class
|
|
|
|
//
|
2004-08-10 23:10:25 +00:00
|
|
|
|
2011-07-08 01:53:10 +00:00
|
|
|
TargetMachine::TargetMachine(const Target &T,
|
|
|
|
StringRef TT, StringRef CPU, StringRef FS)
|
|
|
|
: TheTarget(T), TargetTriple(TT), TargetCPU(CPU), TargetFS(FS), AsmInfo(0),
|
2010-11-19 02:26:16 +00:00
|
|
|
MCRelaxAll(false),
|
2011-01-23 18:50:12 +00:00
|
|
|
MCNoExecStack(false),
|
2011-03-28 22:49:19 +00:00
|
|
|
MCSaveTempLabels(false),
|
2011-04-30 03:44:37 +00:00
|
|
|
MCUseLoc(true),
|
|
|
|
MCUseCFI(true) {
|
2009-06-08 22:53:56 +00:00
|
|
|
// Typically it will be subtargets that will adjust FloatABIType from Default
|
|
|
|
// to Soft or Hard.
|
|
|
|
if (UseSoftFloat)
|
|
|
|
FloatABIType = FloatABI::Soft;
|
|
|
|
}
|
|
|
|
|
2003-12-28 21:23:38 +00:00
|
|
|
TargetMachine::~TargetMachine() {
|
2006-09-07 23:39:26 +00:00
|
|
|
delete AsmInfo;
|
2003-12-28 21:23:38 +00:00
|
|
|
}
|
|
|
|
|
2006-02-22 20:19:42 +00:00
|
|
|
/// getRelocationModel - Returns the code generation relocation model. The
|
|
|
|
/// choices are static, PIC, and dynamic-no-pic, and target default.
|
2011-07-19 06:37:02 +00:00
|
|
|
Reloc::Model TargetMachine::getRelocationModel() const {
|
|
|
|
if (!CodeGenInfo)
|
|
|
|
return Reloc::Default;
|
|
|
|
return CodeGenInfo->getRelocationModel();
|
2006-02-22 20:19:42 +00:00
|
|
|
}
|
2006-05-23 18:18:46 +00:00
|
|
|
|
2006-07-06 01:53:36 +00:00
|
|
|
/// getCodeModel - Returns the code model. The choices are small, kernel,
|
|
|
|
/// medium, large, and target default.
|
|
|
|
CodeModel::Model TargetMachine::getCodeModel() {
|
|
|
|
return CMModel;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// setCodeModel - Sets the code model.
|
|
|
|
void TargetMachine::setCodeModel(CodeModel::Model Model) {
|
|
|
|
CMModel = Model;
|
|
|
|
}
|
|
|
|
|
2009-03-25 01:47:28 +00:00
|
|
|
bool TargetMachine::getAsmVerbosityDefault() {
|
|
|
|
return AsmVerbosityDefault;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TargetMachine::setAsmVerbosityDefault(bool V) {
|
|
|
|
AsmVerbosityDefault = V;
|
|
|
|
}
|
|
|
|
|
2010-04-13 00:36:43 +00:00
|
|
|
bool TargetMachine::getFunctionSections() {
|
|
|
|
return FunctionSections;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TargetMachine::getDataSections() {
|
|
|
|
return DataSections;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TargetMachine::setFunctionSections(bool V) {
|
|
|
|
FunctionSections = V;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TargetMachine::setDataSections(bool V) {
|
|
|
|
DataSections = V;
|
|
|
|
}
|
|
|
|
|
2006-05-23 18:18:46 +00:00
|
|
|
namespace llvm {
|
2010-04-21 03:18:23 +00:00
|
|
|
/// DisableFramePointerElim - This returns true if frame pointer elimination
|
|
|
|
/// optimization should be disabled for the given machine function.
|
|
|
|
bool DisableFramePointerElim(const MachineFunction &MF) {
|
2010-05-17 23:09:50 +00:00
|
|
|
// Check to see if we should eliminate non-leaf frame pointers and then
|
|
|
|
// check to see if we should eliminate all frame pointers.
|
2010-05-18 21:47:08 +00:00
|
|
|
if (NoFramePointerElimNonLeaf && !NoFramePointerElim) {
|
2010-04-21 03:18:23 +00:00
|
|
|
const MachineFrameInfo *MFI = MF.getFrameInfo();
|
2010-05-14 21:28:24 +00:00
|
|
|
return MFI->hasCalls();
|
2010-04-21 03:18:23 +00:00
|
|
|
}
|
2010-05-17 23:09:50 +00:00
|
|
|
|
|
|
|
return NoFramePointerElim;
|
2010-04-21 03:18:23 +00:00
|
|
|
}
|
|
|
|
|
2009-03-20 05:06:58 +00:00
|
|
|
/// LessPreciseFPMAD - This flag return true when -enable-fp-mad option
|
|
|
|
/// is specified on the command line. When this flag is off(default), the
|
|
|
|
/// code generator is not allowed to generate mad (multiply add) if the
|
|
|
|
/// result is "less precise" than doing those operations individually.
|
|
|
|
bool LessPreciseFPMAD() { return UnsafeFPMath || LessPreciseFPMADOption; }
|
|
|
|
|
2007-05-03 00:16:07 +00:00
|
|
|
/// HonorSignDependentRoundingFPMath - Return true if the codegen must assume
|
|
|
|
/// that the rounding mode of the FPU can change from its default.
|
|
|
|
bool HonorSignDependentRoundingFPMath() {
|
|
|
|
return !UnsafeFPMath && HonorSignDependentRoundingFPMathOption;
|
|
|
|
}
|
2011-04-08 21:37:21 +00:00
|
|
|
|
|
|
|
/// getTrapFunctionName - If this returns a non-empty string, this means isel
|
|
|
|
/// should lower Intrinsic::trap to a call to the specified function name
|
|
|
|
/// instead of an ISD::TRAP node.
|
|
|
|
StringRef getTrapFunctionName() {
|
|
|
|
return TrapFuncName;
|
|
|
|
}
|
2006-05-24 19:05:21 +00:00
|
|
|
}
|