Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/MC/MCStreamer.cpp
Line
Count
Source (jump to first uncovered line)
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/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
14.3k
MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
42
14.3k
  S.setTargetStreamer(this);
43
14.3k
}
44
45
// Pin the vtables to this file.
46
14.2k
MCTargetStreamer::~MCTargetStreamer() = default;
47
48
628k
void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
49
50
5.76k
void MCTargetStreamer::finish() {}
51
52
35.5k
void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
53
54
MCStreamer::MCStreamer(MCContext &Ctx)
55
39.4k
    : Context(Ctx), CurrentWinFrameInfo(nullptr) {
56
39.4k
  SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
57
39.4k
}
58
59
39.2k
MCStreamer::~MCStreamer() {
60
39.3k
  for (unsigned i = 0; 
i < getNumWinFrameInfos()39.3k
;
++i17
)
61
17
    delete WinFrameInfos[i];
62
39.2k
}
63
64
33.3k
void MCStreamer::reset() {
65
33.3k
  DwarfFrameInfos.clear();
66
33.7k
  for (unsigned i = 0; 
i < getNumWinFrameInfos()33.7k
;
++i384
)
67
384
    delete WinFrameInfos[i];
68
33.3k
  WinFrameInfos.clear();
69
33.3k
  CurrentWinFrameInfo = nullptr;
70
33.3k
  SymbolOrdering.clear();
71
33.3k
  SectionStack.clear();
72
33.3k
  SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
73
33.3k
}
74
75
0
raw_ostream &MCStreamer::GetCommentOS() {
76
0
  // By default, discard comments.
77
0
  return nulls();
78
0
}
79
80
5.89k
void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
81
82
10.1k
void MCStreamer::addExplicitComment(const Twine &T) {}
83
0
void MCStreamer::emitExplicitComments() {}
84
85
6.34k
void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
86
6.34k
  for (auto &FI : DwarfFrameInfos)
87
53.0k
    FI.CompactUnwindEncoding =
88
53.0k
        (MAB ? 
MAB->generateCompactUnwindEncoding(FI.Instructions)52.4k
:
0662
);
89
6.34k
}
90
91
/// EmitIntValue - Special case of EmitValue that avoids the client having to
92
/// pass in a MCExpr for constant integers.
93
3.07M
void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
94
3.07M
  assert(1 <= Size && Size <= 8 && "Invalid size");
95
3.07M
  assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
96
3.07M
         "Invalid size");
97
3.07M
  char buf[8];
98
3.07M
  const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
99
14.1M
  for (unsigned i = 0; 
i != Size14.1M
;
++i11.0M
) {
100
11.0M
    unsigned index = isLittleEndian ? 
i11.0M
:
(Size - i - 1)21.9k
;
101
11.0M
    buf[i] = uint8_t(Value >> (index * 8));
102
11.0M
  }
103
3.07M
  EmitBytes(StringRef(buf, Size));
104
3.07M
}
105
106
/// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
107
/// client having to pass in a MCExpr for constant integers.
108
491k
void MCStreamer::EmitPaddedULEB128IntValue(uint64_t Value, unsigned PadTo) {
109
491k
  SmallString<128> Tmp;
110
491k
  raw_svector_ostream OSE(Tmp);
111
491k
  encodeULEB128(Value, OSE, PadTo);
112
491k
  EmitBytes(OSE.str());
113
491k
}
114
115
485k
void MCStreamer::EmitULEB128IntValue(uint64_t Value) {
116
485k
  EmitPaddedULEB128IntValue(Value, 0);
117
485k
}
118
119
/// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
120
/// client having to pass in a MCExpr for constant integers.
121
6.76k
void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
122
6.76k
  SmallString<128> Tmp;
123
6.76k
  raw_svector_ostream OSE(Tmp);
124
6.76k
  encodeSLEB128(Value, OSE);
125
6.76k
  EmitBytes(OSE.str());
126
6.76k
}
127
128
818k
void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) {
129
818k
  EmitValueImpl(Value, Size, Loc);
130
818k
}
131
132
void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
133
110k
                                 bool IsSectionRelative) {
134
110k
  assert((!IsSectionRelative || Size == 4) &&
135
110k
         "SectionRelative value requires 4-bytes");
136
110k
137
110k
  if (!IsSectionRelative)
138
110k
    EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size);
139
110k
  else
140
6
    EmitCOFFSecRel32(Sym, /*Offset=*/0);
141
110k
}
142
143
0
void MCStreamer::EmitDTPRel64Value(const MCExpr *Value) {
144
0
  report_fatal_error("unsupported directive in streamer");
145
0
}
146
147
0
void MCStreamer::EmitDTPRel32Value(const MCExpr *Value) {
148
0
  report_fatal_error("unsupported directive in streamer");
149
0
}
150
151
0
void MCStreamer::EmitTPRel64Value(const MCExpr *Value) {
152
0
  report_fatal_error("unsupported directive in streamer");
153
0
}
154
155
0
void MCStreamer::EmitTPRel32Value(const MCExpr *Value) {
156
0
  report_fatal_error("unsupported directive in streamer");
157
0
}
158
159
0
void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
160
0
  report_fatal_error("unsupported directive in streamer");
161
0
}
162
163
0
void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
164
0
  report_fatal_error("unsupported directive in streamer");
165
0
}
166
167
/// Emit NumBytes bytes worth of the value specified by FillValue.
168
/// This implements directives such as '.space'.
169
7
void MCStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
170
7
  for (uint64_t i = 0, e = NumBytes; 
i != e7
;
++i0
)
171
0
    EmitIntValue(FillValue, 1);
172
7
}
173
174
505
void MCStreamer::emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) {
175
505
  int64_t NonZeroSize = Size > 4 ? 
45
:
Size500
;
176
505
  Expr &= ~0ULL >> (64 - NonZeroSize * 8);
177
628k
  for (uint64_t i = 0, e = NumValues; 
i != e628k
;
++i627k
) {
178
627k
    EmitIntValue(Expr, NonZeroSize);
179
627k
    if (NonZeroSize < Size)
180
7
      EmitIntValue(0, Size - NonZeroSize);
181
627k
  }
182
505
}
183
184
/// The implementation in this class just redirects to emitFill.
185
966k
void MCStreamer::EmitZeros(uint64_t NumBytes) {
186
966k
  emitFill(NumBytes, 0);
187
966k
}
188
189
unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
190
                                            StringRef Directory,
191
206k
                                            StringRef Filename, unsigned CUID) {
192
206k
  return getContext().getDwarfFile(Directory, Filename, FileNo, CUID);
193
206k
}
194
195
void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
196
                                       unsigned Column, unsigned Flags,
197
                                       unsigned Isa,
198
                                       unsigned Discriminator,
199
171k
                                       StringRef FileName) {
200
171k
  getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
201
171k
                                  Discriminator);
202
171k
}
203
204
1.20k
MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
205
1.20k
  MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
206
1.20k
  if (
!Table.getLabel()1.20k
) {
207
1.19k
    StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
208
1.19k
    Table.setLabel(
209
1.19k
        Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
210
1.19k
  }
211
1.20k
  return Table.getLabel();
212
1.20k
}
213
214
1.05M
MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
215
1.05M
  if (DwarfFrameInfos.empty())
216
13.1k
    return nullptr;
217
1.03M
  return &DwarfFrameInfos.back();
218
1.03M
}
219
220
125k
bool MCStreamer::hasUnfinishedDwarfFrameInfo() {
221
125k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
222
112k
  return CurFrame && !CurFrame->End;
223
125k
}
224
225
463k
void MCStreamer::EnsureValidDwarfFrame() {
226
463k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
227
463k
  if (
!CurFrame || 463k
CurFrame->End463k
)
228
0
    report_fatal_error("No open frame");
229
463k
}
230
231
bool MCStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
232
                                     ArrayRef<uint8_t> Checksum,
233
61
                                     unsigned ChecksumKind) {
234
61
  return getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
235
61
                                             ChecksumKind);
236
61
}
237
238
158
bool MCStreamer::EmitCVFuncIdDirective(unsigned FunctionId) {
239
158
  return getContext().getCVContext().recordFunctionId(FunctionId);
240
158
}
241
242
bool MCStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
243
                                             unsigned IAFunc, unsigned IAFile,
244
                                             unsigned IALine, unsigned IACol,
245
31
                                             SMLoc Loc) {
246
31
  if (
getContext().getCVContext().getCVFunctionInfo(IAFunc) == nullptr31
) {
247
0
    getContext().reportError(Loc, "parent function id not introduced by "
248
0
                                  ".cv_func_id or .cv_inline_site_id");
249
0
    return true;
250
0
  }
251
31
252
31
  return getContext().getCVContext().recordInlinedCallSiteId(
253
31
      FunctionId, IAFunc, IAFile, IALine, IACol);
254
31
}
255
256
void MCStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
257
                                    unsigned Line, unsigned Column,
258
                                    bool PrologueEnd, bool IsStmt,
259
577
                                    StringRef FileName, SMLoc Loc) {
260
577
  CodeViewContext &CVC = getContext().getCVContext();
261
577
  MCCVFunctionInfo *FI = CVC.getCVFunctionInfo(FunctionId);
262
577
  if (!FI)
263
0
    return getContext().reportError(
264
0
        Loc, "function id not introduced by .cv_func_id or .cv_inline_site_id");
265
577
266
577
  // Track the section
267
577
  
if (577
FI->Section == nullptr577
)
268
184
    FI->Section = getCurrentSectionOnly();
269
393
  else 
if (393
FI->Section != getCurrentSectionOnly()393
)
270
1
    return getContext().reportError(
271
1
        Loc,
272
1
        "all .cv_loc directives for a function must be in the same section");
273
576
274
576
  CVC.setCurrentCVLoc(FunctionId, FileNo, Line, Column, PrologueEnd, IsStmt);
275
576
}
276
277
void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
278
                                          const MCSymbol *Begin,
279
153
                                          const MCSymbol *End) {}
280
281
void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
282
                                                unsigned SourceFileId,
283
                                                unsigned SourceLineNum,
284
                                                const MCSymbol *FnStartSym,
285
29
                                                const MCSymbol *FnEndSym) {}
286
287
void MCStreamer::EmitCVDefRangeDirective(
288
    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
289
142
    StringRef FixedSizePortion) {}
290
291
void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
292
0
                                     MCSymbol *EHSymbol) {
293
0
}
294
295
36.5k
void MCStreamer::InitSections(bool NoExecStack) {
296
36.5k
  SwitchSection(getContext().getObjectFileInfo()->getTextSection());
297
36.5k
}
298
299
355
void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) {
300
355
  assert(Fragment);
301
355
  Symbol->setFragment(Fragment);
302
355
303
355
  // As we emit symbols into a section, track the order so that they can
304
355
  // be sorted upon later. Zero is reserved to mean 'unemitted'.
305
355
  SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
306
355
}
307
308
6.76M
void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
309
6.76M
  Symbol->redefineIfPossible();
310
6.76M
311
6.76M
  if (
!Symbol->isUndefined() || 6.76M
Symbol->isVariable()6.76M
)
312
20
    return getContext().reportError(Loc, "invalid symbol redefinition");
313
6.76M
314
6.76M
  assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
315
6.76M
  assert(getCurrentSectionOnly() && "Cannot emit before setting section!");
316
6.76M
  assert(!Symbol->getFragment() && "Unexpected fragment on symbol data!");
317
6.76M
  assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
318
6.76M
319
6.76M
  Symbol->setFragment(&getCurrentSectionOnly()->getDummyFragment());
320
6.76M
321
6.76M
  MCTargetStreamer *TS = getTargetStreamer();
322
6.76M
  if (TS)
323
633k
    TS->emitLabel(Symbol);
324
6.76M
}
325
326
199
void MCStreamer::EmitCFISections(bool EH, bool Debug) {
327
199
  assert(EH || Debug);
328
199
}
329
330
125k
void MCStreamer::EmitCFIStartProc(bool IsSimple) {
331
125k
  if (hasUnfinishedDwarfFrameInfo())
332
0
    report_fatal_error("Starting a frame before finishing the previous one!");
333
125k
334
125k
  MCDwarfFrameInfo Frame;
335
125k
  Frame.IsSimple = IsSimple;
336
125k
  EmitCFIStartProcImpl(Frame);
337
125k
338
125k
  const MCAsmInfo* MAI = Context.getAsmInfo();
339
125k
  if (
MAI125k
) {
340
178k
    for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
341
178k
      if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
342
178k
          
Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister52.3k
) {
343
125k
        Frame.CurrentCfaRegister = Inst.getRegister();
344
125k
      }
345
178k
    }
346
125k
  }
347
125k
348
125k
  DwarfFrameInfos.push_back(Frame);
349
125k
}
350
351
12
void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
352
12
}
353
354
125k
void MCStreamer::EmitCFIEndProc() {
355
125k
  EnsureValidDwarfFrame();
356
125k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
357
125k
  EmitCFIEndProcImpl(*CurFrame);
358
125k
}
359
360
72.7k
void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
361
72.7k
  // Put a dummy non-null value in Frame.End to mark that this frame has been
362
72.7k
  // closed.
363
72.7k
  Frame.End = (MCSymbol *) 1;
364
72.7k
}
365
366
334k
MCSymbol *MCStreamer::EmitCFILabel() {
367
334k
  MCSymbol *Label = getContext().createTempSymbol("cfi", true);
368
334k
  EmitLabel(Label);
369
334k
  return Label;
370
334k
}
371
372
331k
MCSymbol *MCStreamer::EmitCFICommon() {
373
331k
  EnsureValidDwarfFrame();
374
331k
  return EmitCFILabel();
375
331k
}
376
377
35.7k
void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
378
35.7k
  MCSymbol *Label = EmitCFICommon();
379
35.7k
  MCCFIInstruction Instruction =
380
35.7k
    MCCFIInstruction::createDefCfa(Label, Register, Offset);
381
35.7k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
382
35.7k
  CurFrame->Instructions.push_back(Instruction);
383
35.7k
  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
384
35.7k
}
385
386
18.4k
void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
387
18.4k
  MCSymbol *Label = EmitCFICommon();
388
18.4k
  MCCFIInstruction Instruction =
389
18.4k
    MCCFIInstruction::createDefCfaOffset(Label, Offset);
390
18.4k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
391
18.4k
  CurFrame->Instructions.push_back(Instruction);
392
18.4k
}
393
394
1.81k
void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
395
1.81k
  MCSymbol *Label = EmitCFICommon();
396
1.81k
  MCCFIInstruction Instruction =
397
1.81k
    MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
398
1.81k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
399
1.81k
  CurFrame->Instructions.push_back(Instruction);
400
1.81k
}
401
402
7.61k
void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
403
7.61k
  MCSymbol *Label = EmitCFICommon();
404
7.61k
  MCCFIInstruction Instruction =
405
7.61k
    MCCFIInstruction::createDefCfaRegister(Label, Register);
406
7.61k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
407
7.61k
  CurFrame->Instructions.push_back(Instruction);
408
7.61k
  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
409
7.61k
}
410
411
267k
void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
412
267k
  MCSymbol *Label = EmitCFICommon();
413
267k
  MCCFIInstruction Instruction =
414
267k
    MCCFIInstruction::createOffset(Label, Register, Offset);
415
267k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
416
267k
  CurFrame->Instructions.push_back(Instruction);
417
267k
}
418
419
23
void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
420
23
  MCSymbol *Label = EmitCFICommon();
421
23
  MCCFIInstruction Instruction =
422
23
    MCCFIInstruction::createRelOffset(Label, Register, Offset);
423
23
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
424
23
  CurFrame->Instructions.push_back(Instruction);
425
23
}
426
427
void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
428
2.92k
                                    unsigned Encoding) {
429
2.92k
  EnsureValidDwarfFrame();
430
2.92k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
431
2.92k
  CurFrame->Personality = Sym;
432
2.92k
  CurFrame->PersonalityEncoding = Encoding;
433
2.92k
}
434
435
2.88k
void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
436
2.88k
  EnsureValidDwarfFrame();
437
2.88k
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
438
2.88k
  CurFrame->Lsda = Sym;
439
2.88k
  CurFrame->LsdaEncoding = Encoding;
440
2.88k
}
441
442
30
void MCStreamer::EmitCFIRememberState() {
443
30
  MCSymbol *Label = EmitCFICommon();
444
30
  MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
445
30
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
446
30
  CurFrame->Instructions.push_back(Instruction);
447
30
}
448
449
30
void MCStreamer::EmitCFIRestoreState() {
450
30
  // FIXME: Error if there is no matching cfi_remember_state.
451
30
  MCSymbol *Label = EmitCFICommon();
452
30
  MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
453
30
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
454
30
  CurFrame->Instructions.push_back(Instruction);
455
30
}
456
457
6
void MCStreamer::EmitCFISameValue(int64_t Register) {
458
6
  MCSymbol *Label = EmitCFICommon();
459
6
  MCCFIInstruction Instruction =
460
6
    MCCFIInstruction::createSameValue(Label, Register);
461
6
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
462
6
  CurFrame->Instructions.push_back(Instruction);
463
6
}
464
465
1
void MCStreamer::EmitCFIRestore(int64_t Register) {
466
1
  MCSymbol *Label = EmitCFICommon();
467
1
  MCCFIInstruction Instruction =
468
1
    MCCFIInstruction::createRestore(Label, Register);
469
1
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
470
1
  CurFrame->Instructions.push_back(Instruction);
471
1
}
472
473
1
void MCStreamer::EmitCFIEscape(StringRef Values) {
474
1
  MCSymbol *Label = EmitCFICommon();
475
1
  MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
476
1
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
477
1
  CurFrame->Instructions.push_back(Instruction);
478
1
}
479
480
18
void MCStreamer::EmitCFIGnuArgsSize(int64_t Size) {
481
18
  MCSymbol *Label = EmitCFICommon();
482
18
  MCCFIInstruction Instruction = 
483
18
    MCCFIInstruction::createGnuArgsSize(Label, Size);
484
18
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
485
18
  CurFrame->Instructions.push_back(Instruction);
486
18
}
487
488
1
void MCStreamer::EmitCFISignalFrame() {
489
1
  EnsureValidDwarfFrame();
490
1
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
491
1
  CurFrame->IsSignalFrame = true;
492
1
}
493
494
1
void MCStreamer::EmitCFIUndefined(int64_t Register) {
495
1
  MCSymbol *Label = EmitCFICommon();
496
1
  MCCFIInstruction Instruction =
497
1
    MCCFIInstruction::createUndefined(Label, Register);
498
1
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
499
1
  CurFrame->Instructions.push_back(Instruction);
500
1
}
501
502
385
void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
503
385
  MCSymbol *Label = EmitCFICommon();
504
385
  MCCFIInstruction Instruction =
505
385
    MCCFIInstruction::createRegister(Label, Register1, Register2);
506
385
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
507
385
  CurFrame->Instructions.push_back(Instruction);
508
385
}
509
510
384
void MCStreamer::EmitCFIWindowSave() {
511
384
  MCSymbol *Label = EmitCFICommon();
512
384
  MCCFIInstruction Instruction =
513
384
    MCCFIInstruction::createWindowSave(Label);
514
384
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
515
384
  CurFrame->Instructions.push_back(Instruction);
516
384
}
517
518
6
void MCStreamer::EmitCFIReturnColumn(int64_t Register) {
519
6
  EnsureValidDwarfFrame();
520
6
  MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
521
6
  CurFrame->RAReg = Register;
522
6
}
523
524
2.30k
void MCStreamer::EnsureValidWinFrameInfo() {
525
2.30k
  const MCAsmInfo *MAI = Context.getAsmInfo();
526
2.30k
  if (!MAI->usesWindowsCFI())
527
0
    report_fatal_error(".seh_* directives are not supported on this target");
528
2.30k
  
if (2.30k
!CurrentWinFrameInfo || 2.30k
CurrentWinFrameInfo->End2.30k
)
529
0
    report_fatal_error("No open Win64 EH frame function!");
530
2.30k
}
531
532
400
void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
533
400
  const MCAsmInfo *MAI = Context.getAsmInfo();
534
400
  if (!MAI->usesWindowsCFI())
535
0
    report_fatal_error(".seh_* directives are not supported on this target");
536
400
  
if (400
CurrentWinFrameInfo && 400
!CurrentWinFrameInfo->End252
)
537
0
    report_fatal_error("Starting a function before ending the previous one!");
538
400
539
400
  MCSymbol *StartProc = EmitCFILabel();
540
400
541
400
  WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
542
400
  CurrentWinFrameInfo = WinFrameInfos.back();
543
400
  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
544
400
}
545
546
399
void MCStreamer::EmitWinCFIEndProc() {
547
399
  EnsureValidWinFrameInfo();
548
399
  if (CurrentWinFrameInfo->ChainedParent)
549
0
    report_fatal_error("Not all chained regions terminated!");
550
399
551
399
  MCSymbol *Label = EmitCFILabel();
552
399
  CurrentWinFrameInfo->End = Label;
553
399
}
554
555
2
void MCStreamer::EmitWinCFIStartChained() {
556
2
  EnsureValidWinFrameInfo();
557
2
558
2
  MCSymbol *StartProc = EmitCFILabel();
559
2
560
2
  WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
561
2
                                               StartProc, CurrentWinFrameInfo));
562
2
  CurrentWinFrameInfo = WinFrameInfos.back();
563
2
  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
564
2
}
565
566
2
void MCStreamer::EmitWinCFIEndChained() {
567
2
  EnsureValidWinFrameInfo();
568
2
  if (!CurrentWinFrameInfo->ChainedParent)
569
0
    report_fatal_error("End of a chained region outside a chained region!");
570
2
571
2
  MCSymbol *Label = EmitCFILabel();
572
2
573
2
  CurrentWinFrameInfo->End = Label;
574
2
  CurrentWinFrameInfo =
575
2
      const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
576
2
}
577
578
void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
579
125
                                  bool Except) {
580
125
  EnsureValidWinFrameInfo();
581
125
  if (CurrentWinFrameInfo->ChainedParent)
582
0
    report_fatal_error("Chained unwind areas can't have handlers!");
583
125
  CurrentWinFrameInfo->ExceptionHandler = Sym;
584
125
  if (
!Except && 125
!Unwind0
)
585
0
    report_fatal_error("Don't know what kind of handler this is!");
586
125
  
if (125
Unwind125
)
587
122
    CurrentWinFrameInfo->HandlesUnwind = true;
588
125
  if (Except)
589
125
    CurrentWinFrameInfo->HandlesExceptions = true;
590
125
}
591
592
392
void MCStreamer::EmitWinEHHandlerData() {
593
392
  EnsureValidWinFrameInfo();
594
392
  if (CurrentWinFrameInfo->ChainedParent)
595
0
    report_fatal_error("Chained unwind areas can't have handlers!");
596
392
}
597
598
static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
599
                                   MCSection *MainCFISec,
600
619
                                   const MCSection *TextSec) {
601
619
  // If this is the main .text section, use the main unwind info section.
602
619
  if (TextSec == Context.getObjectFileInfo()->getTextSection())
603
557
    return MainCFISec;
604
62
605
62
  const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
606
62
  unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
607
62
608
62
  // If this section is COMDAT, this unwind section should be COMDAT associative
609
62
  // with its group.
610
62
  const MCSymbol *KeySym = nullptr;
611
62
  if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
612
58
    KeySym = TextSecCOFF->getCOMDATSymbol();
613
619
614
619
  return Context.getAssociativeCOFFSection(cast<MCSectionCOFF>(MainCFISec),
615
619
                                           KeySym, UniqueID);
616
619
}
617
618
72
MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) {
619
72
  return getWinCFISection(getContext(), &NextWinCFIID,
620
72
                          getContext().getObjectFileInfo()->getPDataSection(),
621
72
                          TextSec);
622
72
}
623
624
547
MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
625
547
  return getWinCFISection(getContext(), &NextWinCFIID,
626
547
                          getContext().getObjectFileInfo()->getXDataSection(),
627
547
                          TextSec);
628
547
}
629
630
3.01k
void MCStreamer::EmitSyntaxDirective() {}
631
632
388
void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
633
388
  EnsureValidWinFrameInfo();
634
388
635
388
  MCSymbol *Label = EmitCFILabel();
636
388
637
388
  WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
638
388
  CurrentWinFrameInfo->Instructions.push_back(Inst);
639
388
}
640
641
90
void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
642
90
  EnsureValidWinFrameInfo();
643
90
  if (CurrentWinFrameInfo->LastFrameInst >= 0)
644
0
    report_fatal_error("Frame register and offset already specified!");
645
90
  
if (90
Offset & 0x0F90
)
646
0
    report_fatal_error("Misaligned frame pointer offset!");
647
90
  
if (90
Offset > 24090
)
648
0
    report_fatal_error("Frame offset must be less than or equal to 240!");
649
90
650
90
  MCSymbol *Label = EmitCFILabel();
651
90
652
90
  WinEH::Instruction Inst =
653
90
      Win64EH::Instruction::SetFPReg(Label, Register, Offset);
654
90
  CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
655
90
  CurrentWinFrameInfo->Instructions.push_back(Inst);
656
90
}
657
658
365
void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
659
365
  EnsureValidWinFrameInfo();
660
365
  if (Size == 0)
661
1
    report_fatal_error("Allocation size must be non-zero!");
662
364
  
if (364
Size & 7364
)
663
0
    report_fatal_error("Misaligned stack allocation!");
664
364
665
364
  MCSymbol *Label = EmitCFILabel();
666
364
667
364
  WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
668
364
  CurrentWinFrameInfo->Instructions.push_back(Inst);
669
364
}
670
671
2
void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
672
2
  EnsureValidWinFrameInfo();
673
2
  if (Offset & 7)
674
0
    report_fatal_error("Misaligned saved register offset!");
675
2
676
2
  MCSymbol *Label = EmitCFILabel();
677
2
678
2
  WinEH::Instruction Inst =
679
2
      Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
680
2
  CurrentWinFrameInfo->Instructions.push_back(Inst);
681
2
}
682
683
143
void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
684
143
  EnsureValidWinFrameInfo();
685
143
  if (Offset & 0x0F)
686
0
    report_fatal_error("Misaligned saved vector register offset!");
687
143
688
143
  MCSymbol *Label = EmitCFILabel();
689
143
690
143
  WinEH::Instruction Inst =
691
143
      Win64EH::Instruction::SaveXMM(Label, Register, Offset);
692
143
  CurrentWinFrameInfo->Instructions.push_back(Inst);
693
143
}
694
695
2
void MCStreamer::EmitWinCFIPushFrame(bool Code) {
696
2
  EnsureValidWinFrameInfo();
697
2
  if (!CurrentWinFrameInfo->Instructions.empty())
698
0
    report_fatal_error("If present, PushMachFrame must be the first UOP");
699
2
700
2
  MCSymbol *Label = EmitCFILabel();
701
2
702
2
  WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
703
2
  CurrentWinFrameInfo->Instructions.push_back(Inst);
704
2
}
705
706
397
void MCStreamer::EmitWinCFIEndProlog() {
707
397
  EnsureValidWinFrameInfo();
708
397
709
397
  MCSymbol *Label = EmitCFILabel();
710
397
711
397
  CurrentWinFrameInfo->PrologEnd = Label;
712
397
}
713
714
0
void MCStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
715
0
}
716
717
0
void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
718
0
}
719
720
17
void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {}
721
722
/// EmitRawText - If this file is backed by an assembly streamer, this dumps
723
/// the specified string in the output .s file.  This capability is
724
/// indicated by the hasRawTextSupport() predicate.
725
0
void MCStreamer::EmitRawTextImpl(StringRef String) {
726
0
  errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
727
0
  " something must not be fully mc'ized\n";
728
0
  abort();
729
0
}
730
731
9.75k
void MCStreamer::EmitRawText(const Twine &T) {
732
9.75k
  SmallString<128> Str;
733
9.75k
  EmitRawTextImpl(T.toStringRef(Str));
734
9.75k
}
735
736
0
void MCStreamer::EmitWindowsUnwindTables() {
737
0
}
738
739
37.8k
void MCStreamer::Finish() {
740
37.8k
  if (
!DwarfFrameInfos.empty() && 37.8k
!DwarfFrameInfos.back().End13.1k
)
741
1
    report_fatal_error("Unfinished frame!");
742
37.8k
743
37.8k
  MCTargetStreamer *TS = getTargetStreamer();
744
37.8k
  if (TS)
745
13.1k
    TS->finish();
746
37.8k
747
37.8k
  FinishImpl();
748
37.8k
}
749
750
171k
void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
751
171k
  visitUsedExpr(*Value);
752
171k
  Symbol->setVariableValue(Value);
753
171k
754
171k
  MCTargetStreamer *TS = getTargetStreamer();
755
171k
  if (TS)
756
35.5k
    TS->emitAssignment(Symbol, Value);
757
171k
}
758
759
void MCTargetStreamer::prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
760
932k
                              const MCInst &Inst, const MCSubtargetInfo &STI) {
761
932k
  InstPrinter.printInst(&Inst, OS, "", STI);
762
932k
}
763
764
2.74k
void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
765
2.74k
}
766
767
8.65M
void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
768
8.65M
  switch (Expr.getKind()) {
769
20.5k
  case MCExpr::Target:
770
20.5k
    cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
771
20.5k
    break;
772
8.65M
773
126k
  case MCExpr::Constant:
774
126k
    break;
775
8.65M
776
348k
  case MCExpr::Binary: {
777
348k
    const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
778
348k
    visitUsedExpr(*BE.getLHS());
779
348k
    visitUsedExpr(*BE.getRHS());
780
348k
    break;
781
8.65M
  }
782
8.65M
783
8.16M
  case MCExpr::SymbolRef:
784
8.16M
    visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
785
8.16M
    break;
786
8.65M
787
21
  case MCExpr::Unary:
788
21
    visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
789
21
    break;
790
8.65M
  }
791
8.65M
}
792
793
void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
794
24.3M
                                 bool) {
795
24.3M
  // Scan for values.
796
99.4M
  for (unsigned i = Inst.getNumOperands(); i--;)
797
75.1M
    
if (75.1M
Inst.getOperand(i).isExpr()75.1M
)
798
7.20M
      visitUsedExpr(*Inst.getOperand(i).getExpr());
799
24.3M
}
800
801
void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
802
55.0k
                                        unsigned Size) {
803
55.0k
  // Get the Hi-Lo expression.
804
55.0k
  const MCExpr *Diff =
805
55.0k
      MCBinaryExpr::createSub(MCSymbolRefExpr::create(Hi, Context),
806
55.0k
                              MCSymbolRefExpr::create(Lo, Context), Context);
807
55.0k
808
55.0k
  const MCAsmInfo *MAI = Context.getAsmInfo();
809
55.0k
  if (
!MAI->doesSetDirectiveSuppressReloc()55.0k
) {
810
3.62k
    EmitValue(Diff, Size);
811
3.62k
    return;
812
3.62k
  }
813
51.4k
814
51.4k
  // Otherwise, emit with .set (aka assignment).
815
51.4k
  MCSymbol *SetLabel = Context.createTempSymbol("set", true);
816
51.4k
  EmitAssignment(SetLabel, Diff);
817
51.4k
  EmitSymbolValue(SetLabel, Size);
818
51.4k
}
819
820
5
void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
821
0
void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
822
0
void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
823
0
void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
824
0
  llvm_unreachable("this directive only supported on COFF targets");
825
0
}
826
0
void MCStreamer::EndCOFFSymbolDef() {
827
0
  llvm_unreachable("this directive only supported on COFF targets");
828
0
}
829
7
void MCStreamer::EmitFileDirective(StringRef Filename) {}
830
0
void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
831
0
  llvm_unreachable("this directive only supported on COFF targets");
832
0
}
833
0
void MCStreamer::EmitCOFFSymbolType(int Type) {
834
0
  llvm_unreachable("this directive only supported on COFF targets");
835
0
}
836
48
void MCStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
837
void MCStreamer::emitELFSymverDirective(MCSymbol *Alias,
838
48
                                        const MCSymbol *Aliasee) {}
839
void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
840
0
                                       unsigned ByteAlignment) {}
841
void MCStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
842
0
                                uint64_t Size, unsigned ByteAlignment) {}
843
124
void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {}
844
0
void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
845
412
void MCStreamer::EmitBytes(StringRef Data) {}
846
682
void MCStreamer::EmitBinaryData(StringRef Data) { EmitBytes(Data); }
847
567k
void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) {
848
567k
  visitUsedExpr(*Value);
849
567k
}
850
0
void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
851
0
void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
852
0
void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {}
853
void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
854
0
                          SMLoc Loc) {}
855
void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
856
                                      unsigned ValueSize,
857
4
                                      unsigned MaxBytesToEmit) {}
858
void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
859
28
                                   unsigned MaxBytesToEmit) {}
860
void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
861
0
                                   SMLoc Loc) {}
862
0
void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
863
0
void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
864
75
void MCStreamer::FinishImpl() {}
865
0
void MCStreamer::EmitBundleUnlock() {}
866
867
1.80M
void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
868
1.80M
  assert(Section && "Cannot switch to a null section!");
869
1.80M
  MCSectionSubPair curSection = SectionStack.back().first;
870
1.80M
  SectionStack.back().second = curSection;
871
1.80M
  if (
MCSectionSubPair(Section, Subsection) != curSection1.80M
) {
872
653k
    ChangeSection(Section, Subsection);
873
653k
    SectionStack.back().first = MCSectionSubPair(Section, Subsection);
874
653k
    assert(!Section->hasEnded() && "Section already ended");
875
653k
    MCSymbol *Sym = Section->getBeginSymbol();
876
653k
    if (
Sym && 653k
!Sym->isInSection()631k
)
877
68.4k
      EmitLabel(Sym);
878
653k
  }
879
1.80M
}
880
881
889
MCSymbol *MCStreamer::endSection(MCSection *Section) {
882
889
  // TODO: keep track of the last subsection so that this symbol appears in the
883
889
  // correct place.
884
889
  MCSymbol *Sym = Section->getEndSymbol(Context);
885
889
  if (Sym->isInSection())
886
23
    return Sym;
887
866
888
866
  SwitchSection(Section);
889
866
  EmitLabel(Sym);
890
866
  return Sym;
891
866
}