Coverage Report

Created: 2018-11-12 17:33

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/MC/MCAssembler.h
Line
Count
Source (jump to first uncovered line)
1
//===- MCAssembler.h - Object File Generation -------------------*- 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
#ifndef LLVM_MC_MCASSEMBLER_H
11
#define LLVM_MC_MCASSEMBLER_H
12
13
#include "llvm/ADT/ArrayRef.h"
14
#include "llvm/ADT/STLExtras.h"
15
#include "llvm/ADT/SmallPtrSet.h"
16
#include "llvm/ADT/StringRef.h"
17
#include "llvm/ADT/iterator.h"
18
#include "llvm/ADT/iterator_range.h"
19
#include "llvm/BinaryFormat/MachO.h"
20
#include "llvm/MC/MCDirectives.h"
21
#include "llvm/MC/MCDwarf.h"
22
#include "llvm/MC/MCFixup.h"
23
#include "llvm/MC/MCFragment.h"
24
#include "llvm/MC/MCLinkerOptimizationHint.h"
25
#include "llvm/MC/MCSymbol.h"
26
#include <cassert>
27
#include <cstddef>
28
#include <cstdint>
29
#include <string>
30
#include <utility>
31
#include <vector>
32
33
namespace llvm {
34
35
class MCAsmBackend;
36
class MCAsmLayout;
37
class MCContext;
38
class MCCodeEmitter;
39
class MCFragment;
40
class MCObjectWriter;
41
class MCSection;
42
class MCValue;
43
44
// FIXME: This really doesn't belong here. See comments below.
45
struct IndirectSymbolData {
46
  MCSymbol *Symbol;
47
  MCSection *Section;
48
};
49
50
// FIXME: Ditto this. Purely so the Streamer and the ObjectWriter can talk
51
// to one another.
52
struct DataRegionData {
53
  // This enum should be kept in sync w/ the mach-o definition in
54
  // llvm/Object/MachOFormat.h.
55
  enum KindTy { Data = 1, JumpTable8, JumpTable16, JumpTable32 } Kind;
56
  MCSymbol *Start;
57
  MCSymbol *End;
58
};
59
60
class MCAssembler {
61
  friend class MCAsmLayout;
62
63
public:
64
  using SectionListType = std::vector<MCSection *>;
65
  using SymbolDataListType = std::vector<const MCSymbol *>;
66
67
  using const_iterator = pointee_iterator<SectionListType::const_iterator>;
68
  using iterator = pointee_iterator<SectionListType::iterator>;
69
70
  using const_symbol_iterator =
71
      pointee_iterator<SymbolDataListType::const_iterator>;
72
  using symbol_iterator = pointee_iterator<SymbolDataListType::iterator>;
73
74
  using symbol_range = iterator_range<symbol_iterator>;
75
  using const_symbol_range = iterator_range<const_symbol_iterator>;
76
77
  using const_indirect_symbol_iterator =
78
      std::vector<IndirectSymbolData>::const_iterator;
79
  using indirect_symbol_iterator = std::vector<IndirectSymbolData>::iterator;
80
81
  using const_data_region_iterator =
82
      std::vector<DataRegionData>::const_iterator;
83
  using data_region_iterator = std::vector<DataRegionData>::iterator;
84
85
  /// MachO specific deployment target version info.
86
  // A Major version of 0 indicates that no version information was supplied
87
  // and so the corresponding load command should not be emitted.
88
  using VersionInfoType = struct {
89
    bool EmitBuildVersion;
90
    union {
91
      MCVersionMinType Type;          ///< Used when EmitBuildVersion==false.
92
      MachO::PlatformType Platform;   ///< Used when EmitBuildVersion==true.
93
    } TypeOrPlatform;
94
    unsigned Major;
95
    unsigned Minor;
96
    unsigned Update;
97
  };
98
99
private:
100
  MCContext &Context;
101
102
  std::unique_ptr<MCAsmBackend> Backend;
103
104
  std::unique_ptr<MCCodeEmitter> Emitter;
105
106
  std::unique_ptr<MCObjectWriter> Writer;
107
108
  SectionListType Sections;
109
110
  SymbolDataListType Symbols;
111
112
  std::vector<IndirectSymbolData> IndirectSymbols;
113
114
  std::vector<DataRegionData> DataRegions;
115
116
  /// The list of linker options to propagate into the object file.
117
  std::vector<std::vector<std::string>> LinkerOptions;
118
119
  /// List of declared file names
120
  std::vector<std::string> FileNames;
121
122
  MCDwarfLineTableParams LTParams;
123
124
  /// The set of function symbols for which a .thumb_func directive has
125
  /// been seen.
126
  //
127
  // FIXME: We really would like this in target specific code rather than
128
  // here. Maybe when the relocation stuff moves to target specific,
129
  // this can go with it? The streamer would need some target specific
130
  // refactoring too.
131
  mutable SmallPtrSet<const MCSymbol *, 32> ThumbFuncs;
132
133
  /// The bundle alignment size currently set in the assembler.
134
  ///
135
  /// By default it's 0, which means bundling is disabled.
136
  unsigned BundleAlignSize;
137
138
  bool RelaxAll : 1;
139
  bool SubsectionsViaSymbols : 1;
140
  bool IncrementalLinkerCompatible : 1;
141
142
  /// ELF specific e_header flags
143
  // It would be good if there were an MCELFAssembler class to hold this.
144
  // ELF header flags are used both by the integrated and standalone assemblers.
145
  // Access to the flags is necessary in cases where assembler directives affect
146
  // which flags to be set.
147
  unsigned ELFHeaderEFlags;
148
149
  /// Used to communicate Linker Optimization Hint information between
150
  /// the Streamer and the .o writer
151
  MCLOHContainer LOHContainer;
152
153
  VersionInfoType VersionInfo;
154
155
  /// Evaluate a fixup to a relocatable expression and the value which should be
156
  /// placed into the fixup.
157
  ///
158
  /// \param Layout The layout to use for evaluation.
159
  /// \param Fixup The fixup to evaluate.
160
  /// \param DF The fragment the fixup is inside.
161
  /// \param Target [out] On return, the relocatable expression the fixup
162
  /// evaluates to.
163
  /// \param Value [out] On return, the value of the fixup as currently laid
164
  /// out.
165
  /// \param WasForced [out] On return, the value in the fixup is set to the
166
  /// correct value if WasForced is true, even if evaluateFixup returns false.
167
  /// \return Whether the fixup value was fully resolved. This is true if the
168
  /// \p Value result is fixed, otherwise the value may change due to
169
  /// relocation.
170
  bool evaluateFixup(const MCAsmLayout &Layout, const MCFixup &Fixup,
171
                     const MCFragment *DF, MCValue &Target,
172
                     uint64_t &Value, bool &WasForced) const;
173
174
  /// Check whether a fixup can be satisfied, or whether it needs to be relaxed
175
  /// (increased in size, in order to hold its value correctly).
176
  bool fixupNeedsRelaxation(const MCFixup &Fixup, const MCRelaxableFragment *DF,
177
                            const MCAsmLayout &Layout) const;
178
179
  /// Check whether the given fragment needs relaxation.
180
  bool fragmentNeedsRelaxation(const MCRelaxableFragment *IF,
181
                               const MCAsmLayout &Layout) const;
182
183
  /// Perform one layout iteration and return true if any offsets
184
  /// were adjusted.
185
  bool layoutOnce(MCAsmLayout &Layout);
186
187
  /// Perform one layout iteration of the given section and return true
188
  /// if any offsets were adjusted.
189
  bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec);
190
191
  bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
192
193
  bool relaxPaddingFragment(MCAsmLayout &Layout, MCPaddingFragment &PF);
194
195
  bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
196
197
  bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF);
198
  bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
199
                                   MCDwarfCallFrameFragment &DF);
200
  bool relaxCVInlineLineTable(MCAsmLayout &Layout,
201
                              MCCVInlineLineTableFragment &DF);
202
  bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF);
203
204
  /// finishLayout - Finalize a layout, including fragment lowering.
205
  void finishLayout(MCAsmLayout &Layout);
206
207
  std::tuple<MCValue, uint64_t, bool>
208
  handleFixup(const MCAsmLayout &Layout, MCFragment &F, const MCFixup &Fixup);
209
210
public:
211
  std::vector<std::pair<StringRef, const MCSymbol *>> Symvers;
212
213
  /// Construct a new assembler instance.
214
  //
215
  // FIXME: How are we going to parameterize this? Two obvious options are stay
216
  // concrete and require clients to pass in a target like object. The other
217
  // option is to make this abstract, and have targets provide concrete
218
  // implementations as we do with AsmParser.
219
  MCAssembler(MCContext &Context, std::unique_ptr<MCAsmBackend> Backend,
220
              std::unique_ptr<MCCodeEmitter> Emitter,
221
              std::unique_ptr<MCObjectWriter> Writer);
222
  MCAssembler(const MCAssembler &) = delete;
223
  MCAssembler &operator=(const MCAssembler &) = delete;
224
  ~MCAssembler();
225
226
  /// Compute the effective fragment size assuming it is laid out at the given
227
  /// \p SectionAddress and \p FragmentOffset.
228
  uint64_t computeFragmentSize(const MCAsmLayout &Layout,
229
                               const MCFragment &F) const;
230
231
  /// Find the symbol which defines the atom containing the given symbol, or
232
  /// null if there is no such symbol.
233
  const MCSymbol *getAtom(const MCSymbol &S) const;
234
235
  /// Check whether a particular symbol is visible to the linker and is required
236
  /// in the symbol table, or whether it can be discarded by the assembler. This
237
  /// also effects whether the assembler treats the label as potentially
238
  /// defining a separate atom.
239
  bool isSymbolLinkerVisible(const MCSymbol &SD) const;
240
241
  /// Emit the section contents to \p OS.
242
  void writeSectionData(raw_ostream &OS, const MCSection *Section,
243
                        const MCAsmLayout &Layout) const;
244
245
  /// Check whether a given symbol has been flagged with .thumb_func.
246
  bool isThumbFunc(const MCSymbol *Func) const;
247
248
  /// Flag a function symbol as the target of a .thumb_func directive.
249
11.0k
  void setIsThumbFunc(const MCSymbol *Func) { ThumbFuncs.insert(Func); }
250
251
  /// ELF e_header flags
252
6.69k
  unsigned getELFHeaderEFlags() const { return ELFHeaderEFlags; }
253
2.59k
  void setELFHeaderEFlags(unsigned Flags) { ELFHeaderEFlags = Flags; }
254
255
  /// MachO deployment target version information.
256
14.0k
  const VersionInfoType &getVersionInfo() const { return VersionInfo; }
257
  void setVersionMin(MCVersionMinType Type, unsigned Major, unsigned Minor,
258
13.0k
                     unsigned Update) {
259
13.0k
    VersionInfo.EmitBuildVersion = false;
260
13.0k
    VersionInfo.TypeOrPlatform.Type = Type;
261
13.0k
    VersionInfo.Major = Major;
262
13.0k
    VersionInfo.Minor = Minor;
263
13.0k
    VersionInfo.Update = Update;
264
13.0k
  }
265
  void setBuildVersion(MachO::PlatformType Platform, unsigned Major,
266
1
                       unsigned Minor, unsigned Update) {
267
1
    VersionInfo.EmitBuildVersion = true;
268
1
    VersionInfo.TypeOrPlatform.Platform = Platform;
269
1
    VersionInfo.Major = Major;
270
1
    VersionInfo.Minor = Minor;
271
1
    VersionInfo.Update = Update;
272
1
  }
273
274
  /// Reuse an assembler instance
275
  ///
276
  void reset();
277
278
13.4M
  MCContext &getContext() const { return Context; }
279
280
7.15M
  MCAsmBackend *getBackendPtr() const { return Backend.get(); }
281
282
2.10M
  MCCodeEmitter *getEmitterPtr() const { return Emitter.get(); }
283
284
3.20M
  MCObjectWriter *getWriterPtr() const { return Writer.get(); }
285
286
90.7M
  MCAsmBackend &getBackend() const { return *Backend; }
287
288
17.4M
  MCCodeEmitter &getEmitter() const { return *Emitter; }
289
290
8.21M
  MCObjectWriter &getWriter() const { return *Writer; }
291
292
3.21M
  MCDwarfLineTableParams getDWARFLinetableParams() const { return LTParams; }
293
0
  void setDWARFLinetableParams(MCDwarfLineTableParams P) { LTParams = P; }
294
295
  /// Finish - Do final processing and write the object to the output stream.
296
  /// \p Writer is used for custom object writer (as the MCJIT does),
297
  /// if not specified it is automatically created from backend.
298
  void Finish();
299
300
  // Layout all section and prepare them for emission.
301
  void layout(MCAsmLayout &Layout);
302
303
  // FIXME: This does not belong here.
304
765k
  bool getSubsectionsViaSymbols() const { return SubsectionsViaSymbols; }
305
13.8k
  void setSubsectionsViaSymbols(bool Value) { SubsectionsViaSymbols = Value; }
306
307
461
  bool isIncrementalLinkerCompatible() const {
308
461
    return IncrementalLinkerCompatible;
309
461
  }
310
469
  void setIncrementalLinkerCompatible(bool Value) {
311
469
    IncrementalLinkerCompatible = Value;
312
469
  }
313
314
538k
  bool getRelaxAll() const { return RelaxAll; }
315
560
  void setRelaxAll(bool Value) { RelaxAll = Value; }
316
317
29.4M
  bool isBundlingEnabled() const { return BundleAlignSize != 0; }
318
319
2.26k
  unsigned getBundleAlignSize() const { return BundleAlignSize; }
320
321
42
  void setBundleAlignSize(unsigned Size) {
322
42
    assert((Size == 0 || !(Size & (Size - 1))) &&
323
42
           "Expect a power-of-two bundle align size");
324
42
    BundleAlignSize = Size;
325
42
  }
326
327
  /// \name Section List Access
328
  /// @{
329
330
204k
  iterator begin() { return Sections.begin(); }
331
0
  const_iterator begin() const { return Sections.begin(); }
332
333
204k
  iterator end() { return Sections.end(); }
334
0
  const_iterator end() const { return Sections.end(); }
335
336
14.0k
  size_t size() const { return Sections.size(); }
337
338
  /// @}
339
  /// \name Symbol List Access
340
  /// @{
341
62.1k
  symbol_iterator symbol_begin() { return Symbols.begin(); }
342
0
  const_symbol_iterator symbol_begin() const { return Symbols.begin(); }
343
344
62.1k
  symbol_iterator symbol_end() { return Symbols.end(); }
345
0
  const_symbol_iterator symbol_end() const { return Symbols.end(); }
346
347
62.1k
  symbol_range symbols() { return make_range(symbol_begin(), symbol_end()); }
348
0
  const_symbol_range symbols() const {
349
0
    return make_range(symbol_begin(), symbol_end());
350
0
  }
351
352
0
  size_t symbol_size() const { return Symbols.size(); }
353
354
  /// @}
355
  /// \name Indirect Symbol List Access
356
  /// @{
357
358
  // FIXME: This is a total hack, this should not be here. Once things are
359
  // factored so that the streamer has direct access to the .o writer, it can
360
  // disappear.
361
2.12k
  std::vector<IndirectSymbolData> &getIndirectSymbols() {
362
2.12k
    return IndirectSymbols;
363
2.12k
  }
364
365
55.4k
  indirect_symbol_iterator indirect_symbol_begin() {
366
55.4k
    return IndirectSymbols.begin();
367
55.4k
  }
368
0
  const_indirect_symbol_iterator indirect_symbol_begin() const {
369
0
    return IndirectSymbols.begin();
370
0
  }
371
372
55.4k
  indirect_symbol_iterator indirect_symbol_end() {
373
55.4k
    return IndirectSymbols.end();
374
55.4k
  }
375
0
  const_indirect_symbol_iterator indirect_symbol_end() const {
376
0
    return IndirectSymbols.end();
377
0
  }
378
379
13.0k
  size_t indirect_symbol_size() const { return IndirectSymbols.size(); }
380
381
  /// @}
382
  /// \name Linker Option List Access
383
  /// @{
384
385
28.1k
  std::vector<std::vector<std::string>> &getLinkerOptions() {
386
28.1k
    return LinkerOptions;
387
28.1k
  }
388
389
  /// @}
390
  /// \name Data Region List Access
391
  /// @{
392
393
  // FIXME: This is a total hack, this should not be here. Once things are
394
  // factored so that the streamer has direct access to the .o writer, it can
395
  // disappear.
396
16.4k
  std::vector<DataRegionData> &getDataRegions() { return DataRegions; }
397
398
14.0k
  data_region_iterator data_region_begin() { return DataRegions.begin(); }
399
0
  const_data_region_iterator data_region_begin() const {
400
0
    return DataRegions.begin();
401
0
  }
402
403
14.0k
  data_region_iterator data_region_end() { return DataRegions.end(); }
404
0
  const_data_region_iterator data_region_end() const {
405
0
    return DataRegions.end();
406
0
  }
407
408
0
  size_t data_region_size() const { return DataRegions.size(); }
409
410
  /// @}
411
  /// \name Data Region List Access
412
  /// @{
413
414
  // FIXME: This is a total hack, this should not be here. Once things are
415
  // factored so that the streamer has direct access to the .o writer, it can
416
  // disappear.
417
712k
  MCLOHContainer &getLOHContainer() { return LOHContainer; }
418
0
  const MCLOHContainer &getLOHContainer() const {
419
0
    return const_cast<MCAssembler *>(this)->getLOHContainer();
420
0
  }
421
422
  struct CGProfileEntry {
423
    const MCSymbolRefExpr *From;
424
    const MCSymbolRefExpr *To;
425
    uint64_t Count;
426
  };
427
  std::vector<CGProfileEntry> CGProfile;
428
  /// @}
429
  /// \name Backend Data Access
430
  /// @{
431
432
  bool registerSection(MCSection &Section);
433
434
  void registerSymbol(const MCSymbol &Symbol, bool *Created = nullptr);
435
436
5.07k
  ArrayRef<std::string> getFileNames() { return FileNames; }
437
438
1.18k
  void addFileName(StringRef FileName) {
439
1.18k
    if (!is_contained(FileNames, FileName))
440
1.18k
      FileNames.push_back(FileName);
441
1.18k
  }
442
443
  /// Write the necessary bundle padding to \p OS.
444
  /// Expects a fragment \p F containing instructions and its size \p FSize.
445
  void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F,
446
                            uint64_t FSize) const;
447
448
  /// @}
449
450
  void dump() const;
451
};
452
453
/// Compute the amount of padding required before the fragment \p F to
454
/// obey bundling restrictions, where \p FOffset is the fragment's offset in
455
/// its section and \p FSize is the fragment's size.
456
uint64_t computeBundlePadding(const MCAssembler &Assembler,
457
                              const MCEncodedFragment *F, uint64_t FOffset,
458
                              uint64_t FSize);
459
460
} // end namespace llvm
461
462
#endif // LLVM_MC_MCASSEMBLER_H