Print variable's display name in dwarf DIE.

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

diff --git a/lib/Target/ELFTargetAsmInfo.cpp b/lib/Target/ELFTargetAsmInfo.cpp
index 6ce01a836b400f1760a0d76d17c0089f99ef903d..624b95c7b6c162e643545d7665d0c968a507c83a 100644 (file)
--- a/lib/Target/ELFTargetAsmInfo.cpp
+++ b/lib/Target/ELFTargetAsmInfo.cpp
@@ -17,23 +17,22 @@
 #include "llvm/Function.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/Target/ELFTargetAsmInfo.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetData.h"
 
 using namespace llvm;
 
-ELFTargetAsmInfo::ELFTargetAsmInfo(const TargetMachine &TM) {
-  ETM = &TM;
+ELFTargetAsmInfo::ELFTargetAsmInfo(const TargetMachine &TM)
+  : TargetAsmInfo(TM) {
 
-  TextSection_ = getUnnamedSection("\t.text", SectionFlags::Code);
-  DataSection_ = getUnnamedSection("\t.data", SectionFlags::Writeable);
   BSSSection_  = getUnnamedSection("\t.bss",
                                    SectionFlags::Writeable | SectionFlags::BSS);
-  ReadOnlySection_ = getNamedSection("\t.rodata", SectionFlags::None);
-  TLSDataSection_ = getNamedSection("\t.tdata",
-                                    SectionFlags::Writeable | SectionFlags::TLS);
-  TLSBSSSection_ = getNamedSection("\t.tbss",
+  ReadOnlySection = getNamedSection("\t.rodata", SectionFlags::None);
+  TLSDataSection = getNamedSection("\t.tdata",
+                                   SectionFlags::Writeable | SectionFlags::TLS);
+  TLSBSSSection = getNamedSection("\t.tbss",
                 SectionFlags::Writeable | SectionFlags::TLS | SectionFlags::BSS);
 
 }
@@ -45,10 +44,11 @@ ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
   if (const Function *F = dyn_cast<Function>(GV)) {
     switch (F->getLinkage()) {
      default: assert(0 && "Unknown linkage type!");
+     case Function::PrivateLinkage:
      case Function::InternalLinkage:
      case Function::DLLExportLinkage:
      case Function::ExternalLinkage:
-      return getTextSection_();
+      return TextSection;
      case Function::WeakLinkage:
      case Function::LinkOnceLinkage:
       std::string Name = UniqueSectionForGlobal(GV, Kind);
@@ -56,7 +56,7 @@ ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
       return getNamedSection(Name.c_str(), Flags);
     }
   } else if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
-    if (GVar->isWeakForLinker()) {
+    if (GVar->mayBeOverridden()) {
       std::string Name = UniqueSectionForGlobal(GVar, Kind);
       unsigned Flags = SectionFlagsForGlobal(GVar, Name.c_str());
       return getNamedSection(Name.c_str(), Flags);
@@ -64,41 +64,53 @@ ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
       switch (Kind) {
        case SectionKind::Data:
        case SectionKind::SmallData:
-        return getDataSection_();
+        return DataSection;
        case SectionKind::BSS:
        case SectionKind::SmallBSS:
         // ELF targets usually have BSS sections
         return getBSSSection_();
        case SectionKind::ROData:
        case SectionKind::SmallROData:
-        return getReadOnlySection_();
+        return getReadOnlySection();
        case SectionKind::RODataMergeStr:
         return MergeableStringSection(GVar);
        case SectionKind::RODataMergeConst:
         return MergeableConstSection(GVar);
        case SectionKind::ThreadData:
         // ELF targets usually support TLS stuff
-        return getTLSDataSection_();
+        return TLSDataSection;
        case SectionKind::ThreadBSS:
-        return getTLSBSSSection_();
+        return TLSBSSSection;
        default:
         assert(0 && "Unsuported section kind for global");
       }
     }
   } else
     assert(0 && "Unsupported global");
+
+  return NULL;
+}
+
+const Section*
+ELFTargetAsmInfo::SelectSectionForMachineConst(const Type *Ty) const {
+  // FIXME: Support data.rel stuff someday
+  return MergeableConstSection(Ty);
 }
 
 const Section*
 ELFTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
-  const TargetData *TD = ETM->getTargetData();
-  Constant *C = cast<GlobalVariable>(GV)->getInitializer();
-  const Type *Type = C->getType();
+  Constant *C = GV->getInitializer();
+  return MergeableConstSection(C->getType());
+}
+
+inline const Section*
+ELFTargetAsmInfo::MergeableConstSection(const Type *Ty) const {
+  const TargetData *TD = TM.getTargetData();
 
   // FIXME: string here is temporary, until stuff will fully land in.
   // We cannot use {Four,Eight,Sixteen}ByteConstantSection here, since it's
   // currently directly used by asmprinter.
-  unsigned Size = TD->getABITypeSize(Type);
+  unsigned Size = TD->getTypePaddedSize(Ty);
   if (Size == 4 || Size == 8 || Size == 16) {
     std::string Name =  ".rodata.cst" + utostr(Size);
 
@@ -107,20 +119,20 @@ ELFTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
                                                        Size));
   }
 
-  return getReadOnlySection_();
+  return getReadOnlySection();
 }
 
 const Section*
 ELFTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
-  const TargetData *TD = ETM->getTargetData();
+  const TargetData *TD = TM.getTargetData();
   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
-  const ConstantArray *CVA = cast<ConstantArray>(C);
-  const Type *Ty = CVA->getType()->getElementType();
+  const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
 
-  unsigned Size = TD->getABITypeSize(Ty);
+  unsigned Size = TD->getTypePaddedSize(Ty);
   if (Size <= 16) {
+    assert(getCStringSection() && "Should have string section prefix");
+
     // We also need alignment here
-    const TargetData *TD = ETM->getTargetData();
     unsigned Align = TD->getPrefTypeAlignment(Ty);
     if (Align < Size)
       Align = Size;
@@ -132,10 +144,10 @@ ELFTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
     return getNamedSection(Name.c_str(), Flags);
   }
 
-  return getReadOnlySection_();
+  return getReadOnlySection();
 }
 
-std::string ELFTargetAsmInfo::PrintSectionFlags(unsigned flags) const {
+std::string ELFTargetAsmInfo::printSectionFlags(unsigned flags) const {
   std::string Flags = ",\"";
 
   if (!(flags & SectionFlags::Debug))
@@ -153,17 +165,22 @@ std::string ELFTargetAsmInfo::PrintSectionFlags(unsigned flags) const {
   if (flags & SectionFlags::Small)
     Flags += 's';
 
-  Flags += "\"";
+  Flags += "\",";
+
+  // If comment string is '@', e.g. as on ARM - use '%' instead
+  if (strcmp(CommentString, "@") == 0)
+    Flags += '%';
+  else
+    Flags += '@';
 
   // FIXME: There can be exceptions here
   if (flags & SectionFlags::BSS)
-    Flags += ",@nobits";
+    Flags += "nobits";
   else
-    Flags += ",@progbits";
+    Flags += "progbits";
 
   if (unsigned entitySize = SectionFlags::getEntitySize(flags))
     Flags += "," + utostr(entitySize);
 
   return Flags;
 }
-