Coverage Report

Created: 2019-07-24 05:18

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