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/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  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(Twine("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  Twine(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  if (!getAssembler().isBundlingEnabled())
650  report_fatal_error(".bundle_lock forbidden when bundling is disabled");
651 
652  if (!isBundleLocked())
654 
655  if (getAssembler().getRelaxAll() && !isBundleLocked()) {
656  // TODO: drop the lock state and set directly in the fragment
658  BundleGroups.push_back(DF);
659  }
660 
663 }
664 
667 
668  if (!getAssembler().isBundlingEnabled())
669  report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
670  else if (!isBundleLocked())
671  report_fatal_error(".bundle_unlock without matching lock");
672  else if (Sec.isBundleGroupBeforeFirstInst())
673  report_fatal_error("Empty bundle-locked group is forbidden");
674 
675  // When the -mc-relax-all flag is used, we emit instructions to fragments
676  // stored on a stack. When the bundle unlock is emitted, we pop a fragment
677  // from the stack a merge it to the one below.
678  if (getAssembler().getRelaxAll()) {
679  assert(!BundleGroups.empty() && "There are no bundle groups");
680  MCDataFragment *DF = BundleGroups.back();
681 
682  // FIXME: Use BundleGroups to track the lock state instead.
684 
685  // FIXME: Use more separate fragments for nested groups.
686  if (!isBundleLocked()) {
687  mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF);
688  BundleGroups.pop_back();
689  delete DF;
690  }
691 
694  } else
696 }
697 
699  // Emit the .gnu attributes section if any attributes have been added.
700  if (!GNUAttributes.empty()) {
701  MCSection *DummyAttributeSection = nullptr;
702  createAttributesSection("gnu", ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
703  DummyAttributeSection, GNUAttributes);
704  }
705 
706  // Ensure the last section gets aligned if necessary.
707  MCSection *CurSection = getCurrentSectionOnly();
709 
710  finalizeCGProfile();
711  emitFrames(nullptr);
712 
714 }
715 
717  llvm_unreachable("Generic ELF doesn't support this directive");
718 }
719 
720 void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
721  llvm_unreachable("ELF doesn't support this directive");
722 }
723 
725  uint64_t Size, unsigned ByteAlignment,
726  SMLoc Loc) {
727  llvm_unreachable("ELF doesn't support this directive");
728 }
729 
731  uint64_t Size, unsigned ByteAlignment) {
732  llvm_unreachable("ELF doesn't support this directive");
733 }
734 
736  bool OverwriteExisting) {
737  // Look for existing attribute item
738  if (AttributeItem *Item = getAttributeItem(Attribute)) {
739  if (!OverwriteExisting)
740  return;
741  Item->Type = AttributeItem::NumericAttribute;
742  Item->IntValue = Value;
743  return;
744  }
745 
746  // Create new attribute item
748  std::string(StringRef(""))};
749  Contents.push_back(Item);
750 }
751 
753  bool OverwriteExisting) {
754  // Look for existing attribute item
755  if (AttributeItem *Item = getAttributeItem(Attribute)) {
756  if (!OverwriteExisting)
757  return;
758  Item->Type = AttributeItem::TextAttribute;
759  Item->StringValue = std::string(Value);
760  return;
761  }
762 
763  // Create new attribute item
765  std::string(Value)};
766  Contents.push_back(Item);
767 }
768 
769 void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
770  StringRef StringValue,
771  bool OverwriteExisting) {
772  // Look for existing attribute item
773  if (AttributeItem *Item = getAttributeItem(Attribute)) {
774  if (!OverwriteExisting)
775  return;
777  Item->IntValue = IntValue;
778  Item->StringValue = std::string(StringValue);
779  return;
780  }
781 
782  // Create new attribute item
784  IntValue, std::string(StringValue)};
785  Contents.push_back(Item);
786 }
787 
789 MCELFStreamer::getAttributeItem(unsigned Attribute) {
790  for (size_t I = 0; I < Contents.size(); ++I)
791  if (Contents[I].Tag == Attribute)
792  return &Contents[I];
793  return nullptr;
794 }
795 
796 size_t
797 MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
798  size_t Result = 0;
799  for (size_t I = 0; I < AttrsVec.size(); ++I) {
800  AttributeItem Item = AttrsVec[I];
801  switch (Item.Type) {
803  break;
805  Result += getULEB128Size(Item.Tag);
806  Result += getULEB128Size(Item.IntValue);
807  break;
809  Result += getULEB128Size(Item.Tag);
810  Result += Item.StringValue.size() + 1; // string + '\0'
811  break;
813  Result += getULEB128Size(Item.Tag);
814  Result += getULEB128Size(Item.IntValue);
815  Result += Item.StringValue.size() + 1; // string + '\0';
816  break;
817  }
818  }
819  return Result;
820 }
821 
822 void MCELFStreamer::createAttributesSection(
823  StringRef Vendor, const Twine &Section, unsigned Type,
824  MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
825  // <format-version>
826  // [ <section-length> "vendor-name"
827  // [ <file-tag> <size> <attribute>*
828  // | <section-tag> <size> <section-number>* 0 <attribute>*
829  // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
830  // ]+
831  // ]*
832 
833  // Switch section to AttributeSection or get/create the section.
834  if (AttributeSection) {
835  SwitchSection(AttributeSection);
836  } else {
837  AttributeSection = getContext().getELFSection(Section, Type, 0);
838  SwitchSection(AttributeSection);
839 
840  // Format version
841  emitInt8(0x41);
842  }
843 
844  // Vendor size + Vendor name + '\0'
845  const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
846 
847  // Tag + Tag Size
848  const size_t TagHeaderSize = 1 + 4;
849 
850  const size_t ContentsSize = calculateContentSize(AttrsVec);
851 
852  emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
853  emitBytes(Vendor);
854  emitInt8(0); // '\0'
855 
857  emitInt32(TagHeaderSize + ContentsSize);
858 
859  // Size should have been accounted for already, now
860  // emit each field as its type (ULEB or String)
861  for (size_t I = 0; I < AttrsVec.size(); ++I) {
862  AttributeItem Item = AttrsVec[I];
863  emitULEB128IntValue(Item.Tag);
864  switch (Item.Type) {
865  default:
866  llvm_unreachable("Invalid attribute type");
868  emitULEB128IntValue(Item.IntValue);
869  break;
871  emitBytes(Item.StringValue);
872  emitInt8(0); // '\0'
873  break;
875  emitULEB128IntValue(Item.IntValue);
876  emitBytes(Item.StringValue);
877  emitInt8(0); // '\0'
878  break;
879  }
880  }
881 
882  AttrsVec.clear();
883 }
884 
886  std::unique_ptr<MCAsmBackend> &&MAB,
887  std::unique_ptr<MCObjectWriter> &&OW,
888  std::unique_ptr<MCCodeEmitter> &&CE,
889  bool RelaxAll) {
890  MCELFStreamer *S =
891  new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
892  if (RelaxAll)
893  S->getAssembler().setRelaxAll(true);
894  return S;
895 }
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:795
llvm::MCAssembler::getBackend
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:316
llvm::MCSection::isBundleLocked
bool isBundleLocked() const
Definition: MCSection.h:149
llvm::MCSymbolRefExpr::getKind
VariantKind getKind() const
Definition: MCExpr.h:401
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:1064
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:22
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:287
llvm::MCAssembler::Symvers
std::vector< Symver > Symvers
Definition: MCAssembler.h:222
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:270
llvm::MCAssembler::registerSymbol
void registerSymbol(const MCSymbol &Symbol, bool *Created=nullptr)
Definition: MCAssembler.cpp:466
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:645
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER
@ VK_PPC_DTPREL_HIGHER
Definition: MCExpr.h:282
llvm::ELF::STB_GNU_UNIQUE
@ STB_GNU_UNIQUE
Definition: ELF.h:1152
llvm::ELF::SHF_TLS
@ SHF_TLS
Definition: ELF.h:1024
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: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::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:1008
llvm::MCSA_ELF_TypeObject
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
MCCodeEmitter.h
llvm::ELF::SHF_GNU_RETAIN
@ SHF_GNU_RETAIN
Definition: ELF.h:1030
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:724
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:717
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1176
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::MCELFStreamer::AttributeItem::NumericAttribute
@ NumericAttribute
Definition: MCELFStreamer.h:90
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
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:323
llvm::MCSymbolRefExpr::VK_PPC_DTPREL_HI
@ VK_PPC_DTPREL_HI
Definition: MCExpr.h:278
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::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:730
llvm::MCStreamer::emitInt32
void emitInt32(uint64_t Value)
Definition: MCStreamer.h:719
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::Optional
Definition: APInt.h:33
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:80
llvm::ELF::STV_INTERNAL
@ STV_INTERNAL
Definition: ELF.h:1180
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: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: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:481
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:959
MCELFStreamer.h
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::ELF::STT_TLS
@ STT_TLS
Definition: ELF.h:1167
llvm::MCSymbolAttr
MCSymbolAttr
Definition: MCDirectives.h:18
llvm::MCSA_Cold
@ MCSA_Cold
.cold (MachO)
Definition: MCDirectives.h:22
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
llvm::MCSA_Local
@ MCSA_Local
.local (ELF)
Definition: MCDirectives.h:37
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGHA
@ VK_PPC_TPREL_HIGHA
Definition: MCExpr.h:272
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
llvm::MCSA_NoDeadStrip
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:38
llvm::MCSymbolRefExpr::VK_PPC_TLS
@ VK_PPC_TLS
Definition: MCExpr.h:294
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: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:24
MCAsmBackend.h
llvm::SMLoc
Represents a location in source code.
Definition: SMLoc.h:23
llvm::ELF::SHF_EXCLUDE
@ SHF_EXCLUDE
Definition: ELF.h:1033
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:656
llvm::MCAssembler::getContext
MCContext & getContext() const
Definition: MCAssembler.h:308
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:245
MCSymbolELF.h
llvm::MCSA_Protected
@ MCSA_Protected
.protected (ELF)
Definition: MCDirectives.h:42
MCContext.h
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1151
llvm::MCSymbolRefExpr::VK_GOTNTPOFF
@ VK_GOTNTPOFF
Definition: MCExpr.h:207
llvm::MCSymbolRefExpr::VK_DTPREL
@ VK_DTPREL
Definition: MCExpr.h:358
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:211
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: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::AttributeItem::NumericAndTextAttributes
@ NumericAndTextAttributes
Definition: MCELFStreamer.h:92
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:82
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:202
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1150
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HI
@ VK_PPC_TPREL_HI
Definition: MCExpr.h:269
llvm::MCAssembler::setBundleAlignSize
void setBundleAlignSize(unsigned Size)
Definition: MCAssembler.h:351
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::ELF::STT_FUNC
@ STT_FUNC
Definition: ELF.h:1163
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:365
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1149
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:716
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:47
llvm::MCELFStreamer::AttributeItem::HiddenAttribute
@ HiddenAttribute
Definition: MCELFStreamer.h:89
llvm::MCELFStreamer::finishImpl
void finishImpl() override
Streamer specific finalization.
Definition: MCELFStreamer.cpp:698
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:311
llvm::MCAssembler
Definition: MCAssembler.h:60
llvm::MCAssembler::getEmitter
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:318
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::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:921
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: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::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:999
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:720
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:215
llvm::MCAssembler::getBundleAlignSize
unsigned getBundleAlignSize() const
Definition: MCAssembler.h:349
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1182
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:272
llvm::MCSymbolRefExpr::VK_PPC_TPREL_HIGH
@ VK_PPC_TPREL_HIGH
Definition: MCExpr.h:271
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:88
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:1650
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:133
llvm::MCContext::reportError
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:963
llvm::MCAssembler::getRelaxAll
bool getRelaxAll() const
Definition: MCAssembler.h:344
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::MCObjectStreamer::getAssembler
MCAssembler & getAssembler()
Definition: MCObjectStreamer.h:122
llvm::ELF::STT_OBJECT
@ STT_OBJECT
Definition: ELF.h:1162
llvm::MCELFStreamer::setAttributeItem
void setAttributeItem(unsigned Attribute, unsigned Value, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:735
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:226
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:369
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:134
llvm::MCAssembler::Symver
Definition: MCAssembler.h:215
llvm::ELF::STV_HIDDEN
@ STV_HIDDEN
Definition: ELF.h:1181
llvm::MCELFStreamer::setAttributeItems
void setAttributeItems(unsigned Attribute, unsigned IntValue, StringRef StringValue, bool OverwriteExisting)
Definition: MCELFStreamer.cpp:769
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: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:462
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::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: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:276
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: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:885
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: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:55
llvm::MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA
@ VK_PPC_GOT_TLSGD_HA
Definition: MCExpr.h:298
MCObjectWriter.h
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:636
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:51
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:850
llvm::MCSA_SymbolResolver
@ MCSA_SymbolResolver
.symbol_resolver (MachO)
Definition: MCDirectives.h:39
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1005
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: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:580
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:45
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::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:955
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: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:638
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: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: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
MCStreamer.h
llvm::MCELFStreamer::emitBundleUnlock
void emitBundleUnlock() override
Ends a bundle-locked group.
Definition: MCELFStreamer.cpp:665
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:335
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: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:476
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::ELF::SHF_WRITE
@ SHF_WRITE
Definition: ELF.h:996
llvm::ELF::STT_GNU_IFUNC
@ STT_GNU_IFUNC
Definition: ELF.h:1168
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:191
llvm::ARMBuildAttrs::File
@ File
Definition: ARMBuildAttributes.h:36
raw_ostream.h
llvm::ELF::STT_NOTYPE
@ STT_NOTYPE
Definition: ELF.h:1161
llvm::MCELFStreamer::AttributeItem::TextAttribute
@ TextAttribute
Definition: MCELFStreamer.h:91
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::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:928
llvm::MCDataFragment
Fragment for data and encoded instructions.
Definition: MCFragment.h:242
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:1215
llvm::MCAssembler::isBundlingEnabled
bool isBundlingEnabled() const
Definition: MCAssembler.h:347
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::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::MCSymbolRefExpr::VK_GOTTPOFF
@ VK_GOTTPOFF
Definition: MCExpr.h:204
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:452
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:213
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:320
llvm::MCAssembler::CGProfile
std::vector< CGProfileEntry > CGProfile
Definition: MCAssembler.h:457