Coverage Report

Created: 2019-07-24 05:18

/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
}