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