Coverage Report

Created: 2018-03-23 14:56

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/TargetLoweringObjectFile.h
Line
Count
Source (jump to first uncovered line)
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
43.1k
  TargetLoweringObjectFile() = default;
57
  TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete;
58
  TargetLoweringObjectFile &
59
  operator=(const TargetLoweringObjectFile &) = delete;
60
  virtual ~TargetLoweringObjectFile();
61
62
4.14M
  MCContext &getContext() const { return *Ctx; }
63
5.95M
  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
  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
  MCSection *SectionForGlobal(const GlobalObject *GO,
99
435k
                              const TargetMachine &TM) const {
100
435k
    return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
101
435k
  }
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
  virtual MCSection *getStaticCtorSection(unsigned Priority,
143
179
                                          const MCSymbol *KeySym) const {
144
179
    return StaticCtorSection;
145
179
  }
146
147
  virtual MCSection *getStaticDtorSection(unsigned Priority,
148
5.56k
                                          const MCSymbol *KeySym) const {
149
5.56k
    return StaticDtorSection;
150
5.56k
  }
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
  virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
157
                                               const GlobalValue *RHS,
158
20
                                               const TargetMachine &TM) const {
159
20
    return nullptr;
160
20
  }
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
190k
  bool supportIndirectSymViaGOTPCRel() const {
165
190k
    return SupportIndirectSymViaGOTPCRel;
166
190k
  }
167
168
  /// \brief Target GOT "PC"-relative relocation supports encoding an additional
169
  /// binary expression with an offset?
170
20
  bool supportGOTPCRelWithOffset() const {
171
20
    return SupportGOTPCRelWithOffset;
172
20
  }
173
174
  /// \brief Get the target specific PC relative GOT entry relocation
175
  virtual const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
176
                                                  const MCValue &MV,
177
                                                  int64_t Offset,
178
                                                  MachineModuleInfo *MMI,
179
0
                                                  MCStreamer &Streamer) const {
180
0
    return nullptr;
181
0
  }
182
183
  virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
184
0
                                        const GlobalValue *GV) const {}
185
186
  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