/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/MC/MCStreamer.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===// |
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 | | #include "llvm/MC/MCStreamer.h" |
10 | | #include "llvm/ADT/Optional.h" |
11 | | #include "llvm/ADT/SmallString.h" |
12 | | #include "llvm/ADT/StringRef.h" |
13 | | #include "llvm/ADT/Twine.h" |
14 | | #include "llvm/BinaryFormat/COFF.h" |
15 | | #include "llvm/MC/MCAsmBackend.h" |
16 | | #include "llvm/MC/MCAsmInfo.h" |
17 | | #include "llvm/MC/MCCodeView.h" |
18 | | #include "llvm/MC/MCContext.h" |
19 | | #include "llvm/MC/MCDwarf.h" |
20 | | #include "llvm/MC/MCExpr.h" |
21 | | #include "llvm/MC/MCInst.h" |
22 | | #include "llvm/MC/MCInstPrinter.h" |
23 | | #include "llvm/MC/MCObjectFileInfo.h" |
24 | | #include "llvm/MC/MCSection.h" |
25 | | #include "llvm/MC/MCSectionCOFF.h" |
26 | | #include "llvm/MC/MCSymbol.h" |
27 | | #include "llvm/MC/MCWin64EH.h" |
28 | | #include "llvm/MC/MCWinEH.h" |
29 | | #include "llvm/Support/Casting.h" |
30 | | #include "llvm/Support/ErrorHandling.h" |
31 | | #include "llvm/Support/LEB128.h" |
32 | | #include "llvm/Support/MathExtras.h" |
33 | | #include "llvm/Support/raw_ostream.h" |
34 | | #include <cassert> |
35 | | #include <cstdint> |
36 | | #include <cstdlib> |
37 | | #include <utility> |
38 | | |
39 | | using namespace llvm; |
40 | | |
41 | 32.2k | MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) { |
42 | 32.2k | S.setTargetStreamer(this); |
43 | 32.2k | } |
44 | | |
45 | | // Pin the vtables to this file. |
46 | 32.0k | MCTargetStreamer::~MCTargetStreamer() = default; |
47 | | |
48 | 1.39M | void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {} |
49 | | |
50 | 15.4k | void MCTargetStreamer::finish() {} |
51 | | |
52 | | void MCTargetStreamer::changeSection(const MCSection *CurSection, |
53 | | MCSection *Section, |
54 | | const MCExpr *Subsection, |
55 | 193k | raw_ostream &OS) { |
56 | 193k | Section->PrintSwitchToSection( |
57 | 193k | *Streamer.getContext().getAsmInfo(), |
58 | 193k | Streamer.getContext().getObjectFileInfo()->getTargetTriple(), OS, |
59 | 193k | Subsection); |
60 | 193k | } |
61 | | |
62 | 385 | void MCTargetStreamer::emitDwarfFileDirective(StringRef Directive) { |
63 | 385 | Streamer.EmitRawText(Directive); |
64 | 385 | } |
65 | | |
66 | 604k | void MCTargetStreamer::emitValue(const MCExpr *Value) { |
67 | 604k | SmallString<128> Str; |
68 | 604k | raw_svector_ostream OS(Str); |
69 | 604k | |
70 | 604k | Value->print(OS, Streamer.getContext().getAsmInfo()); |
71 | 604k | Streamer.EmitRawText(OS.str()); |
72 | 604k | } |
73 | | |
74 | 40.0k | void MCTargetStreamer::emitRawBytes(StringRef Data) { |
75 | 40.0k | const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo(); |
76 | 40.0k | const char *Directive = MAI->getData8bitsDirective(); |
77 | 44.0k | for (const unsigned char C : Data.bytes()) { |
78 | 44.0k | SmallString<128> Str; |
79 | 44.0k | raw_svector_ostream OS(Str); |
80 | 44.0k | |
81 | 44.0k | OS << Directive << (unsigned)C; |
82 | 44.0k | Streamer.EmitRawText(OS.str()); |
83 | 44.0k | } |
84 | 40.0k | } |
85 | | |
86 | 156k | void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {} |
87 | | |
88 | | MCStreamer::MCStreamer(MCContext &Ctx) |
89 | | : Context(Ctx), CurrentWinFrameInfo(nullptr), |
90 | 48.3k | UseAssemblerInfoForParsing(false) { |
91 | 48.3k | SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); |
92 | 48.3k | } |
93 | | |
94 | 48.1k | MCStreamer::~MCStreamer() {} |
95 | | |
96 | 35.8k | void MCStreamer::reset() { |
97 | 35.8k | DwarfFrameInfos.clear(); |
98 | 35.8k | CurrentWinFrameInfo = nullptr; |
99 | 35.8k | WinFrameInfos.clear(); |
100 | 35.8k | SymbolOrdering.clear(); |
101 | 35.8k | SectionStack.clear(); |
102 | 35.8k | SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); |
103 | 35.8k | } |
104 | | |
105 | 0 | raw_ostream &MCStreamer::GetCommentOS() { |
106 | 0 | // By default, discard comments. |
107 | 0 | return nulls(); |
108 | 0 | } |
109 | | |
110 | 22.9k | unsigned MCStreamer::getNumFrameInfos() { return DwarfFrameInfos.size(); } |
111 | 7.71k | ArrayRef<MCDwarfFrameInfo> MCStreamer::getDwarfFrameInfos() const { |
112 | 7.71k | return DwarfFrameInfos; |
113 | 7.71k | } |
114 | | |
115 | 20.8k | void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {} |
116 | | |
117 | 124k | void MCStreamer::addExplicitComment(const Twine &T) {} |
118 | 0 | void MCStreamer::emitExplicitComments() {} |
119 | | |
120 | 5.62k | void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) { |
121 | 5.62k | for (auto &FI : DwarfFrameInfos) |
122 | 65.5k | FI.CompactUnwindEncoding = |
123 | 65.5k | (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions)64.5k : 01.04k ); |
124 | 5.62k | } |
125 | | |
126 | | /// EmitIntValue - Special case of EmitValue that avoids the client having to |
127 | | /// pass in a MCExpr for constant integers. |
128 | 8.45M | void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) { |
129 | 8.45M | assert(1 <= Size && Size <= 8 && "Invalid size"); |
130 | 8.45M | assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) && |
131 | 8.45M | "Invalid size"); |
132 | 8.45M | char buf[8]; |
133 | 8.45M | const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian(); |
134 | 25.6M | for (unsigned i = 0; i != Size; ++i17.1M ) { |
135 | 17.1M | unsigned index = isLittleEndian ? i17.1M : (Size - i - 1)26.9k ; |
136 | 17.1M | buf[i] = uint8_t(Value >> (index * 8)); |
137 | 17.1M | } |
138 | 8.45M | EmitBytes(StringRef(buf, Size)); |
139 | 8.45M | } |
140 | | |
141 | | /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the |
142 | | /// client having to pass in a MCExpr for constant integers. |
143 | 2.08M | void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned PadTo) { |
144 | 2.08M | SmallString<128> Tmp; |
145 | 2.08M | raw_svector_ostream OSE(Tmp); |
146 | 2.08M | encodeULEB128(Value, OSE, PadTo); |
147 | 2.08M | EmitBytes(OSE.str()); |
148 | 2.08M | } |
149 | | |
150 | | /// EmitSLEB128IntValue - Special case of EmitSLEB128Value that avoids the |
151 | | /// client having to pass in a MCExpr for constant integers. |
152 | 7.89k | void MCStreamer::EmitSLEB128IntValue(int64_t Value) { |
153 | 7.89k | SmallString<128> Tmp; |
154 | 7.89k | raw_svector_ostream OSE(Tmp); |
155 | 7.89k | encodeSLEB128(Value, OSE); |
156 | 7.89k | EmitBytes(OSE.str()); |
157 | 7.89k | } |
158 | | |
159 | 1.51M | void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) { |
160 | 1.51M | EmitValueImpl(Value, Size, Loc); |
161 | 1.51M | } |
162 | | |
163 | | void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size, |
164 | 487k | bool IsSectionRelative) { |
165 | 487k | assert((!IsSectionRelative || Size == 4) && |
166 | 487k | "SectionRelative value requires 4-bytes"); |
167 | 487k | |
168 | 487k | if (!IsSectionRelative) |
169 | 487k | EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size); |
170 | 6 | else |
171 | 6 | EmitCOFFSecRel32(Sym, /*Offset=*/0); |
172 | 487k | } |
173 | | |
174 | 0 | void MCStreamer::EmitDTPRel64Value(const MCExpr *Value) { |
175 | 0 | report_fatal_error("unsupported directive in streamer"); |
176 | 0 | } |
177 | | |
178 | 0 | void MCStreamer::EmitDTPRel32Value(const MCExpr *Value) { |
179 | 0 | report_fatal_error("unsupported directive in streamer"); |
180 | 0 | } |
181 | | |
182 | 0 | void MCStreamer::EmitTPRel64Value(const MCExpr *Value) { |
183 | 0 | report_fatal_error("unsupported directive in streamer"); |
184 | 0 | } |
185 | | |
186 | 0 | void MCStreamer::EmitTPRel32Value(const MCExpr *Value) { |
187 | 0 | report_fatal_error("unsupported directive in streamer"); |
188 | 0 | } |
189 | | |
190 | 0 | void MCStreamer::EmitGPRel64Value(const MCExpr *Value) { |
191 | 0 | report_fatal_error("unsupported directive in streamer"); |
192 | 0 | } |
193 | | |
194 | 0 | void MCStreamer::EmitGPRel32Value(const MCExpr *Value) { |
195 | 0 | report_fatal_error("unsupported directive in streamer"); |
196 | 0 | } |
197 | | |
198 | | /// Emit NumBytes bytes worth of the value specified by FillValue. |
199 | | /// This implements directives such as '.space'. |
200 | 683k | void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) { |
201 | 683k | emitFill(*MCConstantExpr::create(NumBytes, getContext()), FillValue); |
202 | 683k | } |
203 | | |
204 | | /// The implementation in this class just redirects to emitFill. |
205 | 679k | void MCStreamer::EmitZeros(uint64_t NumBytes) { |
206 | 679k | emitFill(NumBytes, 0); |
207 | 679k | } |
208 | | |
209 | | Expected<unsigned> |
210 | | MCStreamer::tryEmitDwarfFileDirective(unsigned FileNo, StringRef Directory, |
211 | | StringRef Filename, |
212 | | Optional<MD5::MD5Result> Checksum, |
213 | | Optional<StringRef> Source, |
214 | 1.24M | unsigned CUID) { |
215 | 1.24M | return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum, |
216 | 1.24M | Source, CUID); |
217 | 1.24M | } |
218 | | |
219 | | void MCStreamer::emitDwarfFile0Directive(StringRef Directory, |
220 | | StringRef Filename, |
221 | | Optional<MD5::MD5Result> Checksum, |
222 | | Optional<StringRef> Source, |
223 | 2.21k | unsigned CUID) { |
224 | 2.21k | getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum, |
225 | 2.21k | Source); |
226 | 2.21k | } |
227 | | |
228 | 4 | void MCStreamer::EmitCFIBKeyFrame() { |
229 | 4 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
230 | 4 | if (!CurFrame) |
231 | 0 | return; |
232 | 4 | CurFrame->IsBKeyFrame = true; |
233 | 4 | } |
234 | | |
235 | | void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line, |
236 | | unsigned Column, unsigned Flags, |
237 | | unsigned Isa, |
238 | | unsigned Discriminator, |
239 | 969k | StringRef FileName) { |
240 | 969k | getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa, |
241 | 969k | Discriminator); |
242 | 969k | } |
243 | | |
244 | 2.71k | MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) { |
245 | 2.71k | MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID); |
246 | 2.71k | if (!Table.getLabel()) { |
247 | 2.70k | StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix(); |
248 | 2.70k | Table.setLabel( |
249 | 2.70k | Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID))); |
250 | 2.70k | } |
251 | 2.71k | return Table.getLabel(); |
252 | 2.71k | } |
253 | | |
254 | 795k | bool MCStreamer::hasUnfinishedDwarfFrameInfo() { |
255 | 795k | return !DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End780k ; |
256 | 795k | } |
257 | | |
258 | 615k | MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() { |
259 | 615k | if (!hasUnfinishedDwarfFrameInfo()) { |
260 | 4 | getContext().reportError(SMLoc(), "this directive must appear between " |
261 | 4 | ".cfi_startproc and .cfi_endproc " |
262 | 4 | "directives"); |
263 | 4 | return nullptr; |
264 | 4 | } |
265 | 615k | return &DwarfFrameInfos.back(); |
266 | 615k | } |
267 | | |
268 | | bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename, |
269 | | ArrayRef<uint8_t> Checksum, |
270 | 132 | unsigned ChecksumKind) { |
271 | 132 | return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum, |
272 | 132 | ChecksumKind); |
273 | 132 | } |
274 | | |
275 | 492 | bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) { |
276 | 492 | return getContext().getCVContext().recordFunctionId(FunctionId); |
277 | 492 | } |
278 | | |
279 | | bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId, |
280 | | unsigned IAFunc, unsigned IAFile, |
281 | | unsigned IALine, unsigned IACol, |
282 | 48 | SMLoc Loc) { |
283 | 48 | if (getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr) { |
284 | 0 | getContext().reportError(Loc, "parent function id not introduced by " |
285 | 0 | ".cv_func_id or .cv_inline_site_id"); |
286 | 0 | return true; |
287 | 0 | } |
288 | 48 | |
289 | 48 | return getContext().getCVContext().recordInlinedCallSiteId( |
290 | 48 | FunctionId, IAFunc, IAFile, IALine, IACol); |
291 | 48 | } |
292 | | |
293 | | void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, |
294 | | unsigned Line, unsigned Column, |
295 | | bool PrologueEnd, bool IsStmt, |
296 | 0 | StringRef FileName, SMLoc Loc) {} |
297 | | |
298 | | bool MCStreamer::checkCVLocSection(unsigned FuncId, unsigned FileNo, |
299 | 1.51k | SMLoc Loc) { |
300 | 1.51k | CodeViewContext &CVC = getContext().getCVContext(); |
301 | 1.51k | MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FuncId); |
302 | 1.51k | if (!FI) { |
303 | 0 | getContext().reportError( |
304 | 0 | Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id"); |
305 | 0 | return false; |
306 | 0 | } |
307 | 1.51k | |
308 | 1.51k | // Track the section |
309 | 1.51k | if (FI->Section == nullptr) |
310 | 531 | FI->Section = getCurrentSectionOnly(); |
311 | 983 | else if (FI->Section != getCurrentSectionOnly()) { |
312 | 1 | getContext().reportError( |
313 | 1 | Loc, |
314 | 1 | "all .cv_loc directives for a function must be in the same section"); |
315 | 1 | return false; |
316 | 1 | } |
317 | 1.51k | return true; |
318 | 1.51k | } |
319 | | |
320 | | void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId, |
321 | | const MCSymbol *Begin, |
322 | 481 | const MCSymbol *End) {} |
323 | | |
324 | | void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId, |
325 | | unsigned SourceFileId, |
326 | | unsigned SourceLineNum, |
327 | | const MCSymbol *FnStartSym, |
328 | 46 | const MCSymbol *FnEndSym) {} |
329 | | |
330 | | void MCStreamer::EmitCVDefRangeDirective( |
331 | | ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, |
332 | 628 | StringRef FixedSizePortion) {} |
333 | | |
334 | | void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol, |
335 | 0 | MCSymbol *EHSymbol) { |
336 | 0 | } |
337 | | |
338 | 42.1k | void MCStreamer::InitSections(bool NoExecStack) { |
339 | 42.1k | SwitchSection(getContext().getObjectFileInfo()->getTextSection()); |
340 | 42.1k | } |
341 | | |
342 | 375 | void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) { |
343 | 375 | assert(Fragment); |
344 | 375 | Symbol->setFragment(Fragment); |
345 | 375 | |
346 | 375 | // As we emit symbols into a section, track the order so that they can |
347 | 375 | // be sorted upon later. Zero is reserved to mean 'unemitted'. |
348 | 375 | SymbolOrdering[Symbol] = 1 + SymbolOrdering.size(); |
349 | 375 | } |
350 | | |
351 | 6.21M | void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { |
352 | 6.21M | Symbol->redefineIfPossible(); |
353 | 6.21M | |
354 | 6.21M | if (!Symbol->isUndefined() || Symbol->isVariable()6.21M ) |
355 | 16 | return getContext().reportError(Loc, "invalid symbol redefinition"); |
356 | 6.21M | |
357 | 6.21M | assert(!Symbol->isVariable() && "Cannot emit a variable symbol!"); |
358 | 6.21M | assert(getCurrentSectionOnly() && "Cannot emit before setting section!"); |
359 | 6.21M | assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!"); |
360 | 6.21M | assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); |
361 | 6.21M | |
362 | 6.21M | Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment()); |
363 | 6.21M | |
364 | 6.21M | MCTargetStreamer *TS = getTargetStreamer(); |
365 | 6.21M | if (TS) |
366 | 1.41M | TS->emitLabel(Symbol); |
367 | 6.21M | } |
368 | | |
369 | 292 | void MCStreamer::EmitCFISections(bool EH, bool Debug) { |
370 | 292 | assert(EH || Debug); |
371 | 292 | } |
372 | | |
373 | 179k | void MCStreamer::EmitCFIStartProc(bool IsSimple, SMLoc Loc) { |
374 | 179k | if (hasUnfinishedDwarfFrameInfo()) |
375 | 3 | return getContext().reportError( |
376 | 3 | Loc, "starting new .cfi frame before finishing the previous one"); |
377 | 179k | |
378 | 179k | MCDwarfFrameInfo Frame; |
379 | 179k | Frame.IsSimple = IsSimple; |
380 | 179k | EmitCFIStartProcImpl(Frame); |
381 | 179k | |
382 | 179k | const MCAsmInfo* MAI = Context.getAsmInfo(); |
383 | 179k | if (MAI) { |
384 | 280k | for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) { |
385 | 280k | if (Inst.getOperation() == MCCFIInstruction::OpDefCfa || |
386 | 280k | Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister107k ) { |
387 | 179k | Frame.CurrentCfaRegister = Inst.getRegister(); |
388 | 179k | } |
389 | 280k | } |
390 | 179k | } |
391 | 179k | |
392 | 179k | DwarfFrameInfos.push_back(Frame); |
393 | 179k | } |
394 | | |
395 | 14 | void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) { |
396 | 14 | } |
397 | | |
398 | 179k | void MCStreamer::EmitCFIEndProc() { |
399 | 179k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
400 | 179k | if (!CurFrame) |
401 | 0 | return; |
402 | 179k | EmitCFIEndProcImpl(*CurFrame); |
403 | 179k | } |
404 | | |
405 | 114k | void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) { |
406 | 114k | // Put a dummy non-null value in Frame.End to mark that this frame has been |
407 | 114k | // closed. |
408 | 114k | Frame.End = (MCSymbol *)1; |
409 | 114k | } |
410 | | |
411 | 48.8k | MCSymbol *MCStreamer::EmitCFILabel() { |
412 | 48.8k | // Return a dummy non-null value so that label fields appear filled in when |
413 | 48.8k | // generating textual assembly. |
414 | 48.8k | return (MCSymbol *)1; |
415 | 48.8k | } |
416 | | |
417 | 34.4k | void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) { |
418 | 34.4k | MCSymbol *Label = EmitCFILabel(); |
419 | 34.4k | MCCFIInstruction Instruction = |
420 | 34.4k | MCCFIInstruction::createDefCfa(Label, Register, Offset); |
421 | 34.4k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
422 | 34.4k | if (!CurFrame) |
423 | 4 | return; |
424 | 34.4k | CurFrame->Instructions.push_back(Instruction); |
425 | 34.4k | CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register); |
426 | 34.4k | } |
427 | | |
428 | 42.7k | void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) { |
429 | 42.7k | MCSymbol *Label = EmitCFILabel(); |
430 | 42.7k | MCCFIInstruction Instruction = |
431 | 42.7k | MCCFIInstruction::createDefCfaOffset(Label, Offset); |
432 | 42.7k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
433 | 42.7k | if (!CurFrame) |
434 | 0 | return; |
435 | 42.7k | CurFrame->Instructions.push_back(Instruction); |
436 | 42.7k | } |
437 | | |
438 | 2.44k | void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) { |
439 | 2.44k | MCSymbol *Label = EmitCFILabel(); |
440 | 2.44k | MCCFIInstruction Instruction = |
441 | 2.44k | MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment); |
442 | 2.44k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
443 | 2.44k | if (!CurFrame) |
444 | 0 | return; |
445 | 2.44k | CurFrame->Instructions.push_back(Instruction); |
446 | 2.44k | } |
447 | | |
448 | 23.6k | void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) { |
449 | 23.6k | MCSymbol *Label = EmitCFILabel(); |
450 | 23.6k | MCCFIInstruction Instruction = |
451 | 23.6k | MCCFIInstruction::createDefCfaRegister(Label, Register); |
452 | 23.6k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
453 | 23.6k | if (!CurFrame) |
454 | 0 | return; |
455 | 23.6k | CurFrame->Instructions.push_back(Instruction); |
456 | 23.6k | CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register); |
457 | 23.6k | } |
458 | | |
459 | 324k | void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) { |
460 | 324k | MCSymbol *Label = EmitCFILabel(); |
461 | 324k | MCCFIInstruction Instruction = |
462 | 324k | MCCFIInstruction::createOffset(Label, Register, Offset); |
463 | 324k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
464 | 324k | if (!CurFrame) |
465 | 0 | return; |
466 | 324k | CurFrame->Instructions.push_back(Instruction); |
467 | 324k | } |
468 | | |
469 | 148 | void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) { |
470 | 148 | MCSymbol *Label = EmitCFILabel(); |
471 | 148 | MCCFIInstruction Instruction = |
472 | 148 | MCCFIInstruction::createRelOffset(Label, Register, Offset); |
473 | 148 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
474 | 148 | if (!CurFrame) |
475 | 0 | return; |
476 | 148 | CurFrame->Instructions.push_back(Instruction); |
477 | 148 | } |
478 | | |
479 | | void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym, |
480 | 3.39k | unsigned Encoding) { |
481 | 3.39k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
482 | 3.39k | if (!CurFrame) |
483 | 0 | return; |
484 | 3.39k | CurFrame->Personality = Sym; |
485 | 3.39k | CurFrame->PersonalityEncoding = Encoding; |
486 | 3.39k | } |
487 | | |
488 | 3.35k | void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) { |
489 | 3.35k | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
490 | 3.35k | if (!CurFrame) |
491 | 0 | return; |
492 | 3.35k | CurFrame->Lsda = Sym; |
493 | 3.35k | CurFrame->LsdaEncoding = Encoding; |
494 | 3.35k | } |
495 | | |
496 | 2 | void MCStreamer::EmitCFIRememberState() { |
497 | 2 | MCSymbol *Label = EmitCFILabel(); |
498 | 2 | MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label); |
499 | 2 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
500 | 2 | if (!CurFrame) |
501 | 0 | return; |
502 | 2 | CurFrame->Instructions.push_back(Instruction); |
503 | 2 | } |
504 | | |
505 | 2 | void MCStreamer::EmitCFIRestoreState() { |
506 | 2 | // FIXME: Error if there is no matching cfi_remember_state. |
507 | 2 | MCSymbol *Label = EmitCFILabel(); |
508 | 2 | MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label); |
509 | 2 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
510 | 2 | if (!CurFrame) |
511 | 0 | return; |
512 | 2 | CurFrame->Instructions.push_back(Instruction); |
513 | 2 | } |
514 | | |
515 | 6 | void MCStreamer::EmitCFISameValue(int64_t Register) { |
516 | 6 | MCSymbol *Label = EmitCFILabel(); |
517 | 6 | MCCFIInstruction Instruction = |
518 | 6 | MCCFIInstruction::createSameValue(Label, Register); |
519 | 6 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
520 | 6 | if (!CurFrame) |
521 | 0 | return; |
522 | 6 | CurFrame->Instructions.push_back(Instruction); |
523 | 6 | } |
524 | | |
525 | 241 | void MCStreamer::EmitCFIRestore(int64_t Register) { |
526 | 241 | MCSymbol *Label = EmitCFILabel(); |
527 | 241 | MCCFIInstruction Instruction = |
528 | 241 | MCCFIInstruction::createRestore(Label, Register); |
529 | 241 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
530 | 241 | if (!CurFrame) |
531 | 0 | return; |
532 | 241 | CurFrame->Instructions.push_back(Instruction); |
533 | 241 | } |
534 | | |
535 | 4 | void MCStreamer::EmitCFIEscape(StringRef Values) { |
536 | 4 | MCSymbol *Label = EmitCFILabel(); |
537 | 4 | MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values); |
538 | 4 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
539 | 4 | if (!CurFrame) |
540 | 0 | return; |
541 | 4 | CurFrame->Instructions.push_back(Instruction); |
542 | 4 | } |
543 | | |
544 | 32 | void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) { |
545 | 32 | MCSymbol *Label = EmitCFILabel(); |
546 | 32 | MCCFIInstruction Instruction = |
547 | 32 | MCCFIInstruction::createGnuArgsSize(Label, Size); |
548 | 32 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
549 | 32 | if (!CurFrame) |
550 | 0 | return; |
551 | 32 | CurFrame->Instructions.push_back(Instruction); |
552 | 32 | } |
553 | | |
554 | 1 | void MCStreamer::EmitCFISignalFrame() { |
555 | 1 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
556 | 1 | if (!CurFrame) |
557 | 0 | return; |
558 | 1 | CurFrame->IsSignalFrame = true; |
559 | 1 | } |
560 | | |
561 | 1 | void MCStreamer::EmitCFIUndefined(int64_t Register) { |
562 | 1 | MCSymbol *Label = EmitCFILabel(); |
563 | 1 | MCCFIInstruction Instruction = |
564 | 1 | MCCFIInstruction::createUndefined(Label, Register); |
565 | 1 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
566 | 1 | if (!CurFrame) |
567 | 0 | return; |
568 | 1 | CurFrame->Instructions.push_back(Instruction); |
569 | 1 | } |
570 | | |
571 | 380 | void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) { |
572 | 380 | MCSymbol *Label = EmitCFILabel(); |
573 | 380 | MCCFIInstruction Instruction = |
574 | 380 | MCCFIInstruction::createRegister(Label, Register1, Register2); |
575 | 380 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
576 | 380 | if (!CurFrame) |
577 | 0 | return; |
578 | 380 | CurFrame->Instructions.push_back(Instruction); |
579 | 380 | } |
580 | | |
581 | 378 | void MCStreamer::EmitCFIWindowSave() { |
582 | 378 | MCSymbol *Label = EmitCFILabel(); |
583 | 378 | MCCFIInstruction Instruction = |
584 | 378 | MCCFIInstruction::createWindowSave(Label); |
585 | 378 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
586 | 378 | if (!CurFrame) |
587 | 0 | return; |
588 | 378 | CurFrame->Instructions.push_back(Instruction); |
589 | 378 | } |
590 | | |
591 | 11 | void MCStreamer::EmitCFINegateRAState() { |
592 | 11 | MCSymbol *Label = EmitCFILabel(); |
593 | 11 | MCCFIInstruction Instruction = MCCFIInstruction::createNegateRAState(Label); |
594 | 11 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
595 | 11 | if (!CurFrame) |
596 | 0 | return; |
597 | 11 | CurFrame->Instructions.push_back(Instruction); |
598 | 11 | } |
599 | | |
600 | 6 | void MCStreamer::EmitCFIReturnColumn(int64_t Register) { |
601 | 6 | MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo(); |
602 | 6 | if (!CurFrame) |
603 | 0 | return; |
604 | 6 | CurFrame->RAReg = Register; |
605 | 6 | } |
606 | | |
607 | 4.41k | WinEH::FrameInfo *MCStreamer::EnsureValidWinFrameInfo(SMLoc Loc) { |
608 | 4.41k | const MCAsmInfo *MAI = Context.getAsmInfo(); |
609 | 4.41k | if (!MAI->usesWindowsCFI()) { |
610 | 0 | getContext().reportError( |
611 | 0 | Loc, ".seh_* directives are not supported on this target"); |
612 | 0 | return nullptr; |
613 | 0 | } |
614 | 4.41k | if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End4.41k ) { |
615 | 3 | getContext().reportError( |
616 | 3 | Loc, ".seh_ directive must appear within an active frame"); |
617 | 3 | return nullptr; |
618 | 3 | } |
619 | 4.41k | return CurrentWinFrameInfo; |
620 | 4.41k | } |
621 | | |
622 | 904 | void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) { |
623 | 904 | const MCAsmInfo *MAI = Context.getAsmInfo(); |
624 | 904 | if (!MAI->usesWindowsCFI()) |
625 | 0 | return getContext().reportError( |
626 | 0 | Loc, ".seh_* directives are not supported on this target"); |
627 | 904 | if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End613 ) |
628 | 0 | getContext().reportError( |
629 | 0 | Loc, "Starting a function before ending the previous one!"); |
630 | 904 | |
631 | 904 | MCSymbol *StartProc = EmitCFILabel(); |
632 | 904 | |
633 | 904 | WinFrameInfos.emplace_back( |
634 | 904 | llvm::make_unique<WinEH::FrameInfo>(Symbol, StartProc)); |
635 | 904 | CurrentWinFrameInfo = WinFrameInfos.back().get(); |
636 | 904 | CurrentWinFrameInfo->TextSection = getCurrentSectionOnly(); |
637 | 904 | } |
638 | | |
639 | 903 | void MCStreamer::EmitWinCFIEndProc(SMLoc Loc) { |
640 | 903 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
641 | 903 | if (!CurFrame) |
642 | 0 | return; |
643 | 903 | if (CurFrame->ChainedParent) |
644 | 0 | getContext().reportError(Loc, "Not all chained regions terminated!"); |
645 | 903 | |
646 | 903 | MCSymbol *Label = EmitCFILabel(); |
647 | 903 | CurFrame->End = Label; |
648 | 903 | } |
649 | | |
650 | 16 | void MCStreamer::EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) { |
651 | 16 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
652 | 16 | if (!CurFrame) |
653 | 0 | return; |
654 | 16 | if (CurFrame->ChainedParent) |
655 | 0 | getContext().reportError(Loc, "Not all chained regions terminated!"); |
656 | 16 | |
657 | 16 | MCSymbol *Label = EmitCFILabel(); |
658 | 16 | CurFrame->FuncletOrFuncEnd = Label; |
659 | 16 | } |
660 | | |
661 | 3 | void MCStreamer::EmitWinCFIStartChained(SMLoc Loc) { |
662 | 3 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
663 | 3 | if (!CurFrame) |
664 | 0 | return; |
665 | 3 | |
666 | 3 | MCSymbol *StartProc = EmitCFILabel(); |
667 | 3 | |
668 | 3 | WinFrameInfos.emplace_back(llvm::make_unique<WinEH::FrameInfo>( |
669 | 3 | CurFrame->Function, StartProc, CurFrame)); |
670 | 3 | CurrentWinFrameInfo = WinFrameInfos.back().get(); |
671 | 3 | CurrentWinFrameInfo->TextSection = getCurrentSectionOnly(); |
672 | 3 | } |
673 | | |
674 | 3 | void MCStreamer::EmitWinCFIEndChained(SMLoc Loc) { |
675 | 3 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
676 | 3 | if (!CurFrame) |
677 | 0 | return; |
678 | 3 | if (!CurFrame->ChainedParent) |
679 | 0 | return getContext().reportError( |
680 | 0 | Loc, "End of a chained region outside a chained region!"); |
681 | 3 | |
682 | 3 | MCSymbol *Label = EmitCFILabel(); |
683 | 3 | |
684 | 3 | CurFrame->End = Label; |
685 | 3 | CurrentWinFrameInfo = const_cast<WinEH::FrameInfo *>(CurFrame->ChainedParent); |
686 | 3 | } |
687 | | |
688 | | void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except, |
689 | 161 | SMLoc Loc) { |
690 | 161 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
691 | 161 | if (!CurFrame) |
692 | 0 | return; |
693 | 161 | if (CurFrame->ChainedParent) |
694 | 0 | return getContext().reportError( |
695 | 0 | Loc, "Chained unwind areas can't have handlers!"); |
696 | 161 | CurFrame->ExceptionHandler = Sym; |
697 | 161 | if (!Except && !Unwind0 ) |
698 | 0 | getContext().reportError(Loc, "Don't know what kind of handler this is!"); |
699 | 161 | if (Unwind) |
700 | 157 | CurFrame->HandlesUnwind = true; |
701 | 161 | if (Except) |
702 | 161 | CurFrame->HandlesExceptions = true; |
703 | 161 | } |
704 | | |
705 | 893 | void MCStreamer::EmitWinEHHandlerData(SMLoc Loc) { |
706 | 893 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
707 | 893 | if (!CurFrame) |
708 | 0 | return; |
709 | 893 | if (CurFrame->ChainedParent) |
710 | 0 | getContext().reportError(Loc, "Chained unwind areas can't have handlers!"); |
711 | 893 | } |
712 | | |
713 | | void MCStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From, |
714 | 0 | const MCSymbolRefExpr *To, uint64_t Count) { |
715 | 0 | } |
716 | | |
717 | | static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID, |
718 | | MCSection *MainCFISec, |
719 | 1.58k | const MCSection *TextSec) { |
720 | 1.58k | // If this is the main .text section, use the main unwind info section. |
721 | 1.58k | if (TextSec == Context.getObjectFileInfo()->getTextSection()) |
722 | 1.39k | return MainCFISec; |
723 | 197 | |
724 | 197 | const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec); |
725 | 197 | auto *MainCFISecCOFF = cast<MCSectionCOFF>(MainCFISec); |
726 | 197 | unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID); |
727 | 197 | |
728 | 197 | // If this section is COMDAT, this unwind section should be COMDAT associative |
729 | 197 | // with its group. |
730 | 197 | const MCSymbol *KeySym = nullptr; |
731 | 197 | if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT) { |
732 | 193 | KeySym = TextSecCOFF->getCOMDATSymbol(); |
733 | 193 | |
734 | 193 | // In a GNU environment, we can't use associative comdats. Instead, do what |
735 | 193 | // GCC does, which is to make plain comdat selectany section named like |
736 | 193 | // ".[px]data$_Z3foov". |
737 | 193 | if (!Context.getAsmInfo()->hasCOFFAssociativeComdats()) { |
738 | 15 | std::string SectionName = |
739 | 15 | (MainCFISecCOFF->getSectionName() + "$" + |
740 | 15 | TextSecCOFF->getSectionName().split('$').second) |
741 | 15 | .str(); |
742 | 15 | return Context.getCOFFSection( |
743 | 15 | SectionName, |
744 | 15 | MainCFISecCOFF->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT, |
745 | 15 | MainCFISecCOFF->getKind(), "", COFF::IMAGE_COMDAT_SELECT_ANY); |
746 | 15 | } |
747 | 182 | } |
748 | 182 | |
749 | 182 | return Context.getAssociativeCOFFSection(MainCFISecCOFF, KeySym, UniqueID); |
750 | 182 | } |
751 | | |
752 | 216 | MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) { |
753 | 216 | return getWinCFISection(getContext(), &NextWinCFIID, |
754 | 216 | getContext().getObjectFileInfo()->getPDataSection(), |
755 | 216 | TextSec); |
756 | 216 | } |
757 | | |
758 | 1.37k | MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) { |
759 | 1.37k | return getWinCFISection(getContext(), &NextWinCFIID, |
760 | 1.37k | getContext().getObjectFileInfo()->getXDataSection(), |
761 | 1.37k | TextSec); |
762 | 1.37k | } |
763 | | |
764 | 4.31k | void MCStreamer::EmitSyntaxDirective() {} |
765 | | |
766 | 486 | void MCStreamer::EmitWinCFIPushReg(unsigned Register, SMLoc Loc) { |
767 | 486 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
768 | 486 | if (!CurFrame) |
769 | 2 | return; |
770 | 484 | |
771 | 484 | MCSymbol *Label = EmitCFILabel(); |
772 | 484 | |
773 | 484 | WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register); |
774 | 484 | CurFrame->Instructions.push_back(Inst); |
775 | 484 | } |
776 | | |
777 | | void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset, |
778 | 102 | SMLoc Loc) { |
779 | 102 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
780 | 102 | if (!CurFrame) |
781 | 0 | return; |
782 | 102 | if (CurFrame->LastFrameInst >= 0) |
783 | 1 | return getContext().reportError( |
784 | 1 | Loc, "frame register and offset can be set at most once"); |
785 | 101 | if (Offset & 0x0F) |
786 | 1 | return getContext().reportError(Loc, "offset is not a multiple of 16"); |
787 | 100 | if (Offset > 240) |
788 | 1 | return getContext().reportError( |
789 | 1 | Loc, "frame offset must be less than or equal to 240"); |
790 | 99 | |
791 | 99 | MCSymbol *Label = EmitCFILabel(); |
792 | 99 | |
793 | 99 | WinEH::Instruction Inst = |
794 | 99 | Win64EH::Instruction::SetFPReg(Label, Register, Offset); |
795 | 99 | CurFrame->LastFrameInst = CurFrame->Instructions.size(); |
796 | 99 | CurFrame->Instructions.push_back(Inst); |
797 | 99 | } |
798 | | |
799 | 714 | void MCStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) { |
800 | 714 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
801 | 714 | if (!CurFrame) |
802 | 1 | return; |
803 | 713 | if (Size == 0) |
804 | 2 | return getContext().reportError(Loc, |
805 | 2 | "stack allocation size must be non-zero"); |
806 | 711 | if (Size & 7) |
807 | 1 | return getContext().reportError( |
808 | 1 | Loc, "stack allocation size is not a multiple of 8"); |
809 | 710 | |
810 | 710 | MCSymbol *Label = EmitCFILabel(); |
811 | 710 | |
812 | 710 | WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size); |
813 | 710 | CurFrame->Instructions.push_back(Inst); |
814 | 710 | } |
815 | | |
816 | | void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset, |
817 | 2 | SMLoc Loc) { |
818 | 2 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
819 | 2 | if (!CurFrame) |
820 | 0 | return; |
821 | 2 | |
822 | 2 | if (Offset & 7) |
823 | 0 | return getContext().reportError( |
824 | 0 | Loc, "register save offset is not 8 byte aligned"); |
825 | 2 | |
826 | 2 | MCSymbol *Label = EmitCFILabel(); |
827 | 2 | |
828 | 2 | WinEH::Instruction Inst = |
829 | 2 | Win64EH::Instruction::SaveNonVol(Label, Register, Offset); |
830 | 2 | CurFrame->Instructions.push_back(Inst); |
831 | 2 | } |
832 | | |
833 | | void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset, |
834 | 195 | SMLoc Loc) { |
835 | 195 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
836 | 195 | if (!CurFrame) |
837 | 0 | return; |
838 | 195 | if (Offset & 0x0F) |
839 | 1 | return getContext().reportError(Loc, "offset is not a multiple of 16"); |
840 | 194 | |
841 | 194 | MCSymbol *Label = EmitCFILabel(); |
842 | 194 | |
843 | 194 | WinEH::Instruction Inst = |
844 | 194 | Win64EH::Instruction::SaveXMM(Label, Register, Offset); |
845 | 194 | CurFrame->Instructions.push_back(Inst); |
846 | 194 | } |
847 | | |
848 | 2 | void MCStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) { |
849 | 2 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
850 | 2 | if (!CurFrame) |
851 | 0 | return; |
852 | 2 | if (!CurFrame->Instructions.empty()) |
853 | 0 | return getContext().reportError( |
854 | 0 | Loc, "If present, PushMachFrame must be the first UOP"); |
855 | 2 | |
856 | 2 | MCSymbol *Label = EmitCFILabel(); |
857 | 2 | |
858 | 2 | WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code); |
859 | 2 | CurFrame->Instructions.push_back(Inst); |
860 | 2 | } |
861 | | |
862 | 745 | void MCStreamer::EmitWinCFIEndProlog(SMLoc Loc) { |
863 | 745 | WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc); |
864 | 745 | if (!CurFrame) |
865 | 0 | return; |
866 | 745 | |
867 | 745 | MCSymbol *Label = EmitCFILabel(); |
868 | 745 | |
869 | 745 | CurFrame->PrologEnd = Label; |
870 | 745 | } |
871 | | |
872 | 0 | void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {} |
873 | | |
874 | 0 | void MCStreamer::EmitCOFFSymbolIndex(MCSymbol const *Symbol) {} |
875 | | |
876 | 0 | void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {} |
877 | | |
878 | 17 | void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {} |
879 | | |
880 | 0 | void MCStreamer::EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) {} |
881 | | |
882 | | /// EmitRawText - If this file is backed by an assembly streamer, this dumps |
883 | | /// the specified string in the output .s file. This capability is |
884 | | /// indicated by the hasRawTextSupport() predicate. |
885 | 0 | void MCStreamer::EmitRawTextImpl(StringRef String) { |
886 | 0 | // This is not llvm_unreachable for the sake of out of tree backend |
887 | 0 | // developers who may not have assembly streamers and should serve as a |
888 | 0 | // reminder to not accidentally call EmitRawText in the absence of such. |
889 | 0 | report_fatal_error("EmitRawText called on an MCStreamer that doesn't support " |
890 | 0 | "it (target backend is likely missing an AsmStreamer " |
891 | 0 | "implementation)"); |
892 | 0 | } |
893 | | |
894 | 660k | void MCStreamer::EmitRawText(const Twine &T) { |
895 | 660k | SmallString<128> Str; |
896 | 660k | EmitRawTextImpl(T.toStringRef(Str)); |
897 | 660k | } |
898 | | |
899 | 0 | void MCStreamer::EmitWindowsUnwindTables() { |
900 | 0 | } |
901 | | |
902 | 44.8k | void MCStreamer::Finish() { |
903 | 44.8k | if ((!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End15.2k ) || |
904 | 44.8k | (!WinFrameInfos.empty() && !WinFrameInfos.back()->End289 )) { |
905 | 3 | getContext().reportError(SMLoc(), "Unfinished frame!"); |
906 | 3 | return; |
907 | 3 | } |
908 | 44.8k | |
909 | 44.8k | MCTargetStreamer *TS = getTargetStreamer(); |
910 | 44.8k | if (TS) |
911 | 29.0k | TS->finish(); |
912 | 44.8k | |
913 | 44.8k | FinishImpl(); |
914 | 44.8k | } |
915 | | |
916 | 538k | void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { |
917 | 538k | visitUsedExpr(*Value); |
918 | 538k | Symbol->setVariableValue(Value); |
919 | 538k | |
920 | 538k | MCTargetStreamer *TS = getTargetStreamer(); |
921 | 538k | if (TS) |
922 | 156k | TS->emitAssignment(Symbol, Value); |
923 | 538k | } |
924 | | |
925 | | void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, |
926 | | raw_ostream &OS, const MCInst &Inst, |
927 | 2.47M | const MCSubtargetInfo &STI) { |
928 | 2.47M | InstPrinter.printInst(&Inst, OS, "", STI); |
929 | 2.47M | } |
930 | | |
931 | 3.70k | void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) { |
932 | 3.70k | } |
933 | | |
934 | 8.24M | void MCStreamer::visitUsedExpr(const MCExpr &Expr) { |
935 | 8.24M | switch (Expr.getKind()) { |
936 | 8.24M | case MCExpr::Target: |
937 | 67.8k | cast<MCTargetExpr>(Expr).visitUsedExpr(*this); |
938 | 67.8k | break; |
939 | 8.24M | |
940 | 8.24M | case MCExpr::Constant: |
941 | 272k | break; |
942 | 8.24M | |
943 | 8.24M | case MCExpr::Binary: { |
944 | 922k | const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr); |
945 | 922k | visitUsedExpr(*BE.getLHS()); |
946 | 922k | visitUsedExpr(*BE.getRHS()); |
947 | 922k | break; |
948 | 8.24M | } |
949 | 8.24M | |
950 | 8.24M | case MCExpr::SymbolRef: |
951 | 6.98M | visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol()); |
952 | 6.98M | break; |
953 | 8.24M | |
954 | 8.24M | case MCExpr::Unary: |
955 | 23 | visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr()); |
956 | 23 | break; |
957 | 8.24M | } |
958 | 8.24M | } |
959 | | |
960 | 16.7M | void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &) { |
961 | 16.7M | // Scan for values. |
962 | 69.7M | for (unsigned i = Inst.getNumOperands(); i--;) |
963 | 52.9M | if (Inst.getOperand(i).isExpr()) |
964 | 4.42M | visitUsedExpr(*Inst.getOperand(i).getExpr()); |
965 | 16.7M | } |
966 | | |
967 | | void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, |
968 | 375k | unsigned Size) { |
969 | 375k | // Get the Hi-Lo expression. |
970 | 375k | const MCExpr *Diff = |
971 | 375k | MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context), |
972 | 375k | MCSymbolRefExpr::create(Lo, Context), Context); |
973 | 375k | |
974 | 375k | const MCAsmInfo *MAI = Context.getAsmInfo(); |
975 | 375k | if (!MAI->doesSetDirectiveSuppressReloc()) { |
976 | 6.87k | EmitValue(Diff, Size); |
977 | 6.87k | return; |
978 | 6.87k | } |
979 | 368k | |
980 | 368k | // Otherwise, emit with .set (aka assignment). |
981 | 368k | MCSymbol *SetLabel = Context.createTempSymbol("set", true); |
982 | 368k | EmitAssignment(SetLabel, Diff); |
983 | 368k | EmitSymbolValue(SetLabel, Size); |
984 | 368k | } |
985 | | |
986 | | void MCStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, |
987 | 7.04k | const MCSymbol *Lo) { |
988 | 7.04k | // Get the Hi-Lo expression. |
989 | 7.04k | const MCExpr *Diff = |
990 | 7.04k | MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context), |
991 | 7.04k | MCSymbolRefExpr::create(Lo, Context), Context); |
992 | 7.04k | |
993 | 7.04k | EmitULEB128Value(Diff); |
994 | 7.04k | } |
995 | | |
996 | 6 | void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {} |
997 | 0 | void MCStreamer::EmitThumbFunc(MCSymbol *Func) {} |
998 | 0 | void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {} |
999 | 0 | void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) { |
1000 | 0 | llvm_unreachable("this directive only supported on COFF targets"); |
1001 | 0 | } |
1002 | 0 | void MCStreamer::EndCOFFSymbolDef() { |
1003 | 0 | llvm_unreachable("this directive only supported on COFF targets"); |
1004 | 0 | } |
1005 | 11 | void MCStreamer::EmitFileDirective(StringRef Filename) {} |
1006 | 0 | void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) { |
1007 | 0 | llvm_unreachable("this directive only supported on COFF targets"); |
1008 | 0 | } |
1009 | 0 | void MCStreamer::EmitCOFFSymbolType(int Type) { |
1010 | 0 | llvm_unreachable("this directive only supported on COFF targets"); |
1011 | 0 | } |
1012 | 42 | void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {} |
1013 | | void MCStreamer::emitELFSymverDirective(StringRef AliasName, |
1014 | 0 | const MCSymbol *Aliasee) {} |
1015 | | void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
1016 | 0 | unsigned ByteAlignment) {} |
1017 | | void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, |
1018 | 0 | uint64_t Size, unsigned ByteAlignment) {} |
1019 | 812 | void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {} |
1020 | 0 | void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {} |
1021 | 624 | void MCStreamer::EmitBytes(StringRef Data) {} |
1022 | 197 | void MCStreamer::EmitBinaryData(StringRef Data) { EmitBytes(Data); } |
1023 | 1.37M | void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { |
1024 | 1.37M | visitUsedExpr(*Value); |
1025 | 1.37M | } |
1026 | 0 | void MCStreamer::EmitULEB128Value(const MCExpr *Value) {} |
1027 | 0 | void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {} |
1028 | 7 | void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {} |
1029 | | void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr, |
1030 | 0 | SMLoc Loc) {} |
1031 | | void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, |
1032 | | unsigned ValueSize, |
1033 | 9 | unsigned MaxBytesToEmit) {} |
1034 | | void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment, |
1035 | 28 | unsigned MaxBytesToEmit) {} |
1036 | | void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value, |
1037 | 0 | SMLoc Loc) {} |
1038 | 0 | void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {} |
1039 | 0 | void MCStreamer::EmitBundleLock(bool AlignToEnd) {} |
1040 | 752 | void MCStreamer::FinishImpl() {} |
1041 | 0 | void MCStreamer::EmitBundleUnlock() {} |
1042 | | |
1043 | 1.62M | void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) { |
1044 | 1.62M | assert(Section && "Cannot switch to a null section!"); |
1045 | 1.62M | MCSectionSubPair curSection = SectionStack.back().first; |
1046 | 1.62M | SectionStack.back().second = curSection; |
1047 | 1.62M | if (MCSectionSubPair(Section, Subsection) != curSection) { |
1048 | 833k | ChangeSection(Section, Subsection); |
1049 | 833k | SectionStack.back().first = MCSectionSubPair(Section, Subsection); |
1050 | 833k | assert(!Section->hasEnded() && "Section already ended"); |
1051 | 833k | MCSymbol *Sym = Section->getBeginSymbol(); |
1052 | 833k | if (Sym && !Sym->isInSection()791k ) |
1053 | 54.9k | EmitLabel(Sym); |
1054 | 833k | } |
1055 | 1.62M | } |
1056 | | |
1057 | 2.04k | MCSymbol *MCStreamer::endSection(MCSection *Section) { |
1058 | 2.04k | // TODO: keep track of the last subsection so that this symbol appears in the |
1059 | 2.04k | // correct place. |
1060 | 2.04k | MCSymbol *Sym = Section->getEndSymbol(Context); |
1061 | 2.04k | if (Sym->isInSection()) |
1062 | 29 | return Sym; |
1063 | 2.01k | |
1064 | 2.01k | SwitchSection(Section); |
1065 | 2.01k | EmitLabel(Sym); |
1066 | 2.01k | return Sym; |
1067 | 2.01k | } |
1068 | | |
1069 | | void MCStreamer::EmitVersionForTarget(const Triple &Target, |
1070 | 49.9k | const VersionTuple &SDKVersion) { |
1071 | 49.9k | if (!Target.isOSBinFormatMachO() || !Target.isOSDarwin()16.5k ) |
1072 | 34.2k | return; |
1073 | 15.6k | // Do we even know the version? |
1074 | 15.6k | if (Target.getOSMajorVersion() == 0) |
1075 | 1.82k | return; |
1076 | 13.8k | |
1077 | 13.8k | unsigned Major; |
1078 | 13.8k | unsigned Minor; |
1079 | 13.8k | unsigned Update; |
1080 | 13.8k | if (Target.isMacCatalystEnvironment()) { |
1081 | 2 | // Mac Catalyst always uses the build version load command. |
1082 | 2 | Target.getiOSVersion(Major, Minor, Update); |
1083 | 2 | assert(Major && "A non-zero major version is expected"); |
1084 | 2 | EmitBuildVersion(MachO::PLATFORM_MACCATALYST, Major, Minor, Update, |
1085 | 2 | SDKVersion); |
1086 | 2 | return; |
1087 | 2 | } |
1088 | 13.8k | |
1089 | 13.8k | MCVersionMinType VersionType; |
1090 | 13.8k | if (Target.isWatchOS()) { |
1091 | 15 | VersionType = MCVM_WatchOSVersionMin; |
1092 | 15 | Target.getWatchOSVersion(Major, Minor, Update); |
1093 | 13.8k | } else if (Target.isTvOS()) { |
1094 | 6 | VersionType = MCVM_TvOSVersionMin; |
1095 | 6 | Target.getiOSVersion(Major, Minor, Update); |
1096 | 13.8k | } else if (Target.isMacOSX()) { |
1097 | 3.94k | VersionType = MCVM_OSXVersionMin; |
1098 | 3.94k | if (!Target.getMacOSXVersion(Major, Minor, Update)) |
1099 | 2 | Major = 0; |
1100 | 9.89k | } else { |
1101 | 9.89k | VersionType = MCVM_IOSVersionMin; |
1102 | 9.89k | Target.getiOSVersion(Major, Minor, Update); |
1103 | 9.89k | } |
1104 | 13.8k | if (Major != 0) |
1105 | 13.8k | EmitVersionMin(VersionType, Major, Minor, Update, SDKVersion); |
1106 | 13.8k | } |