LLVM  7.0.0svn
MCObjectStreamer.cpp
Go to the documentation of this file.
1 //===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
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 
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/MC/MCAsmBackend.h"
13 #include "llvm/MC/MCAssembler.h"
14 #include "llvm/MC/MCCodeEmitter.h"
15 #include "llvm/MC/MCCodeView.h"
16 #include "llvm/MC/MCContext.h"
17 #include "llvm/MC/MCDwarf.h"
18 #include "llvm/MC/MCExpr.h"
19 #include "llvm/MC/MCObjectWriter.h"
20 #include "llvm/MC/MCSection.h"
21 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/Support/SourceMgr.h"
24 using namespace llvm;
25 
27  std::unique_ptr<MCAsmBackend> TAB,
28  std::unique_ptr<MCObjectWriter> OW,
29  std::unique_ptr<MCCodeEmitter> Emitter)
30  : MCStreamer(Context),
31  Assembler(llvm::make_unique<MCAssembler>(
32  Context, std::move(TAB), std::move(Emitter), std::move(OW))),
33  EmitEHFrame(true), EmitDebugFrame(false) {}
34 
36 
37 // AssemblerPtr is used for evaluation of expressions and causes
38 // difference between asm and object outputs. Return nullptr to in
39 // inline asm mode to limit divergence to assembly inputs.
42  return Assembler.get();
43  return nullptr;
44 }
45 
47  if (PendingLabels.empty())
48  return;
49  if (!F) {
50  F = new MCDataFragment();
51  MCSection *CurSection = getCurrentSectionOnly();
52  CurSection->getFragmentList().insert(CurInsertionPoint, F);
53  F->setParent(CurSection);
54  }
55  for (MCSymbol *Sym : PendingLabels) {
56  Sym->setFragment(F);
57  Sym->setOffset(FOffset);
58  }
59  PendingLabels.clear();
60 }
61 
62 // As a compile-time optimization, avoid allocating and evaluating an MCExpr
63 // tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
65  const MCSymbol *Lo) {
66  assert(Hi && Lo);
67  if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
68  Hi->isVariable() || Lo->isVariable())
69  return None;
70 
71  return Hi->getOffset() - Lo->getOffset();
72 }
73 
75  const MCSymbol *Lo,
76  unsigned Size) {
77  if (Optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
78  EmitIntValue(*Diff, Size);
79  return;
80  }
82 }
83 
85  const MCSymbol *Lo) {
86  if (Optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
87  EmitULEB128IntValue(*Diff);
88  return;
89  }
91 }
92 
94  if (Assembler)
95  Assembler->reset();
96  CurInsertionPoint = MCSection::iterator();
97  EmitEHFrame = true;
98  EmitDebugFrame = false;
99  PendingLabels.clear();
101 }
102 
104  if (!getNumFrameInfos())
105  return;
106 
107  if (EmitEHFrame)
108  MCDwarfFrameEmitter::Emit(*this, MAB, true);
109 
110  if (EmitDebugFrame)
111  MCDwarfFrameEmitter::Emit(*this, MAB, false);
112 }
113 
115  assert(getCurrentSectionOnly() && "No current section!");
116 
117  if (CurInsertionPoint != getCurrentSectionOnly()->getFragmentList().begin())
118  return &*std::prev(CurInsertionPoint);
119 
120  return nullptr;
121 }
122 
124  const MCAssembler &Assembler,
125  const MCSubtargetInfo *STI) {
126  if (!F.hasInstructions())
127  return true;
128  // When bundling is enabled, we don't want to add data to a fragment that
129  // already has instructions (see MCELFStreamer::EmitInstToData for details)
130  if (Assembler.isBundlingEnabled())
131  return Assembler.getRelaxAll();
132  // If the subtarget is changed mid fragment we start a new fragment to record
133  // the new STI.
134  return !STI || F.getSubtargetInfo() == STI;
135 }
136 
139  MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
140  if (!F || !CanReuseDataFragment(*F, *Assembler, STI)) {
141  F = new MCDataFragment();
142  insert(F);
143  }
144  return F;
145 }
146 
149  dyn_cast_or_null<MCPaddingFragment>(getCurrentFragment());
150  if (!F) {
151  F = new MCPaddingFragment();
152  insert(F);
153  }
154  return F;
155 }
156 
158  Assembler->registerSymbol(Sym);
159 }
160 
162  MCStreamer::EmitCFISections(EH, Debug);
163  EmitEHFrame = EH;
164  EmitDebugFrame = Debug;
165 }
166 
168  SMLoc Loc) {
169  MCStreamer::EmitValueImpl(Value, Size, Loc);
171  flushPendingLabels(DF, DF->getContents().size());
172 
173  MCCVLineEntry::Make(this);
175 
176  // Avoid fixups when possible.
177  int64_t AbsValue;
178  if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
179  if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
181  Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
182  return;
183  }
184  EmitIntValue(AbsValue, Size);
185  return;
186  }
187  DF->getFixups().push_back(
188  MCFixup::create(DF->getContents().size(), Value,
189  MCFixup::getKindForSize(Size, false), Loc));
190  DF->getContents().resize(DF->getContents().size() + Size, 0);
191 }
192 
193 MCSymbol *MCObjectStreamer::EmitCFILabel() {
194  MCSymbol *Label = getContext().createTempSymbol("cfi", true);
195  EmitLabel(Label);
196  return Label;
197 }
198 
199 void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
200  // We need to create a local symbol to avoid relocations.
201  Frame.Begin = getContext().createTempSymbol();
202  EmitLabel(Frame.Begin);
203 }
204 
205 void MCObjectStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
206  Frame.End = getContext().createTempSymbol();
207  EmitLabel(Frame.End);
208 }
209 
211  MCStreamer::EmitLabel(Symbol, Loc);
212 
213  getAssembler().registerSymbol(*Symbol);
214 
215  // If there is a current fragment, mark the symbol as pointing into it.
216  // Otherwise queue the label and set its fragment pointer when we emit the
217  // next fragment.
218  auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
219  if (F && !(getAssembler().isBundlingEnabled() &&
220  getAssembler().getRelaxAll())) {
221  Symbol->setFragment(F);
222  Symbol->setOffset(F->getContents().size());
223  } else {
224  PendingLabels.push_back(Symbol);
225  }
226 }
227 
229  MCStreamer::EmitLabel(Symbol, Loc);
230  getAssembler().registerSymbol(*Symbol);
231  auto *DF = dyn_cast_or_null<MCDataFragment>(F);
232  if (DF)
233  Symbol->setFragment(F);
234  else
235  PendingLabels.push_back(Symbol);
236 }
237 
239  int64_t IntValue;
240  if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
241  EmitULEB128IntValue(IntValue);
242  return;
243  }
244  insert(new MCLEBFragment(*Value, false));
245 }
246 
248  int64_t IntValue;
249  if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
250  EmitSLEB128IntValue(IntValue);
251  return;
252  }
253  insert(new MCLEBFragment(*Value, true));
254 }
255 
257  const MCSymbol *Symbol) {
258  report_fatal_error("This file format doesn't support weak aliases.");
259 }
260 
262  const MCExpr *Subsection) {
263  changeSectionImpl(Section, Subsection);
264 }
265 
267  const MCExpr *Subsection) {
268  assert(Section && "Cannot switch to a null section!");
269  flushPendingLabels(nullptr);
272 
273  bool Created = getAssembler().registerSection(*Section);
274 
275  int64_t IntSubsection = 0;
276  if (Subsection &&
277  !Subsection->evaluateAsAbsolute(IntSubsection, getAssemblerPtr()))
278  report_fatal_error("Cannot evaluate subsection number");
279  if (IntSubsection < 0 || IntSubsection > 8192)
280  report_fatal_error("Subsection number out of range");
281  CurInsertionPoint =
282  Section->getSubsectionInsertionPoint(unsigned(IntSubsection));
283  return Created;
284 }
285 
287  getAssembler().registerSymbol(*Symbol);
288  MCStreamer::EmitAssignment(Symbol, Value);
289 }
290 
292  return Sec.hasInstructions();
293 }
294 
296  const MCSubtargetInfo &STI, bool) {
298  EmitInstructionImpl(Inst, STI);
300 }
301 
302 void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
303  const MCSubtargetInfo &STI) {
304  MCStreamer::EmitInstruction(Inst, STI);
305 
307  Sec->setHasInstructions(true);
308 
309  // Now that a machine instruction has been assembled into this section, make
310  // a line entry for any .loc directive that has been seen.
311  MCCVLineEntry::Make(this);
313 
314  // If this instruction doesn't need relaxation, just emit it as data.
315  MCAssembler &Assembler = getAssembler();
316  if (!Assembler.getBackend().mayNeedRelaxation(Inst, STI)) {
317  EmitInstToData(Inst, STI);
318  return;
319  }
320 
321  // Otherwise, relax and emit it as data if either:
322  // - The RelaxAll flag was passed
323  // - Bundling is enabled and this instruction is inside a bundle-locked
324  // group. We want to emit all such instructions into the same data
325  // fragment.
326  if (Assembler.getRelaxAll() ||
327  (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
328  MCInst Relaxed;
329  getAssembler().getBackend().relaxInstruction(Inst, STI, Relaxed);
330  while (getAssembler().getBackend().mayNeedRelaxation(Relaxed, STI))
331  getAssembler().getBackend().relaxInstruction(Relaxed, STI, Relaxed);
332  EmitInstToData(Relaxed, STI);
333  return;
334  }
335 
336  // Otherwise emit to a separate fragment.
337  EmitInstToFragment(Inst, STI);
338 }
339 
341  const MCSubtargetInfo &STI) {
342  if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
343  llvm_unreachable("All instructions should have already been relaxed");
344 
345  // Always create a new, separate fragment here, because its size can change
346  // during relaxation.
347  MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
348  insert(IF);
349 
350  SmallString<128> Code;
351  raw_svector_ostream VecOS(Code);
352  getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
353  STI);
354  IF->getContents().append(Code.begin(), Code.end());
355 }
356 
357 #ifndef NDEBUG
358 static const char *const BundlingNotImplementedMsg =
359  "Aligned bundling is not implemented for this object format";
360 #endif
361 
362 void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
363  llvm_unreachable(BundlingNotImplementedMsg);
364 }
365 
366 void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
367  llvm_unreachable(BundlingNotImplementedMsg);
368 }
369 
371  llvm_unreachable(BundlingNotImplementedMsg);
372 }
373 
374 void MCObjectStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
375  unsigned Column, unsigned Flags,
376  unsigned Isa,
377  unsigned Discriminator,
378  StringRef FileName) {
379  // In case we see two .loc directives in a row, make sure the
380  // first one gets a line entry.
382 
383  this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
384  Isa, Discriminator, FileName);
385 }
386 
387 static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
388  const MCSymbol *B) {
389  MCContext &Context = OS.getContext();
391  const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
392  const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
393  const MCExpr *AddrDelta =
394  MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
395  return AddrDelta;
396 }
397 
399  MCDwarfLineTableParams Params,
400  int64_t LineDelta, const MCSymbol *Label,
401  int PointerSize) {
402  // emit the sequence to set the address
403  OS.EmitIntValue(dwarf::DW_LNS_extended_op, 1);
404  OS.EmitULEB128IntValue(PointerSize + 1);
405  OS.EmitIntValue(dwarf::DW_LNE_set_address, 1);
406  OS.EmitSymbolValue(Label, PointerSize);
407 
408  // emit the sequence for the LineDelta (from 1) and a zero address delta.
409  MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
410 }
411 
413  const MCSymbol *LastLabel,
414  const MCSymbol *Label,
415  unsigned PointerSize) {
416  if (!LastLabel) {
417  emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
418  Label, PointerSize);
419  return;
420  }
421  const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
422  int64_t Res;
423  if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
424  MCDwarfLineAddr::Emit(this, Assembler->getDWARFLinetableParams(), LineDelta,
425  Res);
426  return;
427  }
428  insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
429 }
430 
432  const MCSymbol *Label) {
433  const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
434  int64_t Res;
435  if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
437  return;
438  }
439  insert(new MCDwarfCallFrameFragment(*AddrDelta));
440 }
441 
442 void MCObjectStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
443  unsigned Line, unsigned Column,
444  bool PrologueEnd, bool IsStmt,
445  StringRef FileName, SMLoc Loc) {
446  // In case we see two .cv_loc directives in a row, make sure the
447  // first one gets a line entry.
448  MCCVLineEntry::Make(this);
449 
450  this->MCStreamer::EmitCVLocDirective(FunctionId, FileNo, Line, Column,
451  PrologueEnd, IsStmt, FileName, Loc);
452 }
453 
455  const MCSymbol *Begin,
456  const MCSymbol *End) {
457  getContext().getCVContext().emitLineTableForFunction(*this, FunctionId, Begin,
458  End);
459  this->MCStreamer::EmitCVLinetableDirective(FunctionId, Begin, End);
460 }
461 
463  unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
464  const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
466  *this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
467  FnEndSym);
469  PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
470 }
471 
473  ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
474  StringRef FixedSizePortion) {
475  getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
476  this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
477 }
478 
481 }
484 }
485 
488 }
489 
491  MCCVLineEntry::Make(this);
494  flushPendingLabels(DF, DF->getContents().size());
495  DF->getContents().append(Data.begin(), Data.end());
496 }
497 
499  int64_t Value,
500  unsigned ValueSize,
501  unsigned MaxBytesToEmit) {
502  if (MaxBytesToEmit == 0)
503  MaxBytesToEmit = ByteAlignment;
504  insert(new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit));
505 
506  // Update the maximum alignment on the current section if necessary.
507  MCSection *CurSec = getCurrentSectionOnly();
508  if (ByteAlignment > CurSec->getAlignment())
509  CurSec->setAlignment(ByteAlignment);
510 }
511 
513  unsigned MaxBytesToEmit) {
514  EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
515  cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true);
516 }
517 
519  unsigned char Value,
520  SMLoc Loc) {
521  insert(new MCOrgFragment(*Offset, Value, Loc));
522 }
523 
525  const MCCodePaddingContext &Context) {
527 }
528 
530  const MCCodePaddingContext &Context) {
532 }
533 
534 // Associate DTPRel32 fixup with data and resize data area
537  flushPendingLabels(DF, DF->getContents().size());
538 
539  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
540  Value, FK_DTPRel_4));
541  DF->getContents().resize(DF->getContents().size() + 4, 0);
542 }
543 
544 // Associate DTPRel64 fixup with data and resize data area
547  flushPendingLabels(DF, DF->getContents().size());
548 
549  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
550  Value, FK_DTPRel_8));
551  DF->getContents().resize(DF->getContents().size() + 8, 0);
552 }
553 
554 // Associate TPRel32 fixup with data and resize data area
557  flushPendingLabels(DF, DF->getContents().size());
558 
559  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
560  Value, FK_TPRel_4));
561  DF->getContents().resize(DF->getContents().size() + 4, 0);
562 }
563 
564 // Associate TPRel64 fixup with data and resize data area
567  flushPendingLabels(DF, DF->getContents().size());
568 
569  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
570  Value, FK_TPRel_8));
571  DF->getContents().resize(DF->getContents().size() + 8, 0);
572 }
573 
574 // Associate GPRel32 fixup with data and resize data area
577  flushPendingLabels(DF, DF->getContents().size());
578 
579  DF->getFixups().push_back(
580  MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
581  DF->getContents().resize(DF->getContents().size() + 4, 0);
582 }
583 
584 // Associate GPRel64 fixup with data and resize data area
587  flushPendingLabels(DF, DF->getContents().size());
588 
589  DF->getFixups().push_back(
590  MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
591  DF->getContents().resize(DF->getContents().size() + 8, 0);
592 }
593 
595  const MCExpr *Expr, SMLoc Loc,
596  const MCSubtargetInfo &STI) {
597  int64_t OffsetValue;
598  if (!Offset.evaluateAsAbsolute(OffsetValue))
599  llvm_unreachable("Offset is not absolute");
600 
601  if (OffsetValue < 0)
602  llvm_unreachable("Offset is negative");
603 
605  flushPendingLabels(DF, DF->getContents().size());
606 
607  Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
608  if (!MaybeKind.hasValue())
609  return true;
610 
611  MCFixupKind Kind = *MaybeKind;
612 
613  if (Expr == nullptr)
614  Expr =
615  MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
616  DF->getFixups().push_back(MCFixup::create(OffsetValue, Expr, Kind, Loc));
617  return false;
618 }
619 
620 void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
621  SMLoc Loc) {
623  flushPendingLabels(DF, DF->getContents().size());
624 
625  assert(getCurrentSectionOnly() && "need a section");
626  insert(new MCFillFragment(FillValue, 1, NumBytes, Loc));
627 }
628 
629 void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
630  int64_t Expr, SMLoc Loc) {
631  int64_t IntNumValues;
632  // Do additional checking now if we can resolve the value.
633  if (NumValues.evaluateAsAbsolute(IntNumValues, getAssemblerPtr())) {
634  if (IntNumValues < 0) {
637  "'.fill' directive with negative repeat count has no effect");
638  return;
639  }
640  // Emit now if we can for better errors.
641  int64_t NonZeroSize = Size > 4 ? 4 : Size;
642  Expr &= ~0ULL >> (64 - NonZeroSize * 8);
643  for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
644  EmitIntValue(Expr, NonZeroSize);
645  if (NonZeroSize < Size)
646  EmitIntValue(0, Size - NonZeroSize);
647  }
648  return;
649  }
650 
651  // Otherwise emit as fragment.
653  flushPendingLabels(DF, DF->getContents().size());
654 
655  assert(getCurrentSectionOnly() && "need a section");
656  insert(new MCFillFragment(Expr, Size, NumValues, Loc));
657 }
658 
660  getAssembler().addFileName(Filename);
661 }
662 
665 
666  // If we are generating dwarf for assembly source files dump out the sections.
667  if (getContext().getGenDwarfForAssembly())
668  MCGenDwarfInfo::Emit(this);
669 
670  // Dump out the dwarf file & directory tables and line tables.
671  MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
672 
674  getAssembler().Finish();
675 }
virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName)
This implements the DWARF2 &#39;.loc fileno lineno ...&#39; assembler directive.
Definition: MCStreamer.cpp:212
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
virtual void EmitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion)
This implements the CodeView &#39;.cv_def_range&#39; assembler directive.
Definition: MCStreamer.cpp:301
Fragment for adding required padding.
Definition: MCFragment.h:340
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
void handleCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context)
Handles all target related code padding after writing a block to an object file.
void emitLineTableForFunction(MCObjectStreamer &OS, unsigned FuncId, const MCSymbol *FuncBegin, const MCSymbol *FuncEnd)
Emits a line table substream.
Definition: MCCodeView.cpp:319
A eight-byte dtp relative fixup.
Definition: MCFixup.h:37
LLVMContext & Context
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:241
bool hasInstructions() const
Definition: MCSection.h:137
static void Make(MCObjectStreamer *MCOS, MCSection *Section)
Definition: MCDwarf.cpp:88
static const char *const BundlingNotImplementedMsg
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
void EmitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:136
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
void EmitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative=false)
Special case of EmitValue that avoids the client having to pass in a MCExpr for MCSymbols.
Definition: MCStreamer.cpp:147
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:294
virtual bool mayNeedRelaxation(const MCInst &Inst, const MCSubtargetInfo &STI) const =0
Check whether the given instruction may need relaxation.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
virtual void relaxInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, MCInst &Res) const =0
Relax the instruction in the given fragment to the next wider instruction.
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
void EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override
virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &)
Emit an instruction to a special fragment, because this instruction can change its size during relaxa...
void setAlignment(unsigned Value)
Definition: MCSection.h:118
virtual void reset()
State management.
Definition: MCStreamer.cpp:85
static void Make(MCObjectStreamer *MCOS)
Definition: MCCodeView.cpp:695
static void EmitAdvanceLoc(MCObjectStreamer &Streamer, uint64_t AddrDelta)
Definition: MCDwarf.cpp:1790
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:504
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
static MCFixupKind getKindForSize(unsigned Size, bool isPCRel)
Return the generic fixup kind for a value with the given size.
Definition: MCFixup.h:132
F(f)
void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override
This implements the CodeView &#39;.cv_filechecksumoffset&#39; assembler directive.
void EmitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion) override
This implements the CodeView &#39;.cv_def_range&#39; assembler directive.
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:1056
void handleCodePaddingInstructionEnd(const MCInst &Inst)
Handles all target related code padding after writing an instruction to an object file...
virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo)
Emit the absolute difference between two symbols encoded with ULEB128.
Definition: MCStreamer.cpp:934
static void Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, int64_t LineDelta, uint64_t AddrDelta)
Utility function to emit the encoding to a streamer.
Definition: MCDwarf.cpp:636
bool isBundlingEnabled() const
Definition: MCAssembler.h:317
virtual void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Emit the expression Value into the output as a native integer of the given Size bytes.
Definition: MCStreamer.cpp:971
void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel, const MCSymbol *Label, unsigned PointerSize)
virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool PrintSchedInfo=false)
Emit the given Instruction into the current section.
Definition: MCStreamer.cpp:907
void EmitCVStringTableDirective() override
This implements the CodeView &#39;.cv_stringtable&#39; assembler directive.
virtual void EmitCFISections(bool EH, bool Debug)
Definition: MCStreamer.cpp:340
unsigned getAlignment() const
Definition: MCSection.h:117
void emitInlineLineTableForFunction(MCObjectStreamer &OS, unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
Definition: MCCodeView.cpp:414
MCContext & getContext() const
Definition: MCStreamer.h:250
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges=None, ArrayRef< SMFixIt > FixIts=None, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:248
Definition: BitVector.h:921
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void setHasInstructions(bool Value)
Definition: MCSection.h:138
void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override
Emit a .reloc directive.
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:288
virtual void encodeInstruction(const MCInst &Inst, raw_ostream &OS, SmallVectorImpl< MCFixup > &Fixups, const MCSubtargetInfo &STI) const =0
EncodeInstruction - Encode the given Inst to bytes on the output stream OS.
A four-byte tp relative fixup.
Definition: MCFixup.h:38
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
bool registerSection(MCSection &Section)
MCSymbol * Begin
Definition: MCDwarf.h:577
void setFragment(MCFragment *F) const
Mark the symbol as defined in the fragment F.
Definition: MCSymbol.h:273
bool mayHaveInstructions(MCSection &Sec) const override
void flushPendingLabels()
Create a dummy fragment to assign any pending labels.
void EmitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
virtual void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc)
This implements the CodeView &#39;.cv_loc&#39; assembler directive.
Definition: MCStreamer.cpp:270
virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Emit an assignment of Value to Symbol.
Definition: MCStreamer.cpp:864
Context object for machine code objects.
Definition: MCContext.h:63
void EmitDTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
void emitDefRange(MCObjectStreamer &OS, ArrayRef< std::pair< const MCSymbol *, const MCSymbol *>> Ranges, StringRef FixedSizePortion)
Definition: MCCodeView.cpp:427
A four-byte gp relative fixup.
Definition: MCFixup.h:34
void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc=SMLoc()) override
Emit Size bytes worth of the value specified by FillValue.
void EmitFileDirective(StringRef Filename) override
Switch to a new logical file.
Streaming object file generation interface.
void RemapDebugPaths()
Definition: MCContext.cpp:543
MCAssembler * getAssemblerPtr() override
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
void clearCVLocSeen()
Clear the current cv_loc, if there is one.
Definition: MCContext.cpp:608
bool isBundleLocked() const
Definition: MCSection.h:128
bool getUseAssemblerInfoForParsing()
Definition: MCStreamer.h:255
void EmitDTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (32-bit DTP relative) value.
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:197
virtual void EmitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers...
Definition: MCStreamer.cpp:112
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:161
static const MCBinaryExpr * create(Opcode Op, const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:153
void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) override
Emit the absolute difference between two symbols if possible.
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:270
A four-byte dtp relative fixup.
Definition: MCFixup.h:36
void EmitULEB128Value(const MCExpr *Value) override
Streaming machine code generation interface.
Definition: MCStreamer.h:183
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:217
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void visitUsedSymbol(const MCSymbol &Sym) override
void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc) override
This implements the CodeView &#39;.cv_loc&#39; assembler directive.
virtual void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart, const MCSymbol *FnEnd)
This implements the CodeView &#39;.cv_linetable&#39; assembler directive.
Definition: MCStreamer.cpp:291
void EmitSLEB128Value(const MCExpr *Value) override
void insert(MCFragment *F)
void EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override
void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:117
MCAssembler & getAssembler()
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:23
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:223
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:617
uint64_t getOffset() const
Definition: MCSymbol.h:321
A eight-byte tp relative fixup.
Definition: MCFixup.h:39
void EmitFrames(MCAsmBackend *MAB)
const SourceMgr * getSourceManager() const
Definition: MCContext.h:289
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:398
void handleCodePaddingInstructionBegin(const MCInst &Inst)
Handles all target related code padding before writing a new instruction to an object file...
void setOffset(uint64_t Value)
Definition: MCSymbol.h:327
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:90
void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc) override
Emit some number of copies of Value until the byte offset Offset is reached.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void clearDwarfLocSeen()
Definition: MCContext.h:589
void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
MCPaddingFragment * getOrCreatePaddingFragment()
static const MCExpr * buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A, const MCSymbol *B)
void EmitCFISections(bool EH, bool Debug) override
void handleCodePaddingBasicBlockStart(MCObjectStreamer *OS, const MCCodePaddingContext &Context)
Handles all target related code padding when starting to write a new basic block to an object file...
void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel, const MCSymbol *Label)
void ChangeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size)
Emit the absolute difference between two symbols.
Definition: MCStreamer.cpp:915
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:286
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:384
virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
This implements the CodeView &#39;.cv_inline_linetable&#39; assembler directive.
Definition: MCStreamer.cpp:295
void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin, const MCSymbol *End) override
This implements the CodeView &#39;.cv_linetable&#39; assembler directive.
void addFileName(StringRef FileName)
Definition: MCAssembler.h:438
bool getRelaxAll() const
Definition: MCAssembler.h:314
void EmitBundleAlignMode(unsigned AlignPow2) override
Set the bundle alignment mode from now on in the section.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:337
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:173
static void Emit(MCStreamer *MCOS)
Definition: MCDwarf.cpp:1073
static void emitDwarfSetLineAddr(MCObjectStreamer &OS, MCDwarfLineTableParams Params, int64_t LineDelta, const MCSymbol *Label, int PointerSize)
iterator begin() const
Definition: StringRef.h:106
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:395
void EmitTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params)
Definition: MCDwarf.cpp:233
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment...
Basic Alias true
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:121
iterator insert(iterator where, pointer New)
Definition: ilist.h:228
unsigned getNumFrameInfos()
Definition: MCStreamer.h:261
void EmitBundleUnlock() override
Ends a bundle-locked group.
void FinishImpl() override
Streamer specific finalization.
void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override
Emit an assignment of Value to Symbol.
void reset() override
state management
static bool CanReuseDataFragment(const MCDataFragment &F, const MCAssembler &Assembler, const MCSubtargetInfo *STI)
static Optional< uint64_t > absoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo)
Generic base class for all target subtargets.
void emitStringTable(MCObjectStreamer &OS)
Emits the string table substream.
Definition: MCCodeView.cpp:163
void emitFileChecksumOffset(MCObjectStreamer &OS, unsigned FileNo)
Emits the offset into the checksum table of the given file number.
Definition: MCCodeView.cpp:240
void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName) override
This implements the DWARF2 &#39;.loc fileno lineno ...&#39; assembler directive.
void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) override
This implements the CodeView &#39;.cv_inline_linetable&#39; assembler directive.
MCFragment * getCurrentFragment() const
CodeViewContext & getCVContext()
Definition: MCContext.cpp:602
const unsigned Kind
Fragment for data and encoded instructions.
Definition: MCFragment.h:241
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCObjectStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
MCSection::iterator getSubsectionInsertionPoint(unsigned Subsection)
Definition: MCSection.cpp:58
LLVM Value Representation.
Definition: Value.h:73
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:42
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
static cl::opt< bool, true > Debug("debug", cl::desc("Enable debug output"), cl::Hidden, cl::location(DebugFlag))
void EmitGPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel32 (32-bit GP relative) value.
virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:322
Subtraction.
Definition: MCExpr.h:439
static void Emit(MCObjectStreamer &streamer, MCAsmBackend *MAB, bool isEH)
Definition: MCDwarf.cpp:1730
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
FragmentListType::iterator iterator
Definition: MCSection.h:53
void EmitULEB128IntValue(uint64_t Value)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:127
void EmitCVFileChecksumsDirective() override
This implements the CodeView &#39;.cv_filechecksums&#39; assembler directive.
Represents a location in source code.
Definition: SMLoc.h:24
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:393
void emitFileChecksums(MCObjectStreamer &OS)
Emits the file checksum substream.
Definition: MCCodeView.cpp:185
void setParent(MCSection *Value)
Definition: MCFragment.h:100
iterator end() const
Definition: StringRef.h:108
void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) override
Emit the absolute difference between two symbols encoded with ULEB128.
void Finish()
Finish - Do final processing and write the object to the output stream.
MCSection::FragmentListType & getFragmentList()
Definition: MCSection.h:143
void EmitGPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel64 (64-bit GP relative) value.
void EmitTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (64-bit TP relative) value.
void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool=false) override
Emit the given Instruction into the current section.
void resize(size_type N)
Definition: SmallVector.h:352