LLVM  8.0.0svn
MCFragment.h
Go to the documentation of this file.
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 {
50  };
51 
52 private:
54 
55 protected:
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  FragmentType getKind() const { return Kind; }
98 
99  MCSection *getParent() const { return Parent; }
100  void setParent(MCSection *Value) { Parent = Value; }
101 
102  const MCSymbol *getAtom() const { return Atom; }
103  void setAtom(const MCSymbol *Value) { Atom = Value; }
104 
105  unsigned getLayoutOrder() const { return LayoutOrder; }
106  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  bool hasInstructions() const { return HasInstructions; }
111 
112  /// Return true if given frgment has FT_Dummy type.
113  bool isDummy() const { return Kind == FT_Dummy; }
114 
115  void dump() const;
116 };
117 
118 class MCDummyFragment : public MCFragment {
119 public:
120  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 ///
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:
136  MCSection *Sec)
137  : 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  static bool classof(const MCFragment *F) {
145  MCFragment::FragmentType Kind = F->getKind();
146  switch (Kind) {
147  default:
148  return false;
151  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 ||
237  }
238 };
239 
240 /// Fragment for data and encoded instructions.
241 ///
243 public:
244  MCDataFragment(MCSection *Sec = nullptr)
245  : MCEncodedFragmentWithFixups<32, 4>(FT_Data, false, Sec) {}
246 
247  static bool classof(const MCFragment *F) {
248  return F->getKind() == MCFragment::FT_Data;
249  }
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 ///
258 public:
261  }
262 
263  static bool classof(const MCFragment *F) {
265  }
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 ///
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)
280  Inst(Inst) { this->STI = &STI; }
281 
282  const MCInst &getInst() const { return Inst; }
283  void setInst(const MCInst &Value) { Inst = Value; }
284 
285  static bool classof(const MCFragment *F) {
286  return F->getKind() == MCFragment::FT_Relaxable;
287  }
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  Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
314 
315  /// \name Accessors
316  /// @{
317 
318  unsigned getAlignment() const { return Alignment; }
319 
320  int64_t getValue() const { return Value; }
321 
322  unsigned getValueSize() const { return ValueSize; }
323 
324  unsigned getMaxBytesToEmit() const { return MaxBytesToEmit; }
325 
326  bool hasEmitNops() const { return EmitNops; }
327  void setEmitNops(bool Value) { EmitNops = Value; }
328 
329  /// @}
330 
331  static bool classof(const MCFragment *F) {
332  return F->getKind() == MCFragment::FT_Align;
333  }
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 ///
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 
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  InstInfo({false, MCInst(), false, {0}}) {}
384 
385  bool isInsertionPoint() const { return IsInsertionPoint; }
386  void setAsInsertionPoint() { IsInsertionPoint = true; }
387  uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
388  void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
389  bool hasPaddingPolicy(uint64_t PolicyMask) const {
390  assert(isPowerOf2_64(PolicyMask) &&
391  "Policy mask must contain exactly one policy");
392  return (getPaddingPoliciesMask() & PolicyMask) != PFK_None;
393  }
394  const MCInst &getInst() const {
395  assert(isInstructionInitialized() && "Fragment has no instruction!");
396  return InstInfo.Inst;
397  }
398  size_t getInstSize() const {
399  assert(isInstructionInitialized() && "Fragment has no instruction!");
400  if (InstInfo.IsImmutableSizedInst)
401  return InstInfo.InstSize;
402  assert(InstInfo.InstFragment != nullptr &&
403  "Must have a valid InstFragment to retrieve InstSize from");
404  return InstInfo.InstFragment->getContents().size();
405  }
406  void setInstAndInstSize(const MCInst &Inst, size_t InstSize) {
407  InstInfo.IsInitialized = true;
408  InstInfo.IsImmutableSizedInst = true;
409  InstInfo.Inst = Inst;
410  InstInfo.InstSize = InstSize;
411  }
412  void setInstAndInstFragment(const MCInst &Inst,
413  MCRelaxableFragment *InstFragment) {
414  InstInfo.IsInitialized = true;
415  InstInfo.IsImmutableSizedInst = false;
416  InstInfo.Inst = Inst;
417  InstInfo.InstFragment = InstFragment;
418  }
419  uint64_t getSize() const { return Size; }
420  void setSize(uint64_t Value) { Size = Value; }
421  bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
422 
423  static bool classof(const MCFragment *F) {
424  return F->getKind() == MCFragment::FT_Padding;
425  }
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  NumValues(NumValues), Loc(Loc) {}
443 
444  uint64_t getValue() const { return Value; }
445  uint8_t getValueSize() const { return ValueSize; }
446  const MCExpr &getNumValues() const { return NumValues; }
447 
448  SMLoc getLoc() const { return Loc; }
449 
450  static bool classof(const MCFragment *F) {
451  return F->getKind() == MCFragment::FT_Fill;
452  }
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  : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value), Loc(Loc) {}
469 
470  /// \name Accessors
471  /// @{
472 
473  const MCExpr &getOffset() const { return *Offset; }
474 
475  uint8_t getValue() const { return Value; }
476 
477  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  : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
498  Contents.push_back(0);
499  }
500 
501  /// \name Accessors
502  /// @{
503 
504  const MCExpr &getValue() const { return *Value; }
505 
506  bool isSigned() const { return IsSigned; }
507 
508  SmallString<8> &getContents() { return Contents; }
509  const SmallString<8> &getContents() const { return Contents; }
510 
511  /// @}
512 
513  static bool classof(const MCFragment *F) {
514  return F->getKind() == MCFragment::FT_LEB;
515  }
516 };
517 
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)
531  LineDelta(LineDelta), AddrDelta(&AddrDelta) {}
532 
533  /// \name Accessors
534  /// @{
535 
536  int64_t getLineDelta() const { return LineDelta; }
537 
538  const MCExpr &getAddrDelta() const { return *AddrDelta; }
539 
540  /// @}
541 
542  static bool classof(const MCFragment *F) {
543  return F->getKind() == MCFragment::FT_Dwarf;
544  }
545 };
546 
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  : MCFragment(FT_DwarfFrame, false, Sec), AddrDelta(&AddrDelta) {
557  Contents.push_back(0);
558  }
559 
560  /// \name Accessors
561  /// @{
562 
563  const MCExpr &getAddrDelta() const { return *AddrDelta; }
564 
565  SmallString<8> &getContents() { return Contents; }
566  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.
577  const MCSymbol *Sym;
578 
579 public:
580  MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
581  : MCFragment(FT_SymbolId, false, Sec), Sym(Sym) {}
582 
583  /// \name Accessors
584  /// @{
585 
586  const MCSymbol *getSymbol() { return Sym; }
587  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.
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  FnStartSym(FnStartSym), FnEndSym(FnEndSym) {}
618 
619  /// \name Accessors
620  /// @{
621 
622  const MCSymbol *getFnStartSym() const { return FnStartSym; }
623  const MCSymbol *getFnEndSym() const { return FnEndSym; }
624 
625  SmallString<8> &getContents() { return Contents; }
626  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.
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:
646  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
647  StringRef FixedSizePortion, MCSection *Sec = nullptr)
649  Ranges(Ranges.begin(), Ranges.end()),
650  FixedSizePortion(FixedSizePortion) {}
651 
652  /// \name Accessors
653  /// @{
655  return Ranges;
656  }
657 
658  StringRef getFixedSizePortion() const { return FixedSizePortion; }
659  /// @}
660 
661  static bool classof(const MCFragment *F) {
662  return F->getKind() == MCFragment::FT_CVDefRange;
663  }
664 };
665 
666 } // end namespace llvm
667 
668 #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
void push_back(const T &Elt)
Definition: SmallVector.h:218
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:259
MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit, MCSection *Sec=nullptr)
Definition: MCFragment.h:310
MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc, MCSection *Sec=nullptr)
Definition: MCFragment.h:466
static bool classof(const MCFragment *F)
Definition: MCFragment.h:513
Fragment for adding required padding.
Definition: MCFragment.h:341
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:250
typename SuperClass::const_iterator const_iterator
Definition: SmallVector.h:328
MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta, MCSection *Sec=nullptr)
Definition: MCFragment.h:528
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static bool classof(const MCFragment *F)
Definition: MCFragment.h:450
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
uint8_t getValueSize() const
Definition: MCFragment.h:445
SmallString< 8 > & getContents()
Definition: MCFragment.h:625
static bool classof(const MCFragment *F)
Definition: MCFragment.h:122
const SmallString< 8 > & getContents() const
Definition: MCFragment.h:566
MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec=nullptr)
Definition: MCFragment.h:580
const MCSymbol * getSymbol() const
Definition: MCFragment.h:587
int64_t getValue() const
Definition: MCFragment.h:320
Interface implemented by fragments that contain encoded instructions and/or data. ...
Definition: MCFragment.h:188
uint64_t getSize() const
Definition: MCFragment.h:419
MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues, SMLoc Loc, MCSection *Sec=nullptr)
Definition: MCFragment.h:439
MCFragment & operator=(const MCFragment &)=delete
FragmentType getKind() const
Definition: MCFragment.h:97
This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that...
Definition: MCFragment.h:257
F(f)
block Block Frequency true
const MCExpr & getOffset() const
Definition: MCFragment.h:473
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:658
const_fixup_iterator fixup_begin() const
Definition: MCFragment.h:228
bool hasPaddingPolicy(uint64_t PolicyMask) const
Definition: MCFragment.h:389
bool HasInstructions
Definition: MCFragment.h:56
Interface implemented by fragments that contain encoded instructions and/or data. ...
Definition: MCFragment.h:128
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:29
const_fixup_iterator fixup_end() const
Definition: MCFragment.h:231
void setEmitNops(bool Value)
Definition: MCFragment.h:327
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
bool isInstructionInitialized() const
Definition: MCFragment.h:421
const SmallString< 8 > & getContents() const
Definition: MCFragment.h:626
MCDummyFragment(MCSection *Sec)
Definition: MCFragment.h:120
SMLoc getLoc() const
Definition: MCFragment.h:477
void destroy()
Destroys the current fragment.
Definition: MCFragment.cpp:246
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:538
void setPaddingPoliciesMask(uint64_t Value)
Definition: MCFragment.h:388
void setInstAndInstSize(const MCInst &Inst, size_t InstSize)
Definition: MCFragment.h:406
static bool classof(const MCFragment *F)
Definition: MCFragment.h:542
static bool classof(const MCFragment *F)
Definition: MCFragment.h:144
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:563
MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec=nullptr)
Definition: MCFragment.h:496
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:113
MCPaddingFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:380
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:198
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:161
MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI, MCSection *Sec=nullptr)
Definition: MCFragment.h:277
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:313
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:271
const MCInst & getInst() const
Definition: MCFragment.h:394
An ilist node that can access its parent list.
Definition: ilist_node.h:257
static bool classof(const MCFragment *F)
Definition: MCFragment.h:481
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:129
static bool classof(const MCFragment *F)
Definition: MCFragment.h:285
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:434
MCEncodedFragment(MCFragment::FragmentType FType, bool HasInstructions, MCSection *Sec)
Definition: MCFragment.h:135
const SmallString< 8 > & getContents() const
Definition: MCFragment.h:509
const MCSymbol * getAtom() const
Definition: MCFragment.h:102
MCCVInlineLineTableFragment(unsigned SiteFuncId, unsigned StartFileId, unsigned StartLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym, MCSection *Sec=nullptr)
Definition: MCFragment.h:611
static bool classof(const MCFragment *F)
Definition: MCFragment.h:331
Fragment representing the .cv_def_range directive.
Definition: MCFragment.h:636
MCCVDefRangeFragment(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion, MCSection *Sec=nullptr)
Definition: MCFragment.h:645
const MCExpr & getValue() const
Definition: MCFragment.h:504
MCEncodedFragmentWithFixups(MCFragment::FragmentType FType, bool HasInstructions, MCSection *Sec)
Definition: MCFragment.h:213
unsigned getMaxBytesToEmit() const
Definition: MCFragment.h:324
bool hasEmitNops() const
Definition: MCFragment.h:326
MCCompactEncodedInstFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:259
SmallVectorImpl< MCFixup >::iterator fixup_iterator
Definition: MCFragment.h:222
Represents a symbol table index fragment.
Definition: MCFragment.h:576
unsigned getLayoutOrder() const
Definition: MCFragment.h:105
uint64_t getPaddingPoliciesMask() const
Definition: MCFragment.h:387
static bool classof(const MCFragment *F)
Definition: MCFragment.h:423
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
Definition: MCFragment.h:170
const MCSymbol * getFnEndSym() const
Definition: MCFragment.h:623
MCSection * getParent() const
Definition: MCFragment.h:99
uint64_t getValue() const
Definition: MCFragment.h:444
const MCExpr & getNumValues() const
Definition: MCFragment.h:446
bool hasInstructions() const
Does this fragment have instructions emitted into it? By default this is false, but specific fragment...
Definition: MCFragment.h:110
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:327
SmallString< 8 > & getContents()
Definition: MCFragment.h:565
Fragment representing the binary annotations produced by the .cv_inline_linetable directive...
Definition: MCFragment.h:598
const MCSymbol * getFnStartSym() const
Definition: MCFragment.h:622
unsigned getValueSize() const
Definition: MCFragment.h:322
static bool classof(const MCFragment *F)
Definition: MCFragment.h:263
unsigned getAlignment() const
Definition: MCFragment.h:318
void setSize(uint64_t Value)
Definition: MCFragment.h:420
Interface implemented by fragments that contain encoded instructions and/or data and also have fixups...
Definition: MCFragment.h:206
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:133
static bool classof(const MCFragment *F)
Definition: MCFragment.h:591
int64_t getLineDelta() const
Definition: MCFragment.h:536
size_t getInstSize() const
Definition: MCFragment.h:398
const MCInst & getInst() const
Definition: MCFragment.h:282
static bool classof(const MCFragment *F)
Definition: MCFragment.h:570
#define N
static bool classof(const MCFragment *F)
Definition: MCFragment.h:661
Generic base class for all target subtargets.
uint32_t Size
Definition: Profile.cpp:47
SMLoc getLoc() const
Definition: MCFragment.h:448
SmallString< 8 > & getContents()
Definition: MCFragment.h:508
const MCSymbol * getSymbol()
Definition: MCFragment.h:586
void setLayoutOrder(unsigned Value)
Definition: MCFragment.h:106
void setAlignToBundleEnd(bool V)
Definition: MCFragment.h:159
const unsigned Kind
Fragment for data and encoded instructions.
Definition: MCFragment.h:242
MCFragment()=delete
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isInsertionPoint() const
Definition: MCFragment.h:385
bool isSigned() const
Definition: MCFragment.h:506
LLVM Value Representation.
Definition: Value.h:73
void setInstAndInstFragment(const MCInst &Inst, MCRelaxableFragment *InstFragment)
Definition: MCFragment.h:412
ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > getRanges() const
Definition: MCFragment.h:654
static bool classof(const MCFragment *F)
Definition: MCFragment.h:247
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
uint8_t getValue() const
Definition: MCFragment.h:475
const SmallVectorImpl< MCFixup > & getFixups() const
Definition: MCFragment.h:225
Represents a location in source code.
Definition: SMLoc.h:24
void setParent(MCSection *Value)
Definition: MCFragment.h:100
MCDataFragment(MCSection *Sec=nullptr)
Definition: MCFragment.h:244
MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec=nullptr)
Definition: MCFragment.h:555
void setInst(const MCInst &Value)
Definition: MCFragment.h:283
void setAtom(const MCSymbol *Value)
Definition: MCFragment.h:103
Holds state from .cv_file and .cv_loc directives for later emission.
Definition: MCCodeView.h:138
static bool classof(const MCFragment *F)
Definition: MCFragment.h:630