Coverage Report

Created: 2019-02-20 00:17

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