X86TargetAsmInfo::X86TargetAsmInfo(const X86TargetMachine &TM) {
const X86Subtarget *Subtarget = &TM.getSubtarget<X86Subtarget>();
- X86TM = &TM;
AsmTransCBE = x86_asm_table;
return true;
}
-
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(TM) {
- bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
+ X86TargetAsmInfo(TM), DarwinTargetAsmInfo(TM) {
+ const X86Subtarget* Subtarget = &DTM->getSubtarget<X86Subtarget>();
+ bool is64Bit = Subtarget->is64Bit();
AlignmentIsInBytes = false;
TextAlignFillValue = 0x90;
Data64bitsDirective = 0; // we can't emit a 64-bit unit
ZeroDirective = "\t.space\t"; // ".space N" emits N zeros.
PrivateGlobalPrefix = "L"; // Marker for constant pool idxs
+ LessPrivateGlobalPrefix = "l"; // Marker for some ObjC metadata
BSSSection = 0; // no BSS section.
ZeroFillDirective = "\t.zerofill\t"; // Uses .zerofill
- ConstantPoolSection = "\t.const\n";
+ if (DTM->getRelocationModel() != Reloc::Static)
+ ConstantPoolSection = "\t.const_data";
+ else
+ ConstantPoolSection = "\t.const\n";
JumpTableDataSection = "\t.const\n";
CStringSection = "\t.cstring";
- FourByteConstantSection = "\t.literal4\n";
- EightByteConstantSection = "\t.literal8\n";
// FIXME: Why don't always use this section?
- if (is64Bit)
- SixteenByteConstantSection = "\t.literal16\n";
+ if (is64Bit) {
+ SixteenByteConstantSection = getUnnamedSection("\t.literal16\n",
+ SectionFlags::Mergeable);
+ }
ReadOnlySection = "\t.const\n";
+
LCOMMDirective = "\t.lcomm\t";
SwitchToSectionDirective = "\t.section ";
StringConstantPrefix = "\1LC";
- COMMDirectiveTakesAlignment = false;
+ // Leopard and above support aligned common symbols.
+ COMMDirectiveTakesAlignment = (Subtarget->getDarwinVers() >= 9);
HasDotTypeDotSizeDirective = false;
if (TM.getRelocationModel() == Reloc::Static) {
StaticCtorsSection = ".constructor";
}
X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM):
- X86TargetAsmInfo(TM) {
- bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
+ X86TargetAsmInfo(TM), ELFTargetAsmInfo(TM) {
- ReadOnlySection = "\t.section\t.rodata";
- FourByteConstantSection = "\t.section\t.rodata.cst4,\"aM\",@progbits,4";
- EightByteConstantSection = "\t.section\t.rodata.cst8,\"aM\",@progbits,8";
- SixteenByteConstantSection = "\t.section\t.rodata.cst16,\"aM\",@progbits,16";
- CStringSection = "\t.section\t.rodata.str1.1,\"aMS\",@progbits,1";
+ ReadOnlySection = ".rodata";
+ CStringSection = ".rodata.str";
PrivateGlobalPrefix = ".L";
WeakRefDirective = "\t.weak\t";
SetDirective = "\t.set\t";
DwarfMacInfoSection = "\t.section\t.debug_macinfo,\"\",@progbits";
// Exceptions handling
- if (!is64Bit)
- SupportsExceptionHandling = true;
+ SupportsExceptionHandling = true;
AbsoluteEHSectionOffsets = false;
DwarfEHFrameSection = "\t.section\t.eh_frame,\"aw\",@progbits";
DwarfExceptionSection = "\t.section\t.gcc_except_table,\"a\",@progbits";
// On Linux we must declare when we can use a non-executable stack.
- if (X86TM->getSubtarget<X86Subtarget>().isLinux())
+ if (ETM->getSubtarget<X86Subtarget>().isLinux())
NonexecutableStackDirective = "\t.section\t.note.GNU-stack,\"\",@progbits";
}
unsigned
X86ELFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const {
- CodeModel::Model CM = X86TM->getCodeModel();
- bool is64Bit = X86TM->getSubtarget<X86Subtarget>().is64Bit();
+ CodeModel::Model CM = ETM->getCodeModel();
+ bool is64Bit = ETM->getSubtarget<X86Subtarget>().is64Bit();
- if (X86TM->getRelocationModel() == Reloc::PIC_) {
+ if (ETM->getRelocationModel() == Reloc::PIC_) {
unsigned Format = 0;
if (!is64Bit)
X86COFFTargetAsmInfo::X86COFFTargetAsmInfo(const X86TargetMachine &TM):
X86TargetAsmInfo(TM) {
+ X86TM = &TM;
+
GlobalPrefix = "_";
LCOMMDirective = "\t.lcomm\t";
COMMDirectiveTakesAlignment = false;
DwarfMacInfoSection = "\t.section\t.debug_macinfo,\"dr\"";
}
-X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
- X86TargetAsmInfo(TM) {
- 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";
- JumpTableDataSection = NULL;
- SwitchToSectionDirective = "";
- TextSectionStartSuffix = "\tsegment 'CODE'";
- DataSectionStartSuffix = "\tsegment 'DATA'";
- SectionEndDirectiveSuffix = "\tends\n";
-}
-
unsigned
X86COFFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const {
}
}
-std::string X86TargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
- SectionKind::Kind kind) const {
- const X86Subtarget *Subtarget = &X86TM->getSubtarget<X86Subtarget>();
-
- switch (Subtarget->TargetType) {
- case X86Subtarget::isDarwin:
- if (kind == SectionKind::Text)
- return "__TEXT,__textcoal_nt,coalesced,pure_instructions";
- else
- return "__DATA,__datacoal_nt,coalesced";
- case X86Subtarget::isCygwin:
- case X86Subtarget::isMingw:
- switch (kind) {
- case SectionKind::Text:
- return ".text$linkonce" + GV->getName();
- case SectionKind::Data:
- case SectionKind::BSS:
- case SectionKind::ThreadData:
- case SectionKind::ThreadBSS:
- return ".data$linkonce" + GV->getName();
- case SectionKind::ROData:
- case SectionKind::RODataMergeConst:
- case SectionKind::RODataMergeStr:
- return ".rdata$linkonce" + GV->getName();
- default:
- assert(0 && "Unknown section kind");
- }
- case X86Subtarget::isELF:
- return TargetAsmInfo::UniqueSectionForGlobal(GV, kind);
+std::string
+X86COFFTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
+ SectionKind::Kind kind) const {
+ switch (kind) {
+ case SectionKind::Text:
+ return ".text$linkonce" + GV->getName();
+ case SectionKind::Data:
+ case SectionKind::BSS:
+ case SectionKind::ThreadData:
+ case SectionKind::ThreadBSS:
+ return ".data$linkonce" + GV->getName();
+ case SectionKind::ROData:
+ case SectionKind::RODataMergeConst:
+ case SectionKind::RODataMergeStr:
+ return ".rdata$linkonce" + GV->getName();
default:
- return "";
+ assert(0 && "Unknown section kind");
}
}
+std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const {
+ std::string Flags = ",\"";
-std::string X86TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const {
- 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?
- // FIXME: It seems, that Darwin uses much more sections.
+ if (flags & SectionFlags::Code)
+ Flags += 'x';
+ if (flags & SectionFlags::Writeable)
+ Flags += 'w';
- // Select section name
- if (GV->hasSection()) {
- // Honour section already set, if any
- Name = GV->getSection();
- } else {
- // Use default section depending on the 'type' of global
- if (const Function *F = dyn_cast<Function>(GV)) {
- switch (F->getLinkage()) {
- default: assert(0 && "Unknown linkage type!");
- case Function::InternalLinkage:
- case Function::DLLExportLinkage:
- case Function::ExternalLinkage:
- Name = TextSection;
- break;
- case Function::WeakLinkage:
- case Function::LinkOnceLinkage:
- Name = UniqueSectionForGlobal(F, kind);
- break;
- }
- } else if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
- if (GVar->hasCommonLinkage() ||
- GVar->hasLinkOnceLinkage() ||
- GVar->hasWeakLinkage())
- Name = UniqueSectionForGlobal(GVar, kind);
- else {
- 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");
- }
+ Flags += "\"";
- Name += PrintSectionFlags(flags);
- return Name;
+ return Flags;
}
-std::string X86TargetAsmInfo::PrintSectionFlags(unsigned flags) const {
- const X86Subtarget *Subtarget = &X86TM->getSubtarget<X86Subtarget>();
-
- std::string Flags = "";
-
- // Add all special flags, etc
- switch (Subtarget->TargetType) {
- case X86Subtarget::isELF:
- Flags += ",\"";
-
- if (!(flags & SectionFlags::Debug))
- Flags += 'a';
- if (flags & SectionFlags::Code)
- Flags += 'x';
- if (flags & SectionFlags::Writeable)
- Flags += 'w';
- if (flags & SectionFlags::Mergeable)
- Flags += 'M';
- if (flags & SectionFlags::Strings)
- Flags += 'S';
- if (flags & SectionFlags::TLS)
- Flags += 'T';
-
- Flags += "\"";
-
- // FIXME: There can be exceptions here
- if (flags & SectionFlags::BSS)
- Flags += ",@nobits";
- else
- Flags += ",@progbits";
-
- // FIXME: entity size for mergeable sections
- break;
- case X86Subtarget::isCygwin:
- case X86Subtarget::isMingw:
- Flags += ",\"";
-
- if (flags & SectionFlags::Code)
- Flags += 'x';
- if (flags & SectionFlags::Writeable)
- Flags += 'w';
+X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):
+ X86TargetAsmInfo(TM) {
+ GlobalPrefix = "_";
+ CommentString = ";";
- Flags += "\"";
+ 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;
- break;
- case X86Subtarget::isDarwin:
- // Darwin does not use any special flags
- default:
- break;
- }
+ TextSection = getUnnamedSection("_text", SectionFlags::Code);
+ DataSection = getUnnamedSection("_data", SectionFlags::Writeable);
- return Flags;
+ JumpTableDataSection = NULL;
+ SwitchToSectionDirective = "";
+ TextSectionStartSuffix = "\tsegment 'CODE'";
+ DataSectionStartSuffix = "\tsegment 'DATA'";
+ SectionEndDirectiveSuffix = "\tends\n";
}
projects / oota-llvm.git / blobdiff