using namespace llvm;
-DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM) {
- DTM = &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);
// Note: 16-byte constant section is subtarget specific and should be provided
- // there.
+ // there, if needed.
+ SixteenByteConstantSection = 0;
- ReadOnlySection_ = getUnnamedSection("\t.const\n", SectionFlags::None);
+ ReadOnlySection = getUnnamedSection("\t.const\n", SectionFlags::None);
- // FIXME: These should be named sections, really.
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);
}
/// emitUsedDirectiveFor - On Darwin, internally linked data beginning with
Mangler *Mang) const {
if (GV==0)
return false;
- if (GV->hasInternalLinkage() && !isa<Function>(GV) &&
+ if (GV->hasLocalLinkage() && !isa<Function>(GV) &&
((strlen(getPrivateGlobalPrefix()) != 0 &&
Mang->getValueName(GV).substr(0,strlen(getPrivateGlobalPrefix())) ==
getPrivateGlobalPrefix()) ||
const Section*
DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
SectionKind::Kind Kind = SectionKindForGlobal(GV);
- bool isWeak = GV->isWeakForLinker();
- bool isNonStatic = (DTM->getRelocationModel() != Reloc::Static);
+ bool isWeak = GV->mayBeOverridden();
+ bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
switch (Kind) {
case SectionKind::Text:
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 ?
}
// FIXME: Do we have any extra special weird cases?
+ return NULL;
}
const Section*
DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
- const TargetData *TD = DTM->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->getTypePaddedSize(Ty);
if (Size) {
- const TargetData *TD = DTM->getTargetData();
unsigned Align = TD->getPreferredAlignment(GV);
if (Align <= 32)
return getCStringSection_();
}
- return getReadOnlySection_();
+ return getReadOnlySection();
}
const Section*
inline const Section*
DarwinTargetAsmInfo::MergeableConstSection(const Type *Ty) const {
- const TargetData *TD = DTM->getTargetData();
+ const TargetData *TD = TM.getTargetData();
- unsigned Size = TD->getABITypeSize(Ty);
+ unsigned Size = TD->getTypePaddedSize(Ty);
if (Size == 4)
- return FourByteConstantSection_;
+ return FourByteConstantSection;
else if (Size == 8)
- return EightByteConstantSection_;
- else if (Size == 16 && SixteenByteConstantSection_)
- return SixteenByteConstantSection_;
+ return EightByteConstantSection;
+ else if (Size == 16 && SixteenByteConstantSection)
+ return SixteenByteConstantSection;
- return getReadOnlySection_();
+ return getReadOnlySection();
}
const Section*
const Section* S = MergeableConstSection(Ty);
// Handle weird special case, when compiling PIC stuff.
- if (S == getReadOnlySection_() &&
- DTM->getRelocationModel() != Reloc::Static)
+ if (S == getReadOnlySection() &&
+ TM.getRelocationModel() != Reloc::Static)
return ConstDataSection;
return S;