X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FDarwinTargetAsmInfo.cpp;h=cc05c09c5170a1b401706e4317e49f11410b98de;hb=dd64c417c0ef73345222eca60154289c1ad62a09;hp=749cb7179437c8e9c0329f9c881a10fd8254834e;hpb=42ccc21ce7ae392d9a5c2958786190943fe9aae0;p=oota-llvm.git

diff --git a/lib/Target/DarwinTargetAsmInfo.cpp b/lib/Target/DarwinTargetAsmInfo.cpp
index 749cb717943..cc05c09c517 100644
--- a/lib/Target/DarwinTargetAsmInfo.cpp
+++ b/lib/Target/DarwinTargetAsmInfo.cpp
@@ -17,51 +17,73 @@
 #include "llvm/Function.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/ADT/StringExtras.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) {
-  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
+/// 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;
+  if (GV->hasLocalLinkage() && !isa<Function>(GV) &&
+      ((strlen(getPrivateGlobalPrefix()) != 0 &&
+        Mang->getValueName(GV).substr(0,strlen(getPrivateGlobalPrefix())) ==
+          getPrivateGlobalPrefix()) ||
+       (strlen(getLessPrivateGlobalPrefix()) != 0 &&
+        Mang->getValueName(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 = (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:
@@ -69,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 ?
@@ -86,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*
@@ -132,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;