lib/Target/RISCV/RISCVTargetObjectFile.cpp

   1 //===-- RISCVTargetObjectFile.cpp - RISCV Object Info -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "RISCVTargetObjectFile.h"
  10 #include "RISCVTargetMachine.h"
  11 #include "llvm/BinaryFormat/ELF.h"
  12 #include "llvm/MC/MCContext.h"
  13 #include "llvm/MC/MCSectionELF.h"
  14
  15 using namespace llvm;
  16
  17 void RISCVELFTargetObjectFile::Initialize(MCContext &Ctx,
  18                                           const TargetMachine &TM) {
  19   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
  20   InitializeELF(TM.Options.UseInitArray);
  21
  22   SmallDataSection = getContext().getELFSection(
  23       ".sdata", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
  24   SmallBSSSection = getContext().getELFSection(".sbss", ELF::SHT_NOBITS,
  25                                                ELF::SHF_WRITE | ELF::SHF_ALLOC);
  26 }
  27
  28 // A address must be loaded from a small section if its size is less than the
  29 // small section size threshold. Data in this section could be addressed by
  30 // using gp_rel operator.
  31 bool RISCVELFTargetObjectFile::isInSmallSection(uint64_t Size) const {
  32   // gcc has traditionally not treated zero-sized objects as small data, so this
  33   // is effectively part of the ABI.
  34   return Size > 0 && Size <= SSThreshold;
  35 }
  36
  37 // Return true if this global address should be placed into small data/bss
  38 // section.
  39 bool RISCVELFTargetObjectFile::isGlobalInSmallSection(
  40     const GlobalObject *GO, const TargetMachine &TM) const {
  41   // Only global variables, not functions.
  42   const GlobalVariable *GVA = dyn_cast<GlobalVariable>(GO);
  43   if (!GVA)
  44     return false;
  45
  46   // If the variable has an explicit section, it is placed in that section.
  47   if (GVA->hasSection()) {
  48     StringRef Section = GVA->getSection();
  49
  50     // Explicitly placing any variable in the small data section overrides
  51     // the global -G value.
  52     if (Section == ".sdata" || Section == ".sbss")
  53       return true;
  54
  55     // Otherwise reject putting the variable to small section if it has an
  56     // explicit section name.
  57     return false;
  58   }
  59
  60   if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||
  61        GVA->hasCommonLinkage()))
  62     return false;
  63
  64   Type *Ty = GVA->getValueType();
  65   // It is possible that the type of the global is unsized, i.e. a declaration
  66   // of a extern struct. In this case don't presume it is in the small data
  67   // section. This happens e.g. when building the FreeBSD kernel.
  68   if (!Ty->isSized())
  69     return false;
  70
  71   return isInSmallSection(
  72       GVA->getParent()->getDataLayout().getTypeAllocSize(Ty));
  73 }
  74
  75 MCSection *RISCVELFTargetObjectFile::SelectSectionForGlobal(
  76     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
  77   // Handle Small Section classification here.
  78   if (Kind.isBSS() && isGlobalInSmallSection(GO, TM))
  79     return SmallBSSSection;
  80   if (Kind.isData() && isGlobalInSmallSection(GO, TM))
  81     return SmallDataSection;
  82
  83   // Otherwise, we work the same as ELF.
  84   return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
  85 }
  86
  87 void RISCVELFTargetObjectFile::getModuleMetadata(Module &M) {
  88   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
  89   M.getModuleFlagsMetadata(ModuleFlags);
  90
  91   for (const auto &MFE : ModuleFlags) {
  92     StringRef Key = MFE.Key->getString();
  93     if (Key == "SmallDataLimit") {
  94       SSThreshold = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
  95       break;
  96     }
  97   }
  98 }
  99
 100 /// Return true if this constant should be placed into small data section.
 101 bool RISCVELFTargetObjectFile::isConstantInSmallSection(
 102     const DataLayout &DL, const Constant *CN) const {
 103   return isInSmallSection(DL.getTypeAllocSize(CN->getType()));
 104 }
 105
 106 MCSection *RISCVELFTargetObjectFile::getSectionForConstant(
 107     const DataLayout &DL, SectionKind Kind, const Constant *C,
 108     unsigned &Align) const {
 109   if (isConstantInSmallSection(DL, C))
 110     return SmallDataSection;
 111
 112   // Otherwise, we work the same as ELF.
 113   return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C, Align);
 114 }