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