2006-09-07 22:05:02 +00:00
|
|
|
//===-- X86TargetAsmInfo.cpp - X86 asm properties ---------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// 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.
|
2006-09-07 22:05:02 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains the declarations of the X86TargetAsmInfo properties.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "X86TargetAsmInfo.h"
|
|
|
|
#include "X86TargetMachine.h"
|
|
|
|
#include "X86Subtarget.h"
|
2007-01-12 23:22:14 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2006-11-29 01:14:06 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
|
|
|
#include "llvm/Instructions.h"
|
2007-04-01 20:49:36 +00:00
|
|
|
#include "llvm/Intrinsics.h"
|
2006-11-29 01:14:06 +00:00
|
|
|
#include "llvm/Module.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2008-02-27 23:33:50 +00:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
using namespace llvm;
|
2008-02-27 23:33:50 +00:00
|
|
|
using namespace llvm::dwarf;
|
2006-09-07 22:05:02 +00:00
|
|
|
|
2008-03-25 21:45:14 +00:00
|
|
|
static const char *const x86_asm_table[] = {
|
|
|
|
"{si}", "S",
|
2006-11-28 19:52:49 +00:00
|
|
|
"{di}", "D",
|
|
|
|
"{ax}", "a",
|
|
|
|
"{cx}", "c",
|
|
|
|
"{memory}", "memory",
|
|
|
|
"{flags}", "",
|
|
|
|
"{dirflag}", "",
|
|
|
|
"{fpsr}", "",
|
|
|
|
"{cc}", "cc",
|
|
|
|
0,0};
|
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
X86TargetAsmInfo::X86TargetAsmInfo(const X86TargetMachine &TM) {
|
|
|
|
const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
|
2008-02-27 23:33:50 +00:00
|
|
|
X86TM = &TM;
|
|
|
|
|
2006-11-28 19:52:49 +00:00
|
|
|
AsmTransCBE = x86_asm_table;
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2007-01-16 09:29:17 +00:00
|
|
|
AssemblerDialect = Subtarget->getAsmFlavor();
|
2006-09-07 22:05:02 +00:00
|
|
|
}
|
2006-10-05 02:43:52 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
bool X86TargetAsmInfo::LowerToBSwap(CallInst *CI) const {
|
|
|
|
// FIXME: this should verify that we are targetting a 486 or better. If not,
|
|
|
|
// we will turn this bswap into something that will be lowered to logical ops
|
|
|
|
// instead of emitting the bswap asm. For now, we don't support 486 or lower
|
|
|
|
// so don't worry about this.
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
// Verify this is a simple bswap.
|
|
|
|
if (CI->getNumOperands() != 2 ||
|
|
|
|
CI->getType() != CI->getOperand(1)->getType() ||
|
2007-01-15 02:27:26 +00:00
|
|
|
!CI->getType()->isInteger())
|
2006-11-29 01:14:06 +00:00
|
|
|
return false;
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2007-04-01 20:49:36 +00:00
|
|
|
const IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
|
|
|
|
if (!Ty || Ty->getBitWidth() % 16 != 0)
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
return false;
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
// Okay, we can do this xform, do so now.
|
2007-08-04 01:51:18 +00:00
|
|
|
const Type *Tys[] = { Ty };
|
2006-11-29 01:14:06 +00:00
|
|
|
Module *M = CI->getParent()->getParent()->getParent();
|
2007-08-04 01:51:18 +00:00
|
|
|
Constant *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1);
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
Value *Op = CI->getOperand(1);
|
2008-04-06 20:25:17 +00:00
|
|
|
Op = CallInst::Create(Int, Op, CI->getName(), CI);
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
CI->replaceAllUsesWith(Op);
|
|
|
|
CI->eraseFromParent();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool X86TargetAsmInfo::ExpandInlineAsm(CallInst *CI) const {
|
|
|
|
InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
|
Upgrade the ugly darwin 64-bit bswap idiom (bswap %eax / bswap %edx /
xchgl %eax, %edx) to llvm.bswap.i64. This compiles:
long long test2(long long A) {
return _OSSwapInt64(A);
}
to:
_test2:
movl 8(%esp), %eax
movl 4(%esp), %edx
bswapl %eax
bswapl %edx
ret
instead of:
_test2:
movl 8(%esp), %edx
movl 4(%esp), %eax
bswap %eax
bswap %edx
xchgl %eax, %edx
ret
GCC manages (with -fomit-frame-pointer) the uglier:
_test2:
subl $4, %esp
movl 8(%esp), %eax
movl 12(%esp), %edx
bswap %eax
bswap %edx
xchgl %eax, %edx
addl $4, %esp
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32001 91177308-0d34-0410-b5e6-96231b3b80d8
2006-11-29 01:48:01 +00:00
|
|
|
std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints();
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
std::string AsmStr = IA->getAsmString();
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
// TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
|
|
|
|
std::vector<std::string> AsmPieces;
|
|
|
|
SplitString(AsmStr, AsmPieces, "\n"); // ; as separator?
|
2008-07-09 13:20:27 +00:00
|
|
|
|
2006-11-29 01:14:06 +00:00
|
|
|
switch (AsmPieces.size()) {
|
2008-07-09 13:20:27 +00:00
|
|
|
default: return false;
|
2006-11-29 01:14:06 +00:00
|
|
|
case 1:
|
|
|
|
AsmStr = AsmPieces[0];
|
|
|
|
AsmPieces.clear();
|
|
|
|
SplitString(AsmStr, AsmPieces, " \t"); // Split with whitespace.
|
2008-07-09 13:20:27 +00:00
|
|
|
|
Upgrade the ugly darwin 64-bit bswap idiom (bswap %eax / bswap %edx /
xchgl %eax, %edx) to llvm.bswap.i64. This compiles:
long long test2(long long A) {
return _OSSwapInt64(A);
}
to:
_test2:
movl 8(%esp), %eax
movl 4(%esp), %edx
bswapl %eax
bswapl %edx
ret
instead of:
_test2:
movl 8(%esp), %edx
movl 4(%esp), %eax
bswap %eax
bswap %edx
xchgl %eax, %edx
ret
GCC manages (with -fomit-frame-pointer) the uglier:
_test2:
subl $4, %esp
movl 8(%esp), %eax
movl 12(%esp), %edx
bswap %eax
bswap %edx
xchgl %eax, %edx
addl $4, %esp
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32001 91177308-0d34-0410-b5e6-96231b3b80d8
2006-11-29 01:48:01 +00:00
|
|
|
// bswap $0
|
2008-07-09 13:20:27 +00:00
|
|
|
if (AsmPieces.size() == 2 &&
|
2006-11-29 01:14:06 +00:00
|
|
|
AsmPieces[0] == "bswap" && AsmPieces[1] == "$0") {
|
|
|
|
// No need to check constraints, nothing other than the equivalent of
|
|
|
|
// "=r,0" would be valid here.
|
|
|
|
return LowerToBSwap(CI);
|
|
|
|
}
|
|
|
|
break;
|
Upgrade the ugly darwin 64-bit bswap idiom (bswap %eax / bswap %edx /
xchgl %eax, %edx) to llvm.bswap.i64. This compiles:
long long test2(long long A) {
return _OSSwapInt64(A);
}
to:
_test2:
movl 8(%esp), %eax
movl 4(%esp), %edx
bswapl %eax
bswapl %edx
ret
instead of:
_test2:
movl 8(%esp), %edx
movl 4(%esp), %eax
bswap %eax
bswap %edx
xchgl %eax, %edx
ret
GCC manages (with -fomit-frame-pointer) the uglier:
_test2:
subl $4, %esp
movl 8(%esp), %eax
movl 12(%esp), %edx
bswap %eax
bswap %edx
xchgl %eax, %edx
addl $4, %esp
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32001 91177308-0d34-0410-b5e6-96231b3b80d8
2006-11-29 01:48:01 +00:00
|
|
|
case 3:
|
2006-12-31 05:55:36 +00:00
|
|
|
if (CI->getType() == Type::Int64Ty && Constraints.size() >= 2 &&
|
Upgrade the ugly darwin 64-bit bswap idiom (bswap %eax / bswap %edx /
xchgl %eax, %edx) to llvm.bswap.i64. This compiles:
long long test2(long long A) {
return _OSSwapInt64(A);
}
to:
_test2:
movl 8(%esp), %eax
movl 4(%esp), %edx
bswapl %eax
bswapl %edx
ret
instead of:
_test2:
movl 8(%esp), %edx
movl 4(%esp), %eax
bswap %eax
bswap %edx
xchgl %eax, %edx
ret
GCC manages (with -fomit-frame-pointer) the uglier:
_test2:
subl $4, %esp
movl 8(%esp), %eax
movl 12(%esp), %edx
bswap %eax
bswap %edx
xchgl %eax, %edx
addl $4, %esp
ret
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32001 91177308-0d34-0410-b5e6-96231b3b80d8
2006-11-29 01:48:01 +00:00
|
|
|
Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
|
|
|
|
Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {
|
|
|
|
// bswap %eax / bswap %edx / xchgl %eax, %edx -> llvm.bswap.i64
|
|
|
|
std::vector<std::string> Words;
|
|
|
|
SplitString(AsmPieces[0], Words, " \t");
|
|
|
|
if (Words.size() == 2 && Words[0] == "bswap" && Words[1] == "%eax") {
|
|
|
|
Words.clear();
|
|
|
|
SplitString(AsmPieces[1], Words, " \t");
|
|
|
|
if (Words.size() == 2 && Words[0] == "bswap" && Words[1] == "%edx") {
|
|
|
|
Words.clear();
|
|
|
|
SplitString(AsmPieces[2], Words, " \t,");
|
|
|
|
if (Words.size() == 3 && Words[0] == "xchgl" && Words[1] == "%eax" &&
|
|
|
|
Words[2] == "%edx") {
|
|
|
|
return LowerToBSwap(CI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2006-11-29 01:14:06 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2008-02-27 23:33:50 +00:00
|
|
|
|
2008-07-09 13:20:48 +00:00
|
|
|
X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM):
|
|
|
|
X86TargetAsmInfo(TM) {
|
|
|
|
bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
|
|
|
|
|
|
|
|
AlignmentIsInBytes = false;
|
|
|
|
TextAlignFillValue = 0x90;
|
|
|
|
GlobalPrefix = "_";
|
|
|
|
if (!is64Bit)
|
|
|
|
Data64bitsDirective = 0; // we can't emit a 64-bit unit
|
|
|
|
ZeroDirective = "\t.space\t"; // ".space N" emits N zeros.
|
|
|
|
PrivateGlobalPrefix = "L"; // Marker for constant pool idxs
|
|
|
|
BSSSection = 0; // no BSS section.
|
|
|
|
ZeroFillDirective = "\t.zerofill\t"; // Uses .zerofill
|
|
|
|
ConstantPoolSection = "\t.const\n";
|
|
|
|
JumpTableDataSection = "\t.const\n";
|
|
|
|
CStringSection = "\t.cstring";
|
|
|
|
FourByteConstantSection = "\t.literal4\n";
|
|
|
|
EightByteConstantSection = "\t.literal8\n";
|
|
|
|
// FIXME: Why don't always use this section?
|
|
|
|
if (is64Bit)
|
|
|
|
SixteenByteConstantSection = "\t.literal16\n";
|
|
|
|
ReadOnlySection = "\t.const\n";
|
|
|
|
LCOMMDirective = "\t.lcomm\t";
|
|
|
|
SwitchToSectionDirective = "\t.section ";
|
|
|
|
StringConstantPrefix = "\1LC";
|
|
|
|
COMMDirectiveTakesAlignment = false;
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
if (TM.getRelocationModel() == Reloc::Static) {
|
|
|
|
StaticCtorsSection = ".constructor";
|
|
|
|
StaticDtorsSection = ".destructor";
|
|
|
|
} else {
|
|
|
|
StaticCtorsSection = ".mod_init_func";
|
|
|
|
StaticDtorsSection = ".mod_term_func";
|
|
|
|
}
|
|
|
|
if (is64Bit) {
|
|
|
|
PersonalityPrefix = "";
|
|
|
|
PersonalitySuffix = "+4@GOTPCREL";
|
|
|
|
} else {
|
|
|
|
PersonalityPrefix = "L";
|
|
|
|
PersonalitySuffix = "$non_lazy_ptr";
|
|
|
|
}
|
|
|
|
NeedsIndirectEncoding = true;
|
|
|
|
InlineAsmStart = "## InlineAsm Start";
|
|
|
|
InlineAsmEnd = "## InlineAsm End";
|
|
|
|
CommentString = "##";
|
|
|
|
SetDirective = "\t.set";
|
|
|
|
PCSymbol = ".";
|
|
|
|
UsedDirective = "\t.no_dead_strip\t";
|
|
|
|
WeakDefDirective = "\t.weak_definition ";
|
|
|
|
WeakRefDirective = "\t.weak_reference ";
|
|
|
|
HiddenDirective = "\t.private_extern ";
|
|
|
|
ProtectedDirective = "\t.globl\t";
|
|
|
|
|
|
|
|
// In non-PIC modes, emit a special label before jump tables so that the
|
|
|
|
// linker can perform more accurate dead code stripping.
|
|
|
|
if (TM.getRelocationModel() != Reloc::PIC_) {
|
|
|
|
// Emit a local label that is preserved until the linker runs.
|
|
|
|
JumpTableSpecialLabelPrefix = "l";
|
|
|
|
}
|
|
|
|
|
|
|
|
SupportsDebugInformation = true;
|
|
|
|
NeedsSet = true;
|
|
|
|
DwarfAbbrevSection = ".section __DWARF,__debug_abbrev,regular,debug";
|
|
|
|
DwarfInfoSection = ".section __DWARF,__debug_info,regular,debug";
|
|
|
|
DwarfLineSection = ".section __DWARF,__debug_line,regular,debug";
|
|
|
|
DwarfFrameSection = ".section __DWARF,__debug_frame,regular,debug";
|
|
|
|
DwarfPubNamesSection = ".section __DWARF,__debug_pubnames,regular,debug";
|
|
|
|
DwarfPubTypesSection = ".section __DWARF,__debug_pubtypes,regular,debug";
|
|
|
|
DwarfStrSection = ".section __DWARF,__debug_str,regular,debug";
|
|
|
|
DwarfLocSection = ".section __DWARF,__debug_loc,regular,debug";
|
|
|
|
DwarfARangesSection = ".section __DWARF,__debug_aranges,regular,debug";
|
|
|
|
DwarfRangesSection = ".section __DWARF,__debug_ranges,regular,debug";
|
|
|
|
DwarfMacInfoSection = ".section __DWARF,__debug_macinfo,regular,debug";
|
|
|
|
|
|
|
|
// Exceptions handling
|
|
|
|
SupportsExceptionHandling = true;
|
|
|
|
GlobalEHDirective = "\t.globl\t";
|
|
|
|
SupportsWeakOmittedEHFrame = false;
|
|
|
|
AbsoluteEHSectionOffsets = false;
|
|
|
|
DwarfEHFrameSection =
|
|
|
|
".section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support";
|
|
|
|
DwarfExceptionSection = ".section __DATA,__gcc_except_tab";
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:08 +00:00
|
|
|
unsigned
|
|
|
|
X86DarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
|
|
|
|
bool Global) const {
|
|
|
|
if (Reason == DwarfEncoding::Functions && Global)
|
|
|
|
return (DW_EH_PE_pcrel | DW_EH_PE_indirect | DW_EH_PE_sdata4);
|
|
|
|
else if (Reason == DwarfEncoding::CodeLabels || !Global)
|
|
|
|
return DW_EH_PE_pcrel;
|
|
|
|
else
|
|
|
|
return DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:29 +00:00
|
|
|
std::string
|
|
|
|
X86DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
|
|
|
|
SectionKind::Kind kind) const {
|
|
|
|
if (kind == SectionKind::Text)
|
|
|
|
return "__TEXT,__textcoal_nt,coalesced,pure_instructions";
|
|
|
|
else
|
|
|
|
return "__DATA,__datacoal_nt,coalesced";
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:20:48 +00:00
|
|
|
X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM):
|
|
|
|
X86TargetAsmInfo(TM) {
|
|
|
|
bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
|
|
|
|
|
|
|
|
ReadOnlySection = "\t.section\t.rodata";
|
|
|
|
FourByteConstantSection = "\t.section\t.rodata.cst4,\"aM\",@progbits,4";
|
|
|
|
EightByteConstantSection = "\t.section\t.rodata.cst8,\"aM\",@progbits,8";
|
|
|
|
SixteenByteConstantSection = "\t.section\t.rodata.cst16,\"aM\",@progbits,16";
|
|
|
|
CStringSection = "\t.section\t.rodata.str1.1,\"aMS\",@progbits,1";
|
|
|
|
PrivateGlobalPrefix = ".L";
|
|
|
|
WeakRefDirective = "\t.weak\t";
|
|
|
|
SetDirective = "\t.set\t";
|
|
|
|
PCSymbol = ".";
|
|
|
|
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
|
|
|
|
|
|
|
// Debug Information
|
|
|
|
AbsoluteDebugSectionOffsets = true;
|
|
|
|
SupportsDebugInformation = true;
|
|
|
|
DwarfAbbrevSection = "\t.section\t.debug_abbrev,\"\",@progbits";
|
|
|
|
DwarfInfoSection = "\t.section\t.debug_info,\"\",@progbits";
|
|
|
|
DwarfLineSection = "\t.section\t.debug_line,\"\",@progbits";
|
|
|
|
DwarfFrameSection = "\t.section\t.debug_frame,\"\",@progbits";
|
|
|
|
DwarfPubNamesSection ="\t.section\t.debug_pubnames,\"\",@progbits";
|
|
|
|
DwarfPubTypesSection ="\t.section\t.debug_pubtypes,\"\",@progbits";
|
|
|
|
DwarfStrSection = "\t.section\t.debug_str,\"\",@progbits";
|
|
|
|
DwarfLocSection = "\t.section\t.debug_loc,\"\",@progbits";
|
|
|
|
DwarfARangesSection = "\t.section\t.debug_aranges,\"\",@progbits";
|
|
|
|
DwarfRangesSection = "\t.section\t.debug_ranges,\"\",@progbits";
|
|
|
|
DwarfMacInfoSection = "\t.section\t.debug_macinfo,\"\",@progbits";
|
|
|
|
|
|
|
|
// Exceptions handling
|
|
|
|
if (!is64Bit)
|
|
|
|
SupportsExceptionHandling = true;
|
|
|
|
AbsoluteEHSectionOffsets = false;
|
|
|
|
DwarfEHFrameSection = "\t.section\t.eh_frame,\"aw\",@progbits";
|
|
|
|
DwarfExceptionSection = "\t.section\t.gcc_except_table,\"a\",@progbits";
|
|
|
|
|
|
|
|
// On Linux we must declare when we can use a non-executable stack.
|
|
|
|
if (X86TM->getSubtarget<X86Subtarget>().isLinux())
|
|
|
|
NonexecutableStackDirective = "\t.section\t.note.GNU-stack,\"\",@progbits";
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:08 +00:00
|
|
|
unsigned
|
|
|
|
X86ELFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
|
|
|
|
bool Global) const {
|
|
|
|
CodeModel::Model CM = X86TM->getCodeModel();
|
|
|
|
bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
|
|
|
|
|
|
|
|
if (X86TM->getRelocationModel() == Reloc::PIC_) {
|
|
|
|
unsigned Format = 0;
|
|
|
|
|
|
|
|
if (!is64Bit)
|
|
|
|
// 32 bit targets always encode pointers as 4 bytes
|
|
|
|
Format = DW_EH_PE_sdata4;
|
|
|
|
else {
|
|
|
|
// 64 bit targets encode pointers in 4 bytes iff:
|
|
|
|
// - code model is small OR
|
|
|
|
// - code model is medium and we're emitting externally visible symbols
|
|
|
|
// or any code symbols
|
|
|
|
if (CM == CodeModel::Small ||
|
|
|
|
(CM == CodeModel::Medium && (Global ||
|
|
|
|
Reason != DwarfEncoding::Data)))
|
|
|
|
Format = DW_EH_PE_sdata4;
|
|
|
|
else
|
|
|
|
Format = DW_EH_PE_sdata8;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Global)
|
|
|
|
Format |= DW_EH_PE_indirect;
|
|
|
|
|
|
|
|
return (Format | DW_EH_PE_pcrel);
|
|
|
|
} else {
|
|
|
|
if (is64Bit &&
|
|
|
|
(CM == CodeModel::Small ||
|
|
|
|
(CM == CodeModel::Medium && Reason != DwarfEncoding::Data)))
|
|
|
|
return DW_EH_PE_udata4;
|
|
|
|
else
|
|
|
|
return DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:20:48 +00:00
|
|
|
X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM):
|
|
|
|
X86TargetAsmInfo(TM) {
|
|
|
|
GlobalPrefix = "_";
|
|
|
|
LCOMMDirective = "\t.lcomm\t";
|
|
|
|
COMMDirectiveTakesAlignment = false;
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
StaticCtorsSection = "\t.section .ctors,\"aw\"";
|
|
|
|
StaticDtorsSection = "\t.section .dtors,\"aw\"";
|
|
|
|
HiddenDirective = NULL;
|
|
|
|
PrivateGlobalPrefix = "L"; // Prefix for private global symbols
|
|
|
|
WeakRefDirective = "\t.weak\t";
|
|
|
|
SetDirective = "\t.set\t";
|
|
|
|
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
|
|
|
AbsoluteDebugSectionOffsets = true;
|
|
|
|
AbsoluteEHSectionOffsets = false;
|
|
|
|
SupportsDebugInformation = true;
|
|
|
|
DwarfSectionOffsetDirective = "\t.secrel32\t";
|
|
|
|
DwarfAbbrevSection = "\t.section\t.debug_abbrev,\"dr\"";
|
|
|
|
DwarfInfoSection = "\t.section\t.debug_info,\"dr\"";
|
|
|
|
DwarfLineSection = "\t.section\t.debug_line,\"dr\"";
|
|
|
|
DwarfFrameSection = "\t.section\t.debug_frame,\"dr\"";
|
|
|
|
DwarfPubNamesSection ="\t.section\t.debug_pubnames,\"dr\"";
|
|
|
|
DwarfPubTypesSection ="\t.section\t.debug_pubtypes,\"dr\"";
|
|
|
|
DwarfStrSection = "\t.section\t.debug_str,\"dr\"";
|
|
|
|
DwarfLocSection = "\t.section\t.debug_loc,\"dr\"";
|
|
|
|
DwarfARangesSection = "\t.section\t.debug_aranges,\"dr\"";
|
|
|
|
DwarfRangesSection = "\t.section\t.debug_ranges,\"dr\"";
|
|
|
|
DwarfMacInfoSection = "\t.section\t.debug_macinfo,\"dr\"";
|
|
|
|
}
|
|
|
|
|
|
|
|
X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
|
|
|
|
X86TargetAsmInfo(TM) {
|
|
|
|
GlobalPrefix = "_";
|
|
|
|
CommentString = ";";
|
|
|
|
|
|
|
|
PrivateGlobalPrefix = "$";
|
|
|
|
AlignDirective = "\talign\t";
|
|
|
|
ZeroDirective = "\tdb\t";
|
|
|
|
ZeroDirectiveSuffix = " dup(0)";
|
|
|
|
AsciiDirective = "\tdb\t";
|
|
|
|
AscizDirective = 0;
|
|
|
|
Data8bitsDirective = "\tdb\t";
|
|
|
|
Data16bitsDirective = "\tdw\t";
|
|
|
|
Data32bitsDirective = "\tdd\t";
|
|
|
|
Data64bitsDirective = "\tdq\t";
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
|
|
|
|
TextSection = "_text";
|
|
|
|
DataSection = "_data";
|
|
|
|
JumpTableDataSection = NULL;
|
|
|
|
SwitchToSectionDirective = "";
|
|
|
|
TextSectionStartSuffix = "\tsegment 'CODE'";
|
|
|
|
DataSectionStartSuffix = "\tsegment 'DATA'";
|
|
|
|
SectionEndDirectiveSuffix = "\tends\n";
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:08 +00:00
|
|
|
unsigned
|
|
|
|
X86COFFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
|
|
|
|
bool Global) const {
|
|
|
|
CodeModel::Model CM = X86TM->getCodeModel();
|
|
|
|
bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
|
2008-02-27 23:33:50 +00:00
|
|
|
|
2008-07-09 13:21:08 +00:00
|
|
|
if (X86TM->getRelocationModel() == Reloc::PIC_) {
|
|
|
|
unsigned Format = 0;
|
|
|
|
|
|
|
|
if (!is64Bit)
|
|
|
|
// 32 bit targets always encode pointers as 4 bytes
|
|
|
|
Format = DW_EH_PE_sdata4;
|
|
|
|
else {
|
|
|
|
// 64 bit targets encode pointers in 4 bytes iff:
|
|
|
|
// - code model is small OR
|
|
|
|
// - code model is medium and we're emitting externally visible symbols
|
|
|
|
// or any code symbols
|
|
|
|
if (CM == CodeModel::Small ||
|
|
|
|
(CM == CodeModel::Medium && (Global ||
|
|
|
|
Reason != DwarfEncoding::Data)))
|
2008-02-27 23:33:50 +00:00
|
|
|
Format = DW_EH_PE_sdata4;
|
|
|
|
else
|
2008-07-09 13:21:08 +00:00
|
|
|
Format = DW_EH_PE_sdata8;
|
2008-02-27 23:33:50 +00:00
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:08 +00:00
|
|
|
if (Global)
|
|
|
|
Format |= DW_EH_PE_indirect;
|
|
|
|
|
|
|
|
return (Format | DW_EH_PE_pcrel);
|
|
|
|
} else {
|
|
|
|
if (is64Bit &&
|
|
|
|
(CM == CodeModel::Small ||
|
|
|
|
(CM == CodeModel::Medium && Reason != DwarfEncoding::Data)))
|
|
|
|
return DW_EH_PE_udata4;
|
|
|
|
else
|
|
|
|
return DW_EH_PE_absptr;
|
2008-02-27 23:33:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:21:29 +00:00
|
|
|
std::string
|
|
|
|
X86COFFTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
|
|
|
|
SectionKind::Kind kind) const {
|
|
|
|
switch (kind) {
|
|
|
|
case SectionKind::Text:
|
|
|
|
return ".text$linkonce" + GV->getName();
|
|
|
|
case SectionKind::Data:
|
|
|
|
case SectionKind::BSS:
|
|
|
|
case SectionKind::ThreadData:
|
|
|
|
case SectionKind::ThreadBSS:
|
|
|
|
return ".data$linkonce" + GV->getName();
|
|
|
|
case SectionKind::ROData:
|
|
|
|
case SectionKind::RODataMergeConst:
|
|
|
|
case SectionKind::RODataMergeStr:
|
|
|
|
return ".rdata$linkonce" + GV->getName();
|
2008-07-09 13:19:38 +00:00
|
|
|
default:
|
2008-07-09 13:21:29 +00:00
|
|
|
assert(0 && "Unknown section kind");
|
2008-07-09 13:19:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:19:08 +00:00
|
|
|
std::string X86TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const {
|
|
|
|
SectionKind::Kind kind = SectionKindForGlobal(GV);
|
|
|
|
unsigned flags = SectionFlagsForGlobal(GV, GV->getSection().c_str());
|
|
|
|
std::string Name;
|
|
|
|
|
|
|
|
// FIXME: Should we use some hashing based on section name and just check
|
|
|
|
// flags?
|
2008-07-09 13:19:38 +00:00
|
|
|
// FIXME: It seems, that Darwin uses much more sections.
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
// Select section name
|
2008-07-09 13:19:38 +00:00
|
|
|
if (GV->hasSection()) {
|
|
|
|
// Honour section already set, if any
|
|
|
|
Name = GV->getSection();
|
|
|
|
} else {
|
|
|
|
// Use default section depending on the 'type' of global
|
|
|
|
if (const Function *F = dyn_cast<Function>(GV)) {
|
|
|
|
switch (F->getLinkage()) {
|
|
|
|
default: assert(0 && "Unknown linkage type!");
|
|
|
|
case Function::InternalLinkage:
|
|
|
|
case Function::DLLExportLinkage:
|
|
|
|
case Function::ExternalLinkage:
|
|
|
|
Name = TextSection;
|
2008-07-09 13:19:08 +00:00
|
|
|
break;
|
2008-07-09 13:19:38 +00:00
|
|
|
case Function::WeakLinkage:
|
|
|
|
case Function::LinkOnceLinkage:
|
|
|
|
Name = UniqueSectionForGlobal(F, kind);
|
2008-07-09 13:19:08 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-07-09 13:19:38 +00:00
|
|
|
} else if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
|
|
|
|
if (GVar->hasCommonLinkage() ||
|
|
|
|
GVar->hasLinkOnceLinkage() ||
|
|
|
|
GVar->hasWeakLinkage())
|
|
|
|
Name = UniqueSectionForGlobal(GVar, kind);
|
|
|
|
else {
|
|
|
|
switch (kind) {
|
|
|
|
case SectionKind::Data:
|
|
|
|
Name = DataSection;
|
|
|
|
break;
|
|
|
|
case SectionKind::BSS:
|
|
|
|
Name = (BSSSection ? BSSSection : DataSection);
|
|
|
|
break;
|
|
|
|
case SectionKind::ROData:
|
|
|
|
case SectionKind::RODataMergeStr:
|
|
|
|
case SectionKind::RODataMergeConst:
|
|
|
|
// FIXME: Temporary
|
|
|
|
Name = DataSection;
|
|
|
|
break;
|
|
|
|
case SectionKind::ThreadData:
|
|
|
|
Name = (TLSDataSection ? TLSDataSection : DataSection);
|
|
|
|
break;
|
|
|
|
case SectionKind::ThreadBSS:
|
|
|
|
Name = (TLSBSSSection ? TLSBSSSection : DataSection);
|
|
|
|
default:
|
|
|
|
assert(0 && "Unsuported section kind for global");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
assert(0 && "Unsupported global");
|
|
|
|
}
|
2008-07-09 13:19:08 +00:00
|
|
|
|
2008-07-09 13:20:07 +00:00
|
|
|
Name += PrintSectionFlags(flags);
|
|
|
|
return Name;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string X86TargetAsmInfo::PrintSectionFlags(unsigned flags) const {
|
|
|
|
const X86Subtarget *Subtarget = &X86TM->getSubtarget<X86Subtarget>();
|
|
|
|
|
|
|
|
std::string Flags = "";
|
|
|
|
|
2008-07-09 13:19:08 +00:00
|
|
|
// Add all special flags, etc
|
|
|
|
switch (Subtarget->TargetType) {
|
|
|
|
case X86Subtarget::isELF:
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += ",\"";
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
if (!(flags & SectionFlags::Debug))
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'a';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::Code)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'x';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::Writeable)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'w';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::Mergeable)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'M';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::Strings)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'S';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::TLS)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'T';
|
2008-07-09 13:19:08 +00:00
|
|
|
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += "\"";
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
// FIXME: There can be exceptions here
|
|
|
|
if (flags & SectionFlags::BSS)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += ",@nobits";
|
2008-07-09 13:19:08 +00:00
|
|
|
else
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += ",@progbits";
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
// FIXME: entity size for mergeable sections
|
|
|
|
break;
|
|
|
|
case X86Subtarget::isCygwin:
|
|
|
|
case X86Subtarget::isMingw:
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += ",\"";
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
if (flags & SectionFlags::Code)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'x';
|
2008-07-09 13:19:08 +00:00
|
|
|
if (flags & SectionFlags::Writeable)
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += 'w';
|
2008-07-09 13:19:08 +00:00
|
|
|
|
2008-07-09 13:20:07 +00:00
|
|
|
Flags += "\"";
|
2008-07-09 13:19:08 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
case X86Subtarget::isDarwin:
|
|
|
|
// Darwin does not use any special flags
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:20:07 +00:00
|
|
|
return Flags;
|
2008-07-09 13:19:08 +00:00
|
|
|
}
|