MCELFStreamer.cpp revision 224145
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/Support/Debug.h" 25#include "llvm/Support/ELF.h" 26#include "llvm/Support/ErrorHandling.h" 27#include "llvm/Support/raw_ostream.h" 28#include "llvm/Target/TargetAsmBackend.h" 29 30using namespace llvm; 31 32void 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 41void 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 53void 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 66void 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 75void 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 83void 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 90void 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 98void 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 194void 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 222void 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 232void 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 238void 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 253void 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). 270void 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 280void 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 323void 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 331void 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 351void 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 377MCStreamer *llvm::createELFStreamer(MCContext &Context, TargetAsmBackend &TAB, 378 raw_ostream &OS, MCCodeEmitter *CE, 379 bool RelaxAll, bool NoExecStack) { 380 MCELFStreamer *S = new MCELFStreamer(Context, TAB, OS, CE); 381 if (RelaxAll) 382 S->getAssembler().setRelaxAll(true); 383 if (NoExecStack) 384 S->getAssembler().setNoExecStack(true); 385 return S; 386} 387