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