LLVM  15.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/MC/TargetRegistry.h"
33 #include "llvm/Support/Casting.h"
35 #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  case MCSA_Exported:
219  return false;
220 
221  case MCSA_NoDeadStrip:
222  // Ignore for now.
223  break;
224 
226  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
227  Symbol->setBinding(ELF::STB_GNU_UNIQUE);
229  break;
230 
231  case MCSA_Global:
232  // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
233  // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
234  // error on such cases. Note, we also disallow changed binding from .local.
235  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
237  Symbol->getName() +
238  " changed binding to STB_GLOBAL");
239  Symbol->setBinding(ELF::STB_GLOBAL);
240  break;
241 
242  case MCSA_WeakReference:
243  case MCSA_Weak:
244  // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
245  // We emit a warning for now but may switch to an error in the future.
246  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
248  getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
249  Symbol->setBinding(ELF::STB_WEAK);
250  break;
251 
252  case MCSA_Local:
253  if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
255  Symbol->getName() +
256  " changed binding to STB_LOCAL");
257  Symbol->setBinding(ELF::STB_LOCAL);
258  break;
259 
261  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
262  break;
263 
265  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
266  break;
267 
268  case MCSA_ELF_TypeObject:
269  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
270  break;
271 
272  case MCSA_ELF_TypeTLS:
273  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS));
274  break;
275 
276  case MCSA_ELF_TypeCommon:
277  // TODO: Emit these as a common symbol.
278  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
279  break;
280 
281  case MCSA_ELF_TypeNoType:
282  Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE));
283  break;
284 
285  case MCSA_Protected:
286  Symbol->setVisibility(ELF::STV_PROTECTED);
287  break;
288 
289  case MCSA_Hidden:
290  Symbol->setVisibility(ELF::STV_HIDDEN);
291  break;
292 
293  case MCSA_Internal:
294  Symbol->setVisibility(ELF::STV_INTERNAL);
295  break;
296 
297  case MCSA_AltEntry:
298  llvm_unreachable("ELF doesn't support the .alt_entry attribute");
299 
300  case MCSA_LGlobal:
301  llvm_unreachable("ELF doesn't support the .lglobl attribute");
302  }
303 
304  return true;
305 }
306 
308  unsigned ByteAlignment) {
309  auto *Symbol = cast<MCSymbolELF>(S);
311 
312  if (!Symbol->isBindingSet())
313  Symbol->setBinding(ELF::STB_GLOBAL);
314 
315  Symbol->setType(ELF::STT_OBJECT);
316 
317  if (Symbol->getBinding() == ELF::STB_LOCAL) {
321  switchSection(&Section);
322 
324  emitLabel(Symbol);
325  emitZeros(Size);
326 
327  switchSection(P.first, P.second);
328  } else {
329  if(Symbol->declareCommon(Size, ByteAlignment))
330  report_fatal_error(Twine("Symbol: ") + Symbol->getName() +
331  " redeclared as different type");
332  }
333 
334  cast<MCSymbolELF>(Symbol)
335  ->setSize(MCConstantExpr::create(Size, getContext()));
336 }
337 
339  cast<MCSymbolELF>(Symbol)->setSize(Value);
340 }
341 
343  StringRef Name,
344  bool KeepOriginalSym) {
346  getStartTokLoc(), OriginalSym, Name, KeepOriginalSym});
347 }
348 
350  unsigned ByteAlignment) {
351  auto *Symbol = cast<MCSymbolELF>(S);
352  // FIXME: Should this be caught and done earlier?
354  Symbol->setBinding(ELF::STB_LOCAL);
356 }
357 
358 void MCELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
359  SMLoc Loc) {
360  if (isBundleLocked())
361  report_fatal_error("Emitting values inside a locked bundle is forbidden");
362  fixSymbolsInTLSFixups(Value);
364 }
365 
367  int64_t Value,
368  unsigned ValueSize,
369  unsigned MaxBytesToEmit) {
370  if (isBundleLocked())
371  report_fatal_error("Emitting values inside a locked bundle is forbidden");
373  ValueSize, MaxBytesToEmit);
374 }
375 
377  const MCSymbolRefExpr *To,
378  uint64_t Count) {
379  getAssembler().CGProfile.push_back({From, To, Count});
380 }
381 
385  pushSection();
386  switchSection(Comment);
387  if (!SeenIdent) {
388  emitInt8(0);
389  SeenIdent = true;
390  }
391  emitBytes(IdentString);
392  emitInt8(0);
393  popSection();
394 }
395 
396 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
397  switch (expr->getKind()) {
398  case MCExpr::Target:
399  cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
400  break;
401  case MCExpr::Constant:
402  break;
403 
404  case MCExpr::Binary: {
405  const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
406  fixSymbolsInTLSFixups(be->getLHS());
407  fixSymbolsInTLSFixups(be->getRHS());
408  break;
409  }
410 
411  case MCExpr::SymbolRef: {
412  const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
413  switch (symRef.getKind()) {
414  default:
415  return;
470  break;
471  }
473  cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
474  break;
475  }
476 
477  case MCExpr::Unary:
478  fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
479  break;
480  }
481 }
482 
483 void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE,
484  uint64_t Offset) {
485  const MCSymbol *S = &SRE->getSymbol();
486  if (S->isTemporary()) {
487  if (!S->isInSection()) {
489  SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
490  "`" + S->getName() + "`");
491  return;
492  }
493  S = S->getSection().getBeginSymbol();
494  S->setUsedInReloc();
496  SRE->getLoc());
497  }
498  const MCConstantExpr *MCOffset = MCConstantExpr::create(Offset, getContext());
500  if (Optional<std::pair<bool, std::string>> Err =
502  *MCOffset, "BFD_RELOC_NONE", SRE, SRE->getLoc(),
503  *getContext().getSubtargetInfo()))
504  report_fatal_error("Relocation for CG Profile could not be created: " +
505  Twine(Err->second));
506 }
507 
508 void MCELFStreamer::finalizeCGProfile() {
510  if (Asm.CGProfile.empty())
511  return;
513  ".llvm.call-graph-profile", ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
514  ELF::SHF_EXCLUDE, /*sizeof(Elf_CGProfile_Impl<>)=*/8);
515  pushSection();
516  switchSection(CGProfile);
517  uint64_t Offset = 0;
518  for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
519  finalizeCGProfileEntry(E.From, Offset);
520  finalizeCGProfileEntry(E.To, Offset);
521  emitIntValue(E.Count, sizeof(uint64_t));
522  Offset += sizeof(uint64_t);
523  }
524  popSection();
525 }
526 
527 void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
528  const MCSubtargetInfo &STI) {
529  this->MCObjectStreamer::emitInstToFragment(Inst, STI);
530  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
531 
532  for (auto &Fixup : F.getFixups())
533  fixSymbolsInTLSFixups(Fixup.getValue());
534 }
535 
536 // A fragment can only have one Subtarget, and when bundling is enabled we
537 // sometimes need to use the same fragment. We give an error if there
538 // are conflicting Subtargets.
539 static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
540  const MCSubtargetInfo *NewSTI) {
541  if (OldSTI && NewSTI && OldSTI != NewSTI)
542  report_fatal_error("A Bundle can only have one Subtarget.");
543 }
544 
545 void MCELFStreamer::emitInstToData(const MCInst &Inst,
546  const MCSubtargetInfo &STI) {
547  MCAssembler &Assembler = getAssembler();
550  raw_svector_ostream VecOS(Code);
551  Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
552 
553  for (auto &Fixup : Fixups)
554  fixSymbolsInTLSFixups(Fixup.getValue());
555 
556  // There are several possibilities here:
557  //
558  // If bundling is disabled, append the encoded instruction to the current data
559  // fragment (or create a new such fragment if the current fragment is not a
560  // data fragment, or the Subtarget has changed).
561  //
562  // If bundling is enabled:
563  // - If we're not in a bundle-locked group, emit the instruction into a
564  // fragment of its own. If there are no fixups registered for the
565  // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
566  // MCDataFragment.
567  // - If we're in a bundle-locked group, append the instruction to the current
568  // data fragment because we want all the instructions in a group to get into
569  // the same fragment. Be careful not to do that for the first instruction in
570  // the group, though.
572 
573  if (Assembler.isBundlingEnabled()) {
575  if (Assembler.getRelaxAll() && isBundleLocked()) {
576  // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
577  // the current bundle group.
578  DF = BundleGroups.back();
579  CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
580  }
581  else if (Assembler.getRelaxAll() && !isBundleLocked())
582  // When not in a bundle-locked group and the -mc-relax-all flag is used,
583  // we create a new temporary fragment which will be later merged into
584  // the current fragment.
585  DF = new MCDataFragment();
586  else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
587  // If we are bundle-locked, we re-use the current fragment.
588  // The bundle-locking directive ensures this is a new data fragment.
589  DF = cast<MCDataFragment>(getCurrentFragment());
590  CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
591  }
592  else if (!isBundleLocked() && Fixups.size() == 0) {
593  // Optimize memory usage by emitting the instruction to a
594  // MCCompactEncodedInstFragment when not in a bundle-locked group and
595  // there are no fixups registered.
597  insert(CEIF);
598  CEIF->getContents().append(Code.begin(), Code.end());
599  CEIF->setHasInstructions(STI);
600  return;
601  } else {
602  DF = new MCDataFragment();
603  insert(DF);
604  }
606  // If this fragment is for a group marked "align_to_end", set a flag
607  // in the fragment. This can happen after the fragment has already been
608  // created if there are nested bundle_align groups and an inner one
609  // is the one marked align_to_end.
610  DF->setAlignToBundleEnd(true);
611  }
612 
613  // We're now emitting an instruction in a bundle group, so this flag has
614  // to be turned off.
616  } else {
617  DF = getOrCreateDataFragment(&STI);
618  }
619 
620  // Add the fixups and data.
621  for (auto &Fixup : Fixups) {
622  Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
623  DF->getFixups().push_back(Fixup);
624  }
625 
626  DF->setHasInstructions(STI);
627  DF->getContents().append(Code.begin(), Code.end());
628 
629  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
630  if (!isBundleLocked()) {
631  mergeFragment(getOrCreateDataFragment(&STI), DF);
632  delete DF;
633  }
634  }
635 }
636 
637 void MCELFStreamer::emitBundleAlignMode(unsigned AlignPow2) {
638  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
639  MCAssembler &Assembler = getAssembler();
640  if (AlignPow2 > 0 && (Assembler.getBundleAlignSize() == 0 ||
641  Assembler.getBundleAlignSize() == 1U << AlignPow2))
642  Assembler.setBundleAlignSize(1U << AlignPow2);
643  else
644  report_fatal_error(".bundle_align_mode cannot be changed once set");
645 }
646 
647 void MCELFStreamer::emitBundleLock(bool AlignToEnd) {
649 
650  if (!getAssembler().isBundlingEnabled())
651  report_fatal_error(".bundle_lock forbidden when bundling is disabled");
652 
653  if (!isBundleLocked())
655 
656  if (getAssembler().getRelaxAll() && !isBundleLocked()) {
657  // TODO: drop the lock state and set directly in the fragment
659  BundleGroups.push_back(DF);
660  }
661 
664 }
665 
668 
669  if (!getAssembler().isBundlingEnabled())
670  report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
671  else if (!isBundleLocked())
672  report_fatal_error(".bundle_unlock without matching lock");
673  else if (Sec.isBundleGroupBeforeFirstInst())
674  report_fatal_error("Empty bundle-locked group is forbidden");
675 
676  // When the -mc-relax-all flag is used, we emit instructions to fragments
677  // stored on a stack. When the bundle unlock is emitted, we pop a fragment
678  // from the stack a merge it to the one below.
679  if (getAssembler().getRelaxAll()) {
680  assert(!BundleGroups.empty() && "There are no bundle groups");
681  MCDataFragment *DF = BundleGroups.back();
682 
683  // FIXME: Use BundleGroups to track the lock state instead.
685 
686  // FIXME: Use more separate fragments for nested groups.
687  if (!isBundleLocked()) {
688  mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF);
689  BundleGroups.pop_back();
690  delete DF;
691  }
692 
695  } else
697 }
698 
700  // Emit the .gnu attributes section if any attributes have been added.
701  if (!GNUAttributes.empty()) {
702  MCSection *DummyAttributeSection = nullptr;
703  createAttributesSection("gnu", ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
704  DummyAttributeSection, GNUAttributes);
705  }
706 
707  // Ensure the last section gets aligned if necessary.
708  MCSection *CurSection = getCurrentSectionOnly();
710 
711  finalizeCGProfile();
712  emitFrames(nullptr);
713 
715 }
716 
718  llvm_unreachable("Generic ELF doesn't support this directive");
719 }
720 
721 void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
722  llvm_unreachable("ELF doesn't support this directive");
723 }
724 
726  uint64_t Size, unsigned ByteAlignment,
727  SMLoc Loc) {
728  llvm_unreachable("ELF doesn't support this directive");
729 }
730 
732  uint64_t Size, unsigned ByteAlignment) {
733  llvm_unreachable("ELF doesn't support this directive");
734 }
735 
737  bool OverwriteExisting) {
738  // Look for existing attribute item
739  if (AttributeItem *Item = getAttributeItem(Attribute)) {
740  if (!OverwriteExisting)
741  return;
742  Item->Type = AttributeItem::NumericAttribute;
743  Item->IntValue = Value;
744  return;
745  }
746 
747  // Create new attribute item
749  std::string(StringRef(""))};
750  Contents.push_back(Item);
751 }
752 
754  bool OverwriteExisting) {
755  // Look for existing attribute item
756  if (AttributeItem *Item = getAttributeItem(Attribute)) {
757  if (!OverwriteExisting)
758  return;
759  Item->Type = AttributeItem::TextAttribute;
760  Item->StringValue = std::string(Value);
761  return;
762  }
763 
764  // Create new attribute item
766  std::string(Value)};
767  Contents.push_back(Item);
768 }
769 
770 void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
771  StringRef StringValue,
772  bool OverwriteExisting) {
773  // Look for existing attribute item
774  if (AttributeItem *Item = getAttributeItem(Attribute)) {
775  if (!OverwriteExisting)
776  return;
778  Item->IntValue = IntValue;
779  Item->StringValue = std::string(StringValue);
780  return;
781  }
782 
783  // Create new attribute item
785  IntValue, std::string(StringValue)};
786  Contents.push_back(Item);
787 }
788 
790 MCELFStreamer::getAttributeItem(unsigned Attribute) {
791  for (size_t I = 0; I < Contents.size(); ++I)
792  if (Contents[I].Tag == Attribute)
793  return &Contents[I];
794  return nullptr;
795 }
796 
797 size_t
798 MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
799  size_t Result = 0;
800  for (size_t I = 0; I < AttrsVec.size(); ++I) {
801  AttributeItem Item = AttrsVec[I];
802  switch (Item.Type) {
804  break;
806  Result += getULEB128Size(Item.Tag);
807  Result += getULEB128Size(Item.IntValue);
808  break;
810  Result += getULEB128Size(Item.Tag);
811  Result += Item.StringValue.size() + 1; // string + '\0'
812  break;
814  Result += getULEB128Size(Item.Tag);
815  Result += getULEB128Size(Item.IntValue);
816  Result += Item.StringValue.size() + 1; // string + '\0';
817  break;
818  }
819  }
820  return Result;
821 }
822 
823 void MCELFStreamer::createAttributesSection(
824  StringRef Vendor, const Twine &Section, unsigned Type,
825  MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
826  // <format-version>
827  // [ <section-length> "vendor-name"
828  // [ <file-tag> <size> <attribute>*
829  // | <section-tag> <size> <section-number>* 0 <attribute>*
830  // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
831  // ]+
832  // ]*
833 
834  // Switch section to AttributeSection or get/create the section.
835  if (AttributeSection) {
836  switchSection(AttributeSection);
837  } else {
838  AttributeSection = getContext().getELFSection(Section, Type, 0);
839  switchSection(AttributeSection);
840 
841  // Format version
842  emitInt8(0x41);
843  }
844 
845  // Vendor size + Vendor name + '\0'
846  const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
847 
848  // Tag + Tag Size
849  const size_t TagHeaderSize = 1 + 4;
850 
851  const size_t ContentsSize = calculateContentSize(AttrsVec);
852 
853  emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
854  emitBytes(Vendor);
855  emitInt8(0); // '\0'
856 
858  emitInt32(TagHeaderSize + ContentsSize);
859 
860  // Size should have been accounted for already, now
861  // emit each field as its type (ULEB or String)
862  for (size_t I = 0; I < AttrsVec.size(); ++I) {
863  AttributeItem Item = AttrsVec[I];
864  emitULEB128IntValue(Item.Tag);
865  switch (Item.Type) {
866  default:
867  llvm_unreachable("Invalid attribute type");
869  emitULEB128IntValue(Item.IntValue);
870  break;
872  emitBytes(Item.StringValue);
873  emitInt8(0); // '\0'
874  break;
876  emitULEB128IntValue(Item.IntValue);
877  emitBytes(Item.StringValue);
878  emitInt8(0); // '\0'
879  break;
880  }
881  }
882 
883  AttrsVec.clear();
884 }
885 
887  std::unique_ptr<MCAsmBackend> &&MAB,
888  std::unique_ptr<MCObjectWriter> &&OW,
889  std::unique_ptr<MCCodeEmitter> &&CE,
890  bool RelaxAll) {
891  MCELFStreamer *S =
892  new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
893  if (RelaxAll)
894  S->getAssembler().setRelaxAll(true);
895  return S;
896 }
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:795
llvm::MCAssembler::getBackend
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:329
llvm::MCSection::isBundleLocked
bool isBundleLocked() const
Definition: MCSection.h:151
llvm::MCSymbolRefExpr::getKind
VariantKind getKind() const
Definition: MCExpr.h:401
i
i
Definition: README.txt:29
llvm::MCELFStreamer::AttributeItem::NumericAttribute
@ NumericAttribute
Definition: MCELFStreamer.h:97
llvm::MCObjectWriter::markGnuAbi
virtual void markGnuAbi()
ELF only. Mark that we have seen GNU ABI usage (e.g. SHF_GNU_RETAIN).
Definition: MCObjectWriter.h:93
llvm::ELF::STT_FUNC
@ STT_FUNC
Definition: ELF.h:1202
llvm::MCContext::getObjectFileInfo
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:447
llvm::MCStreamer::visitUsedExpr
void visitUsedExpr(const MCExpr &Expr)
Definition: MCStreamer.cpp:1070
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::MCRelaxableFragment
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:270
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:266
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition: ELF.h:1032
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:176
llvm::MCObjectStreamer::emitLabel
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
Definition: MCObjectStreamer.cpp:286
llvm::MCAssembler::Symvers
std::vector< Symver > Symvers
Definition: MCAssembler.h:235
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::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:1044
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HA
@ VK_PPC_TPREL_HA
Definition: MCExpr.h:270
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:993
llvm::MCAssembler::registerSymbol
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
Definition: MCAssembler.cpp:467
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:644
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER
@ VK_PPC_DTPREL_HIGHER
Definition: MCExpr.h:282
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST
@ VK_PPC_DTPREL_HIGHEST
Definition: MCExpr.h:284
llvm::MCSymbolRefExpr::VK_PPC_TLSGD
@ VK_PPC_TLSGD
Definition: MCExpr.h:299
llvm::MCSymbolRefExpr::VK_INDNTPOFF
@ VK_INDNTPOFF
Definition: MCExpr.h:205
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
llvm::Attribute
Definition: Attributes.h:65
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::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:725
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:288
MCSectionELF.h
llvm::MCStreamer::emitInt8
void emitInt8(uint64_t Value)
Definition: MCStreamer.h:736
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
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:211
ErrorHandling.h
MCFragment.h
llvm::ELF::STT_GNU_IFUNC
@ STT_GNU_IFUNC
Definition: ELF.h:1207
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1060
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:297
MCObjectFileInfo.h
llvm::MCObjectStreamer::emitLabelAtPos
virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset)
Definition: MCObjectStreamer.cpp:322
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HI
@ VK_PPC_DTPREL_HI
Definition: MCExpr.h:278
llvm::MCSection::getBundleLockState
BundleLockStateType getBundleLockState() const
Definition: MCSection.h:149
llvm::getULEB128Size
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:19
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:731
llvm::MCStreamer::popSection
bool popSection()
Restore the current and previous section from the section stack.
Definition: MCStreamer.h:420
llvm::MCStreamer::emitInt32
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:738
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::Optional
Definition: APInt.h:33
llvm::MCELFStreamer::AttributeItem::NumericAndTextAttributes
@ NumericAndTextAttributes
Definition: MCELFStreamer.h:99
llvm::MCSA_ELF_TypeNoType
@ MCSA_ELF_TypeNoType
.type _foo, STT_NOTYPE # aka @notype
Definition: MCDirectives.h:28
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1035
llvm::ELF::STT_TLS
@ STT_TLS
Definition: ELF.h:1206
llvm::MCStreamer::getCurrentSection
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:384
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO
@ VK_PPC_GOT_TLSGD_LO
Definition: MCExpr.h:296
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA
@ VK_PPC_DTPREL_HIGHESTA
Definition: MCExpr.h:285
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:222
llvm::MCSectionELF
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:26
llvm::MCAssemblerFlag
MCAssemblerFlag
Definition: MCDirectives.h:51
llvm::MCSymbol::setVariableValue
void setVariableValue(const MCExpr *Value)
Definition: MCSymbol.cpp:47
llvm::MCSection::setBundleGroupBeforeFirstInst
void setBundleGroupBeforeFirstInst(bool IsFirst)
Definition: MCSection.h:156
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:105
llvm::MCBinaryExpr
Binary assembler expressions.
Definition: MCExpr.h:481
MCELFStreamer.h
F
#define F(x, y, z)
Definition: MD5.cpp:55
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:38
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHA
@ VK_PPC_TPREL_HIGHA
Definition: MCExpr.h:272
llvm::MCSA_NoDeadStrip
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:39
llvm::MCSymbolRefExpr::VK_PPC_TLS
@ VK_PPC_TLS
Definition: MCExpr.h:294
llvm::MCFragment
Definition: MCFragment.h:30
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:212
llvm::MCSymbolRefExpr::VK_NTPOFF
@ VK_NTPOFF
Definition: MCExpr.h:206
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL
@ VK_PPC_GOT_TLSGD_PCREL
Definition: MCExpr.h:307
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO
@ VK_PPC_GOT_DTPREL_LO
Definition: MCExpr.h:291
ELF.h
llvm::MCELFStreamer
Definition: MCELFStreamer.h:31
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:989
MCAsmBackend.h
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
SmallString.h
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST
@ VK_PPC_TPREL_HIGHEST
Definition: MCExpr.h:275
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:667
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1189
llvm::MCAssembler::getContext
MCContext & getContext() const
Definition: MCAssembler.h:321
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:41
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:244
MCSymbolELF.h
llvm::MCSA_Protected
@ MCSA_Protected
.protected (ELF)
Definition: MCDirectives.h:43
MCContext.h
llvm::MCSymbolRefExpr::VK_GOTNTPOFF
@ VK_GOTNTPOFF
Definition: MCExpr.h:207
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:1225
llvm::MCSymbolRefExpr::VK_DTPREL
@ VK_DTPREL
Definition: MCExpr.h:358
MCSymbol.h
llvm::MCSA_LazyReference
@ MCSA_LazyReference
.lazy_reference (MachO)
Definition: MCDirectives.h:37
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::MCELFStreamer::emitCGProfileEntry
void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override
Definition: MCELFStreamer.cpp:376
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:560
llvm::MCSymbolRefExpr::VK_TLSLDM
@ VK_TLSLDM
Definition: MCExpr.h:211
llvm::MCAF_Code16
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:54
llvm::MCObjectStreamer
Streaming object file generation interface.
Definition: MCObjectStreamer.h:42
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:44
llvm::MCELFStreamer::emitBundleLock
void emitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
Definition: MCELFStreamer.cpp:647
llvm::MCID::Flag
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:147
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:143
llvm::MCSymbolRefExpr::getSymbol
const MCSymbol & getSymbol() const
Definition: MCExpr.h:399
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA
@ VK_PPC_DTPREL_HIGHERA
Definition: MCExpr.h:283
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA
@ VK_PPC_GOT_DTPREL_HA
Definition: MCExpr.h:293
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:210
llvm::MCELFStreamer::emitCommonSymbol
void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a common symbol.
Definition: MCELFStreamer.cpp:307
llvm::MCSA_ELF_TypeGnuUniqueObject
@ MCSA_ELF_TypeGnuUniqueObject
Definition: MCDirectives.h:29
llvm::MCELFStreamer::Contents
SmallVector< AttributeItem, 64 > Contents
Definition: MCELFStreamer.h:107
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
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:201
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HI
@ VK_PPC_TPREL_HI
Definition: MCExpr.h:269
llvm::MCAssembler::setBundleAlignSize
void setBundleAlignSize(unsigned Size)
Definition: MCAssembler.h:364
llvm::MCStreamer::getCurrentSectionOnly
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:389
llvm::MCObjectFileInfo::getTextSection
MCSection * getTextSection() const
Definition: MCObjectFileInfo.h:267
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::MCSA_Exported
@ MCSA_Exported
.globl _foo, exported (XCOFF)
Definition: MCDirectives.h:34
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:962
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL
@ VK_PPC_GOT_TPREL_PCREL
Definition: MCExpr.h:309
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:366
llvm::ELF::STV_HIDDEN
@ STV_HIDDEN
Definition: ELF.h:1220
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:717
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI
@ VK_PPC_GOT_DTPREL_HI
Definition: MCExpr.h:292
llvm::MCSA_WeakDefAutoPrivate
@ MCSA_WeakDefAutoPrivate
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:48
llvm::MCELFStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCELFStreamer.cpp:699
llvm::MCSection::BundleLockedAlignToEnd
@ BundleLockedAlignToEnd
Definition: MCSection.h:58
llvm::MCELFStreamer::emitELFSymverDirective
void emitELFSymverDirective(const MCSymbol *OriginalSym, StringRef Name, bool KeepOriginalSym) override
Emit an ELF .symver directive.
Definition: MCELFStreamer.cpp:342
llvm::MCSymbolRefExpr::VK_PPC_TLSLD
@ VK_PPC_TLSLD
Definition: MCExpr.h:311
llvm::MCAssembler
Definition: MCAssembler.h:73
llvm::MCAssembler::getEmitter
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:331
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:413
llvm::MCAF_SubsectionsViaSymbols
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:53
llvm::MCELFStreamer::emitLocalCommonSymbol
void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment) override
Emit a local common (.lcomm) symbol.
Definition: MCELFStreamer.cpp:349
uint64_t
llvm::MCCompactEncodedInstFragment
This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that...
Definition: MCFragment.h:256
llvm::MCContext::getAsmInfo
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:443
llvm::ELF::STT_NOTYPE
@ STT_NOTYPE
Definition: ELF.h:1200
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1188
llvm::MCSymbolRefExpr::VK_PPC_TLS_PCREL
@ VK_PPC_TLS_PCREL
Definition: MCExpr.h:310
llvm::MCSA_WeakReference
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:47
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:382
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:721
llvm::MCEncodedFragment::setBundlePadding
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
Definition: MCFragment.h:168
llvm::MCSymbolRefExpr::VK_TLSDESC
@ VK_TLSDESC
Definition: MCExpr.h:215
llvm::MCAssembler::getBundleAlignSize
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:362
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD
@ VK_PPC_GOT_TLSGD
Definition: MCExpr.h:295
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL
@ VK_PPC_GOT_TPREL
Definition: MCExpr.h:286
llvm::MCStreamer::getStartTokLoc
SMLoc getStartTokLoc() const
Definition: MCStreamer.h:285
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGH
@ VK_PPC_TPREL_HIGH
Definition: MCExpr.h:271
llvm::MCObjectStreamer::insert
void insert(MCFragment *F)
Definition: MCObjectStreamer.h:94
llvm::MCStreamer::pushSection
void pushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:411
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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:1675
llvm::MCSymbolRefExpr::VK_TLSCALL
@ VK_TLSCALL
Definition: MCExpr.h:214
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:134
llvm::MCContext::reportError
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1037
llvm::MCAssembler::getRelaxAll
bool getRelaxAll() const
Definition: MCAssembler.h:357
llvm::MCSymbolRefExpr::VK_PPC_TPREL_LO
@ VK_PPC_TPREL_LO
Definition: MCExpr.h:268
llvm::MCSymbolRefExpr::VK_PPC_GOT_DTPREL
@ VK_PPC_GOT_DTPREL
Definition: MCExpr.h:290
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:212
MCSection.h
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_LO
@ VK_PPC_DTPREL_LO
Definition: MCExpr.h:277
llvm::ELF::STV_INTERNAL
@ STV_INTERNAL
Definition: ELF.h:1219
llvm::MCObjectStreamer::getAssembler
MCAssembler & getAssembler()
Definition: MCObjectStreamer.h:128
llvm::MCELFStreamer::setAttributeItem
void setAttributeItem(unsigned Attribute, unsigned Value, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:736
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:358
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:225
MCAsmInfo.h
Fixup
PowerPC TLS Dynamic Call Fixup
Definition: PPCTLSDynamicCall.cpp:233
llvm::MCObjectStreamer::changeSectionImpl
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
Definition: MCObjectStreamer.cpp:368
llvm::ELF::SHF_GNU_RETAIN
@ SHF_GNU_RETAIN
Definition: ELF.h:1066
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:143
llvm::MCAssembler::Symver
Definition: MCAssembler.h:228
llvm::MCELFStreamer::setAttributeItems
void setAttributeItems(unsigned Attribute, unsigned IntValue, StringRef StringValue, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:770
MCFixup.h
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
llvm::MCELFStreamer::AttributeItem::HiddenAttribute
@ HiddenAttribute
Definition: MCELFStreamer.h:96
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:303
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:461
llvm::MCSA_IndirectSymbol
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition: MCDirectives.h:35
CombineSymbolTypes
static unsigned CombineSymbolTypes(unsigned T1, unsigned T2)
Definition: MCELFStreamer.cpp:181
llvm::MCSymbolRefExpr::VK_WEAKREF
@ VK_WEAKREF
Definition: MCExpr.h:225
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHER
@ VK_PPC_TPREL_HIGHER
Definition: MCExpr.h:273
llvm::MCSA_Internal
@ MCSA_Internal
.internal (ELF)
Definition: MCDirectives.h:36
llvm::ELF::STB_GNU_UNIQUE
@ STB_GNU_UNIQUE
Definition: ELF.h:1191
llvm::MCELFStreamer::AttributeItem
ELF object attributes section emission support.
Definition: MCELFStreamer.h:91
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA
@ VK_PPC_TPREL_HIGHESTA
Definition: MCExpr.h:276
llvm::MCAF_Code32
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:55
llvm::MCSA_ELF_TypeCommon
@ MCSA_ELF_TypeCommon
.type _foo, STT_COMMON # aka @common
Definition: MCDirectives.h:27
llvm::MCSection::BundleLocked
@ BundleLocked
Definition: MCSection.h:57
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO
@ VK_PPC_GOT_TPREL_LO
Definition: MCExpr.h:287
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:886
llvm::MCSection::isBundleGroupBeforeFirstInst
bool isBundleGroupBeforeFirstInst() const
Definition: MCSection.h:153
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI
@ VK_PPC_GOT_TLSLD_HI
Definition: MCExpr.h:304
llvm::StringRef::size
constexpr LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::MCAF_Code64
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:56
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA
@ VK_PPC_GOT_TLSGD_HA
Definition: MCExpr.h:298
MCObjectWriter.h
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1221
llvm::MCSymbolRefExpr::VK_TPREL
@ VK_TPREL
Definition: MCExpr.h:357
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:637
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGH
@ VK_PPC_DTPREL_HIGH
Definition: MCExpr.h:280
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA
@ VK_PPC_TPREL_HIGHERA
Definition: MCExpr.h:274
llvm::MCAF_SyntaxUnified
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:52
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:851
llvm::MCSA_SymbolResolver
@ MCSA_SymbolResolver
.symbol_resolver (MachO)
Definition: MCDirectives.h:40
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1041
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition: ELF.h:1201
llvm::MCEncodedFragment::getSubtargetInfo
const MCSubtargetInfo * getSubtargetInfo() const
Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
Definition: MCFragment.h:172
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:56
llvm::MCSymbolRefExpr::VK_TLSGD
@ VK_TLSGD
Definition: MCExpr.h:209
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:386
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:591
llvm::MCSA_Global
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
llvm::MCSA_WeakDefinition
@ MCSA_WeakDefinition
.weak_definition (MachO)
Definition: MCDirectives.h:46
llvm::LCOMM::ByteAlignment
@ ByteAlignment
Definition: MCAsmInfo.h:50
llvm::MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA
@ VK_PPC_GOT_TPREL_HA
Definition: MCExpr.h:289
llvm::MCSA_ELF_TypeFunction
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
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:213
llvm::MCSA_Weak
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
llvm::MCEncodedFragment::setAlignToBundleEnd
void setAlignToBundleEnd(bool V)
Definition: MCFragment.h:157
llvm::MCObjectStreamer::emitBytes
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
Definition: MCObjectStreamer.cpp:637
llvm::MCObjectStreamer::flushPendingLabels
void flushPendingLabels()
Create a data fragment for any pending labels across all Sections and Subsections.
Definition: MCObjectStreamer.cpp:91
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HA
@ VK_PPC_DTPREL_HA
Definition: MCExpr.h:279
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD
@ VK_PPC_GOT_TLSLD
Definition: MCExpr.h:302
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:162
llvm::MCStreamer::getContext
MCContext & getContext() const
Definition: MCStreamer.h:293
SmallVector.h
llvm::MCExpr::SymbolRef
@ SymbolRef
References to labels and assigned expressions.
Definition: MCExpr.h:40
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:955
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:338
MCStreamer.h
llvm::MCELFStreamer::emitBundleUnlock
void emitBundleUnlock() override
Ends a bundle-locked group.
Definition: MCELFStreamer.cpp:666
llvm::MCSectionSubPair
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Definition: MCStreamer.h:66
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:581
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:348
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:662
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA
@ VK_PPC_GOT_TLSLD_HA
Definition: MCExpr.h:305
llvm::MCSA_PrivateExtern
@ MCSA_PrivateExtern
.private_extern (MachO)
Definition: MCDirectives.h:42
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:477
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::MCSymbolRefExpr::VK_None
@ VK_None
Definition: MCExpr.h:195
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:281
llvm::MCObjectStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCObjectStreamer.cpp:919
llvm::MCObjectStreamer::emitFrames
void emitFrames(MCAsmBackend *MAB)
Definition: MCObjectStreamer.cpp:190
llvm::MCELFStreamer::AttributeItem::TextAttribute
@ TextAttribute
Definition: MCELFStreamer.h:98
llvm::ARMBuildAttrs::File
@ File
Definition: ARMBuildAttributes.h:36
raw_ostream.h
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:659
llvm::MCDataFragment
Fragment for data and encoded instructions.
Definition: MCFragment.h:241
TargetRegistry.h
llvm::MCAssembler::isBundlingEnabled
bool isBundlingEnabled() const
Definition: MCAssembler.h:360
MCExpr.h
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:76
CheckBundleSubtargets
static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI, const MCSubtargetInfo *NewSTI)
Definition: MCELFStreamer.cpp:539
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1190
llvm::MCSymbolRefExpr::VK_GOTTPOFF
@ VK_GOTTPOFF
Definition: MCExpr.h:204
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1069
setSectionAlignmentForBundling
static void setSectionAlignmentForBundling(const MCAssembler &Assembler, MCSection *Section)
Definition: MCELFStreamer.cpp:140
llvm::MCSymbolRefExpr::VK_PPC_DTPMOD
@ VK_PPC_DTPMOD
Definition: MCExpr.h:267
llvm::MCAssembler::CGProfileEntry
Definition: MCAssembler.h:465
llvm::MCEncodedFragmentWithContents::getContents
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:196
llvm::MCExpr::getLoc
SMLoc getLoc() const
Definition: MCExpr.h:82
llvm::MCContext::reportWarning
void reportWarning(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1044
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:213
llvm::MCStreamer::emitZeros
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:227
llvm::MCAssembler::getWriter
MCObjectWriter & getWriter() const
Definition: MCAssembler.h:333
llvm::MCAssembler::CGProfile
std::vector< CGProfileEntry > CGProfile
Definition: MCAssembler.h:470