LLVM 19.0.0git
MCObjectStreamer.cpp
Go to the documentation of this file.
1//===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
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
11#include "llvm/MC/MCAsmInfo.h"
12#include "llvm/MC/MCAssembler.h"
14#include "llvm/MC/MCCodeView.h"
15#include "llvm/MC/MCContext.h"
16#include "llvm/MC/MCDwarf.h"
17#include "llvm/MC/MCExpr.h"
20#include "llvm/MC/MCSection.h"
21#include "llvm/MC/MCSymbol.h"
22#include "llvm/MC/MCValue.h"
25using namespace llvm;
26
28 std::unique_ptr<MCAsmBackend> TAB,
29 std::unique_ptr<MCObjectWriter> OW,
30 std::unique_ptr<MCCodeEmitter> Emitter)
31 : MCStreamer(Context),
32 Assembler(std::make_unique<MCAssembler>(
33 Context, std::move(TAB), std::move(Emitter), std::move(OW))),
34 EmitEHFrame(true), EmitDebugFrame(false) {
35 if (Assembler->getBackendPtr())
36 setAllowAutoPadding(Assembler->getBackend().allowAutoPadding());
37 if (Context.getTargetOptions() && Context.getTargetOptions()->MCRelaxAll)
38 Assembler->setRelaxAll(true);
39}
40
42
45 return Assembler.get();
46 return nullptr;
47}
48
50 MCSection *CurSection = getCurrentSectionOnly();
51 if (CurSection) {
52 // Register labels that have not yet been assigned to a Section.
53 if (!PendingLabels.empty()) {
54 for (MCSymbol* Sym : PendingLabels)
55 CurSection->addPendingLabel(Sym);
56 PendingLabels.clear();
57 }
58
59 // Add this label to the current Section / Subsection.
60 CurSection->addPendingLabel(S, CurSubsectionIdx);
61
62 // Add this Section to the list of PendingLabelSections.
63 PendingLabelSections.insert(CurSection);
64 } else
65 // There is no Section / Subsection for this label yet.
66 PendingLabels.push_back(S);
67}
68
70 assert(F);
71 MCSection *CurSection = getCurrentSectionOnly();
72 if (!CurSection) {
73 assert(PendingLabels.empty());
74 return;
75 }
76 // Register labels that have not yet been assigned to a Section.
77 if (!PendingLabels.empty()) {
78 for (MCSymbol* Sym : PendingLabels)
79 CurSection->addPendingLabel(Sym, CurSubsectionIdx);
80 PendingLabels.clear();
81 }
82
83 // Associate the labels with F.
84 CurSection->flushPendingLabels(F, FOffset, CurSubsectionIdx);
85}
86
88 // Register labels that have not yet been assigned to a Section.
89 if (!PendingLabels.empty()) {
90 MCSection *CurSection = getCurrentSectionOnly();
91 assert(CurSection);
92 for (MCSymbol* Sym : PendingLabels)
93 CurSection->addPendingLabel(Sym, CurSubsectionIdx);
94 PendingLabels.clear();
95 }
96
97 // Assign an empty data fragment to all remaining pending labels.
98 for (MCSection* Section : PendingLabelSections)
99 Section->flushPendingLabels();
100}
101
102// When fixup's offset is a forward declared label, e.g.:
103//
104// .reloc 1f, R_MIPS_JALR, foo
105// 1: nop
106//
107// postpone adding it to Fixups vector until the label is defined and its offset
108// is known.
109void MCObjectStreamer::resolvePendingFixups() {
110 for (PendingMCFixup &PendingFixup : PendingFixups) {
111 if (!PendingFixup.Sym || PendingFixup.Sym->isUndefined ()) {
112 getContext().reportError(PendingFixup.Fixup.getLoc(),
113 "unresolved relocation offset");
114 continue;
115 }
116 flushPendingLabels(PendingFixup.DF, PendingFixup.DF->getContents().size());
117 PendingFixup.Fixup.setOffset(PendingFixup.Sym->getOffset() +
118 PendingFixup.Fixup.getOffset());
119
120 // If the location symbol to relocate is in MCEncodedFragmentWithFixups,
121 // put the Fixup into location symbol's fragment. Otherwise
122 // put into PendingFixup.DF
123 MCFragment *SymFragment = PendingFixup.Sym->getFragment();
124 switch (SymFragment->getKind()) {
128 cast<MCEncodedFragmentWithFixups<8, 1>>(SymFragment)
129 ->getFixups()
130 .push_back(PendingFixup.Fixup);
131 break;
134 cast<MCEncodedFragmentWithFixups<32, 4>>(SymFragment)
135 ->getFixups()
136 .push_back(PendingFixup.Fixup);
137 break;
138 default:
139 PendingFixup.DF->getFixups().push_back(PendingFixup.Fixup);
140 break;
141 }
142 }
143 PendingFixups.clear();
144}
145
146// As a compile-time optimization, avoid allocating and evaluating an MCExpr
147// tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
148static std::optional<uint64_t> absoluteSymbolDiff(const MCSymbol *Hi,
149 const MCSymbol *Lo) {
150 assert(Hi && Lo);
151 if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
152 Hi->isVariable() || Lo->isVariable())
153 return std::nullopt;
154
155 return Hi->getOffset() - Lo->getOffset();
156}
157
159 const MCSymbol *Lo,
160 unsigned Size) {
161 if (!getAssembler().getContext().getTargetTriple().isRISCV())
162 if (std::optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo))
163 return emitIntValue(*Diff, Size);
165}
166
168 const MCSymbol *Lo) {
169 if (!getAssembler().getContext().getTargetTriple().isRISCV())
170 if (std::optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
171 emitULEB128IntValue(*Diff);
172 return;
173 }
175}
176
178 if (Assembler) {
179 Assembler->reset();
180 if (getContext().getTargetOptions())
181 Assembler->setRelaxAll(getContext().getTargetOptions()->MCRelaxAll);
182 }
183 EmitEHFrame = true;
184 EmitDebugFrame = false;
185 PendingLabels.clear();
186 PendingLabelSections.clear();
188}
189
191 if (!getNumFrameInfos())
192 return;
193
194 if (EmitEHFrame)
195 MCDwarfFrameEmitter::Emit(*this, MAB, true);
196
197 if (EmitDebugFrame)
198 MCDwarfFrameEmitter::Emit(*this, MAB, false);
199}
200
203}
204
206 const MCAssembler &Assembler,
207 const MCSubtargetInfo *STI) {
208 if (!F.hasInstructions())
209 return true;
210 // Do not add data after a linker-relaxable instruction. The difference
211 // between a new label and a label at or before the linker-relaxable
212 // instruction cannot be resolved at assemble-time.
213 if (F.isLinkerRelaxable())
214 return false;
215 // When bundling is enabled, we don't want to add data to a fragment that
216 // already has instructions (see MCELFStreamer::emitInstToData for details)
217 if (Assembler.isBundlingEnabled())
218 return Assembler.getRelaxAll();
219 // If the subtarget is changed mid fragment we start a new fragment to record
220 // the new STI.
221 return !STI || F.getSubtargetInfo() == STI;
222}
223
226 MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
227 if (!F || !canReuseDataFragment(*F, *Assembler, STI)) {
228 F = new MCDataFragment();
229 insert(F);
230 }
231 return F;
232}
233
235 Assembler->registerSymbol(Sym);
236}
237
240 EmitEHFrame = EH;
241 EmitDebugFrame = Debug;
242}
243
245 SMLoc Loc) {
248 flushPendingLabels(DF, DF->getContents().size());
249
251
252 // Avoid fixups when possible.
253 int64_t AbsValue;
254 if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
255 if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
257 Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
258 return;
259 }
260 emitIntValue(AbsValue, Size);
261 return;
262 }
263 DF->getFixups().push_back(
264 MCFixup::create(DF->getContents().size(), Value,
265 MCFixup::getKindForSize(Size, false), Loc));
266 DF->getContents().resize(DF->getContents().size() + Size, 0);
267}
268
269MCSymbol *MCObjectStreamer::emitCFILabel() {
270 MCSymbol *Label = getContext().createTempSymbol("cfi");
271 emitLabel(Label);
272 return Label;
273}
274
275void MCObjectStreamer::emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
276 // We need to create a local symbol to avoid relocations.
278 emitLabel(Frame.Begin);
279}
280
281void MCObjectStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
282 Frame.End = getContext().createTempSymbol();
283 emitLabel(Frame.End);
284}
285
287 MCStreamer::emitLabel(Symbol, Loc);
288
289 getAssembler().registerSymbol(*Symbol);
290
291 // If there is a current fragment, mark the symbol as pointing into it.
292 // Otherwise queue the label and set its fragment pointer when we emit the
293 // next fragment.
294 auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
295 if (F && !(getAssembler().isBundlingEnabled() &&
296 getAssembler().getRelaxAll())) {
297 Symbol->setFragment(F);
298 Symbol->setOffset(F->getContents().size());
299 } else {
300 // Assign all pending labels to offset 0 within the dummy "pending"
301 // fragment. (They will all be reassigned to a real fragment in
302 // flushPendingLabels())
303 Symbol->setOffset(0);
304 addPendingLabel(Symbol);
305 }
306
308}
309
311 auto Assignments = pendingAssignments.find(Symbol);
312 if (Assignments != pendingAssignments.end()) {
313 for (const PendingAssignment &A : Assignments->second)
314 emitAssignment(A.Symbol, A.Value);
315
316 pendingAssignments.erase(Assignments);
317 }
318}
319
320// Emit a label at a previously emitted fragment/offset position. This must be
321// within the currently-active section.
324 assert(F->getParent() == getCurrentSectionOnly());
325
326 MCStreamer::emitLabel(Symbol, Loc);
327 getAssembler().registerSymbol(*Symbol);
328 auto *DF = dyn_cast_or_null<MCDataFragment>(F);
329 Symbol->setOffset(Offset);
330 if (DF) {
331 Symbol->setFragment(F);
332 } else {
333 assert(isa<MCDummyFragment>(F) &&
334 "F must either be an MCDataFragment or the pending MCDummyFragment");
335 assert(Offset == 0);
336 addPendingLabel(Symbol);
337 }
338}
339
341 int64_t IntValue;
342 if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
343 emitULEB128IntValue(IntValue);
344 return;
345 }
346 insert(new MCLEBFragment(*Value, false));
347}
348
350 int64_t IntValue;
351 if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
352 emitSLEB128IntValue(IntValue);
353 return;
354 }
355 insert(new MCLEBFragment(*Value, true));
356}
357
359 const MCSymbol *Symbol) {
360 report_fatal_error("This file format doesn't support weak aliases.");
361}
362
364 const MCExpr *Subsection) {
365 changeSectionImpl(Section, Subsection);
366}
367
369 const MCExpr *Subsection) {
370 assert(Section && "Cannot switch to a null section!");
372
373 bool Created = getAssembler().registerSection(*Section);
374
375 int64_t IntSubsection = 0;
376 if (Subsection &&
377 !Subsection->evaluateAsAbsolute(IntSubsection, getAssemblerPtr())) {
378 getContext().reportError(Subsection->getLoc(),
379 "cannot evaluate subsection number");
380 }
381 if (!isUInt<31>(IntSubsection)) {
382 getContext().reportError(Subsection->getLoc(),
383 "subsection number " + Twine(IntSubsection) +
384 " is not within [0,2147483647]");
385 }
386
387 CurSubsectionIdx = unsigned(IntSubsection);
388 Section->switchSubsection(CurSubsectionIdx);
389 return Created;
390}
391
393 getAssembler().registerSymbol(*Symbol);
396}
397
399 const MCExpr *Value) {
400 const MCSymbol *Target = &cast<MCSymbolRefExpr>(*Value).getSymbol();
401
402 // If the symbol already exists, emit the assignment. Otherwise, emit it
403 // later only if the symbol is also emitted.
404 if (Target->isRegistered())
405 emitAssignment(Symbol, Value);
406 else
407 pendingAssignments[Target].push_back({Symbol, Value});
408}
409
411 return Sec.hasInstructions();
412}
413
415 const MCSubtargetInfo &STI) {
416 const MCSection &Sec = *getCurrentSectionOnly();
417 if (Sec.isVirtualSection()) {
419 " section '" + Sec.getName() +
420 "' cannot have instructions");
421 return;
422 }
423 getAssembler().getBackend().emitInstructionBegin(*this, Inst, STI);
424 emitInstructionImpl(Inst, STI);
426}
427
428void MCObjectStreamer::emitInstructionImpl(const MCInst &Inst,
429 const MCSubtargetInfo &STI) {
431
433 Sec->setHasInstructions(true);
434
435 // Now that a machine instruction has been assembled into this section, make
436 // a line entry for any .loc directive that has been seen.
438
439 // If this instruction doesn't need relaxation, just emit it as data.
440 MCAssembler &Assembler = getAssembler();
441 MCAsmBackend &Backend = Assembler.getBackend();
442 if (!(Backend.mayNeedRelaxation(Inst, STI) ||
443 Backend.allowEnhancedRelaxation())) {
444 emitInstToData(Inst, STI);
445 return;
446 }
447
448 // Otherwise, relax and emit it as data if either:
449 // - The RelaxAll flag was passed
450 // - Bundling is enabled and this instruction is inside a bundle-locked
451 // group. We want to emit all such instructions into the same data
452 // fragment.
453 if (Assembler.getRelaxAll() ||
454 (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
455 MCInst Relaxed = Inst;
456 while (Backend.mayNeedRelaxation(Relaxed, STI))
457 Backend.relaxInstruction(Relaxed, STI);
458 emitInstToData(Relaxed, STI);
459 return;
460 }
461
462 // Otherwise emit to a separate fragment.
463 emitInstToFragment(Inst, STI);
464}
465
467 const MCSubtargetInfo &STI) {
468 if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
469 llvm_unreachable("All instructions should have already been relaxed");
470
471 // Always create a new, separate fragment here, because its size can change
472 // during relaxation.
473 MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
474 insert(IF);
475
476 SmallString<128> Code;
477 getAssembler().getEmitter().encodeInstruction(Inst, Code, IF->getFixups(),
478 STI);
479 IF->getContents().append(Code.begin(), Code.end());
480}
481
482#ifndef NDEBUG
483static const char *const BundlingNotImplementedMsg =
484 "Aligned bundling is not implemented for this object format";
485#endif
486
489}
490
491void MCObjectStreamer::emitBundleLock(bool AlignToEnd) {
493}
494
497}
498
499void MCObjectStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line,
500 unsigned Column, unsigned Flags,
501 unsigned Isa,
502 unsigned Discriminator,
503 StringRef FileName) {
504 // In case we see two .loc directives in a row, make sure the
505 // first one gets a line entry.
507
508 this->MCStreamer::emitDwarfLocDirective(FileNo, Line, Column, Flags, Isa,
509 Discriminator, FileName);
510}
511
513 const MCSymbol *B, SMLoc Loc) {
514 MCContext &Context = OS.getContext();
516 const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
517 const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
518 const MCExpr *AddrDelta =
519 MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context, Loc);
520 return AddrDelta;
521}
522
525 int64_t LineDelta, const MCSymbol *Label,
526 int PointerSize) {
527 // emit the sequence to set the address
528 OS.emitIntValue(dwarf::DW_LNS_extended_op, 1);
529 OS.emitULEB128IntValue(PointerSize + 1);
530 OS.emitIntValue(dwarf::DW_LNE_set_address, 1);
531 OS.emitSymbolValue(Label, PointerSize);
532
533 // emit the sequence for the LineDelta (from 1) and a zero address delta.
534 MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
535}
536
538 const MCSymbol *LastLabel,
539 const MCSymbol *Label,
540 unsigned PointerSize) {
541 if (!LastLabel) {
542 emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
543 Label, PointerSize);
544 return;
545 }
546 const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, SMLoc());
547 insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
548}
549
551 MCSymbol *LastLabel) {
552 // Emit a DW_LNE_end_sequence for the end of the section.
553 // Use the section end label to compute the address delta and use INT64_MAX
554 // as the line delta which is the signal that this is actually a
555 // DW_LNE_end_sequence.
556 MCSymbol *SectionEnd = endSection(Section);
557
558 // Switch back the dwarf line section, in case endSection had to switch the
559 // section.
560 MCContext &Ctx = getContext();
562
563 const MCAsmInfo *AsmInfo = Ctx.getAsmInfo();
564 emitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd,
565 AsmInfo->getCodePointerSize());
566}
567
569 const MCSymbol *Label,
570 SMLoc Loc) {
571 const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, Loc);
572 insert(new MCDwarfCallFrameFragment(*AddrDelta, nullptr));
573}
574
576 unsigned Line, unsigned Column,
577 bool PrologueEnd, bool IsStmt,
578 StringRef FileName, SMLoc Loc) {
579 // Validate the directive.
580 if (!checkCVLocSection(FunctionId, FileNo, Loc))
581 return;
582
583 // Emit a label at the current position and record it in the CodeViewContext.
584 MCSymbol *LineSym = getContext().createTempSymbol();
585 emitLabel(LineSym);
587 FileNo, Line, Column, PrologueEnd,
588 IsStmt);
589}
590
592 const MCSymbol *Begin,
593 const MCSymbol *End) {
595 End);
596 this->MCStreamer::emitCVLinetableDirective(FunctionId, Begin, End);
597}
598
600 unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
601 const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
603 *this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
604 FnEndSym);
606 PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
607}
608
610 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
611 StringRef FixedSizePortion) {
612 MCFragment *Frag =
613 getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
614 // Attach labels that were pending before we created the defrange fragment to
615 // the beginning of the new fragment.
616 flushPendingLabels(Frag, 0);
617 this->MCStreamer::emitCVDefRangeDirective(Ranges, FixedSizePortion);
618}
619
622}
625}
626
629}
630
634 flushPendingLabels(DF, DF->getContents().size());
635 DF->getContents().append(Data.begin(), Data.end());
636}
637
639 unsigned ValueSize,
640 unsigned MaxBytesToEmit) {
641 if (MaxBytesToEmit == 0)
642 MaxBytesToEmit = Alignment.value();
643 insert(new MCAlignFragment(Alignment, Value, ValueSize, MaxBytesToEmit));
644
645 // Update the maximum alignment on the current section if necessary.
647 CurSec->ensureMinAlignment(Alignment);
648}
649
651 const MCSubtargetInfo *STI,
652 unsigned MaxBytesToEmit) {
653 emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);
654 cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true, STI);
655}
656
658 unsigned char Value,
659 SMLoc Loc) {
660 insert(new MCOrgFragment(*Offset, Value, Loc));
661}
662
663// Associate DTPRel32 fixup with data and resize data area
666 flushPendingLabels(DF, DF->getContents().size());
667
668 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
670 DF->getContents().resize(DF->getContents().size() + 4, 0);
671}
672
673// Associate DTPRel64 fixup with data and resize data area
676 flushPendingLabels(DF, DF->getContents().size());
677
678 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
680 DF->getContents().resize(DF->getContents().size() + 8, 0);
681}
682
683// Associate TPRel32 fixup with data and resize data area
686 flushPendingLabels(DF, DF->getContents().size());
687
688 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
689 Value, FK_TPRel_4));
690 DF->getContents().resize(DF->getContents().size() + 4, 0);
691}
692
693// Associate TPRel64 fixup with data and resize data area
696 flushPendingLabels(DF, DF->getContents().size());
697
698 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
699 Value, FK_TPRel_8));
700 DF->getContents().resize(DF->getContents().size() + 8, 0);
701}
702
703// Associate GPRel32 fixup with data and resize data area
706 flushPendingLabels(DF, DF->getContents().size());
707
708 DF->getFixups().push_back(
709 MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
710 DF->getContents().resize(DF->getContents().size() + 4, 0);
711}
712
713// Associate GPRel64 fixup with data and resize data area
716 flushPendingLabels(DF, DF->getContents().size());
717
718 DF->getFixups().push_back(
719 MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
720 DF->getContents().resize(DF->getContents().size() + 8, 0);
721}
722
723static std::optional<std::pair<bool, std::string>>
724getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset,
725 MCDataFragment *&DF) {
726 if (Symbol.isVariable()) {
727 const MCExpr *SymbolExpr = Symbol.getVariableValue();
728 MCValue OffsetVal;
729 if(!SymbolExpr->evaluateAsRelocatable(OffsetVal, nullptr, nullptr))
730 return std::make_pair(false,
731 std::string("symbol in .reloc offset is not "
732 "relocatable"));
733 if (OffsetVal.isAbsolute()) {
734 RelocOffset = OffsetVal.getConstant();
735 MCFragment *Fragment = Symbol.getFragment();
736 // FIXME Support symbols with no DF. For example:
737 // .reloc .data, ENUM_VALUE, <some expr>
738 if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
739 return std::make_pair(false,
740 std::string("symbol in offset has no data "
741 "fragment"));
742 DF = cast<MCDataFragment>(Fragment);
743 return std::nullopt;
744 }
745
746 if (OffsetVal.getSymB())
747 return std::make_pair(false,
748 std::string(".reloc symbol offset is not "
749 "representable"));
750
751 const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
752 if (!SRE.getSymbol().isDefined())
753 return std::make_pair(false,
754 std::string("symbol used in the .reloc offset is "
755 "not defined"));
756
757 if (SRE.getSymbol().isVariable())
758 return std::make_pair(false,
759 std::string("symbol used in the .reloc offset is "
760 "variable"));
761
762 MCFragment *Fragment = SRE.getSymbol().getFragment();
763 // FIXME Support symbols with no DF. For example:
764 // .reloc .data, ENUM_VALUE, <some expr>
765 if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
766 return std::make_pair(false,
767 std::string("symbol in offset has no data "
768 "fragment"));
769 RelocOffset = SRE.getSymbol().getOffset() + OffsetVal.getConstant();
770 DF = cast<MCDataFragment>(Fragment);
771 } else {
772 RelocOffset = Symbol.getOffset();
773 MCFragment *Fragment = Symbol.getFragment();
774 // FIXME Support symbols with no DF. For example:
775 // .reloc .data, ENUM_VALUE, <some expr>
776 if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
777 return std::make_pair(false,
778 std::string("symbol in offset has no data "
779 "fragment"));
780 DF = cast<MCDataFragment>(Fragment);
781 }
782 return std::nullopt;
783}
784
785std::optional<std::pair<bool, std::string>>
787 const MCExpr *Expr, SMLoc Loc,
788 const MCSubtargetInfo &STI) {
789 std::optional<MCFixupKind> MaybeKind =
790 Assembler->getBackend().getFixupKind(Name);
791 if (!MaybeKind)
792 return std::make_pair(true, std::string("unknown relocation name"));
793
794 MCFixupKind Kind = *MaybeKind;
795 if (Expr)
796 visitUsedExpr(*Expr);
797 else
798 Expr =
799 MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
800
802 flushPendingLabels(DF, DF->getContents().size());
803
804 MCValue OffsetVal;
805 if (!Offset.evaluateAsRelocatable(OffsetVal, nullptr, nullptr))
806 return std::make_pair(false,
807 std::string(".reloc offset is not relocatable"));
808 if (OffsetVal.isAbsolute()) {
809 if (OffsetVal.getConstant() < 0)
810 return std::make_pair(false, std::string(".reloc offset is negative"));
811 DF->getFixups().push_back(
812 MCFixup::create(OffsetVal.getConstant(), Expr, Kind, Loc));
813 return std::nullopt;
814 }
815 if (OffsetVal.getSymB())
816 return std::make_pair(false,
817 std::string(".reloc offset is not representable"));
818
819 const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
820 const MCSymbol &Symbol = SRE.getSymbol();
821 if (Symbol.isDefined()) {
822 uint32_t SymbolOffset = 0;
823 std::optional<std::pair<bool, std::string>> Error =
824 getOffsetAndDataFragment(Symbol, SymbolOffset, DF);
825
826 if (Error != std::nullopt)
827 return Error;
828
829 DF->getFixups().push_back(
830 MCFixup::create(SymbolOffset + OffsetVal.getConstant(),
831 Expr, Kind, Loc));
832 return std::nullopt;
833 }
834
835 PendingFixups.emplace_back(
836 &SRE.getSymbol(), DF,
837 MCFixup::create(OffsetVal.getConstant(), Expr, Kind, Loc));
838 return std::nullopt;
839}
840
841void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
842 SMLoc Loc) {
844 flushPendingLabels(DF, DF->getContents().size());
845
846 assert(getCurrentSectionOnly() && "need a section");
847 insert(new MCFillFragment(FillValue, 1, NumBytes, Loc));
848}
849
850void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
851 int64_t Expr, SMLoc Loc) {
852 int64_t IntNumValues;
853 // Do additional checking now if we can resolve the value.
854 if (NumValues.evaluateAsAbsolute(IntNumValues, getAssemblerPtr())) {
855 if (IntNumValues < 0) {
858 "'.fill' directive with negative repeat count has no effect");
859 return;
860 }
861 // Emit now if we can for better errors.
862 int64_t NonZeroSize = Size > 4 ? 4 : Size;
863 Expr &= ~0ULL >> (64 - NonZeroSize * 8);
864 for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
865 emitIntValue(Expr, NonZeroSize);
866 if (NonZeroSize < Size)
867 emitIntValue(0, Size - NonZeroSize);
868 }
869 return;
870 }
871
872 // Otherwise emit as fragment.
874 flushPendingLabels(DF, DF->getContents().size());
875
876 assert(getCurrentSectionOnly() && "need a section");
877 insert(new MCFillFragment(Expr, Size, NumValues, Loc));
878}
879
880void MCObjectStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLength,
881 SMLoc Loc, const MCSubtargetInfo &STI) {
882 // Emit an NOP fragment.
884 flushPendingLabels(DF, DF->getContents().size());
885
886 assert(getCurrentSectionOnly() && "need a section");
887
888 insert(new MCNopsFragment(NumBytes, ControlledNopLength, Loc, STI));
889}
890
892 getAssembler().addFileName(Filename);
893}
894
896 StringRef CompilerVersion,
897 StringRef TimeStamp,
898 StringRef Description) {
899 getAssembler().addFileName(Filename);
900 getAssembler().setCompilerVersion(CompilerVersion.str());
901 // TODO: add TimeStamp and Description to .file symbol table entry
902 // with the integrated assembler.
903}
904
907}
908
911}
912
915
916 // If we are generating dwarf for assembly source files dump out the sections.
917 if (getContext().getGenDwarfForAssembly())
919
920 // Dump out the dwarf file & directory tables and line tables.
921 MCDwarfLineTable::emit(this, getAssembler().getDWARFLinetableParams());
922
923 // Emit pseudo probes for the current module.
925
926 // Update any remaining pending labels with empty data fragments.
928
929 resolvePendingFixups();
931}
basic Basic Alias true
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
dxil DXContainer Global Emitter
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
std::string Name
uint64_t Size
bool End
Definition: ELF_riscv.cpp:480
Symbol * Sym
Definition: ELF_riscv.cpp:479
static const MCExpr * buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A, const MCSymbol *B, SMLoc Loc)
static const char *const BundlingNotImplementedMsg
static std::optional< std::pair< bool, std::string > > getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset, MCDataFragment *&DF)
static void emitDwarfSetLineAddr(MCObjectStreamer &OS, MCDwarfLineTableParams Params, int64_t LineDelta, const MCSymbol *Label, int PointerSize)
static std::optional< uint64_t > absoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo)
static bool canReuseDataFragment(const MCDataFragment &F, const MCAssembler &Assembler, const MCSubtargetInfo *STI)
#define F(x, y, z)
Definition: MD5.cpp:55
bool Debug
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
void emitLineTableForFunction(MCObjectStreamer &OS, unsigned FuncId, const MCSymbol *FuncBegin, const MCSymbol *FuncEnd)
Emits a line table substream.
Definition: MCCodeView.cpp:350
void emitFileChecksums(MCObjectStreamer &OS)
Emits the file checksum substream.
Definition: MCCodeView.cpp:193
void recordCVLoc(MCContext &Ctx, const MCSymbol *Label, unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt)
Saves the information from the currently parsed .cv_loc directive and sets CVLocSeen.
Definition: MCCodeView.cpp:131
void emitFileChecksumOffset(MCObjectStreamer &OS, unsigned FileNo)
Emits the offset into the checksum table of the given file number.
Definition: MCCodeView.cpp:248
void emitInlineLineTableForFunction(MCObjectStreamer &OS, unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
Definition: MCCodeView.cpp:445
void emitStringTable(MCObjectStreamer &OS)
Emits the string table substream.
Definition: MCCodeView.cpp:171
MCFragment * emitDefRange(MCObjectStreamer &OS, ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > Ranges, StringRef FixedSizePortion)
Definition: MCCodeView.cpp:458
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:43
virtual bool allowEnhancedRelaxation() const
Return true if this target allows an unrelaxable instruction to be emitted into RelaxableFragment and...
Definition: MCAsmBackend.h:63
virtual void relaxInstruction(MCInst &Inst, const MCSubtargetInfo &STI) const
Relax the instruction in the given fragment to the next wider instruction.
Definition: MCAsmBackend.h:186
virtual bool mayNeedRelaxation(const MCInst &Inst, const MCSubtargetInfo &STI) const
Check whether the given instruction may need relaxation.
Definition: MCAsmBackend.h:163
virtual void emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst)
Definition: MCAsmBackend.h:70
virtual void emitInstructionBegin(MCObjectStreamer &OS, const MCInst &Inst, const MCSubtargetInfo &STI)
Give the target a chance to manipulate state related to instruction alignment (e.g.
Definition: MCAsmBackend.h:68
virtual std::optional< MCFixupKind > getFixupKind(StringRef Name) const
Map a relocation name used in .reloc to a fixup kind.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:546
void Finish()
Finish - Do final processing and write the object to the output stream.
bool isBundlingEnabled() const
Definition: MCAssembler.h:361
MCObjectWriter & getWriter() const
Definition: MCAssembler.h:334
bool getRelaxAll() const
Definition: MCAssembler.h:358
MCCodeEmitter & getEmitter() const
Definition: MCAssembler.h:332
void addFileName(StringRef FileName)
Definition: MCAssembler.h:483
MCAsmBackend & getBackend() const
Definition: MCAssembler.h:330
bool registerSection(MCSection &Section)
bool registerSymbol(const MCSymbol &Symbol)
MCDwarfLineTableParams getDWARFLinetableParams() const
Definition: MCAssembler.h:336
void setCompilerVersion(std::string CompilerVers)
Definition: MCAssembler.h:487
static const MCBinaryExpr * create(Opcode Op, const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:183
@ Sub
Subtraction.
Definition: MCExpr.h:517
virtual void encodeInstruction(const MCInst &Inst, SmallVectorImpl< char > &CB, SmallVectorImpl< MCFixup > &Fixups, const MCSubtargetInfo &STI) const =0
Encode the given Inst to bytes and append to CB.
Context object for machine code objects.
Definition: MCContext.h:81
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:416
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:322
void RemapDebugPaths()
Definition: MCContext.cpp:934
void clearDwarfLocSeen()
Definition: MCContext.h:755
CodeViewContext & getCVContext()
Definition: MCContext.cpp:1044
const SourceMgr * getSourceManager() const
Definition: MCContext.h:401
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:412
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1099
const MCTargetOptions * getTargetOptions() const
Definition: MCContext.h:420
Fragment for data and encoded instructions.
Definition: MCFragment.h:235
static void Emit(MCObjectStreamer &streamer, MCAsmBackend *MAB, bool isEH)
Definition: MCDwarf.cpp:1860
static void Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, int64_t LineDelta, uint64_t AddrDelta)
Utility function to emit the encoding to a streamer.
Definition: MCDwarf.cpp:674
static void make(MCStreamer *MCOS, MCSection *Section)
Definition: MCDwarf.cpp:95
static void emit(MCStreamer *MCOS, MCDwarfLineTableParams Params)
Definition: MCDwarf.cpp:260
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool evaluateAsRelocatable(MCValue &Res, const MCAsmLayout *Layout, const MCFixup *Fixup) const
Try to evaluate the expression to a relocatable value, i.e.
Definition: MCExpr.cpp:809
SMLoc getLoc() const
Definition: MCExpr.h:82
static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel)
Return the generic fixup kind for a value with the given size.
Definition: MCFixup.h:109
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:87
FragmentType getKind() const
Definition: MCFragment.h:91
static void Emit(MCStreamer *MCOS)
Definition: MCDwarf.cpp:1143
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
SMLoc getLoc() const
Definition: MCInst.h:204
MCSection * getDwarfLineSection() const
Streaming object file generation interface.
void reset() override
state management
void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc=SMLoc()) override
Emit Size bytes worth of the value specified by FillValue.
void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel) override
Emit the debug line end entry.
void emitValueToAlignment(Align Alignment, int64_t Value=0, unsigned ValueSize=1, unsigned MaxBytesToEmit=0) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override
Emit an assignment of Value to Symbol.
void emitULEB128Value(const MCExpr *Value) override
void emitSLEB128Value(const MCExpr *Value) override
void emitNops(int64_t NumBytes, int64_t ControlledNopLength, SMLoc Loc, const MCSubtargetInfo &STI) override
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment.
void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) override
This implements the CodeView '.cv_inline_linetable' assembler directive.
void emitCVStringTableDirective() override
This implements the CodeView '.cv_stringtable' assembler directive.
void emitBundleAlignMode(Align Alignment) override
Set the bundle alignment mode from now on in the section.
MCAssembler & getAssembler()
void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override
Emit an weak reference from Alias to Symbol.
void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel, const MCSymbol *Label, unsigned PointerSize) override
If targets does not support representing debug line section by .loc/.file directives in assembly outp...
void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line, unsigned Column, bool PrologueEnd, bool IsStmt, StringRef FileName, SMLoc Loc) override
This implements the CodeView '.cv_loc' assembler directive.
void emitDTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (32-bit DTP relative) value.
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
void emitBundleLock(bool AlignToEnd) override
The following instructions are a bundle-locked group.
void emitPendingAssignments(MCSymbol *Symbol)
Emits pending conditional assignments that depend on Symbol being emitted.
void emitFileDirective(StringRef Filename) override
Switch to a new logical file.
void emitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > Ranges, StringRef FixedSizePortion) override
This implements the CodeView '.cv_def_range' assembler directive.
void emitGPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel64 (64-bit GP relative) value.
MCAssembler * getAssemblerPtr() override
void flushPendingLabels()
Create a data fragment for any pending labels across all Sections and Subsections.
virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset)
std::optional< std::pair< bool, std::string > > emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override
Record a relocation described by the .reloc directive.
void emitAddrsigSym(const MCSymbol *Sym) override
void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override
Emit the given Instruction into the current section.
void visitUsedSymbol(const MCSymbol &Sym) override
void emitGPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a gprel32 (32-bit GP relative) value.
void insert(MCFragment *F)
virtual void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &)
Emit an instruction to a special fragment, because this instruction can change its size during relaxa...
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
MCObjectStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void finishImpl() override
Streamer specific finalization.
void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) override
Emit the absolute difference between two symbols encoded with ULEB128.
void emitBundleUnlock() override
Ends a bundle-locked group.
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection)
void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel, const MCSymbol *Label, SMLoc Loc)
void emitCFISections(bool EH, bool Debug) override
void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName) override
This implements the DWARF2 '.loc fileno lineno ...' assembler directive.
void addPendingLabel(MCSymbol *label)
Assign a label to the current Section and Subsection even though a fragment is not yet present.
bool mayHaveInstructions(MCSection &Sec) const override
MCFragment * getCurrentFragment() const
void emitCodeAlignment(Align ByteAlignment, const MCSubtargetInfo *STI, unsigned MaxBytesToEmit=0) override
Emit nops until the byte alignment ByteAlignment is reached.
void emitFrames(MCAsmBackend *MAB)
void changeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
void emitTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (64-bit TP relative) value.
void emitCVFileChecksumOffsetDirective(unsigned FileNo) override
This implements the CodeView '.cv_filechecksumoffset' assembler directive.
void emitTPRel32Value(const MCExpr *Value) override
Emit the expression Value into the output as a tprel (32-bit TP relative) value.
void emitConditionalAssignment(MCSymbol *Symbol, const MCExpr *Value) override
Emit an assignment of Value to Symbol, but only if Value is also emitted.
void emitCVFileChecksumsDirective() override
This implements the CodeView '.cv_filechecksums' assembler directive.
void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin, const MCSymbol *End) override
This implements the CodeView '.cv_linetable' assembler directive.
void emitDTPRel64Value(const MCExpr *Value) override
Emit the expression Value into the output as a dtprel (64-bit DTP relative) value.
void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc) override
Emit some number of copies of Value until the byte offset Offset is reached.
void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) override
Emit the absolute difference between two symbols if possible.
void emitAddrsigSection()
Tell the object writer to emit an address-significance table during writeObject().
void addAddrsigSymbol(const MCSymbol *Sym)
Record the given symbol in the address-significance table to be written diring writeObject().
static void emit(MCObjectStreamer *MCOS)
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:267
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:35
void addPendingLabel(MCSymbol *label, unsigned Subsection=0)
Add a pending label for the requested subsection.
Definition: MCSection.cpp:81
virtual StringRef getVirtualSectionKind() const
Definition: MCSection.cpp:79
void ensureMinAlignment(Align MinAlignment)
Makes sure that Alignment is at least MinAlignment.
Definition: MCSection.h:156
void flushPendingLabels(MCFragment *F, uint64_t FOffset=0, unsigned Subsection=0)
Associate all pending labels in a subsection with a fragment.
Definition: MCSection.cpp:85
bool hasInstructions() const
Definition: MCSection.h:178
void setHasInstructions(bool Value)
Definition: MCSection.h:179
virtual bool isVirtualSection() const =0
Check whether this section is "virtual", that is has no actual object file contents.
bool isBundleLocked() const
Definition: MCSection.h:169
StringRef getName() const
Definition: MCSection.h:136
FragList * curFragList() const
Definition: MCSection.h:190
Streaming machine code generation interface.
Definition: MCStreamer.h:212
virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value)
Emit an assignment of Value to Symbol.
virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags, unsigned Isa, unsigned Discriminator, StringRef FileName)
This implements the DWARF2 '.loc fileno lineno ...' assembler directive.
Definition: MCStreamer.cpp:263
virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo)
Emit the absolute difference between two symbols encoded with ULEB128.
bool getUseAssemblerInfoForParsing()
Definition: MCStreamer.h:304
MCContext & getContext() const
Definition: MCStreamer.h:297
bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc)
Returns true if the .cv_loc directive is in the right section.
Definition: MCStreamer.cpp:325
virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size)
Emit the absolute difference between two symbols.
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:424
void setAllowAutoPadding(bool v)
Definition: MCStreamer.h:310
virtual void reset()
State management.
Definition: MCStreamer.cpp:102
virtual void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart, const MCSymbol *FnEnd)
This implements the CodeView '.cv_linetable' assembler directive.
Definition: MCStreamer.cpp:347
virtual void emitCFISections(bool EH, bool Debug)
Definition: MCStreamer.cpp:446
virtual void emitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers.
Definition: MCStreamer.cpp:134
unsigned getNumFrameInfos()
Definition: MCStreamer.cpp:116
unsigned emitULEB128IntValue(uint64_t Value, unsigned PadTo=0)
Special case of EmitULEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:162
MCSymbol * endSection(MCSection *Section)
virtual void switchSection(MCSection *Section, const MCExpr *Subsection=nullptr)
Set the current section where code is being emitted to Section.
virtual void emitCVDefRangeDirective(ArrayRef< std::pair< const MCSymbol *, const MCSymbol * > > Ranges, StringRef FixedSizePortion)
This implements the CodeView '.cv_def_range' assembler directive.
Definition: MCStreamer.cpp:369
MCSection * getCurrentSectionOnly() const
Definition: MCStreamer.h:395
virtual void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Emit the expression Value into the output as a native integer of the given Size bytes.
unsigned emitSLEB128IntValue(int64_t Value)
Special case of EmitSLEB128Value that avoids the client having to pass in a MCExpr for constant integ...
Definition: MCStreamer.cpp:172
virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, const MCSymbol *FnStartSym, const MCSymbol *FnEndSym)
This implements the CodeView '.cv_inline_linetable' assembler directive.
Definition: MCStreamer.cpp:351
void visitUsedExpr(const MCExpr &Expr)
Generic base class for all target subtargets.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
const MCSymbol & getSymbol() const
Definition: MCExpr.h:410
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:397
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:250
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:300
uint64_t getOffset() const
Definition: MCSymbol.h:327
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:397
This represents an "assembler immediate".
Definition: MCValue.h:36
int64_t getConstant() const
Definition: MCValue.h:43
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:45
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:44
bool isAbsolute() const
Is this an absolute (as opposed to relocatable) value.
Definition: MCValue.h:49
Represents a location in source code.
Definition: SMLoc.h:23
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
void PrintMessage(raw_ostream &OS, SMLoc Loc, DiagKind Kind, const Twine &Msg, ArrayRef< SMRange > Ranges={}, ArrayRef< SMFixIt > FixIts={}, bool ShowColors=true) const
Emit a message about the specified location with the specified string.
Definition: SourceMgr.cpp:352
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:223
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
This class represents a function that is read from a sample profile.
Definition: FunctionId.h:36
#define INT64_MAX
Definition: DataTypes.h:71
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:239
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:159
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:21
@ FK_DTPRel_4
A four-byte dtp relative fixup.
Definition: MCFixup.h:36
@ FK_DTPRel_8
A eight-byte dtp relative fixup.
Definition: MCFixup.h:37
@ FK_TPRel_4
A four-byte tp relative fixup.
Definition: MCFixup.h:38
@ FK_GPRel_4
A four-byte gp relative fixup.
Definition: MCFixup.h:34
@ FK_TPRel_8
A eight-byte tp relative fixup.
Definition: MCFixup.h:39
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:244
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1849
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
MCSymbol * Begin
Definition: MCDwarf.h:700