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/ErrorHandling.h"
  21 #include "llvm/Support/Mangler.h"
  22 #include "llvm/Target/DarwinTargetAsmInfo.h"
  23 #include "llvm/Target/TargetMachine.h"
  24 #include "llvm/Target/TargetData.h"
  25
  26 using namespace llvm;
  27
  28 DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM)
  29   : TargetAsmInfo(TM) {
  30
  31   CStringSection_ = getUnnamedSection("\t.cstring",
  32                                 SectionFlags::Mergeable |SectionFlags::Strings);
  33   FourByteConstantSection = getUnnamedSection("\t.literal4\n",
  34                                               SectionFlags::Mergeable);
  35   EightByteConstantSection = getUnnamedSection("\t.literal8\n",
  36                                                SectionFlags::Mergeable);
  37
  38   // Note: 16-byte constant section is subtarget specific and should be provided
  39   // there, if needed.
  40   SixteenByteConstantSection = 0;
  41
  42   ReadOnlySection = getUnnamedSection("\t.const\n", SectionFlags::None);
  43
  44   TextCoalSection =
  45     getNamedSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
  46                     SectionFlags::Code);
  47   ConstTextCoalSection = getNamedSection("\t__TEXT,__const_coal,coalesced",
  48                                          SectionFlags::None);
  49   ConstDataCoalSection = getNamedSection("\t__DATA,__const_coal,coalesced",
  50                                          SectionFlags::None);
  51   ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None);
  52   DataCoalSection = getNamedSection("\t__DATA,__datacoal_nt,coalesced",
  53                                     SectionFlags::Writable);
  54
  55
  56   // Common settings for all Darwin targets.
  57   // Syntax:
  58   GlobalPrefix = "_";
  59   PrivateGlobalPrefix = "L";
  60   LinkerPrivateGlobalPrefix = "l";  // Marker for some ObjC metadata
  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   // _foo.eh symbols are currently always exported so that the linker knows
  90   // about them.  This may not strictly be necessary on 10.6 and later, but it
  91   // doesn't hurt anything.
  92   Is_EHSymbolPrivate = false;
  93
  94   DwarfAbbrevSection = ".section __DWARF,__debug_abbrev,regular,debug";
  95   DwarfInfoSection = ".section __DWARF,__debug_info,regular,debug";
  96   DwarfLineSection = ".section __DWARF,__debug_line,regular,debug";
  97   DwarfFrameSection = ".section __DWARF,__debug_frame,regular,debug";
  98   DwarfPubNamesSection = ".section __DWARF,__debug_pubnames,regular,debug";
  99   DwarfPubTypesSection = ".section __DWARF,__debug_pubtypes,regular,debug";
 100   DwarfStrSection = ".section __DWARF,__debug_str,regular,debug";
 101   DwarfLocSection = ".section __DWARF,__debug_loc,regular,debug";
 102   DwarfARangesSection = ".section __DWARF,__debug_aranges,regular,debug";
 103   DwarfRangesSection = ".section __DWARF,__debug_ranges,regular,debug";
 104   DwarfMacroInfoSection = ".section __DWARF,__debug_macinfo,regular,debug";
 105 }
 106
 107 /// emitUsedDirectiveFor - On Darwin, internally linked data beginning with
 108 /// the PrivateGlobalPrefix or the LinkerPrivateGlobalPrefix does not have the
 109 /// directive emitted (this occurs in ObjC metadata).
 110 bool DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
 111                                                Mangler *Mang) const {
 112   if (!GV) return false;
 113
 114   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
 115   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
 116     // FIXME: ObjC metadata is currently emitted as internal symbols that have
 117     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
 118     // this horrible hack can go away.
 119     const std::string &Name = Mang->getMangledName(GV);
 120     if (Name[0] == 'L' || Name[0] == 'l')
 121       return false;
 122   }
 123
 124   return true;
 125 }
 126
 127 const Section*
 128 DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV,
 129                                             SectionKind Kind) const {
 130   assert(!Kind.isTLS() && "Darwin doesn't support TLS");
 131
 132   // FIXME: Use sectionflags:linkonce instead of isWeakForLinker() here.
 133   bool isWeak = GV->isWeakForLinker();
 134   bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
 135
 136   if (Kind.isCode())
 137     return isWeak ? TextCoalSection : TextSection;
 138
 139   // If this is weak/linkonce, put this in a coalescable section, either in text
 140   // or data depending on if it is writable.
 141   if (isWeak) {
 142     if (Kind.isReadOnly())
 143       return ConstTextCoalSection;
 144     return DataCoalSection;
 145   }
 146
 147   // FIXME: Alignment check should be handled by section classifier.
 148   if (Kind.isMergableString())
 149     return MergeableStringSection(cast<GlobalVariable>(GV));
 150
 151   switch (Kind.getKind()) {
 152   case SectionKind::Data:
 153   case SectionKind::DataRelLocal:
 154   case SectionKind::DataRel:
 155   case SectionKind::BSS:
 156     if (cast<GlobalVariable>(GV)->isConstant())
 157       return ConstDataSection;
 158     return DataSection;
 159
 160   case SectionKind::ROData:
 161   case SectionKind::DataRelRO:
 162   case SectionKind::DataRelROLocal:
 163     return isNonStatic ? ConstDataSection : getReadOnlySection();
 164   case SectionKind::RODataMergeConst: {
 165     const Type *Ty = cast<GlobalVariable>(GV)->getInitializer()->getType();
 166     const TargetData *TD = TM.getTargetData();
 167     return getSectionForMergableConstant(TD->getTypeAllocSize(Ty), 0);
 168   }
 169   default:
 170     llvm_unreachable("Unsuported section kind for global");
 171   }
 172
 173   // FIXME: Do we have any extra special weird cases?
 174   return NULL;
 175 }
 176
 177 const Section*
 178 DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
 179   const TargetData *TD = TM.getTargetData();
 180   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
 181   const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
 182
 183   unsigned Size = TD->getTypeAllocSize(Ty);
 184   if (Size) {
 185     unsigned Align = TD->getPreferredAlignment(GV);
 186     if (Align <= 32)
 187       return getCStringSection_();
 188   }
 189
 190   return getReadOnlySection();
 191 }
 192
 193 const Section *
 194 DarwinTargetAsmInfo::getSectionForMergableConstant(uint64_t Size,
 195                                                    unsigned ReloInfo) const {
 196   // If this constant requires a relocation, we have to put it in the data
 197   // segment, not in the text segment.
 198   if (ReloInfo != 0)
 199     return ConstDataSection;
 200
 201   switch (Size) {
 202   default: break;
 203   case 4:
 204     return FourByteConstantSection;
 205   case 8:
 206     return EightByteConstantSection;
 207   case 16:
 208     if (SixteenByteConstantSection)
 209       return SixteenByteConstantSection;
 210     break;
 211   }
 212
 213   return ReadOnlySection;  // .const
 214 }
 215