lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

   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 "ARMUnwindOp.h"
  18 #include "ARMUnwindOpAsm.h"
  19 #include "llvm/ADT/SmallPtrSet.h"
  20 #include "llvm/ADT/Twine.h"
  21 #include "llvm/MC/MCAsmBackend.h"
  22 #include "llvm/MC/MCAssembler.h"
  23 #include "llvm/MC/MCCodeEmitter.h"
  24 #include "llvm/MC/MCContext.h"
  25 #include "llvm/MC/MCELF.h"
  26 #include "llvm/MC/MCELFStreamer.h"
  27 #include "llvm/MC/MCELFSymbolFlags.h"
  28 #include "llvm/MC/MCExpr.h"
  29 #include "llvm/MC/MCInst.h"
  30 #include "llvm/MC/MCInstPrinter.h"
  31 #include "llvm/MC/MCObjectStreamer.h"
  32 #include "llvm/MC/MCRegisterInfo.h"
  33 #include "llvm/MC/MCSection.h"
  34 #include "llvm/MC/MCSectionELF.h"
  35 #include "llvm/MC/MCStreamer.h"
  36 #include "llvm/MC/MCSymbol.h"
  37 #include "llvm/MC/MCValue.h"
  38 #include "llvm/Support/Debug.h"
  39 #include "llvm/Support/ELF.h"
  40 #include "llvm/Support/FormattedStream.h"
  41 #include "llvm/Support/raw_ostream.h"
  42
  43 using namespace llvm;
  44
  45 static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
  46   assert(Index < NUM_PERSONALITY_INDEX && "Invalid personality index");
  47   return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
  48 }
  49
  50 namespace {
  51
  52 class ARMELFStreamer;
  53
  54 class ARMTargetAsmStreamer : public ARMTargetStreamer {
  55   formatted_raw_ostream &OS;
  56   MCInstPrinter &InstPrinter;
  57
  58   virtual void emitFnStart();
  59   virtual void emitFnEnd();
  60   virtual void emitCantUnwind();
  61   virtual void emitPersonality(const MCSymbol *Personality);
  62   virtual void emitHandlerData();
  63   virtual void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0);
  64   virtual void emitPad(int64_t Offset);
  65   virtual void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
  66                            bool isVector);
  67
  68 public:
  69   ARMTargetAsmStreamer(formatted_raw_ostream &OS, MCInstPrinter &InstPrinter);
  70 };
  71
  72 ARMTargetAsmStreamer::ARMTargetAsmStreamer(formatted_raw_ostream &OS,
  73                                            MCInstPrinter &InstPrinter)
  74     : OS(OS), InstPrinter(InstPrinter) {}
  75 void ARMTargetAsmStreamer::emitFnStart() { OS << "\t.fnstart\n"; }
  76 void ARMTargetAsmStreamer::emitFnEnd() { OS << "\t.fnend\n"; }
  77 void ARMTargetAsmStreamer::emitCantUnwind() { OS << "\t.cantunwind\n"; }
  78 void ARMTargetAsmStreamer::emitPersonality(const MCSymbol *Personality) {
  79   OS << "\t.personality " << Personality->getName() << '\n';
  80 }
  81 void ARMTargetAsmStreamer::emitHandlerData() { OS << "\t.handlerdata\n"; }
  82 void ARMTargetAsmStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
  83                                      int64_t Offset) {
  84   OS << "\t.setfp\t";
  85   InstPrinter.printRegName(OS, FpReg);
  86   OS << ", ";
  87   InstPrinter.printRegName(OS, SpReg);
  88   if (Offset)
  89     OS << ", #" << Offset;
  90   OS << '\n';
  91 }
  92 void ARMTargetAsmStreamer::emitPad(int64_t Offset) {
  93   OS << "\t.pad\t#" << Offset << '\n';
  94 }
  95 void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
  96                                        bool isVector) {
  97   assert(RegList.size() && "RegList should not be empty");
  98   if (isVector)
  99     OS << "\t.vsave\t{";
 100   else
 101     OS << "\t.save\t{";
 102
 103   InstPrinter.printRegName(OS, RegList[0]);
 104
 105   for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
 106     OS << ", ";
 107     InstPrinter.printRegName(OS, RegList[i]);
 108   }
 109
 110   OS << "}\n";
 111 }
 112
 113 class ARMTargetELFStreamer : public ARMTargetStreamer {
 114   ARMELFStreamer &getStreamer();
 115   virtual void emitFnStart();
 116   virtual void emitFnEnd();
 117   virtual void emitCantUnwind();
 118   virtual void emitPersonality(const MCSymbol *Personality);
 119   virtual void emitHandlerData();
 120   virtual void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0);
 121   virtual void emitPad(int64_t Offset);
 122   virtual void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
 123                            bool isVector);
 124 };
 125
 126 /// Extend the generic ELFStreamer class so that it can emit mapping symbols at
 127 /// the appropriate points in the object files. These symbols are defined in the
 128 /// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
 129 ///
 130 /// In brief: $a, $t or $d should be emitted at the start of each contiguous
 131 /// region of ARM code, Thumb code or data in a section. In practice, this
 132 /// emission does not rely on explicit assembler directives but on inherent
 133 /// properties of the directives doing the emission (e.g. ".byte" is data, "add
 134 /// r0, r0, r0" an instruction).
 135 ///
 136 /// As a result this system is orthogonal to the DataRegion infrastructure used
 137 /// by MachO. Beware!
 138 class ARMELFStreamer : public MCELFStreamer {
 139 public:
 140   friend class ARMTargetELFStreamer;
 141
 142   ARMELFStreamer(MCContext &Context, MCTargetStreamer *TargetStreamer,
 143                  MCAsmBackend &TAB, raw_ostream &OS, MCCodeEmitter *Emitter,
 144                  bool IsThumb)
 145       : MCELFStreamer(Context, TargetStreamer, TAB, OS, Emitter),
 146         IsThumb(IsThumb), MappingSymbolCounter(0), LastEMS(EMS_None) {
 147     Reset();
 148   }
 149
 150   ~ARMELFStreamer() {}
 151
 152   // ARM exception handling directives
 153   void emitFnStart();
 154   void emitFnEnd();
 155   void emitCantUnwind();
 156   void emitPersonality(const MCSymbol *Per);
 157   void emitHandlerData();
 158   void emitSetFP(unsigned NewFpReg, unsigned NewSpReg, int64_t Offset = 0);
 159   void emitPad(int64_t Offset);
 160   void emitRegSave(const SmallVectorImpl<unsigned> &RegList, bool isVector);
 161
 162   virtual void ChangeSection(const MCSection *Section,
 163                              const MCExpr *Subsection) {
 164     // We have to keep track of the mapping symbol state of any sections we
 165     // use. Each one should start off as EMS_None, which is provided as the
 166     // default constructor by DenseMap::lookup.
 167     LastMappingSymbols[getPreviousSection().first] = LastEMS;
 168     LastEMS = LastMappingSymbols.lookup(Section);
 169
 170     MCELFStreamer::ChangeSection(Section, Subsection);
 171   }
 172
 173   /// This function is the one used to emit instruction data into the ELF
 174   /// streamer. We override it to add the appropriate mapping symbol if
 175   /// necessary.
 176   virtual void EmitInstruction(const MCInst& Inst) {
 177     if (IsThumb)
 178       EmitThumbMappingSymbol();
 179     else
 180       EmitARMMappingSymbol();
 181
 182     MCELFStreamer::EmitInstruction(Inst);
 183   }
 184
 185   /// This is one of the functions used to emit data into an ELF section, so the
 186   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
 187   /// necessary.
 188   virtual void EmitBytes(StringRef Data) {
 189     EmitDataMappingSymbol();
 190     MCELFStreamer::EmitBytes(Data);
 191   }
 192
 193   /// This is one of the functions used to emit data into an ELF section, so the
 194   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
 195   /// necessary.
 196   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size) {
 197     EmitDataMappingSymbol();
 198     MCELFStreamer::EmitValueImpl(Value, Size);
 199   }
 200
 201   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {
 202     MCELFStreamer::EmitAssemblerFlag(Flag);
 203
 204     switch (Flag) {
 205     case MCAF_SyntaxUnified:
 206       return; // no-op here.
 207     case MCAF_Code16:
 208       IsThumb = true;
 209       return; // Change to Thumb mode
 210     case MCAF_Code32:
 211       IsThumb = false;
 212       return; // Change to ARM mode
 213     case MCAF_Code64:
 214       return;
 215     case MCAF_SubsectionsViaSymbols:
 216       return;
 217     }
 218   }
 219
 220 private:
 221   enum ElfMappingSymbol {
 222     EMS_None,
 223     EMS_ARM,
 224     EMS_Thumb,
 225     EMS_Data
 226   };
 227
 228   void EmitDataMappingSymbol() {
 229     if (LastEMS == EMS_Data) return;
 230     EmitMappingSymbol("$d");
 231     LastEMS = EMS_Data;
 232   }
 233
 234   void EmitThumbMappingSymbol() {
 235     if (LastEMS == EMS_Thumb) return;
 236     EmitMappingSymbol("$t");
 237     LastEMS = EMS_Thumb;
 238   }
 239
 240   void EmitARMMappingSymbol() {
 241     if (LastEMS == EMS_ARM) return;
 242     EmitMappingSymbol("$a");
 243     LastEMS = EMS_ARM;
 244   }
 245
 246   void EmitMappingSymbol(StringRef Name) {
 247     MCSymbol *Start = getContext().CreateTempSymbol();
 248     EmitLabel(Start);
 249
 250     MCSymbol *Symbol =
 251       getContext().GetOrCreateSymbol(Name + "." +
 252                                      Twine(MappingSymbolCounter++));
 253
 254     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 255     MCELF::SetType(SD, ELF::STT_NOTYPE);
 256     MCELF::SetBinding(SD, ELF::STB_LOCAL);
 257     SD.setExternal(false);
 258     AssignSection(Symbol, getCurrentSection().first);
 259
 260     const MCExpr *Value = MCSymbolRefExpr::Create(Start, getContext());
 261     Symbol->setVariableValue(Value);
 262   }
 263
 264   void EmitThumbFunc(MCSymbol *Func) {
 265     // FIXME: Anything needed here to flag the function as thumb?
 266
 267     getAssembler().setIsThumbFunc(Func);
 268
 269     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Func);
 270     SD.setFlags(SD.getFlags() | ELF_Other_ThumbFunc);
 271   }
 272
 273   // Helper functions for ARM exception handling directives
 274   void Reset();
 275
 276   void EmitPersonalityFixup(StringRef Name);
 277   void FlushPendingOffset();
 278   void FlushUnwindOpcodes(bool NoHandlerData);
 279
 280   void SwitchToEHSection(const char *Prefix, unsigned Type, unsigned Flags,
 281                          SectionKind Kind, const MCSymbol &Fn);
 282   void SwitchToExTabSection(const MCSymbol &FnStart);
 283   void SwitchToExIdxSection(const MCSymbol &FnStart);
 284
 285   bool IsThumb;
 286   int64_t MappingSymbolCounter;
 287
 288   DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
 289   ElfMappingSymbol LastEMS;
 290
 291   // ARM Exception Handling Frame Information
 292   MCSymbol *ExTab;
 293   MCSymbol *FnStart;
 294   const MCSymbol *Personality;
 295   unsigned PersonalityIndex;
 296   unsigned FPReg; // Frame pointer register
 297   int64_t FPOffset; // Offset: (final frame pointer) - (initial $sp)
 298   int64_t SPOffset; // Offset: (final $sp) - (initial $sp)
 299   int64_t PendingOffset; // Offset: (final $sp) - (emitted $sp)
 300   bool UsedFP;
 301   bool CantUnwind;
 302   SmallVector<uint8_t, 64> Opcodes;
 303   UnwindOpcodeAssembler UnwindOpAsm;
 304 };
 305 } // end anonymous namespace
 306
 307 ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
 308   ARMELFStreamer *S = static_cast<ARMELFStreamer *>(Streamer);
 309   return *S;
 310 }
 311
 312 void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
 313 void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
 314 void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
 315 void ARMTargetELFStreamer::emitPersonality(const MCSymbol *Personality) {
 316   getStreamer().emitPersonality(Personality);
 317 }
 318 void ARMTargetELFStreamer::emitHandlerData() {
 319   getStreamer().emitHandlerData();
 320 }
 321 void ARMTargetELFStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
 322                                      int64_t Offset) {
 323   getStreamer().emitSetFP(FpReg, SpReg, Offset);
 324 }
 325 void ARMTargetELFStreamer::emitPad(int64_t Offset) {
 326   getStreamer().emitPad(Offset);
 327 }
 328 void ARMTargetELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
 329                                        bool isVector) {
 330   getStreamer().emitRegSave(RegList, isVector);
 331 }
 332
 333 inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
 334                                               unsigned Type,
 335                                               unsigned Flags,
 336                                               SectionKind Kind,
 337                                               const MCSymbol &Fn) {
 338   const MCSectionELF &FnSection =
 339     static_cast<const MCSectionELF &>(Fn.getSection());
 340
 341   // Create the name for new section
 342   StringRef FnSecName(FnSection.getSectionName());
 343   SmallString<128> EHSecName(Prefix);
 344   if (FnSecName != ".text") {
 345     EHSecName += FnSecName;
 346   }
 347
 348   // Get .ARM.extab or .ARM.exidx section
 349   const MCSectionELF *EHSection = NULL;
 350   if (const MCSymbol *Group = FnSection.getGroup()) {
 351     EHSection = getContext().getELFSection(
 352       EHSecName, Type, Flags | ELF::SHF_GROUP, Kind,
 353       FnSection.getEntrySize(), Group->getName());
 354   } else {
 355     EHSection = getContext().getELFSection(EHSecName, Type, Flags, Kind);
 356   }
 357   assert(EHSection && "Failed to get the required EH section");
 358
 359   // Switch to .ARM.extab or .ARM.exidx section
 360   SwitchSection(EHSection);
 361   EmitCodeAlignment(4, 0);
 362 }
 363
 364 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
 365   SwitchToEHSection(".ARM.extab",
 366                     ELF::SHT_PROGBITS,
 367                     ELF::SHF_ALLOC,
 368                     SectionKind::getDataRel(),
 369                     FnStart);
 370 }
 371
 372 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
 373   SwitchToEHSection(".ARM.exidx",
 374                     ELF::SHT_ARM_EXIDX,
 375                     ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
 376                     SectionKind::getDataRel(),
 377                     FnStart);
 378 }
 379
 380 void ARMELFStreamer::Reset() {
 381   ExTab = NULL;
 382   FnStart = NULL;
 383   Personality = NULL;
 384   PersonalityIndex = NUM_PERSONALITY_INDEX;
 385   FPReg = ARM::SP;
 386   FPOffset = 0;
 387   SPOffset = 0;
 388   PendingOffset = 0;
 389   UsedFP = false;
 390   CantUnwind = false;
 391
 392   Opcodes.clear();
 393   UnwindOpAsm.Reset();
 394 }
 395
 396 void ARMELFStreamer::emitFnStart() {
 397   assert(FnStart == 0);
 398   FnStart = getContext().CreateTempSymbol();
 399   EmitLabel(FnStart);
 400 }
 401
 402 void ARMELFStreamer::emitFnEnd() {
 403   assert(FnStart && ".fnstart must preceeds .fnend");
 404
 405   // Emit unwind opcodes if there is no .handlerdata directive
 406   if (!ExTab && !CantUnwind)
 407     FlushUnwindOpcodes(true);
 408
 409   // Emit the exception index table entry
 410   SwitchToExIdxSection(*FnStart);
 411
 412   if (PersonalityIndex < NUM_PERSONALITY_INDEX)
 413     EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
 414
 415   const MCSymbolRefExpr *FnStartRef =
 416     MCSymbolRefExpr::Create(FnStart,
 417                             MCSymbolRefExpr::VK_ARM_PREL31,
 418                             getContext());
 419
 420   EmitValue(FnStartRef, 4);
 421
 422   if (CantUnwind) {
 423     EmitIntValue(EXIDX_CANTUNWIND, 4);
 424   } else if (ExTab) {
 425     // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
 426     const MCSymbolRefExpr *ExTabEntryRef =
 427       MCSymbolRefExpr::Create(ExTab,
 428                               MCSymbolRefExpr::VK_ARM_PREL31,
 429                               getContext());
 430     EmitValue(ExTabEntryRef, 4);
 431   } else {
 432     // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
 433     // the second word of exception index table entry.  The size of the unwind
 434     // opcodes should always be 4 bytes.
 435     assert(PersonalityIndex == AEABI_UNWIND_CPP_PR0 &&
 436            "Compact model must use __aeabi_cpp_unwind_pr0 as personality");
 437     assert(Opcodes.size() == 4u &&
 438            "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be equal to 4");
 439     EmitBytes(StringRef(reinterpret_cast<const char*>(Opcodes.data()),
 440                         Opcodes.size()));
 441   }
 442
 443   // Switch to the section containing FnStart
 444   SwitchSection(&FnStart->getSection());
 445
 446   // Clean exception handling frame information
 447   Reset();
 448 }
 449
 450 void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
 451
 452 // Add the R_ARM_NONE fixup at the same position
 453 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
 454   const MCSymbol *PersonalitySym = getContext().GetOrCreateSymbol(Name);
 455
 456   const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::Create(
 457       PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
 458
 459   AddValueSymbols(PersonalityRef);
 460   MCDataFragment *DF = getOrCreateDataFragment();
 461   DF->getFixups().push_back(MCFixup::Create(DF->getContents().size(),
 462                                             PersonalityRef,
 463                                             MCFixup::getKindForSize(4, false)));
 464 }
 465
 466 void ARMELFStreamer::FlushPendingOffset() {
 467   if (PendingOffset != 0) {
 468     UnwindOpAsm.EmitSPOffset(-PendingOffset);
 469     PendingOffset = 0;
 470   }
 471 }
 472
 473 void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) {
 474   // Emit the unwind opcode to restore $sp.
 475   if (UsedFP) {
 476     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
 477     int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
 478     UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
 479     UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
 480   } else {
 481     FlushPendingOffset();
 482   }
 483
 484   // Finalize the unwind opcode sequence
 485   UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
 486
 487   // For compact model 0, we have to emit the unwind opcodes in the .ARM.exidx
 488   // section.  Thus, we don't have to create an entry in the .ARM.extab
 489   // section.
 490   if (NoHandlerData && PersonalityIndex == AEABI_UNWIND_CPP_PR0)
 491     return;
 492
 493   // Switch to .ARM.extab section.
 494   SwitchToExTabSection(*FnStart);
 495
 496   // Create .ARM.extab label for offset in .ARM.exidx
 497   assert(!ExTab);
 498   ExTab = getContext().CreateTempSymbol();
 499   EmitLabel(ExTab);
 500
 501   // Emit personality
 502   if (Personality) {
 503     const MCSymbolRefExpr *PersonalityRef =
 504       MCSymbolRefExpr::Create(Personality,
 505                               MCSymbolRefExpr::VK_ARM_PREL31,
 506                               getContext());
 507
 508     EmitValue(PersonalityRef, 4);
 509   }
 510
 511   // Emit unwind opcodes
 512   EmitBytes(StringRef(reinterpret_cast<const char *>(Opcodes.data()),
 513                       Opcodes.size()));
 514
 515   // According to ARM EHABI section 9.2, if the __aeabi_unwind_cpp_pr1() or
 516   // __aeabi_unwind_cpp_pr2() is used, then the handler data must be emitted
 517   // after the unwind opcodes.  The handler data consists of several 32-bit
 518   // words, and should be terminated by zero.
 519   //
 520   // In case that the .handlerdata directive is not specified by the
 521   // programmer, we should emit zero to terminate the handler data.
 522   if (NoHandlerData && !Personality)
 523     EmitIntValue(0, 4);
 524 }
 525
 526 void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(false); }
 527
 528 void ARMELFStreamer::emitPersonality(const MCSymbol *Per) {
 529   Personality = Per;
 530   UnwindOpAsm.setPersonality(Per);
 531 }
 532
 533 void ARMELFStreamer::emitSetFP(unsigned NewFPReg, unsigned NewSPReg,
 534                                int64_t Offset) {
 535   assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
 536          "the operand of .setfp directive should be either $sp or $fp");
 537
 538   UsedFP = true;
 539   FPReg = NewFPReg;
 540
 541   if (NewSPReg == ARM::SP)
 542     FPOffset = SPOffset + Offset;
 543   else
 544     FPOffset += Offset;
 545 }
 546
 547 void ARMELFStreamer::emitPad(int64_t Offset) {
 548   // Track the change of the $sp offset
 549   SPOffset -= Offset;
 550
 551   // To squash multiple .pad directives, we should delay the unwind opcode
 552   // until the .save, .vsave, .handlerdata, or .fnend directives.
 553   PendingOffset -= Offset;
 554 }
 555
 556 void ARMELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
 557                                  bool IsVector) {
 558   // Collect the registers in the register list
 559   unsigned Count = 0;
 560   uint32_t Mask = 0;
 561   const MCRegisterInfo *MRI = getContext().getRegisterInfo();
 562   for (size_t i = 0; i < RegList.size(); ++i) {
 563     unsigned Reg = MRI->getEncodingValue(RegList[i]);
 564     assert(Reg < (IsVector ? 32U : 16U) && "Register out of range");
 565     unsigned Bit = (1u << Reg);
 566     if ((Mask & Bit) == 0) {
 567       Mask |= Bit;
 568       ++Count;
 569     }
 570   }
 571
 572   // Track the change the $sp offset: For the .save directive, the
 573   // corresponding push instruction will decrease the $sp by (4 * Count).
 574   // For the .vsave directive, the corresponding vpush instruction will
 575   // decrease $sp by (8 * Count).
 576   SPOffset -= Count * (IsVector ? 8 : 4);
 577
 578   // Emit the opcode
 579   FlushPendingOffset();
 580   if (IsVector)
 581     UnwindOpAsm.EmitVFPRegSave(Mask);
 582   else
 583     UnwindOpAsm.EmitRegSave(Mask);
 584 }
 585
 586 namespace llvm {
 587
 588 MCStreamer *createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
 589                                 bool isVerboseAsm, bool useLoc, bool useCFI,
 590                                 bool useDwarfDirectory,
 591                                 MCInstPrinter *InstPrint, MCCodeEmitter *CE,
 592                                 MCAsmBackend *TAB, bool ShowInst) {
 593   ARMTargetAsmStreamer *S = new ARMTargetAsmStreamer(OS, *InstPrint);
 594
 595   return llvm::createAsmStreamer(Ctx, S, OS, isVerboseAsm, useLoc, useCFI,
 596                                  useDwarfDirectory, InstPrint, CE, TAB,
 597                                  ShowInst);
 598 }
 599
 600   MCELFStreamer* createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
 601                                       raw_ostream &OS, MCCodeEmitter *Emitter,
 602                                       bool RelaxAll, bool NoExecStack,
 603                                       bool IsThumb) {
 604     ARMTargetELFStreamer *TS = new ARMTargetELFStreamer();
 605     ARMELFStreamer *S =
 606         new ARMELFStreamer(Context, TS, TAB, OS, Emitter, IsThumb);
 607     // FIXME: This should eventually end up somewhere else where more
 608     // intelligent flag decisions can be made. For now we are just maintaining
 609     // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.
 610     S->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
 611
 612     if (RelaxAll)
 613       S->getAssembler().setRelaxAll(true);
 614     if (NoExecStack)
 615       S->getAssembler().setNoExecStack(true);
 616     return S;
 617   }
 618
 619 }
 620
 621