Coverage Report

Created: 2018-11-12 17:33

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/MC/MCFragment.h
Line
Count
Source (jump to first uncovered line)
1
//===- MCFragment.h - Fragment type hierarchy -------------------*- 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_MCFRAGMENT_H
11
#define LLVM_MC_MCFRAGMENT_H
12
13
#include "llvm/ADT/ArrayRef.h"
14
#include "llvm/ADT/SmallString.h"
15
#include "llvm/ADT/SmallVector.h"
16
#include "llvm/ADT/StringRef.h"
17
#include "llvm/ADT/ilist_node.h"
18
#include "llvm/MC/MCFixup.h"
19
#include "llvm/MC/MCInst.h"
20
#include "llvm/Support/Casting.h"
21
#include "llvm/Support/SMLoc.h"
22
#include <cstdint>
23
#include <utility>
24
25
namespace llvm {
26
27
class MCSection;
28
class MCSubtargetInfo;
29
class MCSymbol;
30
31
class MCFragment : public ilist_node_with_parent<MCFragment, MCSection> {
32
  friend class MCAsmLayout;
33
34
public:
35
  enum FragmentType : uint8_t {
36
    FT_Align,
37
    FT_Data,
38
    FT_CompactEncodedInst,
39
    FT_Fill,
40
    FT_Relaxable,
41
    FT_Org,
42
    FT_Dwarf,
43
    FT_DwarfFrame,
44
    FT_LEB,
45
    FT_Padding,
46
    FT_SymbolId,
47
    FT_CVInlineLines,
48
    FT_CVDefRange,
49
    FT_Dummy
50
  };
51
52
private:
53
  FragmentType Kind;
54
55
protected:
56
  bool HasInstructions;
57
58
private:
59
  /// LayoutOrder - The layout order of this fragment.
60
  unsigned LayoutOrder;
61
62
  /// The data for the section this fragment is in.
63
  MCSection *Parent;
64
65
  /// Atom - The atom this fragment is in, as represented by its defining
66
  /// symbol.
67
  const MCSymbol *Atom;
68
69
  /// \name Assembler Backend Data
70
  /// @{
71
  //
72
  // FIXME: This could all be kept private to the assembler implementation.
73
74
  /// Offset - The offset of this fragment in its section. This is ~0 until
75
  /// initialized.
76
  uint64_t Offset;
77
78
  /// @}
79
80
protected:
81
  MCFragment(FragmentType Kind, bool HasInstructions,
82
             MCSection *Parent = nullptr);
83
84
  ~MCFragment();
85
86
public:
87
  MCFragment() = delete;
88
  MCFragment(const MCFragment &) = delete;
89
  MCFragment &operator=(const MCFragment &) = delete;
90
91
  /// Destroys the current fragment.
92
  ///
93
  /// This must be used instead of delete as MCFragment is non-virtual.
94
  /// This method will dispatch to the appropriate subclass.
95
  void destroy();
96
97
114M
  FragmentType getKind() const { return Kind; }
98
99
88.5M
  MCSection *getParent() const { return Parent; }
100
7.22M
  void setParent(MCSection *Value) { Parent = Value; }
101
102
3.93M
  const MCSymbol *getAtom() const { return Atom; }
103
3.35M
  void setAtom(const MCSymbol *Value) { Atom = Value; }
104
105
57.7M
  unsigned getLayoutOrder() const { return LayoutOrder; }
106
5.86M
  void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
107
108
  /// Does this fragment have instructions emitted into it? By default
109
  /// this is false, but specific fragment types may set it to true.
110
26.6M
  bool hasInstructions() const { return HasInstructions; }
111
112
  /// Return true if given frgment has FT_Dummy type.
113
2.69M
  bool isDummy() const { return Kind == FT_Dummy; }
114
115
  void dump() const;
116
};
117
118
class MCDummyFragment : public MCFragment {
119
public:
120
2.81M
  explicit MCDummyFragment(MCSection *Sec) : MCFragment(FT_Dummy, false, Sec) {}
121
122
  static bool classof(const MCFragment *F) { return F->getKind() == FT_Dummy; }
123
};
124
125
/// Interface implemented by fragments that contain encoded instructions and/or
126
/// data.
127
///
128
class MCEncodedFragment : public MCFragment {
129
  /// Should this fragment be aligned to the end of a bundle?
130
  bool AlignToBundleEnd = false;
131
132
  uint8_t BundlePadding = 0;
133
134
protected:
135
  MCEncodedFragment(MCFragment::FragmentType FType, bool HasInstructions,
136
                    MCSection *Sec)
137
5.89M
      : MCFragment(FType, HasInstructions, Sec) {}
138
139
  /// STI - The MCSubtargetInfo in effect when the instruction was encoded.
140
  /// must be non-null for instructions.
141
  const MCSubtargetInfo *STI = nullptr;
142
143
public:
144
17.5M
  static bool classof(const MCFragment *F) {
145
17.5M
    MCFragment::FragmentType Kind = F->getKind();
146
17.5M
    switch (Kind) {
147
17.5M
    default:
148
3.96M
      return false;
149
17.5M
    case MCFragment::FT_Relaxable:
150
13.6M
    case MCFragment::FT_CompactEncodedInst:
151
13.6M
    case MCFragment::FT_Data:
152
13.6M
    case MCFragment::FT_Dwarf:
153
13.6M
      return true;
154
17.5M
    }
155
17.5M
  }
156
157
  /// Should this fragment be placed at the end of an aligned bundle?
158
1.31k
  bool alignToBundleEnd() const { return AlignToBundleEnd; }
159
2.24k
  void setAlignToBundleEnd(bool V) { AlignToBundleEnd = V; }
160
161
  /// Get the padding size that must be inserted before this fragment.
162
  /// Used for bundling. By default, no padding is inserted.
163
  /// Note that padding size is restricted to 8 bits. This is an optimization
164
  /// to reduce the amount of space used for each fragment. In practice, larger
165
  /// padding should never be required.
166
4.53M
  uint8_t getBundlePadding() const { return BundlePadding; }
167
168
  /// Set the padding size for this fragment. By default it's a no-op,
169
  /// and only some fragments have a meaningful implementation.
170
780
  void setBundlePadding(uint8_t N) { BundlePadding = N; }
171
172
  /// Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
173
  /// Guaranteed to be non-null if hasInstructions() == true
174
4.57M
  const MCSubtargetInfo *getSubtargetInfo() const { return STI; }
175
176
  /// Record that the fragment contains instructions with the MCSubtargetInfo in
177
  /// effect when the instruction was encoded.
178
16.6M
  void setHasInstructions(const MCSubtargetInfo &STI) {
179
16.6M
    HasInstructions = true;
180
16.6M
    this->STI = &STI;
181
16.6M
  }
182
};
183
184
/// Interface implemented by fragments that contain encoded instructions and/or
185
/// data.
186
///
187
template<unsigned ContentsSize>
188
class MCEncodedFragmentWithContents : public MCEncodedFragment {
189
  SmallVector<char, ContentsSize> Contents;
190
191
protected:
192
  MCEncodedFragmentWithContents(MCFragment::FragmentType FType,
193
                                bool HasInstructions,
194
                                MCSection *Sec)
195
5.89M
      : MCEncodedFragment(FType, HasInstructions, Sec) {}
llvm::MCEncodedFragmentWithContents<32u>::MCEncodedFragmentWithContents(llvm::MCFragment::FragmentType, bool, llvm::MCSection*)
Line
Count
Source
195
4.57M
      : MCEncodedFragment(FType, HasInstructions, Sec) {}
llvm::MCEncodedFragmentWithContents<4u>::MCEncodedFragmentWithContents(llvm::MCFragment::FragmentType, bool, llvm::MCSection*)
Line
Count
Source
195
141
      : MCEncodedFragment(FType, HasInstructions, Sec) {}
llvm::MCEncodedFragmentWithContents<8u>::MCEncodedFragmentWithContents(llvm::MCFragment::FragmentType, bool, llvm::MCSection*)
Line
Count
Source
195
1.32M
      : MCEncodedFragment(FType, HasInstructions, Sec) {}
196
197
public:
198
63.8M
  SmallVectorImpl<char> &getContents() { return Contents; }
llvm::MCEncodedFragmentWithContents<32u>::getContents()
Line
Count
Source
198
55.8M
  SmallVectorImpl<char> &getContents() { return Contents; }
llvm::MCEncodedFragmentWithContents<8u>::getContents()
Line
Count
Source
198
8.03M
  SmallVectorImpl<char> &getContents() { return Contents; }
llvm::MCEncodedFragmentWithContents<4u>::getContents()
Line
Count
Source
198
141
  SmallVectorImpl<char> &getContents() { return Contents; }
199
14.7M
  const SmallVectorImpl<char> &getContents() const { return Contents; }
llvm::MCEncodedFragmentWithContents<32u>::getContents() const
Line
Count
Source
199
10.4M
  const SmallVectorImpl<char> &getContents() const { return Contents; }
llvm::MCEncodedFragmentWithContents<8u>::getContents() const
Line
Count
Source
199
4.30M
  const SmallVectorImpl<char> &getContents() const { return Contents; }
llvm::MCEncodedFragmentWithContents<4u>::getContents() const
Line
Count
Source
199
543
  const SmallVectorImpl<char> &getContents() const { return Contents; }
200
};
201
202
/// Interface implemented by fragments that contain encoded instructions and/or
203
/// data and also have fixups registered.
204
///
205
template<unsigned ContentsSize, unsigned FixupsSize>
206
class MCEncodedFragmentWithFixups :
207
  public MCEncodedFragmentWithContents<ContentsSize> {
208
209
  /// Fixups - The list of fixups in this fragment.
210
  SmallVector<MCFixup, FixupsSize> Fixups;
211
212
protected:
213
  MCEncodedFragmentWithFixups(MCFragment::FragmentType FType,
214
                              bool HasInstructions,
215
                              MCSection *Sec)
216
      : MCEncodedFragmentWithContents<ContentsSize>(FType, HasInstructions,
217
5.89M
                                                    Sec) {}
llvm::MCEncodedFragmentWithFixups<32u, 4u>::MCEncodedFragmentWithFixups(llvm::MCFragment::FragmentType, bool, llvm::MCSection*)
Line
Count
Source
217
4.57M
                                                    Sec) {}
llvm::MCEncodedFragmentWithFixups<8u, 1u>::MCEncodedFragmentWithFixups(llvm::MCFragment::FragmentType, bool, llvm::MCSection*)
Line
Count
Source
217
1.32M
                                                    Sec) {}
218
219
public:
220
221
  using const_fixup_iterator = SmallVectorImpl<MCFixup>::const_iterator;
222
  using fixup_iterator = SmallVectorImpl<MCFixup>::iterator;
223
224
13.7M
  SmallVectorImpl<MCFixup> &getFixups() { return Fixups; }
llvm::MCEncodedFragmentWithFixups<32u, 4u>::getFixups()
Line
Count
Source
224
8.94M
  SmallVectorImpl<MCFixup> &getFixups() { return Fixups; }
llvm::MCEncodedFragmentWithFixups<8u, 1u>::getFixups()
Line
Count
Source
224
4.85M
  SmallVectorImpl<MCFixup> &getFixups() { return Fixups; }
225
682k
  const SmallVectorImpl<MCFixup> &getFixups() const { return Fixups; }
llvm::MCEncodedFragmentWithFixups<8u, 1u>::getFixups() const
Line
Count
Source
225
682k
  const SmallVectorImpl<MCFixup> &getFixups() const { return Fixups; }
llvm::MCEncodedFragmentWithFixups<32u, 4u>::getFixups() const
Line
Count
Source
225
8
  const SmallVectorImpl<MCFixup> &getFixups() const { return Fixups; }
226
227
  fixup_iterator fixup_begin() { return Fixups.begin(); }
228
9.93k
  const_fixup_iterator fixup_begin() const { return Fixups.begin(); }
229
230
  fixup_iterator fixup_end() { return Fixups.end(); }
231
9.93k
  const_fixup_iterator fixup_end() const { return Fixups.end(); }
232
233
  static bool classof(const MCFragment *F) {
234
    MCFragment::FragmentType Kind = F->getKind();
235
    return Kind == MCFragment::FT_Relaxable || Kind == MCFragment::FT_Data ||
236
           Kind == MCFragment::FT_CVDefRange || Kind == MCFragment::FT_Dwarf;;
237
  }
238
};
239
240
/// Fragment for data and encoded instructions.
241
///
242
class MCDataFragment : public MCEncodedFragmentWithFixups<32, 4> {
243
public:
244
  MCDataFragment(MCSection *Sec = nullptr)
245
4.57M
      : MCEncodedFragmentWithFixups<32, 4>(FT_Data, false, Sec) {}
246
247
39.0M
  static bool classof(const MCFragment *F) {
248
39.0M
    return F->getKind() == MCFragment::FT_Data;
249
39.0M
  }
250
};
251
252
/// This is a compact (memory-size-wise) fragment for holding an encoded
253
/// instruction (non-relaxable) that has no fixups registered. When applicable,
254
/// it can be used instead of MCDataFragment and lead to lower memory
255
/// consumption.
256
///
257
class MCCompactEncodedInstFragment : public MCEncodedFragmentWithContents<4> {
258
public:
259
  MCCompactEncodedInstFragment(MCSection *Sec = nullptr)
260
141
      : MCEncodedFragmentWithContents(FT_CompactEncodedInst, true, Sec) {
261
141
  }
262
263
4.54M
  static bool classof(const MCFragment *F) {
264
4.54M
    return F->getKind() == MCFragment::FT_CompactEncodedInst;
265
4.54M
  }
266
};
267
268
/// A relaxable fragment holds on to its MCInst, since it may need to be
269
/// relaxed during the assembler layout and relaxation stage.
270
///
271
class MCRelaxableFragment : public MCEncodedFragmentWithFixups<8, 1> {
272
273
  /// Inst - The instruction this is a fragment for.
274
  MCInst Inst;
275
276
public:
277
  MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI,
278
                      MCSection *Sec = nullptr)
279
      : MCEncodedFragmentWithFixups(FT_Relaxable, true, Sec),
280
260k
        Inst(Inst) { this->STI = &STI; }
281
282
971k
  const MCInst &getInst() const { return Inst; }
283
72.2k
  void setInst(const MCInst &Value) { Inst = Value; }
284
285
1.32M
  static bool classof(const MCFragment *F) {
286
1.32M
    return F->getKind() == MCFragment::FT_Relaxable;
287
1.32M
  }
288
};
289
290
class MCAlignFragment : public MCFragment {
291
  /// Alignment - The alignment to ensure, in bytes.
292
  unsigned Alignment;
293
294
  /// EmitNops - Flag to indicate that (optimal) NOPs should be emitted instead
295
  /// of using the provided value. The exact interpretation of this flag is
296
  /// target dependent.
297
  bool EmitNops : 1;
298
299
  /// Value - Value to use for filling padding bytes.
300
  int64_t Value;
301
302
  /// ValueSize - The size of the integer (in bytes) of \p Value.
303
  unsigned ValueSize;
304
305
  /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
306
  /// cannot be satisfied in this width then this fragment is ignored.
307
  unsigned MaxBytesToEmit;
308
309
public:
310
  MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize,
311
                  unsigned MaxBytesToEmit, MCSection *Sec = nullptr)
312
      : MCFragment(FT_Align, false, Sec), Alignment(Alignment), EmitNops(false),
313
502k
        Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
314
315
  /// \name Accessors
316
  /// @{
317
318
1.05M
  unsigned getAlignment() const { return Alignment; }
319
320
1.57M
  int64_t getValue() const { return Value; }
321
322
2.56M
  unsigned getValueSize() const { return ValueSize; }
323
324
1.05M
  unsigned getMaxBytesToEmit() const { return MaxBytesToEmit; }
325
326
811k
  bool hasEmitNops() const { return EmitNops; }
327
300k
  void setEmitNops(bool Value) { EmitNops = Value; }
328
329
  /// @}
330
331
227
  static bool classof(const MCFragment *F) {
332
227
    return F->getKind() == MCFragment::FT_Align;
333
227
  }
334
};
335
336
/// Fragment for adding required padding.
337
/// This fragment is always inserted before an instruction, and holds that
338
/// instruction as context information (as well as a mask of kinds) for
339
/// determining the padding size.
340
///
341
class MCPaddingFragment : public MCFragment {
342
  /// A mask containing all the kinds relevant to this fragment. i.e. the i'th
343
  /// bit will be set iff kind i is relevant to this fragment.
344
  uint64_t PaddingPoliciesMask;
345
  /// A boolean indicating if this fragment will actually hold padding. If its
346
  /// value is false, then this fragment serves only as a placeholder,
347
  /// containing data to assist other insertion point in their decision making.
348
  bool IsInsertionPoint;
349
350
  uint64_t Size;
351
352
  struct MCInstInfo {
353
    bool IsInitialized;
354
    MCInst Inst;
355
    /// A boolean indicating whether the instruction pointed by this fragment is
356
    /// a fixed size instruction or a relaxable instruction held by a
357
    /// MCRelaxableFragment.
358
    bool IsImmutableSizedInst;
359
    union {
360
      /// If the instruction is a fixed size instruction, hold its size.
361
      size_t InstSize;
362
      /// Otherwise, hold a pointer to the MCRelaxableFragment holding it.
363
      MCRelaxableFragment *InstFragment;
364
    };
365
  };
366
  MCInstInfo InstInfo;
367
368
public:
369
  static const uint64_t PFK_None = UINT64_C(0);
370
371
  enum MCPaddingFragmentKind {
372
    // values 0-7 are reserved for future target independet values.
373
374
    FirstTargetPerfNopFragmentKind = 8,
375
376
    /// Limit range of target MCPerfNopFragment kinds to fit in uint64_t
377
    MaxTargetPerfNopFragmentKind = 63
378
  };
379
380
  MCPaddingFragment(MCSection *Sec = nullptr)
381
      : MCFragment(FT_Padding, false, Sec), PaddingPoliciesMask(PFK_None),
382
        IsInsertionPoint(false), Size(UINT64_C(0)),
383
0
        InstInfo({false, MCInst(), false, {0}}) {}
384
385
0
  bool isInsertionPoint() const { return IsInsertionPoint; }
386
0
  void setAsInsertionPoint() { IsInsertionPoint = true; }
387
0
  uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
388
0
  void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
389
0
  bool hasPaddingPolicy(uint64_t PolicyMask) const {
390
0
    assert(isPowerOf2_64(PolicyMask) &&
391
0
           "Policy mask must contain exactly one policy");
392
0
    return (getPaddingPoliciesMask() & PolicyMask) != PFK_None;
393
0
  }
394
  const MCInst &getInst() const {
395
    assert(isInstructionInitialized() && "Fragment has no instruction!");
396
    return InstInfo.Inst;
397
  }
398
0
  size_t getInstSize() const {
399
0
    assert(isInstructionInitialized() && "Fragment has no instruction!");
400
0
    if (InstInfo.IsImmutableSizedInst)
401
0
      return InstInfo.InstSize;
402
0
    assert(InstInfo.InstFragment != nullptr &&
403
0
           "Must have a valid InstFragment to retrieve InstSize from");
404
0
    return InstInfo.InstFragment->getContents().size();
405
0
  }
406
0
  void setInstAndInstSize(const MCInst &Inst, size_t InstSize) {
407
0
  InstInfo.IsInitialized = true;
408
0
    InstInfo.IsImmutableSizedInst = true;
409
0
    InstInfo.Inst = Inst;
410
0
    InstInfo.InstSize = InstSize;
411
0
  }
412
  void setInstAndInstFragment(const MCInst &Inst,
413
0
                              MCRelaxableFragment *InstFragment) {
414
0
    InstInfo.IsInitialized = true;
415
0
    InstInfo.IsImmutableSizedInst = false;
416
0
    InstInfo.Inst = Inst;
417
0
    InstInfo.InstFragment = InstFragment;
418
0
  }
419
0
  uint64_t getSize() const { return Size; }
420
0
  void setSize(uint64_t Value) { Size = Value; }
421
  bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
422
423
0
  static bool classof(const MCFragment *F) {
424
0
    return F->getKind() == MCFragment::FT_Padding;
425
0
  }
426
};
427
428
class MCFillFragment : public MCFragment {
429
  /// Value to use for filling bytes.
430
  uint64_t Value;
431
  uint8_t ValueSize;
432
  /// The number of bytes to insert.
433
  const MCExpr &NumValues;
434
435
  /// Source location of the directive that this fragment was created for.
436
  SMLoc Loc;
437
438
public:
439
  MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues,
440
                 SMLoc Loc, MCSection *Sec = nullptr)
441
      : MCFragment(FT_Fill, false, Sec), Value(Value), ValueSize(VSize),
442
645k
        NumValues(NumValues), Loc(Loc) {}
443
444
638k
  uint64_t getValue() const { return Value; }
445
1.99M
  uint8_t getValueSize() const { return ValueSize; }
446
1.35M
  const MCExpr &getNumValues() const { return NumValues; }
447
448
6
  SMLoc getLoc() const { return Loc; }
449
450
159
  static bool classof(const MCFragment *F) {
451
159
    return F->getKind() == MCFragment::FT_Fill;
452
159
  }
453
};
454
455
class MCOrgFragment : public MCFragment {
456
  /// The offset this fragment should start at.
457
  const MCExpr *Offset;
458
459
  /// Value to use for filling bytes.
460
  int8_t Value;
461
462
  /// Source location of the directive that this fragment was created for.
463
  SMLoc Loc;
464
465
public:
466
  MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc,
467
                MCSection *Sec = nullptr)
468
19
      : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value), Loc(Loc) {}
469
470
  /// \name Accessors
471
  /// @{
472
473
40
  const MCExpr &getOffset() const { return *Offset; }
474
475
2.46k
  uint8_t getValue() const { return Value; }
476
477
10
  SMLoc getLoc() const { return Loc; }
478
479
  /// @}
480
481
  static bool classof(const MCFragment *F) {
482
    return F->getKind() == MCFragment::FT_Org;
483
  }
484
};
485
486
class MCLEBFragment : public MCFragment {
487
  /// Value - The value this fragment should contain.
488
  const MCExpr *Value;
489
490
  /// IsSigned - True if this is a sleb128, false if uleb128.
491
  bool IsSigned;
492
493
  SmallString<8> Contents;
494
495
public:
496
  MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
497
4.79k
      : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
498
4.79k
    Contents.push_back(0);
499
4.79k
  }
500
501
  /// \name Accessors
502
  /// @{
503
504
10.5k
  const MCExpr &getValue() const { return *Value; }
505
506
10.5k
  bool isSigned() const { return IsSigned; }
507
508
31.6k
  SmallString<8> &getContents() { return Contents; }
509
16.3k
  const SmallString<8> &getContents() const { return Contents; }
510
511
  /// @}
512
513
153
  static bool classof(const MCFragment *F) {
514
153
    return F->getKind() == MCFragment::FT_LEB;
515
153
  }
516
};
517
518
class MCDwarfLineAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
519
  /// LineDelta - the value of the difference between the two line numbers
520
  /// between two .loc dwarf directives.
521
  int64_t LineDelta;
522
523
  /// AddrDelta - The expression for the difference of the two symbols that
524
  /// make up the address delta between two .loc dwarf directives.
525
  const MCExpr *AddrDelta;
526
527
public:
528
  MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta,
529
                          MCSection *Sec = nullptr)
530
      : MCEncodedFragmentWithFixups<8, 1>(FT_Dwarf, false, Sec),
531
1.06M
        LineDelta(LineDelta), AddrDelta(&AddrDelta) {}
532
533
  /// \name Accessors
534
  /// @{
535
536
3.18M
  int64_t getLineDelta() const { return LineDelta; }
537
538
3.18M
  const MCExpr &getAddrDelta() const { return *AddrDelta; }
539
540
  /// @}
541
542
1.06M
  static bool classof(const MCFragment *F) {
543
1.06M
    return F->getKind() == MCFragment::FT_Dwarf;
544
1.06M
  }
545
};
546
547
class MCDwarfCallFrameFragment : public MCFragment {
548
  /// AddrDelta - The expression for the difference of the two symbols that
549
  /// make up the address delta between two .cfi_* dwarf directives.
550
  const MCExpr *AddrDelta;
551
552
  SmallString<8> Contents;
553
554
public:
555
  MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec = nullptr)
556
172k
      : MCFragment(FT_DwarfFrame, false, Sec), AddrDelta(&AddrDelta) {
557
172k
    Contents.push_back(0);
558
172k
  }
559
560
  /// \name Accessors
561
  /// @{
562
563
515k
  const MCExpr &getAddrDelta() const { return *AddrDelta; }
564
565
1.03M
  SmallString<8> &getContents() { return Contents; }
566
516k
  const SmallString<8> &getContents() const { return Contents; }
567
568
  /// @}
569
570
  static bool classof(const MCFragment *F) {
571
    return F->getKind() == MCFragment::FT_DwarfFrame;
572
  }
573
};
574
575
/// Represents a symbol table index fragment.
576
class MCSymbolIdFragment : public MCFragment {
577
  const MCSymbol *Sym;
578
579
public:
580
  MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
581
15
      : MCFragment(FT_SymbolId, false, Sec), Sym(Sym) {}
582
583
  /// \name Accessors
584
  /// @{
585
586
0
  const MCSymbol *getSymbol() { return Sym; }
587
15
  const MCSymbol *getSymbol() const { return Sym; }
588
589
  /// @}
590
591
  static bool classof(const MCFragment *F) {
592
    return F->getKind() == MCFragment::FT_SymbolId;
593
  }
594
};
595
596
/// Fragment representing the binary annotations produced by the
597
/// .cv_inline_linetable directive.
598
class MCCVInlineLineTableFragment : public MCFragment {
599
  unsigned SiteFuncId;
600
  unsigned StartFileId;
601
  unsigned StartLineNum;
602
  const MCSymbol *FnStartSym;
603
  const MCSymbol *FnEndSym;
604
  SmallString<8> Contents;
605
606
  /// CodeViewContext has the real knowledge about this format, so let it access
607
  /// our members.
608
  friend class CodeViewContext;
609
610
public:
611
  MCCVInlineLineTableFragment(unsigned SiteFuncId, unsigned StartFileId,
612
                              unsigned StartLineNum, const MCSymbol *FnStartSym,
613
                              const MCSymbol *FnEndSym,
614
                              MCSection *Sec = nullptr)
615
      : MCFragment(FT_CVInlineLines, false, Sec), SiteFuncId(SiteFuncId),
616
        StartFileId(StartFileId), StartLineNum(StartLineNum),
617
24
        FnStartSym(FnStartSym), FnEndSym(FnEndSym) {}
618
619
  /// \name Accessors
620
  /// @{
621
622
144
  const MCSymbol *getFnStartSym() const { return FnStartSym; }
623
72
  const MCSymbol *getFnEndSym() const { return FnEndSym; }
624
625
216
  SmallString<8> &getContents() { return Contents; }
626
72
  const SmallString<8> &getContents() const { return Contents; }
627
628
  /// @}
629
630
  static bool classof(const MCFragment *F) {
631
    return F->getKind() == MCFragment::FT_CVInlineLines;
632
  }
633
};
634
635
/// Fragment representing the .cv_def_range directive.
636
class MCCVDefRangeFragment : public MCEncodedFragmentWithFixups<32, 4> {
637
  SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 2> Ranges;
638
  SmallString<32> FixedSizePortion;
639
640
  /// CodeViewContext has the real knowledge about this format, so let it access
641
  /// our members.
642
  friend class CodeViewContext;
643
644
public:
645
  MCCVDefRangeFragment(
646
      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
647
      StringRef FixedSizePortion, MCSection *Sec = nullptr)
648
      : MCEncodedFragmentWithFixups<32, 4>(FT_CVDefRange, false, Sec),
649
        Ranges(Ranges.begin(), Ranges.end()),
650
207
        FixedSizePortion(FixedSizePortion) {}
651
652
  /// \name Accessors
653
  /// @{
654
1.86k
  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> getRanges() const {
655
1.86k
    return Ranges;
656
1.86k
  }
657
658
627
  StringRef getFixedSizePortion() const { return FixedSizePortion; }
659
  /// @}
660
661
2.38M
  static bool classof(const MCFragment *F) {
662
2.38M
    return F->getKind() == MCFragment::FT_CVDefRange;
663
2.38M
  }
664
};
665
666
} // end namespace llvm
667
668
#endif // LLVM_MC_MCFRAGMENT_H