contrib/llvm/lib/Target/Lanai/LanaiTargetObjectFile.cpp

   1 //
   2 //                     The LLVM Compiler Infrastructure
   3 //
   4 // This file is distributed under the University of Illinois Open Source
   5 // License. See LICENSE.TXT for details.
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "LanaiTargetObjectFile.h"
  10
  11 #include "LanaiSubtarget.h"
  12 #include "LanaiTargetMachine.h"
  13 #include "llvm/IR/DataLayout.h"
  14 #include "llvm/IR/DerivedTypes.h"
  15 #include "llvm/IR/GlobalVariable.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCSectionELF.h"
  18 #include "llvm/Support/CommandLine.h"
  19 #include "llvm/Support/ELF.h"
  20 #include "llvm/Target/TargetMachine.h"
  21
  22 using namespace llvm;
  23
  24 static cl::opt<unsigned> SSThreshold(
  25     "lanai-ssection-threshold", cl::Hidden,
  26     cl::desc("Small data and bss section threshold size (default=0)"),
  27     cl::init(0));
  28
  29 void LanaiTargetObjectFile::Initialize(MCContext &Ctx,
  30                                        const TargetMachine &TM) {
  31   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
  32   InitializeELF(TM.Options.UseInitArray);
  33
  34   SmallDataSection = getContext().getELFSection(
  35       ".sdata", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
  36   SmallBSSSection = getContext().getELFSection(".sbss", ELF::SHT_NOBITS,
  37                                                ELF::SHF_WRITE | ELF::SHF_ALLOC);
  38 }
  39
  40 // A address must be loaded from a small section if its size is less than the
  41 // small section size threshold. Data in this section must be addressed using
  42 // gp_rel operator.
  43 static bool isInSmallSection(uint64_t Size) {
  44   // gcc has traditionally not treated zero-sized objects as small data, so this
  45   // is effectively part of the ABI.
  46   return Size > 0 && Size <= SSThreshold;
  47 }
  48
  49 // Return true if this global address should be placed into small data/bss
  50 // section.
  51 bool LanaiTargetObjectFile::isGlobalInSmallSection(
  52     const GlobalValue *GV, const TargetMachine &TM) const {
  53   // We first check the case where global is a declaration, because finding
  54   // section kind using getKindForGlobal() is only allowed for global
  55   // definitions.
  56   if (GV->isDeclaration() || GV->hasAvailableExternallyLinkage())
  57     return isGlobalInSmallSectionImpl(GV, TM);
  58
  59   return isGlobalInSmallSection(GV, TM, getKindForGlobal(GV, TM));
  60 }
  61
  62 // Return true if this global address should be placed into small data/bss
  63 // section.
  64 bool LanaiTargetObjectFile::isGlobalInSmallSection(const GlobalValue *GV,
  65                                                    const TargetMachine &TM,
  66                                                    SectionKind Kind) const {
  67   return (isGlobalInSmallSectionImpl(GV, TM) &&
  68           (Kind.isData() || Kind.isBSS() || Kind.isCommon()));
  69 }
  70
  71 // Return true if this global address should be placed into small data/bss
  72 // section. This method does all the work, except for checking the section
  73 // kind.
  74 bool LanaiTargetObjectFile::isGlobalInSmallSectionImpl(
  75     const GlobalValue *GV, const TargetMachine & /*TM*/) const {
  76   // Only global variables, not functions.
  77   const GlobalVariable *GVA = dyn_cast<GlobalVariable>(GV);
  78   if (!GVA)
  79     return false;
  80
  81   if (GV->hasLocalLinkage())
  82     return false;
  83
  84   if (((GV->hasExternalLinkage() && GV->isDeclaration()) ||
  85        GV->hasCommonLinkage()))
  86     return false;
  87
  88   Type *Ty = GV->getType()->getElementType();
  89   return isInSmallSection(
  90       GV->getParent()->getDataLayout().getTypeAllocSize(Ty));
  91 }
  92
  93 MCSection *
  94 LanaiTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
  95                                               SectionKind Kind, Mangler &Mang,
  96                                               const TargetMachine &TM) const {
  97   // Handle Small Section classification here.
  98   if (Kind.isBSS() && isGlobalInSmallSection(GV, TM, Kind))
  99     return SmallBSSSection;
 100   if (Kind.isData() && isGlobalInSmallSection(GV, TM, Kind))
 101     return SmallDataSection;
 102
 103   // Otherwise, we work the same as ELF.
 104   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang,
 105                                                              TM);
 106 }
 107
 108 /// Return true if this constant should be placed into small data section.
 109 bool LanaiTargetObjectFile::isConstantInSmallSection(const DataLayout &DL,
 110                                                      const Constant *CN) const {
 111   return isInSmallSection(DL.getTypeAllocSize(CN->getType()));
 112 }
 113
 114 MCSection *LanaiTargetObjectFile::getSectionForConstant(const DataLayout &DL,
 115                                                         SectionKind Kind,
 116                                                         const Constant *C,
 117                                                         unsigned &Align) const {
 118   if (isConstantInSmallSection(DL, C))
 119     return SmallDataSection;
 120
 121   // Otherwise, we work the same as ELF.
 122   return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C, Align);
 123 }