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