2006-09-07 22:05:02 +00:00
|
|
|
//===-- X86TargetAsmInfo.cpp - X86 asm properties ---------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by James M. Laskey and is distributed under the
|
|
|
|
// University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// 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"
|
|
|
|
#include "llvm/Module.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2006-09-07 22:05:02 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2006-11-28 19:52:49 +00:00
|
|
|
static const char* x86_asm_table[] = {"{si}", "S",
|
|
|
|
"{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>();
|
|
|
|
|
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;
|
|
|
|
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
|
|
|
|
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";
|
2006-09-07 22:05:02 +00:00
|
|
|
LCOMMDirective = "\t.lcomm\t";
|
|
|
|
COMMDirectiveTakesAlignment = false;
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
StaticCtorsSection = ".mod_init_func";
|
|
|
|
StaticDtorsSection = ".mod_term_func";
|
|
|
|
InlineAsmStart = "# InlineAsm Start";
|
|
|
|
InlineAsmEnd = "# InlineAsm End";
|
|
|
|
SetDirective = "\t.set";
|
2006-09-26 03:39:53 +00:00
|
|
|
UsedDirective = "\t.no_dead_strip\t";
|
2006-12-01 20:47:11 +00:00
|
|
|
WeakRefDirective = "\t.weak_reference\t";
|
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";
|
|
|
|
break;
|
2006-10-30 22:32:30 +00:00
|
|
|
|
|
|
|
case X86Subtarget::isELF:
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
|
|
|
// bool HasLEB128; // Defaults to false.
|
|
|
|
// hasDotLoc - True if target asm supports .loc directives.
|
|
|
|
// bool HasDotLoc; // Defaults to false.
|
|
|
|
// HasDotFile - True if target asm supports .file directives.
|
|
|
|
// bool HasDotFile; // Defaults to false.
|
2007-01-03 18:16:48 +00:00
|
|
|
PrivateGlobalPrefix = ".L";
|
2006-12-01 20:47:11 +00:00
|
|
|
WeakRefDirective = "\t.weak\t";
|
2006-10-30 22:32:30 +00:00
|
|
|
DwarfRequiresFrameSection = false;
|
|
|
|
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";
|
|
|
|
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\"";
|
2006-10-31 08:31:24 +00:00
|
|
|
|
|
|
|
// Set up DWARF directives
|
|
|
|
HasLEB128 = true; // Target asm supports leb128 directives (little-endian)
|
|
|
|
PrivateGlobalPrefix = "L"; // Prefix for private global symbols
|
|
|
|
DwarfRequiresFrameSection = false;
|
|
|
|
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;
|
|
|
|
|
2006-09-07 22:05:02 +00:00
|
|
|
break;
|
|
|
|
case X86Subtarget::isWindows:
|
|
|
|
GlobalPrefix = "_";
|
|
|
|
HasDotTypeDotSizeDirective = false;
|
|
|
|
break;
|
|
|
|
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";
|
|
|
|
}
|
|
|
|
}
|
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() ||
|
|
|
|
!CI->getType()->isInteger())
|
|
|
|
return false;
|
|
|
|
|
2006-12-31 05:55:36 +00:00
|
|
|
const Type *Ty = CI->getType();
|
2006-11-29 01:14:06 +00:00
|
|
|
const char *IntName;
|
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
|
|
|
if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) {
|
|
|
|
unsigned BitWidth = ITy->getBitWidth();
|
|
|
|
if (BitWidth > 8 && BitWidth <= 16)
|
|
|
|
IntName = "llvm.bswap.i16";
|
|
|
|
else if (BitWidth > 24 && BitWidth <= 32)
|
|
|
|
IntName = "llvm.bswap.i32";
|
|
|
|
else if (BitWidth > 56 && BitWidth <= 64)
|
|
|
|
IntName = "llvm.bswap.i64";
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
} else
|
|
|
|
return false;
|
2006-11-29 01:14:06 +00:00
|
|
|
|
|
|
|
// Okay, we can do this xform, do so now.
|
|
|
|
Module *M = CI->getParent()->getParent()->getParent();
|
2007-01-07 07:24:32 +00:00
|
|
|
Constant *Int = M->getOrInsertFunction(IntName, Ty, Ty, (Type*)0);
|
2006-11-29 01:14:06 +00:00
|
|
|
|
|
|
|
Value *Op = CI->getOperand(1);
|
|
|
|
Op = new CallInst(Int, Op, CI->getName(), CI);
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|