Home | History | Annotate | Download | only in MCTargetDesc 
      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/StringExtras.h"
     19 #include "llvm/ADT/Twine.h"
     20 #include "llvm/MC/MCAsmBackend.h"
     21 #include "llvm/MC/MCAsmInfo.h"
     22 #include "llvm/MC/MCAssembler.h"
     23 #include "llvm/MC/MCCodeEmitter.h"
     24 #include "llvm/MC/MCContext.h"
     25 #include "llvm/MC/MCELFStreamer.h"
     26 #include "llvm/MC/MCExpr.h"
     27 #include "llvm/MC/MCInst.h"
     28 #include "llvm/MC/MCInstPrinter.h"
     29 #include "llvm/MC/MCObjectFileInfo.h"
     30 #include "llvm/MC/MCObjectStreamer.h"
     31 #include "llvm/MC/MCRegisterInfo.h"
     32 #include "llvm/MC/MCSection.h"
     33 #include "llvm/MC/MCSectionELF.h"
     34 #include "llvm/MC/MCStreamer.h"
     35 #include "llvm/MC/MCSymbolELF.h"
     36 #include "llvm/MC/MCValue.h"
     37 #include "llvm/Support/ARMBuildAttributes.h"
     38 #include "llvm/Support/ARMEHABI.h"
     39 #include "llvm/Support/TargetParser.h"
     40 #include "llvm/Support/Debug.h"
     41 #include "llvm/Support/ELF.h"
     42 #include "llvm/Support/FormattedStream.h"
     43 #include "llvm/Support/LEB128.h"
     44 #include "llvm/Support/raw_ostream.h"
     45 #include <algorithm>
     46 
     47 using namespace llvm;
     48 
     49 static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
     50   assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX &&
     51          "Invalid personality index");
     52   return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
     53 }
     54 
     55 namespace {
     56 
     57 class ARMELFStreamer;
     58 
     59 class ARMTargetAsmStreamer : public ARMTargetStreamer {
     60   formatted_raw_ostream &OS;
     61   MCInstPrinter &InstPrinter;
     62   bool IsVerboseAsm;
     63 
     64   void emitFnStart() override;
     65   void emitFnEnd() override;
     66   void emitCantUnwind() override;
     67   void emitPersonality(const MCSymbol *Personality) override;
     68   void emitPersonalityIndex(unsigned Index) override;
     69   void emitHandlerData() override;
     70   void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
     71   void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
     72   void emitPad(int64_t Offset) override;
     73   void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
     74                    bool isVector) override;
     75   void emitUnwindRaw(int64_t Offset,
     76                      const SmallVectorImpl<uint8_t> &Opcodes) override;
     77 
     78   void switchVendor(StringRef Vendor) override;
     79   void emitAttribute(unsigned Attribute, unsigned Value) override;
     80   void emitTextAttribute(unsigned Attribute, StringRef String) override;
     81   void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
     82                             StringRef StringValue) override;
     83   void emitArch(unsigned Arch) override;
     84   void emitArchExtension(unsigned ArchExt) override;
     85   void emitObjectArch(unsigned Arch) override;
     86   void emitFPU(unsigned FPU) override;
     87   void emitInst(uint32_t Inst, char Suffix = '\0') override;
     88   void finishAttributeSection() override;
     89 
     90   void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
     91   void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
     92 
     93 public:
     94   ARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS,
     95                        MCInstPrinter &InstPrinter, bool VerboseAsm);
     96 };
     97 
     98 ARMTargetAsmStreamer::ARMTargetAsmStreamer(MCStreamer &S,
     99                                            formatted_raw_ostream &OS,
    100                                            MCInstPrinter &InstPrinter,
    101                                            bool VerboseAsm)
    102     : ARMTargetStreamer(S), OS(OS), InstPrinter(InstPrinter),
    103       IsVerboseAsm(VerboseAsm) {}
    104 void ARMTargetAsmStreamer::emitFnStart() { OS << "\t.fnstart\n"; }
    105 void ARMTargetAsmStreamer::emitFnEnd() { OS << "\t.fnend\n"; }
    106 void ARMTargetAsmStreamer::emitCantUnwind() { OS << "\t.cantunwind\n"; }
    107 void ARMTargetAsmStreamer::emitPersonality(const MCSymbol *Personality) {
    108   OS << "\t.personality " << Personality->getName() << '\n';
    109 }
    110 void ARMTargetAsmStreamer::emitPersonalityIndex(unsigned Index) {
    111   OS << "\t.personalityindex " << Index << '\n';
    112 }
    113 void ARMTargetAsmStreamer::emitHandlerData() { OS << "\t.handlerdata\n"; }
    114 void ARMTargetAsmStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
    115                                      int64_t Offset) {
    116   OS << "\t.setfp\t";
    117   InstPrinter.printRegName(OS, FpReg);
    118   OS << ", ";
    119   InstPrinter.printRegName(OS, SpReg);
    120   if (Offset)
    121     OS << ", #" << Offset;
    122   OS << '\n';
    123 }
    124 void ARMTargetAsmStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
    125   assert((Reg != ARM::SP && Reg != ARM::PC) &&
    126          "the operand of .movsp cannot be either sp or pc");
    127 
    128   OS << "\t.movsp\t";
    129   InstPrinter.printRegName(OS, Reg);
    130   if (Offset)
    131     OS << ", #" << Offset;
    132   OS << '\n';
    133 }
    134 void ARMTargetAsmStreamer::emitPad(int64_t Offset) {
    135   OS << "\t.pad\t#" << Offset << '\n';
    136 }
    137 void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
    138                                        bool isVector) {
    139   assert(RegList.size() && "RegList should not be empty");
    140   if (isVector)
    141     OS << "\t.vsave\t{";
    142   else
    143     OS << "\t.save\t{";
    144 
    145   InstPrinter.printRegName(OS, RegList[0]);
    146 
    147   for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
    148     OS << ", ";
    149     InstPrinter.printRegName(OS, RegList[i]);
    150   }
    151 
    152   OS << "}\n";
    153 }
    154 void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {
    155 }
    156 void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
    157   OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
    158   if (IsVerboseAsm) {
    159     StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
    160     if (!Name.empty())
    161       OS << "\t@ " << Name;
    162   }
    163   OS << "\n";
    164 }
    165 void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
    166                                              StringRef String) {
    167   switch (Attribute) {
    168   case ARMBuildAttrs::CPU_name:
    169     OS << "\t.cpu\t" << String.lower();
    170     break;
    171   default:
    172     OS << "\t.eabi_attribute\t" << Attribute << ", \"" << String << "\"";
    173     if (IsVerboseAsm) {
    174       StringRef Name = ARMBuildAttrs::AttrTypeAsString(Attribute);
    175       if (!Name.empty())
    176         OS << "\t@ " << Name;
    177     }
    178     break;
    179   }
    180   OS << "\n";
    181 }
    182 void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
    183                                                 unsigned IntValue,
    184                                                 StringRef StringValue) {
    185   switch (Attribute) {
    186   default: llvm_unreachable("unsupported multi-value attribute in asm mode");
    187   case ARMBuildAttrs::compatibility:
    188     OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
    189     if (!StringValue.empty())
    190       OS << ", \"" << StringValue << "\"";
    191     if (IsVerboseAsm)
    192       OS << "\t@ " << ARMBuildAttrs::AttrTypeAsString(Attribute);
    193     break;
    194   }
    195   OS << "\n";
    196 }
    197 void ARMTargetAsmStreamer::emitArch(unsigned Arch) {
    198   OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";
    199 }
    200 void ARMTargetAsmStreamer::emitArchExtension(unsigned ArchExt) {
    201   OS << "\t.arch_extension\t" << ARM::getArchExtName(ArchExt) << "\n";
    202 }
    203 void ARMTargetAsmStreamer::emitObjectArch(unsigned Arch) {
    204   OS << "\t.object_arch\t" << ARM::getArchName(Arch) << '\n';
    205 }
    206 void ARMTargetAsmStreamer::emitFPU(unsigned FPU) {
    207   OS << "\t.fpu\t" << ARM::getFPUName(FPU) << "\n";
    208 }
    209 void ARMTargetAsmStreamer::finishAttributeSection() {
    210 }
    211 void
    212 ARMTargetAsmStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
    213   OS << "\t.tlsdescseq\t" << S->getSymbol().getName();
    214 }
    215 
    216 void ARMTargetAsmStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
    217   const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
    218 
    219   OS << "\t.thumb_set\t";
    220   Symbol->print(OS, MAI);
    221   OS << ", ";
    222   Value->print(OS, MAI);
    223   OS << '\n';
    224 }
    225 
    226 void ARMTargetAsmStreamer::emitInst(uint32_t Inst, char Suffix) {
    227   OS << "\t.inst";
    228   if (Suffix)
    229     OS << "." << Suffix;
    230   OS << "\t0x" << Twine::utohexstr(Inst) << "\n";
    231 }
    232 
    233 void ARMTargetAsmStreamer::emitUnwindRaw(int64_t Offset,
    234                                       const SmallVectorImpl<uint8_t> &Opcodes) {
    235   OS << "\t.unwind_raw " << Offset;
    236   for (SmallVectorImpl<uint8_t>::const_iterator OCI = Opcodes.begin(),
    237                                                 OCE = Opcodes.end();
    238        OCI != OCE; ++OCI)
    239     OS << ", 0x" << Twine::utohexstr(*OCI);
    240   OS << '\n';
    241 }
    242 
    243 class ARMTargetELFStreamer : public ARMTargetStreamer {
    244 private:
    245   // This structure holds all attributes, accounting for
    246   // their string/numeric value, so we can later emit them
    247   // in declaration order, keeping all in the same vector
    248   struct AttributeItem {
    249     enum {
    250       HiddenAttribute = 0,
    251       NumericAttribute,
    252       TextAttribute,
    253       NumericAndTextAttributes
    254     } Type;
    255     unsigned Tag;
    256     unsigned IntValue;
    257     std::string StringValue;
    258 
    259     static bool LessTag(const AttributeItem &LHS, const AttributeItem &RHS) {
    260       // The conformance tag must be emitted first when serialised
    261       // into an object file. Specifically, the addenda to the ARM ABI
    262       // states that (2.3.7.4):
    263       //
    264       // "To simplify recognition by consumers in the common case of
    265       // claiming conformity for the whole file, this tag should be
    266       // emitted first in a file-scope sub-subsection of the first
    267       // public subsection of the attributes section."
    268       //
    269       // So it is special-cased in this comparison predicate when the
    270       // attributes are sorted in finishAttributeSection().
    271       return (RHS.Tag != ARMBuildAttrs::conformance) &&
    272              ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
    273     }
    274   };
    275 
    276   StringRef CurrentVendor;
    277   unsigned FPU;
    278   unsigned Arch;
    279   unsigned EmittedArch;
    280   SmallVector<AttributeItem, 64> Contents;
    281 
    282   MCSection *AttributeSection;
    283 
    284   AttributeItem *getAttributeItem(unsigned Attribute) {
    285     for (size_t i = 0; i < Contents.size(); ++i)
    286       if (Contents[i].Tag == Attribute)
    287         return &Contents[i];
    288     return nullptr;
    289   }
    290 
    291   void setAttributeItem(unsigned Attribute, unsigned Value,
    292                         bool OverwriteExisting) {
    293     // Look for existing attribute item
    294     if (AttributeItem *Item = getAttributeItem(Attribute)) {
    295       if (!OverwriteExisting)
    296         return;
    297       Item->Type = AttributeItem::NumericAttribute;
    298       Item->IntValue = Value;
    299       return;
    300     }
    301 
    302     // Create new attribute item
    303     AttributeItem Item = {
    304       AttributeItem::NumericAttribute,
    305       Attribute,
    306       Value,
    307       StringRef("")
    308     };
    309     Contents.push_back(Item);
    310   }
    311 
    312   void setAttributeItem(unsigned Attribute, StringRef Value,
    313                         bool OverwriteExisting) {
    314     // Look for existing attribute item
    315     if (AttributeItem *Item = getAttributeItem(Attribute)) {
    316       if (!OverwriteExisting)
    317         return;
    318       Item->Type = AttributeItem::TextAttribute;
    319       Item->StringValue = Value;
    320       return;
    321     }
    322 
    323     // Create new attribute item
    324     AttributeItem Item = {
    325       AttributeItem::TextAttribute,
    326       Attribute,
    327       0,
    328       Value
    329     };
    330     Contents.push_back(Item);
    331   }
    332 
    333   void setAttributeItems(unsigned Attribute, unsigned IntValue,
    334                          StringRef StringValue, bool OverwriteExisting) {
    335     // Look for existing attribute item
    336     if (AttributeItem *Item = getAttributeItem(Attribute)) {
    337       if (!OverwriteExisting)
    338         return;
    339       Item->Type = AttributeItem::NumericAndTextAttributes;
    340       Item->IntValue = IntValue;
    341       Item->StringValue = StringValue;
    342       return;
    343     }
    344 
    345     // Create new attribute item
    346     AttributeItem Item = {
    347       AttributeItem::NumericAndTextAttributes,
    348       Attribute,
    349       IntValue,
    350       StringValue
    351     };
    352     Contents.push_back(Item);
    353   }
    354 
    355   void emitArchDefaultAttributes();
    356   void emitFPUDefaultAttributes();
    357 
    358   ARMELFStreamer &getStreamer();
    359 
    360   void emitFnStart() override;
    361   void emitFnEnd() override;
    362   void emitCantUnwind() override;
    363   void emitPersonality(const MCSymbol *Personality) override;
    364   void emitPersonalityIndex(unsigned Index) override;
    365   void emitHandlerData() override;
    366   void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
    367   void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
    368   void emitPad(int64_t Offset) override;
    369   void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
    370                    bool isVector) override;
    371   void emitUnwindRaw(int64_t Offset,
    372                      const SmallVectorImpl<uint8_t> &Opcodes) override;
    373 
    374   void switchVendor(StringRef Vendor) override;
    375   void emitAttribute(unsigned Attribute, unsigned Value) override;
    376   void emitTextAttribute(unsigned Attribute, StringRef String) override;
    377   void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
    378                             StringRef StringValue) override;
    379   void emitArch(unsigned Arch) override;
    380   void emitObjectArch(unsigned Arch) override;
    381   void emitFPU(unsigned FPU) override;
    382   void emitInst(uint32_t Inst, char Suffix = '\0') override;
    383   void finishAttributeSection() override;
    384   void emitLabel(MCSymbol *Symbol) override;
    385 
    386   void AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
    387   void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
    388 
    389   size_t calculateContentSize() const;
    390 
    391 public:
    392   ARMTargetELFStreamer(MCStreamer &S)
    393     : ARMTargetStreamer(S), CurrentVendor("aeabi"), FPU(ARM::FK_INVALID),
    394       Arch(ARM::AK_INVALID), EmittedArch(ARM::AK_INVALID),
    395       AttributeSection(nullptr) {}
    396 };
    397 
    398 /// Extend the generic ELFStreamer class so that it can emit mapping symbols at
    399 /// the appropriate points in the object files. These symbols are defined in the
    400 /// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
    401 ///
    402 /// In brief: $a, $t or $d should be emitted at the start of each contiguous
    403 /// region of ARM code, Thumb code or data in a section. In practice, this
    404 /// emission does not rely on explicit assembler directives but on inherent
    405 /// properties of the directives doing the emission (e.g. ".byte" is data, "add
    406 /// r0, r0, r0" an instruction).
    407 ///
    408 /// As a result this system is orthogonal to the DataRegion infrastructure used
    409 /// by MachO. Beware!
    410 class ARMELFStreamer : public MCELFStreamer {
    411 public:
    412   friend class ARMTargetELFStreamer;
    413 
    414   ARMELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
    415                  MCCodeEmitter *Emitter, bool IsThumb)
    416       : MCELFStreamer(Context, TAB, OS, Emitter), IsThumb(IsThumb),
    417         MappingSymbolCounter(0), LastEMS(EMS_None) {
    418     Reset();
    419   }
    420 
    421   ~ARMELFStreamer() {}
    422 
    423   void FinishImpl() override;
    424 
    425   // ARM exception handling directives
    426   void emitFnStart();
    427   void emitFnEnd();
    428   void emitCantUnwind();
    429   void emitPersonality(const MCSymbol *Per);
    430   void emitPersonalityIndex(unsigned index);
    431   void emitHandlerData();
    432   void emitSetFP(unsigned NewFpReg, unsigned NewSpReg, int64_t Offset = 0);
    433   void emitMovSP(unsigned Reg, int64_t Offset = 0);
    434   void emitPad(int64_t Offset);
    435   void emitRegSave(const SmallVectorImpl<unsigned> &RegList, bool isVector);
    436   void emitUnwindRaw(int64_t Offset, const SmallVectorImpl<uint8_t> &Opcodes);
    437 
    438   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override {
    439     // We have to keep track of the mapping symbol state of any sections we
    440     // use. Each one should start off as EMS_None, which is provided as the
    441     // default constructor by DenseMap::lookup.
    442     LastMappingSymbols[getPreviousSection().first] = LastEMS;
    443     LastEMS = LastMappingSymbols.lookup(Section);
    444 
    445     MCELFStreamer::ChangeSection(Section, Subsection);
    446   }
    447 
    448   /// This function is the one used to emit instruction data into the ELF
    449   /// streamer. We override it to add the appropriate mapping symbol if
    450   /// necessary.
    451   void EmitInstruction(const MCInst& Inst,
    452                        const MCSubtargetInfo &STI) override {
    453     if (IsThumb)
    454       EmitThumbMappingSymbol();
    455     else
    456       EmitARMMappingSymbol();
    457 
    458     MCELFStreamer::EmitInstruction(Inst, STI);
    459   }
    460 
    461   void emitInst(uint32_t Inst, char Suffix) {
    462     unsigned Size;
    463     char Buffer[4];
    464     const bool LittleEndian = getContext().getAsmInfo()->isLittleEndian();
    465 
    466     switch (Suffix) {
    467     case '\0':
    468       Size = 4;
    469 
    470       assert(!IsThumb);
    471       EmitARMMappingSymbol();
    472       for (unsigned II = 0, IE = Size; II != IE; II++) {
    473         const unsigned I = LittleEndian ? (Size - II - 1) : II;
    474         Buffer[Size - II - 1] = uint8_t(Inst >> I * CHAR_BIT);
    475       }
    476 
    477       break;
    478     case 'n':
    479     case 'w':
    480       Size = (Suffix == 'n' ? 2 : 4);
    481 
    482       assert(IsThumb);
    483       EmitThumbMappingSymbol();
    484       for (unsigned II = 0, IE = Size; II != IE; II = II + 2) {
    485         const unsigned I0 = LittleEndian ? II + 0 : (Size - II - 1);
    486         const unsigned I1 = LittleEndian ? II + 1 : (Size - II - 2);
    487         Buffer[Size - II - 2] = uint8_t(Inst >> I0 * CHAR_BIT);
    488         Buffer[Size - II - 1] = uint8_t(Inst >> I1 * CHAR_BIT);
    489       }
    490 
    491       break;
    492     default:
    493       llvm_unreachable("Invalid Suffix");
    494     }
    495 
    496     MCELFStreamer::EmitBytes(StringRef(Buffer, Size));
    497   }
    498 
    499   /// This is one of the functions used to emit data into an ELF section, so the
    500   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
    501   /// necessary.
    502   void EmitBytes(StringRef Data) override {
    503     EmitDataMappingSymbol();
    504     MCELFStreamer::EmitBytes(Data);
    505   }
    506 
    507   /// This is one of the functions used to emit data into an ELF section, so the
    508   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
    509   /// necessary.
    510   void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
    511     if (const MCSymbolRefExpr *SRE = dyn_cast_or_null<MCSymbolRefExpr>(Value))
    512       if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) {
    513         getContext().reportError(Loc, "relocated expression must be 32-bit");
    514         return;
    515       }
    516 
    517     EmitDataMappingSymbol();
    518     MCELFStreamer::EmitValueImpl(Value, Size, Loc);
    519   }
    520 
    521   void EmitAssemblerFlag(MCAssemblerFlag Flag) override {
    522     MCELFStreamer::EmitAssemblerFlag(Flag);
    523 
    524     switch (Flag) {
    525     case MCAF_SyntaxUnified:
    526       return; // no-op here.
    527     case MCAF_Code16:
    528       IsThumb = true;
    529       return; // Change to Thumb mode
    530     case MCAF_Code32:
    531       IsThumb = false;
    532       return; // Change to ARM mode
    533     case MCAF_Code64:
    534       return;
    535     case MCAF_SubsectionsViaSymbols:
    536       return;
    537     }
    538   }
    539 
    540 private:
    541   enum ElfMappingSymbol {
    542     EMS_None,
    543     EMS_ARM,
    544     EMS_Thumb,
    545     EMS_Data
    546   };
    547 
    548   void EmitDataMappingSymbol() {
    549     if (LastEMS == EMS_Data) return;
    550     EmitMappingSymbol("$d");
    551     LastEMS = EMS_Data;
    552   }
    553 
    554   void EmitThumbMappingSymbol() {
    555     if (LastEMS == EMS_Thumb) return;
    556     EmitMappingSymbol("$t");
    557     LastEMS = EMS_Thumb;
    558   }
    559 
    560   void EmitARMMappingSymbol() {
    561     if (LastEMS == EMS_ARM) return;
    562     EmitMappingSymbol("$a");
    563     LastEMS = EMS_ARM;
    564   }
    565 
    566   void EmitMappingSymbol(StringRef Name) {
    567     auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
    568         Name + "." + Twine(MappingSymbolCounter++)));
    569     EmitLabel(Symbol);
    570 
    571     Symbol->setType(ELF::STT_NOTYPE);
    572     Symbol->setBinding(ELF::STB_LOCAL);
    573     Symbol->setExternal(false);
    574   }
    575 
    576   void EmitThumbFunc(MCSymbol *Func) override {
    577     getAssembler().setIsThumbFunc(Func);
    578     EmitSymbolAttribute(Func, MCSA_ELF_TypeFunction);
    579   }
    580 
    581   // Helper functions for ARM exception handling directives
    582   void Reset();
    583 
    584   void EmitPersonalityFixup(StringRef Name);
    585   void FlushPendingOffset();
    586   void FlushUnwindOpcodes(bool NoHandlerData);
    587 
    588   void SwitchToEHSection(const char *Prefix, unsigned Type, unsigned Flags,
    589                          SectionKind Kind, const MCSymbol &Fn);
    590   void SwitchToExTabSection(const MCSymbol &FnStart);
    591   void SwitchToExIdxSection(const MCSymbol &FnStart);
    592 
    593   void EmitFixup(const MCExpr *Expr, MCFixupKind Kind);
    594 
    595   bool IsThumb;
    596   int64_t MappingSymbolCounter;
    597 
    598   DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
    599   ElfMappingSymbol LastEMS;
    600 
    601   // ARM Exception Handling Frame Information
    602   MCSymbol *ExTab;
    603   MCSymbol *FnStart;
    604   const MCSymbol *Personality;
    605   unsigned PersonalityIndex;
    606   unsigned FPReg; // Frame pointer register
    607   int64_t FPOffset; // Offset: (final frame pointer) - (initial $sp)
    608   int64_t SPOffset; // Offset: (final $sp) - (initial $sp)
    609   int64_t PendingOffset; // Offset: (final $sp) - (emitted $sp)
    610   bool UsedFP;
    611   bool CantUnwind;
    612   SmallVector<uint8_t, 64> Opcodes;
    613   UnwindOpcodeAssembler UnwindOpAsm;
    614 };
    615 } // end anonymous namespace
    616 
    617 ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
    618   return static_cast<ARMELFStreamer &>(Streamer);
    619 }
    620 
    621 void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
    622 void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
    623 void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
    624 void ARMTargetELFStreamer::emitPersonality(const MCSymbol *Personality) {
    625   getStreamer().emitPersonality(Personality);
    626 }
    627 void ARMTargetELFStreamer::emitPersonalityIndex(unsigned Index) {
    628   getStreamer().emitPersonalityIndex(Index);
    629 }
    630 void ARMTargetELFStreamer::emitHandlerData() {
    631   getStreamer().emitHandlerData();
    632 }
    633 void ARMTargetELFStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
    634                                      int64_t Offset) {
    635   getStreamer().emitSetFP(FpReg, SpReg, Offset);
    636 }
    637 void ARMTargetELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
    638   getStreamer().emitMovSP(Reg, Offset);
    639 }
    640 void ARMTargetELFStreamer::emitPad(int64_t Offset) {
    641   getStreamer().emitPad(Offset);
    642 }
    643 void ARMTargetELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
    644                                        bool isVector) {
    645   getStreamer().emitRegSave(RegList, isVector);
    646 }
    647 void ARMTargetELFStreamer::emitUnwindRaw(int64_t Offset,
    648                                       const SmallVectorImpl<uint8_t> &Opcodes) {
    649   getStreamer().emitUnwindRaw(Offset, Opcodes);
    650 }
    651 void ARMTargetELFStreamer::switchVendor(StringRef Vendor) {
    652   assert(!Vendor.empty() && "Vendor cannot be empty.");
    653 
    654   if (CurrentVendor == Vendor)
    655     return;
    656 
    657   if (!CurrentVendor.empty())
    658     finishAttributeSection();
    659 
    660   assert(Contents.empty() &&
    661          ".ARM.attributes should be flushed before changing vendor");
    662   CurrentVendor = Vendor;
    663 
    664 }
    665 void ARMTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
    666   setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
    667 }
    668 void ARMTargetELFStreamer::emitTextAttribute(unsigned Attribute,
    669                                              StringRef Value) {
    670   setAttributeItem(Attribute, Value, /* OverwriteExisting= */ true);
    671 }
    672 void ARMTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
    673                                                 unsigned IntValue,
    674                                                 StringRef StringValue) {
    675   setAttributeItems(Attribute, IntValue, StringValue,
    676                     /* OverwriteExisting= */ true);
    677 }
    678 void ARMTargetELFStreamer::emitArch(unsigned Value) {
    679   Arch = Value;
    680 }
    681 void ARMTargetELFStreamer::emitObjectArch(unsigned Value) {
    682   EmittedArch = Value;
    683 }
    684 void ARMTargetELFStreamer::emitArchDefaultAttributes() {
    685   using namespace ARMBuildAttrs;
    686 
    687   setAttributeItem(CPU_name,
    688                    ARM::getCPUAttr(Arch),
    689                    false);
    690 
    691   if (EmittedArch == ARM::AK_INVALID)
    692     setAttributeItem(CPU_arch,
    693                      ARM::getArchAttr(Arch),
    694                      false);
    695   else
    696     setAttributeItem(CPU_arch,
    697                      ARM::getArchAttr(EmittedArch),
    698                      false);
    699 
    700   switch (Arch) {
    701   case ARM::AK_ARMV2:
    702   case ARM::AK_ARMV2A:
    703   case ARM::AK_ARMV3:
    704   case ARM::AK_ARMV3M:
    705   case ARM::AK_ARMV4:
    706     setAttributeItem(ARM_ISA_use, Allowed, false);
    707     break;
    708 
    709   case ARM::AK_ARMV4T:
    710   case ARM::AK_ARMV5T:
    711   case ARM::AK_ARMV5TE:
    712   case ARM::AK_ARMV6:
    713     setAttributeItem(ARM_ISA_use, Allowed, false);
    714     setAttributeItem(THUMB_ISA_use, Allowed, false);
    715     break;
    716 
    717   case ARM::AK_ARMV6T2:
    718     setAttributeItem(ARM_ISA_use, Allowed, false);
    719     setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
    720     break;
    721 
    722   case ARM::AK_ARMV6K:
    723   case ARM::AK_ARMV6KZ:
    724     setAttributeItem(ARM_ISA_use, Allowed, false);
    725     setAttributeItem(THUMB_ISA_use, Allowed, false);
    726     setAttributeItem(Virtualization_use, AllowTZ, false);
    727     break;
    728 
    729   case ARM::AK_ARMV6M:
    730     setAttributeItem(THUMB_ISA_use, Allowed, false);
    731     break;
    732 
    733   case ARM::AK_ARMV7A:
    734     setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
    735     setAttributeItem(ARM_ISA_use, Allowed, false);
    736     setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
    737     break;
    738 
    739   case ARM::AK_ARMV7R:
    740     setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
    741     setAttributeItem(ARM_ISA_use, Allowed, false);
    742     setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
    743     break;
    744 
    745   case ARM::AK_ARMV7M:
    746     setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
    747     setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
    748     break;
    749 
    750   case ARM::AK_ARMV8A:
    751   case ARM::AK_ARMV8_1A:
    752   case ARM::AK_ARMV8_2A:
    753     setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
    754     setAttributeItem(ARM_ISA_use, Allowed, false);
    755     setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
    756     setAttributeItem(MPextension_use, Allowed, false);
    757     setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
    758     break;
    759 
    760   case ARM::AK_IWMMXT:
    761     setAttributeItem(ARM_ISA_use, Allowed, false);
    762     setAttributeItem(THUMB_ISA_use, Allowed, false);
    763     setAttributeItem(WMMX_arch, AllowWMMXv1, false);
    764     break;
    765 
    766   case ARM::AK_IWMMXT2:
    767     setAttributeItem(ARM_ISA_use, Allowed, false);
    768     setAttributeItem(THUMB_ISA_use, Allowed, false);
    769     setAttributeItem(WMMX_arch, AllowWMMXv2, false);
    770     break;
    771 
    772   default:
    773     report_fatal_error("Unknown Arch: " + Twine(Arch));
    774     break;
    775   }
    776 }
    777 void ARMTargetELFStreamer::emitFPU(unsigned Value) {
    778   FPU = Value;
    779 }
    780 void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
    781   switch (FPU) {
    782   case ARM::FK_VFP:
    783   case ARM::FK_VFPV2:
    784     setAttributeItem(ARMBuildAttrs::FP_arch,
    785                      ARMBuildAttrs::AllowFPv2,
    786                      /* OverwriteExisting= */ false);
    787     break;
    788 
    789   case ARM::FK_VFPV3:
    790     setAttributeItem(ARMBuildAttrs::FP_arch,
    791                      ARMBuildAttrs::AllowFPv3A,
    792                      /* OverwriteExisting= */ false);
    793     break;
    794 
    795   case ARM::FK_VFPV3_FP16:
    796     setAttributeItem(ARMBuildAttrs::FP_arch,
    797                      ARMBuildAttrs::AllowFPv3A,
    798                      /* OverwriteExisting= */ false);
    799     setAttributeItem(ARMBuildAttrs::FP_HP_extension,
    800                      ARMBuildAttrs::AllowHPFP,
    801                      /* OverwriteExisting= */ false);
    802     break;
    803 
    804   case ARM::FK_VFPV3_D16:
    805     setAttributeItem(ARMBuildAttrs::FP_arch,
    806                      ARMBuildAttrs::AllowFPv3B,
    807                      /* OverwriteExisting= */ false);
    808     break;
    809 
    810   case ARM::FK_VFPV3_D16_FP16:
    811     setAttributeItem(ARMBuildAttrs::FP_arch,
    812                      ARMBuildAttrs::AllowFPv3B,
    813                      /* OverwriteExisting= */ false);
    814     setAttributeItem(ARMBuildAttrs::FP_HP_extension,
    815                      ARMBuildAttrs::AllowHPFP,
    816                      /* OverwriteExisting= */ false);
    817     break;
    818 
    819   case ARM::FK_VFPV3XD:
    820     setAttributeItem(ARMBuildAttrs::FP_arch,
    821                      ARMBuildAttrs::AllowFPv3B,
    822                      /* OverwriteExisting= */ false);
    823     break;
    824   case ARM::FK_VFPV3XD_FP16:
    825     setAttributeItem(ARMBuildAttrs::FP_arch,
    826                      ARMBuildAttrs::AllowFPv3B,
    827                      /* OverwriteExisting= */ false);
    828     setAttributeItem(ARMBuildAttrs::FP_HP_extension,
    829                      ARMBuildAttrs::AllowHPFP,
    830                      /* OverwriteExisting= */ false);
    831     break;
    832 
    833   case ARM::FK_VFPV4:
    834     setAttributeItem(ARMBuildAttrs::FP_arch,
    835                      ARMBuildAttrs::AllowFPv4A,
    836                      /* OverwriteExisting= */ false);
    837     break;
    838 
    839   // ABI_HardFP_use is handled in ARMAsmPrinter, so _SP_D16 is treated the same
    840   // as _D16 here.
    841   case ARM::FK_FPV4_SP_D16:
    842   case ARM::FK_VFPV4_D16:
    843     setAttributeItem(ARMBuildAttrs::FP_arch,
    844                      ARMBuildAttrs::AllowFPv4B,
    845                      /* OverwriteExisting= */ false);
    846     break;
    847 
    848   case ARM::FK_FP_ARMV8:
    849     setAttributeItem(ARMBuildAttrs::FP_arch,
    850                      ARMBuildAttrs::AllowFPARMv8A,
    851                      /* OverwriteExisting= */ false);
    852     break;
    853 
    854   // FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
    855   // uses the FP_ARMV8_D16 build attribute.
    856   case ARM::FK_FPV5_SP_D16:
    857   case ARM::FK_FPV5_D16:
    858     setAttributeItem(ARMBuildAttrs::FP_arch,
    859                      ARMBuildAttrs::AllowFPARMv8B,
    860                      /* OverwriteExisting= */ false);
    861     break;
    862 
    863   case ARM::FK_NEON:
    864     setAttributeItem(ARMBuildAttrs::FP_arch,
    865                      ARMBuildAttrs::AllowFPv3A,
    866                      /* OverwriteExisting= */ false);
    867     setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
    868                      ARMBuildAttrs::AllowNeon,
    869                      /* OverwriteExisting= */ false);
    870     break;
    871 
    872   case ARM::FK_NEON_FP16:
    873     setAttributeItem(ARMBuildAttrs::FP_arch,
    874                      ARMBuildAttrs::AllowFPv3A,
    875                      /* OverwriteExisting= */ false);
    876     setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
    877                      ARMBuildAttrs::AllowNeon,
    878                      /* OverwriteExisting= */ false);
    879     setAttributeItem(ARMBuildAttrs::FP_HP_extension,
    880                      ARMBuildAttrs::AllowHPFP,
    881                      /* OverwriteExisting= */ false);
    882     break;
    883 
    884   case ARM::FK_NEON_VFPV4:
    885     setAttributeItem(ARMBuildAttrs::FP_arch,
    886                      ARMBuildAttrs::AllowFPv4A,
    887                      /* OverwriteExisting= */ false);
    888     setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
    889                      ARMBuildAttrs::AllowNeon2,
    890                      /* OverwriteExisting= */ false);
    891     break;
    892 
    893   case ARM::FK_NEON_FP_ARMV8:
    894   case ARM::FK_CRYPTO_NEON_FP_ARMV8:
    895     setAttributeItem(ARMBuildAttrs::FP_arch,
    896                      ARMBuildAttrs::AllowFPARMv8A,
    897                      /* OverwriteExisting= */ false);
    898     // 'Advanced_SIMD_arch' must be emitted not here, but within
    899     // ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
    900     break;
    901 
    902   case ARM::FK_SOFTVFP:
    903   case ARM::FK_NONE:
    904     break;
    905 
    906   default:
    907     report_fatal_error("Unknown FPU: " + Twine(FPU));
    908     break;
    909   }
    910 }
    911 size_t ARMTargetELFStreamer::calculateContentSize() const {
    912   size_t Result = 0;
    913   for (size_t i = 0; i < Contents.size(); ++i) {
    914     AttributeItem item = Contents[i];
    915     switch (item.Type) {
    916     case AttributeItem::HiddenAttribute:
    917       break;
    918     case AttributeItem::NumericAttribute:
    919       Result += getULEB128Size(item.Tag);
    920       Result += getULEB128Size(item.IntValue);
    921       break;
    922     case AttributeItem::TextAttribute:
    923       Result += getULEB128Size(item.Tag);
    924       Result += item.StringValue.size() + 1; // string + '\0'
    925       break;
    926     case AttributeItem::NumericAndTextAttributes:
    927       Result += getULEB128Size(item.Tag);
    928       Result += getULEB128Size(item.IntValue);
    929       Result += item.StringValue.size() + 1; // string + '\0';
    930       break;
    931     }
    932   }
    933   return Result;
    934 }
    935 void ARMTargetELFStreamer::finishAttributeSection() {
    936   // <format-version>
    937   // [ <section-length> "vendor-name"
    938   // [ <file-tag> <size> <attribute>*
    939   //   | <section-tag> <size> <section-number>* 0 <attribute>*
    940   //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
    941   //   ]+
    942   // ]*
    943 
    944   if (FPU != ARM::FK_INVALID)
    945     emitFPUDefaultAttributes();
    946 
    947   if (Arch != ARM::AK_INVALID)
    948     emitArchDefaultAttributes();
    949 
    950   if (Contents.empty())
    951     return;
    952 
    953   std::sort(Contents.begin(), Contents.end(), AttributeItem::LessTag);
    954 
    955   ARMELFStreamer &Streamer = getStreamer();
    956 
    957   // Switch to .ARM.attributes section
    958   if (AttributeSection) {
    959     Streamer.SwitchSection(AttributeSection);
    960   } else {
    961     AttributeSection = Streamer.getContext().getELFSection(
    962         ".ARM.attributes", ELF::SHT_ARM_ATTRIBUTES, 0);
    963     Streamer.SwitchSection(AttributeSection);
    964 
    965     // Format version
    966     Streamer.EmitIntValue(0x41, 1);
    967   }
    968 
    969   // Vendor size + Vendor name + '\0'
    970   const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
    971 
    972   // Tag + Tag Size
    973   const size_t TagHeaderSize = 1 + 4;
    974 
    975   const size_t ContentsSize = calculateContentSize();
    976 
    977   Streamer.EmitIntValue(VendorHeaderSize + TagHeaderSize + ContentsSize, 4);
    978   Streamer.EmitBytes(CurrentVendor);
    979   Streamer.EmitIntValue(0, 1); // '\0'
    980 
    981   Streamer.EmitIntValue(ARMBuildAttrs::File, 1);
    982   Streamer.EmitIntValue(TagHeaderSize + ContentsSize, 4);
    983 
    984   // Size should have been accounted for already, now
    985   // emit each field as its type (ULEB or String)
    986   for (size_t i = 0; i < Contents.size(); ++i) {
    987     AttributeItem item = Contents[i];
    988     Streamer.EmitULEB128IntValue(item.Tag);
    989     switch (item.Type) {
    990     default: llvm_unreachable("Invalid attribute type");
    991     case AttributeItem::NumericAttribute:
    992       Streamer.EmitULEB128IntValue(item.IntValue);
    993       break;
    994     case AttributeItem::TextAttribute:
    995       Streamer.EmitBytes(item.StringValue);
    996       Streamer.EmitIntValue(0, 1); // '\0'
    997       break;
    998     case AttributeItem::NumericAndTextAttributes:
    999       Streamer.EmitULEB128IntValue(item.IntValue);
   1000       Streamer.EmitBytes(item.StringValue);
   1001       Streamer.EmitIntValue(0, 1); // '\0'
   1002       break;
   1003     }
   1004   }
   1005 
   1006   Contents.clear();
   1007   FPU = ARM::FK_INVALID;
   1008 }
   1009 
   1010 void ARMTargetELFStreamer::emitLabel(MCSymbol *Symbol) {
   1011   ARMELFStreamer &Streamer = getStreamer();
   1012   if (!Streamer.IsThumb)
   1013     return;
   1014 
   1015   Streamer.getAssembler().registerSymbol(*Symbol);
   1016   unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
   1017   if (Type == ELF::STT_FUNC || Type == ELF::STT_GNU_IFUNC)
   1018     Streamer.EmitThumbFunc(Symbol);
   1019 }
   1020 
   1021 void
   1022 ARMTargetELFStreamer::AnnotateTLSDescriptorSequence(const MCSymbolRefExpr *S) {
   1023   getStreamer().EmitFixup(S, FK_Data_4);
   1024 }
   1025 
   1026 void ARMTargetELFStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
   1027   if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Value)) {
   1028     const MCSymbol &Sym = SRE->getSymbol();
   1029     if (!Sym.isDefined()) {
   1030       getStreamer().EmitAssignment(Symbol, Value);
   1031       return;
   1032     }
   1033   }
   1034 
   1035   getStreamer().EmitThumbFunc(Symbol);
   1036   getStreamer().EmitAssignment(Symbol, Value);
   1037 }
   1038 
   1039 void ARMTargetELFStreamer::emitInst(uint32_t Inst, char Suffix) {
   1040   getStreamer().emitInst(Inst, Suffix);
   1041 }
   1042 
   1043 void ARMELFStreamer::FinishImpl() {
   1044   MCTargetStreamer &TS = *getTargetStreamer();
   1045   ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
   1046   ATS.finishAttributeSection();
   1047 
   1048   MCELFStreamer::FinishImpl();
   1049 }
   1050 
   1051 inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
   1052                                               unsigned Type,
   1053                                               unsigned Flags,
   1054                                               SectionKind Kind,
   1055                                               const MCSymbol &Fn) {
   1056   const MCSectionELF &FnSection =
   1057     static_cast<const MCSectionELF &>(Fn.getSection());
   1058 
   1059   // Create the name for new section
   1060   StringRef FnSecName(FnSection.getSectionName());
   1061   SmallString<128> EHSecName(Prefix);
   1062   if (FnSecName != ".text") {
   1063     EHSecName += FnSecName;
   1064   }
   1065 
   1066   // Get .ARM.extab or .ARM.exidx section
   1067   const MCSymbolELF *Group = FnSection.getGroup();
   1068   if (Group)
   1069     Flags |= ELF::SHF_GROUP;
   1070   MCSectionELF *EHSection =
   1071       getContext().getELFSection(EHSecName, Type, Flags, 0, Group,
   1072                                  FnSection.getUniqueID(), nullptr, &FnSection);
   1073 
   1074   assert(EHSection && "Failed to get the required EH section");
   1075 
   1076   // Switch to .ARM.extab or .ARM.exidx section
   1077   SwitchSection(EHSection);
   1078   EmitCodeAlignment(4);
   1079 }
   1080 
   1081 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
   1082   SwitchToEHSection(".ARM.extab", ELF::SHT_PROGBITS, ELF::SHF_ALLOC,
   1083                     SectionKind::getData(), FnStart);
   1084 }
   1085 
   1086 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
   1087   SwitchToEHSection(".ARM.exidx", ELF::SHT_ARM_EXIDX,
   1088                     ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
   1089                     SectionKind::getData(), FnStart);
   1090 }
   1091 void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
   1092   MCDataFragment *Frag = getOrCreateDataFragment();
   1093   Frag->getFixups().push_back(MCFixup::create(Frag->getContents().size(), Expr,
   1094                                               Kind));
   1095 }
   1096 
   1097 void ARMELFStreamer::Reset() {
   1098   ExTab = nullptr;
   1099   FnStart = nullptr;
   1100   Personality = nullptr;
   1101   PersonalityIndex = ARM::EHABI::NUM_PERSONALITY_INDEX;
   1102   FPReg = ARM::SP;
   1103   FPOffset = 0;
   1104   SPOffset = 0;
   1105   PendingOffset = 0;
   1106   UsedFP = false;
   1107   CantUnwind = false;
   1108 
   1109   Opcodes.clear();
   1110   UnwindOpAsm.Reset();
   1111 }
   1112 
   1113 void ARMELFStreamer::emitFnStart() {
   1114   assert(FnStart == nullptr);
   1115   FnStart = getContext().createTempSymbol();
   1116   EmitLabel(FnStart);
   1117 }
   1118 
   1119 void ARMELFStreamer::emitFnEnd() {
   1120   assert(FnStart && ".fnstart must precedes .fnend");
   1121 
   1122   // Emit unwind opcodes if there is no .handlerdata directive
   1123   if (!ExTab && !CantUnwind)
   1124     FlushUnwindOpcodes(true);
   1125 
   1126   // Emit the exception index table entry
   1127   SwitchToExIdxSection(*FnStart);
   1128 
   1129   if (PersonalityIndex < ARM::EHABI::NUM_PERSONALITY_INDEX)
   1130     EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
   1131 
   1132   const MCSymbolRefExpr *FnStartRef =
   1133     MCSymbolRefExpr::create(FnStart,
   1134                             MCSymbolRefExpr::VK_ARM_PREL31,
   1135                             getContext());
   1136 
   1137   EmitValue(FnStartRef, 4);
   1138 
   1139   if (CantUnwind) {
   1140     EmitIntValue(ARM::EHABI::EXIDX_CANTUNWIND, 4);
   1141   } else if (ExTab) {
   1142     // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
   1143     const MCSymbolRefExpr *ExTabEntryRef =
   1144       MCSymbolRefExpr::create(ExTab,
   1145                               MCSymbolRefExpr::VK_ARM_PREL31,
   1146                               getContext());
   1147     EmitValue(ExTabEntryRef, 4);
   1148   } else {
   1149     // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
   1150     // the second word of exception index table entry.  The size of the unwind
   1151     // opcodes should always be 4 bytes.
   1152     assert(PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0 &&
   1153            "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
   1154     assert(Opcodes.size() == 4u &&
   1155            "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
   1156     uint64_t Intval = Opcodes[0] |
   1157                       Opcodes[1] << 8 |
   1158                       Opcodes[2] << 16 |
   1159                       Opcodes[3] << 24;
   1160     EmitIntValue(Intval, Opcodes.size());
   1161   }
   1162 
   1163   // Switch to the section containing FnStart
   1164   SwitchSection(&FnStart->getSection());
   1165 
   1166   // Clean exception handling frame information
   1167   Reset();
   1168 }
   1169 
   1170 void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
   1171 
   1172 // Add the R_ARM_NONE fixup at the same position
   1173 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
   1174   const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(Name);
   1175 
   1176   const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::create(
   1177       PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
   1178 
   1179   visitUsedExpr(*PersonalityRef);
   1180   MCDataFragment *DF = getOrCreateDataFragment();
   1181   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
   1182                                             PersonalityRef,
   1183                                             MCFixup::getKindForSize(4, false)));
   1184 }
   1185 
   1186 void ARMELFStreamer::FlushPendingOffset() {
   1187   if (PendingOffset != 0) {
   1188     UnwindOpAsm.EmitSPOffset(-PendingOffset);
   1189     PendingOffset = 0;
   1190   }
   1191 }
   1192 
   1193 void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) {
   1194   // Emit the unwind opcode to restore $sp.
   1195   if (UsedFP) {
   1196     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
   1197     int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
   1198     UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
   1199     UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
   1200   } else {
   1201     FlushPendingOffset();
   1202   }
   1203 
   1204   // Finalize the unwind opcode sequence
   1205   UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
   1206 
   1207   // For compact model 0, we have to emit the unwind opcodes in the .ARM.exidx
   1208   // section.  Thus, we don't have to create an entry in the .ARM.extab
   1209   // section.
   1210   if (NoHandlerData && PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0)
   1211     return;
   1212 
   1213   // Switch to .ARM.extab section.
   1214   SwitchToExTabSection(*FnStart);
   1215 
   1216   // Create .ARM.extab label for offset in .ARM.exidx
   1217   assert(!ExTab);
   1218   ExTab = getContext().createTempSymbol();
   1219   EmitLabel(ExTab);
   1220 
   1221   // Emit personality
   1222   if (Personality) {
   1223     const MCSymbolRefExpr *PersonalityRef =
   1224       MCSymbolRefExpr::create(Personality,
   1225                               MCSymbolRefExpr::VK_ARM_PREL31,
   1226                               getContext());
   1227 
   1228     EmitValue(PersonalityRef, 4);
   1229   }
   1230 
   1231   // Emit unwind opcodes
   1232   assert((Opcodes.size() % 4) == 0 &&
   1233          "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
   1234   for (unsigned I = 0; I != Opcodes.size(); I += 4) {
   1235     uint64_t Intval = Opcodes[I] |
   1236                       Opcodes[I + 1] << 8 |
   1237                       Opcodes[I + 2] << 16 |
   1238                       Opcodes[I + 3] << 24;
   1239     EmitIntValue(Intval, 4);
   1240   }
   1241 
   1242   // According to ARM EHABI section 9.2, if the __aeabi_unwind_cpp_pr1() or
   1243   // __aeabi_unwind_cpp_pr2() is used, then the handler data must be emitted
   1244   // after the unwind opcodes.  The handler data consists of several 32-bit
   1245   // words, and should be terminated by zero.
   1246   //
   1247   // In case that the .handlerdata directive is not specified by the
   1248   // programmer, we should emit zero to terminate the handler data.
   1249   if (NoHandlerData && !Personality)
   1250     EmitIntValue(0, 4);
   1251 }
   1252 
   1253 void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(false); }
   1254 
   1255 void ARMELFStreamer::emitPersonality(const MCSymbol *Per) {
   1256   Personality = Per;
   1257   UnwindOpAsm.setPersonality(Per);
   1258 }
   1259 
   1260 void ARMELFStreamer::emitPersonalityIndex(unsigned Index) {
   1261   assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX && "invalid index");
   1262   PersonalityIndex = Index;
   1263 }
   1264 
   1265 void ARMELFStreamer::emitSetFP(unsigned NewFPReg, unsigned NewSPReg,
   1266                                int64_t Offset) {
   1267   assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
   1268          "the operand of .setfp directive should be either $sp or $fp");
   1269 
   1270   UsedFP = true;
   1271   FPReg = NewFPReg;
   1272 
   1273   if (NewSPReg == ARM::SP)
   1274     FPOffset = SPOffset + Offset;
   1275   else
   1276     FPOffset += Offset;
   1277 }
   1278 
   1279 void ARMELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
   1280   assert((Reg != ARM::SP && Reg != ARM::PC) &&
   1281          "the operand of .movsp cannot be either sp or pc");
   1282   assert(FPReg == ARM::SP && "current FP must be SP");
   1283 
   1284   FlushPendingOffset();
   1285 
   1286   FPReg = Reg;
   1287   FPOffset = SPOffset + Offset;
   1288 
   1289   const MCRegisterInfo *MRI = getContext().getRegisterInfo();
   1290   UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
   1291 }
   1292 
   1293 void ARMELFStreamer::emitPad(int64_t Offset) {
   1294   // Track the change of the $sp offset
   1295   SPOffset -= Offset;
   1296 
   1297   // To squash multiple .pad directives, we should delay the unwind opcode
   1298   // until the .save, .vsave, .handlerdata, or .fnend directives.
   1299   PendingOffset -= Offset;
   1300 }
   1301 
   1302 void ARMELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
   1303                                  bool IsVector) {
   1304   // Collect the registers in the register list
   1305   unsigned Count = 0;
   1306   uint32_t Mask = 0;
   1307   const MCRegisterInfo *MRI = getContext().getRegisterInfo();
   1308   for (size_t i = 0; i < RegList.size(); ++i) {
   1309     unsigned Reg = MRI->getEncodingValue(RegList[i]);
   1310     assert(Reg < (IsVector ? 32U : 16U) && "Register out of range");
   1311     unsigned Bit = (1u << Reg);
   1312     if ((Mask & Bit) == 0) {
   1313       Mask |= Bit;
   1314       ++Count;
   1315     }
   1316   }
   1317 
   1318   // Track the change the $sp offset: For the .save directive, the
   1319   // corresponding push instruction will decrease the $sp by (4 * Count).
   1320   // For the .vsave directive, the corresponding vpush instruction will
   1321   // decrease $sp by (8 * Count).
   1322   SPOffset -= Count * (IsVector ? 8 : 4);
   1323 
   1324   // Emit the opcode
   1325   FlushPendingOffset();
   1326   if (IsVector)
   1327     UnwindOpAsm.EmitVFPRegSave(Mask);
   1328   else
   1329     UnwindOpAsm.EmitRegSave(Mask);
   1330 }
   1331 
   1332 void ARMELFStreamer::emitUnwindRaw(int64_t Offset,
   1333                                    const SmallVectorImpl<uint8_t> &Opcodes) {
   1334   FlushPendingOffset();
   1335   SPOffset = SPOffset - Offset;
   1336   UnwindOpAsm.EmitRaw(Opcodes);
   1337 }
   1338 
   1339 namespace llvm {
   1340 
   1341 MCTargetStreamer *createARMTargetAsmStreamer(MCStreamer &S,
   1342                                              formatted_raw_ostream &OS,
   1343                                              MCInstPrinter *InstPrint,
   1344                                              bool isVerboseAsm) {
   1345   return new ARMTargetAsmStreamer(S, OS, *InstPrint, isVerboseAsm);
   1346 }
   1347 
   1348 MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S) {
   1349   return new ARMTargetStreamer(S);
   1350 }
   1351 
   1352 MCTargetStreamer *createARMObjectTargetStreamer(MCStreamer &S,
   1353                                                 const MCSubtargetInfo &STI) {
   1354   const Triple &TT = STI.getTargetTriple();
   1355   if (TT.isOSBinFormatELF())
   1356     return new ARMTargetELFStreamer(S);
   1357   return new ARMTargetStreamer(S);
   1358 }
   1359 
   1360 MCELFStreamer *createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
   1361                                     raw_pwrite_stream &OS,
   1362                                     MCCodeEmitter *Emitter, bool RelaxAll,
   1363                                     bool IsThumb) {
   1364     ARMELFStreamer *S = new ARMELFStreamer(Context, TAB, OS, Emitter, IsThumb);
   1365     // FIXME: This should eventually end up somewhere else where more
   1366     // intelligent flag decisions can be made. For now we are just maintaining
   1367     // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.
   1368     S->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
   1369 
   1370     if (RelaxAll)
   1371       S->getAssembler().setRelaxAll(true);
   1372     return S;
   1373   }
   1374 
   1375 }
   1376 
   1377 
   1378