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

   1 //
   2 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   3 // See https://llvm.org/LICENSE.txt for license information.
   4 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "LanaiTargetObjectFile.h"
   9
  10 #include "LanaiSubtarget.h"
  11 #include "LanaiTargetMachine.h"
  12 #include "llvm/BinaryFormat/ELF.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/Target/TargetMachine.h"
  20
  21 using namespace llvm;
  22
  23 static cl::opt<unsigned> SSThreshold(
  24     "lanai-ssection-threshold", cl::Hidden,
  25     cl::desc("Small data and bss section threshold size (default=0)"),
  26     cl::init(0));
  27
  28 void LanaiTargetObjectFile::Initialize(MCContext &Ctx,
  29                                        const TargetMachine &TM) {
  30   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
  31
  32   SmallDataSection = getContext().getELFSection(
  33       ".sdata", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
  34   SmallBSSSection = getContext().getELFSection(".sbss", ELF::SHT_NOBITS,
  35                                                ELF::SHF_WRITE | ELF::SHF_ALLOC);
  36 }
  37
  38 // A address must be loaded from a small section if its size is less than the
  39 // small section size threshold. Data in this section must be addressed using
  40 // gp_rel operator.
  41 static bool isInSmallSection(uint64_t Size) {
  42   // gcc has traditionally not treated zero-sized objects as small data, so this
  43   // is effectively part of the ABI.
  44   return Size > 0 && Size <= SSThreshold;
  45 }
  46
  47 // Return true if this global address should be placed into small data/bss
  48 // section.
  49 bool LanaiTargetObjectFile::isGlobalInSmallSection(
  50     const GlobalObject *GO, const TargetMachine &TM) const {
  51   if (GO == nullptr) return TM.getCodeModel() == CodeModel::Small;
  52
  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 (GO->isDeclaration() || GO->hasAvailableExternallyLinkage())
  57     return isGlobalInSmallSectionImpl(GO, TM);
  58
  59   return isGlobalInSmallSection(GO, TM, getKindForGlobal(GO, TM));
  60 }
  61
  62 // Return true if this global address should be placed into small data/bss
  63 // section.
  64 bool LanaiTargetObjectFile::isGlobalInSmallSection(const GlobalObject *GO,
  65                                                    const TargetMachine &TM,
  66                                                    SectionKind Kind) const {
  67   return isGlobalInSmallSectionImpl(GO, TM);
  68 }
  69
  70 // Return true if this global address should be placed into small data/bss
  71 // section. This method does all the work, except for checking the section
  72 // kind.
  73 bool LanaiTargetObjectFile::isGlobalInSmallSectionImpl(
  74     const GlobalObject *GO, const TargetMachine &TM) const {
  75   const auto *GVA = dyn_cast<GlobalVariable>(GO);
  76
  77   // If not a GlobalVariable, only consider the code model.
  78   if (!GVA) return TM.getCodeModel() == CodeModel::Small;
  79
  80   // Global values placed in sections starting with .ldata do not fit in
  81   // 21-bits, so always use large memory access for them. FIXME: This is a
  82   // workaround for a tool limitation.
  83   if (GVA->getSection().startswith(".ldata"))
  84     return false;
  85
  86   if (TM.getCodeModel() == CodeModel::Small)
  87     return true;
  88
  89   if (GVA->hasLocalLinkage())
  90     return false;
  91
  92   if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||
  93        GVA->hasCommonLinkage()))
  94     return false;
  95
  96   Type *Ty = GVA->getValueType();
  97   return isInSmallSection(
  98       GVA->getParent()->getDataLayout().getTypeAllocSize(Ty));
  99 }
 100
 101 MCSection *LanaiTargetObjectFile::SelectSectionForGlobal(
 102     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
 103   // Handle Small Section classification here.
 104   if (Kind.isBSS() && isGlobalInSmallSection(GO, TM, Kind))
 105     return SmallBSSSection;
 106   if (Kind.isData() && isGlobalInSmallSection(GO, TM, Kind))
 107     return SmallDataSection;
 108
 109   // Otherwise, we work the same as ELF.
 110   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
 111 }
 112
 113 /// Return true if this constant should be placed into small data section.
 114 bool LanaiTargetObjectFile::isConstantInSmallSection(const DataLayout &DL,
 115                                                      const Constant *CN) const {
 116   return isInSmallSection(DL.getTypeAllocSize(CN->getType()));
 117 }
 118
 119 MCSection *LanaiTargetObjectFile::getSectionForConstant(
 120     const DataLayout &DL, SectionKind Kind, const Constant *C,
 121     Align &Alignment) const {
 122   if (isConstantInSmallSection(DL, C))
 123     return SmallDataSection;
 124
 125   // Otherwise, we work the same as ELF.
 126   return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C,
 127                                                             Alignment);
 128 }