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