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/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/MCSymbol.h"
  36 #include "llvm/MC/MCValue.h"
  37 #include "llvm/Support/Debug.h"
  38 #include "llvm/Support/ELF.h"
  39 #include "llvm/Support/raw_ostream.h"
  40
  41 using namespace llvm;
  42
  43 static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
  44   assert(Index < NUM_PERSONALITY_INDEX && "Invalid personality index");
  45   return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
  46 }
  47
  48 namespace {
  49
  50 /// Extend the generic ELFStreamer class so that it can emit mapping symbols at
  51 /// the appropriate points in the object files. These symbols are defined in the
  52 /// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
  53 ///
  54 /// In brief: $a, $t or $d should be emitted at the start of each contiguous
  55 /// region of ARM code, Thumb code or data in a section. In practice, this
  56 /// emission does not rely on explicit assembler directives but on inherent
  57 /// properties of the directives doing the emission (e.g. ".byte" is data, "add
  58 /// r0, r0, r0" an instruction).
  59 ///
  60 /// As a result this system is orthogonal to the DataRegion infrastructure used
  61 /// by MachO. Beware!
  62 class ARMELFStreamer : public MCELFStreamer {
  63 public:
  64   ARMELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &OS,
  65                  MCCodeEmitter *Emitter, bool IsThumb)
  66       : MCELFStreamer(SK_ARMELFStreamer, Context, TAB, OS, Emitter),
  67         IsThumb(IsThumb), MappingSymbolCounter(0), LastEMS(EMS_None) {
  68     Reset();
  69   }
  70
  71   ~ARMELFStreamer() {}
  72
  73   // ARM exception handling directives
  74   virtual void EmitFnStart();
  75   virtual void EmitFnEnd();
  76   virtual void EmitCantUnwind();
  77   virtual void EmitPersonality(const MCSymbol *Per);
  78   virtual void EmitHandlerData();
  79   virtual void EmitSetFP(unsigned NewFpReg,
  80                          unsigned NewSpReg,
  81                          int64_t Offset = 0);
  82   virtual void EmitPad(int64_t Offset);
  83   virtual void EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
  84                            bool isVector);
  85
  86   virtual void ChangeSection(const MCSection *Section) {
  87     // We have to keep track of the mapping symbol state of any sections we
  88     // use. Each one should start off as EMS_None, which is provided as the
  89     // default constructor by DenseMap::lookup.
  90     LastMappingSymbols[getPreviousSection()] = LastEMS;
  91     LastEMS = LastMappingSymbols.lookup(Section);
  92
  93     MCELFStreamer::ChangeSection(Section);
  94   }
  95
  96   /// This function is the one used to emit instruction data into the ELF
  97   /// streamer. We override it to add the appropriate mapping symbol if
  98   /// necessary.
  99   virtual void EmitInstruction(const MCInst& Inst) {
 100     if (IsThumb)
 101       EmitThumbMappingSymbol();
 102     else
 103       EmitARMMappingSymbol();
 104
 105     MCELFStreamer::EmitInstruction(Inst);
 106   }
 107
 108   /// This is one of the functions used to emit data into an ELF section, so the
 109   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
 110   /// necessary.
 111   virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {
 112     EmitDataMappingSymbol();
 113     MCELFStreamer::EmitBytes(Data, AddrSpace);
 114   }
 115
 116   /// This is one of the functions used to emit data into an ELF section, so the
 117   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
 118   /// necessary.
 119   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
 120                              unsigned AddrSpace) {
 121     EmitDataMappingSymbol();
 122     MCELFStreamer::EmitValueImpl(Value, Size, AddrSpace);
 123   }
 124
 125   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {
 126     MCELFStreamer::EmitAssemblerFlag(Flag);
 127
 128     switch (Flag) {
 129     case MCAF_SyntaxUnified:
 130       return; // no-op here.
 131     case MCAF_Code16:
 132       IsThumb = true;
 133       return; // Change to Thumb mode
 134     case MCAF_Code32:
 135       IsThumb = false;
 136       return; // Change to ARM mode
 137     case MCAF_Code64:
 138       return;
 139     case MCAF_SubsectionsViaSymbols:
 140       return;
 141     }
 142   }
 143
 144   static bool classof(const MCStreamer *S) {
 145     return S->getKind() == SK_ARMELFStreamer;
 146   }
 147
 148 private:
 149   enum ElfMappingSymbol {
 150     EMS_None,
 151     EMS_ARM,
 152     EMS_Thumb,
 153     EMS_Data
 154   };
 155
 156   void EmitDataMappingSymbol() {
 157     if (LastEMS == EMS_Data) return;
 158     EmitMappingSymbol("$d");
 159     LastEMS = EMS_Data;
 160   }
 161
 162   void EmitThumbMappingSymbol() {
 163     if (LastEMS == EMS_Thumb) return;
 164     EmitMappingSymbol("$t");
 165     LastEMS = EMS_Thumb;
 166   }
 167
 168   void EmitARMMappingSymbol() {
 169     if (LastEMS == EMS_ARM) return;
 170     EmitMappingSymbol("$a");
 171     LastEMS = EMS_ARM;
 172   }
 173
 174   void EmitMappingSymbol(StringRef Name) {
 175     MCSymbol *Start = getContext().CreateTempSymbol();
 176     EmitLabel(Start);
 177
 178     MCSymbol *Symbol =
 179       getContext().GetOrCreateSymbol(Name + "." +
 180                                      Twine(MappingSymbolCounter++));
 181
 182     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 183     MCELF::SetType(SD, ELF::STT_NOTYPE);
 184     MCELF::SetBinding(SD, ELF::STB_LOCAL);
 185     SD.setExternal(false);
 186     Symbol->setSection(*getCurrentSection());
 187
 188     const MCExpr *Value = MCSymbolRefExpr::Create(Start, getContext());
 189     Symbol->setVariableValue(Value);
 190   }
 191
 192   void EmitThumbFunc(MCSymbol *Func) {
 193     // FIXME: Anything needed here to flag the function as thumb?
 194
 195     getAssembler().setIsThumbFunc(Func);
 196
 197     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Func);
 198     SD.setFlags(SD.getFlags() | ELF_Other_ThumbFunc);
 199   }
 200
 201   // Helper functions for ARM exception handling directives
 202   void Reset();
 203
 204   void EmitPersonalityFixup(StringRef Name);
 205   void CollectUnwindOpcodes();
 206
 207   void SwitchToEHSection(const char *Prefix, unsigned Type, unsigned Flags,
 208                          SectionKind Kind, const MCSymbol &Fn);
 209   void SwitchToExTabSection(const MCSymbol &FnStart);
 210   void SwitchToExIdxSection(const MCSymbol &FnStart);
 211
 212   bool IsThumb;
 213   int64_t MappingSymbolCounter;
 214
 215   DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
 216   ElfMappingSymbol LastEMS;
 217
 218   // ARM Exception Handling Frame Information
 219   MCSymbol *ExTab;
 220   MCSymbol *FnStart;
 221   const MCSymbol *Personality;
 222   uint32_t VFPRegSave; // Register mask for {d31-d0}
 223   uint32_t RegSave; // Register mask for {r15-r0}
 224   int64_t SPOffset;
 225   uint16_t FPReg;
 226   int64_t FPOffset;
 227   bool UsedFP;
 228   bool CantUnwind;
 229   UnwindOpcodeAssembler UnwindOpAsm;
 230 };
 231 } // end anonymous namespace
 232
 233 inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
 234                                               unsigned Type,
 235                                               unsigned Flags,
 236                                               SectionKind Kind,
 237                                               const MCSymbol &Fn) {
 238   const MCSectionELF &FnSection =
 239     static_cast<const MCSectionELF &>(Fn.getSection());
 240
 241   // Create the name for new section
 242   StringRef FnSecName(FnSection.getSectionName());
 243   SmallString<128> EHSecName(Prefix);
 244   if (FnSecName != ".text") {
 245     EHSecName += FnSecName;
 246   }
 247
 248   // Get .ARM.extab or .ARM.exidx section
 249   const MCSectionELF *EHSection = NULL;
 250   if (const MCSymbol *Group = FnSection.getGroup()) {
 251     EHSection = getContext().getELFSection(
 252       EHSecName, Type, Flags | ELF::SHF_GROUP, Kind,
 253       FnSection.getEntrySize(), Group->getName());
 254   } else {
 255     EHSection = getContext().getELFSection(EHSecName, Type, Flags, Kind);
 256   }
 257   assert(EHSection && "Failed to get the required EH section");
 258
 259   // Switch to .ARM.extab or .ARM.exidx section
 260   SwitchSection(EHSection);
 261   EmitCodeAlignment(4, 0);
 262 }
 263
 264 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
 265   SwitchToEHSection(".ARM.extab",
 266                     ELF::SHT_PROGBITS,
 267                     ELF::SHF_ALLOC,
 268                     SectionKind::getDataRel(),
 269                     FnStart);
 270 }
 271
 272 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
 273   SwitchToEHSection(".ARM.exidx",
 274                     ELF::SHT_ARM_EXIDX,
 275                     ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
 276                     SectionKind::getDataRel(),
 277                     FnStart);
 278 }
 279
 280 void ARMELFStreamer::Reset() {
 281   const MCRegisterInfo &MRI = getContext().getRegisterInfo();
 282
 283   ExTab = NULL;
 284   FnStart = NULL;
 285   Personality = NULL;
 286   VFPRegSave = 0;
 287   RegSave = 0;
 288   FPReg = MRI.getEncodingValue(ARM::SP);
 289   FPOffset = 0;
 290   SPOffset = 0;
 291   UsedFP = false;
 292   CantUnwind = false;
 293
 294   UnwindOpAsm.Reset();
 295 }
 296
 297 // Add the R_ARM_NONE fixup at the same position
 298 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
 299   const MCSymbol *PersonalitySym = getContext().GetOrCreateSymbol(Name);
 300
 301   const MCSymbolRefExpr *PersonalityRef =
 302     MCSymbolRefExpr::Create(PersonalitySym,
 303                             MCSymbolRefExpr::VK_ARM_NONE,
 304                             getContext());
 305
 306   AddValueSymbols(PersonalityRef);
 307   MCDataFragment *DF = getOrCreateDataFragment();
 308   DF->getFixups().push_back(
 309     MCFixup::Create(DF->getContents().size(), PersonalityRef,
 310                     MCFixup::getKindForSize(4, false)));
 311 }
 312
 313 void ARMELFStreamer::CollectUnwindOpcodes() {
 314   if (UsedFP) {
 315     UnwindOpAsm.EmitSetFP(FPReg);
 316     UnwindOpAsm.EmitSPOffset(-FPOffset);
 317   } else {
 318     UnwindOpAsm.EmitSPOffset(SPOffset);
 319   }
 320   UnwindOpAsm.EmitVFPRegSave(VFPRegSave);
 321   UnwindOpAsm.EmitRegSave(RegSave);
 322   UnwindOpAsm.Finalize();
 323 }
 324
 325 void ARMELFStreamer::EmitFnStart() {
 326   assert(FnStart == 0);
 327   FnStart = getContext().CreateTempSymbol();
 328   EmitLabel(FnStart);
 329 }
 330
 331 void ARMELFStreamer::EmitFnEnd() {
 332   assert(FnStart && ".fnstart must preceeds .fnend");
 333
 334   // Emit unwind opcodes if there is no .handlerdata directive
 335   if (!ExTab && !CantUnwind) {
 336     CollectUnwindOpcodes();
 337
 338     unsigned PersonalityIndex = UnwindOpAsm.getPersonalityIndex();
 339     if (PersonalityIndex == AEABI_UNWIND_CPP_PR1 ||
 340         PersonalityIndex == AEABI_UNWIND_CPP_PR2) {
 341       // For the __aeabi_unwind_cpp_pr1 and __aeabi_unwind_cpp_pr2, we have to
 342       // emit the unwind opcodes in the corresponding ".ARM.extab" section, and
 343       // then emit a reference to these unwind opcodes in the second word of
 344       // the exception index table entry.
 345       SwitchToExTabSection(*FnStart);
 346       ExTab = getContext().CreateTempSymbol();
 347       EmitLabel(ExTab);
 348       EmitBytes(UnwindOpAsm.data(), 0);
 349     }
 350   }
 351
 352   // Emit the exception index table entry
 353   SwitchToExIdxSection(*FnStart);
 354
 355   unsigned PersonalityIndex = UnwindOpAsm.getPersonalityIndex();
 356   if (PersonalityIndex < NUM_PERSONALITY_INDEX)
 357     EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
 358
 359   const MCSymbolRefExpr *FnStartRef =
 360     MCSymbolRefExpr::Create(FnStart,
 361                             MCSymbolRefExpr::VK_ARM_PREL31,
 362                             getContext());
 363
 364   EmitValue(FnStartRef, 4, 0);
 365
 366   if (CantUnwind) {
 367     EmitIntValue(EXIDX_CANTUNWIND, 4, 0);
 368   } else if (ExTab) {
 369     // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
 370     const MCSymbolRefExpr *ExTabEntryRef =
 371       MCSymbolRefExpr::Create(ExTab,
 372                               MCSymbolRefExpr::VK_ARM_PREL31,
 373                               getContext());
 374     EmitValue(ExTabEntryRef, 4, 0);
 375   } else {
 376     // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
 377     // the second word of exception index table entry.  The size of the unwind
 378     // opcodes should always be 4 bytes.
 379     assert(PersonalityIndex == AEABI_UNWIND_CPP_PR0 &&
 380            "Compact model must use __aeabi_cpp_unwind_pr0 as personality");
 381     assert(UnwindOpAsm.size() == 4u &&
 382            "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be equal to 4");
 383     EmitBytes(UnwindOpAsm.data(), 0);
 384   }
 385
 386   // Clean exception handling frame information
 387   Reset();
 388 }
 389
 390 void ARMELFStreamer::EmitCantUnwind() {
 391   CantUnwind = true;
 392 }
 393
 394 void ARMELFStreamer::EmitHandlerData() {
 395   SwitchToExTabSection(*FnStart);
 396
 397   // Create .ARM.extab label for offset in .ARM.exidx
 398   assert(!ExTab);
 399   ExTab = getContext().CreateTempSymbol();
 400   EmitLabel(ExTab);
 401
 402   // Emit Personality
 403   assert(Personality && ".personality directive must preceed .handlerdata");
 404
 405   const MCSymbolRefExpr *PersonalityRef =
 406     MCSymbolRefExpr::Create(Personality,
 407                             MCSymbolRefExpr::VK_ARM_PREL31,
 408                             getContext());
 409
 410   EmitValue(PersonalityRef, 4, 0);
 411
 412   // Emit unwind opcodes
 413   CollectUnwindOpcodes();
 414   EmitBytes(UnwindOpAsm.data(), 0);
 415 }
 416
 417 void ARMELFStreamer::EmitPersonality(const MCSymbol *Per) {
 418   Personality = Per;
 419   UnwindOpAsm.setPersonality(Per);
 420 }
 421
 422 void ARMELFStreamer::EmitSetFP(unsigned NewFPReg,
 423                                unsigned NewSPReg,
 424                                int64_t Offset) {
 425   assert(SPOffset == 0 &&
 426          "Current implementation assumes .setfp precedes .pad");
 427
 428   const MCRegisterInfo &MRI = getContext().getRegisterInfo();
 429
 430   uint16_t NewFPRegEncVal = MRI.getEncodingValue(NewFPReg);
 431 #ifndef NDEBUG
 432   uint16_t NewSPRegEncVal = MRI.getEncodingValue(NewSPReg);
 433 #endif
 434
 435   assert((NewSPReg == ARM::SP || NewSPRegEncVal == FPReg) &&
 436          "the operand of .setfp directive should be either $sp or $fp");
 437
 438   UsedFP = true;
 439   FPReg = NewFPRegEncVal;
 440   FPOffset = Offset;
 441 }
 442
 443 void ARMELFStreamer::EmitPad(int64_t Offset) {
 444   SPOffset += Offset;
 445 }
 446
 447 void ARMELFStreamer::EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
 448                                  bool IsVector) {
 449   const MCRegisterInfo &MRI = getContext().getRegisterInfo();
 450
 451 #ifndef NDEBUG
 452   unsigned Max = IsVector ? 32 : 16;
 453 #endif
 454   uint32_t &RegMask = IsVector ? VFPRegSave : RegSave;
 455
 456   for (size_t i = 0; i < RegList.size(); ++i) {
 457     unsigned Reg = MRI.getEncodingValue(RegList[i]);
 458     assert(Reg < Max && "Register encoded value out of range");
 459     RegMask |= 1u << Reg;
 460   }
 461 }
 462
 463 namespace llvm {
 464   MCELFStreamer* createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
 465                                       raw_ostream &OS, MCCodeEmitter *Emitter,
 466                                       bool RelaxAll, bool NoExecStack,
 467                                       bool IsThumb) {
 468     ARMELFStreamer *S = new ARMELFStreamer(Context, TAB, OS, Emitter, IsThumb);
 469     if (RelaxAll)
 470       S->getAssembler().setRelaxAll(true);
 471     if (NoExecStack)
 472       S->getAssembler().setNoExecStack(true);
 473     return S;
 474   }
 475
 476 }
 477
 478