LLVM  10.0.0svn
MCFragment.cpp
Go to the documentation of this file.
1 //===- lib/MC/MCFragment.cpp - Assembler Fragment Implementation ----------===//
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 #include "llvm/MC/MCFragment.h"
10 #include "llvm/ADT/SmallVector.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/ADT/Twine.h"
13 #include "llvm/Config/llvm-config.h"
14 #include "llvm/MC/MCAsmLayout.h"
15 #include "llvm/MC/MCAssembler.h"
16 #include "llvm/MC/MCContext.h"
17 #include "llvm/MC/MCExpr.h"
18 #include "llvm/MC/MCFixup.h"
19 #include "llvm/MC/MCSection.h"
20 #include "llvm/MC/MCSymbol.h"
21 #include "llvm/MC/MCValue.h"
22 #include "llvm/Support/Casting.h"
23 #include "llvm/Support/Compiler.h"
26 #include <cassert>
27 #include <cstdint>
28 #include <utility>
29 
30 using namespace llvm;
31 
33  // Compute the section layout order. Virtual sections must go last.
34  for (MCSection &Sec : Asm)
35  if (!Sec.isVirtualSection())
36  SectionOrder.push_back(&Sec);
37  for (MCSection &Sec : Asm)
38  if (Sec.isVirtualSection())
39  SectionOrder.push_back(&Sec);
40 }
41 
42 bool MCAsmLayout::isFragmentValid(const MCFragment *F) const {
43  const MCSection *Sec = F->getParent();
44  const MCFragment *LastValid = LastValidFragment.lookup(Sec);
45  if (!LastValid)
46  return false;
47  assert(LastValid->getParent() == Sec);
48  return F->getLayoutOrder() <= LastValid->getLayoutOrder();
49 }
50 
52  // If this fragment wasn't already valid, we don't need to do anything.
53  if (!isFragmentValid(F))
54  return;
55 
56  // Otherwise, reset the last valid fragment to the previous fragment
57  // (if this is the first fragment, it will be NULL).
58  LastValidFragment[F->getParent()] = F->getPrevNode();
59 }
60 
61 void MCAsmLayout::ensureValid(const MCFragment *F) const {
62  MCSection *Sec = F->getParent();
64  if (MCFragment *Cur = LastValidFragment[Sec])
65  I = ++MCSection::iterator(Cur);
66  else
67  I = Sec->begin();
68 
69  // Advance the layout position until the fragment is valid.
70  while (!isFragmentValid(F)) {
71  assert(I != Sec->end() && "Layout bookkeeping error");
72  const_cast<MCAsmLayout *>(this)->layoutFragment(&*I);
73  ++I;
74  }
75 }
76 
77 uint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const {
78  ensureValid(F);
79  assert(F->Offset != ~UINT64_C(0) && "Address not set!");
80  return F->Offset;
81 }
82 
83 // Simple getSymbolOffset helper for the non-variable case.
84 static bool getLabelOffset(const MCAsmLayout &Layout, const MCSymbol &S,
85  bool ReportError, uint64_t &Val) {
86  if (!S.getFragment()) {
87  if (ReportError)
88  report_fatal_error("unable to evaluate offset to undefined symbol '" +
89  S.getName() + "'");
90  return false;
91  }
92  Val = Layout.getFragmentOffset(S.getFragment()) + S.getOffset();
93  return true;
94 }
95 
96 static bool getSymbolOffsetImpl(const MCAsmLayout &Layout, const MCSymbol &S,
97  bool ReportError, uint64_t &Val) {
98  if (!S.isVariable())
99  return getLabelOffset(Layout, S, ReportError, Val);
100 
101  // If SD is a variable, evaluate it.
102  MCValue Target;
103  if (!S.getVariableValue()->evaluateAsValue(Target, Layout))
104  report_fatal_error("unable to evaluate offset for variable '" +
105  S.getName() + "'");
106 
107  uint64_t Offset = Target.getConstant();
108 
109  const MCSymbolRefExpr *A = Target.getSymA();
110  if (A) {
111  uint64_t ValA;
112  if (!getLabelOffset(Layout, A->getSymbol(), ReportError, ValA))
113  return false;
114  Offset += ValA;
115  }
116 
117  const MCSymbolRefExpr *B = Target.getSymB();
118  if (B) {
119  uint64_t ValB;
120  if (!getLabelOffset(Layout, B->getSymbol(), ReportError, ValB))
121  return false;
122  Offset -= ValB;
123  }
124 
125  Val = Offset;
126  return true;
127 }
128 
129 bool MCAsmLayout::getSymbolOffset(const MCSymbol &S, uint64_t &Val) const {
130  return getSymbolOffsetImpl(*this, S, false, Val);
131 }
132 
133 uint64_t MCAsmLayout::getSymbolOffset(const MCSymbol &S) const {
134  uint64_t Val;
135  getSymbolOffsetImpl(*this, S, true, Val);
136  return Val;
137 }
138 
140  if (!Symbol.isVariable())
141  return &Symbol;
142 
143  const MCExpr *Expr = Symbol.getVariableValue();
144  MCValue Value;
145  if (!Expr->evaluateAsValue(Value, *this)) {
146  Assembler.getContext().reportError(
147  Expr->getLoc(), "expression could not be evaluated");
148  return nullptr;
149  }
150 
151  const MCSymbolRefExpr *RefB = Value.getSymB();
152  if (RefB) {
153  Assembler.getContext().reportError(
154  Expr->getLoc(), Twine("symbol '") + RefB->getSymbol().getName() +
155  "' could not be evaluated in a subtraction expression");
156  return nullptr;
157  }
158 
159  const MCSymbolRefExpr *A = Value.getSymA();
160  if (!A)
161  return nullptr;
162 
163  const MCSymbol &ASym = A->getSymbol();
164  const MCAssembler &Asm = getAssembler();
165  if (ASym.isCommon()) {
166  Asm.getContext().reportError(Expr->getLoc(),
167  "Common symbol '" + ASym.getName() +
168  "' cannot be used in assignment expr");
169  return nullptr;
170  }
171 
172  return &ASym;
173 }
174 
175 uint64_t MCAsmLayout::getSectionAddressSize(const MCSection *Sec) const {
176  // The size is the last fragment's end offset.
177  const MCFragment &F = Sec->getFragmentList().back();
178  return getFragmentOffset(&F) + getAssembler().computeFragmentSize(*this, F);
179 }
180 
181 uint64_t MCAsmLayout::getSectionFileSize(const MCSection *Sec) const {
182  // Virtual sections have no file size.
183  if (Sec->isVirtualSection())
184  return 0;
185 
186  // Otherwise, the file size is the same as the address space size.
187  return getSectionAddressSize(Sec);
188 }
189 
190 uint64_t llvm::computeBundlePadding(const MCAssembler &Assembler,
191  const MCEncodedFragment *F,
192  uint64_t FOffset, uint64_t FSize) {
193  uint64_t BundleSize = Assembler.getBundleAlignSize();
194  assert(BundleSize > 0 &&
195  "computeBundlePadding should only be called if bundling is enabled");
196  uint64_t BundleMask = BundleSize - 1;
197  uint64_t OffsetInBundle = FOffset & BundleMask;
198  uint64_t EndOfFragment = OffsetInBundle + FSize;
199 
200  // There are two kinds of bundling restrictions:
201  //
202  // 1) For alignToBundleEnd(), add padding to ensure that the fragment will
203  // *end* on a bundle boundary.
204  // 2) Otherwise, check if the fragment would cross a bundle boundary. If it
205  // would, add padding until the end of the bundle so that the fragment
206  // will start in a new one.
207  if (F->alignToBundleEnd()) {
208  // Three possibilities here:
209  //
210  // A) The fragment just happens to end at a bundle boundary, so we're good.
211  // B) The fragment ends before the current bundle boundary: pad it just
212  // enough to reach the boundary.
213  // C) The fragment ends after the current bundle boundary: pad it until it
214  // reaches the end of the next bundle boundary.
215  //
216  // Note: this code could be made shorter with some modulo trickery, but it's
217  // intentionally kept in its more explicit form for simplicity.
218  if (EndOfFragment == BundleSize)
219  return 0;
220  else if (EndOfFragment < BundleSize)
221  return BundleSize - EndOfFragment;
222  else { // EndOfFragment > BundleSize
223  return 2 * BundleSize - EndOfFragment;
224  }
225  } else if (OffsetInBundle > 0 && EndOfFragment > BundleSize)
226  return BundleSize - OffsetInBundle;
227  else
228  return 0;
229 }
230 
231 /* *** */
232 
234 
235 MCFragment::~MCFragment() = default;
236 
238  MCSection *Parent)
239  : Kind(Kind), HasInstructions(HasInstructions), LayoutOrder(0),
240  Parent(Parent), Atom(nullptr), Offset(~UINT64_C(0)) {
241  if (Parent && !isDummy())
242  Parent->getFragmentList().push_back(this);
243 }
244 
246  // First check if we are the sentinal.
247  if (Kind == FragmentType(~0)) {
248  delete this;
249  return;
250  }
251 
252  switch (Kind) {
253  case FT_Align:
254  delete cast<MCAlignFragment>(this);
255  return;
256  case FT_Data:
257  delete cast<MCDataFragment>(this);
258  return;
260  delete cast<MCCompactEncodedInstFragment>(this);
261  return;
262  case FT_Fill:
263  delete cast<MCFillFragment>(this);
264  return;
265  case FT_Relaxable:
266  delete cast<MCRelaxableFragment>(this);
267  return;
268  case FT_Org:
269  delete cast<MCOrgFragment>(this);
270  return;
271  case FT_Dwarf:
272  delete cast<MCDwarfLineAddrFragment>(this);
273  return;
274  case FT_DwarfFrame:
275  delete cast<MCDwarfCallFrameFragment>(this);
276  return;
277  case FT_LEB:
278  delete cast<MCLEBFragment>(this);
279  return;
280  case FT_Padding:
281  delete cast<MCPaddingFragment>(this);
282  return;
283  case FT_SymbolId:
284  delete cast<MCSymbolIdFragment>(this);
285  return;
286  case FT_CVInlineLines:
287  delete cast<MCCVInlineLineTableFragment>(this);
288  return;
289  case FT_CVDefRange:
290  delete cast<MCCVDefRangeFragment>(this);
291  return;
292  case FT_Dummy:
293  delete cast<MCDummyFragment>(this);
294  return;
295  }
296 }
297 
298 // Debugging methods
299 
300 namespace llvm {
301 
303  OS << "<MCFixup" << " Offset:" << AF.getOffset()
304  << " Value:" << *AF.getValue()
305  << " Kind:" << AF.getKind() << ">";
306  return OS;
307 }
308 
309 } // end namespace llvm
310 
311 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
313  raw_ostream &OS = errs();
314 
315  OS << "<";
316  switch (getKind()) {
317  case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
318  case MCFragment::FT_Data: OS << "MCDataFragment"; break;
320  OS << "MCCompactEncodedInstFragment"; break;
321  case MCFragment::FT_Fill: OS << "MCFillFragment"; break;
322  case MCFragment::FT_Relaxable: OS << "MCRelaxableFragment"; break;
323  case MCFragment::FT_Org: OS << "MCOrgFragment"; break;
324  case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
325  case MCFragment::FT_DwarfFrame: OS << "MCDwarfCallFrameFragment"; break;
326  case MCFragment::FT_LEB: OS << "MCLEBFragment"; break;
327  case MCFragment::FT_Padding: OS << "MCPaddingFragment"; break;
328  case MCFragment::FT_SymbolId: OS << "MCSymbolIdFragment"; break;
329  case MCFragment::FT_CVInlineLines: OS << "MCCVInlineLineTableFragment"; break;
330  case MCFragment::FT_CVDefRange: OS << "MCCVDefRangeTableFragment"; break;
331  case MCFragment::FT_Dummy: OS << "MCDummyFragment"; break;
332  }
333 
334  OS << "<MCFragment " << (const void *)this << " LayoutOrder:" << LayoutOrder
335  << " Offset:" << Offset << " HasInstructions:" << hasInstructions();
336  if (const MCEncodedFragment *EF = dyn_cast<MCEncodedFragment>(this))
337  OS << " BundlePadding:" << static_cast<unsigned>(EF->getBundlePadding());
338  OS << ">";
339 
340  switch (getKind()) {
341  case MCFragment::FT_Align: {
342  const MCAlignFragment *AF = cast<MCAlignFragment>(this);
343  if (AF->hasEmitNops())
344  OS << " (emit nops)";
345  OS << "\n ";
346  OS << " Alignment:" << AF->getAlignment()
347  << " Value:" << AF->getValue() << " ValueSize:" << AF->getValueSize()
348  << " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
349  break;
350  }
351  case MCFragment::FT_Data: {
352  const MCDataFragment *DF = cast<MCDataFragment>(this);
353  OS << "\n ";
354  OS << " Contents:[";
355  const SmallVectorImpl<char> &Contents = DF->getContents();
356  for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
357  if (i) OS << ",";
358  OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
359  }
360  OS << "] (" << Contents.size() << " bytes)";
361 
362  if (DF->fixup_begin() != DF->fixup_end()) {
363  OS << ",\n ";
364  OS << " Fixups:[";
366  ie = DF->fixup_end(); it != ie; ++it) {
367  if (it != DF->fixup_begin()) OS << ",\n ";
368  OS << *it;
369  }
370  OS << "]";
371  }
372  break;
373  }
375  const MCCompactEncodedInstFragment *CEIF =
376  cast<MCCompactEncodedInstFragment>(this);
377  OS << "\n ";
378  OS << " Contents:[";
379  const SmallVectorImpl<char> &Contents = CEIF->getContents();
380  for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
381  if (i) OS << ",";
382  OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
383  }
384  OS << "] (" << Contents.size() << " bytes)";
385  break;
386  }
387  case MCFragment::FT_Fill: {
388  const MCFillFragment *FF = cast<MCFillFragment>(this);
389  OS << " Value:" << static_cast<unsigned>(FF->getValue())
390  << " ValueSize:" << static_cast<unsigned>(FF->getValueSize())
391  << " NumValues:" << FF->getNumValues();
392  break;
393  }
395  const MCRelaxableFragment *F = cast<MCRelaxableFragment>(this);
396  OS << "\n ";
397  OS << " Inst:";
398  F->getInst().dump_pretty(OS);
399  break;
400  }
401  case MCFragment::FT_Org: {
402  const MCOrgFragment *OF = cast<MCOrgFragment>(this);
403  OS << "\n ";
404  OS << " Offset:" << OF->getOffset()
405  << " Value:" << static_cast<unsigned>(OF->getValue());
406  break;
407  }
408  case MCFragment::FT_Dwarf: {
409  const MCDwarfLineAddrFragment *OF = cast<MCDwarfLineAddrFragment>(this);
410  OS << "\n ";
411  OS << " AddrDelta:" << OF->getAddrDelta()
412  << " LineDelta:" << OF->getLineDelta();
413  break;
414  }
416  const MCDwarfCallFrameFragment *CF = cast<MCDwarfCallFrameFragment>(this);
417  OS << "\n ";
418  OS << " AddrDelta:" << CF->getAddrDelta();
419  break;
420  }
421  case MCFragment::FT_LEB: {
422  const MCLEBFragment *LF = cast<MCLEBFragment>(this);
423  OS << "\n ";
424  OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
425  break;
426  }
427  case MCFragment::FT_Padding: {
428  const MCPaddingFragment *F = cast<MCPaddingFragment>(this);
429  OS << "\n ";
430  OS << " PaddingPoliciesMask:" << F->getPaddingPoliciesMask()
431  << " IsInsertionPoint:" << F->isInsertionPoint()
432  << " Size:" << F->getSize();
433  OS << "\n ";
434  OS << " Inst:";
435  F->getInst().dump_pretty(OS);
436  OS << " InstSize:" << F->getInstSize();
437  OS << "\n ";
438  break;
439  }
441  const MCSymbolIdFragment *F = cast<MCSymbolIdFragment>(this);
442  OS << "\n ";
443  OS << " Sym:" << F->getSymbol();
444  break;
445  }
447  const auto *F = cast<MCCVInlineLineTableFragment>(this);
448  OS << "\n ";
449  OS << " Sym:" << *F->getFnStartSym();
450  break;
451  }
453  const auto *F = cast<MCCVDefRangeFragment>(this);
454  OS << "\n ";
455  for (std::pair<const MCSymbol *, const MCSymbol *> RangeStartEnd :
456  F->getRanges()) {
457  OS << " RangeStart:" << RangeStartEnd.first;
458  OS << " RangeEnd:" << RangeStartEnd.second;
459  }
460  break;
461  }
463  break;
464  }
465  OS << ">";
466 }
467 #endif
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
static bool getSymbolOffsetImpl(const MCAsmLayout &Layout, const MCSymbol &S, bool ReportError, uint64_t &Val)
Definition: MCFragment.cpp:96
Fragment for adding required padding.
Definition: MCFragment.h:342
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:297
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:476
This represents an "assembler immediate".
Definition: MCValue.h:39
uint64_t getSectionAddressSize(const MCSection *Sec) const
Get the address space size of the given section, as it effects layout.
Definition: MCFragment.cpp:175
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
void dump_pretty(raw_ostream &OS, const MCInstPrinter *Printer=nullptr, StringRef Separator=" ") const
Dump the MCInst as prettily as possible using the additional MC structures, if given.
Definition: MCInst.cpp:72
int64_t getValue() const
Definition: MCFragment.h:321
uint64_t getSize() const
Definition: MCFragment.h:420
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)
const MCExpr & getOffset() const
Definition: MCFragment.h:474
bool isCommon() const
Is this a &#39;common&#39; symbol.
Definition: MCSymbol.h:386
static bool getLabelOffset(const MCAsmLayout &Layout, const MCSymbol &S, bool ReportError, uint64_t &Val)
Definition: MCFragment.cpp:84
SMLoc getLoc() const
Definition: MCExpr.h:69
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:77
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:325
MCContext & getContext() const
Definition: MCAssembler.h:284
int64_t getConstant() const
Definition: MCValue.h:46
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:48
Interface implemented by fragments that contain encoded instructions and/or data. ...
Definition: MCFragment.h:127
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
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
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:169
void destroy()
Destroys the current fragment.
Definition: MCFragment.cpp:245
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:539
const MCExpr & getAddrDelta() const
Definition: MCFragment.h:561
MCAssembler & getAssembler() const
Get the assembler object this is a layout for.
Definition: MCAsmLayout.h:50
char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16)...
Definition: StringExtras.h:36
bool isDummy() const
Return true if given frgment has FT_Dummy type.
Definition: MCFragment.h:112
void layoutFragment(MCFragment *Fragment)
Perform layout for a single fragment, assuming that the previous fragment has already been laid out c...
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:198
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
MCAsmLayout(MCAssembler &Assembler)
Definition: MCFragment.cpp:32
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static void LLVM_ATTRIBUTE_NORETURN ReportError(uint64_t StartOffset, const char *ErrorMsg)
void invalidateFragmentsFrom(MCFragment *F)
Invalidate the fragments starting with F because it has been resized.
Definition: MCFragment.cpp:51
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
Definition: MCFragment.cpp:129
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:47
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:687
uint64_t getOffset() const
Definition: MCSymbol.h:324
uint32_t getOffset() const
Definition: MCFixup.h:130
size_t size() const
Definition: SmallVector.h:52
const MCExpr & getValue() const
Definition: MCFragment.h:505
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
Definition: MCFragment.cpp:77
Iterator for intrusive lists based on ilist_node.
unsigned getMaxBytesToEmit() const
Definition: MCFragment.h:325
bool hasEmitNops() const
Definition: MCFragment.h:327
virtual bool isVirtualSection() const =0
Check whether this section is "virtual", that is has no actual object file contents.
const MCSymbol & getSymbol() const
Definition: MCExpr.h:340
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:396
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 void deleteNode(NodeTy *V)
Definition: ilist.h:41
uint64_t computeBundlePadding(const MCAssembler &Assembler, const MCEncodedFragment *F, uint64_t FOffset, uint64_t FSize)
Compute the amount of padding required before the fragment F to obey bundling restrictions, where FOffset is the fragment&#39;s offset in its section and FSize is the fragment&#39;s size.
Definition: MCFragment.cpp:190
Target - Wrapper for Target specific information.
MCSection * getParent() const
Definition: MCFragment.h:98
void push_back(pointer val)
Definition: ilist.h:311
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
unsigned getValueSize() const
Definition: MCFragment.h:323
unsigned getAlignment() const
Definition: MCFragment.h:319
int64_t getLineDelta() const
Definition: MCFragment.h:537
size_t getInstSize() const
Definition: MCFragment.h:399
const MCInst & getInst() const
Definition: MCFragment.h:283
#define I(x, y, z)
Definition: MD5.cpp:58
bool evaluateAsValue(MCValue &Res, const MCAsmLayout &Layout) const
Try to evaluate the expression to the form (a - b + constant) where neither a nor b are variables...
Definition: MCExpr.cpp:673
uint64_t computeFragmentSize(const MCAsmLayout &Layout, const MCFragment &F) const
Compute the effective fragment size assuming it is laid out at the given SectionAddress and FragmentO...
const MCSymbol * getSymbol()
Definition: MCFragment.h:581
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2047
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:204
Fragment for data and encoded instructions.
Definition: MCFragment.h:243
uint64_t getSectionFileSize(const MCSection *Sec) const
Get the data size of the given section, as emitted to the object file.
Definition: MCFragment.cpp:181
MCFragment()=delete
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const MCExpr * getVariableValue(bool SetUsed=true) const
getVariableValue - Get the value for variable symbols.
Definition: MCSymbol.h:302
bool isInsertionPoint() const
Definition: MCFragment.h:386
bool isSigned() const
Definition: MCFragment.h:507
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
const MCExpr * getValue() const
Definition: MCFixup.h:133
FragmentListType::iterator iterator
Definition: MCSection.h:53
uint8_t getValue() const
Definition: MCFragment.h:476
MCSection::FragmentListType & getFragmentList()
Definition: MCSection.h:150
const MCSymbol * getBaseSymbol(const MCSymbol &Symbol) const
If this symbol is equivalent to A + Constant, return A.
Definition: MCFragment.cpp:139
MCFixupKind getKind() const
Definition: MCFixup.h:126