6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-09-27 16:17:17 +00:00
Code Issues Projects Releases Wiki Activity

Reapply 56585:56589 with proper fix for some gcc versions

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56621 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Anton Korobeynikov
2008-09-25 21:00:33 +00:00
parent 0b457f0c3a
commit 32b952a2a6
12 changed files with 222 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Target/DarwinTargetAsmInfo.h
View File

@@ -24,7 +24,7 @@ namespace llvm {
class Type; class Type;
class Mangler; class Mangler;
struct DarwinTargetAsmInfo: public virtual TargetAsmInfo { struct DarwinTargetAsmInfo: public TargetAsmInfo {
const Section* TextCoalSection; const Section* TextCoalSection;
const Section* ConstDataCoalSection; const Section* ConstDataCoalSection;
const Section* ConstDataSection; const Section* ConstDataSection;

2
include/llvm/Target/ELFTargetAsmInfo.h
View File

@@ -23,7 +23,7 @@ namespace llvm {
class GlobalVariable; class GlobalVariable;
class Type; class Type;
struct ELFTargetAsmInfo: public virtual TargetAsmInfo { struct ELFTargetAsmInfo: public TargetAsmInfo {
explicit ELFTargetAsmInfo(const TargetMachine &TM); explicit ELFTargetAsmInfo(const TargetMachine &TM);
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const; virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const;

2
include/llvm/Target/TargetAsmInfo.h
View File

@@ -124,6 +124,7 @@ namespace llvm {
private: private:
mutable StringMap<Section> Sections; mutable StringMap<Section> Sections;
mutable SectionFlags::FlagsStringsMapType FlagsStrings; mutable SectionFlags::FlagsStringsMapType FlagsStrings;
void fillDefaultValues();
protected: protected:
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
// Properties to be set by the target writer, used to configure asm printer. // Properties to be set by the target writer, used to configure asm printer.
@@ -510,6 +511,7 @@ namespace llvm {
public: public:
TargetAsmInfo(); TargetAsmInfo();
TargetAsmInfo(const TargetMachine &TM);
virtual ~TargetAsmInfo(); virtual ~TargetAsmInfo();
const Section* getNamedSection(const char *Name, const Section* getNamedSection(const char *Name,

42
lib/Target/ARM/ARMTargetAsmInfo.cpp
View File

@@ -17,7 +17,7 @@
#include <cctype> #include <cctype>
using namespace llvm; using namespace llvm;
static const char *const arm_asm_table[] = { const char *const llvm::arm_asm_table[] = {
"{r0}", "r0", "{r0}", "r0",
"{r1}", "r1", "{r1}", "r1",
"{r2}", "r2", "{r2}", "r2",
@@ -42,21 +42,17 @@ static const char *const arm_asm_table[] = {
"{cc}", "cc", "{cc}", "cc",
0,0}; 0,0};
ARMTargetAsmInfo::ARMTargetAsmInfo(const ARMTargetMachine &TM) { // Instantiate 'common' cases.
AsmTransCBE = arm_asm_table; TEMPLATE_INSTANTIATION(class ARMTargetAsmInfo<TargetAsmInfo>);
TEMPLATE_INSTANTIATION(
AlignmentIsInBytes = false; unsigned ARMTargetAsmInfo<TargetAsmInfo>::getInlineAsmLength(const char*) const);
Data64bitsDirective = 0; TEMPLATE_INSTANTIATION(
CommentString = "@"; unsigned ARMTargetAsmInfo<TargetAsmInfo>::countArguments(const char*) const);
ConstantPoolSection = "\t.text\n"; TEMPLATE_INSTANTIATION(
COMMDirectiveTakesAlignment = false; unsigned ARMTargetAsmInfo<TargetAsmInfo>::countString(const char*) const);
InlineAsmStart = "@ InlineAsm Start";
InlineAsmEnd = "@ InlineAsm End";
LCOMMDirective = "\t.lcomm\t";
}
ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM): ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM):
ARMTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) { ARMTargetAsmInfo<DarwinTargetAsmInfo>(TM) {
Subtarget = &DTM->getSubtarget<ARMSubtarget>(); Subtarget = &DTM->getSubtarget<ARMSubtarget>();
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -104,7 +100,7 @@ ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM):
} }
ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM): ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM):
ARMTargetAsmInfo(TM), ELFTargetAsmInfo(TM) { ARMTargetAsmInfo<ELFTargetAsmInfo>(TM) {
Subtarget = &ETM->getSubtarget<ARMSubtarget>(); Subtarget = &ETM->getSubtarget<ARMSubtarget>();
NeedsSet = false; NeedsSet = false;
@@ -138,13 +134,15 @@ ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM):
/// Count the number of comma-separated arguments. /// Count the number of comma-separated arguments.
/// Do not try to detect errors. /// Do not try to detect errors.
unsigned ARMTargetAsmInfo::countArguments(const char* p) const { template <class BaseTAI>
unsigned ARMTargetAsmInfo<BaseTAI>::countArguments(const char* p) const {
unsigned count = 0; unsigned count = 0;
while (*p && isspace(*p) && *p != '\n') while (*p && isspace(*p) && *p != '\n')
p++; p++;
count++; count++;
while (*p && *p!='\n' && while (*p && *p!='\n' &&
strncmp(p, CommentString, strlen(CommentString))!=0) { strncmp(p, BaseTAI::CommentString,
strlen(BaseTAI::CommentString))!=0) {
if (*p==',') if (*p==',')
count++; count++;
p++; p++;
@@ -154,7 +152,8 @@ unsigned ARMTargetAsmInfo::countArguments(const char* p) const {
/// Count the length of a string enclosed in quote characters. /// Count the length of a string enclosed in quote characters.
/// Do not try to detect errors. /// Do not try to detect errors.
unsigned ARMTargetAsmInfo::countString(const char* p) const { template <class BaseTAI>
unsigned ARMTargetAsmInfo<BaseTAI>::countString(const char* p) const {
unsigned count = 0; unsigned count = 0;
while (*p && isspace(*p) && *p!='\n') while (*p && isspace(*p) && *p!='\n')
p++; p++;
@@ -166,7 +165,8 @@ unsigned ARMTargetAsmInfo::countString(const char* p) const {
} }
/// ARM-specific version of TargetAsmInfo::getInlineAsmLength. /// ARM-specific version of TargetAsmInfo::getInlineAsmLength.
unsigned ARMTargetAsmInfo::getInlineAsmLength(const char *s) const { template <class BaseTAI>
unsigned ARMTargetAsmInfo<BaseTAI>::getInlineAsmLength(const char *s) const {
// Make a lowercase-folded version of s for counting purposes. // Make a lowercase-folded version of s for counting purposes.
char *q, *s_copy = (char *)malloc(strlen(s) + 1); char *q, *s_copy = (char *)malloc(strlen(s) + 1);
strcpy(s_copy, s); strcpy(s_copy, s);
@@ -192,7 +192,7 @@ unsigned ARMTargetAsmInfo::getInlineAsmLength(const char *s) const {
break; break;
} }
// Ignore everything from comment char(s) to EOL // Ignore everything from comment char(s) to EOL
if (strncmp(Str, CommentString, strlen(CommentString))==-0) if (strncmp(Str, BaseTAI::CommentString, strlen(BaseTAI::CommentString))==-0)
atInsnStart = false; atInsnStart = false;
// FIXME do something like the following for non-Darwin // FIXME do something like the following for non-Darwin
else if (*Str == '.' && Subtarget->isTargetDarwin()) { else if (*Str == '.' && Subtarget->isTargetDarwin()) {
@@ -282,7 +282,7 @@ unsigned ARMTargetAsmInfo::getInlineAsmLength(const char *s) const {
Length += 4; // ARM Length += 4; // ARM
} }
} }
if (*Str == '\n' || *Str == SeparatorChar) if (*Str == '\n' || *Str == BaseTAI::SeparatorChar)
atInsnStart = true; atInsnStart = true;
} }
free(s_copy); free(s_copy);

34
lib/Target/ARM/ARMTargetAsmInfo.h
View File

@@ -14,19 +14,31 @@
#ifndef ARMTARGETASMINFO_H #ifndef ARMTARGETASMINFO_H
#define ARMTARGETASMINFO_H #define ARMTARGETASMINFO_H
#include "ARMTargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h" #include "llvm/Target/ELFTargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h" #include "llvm/Target/DarwinTargetAsmInfo.h"
#include "llvm/Support/Compiler.h"
#include "ARMSubtarget.h"
namespace llvm { namespace llvm {
// Forward declaration. extern const char *const arm_asm_table[];
class ARMTargetMachine;
struct ARMTargetAsmInfo : public virtual TargetAsmInfo { template <class BaseTAI>
explicit ARMTargetAsmInfo(const ARMTargetMachine &TM); struct ARMTargetAsmInfo : public BaseTAI {
explicit ARMTargetAsmInfo(const ARMTargetMachine &TM):
BaseTAI(TM) {
BaseTAI::AsmTransCBE = arm_asm_table;
BaseTAI::AlignmentIsInBytes = false;
BaseTAI::Data64bitsDirective = 0;
BaseTAI::CommentString = "@";
BaseTAI::ConstantPoolSection = "\t.text\n";
BaseTAI::COMMDirectiveTakesAlignment = false;
BaseTAI::InlineAsmStart = "@ InlineAsm Start";
BaseTAI::InlineAsmEnd = "@ InlineAsm End";
BaseTAI::LCOMMDirective = "\t.lcomm\t";
}
const ARMSubtarget *Subtarget; const ARMSubtarget *Subtarget;
@@ -35,13 +47,15 @@ namespace llvm {
unsigned countString(const char *p) const; unsigned countString(const char *p) const;
}; };
struct ARMDarwinTargetAsmInfo : public virtual ARMTargetAsmInfo, typedef ARMTargetAsmInfo<TargetAsmInfo> ARMGenericTargetAsmInfo;
public virtual DarwinTargetAsmInfo {
EXTERN_TEMPLATE_INSTANTIATION(class ARMTargetAsmInfo<TargetAsmInfo>);
struct ARMDarwinTargetAsmInfo : public ARMTargetAsmInfo<DarwinTargetAsmInfo> {
explicit ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM); explicit ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM);
}; };
struct ARMELFTargetAsmInfo : public virtual ARMTargetAsmInfo, struct ARMELFTargetAsmInfo : public ARMTargetAsmInfo<ELFTargetAsmInfo> {
public virtual ELFTargetAsmInfo {
explicit ARMELFTargetAsmInfo(const ARMTargetMachine &TM); explicit ARMELFTargetAsmInfo(const ARMTargetMachine &TM);
}; };

2
lib/Target/ARM/ARMTargetMachine.cpp
View File

@@ -120,7 +120,7 @@ const TargetAsmInfo *ARMTargetMachine::createTargetAsmInfo() const {
case ARMSubtarget::isELF: case ARMSubtarget::isELF:
return new ARMELFTargetAsmInfo(*this); return new ARMELFTargetAsmInfo(*this);
default: default:
return new ARMTargetAsmInfo(*this); return new ARMGenericTargetAsmInfo(*this);
} }
} }

17
lib/Target/PowerPC/PPCTargetAsmInfo.cpp
View File

@@ -19,21 +19,10 @@
using namespace llvm; using namespace llvm;
using namespace llvm::dwarf; using namespace llvm::dwarf;
PPCTargetAsmInfo::PPCTargetAsmInfo(const PPCTargetMachine &TM) { TEMPLATE_INSTANTIATION(class PPCTargetAsmInfo<TargetAsmInfo>);
bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
ZeroDirective = "\t.space\t";
SetDirective = "\t.set";
Data64bitsDirective = isPPC64 ? "\t.quad\t" : 0;
AlignmentIsInBytes = false;
LCOMMDirective = "\t.lcomm\t";
InlineAsmStart = "# InlineAsm Start";
InlineAsmEnd = "# InlineAsm End";
AssemblerDialect = TM.getSubtargetImpl()->getAsmFlavor();
}
PPCDarwinTargetAsmInfo::PPCDarwinTargetAsmInfo(const PPCTargetMachine &TM): PPCDarwinTargetAsmInfo::PPCDarwinTargetAsmInfo(const PPCTargetMachine &TM):
PPCTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) { PPCTargetAsmInfo<DarwinTargetAsmInfo>(TM) {
PCSymbol = "."; PCSymbol = ".";
CommentString = ";"; CommentString = ";";
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -103,7 +92,7 @@ PPCDarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM) : PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM) :
PPCTargetAsmInfo(TM), ELFTargetAsmInfo(TM) { PPCTargetAsmInfo<ELFTargetAsmInfo>(TM) {
CommentString = "#"; CommentString = "#";
GlobalPrefix = ""; GlobalPrefix = "";
PrivateGlobalPrefix = ""; PrivateGlobalPrefix = "";

31
lib/Target/PowerPC/PPCTargetAsmInfo.h
View File

@@ -14,28 +14,43 @@
#ifndef PPCTARGETASMINFO_H #ifndef PPCTARGETASMINFO_H
#define PPCTARGETASMINFO_H #define PPCTARGETASMINFO_H
#include "PPCTargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h" #include "llvm/Target/DarwinTargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h" #include "llvm/Target/ELFTargetAsmInfo.h"
#include "llvm/Support/Compiler.h"
namespace llvm { namespace llvm {
// Forward declaration. template <class BaseTAI>
class PPCTargetMachine; struct PPCTargetAsmInfo : public BaseTAI {
explicit PPCTargetAsmInfo(const PPCTargetMachine &TM):
BaseTAI(TM) {
const PPCSubtarget *Subtarget = &TM.getSubtarget<PPCSubtarget>();
bool isPPC64 = Subtarget->isPPC64();
struct PPCTargetAsmInfo : public virtual TargetAsmInfo { BaseTAI::ZeroDirective = "\t.space\t";
explicit PPCTargetAsmInfo(const PPCTargetMachine &TM); BaseTAI::SetDirective = "\t.set";
BaseTAI::Data64bitsDirective = isPPC64 ? "\t.quad\t" : 0;
BaseTAI::AlignmentIsInBytes = false;
BaseTAI::LCOMMDirective = "\t.lcomm\t";
BaseTAI::InlineAsmStart = "# InlineAsm Start";
BaseTAI::InlineAsmEnd = "# InlineAsm End";
BaseTAI::AssemblerDialect = Subtarget->getAsmFlavor();
}
}; };
struct PPCDarwinTargetAsmInfo : public PPCTargetAsmInfo, typedef PPCTargetAsmInfo<TargetAsmInfo> PPCGenericTargetAsmInfo;
public DarwinTargetAsmInfo {
EXTERN_TEMPLATE_INSTANTIATION(class PPCTargetAsmInfo<TargetAsmInfo>);
struct PPCDarwinTargetAsmInfo : public PPCTargetAsmInfo<DarwinTargetAsmInfo> {
explicit PPCDarwinTargetAsmInfo(const PPCTargetMachine &TM); explicit PPCDarwinTargetAsmInfo(const PPCTargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;
}; };
struct PPCLinuxTargetAsmInfo : public PPCTargetAsmInfo, struct PPCLinuxTargetAsmInfo : public PPCTargetAsmInfo<ELFTargetAsmInfo> {
public ELFTargetAsmInfo {
explicit PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM); explicit PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;

188
lib/Target/TargetAsmInfo.cpp
View File

@@ -25,100 +25,108 @@
using namespace llvm; using namespace llvm;
TargetAsmInfo::TargetAsmInfo() : void TargetAsmInfo::fillDefaultValues() {
TextSection(0), BSSSection = "\t.bss";
DataSection(0), BSSSection_ = 0;
BSSSection("\t.bss"), ReadOnlySection = 0;
BSSSection_(0), SmallDataSection = 0;
ReadOnlySection(0), SmallBSSSection = 0;
SmallDataSection(0), SmallRODataSection = 0;
SmallBSSSection(0), TLSDataSection = 0;
SmallRODataSection(0), TLSBSSSection = 0;
TLSDataSection(0), ZeroFillDirective = 0;
TLSBSSSection(0), NonexecutableStackDirective = 0;
ZeroFillDirective(0), NeedsSet = false;
NonexecutableStackDirective(0), MaxInstLength = 4;
NeedsSet(false), PCSymbol = "$";
MaxInstLength(4), SeparatorChar = ';';
PCSymbol("$"), CommentString = "#";
SeparatorChar(';'), GlobalPrefix = "";
CommentString("#"), PrivateGlobalPrefix = ".";
GlobalPrefix(""), LessPrivateGlobalPrefix = "";
PrivateGlobalPrefix("."), JumpTableSpecialLabelPrefix = 0;
LessPrivateGlobalPrefix(""), GlobalVarAddrPrefix = "";
JumpTableSpecialLabelPrefix(0), GlobalVarAddrSuffix = "";
GlobalVarAddrPrefix(""), FunctionAddrPrefix = "";
GlobalVarAddrSuffix(""), FunctionAddrSuffix = "";
FunctionAddrPrefix(""), PersonalityPrefix = "";
FunctionAddrSuffix(""), PersonalitySuffix = "";
PersonalityPrefix(""), NeedsIndirectEncoding = false;
PersonalitySuffix(""), InlineAsmStart = "#APP";
NeedsIndirectEncoding(false), InlineAsmEnd = "#NO_APP";
InlineAsmStart("#APP"), AssemblerDialect = 0;
InlineAsmEnd("#NO_APP"), StringConstantPrefix = ".str";
AssemblerDialect(0), ZeroDirective = "\t.zero\t";
StringConstantPrefix(".str"), ZeroDirectiveSuffix = 0;
ZeroDirective("\t.zero\t"), AsciiDirective = "\t.ascii\t";
ZeroDirectiveSuffix(0), AscizDirective = "\t.asciz\t";
AsciiDirective("\t.ascii\t"), Data8bitsDirective = "\t.byte\t";
AscizDirective("\t.asciz\t"), Data16bitsDirective = "\t.short\t";
Data8bitsDirective("\t.byte\t"), Data32bitsDirective = "\t.long\t";
Data16bitsDirective("\t.short\t"), Data64bitsDirective = "\t.quad\t";
Data32bitsDirective("\t.long\t"), AlignDirective = "\t.align\t";
Data64bitsDirective("\t.quad\t"), AlignmentIsInBytes = true;
AlignDirective("\t.align\t"), TextAlignFillValue = 0;
AlignmentIsInBytes(true), SwitchToSectionDirective = "\t.section\t";
TextAlignFillValue(0), TextSectionStartSuffix = "";
SwitchToSectionDirective("\t.section\t"), DataSectionStartSuffix = "";
TextSectionStartSuffix(""), SectionEndDirectiveSuffix = 0;
DataSectionStartSuffix(""), ConstantPoolSection = "\t.section .rodata";
SectionEndDirectiveSuffix(0), JumpTableDataSection = "\t.section .rodata";
ConstantPoolSection("\t.section .rodata"), JumpTableDirective = 0;
JumpTableDataSection("\t.section .rodata"), CStringSection = 0;
JumpTableDirective(0), CStringSection_ = 0;
CStringSection(0), // FIXME: Flags are ELFish - replace with normal section stuff.
CStringSection_(0), StaticCtorsSection = "\t.section .ctors,\"aw\",@progbits";
StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"), StaticDtorsSection = "\t.section .dtors,\"aw\",@progbits";
StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"), GlobalDirective = "\t.globl\t";
GlobalDirective("\t.globl\t"), SetDirective = 0;
SetDirective(0), LCOMMDirective = 0;
LCOMMDirective(0), COMMDirective = "\t.comm\t";
COMMDirective("\t.comm\t"), COMMDirectiveTakesAlignment = true;
COMMDirectiveTakesAlignment(true), HasDotTypeDotSizeDirective = true;
HasDotTypeDotSizeDirective(true), UsedDirective = 0;
UsedDirective(0), WeakRefDirective = 0;
WeakRefDirective(0), WeakDefDirective = 0;
WeakDefDirective(0), // FIXME: These are ELFish - move to ELFTAI.
HiddenDirective("\t.hidden\t"), HiddenDirective = "\t.hidden\t";
ProtectedDirective("\t.protected\t"), ProtectedDirective = "\t.protected\t";
AbsoluteDebugSectionOffsets(false), AbsoluteDebugSectionOffsets = false;
AbsoluteEHSectionOffsets(false), AbsoluteEHSectionOffsets = false;
HasLEB128(false), HasLEB128 = false;
HasDotLocAndDotFile(false), HasDotLocAndDotFile = false;
SupportsDebugInformation(false), SupportsDebugInformation = false;
SupportsExceptionHandling(false), SupportsExceptionHandling = false;
DwarfRequiresFrameSection(true), DwarfRequiresFrameSection = true;
GlobalEHDirective(0), GlobalEHDirective = 0;
SupportsWeakOmittedEHFrame(true), SupportsWeakOmittedEHFrame = true;
DwarfSectionOffsetDirective(0), DwarfSectionOffsetDirective = 0;
DwarfAbbrevSection(".debug_abbrev"), DwarfAbbrevSection = ".debug_abbrev";
DwarfInfoSection(".debug_info"), DwarfInfoSection = ".debug_info";
DwarfLineSection(".debug_line"), DwarfLineSection = ".debug_line";
DwarfFrameSection(".debug_frame"), DwarfFrameSection = ".debug_frame";
DwarfPubNamesSection(".debug_pubnames"), DwarfPubNamesSection = ".debug_pubnames";
DwarfPubTypesSection(".debug_pubtypes"), DwarfPubTypesSection = ".debug_pubtypes";
DwarfStrSection(".debug_str"), DwarfStrSection = ".debug_str";
DwarfLocSection(".debug_loc"), DwarfLocSection = ".debug_loc";
DwarfARangesSection(".debug_aranges"), DwarfARangesSection = ".debug_aranges";
DwarfRangesSection(".debug_ranges"), DwarfRangesSection = ".debug_ranges";
DwarfMacInfoSection(".debug_macinfo"), DwarfMacInfoSection = ".debug_macinfo";
DwarfEHFrameSection(".eh_frame"), DwarfEHFrameSection = ".eh_frame";
DwarfExceptionSection(".gcc_except_table"), DwarfExceptionSection = ".gcc_except_table";
AsmTransCBE(0) { AsmTransCBE = 0;
TextSection = getUnnamedSection("\t.text", SectionFlags::Code); TextSection = getUnnamedSection("\t.text", SectionFlags::Code);
DataSection = getUnnamedSection("\t.data", SectionFlags::Writeable); DataSection = getUnnamedSection("\t.data", SectionFlags::Writeable);
} }
TargetAsmInfo::TargetAsmInfo() {
fillDefaultValues();
}
TargetAsmInfo::TargetAsmInfo(const TargetMachine &TM) {
fillDefaultValues();
}
TargetAsmInfo::~TargetAsmInfo() { TargetAsmInfo::~TargetAsmInfo() {
} }

28
lib/Target/X86/X86TargetAsmInfo.cpp
View File

@@ -25,7 +25,7 @@
using namespace llvm; using namespace llvm;
using namespace llvm::dwarf; using namespace llvm::dwarf;
static const char *const x86_asm_table[] = { const char *const llvm::x86_asm_table[] = {
"{si}", "S", "{si}", "S",
"{di}", "D", "{di}", "D",
"{ax}", "a", "{ax}", "a",
@@ -37,15 +37,14 @@ static const char *const x86_asm_table[] = {
"{cc}", "cc", "{cc}", "cc",
0,0}; 0,0};
X86TargetAsmInfo::X86TargetAsmInfo(const X86TargetMachine &TM) { TEMPLATE_INSTANTIATION(class X86TargetAsmInfo<TargetAsmInfo>);
const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>(); TEMPLATE_INSTANTIATION(
bool X86TargetAsmInfo<TargetAsmInfo>::ExpandInlineAsm(CallInst*) const);
TEMPLATE_INSTANTIATION(
bool X86TargetAsmInfo<TargetAsmInfo>::LowerToBSwap(CallInst*) const);
AsmTransCBE = x86_asm_table; template <class BaseTAI>
bool X86TargetAsmInfo<BaseTAI>::LowerToBSwap(CallInst *CI) const {
AssemblerDialect = Subtarget->getAsmFlavor();
}
bool X86TargetAsmInfo::LowerToBSwap(CallInst *CI) const {
// FIXME: this should verify that we are targetting a 486 or better. If not, // 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 // 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 // instead of emitting the bswap asm. For now, we don't support 486 or lower
@@ -74,7 +73,8 @@ bool X86TargetAsmInfo::LowerToBSwap(CallInst *CI) const {
return true; return true;
} }
bool X86TargetAsmInfo::ExpandInlineAsm(CallInst *CI) const { template <class BaseTAI>
bool X86TargetAsmInfo<BaseTAI>::ExpandInlineAsm(CallInst *CI) const {
InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue()); InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints(); std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints();
@@ -125,7 +125,7 @@ bool X86TargetAsmInfo::ExpandInlineAsm(CallInst *CI) const {
} }
X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM): X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo(TM), DarwinTargetAsmInfo(TM) { X86TargetAsmInfo<DarwinTargetAsmInfo>(TM) {
const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>(); const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>();
bool is64Bit = Subtarget->is64Bit(); bool is64Bit = Subtarget->is64Bit();
@@ -225,7 +225,7 @@ X86DarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
} }
X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM): X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo(TM), ELFTargetAsmInfo(TM) { X86TargetAsmInfo<ELFTargetAsmInfo>(TM) {
CStringSection = ".rodata.str"; CStringSection = ".rodata.str";
PrivateGlobalPrefix = ".L"; PrivateGlobalPrefix = ".L";
@@ -302,7 +302,7 @@ X86ELFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
} }
X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM): X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo(TM) { X86GenericTargetAsmInfo(TM) {
X86TM = &TM; X86TM = &TM;
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -408,7 +408,7 @@ std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const {
} }
X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM): X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo(TM) { X86GenericTargetAsmInfo(TM) {
GlobalPrefix = "_"; GlobalPrefix = "_";
CommentString = ";"; CommentString = ";";

32
lib/Target/X86/X86TargetAsmInfo.h
View File

@@ -14,17 +14,25 @@
#ifndef X86TARGETASMINFO_H #ifndef X86TARGETASMINFO_H
#define X86TARGETASMINFO_H #define X86TARGETASMINFO_H
#include "X86TargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h" #include "llvm/Target/ELFTargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h" #include "llvm/Target/DarwinTargetAsmInfo.h"
#include "llvm/Support/Compiler.h"
namespace llvm { namespace llvm {
// Forward declaration. extern const char *const x86_asm_table[];
class X86TargetMachine;
struct X86TargetAsmInfo : public virtual TargetAsmInfo { template <class BaseTAI>
explicit X86TargetAsmInfo(const X86TargetMachine &TM); struct X86TargetAsmInfo : public BaseTAI {
explicit X86TargetAsmInfo(const X86TargetMachine &TM):
BaseTAI(TM) {
const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
BaseTAI::AsmTransCBE = x86_asm_table;
BaseTAI::AssemblerDialect = Subtarget->getAsmFlavor();
}
virtual bool ExpandInlineAsm(CallInst *CI) const; virtual bool ExpandInlineAsm(CallInst *CI) const;
@@ -32,21 +40,23 @@ namespace llvm {
bool LowerToBSwap(CallInst *CI) const; bool LowerToBSwap(CallInst *CI) const;
}; };
struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo, typedef X86TargetAsmInfo<TargetAsmInfo> X86GenericTargetAsmInfo;
public DarwinTargetAsmInfo {
EXTERN_TEMPLATE_INSTANTIATION(class X86TargetAsmInfo<TargetAsmInfo>);
struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo<DarwinTargetAsmInfo> {
explicit X86DarwinTargetAsmInfo(const X86TargetMachine &TM); explicit X86DarwinTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;
}; };
struct X86ELFTargetAsmInfo : public X86TargetAsmInfo, struct X86ELFTargetAsmInfo : public X86TargetAsmInfo<ELFTargetAsmInfo> {
public ELFTargetAsmInfo {
explicit X86ELFTargetAsmInfo(const X86TargetMachine &TM); explicit X86ELFTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;
}; };
struct X86COFFTargetAsmInfo : public X86TargetAsmInfo { struct X86COFFTargetAsmInfo : public X86GenericTargetAsmInfo {
explicit X86COFFTargetAsmInfo(const X86TargetMachine &TM); explicit X86COFFTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;
@@ -57,9 +67,11 @@ namespace llvm {
const X86TargetMachine *X86TM; const X86TargetMachine *X86TM;
}; };
struct X86WinTargetAsmInfo : public X86TargetAsmInfo { struct X86WinTargetAsmInfo : public X86GenericTargetAsmInfo {
explicit X86WinTargetAsmInfo(const X86TargetMachine &TM); explicit X86WinTargetAsmInfo(const X86TargetMachine &TM);
}; };
} // namespace llvm } // namespace llvm
#endif #endif

2
lib/Target/X86/X86TargetMachine.cpp
View File

@@ -54,7 +54,7 @@ const TargetAsmInfo *X86TargetMachine::createTargetAsmInfo() const {
case X86Subtarget::isWindows: case X86Subtarget::isWindows:
return new X86WinTargetAsmInfo(*this); return new X86WinTargetAsmInfo(*this);
default: default:
return new X86TargetAsmInfo(*this); return new X86GenericTargetAsmInfo(*this);
} }
} }