LLVM  14.0.0git
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"
34 #include "llvm/Support/LEB128.h"
37 #include <cassert>
38 #include <cstdint>
39 
40 using namespace llvm;
41 
43  std::unique_ptr<MCAsmBackend> TAB,
44  std::unique_ptr<MCObjectWriter> OW,
45  std::unique_ptr<MCCodeEmitter> Emitter)
46  : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
47  std::move(Emitter)) {}
48 
49 bool MCELFStreamer::isBundleLocked() const {
51 }
52 
53 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
54  MCDataFragment *EF) {
55  MCAssembler &Assembler = getAssembler();
56 
57  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
58  uint64_t FSize = EF->getContents().size();
59 
60  if (FSize > Assembler.getBundleAlignSize())
61  report_fatal_error("Fragment can't be larger than a bundle size");
62 
63  uint64_t RequiredBundlePadding = computeBundlePadding(
64  Assembler, EF, DF->getContents().size(), FSize);
65 
66  if (RequiredBundlePadding > UINT8_MAX)
67  report_fatal_error("Padding cannot exceed 255 bytes");
68 
69  if (RequiredBundlePadding > 0) {
70  SmallString<256> Code;
71  raw_svector_ostream VecOS(Code);
72  EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
73  Assembler.writeFragmentPadding(VecOS, *EF, FSize);
74 
75  DF->getContents().append(Code.begin(), Code.end());
76  }
77  }
78 
79  flushPendingLabels(DF, DF->getContents().size());
80 
81  for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
82  EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
83  DF->getContents().size());
84  DF->getFixups().push_back(EF->getFixups()[i]);
85  }
86  if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
87  DF->setHasInstructions(*EF->getSubtargetInfo());
88  DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
89 }
90 
91 void MCELFStreamer::initSections(bool NoExecStack, const MCSubtargetInfo &STI) {
92  MCContext &Ctx = getContext();
95 
96  if (NoExecStack)
98 }
99 
101  auto *Symbol = cast<MCSymbolELF>(S);
103 
104  const MCSectionELF &Section =
105  static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
106  if (Section.getFlags() & ELF::SHF_TLS)
107  Symbol->setType(ELF::STT_TLS);
108 }
109 
111  uint64_t Offset) {
112  auto *Symbol = cast<MCSymbolELF>(S);
114 
115  const MCSectionELF &Section =
116  static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
117  if (Section.getFlags() & ELF::SHF_TLS)
118  Symbol->setType(ELF::STT_TLS);
119 }
120 
122  // Let the target do whatever target specific stuff it needs to do.
124  // Do any generic stuff we need to do.
125  switch (Flag) {
126  case MCAF_SyntaxUnified: return; // no-op here.
127  case MCAF_Code16: return; // Change parsing mode; no-op here.
128  case MCAF_Code32: return; // Change parsing mode; no-op here.
129  case MCAF_Code64: return; // Change parsing mode; no-op here.
132  return;
133  }
134 
135  llvm_unreachable("invalid assembler flag!");
136 }
137 
138 // If bundle alignment is used and there are any instructions in the section, it
139 // needs to be aligned to at least the bundle size.
140 static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
141  MCSection *Section) {
142  if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions() &&
143  Section->getAlignment() < Assembler.getBundleAlignSize())
144  Section->setAlignment(Align(Assembler.getBundleAlignSize()));
145 }
146 
148  const MCExpr *Subsection) {
149  MCSection *CurSection = getCurrentSectionOnly();
150  if (CurSection && isBundleLocked())
151  report_fatal_error("Unterminated .bundle_lock when changing a section");
152 
154  // Ensure the previous section gets aligned if necessary.
155  setSectionAlignmentForBundling(Asm, CurSection);
156  auto *SectionELF = static_cast<const MCSectionELF *>(Section);
157  const MCSymbol *Grp = SectionELF->getGroup();
158  if (Grp)
159  Asm.registerSymbol(*Grp);
160  if (SectionELF->getFlags() & ELF::SHF_GNU_RETAIN)
161  Asm.getWriter().markGnuAbi();
162 
163  changeSectionImpl(Section, Subsection);
164  Asm.registerSymbol(*Section->getBeginSymbol());
165 }
166 
171  Alias->setVariableValue(Value);
172 }
173 
174 // When GNU as encounters more than one .type declaration for an object it seems
175 // to use a mechanism similar to the one below to decide which type is actually
176 // used in the object file. The greater of T1 and T2 is selected based on the
177 // following ordering:
178 // STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
179 // If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
180 // provided type).
181 static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
184  if (T1 == Type)
185  return T2;
186  if (T2 == Type)
187  return T1;
188  }
189 
190  return T2;
191 }
192 
194  auto *Symbol = cast<MCSymbolELF>(S);
195 
196  // Adding a symbol attribute always introduces the symbol, note that an
197  // important side effect of calling registerSymbol here is to register
198  // the symbol with the assembler.
200 
201  // The implementation of symbol attributes is designed to match 'as', but it
202  // leaves much to desired. It doesn't really make sense to arbitrarily add and
203  // remove flags, but 'as' allows this (in particular, see .desc).
204  //
205  // In the future it might be worth trying to make these operations more well
206  // defined.
207  switch (Attribute) {
208  case MCSA_Cold:
209  case MCSA_Extern:
210  case MCSA_LazyReference:
211  case MCSA_Reference:
212  case MCSA_SymbolResolver:
213  case MCSA_PrivateExtern:
214  case MCSA_WeakDefinition:
216  case MCSA_Invalid:
217  case MCSA_IndirectSymbol:
218  return false;
219 
220  case MCSA_NoDeadStrip:
221  // Ignore for now.
222  break;
223 
225  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
226  Symbol->setBinding(ELF::STB_GNU_UNIQUE);
228  break;
229 
230  case MCSA_Global:
231  // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
232  // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
233  // error on such cases. Note, we also disallow changed binding from .local.
234  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
236  Symbol->getName() +
237  " changed binding to STB_GLOBAL");
238  Symbol->setBinding(ELF::STB_GLOBAL);
239  break;
240 
241  case MCSA_WeakReference:
242  case MCSA_Weak:
243  // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
244  // We emit a warning for now but may switch to an error in the future.
245  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
247  getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
248  Symbol->setBinding(ELF::STB_WEAK);
249  break;
250 
251  case MCSA_Local:
252  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
254  Symbol->getName() +
255  " changed binding to STB_LOCAL");
256  Symbol->setBinding(ELF::STB_LOCAL);
257  break;
258 
260  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
261  break;
262 
264  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
265  break;
266 
267  case MCSA_ELF_TypeObject:
268  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
269  break;
270 
271  case MCSA_ELF_TypeTLS:
272  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS));
273  break;
274 
275  case MCSA_ELF_TypeCommon:
276  // TODO: Emit these as a common symbol.
277  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
278  break;
279 
280  case MCSA_ELF_TypeNoType:
281  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE));
282  break;
283 
284  case MCSA_Protected:
285  Symbol->setVisibility(ELF::STV_PROTECTED);
286  break;
287 
288  case MCSA_Hidden:
289  Symbol->setVisibility(ELF::STV_HIDDEN);
290  break;
291 
292  case MCSA_Internal:
293  Symbol->setVisibility(ELF::STV_INTERNAL);
294  break;
295 
296  case MCSA_AltEntry:
297  llvm_unreachable("ELF doesn't support the .alt_entry attribute");
298 
299  case MCSA_LGlobal:
300  llvm_unreachable("ELF doesn't support the .lglobl attribute");
301  }
302 
303  return true;
304 }
305 
307  unsigned ByteAlignment) {
308  auto *Symbol = cast<MCSymbolELF>(S);
310 
311  if (!Symbol->isBindingSet())
312  Symbol->setBinding(ELF::STB_GLOBAL);
313 
314  Symbol->setType(ELF::STT_OBJECT);
315 
316  if (Symbol->getBinding() == ELF::STB_LOCAL) {
321 
323  emitLabel(Symbol);
324  emitZeros(Size);
325 
326  SwitchSection(P.first, P.second);
327  } else {
328  if(Symbol->declareCommon(Size, ByteAlignment))
329  report_fatal_error("Symbol: " + Symbol->getName() +
330  " redeclared as different type");
331  }
332 
333  cast<MCSymbolELF>(Symbol)
334  ->setSize(MCConstantExpr::create(Size, getContext()));
335 }
336 
338  cast<MCSymbolELF>(Symbol)->setSize(Value);
339 }
340 
342  StringRef Name,
343  bool KeepOriginalSym) {
345  getStartTokLoc(), OriginalSym, Name, KeepOriginalSym});
346 }
347 
349  unsigned ByteAlignment) {
350  auto *Symbol = cast<MCSymbolELF>(S);
351  // FIXME: Should this be caught and done earlier?
353  Symbol->setBinding(ELF::STB_LOCAL);
355 }
356 
358  SMLoc Loc) {
359  if (isBundleLocked())
360  report_fatal_error("Emitting values inside a locked bundle is forbidden");
361  fixSymbolsInTLSFixups(Value);
363 }
364 
366  int64_t Value,
367  unsigned ValueSize,
368  unsigned MaxBytesToEmit) {
369  if (isBundleLocked())
370  report_fatal_error("Emitting values inside a locked bundle is forbidden");
372  ValueSize, MaxBytesToEmit);
373 }
374 
376  const MCSymbolRefExpr *To,
377  uint64_t Count) {
378  getAssembler().CGProfile.push_back({From, To, Count});
379 }
380 
384  PushSection();
385  SwitchSection(Comment);
386  if (!SeenIdent) {
387  emitInt8(0);
388  SeenIdent = true;
389  }
390  emitBytes(IdentString);
391  emitInt8(0);
392  PopSection();
393 }
394 
395 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
396  switch (expr->getKind()) {
397  case MCExpr::Target:
398  cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
399  break;
400  case MCExpr::Constant:
401  break;
402 
403  case MCExpr::Binary: {
404  const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
405  fixSymbolsInTLSFixups(be->getLHS());
406  fixSymbolsInTLSFixups(be->getRHS());
407  break;
408  }
409 
410  case MCExpr::SymbolRef: {
411  const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
412  switch (symRef.getKind()) {
413  default:
414  return;
469  break;
470  }
472  cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
473  break;
474  }
475 
476  case MCExpr::Unary:
477  fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
478  break;
479  }
480 }
481 
482 void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE,
483  uint64_t Offset) {
484  const MCSymbol *S = &SRE->getSymbol();
485  if (S->isTemporary()) {
486  if (!S->isInSection()) {
488  SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
489  "`" + S->getName() + "`");
490  return;
491  }
492  S = S->getSection().getBeginSymbol();
493  S->setUsedInReloc();
495  SRE->getLoc());
496  }
499  if (Optional<std::pair<bool, std::string>> Err =
501  *MCOffset, "BFD_RELOC_NONE", SRE, SRE->getLoc(),
502  *getContext().getSubtargetInfo()))
503  report_fatal_error("Relocation for CG Profile could not be created: " +
504  Err->second);
505 }
506 
507 void MCELFStreamer::finalizeCGProfile() {
509  if (Asm.CGProfile.empty())
510  return;
512  ".llvm.call-graph-profile", ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
513  ELF::SHF_EXCLUDE, /*sizeof(Elf_CGProfile_Impl<>)=*/8);
514  PushSection();
515  SwitchSection(CGProfile);
516  uint64_t Offset = 0;
517  for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
518  finalizeCGProfileEntry(E.From, Offset);
519  finalizeCGProfileEntry(E.To, Offset);
520  emitIntValue(E.Count, sizeof(uint64_t));
521  Offset += sizeof(uint64_t);
522  }
523  PopSection();
524 }
525 
526 void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
527  const MCSubtargetInfo &STI) {
528  this->MCObjectStreamer::emitInstToFragment(Inst, STI);
529  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
530 
531  for (auto &Fixup : F.getFixups())
532  fixSymbolsInTLSFixups(Fixup.getValue());
533 }
534 
535 // A fragment can only have one Subtarget, and when bundling is enabled we
536 // sometimes need to use the same fragment. We give an error if there
537 // are conflicting Subtargets.
538 static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
539  const MCSubtargetInfo *NewSTI) {
540  if (OldSTI && NewSTI && OldSTI != NewSTI)
541  report_fatal_error("A Bundle can only have one Subtarget.");
542 }
543 
544 void MCELFStreamer::emitInstToData(const MCInst &Inst,
545  const MCSubtargetInfo &STI) {
546  MCAssembler &Assembler = getAssembler();
549  raw_svector_ostream VecOS(Code);
550  Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
551 
552  for (auto &Fixup : Fixups)
553  fixSymbolsInTLSFixups(Fixup.getValue());
554 
555  // There are several possibilities here:
556  //
557  // If bundling is disabled, append the encoded instruction to the current data
558  // fragment (or create a new such fragment if the current fragment is not a
559  // data fragment, or the Subtarget has changed).
560  //
561  // If bundling is enabled:
562  // - If we're not in a bundle-locked group, emit the instruction into a
563  // fragment of its own. If there are no fixups registered for the
564  // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
565  // MCDataFragment.
566  // - If we're in a bundle-locked group, append the instruction to the current
567  // data fragment because we want all the instructions in a group to get into
568  // the same fragment. Be careful not to do that for the first instruction in
569  // the group, though.
571 
572  if (Assembler.isBundlingEnabled()) {
574  if (Assembler.getRelaxAll() && isBundleLocked()) {
575  // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
576  // the current bundle group.
577  DF = BundleGroups.back();
578  CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
579  }
580  else if (Assembler.getRelaxAll() && !isBundleLocked())
581  // When not in a bundle-locked group and the -mc-relax-all flag is used,
582  // we create a new temporary fragment which will be later merged into
583  // the current fragment.
584  DF = new MCDataFragment();
585  else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
586  // If we are bundle-locked, we re-use the current fragment.
587  // The bundle-locking directive ensures this is a new data fragment.
588  DF = cast<MCDataFragment>(getCurrentFragment());
589  CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
590  }
591  else if (!isBundleLocked() && Fixups.size() == 0) {
592  // Optimize memory usage by emitting the instruction to a
593  // MCCompactEncodedInstFragment when not in a bundle-locked group and
594  // there are no fixups registered.
596  insert(CEIF);
597  CEIF->getContents().append(Code.begin(), Code.end());
598  CEIF->setHasInstructions(STI);
599  return;
600  } else {
601  DF = new MCDataFragment();
602  insert(DF);
603  }
605  // If this fragment is for a group marked "align_to_end", set a flag
606  // in the fragment. This can happen after the fragment has already been
607  // created if there are nested bundle_align groups and an inner one
608  // is the one marked align_to_end.
609  DF->setAlignToBundleEnd(true);
610  }
611 
612  // We're now emitting an instruction in a bundle group, so this flag has
613  // to be turned off.
615  } else {
616  DF = getOrCreateDataFragment(&STI);
617  }
618 
619  // Add the fixups and data.
620  for (auto &Fixup : Fixups) {
621  Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
622  DF->getFixups().push_back(Fixup);
623  }
624 
625  DF->setHasInstructions(STI);
626  DF->getContents().append(Code.begin(), Code.end());
627 
628  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
629  if (!isBundleLocked()) {
630  mergeFragment(getOrCreateDataFragment(&STI), DF);
631  delete DF;
632  }
633  }
634 }
635 
636 void MCELFStreamer::emitBundleAlignMode(unsigned AlignPow2) {
637  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
638  MCAssembler &Assembler = getAssembler();
639  if (AlignPow2 > 0 && (Assembler.getBundleAlignSize() == 0 ||
640  Assembler.getBundleAlignSize() == 1U << AlignPow2))
641  Assembler.setBundleAlignSize(1U << AlignPow2);
642  else
643  report_fatal_error(".bundle_align_mode cannot be changed once set");
644 }
645 
646 void MCELFStreamer::emitBundleLock(bool AlignToEnd) {
648 
649  // Sanity checks
650  //
651  if (!getAssembler().isBundlingEnabled())
652  report_fatal_error(".bundle_lock forbidden when bundling is disabled");
653 
654  if (!isBundleLocked())
656 
657  if (getAssembler().getRelaxAll() && !isBundleLocked()) {
658  // TODO: drop the lock state and set directly in the fragment
660  BundleGroups.push_back(DF);
661  }
662 
665 }
666 
669 
670  // Sanity checks
671  if (!getAssembler().isBundlingEnabled())
672  report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
673  else if (!isBundleLocked())
674  report_fatal_error(".bundle_unlock without matching lock");
675  else if (Sec.isBundleGroupBeforeFirstInst())
676  report_fatal_error("Empty bundle-locked group is forbidden");
677 
678  // When the -mc-relax-all flag is used, we emit instructions to fragments
679  // stored on a stack. When the bundle unlock is emitted, we pop a fragment
680  // from the stack a merge it to the one below.
681  if (getAssembler().getRelaxAll()) {
682  assert(!BundleGroups.empty() && "There are no bundle groups");
683  MCDataFragment *DF = BundleGroups.back();
684 
685  // FIXME: Use BundleGroups to track the lock state instead.
687 
688  // FIXME: Use more separate fragments for nested groups.
689  if (!isBundleLocked()) {
690  mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF);
691  BundleGroups.pop_back();
692  delete DF;
693  }
694 
697  } else
699 }
700 
702  // Emit the .gnu attributes section if any attributes have been added.
703  if (!GNUAttributes.empty()) {
704  MCSection *DummyAttributeSection = nullptr;
705  createAttributesSection("gnu", ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
706  DummyAttributeSection, GNUAttributes);
707  }
708 
709  // Ensure the last section gets aligned if necessary.
710  MCSection *CurSection = getCurrentSectionOnly();
712 
713  finalizeCGProfile();
714  emitFrames(nullptr);
715 
717 }
718 
720  llvm_unreachable("Generic ELF doesn't support this directive");
721 }
722 
723 void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
724  llvm_unreachable("ELF doesn't support this directive");
725 }
726 
728  uint64_t Size, unsigned ByteAlignment,
729  SMLoc Loc) {
730  llvm_unreachable("ELF doesn't support this directive");
731 }
732 
734  uint64_t Size, unsigned ByteAlignment) {
735  llvm_unreachable("ELF doesn't support this directive");
736 }
737 
739  bool OverwriteExisting) {
740  // Look for existing attribute item
741  if (AttributeItem *Item = getAttributeItem(Attribute)) {
742  if (!OverwriteExisting)
743  return;
744  Item->Type = AttributeItem::NumericAttribute;
745  Item->IntValue = Value;
746  return;
747  }
748 
749  // Create new attribute item
751  std::string(StringRef(""))};
752  Contents.push_back(Item);
753 }
754 
756  bool OverwriteExisting) {
757  // Look for existing attribute item
758  if (AttributeItem *Item = getAttributeItem(Attribute)) {
759  if (!OverwriteExisting)
760  return;
761  Item->Type = AttributeItem::TextAttribute;
762  Item->StringValue = std::string(Value);
763  return;
764  }
765 
766  // Create new attribute item
768  std::string(Value)};
769  Contents.push_back(Item);
770 }
771 
772 void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
773  StringRef StringValue,
774  bool OverwriteExisting) {
775  // Look for existing attribute item
776  if (AttributeItem *Item = getAttributeItem(Attribute)) {
777  if (!OverwriteExisting)
778  return;
780  Item->IntValue = IntValue;
781  Item->StringValue = std::string(StringValue);
782  return;
783  }
784 
785  // Create new attribute item
787  IntValue, std::string(StringValue)};
788  Contents.push_back(Item);
789 }
790 
792 MCELFStreamer::getAttributeItem(unsigned Attribute) {
793  for (size_t I = 0; I < Contents.size(); ++I)
794  if (Contents[I].Tag == Attribute)
795  return &Contents[I];
796  return nullptr;
797 }
798 
799 size_t
800 MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
801  size_t Result = 0;
802  for (size_t I = 0; I < AttrsVec.size(); ++I) {
803  AttributeItem Item = AttrsVec[I];
804  switch (Item.Type) {
806  break;
808  Result += getULEB128Size(Item.Tag);
809  Result += getULEB128Size(Item.IntValue);
810  break;
812  Result += getULEB128Size(Item.Tag);
813  Result += Item.StringValue.size() + 1; // string + '\0'
814  break;
816  Result += getULEB128Size(Item.Tag);
817  Result += getULEB128Size(Item.IntValue);
818  Result += Item.StringValue.size() + 1; // string + '\0';
819  break;
820  }
821  }
822  return Result;
823 }
824 
825 void MCELFStreamer::createAttributesSection(
826  StringRef Vendor, const Twine &Section, unsigned Type,
827  MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
828  // <format-version>
829  // [ <section-length> "vendor-name"
830  // [ <file-tag> <size> <attribute>*
831  // | <section-tag> <size> <section-number>* 0 <attribute>*
832  // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
833  // ]+
834  // ]*
835 
836  // Switch section to AttributeSection or get/create the section.
837  if (AttributeSection) {
838  SwitchSection(AttributeSection);
839  } else {
840  AttributeSection = getContext().getELFSection(Section, Type, 0);
841  SwitchSection(AttributeSection);
842 
843  // Format version
844  emitInt8(0x41);
845  }
846 
847  // Vendor size + Vendor name + '\0'
848  const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
849 
850  // Tag + Tag Size
851  const size_t TagHeaderSize = 1 + 4;
852 
853  const size_t ContentsSize = calculateContentSize(AttrsVec);
854 
855  emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
856  emitBytes(Vendor);
857  emitInt8(0); // '\0'
858 
860  emitInt32(TagHeaderSize + ContentsSize);
861 
862  // Size should have been accounted for already, now
863  // emit each field as its type (ULEB or String)
864  for (size_t I = 0; I < AttrsVec.size(); ++I) {
865  AttributeItem Item = AttrsVec[I];
866  emitULEB128IntValue(Item.Tag);
867  switch (Item.Type) {
868  default:
869  llvm_unreachable("Invalid attribute type");
871  emitULEB128IntValue(Item.IntValue);
872  break;
874  emitBytes(Item.StringValue);
875  emitInt8(0); // '\0'
876  break;
878  emitULEB128IntValue(Item.IntValue);
879  emitBytes(Item.StringValue);
880  emitInt8(0); // '\0'
881  break;
882  }
883  }
884 
885  AttrsVec.clear();
886 }
887 
889  std::unique_ptr<MCAsmBackend> &&MAB,
890  std::unique_ptr<MCObjectWriter> &&OW,
891  std::unique_ptr<MCCodeEmitter> &&CE,
892  bool RelaxAll) {
893  MCELFStreamer *S =
894  new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
895  if (RelaxAll)
896  S->getAssembler().setRelaxAll(true);
897  return S;
898 }
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::MCObjectStreamer::emitRelocDirective
Optional< std::pair< bool, std::string > > emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override
Record a relocation described by the .reloc directive.
Definition: MCObjectStreamer.cpp:747
llvm::MCAssembler::getBackend
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:300
llvm::MCSection::isBundleLocked
bool isBundleLocked() const
Definition: MCSection.h:149
llvm::MCSymbolRefExpr::getKind
VariantKind getKind() const
Definition: MCExpr.h:400
llvm::MCELFStreamer::AttributeItem::TextAttribute
@ TextAttribute
Definition: MCELFStreamer.h:91
i
i
Definition: README.txt:29
llvm::MCObjectWriter::markGnuAbi
virtual void markGnuAbi()
ELF only. Mark that we have seen GNU ABI usage (e.g. SHF_GNU_RETAIN).
Definition: MCObjectWriter.h:89
llvm::MCContext::getObjectFileInfo
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:427
llvm::MCStreamer::visitUsedExpr
void visitUsedExpr(const MCExpr &Expr)
Definition: MCStreamer.cpp:1061
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::MCRelaxableFragment
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:271
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
llvm::MCObjectFileInfo::getTextSectionAlignment
virtual unsigned getTextSectionAlignment() const
Definition: MCObjectFileInfo.h:257
llvm::MCEncodedFragment::setHasInstructions
void setHasInstructions(const MCSubtargetInfo &STI)
Record that the fragment contains instructions with the MCSubtargetInfo in effect when the instructio...
Definition: MCFragment.h:177
llvm::MCObjectStreamer::emitLabel
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Definition: MCObjectStreamer.cpp:264
llvm::MCAssembler::Symvers
std::vector< Symver > Symvers
Definition: MCAssembler.h:221
llvm::MCELFStreamer::emitLabel
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Definition: MCELFStreamer.cpp:100
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HA
@ VK_PPC_TPREL_HA
Definition: MCExpr.h:269
llvm::MCAssembler::registerSymbol
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
Definition: MCAssembler.cpp:463
llvm::MCSection::setBundleLockState
void setBundleLockState(BundleLockStateType NewState)
Definition: MCSection.cpp:39
llvm::MCObjectStreamer::emitValueToAlignment
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.
Definition: MCObjectStreamer.cpp:597
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER
@ VK_PPC_DTPREL_HIGHER
Definition: MCExpr.h:281
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST
@ VK_PPC_DTPREL_HIGHEST
Definition: MCExpr.h:283
llvm::MCSymbolRefExpr::VK_PPC_TLSGD
@ VK_PPC_TLSGD
Definition: MCExpr.h:298
llvm::MCSymbolRefExpr::VK_INDNTPOFF
@ VK_INDNTPOFF
Definition: MCExpr.h:204
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:72
llvm::Attribute
Definition: Attributes.h:52
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::MCSA_ELF_TypeObject
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
MCCodeEmitter.h
llvm::MCSA_Invalid
@ MCSA_Invalid
Not a valid directive.
Definition: MCDirectives.h:19
llvm::ELF::STT_NOTYPE
@ STT_NOTYPE
Definition: ELF.h:1150
llvm::MCELFStreamer::emitZerofill
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.
Definition: MCELFStreamer.cpp:727
llvm::MCConstantExpr::create
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI
@ VK_PPC_GOT_TPREL_HI
Definition: MCExpr.h:287
MCSectionELF.h
llvm::MCStreamer::emitInt8
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:705
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::tgtok::Code
@ Code
Definition: TGLexer.h:50
llvm::MCELFStreamer::changeSection
void changeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
Definition: MCELFStreamer.cpp:147
llvm::MCAsmBackend::handleAssemblerFlag
virtual void handleAssemblerFlag(MCAssemblerFlag Flag)
Handle any target-specific assembler flags. By default, do nothing.
Definition: MCAsmBackend.h:205
ErrorHandling.h
MCFragment.h
llvm::ELF::STT_TLS
@ STT_TLS
Definition: ELF.h:1156
MCAssembler.h
llvm::MCELFStreamer::MCELFStreamer
MCELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
Definition: MCELFStreamer.cpp:42
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI
@ VK_PPC_GOT_TLSGD_HI
Definition: MCExpr.h:296
MCObjectFileInfo.h
llvm::MCObjectStreamer::emitLabelAtPos
virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset)
Definition: MCObjectStreamer.cpp:288
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HI
@ VK_PPC_DTPREL_HI
Definition: MCExpr.h:277
llvm::MCSection::getBundleLockState
BundleLockStateType getBundleLockState() const
Definition: MCSection.h:147
llvm::getULEB128Size
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:19
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1139
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::MCELFStreamer::emitTBSSSymbol
void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment=0) override
Emit a thread local bss (.tbss) symbol.
Definition: MCELFStreamer.cpp:733
llvm::ELF::STT_GNU_IFUNC
@ STT_GNU_IFUNC
Definition: ELF.h:1157
llvm::MCStreamer::emitInt32
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:707
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::Optional
Definition: APInt.h:33
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MCSA_ELF_TypeNoType
@ MCSA_ELF_TypeNoType
.type _foo, STT_NOTYPE # aka @notype
Definition: MCDirectives.h:28
llvm::MCStreamer::getCurrentSection
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:371
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO
@ VK_PPC_GOT_TLSGD_LO
Definition: MCExpr.h:295
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA
@ VK_PPC_DTPREL_HIGHESTA
Definition: MCExpr.h:284
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::MCEncodedFragmentWithFixups::getFixups
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:223
llvm::MCSectionELF
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:28
llvm::MCAssemblerFlag
MCAssemblerFlag
Definition: MCDirectives.h:50
llvm::MCSymbol::setVariableValue
void setVariableValue(const MCExpr *Value)
Definition: MCSymbol.cpp:48
llvm::MCSection::setBundleGroupBeforeFirstInst
void setBundleGroupBeforeFirstInst(bool IsFirst)
Definition: MCSection.h:154
llvm::MCBinaryExpr
Binary assembler expressions.
Definition: MCExpr.h:480
MCELFStreamer.h
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::MCSymbolAttr
MCSymbolAttr
Definition: MCDirectives.h:18
llvm::MCSA_Cold
@ MCSA_Cold
.cold (MachO)
Definition: MCDirectives.h:22
llvm::MCSA_Local
@ MCSA_Local
.local (ELF)
Definition: MCDirectives.h:37
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:910
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHA
@ VK_PPC_TPREL_HIGHA
Definition: MCExpr.h:271
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:78
llvm::MCSA_NoDeadStrip
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:38
llvm::MCSymbolRefExpr::VK_PPC_TLS
@ VK_PPC_TLS
Definition: MCExpr.h:293
llvm::MCFragment
Definition: MCFragment.h:31
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:199
llvm::MCSymbolRefExpr::VK_NTPOFF
@ VK_NTPOFF
Definition: MCExpr.h:205
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL
@ VK_PPC_GOT_TLSGD_PCREL
Definition: MCExpr.h:306
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO
@ VK_PPC_GOT_DTPREL_LO
Definition: MCExpr.h:290
ELF.h
llvm::MCELFStreamer
Definition: MCELFStreamer.h:24
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1013
llvm::ELF::STV_HIDDEN
@ STV_HIDDEN
Definition: ELF.h:1170
MCAsmBackend.h
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
llvm::ELF::SHF_GNU_RETAIN
@ SHF_GNU_RETAIN
Definition: ELF.h:1019
SmallString.h
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST
@ VK_PPC_TPREL_HIGHEST
Definition: MCExpr.h:274
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:648
llvm::MCAssembler::getContext
MCContext & getContext() const
Definition: MCAssembler.h:292
llvm::MCExpr::Target
@ Target
Target specific expression.
Definition: MCExpr.h:42
llvm::MCSA_Extern
@ MCSA_Extern
.extern (XCOFF)
Definition: MCDirectives.h:32
llvm::MCSA_AltEntry
@ MCSA_AltEntry
.alt_entry (MachO)
Definition: MCDirectives.h:40
llvm::MCObjectStreamer::emitValueImpl
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.
Definition: MCObjectStreamer.cpp:222
MCSymbolELF.h
llvm::MCSA_Protected
@ MCSA_Protected
.protected (ELF)
Definition: MCDirectives.h:42
MCContext.h
llvm::MCSymbolRefExpr::VK_GOTNTPOFF
@ VK_GOTNTPOFF
Definition: MCExpr.h:206
llvm::MCSymbolRefExpr::VK_DTPREL
@ VK_DTPREL
Definition: MCExpr.h:357
MCSymbol.h
llvm::MCSA_LazyReference
@ MCSA_LazyReference
.lazy_reference (MachO)
Definition: MCDirectives.h:36
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::MCELFStreamer::emitCGProfileEntry
void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override
Definition: MCELFStreamer.cpp:375
llvm::MCSA_LGlobal
@ MCSA_LGlobal
.lglobl (XCOFF)
Definition: MCDirectives.h:31
llvm::MCContext::getELFSection
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:540
llvm::MCSymbolRefExpr::VK_TLSLDM
@ VK_TLSLDM
Definition: MCExpr.h:210
llvm::MCAF_Code16
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:53
llvm::MCObjectStreamer
Streaming object file generation interface.
Definition: MCObjectStreamer.h:36
llvm::MCSA_ELF_TypeIndFunction
@ MCSA_ELF_TypeIndFunction
.type _foo, STT_GNU_IFUNC
Definition: MCDirectives.h:24
llvm::AArch64::Fixups
Fixups
Definition: AArch64FixupKinds.h:17
llvm::MCSA_Reference
@ MCSA_Reference
.reference (MachO)
Definition: MCDirectives.h:43
llvm::MCELFStreamer::emitBundleLock
void emitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
Definition: MCELFStreamer.cpp:646
llvm::MCID::Flag
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:146
be
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can be
Definition: README.txt:14
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
llvm::MCSymbolRefExpr::getSymbol
const MCSymbol & getSymbol() const
Definition: MCExpr.h:398
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA
@ VK_PPC_DTPREL_HIGHERA
Definition: MCExpr.h:282
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA
@ VK_PPC_GOT_DTPREL_HA
Definition: MCExpr.h:292
llvm::MCELFStreamer::emitWeakReference
void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
Definition: MCELFStreamer.cpp:167
llvm::MCSA_Hidden
@ MCSA_Hidden
.hidden (ELF)
Definition: MCDirectives.h:33
llvm::MCSymbolRefExpr::VK_TLSLD
@ VK_TLSLD
Definition: MCExpr.h:209
llvm::MCELFStreamer::emitCommonSymbol
void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a common symbol.
Definition: MCELFStreamer.cpp:306
llvm::MCSA_ELF_TypeGnuUniqueObject
@ MCSA_ELF_TypeGnuUniqueObject
Definition: MCDirectives.h:29
llvm::MCELFStreamer::Contents
SmallVector< AttributeItem, 64 > Contents
Definition: MCELFStreamer.h:100
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::MCELFStreamer::emitLabelAtPos
void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset) override
Definition: MCELFStreamer.cpp:110
llvm::MCExpr::getKind
ExprKind getKind() const
Definition: MCExpr.h:81
llvm::MCObjectStreamer::getCurrentFragment
MCFragment * getCurrentFragment() const
Definition: MCObjectStreamer.cpp:179
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HI
@ VK_PPC_TPREL_HI
Definition: MCExpr.h:268
llvm::MCAssembler::setBundleAlignSize
void setBundleAlignSize(unsigned Size)
Definition: MCAssembler.h:335
llvm::MCStreamer::getCurrentSectionOnly
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:376
llvm::MCObjectFileInfo::getTextSection
MCSection * getTextSection() const
Definition: MCObjectFileInfo.h:258
llvm::MCExpr::Binary
@ Binary
Binary expressions.
Definition: MCExpr.h:38
DF
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
llvm::SmallString< 256 >
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL
@ VK_PPC_GOT_TPREL_PCREL
Definition: MCExpr.h:308
llvm::MCELFStreamer::emitValueToAlignment
void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
Definition: MCELFStreamer.cpp:365
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1140
llvm::MCConstantExpr
Definition: MCExpr.h:144
llvm::MCELFStreamer::emitThumbFunc
void emitThumbFunc(MCSymbol *Func) override
Note in the output that the specified Func is a Thumb mode function (ARM target only).
Definition: MCELFStreamer.cpp:719
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI
@ VK_PPC_GOT_DTPREL_HI
Definition: MCExpr.h:291
llvm::MCSA_WeakDefAutoPrivate
@ MCSA_WeakDefAutoPrivate
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:47
llvm::MCELFStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCELFStreamer.cpp:701
llvm::MCSection::BundleLockedAlignToEnd
@ BundleLockedAlignToEnd
Definition: MCSection.h:56
llvm::MCELFStreamer::emitELFSymverDirective
void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name, bool KeepOriginalSym) override
Emit an ELF .symver directive.
Definition: MCELFStreamer.cpp:341
llvm::MCSymbolRefExpr::VK_PPC_TLSLD
@ VK_PPC_TLSLD
Definition: MCExpr.h:310
llvm::MCAssembler
Definition: MCAssembler.h:60
llvm::MCAssembler::getEmitter
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:302
llvm::MCAF_SubsectionsViaSymbols
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:52
llvm::MCELFStreamer::emitLocalCommonSymbol
void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a local common (.lcomm) symbol.
Definition: MCELFStreamer.cpp:348
uint64_t
llvm::MCCompactEncodedInstFragment
This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that...
Definition: MCFragment.h:257
llvm::MCContext::getAsmInfo
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:423
llvm::MCSymbolRefExpr::VK_PPC_TLS_PCREL
@ VK_PPC_TLS_PCREL
Definition: MCExpr.h:309
llvm::MCSA_WeakReference
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:46
LEB128.h
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::MCELFStreamer::emitIdent
void emitIdent(StringRef IdentString) override
Emit the "identifiers" directive.
Definition: MCELFStreamer.cpp:381
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::MCELFStreamer::emitSymbolDesc
void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override
Set the DescValue for the Symbol.
Definition: MCELFStreamer.cpp:723
llvm::MCEncodedFragment::setBundlePadding
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
Definition: MCFragment.h:169
llvm::MCSymbolRefExpr::VK_TLSDESC
@ VK_TLSDESC
Definition: MCExpr.h:214
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition: ELF.h:985
llvm::MCAssembler::getBundleAlignSize
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:333
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD
@ VK_PPC_GOT_TLSGD
Definition: MCExpr.h:294
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL
@ VK_PPC_GOT_TPREL
Definition: MCExpr.h:285
llvm::MCStreamer::getStartTokLoc
SMLoc getStartTokLoc() const
Definition: MCStreamer.h:272
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGH
@ VK_PPC_TPREL_HIGH
Definition: MCExpr.h:270
llvm::MCStreamer::PopSection
bool PopSection()
Restore the current and previous section from the section stack.
Definition: MCStreamer.h:407
llvm::MCObjectStreamer::insert
void insert(MCFragment *F)
Definition: MCObjectStreamer.h:78
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::MCELFStreamer::AttributeItem::NumericAndTextAttributes
@ NumericAndTextAttributes
Definition: MCELFStreamer.h:92
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1609
llvm::MCSymbolRefExpr::VK_TLSCALL
@ VK_TLSCALL
Definition: MCExpr.h:213
llvm::MCStreamer::emitIntValue
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:133
llvm::MCContext::reportError
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:963
llvm::MCAssembler::getRelaxAll
bool getRelaxAll() const
Definition: MCAssembler.h:328
llvm::MCSymbolRefExpr::VK_PPC_TPREL_LO
@ VK_PPC_TPREL_LO
Definition: MCExpr.h:267
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL
@ VK_PPC_GOT_DTPREL
Definition: MCExpr.h:289
llvm::ELF::STT_FUNC
@ STT_FUNC
Definition: ELF.h:1152
llvm::MCSymbolRefExpr
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
llvm::MCSymbolRefExpr::VK_TPOFF
@ VK_TPOFF
Definition: MCExpr.h:211
MCSection.h
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_LO
@ VK_PPC_DTPREL_LO
Definition: MCExpr.h:276
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1171
llvm::MCObjectStreamer::getAssembler
MCAssembler & getAssembler()
Definition: MCObjectStreamer.h:112
llvm::MCELFStreamer::AttributeItem::NumericAttribute
@ NumericAttribute
Definition: MCELFStreamer.h:90
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:988
llvm::MCELFStreamer::setAttributeItem
void setAttributeItem(unsigned Attribute, unsigned Value, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:738
llvm::MCELFStreamer::emitValueImpl
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.
Definition: MCELFStreamer.cpp:357
llvm::MCObjectStreamer::getOrCreateDataFragment
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.
Definition: MCObjectStreamer.cpp:203
MCAsmInfo.h
Fixup
PowerPC TLS Dynamic Call Fixup
Definition: PPCTLSDynamicCall.cpp:235
llvm::MCObjectStreamer::changeSectionImpl
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
Definition: MCObjectStreamer.cpp:334
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::MCAssembler::Symver
Definition: MCAssembler.h:214
llvm::MCELFStreamer::setAttributeItems
void setAttributeItems(unsigned Attribute, unsigned IntValue, StringRef StringValue, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:772
MCFixup.h
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO
@ VK_PPC_GOT_TLSLD_LO
Definition: MCExpr.h:302
llvm::MCSA_ELF_TypeTLS
@ MCSA_ELF_TypeTLS
.type _foo, STT_TLS # aka @tls_object
Definition: MCDirectives.h:26
llvm::MCObjectStreamer::emitInstToFragment
virtual void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &)
Emit an instruction to a special fragment, because this instruction can change its size during relaxa...
Definition: MCObjectStreamer.cpp:414
llvm::MCSA_IndirectSymbol
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition: MCDirectives.h:34
CombineSymbolTypes
static unsigned CombineSymbolTypes(unsigned T1, unsigned T2)
Definition: MCELFStreamer.cpp:181
llvm::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:997
llvm::ELF::STV_INTERNAL
@ STV_INTERNAL
Definition: ELF.h:1169
llvm::MCSymbolRefExpr::VK_WEAKREF
@ VK_WEAKREF
Definition: MCExpr.h:224
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:994
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHER
@ VK_PPC_TPREL_HIGHER
Definition: MCExpr.h:272
llvm::MCSA_Internal
@ MCSA_Internal
.internal (ELF)
Definition: MCDirectives.h:35
llvm::MCELFStreamer::AttributeItem
ELF object attributes section emission support.
Definition: MCELFStreamer.h:84
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA
@ VK_PPC_TPREL_HIGHESTA
Definition: MCExpr.h:275
llvm::MCAF_Code32
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:54
llvm::MCSA_ELF_TypeCommon
@ MCSA_ELF_TypeCommon
.type _foo, STT_COMMON # aka @common
Definition: MCDirectives.h:27
llvm::MCSection::BundleLocked
@ BundleLocked
Definition: MCSection.h:55
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO
@ VK_PPC_GOT_TPREL_LO
Definition: MCExpr.h:286
llvm::createELFStreamer
MCStreamer * createELFStreamer(MCContext &Ctx, std::unique_ptr< MCAsmBackend > &&TAB, std::unique_ptr< MCObjectWriter > &&OW, std::unique_ptr< MCCodeEmitter > &&CE, bool RelaxAll)
Definition: MCELFStreamer.cpp:888
llvm::MCSection::isBundleGroupBeforeFirstInst
bool isBundleGroupBeforeFirstInst() const
Definition: MCSection.h:151
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI
@ VK_PPC_GOT_TLSLD_HI
Definition: MCExpr.h:303
llvm::MCAF_Code64
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:55
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA
@ VK_PPC_GOT_TLSGD_HA
Definition: MCExpr.h:297
MCObjectWriter.h
llvm::MCSymbolRefExpr::VK_TPREL
@ VK_TPREL
Definition: MCExpr.h:356
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::MCELFStreamer::emitBundleAlignMode
void emitBundleAlignMode(unsigned AlignPow2) override
Set the bundle alignment mode from now on in the section.
Definition: MCELFStreamer.cpp:636
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGH
@ VK_PPC_DTPREL_HIGH
Definition: MCExpr.h:279
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA
@ VK_PPC_TPREL_HIGHERA
Definition: MCExpr.h:273
llvm::MCAF_SyntaxUnified
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:51
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition: ELF.h:1151
llvm::MCSA_SymbolResolver
@ MCSA_SymbolResolver
.symbol_resolver (MachO)
Definition: MCDirectives.h:39
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:948
llvm::MCStreamer::PushSection
void PushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:398
llvm::MCEncodedFragment::getSubtargetInfo
const MCSubtargetInfo * getSubtargetInfo() const
Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
Definition: MCFragment.h:173
Casting.h
llvm::MCELFStreamer::emitSymbolAttribute
bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override
Add the given Attribute to Symbol.
Definition: MCELFStreamer.cpp:193
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::MCELFStreamer::emitAssemblerFlag
void emitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
Definition: MCELFStreamer.cpp:121
llvm::MCSection::NotBundleLocked
@ NotBundleLocked
Definition: MCSection.h:54
llvm::MCSymbolRefExpr::VK_TLSGD
@ VK_TLSGD
Definition: MCExpr.h:208
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:385
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::MCSA_Global
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
llvm::MCELFStreamer::AttributeItem::HiddenAttribute
@ HiddenAttribute
Definition: MCELFStreamer.h:89
llvm::MCSA_WeakDefinition
@ MCSA_WeakDefinition
.weak_definition (MachO)
Definition: MCDirectives.h:45
llvm::LCOMM::ByteAlignment
@ ByteAlignment
Definition: MCAsmInfo.h:50
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA
@ VK_PPC_GOT_TPREL_HA
Definition: MCExpr.h:288
llvm::MCSA_ELF_TypeFunction
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:79
llvm::computeBundlePadding
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,...
Definition: MCFragment.cpp:209
llvm::MCSA_Weak
@ MCSA_Weak
.weak
Definition: MCDirectives.h:44
llvm::MCEncodedFragment::setAlignToBundleEnd
void setAlignToBundleEnd(bool V)
Definition: MCFragment.h:158
llvm::MCObjectStreamer::emitBytes
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
Definition: MCObjectStreamer.cpp:590
llvm::MCObjectStreamer::flushPendingLabels
void flushPendingLabels()
Create a data fragment for any pending labels across all Sections and Subsections.
Definition: MCObjectStreamer.cpp:92
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HA
@ VK_PPC_DTPREL_HA
Definition: MCExpr.h:278
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD
@ VK_PPC_GOT_TLSLD
Definition: MCExpr.h:301
llvm::MCStreamer::emitULEB128IntValue
void emitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:161
llvm::MCStreamer::getContext
MCContext & getContext() const
Definition: MCStreamer.h:280
SmallVector.h
llvm::MCExpr::SymbolRef
@ SymbolRef
References to labels and assigned expressions.
Definition: MCExpr.h:40
llvm::MCExpr::Unary
@ Unary
Unary expressions.
Definition: MCExpr.h:41
llvm::MCELFStreamer::emitELFSize
void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override
Emit an ELF .size directive.
Definition: MCELFStreamer.cpp:337
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1138
MCStreamer.h
llvm::MCELFStreamer::emitBundleUnlock
void emitBundleUnlock() override
Ends a bundle-locked group.
Definition: MCELFStreamer.cpp:667
llvm::MCSectionSubPair
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:64
llvm::MCAsmInfo::getNonexecutableStackSection
virtual MCSection * getNonexecutableStackSection(MCContext &Ctx) const
Targets can implement this method to specify a section to switch to if the translation unit doesn't h...
Definition: MCAsmInfo.h:569
llvm::MCExpr::Constant
@ Constant
Constant expressions.
Definition: MCExpr.h:39
llvm::MCELFStreamer::initSections
void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override
Create the default sections and set the initial one.
Definition: MCELFStreamer.cpp:91
llvm::MCAssembler::setSubsectionsViaSymbols
void setSubsectionsViaSymbols(bool Value)
Definition: MCAssembler.h:319
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:658
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA
@ VK_PPC_GOT_TLSLD_HA
Definition: MCExpr.h:304
llvm::MCSA_PrivateExtern
@ MCSA_PrivateExtern
.private_extern (MachO)
Definition: MCDirectives.h:41
llvm::MCAssembler::writeFragmentPadding
void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F, uint64_t FSize) const
Write the necessary bundle padding to OS.
Definition: MCAssembler.cpp:473
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::MCSymbolRefExpr::VK_None
@ VK_None
Definition: MCExpr.h:195
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:944
llvm::mc::getRelaxAll
bool getRelaxAll()
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHA
@ VK_PPC_DTPREL_HIGHA
Definition: MCExpr.h:280
llvm::MCObjectStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCObjectStreamer.cpp:870
llvm::MCObjectStreamer::emitFrames
void emitFrames(MCAsmBackend *MAB)
Definition: MCObjectStreamer.cpp:168
llvm::ARMBuildAttrs::File
@ File
Definition: ARMBuildAttributes.h:36
raw_ostream.h
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::MCObjectStreamer::emitCodeAlignment
void emitCodeAlignment(unsigned ByteAlignment, const MCSubtargetInfo *STI, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
Definition: MCObjectStreamer.cpp:611
llvm::MCDataFragment
Fragment for data and encoded instructions.
Definition: MCFragment.h:242
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:917
TargetRegistry.h
llvm::MCStreamer::SwitchSection
virtual void SwitchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
Definition: MCStreamer.cpp:1212
llvm::MCAssembler::isBundlingEnabled
bool isBundlingEnabled() const
Definition: MCAssembler.h:331
MCExpr.h
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:75
CheckBundleSubtargets
static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI, const MCSubtargetInfo *NewSTI)
Definition: MCELFStreamer.cpp:538
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1022
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::ELF::STB_GNU_UNIQUE
@ STB_GNU_UNIQUE
Definition: ELF.h:1141
llvm::MCSymbolRefExpr::VK_GOTTPOFF
@ VK_GOTTPOFF
Definition: MCExpr.h:203
setSectionAlignmentForBundling
static void setSectionAlignmentForBundling(const MCAssembler &Assembler, MCSection *Section)
Definition: MCELFStreamer.cpp:140
llvm::MCSymbolRefExpr::VK_PPC_DTPMOD
@ VK_PPC_DTPMOD
Definition: MCExpr.h:266
llvm::MCAssembler::CGProfileEntry
Definition: MCAssembler.h:436
llvm::MCEncodedFragmentWithContents::getContents
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:197
llvm::MCExpr::getLoc
SMLoc getLoc() const
Definition: MCExpr.h:82
llvm::MCContext::reportWarning
void reportWarning(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:970
llvm::MCCodeEmitter::encodeInstruction
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.
llvm::MCSymbolRefExpr::VK_DTPOFF
@ VK_DTPOFF
Definition: MCExpr.h:212
llvm::MCStreamer::emitZeros
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:226
llvm::MCAssembler::getWriter
MCObjectWriter & getWriter() const
Definition: MCAssembler.h:304
llvm::MCAssembler::CGProfile
std::vector< CGProfileEntry > CGProfile
Definition: MCAssembler.h:441