class Type;
class Mangler;
- struct DarwinTargetAsmInfo: public TargetAsmInfo {
+ struct DarwinTargetAsmInfo: public virtual TargetAsmInfo {
const Section* TextCoalSection;
const Section* ConstDataCoalSection;
const Section* ConstDataSection;
class GlobalVariable;
class Type;
- struct ELFTargetAsmInfo: public TargetAsmInfo {
+ struct ELFTargetAsmInfo: public virtual TargetAsmInfo {
explicit ELFTargetAsmInfo(const TargetMachine &TM);
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const;
private:
mutable StringMap<Section> Sections;
mutable SectionFlags::FlagsStringsMapType FlagsStrings;
- void fillDefaultValues();
protected:
//===------------------------------------------------------------------===//
// Properties to be set by the target writer, used to configure asm printer.
public:
TargetAsmInfo();
- TargetAsmInfo(const TargetMachine &TM);
virtual ~TargetAsmInfo();
const Section* getNamedSection(const char *Name,
#include <cctype>
using namespace llvm;
-const char *const llvm::arm_asm_table[] = {
+static const char *const arm_asm_table[] = {
"{r0}", "r0",
"{r1}", "r1",
"{r2}", "r2",
"{cc}", "cc",
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):
- ARMTargetAsmInfo<DarwinTargetAsmInfo>(TM) {
+ ARMTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
Subtarget = &DTM->getSubtarget<ARMSubtarget>();
GlobalPrefix = "_";
}
ARMELFTargetAsmInfo::ARMELFTargetAsmInfo(const ARMTargetMachine &TM):
- ARMTargetAsmInfo<ELFTargetAsmInfo>(TM) {
+ ARMTargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
Subtarget = &ETM->getSubtarget<ARMSubtarget>();
NeedsSet = false;
/// Count the number of comma-separated arguments.
/// Do not try to detect errors.
-template <class BaseTAI>
-unsigned ARMTargetAsmInfo<BaseTAI>::countArguments(const char* p) const {
+unsigned ARMTargetAsmInfo::countArguments(const char* p) const {
unsigned count = 0;
while (*p && isspace(*p) && *p != '\n')
p++;
count++;
- while (*p && *p!='\n' &&
- strncmp(p, BaseTAI::CommentString,
- strlen(BaseTAI::CommentString))!=0) {
+ while (*p && *p!='\n' &&
+ strncmp(p, CommentString, strlen(CommentString))!=0) {
if (*p==',')
count++;
p++;
/// Count the length of a string enclosed in quote characters.
/// Do not try to detect errors.
-template <class BaseTAI>
-unsigned ARMTargetAsmInfo<BaseTAI>::countString(const char* p) const {
+unsigned ARMTargetAsmInfo::countString(const char* p) const {
unsigned count = 0;
while (*p && isspace(*p) && *p!='\n')
p++;
}
/// ARM-specific version of TargetAsmInfo::getInlineAsmLength.
-template <class BaseTAI>
-unsigned ARMTargetAsmInfo<BaseTAI>::getInlineAsmLength(const char *s) const {
+unsigned ARMTargetAsmInfo::getInlineAsmLength(const char *s) const {
// Make a lowercase-folded version of s for counting purposes.
char *q, *s_copy = (char *)malloc(strlen(s) + 1);
strcpy(s_copy, s);
break;
}
// 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;
// FIXME do something like the following for non-Darwin
else if (*Str == '.' && Subtarget->isTargetDarwin()) {
Length += 4; // ARM
}
}
- if (*Str == '\n' || *Str == BaseTAI::SeparatorChar)
+ if (*Str == '\n' || *Str == SeparatorChar)
atInsnStart = true;
}
free(s_copy);
#ifndef ARMTARGETASMINFO_H
#define ARMTARGETASMINFO_H
-#include "ARMTargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h"
-#include "llvm/Support/Compiler.h"
-namespace llvm {
+#include "ARMSubtarget.h"
- extern const char *const arm_asm_table[];
+namespace llvm {
- template <class BaseTAI>
- struct ARMTargetAsmInfo : public BaseTAI {
- explicit ARMTargetAsmInfo(const ARMTargetMachine &TM):
- BaseTAI(TM) {
- BaseTAI::AsmTransCBE = arm_asm_table;
+ // Forward declaration.
+ class ARMTargetMachine;
- 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";
- }
+ struct ARMTargetAsmInfo : public virtual TargetAsmInfo {
+ explicit ARMTargetAsmInfo(const ARMTargetMachine &TM);
const ARMSubtarget *Subtarget;
unsigned countString(const char *p) const;
};
- typedef ARMTargetAsmInfo<TargetAsmInfo> ARMGenericTargetAsmInfo;
-
- EXTERN_TEMPLATE_INSTANTIATION(class ARMTargetAsmInfo<TargetAsmInfo>);
-
- struct ARMDarwinTargetAsmInfo : public ARMTargetAsmInfo<DarwinTargetAsmInfo> {
+ struct ARMDarwinTargetAsmInfo : public virtual ARMTargetAsmInfo,
+ public virtual DarwinTargetAsmInfo {
explicit ARMDarwinTargetAsmInfo(const ARMTargetMachine &TM);
};
- struct ARMELFTargetAsmInfo : public ARMTargetAsmInfo<ELFTargetAsmInfo> {
+ struct ARMELFTargetAsmInfo : public virtual ARMTargetAsmInfo,
+ public virtual ELFTargetAsmInfo {
explicit ARMELFTargetAsmInfo(const ARMTargetMachine &TM);
};
case ARMSubtarget::isELF:
return new ARMELFTargetAsmInfo(*this);
default:
- return new ARMGenericTargetAsmInfo(*this);
+ return new ARMTargetAsmInfo(*this);
}
}
using namespace llvm;
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):
- PPCTargetAsmInfo<DarwinTargetAsmInfo>(TM) {
+ PPCTargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
PCSymbol = ".";
CommentString = ";";
GlobalPrefix = "_";
PPCLinuxTargetAsmInfo::PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM) :
- PPCTargetAsmInfo<ELFTargetAsmInfo>(TM) {
+ PPCTargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
CommentString = "#";
GlobalPrefix = "";
PrivateGlobalPrefix = "";
#ifndef PPCTARGETASMINFO_H
#define PPCTARGETASMINFO_H
-#include "PPCTargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h"
-#include "llvm/Support/Compiler.h"
namespace llvm {
- template <class BaseTAI>
- struct PPCTargetAsmInfo : public BaseTAI {
- explicit PPCTargetAsmInfo(const PPCTargetMachine &TM):
- BaseTAI(TM) {
- const PPCSubtarget *Subtarget = &TM.getSubtarget<PPCSubtarget>();
- bool isPPC64 = Subtarget->isPPC64();
-
- BaseTAI::ZeroDirective = "\t.space\t";
- 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();
- }
- };
-
- typedef PPCTargetAsmInfo<TargetAsmInfo> PPCGenericTargetAsmInfo;
+ // Forward declaration.
+ class PPCTargetMachine;
- EXTERN_TEMPLATE_INSTANTIATION(class PPCTargetAsmInfo<TargetAsmInfo>);
+ struct PPCTargetAsmInfo : public virtual TargetAsmInfo {
+ explicit PPCTargetAsmInfo(const PPCTargetMachine &TM);
+ };
- struct PPCDarwinTargetAsmInfo : public PPCTargetAsmInfo<DarwinTargetAsmInfo> {
+ struct PPCDarwinTargetAsmInfo : public PPCTargetAsmInfo,
+ public DarwinTargetAsmInfo {
explicit PPCDarwinTargetAsmInfo(const PPCTargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const;
};
- struct PPCLinuxTargetAsmInfo : public PPCTargetAsmInfo<ELFTargetAsmInfo> {
+ struct PPCLinuxTargetAsmInfo : public PPCTargetAsmInfo,
+ public ELFTargetAsmInfo {
explicit PPCLinuxTargetAsmInfo(const PPCTargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const;
using namespace llvm;
-void TargetAsmInfo::fillDefaultValues() {
- BSSSection = "\t.bss";
- BSSSection_ = 0;
- ReadOnlySection = 0;
- SmallDataSection = 0;
- SmallBSSSection = 0;
- SmallRODataSection = 0;
- TLSDataSection = 0;
- TLSBSSSection = 0;
- ZeroFillDirective = 0;
- NonexecutableStackDirective = 0;
- NeedsSet = false;
- MaxInstLength = 4;
- PCSymbol = "$";
- SeparatorChar = ';';
- CommentString = "#";
- GlobalPrefix = "";
- PrivateGlobalPrefix = ".";
- LessPrivateGlobalPrefix = "";
- JumpTableSpecialLabelPrefix = 0;
- GlobalVarAddrPrefix = "";
- GlobalVarAddrSuffix = "";
- FunctionAddrPrefix = "";
- FunctionAddrSuffix = "";
- PersonalityPrefix = "";
- PersonalitySuffix = "";
- NeedsIndirectEncoding = false;
- InlineAsmStart = "#APP";
- InlineAsmEnd = "#NO_APP";
- AssemblerDialect = 0;
- StringConstantPrefix = ".str";
- ZeroDirective = "\t.zero\t";
- ZeroDirectiveSuffix = 0;
- AsciiDirective = "\t.ascii\t";
- AscizDirective = "\t.asciz\t";
- Data8bitsDirective = "\t.byte\t";
- Data16bitsDirective = "\t.short\t";
- Data32bitsDirective = "\t.long\t";
- Data64bitsDirective = "\t.quad\t";
- AlignDirective = "\t.align\t";
- AlignmentIsInBytes = true;
- TextAlignFillValue = 0;
- SwitchToSectionDirective = "\t.section\t";
- TextSectionStartSuffix = "";
- DataSectionStartSuffix = "";
- SectionEndDirectiveSuffix = 0;
- ConstantPoolSection = "\t.section .rodata";
- JumpTableDataSection = "\t.section .rodata";
- JumpTableDirective = 0;
- CStringSection = 0;
- CStringSection_ = 0;
- // FIXME: Flags are ELFish - replace with normal section stuff.
- StaticCtorsSection = "\t.section .ctors,\"aw\",@progbits";
- StaticDtorsSection = "\t.section .dtors,\"aw\",@progbits";
- GlobalDirective = "\t.globl\t";
- SetDirective = 0;
- LCOMMDirective = 0;
- COMMDirective = "\t.comm\t";
- COMMDirectiveTakesAlignment = true;
- HasDotTypeDotSizeDirective = true;
- UsedDirective = 0;
- WeakRefDirective = 0;
- WeakDefDirective = 0;
- // FIXME: These are ELFish - move to ELFTAI.
- HiddenDirective = "\t.hidden\t";
- ProtectedDirective = "\t.protected\t";
- AbsoluteDebugSectionOffsets = false;
- AbsoluteEHSectionOffsets = false;
- HasLEB128 = false;
- HasDotLocAndDotFile = false;
- SupportsDebugInformation = false;
- SupportsExceptionHandling = false;
- DwarfRequiresFrameSection = true;
- GlobalEHDirective = 0;
- SupportsWeakOmittedEHFrame = true;
- DwarfSectionOffsetDirective = 0;
- DwarfAbbrevSection = ".debug_abbrev";
- DwarfInfoSection = ".debug_info";
- DwarfLineSection = ".debug_line";
- DwarfFrameSection = ".debug_frame";
- DwarfPubNamesSection = ".debug_pubnames";
- DwarfPubTypesSection = ".debug_pubtypes";
- DwarfStrSection = ".debug_str";
- DwarfLocSection = ".debug_loc";
- DwarfARangesSection = ".debug_aranges";
- DwarfRangesSection = ".debug_ranges";
- DwarfMacInfoSection = ".debug_macinfo";
- DwarfEHFrameSection = ".eh_frame";
- DwarfExceptionSection = ".gcc_except_table";
- AsmTransCBE = 0;
+TargetAsmInfo::TargetAsmInfo() :
+ TextSection(0),
+ DataSection(0),
+ BSSSection("\t.bss"),
+ BSSSection_(0),
+ ReadOnlySection(0),
+ SmallDataSection(0),
+ SmallBSSSection(0),
+ SmallRODataSection(0),
+ TLSDataSection(0),
+ TLSBSSSection(0),
+ ZeroFillDirective(0),
+ NonexecutableStackDirective(0),
+ NeedsSet(false),
+ MaxInstLength(4),
+ PCSymbol("$"),
+ SeparatorChar(';'),
+ CommentString("#"),
+ GlobalPrefix(""),
+ PrivateGlobalPrefix("."),
+ LessPrivateGlobalPrefix(""),
+ JumpTableSpecialLabelPrefix(0),
+ GlobalVarAddrPrefix(""),
+ GlobalVarAddrSuffix(""),
+ FunctionAddrPrefix(""),
+ FunctionAddrSuffix(""),
+ PersonalityPrefix(""),
+ PersonalitySuffix(""),
+ NeedsIndirectEncoding(false),
+ InlineAsmStart("#APP"),
+ InlineAsmEnd("#NO_APP"),
+ AssemblerDialect(0),
+ StringConstantPrefix(".str"),
+ ZeroDirective("\t.zero\t"),
+ ZeroDirectiveSuffix(0),
+ AsciiDirective("\t.ascii\t"),
+ AscizDirective("\t.asciz\t"),
+ Data8bitsDirective("\t.byte\t"),
+ Data16bitsDirective("\t.short\t"),
+ Data32bitsDirective("\t.long\t"),
+ Data64bitsDirective("\t.quad\t"),
+ AlignDirective("\t.align\t"),
+ AlignmentIsInBytes(true),
+ TextAlignFillValue(0),
+ SwitchToSectionDirective("\t.section\t"),
+ TextSectionStartSuffix(""),
+ DataSectionStartSuffix(""),
+ SectionEndDirectiveSuffix(0),
+ ConstantPoolSection("\t.section .rodata"),
+ JumpTableDataSection("\t.section .rodata"),
+ JumpTableDirective(0),
+ CStringSection(0),
+ CStringSection_(0),
+ StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"),
+ StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"),
+ GlobalDirective("\t.globl\t"),
+ SetDirective(0),
+ LCOMMDirective(0),
+ COMMDirective("\t.comm\t"),
+ COMMDirectiveTakesAlignment(true),
+ HasDotTypeDotSizeDirective(true),
+ UsedDirective(0),
+ WeakRefDirective(0),
+ WeakDefDirective(0),
+ HiddenDirective("\t.hidden\t"),
+ ProtectedDirective("\t.protected\t"),
+ AbsoluteDebugSectionOffsets(false),
+ AbsoluteEHSectionOffsets(false),
+ HasLEB128(false),
+ HasDotLocAndDotFile(false),
+ SupportsDebugInformation(false),
+ SupportsExceptionHandling(false),
+ DwarfRequiresFrameSection(true),
+ GlobalEHDirective(0),
+ SupportsWeakOmittedEHFrame(true),
+ DwarfSectionOffsetDirective(0),
+ DwarfAbbrevSection(".debug_abbrev"),
+ DwarfInfoSection(".debug_info"),
+ DwarfLineSection(".debug_line"),
+ DwarfFrameSection(".debug_frame"),
+ DwarfPubNamesSection(".debug_pubnames"),
+ DwarfPubTypesSection(".debug_pubtypes"),
+ DwarfStrSection(".debug_str"),
+ DwarfLocSection(".debug_loc"),
+ DwarfARangesSection(".debug_aranges"),
+ DwarfRangesSection(".debug_ranges"),
+ DwarfMacInfoSection(".debug_macinfo"),
+ DwarfEHFrameSection(".eh_frame"),
+ DwarfExceptionSection(".gcc_except_table"),
+ AsmTransCBE(0) {
TextSection = getUnnamedSection("\t.text", SectionFlags::Code);
DataSection = getUnnamedSection("\t.data", SectionFlags::Writeable);
}
-TargetAsmInfo::TargetAsmInfo() {
- fillDefaultValues();
-}
-
-TargetAsmInfo::TargetAsmInfo(const TargetMachine &TM) {
- fillDefaultValues();
-}
-
TargetAsmInfo::~TargetAsmInfo() {
}
using namespace llvm;
using namespace llvm::dwarf;
-const char *const llvm::x86_asm_table[] = {
- "{si}", "S",
- "{di}", "D",
- "{ax}", "a",
- "{cx}", "c",
- "{memory}", "memory",
- "{flags}", "",
- "{dirflag}", "",
- "{fpsr}", "",
- "{cc}", "cc",
- 0,0};
-
-TEMPLATE_INSTANTIATION(class X86TargetAsmInfo<TargetAsmInfo>);
-
-template <class BaseTAI>
-bool X86TargetAsmInfo<BaseTAI>::LowerToBSwap(CallInst *CI) const {
+static const char *const x86_asm_table[] = {
+ "{si}", "S",
+ "{di}", "D",
+ "{ax}", "a",
+ "{cx}", "c",
+ "{memory}", "memory",
+ "{flags}", "",
+ "{dirflag}", "",
+ "{fpsr}", "",
+ "{cc}", "cc",
+ 0,0};
+
+X86TargetAsmInfo::X86TargetAsmInfo(const X86TargetMachine &TM) {
+ const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
+
+ AsmTransCBE = x86_asm_table;
+
+ AssemblerDialect = Subtarget->getAsmFlavor();
+}
+
+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
return true;
}
-template <class BaseTAI>
-bool X86TargetAsmInfo<BaseTAI>::ExpandInlineAsm(CallInst *CI) const {
+bool X86TargetAsmInfo::ExpandInlineAsm(CallInst *CI) const {
InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
std::vector<InlineAsm::ConstraintInfo> Constraints = IA->ParseConstraints();
}
X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM):
- X86TargetAsmInfo<DarwinTargetAsmInfo>(TM) {
+ X86TargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>();
bool is64Bit = Subtarget->is64Bit();
}
X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM):
- X86TargetAsmInfo<ELFTargetAsmInfo>(TM) {
+ X86TargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
CStringSection = ".rodata.str";
PrivateGlobalPrefix = ".L";
}
X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM):
- X86GenericTargetAsmInfo(TM) {
+ X86TargetAsmInfo(TM) {
X86TM = &TM;
GlobalPrefix = "_";
}
X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
- X86GenericTargetAsmInfo(TM) {
+ X86TargetAsmInfo(TM) {
GlobalPrefix = "_";
CommentString = ";";
#ifndef X86TARGETASMINFO_H
#define X86TARGETASMINFO_H
-#include "X86TargetMachine.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/ELFTargetAsmInfo.h"
#include "llvm/Target/DarwinTargetAsmInfo.h"
-#include "llvm/Support/Compiler.h"
namespace llvm {
- extern const char *const x86_asm_table[];
+ // Forward declaration.
+ class X86TargetMachine;
- template <class BaseTAI>
- 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();
- }
+ struct X86TargetAsmInfo : public virtual TargetAsmInfo {
+ explicit X86TargetAsmInfo(const X86TargetMachine &TM);
virtual bool ExpandInlineAsm(CallInst *CI) const;
bool LowerToBSwap(CallInst *CI) const;
};
- typedef X86TargetAsmInfo<TargetAsmInfo> X86GenericTargetAsmInfo;
-
- EXTERN_TEMPLATE_INSTANTIATION(class X86TargetAsmInfo<TargetAsmInfo>);
-
- struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo<DarwinTargetAsmInfo> {
+ struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo,
+ public DarwinTargetAsmInfo {
explicit X86DarwinTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const;
};
- struct X86ELFTargetAsmInfo : public X86TargetAsmInfo<ELFTargetAsmInfo> {
+ struct X86ELFTargetAsmInfo : public X86TargetAsmInfo,
+ public ELFTargetAsmInfo {
explicit X86ELFTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const;
};
- struct X86COFFTargetAsmInfo : public X86GenericTargetAsmInfo {
+ struct X86COFFTargetAsmInfo : public X86TargetAsmInfo {
explicit X86COFFTargetAsmInfo(const X86TargetMachine &TM);
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const;
const X86TargetMachine *X86TM;
};
- struct X86WinTargetAsmInfo : public X86GenericTargetAsmInfo {
+ struct X86WinTargetAsmInfo : public X86TargetAsmInfo {
explicit X86WinTargetAsmInfo(const X86TargetMachine &TM);
};
-
} // namespace llvm
#endif
-
case X86Subtarget::isWindows:
return new X86WinTargetAsmInfo(*this);
default:
- return new X86GenericTargetAsmInfo(*this);
+ return new X86TargetAsmInfo(*this);
}
}
projects / oota-llvm.git / commitdiff