contrib/llvm/lib/MC/MCObjectStreamer.cpp

   1 //===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/MC/MCObjectStreamer.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/MC/MCAsmBackend.h"
  13 #include "llvm/MC/MCAssembler.h"
  14 #include "llvm/MC/MCCodeEmitter.h"
  15 #include "llvm/MC/MCCodeView.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCDwarf.h"
  18 #include "llvm/MC/MCExpr.h"
  19 #include "llvm/MC/MCObjectWriter.h"
  20 #include "llvm/MC/MCSection.h"
  21 #include "llvm/MC/MCSymbol.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/SourceMgr.h"
  24 using namespace llvm;
  25
  26 MCObjectStreamer::MCObjectStreamer(MCContext &Context,
  27                                    std::unique_ptr<MCAsmBackend> TAB,
  28                                    std::unique_ptr<MCObjectWriter> OW,
  29                                    std::unique_ptr<MCCodeEmitter> Emitter)
  30     : MCStreamer(Context),
  31       Assembler(llvm::make_unique<MCAssembler>(
  32           Context, std::move(TAB), std::move(Emitter), std::move(OW))),
  33       EmitEHFrame(true), EmitDebugFrame(false) {}
  34
  35 MCObjectStreamer::~MCObjectStreamer() {}
  36
  37 // AssemblerPtr is used for evaluation of expressions and causes
  38 // difference between asm and object outputs. Return nullptr to in
  39 // inline asm mode to limit divergence to assembly inputs.
  40 MCAssembler *MCObjectStreamer::getAssemblerPtr() {
  41   if (getUseAssemblerInfoForParsing())
  42     return Assembler.get();
  43   return nullptr;
  44 }
  45
  46 void MCObjectStreamer::flushPendingLabels(MCFragment *F, uint64_t FOffset) {
  47   if (PendingLabels.empty())
  48     return;
  49   if (!F) {
  50     F = new MCDataFragment();
  51     MCSection *CurSection = getCurrentSectionOnly();
  52     CurSection->getFragmentList().insert(CurInsertionPoint, F);
  53     F->setParent(CurSection);
  54   }
  55   for (MCSymbol *Sym : PendingLabels) {
  56     Sym->setFragment(F);
  57     Sym->setOffset(FOffset);
  58   }
  59   PendingLabels.clear();
  60 }
  61
  62 // When fixup's offset is a forward declared label, e.g.:
  63 //
  64 //   .reloc 1f, R_MIPS_JALR, foo
  65 // 1: nop
  66 //
  67 // postpone adding it to Fixups vector until the label is defined and its offset
  68 // is known.
  69 void MCObjectStreamer::resolvePendingFixups() {
  70   for (PendingMCFixup &PendingFixup : PendingFixups) {
  71     if (!PendingFixup.Sym || PendingFixup.Sym->isUndefined ()) {
  72       getContext().reportError(PendingFixup.Fixup.getLoc(),
  73                                "unresolved relocation offset");
  74       continue;
  75     }
  76     flushPendingLabels(PendingFixup.DF, PendingFixup.DF->getContents().size());
  77     PendingFixup.Fixup.setOffset(PendingFixup.Sym->getOffset());
  78     PendingFixup.DF->getFixups().push_back(PendingFixup.Fixup);
  79   }
  80   PendingFixups.clear();
  81 }
  82
  83 // As a compile-time optimization, avoid allocating and evaluating an MCExpr
  84 // tree for (Hi - Lo) when Hi and Lo are offsets into the same fragment.
  85 static Optional<uint64_t>
  86 absoluteSymbolDiff(MCAssembler &Asm, const MCSymbol *Hi, const MCSymbol *Lo) {
  87   assert(Hi && Lo);
  88   if (Asm.getBackendPtr()->requiresDiffExpressionRelocations())
  89     return None;
  90
  91   if (!Hi->getFragment() || Hi->getFragment() != Lo->getFragment() ||
  92       Hi->isVariable() || Lo->isVariable())
  93     return None;
  94
  95   return Hi->getOffset() - Lo->getOffset();
  96 }
  97
  98 void MCObjectStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi,
  99                                               const MCSymbol *Lo,
 100                                               unsigned Size) {
 101   if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
 102     EmitIntValue(*Diff, Size);
 103     return;
 104   }
 105   MCStreamer::emitAbsoluteSymbolDiff(Hi, Lo, Size);
 106 }
 107
 108 void MCObjectStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
 109                                                        const MCSymbol *Lo) {
 110   if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
 111     EmitULEB128IntValue(*Diff);
 112     return;
 113   }
 114   MCStreamer::emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
 115 }
 116
 117 void MCObjectStreamer::reset() {
 118   if (Assembler)
 119     Assembler->reset();
 120   CurInsertionPoint = MCSection::iterator();
 121   EmitEHFrame = true;
 122   EmitDebugFrame = false;
 123   PendingLabels.clear();
 124   MCStreamer::reset();
 125 }
 126
 127 void MCObjectStreamer::EmitFrames(MCAsmBackend *MAB) {
 128   if (!getNumFrameInfos())
 129     return;
 130
 131   if (EmitEHFrame)
 132     MCDwarfFrameEmitter::Emit(*this, MAB, true);
 133
 134   if (EmitDebugFrame)
 135     MCDwarfFrameEmitter::Emit(*this, MAB, false);
 136 }
 137
 138 MCFragment *MCObjectStreamer::getCurrentFragment() const {
 139   assert(getCurrentSectionOnly() && "No current section!");
 140
 141   if (CurInsertionPoint != getCurrentSectionOnly()->getFragmentList().begin())
 142     return &*std::prev(CurInsertionPoint);
 143
 144   return nullptr;
 145 }
 146
 147 static bool CanReuseDataFragment(const MCDataFragment &F,
 148                                  const MCAssembler &Assembler,
 149                                  const MCSubtargetInfo *STI) {
 150   if (!F.hasInstructions())
 151     return true;
 152   // When bundling is enabled, we don't want to add data to a fragment that
 153   // already has instructions (see MCELFStreamer::EmitInstToData for details)
 154   if (Assembler.isBundlingEnabled())
 155     return Assembler.getRelaxAll();
 156   // If the subtarget is changed mid fragment we start a new fragment to record
 157   // the new STI.
 158   return !STI || F.getSubtargetInfo() == STI;
 159 }
 160
 161 MCDataFragment *
 162 MCObjectStreamer::getOrCreateDataFragment(const MCSubtargetInfo *STI) {
 163   MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
 164   if (!F || !CanReuseDataFragment(*F, *Assembler, STI)) {
 165     F = new MCDataFragment();
 166     insert(F);
 167   }
 168   return F;
 169 }
 170
 171 MCPaddingFragment *MCObjectStreamer::getOrCreatePaddingFragment() {
 172   MCPaddingFragment *F =
 173       dyn_cast_or_null<MCPaddingFragment>(getCurrentFragment());
 174   if (!F) {
 175     F = new MCPaddingFragment();
 176     insert(F);
 177   }
 178   return F;
 179 }
 180
 181 void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
 182   Assembler->registerSymbol(Sym);
 183 }
 184
 185 void MCObjectStreamer::EmitCFISections(bool EH, bool Debug) {
 186   MCStreamer::EmitCFISections(EH, Debug);
 187   EmitEHFrame = EH;
 188   EmitDebugFrame = Debug;
 189 }
 190
 191 void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
 192                                      SMLoc Loc) {
 193   MCStreamer::EmitValueImpl(Value, Size, Loc);
 194   MCDataFragment *DF = getOrCreateDataFragment();
 195   flushPendingLabels(DF, DF->getContents().size());
 196
 197   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
 198
 199   // Avoid fixups when possible.
 200   int64_t AbsValue;
 201   if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
 202     if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
 203       getContext().reportError(
 204           Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
 205       return;
 206     }
 207     EmitIntValue(AbsValue, Size);
 208     return;
 209   }
 210   DF->getFixups().push_back(
 211       MCFixup::create(DF->getContents().size(), Value,
 212                       MCFixup::getKindForSize(Size, false), Loc));
 213   DF->getContents().resize(DF->getContents().size() + Size, 0);
 214 }
 215
 216 MCSymbol *MCObjectStreamer::EmitCFILabel() {
 217   MCSymbol *Label = getContext().createTempSymbol("cfi", true);
 218   EmitLabel(Label);
 219   return Label;
 220 }
 221
 222 void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
 223   // We need to create a local symbol to avoid relocations.
 224   Frame.Begin = getContext().createTempSymbol();
 225   EmitLabel(Frame.Begin);
 226 }
 227
 228 void MCObjectStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
 229   Frame.End = getContext().createTempSymbol();
 230   EmitLabel(Frame.End);
 231 }
 232
 233 void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
 234   MCStreamer::EmitLabel(Symbol, Loc);
 235
 236   getAssembler().registerSymbol(*Symbol);
 237
 238   // If there is a current fragment, mark the symbol as pointing into it.
 239   // Otherwise queue the label and set its fragment pointer when we emit the
 240   // next fragment.
 241   auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
 242   if (F && !(getAssembler().isBundlingEnabled() &&
 243              getAssembler().getRelaxAll())) {
 244     Symbol->setFragment(F);
 245     Symbol->setOffset(F->getContents().size());
 246   } else {
 247     PendingLabels.push_back(Symbol);
 248   }
 249 }
 250
 251 void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) {
 252   MCStreamer::EmitLabel(Symbol, Loc);
 253   getAssembler().registerSymbol(*Symbol);
 254   auto *DF = dyn_cast_or_null<MCDataFragment>(F);
 255   if (DF)
 256     Symbol->setFragment(F);
 257   else
 258     PendingLabels.push_back(Symbol);
 259 }
 260
 261 void MCObjectStreamer::EmitULEB128Value(const MCExpr *Value) {
 262   int64_t IntValue;
 263   if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
 264     EmitULEB128IntValue(IntValue);
 265     return;
 266   }
 267   insert(new MCLEBFragment(*Value, false));
 268 }
 269
 270 void MCObjectStreamer::EmitSLEB128Value(const MCExpr *Value) {
 271   int64_t IntValue;
 272   if (Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
 273     EmitSLEB128IntValue(IntValue);
 274     return;
 275   }
 276   insert(new MCLEBFragment(*Value, true));
 277 }
 278
 279 void MCObjectStreamer::EmitWeakReference(MCSymbol *Alias,
 280                                          const MCSymbol *Symbol) {
 281   report_fatal_error("This file format doesn't support weak aliases.");
 282 }
 283
 284 void MCObjectStreamer::ChangeSection(MCSection *Section,
 285                                      const MCExpr *Subsection) {
 286   changeSectionImpl(Section, Subsection);
 287 }
 288
 289 bool MCObjectStreamer::changeSectionImpl(MCSection *Section,
 290                                          const MCExpr *Subsection) {
 291   assert(Section && "Cannot switch to a null section!");
 292   flushPendingLabels(nullptr);
 293   getContext().clearDwarfLocSeen();
 294
 295   bool Created = getAssembler().registerSection(*Section);
 296
 297   int64_t IntSubsection = 0;
 298   if (Subsection &&
 299       !Subsection->evaluateAsAbsolute(IntSubsection, getAssemblerPtr()))
 300     report_fatal_error("Cannot evaluate subsection number");
 301   if (IntSubsection < 0 || IntSubsection > 8192)
 302     report_fatal_error("Subsection number out of range");
 303   CurInsertionPoint =
 304       Section->getSubsectionInsertionPoint(unsigned(IntSubsection));
 305   return Created;
 306 }
 307
 308 void MCObjectStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
 309   getAssembler().registerSymbol(*Symbol);
 310   MCStreamer::EmitAssignment(Symbol, Value);
 311 }
 312
 313 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
 314   return Sec.hasInstructions();
 315 }
 316
 317 void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
 318                                        const MCSubtargetInfo &STI, bool) {
 319   getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
 320   EmitInstructionImpl(Inst, STI);
 321   getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
 322 }
 323
 324 void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
 325                                            const MCSubtargetInfo &STI) {
 326   MCStreamer::EmitInstruction(Inst, STI);
 327
 328   MCSection *Sec = getCurrentSectionOnly();
 329   Sec->setHasInstructions(true);
 330
 331   // Now that a machine instruction has been assembled into this section, make
 332   // a line entry for any .loc directive that has been seen.
 333   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
 334
 335   // If this instruction doesn't need relaxation, just emit it as data.
 336   MCAssembler &Assembler = getAssembler();
 337   if (!Assembler.getBackend().mayNeedRelaxation(Inst, STI)) {
 338     EmitInstToData(Inst, STI);
 339     return;
 340   }
 341
 342   // Otherwise, relax and emit it as data if either:
 343   // - The RelaxAll flag was passed
 344   // - Bundling is enabled and this instruction is inside a bundle-locked
 345   //   group. We want to emit all such instructions into the same data
 346   //   fragment.
 347   if (Assembler.getRelaxAll() ||
 348       (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
 349     MCInst Relaxed;
 350     getAssembler().getBackend().relaxInstruction(Inst, STI, Relaxed);
 351     while (getAssembler().getBackend().mayNeedRelaxation(Relaxed, STI))
 352       getAssembler().getBackend().relaxInstruction(Relaxed, STI, Relaxed);
 353     EmitInstToData(Relaxed, STI);
 354     return;
 355   }
 356
 357   // Otherwise emit to a separate fragment.
 358   EmitInstToFragment(Inst, STI);
 359 }
 360
 361 void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
 362                                           const MCSubtargetInfo &STI) {
 363   if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
 364     llvm_unreachable("All instructions should have already been relaxed");
 365
 366   // Always create a new, separate fragment here, because its size can change
 367   // during relaxation.
 368   MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
 369   insert(IF);
 370
 371   SmallString<128> Code;
 372   raw_svector_ostream VecOS(Code);
 373   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
 374                                                 STI);
 375   IF->getContents().append(Code.begin(), Code.end());
 376 }
 377
 378 #ifndef NDEBUG
 379 static const char *const BundlingNotImplementedMsg =
 380   "Aligned bundling is not implemented for this object format";
 381 #endif
 382
 383 void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
 384   llvm_unreachable(BundlingNotImplementedMsg);
 385 }
 386
 387 void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
 388   llvm_unreachable(BundlingNotImplementedMsg);
 389 }
 390
 391 void MCObjectStreamer::EmitBundleUnlock() {
 392   llvm_unreachable(BundlingNotImplementedMsg);
 393 }
 394
 395 void MCObjectStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
 396                                              unsigned Column, unsigned Flags,
 397                                              unsigned Isa,
 398                                              unsigned Discriminator,
 399                                              StringRef FileName) {
 400   // In case we see two .loc directives in a row, make sure the
 401   // first one gets a line entry.
 402   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
 403
 404   this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
 405                                           Isa, Discriminator, FileName);
 406 }
 407
 408 static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
 409                                      const MCSymbol *B) {
 410   MCContext &Context = OS.getContext();
 411   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
 412   const MCExpr *ARef = MCSymbolRefExpr::create(A, Variant, Context);
 413   const MCExpr *BRef = MCSymbolRefExpr::create(B, Variant, Context);
 414   const MCExpr *AddrDelta =
 415       MCBinaryExpr::create(MCBinaryExpr::Sub, ARef, BRef, Context);
 416   return AddrDelta;
 417 }
 418
 419 static void emitDwarfSetLineAddr(MCObjectStreamer &OS,
 420                                  MCDwarfLineTableParams Params,
 421                                  int64_t LineDelta, const MCSymbol *Label,
 422                                  int PointerSize) {
 423   // emit the sequence to set the address
 424   OS.EmitIntValue(dwarf::DW_LNS_extended_op, 1);
 425   OS.EmitULEB128IntValue(PointerSize + 1);
 426   OS.EmitIntValue(dwarf::DW_LNE_set_address, 1);
 427   OS.EmitSymbolValue(Label, PointerSize);
 428
 429   // emit the sequence for the LineDelta (from 1) and a zero address delta.
 430   MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0);
 431 }
 432
 433 void MCObjectStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
 434                                                 const MCSymbol *LastLabel,
 435                                                 const MCSymbol *Label,
 436                                                 unsigned PointerSize) {
 437   if (!LastLabel) {
 438     emitDwarfSetLineAddr(*this, Assembler->getDWARFLinetableParams(), LineDelta,
 439                          Label, PointerSize);
 440     return;
 441   }
 442   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
 443   int64_t Res;
 444   if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
 445     MCDwarfLineAddr::Emit(this, Assembler->getDWARFLinetableParams(), LineDelta,
 446                           Res);
 447     return;
 448   }
 449   insert(new MCDwarfLineAddrFragment(LineDelta, *AddrDelta));
 450 }
 451
 452 void MCObjectStreamer::EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
 453                                                  const MCSymbol *Label) {
 454   const MCExpr *AddrDelta = buildSymbolDiff(*this, Label, LastLabel);
 455   int64_t Res;
 456   if (AddrDelta->evaluateAsAbsolute(Res, getAssemblerPtr())) {
 457     MCDwarfFrameEmitter::EmitAdvanceLoc(*this, Res);
 458     return;
 459   }
 460   insert(new MCDwarfCallFrameFragment(*AddrDelta));
 461 }
 462
 463 void MCObjectStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
 464                                           unsigned Line, unsigned Column,
 465                                           bool PrologueEnd, bool IsStmt,
 466                                           StringRef FileName, SMLoc Loc) {
 467   // Validate the directive.
 468   if (!checkCVLocSection(FunctionId, FileNo, Loc))
 469     return;
 470
 471   // Emit a label at the current position and record it in the CodeViewContext.
 472   MCSymbol *LineSym = getContext().createTempSymbol();
 473   EmitLabel(LineSym);
 474   getContext().getCVContext().recordCVLoc(getContext(), LineSym, FunctionId,
 475                                           FileNo, Line, Column, PrologueEnd,
 476                                           IsStmt);
 477 }
 478
 479 void MCObjectStreamer::EmitCVLinetableDirective(unsigned FunctionId,
 480                                                 const MCSymbol *Begin,
 481                                                 const MCSymbol *End) {
 482   getContext().getCVContext().emitLineTableForFunction(*this, FunctionId, Begin,
 483                                                        End);
 484   this->MCStreamer::EmitCVLinetableDirective(FunctionId, Begin, End);
 485 }
 486
 487 void MCObjectStreamer::EmitCVInlineLinetableDirective(
 488     unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
 489     const MCSymbol *FnStartSym, const MCSymbol *FnEndSym) {
 490   getContext().getCVContext().emitInlineLineTableForFunction(
 491       *this, PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym,
 492       FnEndSym);
 493   this->MCStreamer::EmitCVInlineLinetableDirective(
 494       PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
 495 }
 496
 497 void MCObjectStreamer::EmitCVDefRangeDirective(
 498     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
 499     StringRef FixedSizePortion) {
 500   MCFragment *Frag =
 501       getContext().getCVContext().emitDefRange(*this, Ranges, FixedSizePortion);
 502   // Attach labels that were pending before we created the defrange fragment to
 503   // the beginning of the new fragment.
 504   flushPendingLabels(Frag, 0);
 505   this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
 506 }
 507
 508 void MCObjectStreamer::EmitCVStringTableDirective() {
 509   getContext().getCVContext().emitStringTable(*this);
 510 }
 511 void MCObjectStreamer::EmitCVFileChecksumsDirective() {
 512   getContext().getCVContext().emitFileChecksums(*this);
 513 }
 514
 515 void MCObjectStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
 516   getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
 517 }
 518
 519 void MCObjectStreamer::EmitBytes(StringRef Data) {
 520   MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
 521   MCDataFragment *DF = getOrCreateDataFragment();
 522   flushPendingLabels(DF, DF->getContents().size());
 523   DF->getContents().append(Data.begin(), Data.end());
 524
 525   // EmitBytes might not cover all possible ways we emit data (or could be used
 526   // to emit executable code in some cases), but is the best method we have
 527   // right now for checking this.
 528   MCSection *Sec = getCurrentSectionOnly();
 529   Sec->setHasData(true);
 530 }
 531
 532 void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment,
 533                                             int64_t Value,
 534                                             unsigned ValueSize,
 535                                             unsigned MaxBytesToEmit) {
 536   if (MaxBytesToEmit == 0)
 537     MaxBytesToEmit = ByteAlignment;
 538   insert(new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit));
 539
 540   // Update the maximum alignment on the current section if necessary.
 541   MCSection *CurSec = getCurrentSectionOnly();
 542   if (ByteAlignment > CurSec->getAlignment())
 543     CurSec->setAlignment(ByteAlignment);
 544 }
 545
 546 void MCObjectStreamer::EmitCodeAlignment(unsigned ByteAlignment,
 547                                          unsigned MaxBytesToEmit) {
 548   EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
 549   cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true);
 550 }
 551
 552 void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset,
 553                                          unsigned char Value,
 554                                          SMLoc Loc) {
 555   insert(new MCOrgFragment(*Offset, Value, Loc));
 556 }
 557
 558 void MCObjectStreamer::EmitCodePaddingBasicBlockStart(
 559     const MCCodePaddingContext &Context) {
 560   getAssembler().getBackend().handleCodePaddingBasicBlockStart(this, Context);
 561 }
 562
 563 void MCObjectStreamer::EmitCodePaddingBasicBlockEnd(
 564     const MCCodePaddingContext &Context) {
 565   getAssembler().getBackend().handleCodePaddingBasicBlockEnd(Context);
 566 }
 567
 568 // Associate DTPRel32 fixup with data and resize data area
 569 void MCObjectStreamer::EmitDTPRel32Value(const MCExpr *Value) {
 570   MCDataFragment *DF = getOrCreateDataFragment();
 571   flushPendingLabels(DF, DF->getContents().size());
 572
 573   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
 574                                             Value, FK_DTPRel_4));
 575   DF->getContents().resize(DF->getContents().size() + 4, 0);
 576 }
 577
 578 // Associate DTPRel64 fixup with data and resize data area
 579 void MCObjectStreamer::EmitDTPRel64Value(const MCExpr *Value) {
 580   MCDataFragment *DF = getOrCreateDataFragment();
 581   flushPendingLabels(DF, DF->getContents().size());
 582
 583   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
 584                                             Value, FK_DTPRel_8));
 585   DF->getContents().resize(DF->getContents().size() + 8, 0);
 586 }
 587
 588 // Associate TPRel32 fixup with data and resize data area
 589 void MCObjectStreamer::EmitTPRel32Value(const MCExpr *Value) {
 590   MCDataFragment *DF = getOrCreateDataFragment();
 591   flushPendingLabels(DF, DF->getContents().size());
 592
 593   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
 594                                             Value, FK_TPRel_4));
 595   DF->getContents().resize(DF->getContents().size() + 4, 0);
 596 }
 597
 598 // Associate TPRel64 fixup with data and resize data area
 599 void MCObjectStreamer::EmitTPRel64Value(const MCExpr *Value) {
 600   MCDataFragment *DF = getOrCreateDataFragment();
 601   flushPendingLabels(DF, DF->getContents().size());
 602
 603   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
 604                                             Value, FK_TPRel_8));
 605   DF->getContents().resize(DF->getContents().size() + 8, 0);
 606 }
 607
 608 // Associate GPRel32 fixup with data and resize data area
 609 void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) {
 610   MCDataFragment *DF = getOrCreateDataFragment();
 611   flushPendingLabels(DF, DF->getContents().size());
 612
 613   DF->getFixups().push_back(
 614       MCFixup::create(DF->getContents().size(), Value, FK_GPRel_4));
 615   DF->getContents().resize(DF->getContents().size() + 4, 0);
 616 }
 617
 618 // Associate GPRel64 fixup with data and resize data area
 619 void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) {
 620   MCDataFragment *DF = getOrCreateDataFragment();
 621   flushPendingLabels(DF, DF->getContents().size());
 622
 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 bool MCObjectStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
 629                                           const MCExpr *Expr, SMLoc Loc,
 630                                           const MCSubtargetInfo &STI) {
 631   Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
 632   if (!MaybeKind.hasValue())
 633     return true;
 634
 635   MCFixupKind Kind = *MaybeKind;
 636
 637   if (Expr == nullptr)
 638     Expr =
 639         MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
 640
 641   MCDataFragment *DF = getOrCreateDataFragment(&STI);
 642   flushPendingLabels(DF, DF->getContents().size());
 643
 644   int64_t OffsetValue;
 645   if (Offset.evaluateAsAbsolute(OffsetValue)) {
 646     if (OffsetValue < 0)
 647       llvm_unreachable(".reloc offset is negative");
 648     DF->getFixups().push_back(MCFixup::create(OffsetValue, Expr, Kind, Loc));
 649     return false;
 650   }
 651
 652   if (Offset.getKind() != llvm::MCExpr::SymbolRef)
 653     llvm_unreachable(".reloc offset is not absolute nor a label");
 654
 655   const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(Offset);
 656   if (SRE.getSymbol().isDefined()) {
 657     DF->getFixups().push_back(MCFixup::create(SRE.getSymbol().getOffset(),
 658                                               Expr, Kind, Loc));
 659     return false;
 660   }
 661
 662   PendingFixups.emplace_back(&SRE.getSymbol(), DF,
 663                                          MCFixup::create(-1, Expr, Kind, Loc));
 664   return false;
 665 }
 666
 667 void MCObjectStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
 668                                 SMLoc Loc) {
 669   MCDataFragment *DF = getOrCreateDataFragment();
 670   flushPendingLabels(DF, DF->getContents().size());
 671
 672   assert(getCurrentSectionOnly() && "need a section");
 673   insert(new MCFillFragment(FillValue, 1, NumBytes, Loc));
 674 }
 675
 676 void MCObjectStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
 677                                 int64_t Expr, SMLoc Loc) {
 678   int64_t IntNumValues;
 679   // Do additional checking now if we can resolve the value.
 680   if (NumValues.evaluateAsAbsolute(IntNumValues, getAssemblerPtr())) {
 681     if (IntNumValues < 0) {
 682       getContext().getSourceManager()->PrintMessage(
 683           Loc, SourceMgr::DK_Warning,
 684           "'.fill' directive with negative repeat count has no effect");
 685       return;
 686     }
 687     // Emit now if we can for better errors.
 688     int64_t NonZeroSize = Size > 4 ? 4 : Size;
 689     Expr &= ~0ULL >> (64 - NonZeroSize * 8);
 690     for (uint64_t i = 0, e = IntNumValues; i != e; ++i) {
 691       EmitIntValue(Expr, NonZeroSize);
 692       if (NonZeroSize < Size)
 693         EmitIntValue(0, Size - NonZeroSize);
 694     }
 695     return;
 696   }
 697
 698   // Otherwise emit as fragment.
 699   MCDataFragment *DF = getOrCreateDataFragment();
 700   flushPendingLabels(DF, DF->getContents().size());
 701
 702   assert(getCurrentSectionOnly() && "need a section");
 703   insert(new MCFillFragment(Expr, Size, NumValues, Loc));
 704 }
 705
 706 void MCObjectStreamer::EmitFileDirective(StringRef Filename) {
 707   getAssembler().addFileName(Filename);
 708 }
 709
 710 void MCObjectStreamer::EmitAddrsig() {
 711   getAssembler().getWriter().emitAddrsigSection();
 712 }
 713
 714 void MCObjectStreamer::EmitAddrsigSym(const MCSymbol *Sym) {
 715   getAssembler().registerSymbol(*Sym);
 716   getAssembler().getWriter().addAddrsigSymbol(Sym);
 717 }
 718
 719 void MCObjectStreamer::FinishImpl() {
 720   getContext().RemapDebugPaths();
 721
 722   // If we are generating dwarf for assembly source files dump out the sections.
 723   if (getContext().getGenDwarfForAssembly())
 724     MCGenDwarfInfo::Emit(this);
 725
 726   // Dump out the dwarf file & directory tables and line tables.
 727   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 728
 729   flushPendingLabels();
 730   resolvePendingFixups();
 731   getAssembler().Finish();
 732 }