LLVM  10.0.0svn
MCFragment.h
Go to the documentation of this file.
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 {
49  };
50 
51 private:
53 
54 protected:
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  FragmentType getKind() const { return Kind; }
97 
98  MCSection *getParent() const { return Parent; }
99  void setParent(MCSection *Value) { Parent = Value; }
100 
101  const MCSymbol *getAtom() const { return Atom; }
102  void setAtom(const MCSymbol *Value) { Atom = Value; }
103 
104  unsigned getLayoutOrder() const { return LayoutOrder; }
105  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  bool hasInstructions() const { return HasInstructions; }
110 
111  /// Return true if given frgment has FT_Dummy type.
112  bool isDummy() const { return Kind == FT_Dummy; }
113 
114  void dump() const;
115 };
116 
117 class MCDummyFragment : public MCFragment {
118 public:
119  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 ///
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:
135  MCSection *Sec)
136  : 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  static bool classof(const MCFragment *F) {
144  MCFragment::FragmentType Kind = F->getKind();
145  switch (Kind) {
146  default:
147  return false;
150  case MCFragment::FT_Data:
153  return true;
154  }
155  }
156 
157  /// Should this fragment be placed at the end of an aligned bundle?
158  bool alignToBundleEnd() const { return AlignToBundleEnd; }
159  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  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  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  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.
179  HasInstructions = true;
180  this->STI = &STI;
181  }
182 };
183 
184 /// Interface implemented by fragments that contain encoded instructions and/or
185 /// data.
186 ///
187 template<unsigned ContentsSize>
190 
191 protected:
193  bool HasInstructions,
194  MCSection *Sec)
195  : MCEncodedFragment(FType, HasInstructions, Sec) {}
196 
197 public:
198  SmallVectorImpl<char> &getContents() { return Contents; }
199  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>
207  public MCEncodedFragmentWithContents<ContentsSize> {
208 
209  /// Fixups - The list of fixups in this fragment.
211 
212 protected:
214  bool HasInstructions,
215  MCSection *Sec)
216  : MCEncodedFragmentWithContents<ContentsSize>(FType, HasInstructions,
217  Sec) {}
218 
219 public:
220 
223 
225  const SmallVectorImpl<MCFixup> &getFixups() const { return Fixups; }
226 
227  fixup_iterator fixup_begin() { return Fixups.begin(); }
228  const_fixup_iterator fixup_begin() const { return Fixups.begin(); }
229 
230  fixup_iterator fixup_end() { return Fixups.end(); }
231  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 ||
238  }
239 };
240 
241 /// Fragment for data and encoded instructions.
242 ///
244 public:
245  MCDataFragment(MCSection *Sec = nullptr)
246  : MCEncodedFragmentWithFixups<32, 4>(FT_Data, false, Sec) {}
247 
248  static bool classof(const MCFragment *F) {
249  return F->getKind() == MCFragment::FT_Data;
250  }
251 };
252 
253 /// This is a compact (memory-size-wise) fragment for holding an encoded
254 /// instruction (non-relaxable) that has no fixups registered. When applicable,
255 /// it can be used instead of MCDataFragment and lead to lower memory
256 /// consumption.
257 ///
259 public:
262  }
263 
264  static bool classof(const MCFragment *F) {
266  }
267 };
268 
269 /// A relaxable fragment holds on to its MCInst, since it may need to be
270 /// relaxed during the assembler layout and relaxation stage.
271 ///
273 
274  /// Inst - The instruction this is a fragment for.
275  MCInst Inst;
276 
277 public:
278  MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI,
279  MCSection *Sec = nullptr)
281  Inst(Inst) { this->STI = &STI; }
282 
283  const MCInst &getInst() const { return Inst; }
284  void setInst(const MCInst &Value) { Inst = Value; }
285 
286  static bool classof(const MCFragment *F) {
287  return F->getKind() == MCFragment::FT_Relaxable;
288  }
289 };
290 
291 class MCAlignFragment : public MCFragment {
292  /// Alignment - The alignment to ensure, in bytes.
293  unsigned Alignment;
294 
295  /// EmitNops - Flag to indicate that (optimal) NOPs should be emitted instead
296  /// of using the provided value. The exact interpretation of this flag is
297  /// target dependent.
298  bool EmitNops : 1;
299 
300  /// Value - Value to use for filling padding bytes.
301  int64_t Value;
302 
303  /// ValueSize - The size of the integer (in bytes) of \p Value.
304  unsigned ValueSize;
305 
306  /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
307  /// cannot be satisfied in this width then this fragment is ignored.
308  unsigned MaxBytesToEmit;
309 
310 public:
311  MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize,
312  unsigned MaxBytesToEmit, MCSection *Sec = nullptr)
313  : MCFragment(FT_Align, false, Sec), Alignment(Alignment), EmitNops(false),
314  Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
315 
316  /// \name Accessors
317  /// @{
318 
319  unsigned getAlignment() const { return Alignment; }
320 
321  int64_t getValue() const { return Value; }
322 
323  unsigned getValueSize() const { return ValueSize; }
324 
325  unsigned getMaxBytesToEmit() const { return MaxBytesToEmit; }
326 
327  bool hasEmitNops() const { return EmitNops; }
328  void setEmitNops(bool Value) { EmitNops = Value; }
329 
330  /// @}
331 
332  static bool classof(const MCFragment *F) {
333  return F->getKind() == MCFragment::FT_Align;
334  }
335 };
336 
337 /// Fragment for adding required padding.
338 /// This fragment is always inserted before an instruction, and holds that
339 /// instruction as context information (as well as a mask of kinds) for
340 /// determining the padding size.
341 ///
343  /// A mask containing all the kinds relevant to this fragment. i.e. the i'th
344  /// bit will be set iff kind i is relevant to this fragment.
345  uint64_t PaddingPoliciesMask;
346  /// A boolean indicating if this fragment will actually hold padding. If its
347  /// value is false, then this fragment serves only as a placeholder,
348  /// containing data to assist other insertion point in their decision making.
349  bool IsInsertionPoint;
350 
351  uint64_t Size;
352 
353  struct MCInstInfo {
354  bool IsInitialized;
355  MCInst Inst;
356  /// A boolean indicating whether the instruction pointed by this fragment is
357  /// a fixed size instruction or a relaxable instruction held by a
358  /// MCRelaxableFragment.
359  bool IsImmutableSizedInst;
360  union {
361  /// If the instruction is a fixed size instruction, hold its size.
362  size_t InstSize;
363  /// Otherwise, hold a pointer to the MCRelaxableFragment holding it.
364  MCRelaxableFragment *InstFragment;
365  };
366  };
367  MCInstInfo InstInfo;
368 
369 public:
370  static const uint64_t PFK_None = UINT64_C(0);
371 
373  // values 0-7 are reserved for future target independet values.
374 
375  FirstTargetPerfNopFragmentKind = 8,
376 
377  /// Limit range of target MCPerfNopFragment kinds to fit in uint64_t
378  MaxTargetPerfNopFragmentKind = 63
379  };
380 
381  MCPaddingFragment(MCSection *Sec = nullptr)
382  : MCFragment(FT_Padding, false, Sec), PaddingPoliciesMask(PFK_None),
383  IsInsertionPoint(false), Size(UINT64_C(0)),
384  InstInfo({false, MCInst(), false, {0}}) {}
385 
386  bool isInsertionPoint() const { return IsInsertionPoint; }
387  void setAsInsertionPoint() { IsInsertionPoint = true; }
388  uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
389  void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
390  bool hasPaddingPolicy(uint64_t PolicyMask) const {
391  assert(isPowerOf2_64(PolicyMask) &&
392  "Policy mask must contain exactly one policy");
393  return (getPaddingPoliciesMask() & PolicyMask) != PFK_None;
394  }
395  const MCInst &getInst() const {
396  assert(isInstructionInitialized() && "Fragment has no instruction!");
397  return InstInfo.Inst;
398  }
399  size_t getInstSize() const {
400  assert(isInstructionInitialized() && "Fragment has no instruction!");
401  if (InstInfo.IsImmutableSizedInst)
402  return InstInfo.InstSize;
403  assert(InstInfo.InstFragment != nullptr &&
404  "Must have a valid InstFragment to retrieve InstSize from");
405  return InstInfo.InstFragment->getContents().size();
406  }
407  void setInstAndInstSize(const MCInst &Inst, size_t InstSize) {
408  InstInfo.IsInitialized = true;
409  InstInfo.IsImmutableSizedInst = true;
410  InstInfo.Inst = Inst;
411  InstInfo.InstSize = InstSize;
412  }
413  void setInstAndInstFragment(const MCInst &Inst,
414  MCRelaxableFragment *InstFragment) {
415  InstInfo.IsInitialized = true;
416  InstInfo.IsImmutableSizedInst = false;
417  InstInfo.Inst = Inst;
418  InstInfo.InstFragment = InstFragment;
419  }
420  uint64_t getSize() const { return Size; }
421  void setSize(uint64_t Value) { Size = Value; }
422  bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
423 
424  static bool classof(const MCFragment *F) {
425  return F->getKind() == MCFragment::FT_Padding;
426  }
427 };
428 
429 class MCFillFragment : public MCFragment {
430  /// Value to use for filling bytes.
431  uint64_t Value;
432  uint8_t ValueSize;
433  /// The number of bytes to insert.
434  const MCExpr &NumValues;
435 
436  /// Source location of the directive that this fragment was created for.
437  SMLoc Loc;
438 
439 public:
440  MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues,
441  SMLoc Loc, MCSection *Sec = nullptr)
442  : MCFragment(FT_Fill, false, Sec), Value(Value), ValueSize(VSize),
443  NumValues(NumValues), Loc(Loc) {}
444 
445  uint64_t getValue() const { return Value; }
446  uint8_t getValueSize() const { return ValueSize; }
447  const MCExpr &getNumValues() const { return NumValues; }
448 
449  SMLoc getLoc() const { return Loc; }
450 
451  static bool classof(const MCFragment *F) {
452  return F->getKind() == MCFragment::FT_Fill;
453  }
454 };
455 
456 class MCOrgFragment : public MCFragment {
457  /// The offset this fragment should start at.
458  const MCExpr *Offset;
459 
460  /// Value to use for filling bytes.
461  int8_t Value;
462 
463  /// Source location of the directive that this fragment was created for.
464  SMLoc Loc;
465 
466 public:
467  MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc,
468  MCSection *Sec = nullptr)
469  : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value), Loc(Loc) {}
470 
471  /// \name Accessors
472  /// @{
473 
474  const MCExpr &getOffset() const { return *Offset; }
475 
476  uint8_t getValue() const { return Value; }
477 
478  SMLoc getLoc() const { return Loc; }
479 
480  /// @}
481 
482  static bool classof(const MCFragment *F) {
483  return F->getKind() == MCFragment::FT_Org;
484  }
485 };
486 
487 class MCLEBFragment : public MCFragment {
488  /// Value - The value this fragment should contain.
489  const MCExpr *Value;
490 
491  /// IsSigned - True if this is a sleb128, false if uleb128.
492  bool IsSigned;
493 
494  SmallString<8> Contents;
495 
496 public:
497  MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
498  : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
499  Contents.push_back(0);
500  }
501 
502  /// \name Accessors
503  /// @{
504 
505  const MCExpr &getValue() const { return *Value; }
506 
507  bool isSigned() const { return IsSigned; }
508 
509  SmallString<8> &getContents() { return Contents; }
510  const SmallString<8> &getContents() const { return Contents; }
511 
512  /// @}
513 
514  static bool classof(const MCFragment *F) {
515  return F->getKind() == MCFragment::FT_LEB;
516  }
517 };
518 
520  /// LineDelta - the value of the difference between the two line numbers
521  /// between two .loc dwarf directives.
522  int64_t LineDelta;
523 
524  /// AddrDelta - The expression for the difference of the two symbols that
525  /// make up the address delta between two .loc dwarf directives.
526  const MCExpr *AddrDelta;
527 
528 public:
529  MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta,
530  MCSection *Sec = nullptr)
532  LineDelta(LineDelta), AddrDelta(&AddrDelta) {}
533 
534  /// \name Accessors
535  /// @{
536 
537  int64_t getLineDelta() const { return LineDelta; }
538 
539  const MCExpr &getAddrDelta() const { return *AddrDelta; }
540 
541  /// @}
542 
543  static bool classof(const MCFragment *F) {
544  return F->getKind() == MCFragment::FT_Dwarf;
545  }
546 };
547 
549  /// AddrDelta - The expression for the difference of the two symbols that
550  /// make up the address delta between two .cfi_* dwarf directives.
551  const MCExpr *AddrDelta;
552 
553 public:
554  MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec = nullptr)
556  AddrDelta(&AddrDelta) {}
557 
558  /// \name Accessors
559  /// @{
560 
561  const MCExpr &getAddrDelta() const { return *AddrDelta; }
562 
563  /// @}
564 
565  static bool classof(const MCFragment *F) {
566  return F->getKind() == MCFragment::FT_DwarfFrame;
567  }
568 };
569 
570 /// Represents a symbol table index fragment.
572  const MCSymbol *Sym;
573 
574 public:
575  MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
576  : MCFragment(FT_SymbolId, false, Sec), Sym(Sym) {}
577 
578  /// \name Accessors
579  /// @{
580 
581  const MCSymbol *getSymbol() { return Sym; }
582  const MCSymbol *getSymbol() const { return Sym; }
583 
584  /// @}
585 
586  static bool classof(const MCFragment *F) {
587  return F->getKind() == MCFragment::FT_SymbolId;
588  }
589 };
590 
591 /// Fragment representing the binary annotations produced by the
592 /// .cv_inline_linetable directive.
594  unsigned SiteFuncId;
595  unsigned StartFileId;
596  unsigned StartLineNum;
597  const MCSymbol *FnStartSym;
598  const MCSymbol *FnEndSym;
599  SmallString<8> Contents;
600 
601  /// CodeViewContext has the real knowledge about this format, so let it access
602  /// our members.
603  friend class CodeViewContext;
604 
605 public:
606  MCCVInlineLineTableFragment(unsigned SiteFuncId, unsigned StartFileId,
607  unsigned StartLineNum, const MCSymbol *FnStartSym,
608  const MCSymbol *FnEndSym,
609  MCSection *Sec = nullptr)
610  : MCFragment(FT_CVInlineLines, false, Sec), SiteFuncId(SiteFuncId),
611  StartFileId(StartFileId), StartLineNum(StartLineNum),
612  FnStartSym(FnStartSym), FnEndSym(FnEndSym) {}
613 
614  /// \name Accessors
615  /// @{
616 
617  const MCSymbol *getFnStartSym() const { return FnStartSym; }
618  const MCSymbol *getFnEndSym() const { return FnEndSym; }
619 
620  SmallString<8> &getContents() { return Contents; }
621  const SmallString<8> &getContents() const { return Contents; }
622 
623  /// @}
624 
625  static bool classof(const MCFragment *F) {
626  return F->getKind() == MCFragment::FT_CVInlineLines;
627  }
628 };
629 
630 /// Fragment representing the .cv_def_range directive.
633  SmallString<32> FixedSizePortion;
634 
635  /// CodeViewContext has the real knowledge about this format, so let it access
636  /// our members.
637  friend class CodeViewContext;
638 
639 public:
641  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
642  StringRef FixedSizePortion, MCSection *Sec = nullptr)
644  Ranges(Ranges.begin(), Ranges.end()),
645  FixedSizePortion(FixedSizePortion) {}
646 
647  /// \name Accessors
648  /// @{
650  return Ranges;
651  }
652 
653  StringRef getFixedSizePortion() const { return FixedSizePortion; }
654  /// @}
655 
656  static bool classof(const MCFragment *F) {
657  return F->getKind() == MCFragment::FT_CVDefRange;
658  }
659 };
660 
661 } // end namespace llvm
662 
663 #endif // LLVM_MC_MCFRAGMENT_H
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
bool alignToBundleEnd() const
Should this fragment be placed at the end of an aligned bundle?
Definition: MCFragment.h:158
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:233
MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit, MCSection *Sec=nullptr)
Definition: MCFragment.h:311
MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc, MCSection *Sec=nullptr)
Definition: MCFragment.h:467
static bool classof(const MCFragment *F)
Definition: MCFragment.h:514
Fragment for adding required padding.
Definition: MCFragment.h:342
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:320
MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta, MCSection *Sec=nullptr)
Definition: MCFragment.h:529
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static bool classof(const MCFragment *F)
Definition: MCFragment.h:451
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
uint8_t getValueSize() const
Definition: MCFragment.h:446
SmallString< 8 > & getContents()
Definition: MCFragment.h:620
static bool classof(const MCFragment *F)
Definition: MCFragment.h:121
void push_back(const T &Elt)
Definition: SmallVector.h:211
MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec=nullptr)
Definition: MCFragment.h:575
const MCSymbol * getSymbol() const
Definition: MCFragment.h:582
int64_t getValue() const
Definition: MCFragment.h:321
Interface implemented by fragments that contain encoded instructions and/or data. ...
Definition: MCFragment.h:188
uint64_t getSize() const
Definition: MCFragment.h:420
MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues, SMLoc Loc, MCSection *Sec=nullptr)
Definition: MCFragment.h:440
MCFragment & operator=(const MCFragment &)=delete
FragmentType getKind() const
Definition: MCFragment.h:96
This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that...
Definition: MCFragment.h:258
F(f)
block Block Frequency true
const MCExpr & getOffset() const
Definition: MCFragment.h:474
static void EmitNops(MCStreamer &OS, unsigned NumBytes, bool Is64Bit, const MCSubtargetInfo &STI)
Emit the optimal amount of multi-byte nops on X86.
StringRef getFixedSizePortion() const
Definition: MCFragment.h:653
const_fixup_iterator fixup_begin() const
Definition: MCFragment.h:228
bool hasPaddingPolicy(uint64_t PolicyMask) const
Definition: MCFragment.h:390
bool HasInstructions
Definition: MCFragment.h:55
Interface implemented by fragments that contain encoded instructions and/or data. ...
Definition: MCFragment.h:127
SmallVectorImpl< MCFixup >::const_iterator const_fixup_iterator
Definition: MCFragment.h:221
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
const_fixup_iterator fixup_end() const
Definition: MCFragment.h:231
void setEmitNops(bool Value)
Definition: MCFragment.h:328
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool isInstructionInitialized() const
Definition: MCFragment.h:422
const SmallString< 8 > & getContents() const
Definition: MCFragment.h:621
MCDummyFragment(MCSection *Sec)
Definition: MCFragment.h:119
SMLoc getLoc() const
Definition: MCFragment.h:478
void destroy()
Destroys the current fragment.
Definition: MCFragment.cpp:245
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:539
void setPaddingPoliciesMask(uint64_t Value)
Definition: MCFragment.h:389
void setInstAndInstSize(const MCInst &Inst, size_t InstSize)
Definition: MCFragment.h:407
static bool classof(const MCFragment *F)
Definition: MCFragment.h:543
static bool classof(const MCFragment *F)
Definition: MCFragment.h:143
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:561
MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec=nullptr)
Definition: MCFragment.h:497
MCEncodedFragmentWithContents(MCFragment::FragmentType FType, bool HasInstructions, MCSection *Sec)
Definition: MCFragment.h:192
bool isDummy() const
Return true if given frgment has FT_Dummy type.
Definition: MCFragment.h:112
MCPaddingFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:381
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:198
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI, MCSection *Sec=nullptr)
Definition: MCFragment.h:278
uint8_t getBundlePadding() const
Get the padding size that must be inserted before this fragment.
Definition: MCFragment.h:166
void dump() const
Definition: MCFragment.cpp:312
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:272
const MCInst & getInst() const
Definition: MCFragment.h:395
An ilist node that can access its parent list.
Definition: ilist_node.h:256
static bool classof(const MCFragment *F)
Definition: MCFragment.h:482
static bool classof(const MCFragment *F)
Definition: MCFragment.h:286
const SmallVectorImpl< char > & getContents() const
Definition: MCFragment.h:199
void setHasInstructions(const MCSubtargetInfo &STI)
Record that the fragment contains instructions with the MCSubtargetInfo in effect when the instructio...
Definition: MCFragment.h:178
static bool classof(const MCFragment *F)
Definition: MCFragment.h:233
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:224
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
Definition: MathExtras.h:470
MCEncodedFragment(MCFragment::FragmentType FType, bool HasInstructions, MCSection *Sec)
Definition: MCFragment.h:134
const SmallString< 8 > & getContents() const
Definition: MCFragment.h:510
const MCSymbol * getAtom() const
Definition: MCFragment.h:101
MCCVInlineLineTableFragment(unsigned SiteFuncId, unsigned StartFileId, unsigned StartLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym, MCSection *Sec=nullptr)
Definition: MCFragment.h:606
static bool classof(const MCFragment *F)
Definition: MCFragment.h:332
Fragment representing the .cv_def_range directive.
Definition: MCFragment.h:631
MCCVDefRangeFragment(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion, MCSection *Sec=nullptr)
Definition: MCFragment.h:640
const MCExpr & getValue() const
Definition: MCFragment.h:505
MCEncodedFragmentWithFixups(MCFragment::FragmentType FType, bool HasInstructions, MCSection *Sec)
Definition: MCFragment.h:213
unsigned getMaxBytesToEmit() const
Definition: MCFragment.h:325
bool hasEmitNops() const
Definition: MCFragment.h:327
MCCompactEncodedInstFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:260
SmallVectorImpl< MCFixup >::iterator fixup_iterator
Definition: MCFragment.h:222
Represents a symbol table index fragment.
Definition: MCFragment.h:571
unsigned getLayoutOrder() const
Definition: MCFragment.h:104
uint64_t getPaddingPoliciesMask() const
Definition: MCFragment.h:388
static bool classof(const MCFragment *F)
Definition: MCFragment.h:424
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
Definition: MCFragment.h:170
const MCSymbol * getFnEndSym() const
Definition: MCFragment.h:618
MCSection * getParent() const
Definition: MCFragment.h:98
uint64_t getValue() const
Definition: MCFragment.h:445
const MCExpr & getNumValues() const
Definition: MCFragment.h:447
bool hasInstructions() const
Does this fragment have instructions emitted into it? By default this is false, but specific fragment...
Definition: MCFragment.h:109
const MCSubtargetInfo * getSubtargetInfo() const
Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
Definition: MCFragment.h:174
typename SuperClass::iterator iterator
Definition: SmallVector.h:319
Fragment representing the binary annotations produced by the .cv_inline_linetable directive...
Definition: MCFragment.h:593
const MCSymbol * getFnStartSym() const
Definition: MCFragment.h:617
unsigned getValueSize() const
Definition: MCFragment.h:323
static bool classof(const MCFragment *F)
Definition: MCFragment.h:264
unsigned getAlignment() const
Definition: MCFragment.h:319
void setSize(uint64_t Value)
Definition: MCFragment.h:421
Interface implemented by fragments that contain encoded instructions and/or data and also have fixups...
Definition: MCFragment.h:206
static bool classof(const MCFragment *F)
Definition: MCFragment.h:586
int64_t getLineDelta() const
Definition: MCFragment.h:537
size_t getInstSize() const
Definition: MCFragment.h:399
const MCInst & getInst() const
Definition: MCFragment.h:283
static bool classof(const MCFragment *F)
Definition: MCFragment.h:565
#define N
static bool classof(const MCFragment *F)
Definition: MCFragment.h:656
Generic base class for all target subtargets.
uint32_t Size
Definition: Profile.cpp:46
SMLoc getLoc() const
Definition: MCFragment.h:449
SmallString< 8 > & getContents()
Definition: MCFragment.h:509
const MCSymbol * getSymbol()
Definition: MCFragment.h:581
void setLayoutOrder(unsigned Value)
Definition: MCFragment.h:105
void setAlignToBundleEnd(bool V)
Definition: MCFragment.h:159
Fragment for data and encoded instructions.
Definition: MCFragment.h:243
MCFragment()=delete
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isInsertionPoint() const
Definition: MCFragment.h:386
bool isSigned() const
Definition: MCFragment.h:507
LLVM Value Representation.
Definition: Value.h:74
void setInstAndInstFragment(const MCInst &Inst, MCRelaxableFragment *InstFragment)
Definition: MCFragment.h:413
ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > getRanges() const
Definition: MCFragment.h:649
static bool classof(const MCFragment *F)
Definition: MCFragment.h:248
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
uint8_t getValue() const
Definition: MCFragment.h:476
const SmallVectorImpl< MCFixup > & getFixups() const
Definition: MCFragment.h:225
Represents a location in source code.
Definition: SMLoc.h:23
void setParent(MCSection *Value)
Definition: MCFragment.h:99
MCDataFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:245
MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec=nullptr)
Definition: MCFragment.h:554
void setInst(const MCInst &Value)
Definition: MCFragment.h:284
void setAtom(const MCSymbol *Value)
Definition: MCFragment.h:102
Holds state from .cv_file and .cv_loc directives for later emission.
Definition: MCCodeView.h:137
static bool classof(const MCFragment *F)
Definition: MCFragment.h:625