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/Target/DarwinTargetAsmInfo.h"
  21 #include "llvm/Target/TargetMachine.h"
  22 #include "llvm/Target/TargetData.h"
  23
  24 using namespace llvm;
  25
  26 DarwinTargetAsmInfo::DarwinTargetAsmInfo(const TargetMachine &TM) {
  27   DTM = &TM;
  28
  29   CStringSection_ = getUnnamedSection("\t.cstring",
  30                                 SectionFlags::Mergeable | SectionFlags::Strings);
  31   FourByteConstantSection_ = getUnnamedSection("\t.literal4\n",
  32                                                SectionFlags::Mergeable);
  33   EightByteConstantSection_ = getUnnamedSection("\t.literal8\n",
  34                                                 SectionFlags::Mergeable);
  35   // Note: 16-byte constant section is subtarget specific and should be provided
  36   // there.
  37
  38   ReadOnlySection_ = getUnnamedSection("\t.const\n", SectionFlags::None);
  39
  40   // FIXME: These should be named sections, really.
  41   TextCoalSection =
  42   getUnnamedSection(".section __TEXT,__textcoal_nt,coalesced,pure_instructions",
  43                     SectionFlags::Code);
  44   ConstDataCoalSection =
  45     getUnnamedSection(".section __DATA,__const_coal,coalesced",
  46                       SectionFlags::None);
  47   ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None);
  48   DataCoalSection = getUnnamedSection(".section __DATA,__datacoal_nt,coalesced",
  49                                       SectionFlags::Writeable);
  50 }
  51
  52 const Section*
  53 DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const {
  54   SectionKind::Kind Kind = SectionKindForGlobal(GV);
  55   bool isWeak = GV->isWeakForLinker();
  56   bool isNonStatic = (DTM->getRelocationModel() != Reloc::Static);
  57
  58   switch (Kind) {
  59    case SectionKind::Text:
  60     if (isWeak)
  61       return TextCoalSection;
  62     else
  63       return getTextSection_();
  64    case SectionKind::Data:
  65    case SectionKind::ThreadData:
  66    case SectionKind::BSS:
  67    case SectionKind::ThreadBSS:
  68     if (cast<GlobalVariable>(GV)->isConstant())
  69       return (isWeak ? ConstDataCoalSection : ConstDataSection);
  70     else
  71       return (isWeak ? DataCoalSection : getDataSection_());
  72    case SectionKind::ROData:
  73     return (isWeak ? ConstDataCoalSection :
  74             (isNonStatic ? ConstDataSection : getReadOnlySection_()));
  75    case SectionKind::RODataMergeStr:
  76     return (isWeak ?
  77             ConstDataCoalSection :
  78             MergeableStringSection(cast<GlobalVariable>(GV)));
  79    case SectionKind::RODataMergeConst:
  80     return (isWeak ?
  81             ConstDataCoalSection:
  82             MergeableConstSection(cast<GlobalVariable>(GV)));
  83    default:
  84     assert(0 && "Unsuported section kind for global");
  85   }
  86
  87   // FIXME: Do we have any extra special weird cases?
  88 }
  89
  90 const Section*
  91 DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
  92   const TargetData *TD = DTM->getTargetData();
  93   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
  94   const Type *Type = cast<ConstantArray>(C)->getType()->getElementType();
  95
  96   unsigned Size = TD->getABITypeSize(Type);
  97   if (Size) {
  98     const TargetData *TD = DTM->getTargetData();
  99     unsigned Align = TD->getPreferredAlignment(GV);
 100     if (Align <= 32)
 101       return getCStringSection_();
 102   }
 103
 104   return getReadOnlySection_();
 105 }
 106
 107 const Section*
 108 DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const {
 109   const TargetData *TD = DTM->getTargetData();
 110   Constant *C = cast<GlobalVariable>(GV)->getInitializer();
 111
 112   unsigned Size = TD->getABITypeSize(C->getType());
 113   if (Size == 4)
 114     return FourByteConstantSection_;
 115   else if (Size == 8)
 116     return EightByteConstantSection_;
 117   else if (Size == 16 && SixteenByteConstantSection_)
 118     return SixteenByteConstantSection_;
 119
 120   return getReadOnlySection_();
 121 }
 122
 123 std::string
 124 DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV,
 125                                                SectionKind::Kind kind) const {
 126   assert(0 && "Darwin does not use unique sections");
 127   return "";
 128 }