Patch up omissions in DebugLoc propagation.

[oota-llvm.git] / lib / Target / DarwinTargetAsmInfo.cpp

diff --git a/lib/Target/DarwinTargetAsmInfo.cpp b/lib/Target/DarwinTargetAsmInfo.cpp
index a5b72e3edd3abddd6620dd8da5bb842e46764f58..cc05c09c5170a1b401706e4317e49f11410b98de 100644 (file)
--- a/lib/Target/DarwinTargetAsmInfo.cpp
+++ b/lib/Target/DarwinTargetAsmInfo.cpp
@@ -24,31 +24,32 @@
 
 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
@@ -60,7 +61,7 @@ DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
                                           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()) ||
@@ -74,15 +75,15 @@ DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
 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:
     if (isWeak)
       return TextCoalSection;
     else
-      return getTextSection();
+      return TextSection;
    case SectionKind::Data:
    case SectionKind::ThreadData:
    case SectionKind::BSS:
@@ -90,13 +91,13 @@ DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
     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 ?
@@ -107,45 +108,45 @@ DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
   }
 
   // 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*
 DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
-  Constant *C = cast<GlobalVariable>(GV)->getInitializer();
+  Constant *C = GV->getInitializer();
 
   return MergeableConstSection(C->getType());
 }
 
 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*
@@ -153,8 +154,8 @@ DarwinTargetAsmInfo::SelectSectionForMachineConst(const Type *Ty) const {
   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;