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