Line data Source code
1 : //===-- llvm/CodeGen/TargetLoweringObjectFile.h - Object Info ---*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file implements classes used to handle lowerings specific to common
11 : // object file formats.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #ifndef LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H
16 : #define LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H
17 :
18 : #include "llvm/ADT/ArrayRef.h"
19 : #include "llvm/ADT/StringRef.h"
20 : #include "llvm/IR/Module.h"
21 : #include "llvm/MC/MCObjectFileInfo.h"
22 : #include "llvm/MC/SectionKind.h"
23 : #include <cstdint>
24 :
25 : namespace llvm {
26 :
27 : class GlobalValue;
28 : class MachineModuleInfo;
29 : class Mangler;
30 : class MCContext;
31 : class MCExpr;
32 : class MCSection;
33 : class MCSymbol;
34 : class MCSymbolRefExpr;
35 : class MCStreamer;
36 : class MCValue;
37 : class TargetMachine;
38 :
39 : class TargetLoweringObjectFile : public MCObjectFileInfo {
40 : MCContext *Ctx = nullptr;
41 :
42 : /// Name-mangler for global names.
43 : Mangler *Mang = nullptr;
44 :
45 : protected:
46 : bool SupportIndirectSymViaGOTPCRel = false;
47 : bool SupportGOTPCRelWithOffset = true;
48 :
49 : /// This section contains the static constructor pointer list.
50 : MCSection *StaticCtorSection = nullptr;
51 :
52 : /// This section contains the static destructor pointer list.
53 : MCSection *StaticDtorSection = nullptr;
54 :
55 : public:
56 31401 : TargetLoweringObjectFile() = default;
57 : TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete;
58 : TargetLoweringObjectFile &
59 : operator=(const TargetLoweringObjectFile &) = delete;
60 : virtual ~TargetLoweringObjectFile();
61 :
62 : MCContext &getContext() const { return *Ctx; }
63 : Mangler &getMangler() const { return *Mang; }
64 :
65 : /// This method must be called before any actual lowering is done. This
66 : /// specifies the current context for codegen, and gives the lowering
67 : /// implementations a chance to set up their default sections.
68 : virtual void Initialize(MCContext &ctx, const TargetMachine &TM);
69 :
70 : virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM,
71 : const MCSymbol *Sym) const;
72 :
73 : /// Emit the module-level metadata that the platform cares about.
74 230 : virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M,
75 230 : const TargetMachine &TM) const {}
76 :
77 : /// Given a constant with the SectionKind, return a section that it should be
78 : /// placed in.
79 : virtual MCSection *getSectionForConstant(const DataLayout &DL,
80 : SectionKind Kind,
81 : const Constant *C,
82 : unsigned &Align) const;
83 :
84 : /// Classify the specified global variable into a set of target independent
85 : /// categories embodied in SectionKind.
86 : static SectionKind getKindForGlobal(const GlobalObject *GO,
87 : const TargetMachine &TM);
88 :
89 : /// This method computes the appropriate section to emit the specified global
90 : /// variable or function definition. This should not be passed external (or
91 : /// available externally) globals.
92 : MCSection *SectionForGlobal(const GlobalObject *GO, SectionKind Kind,
93 : const TargetMachine &TM) const;
94 :
95 : /// This method computes the appropriate section to emit the specified global
96 : /// variable or function definition. This should not be passed external (or
97 : /// available externally) globals.
98 170276 : MCSection *SectionForGlobal(const GlobalObject *GO,
99 : const TargetMachine &TM) const {
100 170276 : return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
101 : }
102 :
103 : virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
104 : const GlobalValue *GV,
105 : const TargetMachine &TM) const;
106 :
107 : virtual MCSection *getSectionForJumpTable(const Function &F,
108 : const TargetMachine &TM) const;
109 :
110 : virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
111 : const Function &F) const;
112 :
113 : /// Targets should implement this method to assign a section to globals with
114 : /// an explicit section specfied. The implementation of this method can
115 : /// assume that GO->hasSection() is true.
116 : virtual MCSection *
117 : getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
118 : const TargetMachine &TM) const = 0;
119 :
120 : /// Return an MCExpr to use for a reference to the specified global variable
121 : /// from exception handling information.
122 : virtual const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
123 : unsigned Encoding,
124 : const TargetMachine &TM,
125 : MachineModuleInfo *MMI,
126 : MCStreamer &Streamer) const;
127 :
128 : /// Return the MCSymbol for a private symbol with global value name as its
129 : /// base, with the specified suffix.
130 : MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV,
131 : StringRef Suffix,
132 : const TargetMachine &TM) const;
133 :
134 : // The symbol that gets passed to .cfi_personality.
135 : virtual MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
136 : const TargetMachine &TM,
137 : MachineModuleInfo *MMI) const;
138 :
139 : const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
140 : MCStreamer &Streamer) const;
141 :
142 15 : virtual MCSection *getStaticCtorSection(unsigned Priority,
143 : const MCSymbol *KeySym) const {
144 15 : return StaticCtorSection;
145 : }
146 :
147 4 : virtual MCSection *getStaticDtorSection(unsigned Priority,
148 : const MCSymbol *KeySym) const {
149 4 : return StaticDtorSection;
150 : }
151 :
152 : /// \brief Create a symbol reference to describe the given TLS variable when
153 : /// emitting the address in debug info.
154 : virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
155 :
156 20 : virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
157 : const GlobalValue *RHS,
158 : const TargetMachine &TM) const {
159 20 : return nullptr;
160 : }
161 :
162 : /// \brief Target supports replacing a data "PC"-relative access to a symbol
163 : /// through another symbol, by accessing the later via a GOT entry instead?
164 : bool supportIndirectSymViaGOTPCRel() const {
165 : return SupportIndirectSymViaGOTPCRel;
166 : }
167 :
168 : /// \brief Target GOT "PC"-relative relocation supports encoding an additional
169 : /// binary expression with an offset?
170 : bool supportGOTPCRelWithOffset() const {
171 : return SupportGOTPCRelWithOffset;
172 : }
173 :
174 : /// \brief Get the target specific PC relative GOT entry relocation
175 0 : virtual const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
176 : const MCValue &MV,
177 : int64_t Offset,
178 : MachineModuleInfo *MMI,
179 : MCStreamer &Streamer) const {
180 0 : return nullptr;
181 : }
182 :
183 0 : virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
184 0 : const GlobalValue *GV) const {}
185 :
186 0 : virtual void emitLinkerFlagsForUsed(raw_ostream &OS,
187 0 : const GlobalValue *GV) const {}
188 :
189 : protected:
190 : virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
191 : SectionKind Kind,
192 : const TargetMachine &TM) const = 0;
193 : };
194 :
195 : } // end namespace llvm
196 :
197 : #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILE_H
|
