LLVM 18.0.0git
RISCVTargetObjectFile.cpp
Go to the documentation of this file.
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
11#include "RISCVTargetMachine.h"
13#include "llvm/MC/MCContext.h"
15
16using namespace llvm;
17
20 *getContext().getSubtargetInfo());
21}
22
24 const TargetMachine &TM) {
26
28
29 SmallDataSection = getContext().getELFSection(
31 SmallBSSSection = getContext().getELFSection(".sbss", ELF::SHT_NOBITS,
33}
34
35// A address must be loaded from a small section if its size is less than the
36// small section size threshold. Data in this section could be addressed by
37// using gp_rel operator.
39 // gcc has traditionally not treated zero-sized objects as small data, so this
40 // is effectively part of the ABI.
41 return Size > 0 && Size <= SSThreshold;
42}
43
44// Return true if this global address should be placed into small data/bss
45// section.
47 const GlobalObject *GO, const TargetMachine &TM) const {
48 // Only global variables, not functions.
49 const GlobalVariable *GVA = dyn_cast<GlobalVariable>(GO);
50 if (!GVA)
51 return false;
52
53 // If the variable has an explicit section, it is placed in that section.
54 if (GVA->hasSection()) {
55 StringRef Section = GVA->getSection();
56
57 // Explicitly placing any variable in the small data section overrides
58 // the global -G value.
59 if (Section == ".sdata" || Section == ".sbss")
60 return true;
61
62 // Otherwise reject putting the variable to small section if it has an
63 // explicit section name.
64 return false;
65 }
66
67 if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||
68 GVA->hasCommonLinkage()))
69 return false;
70
71 Type *Ty = GVA->getValueType();
72 // It is possible that the type of the global is unsized, i.e. a declaration
73 // of a extern struct. In this case don't presume it is in the small data
74 // section. This happens e.g. when building the FreeBSD kernel.
75 if (!Ty->isSized())
76 return false;
77
78 return isInSmallSection(
80}
81
83 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
84 // Handle Small Section classification here.
85 if (Kind.isBSS() && isGlobalInSmallSection(GO, TM))
86 return SmallBSSSection;
87 if (Kind.isData() && isGlobalInSmallSection(GO, TM))
88 return SmallDataSection;
89
90 // Otherwise, we work the same as ELF.
92}
93
97 M.getModuleFlagsMetadata(ModuleFlags);
98
99 for (const auto &MFE : ModuleFlags) {
100 StringRef Key = MFE.Key->getString();
101 if (Key == "SmallDataLimit") {
102 SSThreshold = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
103 break;
104 }
105 }
106}
107
108/// Return true if this constant should be placed into small data section.
110 const DataLayout &DL, const Constant *CN) const {
111 return isInSmallSection(DL.getTypeAllocSize(CN->getType()));
112}
113
115 const DataLayout &DL, SectionKind Kind, const Constant *C,
116 Align &Alignment) const {
118 return SmallDataSection;
119
120 // Otherwise, we work the same as ELF.
122 Alignment);
123}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
uint64_t Size
const char LLVMTargetMachineRef TM
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:504
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:117
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:109
bool hasExternalLinkage() const
Definition: GlobalValue.h:506
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:273
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
bool hasCommonLinkage() const
Definition: GlobalValue.h:527
Type * getValueType() const
Definition: GlobalValue.h:292
Context object for machine code objects.
Definition: MCContext.h:76
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:565
MCContext & getContext() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:254
bool isGlobalInSmallSection(const GlobalObject *GO, const TargetMachine &TM) const
Return true if this global address should be placed into small data/bss section.
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
void getModuleMetadata(Module &M) override
Get the module-level metadata that the platform cares about.
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const override
Given a constant with the SectionKind, return a section that it should be placed in.
bool isInSmallSection(uint64_t Size) const
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
unsigned getTextSectionAlignment() const override
bool isConstantInSmallSection(const DataLayout &DL, const Constant *CN) const
Return true if this constant should be placed into small data section.
unsigned getTextSectionAlignment() const override
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
void Initialize(MCContext &Ctx, const TargetMachine &TM) override
This method must be called before any actual lowering is done.
MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const override
Given a constant with the SectionKind, return a section that it should be placed in.
void getModuleMetadata(Module &M) override
Get the module-level metadata that the platform cares about.
MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override
MCSymbolRefExpr::VariantKind PLTRelativeVariantKind
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:302
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ SHT_PROGBITS
Definition: ELF.h:1000
@ SHT_NOBITS
Definition: ELF.h:1007
@ SHF_ALLOC
Definition: ELF.h:1089
@ SHF_WRITE
Definition: ELF.h:1086
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39