LLVM  10.0.0svn
MCELFStreamer.cpp
Go to the documentation of this file.
1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===//
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 // This file assembles .s files and emits ELF .o object files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/MC/MCELFStreamer.h"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/BinaryFormat/ELF.h"
17 #include "llvm/MC/MCAsmBackend.h"
18 #include "llvm/MC/MCAsmInfo.h"
19 #include "llvm/MC/MCAssembler.h"
20 #include "llvm/MC/MCCodeEmitter.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCExpr.h"
23 #include "llvm/MC/MCFixup.h"
24 #include "llvm/MC/MCFragment.h"
26 #include "llvm/MC/MCObjectWriter.h"
27 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCSectionELF.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/MC/MCSymbol.h"
31 #include "llvm/MC/MCSymbolELF.h"
32 #include "llvm/Support/Casting.h"
36 #include <cassert>
37 #include <cstdint>
38 
39 using namespace llvm;
40 
42  std::unique_ptr<MCAsmBackend> TAB,
43  std::unique_ptr<MCObjectWriter> OW,
44  std::unique_ptr<MCCodeEmitter> Emitter)
45  : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
46  std::move(Emitter)) {}
47 
48 bool MCELFStreamer::isBundleLocked() const {
50 }
51 
52 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
53  MCDataFragment *EF) {
54  MCAssembler &Assembler = getAssembler();
55 
56  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
57  uint64_t FSize = EF->getContents().size();
58 
59  if (FSize > Assembler.getBundleAlignSize())
60  report_fatal_error("Fragment can't be larger than a bundle size");
61 
62  uint64_t RequiredBundlePadding = computeBundlePadding(
63  Assembler, EF, DF->getContents().size(), FSize);
64 
65  if (RequiredBundlePadding > UINT8_MAX)
66  report_fatal_error("Padding cannot exceed 255 bytes");
67 
68  if (RequiredBundlePadding > 0) {
69  SmallString<256> Code;
70  raw_svector_ostream VecOS(Code);
71  EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
72  Assembler.writeFragmentPadding(VecOS, *EF, FSize);
73 
74  DF->getContents().append(Code.begin(), Code.end());
75  }
76  }
77 
78  flushPendingLabels(DF, DF->getContents().size());
79 
80  for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
81  EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
82  DF->getContents().size());
83  DF->getFixups().push_back(EF->getFixups()[i]);
84  }
85  if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
87  DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
88 }
89 
90 void MCELFStreamer::InitSections(bool NoExecStack) {
91  MCContext &Ctx = getContext();
94 
95  if (NoExecStack)
97 }
98 
100  auto *Symbol = cast<MCSymbolELF>(S);
102 
103  const MCSectionELF &Section =
104  static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
105  if (Section.getFlags() & ELF::SHF_TLS)
106  Symbol->setType(ELF::STT_TLS);
107 }
108 
110  auto *Symbol = cast<MCSymbolELF>(S);
112 
113  const MCSectionELF &Section =
114  static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
115  if (Section.getFlags() & ELF::SHF_TLS)
116  Symbol->setType(ELF::STT_TLS);
117 }
118 
120  // Let the target do whatever target specific stuff it needs to do.
122  // Do any generic stuff we need to do.
123  switch (Flag) {
124  case MCAF_SyntaxUnified: return; // no-op here.
125  case MCAF_Code16: return; // Change parsing mode; no-op here.
126  case MCAF_Code32: return; // Change parsing mode; no-op here.
127  case MCAF_Code64: return; // Change parsing mode; no-op here.
130  return;
131  }
132 
133  llvm_unreachable("invalid assembler flag!");
134 }
135 
136 // If bundle alignment is used and there are any instructions in the section, it
137 // needs to be aligned to at least the bundle size.
138 static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
139  MCSection *Section) {
140  if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions() &&
141  Section->getAlignment() < Assembler.getBundleAlignSize())
142  Section->setAlignment(Assembler.getBundleAlignSize());
143 }
144 
146  const MCExpr *Subsection) {
147  MCSection *CurSection = getCurrentSectionOnly();
148  if (CurSection && isBundleLocked())
149  report_fatal_error("Unterminated .bundle_lock when changing a section");
150 
152  // Ensure the previous section gets aligned if necessary.
153  setSectionAlignmentForBundling(Asm, CurSection);
154  auto *SectionELF = static_cast<const MCSectionELF *>(Section);
155  const MCSymbol *Grp = SectionELF->getGroup();
156  if (Grp)
157  Asm.registerSymbol(*Grp);
158 
159  changeSectionImpl(Section, Subsection);
160  Asm.registerSymbol(*Section->getBeginSymbol());
161 }
162 
164  getAssembler().registerSymbol(*Symbol);
167  Alias->setVariableValue(Value);
168 }
169 
170 // When GNU as encounters more than one .type declaration for an object it seems
171 // to use a mechanism similar to the one below to decide which type is actually
172 // used in the object file. The greater of T1 and T2 is selected based on the
173 // following ordering:
174 // STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
175 // If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
176 // provided type).
177 static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
180  if (T1 == Type)
181  return T2;
182  if (T2 == Type)
183  return T1;
184  }
185 
186  return T2;
187 }
188 
190  auto *Symbol = cast<MCSymbolELF>(S);
191 
192  // Adding a symbol attribute always introduces the symbol, note that an
193  // important side effect of calling registerSymbol here is to register
194  // the symbol with the assembler.
196 
197  // The implementation of symbol attributes is designed to match 'as', but it
198  // leaves much to desired. It doesn't really make sense to arbitrarily add and
199  // remove flags, but 'as' allows this (in particular, see .desc).
200  //
201  // In the future it might be worth trying to make these operations more well
202  // defined.
203  switch (Attribute) {
204  case MCSA_Cold:
205  case MCSA_LazyReference:
206  case MCSA_Reference:
207  case MCSA_SymbolResolver:
208  case MCSA_PrivateExtern:
209  case MCSA_WeakDefinition:
211  case MCSA_Invalid:
212  case MCSA_IndirectSymbol:
213  return false;
214 
215  case MCSA_NoDeadStrip:
216  // Ignore for now.
217  break;
218 
220  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
221  Symbol->setBinding(ELF::STB_GNU_UNIQUE);
222  Symbol->setExternal(true);
223  break;
224 
225  case MCSA_Global:
226  Symbol->setBinding(ELF::STB_GLOBAL);
227  Symbol->setExternal(true);
228  break;
229 
230  case MCSA_WeakReference:
231  case MCSA_Weak:
232  Symbol->setBinding(ELF::STB_WEAK);
233  Symbol->setExternal(true);
234  break;
235 
236  case MCSA_Local:
237  Symbol->setBinding(ELF::STB_LOCAL);
238  Symbol->setExternal(false);
239  break;
240 
242  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
243  break;
244 
246  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
247  break;
248 
249  case MCSA_ELF_TypeObject:
250  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
251  break;
252 
253  case MCSA_ELF_TypeTLS:
254  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS));
255  break;
256 
257  case MCSA_ELF_TypeCommon:
258  // TODO: Emit these as a common symbol.
259  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
260  break;
261 
262  case MCSA_ELF_TypeNoType:
263  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE));
264  break;
265 
266  case MCSA_Protected:
267  Symbol->setVisibility(ELF::STV_PROTECTED);
268  break;
269 
270  case MCSA_Hidden:
271  Symbol->setVisibility(ELF::STV_HIDDEN);
272  break;
273 
274  case MCSA_Internal:
275  Symbol->setVisibility(ELF::STV_INTERNAL);
276  break;
277 
278  case MCSA_AltEntry:
279  llvm_unreachable("ELF doesn't support the .alt_entry attribute");
280  }
281 
282  return true;
283 }
284 
286  unsigned ByteAlignment) {
287  auto *Symbol = cast<MCSymbolELF>(S);
289 
290  if (!Symbol->isBindingSet()) {
291  Symbol->setBinding(ELF::STB_GLOBAL);
292  Symbol->setExternal(true);
293  }
294 
295  Symbol->setType(ELF::STT_OBJECT);
296 
297  if (Symbol->getBinding() == ELF::STB_LOCAL) {
301  SwitchSection(&Section);
302 
303  EmitValueToAlignment(ByteAlignment, 0, 1, 0);
304  EmitLabel(Symbol);
305  EmitZeros(Size);
306 
307  // Update the maximum alignment of the section if necessary.
308  if (ByteAlignment > Section.getAlignment())
309  Section.setAlignment(ByteAlignment);
310 
311  SwitchSection(P.first, P.second);
312  } else {
313  if(Symbol->declareCommon(Size, ByteAlignment))
314  report_fatal_error("Symbol: " + Symbol->getName() +
315  " redeclared as different type");
316  }
317 
318  cast<MCSymbolELF>(Symbol)
319  ->setSize(MCConstantExpr::create(Size, getContext()));
320 }
321 
323  cast<MCSymbolELF>(Symbol)->setSize(Value);
324 }
325 
327  const MCSymbol *Aliasee) {
328  getAssembler().Symvers.push_back({AliasName, Aliasee});
329 }
330 
332  unsigned ByteAlignment) {
333  auto *Symbol = cast<MCSymbolELF>(S);
334  // FIXME: Should this be caught and done earlier?
336  Symbol->setBinding(ELF::STB_LOCAL);
337  Symbol->setExternal(false);
338  EmitCommonSymbol(Symbol, Size, ByteAlignment);
339 }
340 
342  SMLoc Loc) {
343  if (isBundleLocked())
344  report_fatal_error("Emitting values inside a locked bundle is forbidden");
345  fixSymbolsInTLSFixups(Value);
346  MCObjectStreamer::EmitValueImpl(Value, Size, Loc);
347 }
348 
350  int64_t Value,
351  unsigned ValueSize,
352  unsigned MaxBytesToEmit) {
353  if (isBundleLocked())
354  report_fatal_error("Emitting values inside a locked bundle is forbidden");
355  MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value,
356  ValueSize, MaxBytesToEmit);
357 }
358 
360  const MCSymbolRefExpr *To,
361  uint64_t Count) {
362  getAssembler().CGProfile.push_back({From, To, Count});
363 }
364 
367  ".comment", ELF::SHT_PROGBITS, ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
368  PushSection();
369  SwitchSection(Comment);
370  if (!SeenIdent) {
371  EmitIntValue(0, 1);
372  SeenIdent = true;
373  }
374  EmitBytes(IdentString);
375  EmitIntValue(0, 1);
376  PopSection();
377 }
378 
379 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
380  switch (expr->getKind()) {
381  case MCExpr::Target:
382  cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
383  break;
384  case MCExpr::Constant:
385  break;
386 
387  case MCExpr::Binary: {
388  const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
389  fixSymbolsInTLSFixups(be->getLHS());
390  fixSymbolsInTLSFixups(be->getRHS());
391  break;
392  }
393 
394  case MCExpr::SymbolRef: {
395  const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
396  switch (symRef.getKind()) {
397  default:
398  return;
450  break;
451  }
453  cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
454  break;
455  }
456 
457  case MCExpr::Unary:
458  fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
459  break;
460  }
461 }
462 
463 void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
464  const MCSymbol *S = &SRE->getSymbol();
465  if (S->isTemporary()) {
466  if (!S->isInSection()) {
468  SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
469  "`" + S->getName() + "`");
470  return;
471  }
472  S = S->getSection().getBeginSymbol();
473  S->setUsedInReloc();
474  SRE =
475  MCSymbolRefExpr::create(S, SRE->getKind(), getContext(), SRE->getLoc());
476  return;
477  }
478  // Not a temporary, referece it as a weak undefined.
479  bool Created;
480  getAssembler().registerSymbol(*S, &Created);
481  if (Created) {
482  cast<MCSymbolELF>(S)->setBinding(ELF::STB_WEAK);
483  cast<MCSymbolELF>(S)->setExternal(true);
484  }
485 }
486 
487 void MCELFStreamer::finalizeCGProfile() {
488  for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) {
489  finalizeCGProfileEntry(E.From);
490  finalizeCGProfileEntry(E.To);
491  }
492 }
493 
494 void MCELFStreamer::EmitInstToFragment(const MCInst &Inst,
495  const MCSubtargetInfo &STI) {
496  this->MCObjectStreamer::EmitInstToFragment(Inst, STI);
497  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
498 
499  for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
500  fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
501 }
502 
503 // A fragment can only have one Subtarget, and when bundling is enabled we
504 // sometimes need to use the same fragment. We give an error if there
505 // are conflicting Subtargets.
506 static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
507  const MCSubtargetInfo *NewSTI) {
508  if (OldSTI && NewSTI && OldSTI != NewSTI)
509  report_fatal_error("A Bundle can only have one Subtarget.");
510 }
511 
512 void MCELFStreamer::EmitInstToData(const MCInst &Inst,
513  const MCSubtargetInfo &STI) {
514  MCAssembler &Assembler = getAssembler();
516  SmallString<256> Code;
517  raw_svector_ostream VecOS(Code);
518  Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
519 
520  for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
521  fixSymbolsInTLSFixups(Fixups[i].getValue());
522 
523  // There are several possibilities here:
524  //
525  // If bundling is disabled, append the encoded instruction to the current data
526  // fragment (or create a new such fragment if the current fragment is not a
527  // data fragment, or the Subtarget has changed).
528  //
529  // If bundling is enabled:
530  // - If we're not in a bundle-locked group, emit the instruction into a
531  // fragment of its own. If there are no fixups registered for the
532  // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
533  // MCDataFragment.
534  // - If we're in a bundle-locked group, append the instruction to the current
535  // data fragment because we want all the instructions in a group to get into
536  // the same fragment. Be careful not to do that for the first instruction in
537  // the group, though.
538  MCDataFragment *DF;
539 
540  if (Assembler.isBundlingEnabled()) {
542  if (Assembler.getRelaxAll() && isBundleLocked()) {
543  // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
544  // the current bundle group.
545  DF = BundleGroups.back();
547  }
548  else if (Assembler.getRelaxAll() && !isBundleLocked())
549  // When not in a bundle-locked group and the -mc-relax-all flag is used,
550  // we create a new temporary fragment which will be later merged into
551  // the current fragment.
552  DF = new MCDataFragment();
553  else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
554  // If we are bundle-locked, we re-use the current fragment.
555  // The bundle-locking directive ensures this is a new data fragment.
556  DF = cast<MCDataFragment>(getCurrentFragment());
558  }
559  else if (!isBundleLocked() && Fixups.size() == 0) {
560  // Optimize memory usage by emitting the instruction to a
561  // MCCompactEncodedInstFragment when not in a bundle-locked group and
562  // there are no fixups registered.
564  insert(CEIF);
565  CEIF->getContents().append(Code.begin(), Code.end());
566  CEIF->setHasInstructions(STI);
567  return;
568  } else {
569  DF = new MCDataFragment();
570  insert(DF);
571  }
573  // If this fragment is for a group marked "align_to_end", set a flag
574  // in the fragment. This can happen after the fragment has already been
575  // created if there are nested bundle_align groups and an inner one
576  // is the one marked align_to_end.
577  DF->setAlignToBundleEnd(true);
578  }
579 
580  // We're now emitting an instruction in a bundle group, so this flag has
581  // to be turned off.
583  } else {
584  DF = getOrCreateDataFragment(&STI);
585  }
586 
587  // Add the fixups and data.
588  for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
589  Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
590  DF->getFixups().push_back(Fixups[i]);
591  }
592  DF->setHasInstructions(STI);
593  DF->getContents().append(Code.begin(), Code.end());
594 
595  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
596  if (!isBundleLocked()) {
597  mergeFragment(getOrCreateDataFragment(&STI), DF);
598  delete DF;
599  }
600  }
601 }
602 
603 void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
604  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
605  MCAssembler &Assembler = getAssembler();
606  if (AlignPow2 > 0 && (Assembler.getBundleAlignSize() == 0 ||
607  Assembler.getBundleAlignSize() == 1U << AlignPow2))
608  Assembler.setBundleAlignSize(1U << AlignPow2);
609  else
610  report_fatal_error(".bundle_align_mode cannot be changed once set");
611 }
612 
613 void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
615 
616  // Sanity checks
617  //
618  if (!getAssembler().isBundlingEnabled())
619  report_fatal_error(".bundle_lock forbidden when bundling is disabled");
620 
621  if (!isBundleLocked())
623 
624  if (getAssembler().getRelaxAll() && !isBundleLocked()) {
625  // TODO: drop the lock state and set directly in the fragment
626  MCDataFragment *DF = new MCDataFragment();
627  BundleGroups.push_back(DF);
628  }
629 
632 }
633 
636 
637  // Sanity checks
638  if (!getAssembler().isBundlingEnabled())
639  report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
640  else if (!isBundleLocked())
641  report_fatal_error(".bundle_unlock without matching lock");
642  else if (Sec.isBundleGroupBeforeFirstInst())
643  report_fatal_error("Empty bundle-locked group is forbidden");
644 
645  // When the -mc-relax-all flag is used, we emit instructions to fragments
646  // stored on a stack. When the bundle unlock is emitted, we pop a fragment
647  // from the stack a merge it to the one below.
648  if (getAssembler().getRelaxAll()) {
649  assert(!BundleGroups.empty() && "There are no bundle groups");
650  MCDataFragment *DF = BundleGroups.back();
651 
652  // FIXME: Use BundleGroups to track the lock state instead.
654 
655  // FIXME: Use more separate fragments for nested groups.
656  if (!isBundleLocked()) {
657  mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF);
658  BundleGroups.pop_back();
659  delete DF;
660  }
661 
664  } else
666 }
667 
669  // Ensure the last section gets aligned if necessary.
670  MCSection *CurSection = getCurrentSectionOnly();
672 
673  finalizeCGProfile();
674  EmitFrames(nullptr);
675 
677 }
678 
680  llvm_unreachable("Generic ELF doesn't support this directive");
681 }
682 
683 void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
684  llvm_unreachable("ELF doesn't support this directive");
685 }
686 
688  uint64_t Size, unsigned ByteAlignment,
689  SMLoc Loc) {
690  llvm_unreachable("ELF doesn't support this directive");
691 }
692 
694  uint64_t Size, unsigned ByteAlignment) {
695  llvm_unreachable("ELF doesn't support this directive");
696 }
697 
699  std::unique_ptr<MCAsmBackend> &&MAB,
700  std::unique_ptr<MCObjectWriter> &&OW,
701  std::unique_ptr<MCCodeEmitter> &&CE,
702  bool RelaxAll) {
703  MCELFStreamer *S =
704  new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
705  if (RelaxAll)
706  S->getAssembler().setRelaxAll(true);
707  return S;
708 }
void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a local common (.lcomm) symbol.
void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:310
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:38
void EmitBundleAlignMode(unsigned AlignPow2) override
Set the bundle alignment mode from now on in the section.
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
void setUsedInReloc() const
Definition: MCSymbol.h:214
LLVMContext & Context
bool hasInstructions() const
Definition: MCSection.h:140
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:331
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
.type _foo, STT_OBJECT # aka
Definition: MCDirectives.h:25
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
VariantKind getKind() const
Definition: MCExpr.h:346
Not a valid directive.
Definition: MCDirectives.h:19
void EmitBundleUnlock() override
Ends a bundle-locked group.
void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override
Emit an ELF .size directive.
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:121
void setBundleLockState(BundleLockStateType NewState)
Definition: MCSection.cpp:38
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition: MCExpr.h:572
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
void PushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:365
This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that...
Definition: MCFragment.h:258
F(f)
void EmitZerofill(MCSection *Section, MCSymbol *Symbol=nullptr, uint64_t Size=0, unsigned ByteAlignment=0, SMLoc L=SMLoc()) override
Emit the zerofill section and an optional symbol.
void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
.type _foo, STT_NOTYPE # aka
Definition: MCDirectives.h:28
bool isBundlingEnabled() const
Definition: MCAssembler.h:323
static unsigned CombineSymbolTypes(unsigned T1, unsigned T2)
void EmitIdent(StringRef IdentString) override
Emit the "identifiers" directive.
SMLoc getLoc() const
Definition: MCExpr.h:73
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:325
unsigned getAlignment() const
Definition: MCSection.h:120
MCContext & getContext() const
Definition: MCAssembler.h:284
.cold (MachO)
Definition: MCDirectives.h:22
MCContext & getContext() const
Definition: MCStreamer.h:250
void InitSections(bool NoExecStack) override
Create the default sections and set the initial one.
Definition: BitVector.h:937
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:294
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.
void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment=0) override
Emit a thread local bss (.tbss) symbol.
void setRelaxAll(bool Value)
Definition: MCAssembler.h:321
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:253
bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override
Add the given Attribute to Symbol.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:173
.local (ELF)
Definition: MCDirectives.h:35
.no_dead_strip (MachO)
Definition: MCDirectives.h:36
void flushPendingLabels()
Create a dummy fragment to assign any pending labels.
void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override
Set the DescValue for the Symbol.
void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
void setSubsectionsViaSymbols(bool Value)
Definition: MCAssembler.h:311
Context object for machine code objects.
Definition: MCContext.h:64
void EmitThumbFunc(MCSymbol *Func) override
Note in the output that the specified Func is a Thumb mode function (ARM target only).
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:51
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition: MCExpr.h:575
Streaming object file generation interface.
.type _foo, STT_GNU_IFUNC
Definition: MCDirectives.h:24
.alt_entry (MachO)
Definition: MCDirectives.h:38
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.
.protected (ELF)
Definition: MCDirectives.h:40
void setBundleAlignSize(unsigned Size)
Definition: MCAssembler.h:327
BundleLockStateType getBundleLockState() const
Definition: MCSection.h:129
bool isBundleLocked() const
Definition: MCSection.h:131
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
.lazy_reference (MachO)
Definition: MCDirectives.h:34
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:198
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:128
.reference (MachO)
Definition: MCDirectives.h:41
Unary expressions.
Definition: MCExpr.h:41
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false)
Definition: MCExpr.cpp:169
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:117
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:272
virtual MCSection * getNonexecutableStackSection(MCContext &Ctx) const
Targets can implement this method to specify a section to switch to if the translation unit doesn&#39;t h...
Definition: MCAsmInfo.h:428
void ChangeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
.hidden (ELF)
Definition: MCDirectives.h:31
#define P(N)
void EmitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:205
Streaming machine code generation interface.
Definition: MCStreamer.h:188
void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:45
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
void insert(MCFragment *F)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void EmitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
static void setSectionAlignmentForBundling(const MCAssembler &Assembler, MCSection *Section)
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
MCAssembler & getAssembler()
void setHasInstructions(const MCSubtargetInfo &STI)
Record that the fragment contains instructions with the MCSubtargetInfo in effect when the instructio...
Definition: MCFragment.h:178
void emitELFSymverDirective(StringRef AliasName, const MCSymbol *Aliasee) override
Emit an ELF .symver directive.
void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a common symbol.
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:224
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:221
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:314
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:679
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:50
void EmitFrames(MCAsmBackend *MAB)
.weak_reference (MachO)
Definition: MCDirectives.h:44
Binary assembler expressions.
Definition: MCExpr.h:425
size_t size() const
Definition: SmallVector.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
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.
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:338
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:56
BlockVerifier::State From
void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F, uint64_t FSize) const
Write the necessary bundle padding to OS.
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:292
const MCSymbol & getSymbol() const
Definition: MCExpr.h:344
ExprKind getKind() const
Definition: MCExpr.h:72
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI, const MCSubtargetInfo *NewSTI)
.indirect_symbol (MachO)
Definition: MCDirectives.h:32
.type _foo, STT_TLS # aka
Definition: MCDirectives.h:26
MCSymbol * getBeginSymbol()
Definition: MCSection.h:109
void setVariableValue(const MCExpr *Value)
Definition: MCSymbol.cpp:48
MCSymbolAttr
Definition: MCDirectives.h:18
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
Definition: MCFragment.h:170
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
bool getRelaxAll() const
Definition: MCAssembler.h:320
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:343
.syntax (ARM/ELF)
Definition: MCDirectives.h:49
const MCSubtargetInfo * getSubtargetInfo() const
Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
Definition: MCFragment.h:174
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:268
.internal (ELF)
Definition: MCDirectives.h:33
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:387
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:52
.type _foo, STT_COMMON # aka
Definition: MCDirectives.h:27
.code64 (X86)
Definition: MCDirectives.h:53
MCELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
std::vector< CGProfileEntry > CGProfile
Definition: MCAssembler.h:433
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...
virtual void handleAssemblerFlag(MCAssemblerFlag Flag)
Handle any target-specific assembler flags. By default, do nothing.
Definition: MCAsmBackend.h:175
.symbol_resolver (MachO)
Definition: MCDirectives.h:37
.type _foo,
Definition: MCDirectives.h:30
void FinishImpl() override
Streamer specific finalization.
MCAssemblerFlag
Definition: MCDirectives.h:48
.type _foo, STT_FUNC # aka
Definition: MCDirectives.h:23
Generic base class for all target subtargets.
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:27
References to labels and assigned expressions.
Definition: MCExpr.h:40
uint32_t Size
Definition: Profile.cpp:46
bool isBundleGroupBeforeFirstInst() const
Definition: MCSection.h:133
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.
.weak_definition (MachO)
Definition: MCDirectives.h:43
void setBundleGroupBeforeFirstInst(bool IsFirst)
Definition: MCSection.h:136
void EmitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
MCFragment * getCurrentFragment() const
void setAlignToBundleEnd(bool V)
Definition: MCFragment.h:159
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:204
Fragment for data and encoded instructions.
Definition: MCFragment.h:243
void EmitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
MCSection * getTextSection() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
.private_extern (MachO)
Definition: MCDirectives.h:39
bool PopSection()
Restore the current and previous section from the section stack.
Definition: MCStreamer.h:374
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:406
LLVM Value Representation.
Definition: Value.h:72
Constant expressions.
Definition: MCExpr.h:39
Binary expressions.
Definition: MCExpr.h:38
void EmitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Target specific expression.
Definition: MCExpr.h:42
unsigned getFlags() const
Definition: MCSectionELF.h:72
Represents a location in source code.
Definition: SMLoc.h:23
void FinishImpl() override
Streamer specific finalization.
std::vector< std::pair< StringRef, const MCSymbol * > > Symvers
Definition: MCAssembler.h:213
#define T1