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 "ARMUnwindOp.h"
  17 #include "llvm/ADT/SmallPtrSet.h"
  18 #include "llvm/ADT/Twine.h"
  19 #include "llvm/MC/MCAsmBackend.h"
  20 #include "llvm/MC/MCAssembler.h"
  21 #include "llvm/MC/MCCodeEmitter.h"
  22 #include "llvm/MC/MCContext.h"
  23 #include "llvm/MC/MCELF.h"
  24 #include "llvm/MC/MCELFStreamer.h"
  25 #include "llvm/MC/MCELFSymbolFlags.h"
  26 #include "llvm/MC/MCExpr.h"
  27 #include "llvm/MC/MCInst.h"
  28 #include "llvm/MC/MCObjectStreamer.h"
  29 #include "llvm/MC/MCSection.h"
  30 #include "llvm/MC/MCSectionELF.h"
  31 #include "llvm/MC/MCStreamer.h"
  32 #include "llvm/MC/MCSymbol.h"
  33 #include "llvm/MC/MCValue.h"
  34 #include "llvm/Support/Debug.h"
  35 #include "llvm/Support/ELF.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37 #include "llvm/Support/raw_ostream.h"
  38
  39 using namespace llvm;
  40
  41 namespace {
  42
  43 /// Extend the generic ELFStreamer class so that it can emit mapping symbols at
  44 /// the appropriate points in the object files. These symbols are defined in the
  45 /// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
  46 ///
  47 /// In brief: $a, $t or $d should be emitted at the start of each contiguous
  48 /// region of ARM code, Thumb code or data in a section. In practice, this
  49 /// emission does not rely on explicit assembler directives but on inherent
  50 /// properties of the directives doing the emission (e.g. ".byte" is data, "add
  51 /// r0, r0, r0" an instruction).
  52 ///
  53 /// As a result this system is orthogonal to the DataRegion infrastructure used
  54 /// by MachO. Beware!
  55 class ARMELFStreamer : public MCELFStreamer {
  56 public:
  57   ARMELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &OS,
  58                  MCCodeEmitter *Emitter, bool IsThumb)
  59       : MCELFStreamer(SK_ARMELFStreamer, Context, TAB, OS, Emitter),
  60         IsThumb(IsThumb), MappingSymbolCounter(0), LastEMS(EMS_None), ExTab(0),
  61         FnStart(0), Personality(0), CantUnwind(false) {}
  62
  63   ~ARMELFStreamer() {}
  64
  65   // ARM exception handling directives
  66   virtual void EmitFnStart();
  67   virtual void EmitFnEnd();
  68   virtual void EmitCantUnwind();
  69   virtual void EmitPersonality(const MCSymbol *Per);
  70   virtual void EmitHandlerData();
  71   virtual void EmitSetFP(unsigned NewFpReg,
  72                          unsigned NewSpReg,
  73                          int64_t Offset = 0);
  74   virtual void EmitPad(int64_t Offset);
  75   virtual void EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
  76                            bool isVector);
  77
  78   virtual void ChangeSection(const MCSection *Section) {
  79     // We have to keep track of the mapping symbol state of any sections we
  80     // use. Each one should start off as EMS_None, which is provided as the
  81     // default constructor by DenseMap::lookup.
  82     LastMappingSymbols[getPreviousSection()] = LastEMS;
  83     LastEMS = LastMappingSymbols.lookup(Section);
  84
  85     MCELFStreamer::ChangeSection(Section);
  86   }
  87
  88   /// This function is the one used to emit instruction data into the ELF
  89   /// streamer. We override it to add the appropriate mapping symbol if
  90   /// necessary.
  91   virtual void EmitInstruction(const MCInst& Inst) {
  92     if (IsThumb)
  93       EmitThumbMappingSymbol();
  94     else
  95       EmitARMMappingSymbol();
  96
  97     MCELFStreamer::EmitInstruction(Inst);
  98   }
  99
 100   /// This is one of the functions used to emit data into an ELF section, so the
 101   /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
 102   /// necessary.
 103   virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {
 104     EmitDataMappingSymbol();
 105     MCELFStreamer::EmitBytes(Data, AddrSpace);
 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 EmitValueImpl(const MCExpr *Value, unsigned Size,
 112                              unsigned AddrSpace) {
 113     EmitDataMappingSymbol();
 114     MCELFStreamer::EmitValueImpl(Value, Size, AddrSpace);
 115   }
 116
 117   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {
 118     MCELFStreamer::EmitAssemblerFlag(Flag);
 119
 120     switch (Flag) {
 121     case MCAF_SyntaxUnified:
 122       return; // no-op here.
 123     case MCAF_Code16:
 124       IsThumb = true;
 125       return; // Change to Thumb mode
 126     case MCAF_Code32:
 127       IsThumb = false;
 128       return; // Change to ARM mode
 129     case MCAF_Code64:
 130       return;
 131     case MCAF_SubsectionsViaSymbols:
 132       return;
 133     }
 134   }
 135
 136   static bool classof(const MCStreamer *S) {
 137     return S->getKind() == SK_ARMELFStreamer;
 138   }
 139
 140 private:
 141   enum ElfMappingSymbol {
 142     EMS_None,
 143     EMS_ARM,
 144     EMS_Thumb,
 145     EMS_Data
 146   };
 147
 148   void EmitDataMappingSymbol() {
 149     if (LastEMS == EMS_Data) return;
 150     EmitMappingSymbol("$d");
 151     LastEMS = EMS_Data;
 152   }
 153
 154   void EmitThumbMappingSymbol() {
 155     if (LastEMS == EMS_Thumb) return;
 156     EmitMappingSymbol("$t");
 157     LastEMS = EMS_Thumb;
 158   }
 159
 160   void EmitARMMappingSymbol() {
 161     if (LastEMS == EMS_ARM) return;
 162     EmitMappingSymbol("$a");
 163     LastEMS = EMS_ARM;
 164   }
 165
 166   void EmitMappingSymbol(StringRef Name) {
 167     MCSymbol *Start = getContext().CreateTempSymbol();
 168     EmitLabel(Start);
 169
 170     MCSymbol *Symbol =
 171       getContext().GetOrCreateSymbol(Name + "." +
 172                                      Twine(MappingSymbolCounter++));
 173
 174     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 175     MCELF::SetType(SD, ELF::STT_NOTYPE);
 176     MCELF::SetBinding(SD, ELF::STB_LOCAL);
 177     SD.setExternal(false);
 178     Symbol->setSection(*getCurrentSection());
 179
 180     const MCExpr *Value = MCSymbolRefExpr::Create(Start, getContext());
 181     Symbol->setVariableValue(Value);
 182   }
 183
 184   void EmitThumbFunc(MCSymbol *Func) {
 185     // FIXME: Anything needed here to flag the function as thumb?
 186
 187     getAssembler().setIsThumbFunc(Func);
 188
 189     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Func);
 190     SD.setFlags(SD.getFlags() | ELF_Other_ThumbFunc);
 191   }
 192
 193   // Helper functions for ARM exception handling directives
 194   void Reset();
 195
 196   void EmitPersonalityFixup(StringRef Name);
 197
 198   void SwitchToEHSection(const char *Prefix, unsigned Type, unsigned Flags,
 199                          SectionKind Kind, const MCSymbol &Fn);
 200   void SwitchToExTabSection(const MCSymbol &FnStart);
 201   void SwitchToExIdxSection(const MCSymbol &FnStart);
 202
 203   bool IsThumb;
 204   int64_t MappingSymbolCounter;
 205
 206   DenseMap<const MCSection *, ElfMappingSymbol> LastMappingSymbols;
 207   ElfMappingSymbol LastEMS;
 208
 209   // ARM Exception Handling Frame Information
 210   MCSymbol *ExTab;
 211   MCSymbol *FnStart;
 212   const MCSymbol *Personality;
 213   bool CantUnwind;
 214 };
 215 }
 216
 217 inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
 218                                               unsigned Type,
 219                                               unsigned Flags,
 220                                               SectionKind Kind,
 221                                               const MCSymbol &Fn) {
 222   const MCSectionELF &FnSection =
 223     static_cast<const MCSectionELF &>(Fn.getSection());
 224
 225   // Create the name for new section
 226   StringRef FnSecName(FnSection.getSectionName());
 227   SmallString<128> EHSecName(Prefix);
 228   if (FnSecName != ".text") {
 229     EHSecName += FnSecName;
 230   }
 231
 232   // Get .ARM.extab or .ARM.exidx section
 233   const MCSectionELF *EHSection = NULL;
 234   if (const MCSymbol *Group = FnSection.getGroup()) {
 235     EHSection = getContext().getELFSection(
 236       EHSecName, Type, Flags | ELF::SHF_GROUP, Kind,
 237       FnSection.getEntrySize(), Group->getName());
 238   } else {
 239     EHSection = getContext().getELFSection(EHSecName, Type, Flags, Kind);
 240   }
 241   assert(EHSection);
 242
 243   // Switch to .ARM.extab or .ARM.exidx section
 244   SwitchSection(EHSection);
 245   EmitCodeAlignment(4, 0);
 246 }
 247
 248 inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
 249   SwitchToEHSection(".ARM.extab",
 250                     ELF::SHT_PROGBITS,
 251                     ELF::SHF_ALLOC,
 252                     SectionKind::getDataRel(),
 253                     FnStart);
 254 }
 255
 256 inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
 257   SwitchToEHSection(".ARM.exidx",
 258                     ELF::SHT_ARM_EXIDX,
 259                     ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER,
 260                     SectionKind::getDataRel(),
 261                     FnStart);
 262 }
 263
 264 void ARMELFStreamer::Reset() {
 265   ExTab = NULL;
 266   FnStart = NULL;
 267   Personality = NULL;
 268   CantUnwind = false;
 269 }
 270
 271 // Add the R_ARM_NONE fixup at the same position
 272 void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
 273   const MCSymbol *PersonalitySym = getContext().GetOrCreateSymbol(Name);
 274
 275   const MCSymbolRefExpr *PersonalityRef =
 276     MCSymbolRefExpr::Create(PersonalitySym,
 277                             MCSymbolRefExpr::VK_ARM_NONE,
 278                             getContext());
 279
 280   AddValueSymbols(PersonalityRef);
 281   MCDataFragment *DF = getOrCreateDataFragment();
 282   DF->getFixups().push_back(
 283     MCFixup::Create(DF->getContents().size(), PersonalityRef,
 284                     MCFixup::getKindForSize(4, false)));
 285 }
 286
 287 void ARMELFStreamer::EmitFnStart() {
 288   assert(FnStart == 0);
 289   FnStart = getContext().CreateTempSymbol();
 290   EmitLabel(FnStart);
 291 }
 292
 293 void ARMELFStreamer::EmitFnEnd() {
 294   assert(FnStart && ".fnstart must preceeds .fnend");
 295
 296   // Emit unwind opcodes if there is no .handlerdata directive
 297   int PersonalityIndex = -1;
 298   if (!ExTab && !CantUnwind) {
 299     // For __aeabi_unwind_cpp_pr1, we have to emit opcodes in .ARM.extab.
 300     SwitchToExTabSection(*FnStart);
 301
 302     // Create .ARM.extab label for offset in .ARM.exidx
 303     ExTab = getContext().CreateTempSymbol();
 304     EmitLabel(ExTab);
 305
 306     PersonalityIndex = 1;
 307
 308     uint32_t Entry = 0;
 309     uint32_t NumExtraEntryWords = 0;
 310     Entry |= NumExtraEntryWords << 24;
 311     Entry |= (EHT_COMPACT | PersonalityIndex) << 16;
 312
 313     // TODO: This should be generated according to .save, .vsave, .setfp
 314     // directives.  Currently, we are simply generating FINISH opcode.
 315     Entry |= UNWIND_OPCODE_FINISH << 8;
 316     Entry |= UNWIND_OPCODE_FINISH;
 317
 318     EmitIntValue(Entry, 4, 0);
 319   }
 320
 321   // Emit the exception index table entry
 322   SwitchToExIdxSection(*FnStart);
 323
 324   if (PersonalityIndex == 1)
 325     EmitPersonalityFixup("__aeabi_unwind_cpp_pr1");
 326
 327   const MCSymbolRefExpr *FnStartRef =
 328     MCSymbolRefExpr::Create(FnStart,
 329                             MCSymbolRefExpr::VK_ARM_PREL31,
 330                             getContext());
 331
 332   EmitValue(FnStartRef, 4, 0);
 333
 334   if (CantUnwind) {
 335     EmitIntValue(EXIDX_CANTUNWIND, 4, 0);
 336   } else {
 337     const MCSymbolRefExpr *ExTabEntryRef =
 338       MCSymbolRefExpr::Create(ExTab,
 339                               MCSymbolRefExpr::VK_ARM_PREL31,
 340                               getContext());
 341     EmitValue(ExTabEntryRef, 4, 0);
 342   }
 343
 344   // Clean exception handling frame information
 345   Reset();
 346 }
 347
 348 void ARMELFStreamer::EmitCantUnwind() {
 349   CantUnwind = true;
 350 }
 351
 352 void ARMELFStreamer::EmitHandlerData() {
 353   SwitchToExTabSection(*FnStart);
 354
 355   // Create .ARM.extab label for offset in .ARM.exidx
 356   assert(!ExTab);
 357   ExTab = getContext().CreateTempSymbol();
 358   EmitLabel(ExTab);
 359
 360   // Emit Personality
 361   assert(Personality && ".personality directive must preceed .handlerdata");
 362
 363   const MCSymbolRefExpr *PersonalityRef =
 364     MCSymbolRefExpr::Create(Personality,
 365                             MCSymbolRefExpr::VK_ARM_PREL31,
 366                             getContext());
 367
 368   EmitValue(PersonalityRef, 4, 0);
 369
 370   // Emit unwind opcodes
 371   uint32_t Entry = 0;
 372   uint32_t NumExtraEntryWords = 0;
 373
 374   // TODO: This should be generated according to .save, .vsave, .setfp
 375   // directives.  Currently, we are simply generating FINISH opcode.
 376   Entry |= NumExtraEntryWords << 24;
 377   Entry |= UNWIND_OPCODE_FINISH << 16;
 378   Entry |= UNWIND_OPCODE_FINISH << 8;
 379   Entry |= UNWIND_OPCODE_FINISH;
 380
 381   EmitIntValue(Entry, 4, 0);
 382 }
 383
 384 void ARMELFStreamer::EmitPersonality(const MCSymbol *Per) {
 385   Personality = Per;
 386 }
 387
 388 void ARMELFStreamer::EmitSetFP(unsigned NewFpReg,
 389                                unsigned NewSpReg,
 390                                int64_t Offset) {
 391   // TODO: Not implemented
 392 }
 393
 394 void ARMELFStreamer::EmitPad(int64_t Offset) {
 395   // TODO: Not implemented
 396 }
 397
 398 void ARMELFStreamer::EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
 399                                  bool IsVector) {
 400   // TODO: Not implemented
 401 }
 402
 403 namespace llvm {
 404   MCELFStreamer* createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
 405                                       raw_ostream &OS, MCCodeEmitter *Emitter,
 406                                       bool RelaxAll, bool NoExecStack,
 407                                       bool IsThumb) {
 408     ARMELFStreamer *S = new ARMELFStreamer(Context, TAB, OS, Emitter, IsThumb);
 409     if (RelaxAll)
 410       S->getAssembler().setRelaxAll(true);
 411     if (NoExecStack)
 412       S->getAssembler().setNoExecStack(true);
 413     return S;
 414   }
 415
 416 }
 417
 418