1//===-- RISCVTargetObjectFile.cpp - RISC-V 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 "MCTargetDesc/RISCVMCObjectFileInfo.h"
11#include "RISCVTargetMachine.h"
12#include "llvm/BinaryFormat/ELF.h"
13#include "llvm/MC/MCContext.h"
14#include "llvm/MC/MCSectionELF.h"
15#include "llvm/MC/MCValue.h"
16
17using namespace llvm;
18
19unsigned RISCVELFTargetObjectFile::getTextSectionAlignment() const {
20 return RISCVMCObjectFileInfo::getTextSectionAlignment(
21 STI: *getContext().getSubtargetInfo());
22}
23
24void RISCVELFTargetObjectFile::Initialize(MCContext &Ctx,
25 const TargetMachine &TM) {
26 TargetLoweringObjectFileELF::Initialize(Ctx, TM);
27
28 PLTRelativeVariantKind = MCSymbolRefExpr::VK_PLT;
29 SupportIndirectSymViaGOTPCRel = true;
30
31 SmallDataSection = getContext().getELFSection(
32 Section: ".sdata", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_WRITE | ELF::SHF_ALLOC);
33 SmallBSSSection = getContext().getELFSection(Section: ".sbss", Type: ELF::SHT_NOBITS,
34 Flags: ELF::SHF_WRITE | ELF::SHF_ALLOC);
35 SmallRODataSection =
36 getContext().getELFSection(Section: ".srodata", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC);
37 SmallROData4Section = getContext().getELFSection(
38 Section: ".srodata.cst4", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC | ELF::SHF_MERGE, EntrySize: 4);
39 SmallROData8Section = getContext().getELFSection(
40 Section: ".srodata.cst8", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC | ELF::SHF_MERGE, EntrySize: 8);
41 SmallROData16Section = getContext().getELFSection(
42 Section: ".srodata.cst16", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC | ELF::SHF_MERGE, EntrySize: 16);
43 SmallROData32Section = getContext().getELFSection(
44 Section: ".srodata.cst32", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_ALLOC | ELF::SHF_MERGE, EntrySize: 32);
45}
46
47const MCExpr *RISCVELFTargetObjectFile::getIndirectSymViaGOTPCRel(
48 const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV,
49 int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
50 int64_t FinalOffset = Offset + MV.getConstant();
51 const MCExpr *Res =
52 MCSymbolRefExpr::create(Symbol: Sym, Kind: MCSymbolRefExpr::VK_GOTPCREL, Ctx&: getContext());
53 const MCExpr *Off = MCConstantExpr::create(Value: FinalOffset, Ctx&: getContext());
54 return MCBinaryExpr::createAdd(LHS: Res, RHS: Off, Ctx&: getContext());
55}
56
57// A address must be loaded from a small section if its size is less than the
58// small section size threshold. Data in this section could be addressed by
59// using gp_rel operator.
60bool RISCVELFTargetObjectFile::isInSmallSection(uint64_t Size) const {
61 // gcc has traditionally not treated zero-sized objects as small data, so this
62 // is effectively part of the ABI.
63 return Size > 0 && Size <= SSThreshold;
64}
65
66// Return true if this global address should be placed into small data/bss
67// section.
68bool RISCVELFTargetObjectFile::isGlobalInSmallSection(
69 const GlobalObject *GO, const TargetMachine &TM) const {
70 // Only global variables, not functions.
71 const GlobalVariable *GVA = dyn_cast<GlobalVariable>(Val: GO);
72 if (!GVA)
73 return false;
74
75 // If the variable has an explicit section, it is placed in that section.
76 if (GVA->hasSection()) {
77 StringRef Section = GVA->getSection();
78
79 // Explicitly placing any variable in the small data section overrides
80 // the global -G value.
81 if (Section == ".sdata" || Section == ".sbss")
82 return true;
83
84 // Otherwise reject putting the variable to small section if it has an
85 // explicit section name.
86 return false;
87 }
88
89 if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||
90 GVA->hasCommonLinkage()))
91 return false;
92
93 Type *Ty = GVA->getValueType();
94 // It is possible that the type of the global is unsized, i.e. a declaration
95 // of a extern struct. In this case don't presume it is in the small data
96 // section. This happens e.g. when building the FreeBSD kernel.
97 if (!Ty->isSized())
98 return false;
99
100 return isInSmallSection(
101 Size: GVA->getParent()->getDataLayout().getTypeAllocSize(Ty));
102}
103
104MCSection *RISCVELFTargetObjectFile::SelectSectionForGlobal(
105 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
106 // Handle Small Section classification here.
107 if (Kind.isBSS() && isGlobalInSmallSection(GO, TM))
108 return SmallBSSSection;
109 if (Kind.isData() && isGlobalInSmallSection(GO, TM))
110 return SmallDataSection;
111
112 // Otherwise, we work the same as ELF.
113 return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);
114}
115
116void RISCVELFTargetObjectFile::getModuleMetadata(Module &M) {
117 TargetLoweringObjectFileELF::getModuleMetadata(M);
118 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
119 M.getModuleFlagsMetadata(Flags&: ModuleFlags);
120
121 for (const auto &MFE : ModuleFlags) {
122 StringRef Key = MFE.Key->getString();
123 if (Key == "SmallDataLimit") {
124 SSThreshold = mdconst::extract<ConstantInt>(MD: MFE.Val)->getZExtValue();
125 break;
126 }
127 }
128}
129
130/// Return true if this constant should be placed into small data section.
131bool RISCVELFTargetObjectFile::isConstantInSmallSection(
132 const DataLayout &DL, const Constant *CN) const {
133 return isInSmallSection(Size: DL.getTypeAllocSize(Ty: CN->getType()));
134}
135
136MCSection *RISCVELFTargetObjectFile::getSectionForConstant(
137 const DataLayout &DL, SectionKind Kind, const Constant *C,
138 Align &Alignment) const {
139 if (isConstantInSmallSection(DL, CN: C)) {
140 if (Kind.isMergeableConst4())
141 return SmallROData4Section;
142 if (Kind.isMergeableConst8())
143 return SmallROData8Section;
144 if (Kind.isMergeableConst16())
145 return SmallROData16Section;
146 if (Kind.isMergeableConst32())
147 return SmallROData32Section;
148 // LLVM only generate up to .rodata.cst32, and use .rodata section if more
149 // than 32 bytes, so just use .srodata here.
150 return SmallRODataSection;
151 }
152
153 // Otherwise, we work the same as ELF.
154 return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C,
155 Alignment);
156}
157

source code of llvm/lib/Target/RISCV/RISCVTargetObjectFile.cpp