WinCOFFStreamer.cpp revision ef76b273f96d99a4a260f3dcadde8fbb96256cf3
1//===-- llvm/MC/WinCOFFStreamer.cpp -----------------------------*- C++ -*-===// 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 contains an implementation of a Win32 COFF object file streamer. 11// 12//===----------------------------------------------------------------------===// 13 14#define DEBUG_TYPE "WinCOFFStreamer" 15 16#include "llvm/MC/MCStreamer.h" 17#include "llvm/MC/MCAsmBackend.h" 18#include "llvm/MC/MCAsmLayout.h" 19#include "llvm/MC/MCAssembler.h" 20#include "llvm/MC/MCCodeEmitter.h" 21#include "llvm/MC/MCContext.h" 22#include "llvm/MC/MCExpr.h" 23#include "llvm/MC/MCObjectStreamer.h" 24#include "llvm/MC/MCSection.h" 25#include "llvm/MC/MCSectionCOFF.h" 26#include "llvm/MC/MCSymbol.h" 27#include "llvm/MC/MCValue.h" 28#include "llvm/MC/MCWin64EH.h" 29#include "llvm/Support/COFF.h" 30#include "llvm/Support/Debug.h" 31#include "llvm/Support/ErrorHandling.h" 32#include "llvm/Support/TargetRegistry.h" 33#include "llvm/Support/raw_ostream.h" 34 35using namespace llvm; 36 37namespace { 38class WinCOFFStreamer : public MCObjectStreamer { 39public: 40 MCSymbol const *CurSymbol; 41 42 WinCOFFStreamer(MCContext &Context, 43 MCAsmBackend &MAB, 44 MCCodeEmitter &CE, 45 raw_ostream &OS); 46 47 void AddCommonSymbol(MCSymbol *Symbol, uint64_t Size, 48 unsigned ByteAlignment, bool External); 49 50 // MCStreamer interface 51 52 virtual void InitSections(); 53 virtual void EmitLabel(MCSymbol *Symbol); 54 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag); 55 virtual void EmitThumbFunc(MCSymbol *Func); 56 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value); 57 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute); 58 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue); 59 virtual void BeginCOFFSymbolDef(MCSymbol const *Symbol); 60 virtual void EmitCOFFSymbolStorageClass(int StorageClass); 61 virtual void EmitCOFFSymbolType(int Type); 62 virtual void EndCOFFSymbolDef(); 63 virtual void EmitCOFFSecRel32(MCSymbol const *Symbol); 64 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value); 65 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 66 unsigned ByteAlignment); 67 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 68 unsigned ByteAlignment); 69 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 70 uint64_t Size,unsigned ByteAlignment); 71 virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 72 uint64_t Size, unsigned ByteAlignment); 73 virtual void EmitFileDirective(StringRef Filename); 74 virtual void EmitInstruction(const MCInst &Instruction); 75 virtual void EmitWin64EHHandlerData(); 76 virtual void FinishImpl(); 77 78private: 79 virtual void EmitInstToFragment(const MCInst &Inst) { 80 llvm_unreachable("Not used by WinCOFF."); 81 } 82 virtual void EmitInstToData(const MCInst &Inst) { 83 llvm_unreachable("Not used by WinCOFF."); 84 } 85 86 void SetSection(StringRef Section, 87 unsigned Characteristics, 88 SectionKind Kind) { 89 SwitchSection(getContext().getCOFFSection(Section, Characteristics, Kind)); 90 } 91 92 void SetSectionText() { 93 SetSection(".text", 94 COFF::IMAGE_SCN_CNT_CODE 95 | COFF::IMAGE_SCN_MEM_EXECUTE 96 | COFF::IMAGE_SCN_MEM_READ, 97 SectionKind::getText()); 98 EmitCodeAlignment(4, 0); 99 } 100 101 void SetSectionData() { 102 SetSection(".data", 103 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA 104 | COFF::IMAGE_SCN_MEM_READ 105 | COFF::IMAGE_SCN_MEM_WRITE, 106 SectionKind::getDataRel()); 107 EmitCodeAlignment(4, 0); 108 } 109 110 void SetSectionBSS() { 111 SetSection(".bss", 112 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA 113 | COFF::IMAGE_SCN_MEM_READ 114 | COFF::IMAGE_SCN_MEM_WRITE, 115 SectionKind::getBSS()); 116 EmitCodeAlignment(4, 0); 117 } 118 119}; 120} // end anonymous namespace. 121 122WinCOFFStreamer::WinCOFFStreamer(MCContext &Context, 123 MCAsmBackend &MAB, 124 MCCodeEmitter &CE, 125 raw_ostream &OS) 126 : MCObjectStreamer(Context, MAB, OS, &CE) 127 , CurSymbol(NULL) { 128} 129 130void WinCOFFStreamer::AddCommonSymbol(MCSymbol *Symbol, uint64_t Size, 131 unsigned ByteAlignment, bool External) { 132 assert(!Symbol->isInSection() && "Symbol must not already have a section!"); 133 134 std::string SectionName(".bss$linkonce"); 135 SectionName.append(Symbol->getName().begin(), Symbol->getName().end()); 136 137 MCSymbolData &SymbolData = getAssembler().getOrCreateSymbolData(*Symbol); 138 139 unsigned Characteristics = 140 COFF::IMAGE_SCN_LNK_COMDAT | 141 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 142 COFF::IMAGE_SCN_MEM_READ | 143 COFF::IMAGE_SCN_MEM_WRITE; 144 145 int Selection = COFF::IMAGE_COMDAT_SELECT_LARGEST; 146 147 const MCSection *Section = MCStreamer::getContext().getCOFFSection( 148 SectionName, Characteristics, Selection, SectionKind::getBSS()); 149 150 MCSectionData &SectionData = getAssembler().getOrCreateSectionData(*Section); 151 152 if (SectionData.getAlignment() < ByteAlignment) 153 SectionData.setAlignment(ByteAlignment); 154 155 SymbolData.setExternal(External); 156 157 Symbol->setSection(*Section); 158 159 if (ByteAlignment != 1) 160 new MCAlignFragment(ByteAlignment, 0, 0, ByteAlignment, &SectionData); 161 162 SymbolData.setFragment(new MCFillFragment(0, 0, Size, &SectionData)); 163} 164 165// MCStreamer interface 166 167void WinCOFFStreamer::InitSections() { 168 SetSectionText(); 169 SetSectionData(); 170 SetSectionBSS(); 171 SetSectionText(); 172} 173 174void WinCOFFStreamer::EmitLabel(MCSymbol *Symbol) { 175 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 176 MCObjectStreamer::EmitLabel(Symbol); 177} 178 179void WinCOFFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 180 llvm_unreachable("not implemented"); 181} 182 183void WinCOFFStreamer::EmitThumbFunc(MCSymbol *Func) { 184 llvm_unreachable("not implemented"); 185} 186 187void WinCOFFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 188 assert((Symbol->isInSection() 189 ? Symbol->getSection().getVariant() == MCSection::SV_COFF 190 : true) && "Got non COFF section in the COFF backend!"); 191 // FIXME: This is all very ugly and depressing. What needs to happen here 192 // depends on quite a few things that are all part of relaxation, which we 193 // don't really even do. 194 195 if (Value->getKind() != MCExpr::SymbolRef) { 196 getAssembler().getOrCreateSymbolData(*Symbol); 197 AddValueSymbols(Value); 198 Symbol->setVariableValue(Value); 199 } else { 200 // FIXME: This is a horrible way to do this :(. This should really be 201 // handled after we are done with the MC* objects and immediately before 202 // writing out the object file when we know exactly what the symbol should 203 // look like in the coff symbol table. I'm not doing that now because the 204 // COFF object writer doesn't have a clearly defined separation between MC 205 // data structures, the object writers data structures, and the raw, POD, 206 // data structures that get written to disk. 207 208 // Copy over the aliased data. 209 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 210 const MCSymbolData &RealSD = getAssembler().getOrCreateSymbolData( 211 dyn_cast<const MCSymbolRefExpr>(Value)->getSymbol()); 212 213 // FIXME: This is particularly nasty because it breaks as soon as any data 214 // members of MCSymbolData change. 215 SD.CommonAlign = RealSD.CommonAlign; 216 SD.CommonSize = RealSD.CommonSize; 217 SD.Flags = RealSD.Flags; 218 SD.Fragment = RealSD.Fragment; 219 SD.Index = RealSD.Index; 220 SD.IsExternal = RealSD.IsExternal; 221 SD.IsPrivateExtern = RealSD.IsPrivateExtern; 222 SD.Offset = RealSD.Offset; 223 SD.SymbolSize = RealSD.SymbolSize; 224 } 225} 226 227void WinCOFFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 228 MCSymbolAttr Attribute) { 229 assert(Symbol && "Symbol must be non-null!"); 230 assert((Symbol->isInSection() 231 ? Symbol->getSection().getVariant() == MCSection::SV_COFF 232 : true) && "Got non COFF section in the COFF backend!"); 233 switch (Attribute) { 234 case MCSA_WeakReference: 235 case MCSA_Weak: { 236 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 237 SD.modifyFlags(COFF::SF_WeakExternal, COFF::SF_WeakExternal); 238 SD.setExternal(true); 239 } 240 break; 241 242 case MCSA_Global: 243 getAssembler().getOrCreateSymbolData(*Symbol).setExternal(true); 244 break; 245 246 default: 247 llvm_unreachable("unsupported attribute"); 248 } 249} 250 251void WinCOFFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 252 llvm_unreachable("not implemented"); 253} 254 255void WinCOFFStreamer::BeginCOFFSymbolDef(MCSymbol const *Symbol) { 256 assert((Symbol->isInSection() 257 ? Symbol->getSection().getVariant() == MCSection::SV_COFF 258 : true) && "Got non COFF section in the COFF backend!"); 259 assert(CurSymbol == NULL && "EndCOFFSymbolDef must be called between calls " 260 "to BeginCOFFSymbolDef!"); 261 CurSymbol = Symbol; 262} 263 264void WinCOFFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) { 265 assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!"); 266 assert((StorageClass & ~0xFF) == 0 && "StorageClass must only have data in " 267 "the first byte!"); 268 269 getAssembler().getOrCreateSymbolData(*CurSymbol).modifyFlags( 270 StorageClass << COFF::SF_ClassShift, 271 COFF::SF_ClassMask); 272} 273 274void WinCOFFStreamer::EmitCOFFSymbolType(int Type) { 275 assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!"); 276 assert((Type & ~0xFFFF) == 0 && "Type must only have data in the first 2 " 277 "bytes"); 278 279 getAssembler().getOrCreateSymbolData(*CurSymbol).modifyFlags( 280 Type << COFF::SF_TypeShift, 281 COFF::SF_TypeMask); 282} 283 284void WinCOFFStreamer::EndCOFFSymbolDef() { 285 assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!"); 286 CurSymbol = NULL; 287} 288 289void WinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) 290{ 291 MCDataFragment *DF = getOrCreateDataFragment(); 292 293 DF->addFixup(MCFixup::Create(DF->getContents().size(), 294 MCSymbolRefExpr::Create (Symbol, getContext ()), 295 FK_SecRel_4)); 296 DF->getContents().resize(DF->getContents().size() + 4, 0); 297} 298 299void WinCOFFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 300 llvm_unreachable("not implemented"); 301} 302 303void WinCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 304 unsigned ByteAlignment) { 305 assert((Symbol->isInSection() 306 ? Symbol->getSection().getVariant() == MCSection::SV_COFF 307 : true) && "Got non COFF section in the COFF backend!"); 308 AddCommonSymbol(Symbol, Size, ByteAlignment, true); 309} 310 311void WinCOFFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 312 unsigned ByteAlignment) { 313 assert((Symbol->isInSection() 314 ? Symbol->getSection().getVariant() == MCSection::SV_COFF 315 : true) && "Got non COFF section in the COFF backend!"); 316 AddCommonSymbol(Symbol, Size, ByteAlignment, false); 317} 318 319void WinCOFFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 320 uint64_t Size,unsigned ByteAlignment) { 321 llvm_unreachable("not implemented"); 322} 323 324void WinCOFFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 325 uint64_t Size, unsigned ByteAlignment) { 326 llvm_unreachable("not implemented"); 327} 328 329void WinCOFFStreamer::EmitFileDirective(StringRef Filename) { 330 // Ignore for now, linkers don't care, and proper debug 331 // info will be a much large effort. 332} 333 334void WinCOFFStreamer::EmitInstruction(const MCInst &Instruction) { 335 for (unsigned i = 0, e = Instruction.getNumOperands(); i != e; ++i) 336 if (Instruction.getOperand(i).isExpr()) 337 AddValueSymbols(Instruction.getOperand(i).getExpr()); 338 339 getCurrentSectionData()->setHasInstructions(true); 340 341 MCInstFragment *Fragment = 342 new MCInstFragment(Instruction, getCurrentSectionData()); 343 344 raw_svector_ostream VecOS(Fragment->getCode()); 345 346 getAssembler().getEmitter().EncodeInstruction(Instruction, VecOS, 347 Fragment->getFixups()); 348} 349 350void WinCOFFStreamer::EmitWin64EHHandlerData() { 351 MCStreamer::EmitWin64EHHandlerData(); 352 353 // We have to emit the unwind info now, because this directive 354 // actually switches to the .xdata section! 355 MCWin64EHUnwindEmitter::EmitUnwindInfo(*this, getCurrentW64UnwindInfo()); 356} 357 358void WinCOFFStreamer::FinishImpl() { 359 EmitW64Tables(); 360 MCObjectStreamer::FinishImpl(); 361} 362 363namespace llvm 364{ 365 MCStreamer *createWinCOFFStreamer(MCContext &Context, 366 MCAsmBackend &MAB, 367 MCCodeEmitter &CE, 368 raw_ostream &OS, 369 bool RelaxAll) { 370 WinCOFFStreamer *S = new WinCOFFStreamer(Context, MAB, CE, OS); 371 S->getAssembler().setRelaxAll(RelaxAll); 372 return S; 373 } 374} 375