MCMachOStreamer.cpp revision 204642
1//===- lib/MC/MCMachOStreamer.cpp - Mach-O 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#include "llvm/MC/MCStreamer.h" 11 12#include "llvm/MC/MCAssembler.h" 13#include "llvm/MC/MCContext.h" 14#include "llvm/MC/MCCodeEmitter.h" 15#include "llvm/MC/MCExpr.h" 16#include "llvm/MC/MCInst.h" 17#include "llvm/MC/MCSection.h" 18#include "llvm/MC/MCSymbol.h" 19#include "llvm/MC/MCValue.h" 20#include "llvm/Support/ErrorHandling.h" 21#include "llvm/Support/raw_ostream.h" 22using namespace llvm; 23 24namespace { 25 26class MCMachOStreamer : public MCStreamer { 27 /// SymbolFlags - We store the value for the 'desc' symbol field in the lowest 28 /// 16 bits of the implementation defined flags. 29 enum SymbolFlags { // See <mach-o/nlist.h>. 30 SF_DescFlagsMask = 0xFFFF, 31 32 // Reference type flags. 33 SF_ReferenceTypeMask = 0x0007, 34 SF_ReferenceTypeUndefinedNonLazy = 0x0000, 35 SF_ReferenceTypeUndefinedLazy = 0x0001, 36 SF_ReferenceTypeDefined = 0x0002, 37 SF_ReferenceTypePrivateDefined = 0x0003, 38 SF_ReferenceTypePrivateUndefinedNonLazy = 0x0004, 39 SF_ReferenceTypePrivateUndefinedLazy = 0x0005, 40 41 // Other 'desc' flags. 42 SF_NoDeadStrip = 0x0020, 43 SF_WeakReference = 0x0040, 44 SF_WeakDefinition = 0x0080 45 }; 46 47private: 48 MCAssembler Assembler; 49 MCCodeEmitter *Emitter; 50 MCSectionData *CurSectionData; 51 DenseMap<const MCSection*, MCSectionData*> SectionMap; 52 DenseMap<const MCSymbol*, MCSymbolData*> SymbolMap; 53 54private: 55 MCFragment *getCurrentFragment() const { 56 assert(CurSectionData && "No current section!"); 57 58 if (!CurSectionData->empty()) 59 return &CurSectionData->getFragmentList().back(); 60 61 return 0; 62 } 63 64 MCSectionData &getSectionData(const MCSection &Section) { 65 MCSectionData *&Entry = SectionMap[&Section]; 66 67 if (!Entry) 68 Entry = new MCSectionData(Section, &Assembler); 69 70 return *Entry; 71 } 72 73 MCSymbolData &getSymbolData(const MCSymbol &Symbol) { 74 MCSymbolData *&Entry = SymbolMap[&Symbol]; 75 76 if (!Entry) 77 Entry = new MCSymbolData(Symbol, 0, 0, &Assembler); 78 79 return *Entry; 80 } 81 82public: 83 MCMachOStreamer(MCContext &Context, raw_ostream &_OS, MCCodeEmitter *_Emitter) 84 : MCStreamer(Context), Assembler(Context, _OS), Emitter(_Emitter), 85 CurSectionData(0) {} 86 ~MCMachOStreamer() {} 87 88 const MCExpr *AddValueSymbols(const MCExpr *Value) { 89 switch (Value->getKind()) { 90 case MCExpr::Target: assert(0 && "Can't handle target exprs yet!"); 91 case MCExpr::Constant: 92 break; 93 94 case MCExpr::Binary: { 95 const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value); 96 AddValueSymbols(BE->getLHS()); 97 AddValueSymbols(BE->getRHS()); 98 break; 99 } 100 101 case MCExpr::SymbolRef: 102 getSymbolData(cast<MCSymbolRefExpr>(Value)->getSymbol()); 103 break; 104 105 case MCExpr::Unary: 106 AddValueSymbols(cast<MCUnaryExpr>(Value)->getSubExpr()); 107 break; 108 } 109 110 return Value; 111 } 112 113 /// @name MCStreamer Interface 114 /// @{ 115 116 virtual void SwitchSection(const MCSection *Section); 117 virtual void EmitLabel(MCSymbol *Symbol); 118 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag); 119 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value); 120 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute); 121 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue); 122 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 123 unsigned ByteAlignment); 124 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 125 assert(0 && "macho doesn't support this directive"); 126 } 127 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) { 128 assert(0 && "macho doesn't support this directive"); 129 } 130 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0, 131 unsigned Size = 0, unsigned ByteAlignment = 0); 132 virtual void EmitBytes(StringRef Data, unsigned AddrSpace); 133 virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace); 134 virtual void EmitGPRel32Value(const MCExpr *Value) { 135 assert(0 && "macho doesn't support this directive"); 136 } 137 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, 138 unsigned ValueSize = 1, 139 unsigned MaxBytesToEmit = 0); 140 virtual void EmitCodeAlignment(unsigned ByteAlignment, 141 unsigned MaxBytesToEmit = 0); 142 virtual void EmitValueToOffset(const MCExpr *Offset, 143 unsigned char Value = 0); 144 145 virtual void EmitFileDirective(StringRef Filename) { 146 errs() << "FIXME: MCMachoStreamer:EmitFileDirective not implemented\n"; 147 } 148 virtual void EmitDwarfFileDirective(unsigned FileNo, StringRef Filename) { 149 errs() << "FIXME: MCMachoStreamer:EmitDwarfFileDirective not implemented\n"; 150 } 151 152 virtual void EmitInstruction(const MCInst &Inst); 153 virtual void Finish(); 154 155 /// @} 156}; 157 158} // end anonymous namespace. 159 160void MCMachOStreamer::SwitchSection(const MCSection *Section) { 161 assert(Section && "Cannot switch to a null section!"); 162 163 // If already in this section, then this is a noop. 164 if (Section == CurSection) return; 165 166 CurSection = Section; 167 CurSectionData = &getSectionData(*Section); 168} 169 170void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) { 171 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 172 173 // FIXME: We should also use offsets into Fill fragments. 174 MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); 175 if (!F) 176 F = new MCDataFragment(CurSectionData); 177 178 MCSymbolData &SD = getSymbolData(*Symbol); 179 assert(!SD.getFragment() && "Unexpected fragment on symbol data!"); 180 SD.setFragment(F); 181 SD.setOffset(F->getContents().size()); 182 183 // This causes the reference type and weak reference flags to be cleared. 184 SD.setFlags(SD.getFlags() & ~(SF_WeakReference | SF_ReferenceTypeMask)); 185 186 Symbol->setSection(*CurSection); 187} 188 189void MCMachOStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 190 switch (Flag) { 191 case MCAF_SubsectionsViaSymbols: 192 Assembler.setSubsectionsViaSymbols(true); 193 return; 194 } 195 196 assert(0 && "invalid assembler flag!"); 197} 198 199void MCMachOStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 200 // Only absolute symbols can be redefined. 201 assert((Symbol->isUndefined() || Symbol->isAbsolute()) && 202 "Cannot define a symbol twice!"); 203 204 // FIXME: Lift context changes into super class. 205 // FIXME: Set associated section. 206 Symbol->setValue(Value); 207} 208 209void MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 210 MCSymbolAttr Attribute) { 211 // Indirect symbols are handled differently, to match how 'as' handles 212 // them. This makes writing matching .o files easier. 213 if (Attribute == MCSA_IndirectSymbol) { 214 // Note that we intentionally cannot use the symbol data here; this is 215 // important for matching the string table that 'as' generates. 216 IndirectSymbolData ISD; 217 ISD.Symbol = Symbol; 218 ISD.SectionData = CurSectionData; 219 Assembler.getIndirectSymbols().push_back(ISD); 220 return; 221 } 222 223 // Adding a symbol attribute always introduces the symbol, note that an 224 // important side effect of calling getSymbolData here is to register the 225 // symbol with the assembler. 226 MCSymbolData &SD = getSymbolData(*Symbol); 227 228 // The implementation of symbol attributes is designed to match 'as', but it 229 // leaves much to desired. It doesn't really make sense to arbitrarily add and 230 // remove flags, but 'as' allows this (in particular, see .desc). 231 // 232 // In the future it might be worth trying to make these operations more well 233 // defined. 234 switch (Attribute) { 235 case MCSA_Invalid: 236 case MCSA_ELF_TypeFunction: 237 case MCSA_ELF_TypeIndFunction: 238 case MCSA_ELF_TypeObject: 239 case MCSA_ELF_TypeTLS: 240 case MCSA_ELF_TypeCommon: 241 case MCSA_ELF_TypeNoType: 242 case MCSA_IndirectSymbol: 243 case MCSA_Hidden: 244 case MCSA_Internal: 245 case MCSA_Protected: 246 case MCSA_Weak: 247 case MCSA_Local: 248 assert(0 && "Invalid symbol attribute for Mach-O!"); 249 break; 250 251 case MCSA_Global: 252 SD.setExternal(true); 253 break; 254 255 case MCSA_LazyReference: 256 // FIXME: This requires -dynamic. 257 SD.setFlags(SD.getFlags() | SF_NoDeadStrip); 258 if (Symbol->isUndefined()) 259 SD.setFlags(SD.getFlags() | SF_ReferenceTypeUndefinedLazy); 260 break; 261 262 // Since .reference sets the no dead strip bit, it is equivalent to 263 // .no_dead_strip in practice. 264 case MCSA_Reference: 265 case MCSA_NoDeadStrip: 266 SD.setFlags(SD.getFlags() | SF_NoDeadStrip); 267 break; 268 269 case MCSA_PrivateExtern: 270 SD.setExternal(true); 271 SD.setPrivateExtern(true); 272 break; 273 274 case MCSA_WeakReference: 275 // FIXME: This requires -dynamic. 276 if (Symbol->isUndefined()) 277 SD.setFlags(SD.getFlags() | SF_WeakReference); 278 break; 279 280 case MCSA_WeakDefinition: 281 // FIXME: 'as' enforces that this is defined and global. The manual claims 282 // it has to be in a coalesced section, but this isn't enforced. 283 SD.setFlags(SD.getFlags() | SF_WeakDefinition); 284 break; 285 } 286} 287 288void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 289 // Encode the 'desc' value into the lowest implementation defined bits. 290 assert(DescValue == (DescValue & SF_DescFlagsMask) && 291 "Invalid .desc value!"); 292 getSymbolData(*Symbol).setFlags(DescValue & SF_DescFlagsMask); 293} 294 295void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 296 unsigned ByteAlignment) { 297 // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself. 298 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 299 300 MCSymbolData &SD = getSymbolData(*Symbol); 301 SD.setExternal(true); 302 SD.setCommon(Size, ByteAlignment); 303} 304 305void MCMachOStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 306 unsigned Size, unsigned ByteAlignment) { 307 MCSectionData &SectData = getSectionData(*Section); 308 309 // The symbol may not be present, which only creates the section. 310 if (!Symbol) 311 return; 312 313 // FIXME: Assert that this section has the zerofill type. 314 315 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 316 317 MCSymbolData &SD = getSymbolData(*Symbol); 318 319 MCFragment *F = new MCZeroFillFragment(Size, ByteAlignment, &SectData); 320 SD.setFragment(F); 321 322 Symbol->setSection(*Section); 323 324 // Update the maximum alignment on the zero fill section if necessary. 325 if (ByteAlignment > SectData.getAlignment()) 326 SectData.setAlignment(ByteAlignment); 327} 328 329void MCMachOStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) { 330 MCDataFragment *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); 331 if (!DF) 332 DF = new MCDataFragment(CurSectionData); 333 DF->getContents().append(Data.begin(), Data.end()); 334} 335 336void MCMachOStreamer::EmitValue(const MCExpr *Value, unsigned Size, 337 unsigned AddrSpace) { 338 MCDataFragment *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); 339 if (!DF) 340 DF = new MCDataFragment(CurSectionData); 341 342 // Avoid fixups when possible. 343 int64_t AbsValue; 344 if (AddValueSymbols(Value)->EvaluateAsAbsolute(AbsValue)) { 345 // FIXME: Endianness assumption. 346 for (unsigned i = 0; i != Size; ++i) 347 DF->getContents().push_back(uint8_t(AbsValue >> (i * 8))); 348 } else { 349 DF->getFixups().push_back(MCAsmFixup(DF->getContents().size(), 350 *AddValueSymbols(Value), 351 MCFixup::getKindForSize(Size))); 352 DF->getContents().resize(DF->getContents().size() + Size, 0); 353 } 354} 355 356void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment, 357 int64_t Value, unsigned ValueSize, 358 unsigned MaxBytesToEmit) { 359 if (MaxBytesToEmit == 0) 360 MaxBytesToEmit = ByteAlignment; 361 new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit, 362 false /* EmitNops */, CurSectionData); 363 364 // Update the maximum alignment on the current section if necessary. 365 if (ByteAlignment > CurSectionData->getAlignment()) 366 CurSectionData->setAlignment(ByteAlignment); 367} 368 369void MCMachOStreamer::EmitCodeAlignment(unsigned ByteAlignment, 370 unsigned MaxBytesToEmit) { 371 if (MaxBytesToEmit == 0) 372 MaxBytesToEmit = ByteAlignment; 373 // FIXME the 0x90 is the default x86 1 byte nop opcode. 374 new MCAlignFragment(ByteAlignment, 0x90, 1, MaxBytesToEmit, 375 true /* EmitNops */, CurSectionData); 376 377 // Update the maximum alignment on the current section if necessary. 378 if (ByteAlignment > CurSectionData->getAlignment()) 379 CurSectionData->setAlignment(ByteAlignment); 380} 381 382void MCMachOStreamer::EmitValueToOffset(const MCExpr *Offset, 383 unsigned char Value) { 384 new MCOrgFragment(*Offset, Value, CurSectionData); 385} 386 387void MCMachOStreamer::EmitInstruction(const MCInst &Inst) { 388 // Scan for values. 389 for (unsigned i = 0; i != Inst.getNumOperands(); ++i) 390 if (Inst.getOperand(i).isExpr()) 391 AddValueSymbols(Inst.getOperand(i).getExpr()); 392 393 if (!Emitter) 394 llvm_unreachable("no code emitter available!"); 395 396 CurSectionData->setHasInstructions(true); 397 398 SmallVector<MCFixup, 4> Fixups; 399 SmallString<256> Code; 400 raw_svector_ostream VecOS(Code); 401 Emitter->EncodeInstruction(Inst, VecOS, Fixups); 402 VecOS.flush(); 403 404 // Add the fixups and data. 405 MCDataFragment *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment()); 406 if (!DF) 407 DF = new MCDataFragment(CurSectionData); 408 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 409 MCFixup &F = Fixups[i]; 410 DF->getFixups().push_back(MCAsmFixup(DF->getContents().size()+F.getOffset(), 411 *F.getValue(), 412 F.getKind())); 413 } 414 DF->getContents().append(Code.begin(), Code.end()); 415} 416 417void MCMachOStreamer::Finish() { 418 Assembler.Finish(); 419} 420 421MCStreamer *llvm::createMachOStreamer(MCContext &Context, raw_ostream &OS, 422 MCCodeEmitter *CE) { 423 return new MCMachOStreamer(Context, OS, CE); 424} 425