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   // Common settings for all Darwin targets.
  56   // Syntax:
  57   GlobalPrefix = "_";
  58   PrivateGlobalPrefix = "L";
  59   LessPrivateGlobalPrefix = "l";  // Marker for some ObjC metadata
  60   StringConstantPrefix = "\1LC";
  61   NeedsSet = true;
  62   NeedsIndirectEncoding = true;
  63   AllowQuotesInName = true;
  64   HasSingleParameterDotFile = false;
  65
  66   // In non-PIC modes, emit a special label before jump tables so that the
  67   // linker can perform more accurate dead code stripping.  We do not check the
  68   // relocation model here since it can be overridden later.
  69   JumpTableSpecialLabelPrefix = "l";
  70
  71   // Directives:
  72   WeakDefDirective = "\t.weak_definition ";
  73   WeakRefDirective = "\t.weak_reference ";
  74   HiddenDirective = "\t.private_extern ";
  75
  76   // Sections:
  77   CStringSection = "\t.cstring";
  78   JumpTableDataSection = "\t.const\n";
  79   BSSSection = 0;
  80
  81   if (TM.getRelocationModel() == Reloc::Static) {
  82     StaticCtorsSection = ".constructor";
  83     StaticDtorsSection = ".destructor";
  84   } else {
  85     StaticCtorsSection = ".mod_init_func";
  86     StaticDtorsSection = ".mod_term_func";
  87   }
  88
  89   DwarfAbbrevSection = ".section __DWARF,__debug_abbrev,regular,debug";
  90   DwarfInfoSection = ".section __DWARF,__debug_info,regular,debug";
  91   DwarfLineSection = ".section __DWARF,__debug_line,regular,debug";
  92   DwarfFrameSection = ".section __DWARF,__debug_frame,regular,debug";
  93   DwarfPubNamesSection = ".section __DWARF,__debug_pubnames,regular,debug";
  94   DwarfPubTypesSection = ".section __DWARF,__debug_pubtypes,regular,debug";
  95   DwarfStrSection = ".section __DWARF,__debug_str,regular,debug";
  96   DwarfLocSection = ".section __DWARF,__debug_loc,regular,debug";
  97   DwarfARangesSection = ".section __DWARF,__debug_aranges,regular,debug";
  98   DwarfRangesSection = ".section __DWARF,__debug_ranges,regular,debug";
  99   DwarfMacroInfoSection = ".section __DWARF,__debug_macinfo,regular,debug";
 100 }
 101
 102 /// emitUsedDirectiveFor - On Darwin, internally linked data beginning with
 103 /// the PrivateGlobalPrefix or the LessPrivateGlobalPrefix does not have the
 104 /// directive emitted (this occurs in ObjC metadata).
 105
 106 bool
 107 DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
 108                                           Mangler *Mang) const {
 109   if (GV==0)
 110     return false;
 111   if (GV->hasLocalLinkage() && !isa<Function>(GV) &&
 112       ((strlen(getPrivateGlobalPrefix()) != 0 &&
 113         Mang->getValueName(GV).substr(0,strlen(getPrivateGlobalPrefix())) ==
 114           getPrivateGlobalPrefix()) ||
 115        (strlen(getLessPrivateGlobalPrefix()) != 0 &&
 116         Mang->getValueName(GV).substr(0,strlen(getLessPrivateGlobalPrefix())) ==
 117           getLessPrivateGlobalPrefix())))
 118     return false;
 119   return true;
 120 }
 121
 122 const Section*
 123 DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
 124   SectionKind::Kind Kind = SectionKindForGlobal(GV);
 125   bool isWeak = GV->isWeakForLinker();
 126   bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
 127
 128   switch (Kind) {
 129    case SectionKind::Text:
 130     if (isWeak)
 131       return TextCoalSection;
 132     else
 133       return TextSection;
 134    case SectionKind::Data:
 135    case SectionKind::ThreadData:
 136    case SectionKind::BSS:
 137    case SectionKind::ThreadBSS:
 138     if (cast<GlobalVariable>(GV)->isConstant())
 139       return (isWeak ? ConstDataCoalSection : ConstDataSection);
 140     else
 141       return (isWeak ? DataCoalSection : DataSection);
 142    case SectionKind::ROData:
 143     return (isWeak ? ConstDataCoalSection :
 144             (isNonStatic ? ConstDataSection : getReadOnlySection()));
 145    case SectionKind::RODataMergeStr:
 146     return (isWeak ?
 147             ConstTextCoalSection :
 148             MergeableStringSection(cast<GlobalVariable>(GV)));
 149    case SectionKind::RODataMergeConst:
 150     return (isWeak ?
 151             ConstDataCoalSection:
 152             MergeableConstSection(cast<GlobalVariable>(GV)));
 153    default:
 154     assert(0 && "Unsuported section kind for global");
 155   }
 156
 157   // FIXME: Do we have any extra special weird cases?
 158   return NULL;
 159 }
 160
 161 const Section*
 162 DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
 163   const TargetData *TD = TM.getTargetData();
 164   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
 165   const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
 166
 167   unsigned Size = TD->getTypeAllocSize(Ty);
 168   if (Size) {
 169     unsigned Align = TD->getPreferredAlignment(GV);
 170     if (Align <= 32)
 171       return getCStringSection_();
 172   }
 173
 174   return getReadOnlySection();
 175 }
 176
 177 const Section*
 178 DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
 179   Constant *C = GV->getInitializer();
 180
 181   return MergeableConstSection(C->getType());
 182 }
 183
 184 inline const Section*
 185 DarwinTargetAsmInfo::MergeableConstSection(const Type *Ty) const {
 186   const TargetData *TD = TM.getTargetData();
 187
 188   unsigned Size = TD->getTypeAllocSize(Ty);
 189   if (Size == 4)
 190     return FourByteConstantSection;
 191   else if (Size == 8)
 192     return EightByteConstantSection;
 193   else if (Size == 16 && SixteenByteConstantSection)
 194     return SixteenByteConstantSection;
 195
 196   return getReadOnlySection();
 197 }
 198
 199 const Section*
 200 DarwinTargetAsmInfo::SelectSectionForMachineConst(const Type *Ty) const {
 201   const Section* S = MergeableConstSection(Ty);
 202
 203   // Handle weird special case, when compiling PIC stuff.
 204   if (S == getReadOnlySection() &&
 205       TM.getRelocationModel() != Reloc::Static)
 206     return ConstDataSection;
 207
 208   return S;
 209 }
 210
 211 std::string
 212 DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
 213                                                SectionKind::Kind kind) const {
 214   assert(0 && "Darwin does not use unique sections");
 215   return "";
 216 }