lib/MC/MCELFStreamer.cpp

   1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output ------------===//
   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 ELF .o object files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MCELF.h"
  15 #include "llvm/ADT/SmallPtrSet.h"
  16 #include "llvm/MC/MCAssembler.h"
  17 #include "llvm/MC/MCCodeEmitter.h"
  18 #include "llvm/MC/MCContext.h"
  19 #include "llvm/MC/MCSectionELF.h"
  20 #include "llvm/MC/MCStreamer.h"
  21 #include "llvm/MC/MCELFSymbolFlags.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCInst.h"
  24 #include "llvm/MC/MCObjectStreamer.h"
  25 #include "llvm/MC/MCSection.h"
  26 #include "llvm/MC/MCSymbol.h"
  27 #include "llvm/MC/MCValue.h"
  28 #include "llvm/MC/MCAsmBackend.h"
  29 #include "llvm/Support/Debug.h"
  30 #include "llvm/Support/ELF.h"
  31 #include "llvm/Support/ErrorHandling.h"
  32 #include "llvm/Support/raw_ostream.h"
  33
  34 using namespace llvm;
  35
  36 namespace {
  37 class MCELFStreamer : public MCObjectStreamer {
  38 public:
  39   MCELFStreamer(MCContext &Context, MCAsmBackend &TAB,
  40                   raw_ostream &OS, MCCodeEmitter *Emitter)
  41     : MCObjectStreamer(Context, TAB, OS, Emitter) {}
  42
  43   MCELFStreamer(MCContext &Context, MCAsmBackend &TAB,
  44                 raw_ostream &OS, MCCodeEmitter *Emitter,
  45                 MCAssembler *Assembler)
  46     : MCObjectStreamer(Context, TAB, OS, Emitter, Assembler) {}
  47
  48
  49   ~MCELFStreamer() {}
  50
  51   /// @name MCStreamer Interface
  52   /// @{
  53
  54   virtual void InitSections();
  55   virtual void ChangeSection(const MCSection *Section);
  56   virtual void EmitLabel(MCSymbol *Symbol);
  57   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
  58   virtual void EmitThumbFunc(MCSymbol *Func);
  59   virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
  60   virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
  61   virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
  62   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
  63     llvm_unreachable("ELF doesn't support this directive");
  64   }
  65   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
  66                                 unsigned ByteAlignment);
  67   virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {
  68     llvm_unreachable("ELF doesn't support this directive");
  69   }
  70
  71   virtual void EmitCOFFSymbolStorageClass(int StorageClass) {
  72     llvm_unreachable("ELF doesn't support this directive");
  73   }
  74
  75   virtual void EmitCOFFSymbolType(int Type) {
  76     llvm_unreachable("ELF doesn't support this directive");
  77   }
  78
  79   virtual void EndCOFFSymbolDef() {
  80     llvm_unreachable("ELF doesn't support this directive");
  81   }
  82
  83   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
  84      MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
  85      SD.setSize(Value);
  86   }
  87
  88   virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
  89                                      unsigned ByteAlignment);
  90
  91   virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
  92                             unsigned Size = 0, unsigned ByteAlignment = 0) {
  93     llvm_unreachable("ELF doesn't support this directive");
  94   }
  95   virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
  96                               uint64_t Size, unsigned ByteAlignment = 0) {
  97     llvm_unreachable("ELF doesn't support this directive");
  98   }
  99   virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
 100   virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
 101                                     unsigned ValueSize = 1,
 102                                     unsigned MaxBytesToEmit = 0);
 103   virtual void EmitCodeAlignment(unsigned ByteAlignment,
 104                                  unsigned MaxBytesToEmit = 0);
 105   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
 106                              unsigned AddrSpace);
 107
 108   virtual void EmitFileDirective(StringRef Filename);
 109
 110   virtual void FinishImpl();
 111
 112 private:
 113   virtual void EmitInstToFragment(const MCInst &Inst);
 114   virtual void EmitInstToData(const MCInst &Inst);
 115
 116   void fixSymbolsInTLSFixups(const MCExpr *expr);
 117
 118   struct LocalCommon {
 119     MCSymbolData *SD;
 120     uint64_t Size;
 121     unsigned ByteAlignment;
 122   };
 123   std::vector<LocalCommon> LocalCommons;
 124
 125   SmallPtrSet<MCSymbol *, 16> BindingExplicitlySet;
 126   /// @}
 127   void SetSection(StringRef Section, unsigned Type, unsigned Flags,
 128                   SectionKind Kind) {
 129     SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind));
 130   }
 131
 132   void SetSectionData() {
 133     SetSection(".data", ELF::SHT_PROGBITS,
 134                ELF::SHF_WRITE |ELF::SHF_ALLOC,
 135                SectionKind::getDataRel());
 136     EmitCodeAlignment(4, 0);
 137   }
 138   void SetSectionText() {
 139     SetSection(".text", ELF::SHT_PROGBITS,
 140                ELF::SHF_EXECINSTR |
 141                ELF::SHF_ALLOC, SectionKind::getText());
 142     EmitCodeAlignment(4, 0);
 143   }
 144   void SetSectionBss() {
 145     SetSection(".bss", ELF::SHT_NOBITS,
 146                ELF::SHF_WRITE |
 147                ELF::SHF_ALLOC, SectionKind::getBSS());
 148     EmitCodeAlignment(4, 0);
 149   }
 150 };
 151 }
 152
 153 void MCELFStreamer::InitSections() {
 154   // This emulates the same behavior of GNU as. This makes it easier
 155   // to compare the output as the major sections are in the same order.
 156   SetSectionText();
 157   SetSectionData();
 158   SetSectionBss();
 159   SetSectionText();
 160 }
 161
 162 void MCELFStreamer::EmitLabel(MCSymbol *Symbol) {
 163   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
 164
 165   MCObjectStreamer::EmitLabel(Symbol);
 166
 167   const MCSectionELF &Section =
 168     static_cast<const MCSectionELF&>(Symbol->getSection());
 169   MCSymbolData &SD = getAssembler().getSymbolData(*Symbol);
 170   if (Section.getFlags() & ELF::SHF_TLS)
 171     MCELF::SetType(SD, ELF::STT_TLS);
 172 }
 173
 174 void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
 175   switch (Flag) {
 176   case MCAF_SyntaxUnified: return; // no-op here.
 177   case MCAF_Code16: return; // Change parsing mode; no-op here.
 178   case MCAF_Code32: return; // Change parsing mode; no-op here.
 179   case MCAF_Code64: return; // Change parsing mode; no-op here.
 180   case MCAF_SubsectionsViaSymbols:
 181     getAssembler().setSubsectionsViaSymbols(true);
 182     return;
 183   }
 184
 185   llvm_unreachable("invalid assembler flag!");
 186 }
 187
 188 void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) {
 189   // FIXME: Anything needed here to flag the function as thumb?
 190
 191   getAssembler().setIsThumbFunc(Func);
 192
 193   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Func);
 194   SD.setFlags(SD.getFlags() | ELF_Other_ThumbFunc);
 195 }
 196
 197 void MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
 198   // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
 199   // MCObjectStreamer.
 200   // FIXME: Lift context changes into super class.
 201   getAssembler().getOrCreateSymbolData(*Symbol);
 202   Symbol->setVariableValue(AddValueSymbols(Value));
 203 }
 204
 205 void MCELFStreamer::ChangeSection(const MCSection *Section) {
 206   const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup();
 207   if (Grp)
 208     getAssembler().getOrCreateSymbolData(*Grp);
 209   this->MCObjectStreamer::ChangeSection(Section);
 210 }
 211
 212 void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
 213   getAssembler().getOrCreateSymbolData(*Symbol);
 214   MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias);
 215   AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref);
 216   const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext());
 217   Alias->setVariableValue(Value);
 218 }
 219
 220 void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
 221                                           MCSymbolAttr Attribute) {
 222   // Indirect symbols are handled differently, to match how 'as' handles
 223   // them. This makes writing matching .o files easier.
 224   if (Attribute == MCSA_IndirectSymbol) {
 225     // Note that we intentionally cannot use the symbol data here; this is
 226     // important for matching the string table that 'as' generates.
 227     IndirectSymbolData ISD;
 228     ISD.Symbol = Symbol;
 229     ISD.SectionData = getCurrentSectionData();
 230     getAssembler().getIndirectSymbols().push_back(ISD);
 231     return;
 232   }
 233
 234   // Adding a symbol attribute always introduces the symbol, note that an
 235   // important side effect of calling getOrCreateSymbolData here is to register
 236   // the symbol with the assembler.
 237   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 238
 239   // The implementation of symbol attributes is designed to match 'as', but it
 240   // leaves much to desired. It doesn't really make sense to arbitrarily add and
 241   // remove flags, but 'as' allows this (in particular, see .desc).
 242   //
 243   // In the future it might be worth trying to make these operations more well
 244   // defined.
 245   switch (Attribute) {
 246   case MCSA_LazyReference:
 247   case MCSA_Reference:
 248   case MCSA_NoDeadStrip:
 249   case MCSA_SymbolResolver:
 250   case MCSA_PrivateExtern:
 251   case MCSA_WeakDefinition:
 252   case MCSA_WeakDefAutoPrivate:
 253   case MCSA_Invalid:
 254   case MCSA_IndirectSymbol:
 255     llvm_unreachable("Invalid symbol attribute for ELF!");
 256
 257   case MCSA_ELF_TypeGnuUniqueObject:
 258     // Ignore for now.
 259     break;
 260
 261   case MCSA_Global:
 262     MCELF::SetBinding(SD, ELF::STB_GLOBAL);
 263     SD.setExternal(true);
 264     BindingExplicitlySet.insert(Symbol);
 265     break;
 266
 267   case MCSA_WeakReference:
 268   case MCSA_Weak:
 269     MCELF::SetBinding(SD, ELF::STB_WEAK);
 270     SD.setExternal(true);
 271     BindingExplicitlySet.insert(Symbol);
 272     break;
 273
 274   case MCSA_Local:
 275     MCELF::SetBinding(SD, ELF::STB_LOCAL);
 276     SD.setExternal(false);
 277     BindingExplicitlySet.insert(Symbol);
 278     break;
 279
 280   case MCSA_ELF_TypeFunction:
 281     MCELF::SetType(SD, ELF::STT_FUNC);
 282     break;
 283
 284   case MCSA_ELF_TypeIndFunction:
 285     MCELF::SetType(SD, ELF::STT_GNU_IFUNC);
 286     break;
 287
 288   case MCSA_ELF_TypeObject:
 289     MCELF::SetType(SD, ELF::STT_OBJECT);
 290     break;
 291
 292   case MCSA_ELF_TypeTLS:
 293     MCELF::SetType(SD, ELF::STT_TLS);
 294     break;
 295
 296   case MCSA_ELF_TypeCommon:
 297     MCELF::SetType(SD, ELF::STT_COMMON);
 298     break;
 299
 300   case MCSA_ELF_TypeNoType:
 301     MCELF::SetType(SD, ELF::STT_NOTYPE);
 302     break;
 303
 304   case MCSA_Protected:
 305     MCELF::SetVisibility(SD, ELF::STV_PROTECTED);
 306     break;
 307
 308   case MCSA_Hidden:
 309     MCELF::SetVisibility(SD, ELF::STV_HIDDEN);
 310     break;
 311
 312   case MCSA_Internal:
 313     MCELF::SetVisibility(SD, ELF::STV_INTERNAL);
 314     break;
 315   }
 316 }
 317
 318 void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 319                                        unsigned ByteAlignment) {
 320   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 321
 322   if (!BindingExplicitlySet.count(Symbol)) {
 323     MCELF::SetBinding(SD, ELF::STB_GLOBAL);
 324     SD.setExternal(true);
 325   }
 326
 327   MCELF::SetType(SD, ELF::STT_OBJECT);
 328
 329   if (MCELF::GetBinding(SD) == ELF_STB_Local) {
 330     const MCSection *Section = getAssembler().getContext().getELFSection(".bss",
 331                                                          ELF::SHT_NOBITS,
 332                                                          ELF::SHF_WRITE |
 333                                                          ELF::SHF_ALLOC,
 334                                                          SectionKind::getBSS());
 335     Symbol->setSection(*Section);
 336
 337     struct LocalCommon L = {&SD, Size, ByteAlignment};
 338     LocalCommons.push_back(L);
 339   } else {
 340     SD.setCommon(Size, ByteAlignment);
 341   }
 342
 343   SD.setSize(MCConstantExpr::Create(Size, getContext()));
 344 }
 345
 346 void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 347                                           unsigned ByteAlignment) {
 348   // FIXME: Should this be caught and done earlier?
 349   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 350   MCELF::SetBinding(SD, ELF::STB_LOCAL);
 351   SD.setExternal(false);
 352   BindingExplicitlySet.insert(Symbol);
 353   EmitCommonSymbol(Symbol, Size, ByteAlignment);
 354 }
 355
 356 void MCELFStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
 357   // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
 358   // MCObjectStreamer.
 359   getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end());
 360 }
 361
 362 void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
 363                                            int64_t Value, unsigned ValueSize,
 364                                            unsigned MaxBytesToEmit) {
 365   // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
 366   // MCObjectStreamer.
 367   if (MaxBytesToEmit == 0)
 368     MaxBytesToEmit = ByteAlignment;
 369   new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit,
 370                       getCurrentSectionData());
 371
 372   // Update the maximum alignment on the current section if necessary.
 373   if (ByteAlignment > getCurrentSectionData()->getAlignment())
 374     getCurrentSectionData()->setAlignment(ByteAlignment);
 375 }
 376
 377 void MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment,
 378                                         unsigned MaxBytesToEmit) {
 379   // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
 380   // MCObjectStreamer.
 381   if (MaxBytesToEmit == 0)
 382     MaxBytesToEmit = ByteAlignment;
 383   MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit,
 384                                            getCurrentSectionData());
 385   F->setEmitNops(true);
 386
 387   // Update the maximum alignment on the current section if necessary.
 388   if (ByteAlignment > getCurrentSectionData()->getAlignment())
 389     getCurrentSectionData()->setAlignment(ByteAlignment);
 390 }
 391
 392 void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
 393                                   unsigned AddrSpace) {
 394   fixSymbolsInTLSFixups(Value);
 395   MCObjectStreamer::EmitValueImpl(Value, Size, AddrSpace);
 396 }
 397
 398
 399 // Add a symbol for the file name of this module. This is the second
 400 // entry in the module's symbol table (the first being the null symbol).
 401 void MCELFStreamer::EmitFileDirective(StringRef Filename) {
 402   MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename);
 403   Symbol->setSection(*getCurrentSection());
 404   Symbol->setAbsolute();
 405
 406   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 407
 408   SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default);
 409 }
 410
 411 void  MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
 412   switch (expr->getKind()) {
 413   case MCExpr::Target: llvm_unreachable("Can't handle target exprs yet!");
 414   case MCExpr::Constant:
 415     break;
 416
 417   case MCExpr::Binary: {
 418     const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
 419     fixSymbolsInTLSFixups(be->getLHS());
 420     fixSymbolsInTLSFixups(be->getRHS());
 421     break;
 422   }
 423
 424   case MCExpr::SymbolRef: {
 425     const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
 426     switch (symRef.getKind()) {
 427     default:
 428       return;
 429     case MCSymbolRefExpr::VK_GOTTPOFF:
 430     case MCSymbolRefExpr::VK_INDNTPOFF:
 431     case MCSymbolRefExpr::VK_NTPOFF:
 432     case MCSymbolRefExpr::VK_GOTNTPOFF:
 433     case MCSymbolRefExpr::VK_TLSGD:
 434     case MCSymbolRefExpr::VK_TLSLD:
 435     case MCSymbolRefExpr::VK_TLSLDM:
 436     case MCSymbolRefExpr::VK_TPOFF:
 437     case MCSymbolRefExpr::VK_DTPOFF:
 438     case MCSymbolRefExpr::VK_ARM_TLSGD:
 439     case MCSymbolRefExpr::VK_ARM_TPOFF:
 440     case MCSymbolRefExpr::VK_ARM_GOTTPOFF:
 441     case MCSymbolRefExpr::VK_Mips_TLSGD:
 442     case MCSymbolRefExpr::VK_Mips_GOTTPREL:
 443     case MCSymbolRefExpr::VK_Mips_TPREL_HI:
 444     case MCSymbolRefExpr::VK_Mips_TPREL_LO:
 445       break;
 446     }
 447     MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol());
 448     MCELF::SetType(SD, ELF::STT_TLS);
 449     break;
 450   }
 451
 452   case MCExpr::Unary:
 453     fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
 454     break;
 455   }
 456 }
 457
 458 void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) {
 459   this->MCObjectStreamer::EmitInstToFragment(Inst);
 460   MCInstFragment &F = *cast<MCInstFragment>(getCurrentFragment());
 461
 462   for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
 463     fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
 464 }
 465
 466 void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
 467   MCDataFragment *DF = getOrCreateDataFragment();
 468
 469   SmallVector<MCFixup, 4> Fixups;
 470   SmallString<256> Code;
 471   raw_svector_ostream VecOS(Code);
 472   getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
 473   VecOS.flush();
 474
 475   for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
 476     fixSymbolsInTLSFixups(Fixups[i].getValue());
 477
 478   // Add the fixups and data.
 479   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
 480     Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
 481     DF->addFixup(Fixups[i]);
 482   }
 483   DF->getContents().append(Code.begin(), Code.end());
 484 }
 485
 486 void MCELFStreamer::FinishImpl() {
 487   EmitFrames(true);
 488
 489   for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
 490                                                 e = LocalCommons.end();
 491        i != e; ++i) {
 492     MCSymbolData *SD = i->SD;
 493     uint64_t Size = i->Size;
 494     unsigned ByteAlignment = i->ByteAlignment;
 495     const MCSymbol &Symbol = SD->getSymbol();
 496     const MCSection &Section = Symbol.getSection();
 497
 498     MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section);
 499     new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData);
 500
 501     MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
 502     SD->setFragment(F);
 503
 504     // Update the maximum alignment of the section if necessary.
 505     if (ByteAlignment > SectData.getAlignment())
 506       SectData.setAlignment(ByteAlignment);
 507   }
 508
 509   this->MCObjectStreamer::FinishImpl();
 510 }
 511
 512 MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB,
 513                                     raw_ostream &OS, MCCodeEmitter *CE,
 514                                     bool RelaxAll, bool NoExecStack) {
 515   MCELFStreamer *S = new MCELFStreamer(Context, MAB, OS, CE);
 516   if (RelaxAll)
 517     S->getAssembler().setRelaxAll(true);
 518   if (NoExecStack)
 519     S->getAssembler().setNoExecStack(true);
 520   return S;
 521 }