MCMachOStreamer.cpp revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f
1//===-- MCMachOStreamer.cpp - MachO Streamer ------------------------------===// 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#include "llvm/MC/MCStreamer.h" 11#include "llvm/ADT/DenseMap.h" 12#include "llvm/ADT/SmallVector.h" 13#include "llvm/MC/MCAsmBackend.h" 14#include "llvm/MC/MCAssembler.h" 15#include "llvm/MC/MCCodeEmitter.h" 16#include "llvm/MC/MCContext.h" 17#include "llvm/MC/MCDwarf.h" 18#include "llvm/MC/MCExpr.h" 19#include "llvm/MC/MCInst.h" 20#include "llvm/MC/MCLinkerOptimizationHint.h" 21#include "llvm/MC/MCMachOSymbolFlags.h" 22#include "llvm/MC/MCObjectFileInfo.h" 23#include "llvm/MC/MCObjectStreamer.h" 24#include "llvm/MC/MCSection.h" 25#include "llvm/MC/MCSectionMachO.h" 26#include "llvm/MC/MCSymbol.h" 27#include "llvm/Support/Dwarf.h" 28#include "llvm/Support/ErrorHandling.h" 29#include "llvm/Support/raw_ostream.h" 30 31using namespace llvm; 32 33namespace { 34 35class MCMachOStreamer : public MCObjectStreamer { 36private: 37 /// LabelSections - true if each section change should emit a linker local 38 /// label for use in relocations for assembler local references. Obviates the 39 /// need for local relocations. False by default. 40 bool LabelSections; 41 42 /// HasSectionLabel - map of which sections have already had a non-local 43 /// label emitted to them. Used so we don't emit extraneous linker local 44 /// labels in the middle of the section. 45 DenseMap<const MCSection*, bool> HasSectionLabel; 46 47 void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override; 48 49 void EmitDataRegion(DataRegionData::KindTy Kind); 50 void EmitDataRegionEnd(); 51 52public: 53 MCMachOStreamer(MCContext &Context, MCAsmBackend &MAB, raw_ostream &OS, 54 MCCodeEmitter *Emitter, bool label) 55 : MCObjectStreamer(Context, MAB, OS, Emitter), 56 LabelSections(label) {} 57 58 /// @name MCStreamer Interface 59 /// @{ 60 61 void ChangeSection(const MCSection *Sect, const MCExpr *Subsect) override; 62 void EmitLabel(MCSymbol *Symbol) override; 63 void EmitDebugLabel(MCSymbol *Symbol) override; 64 void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol) override; 65 void EmitAssemblerFlag(MCAssemblerFlag Flag) override; 66 void EmitLinkerOptions(ArrayRef<std::string> Options) override; 67 void EmitDataRegion(MCDataRegionType Kind) override; 68 void EmitVersionMin(MCVersionMinType Kind, unsigned Major, 69 unsigned Minor, unsigned Update) override; 70 void EmitThumbFunc(MCSymbol *Func) override; 71 bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override; 72 void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override; 73 void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 74 unsigned ByteAlignment) override; 75 void BeginCOFFSymbolDef(const MCSymbol *Symbol) override { 76 llvm_unreachable("macho doesn't support this directive"); 77 } 78 void EmitCOFFSymbolStorageClass(int StorageClass) override { 79 llvm_unreachable("macho doesn't support this directive"); 80 } 81 void EmitCOFFSymbolType(int Type) override { 82 llvm_unreachable("macho doesn't support this directive"); 83 } 84 void EndCOFFSymbolDef() override { 85 llvm_unreachable("macho doesn't support this directive"); 86 } 87 void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) override { 88 llvm_unreachable("macho doesn't support this directive"); 89 } 90 void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 91 unsigned ByteAlignment) override; 92 void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = nullptr, 93 uint64_t Size = 0, unsigned ByteAlignment = 0) override; 94 virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 95 uint64_t Size, unsigned ByteAlignment = 0) override; 96 97 void EmitFileDirective(StringRef Filename) override { 98 // FIXME: Just ignore the .file; it isn't important enough to fail the 99 // entire assembly. 100 101 // report_fatal_error("unsupported directive: '.file'"); 102 } 103 104 void EmitIdent(StringRef IdentString) override { 105 llvm_unreachable("macho doesn't support this directive"); 106 } 107 108 void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override { 109 getAssembler().getLOHContainer().addDirective(Kind, Args); 110 } 111 112 void FinishImpl() override; 113}; 114 115} // end anonymous namespace. 116 117void MCMachOStreamer::ChangeSection(const MCSection *Section, 118 const MCExpr *Subsection) { 119 // Change the section normally. 120 MCObjectStreamer::ChangeSection(Section, Subsection); 121 // Output a linker-local symbol so we don't need section-relative local 122 // relocations. The linker hates us when we do that. 123 if (LabelSections && !HasSectionLabel[Section]) { 124 MCSymbol *Label = getContext().CreateLinkerPrivateTempSymbol(); 125 EmitLabel(Label); 126 HasSectionLabel[Section] = true; 127 } 128} 129 130void MCMachOStreamer::EmitEHSymAttributes(const MCSymbol *Symbol, 131 MCSymbol *EHSymbol) { 132 MCSymbolData &SD = 133 getAssembler().getOrCreateSymbolData(*Symbol); 134 if (SD.isExternal()) 135 EmitSymbolAttribute(EHSymbol, MCSA_Global); 136 if (SD.getFlags() & SF_WeakDefinition) 137 EmitSymbolAttribute(EHSymbol, MCSA_WeakDefinition); 138 if (SD.isPrivateExtern()) 139 EmitSymbolAttribute(EHSymbol, MCSA_PrivateExtern); 140} 141 142void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) { 143 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 144 145 // isSymbolLinkerVisible uses the section. 146 AssignSection(Symbol, getCurrentSection().first); 147 // We have to create a new fragment if this is an atom defining symbol, 148 // fragments cannot span atoms. 149 if (getAssembler().isSymbolLinkerVisible(*Symbol)) 150 insert(new MCDataFragment()); 151 152 MCObjectStreamer::EmitLabel(Symbol); 153 154 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); 155 // This causes the reference type flag to be cleared. Darwin 'as' was "trying" 156 // to clear the weak reference and weak definition bits too, but the 157 // implementation was buggy. For now we just try to match 'as', for 158 // diffability. 159 // 160 // FIXME: Cleanup this code, these bits should be emitted based on semantic 161 // properties, not on the order of definition, etc. 162 SD.setFlags(SD.getFlags() & ~SF_ReferenceTypeMask); 163} 164 165void MCMachOStreamer::EmitDebugLabel(MCSymbol *Symbol) { 166 EmitLabel(Symbol); 167} 168void MCMachOStreamer::EmitDataRegion(DataRegionData::KindTy Kind) { 169 if (!getAssembler().getBackend().hasDataInCodeSupport()) 170 return; 171 // Create a temporary label to mark the start of the data region. 172 MCSymbol *Start = getContext().CreateTempSymbol(); 173 EmitLabel(Start); 174 // Record the region for the object writer to use. 175 DataRegionData Data = { Kind, Start, nullptr }; 176 std::vector<DataRegionData> &Regions = getAssembler().getDataRegions(); 177 Regions.push_back(Data); 178} 179 180void MCMachOStreamer::EmitDataRegionEnd() { 181 if (!getAssembler().getBackend().hasDataInCodeSupport()) 182 return; 183 std::vector<DataRegionData> &Regions = getAssembler().getDataRegions(); 184 assert(Regions.size() && "Mismatched .end_data_region!"); 185 DataRegionData &Data = Regions.back(); 186 assert(!Data.End && "Mismatched .end_data_region!"); 187 // Create a temporary label to mark the end of the data region. 188 Data.End = getContext().CreateTempSymbol(); 189 EmitLabel(Data.End); 190} 191 192void MCMachOStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 193 // Let the target do whatever target specific stuff it needs to do. 194 getAssembler().getBackend().handleAssemblerFlag(Flag); 195 // Do any generic stuff we need to do. 196 switch (Flag) { 197 case MCAF_SyntaxUnified: return; // no-op here. 198 case MCAF_Code16: return; // Change parsing mode; no-op here. 199 case MCAF_Code32: return; // Change parsing mode; no-op here. 200 case MCAF_Code64: return; // Change parsing mode; no-op here. 201 case MCAF_SubsectionsViaSymbols: 202 getAssembler().setSubsectionsViaSymbols(true); 203 return; 204 } 205} 206 207void MCMachOStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) { 208 getAssembler().getLinkerOptions().push_back(Options); 209} 210 211void MCMachOStreamer::EmitDataRegion(MCDataRegionType Kind) { 212 switch (Kind) { 213 case MCDR_DataRegion: 214 EmitDataRegion(DataRegionData::Data); 215 return; 216 case MCDR_DataRegionJT8: 217 EmitDataRegion(DataRegionData::JumpTable8); 218 return; 219 case MCDR_DataRegionJT16: 220 EmitDataRegion(DataRegionData::JumpTable16); 221 return; 222 case MCDR_DataRegionJT32: 223 EmitDataRegion(DataRegionData::JumpTable32); 224 return; 225 case MCDR_DataRegionEnd: 226 EmitDataRegionEnd(); 227 return; 228 } 229} 230 231void MCMachOStreamer::EmitVersionMin(MCVersionMinType Kind, unsigned Major, 232 unsigned Minor, unsigned Update) { 233 getAssembler().setVersionMinInfo(Kind, Major, Minor, Update); 234} 235 236void MCMachOStreamer::EmitThumbFunc(MCSymbol *Symbol) { 237 // Remember that the function is a thumb function. Fixup and relocation 238 // values will need adjusted. 239 getAssembler().setIsThumbFunc(Symbol); 240} 241 242bool MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 243 MCSymbolAttr Attribute) { 244 // Indirect symbols are handled differently, to match how 'as' handles 245 // them. This makes writing matching .o files easier. 246 if (Attribute == MCSA_IndirectSymbol) { 247 // Note that we intentionally cannot use the symbol data here; this is 248 // important for matching the string table that 'as' generates. 249 IndirectSymbolData ISD; 250 ISD.Symbol = Symbol; 251 ISD.SectionData = getCurrentSectionData(); 252 getAssembler().getIndirectSymbols().push_back(ISD); 253 return true; 254 } 255 256 // Adding a symbol attribute always introduces the symbol, note that an 257 // important side effect of calling getOrCreateSymbolData here is to register 258 // the symbol with the assembler. 259 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 260 261 // The implementation of symbol attributes is designed to match 'as', but it 262 // leaves much to desired. It doesn't really make sense to arbitrarily add and 263 // remove flags, but 'as' allows this (in particular, see .desc). 264 // 265 // In the future it might be worth trying to make these operations more well 266 // defined. 267 switch (Attribute) { 268 case MCSA_Invalid: 269 case MCSA_ELF_TypeFunction: 270 case MCSA_ELF_TypeIndFunction: 271 case MCSA_ELF_TypeObject: 272 case MCSA_ELF_TypeTLS: 273 case MCSA_ELF_TypeCommon: 274 case MCSA_ELF_TypeNoType: 275 case MCSA_ELF_TypeGnuUniqueObject: 276 case MCSA_Hidden: 277 case MCSA_IndirectSymbol: 278 case MCSA_Internal: 279 case MCSA_Protected: 280 case MCSA_Weak: 281 case MCSA_Local: 282 return false; 283 284 case MCSA_Global: 285 SD.setExternal(true); 286 // This effectively clears the undefined lazy bit, in Darwin 'as', although 287 // it isn't very consistent because it implements this as part of symbol 288 // lookup. 289 // 290 // FIXME: Cleanup this code, these bits should be emitted based on semantic 291 // properties, not on the order of definition, etc. 292 SD.setFlags(SD.getFlags() & ~SF_ReferenceTypeUndefinedLazy); 293 break; 294 295 case MCSA_LazyReference: 296 // FIXME: This requires -dynamic. 297 SD.setFlags(SD.getFlags() | SF_NoDeadStrip); 298 if (Symbol->isUndefined()) 299 SD.setFlags(SD.getFlags() | SF_ReferenceTypeUndefinedLazy); 300 break; 301 302 // Since .reference sets the no dead strip bit, it is equivalent to 303 // .no_dead_strip in practice. 304 case MCSA_Reference: 305 case MCSA_NoDeadStrip: 306 SD.setFlags(SD.getFlags() | SF_NoDeadStrip); 307 break; 308 309 case MCSA_SymbolResolver: 310 SD.setFlags(SD.getFlags() | SF_SymbolResolver); 311 break; 312 313 case MCSA_PrivateExtern: 314 SD.setExternal(true); 315 SD.setPrivateExtern(true); 316 break; 317 318 case MCSA_WeakReference: 319 // FIXME: This requires -dynamic. 320 if (Symbol->isUndefined()) 321 SD.setFlags(SD.getFlags() | SF_WeakReference); 322 break; 323 324 case MCSA_WeakDefinition: 325 // FIXME: 'as' enforces that this is defined and global. The manual claims 326 // it has to be in a coalesced section, but this isn't enforced. 327 SD.setFlags(SD.getFlags() | SF_WeakDefinition); 328 break; 329 330 case MCSA_WeakDefAutoPrivate: 331 SD.setFlags(SD.getFlags() | SF_WeakDefinition | SF_WeakReference); 332 break; 333 } 334 335 return true; 336} 337 338void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 339 // Encode the 'desc' value into the lowest implementation defined bits. 340 assert(DescValue == (DescValue & SF_DescFlagsMask) && 341 "Invalid .desc value!"); 342 getAssembler().getOrCreateSymbolData(*Symbol).setFlags( 343 DescValue & SF_DescFlagsMask); 344} 345 346void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 347 unsigned ByteAlignment) { 348 // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself. 349 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 350 351 AssignSection(Symbol, nullptr); 352 353 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 354 SD.setExternal(true); 355 SD.setCommon(Size, ByteAlignment); 356} 357 358void MCMachOStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 359 unsigned ByteAlignment) { 360 // '.lcomm' is equivalent to '.zerofill'. 361 return EmitZerofill(getContext().getObjectFileInfo()->getDataBSSSection(), 362 Symbol, Size, ByteAlignment); 363} 364 365void MCMachOStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 366 uint64_t Size, unsigned ByteAlignment) { 367 MCSectionData &SectData = getAssembler().getOrCreateSectionData(*Section); 368 369 // The symbol may not be present, which only creates the section. 370 if (!Symbol) 371 return; 372 373 // On darwin all virtual sections have zerofill type. 374 assert(Section->isVirtualSection() && "Section does not have zerofill type!"); 375 376 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 377 378 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 379 380 // Emit an align fragment if necessary. 381 if (ByteAlignment != 1) 382 new MCAlignFragment(ByteAlignment, 0, 0, ByteAlignment, &SectData); 383 384 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); 385 SD.setFragment(F); 386 387 AssignSection(Symbol, Section); 388 389 // Update the maximum alignment on the zero fill section if necessary. 390 if (ByteAlignment > SectData.getAlignment()) 391 SectData.setAlignment(ByteAlignment); 392} 393 394// This should always be called with the thread local bss section. Like the 395// .zerofill directive this doesn't actually switch sections on us. 396void MCMachOStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 397 uint64_t Size, unsigned ByteAlignment) { 398 EmitZerofill(Section, Symbol, Size, ByteAlignment); 399 return; 400} 401 402void MCMachOStreamer::EmitInstToData(const MCInst &Inst, 403 const MCSubtargetInfo &STI) { 404 MCDataFragment *DF = getOrCreateDataFragment(); 405 406 SmallVector<MCFixup, 4> Fixups; 407 SmallString<256> Code; 408 raw_svector_ostream VecOS(Code); 409 getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups, STI); 410 VecOS.flush(); 411 412 // Add the fixups and data. 413 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 414 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 415 DF->getFixups().push_back(Fixups[i]); 416 } 417 DF->getContents().append(Code.begin(), Code.end()); 418} 419 420void MCMachOStreamer::FinishImpl() { 421 EmitFrames(&getAssembler().getBackend()); 422 423 // We have to set the fragment atom associations so we can relax properly for 424 // Mach-O. 425 426 // First, scan the symbol table to build a lookup table from fragments to 427 // defining symbols. 428 DenseMap<const MCFragment*, MCSymbolData*> DefiningSymbolMap; 429 for (MCSymbolData &SD : getAssembler().symbols()) { 430 if (getAssembler().isSymbolLinkerVisible(SD.getSymbol()) && 431 SD.getFragment()) { 432 // An atom defining symbol should never be internal to a fragment. 433 assert(SD.getOffset() == 0 && "Invalid offset in atom defining symbol!"); 434 DefiningSymbolMap[SD.getFragment()] = &SD; 435 } 436 } 437 438 // Set the fragment atom associations by tracking the last seen atom defining 439 // symbol. 440 for (MCAssembler::iterator it = getAssembler().begin(), 441 ie = getAssembler().end(); it != ie; ++it) { 442 MCSymbolData *CurrentAtom = nullptr; 443 for (MCSectionData::iterator it2 = it->begin(), 444 ie2 = it->end(); it2 != ie2; ++it2) { 445 if (MCSymbolData *SD = DefiningSymbolMap.lookup(it2)) 446 CurrentAtom = SD; 447 it2->setAtom(CurrentAtom); 448 } 449 } 450 451 this->MCObjectStreamer::FinishImpl(); 452} 453 454MCStreamer *llvm::createMachOStreamer(MCContext &Context, MCAsmBackend &MAB, 455 raw_ostream &OS, MCCodeEmitter *CE, 456 bool RelaxAll, 457 bool LabelSections) { 458 MCMachOStreamer *S = new MCMachOStreamer(Context, MAB, OS, CE, LabelSections); 459 if (RelaxAll) 460 S->getAssembler().setRelaxAll(true); 461 return S; 462} 463