LLVM 20.0.0git
MCWinCOFFStreamer.cpp
Go to the documentation of this file.
1//===- llvm/MC/MCWinCOFFStreamer.cpp --------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains an implementation of a Windows COFF object file streamer.
10//
11//===----------------------------------------------------------------------===//
12
16#include "llvm/ADT/Twine.h"
19#include "llvm/MC/MCAssembler.h"
21#include "llvm/MC/MCContext.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCFixup.h"
24#include "llvm/MC/MCFragment.h"
35#include "llvm/Support/SMLoc.h"
38#include <algorithm>
39#include <cstdint>
40
41using namespace llvm;
42
43#define DEBUG_TYPE "WinCOFFStreamer"
44
46 std::unique_ptr<MCAsmBackend> MAB,
47 std::unique_ptr<MCCodeEmitter> CE,
48 std::unique_ptr<MCObjectWriter> OW)
49 : MCObjectStreamer(Context, std::move(MAB), std::move(OW), std::move(CE)),
50 CurSymbol(nullptr) {
51 auto *TO = Context.getTargetOptions();
52 if (TO && TO->MCIncrementalLinkerCompatible)
54}
55
57 return static_cast<WinCOFFObjectWriter &>(getAssembler().getWriter());
58}
59
61 const MCSubtargetInfo &STI) {
63
66 getAssembler().getEmitter().encodeInstruction(Inst, Code, Fixups, STI);
67
68 // Add the fixups and data.
69 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
70 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
71 DF->getFixups().push_back(Fixups[i]);
72 }
73 DF->setHasInstructions(STI);
74 DF->getContents().append(Code.begin(), Code.end());
75}
76
77void MCWinCOFFStreamer::initSections(bool NoExecStack,
78 const MCSubtargetInfo &STI) {
79 // FIXME: this is identical to the ELF one.
80 // This emulates the same behavior of GNU as. This makes it easier
81 // to compare the output as the major sections are in the same order.
82 switchSection(getContext().getObjectFileInfo()->getTextSection());
83 emitCodeAlignment(Align(4), &STI);
84
85 switchSection(getContext().getObjectFileInfo()->getDataSection());
86 emitCodeAlignment(Align(4), &STI);
87
88 switchSection(getContext().getObjectFileInfo()->getBSSSection());
89 emitCodeAlignment(Align(4), &STI);
90
91 switchSection(getContext().getObjectFileInfo()->getTextSection());
92}
93
95 changeSectionImpl(Section, Subsection);
96 // Ensure that the first and the second symbols relative to the section are
97 // the section symbol and the COMDAT symbol.
98 getAssembler().registerSymbol(*Section->getBeginSymbol());
99 if (auto *Sym = cast<MCSectionCOFF>(Section)->getCOMDATSymbol())
101}
102
104 auto *Symbol = cast<MCSymbolCOFF>(S);
105 MCObjectStreamer::emitLabel(Symbol, Loc);
106}
107
109 // Let the target do whatever target specific stuff it needs to do.
111
112 switch (Flag) {
113 // None of these require COFF specific handling.
115 case MCAF_Code16:
116 case MCAF_Code32:
117 case MCAF_Code64:
118 break;
120 llvm_unreachable("COFF doesn't support .subsections_via_symbols");
121 }
122}
123
125 llvm_unreachable("not implemented");
126}
127
130 auto *Symbol = cast<MCSymbolCOFF>(S);
131 getAssembler().registerSymbol(*Symbol);
132
133 switch (Attribute) {
134 default: return false;
136 case MCSA_Weak:
137 Symbol->setWeakExternalCharacteristics(COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS);
138 Symbol->setExternal(true);
139 break;
140 case MCSA_WeakAntiDep:
141 Symbol->setWeakExternalCharacteristics(COFF::IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY);
142 Symbol->setExternal(true);
143 Symbol->setIsWeakExternal(true);
144 break;
145 case MCSA_Global:
146 Symbol->setExternal(true);
147 break;
148 case MCSA_AltEntry:
149 llvm_unreachable("COFF doesn't support the .alt_entry attribute");
150 }
151
152 return true;
153}
154
155void MCWinCOFFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
156 llvm_unreachable("not implemented");
157}
158
160 auto *Symbol = cast<MCSymbolCOFF>(S);
161 if (CurSymbol)
162 Error("starting a new symbol definition without completing the "
163 "previous one");
164 CurSymbol = Symbol;
165}
166
168 if (!CurSymbol) {
169 Error("storage class specified outside of symbol definition");
170 return;
171 }
172
174 Error("storage class value '" + Twine(StorageClass) +
175 "' out of range");
176 return;
177 }
178
180 cast<MCSymbolCOFF>(CurSymbol)->setClass((uint16_t)StorageClass);
181}
182
184 if (!CurSymbol) {
185 Error("symbol type specified outside of a symbol definition");
186 return;
187 }
188
189 if (Type & ~0xffff) {
190 Error("type value '" + Twine(Type) + "' out of range");
191 return;
192 }
193
195 cast<MCSymbolCOFF>(CurSymbol)->setType((uint16_t)Type);
196}
197
199 if (!CurSymbol)
200 Error("ending symbol definition without starting one");
201 CurSymbol = nullptr;
202}
203
205 // SafeSEH is a feature specific to 32-bit x86. It does not exist (and is
206 // unnecessary) on all platforms which use table-based exception dispatch.
207 if (getContext().getTargetTriple().getArch() != Triple::x86)
208 return;
209
210 const MCSymbolCOFF *CSymbol = cast<MCSymbolCOFF>(Symbol);
211 if (CSymbol->isSafeSEH())
212 return;
213
215 changeSection(SXData);
216 SXData->ensureMinAlignment(Align(4));
217
218 insert(getContext().allocFragment<MCSymbolIdFragment>(Symbol));
219 getAssembler().registerSymbol(*Symbol);
220 CSymbol->setIsSafeSEH();
221
222 // The Microsoft linker requires that the symbol type of a handler be
223 // function. Go ahead and oblige it here.
226}
227
230 Sec->ensureMinAlignment(Align(4));
231
232 insert(getContext().allocFragment<MCSymbolIdFragment>(Symbol));
233 getAssembler().registerSymbol(*Symbol);
234}
235
237 visitUsedSymbol(*Symbol);
239 const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
240 MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_2);
241 DF->getFixups().push_back(Fixup);
242 DF->getContents().resize(DF->getContents().size() + 2, 0);
243}
244
247 visitUsedSymbol(*Symbol);
249 // Create Symbol A for the relocation relative reference.
250 const MCExpr *MCE = MCSymbolRefExpr::create(Symbol, getContext());
251 // Add the constant offset, if given.
252 if (Offset)
255 // Build the secrel32 relocation.
256 MCFixup Fixup = MCFixup::create(DF->getContents().size(), MCE, FK_SecRel_4);
257 // Record the relocation.
258 DF->getFixups().push_back(Fixup);
259 // Emit 4 bytes (zeros) to the object file.
260 DF->getContents().resize(DF->getContents().size() + 4, 0);
261}
262
264 int64_t Offset) {
265 visitUsedSymbol(*Symbol);
267 // Create Symbol A for the relocation relative reference.
268 const MCExpr *MCE = MCSymbolRefExpr::create(
270 // Add the constant offset, if given.
271 if (Offset)
274 // Build the imgrel relocation.
275 MCFixup Fixup = MCFixup::create(DF->getContents().size(), MCE, FK_Data_4);
276 // Record the relocation.
277 DF->getFixups().push_back(Fixup);
278 // Emit 4 bytes (zeros) to the object file.
279 DF->getContents().resize(DF->getContents().size() + 4, 0);
280}
281
283 Align ByteAlignment) {
284 auto *Symbol = cast<MCSymbolCOFF>(S);
285
286 const Triple &T = getContext().getTargetTriple();
287 if (T.isWindowsMSVCEnvironment()) {
288 if (ByteAlignment > 32)
289 report_fatal_error("alignment is limited to 32-bytes");
290
291 // Round size up to alignment so that we will honor the alignment request.
292 Size = std::max(Size, ByteAlignment.value());
293 }
294
295 getAssembler().registerSymbol(*Symbol);
296 Symbol->setExternal(true);
297 Symbol->setCommon(Size, ByteAlignment);
298
299 if (!T.isWindowsMSVCEnvironment() && ByteAlignment > 1) {
303
304 OS << " -aligncomm:\"" << Symbol->getName() << "\","
305 << Log2_32_Ceil(ByteAlignment.value());
306
307 pushSection();
310 popSection();
311 }
312}
313
315 Align ByteAlignment) {
316 auto *Symbol = cast<MCSymbolCOFF>(S);
317
319 pushSection();
320 switchSection(Section);
321 emitValueToAlignment(ByteAlignment, 0, 1, 0);
322 emitLabel(Symbol);
323 Symbol->setExternal(false);
325 popSection();
326}
327
329 const MCSymbol *Symbol) {
330 auto *Alias = cast<MCSymbolCOFF>(AliasS);
332
333 getAssembler().registerSymbol(*Symbol);
334 Alias->setVariableValue(MCSymbolRefExpr::create(
336}
337
339 uint64_t Size, Align ByteAlignment,
340 SMLoc Loc) {
341 llvm_unreachable("not implemented");
342}
343
345 uint64_t Size, Align ByteAlignment) {
346 llvm_unreachable("not implemented");
347}
348
349// TODO: Implement this if you want to emit .comment section in COFF obj files.
351 llvm_unreachable("not implemented");
352}
353
355 llvm_unreachable("not implemented");
356}
357
359 const MCSymbolRefExpr *To,
360 uint64_t Count) {
361 // Ignore temporary symbols for now.
362 if (!From->getSymbol().isTemporary() && !To->getSymbol().isTemporary())
363 getWriter().getCGProfile().push_back({From, To, Count});
364}
365
367 const MCSymbol *S = &SRE->getSymbol();
368 if (getAssembler().registerSymbol(*S))
369 cast<MCSymbolCOFF>(S)->setExternal(true);
370}
371
373 MCAssembler &Asm = getAssembler();
374 if (Asm.getWriter().getEmitAddrsigSection()) {
375 // Register the section.
376 switchSection(Asm.getContext().getCOFFSection(".llvm_addrsig",
378 }
379 if (!Asm.getWriter().getCGProfile().empty()) {
380 for (auto &E : Asm.getWriter().getCGProfile()) {
383 }
384 switchSection(Asm.getContext().getCOFFSection(".llvm.call-graph-profile",
386 }
387
389}
390
391void MCWinCOFFStreamer::Error(const Twine &Msg) const {
392 getContext().reportError(SMLoc(), Msg);
393}
BlockVerifier::State From
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
PowerPC TLS Dynamic Call Fixup
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the SmallVector class.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
virtual void handleAssemblerFlag(MCAssemblerFlag Flag)
Handle any target-specific assembler flags. By default, do nothing.
Definition: MCAsmBackend.h:225
MCObjectWriter & getWriter() const
Definition: MCAssembler.h:192
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:190
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:188
bool registerSymbol(const MCSymbol &Symbol)
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:532
virtual void encodeInstruction(const MCInst &Inst, SmallVectorImpl< char > &CB, SmallVectorImpl< MCFixup > &Fixups, const MCSubtargetInfo &STI) const =0
Encode the given Inst to bytes and append to CB.
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:193
Context object for machine code objects.
Definition: MCContext.h:83
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:416
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1067
const MCTargetOptions * getTargetOptions() const
Definition: MCContext.h:420
const Triple & getTargetTriple() const
Definition: MCContext.h:400
Fragment for data and encoded instructions.
Definition: MCFragment.h:231
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:87
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
MCSection * getSXDataSection() const
MCSection * getBSSSection() const
MCSection * getDrectveSection() const
Streaming object file generation interface.
void emitValueToAlignment(Align Alignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment.
MCAssembler & getAssembler()
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
bool changeSectionImpl(MCSection *Section, uint32_t Subsection)
void visitUsedSymbol(const MCSymbol &Sym) override
void insert(MCFragment *F)
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void finishImpl() override
Streamer specific finalization.
void emitCodeAlignment(Align ByteAlignment, const MCSubtargetInfo *STI, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
SmallVector< CGProfileEntry, 0 > & getCGProfile()
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
void ensureMinAlignment(Align MinAlignment)
Makes sure that Alignment is at least MinAlignment.
Definition: MCSection.h:148
bool popSection()
Restore the current and previous section from the section stack.
MCContext & getContext() const
Definition: MCStreamer.h:300
void pushSection()
Save the current and previous section on the section stack.
Definition: MCStreamer.h:416
virtual void switchSection(MCSection *Section, uint32_t Subsec=0)
Set the current section where code is being emitted to Section.
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:398
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:229
Generic base class for all target subtargets.
void setIsSafeSEH() const
Definition: MCSymbolCOFF.h:65
void setType(uint16_t Ty) const
Definition: MCSymbolCOFF.h:39
bool isSafeSEH() const
Definition: MCSymbolCOFF.h:62
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:188
const MCSymbol & getSymbol() const
Definition: MCExpr.h:406
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:393
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
void setExternal(bool Value) const
Definition: MCSymbol.h:408
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:222
void emitCOFFSectionIndex(MCSymbol const *Symbol) override
Emits a COFF section index.
void emitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
void finalizeCGProfileEntry(const MCSymbolRefExpr *&S)
void emitThumbFunc(MCSymbol *Func) override
Note in the output that the specified Func is a Thumb mode function (ARM target only).
void emitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override
Emits a COFF image relative relocation.
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size, Align ByteAlignment, SMLoc Loc=SMLoc()) override
Emit the zerofill section and an optional symbol.
void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
void initSections(bool NoExecStack, const MCSubtargetInfo &STI) override
Create the default sections and set the initial one.
void emitCOFFSafeSEH(MCSymbol const *Symbol) override
void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment) override
Emit a common symbol.
void endCOFFSymbolDef() override
Marks the end of the symbol definition.
MCWinCOFFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > MAB, std::unique_ptr< MCCodeEmitter > CE, std::unique_ptr< MCObjectWriter > OW)
void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, Align ByteAlignment) override
Emit a thread local bss (.tbss) symbol.
void changeSection(MCSection *Section, uint32_t Subsection=0) override
This is called by popSection and switchSection, if the current section changes.
void emitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override
Emits a COFF section relative relocation.
void finishImpl() override
Streamer specific finalization.
void emitIdent(StringRef IdentString) override
Emit the "identifiers" directive.
void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override
void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, Align ByteAlignment) override
Emit a local common (.lcomm) symbol.
WinCOFFObjectWriter & getWriter()
void emitCOFFSymbolType(int Type) override
Emit the type of the symbol.
void emitWinEHHandlerData(SMLoc Loc) override
void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override
Set the DescValue for the Symbol.
const MCSymbol * CurSymbol
bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override
Add the given Attribute to Symbol.
void emitCOFFSymbolIndex(MCSymbol const *Symbol) override
Emits the symbol table index of a Symbol into the current section.
void beginCOFFSymbolDef(MCSymbol const *Symbol) override
Start emitting COFF symbol definition.
void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override
void emitCOFFSymbolStorageClass(int StorageClass) override
Emit the storage class of the symbol.
Represents a location in source code.
Definition: SMLoc.h:23
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
void setIncrementalLinkerCompatible(bool Value)
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:691
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_SCN_LNK_REMOVE
Definition: COFF.h:307
@ SSC_Invalid
Definition: COFF.h:218
@ IMAGE_WEAK_EXTERN_SEARCH_ALIAS
Definition: COFF.h:456
@ IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY
Definition: COFF.h:457
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
Definition: COFF.h:275
@ SCT_COMPLEX_TYPE_SHIFT
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
Definition: COFF.h:279
StorageClass
Definition: XCOFF.h:170
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:353
@ Offset
Definition: DWP.cpp:480
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
@ FK_SecRel_2
A two-byte section relative fixup.
Definition: MCFixup.h:41
@ FK_Data_4
A four-byte fixup.
Definition: MCFixup.h:25
@ FK_SecRel_4
A four-byte section relative fixup.
Definition: MCFixup.h:42
MCAssemblerFlag
Definition: MCDirectives.h:53
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:54
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:58
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:56
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:57
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:55
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1849
MCSymbolAttr
Definition: MCDirectives.h:18
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:47
@ MCSA_AltEntry
.alt_entry (MachO)
Definition: MCDirectives.h:41
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
@ MCSA_WeakAntiDep
.weak_anti_dep (COFF)
Definition: MCDirectives.h:49
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39