LLVM  7.0.0svn
ARMELFStreamer.cpp
Go to the documentation of this file.
1 //===- lib/MC/ARMELFStreamer.cpp - ELF Object Output for ARM --------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file assembles .s files and emits ARM ELF .o object files. Different
11 // from generic ELF streamer in emitting mapping symbols ($a, $t and $d) to
12 // delimit regions of data and code.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "ARMRegisterInfo.h"
17 #include "ARMUnwindOpAsm.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/ADT/Twine.h"
24 #include "llvm/BinaryFormat/ELF.h"
25 #include "llvm/MC/MCAsmBackend.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCAssembler.h"
28 #include "llvm/MC/MCCodeEmitter.h"
29 #include "llvm/MC/MCContext.h"
30 #include "llvm/MC/MCELFStreamer.h"
31 #include "llvm/MC/MCExpr.h"
32 #include "llvm/MC/MCFixup.h"
33 #include "llvm/MC/MCFragment.h"
34 #include "llvm/MC/MCInst.h"
35 #include "llvm/MC/MCInstPrinter.h"
36 #include "llvm/MC/MCObjectWriter.h"
37 #include "llvm/MC/MCRegisterInfo.h"
38 #include "llvm/MC/MCSection.h"
39 #include "llvm/MC/MCSectionELF.h"
40 #include "llvm/MC/MCStreamer.h"
42 #include "llvm/MC/MCSymbol.h"
43 #include "llvm/MC/MCSymbolELF.h"
44 #include "llvm/MC/SectionKind.h"
46 #include "llvm/Support/ARMEHABI.h"
47 #include "llvm/Support/Casting.h"
50 #include "llvm/Support/LEB128.h"
53 #include <algorithm>
54 #include <cassert>
55 #include <climits>
56 #include <cstddef>
57 #include <cstdint>
58 #include <string>
59 
60 using namespace llvm;
61 
62 static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
64  "Invalid personality index");
65  return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
66 }
67 
68 namespace {
69 
70 class ARMELFStreamer;
71 
72 class ARMTargetAsmStreamer : public ARMTargetStreamer {
74  MCInstPrinter &InstPrinter;
75  bool IsVerboseAsm;
76 
77  void emitFnStart() override;
78  void emitFnEnd() override;
79  void emitCantUnwind() override;
80  void emitPersonality(const MCSymbol *Personality) override;
81  void emitPersonalityIndex(unsigned Index) override;
82  void emitHandlerData() override;
83  void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
84  void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
85  void emitPad(int64_t Offset) override;
86  void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
87  bool isVector) override;
88  void emitUnwindRaw(int64_t Offset,
89  const SmallVectorImpl<uint8_t> &Opcodes) override;
90 
91  void switchVendor(StringRef Vendor) override;
92  void emitAttribute(unsigned Attribute, unsigned Value) override;
93  void emitTextAttribute(unsigned Attribute, StringRef String) override;
94  void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
95  StringRef StringValue) override;
96  void emitArch(ARM::ArchKind Arch) override;
97  void emitArchExtension(unsigned ArchExt) override;
98  void emitObjectArch(ARM::ArchKind Arch) override;
99  void emitFPU(unsigned FPU) override;
100  void emitInst(uint32_t Inst, char Suffix = '\0') override;
101  void finishAttributeSection() override;
102 
103  void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
104  void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
105 
106 public:
107  ARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS,
108  MCInstPrinter &InstPrinter, bool VerboseAsm);
109 };
110 
111 ARMTargetAsmStreamer::ARMTargetAsmStreamer(MCStreamer &S,
113  MCInstPrinter &InstPrinter,
114  bool VerboseAsm)
115  : ARMTargetStreamer(S), OS(OS), InstPrinter(InstPrinter),
116  IsVerboseAsm(VerboseAsm) {}
117 
118 void ARMTargetAsmStreamer::emitFnStart() { OS << "\t.fnstart\n"; }
119 void ARMTargetAsmStreamer::emitFnEnd() { OS << "\t.fnend\n"; }
120 void ARMTargetAsmStreamer::emitCantUnwind() { OS << "\t.cantunwind\n"; }
121 
122 void ARMTargetAsmStreamer::emitPersonality(const MCSymbol *Personality) {
123  OS << "\t.personality " << Personality->getName() << '\n';
124 }
125 
126 void ARMTargetAsmStreamer::emitPersonalityIndex(unsigned Index) {
127  OS << "\t.personalityindex " << Index << '\n';
128 }
129 
130 void ARMTargetAsmStreamer::emitHandlerData() { OS << "\t.handlerdata\n"; }
131 
132 void ARMTargetAsmStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
133  int64_t Offset) {
134  OS << "\t.setfp\t";
135  InstPrinter.printRegName(OS, FpReg);
136  OS << ", ";
137  InstPrinter.printRegName(OS, SpReg);
138  if (Offset)
139  OS << ", #" << Offset;
140  OS << '\n';
141 }
142 
143 void ARMTargetAsmStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
144  assert((Reg != ARM::SP && Reg != ARM::PC) &&
145  "the operand of .movsp cannot be either sp or pc");
146 
147  OS << "\t.movsp\t";
148  InstPrinter.printRegName(OS, Reg);
149  if (Offset)
150  OS << ", #" << Offset;
151  OS << '\n';
152 }
153 
154 void ARMTargetAsmStreamer::emitPad(int64_t Offset) {
155  OS << "\t.pad\t#" << Offset << '\n';
156 }
157 
158 void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
159  bool isVector) {
160  assert(RegList.size() && "RegList should not be empty");
161  if (isVector)
162  OS << "\t.vsave\t{";
163  else
164  OS << "\t.save\t{";
165 
166  InstPrinter.printRegName(OS, RegList[0]);
167 
168  for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
169  OS << ", ";
170  InstPrinter.printRegName(OS, RegList[i]);
171  }
172 
173  OS << "}\n";
174 }
175 
176 void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {}
177 
178 void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
179  OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
180  if (IsVerboseAsm) {
182  if (!Name.empty())
183  OS << "\t@ " << Name;
184  }
185  OS << "\n";
186 }
187 
188 void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
189  StringRef String) {
190  switch (Attribute) {
192  OS << "\t.cpu\t" << String.lower();
193  break;
194  default:
195  OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
196  if (IsVerboseAsm) {
198  if (!Name.empty())
199  OS << "\t@ " << Name;
200  }
201  break;
202  }
203  OS << "\n";
204 }
205 
206 void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
207  unsigned IntValue,
208  StringRef StringValue) {
209  switch (Attribute) {
210  default: llvm_unreachable("unsupported multi-value attribute in asm mode");
212  OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
213  if (!StringValue.empty())
214  OS << ", \"" << StringValue << "\"";
215  if (IsVerboseAsm)
216  OS << "\t@ " << ARMBuildAttrs::AttrTypeAsString(Attribute);
217  break;
218  }
219  OS << "\n";
220 }
221 
222 void ARMTargetAsmStreamer::emitArch(ARM::ArchKind Arch) {
223  OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";
224 }
225 
226 void ARMTargetAsmStreamer::emitArchExtension(unsigned ArchExt) {
227  OS << "\t.arch_extension\t" << ARM::getArchExtName(ArchExt) << "\n";
228 }
229 
230 void ARMTargetAsmStreamer::emitObjectArch(ARM::ArchKind Arch) {
231  OS << "\t.object_arch\t" << ARM::getArchName(Arch) << '\n';
232 }
233 
234 void ARMTargetAsmStreamer::emitFPU(unsigned FPU) {
235  OS << "\t.fpu\t" << ARM::getFPUName(FPU) << "\n";
236 }
237 
238 void ARMTargetAsmStreamer::finishAttributeSection() {}
239 
240 void
241 ARMTargetAsmStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
242  OS << "\t.tlsdescseq\t" << S->getSymbol().getName();
243 }
244 
245 void ARMTargetAsmStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
246  const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
247 
248  OS << "\t.thumb_set\t";
249  Symbol->print(OS, MAI);
250  OS << ", ";
251  Value->print(OS, MAI);
252  OS << '\n';
253 }
254 
255 void ARMTargetAsmStreamer::emitInst(uint32_t Inst, char Suffix) {
256  OS << "\t.inst";
257  if (Suffix)
258  OS << "." << Suffix;
259  OS << "\t0x" << Twine::utohexstr(Inst) << "\n";
260 }
261 
262 void ARMTargetAsmStreamer::emitUnwindRaw(int64_t Offset,
263  const SmallVectorImpl<uint8_t> &Opcodes) {
264  OS << "\t.unwind_raw " << Offset;
265  for (SmallVectorImpl<uint8_t>::const_iterator OCI = Opcodes.begin(),
266  OCE = Opcodes.end();
267  OCI != OCE; ++OCI)
268  OS << ", 0x" << Twine::utohexstr(*OCI);
269  OS << '\n';
270 }
271 
272 class ARMTargetELFStreamer : public ARMTargetStreamer {
273 private:
274  // This structure holds all attributes, accounting for
275  // their string/numeric value, so we can later emit them
276  // in declaration order, keeping all in the same vector
277  struct AttributeItem {
278  enum {
279  HiddenAttribute = 0,
280  NumericAttribute,
281  TextAttribute,
282  NumericAndTextAttributes
283  } Type;
284  unsigned Tag;
285  unsigned IntValue;
286  std::string StringValue;
287 
288  static bool LessTag(const AttributeItem &LHS, const AttributeItem &RHS) {
289  // The conformance tag must be emitted first when serialised
290  // into an object file. Specifically, the addenda to the ARM ABI
291  // states that (2.3.7.4):
292  //
293  // "To simplify recognition by consumers in the common case of
294  // claiming conformity for the whole file, this tag should be
295  // emitted first in a file-scope sub-subsection of the first
296  // public subsection of the attributes section."
297  //
298  // So it is special-cased in this comparison predicate when the
299  // attributes are sorted in finishAttributeSection().
300  return (RHS.Tag != ARMBuildAttrs::conformance) &&
301  ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
302  }
303  };
304 
305  StringRef CurrentVendor;
306  unsigned FPU = ARM::FK_INVALID;
310 
311  MCSection *AttributeSection = nullptr;
312 
313  AttributeItem *getAttributeItem(unsigned Attribute) {
314  for (size_t i = 0; i < Contents.size(); ++i)
315  if (Contents[i].Tag == Attribute)
316  return &Contents[i];
317  return nullptr;
318  }
319 
320  void setAttributeItem(unsigned Attribute, unsigned Value,
321  bool OverwriteExisting) {
322  // Look for existing attribute item
323  if (AttributeItem *Item = getAttributeItem(Attribute)) {
324  if (!OverwriteExisting)
325  return;
326  Item->Type = AttributeItem::NumericAttribute;
327  Item->IntValue = Value;
328  return;
329  }
330 
331  // Create new attribute item
332  AttributeItem Item = {
333  AttributeItem::NumericAttribute,
334  Attribute,
335  Value,
336  StringRef("")
337  };
338  Contents.push_back(Item);
339  }
340 
341  void setAttributeItem(unsigned Attribute, StringRef Value,
342  bool OverwriteExisting) {
343  // Look for existing attribute item
344  if (AttributeItem *Item = getAttributeItem(Attribute)) {
345  if (!OverwriteExisting)
346  return;
347  Item->Type = AttributeItem::TextAttribute;
348  Item->StringValue = Value;
349  return;
350  }
351 
352  // Create new attribute item
353  AttributeItem Item = {
354  AttributeItem::TextAttribute,
355  Attribute,
356  0,
357  Value
358  };
359  Contents.push_back(Item);
360  }
361 
362  void setAttributeItems(unsigned Attribute, unsigned IntValue,
363  StringRef StringValue, bool OverwriteExisting) {
364  // Look for existing attribute item
365  if (AttributeItem *Item = getAttributeItem(Attribute)) {
366  if (!OverwriteExisting)
367  return;
368  Item->Type = AttributeItem::NumericAndTextAttributes;
369  Item->IntValue = IntValue;
370  Item->StringValue = StringValue;
371  return;
372  }
373 
374  // Create new attribute item
375  AttributeItem Item = {
376  AttributeItem::NumericAndTextAttributes,
377  Attribute,
378  IntValue,
379  StringValue
380  };
381  Contents.push_back(Item);
382  }
383 
384  void emitArchDefaultAttributes();
385  void emitFPUDefaultAttributes();
386 
387  ARMELFStreamer &getStreamer();
388 
389  void emitFnStart() override;
390  void emitFnEnd() override;
391  void emitCantUnwind() override;
392  void emitPersonality(const MCSymbol *Personality) override;
393  void emitPersonalityIndex(unsigned Index) override;
394  void emitHandlerData() override;
395  void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
396  void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
397  void emitPad(int64_t Offset) override;
398  void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
399  bool isVector) override;
400  void emitUnwindRaw(int64_t Offset,
401  const SmallVectorImpl<uint8_t> &Opcodes) override;
402 
403  void switchVendor(StringRef Vendor) override;
404  void emitAttribute(unsigned Attribute, unsigned Value) override;
405  void emitTextAttribute(unsigned Attribute, StringRef String) override;
406  void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
407  StringRef StringValue) override;
408  void emitArch(ARM::ArchKind Arch) override;
409  void emitObjectArch(ARM::ArchKind Arch) override;
410  void emitFPU(unsigned FPU) override;
411  void emitInst(uint32_t Inst, char Suffix = '\0') override;
412  void finishAttributeSection() override;
413  void emitLabel(MCSymbol *Symbol) override;
414 
415  void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
416  void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
417 
418  size_t calculateContentSize() const;
419 
420  // Reset state between object emissions
421  void reset() override;
422 
423 public:
424  ARMTargetELFStreamer(MCStreamer &S)
425  : ARMTargetStreamer(S), CurrentVendor("aeabi") {}
426 };
427 
428 /// Extend the generic ELFStreamer class so that it can emit mapping symbols at
429 /// the appropriate points in the object files. These symbols are defined in the
430 /// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
431 ///
432 /// In brief: $a, $t or $d should be emitted at the start of each contiguous
433 /// region of ARM code, Thumb code or data in a section. In practice, this
434 /// emission does not rely on explicit assembler directives but on inherent
435 /// properties of the directives doing the emission (e.g. ".byte" is data, "add
436 /// r0, r0, r0" an instruction).
437 ///
438 /// As a result this system is orthogonal to the DataRegion infrastructure used
439 /// by MachO. Beware!
440 class ARMELFStreamer : public MCELFStreamer {
441 public:
442  friend class ARMTargetELFStreamer;
443 
444  ARMELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
445  std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter,
446  bool IsThumb)
447  : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
448  IsThumb(IsThumb) {
449  EHReset();
450  }
451 
452  ~ARMELFStreamer() override = default;
453 
454  void FinishImpl() override;
455 
456  // ARM exception handling directives
457  void emitFnStart();
458  void emitFnEnd();
459  void emitCantUnwind();
460  void emitPersonality(const MCSymbol *Per);
461  void emitPersonalityIndex(unsigned index);
462  void emitHandlerData();
463  void emitSetFP(unsigned NewFpReg, unsigned NewSpReg, int64_t Offset = 0);
464  void emitMovSP(unsigned Reg, int64_t Offset = 0);
465  void emitPad(int64_t Offset);
466  void emitRegSave(const SmallVectorImpl<unsigned> &RegList, bool isVector);
467  void emitUnwindRaw(int64_t Offset, const SmallVectorImpl<uint8_t> &Opcodes);
468 
469  void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
470  LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);
471  MCELFStreamer::ChangeSection(Section, Subsection);
472  auto LastMappingSymbol = LastMappingSymbols.find(Section);
473  if (LastMappingSymbol != LastMappingSymbols.end()) {
474  LastEMSInfo = std::move(LastMappingSymbol->second);
475  return;
476  }
477  LastEMSInfo.reset(new ElfMappingSymbolInfo(SMLoc(), nullptr, 0));
478  }
479 
480  /// This function is the one used to emit instruction data into the ELF
481  /// streamer. We override it to add the appropriate mapping symbol if
482  /// necessary.
483  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
484  bool) override {
485  if (IsThumb)
486  EmitThumbMappingSymbol();
487  else
488  EmitARMMappingSymbol();
489 
491  }
492 
493  void emitInst(uint32_t Inst, char Suffix) {
494  unsigned Size;
495  char Buffer[4];
496  const bool LittleEndian = getContext().getAsmInfo()->isLittleEndian();
497 
498  switch (Suffix) {
499  case '\0':
500  Size = 4;
501 
502  assert(!IsThumb);
503  EmitARMMappingSymbol();
504  for (unsigned II = 0, IE = Size; II != IE; II++) {
505  const unsigned I = LittleEndian ? (Size - II - 1) : II;
506  Buffer[Size - II - 1] = uint8_t(Inst >> I * CHAR_BIT);
507  }
508 
509  break;
510  case 'n':
511  case 'w':
512  Size = (Suffix == 'n' ? 2 : 4);
513 
514  assert(IsThumb);
515  EmitThumbMappingSymbol();
516  // Thumb wide instructions are emitted as a pair of 16-bit words of the
517  // appropriate endianness.
518  for (unsigned II = 0, IE = Size; II != IE; II = II + 2) {
519  const unsigned I0 = LittleEndian ? II + 0 : II + 1;
520  const unsigned I1 = LittleEndian ? II + 1 : II + 0;
521  Buffer[Size - II - 2] = uint8_t(Inst >> I0 * CHAR_BIT);
522  Buffer[Size - II - 1] = uint8_t(Inst >> I1 * CHAR_BIT);
523  }
524 
525  break;
526  default:
527  llvm_unreachable("Invalid Suffix");
528  }
529 
530  MCELFStreamer::EmitBytes(StringRef(Buffer, Size));
531  }
532 
533  /// This is one of the functions used to emit data into an ELF section, so the
534  /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
535  /// necessary.
536  void EmitBytes(StringRef Data) override {
537  EmitDataMappingSymbol();
539  }
540 
541  void FlushPendingMappingSymbol() {
542  if (!LastEMSInfo->hasInfo())
543  return;
544  ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
545  EmitMappingSymbol("$d", EMS->Loc, EMS->F, EMS->Offset);
546  EMS->resetInfo();
547  }
548 
549  /// This is one of the functions used to emit data into an ELF section, so the
550  /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
551  /// necessary.
552  void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
553  if (const MCSymbolRefExpr *SRE = dyn_cast_or_null<MCSymbolRefExpr>(Value)) {
554  if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) {
555  getContext().reportError(Loc, "relocated expression must be 32-bit");
556  return;
557  }
558  getOrCreateDataFragment();
559  }
560 
561  EmitDataMappingSymbol();
562  MCELFStreamer::EmitValueImpl(Value, Size, Loc);
563  }
564 
565  void EmitAssemblerFlag(MCAssemblerFlag Flag) override {
567 
568  switch (Flag) {
569  case MCAF_SyntaxUnified:
570  return; // no-op here.
571  case MCAF_Code16:
572  IsThumb = true;
573  return; // Change to Thumb mode
574  case MCAF_Code32:
575  IsThumb = false;
576  return; // Change to ARM mode
577  case MCAF_Code64:
578  return;
580  return;
581  }
582  }
583 
584 private:
585  enum ElfMappingSymbol {
586  EMS_None,
587  EMS_ARM,
588  EMS_Thumb,
589  EMS_Data
590  };
591 
592  struct ElfMappingSymbolInfo {
593  explicit ElfMappingSymbolInfo(SMLoc Loc, MCFragment *F, uint64_t O)
594  : Loc(Loc), F(F), Offset(O), State(EMS_None) {}
595  void resetInfo() {
596  F = nullptr;
597  Offset = 0;
598  }
599  bool hasInfo() { return F != nullptr; }
600  SMLoc Loc;
601  MCFragment *F;
602  uint64_t Offset;
603  ElfMappingSymbol State;
604  };
605 
606  void EmitDataMappingSymbol() {
607  if (LastEMSInfo->State == EMS_Data)
608  return;
609  else if (LastEMSInfo->State == EMS_None) {
610  // This is a tentative symbol, it won't really be emitted until it's
611  // actually needed.
612  ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
613  auto *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
614  if (!DF)
615  return;
616  EMS->Loc = SMLoc();
617  EMS->F = getCurrentFragment();
618  EMS->Offset = DF->getContents().size();
619  LastEMSInfo->State = EMS_Data;
620  return;
621  }
622  EmitMappingSymbol("$d");
623  LastEMSInfo->State = EMS_Data;
624  }
625 
626  void EmitThumbMappingSymbol() {
627  if (LastEMSInfo->State == EMS_Thumb)
628  return;
629  FlushPendingMappingSymbol();
630  EmitMappingSymbol("$t");
631  LastEMSInfo->State = EMS_Thumb;
632  }
633 
634  void EmitARMMappingSymbol() {
635  if (LastEMSInfo->State == EMS_ARM)
636  return;
637  FlushPendingMappingSymbol();
638  EmitMappingSymbol("$a");
639  LastEMSInfo->State = EMS_ARM;
640  }
641 
642  void EmitMappingSymbol(StringRef Name) {
643  auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
644  Name + "." + Twine(MappingSymbolCounter++)));
645  EmitLabel(Symbol);
646 
647  Symbol->setType(ELF::STT_NOTYPE);
648  Symbol->setBinding(ELF::STB_LOCAL);
649  Symbol->setExternal(false);
650  }
651 
652  void EmitMappingSymbol(StringRef Name, SMLoc Loc, MCFragment *F,
653  uint64_t Offset) {
654  auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
655  Name + "." + Twine(MappingSymbolCounter++)));
656  EmitLabel(Symbol, Loc, F);
657  Symbol->setType(ELF::STT_NOTYPE);
658  Symbol->setBinding(ELF::STB_LOCAL);
659  Symbol->setExternal(false);
660  Symbol->setOffset(Offset);
661  }
662 
663  void EmitThumbFunc(MCSymbol *Func) override {
664  getAssembler().setIsThumbFunc(Func);
665  EmitSymbolAttribute(Func, MCSA_ELF_TypeFunction);
666  }
667 
668  // Helper functions for ARM exception handling directives
669  void EHReset();
670 
671  // Reset state between object emissions
672  void reset() override;
673 
674  void EmitPersonalityFixup(StringRef Name);
675  void FlushPendingOffset();
676  void FlushUnwindOpcodes(bool NoHandlerData);
677 
678  void SwitchToEHSection(StringRef Prefix, unsigned Type, unsigned Flags,
679  SectionKind Kind, const MCSymbol &Fn);
680  void SwitchToExTabSection(const MCSymbol &FnStart);
681  void SwitchToExIdxSection(const MCSymbol &FnStart);
682 
683  void EmitFixup(const MCExpr *Expr, MCFixupKind Kind);
684 
685  bool IsThumb;
686  int64_t MappingSymbolCounter = 0;
687 
689  LastMappingSymbols;
690 
691  std::unique_ptr<ElfMappingSymbolInfo> LastEMSInfo;
692 
693  // ARM Exception Handling Frame Information
694  MCSymbol *ExTab;
695  MCSymbol *FnStart;
696  const MCSymbol *Personality;
697  unsigned PersonalityIndex;
698  unsigned FPReg; // Frame pointer register
699  int64_t FPOffset; // Offset: (final frame pointer) - (initial $sp)
700  int64_t SPOffset; // Offset: (final $sp) - (initial $sp)
701  int64_t PendingOffset; // Offset: (final $sp) - (emitted $sp)
702  bool UsedFP;
703  bool CantUnwind;
704  SmallVector<uint8_t, 64> Opcodes;
705  UnwindOpcodeAssembler UnwindOpAsm;
706 };
707 
708 } // end anonymous namespace
709 
710 ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
711  return static_cast<ARMELFStreamer &>(Streamer);
712 }
713 
714 void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
715 void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
716 void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
717 
718 void ARMTargetELFStreamer::emitPersonality(const MCSymbol *Personality) {
719  getStreamer().emitPersonality(Personality);
720 }
721 
722 void ARMTargetELFStreamer::emitPersonalityIndex(unsigned Index) {
723  getStreamer().emitPersonalityIndex(Index);
724 }
725 
726 void ARMTargetELFStreamer::emitHandlerData() {
727  getStreamer().emitHandlerData();
728 }
729 
730 void ARMTargetELFStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
731  int64_t Offset) {
732  getStreamer().emitSetFP(FpReg, SpReg, Offset);
733 }
734 
735 void ARMTargetELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
736  getStreamer().emitMovSP(Reg, Offset);
737 }
738 
739 void ARMTargetELFStreamer::emitPad(int64_t Offset) {
740  getStreamer().emitPad(Offset);
741 }
742 
743 void ARMTargetELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
744  bool isVector) {
745  getStreamer().emitRegSave(RegList, isVector);
746 }
747 
748 void ARMTargetELFStreamer::emitUnwindRaw(int64_t Offset,
749  const SmallVectorImpl<uint8_t> &Opcodes) {
750  getStreamer().emitUnwindRaw(Offset, Opcodes);
751 }
752 
753 void ARMTargetELFStreamer::switchVendor(StringRef Vendor) {
754  assert(!Vendor.empty() && "Vendor cannot be empty.");
755 
756  if (CurrentVendor == Vendor)
757  return;
758 
759  if (!CurrentVendor.empty())
760  finishAttributeSection();
761 
762  assert(Contents.empty() &&
763  ".ARM.attributes should be flushed before changing vendor");
764  CurrentVendor = Vendor;
765 
766 }
767 
768 void ARMTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
769  setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
770 }
771 
772 void ARMTargetELFStreamer::emitTextAttribute(unsigned Attribute,
773  StringRef Value) {
774  setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
775 }
776 
777 void ARMTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
778  unsigned IntValue,
779  StringRef StringValue) {
780  setAttributeItems(Attribute, IntValue, StringValue,
781  /* OverwriteExisting= */ true);
782 }
783 
784 void ARMTargetELFStreamer::emitArch(ARM::ArchKind Value) {
785  Arch = Value;
786 }
787 
788 void ARMTargetELFStreamer::emitObjectArch(ARM::ArchKind Value) {
789  EmittedArch = Value;
790 }
791 
792 void ARMTargetELFStreamer::emitArchDefaultAttributes() {
793  using namespace ARMBuildAttrs;
794 
795  setAttributeItem(CPU_name,
796  ARM::getCPUAttr(Arch),
797  false);
798 
799  if (EmittedArch == ARM::ArchKind::INVALID)
800  setAttributeItem(CPU_arch,
801  ARM::getArchAttr(Arch),
802  false);
803  else
804  setAttributeItem(CPU_arch,
805  ARM::getArchAttr(EmittedArch),
806  false);
807 
808  switch (Arch) {
809  case ARM::ArchKind::ARMV2:
810  case ARM::ArchKind::ARMV2A:
811  case ARM::ArchKind::ARMV3:
812  case ARM::ArchKind::ARMV3M:
813  case ARM::ArchKind::ARMV4:
814  setAttributeItem(ARM_ISA_use, Allowed, false);
815  break;
816 
817  case ARM::ArchKind::ARMV4T:
818  case ARM::ArchKind::ARMV5T:
819  case ARM::ArchKind::ARMV5TE:
820  case ARM::ArchKind::ARMV6:
821  setAttributeItem(ARM_ISA_use, Allowed, false);
822  setAttributeItem(THUMB_ISA_use, Allowed, false);
823  break;
824 
825  case ARM::ArchKind::ARMV6T2:
826  setAttributeItem(ARM_ISA_use, Allowed, false);
827  setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
828  break;
829 
830  case ARM::ArchKind::ARMV6K:
831  case ARM::ArchKind::ARMV6KZ:
832  setAttributeItem(ARM_ISA_use, Allowed, false);
833  setAttributeItem(THUMB_ISA_use, Allowed, false);
834  setAttributeItem(Virtualization_use, AllowTZ, false);
835  break;
836 
837  case ARM::ArchKind::ARMV6M:
838  setAttributeItem(THUMB_ISA_use, Allowed, false);
839  break;
840 
841  case ARM::ArchKind::ARMV7A:
842  setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
843  setAttributeItem(ARM_ISA_use, Allowed, false);
844  setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
845  break;
846 
847  case ARM::ArchKind::ARMV7R:
848  setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
849  setAttributeItem(ARM_ISA_use, Allowed, false);
850  setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
851  break;
852 
853  case ARM::ArchKind::ARMV7EM:
854  case ARM::ArchKind::ARMV7M:
855  setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
856  setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
857  break;
858 
859  case ARM::ArchKind::ARMV8A:
860  case ARM::ArchKind::ARMV8_1A:
861  case ARM::ArchKind::ARMV8_2A:
862  setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
863  setAttributeItem(ARM_ISA_use, Allowed, false);
864  setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
865  setAttributeItem(MPextension_use, Allowed, false);
866  setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
867  break;
868 
869  case ARM::ArchKind::ARMV8MBaseline:
870  case ARM::ArchKind::ARMV8MMainline:
871  setAttributeItem(THUMB_ISA_use, AllowThumbDerived, false);
872  setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
873  break;
874 
875  case ARM::ArchKind::IWMMXT:
876  setAttributeItem(ARM_ISA_use, Allowed, false);
877  setAttributeItem(THUMB_ISA_use, Allowed, false);
878  setAttributeItem(WMMX_arch, AllowWMMXv1, false);
879  break;
880 
881  case ARM::ArchKind::IWMMXT2:
882  setAttributeItem(ARM_ISA_use, Allowed, false);
883  setAttributeItem(THUMB_ISA_use, Allowed, false);
884  setAttributeItem(WMMX_arch, AllowWMMXv2, false);
885  break;
886 
887  default:
888  report_fatal_error("Unknown Arch: " + Twine(ARM::getArchName(Arch)));
889  break;
890  }
891 }
892 
893 void ARMTargetELFStreamer::emitFPU(unsigned Value) {
894  FPU = Value;
895 }
896 
897 void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
898  switch (FPU) {
899  case ARM::FK_VFP:
900  case ARM::FK_VFPV2:
901  setAttributeItem(ARMBuildAttrs::FP_arch,
903  /* OverwriteExisting= */ false);
904  break;
905 
906  case ARM::FK_VFPV3:
907  setAttributeItem(ARMBuildAttrs::FP_arch,
909  /* OverwriteExisting= */ false);
910  break;
911 
912  case ARM::FK_VFPV3_FP16:
913  setAttributeItem(ARMBuildAttrs::FP_arch,
915  /* OverwriteExisting= */ false);
916  setAttributeItem(ARMBuildAttrs::FP_HP_extension,
918  /* OverwriteExisting= */ false);
919  break;
920 
921  case ARM::FK_VFPV3_D16:
922  setAttributeItem(ARMBuildAttrs::FP_arch,
924  /* OverwriteExisting= */ false);
925  break;
926 
927  case ARM::FK_VFPV3_D16_FP16:
928  setAttributeItem(ARMBuildAttrs::FP_arch,
930  /* OverwriteExisting= */ false);
931  setAttributeItem(ARMBuildAttrs::FP_HP_extension,
933  /* OverwriteExisting= */ false);
934  break;
935 
936  case ARM::FK_VFPV3XD:
937  setAttributeItem(ARMBuildAttrs::FP_arch,
939  /* OverwriteExisting= */ false);
940  break;
941  case ARM::FK_VFPV3XD_FP16:
942  setAttributeItem(ARMBuildAttrs::FP_arch,
944  /* OverwriteExisting= */ false);
945  setAttributeItem(ARMBuildAttrs::FP_HP_extension,
947  /* OverwriteExisting= */ false);
948  break;
949 
950  case ARM::FK_VFPV4:
951  setAttributeItem(ARMBuildAttrs::FP_arch,
953  /* OverwriteExisting= */ false);
954  break;
955 
956  // ABI_HardFP_use is handled in ARMAsmPrinter, so _SP_D16 is treated the same
957  // as _D16 here.
958  case ARM::FK_FPV4_SP_D16:
959  case ARM::FK_VFPV4_D16:
960  setAttributeItem(ARMBuildAttrs::FP_arch,
962  /* OverwriteExisting= */ false);
963  break;
964 
965  case ARM::FK_FP_ARMV8:
966  setAttributeItem(ARMBuildAttrs::FP_arch,
968  /* OverwriteExisting= */ false);
969  break;
970 
971  // FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
972  // uses the FP_ARMV8_D16 build attribute.
973  case ARM::FK_FPV5_SP_D16:
974  case ARM::FK_FPV5_D16:
975  setAttributeItem(ARMBuildAttrs::FP_arch,
977  /* OverwriteExisting= */ false);
978  break;
979 
980  case ARM::FK_NEON:
981  setAttributeItem(ARMBuildAttrs::FP_arch,
983  /* OverwriteExisting= */ false);
984  setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
986  /* OverwriteExisting= */ false);
987  break;
988 
989  case ARM::FK_NEON_FP16:
990  setAttributeItem(ARMBuildAttrs::FP_arch,
992  /* OverwriteExisting= */ false);
993  setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
995  /* OverwriteExisting= */ false);
996  setAttributeItem(ARMBuildAttrs::FP_HP_extension,
998  /* OverwriteExisting= */ false);
999  break;
1000 
1001  case ARM::FK_NEON_VFPV4:
1002  setAttributeItem(ARMBuildAttrs::FP_arch,
1004  /* OverwriteExisting= */ false);
1005  setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
1007  /* OverwriteExisting= */ false);
1008  break;
1009 
1010  case ARM::FK_NEON_FP_ARMV8:
1011  case ARM::FK_CRYPTO_NEON_FP_ARMV8:
1012  setAttributeItem(ARMBuildAttrs::FP_arch,
1014  /* OverwriteExisting= */ false);
1015  // 'Advanced_SIMD_arch' must be emitted not here, but within
1016  // ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
1017  break;
1018 
1019  case ARM::FK_SOFTVFP:
1020  case ARM::FK_NONE:
1021  break;
1022 
1023  default:
1024  report_fatal_error("Unknown FPU: " + Twine(FPU));
1025  break;
1026  }
1027 }
1028 
1029 size_t ARMTargetELFStreamer::calculateContentSize() const {
1030  size_t Result = 0;
1031  for (size_t i = 0; i < Contents.size(); ++i) {
1032  AttributeItem item = Contents[i];
1033  switch (item.Type) {
1034  case AttributeItem::HiddenAttribute:
1035  break;
1036  case AttributeItem::NumericAttribute:
1037  Result += getULEB128Size(item.Tag);
1038  Result += getULEB128Size(item.IntValue);
1039  break;
1040  case AttributeItem::TextAttribute:
1041  Result += getULEB128Size(item.Tag);
1042  Result += item.StringValue.size() + 1; // string + '\0'
1043  break;
1044  case AttributeItem::NumericAndTextAttributes:
1045  Result += getULEB128Size(item.Tag);
1046  Result += getULEB128Size(item.IntValue);
1047  Result += item.StringValue.size() + 1; // string + '\0';
1048  break;
1049  }
1050  }
1051  return Result;
1052 }
1053 
1054 void ARMTargetELFStreamer::finishAttributeSection() {
1055  // <format-version>
1056  // [ <section-length> "vendor-name"
1057  // [ <file-tag> <size> <attribute>*
1058  // | <section-tag> <size> <section-number>* 0 <attribute>*
1059  // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
1060  // ]+
1061  // ]*
1062 
1063  if (FPU != ARM::FK_INVALID)
1064  emitFPUDefaultAttributes();
1065 
1066  if (Arch != ARM::ArchKind::INVALID)
1067  emitArchDefaultAttributes();
1068 
1069  if (Contents.empty())
1070  return;
1071 
1072  llvm::sort(Contents.begin(), Contents.end(), AttributeItem::LessTag);
1073 
1074  ARMELFStreamer &Streamer = getStreamer();
1075 
1076  // Switch to .ARM.attributes section
1077  if (AttributeSection) {
1078  Streamer.SwitchSection(AttributeSection);
1079  } else {
1080  AttributeSection = Streamer.getContext().getELFSection(
1081  ".ARM.attributes", ELF::SHT_ARM_ATTRIBUTES, 0);
1082  Streamer.SwitchSection(AttributeSection);
1083 
1084  // Format version
1085  Streamer.EmitIntValue(0x41, 1);
1086  }
1087 
1088  // Vendor size + Vendor name + '\0'
1089  const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
1090 
1091  // Tag + Tag Size
1092  const size_t TagHeaderSize = 1 + 4;
1093 
1094  const size_t ContentsSize = calculateContentSize();
1095 
1096  Streamer.EmitIntValue(VendorHeaderSize + TagHeaderSize + ContentsSize, 4);
1097  Streamer.EmitBytes(CurrentVendor);
1098  Streamer.EmitIntValue(0, 1); // '\0'
1099 
1100  Streamer.EmitIntValue(ARMBuildAttrs::File, 1);
1101  Streamer.EmitIntValue(TagHeaderSize + ContentsSize, 4);
1102 
1103  // Size should have been accounted for already, now
1104  // emit each field as its type (ULEB or String)
1105  for (size_t i = 0; i < Contents.size(); ++i) {
1106  AttributeItem item = Contents[i];
1107  Streamer.EmitULEB128IntValue(item.Tag);
1108  switch (item.Type) {
1109  default: llvm_unreachable("Invalid attribute type");
1110  case AttributeItem::NumericAttribute:
1111  Streamer.EmitULEB128IntValue(item.IntValue);
1112  break;
1113  case AttributeItem::TextAttribute:
1114  Streamer.EmitBytes(item.StringValue);
1115  Streamer.EmitIntValue(0, 1); // '\0'
1116  break;
1117  case AttributeItem::NumericAndTextAttributes:
1118  Streamer.EmitULEB128IntValue(item.IntValue);
1119  Streamer.EmitBytes(item.StringValue);
1120  Streamer.EmitIntValue(0, 1); // '\0'
1121  break;
1122  }
1123  }
1124 
1125  Contents.clear();
1126  FPU = ARM::FK_INVALID;
1127 }
1128 
1129 void ARMTargetELFStreamer::emitLabel(MCSymbol *Symbol) {
1130  ARMELFStreamer &Streamer = getStreamer();
1131  if (!Streamer.IsThumb)
1132  return;
1133 
1134  Streamer.getAssembler().registerSymbol(*Symbol);
1135  unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
1136  if (Type == ELF::STT_FUNC || Type == ELF::STT_GNU_IFUNC)
1137  Streamer.EmitThumbFunc(Symbol);
1138 }
1139 
1140 void
1141 ARMTargetELFStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
1142  getStreamer().EmitFixup(S, FK_Data_4);
1143 }
1144 
1145 void ARMTargetELFStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
1146  if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Value)) {
1147  const MCSymbol &Sym = SRE->getSymbol();
1148  if (!Sym.isDefined()) {
1149  getStreamer().EmitAssignment(Symbol, Value);
1150  return;
1151  }
1152  }
1153 
1154  getStreamer().EmitThumbFunc(Symbol);
1155  getStreamer().EmitAssignment(Symbol, Value);
1156 }
1157 
1158 void ARMTargetELFStreamer::emitInst(uint32_t Inst, char Suffix) {
1159  getStreamer().emitInst(Inst, Suffix);
1160 }
1161 
1162 void ARMTargetELFStreamer::reset() { AttributeSection = nullptr; }
1163 
1164 void ARMELFStreamer::FinishImpl() {
1165  MCTargetStreamer &TS = *getTargetStreamer();
1166  ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
1167  ATS.finishAttributeSection();
1168 
1170 }
1171 
1172 void ARMELFStreamer::reset() {
1173  MCTargetStreamer &TS = *getTargetStreamer();
1174  ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
1175  ATS.reset();
1176  MappingSymbolCounter = 0;
1178  LastMappingSymbols.clear();
1179  LastEMSInfo.reset();
1180  // MCELFStreamer clear's the assembler's e_flags. However, for
1181  // arm we manually set the ABI version on streamer creation, so
1182  // do the same here
1183  getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
1184 }
1185 
1186 inline void ARMELFStreamer::SwitchToEHSection(StringRef Prefix,
1187  unsigned Type,
1188  unsigned Flags,
1189  SectionKind Kind,
1190  const MCSymbol &Fn) {
1191  const MCSectionELF &FnSection =
1192  static_cast<const MCSectionELF &>(Fn.getSection());
1193 
1194  // Create the name for new section
1195  StringRef FnSecName(FnSection.getSectionName());
1196  SmallString<128> EHSecName(Prefix);
1197  if (FnSecName != ".text") {
1198  EHSecName += FnSecName;
1199  }
1200 
1201  // Get .ARM.extab or .ARM.exidx section
1202  const MCSymbolELF *Group = FnSection.getGroup();
1203  if (Group)
1204  Flags |= ELF::SHF_GROUP;
1205  MCSectionELF *EHSection = getContext().getELFSection(
1206  EHSecName, Type, Flags, 0, Group, FnSection.getUniqueID(),
1207  static_cast<const MCSymbolELF *>(&Fn));
1208 
1209  assert(EHSection && "Failed to get the required EH section");
1210 
1211  // Switch to .ARM.extab or .ARM.exidx section
1212  SwitchSection(EHSection);
1213  EmitCodeAlignment(4);
1214 }
1215 
1216 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
1217  SwitchToEHSection(".ARM.extab", ELF::SHT_PROGBITS, ELF::SHF_ALLOC,
1218  SectionKind::getData(), FnStart);
1219 }
1220 
1221 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
1222  SwitchToEHSection(".ARM.exidx", ELF::SHT_ARM_EXIDX,
1224  SectionKind::getData(), FnStart);
1225 }
1226 
1227 void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
1228  MCDataFragment *Frag = getOrCreateDataFragment();
1229  Frag->getFixups().push_back(MCFixup::create(Frag->getContents().size(), Expr,
1230  Kind));
1231 }
1232 
1233 void ARMELFStreamer::EHReset() {
1234  ExTab = nullptr;
1235  FnStart = nullptr;
1236  Personality = nullptr;
1237  PersonalityIndex = ARM::EHABI::NUM_PERSONALITY_INDEX;
1238  FPReg = ARM::SP;
1239  FPOffset = 0;
1240  SPOffset = 0;
1241  PendingOffset = 0;
1242  UsedFP = false;
1243  CantUnwind = false;
1244 
1245  Opcodes.clear();
1246  UnwindOpAsm.Reset();
1247 }
1248 
1249 void ARMELFStreamer::emitFnStart() {
1250  assert(FnStart == nullptr);
1251  FnStart = getContext().createTempSymbol();
1252  EmitLabel(FnStart);
1253 }
1254 
1255 void ARMELFStreamer::emitFnEnd() {
1256  assert(FnStart && ".fnstart must precedes .fnend");
1257 
1258  // Emit unwind opcodes if there is no .handlerdata directive
1259  if (!ExTab && !CantUnwind)
1260  FlushUnwindOpcodes(true);
1261 
1262  // Emit the exception index table entry
1263  SwitchToExIdxSection(*FnStart);
1264 
1265  if (PersonalityIndex < ARM::EHABI::NUM_PERSONALITY_INDEX)
1266  EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
1267 
1268  const MCSymbolRefExpr *FnStartRef =
1269  MCSymbolRefExpr::create(FnStart,
1271  getContext());
1272 
1273  EmitValue(FnStartRef, 4);
1274 
1275  if (CantUnwind) {
1276  EmitIntValue(ARM::EHABI::EXIDX_CANTUNWIND, 4);
1277  } else if (ExTab) {
1278  // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
1279  const MCSymbolRefExpr *ExTabEntryRef =
1282  getContext());
1283  EmitValue(ExTabEntryRef, 4);
1284  } else {
1285  // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
1286  // the second word of exception index table entry. The size of the unwind
1287  // opcodes should always be 4 bytes.
1288  assert(PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0 &&
1289  "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
1290  assert(Opcodes.size() == 4u &&
1291  "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
1292  uint64_t Intval = Opcodes[0] |
1293  Opcodes[1] << 8 |
1294  Opcodes[2] << 16 |
1295  Opcodes[3] << 24;
1296  EmitIntValue(Intval, Opcodes.size());
1297  }
1298 
1299  // Switch to the section containing FnStart
1300  SwitchSection(&FnStart->getSection());
1301 
1302  // Clean exception handling frame information
1303  EHReset();
1304 }
1305 
1306 void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
1307 
1308 // Add the R_ARM_NONE fixup at the same position
1309 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
1310  const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(Name);
1311 
1312  const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::create(
1313  PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
1314 
1315  visitUsedExpr(*PersonalityRef);
1316  MCDataFragment *DF = getOrCreateDataFragment();
1317  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
1318  PersonalityRef,
1319  MCFixup::getKindForSize(4, false)));
1320 }
1321 
1322 void ARMELFStreamer::FlushPendingOffset() {
1323  if (PendingOffset != 0) {
1324  UnwindOpAsm.EmitSPOffset(-PendingOffset);
1325  PendingOffset = 0;
1326  }
1327 }
1328 
1329 void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) {
1330  // Emit the unwind opcode to restore $sp.
1331  if (UsedFP) {
1332  const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1333  int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
1334  UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
1335  UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
1336  } else {
1337  FlushPendingOffset();
1338  }
1339 
1340  // Finalize the unwind opcode sequence
1341  UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
1342 
1343  // For compact model 0, we have to emit the unwind opcodes in the .ARM.exidx
1344  // section. Thus, we don't have to create an entry in the .ARM.extab
1345  // section.
1346  if (NoHandlerData && PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0)
1347  return;
1348 
1349  // Switch to .ARM.extab section.
1350  SwitchToExTabSection(*FnStart);
1351 
1352  // Create .ARM.extab label for offset in .ARM.exidx
1353  assert(!ExTab);
1354  ExTab = getContext().createTempSymbol();
1355  EmitLabel(ExTab);
1356 
1357  // Emit personality
1358  if (Personality) {
1359  const MCSymbolRefExpr *PersonalityRef =
1360  MCSymbolRefExpr::create(Personality,
1362  getContext());
1363 
1364  EmitValue(PersonalityRef, 4);
1365  }
1366 
1367  // Emit unwind opcodes
1368  assert((Opcodes.size() % 4) == 0 &&
1369  "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
1370  for (unsigned I = 0; I != Opcodes.size(); I += 4) {
1371  uint64_t Intval = Opcodes[I] |
1372  Opcodes[I + 1] << 8 |
1373  Opcodes[I + 2] << 16 |
1374  Opcodes[I + 3] << 24;
1375  EmitIntValue(Intval, 4);
1376  }
1377 
1378  // According to ARM EHABI section 9.2, if the __aeabi_unwind_cpp_pr1() or
1379  // __aeabi_unwind_cpp_pr2() is used, then the handler data must be emitted
1380  // after the unwind opcodes. The handler data consists of several 32-bit
1381  // words, and should be terminated by zero.
1382  //
1383  // In case that the .handlerdata directive is not specified by the
1384  // programmer, we should emit zero to terminate the handler data.
1385  if (NoHandlerData && !Personality)
1386  EmitIntValue(0, 4);
1387 }
1388 
1389 void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(false); }
1390 
1391 void ARMELFStreamer::emitPersonality(const MCSymbol *Per) {
1392  Personality = Per;
1393  UnwindOpAsm.setPersonality(Per);
1394 }
1395 
1396 void ARMELFStreamer::emitPersonalityIndex(unsigned Index) {
1397  assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX && "invalid index");
1398  PersonalityIndex = Index;
1399 }
1400 
1401 void ARMELFStreamer::emitSetFP(unsigned NewFPReg, unsigned NewSPReg,
1402  int64_t Offset) {
1403  assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
1404  "the operand of .setfp directive should be either $sp or $fp");
1405 
1406  UsedFP = true;
1407  FPReg = NewFPReg;
1408 
1409  if (NewSPReg == ARM::SP)
1410  FPOffset = SPOffset + Offset;
1411  else
1412  FPOffset += Offset;
1413 }
1414 
1415 void ARMELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
1416  assert((Reg != ARM::SP && Reg != ARM::PC) &&
1417  "the operand of .movsp cannot be either sp or pc");
1418  assert(FPReg == ARM::SP && "current FP must be SP");
1419 
1420  FlushPendingOffset();
1421 
1422  FPReg = Reg;
1423  FPOffset = SPOffset + Offset;
1424 
1425  const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1426  UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
1427 }
1428 
1429 void ARMELFStreamer::emitPad(int64_t Offset) {
1430  // Track the change of the $sp offset
1431  SPOffset -= Offset;
1432 
1433  // To squash multiple .pad directives, we should delay the unwind opcode
1434  // until the .save, .vsave, .handlerdata, or .fnend directives.
1435  PendingOffset -= Offset;
1436 }
1437 
1438 void ARMELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
1439  bool IsVector) {
1440  // Collect the registers in the register list
1441  unsigned Count = 0;
1442  uint32_t Mask = 0;
1443  const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1444  for (size_t i = 0; i < RegList.size(); ++i) {
1445  unsigned Reg = MRI->getEncodingValue(RegList[i]);
1446  assert(Reg < (IsVector ? 32U : 16U) && "Register out of range");
1447  unsigned Bit = (1u << Reg);
1448  if ((Mask & Bit) == 0) {
1449  Mask |= Bit;
1450  ++Count;
1451  }
1452  }
1453 
1454  // Track the change the $sp offset: For the .save directive, the
1455  // corresponding push instruction will decrease the $sp by (4 * Count).
1456  // For the .vsave directive, the corresponding vpush instruction will
1457  // decrease $sp by (8 * Count).
1458  SPOffset -= Count * (IsVector ? 8 : 4);
1459 
1460  // Emit the opcode
1461  FlushPendingOffset();
1462  if (IsVector)
1463  UnwindOpAsm.EmitVFPRegSave(Mask);
1464  else
1465  UnwindOpAsm.EmitRegSave(Mask);
1466 }
1467 
1468 void ARMELFStreamer::emitUnwindRaw(int64_t Offset,
1469  const SmallVectorImpl<uint8_t> &Opcodes) {
1470  FlushPendingOffset();
1471  SPOffset = SPOffset - Offset;
1472  UnwindOpAsm.EmitRaw(Opcodes);
1473 }
1474 
1475 namespace llvm {
1476 
1479  MCInstPrinter *InstPrint,
1480  bool isVerboseAsm) {
1481  return new ARMTargetAsmStreamer(S, OS, *InstPrint, isVerboseAsm);
1482 }
1483 
1485  return new ARMTargetStreamer(S);
1486 }
1487 
1489  const MCSubtargetInfo &STI) {
1490  const Triple &TT = STI.getTargetTriple();
1491  if (TT.isOSBinFormatELF())
1492  return new ARMTargetELFStreamer(S);
1493  return new ARMTargetStreamer(S);
1494 }
1495 
1497  std::unique_ptr<MCAsmBackend> TAB,
1498  std::unique_ptr<MCObjectWriter> OW,
1499  std::unique_ptr<MCCodeEmitter> Emitter,
1500  bool RelaxAll, bool IsThumb) {
1501  ARMELFStreamer *S = new ARMELFStreamer(Context, std::move(TAB), std::move(OW),
1502  std::move(Emitter), IsThumb);
1503  // FIXME: This should eventually end up somewhere else where more
1504  // intelligent flag decisions can be made. For now we are just maintaining
1505  // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.
1506  S->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
1507 
1508  if (RelaxAll)
1509  S->getAssembler().setRelaxAll(true);
1510  return S;
1511 }
1512 
1513 } // end namespace llvm
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
static SectionKind getData()
Definition: SectionKind.h:202
void EmitBytes(StringRef Data) override
Emit the bytes in Data into the output.
LLVMContext & Context
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:115
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void reset() override
state management
Definition: MCELFStreamer.h:33
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:137
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:586
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
Target specific streamer interface.
Definition: MCStreamer.h:83
unsigned Reg
virtual void printRegName(raw_ostream &OS, unsigned RegNo) const
Print the assembler register name.
static MCFixupKind getKindForSize(unsigned Size, bool isPCRel)
Return the generic fixup kind for a value with the given size.
Definition: MCFixup.h:132
virtual void finishAttributeSection()
F(f)
StringRef getCPUAttr(ArchKind AK)
StringRef getArchExtName(unsigned ArchExtKind)
StringRef getFPUName(unsigned FPUKind)
virtual void reset()
Reset any state between object emissions, i.e.
const Triple & getTargetTriple() const
void setExternal(bool Value) const
Definition: MCSymbol.h:394
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
StringRef getArchName(ArchKind AK)
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:36
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:166
A four-byte fixup.
Definition: MCFixup.h:26
Context object for machine code objects.
Definition: MCContext.h:63
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:51
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:197
MCTargetStreamer * createARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool isVerboseAsm)
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:161
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:118
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
StringRef AttrTypeAsString(unsigned Attr, bool HasTagPrefix=true)
unsigned getUniqueID() const
Definition: MCSectionELF.h:87
void ChangeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
MCTargetStreamer * createARMObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI)
Streaming machine code generation interface.
Definition: MCStreamer.h:183
void print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens=false) const
Definition: MCExpr.cpp:42
unsigned const MachineRegisterInfo * MRI
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:78
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:117
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:23
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:223
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:50
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:23
void setOffset(uint64_t Value)
Definition: MCSymbol.h:327
MCELFStreamer * createARMELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter, bool RelaxAll, bool IsThumb)
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:90
static wasm::ValType getType(const TargetRegisterClass *RC)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Special entry for the function never unwind.
Definition: ARMEHABI.h:36
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
unsigned getULEB128Size(uint64_t Value)
Utility function to get the size of the ULEB128-encoded value.
Definition: LEB128.cpp:20
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:859
const MCSymbol & getSymbol() const
Definition: MCExpr.h:334
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
bool isVector(MCInstrInfo const &MCII, MCInst const &MCI)
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:385
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:248
.syntax (ARM/ELF)
Definition: MCDirectives.h:49
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:267
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:52
.code64 (X86)
Definition: MCDirectives.h:53
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:121
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:40
uint16_t getEncodingValue(unsigned RegNo) const
Returns the encoding for RegNo.
MCAssemblerFlag
Definition: MCDirectives.h:48
.type _foo, STT_FUNC # aka
Definition: MCDirectives.h:23
#define I(x, y, z)
Definition: MD5.cpp:58
Generic base class for all target subtargets.
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:28
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:203
const unsigned Kind
Fragment for data and encoded instructions.
Definition: MCFragment.h:241
LLVM_NODISCARD std::string lower() const
Definition: StringRef.cpp:108
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCTargetStreamer * createARMNullTargetStreamer(MCStreamer &S)
LLVM Value Representation.
Definition: Value.h:73
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
void EmitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
static std::string GetAEABIUnwindPersonalityName(unsigned Index)
Represents a location in source code.
Definition: SMLoc.h:24
unsigned getArchAttr(ArchKind AK)
void FinishImpl() override
Streamer specific finalization.
StringRef getSectionName() const
Definition: MCSectionELF.h:73
void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI, bool=false) override
Emit the given Instruction into the current section.
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:60