LanaiTargetObjectFile.cpp

Go to the documentation of this file.

1//

2// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

3// See https://llvm.org/LICENSE.txt for license information.

4// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

5//

6//===----------------------------------------------------------------------===//

7

8#include "LanaiTargetObjectFile.h"

9

10#include "llvm/BinaryFormat/ELF.h"

11#include "llvm/IR/DataLayout.h"

12#include "llvm/IR/GlobalVariable.h"

13#include "llvm/MC/MCContext.h"

14#include "llvm/MC/MCSectionELF.h"

15#include "llvm/Support/CommandLine.h"

16#include "llvm/Target/TargetMachine.h"

17

18using namespace llvm;

19

20 static cl::opt<unsigned> SSThreshold(

21 "lanai-ssection-threshold", cl::Hidden,

22 cl::desc("Small data and bss section threshold size (default=0)"),

23 cl::init(0));

24

25 void LanaiTargetObjectFile::Initialize(MCContext &Ctx,

26 const TargetMachine &TM) {

27 TargetLoweringObjectFileELF::Initialize(Ctx, TM);

28

29 SmallDataSection = getContext().getELFSection(

30 ".sdata", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);

31 SmallBSSSection = getContext().getELFSection(".sbss", ELF::SHT_NOBITS,

32 ELF::SHF_WRITE | ELF::SHF_ALLOC);

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 must be addressed using

37// gp_rel operator.

38 static bool isInSmallSection(uint64_t Size) {

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.

46 bool LanaiTargetObjectFile::isGlobalInSmallSection(

47 const GlobalObject *GO, const TargetMachine &TM) const {

48 if (GO == nullptr) return TM.getCodeModel() == CodeModel::Small;

49

50 // We first check the case where global is a declaration, because finding

51 // section kind using getKindForGlobal() is only allowed for global

52 // definitions.

53 if (GO->isDeclaration() || GO->hasAvailableExternallyLinkage())

54 return isGlobalInSmallSectionImpl(GO, TM);

55

56 return isGlobalInSmallSection(GO, TM, getKindForGlobal(GO, TM));

57}

58

59// Return true if this global address should be placed into small data/bss

60// section.

61bool LanaiTargetObjectFile::isGlobalInSmallSection(const GlobalObject *GO,

62 const TargetMachine &TM,

63 SectionKind Kind) const {

64 return isGlobalInSmallSectionImpl(GO, TM);

65}

66

67// Return true if this global address should be placed into small data/bss

68// section. This method does all the work, except for checking the section

69// kind.

70bool LanaiTargetObjectFile::isGlobalInSmallSectionImpl(

71 const GlobalObject *GO, const TargetMachine &TM) const {

72 const auto *GVA = dyn_cast<GlobalVariable>(GO);

73

74 // If not a GlobalVariable, only consider the code model.

75 if (!GVA) return TM.getCodeModel() == CodeModel::Small;

76

77 // Global values placed in sections starting with .ldata do not fit in

78 // 21-bits, so always use large memory access for them. FIXME: This is a

79 // workaround for a tool limitation.

80 if (GVA->getSection().starts_with(".ldata"))

81 return false;

82

83 if (TM.getCodeModel() == CodeModel::Small)

84 return true;

85

86 if (GVA->hasLocalLinkage())

87 return false;

88

89 if (((GVA->hasExternalLinkage() && GVA->isDeclaration()) ||

90 GVA->hasCommonLinkage()))

91 return false;

92

93 Type *Ty = GVA->getValueType();

94 return isInSmallSection(

95 GVA->getDataLayout().getTypeAllocSize(Ty));

96}

97

98 MCSection *LanaiTargetObjectFile::SelectSectionForGlobal(

99 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {

100 // Handle Small Section classification here.

101 if (Kind.isBSS() && isGlobalInSmallSection(GO, TM, Kind))

102 return SmallBSSSection;

103 if (Kind.isData() && isGlobalInSmallSection(GO, TM, Kind))

104 return SmallDataSection;

105

106 // Otherwise, we work the same as ELF.

107 return TargetLoweringObjectFileELF::SelectSectionForGlobal(GO, Kind, TM);

108}

109

110/// Return true if this constant should be placed into small data section.

111 bool LanaiTargetObjectFile::isConstantInSmallSection(const DataLayout &DL,

112 const Constant *CN) const {

113 return isInSmallSection(DL.getTypeAllocSize(CN->getType()));

114}

115

116 MCSection *LanaiTargetObjectFile::getSectionForConstant(

117 const DataLayout &DL, SectionKind Kind, const Constant *C,

118 Align &Alignment) const {

119 if (isConstantInSmallSection(DL, C))

120 return SmallDataSection;

121

122 // Otherwise, we work the same as ELF.

123 return TargetLoweringObjectFileELF::getSectionForConstant(DL, Kind, C,

124 Alignment);

125}

DL

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Definition ARMSLSHardening.cpp:73

InlinePriorityMode::Size

@ Size

Definition InlineOrder.cpp:25

SSThreshold

static cl::opt< unsigned > SSThreshold("lanai-ssection-threshold", cl::Hidden, cl::desc("Small data and bss section threshold size (default=0)"), cl::init(0))

isInSmallSection

static bool isInSmallSection(uint64_t Size)

Definition LanaiTargetObjectFile.cpp:38

LanaiTargetObjectFile.h

MCContext.h

MCSectionELF.h

llvm::Constant

This is an important base class in LLVM.

Definition Constant.h:43

llvm::DataLayout

A parsed version of the target data layout string in and methods for querying it.

Definition DataLayout.h:63

llvm::GlobalObject

Definition GlobalObject.h:28

llvm::GlobalValue::isDeclaration

LLVM_ABI bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

Definition Globals.cpp:328

llvm::GlobalValue::hasAvailableExternallyLinkage

bool hasAvailableExternallyLinkage() const

Definition GlobalValue.h:514

llvm::LanaiTargetObjectFile::getSectionForConstant

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.

Definition LanaiTargetObjectFile.cpp:116

llvm::LanaiTargetObjectFile::Initialize

void Initialize(MCContext &Ctx, const TargetMachine &TM) override

This method must be called before any actual lowering is done.

Definition LanaiTargetObjectFile.cpp:25

llvm::LanaiTargetObjectFile::SelectSectionForGlobal

MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override

Definition LanaiTargetObjectFile.cpp:98

llvm::LanaiTargetObjectFile::isConstantInSmallSection

bool isConstantInSmallSection(const DataLayout &DL, const Constant *CN) const

Return true if this constant should be placed into small data section.

Definition LanaiTargetObjectFile.cpp:111

llvm::MCContext

Context object for machine code objects.

Definition MCContext.h:83

llvm::MCContext::getELFSection

MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)

Definition MCContext.h:553

llvm::MCObjectFileInfo::getContext

MCContext & getContext() const

Definition MCObjectFileInfo.h:261

llvm::MCSection

Instances of this class represent a uniqued identifier for a section in the current translation unit.

Definition MCSection.h:521

llvm::SectionKind

SectionKind - This is a simple POD value that classifies the properties of a section.

Definition SectionKind.h:22

llvm::TargetLoweringObjectFileELF::Initialize

void Initialize(MCContext &Ctx, const TargetMachine &TM) override

This method must be called before any actual lowering is done.

Definition TargetLoweringObjectFileImpl.cpp:121

llvm::TargetLoweringObjectFileELF::getSectionForConstant

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.

Definition TargetLoweringObjectFileImpl.cpp:1038

llvm::TargetLoweringObjectFileELF::SelectSectionForGlobal

MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const override

Definition TargetLoweringObjectFileImpl.cpp:938

llvm::TargetLoweringObjectFile::getKindForGlobal

static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)

Classify the specified global variable into a set of target independent categories embodied in Sectio...

Definition TargetLoweringObjectFile.cpp:233

llvm::TargetLoweringObjectFile::TM

const TargetMachine * TM

Definition TargetLoweringObjectFile.h:70

llvm::TargetMachine

Primary interface to the complete machine description for the target machine.

Definition TargetMachine.h:83

llvm::TargetMachine::getCodeModel

CodeModel::Model getCodeModel() const

Returns the code model.

Definition TargetMachine.h:264

llvm::Type

The instances of the Type class are immutable: once they are created, they are never changed.

Definition Type.h:45

llvm::Value::getType

Type * getType() const

All values are typed, get the type of this value.

Definition Value.h:256

llvm::cl::opt

Definition CommandLine.h:1455

uint64_t

TargetMachine.h

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition CallingConv.h:34

llvm::CodeModel::Small

@ Small

Definition CodeGen.h:31

llvm::ELF::SHF_ALLOC

@ SHF_ALLOC

Definition ELF.h:1248

llvm::ELF::SHF_WRITE

@ SHF_WRITE

Definition ELF.h:1245

llvm::ELF::SHT_PROGBITS

@ SHT_PROGBITS

Definition ELF.h:1147

llvm::ELF::SHT_NOBITS

@ SHT_NOBITS

Definition ELF.h:1154

llvm::cl::Hidden

@ Hidden

Definition CommandLine.h:139

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition CommandLine.h:445

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition AddressRanges.h:18

llvm::dyn_cast

decltype(auto) dyn_cast(const From &Val)

dyn_cast<X> - Return the argument parameter cast to the specified type.

Definition Casting.h:643

llvm::Align

This struct is a compact representation of a valid (non-zero power of two) alignment.

Definition Alignment.h:39

llvm::cl::desc

Definition CommandLine.h:411

Generated on for LLVM by doxygen 1.14.0

LLVM: lib/Target/Lanai/LanaiTargetObjectFile.cpp Source File