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