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