lib/Target/DarwinTargetAsmInfo.cpp

   1 //===-- DarwinTargetAsmInfo.cpp - Darwin asm properties ---------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines target asm properties related what form asm statements
  11 // should take in general on Darwin-based targets
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Constants.h"
  16 #include "llvm/DerivedTypes.h"
  17 #include "llvm/Function.h"
  18 #include "llvm/GlobalVariable.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/Support/Mangler.h"
  21 #include "llvm/Target/DarwinTargetAsmInfo.h"
  22 #include "llvm/Target/TargetMachine.h"
  23 #include "llvm/Target/TargetData.h"
  24
  25 using namespace llvm;
  26
  27 DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM)
  28   : TargetAsmInfo(TM) {
  29
  30   CStringSection_ = getUnnamedSection("\t.cstring",
  31                                 SectionFlags::Mergeable | SectionFlags::Strings);
  32   FourByteConstantSection = getUnnamedSection("\t.literal4\n",
  33                                               SectionFlags::Mergeable);
  34   EightByteConstantSection = getUnnamedSection("\t.literal8\n",
  35                                                SectionFlags::Mergeable);
  36
  37   // Note: 16-byte constant section is subtarget specific and should be provided
  38   // there, if needed.
  39   SixteenByteConstantSection = 0;
  40
  41   ReadOnlySection = getUnnamedSection("\t.const\n", SectionFlags::None);
  42
  43   TextCoalSection =
  44     getNamedSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
  45                     SectionFlags::Code);
  46   ConstTextCoalSection = getNamedSection("\t__TEXT,__const_coal,coalesced",
  47                                          SectionFlags::None);
  48   ConstDataCoalSection = getNamedSection("\t__DATA,__const_coal,coalesced",
  49                                          SectionFlags::None);
  50   ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None);
  51   DataCoalSection = getNamedSection("\t__DATA,__datacoal_nt,coalesced",
  52                                     SectionFlags::Writeable);
  53 }
  54
  55 /// emitUsedDirectiveFor - On Darwin, internally linked data beginning with
  56 /// the PrivateGlobalPrefix or the LessPrivateGlobalPrefix does not have the
  57 /// directive emitted (this occurs in ObjC metadata).
  58
  59 bool
  60 DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
  61                                           Mangler *Mang) const {
  62   if (GV==0)
  63     return false;
  64   if (GV->hasLocalLinkage() && !isa<Function>(GV) &&
  65       ((strlen(getPrivateGlobalPrefix()) != 0 &&
  66         Mang->getValueName(GV).substr(0,strlen(getPrivateGlobalPrefix())) ==
  67           getPrivateGlobalPrefix()) ||
  68        (strlen(getLessPrivateGlobalPrefix()) != 0 &&
  69         Mang->getValueName(GV).substr(0,strlen(getLessPrivateGlobalPrefix())) ==
  70           getLessPrivateGlobalPrefix())))
  71     return false;
  72   return true;
  73 }
  74
  75 const Section*
  76 DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
  77   SectionKind::Kind Kind = SectionKindForGlobal(GV);
  78   bool isWeak = GV->isWeakForLinker();
  79   bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
  80
  81   switch (Kind) {
  82    case SectionKind::Text:
  83     if (isWeak)
  84       return TextCoalSection;
  85     else
  86       return TextSection;
  87    case SectionKind::Data:
  88    case SectionKind::DataRel:
  89    case SectionKind::DataRelRO:
  90    case SectionKind::DataRelROLocal:
  91    case SectionKind::ThreadData:
  92    case SectionKind::BSS:
  93    case SectionKind::ThreadBSS:
  94     if (cast<GlobalVariable>(GV)->isConstant())
  95       return (isWeak ? ConstDataCoalSection : ConstDataSection);
  96     else
  97       return (isWeak ? DataCoalSection : DataSection);
  98    case SectionKind::ROData:
  99     return (isWeak ? ConstDataCoalSection :
 100             (isNonStatic ? ConstDataSection : getReadOnlySection()));
 101    case SectionKind::RODataMergeStr:
 102     return (isWeak ?
 103             ConstTextCoalSection :
 104             MergeableStringSection(cast<GlobalVariable>(GV)));
 105    case SectionKind::RODataMergeConst:
 106     return (isWeak ?
 107             ConstDataCoalSection:
 108             MergeableConstSection(cast<GlobalVariable>(GV)));
 109    default:
 110     assert(0 && "Unsuported section kind for global");
 111   }
 112
 113   // FIXME: Do we have any extra special weird cases?
 114   return NULL;
 115 }
 116
 117 const Section*
 118 DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
 119   const TargetData *TD = TM.getTargetData();
 120   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
 121   const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
 122
 123   unsigned Size = TD->getTypePaddedSize(Ty);
 124   if (Size) {
 125     unsigned Align = TD->getPreferredAlignment(GV);
 126     if (Align <= 32)
 127       return getCStringSection_();
 128   }
 129
 130   return getReadOnlySection();
 131 }
 132
 133 const Section*
 134 DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
 135   Constant *C = GV->getInitializer();
 136
 137   return MergeableConstSection(C->getType());
 138 }
 139
 140 inline const Section*
 141 DarwinTargetAsmInfo::MergeableConstSection(const Type *Ty) const {
 142   const TargetData *TD = TM.getTargetData();
 143
 144   unsigned Size = TD->getTypePaddedSize(Ty);
 145   if (Size == 4)
 146     return FourByteConstantSection;
 147   else if (Size == 8)
 148     return EightByteConstantSection;
 149   else if (Size == 16 && SixteenByteConstantSection)
 150     return SixteenByteConstantSection;
 151
 152   return getReadOnlySection();
 153 }
 154
 155 const Section*
 156 DarwinTargetAsmInfo::SelectSectionForMachineConst(const Type *Ty) const {
 157   const Section* S = MergeableConstSection(Ty);
 158
 159   // Handle weird special case, when compiling PIC stuff.
 160   if (S == getReadOnlySection() &&
 161       TM.getRelocationModel() != Reloc::Static)
 162     return ConstDataSection;
 163
 164   return S;
 165 }
 166
 167 std::string
 168 DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
 169                                                SectionKind::Kind kind) const {
 170   assert(0 && "Darwin does not use unique sections");
 171   return "";
 172 }