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