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 
9 #include "llvm/MC/MCObjectStreamer.h"
10 #include "llvm/MC/MCAsmBackend.h"
11 #include "llvm/MC/MCAsmInfo.h"
12 #include "llvm/MC/MCAssembler.h"
13 #include "llvm/MC/MCCodeEmitter.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"
18 #include "llvm/MC/MCObjectFileInfo.h"
19 #include "llvm/MC/MCObjectWriter.h"
20 #include "llvm/MC/MCSection.h"
21 #include "llvm/MC/MCSymbol.h"
22 #include "llvm/MC/MCValue.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/SourceMgr.h"
25 using namespace llvm;
26 
27 MCObjectStreamer::MCObjectStreamer(MCContext &Context,
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 }
38 
39 MCObjectStreamer::~MCObjectStreamer() = default;
40 
41 // AssemblerPtr is used for evaluation of expressions and causes
42 // difference between asm and object outputs. Return nullptr to in
43 // inline asm mode to limit divergence to assembly inputs.
44 MCAssembler *MCObjectStreamer::getAssemblerPtr() {
45   if (getUseAssemblerInfoForParsing())
46     return Assembler.get();
47   return nullptr;
48 }
49 
50 void MCObjectStreamer::addPendingLabel(MCSymbol* S) {
51   MCSection *CurSection = getCurrentSectionOnly();
52   if (CurSection) {
53     // Register labels that have not yet been assigned to a Section.
54     if (!PendingLabels.empty()) {
55       for (MCSymbol* Sym : PendingLabels)
56         CurSection->addPendingLabel(Sym);
57       PendingLabels.clear();
58     }
59 
60     // Add this label to the current Section / Subsection.
61     CurSection->addPendingLabel(S, CurSubsectionIdx);
62 
63     // Add this Section to the list of PendingLabelSections.
64     PendingLabelSections.insert(CurSection);
65   } else
66     // There is no Section / Subsection for this label yet.
67     PendingLabels.push_back(S);
68 }
69 
70 void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
71   assert(F);
72   MCSection *CurSection = getCurrentSectionOnly();
73   if (!CurSection) {
74     assert(PendingLabels.empty());
75     return;
76   }
77   // Register labels that have not yet been assigned to a Section.
78   if (!PendingLabels.empty()) {
79     for (MCSymbol* Sym : PendingLabels)
80       CurSection->addPendingLabel(Sym, CurSubsectionIdx);
81     PendingLabels.clear();
82   }
83 
84   // Associate the labels with F.
85   CurSection->flushPendingLabels(F, FOffset, CurSubsectionIdx);
86 }
87 
88 void MCObjectStreamer::flushPendingLabels() {
89   // Register labels that have not yet been assigned to a Section.
90   if (!PendingLabels.empty()) {
91     MCSection *CurSection = getCurrentSectionOnly();
92     assert(CurSection);
93     for (MCSymbol* Sym : PendingLabels)
94       CurSection->addPendingLabel(Sym, CurSubsectionIdx);
95     PendingLabels.clear();
96   }
97 
98   // Assign an empty data fragment to all remaining pending labels.
99   for (MCSection* Section : PendingLabelSections)
100     Section->flushPendingLabels();
101 }
102 
103 // When fixup's offset is a forward declared label, e.g.:
104 //
105 //   .reloc 1f, R_MIPS_JALR, foo
106 // 1: nop
107 //
108 // postpone adding it to Fixups vector until the label is defined and its offset
109 // is known.
110 void MCObjectStreamer::resolvePendingFixups() {
111   for (PendingMCFixup &PendingFixup : PendingFixups) {
112     if (!PendingFixup.Sym || PendingFixup.Sym->isUndefined ()) {
113       getContext().reportError(PendingFixup.Fixup.getLoc(),
114                                "unresolved relocation offset");
115       continue;
116     }
117     flushPendingLabels(PendingFixup.DF, PendingFixup.DF->getContents().size());
118     PendingFixup.Fixup.setOffset(PendingFixup.Sym->getOffset() +
119                                  PendingFixup.Fixup.getOffset());
120 
121     // If the location symbol to relocate is in MCEncodedFragmentWithFixups,
122     // put the Fixup into location symbol's fragment. Otherwise
123     // put into PendingFixup.DF
124     MCFragment *SymFragment = PendingFixup.Sym->getFragment();
125     switch (SymFragment->getKind()) {
126     case MCFragment::FT_Relaxable:
127     case MCFragment::FT_Dwarf:
128     case MCFragment::FT_PseudoProbe:
129       cast<MCEncodedFragmentWithFixups<8, 1>>(SymFragment)
130           ->getFixups()
131           .push_back(PendingFixup.Fixup);
132       break;
133     case MCFragment::FT_Data:
134     case MCFragment::FT_CVDefRange:
135       cast<MCEncodedFragmentWithFixups<32, 4>>(SymFragment)
136           ->getFixups()
137           .push_back(PendingFixup.Fixup);
138       break;
139     default:
140       PendingFixup.DF->getFixups().push_back(PendingFixup.Fixup);
141       break;
142     }
143   }
144   PendingFixups.clear();
145 }
146 
147 // As a compile-time optimization, avoid allocating and evaluating an MCExpr
148 // tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
149 static std::optional<uint64_t> absoluteSymbolDiff(const MCSymbol *Hi,
150                                                   const MCSymbol *Lo) {
151   assert(Hi && Lo);
152   if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
153       Hi->isVariable() || Lo->isVariable())
154     return std::nullopt;
155 
156   return Hi->getOffset() - Lo->getOffset();
157 }
158 
159 void MCObjectStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi,
160                                               const MCSymbol *Lo,
161                                               unsigned Size) {
162   if (!getAssembler().getContext().getTargetTriple().isRISCV())
163     if (std::optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo))
164       return emitIntValue(*Diff, Size);
165   MCStreamer::emitAbsoluteSymbolDiff(Hi, Lo, Size);
166 }
167 
168 void MCObjectStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
169                                                        const MCSymbol *Lo) {
170   if (!getAssembler().getContext().getTargetTriple().isRISCV())
171     if (std::optional<uint64_t> Diff = absoluteSymbolDiff(Hi, Lo)) {
172       emitULEB128IntValue(*Diff);
173       return;
174     }
175   MCStreamer::emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
176 }
177 
178 void MCObjectStreamer::reset() {
179   if (Assembler)
180     Assembler->reset();
181   CurInsertionPoint = MCSection::iterator();
182   EmitEHFrame = true;
183   EmitDebugFrame = false;
184   PendingLabels.clear();
185   PendingLabelSections.clear();
186   MCStreamer::reset();
187 }
188 
189 void MCObjectStreamer::emitFrames(MCAsmBackend *MAB) {
190   if (!getNumFrameInfos())
191     return;
192 
193   if (EmitEHFrame)
194     MCDwarfFrameEmitter::Emit(*this, MAB, true);
195 
196   if (EmitDebugFrame)
197     MCDwarfFrameEmitter::Emit(*this, MAB, false);
198 }
199 
200 MCFragment *MCObjectStreamer::getCurrentFragment() const {
201   assert(getCurrentSectionOnly() && "No current section!");
202 
203   if (CurInsertionPoint != getCurrentSectionOnly()->getFragmentList().begin())
204     return &*std::prev(CurInsertionPoint);
205 
206   return nullptr;
207 }
208 
209 static bool canReuseDataFragment(const MCDataFragment &F,
210                                  const MCAssembler &Assembler,
211                                  const MCSubtargetInfo *STI) {
212   if (!F.hasInstructions())
213     return true;
214   // Do not add data after a linker-relaxable instruction. The difference
215   // between a new label and a label at or before the linker-relaxable
216   // instruction cannot be resolved at assemble-time.
217   if (F.isLinkerRelaxable())
218     return false;
219   // When bundling is enabled, we don't want to add data to a fragment that
220   // already has instructions (see MCELFStreamer::emitInstToData for details)
221   if (Assembler.isBundlingEnabled())
222     return Assembler.getRelaxAll();
223   // If the subtarget is changed mid fragment we start a new fragment to record
224   // the new STI.
225   return !STI || F.getSubtargetInfo() == STI;
226 }
227 
228 MCDataFragment *
229 MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) {
230   MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
231   if (!F || !canReuseDataFragment(*F, *Assembler, STI)) {
232     F = new MCDataFragment();
233     insert(F);
234   }
235   return F;
236 }
237 
238 void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
239   Assembler->registerSymbol(Sym);
240 }
241 
242 void MCObjectStreamer::emitCFISections(bool EH, bool Debug) {
243   MCStreamer::emitCFISections(EH, Debug);
244   EmitEHFrame = EH;
245   EmitDebugFrame = Debug;
246 }
247 
248 void MCObjectStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
249                                      SMLoc Loc) {
250   MCStreamer::emitValueImpl(Value, Size, Loc);
251   MCDataFragment *DF = getOrCreateDataFragment();
252   flushPendingLabels(DF, DF->getContents().size());
253 
254   MCDwarfLineEntry::make(this, getCurrentSectionOnly());
255 
256   // Avoid fixups when possible.
257   int64_t AbsValue;
258   if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
259     if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
260       getContext().reportError(
261           Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
262       return;
263     }
264     emitIntValue(AbsValue, Size);
265     return;
266   }
267   DF->getFixups().push_back(
268       MCFixup::create(DF->getContents().size(), Value,
269                       MCFixup::getKindForSize(Size, false), Loc));
270   DF->getContents().resize(DF->getContents().size() + Size, 0);
271 }
272 
273 MCSymbol *MCObjectStreamer::emitCFILabel() {
274   MCSymbol *Label = getContext().createTempSymbol("cfi");
275   emitLabel(Label);
276   return Label;
277 }
278 
279 void MCObjectStreamer::emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
280   // We need to create a local symbol to avoid relocations.
281   Frame.Begin = getContext().createTempSymbol();
282   emitLabel(Frame.Begin);
283 }
284 
285 void MCObjectStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
286   Frame.End = getContext().createTempSymbol();
287   emitLabel(Frame.End);
288 }
289 
290 void MCObjectStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) {
291   MCStreamer::emitLabel(Symbol, Loc);
292 
293   getAssembler().registerSymbol(*Symbol);
294 
295   // If there is a current fragment, mark the symbol as pointing into it.
296   // Otherwise queue the label and set its fragment pointer when we emit the
297   // next fragment.
298   auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
299   if (F && !(getAssembler().isBundlingEnabled() &&
300              getAssembler().getRelaxAll())) {
301     Symbol->setFragment(F);
302     Symbol->setOffset(F->getContents().size());
303   } else {
304     // Assign all pending labels to offset 0 within the dummy "pending"
305     // fragment. (They will all be reassigned to a real fragment in
306     // flushPendingLabels())
307     Symbol->setOffset(0);
308     addPendingLabel(Symbol);
309   }
310 
311   emitPendingAssignments(Symbol);
312 }
313 
314 void MCObjectStreamer::emitPendingAssignments(MCSymbol *Symbol) {
315   auto Assignments = pendingAssignments.find(Symbol);
316   if (Assignments != pendingAssignments.end()) {
317     for (const PendingAssignment &A : Assignments->second)
318       emitAssignment(A.Symbol, A.Value);
319 
320     pendingAssignments.erase(Assignments);
321   }
322 }
323 
324 // Emit a label at a previously emitted fragment/offset position. This must be
325 // within the currently-active section.
326 void MCObjectStreamer::emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc,
327                                       MCFragment *F, uint64_t Offset) {
328   assert(F->getParent() == getCurrentSectionOnly());
329 
330   MCStreamer::emitLabel(Symbol, Loc);
331   getAssembler().registerSymbol(*Symbol);
332   auto *DF = dyn_cast_or_null<MCDataFragment>(F);
333   Symbol->setOffset(Offset);
334   if (DF) {
335     Symbol->setFragment(F);
336   } else {
337     assert(isa<MCDummyFragment>(F) &&
338            "F must either be an MCDataFragment or the pending MCDummyFragment");
339     assert(Offset == 0);
340     addPendingLabel(Symbol);
341   }
342 }
343 
344 void MCObjectStreamer::emitULEB128Value(const MCExpr *Value) {
345   int64_t IntValue;
346   if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
347     emitULEB128IntValue(IntValue);
348     return;
349   }
350   insert(new MCLEBFragment(*Value, false));
351 }
352 
353 void MCObjectStreamer::emitSLEB128Value(const MCExpr *Value) {
354   int64_t IntValue;
355   if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
356     emitSLEB128IntValue(IntValue);
357     return;
358   }
359   insert(new MCLEBFragment(*Value, true));
360 }
361 
362 void MCObjectStreamer::emitWeakReference(MCSymbol *Alias,
363                                          const MCSymbol *Symbol) {
364   report_fatal_error("This file format doesn't support weak aliases.");
365 }
366 
367 void MCObjectStreamer::changeSection(MCSection *Section,
368                                      const MCExpr *Subsection) {
369   changeSectionImpl(Section, Subsection);
370 }
371 
372 bool MCObjectStreamer::changeSectionImpl(MCSection *Section,
373                                          const MCExpr *Subsection) {
374   assert(Section && "Cannot switch to a null section!");
375   getContext().clearDwarfLocSeen();
376 
377   bool Created = getAssembler().registerSection(*Section);
378 
379   int64_t IntSubsection = 0;
380   if (Subsection &&
381       !Subsection->evaluateAsAbsolute(IntSubsection, getAssemblerPtr())) {
382     getContext().reportError(Subsection->getLoc(),
383                              "cannot evaluate subsection number");
384   }
385   if (!isUInt<31>(IntSubsection)) {
386     getContext().reportError(Subsection->getLoc(),
387                              "subsection number " + Twine(IntSubsection) +
388                                  " is not within [0,2147483647]");
389   }
390 
391   CurSubsectionIdx = unsigned(IntSubsection);
392   CurInsertionPoint =
393       Section->getSubsectionInsertionPoint(CurSubsectionIdx);
394   return Created;
395 }
396 
397 void MCObjectStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
398   getAssembler().registerSymbol(*Symbol);
399   MCStreamer::emitAssignment(Symbol, Value);
400   emitPendingAssignments(Symbol);
401 }
402 
403 void MCObjectStreamer::emitConditionalAssignment(MCSymbol *Symbol,
404                                                  const MCExpr *Value) {
405   const MCSymbol *Target = &cast<MCSymbolRefExpr>(*Value).getSymbol();
406 
407   // If the symbol already exists, emit the assignment. Otherwise, emit it
408   // later only if the symbol is also emitted.
409   if (Target->isRegistered())
410     emitAssignment(Symbol, Value);
411   else
412     pendingAssignments[Target].push_back({Symbol, Value});
413 }
414 
415 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
416   return Sec.hasInstructions();
417 }
418 
419 void MCObjectStreamer::emitInstruction(const MCInst &Inst,
420                                        const MCSubtargetInfo &STI) {
421   const MCSection &Sec = *getCurrentSectionOnly();
422   if (Sec.isVirtualSection()) {
423     getContext().reportError(Inst.getLoc(), Twine(Sec.getVirtualSectionKind()) +
424                                                 " section '" + Sec.getName() +
425                                                 "' cannot have instructions");
426     return;
427   }
428   getAssembler().getBackend().emitInstructionBegin(*this, Inst, STI);
429   emitInstructionImpl(Inst, STI);
430   getAssembler().getBackend().emitInstructionEnd(*this, Inst);
431 }
432 
433 void MCObjectStreamer::emitInstructionImpl(const MCInst &Inst,
434                                            const MCSubtargetInfo &STI) {
435   MCStreamer::emitInstruction(Inst, STI);
436 
437   MCSection *Sec = getCurrentSectionOnly();
438   Sec->setHasInstructions(true);
439 
440   // Now that a machine instruction has been assembled into this section, make
441   // a line entry for any .loc directive that has been seen.
442   MCDwarfLineEntry::make(this, getCurrentSectionOnly());
443 
444   // If this instruction doesn't need relaxation, just emit it as data.
445   MCAssembler &Assembler = getAssembler();
446   MCAsmBackend &Backend = Assembler.getBackend();
447   if (!(Backend.mayNeedRelaxation(Inst, STI) ||
448         Backend.allowEnhancedRelaxation())) {
449     emitInstToData(Inst, STI);
450     return;
451   }
452 
453   // Otherwise, relax and emit it as data if either:
454   // - The RelaxAll flag was passed
455   // - Bundling is enabled and this instruction is inside a bundle-locked
456   //   group. We want to emit all such instructions into the same data
457   //   fragment.
458   if (Assembler.getRelaxAll() ||
459       (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
460     MCInst Relaxed = Inst;
461     while (Backend.mayNeedRelaxation(Relaxed, STI))
462       Backend.relaxInstruction(Relaxed, STI);
463     emitInstToData(Relaxed, STI);
464     return;
465   }
466 
467   // Otherwise emit to a separate fragment.
468   emitInstToFragment(Inst, STI);
469 }
470 
471 void MCObjectStreamer::emitInstToFragment(const MCInst &Inst,
472                                           const MCSubtargetInfo &STI) {
473   if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
474     llvm_unreachable("All instructions should have already been relaxed");
475 
476   // Always create a new, separate fragment here, because its size can change
477   // during relaxation.
478   MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
479   insert(IF);
480 
481   SmallString<128> Code;
482   getAssembler().getEmitter().encodeInstruction(Inst, Code, IF->getFixups(),
483                                                 STI);
484   IF->getContents().append(Code.begin(), Code.end());
485 }
486 
487 #ifndef NDEBUG
488 static const char *const BundlingNotImplementedMsg =
489   "Aligned bundling is not implemented for this object format";
490 #endif
491 
492 void MCObjectStreamer::emitBundleAlignMode(Align Alignment) {
493   llvm_unreachable(BundlingNotImplementedMsg);
494 }
495 
496 void MCObjectStreamer::emitBundleLock(bool AlignToEnd) {
497   llvm_unreachable(BundlingNotImplementedMsg);
498 }
499 
500 void MCObjectStreamer::emitBundleUnlock() {
501   llvm_unreachable(BundlingNotImplementedMsg);
502 }
503 
504 void MCObjectStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line,
505                                              unsigned Column, unsigned Flags,
506                                              unsigned Isa,
507                                              unsigned Discriminator,
508                                              StringRef FileName) {
509   // In case we see two .loc directives in a row, make sure the
510   // first one gets a line entry.
511   MCDwarfLineEntry::make(this, getCurrentSectionOnly());
512 
513   this->MCStreamer::emitDwarfLocDirective(FileNo, Line, Column, Flags, Isa,
514                                           Discriminator, FileName);
515 }
516 
517 static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
518                                      const MCSymbol *B, SMLoc Loc) {
519   MCContext &Context = OS.getContext();
520   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
521   const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
522   const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
523   const MCExpr *AddrDelta =
524       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context, Loc);
525   return AddrDelta;
526 }
527 
528 static void emitDwarfSetLineAddr(MCObjectStreamer &OS,
529                                  MCDwarfLineTableParams Params,
530                                  int64_t LineDelta, const MCSymbol *Label,
531                                  int PointerSize) {
532   // emit the sequence to set the address
533   OS.emitIntValue(dwarf::DW_LNS_extended_op, 1);
534   OS.emitULEB128IntValue(PointerSize + 1);
535   OS.emitIntValue(dwarf::DW_LNE_set_address, 1);
536   OS.emitSymbolValue(Label, PointerSize);
537 
538   // emit the sequence for the LineDelta (from 1) and a zero address delta.
539   MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
540 }
541 
542 void MCObjectStreamer::emitDwarfAdvanceLineAddr(int64_t LineDelta,
543                                                 const MCSymbol *LastLabel,
544                                                 const MCSymbol *Label,
545                                                 unsigned PointerSize) {
546   if (!LastLabel) {
547     emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
548                          Label, PointerSize);
549     return;
550   }
551   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, SMLoc());
552   insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
553 }
554 
555 void MCObjectStreamer::emitDwarfLineEndEntry(MCSection *Section,
556                                              MCSymbol *LastLabel) {
557   // Emit a DW_LNE_end_sequence for the end of the section.
558   // Use the section end label to compute the address delta and use INT64_MAX
559   // as the line delta which is the signal that this is actually a
560   // DW_LNE_end_sequence.
561   MCSymbol *SectionEnd = endSection(Section);
562 
563   // Switch back the dwarf line section, in case endSection had to switch the
564   // section.
565   MCContext &Ctx = getContext();
566   switchSection(Ctx.getObjectFileInfo()->getDwarfLineSection());
567 
568   const MCAsmInfo *AsmInfo = Ctx.getAsmInfo();
569   emitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd,
570                            AsmInfo->getCodePointerSize());
571 }
572 
573 void MCObjectStreamer::emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
574                                                  const MCSymbol *Label,
575                                                  SMLoc Loc) {
576   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel, Loc);
577   insert(new MCDwarfCallFrameFragment(*AddrDelta, nullptr));
578 }
579 
580 void MCObjectStreamer::emitCVLocDirective(unsigned FunctionId, unsigned FileNo,
581                                           unsigned Line, unsigned Column,
582                                           bool PrologueEnd, bool IsStmt,
583                                           StringRef FileName, SMLoc Loc) {
584   // Validate the directive.
585   if (!checkCVLocSection(FunctionId, FileNo, Loc))
586     return;
587 
588   // Emit a label at the current position and record it in the CodeViewContext.
589   MCSymbol *LineSym = getContext().createTempSymbol();
590   emitLabel(LineSym);
591   getContext().getCVContext().recordCVLoc(getContext(), LineSym, FunctionId,
592                                           FileNo, Line, Column, PrologueEnd,
593                                           IsStmt);
594 }
595 
596 void MCObjectStreamer::emitCVLinetableDirective(unsigned FunctionId,
597                                                 const MCSymbol *Begin,
598                                                 const MCSymbol *End) {
599   getContext().getCVContext().emitLineTableForFunction(*this, FunctionId, Begin,
600                                                        End);
601   this->MCStreamer::emitCVLinetableDirective(FunctionId, Begin, End);
602 }
603 
604 void MCObjectStreamer::emitCVInlineLinetableDirective(
605     unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
606     const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
607   getContext().getCVContext().emitInlineLineTableForFunction(
608       *this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
609       FnEndSym);
610   this->MCStreamer::emitCVInlineLinetableDirective(
611       PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
612 }
613 
614 void MCObjectStreamer::emitCVDefRangeDirective(
615     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
616     StringRef FixedSizePortion) {
617   MCFragment *Frag =
618       getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
619   // Attach labels that were pending before we created the defrange fragment to
620   // the beginning of the new fragment.
621   flushPendingLabels(Frag, 0);
622   this->MCStreamer::emitCVDefRangeDirective(Ranges, FixedSizePortion);
623 }
624 
625 void MCObjectStreamer::emitCVStringTableDirective() {
626   getContext().getCVContext().emitStringTable(*this);
627 }
628 void MCObjectStreamer::emitCVFileChecksumsDirective() {
629   getContext().getCVContext().emitFileChecksums(*this);
630 }
631 
632 void MCObjectStreamer::emitCVFileChecksumOffsetDirective(unsigned FileNo) {
633   getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
634 }
635 
636 void MCObjectStreamer::emitBytes(StringRef Data) {
637   MCDwarfLineEntry::make(this, getCurrentSectionOnly());
638   MCDataFragment *DF = getOrCreateDataFragment();
639   flushPendingLabels(DF, DF->getContents().size());
640   DF->getContents().append(Data.begin(), Data.end());
641 }
642 
643 void MCObjectStreamer::emitValueToAlignment(Align Alignment, int64_t Value,
644                                             unsigned ValueSize,
645                                             unsigned MaxBytesToEmit) {
646   if (MaxBytesToEmit == 0)
647     MaxBytesToEmit = Alignment.value();
648   insert(new MCAlignFragment(Alignment, Value, ValueSize, MaxBytesToEmit));
649 
650   // Update the maximum alignment on the current section if necessary.
651   MCSection *CurSec = getCurrentSectionOnly();
652   CurSec->ensureMinAlignment(Alignment);
653 }
654 
655 void MCObjectStreamer::emitCodeAlignment(Align Alignment,
656                                          const MCSubtargetInfo *STI,
657                                          unsigned MaxBytesToEmit) {
658   emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);
659   cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true, STI);
660 }
661 
662 void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
663                                          unsigned char Value,
664                                          SMLoc Loc) {
665   insert(new MCOrgFragment(*Offset, Value, Loc));
666 }
667 
668 // Associate DTPRel32 fixup with data and resize data area
669 void MCObjectStreamer::emitDTPRel32Value(const MCExpr *Value) {
670   MCDataFragment *DF = getOrCreateDataFragment();
671   flushPendingLabels(DF, DF->getContents().size());
672 
673   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
674                                             Value, FK_DTPRel_4));
675   DF->getContents().resize(DF->getContents().size() + 4, 0);
676 }
677 
678 // Associate DTPRel64 fixup with data and resize data area
679 void MCObjectStreamer::emitDTPRel64Value(const MCExpr *Value) {
680   MCDataFragment *DF = getOrCreateDataFragment();
681   flushPendingLabels(DF, DF->getContents().size());
682 
683   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
684                                             Value, FK_DTPRel_8));
685   DF->getContents().resize(DF->getContents().size() + 8, 0);
686 }
687 
688 // Associate TPRel32 fixup with data and resize data area
689 void MCObjectStreamer::emitTPRel32Value(const MCExpr *Value) {
690   MCDataFragment *DF = getOrCreateDataFragment();
691   flushPendingLabels(DF, DF->getContents().size());
692 
693   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
694                                             Value, FK_TPRel_4));
695   DF->getContents().resize(DF->getContents().size() + 4, 0);
696 }
697 
698 // Associate TPRel64 fixup with data and resize data area
699 void MCObjectStreamer::emitTPRel64Value(const MCExpr *Value) {
700   MCDataFragment *DF = getOrCreateDataFragment();
701   flushPendingLabels(DF, DF->getContents().size());
702 
703   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
704                                             Value, FK_TPRel_8));
705   DF->getContents().resize(DF->getContents().size() + 8, 0);
706 }
707 
708 // Associate GPRel32 fixup with data and resize data area
709 void MCObjectStreamer::emitGPRel32Value(const MCExpr *Value) {
710   MCDataFragment *DF = getOrCreateDataFragment();
711   flushPendingLabels(DF, DF->getContents().size());
712 
713   DF->getFixups().push_back(
714       MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
715   DF->getContents().resize(DF->getContents().size() + 4, 0);
716 }
717 
718 // Associate GPRel64 fixup with data and resize data area
719 void MCObjectStreamer::emitGPRel64Value(const MCExpr *Value) {
720   MCDataFragment *DF = getOrCreateDataFragment();
721   flushPendingLabels(DF, DF->getContents().size());
722 
723   DF->getFixups().push_back(
724       MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
725   DF->getContents().resize(DF->getContents().size() + 8, 0);
726 }
727 
728 static std::optional<std::pair<bool, std::string>>
729 getOffsetAndDataFragment(const MCSymbol &Symbol, uint32_t &RelocOffset,
730                          MCDataFragment *&DF) {
731   if (Symbol.isVariable()) {
732     const MCExpr *SymbolExpr = Symbol.getVariableValue();
733     MCValue OffsetVal;
734     if(!SymbolExpr->evaluateAsRelocatable(OffsetVal, nullptr, nullptr))
735       return std::make_pair(false,
736                             std::string("symbol in .reloc offset is not "
737                                         "relocatable"));
738     if (OffsetVal.isAbsolute()) {
739       RelocOffset = OffsetVal.getConstant();
740       MCFragment *Fragment = Symbol.getFragment();
741       // FIXME Support symbols with no DF. For example:
742       // .reloc .data, ENUM_VALUE, <some expr>
743       if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
744         return std::make_pair(false,
745                               std::string("symbol in offset has no data "
746                                           "fragment"));
747       DF = cast<MCDataFragment>(Fragment);
748       return std::nullopt;
749     }
750 
751     if (OffsetVal.getSymB())
752       return std::make_pair(false,
753                             std::string(".reloc symbol offset is not "
754                                         "representable"));
755 
756     const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
757     if (!SRE.getSymbol().isDefined())
758       return std::make_pair(false,
759                             std::string("symbol used in the .reloc offset is "
760                                         "not defined"));
761 
762     if (SRE.getSymbol().isVariable())
763       return std::make_pair(false,
764                             std::string("symbol used in the .reloc offset is "
765                                         "variable"));
766 
767     MCFragment *Fragment = SRE.getSymbol().getFragment();
768     // FIXME Support symbols with no DF. For example:
769     // .reloc .data, ENUM_VALUE, <some expr>
770     if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
771       return std::make_pair(false,
772                             std::string("symbol in offset has no data "
773                                         "fragment"));
774     RelocOffset = SRE.getSymbol().getOffset() + OffsetVal.getConstant();
775     DF = cast<MCDataFragment>(Fragment);
776   } else {
777     RelocOffset = Symbol.getOffset();
778     MCFragment *Fragment = Symbol.getFragment();
779     // FIXME Support symbols with no DF. For example:
780     // .reloc .data, ENUM_VALUE, <some expr>
781     if (!Fragment || Fragment->getKind() != MCFragment::FT_Data)
782       return std::make_pair(false,
783                             std::string("symbol in offset has no data "
784                                         "fragment"));
785     DF = cast<MCDataFragment>(Fragment);
786   }
787   return std::nullopt;
788 }
789 
790 std::optional<std::pair<bool, std::string>>
791 MCObjectStreamer::emitRelocDirective(const MCExpr &Offset, StringRef Name,
792                                      const MCExpr *Expr, SMLoc Loc,
793                                      const MCSubtargetInfo &STI) {
794   std::optional<MCFixupKind> MaybeKind =
795       Assembler->getBackend().getFixupKind(Name);
796   if (!MaybeKind)
797     return std::make_pair(true, std::string("unknown relocation name"));
798 
799   MCFixupKind Kind = *MaybeKind;
800 
801   if (Expr == nullptr)
802     Expr =
803         MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
804 
805   MCDataFragment *DF = getOrCreateDataFragment(&STI);
806   flushPendingLabels(DF, DF->getContents().size());
807 
808   MCValue OffsetVal;
809   if (!Offset.evaluateAsRelocatable(OffsetVal, nullptr, nullptr))
810     return std::make_pair(false,
811                           std::string(".reloc offset is not relocatable"));
812   if (OffsetVal.isAbsolute()) {
813     if (OffsetVal.getConstant() < 0)
814       return std::make_pair(false, std::string(".reloc offset is negative"));
815     DF->getFixups().push_back(
816         MCFixup::create(OffsetVal.getConstant(), Expr, Kind, Loc));
817     return std::nullopt;
818   }
819   if (OffsetVal.getSymB())
820     return std::make_pair(false,
821                           std::string(".reloc offset is not representable"));
822 
823   const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*OffsetVal.getSymA());
824   const MCSymbol &Symbol = SRE.getSymbol();
825   if (Symbol.isDefined()) {
826     uint32_t SymbolOffset = 0;
827     std::optional<std::pair<bool, std::string>> Error =
828         getOffsetAndDataFragment(Symbol, SymbolOffset, DF);
829 
830     if (Error != std::nullopt)
831       return Error;
832 
833     DF->getFixups().push_back(
834         MCFixup::create(SymbolOffset + OffsetVal.getConstant(),
835                         Expr, Kind, Loc));
836     return std::nullopt;
837   }
838 
839   PendingFixups.emplace_back(
840       &SRE.getSymbol(), DF,
841       MCFixup::create(OffsetVal.getConstant(), Expr, Kind, Loc));
842   return std::nullopt;
843 }
844 
845 void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
846                                 SMLoc Loc) {
847   MCDataFragment *DF = getOrCreateDataFragment();
848   flushPendingLabels(DF, DF->getContents().size());
849 
850   assert(getCurrentSectionOnly() && "need a section");
851   insert(new MCFillFragment(FillValue, 1, NumBytes, Loc));
852 }
853 
854 void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
855                                 int64_t Expr, SMLoc Loc) {
856   int64_t IntNumValues;
857   // Do additional checking now if we can resolve the value.
858   if (NumValues.evaluateAsAbsolute(IntNumValues, getAssemblerPtr())) {
859     if (IntNumValues < 0) {
860       getContext().getSourceManager()->PrintMessage(
861           Loc, SourceMgr::DK_Warning,
862           "'.fill' directive with negative repeat count has no effect");
863       return;
864     }
865     // Emit now if we can for better errors.
866     int64_t NonZeroSize = Size > 4 ? 4 : Size;
867     Expr &= ~0ULL >> (64 - NonZeroSize * 8);
868     for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
869       emitIntValue(Expr, NonZeroSize);
870       if (NonZeroSize < Size)
871         emitIntValue(0, Size - NonZeroSize);
872     }
873     return;
874   }
875 
876   // Otherwise emit as fragment.
877   MCDataFragment *DF = getOrCreateDataFragment();
878   flushPendingLabels(DF, DF->getContents().size());
879 
880   assert(getCurrentSectionOnly() && "need a section");
881   insert(new MCFillFragment(Expr, Size, NumValues, Loc));
882 }
883 
884 void MCObjectStreamer::emitNops(int64_t NumBytes, int64_t ControlledNopLength,
885                                 SMLoc Loc, const MCSubtargetInfo &STI) {
886   // Emit an NOP fragment.
887   MCDataFragment *DF = getOrCreateDataFragment();
888   flushPendingLabels(DF, DF->getContents().size());
889 
890   assert(getCurrentSectionOnly() && "need a section");
891 
892   insert(new MCNopsFragment(NumBytes, ControlledNopLength, Loc, STI));
893 }
894 
895 void MCObjectStreamer::emitFileDirective(StringRef Filename) {
896   getAssembler().addFileName(Filename);
897 }
898 
899 void MCObjectStreamer::emitFileDirective(StringRef Filename,
900                                          StringRef CompilerVerion,
901                                          StringRef TimeStamp,
902                                          StringRef Description) {
903   getAssembler().addFileName(Filename);
904   // TODO: add additional info to integrated assembler.
905 }
906 
907 void MCObjectStreamer::emitAddrsig() {
908   getAssembler().getWriter().emitAddrsigSection();
909 }
910 
911 void MCObjectStreamer::emitAddrsigSym(const MCSymbol *Sym) {
912   getAssembler().getWriter().addAddrsigSymbol(Sym);
913 }
914 
915 void MCObjectStreamer::finishImpl() {
916   getContext().RemapDebugPaths();
917 
918   // If we are generating dwarf for assembly source files dump out the sections.
919   if (getContext().getGenDwarfForAssembly())
920     MCGenDwarfInfo::Emit(this);
921 
922   // Dump out the dwarf file & directory tables and line tables.
923   MCDwarfLineTable::emit(this, getAssembler().getDWARFLinetableParams());
924 
925   // Emit pseudo probes for the current module.
926   MCPseudoProbeTable::emit(this);
927 
928   // Update any remaining pending labels with empty data fragments.
929   flushPendingLabels();
930 
931   resolvePendingFixups();
932   getAssembler().Finish();
933 }
934