#include "llvm/Function.h"
#include "llvm/GlobalVariable.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Mangler.h"
#include "llvm/Target/DarwinTargetAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetData.h"
using namespace llvm;
-DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM) {
- ETM = &TM;
+DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM)
+ : TargetAsmInfo(TM) {
CStringSection_ = getUnnamedSection("\t.cstring",
SectionFlags::Mergeable | SectionFlags::Strings);
- FourByteConstantSection_ = getUnnamedSection("\t.literal4\n",
+ FourByteConstantSection = getUnnamedSection("\t.literal4\n",
+ SectionFlags::Mergeable);
+ EightByteConstantSection = getUnnamedSection("\t.literal8\n",
SectionFlags::Mergeable);
- EightByteConstantSection_ = getUnnamedSection("\t.literal8\n",
- SectionFlags::Mergeable);
- // FIXME: Check for 64 bit
- SixteenByteConstantSection_ = getUnnamedSection("\t.literal16\n",
- SectionFlags::Mergeable);
- ReadOnlySection_ = getUnnamedSection("\t.const\n", SectionFlags::None);
-
- // FIXME: These should be named sections, really.
+
+ // Note: 16-byte constant section is subtarget specific and should be provided
+ // there, if needed.
+ SixteenByteConstantSection = 0;
+
+ ReadOnlySection = getUnnamedSection("\t.const\n", SectionFlags::None);
+
TextCoalSection =
- getUnnamedSection(".section __TEXT,__textcoal_nt,coalesced,pure_instructions",
+ getNamedSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
SectionFlags::Code);
- ConstDataCoalSection =
- getUnnamedSection(".section __DATA,__const_coal,coalesced",
- SectionFlags::None);
+ ConstTextCoalSection = getNamedSection("\t__TEXT,__const_coal,coalesced",
+ SectionFlags::None);
+ ConstDataCoalSection = getNamedSection("\t__DATA,__const_coal,coalesced",
+ SectionFlags::None);
ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None);
- DataCoalSection = getUnnamedSection(".section __DATA,__datacoal_nt,coalesced",
- SectionFlags::Writeable);
+ DataCoalSection = getNamedSection("\t__DATA,__datacoal_nt,coalesced",
+ SectionFlags::Writeable);
+
+
+ // Common settings for all Darwin targets.
+ // Syntax:
+ GlobalPrefix = "_";
+ PrivateGlobalPrefix = "L";
+ LessPrivateGlobalPrefix = "l"; // Marker for some ObjC metadata
+ NeedsSet = true;
+ NeedsIndirectEncoding = true;
+ AllowQuotesInName = true;
+ HasSingleParameterDotFile = false;
+
+ // In non-PIC modes, emit a special label before jump tables so that the
+ // linker can perform more accurate dead code stripping. We do not check the
+ // relocation model here since it can be overridden later.
+ JumpTableSpecialLabelPrefix = "l";
+
+ // Directives:
+ WeakDefDirective = "\t.weak_definition ";
+ WeakRefDirective = "\t.weak_reference ";
+ HiddenDirective = "\t.private_extern ";
+
+ // Sections:
+ CStringSection = "\t.cstring";
+ JumpTableDataSection = "\t.const\n";
+ BSSSection = 0;
+
+ if (TM.getRelocationModel() == Reloc::Static) {
+ StaticCtorsSection = ".constructor";
+ StaticDtorsSection = ".destructor";
+ } else {
+ StaticCtorsSection = ".mod_init_func";
+ StaticDtorsSection = ".mod_term_func";
+ }
+
+ 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";
+ DwarfMacroInfoSection = ".section __DWARF,__debug_macinfo,regular,debug";
+}
+
+/// emitUsedDirectiveFor - On Darwin, internally linked data beginning with
+/// the PrivateGlobalPrefix or the LessPrivateGlobalPrefix does not have the
+/// directive emitted (this occurs in ObjC metadata).
+bool
+DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
+ Mangler *Mang) const {
+ if (GV==0)
+ return false;
+
+ /// FIXME: WHAT IS THIS?
+
+ if (GV->hasLocalLinkage() && !isa<Function>(GV) &&
+ ((strlen(getPrivateGlobalPrefix()) != 0 &&
+ Mang->getMangledName(GV).substr(0,strlen(getPrivateGlobalPrefix())) ==
+ getPrivateGlobalPrefix()) ||
+ (strlen(getLessPrivateGlobalPrefix()) != 0 &&
+ Mang->getMangledName(GV).substr(0,
+ strlen(getLessPrivateGlobalPrefix())) ==
+ getLessPrivateGlobalPrefix())))
+ return false;
+ return true;
}
const Section*
DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
SectionKind::Kind Kind = SectionKindForGlobal(GV);
bool isWeak = GV->isWeakForLinker();
- bool isNonStatic = (ETM->getRelocationModel() != Reloc::Static);
+ bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
switch (Kind) {
case SectionKind::Text:
if (isWeak)
return TextCoalSection;
else
- return getTextSection_();
+ return TextSection;
case SectionKind::Data:
case SectionKind::ThreadData:
case SectionKind::BSS:
if (cast<GlobalVariable>(GV)->isConstant())
return (isWeak ? ConstDataCoalSection : ConstDataSection);
else
- return (isWeak ? DataCoalSection : getDataSection_());
+ return (isWeak ? DataCoalSection : DataSection);
case SectionKind::ROData:
return (isWeak ? ConstDataCoalSection :
- (isNonStatic ? ConstDataSection : getReadOnlySection_()));
+ (isNonStatic ? ConstDataSection : getReadOnlySection()));
case SectionKind::RODataMergeStr:
return (isWeak ?
- ConstDataCoalSection :
+ ConstTextCoalSection :
MergeableStringSection(cast<GlobalVariable>(GV)));
case SectionKind::RODataMergeConst:
return (isWeak ?
ConstDataCoalSection:
MergeableConstSection(cast<GlobalVariable>(GV)));
default:
- assert(0 && "Unsuported section kind for global");
+ llvm_unreachable("Unsuported section kind for global");
}
// FIXME: Do we have any extra special weird cases?
+ return NULL;
}
const Section*
DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
- const TargetData *TD = ETM->getTargetData();
+ const TargetData *TD = TM.getTargetData();
Constant *C = cast<GlobalVariable>(GV)->getInitializer();
- const Type *Type = cast<ConstantArray>(C)->getType()->getElementType();
+ const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
- unsigned Size = TD->getABITypeSize(Type);
+ unsigned Size = TD->getTypeAllocSize(Ty);
if (Size) {
- const TargetData *TD = ETM->getTargetData();
unsigned Align = TD->getPreferredAlignment(GV);
if (Align <= 32)
return getCStringSection_();
}
- return getReadOnlySection_();
+ return getReadOnlySection();
}
const Section*
DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
- const TargetData *TD = ETM->getTargetData();
- Constant *C = cast<GlobalVariable>(GV)->getInitializer();
+ Constant *C = GV->getInitializer();
- unsigned Size = TD->getABITypeSize(C->getType());
+ return MergeableConstSection(C->getType());
+}
+
+inline const Section*
+DarwinTargetAsmInfo::MergeableConstSection(const Type *Ty) const {
+ const TargetData *TD = TM.getTargetData();
+
+ unsigned Size = TD->getTypeAllocSize(Ty);
if (Size == 4)
- return FourByteConstantSection_;
+ return FourByteConstantSection;
else if (Size == 8)
- return EightByteConstantSection_;
- // FIXME: 64 bit
- /*else if (Size == 16 && ETM->getSubtarget<X86Subtarget>().is64Bit())
- return SixteenByteConstantSection_;*/
+ return EightByteConstantSection;
+ else if (Size == 16 && SixteenByteConstantSection)
+ return SixteenByteConstantSection;
+
+ return getReadOnlySection();
+}
+
+const Section*
+DarwinTargetAsmInfo::SelectSectionForMachineConst(const Type *Ty) const {
+ const Section* S = MergeableConstSection(Ty);
+
+ // Handle weird special case, when compiling PIC stuff.
+ if (S == getReadOnlySection() &&
+ TM.getRelocationModel() != Reloc::Static)
+ return ConstDataSection;
- return getReadOnlySection_();
+ return S;
}
std::string
DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
SectionKind::Kind kind) const {
- assert(0 && "Darwin does not use unique sections");
+ llvm_unreachable("Darwin does not use unique sections");
return "";
}
projects / oota-llvm.git / blobdiff