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-10-05 02:43:52 +00:00
|
|
|
// FIXME - Should be simplified.
|
2006-11-28 19:52:49 +00:00
|
|
|
|
|
|
|
AsmTransCBE = x86_asm_table;
|
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
switch (Subtarget->TargetType) {
|
|
|
|
case X86Subtarget::isDarwin:
|
|
|
|
AlignmentIsInBytes = false;
|
2008-02-28 00:43:03 +00:00
|
|
|
TextAlignFillValue = 0x90;
|
2006-09-07 22:05:02 +00:00
|
|
|
GlobalPrefix = "_";
|
2006-09-08 06:48:29 +00:00
|
|
|
if (!Subtarget->is64Bit())
|
|
|
|
Data64bitsDirective = 0; // we can't emit a 64-bit unit
|
2006-09-07 22:05:02 +00:00
|
|
|
ZeroDirective = "\t.space\t"; // ".space N" emits N zeros.
|
|
|
|
PrivateGlobalPrefix = "L"; // Marker for constant pool idxs
|
2007-01-17 17:43:33 +00:00
|
|
|
BSSSection = 0; // no BSS section.
|
|
|
|
ZeroFillDirective = "\t.zerofill\t"; // Uses .zerofill
|
2006-09-07 22:05:02 +00:00
|
|
|
ConstantPoolSection = "\t.const\n";
|
2006-10-05 02:43:52 +00:00
|
|
|
JumpTableDataSection = "\t.const\n";
|
2006-10-26 19:18:18 +00:00
|
|
|
CStringSection = "\t.cstring";
|
2006-09-07 22:05:02 +00:00
|
|
|
FourByteConstantSection = "\t.literal4\n";
|
|
|
|
EightByteConstantSection = "\t.literal8\n";
|
2006-09-08 06:48:29 +00:00
|
|
|
if (Subtarget->is64Bit())
|
|
|
|
SixteenByteConstantSection = "\t.literal16\n";
|
2007-03-08 01:07:07 +00:00
|
|
|
ReadOnlySection = "\t.const\n";
|
2006-09-07 22:05:02 +00:00
|
|
|
LCOMMDirective = "\t.lcomm\t";
|
2008-01-15 23:24:56 +00:00
|
|
|
SwitchToSectionDirective = "\t.section ";
|
2008-06-03 18:09:06 +00:00
|
|
|
StringConstantPrefix = "\1LC";
|
2006-09-07 22:05:02 +00:00
|
|
|
COMMDirectiveTakesAlignment = false;
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
2007-01-30 08:04:53 +00:00
|
|
|
if (TM.getRelocationModel() == Reloc::Static) {
|
|
|
|
StaticCtorsSection = ".constructor";
|
|
|
|
StaticDtorsSection = ".destructor";
|
|
|
|
} else {
|
|
|
|
StaticCtorsSection = ".mod_init_func";
|
|
|
|
StaticDtorsSection = ".mod_term_func";
|
|
|
|
}
|
2008-01-15 23:24:56 +00:00
|
|
|
if (Subtarget->is64Bit()) {
|
|
|
|
PersonalityPrefix = "";
|
|
|
|
PersonalitySuffix = "+4@GOTPCREL";
|
|
|
|
} else {
|
|
|
|
PersonalityPrefix = "L";
|
|
|
|
PersonalitySuffix = "$non_lazy_ptr";
|
|
|
|
}
|
2007-09-11 17:20:55 +00:00
|
|
|
NeedsIndirectEncoding = true;
|
2008-03-25 23:29:30 +00:00
|
|
|
InlineAsmStart = "## InlineAsm Start";
|
|
|
|
InlineAsmEnd = "## InlineAsm End";
|
|
|
|
CommentString = "##";
|
2006-09-07 22:05:02 +00:00
|
|
|
SetDirective = "\t.set";
|
2007-08-22 18:44:05 +00:00
|
|
|
PCSymbol = ".";
|
2006-09-26 03:39:53 +00:00
|
|
|
UsedDirective = "\t.no_dead_strip\t";
|
2008-01-10 02:03:30 +00:00
|
|
|
WeakDefDirective = "\t.weak_definition ";
|
|
|
|
WeakRefDirective = "\t.weak_reference ";
|
2008-01-11 00:54:37 +00:00
|
|
|
HiddenDirective = "\t.private_extern ";
|
2008-03-18 23:38:12 +00:00
|
|
|
ProtectedDirective = "\t.globl\t";
|
2006-09-07 22:05:02 +00:00
|
|
|
|
2007-01-18 01:15:58 +00:00
|
|
|
// 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";
|
|
|
|
}
|
2007-05-05 09:04:50 +00:00
|
|
|
|
|
|
|
SupportsDebugInformation = true;
|
2006-09-07 22:05:02 +00:00
|
|
|
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";
|
2007-08-21 00:31:30 +00:00
|
|
|
|
|
|
|
// Exceptions handling
|
2008-01-15 23:24:56 +00:00
|
|
|
SupportsExceptionHandling = true;
|
2008-01-10 02:03:30 +00:00
|
|
|
GlobalEHDirective = "\t.globl\t";
|
|
|
|
SupportsWeakOmittedEHFrame = false;
|
2007-08-21 00:31:30 +00:00
|
|
|
AbsoluteEHSectionOffsets = false;
|
|
|
|
DwarfEHFrameSection =
|
|
|
|
".section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support";
|
|
|
|
DwarfExceptionSection = ".section __DATA,__gcc_except_tab";
|
2006-09-07 22:05:02 +00:00
|
|
|
break;
|
2006-10-30 22:32:30 +00:00
|
|
|
|
|
|
|
case X86Subtarget::isELF:
|
2007-06-27 15:09:47 +00:00
|
|
|
ReadOnlySection = "\t.section\t.rodata";
|
2007-05-03 16:38:57 +00:00
|
|
|
FourByteConstantSection = "\t.section\t.rodata.cst4,\"aM\",@progbits,4";
|
|
|
|
EightByteConstantSection = "\t.section\t.rodata.cst8,\"aM\",@progbits,8";
|
2007-05-05 09:04:50 +00:00
|
|
|
SixteenByteConstantSection = "\t.section\t.rodata.cst16,\"aM\",@progbits,16";
|
2007-05-03 16:38:57 +00:00
|
|
|
CStringSection = "\t.section\t.rodata.str1.1,\"aMS\",@progbits,1";
|
2007-01-03 18:16:48 +00:00
|
|
|
PrivateGlobalPrefix = ".L";
|
2006-12-01 20:47:11 +00:00
|
|
|
WeakRefDirective = "\t.weak\t";
|
2007-04-25 14:27:10 +00:00
|
|
|
SetDirective = "\t.set\t";
|
2007-05-01 10:19:31 +00:00
|
|
|
PCSymbol = ".";
|
2007-05-05 09:04:50 +00:00
|
|
|
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
2007-07-25 00:06:28 +00:00
|
|
|
|
|
|
|
// Debug Information
|
2007-05-05 09:04:50 +00:00
|
|
|
AbsoluteDebugSectionOffsets = true;
|
|
|
|
SupportsDebugInformation = true;
|
2006-10-30 22:32:30 +00:00
|
|
|
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";
|
2007-07-14 14:06:15 +00:00
|
|
|
|
2007-07-25 00:06:28 +00:00
|
|
|
// Exceptions handling
|
2007-07-14 14:06:15 +00:00
|
|
|
if (!Subtarget->is64Bit())
|
|
|
|
SupportsExceptionHandling = true;
|
2007-07-25 00:06:28 +00:00
|
|
|
AbsoluteEHSectionOffsets = false;
|
2007-05-01 10:16:06 +00:00
|
|
|
DwarfEHFrameSection = "\t.section\t.eh_frame,\"aw\",@progbits";
|
|
|
|
DwarfExceptionSection = "\t.section\t.gcc_except_table,\"a\",@progbits";
|
2006-10-30 22:32:30 +00:00
|
|
|
break;
|
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
case X86Subtarget::isCygwin:
|
2007-01-03 11:43:14 +00:00
|
|
|
case X86Subtarget::isMingw:
|
2006-09-07 22:05:02 +00:00
|
|
|
GlobalPrefix = "_";
|
2007-01-03 11:43:14 +00:00
|
|
|
LCOMMDirective = "\t.lcomm\t";
|
2006-09-07 22:05:02 +00:00
|
|
|
COMMDirectiveTakesAlignment = false;
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
StaticCtorsSection = "\t.section .ctors,\"aw\"";
|
|
|
|
StaticDtorsSection = "\t.section .dtors,\"aw\"";
|
2007-01-14 11:49:39 +00:00
|
|
|
HiddenDirective = NULL;
|
2007-05-05 09:04:50 +00:00
|
|
|
PrivateGlobalPrefix = "L"; // Prefix for private global symbols
|
|
|
|
WeakRefDirective = "\t.weak\t";
|
|
|
|
SetDirective = "\t.set\t";
|
2006-10-31 08:31:24 +00:00
|
|
|
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
2007-05-01 22:23:12 +00:00
|
|
|
AbsoluteDebugSectionOffsets = true;
|
|
|
|
AbsoluteEHSectionOffsets = false;
|
2007-05-05 09:04:50 +00:00
|
|
|
SupportsDebugInformation = true;
|
2007-03-07 02:47:57 +00:00
|
|
|
DwarfSectionOffsetDirective = "\t.secrel32\t";
|
2006-10-31 08:31:24 +00:00
|
|
|
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\"";
|
|
|
|
break;
|
2007-01-16 04:13:03 +00:00
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
case X86Subtarget::isWindows:
|
|
|
|
GlobalPrefix = "_";
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
break;
|
2007-01-16 04:13:03 +00:00
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Subtarget->isFlavorIntel()) {
|
|
|
|
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";
|
2006-12-19 21:04:20 +00:00
|
|
|
JumpTableDataSection = NULL;
|
2006-09-07 22:05:02 +00:00
|
|
|
SwitchToSectionDirective = "";
|
|
|
|
TextSectionStartSuffix = "\tsegment 'CODE'";
|
|
|
|
DataSectionStartSuffix = "\tsegment 'DATA'";
|
|
|
|
SectionEndDirectiveSuffix = "\tends\n";
|
|
|
|
}
|
2007-01-16 09:29:17 +00:00
|
|
|
|
2008-05-05 00:28:39 +00:00
|
|
|
// On Linux we must declare when we can use a non-executable stack.
|
2008-05-05 16:11:31 +00:00
|
|
|
if (Subtarget->isLinux())
|
2008-05-05 00:28:39 +00:00
|
|
|
NonexecutableStackDirective = "\t.section\t.note.GNU-stack,\"\",@progbits";
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
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;
|
2007-04-01 20:49:36 +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);
|
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);
|
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();
|
2006-11-29 01:14:06 +00:00
|
|
|
|
|
|
|
std::string AsmStr = IA->getAsmString();
|
|
|
|
|
|
|
|
// TODO: should remove alternatives from the asmstring: "foo {a|b}" -> "foo a"
|
|
|
|
std::vector<std::string> AsmPieces;
|
|
|
|
SplitString(AsmStr, AsmPieces, "\n"); // ; as separator?
|
|
|
|
|
|
|
|
switch (AsmPieces.size()) {
|
|
|
|
default: return false;
|
|
|
|
case 1:
|
|
|
|
AsmStr = AsmPieces[0];
|
|
|
|
AsmPieces.clear();
|
|
|
|
SplitString(AsmStr, AsmPieces, " \t"); // Split with whitespace.
|
|
|
|
|
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
|
2006-11-29 01:14:06 +00:00
|
|
|
if (AsmPieces.size() == 2 &&
|
|
|
|
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
|
|
|
|
|
|
|
/// PreferredEHDataFormat - This hook allows the target to select data
|
|
|
|
/// format used for encoding pointers in exception handling data. Reason is
|
|
|
|
/// 0 for data, 1 for code labels, 2 for function pointers. Global is true
|
|
|
|
/// if the symbol can be relocated.
|
2008-02-29 22:09:08 +00:00
|
|
|
unsigned X86TargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
|
2008-02-27 23:33:50 +00:00
|
|
|
bool Global) const {
|
|
|
|
const X86Subtarget *Subtarget = &X86TM->getSubtarget<X86Subtarget>();
|
|
|
|
|
|
|
|
switch (Subtarget->TargetType) {
|
|
|
|
case X86Subtarget::isDarwin:
|
2008-02-29 22:09:08 +00:00
|
|
|
if (Reason == DwarfEncoding::Functions && Global)
|
2008-02-27 23:33:50 +00:00
|
|
|
return (DW_EH_PE_pcrel | DW_EH_PE_indirect | DW_EH_PE_sdata4);
|
2008-02-29 22:09:08 +00:00
|
|
|
else if (Reason == DwarfEncoding::CodeLabels || !Global)
|
2008-02-27 23:33:50 +00:00
|
|
|
return DW_EH_PE_pcrel;
|
|
|
|
else
|
|
|
|
return DW_EH_PE_absptr;
|
|
|
|
|
|
|
|
case X86Subtarget::isELF:
|
|
|
|
case X86Subtarget::isCygwin:
|
|
|
|
case X86Subtarget::isMingw: {
|
|
|
|
CodeModel::Model CM = X86TM->getCodeModel();
|
|
|
|
|
|
|
|
if (X86TM->getRelocationModel() == Reloc::PIC_) {
|
|
|
|
unsigned Format = 0;
|
|
|
|
|
|
|
|
if (!Subtarget->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
|
2008-07-09 13:19:08 +00:00
|
|
|
// - code model is medium and we're emitting externally visible symbols
|
|
|
|
// or any code symbols
|
2008-02-27 23:33:50 +00:00
|
|
|
if (CM == CodeModel::Small ||
|
2008-02-29 22:09:08 +00:00
|
|
|
(CM == CodeModel::Medium && (Global ||
|
|
|
|
Reason != DwarfEncoding::Data)))
|
2008-02-27 23:33:50 +00:00
|
|
|
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 (Subtarget->is64Bit() &&
|
|
|
|
(CM == CodeModel::Small ||
|
2008-02-29 22:09:08 +00:00
|
|
|
(CM == CodeModel::Medium && Reason != DwarfEncoding::Data)))
|
2008-02-27 23:33:50 +00:00
|
|
|
return DW_EH_PE_udata4;
|
|
|
|
else
|
|
|
|
return DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return TargetAsmInfo::PreferredEHDataFormat(Reason, Global);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 13:19:08 +00:00
|
|
|
std::string X86TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const {
|
|
|
|
const X86Subtarget *Subtarget = &X86TM->getSubtarget<X86Subtarget>();
|
|
|
|
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?
|
|
|
|
|
|
|
|
// Select section name
|
|
|
|
if (const Function *F = dyn_cast<Function>(GV)) {
|
|
|
|
// Implement here
|
|
|
|
} else if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
|
|
|
|
if (GVar->hasSection()) {
|
|
|
|
// Honour section already set, if any
|
|
|
|
Name = GVar->getSection();
|
|
|
|
} else {
|
|
|
|
// Use default section depending on the 'type' of global
|
|
|
|
// FIXME: Handle linkonce stuff
|
|
|
|
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");
|
|
|
|
|
|
|
|
// Add all special flags, etc
|
|
|
|
switch (Subtarget->TargetType) {
|
|
|
|
case X86Subtarget::isELF:
|
|
|
|
Name += ",\"";
|
|
|
|
|
|
|
|
if (!(flags & SectionFlags::Debug))
|
|
|
|
Name += 'a';
|
|
|
|
if (flags & SectionFlags::Code)
|
|
|
|
Name += 'x';
|
|
|
|
if (flags & SectionFlags::Writeable)
|
|
|
|
Name += 'w';
|
|
|
|
if (flags & SectionFlags::Mergeable)
|
|
|
|
Name += 'M';
|
|
|
|
if (flags & SectionFlags::Strings)
|
|
|
|
Name += 'S';
|
|
|
|
if (flags & SectionFlags::TLS)
|
|
|
|
Name += 'T';
|
|
|
|
|
|
|
|
Name += "\"";
|
|
|
|
|
|
|
|
// FIXME: There can be exceptions here
|
|
|
|
if (flags & SectionFlags::BSS)
|
|
|
|
Name += ",@nobits";
|
|
|
|
else
|
|
|
|
Name += ",@progbits";
|
|
|
|
|
|
|
|
// FIXME: entity size for mergeable sections
|
|
|
|
break;
|
|
|
|
case X86Subtarget::isCygwin:
|
|
|
|
case X86Subtarget::isMingw:
|
|
|
|
Name += ",\"";
|
|
|
|
|
|
|
|
if (flags & SectionFlags::Code)
|
|
|
|
Name += 'x';
|
|
|
|
if (flags & SectionFlags::Writeable)
|
|
|
|
Name += 'w';
|
|
|
|
|
|
|
|
Name += "\"";
|
|
|
|
|
|
|
|
break;
|
|
|
|
case X86Subtarget::isDarwin:
|
|
|
|
// Darwin does not use any special flags
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Name;
|
|
|
|
}
|
|
|
|
|