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