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

Temporarily backing out 56585:56589 to unbreak the build.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56607 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng
2008-09-25 07:38:08 +00:00
parent dceffe66b9
commit 688535e005
12 changed files with 182 additions and 211 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 TargetAsmInfo { struct DarwinTargetAsmInfo: public virtual 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 TargetAsmInfo { struct ELFTargetAsmInfo: public virtual 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,7 +124,6 @@ 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.
@@ -511,7 +510,6 @@ 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,

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

@@ -17,7 +17,7 @@
#include <cctype> #include <cctype>
using namespace llvm; using namespace llvm;
const char *const llvm::arm_asm_table[] = { static const char *const arm_asm_table[] = {
"{r0}", "r0", "{r0}", "r0",
"{r1}", "r1", "{r1}", "r1",
"{r2}", "r2", "{r2}", "r2",
@@ -42,10 +42,21 @@ const char *const llvm::arm_asm_table[] = {
"{cc}", "cc", "{cc}", "cc",
0,0}; 0,0};
TEMPLATE_INSTANTIATION(class ARMTargetAsmInfo<TargetAsmInfo>); ARMTargetAsmInfo::ARMTargetAsmInfo(const ARMTargetMachine &TM) {
AsmTransCBE = arm_asm_table;
AlignmentIsInBytes = false;
Data64bitsDirective = 0;
CommentString = "@";
ConstantPoolSection = "\t.text\n";
COMMDirectiveTakesAlignment = false;
InlineAsmStart = "@ InlineAsm Start";
InlineAsmEnd = "@ InlineAsm End";
LCOMMDirective = "\t.lcomm\t";
}
ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM): ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM):
ARMTargetAsmInfo<DarwinTargetAsmInfo>(TM) { ARMTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
Subtarget = &DTM->getSubtarget<ARMSubtarget>(); Subtarget = &DTM->getSubtarget<ARMSubtarget>();
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -93,7 +104,7 @@ ARMDarwinTargetAsmInfo::ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM):
} }
ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM): ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM):
ARMTargetAsmInfo<ELFTargetAsmInfo>(TM) { ARMTargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
Subtarget = &ETM->getSubtarget<ARMSubtarget>(); Subtarget = &ETM->getSubtarget<ARMSubtarget>();
NeedsSet = false; NeedsSet = false;
@@ -127,15 +138,13 @@ 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.
template <class BaseTAI> unsigned ARMTargetAsmInfo::countArguments(const char* p) const {
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, BaseTAI::CommentString, strncmp(p, CommentString, strlen(CommentString))!=0) {
strlen(BaseTAI::CommentString))!=0) {
if (*p==',') if (*p==',')
count++; count++;
p++; p++;
@@ -145,8 +154,7 @@ unsigned ARMTargetAsmInfo<BaseTAI>::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.
template <class BaseTAI> unsigned ARMTargetAsmInfo::countString(const char* p) const {
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++;
@@ -158,8 +166,7 @@ unsigned ARMTargetAsmInfo<BaseTAI>::countString(const char* p) const {
} }
/// ARM-specific version of TargetAsmInfo::getInlineAsmLength. /// ARM-specific version of TargetAsmInfo::getInlineAsmLength.
template <class BaseTAI> unsigned ARMTargetAsmInfo::getInlineAsmLength(const char *s) const {
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);
@@ -185,7 +192,7 @@ unsigned ARMTargetAsmInfo<BaseTAI>::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, BaseTAI::CommentString, strlen(BaseTAI::CommentString))==-0) if (strncmp(Str, CommentString, strlen(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()) {
@@ -275,7 +282,7 @@ unsigned ARMTargetAsmInfo<BaseTAI>::getInlineAsmLength(const char *s) const {
Length += 4; // ARM Length += 4; // ARM
} }
} }
if (*Str == '\n' || *Str == BaseTAI::SeparatorChar) if (*Str == '\n' || *Str == SeparatorChar)
atInsnStart = true; atInsnStart = true;
} }
free(s_copy); free(s_copy);

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

@@ -14,31 +14,19 @@
#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 {
extern const char *const arm_asm_table[]; // Forward declaration.
class ARMTargetMachine;
template <class BaseTAI> struct ARMTargetAsmInfo : public virtual TargetAsmInfo {
struct ARMTargetAsmInfo : public BaseTAI { explicit ARMTargetAsmInfo(const ARMTargetMachine &TM);
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;
@@ -47,15 +35,13 @@ namespace llvm {
unsigned countString(const char *p) const; unsigned countString(const char *p) const;
}; };
typedef ARMTargetAsmInfo<TargetAsmInfo> ARMGenericTargetAsmInfo; struct ARMDarwinTargetAsmInfo : public virtual ARMTargetAsmInfo,
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 ARMTargetAsmInfo<ELFTargetAsmInfo> { struct ARMELFTargetAsmInfo : public virtual ARMTargetAsmInfo,
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 ARMGenericTargetAsmInfo(*this); return new ARMTargetAsmInfo(*this);
} }
} }

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

@@ -19,10 +19,21 @@
using namespace llvm; using namespace llvm;
using namespace llvm::dwarf; using namespace llvm::dwarf;
TEMPLATE_INSTANTIATION(class PPCTargetAsmInfo<TargetAsmInfo>); PPCTargetAsmInfo::PPCTargetAsmInfo(const PPCTargetMachine &TM) {
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<DarwinTargetAsmInfo>(TM) { PPCTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
PCSymbol = "."; PCSymbol = ".";
CommentString = ";"; CommentString = ";";
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -92,7 +103,7 @@ PPCDarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM) : PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM) :
PPCTargetAsmInfo<ELFTargetAsmInfo>(TM) { PPCTargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
CommentString = "#"; CommentString = "#";
GlobalPrefix = ""; GlobalPrefix = "";
PrivateGlobalPrefix = ""; PrivateGlobalPrefix = "";

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

@@ -14,43 +14,28 @@
#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 {
template <class BaseTAI> // Forward declaration.
struct PPCTargetAsmInfo : public BaseTAI { class PPCTargetMachine;
explicit PPCTargetAsmInfo(const PPCTargetMachine &TM):
BaseTAI(TM) {
const PPCSubtarget *Subtarget = &TM.getSubtarget<PPCSubtarget>();
bool isPPC64 = Subtarget->isPPC64();
BaseTAI::ZeroDirective = "\t.space\t"; struct PPCTargetAsmInfo : public virtual TargetAsmInfo {
BaseTAI::SetDirective = "\t.set"; explicit PPCTargetAsmInfo(const PPCTargetMachine &TM);
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();
}
}; };
typedef PPCTargetAsmInfo<TargetAsmInfo> PPCGenericTargetAsmInfo; struct PPCDarwinTargetAsmInfo : public PPCTargetAsmInfo,
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<ELFTargetAsmInfo> { struct PPCLinuxTargetAsmInfo : public PPCTargetAsmInfo,
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,108 +25,100 @@
using namespace llvm; using namespace llvm;
void TargetAsmInfo::fillDefaultValues() { TargetAsmInfo::TargetAsmInfo() :
BSSSection = "\t.bss"; TextSection(0),
BSSSection_ = 0; DataSection(0),
ReadOnlySection = 0; BSSSection("\t.bss"),
SmallDataSection = 0; BSSSection_(0),
SmallBSSSection = 0; ReadOnlySection(0),
SmallRODataSection = 0; SmallDataSection(0),
TLSDataSection = 0; SmallBSSSection(0),
TLSBSSSection = 0; SmallRODataSection(0),
ZeroFillDirective = 0; TLSDataSection(0),
NonexecutableStackDirective = 0; TLSBSSSection(0),
NeedsSet = false; ZeroFillDirective(0),
MaxInstLength = 4; NonexecutableStackDirective(0),
PCSymbol = "$"; NeedsSet(false),
SeparatorChar = ';'; MaxInstLength(4),
CommentString = "#"; PCSymbol("$"),
GlobalPrefix = ""; SeparatorChar(';'),
PrivateGlobalPrefix = "."; CommentString("#"),
LessPrivateGlobalPrefix = ""; GlobalPrefix(""),
JumpTableSpecialLabelPrefix = 0; PrivateGlobalPrefix("."),
GlobalVarAddrPrefix = ""; LessPrivateGlobalPrefix(""),
GlobalVarAddrSuffix = ""; JumpTableSpecialLabelPrefix(0),
FunctionAddrPrefix = ""; GlobalVarAddrPrefix(""),
FunctionAddrSuffix = ""; GlobalVarAddrSuffix(""),
PersonalityPrefix = ""; FunctionAddrPrefix(""),
PersonalitySuffix = ""; FunctionAddrSuffix(""),
NeedsIndirectEncoding = false; PersonalityPrefix(""),
InlineAsmStart = "#APP"; PersonalitySuffix(""),
InlineAsmEnd = "#NO_APP"; NeedsIndirectEncoding(false),
AssemblerDialect = 0; InlineAsmStart("#APP"),
StringConstantPrefix = ".str"; InlineAsmEnd("#NO_APP"),
ZeroDirective = "\t.zero\t"; AssemblerDialect(0),
ZeroDirectiveSuffix = 0; StringConstantPrefix(".str"),
AsciiDirective = "\t.ascii\t"; ZeroDirective("\t.zero\t"),
AscizDirective = "\t.asciz\t"; ZeroDirectiveSuffix(0),
Data8bitsDirective = "\t.byte\t"; AsciiDirective("\t.ascii\t"),
Data16bitsDirective = "\t.short\t"; AscizDirective("\t.asciz\t"),
Data32bitsDirective = "\t.long\t"; Data8bitsDirective("\t.byte\t"),
Data64bitsDirective = "\t.quad\t"; Data16bitsDirective("\t.short\t"),
AlignDirective = "\t.align\t"; Data32bitsDirective("\t.long\t"),
AlignmentIsInBytes = true; Data64bitsDirective("\t.quad\t"),
TextAlignFillValue = 0; AlignDirective("\t.align\t"),
SwitchToSectionDirective = "\t.section\t"; AlignmentIsInBytes(true),
TextSectionStartSuffix = ""; TextAlignFillValue(0),
DataSectionStartSuffix = ""; SwitchToSectionDirective("\t.section\t"),
SectionEndDirectiveSuffix = 0; TextSectionStartSuffix(""),
ConstantPoolSection = "\t.section .rodata"; DataSectionStartSuffix(""),
JumpTableDataSection = "\t.section .rodata"; SectionEndDirectiveSuffix(0),
JumpTableDirective = 0; ConstantPoolSection("\t.section .rodata"),
CStringSection = 0; JumpTableDataSection("\t.section .rodata"),
CStringSection_ = 0; JumpTableDirective(0),
// FIXME: Flags are ELFish - replace with normal section stuff. CStringSection(0),
StaticCtorsSection = "\t.section .ctors,\"aw\",@progbits"; CStringSection_(0),
StaticDtorsSection = "\t.section .dtors,\"aw\",@progbits"; StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"),
GlobalDirective = "\t.globl\t"; StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"),
SetDirective = 0; GlobalDirective("\t.globl\t"),
LCOMMDirective = 0; SetDirective(0),
COMMDirective = "\t.comm\t"; LCOMMDirective(0),
COMMDirectiveTakesAlignment = true; COMMDirective("\t.comm\t"),
HasDotTypeDotSizeDirective = true; COMMDirectiveTakesAlignment(true),
UsedDirective = 0; HasDotTypeDotSizeDirective(true),
WeakRefDirective = 0; UsedDirective(0),
WeakDefDirective = 0; WeakRefDirective(0),
// FIXME: These are ELFish - move to ELFTAI. WeakDefDirective(0),
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() {
} }

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

@@ -25,22 +25,27 @@
using namespace llvm; using namespace llvm;
using namespace llvm::dwarf; using namespace llvm::dwarf;
const char *const llvm::x86_asm_table[] = { static const char *const x86_asm_table[] = {
"{si}", "S", "{si}", "S",
"{di}", "D", "{di}", "D",
"{ax}", "a", "{ax}", "a",
"{cx}", "c", "{cx}", "c",
"{memory}", "memory", "{memory}", "memory",
"{flags}", "", "{flags}", "",
"{dirflag}", "", "{dirflag}", "",
"{fpsr}", "", "{fpsr}", "",
"{cc}", "cc", "{cc}", "cc",
0,0}; 0,0};
TEMPLATE_INSTANTIATION(class X86TargetAsmInfo<TargetAsmInfo>); X86TargetAsmInfo::X86TargetAsmInfo(const X86TargetMachine &TM) {
const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
template <class BaseTAI> AsmTransCBE = x86_asm_table;
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
@@ -69,8 +74,7 @@ bool X86TargetAsmInfo<BaseTAI>::LowerToBSwap(CallInst *CI) const {
return true; return true;
} }
template <class BaseTAI> bool X86TargetAsmInfo::ExpandInlineAsm(CallInst *CI) const {
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();
@@ -121,7 +125,7 @@ bool X86TargetAsmInfo<BaseTAI>::ExpandInlineAsm(CallInst *CI) const {
} }
X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM): X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo<DarwinTargetAsmInfo>(TM) { X86TargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>(); const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>();
bool is64Bit = Subtarget->is64Bit(); bool is64Bit = Subtarget->is64Bit();
@@ -221,7 +225,7 @@ X86DarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
} }
X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM): X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo<ELFTargetAsmInfo>(TM) { X86TargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
CStringSection = ".rodata.str"; CStringSection = ".rodata.str";
PrivateGlobalPrefix = ".L"; PrivateGlobalPrefix = ".L";
@@ -298,7 +302,7 @@ X86ELFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
} }
X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM): X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM):
X86GenericTargetAsmInfo(TM) { X86TargetAsmInfo(TM) {
X86TM = &TM; X86TM = &TM;
GlobalPrefix = "_"; GlobalPrefix = "_";
@@ -404,7 +408,7 @@ std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const {
} }
X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM): X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
X86GenericTargetAsmInfo(TM) { X86TargetAsmInfo(TM) {
GlobalPrefix = "_"; GlobalPrefix = "_";
CommentString = ";"; CommentString = ";";

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

@@ -14,25 +14,17 @@
#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 {
extern const char *const x86_asm_table[]; // Forward declaration.
class X86TargetMachine;
template <class BaseTAI> struct X86TargetAsmInfo : public virtual TargetAsmInfo {
struct X86TargetAsmInfo : public BaseTAI { explicit X86TargetAsmInfo(const X86TargetMachine &TM);
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;
@@ -40,23 +32,21 @@ namespace llvm {
bool LowerToBSwap(CallInst *CI) const; bool LowerToBSwap(CallInst *CI) const;
}; };
typedef X86TargetAsmInfo<TargetAsmInfo> X86GenericTargetAsmInfo; struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo,
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<ELFTargetAsmInfo> { struct X86ELFTargetAsmInfo : public X86TargetAsmInfo,
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 X86GenericTargetAsmInfo { struct X86COFFTargetAsmInfo : public X86TargetAsmInfo {
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;
@@ -67,11 +57,9 @@ namespace llvm {
const X86TargetMachine *X86TM; const X86TargetMachine *X86TM;
}; };
struct X86WinTargetAsmInfo : public X86GenericTargetAsmInfo { struct X86WinTargetAsmInfo : public X86TargetAsmInfo {
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 X86GenericTargetAsmInfo(*this); return new X86TargetAsmInfo(*this);
} }
} }