1 //===- MCStreamer.h - High-level Streaming Machine Code Output --*- C++ -*-===// 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 // This file declares the MCStreamer class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_MC_MCSTREAMER_H 14 #define LLVM_MC_MCSTREAMER_H 15 16 #include "llvm/ADT/ArrayRef.h" 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/Optional.h" 19 #include "llvm/ADT/SmallVector.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/MC/MCDirectives.h" 22 #include "llvm/MC/MCDwarf.h" 23 #include "llvm/MC/MCLinkerOptimizationHint.h" 24 #include "llvm/MC/MCPseudoProbe.h" 25 #include "llvm/MC/MCWinEH.h" 26 #include "llvm/Support/ARMTargetParser.h" 27 #include "llvm/Support/Error.h" 28 #include "llvm/Support/MD5.h" 29 #include "llvm/Support/SMLoc.h" 30 #include "llvm/Support/VersionTuple.h" 31 #include <cassert> 32 #include <cstdint> 33 #include <memory> 34 #include <string> 35 #include <utility> 36 #include <vector> 37 38 namespace llvm { 39 40 class APInt; 41 class AssemblerConstantPools; 42 class MCAsmBackend; 43 class MCAssembler; 44 class MCContext; 45 class MCExpr; 46 class MCFragment; 47 class MCInst; 48 class MCInstPrinter; 49 class MCRegister; 50 class MCSection; 51 class MCStreamer; 52 class MCSubtargetInfo; 53 class MCSymbol; 54 class MCSymbolRefExpr; 55 class Triple; 56 class Twine; 57 class raw_ostream; 58 59 namespace codeview { 60 struct DefRangeRegisterRelHeader; 61 struct DefRangeSubfieldRegisterHeader; 62 struct DefRangeRegisterHeader; 63 struct DefRangeFramePointerRelHeader; 64 } 65 66 using MCSectionSubPair = std::pair<MCSection *, const MCExpr *>; 67 68 /// Target specific streamer interface. This is used so that targets can 69 /// implement support for target specific assembly directives. 70 /// 71 /// If target foo wants to use this, it should implement 3 classes: 72 /// * FooTargetStreamer : public MCTargetStreamer 73 /// * FooTargetAsmStreamer : public FooTargetStreamer 74 /// * FooTargetELFStreamer : public FooTargetStreamer 75 /// 76 /// FooTargetStreamer should have a pure virtual method for each directive. For 77 /// example, for a ".bar symbol_name" directive, it should have 78 /// virtual emitBar(const MCSymbol &Symbol) = 0; 79 /// 80 /// The FooTargetAsmStreamer and FooTargetELFStreamer classes implement the 81 /// method. The assembly streamer just prints ".bar symbol_name". The object 82 /// streamer does whatever is needed to implement .bar in the object file. 83 /// 84 /// In the assembly printer and parser the target streamer can be used by 85 /// calling getTargetStreamer and casting it to FooTargetStreamer: 86 /// 87 /// MCTargetStreamer &TS = OutStreamer.getTargetStreamer(); 88 /// FooTargetStreamer &ATS = static_cast<FooTargetStreamer &>(TS); 89 /// 90 /// The base classes FooTargetAsmStreamer and FooTargetELFStreamer should 91 /// *never* be treated differently. Callers should always talk to a 92 /// FooTargetStreamer. 93 class MCTargetStreamer { 94 protected: 95 MCStreamer &Streamer; 96 97 public: 98 MCTargetStreamer(MCStreamer &S); 99 virtual ~MCTargetStreamer(); 100 101 MCStreamer &getStreamer() { return Streamer; } 102 103 // Allow a target to add behavior to the EmitLabel of MCStreamer. 104 virtual void emitLabel(MCSymbol *Symbol); 105 // Allow a target to add behavior to the emitAssignment of MCStreamer. 106 virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value); 107 108 virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address, 109 const MCInst &Inst, const MCSubtargetInfo &STI, 110 raw_ostream &OS); 111 112 virtual void emitDwarfFileDirective(StringRef Directive); 113 114 /// Update streamer for a new active section. 115 /// 116 /// This is called by popSection and switchSection, if the current 117 /// section changes. 118 virtual void changeSection(const MCSection *CurSection, MCSection *Section, 119 const MCExpr *SubSection, raw_ostream &OS); 120 121 virtual void emitValue(const MCExpr *Value); 122 123 /// Emit the bytes in \p Data into the output. 124 /// 125 /// This is used to emit bytes in \p Data as sequence of .byte directives. 126 virtual void emitRawBytes(StringRef Data); 127 128 virtual void emitConstantPools(); 129 130 virtual void finish(); 131 }; 132 133 // FIXME: declared here because it is used from 134 // lib/CodeGen/AsmPrinter/ARMException.cpp. 135 class ARMTargetStreamer : public MCTargetStreamer { 136 public: 137 ARMTargetStreamer(MCStreamer &S); 138 ~ARMTargetStreamer() override; 139 140 virtual void emitFnStart(); 141 virtual void emitFnEnd(); 142 virtual void emitCantUnwind(); 143 virtual void emitPersonality(const MCSymbol *Personality); 144 virtual void emitPersonalityIndex(unsigned Index); 145 virtual void emitHandlerData(); 146 virtual void emitSetFP(unsigned FpReg, unsigned SpReg, 147 int64_t Offset = 0); 148 virtual void emitMovSP(unsigned Reg, int64_t Offset = 0); 149 virtual void emitPad(int64_t Offset); 150 virtual void emitRegSave(const SmallVectorImpl<unsigned> &RegList, 151 bool isVector); 152 virtual void emitUnwindRaw(int64_t StackOffset, 153 const SmallVectorImpl<uint8_t> &Opcodes); 154 155 virtual void switchVendor(StringRef Vendor); 156 virtual void emitAttribute(unsigned Attribute, unsigned Value); 157 virtual void emitTextAttribute(unsigned Attribute, StringRef String); 158 virtual void emitIntTextAttribute(unsigned Attribute, unsigned IntValue, 159 StringRef StringValue = ""); 160 virtual void emitFPU(unsigned FPU); 161 virtual void emitArch(ARM::ArchKind Arch); 162 virtual void emitArchExtension(uint64_t ArchExt); 163 virtual void emitObjectArch(ARM::ArchKind Arch); 164 void emitTargetAttributes(const MCSubtargetInfo &STI); 165 virtual void finishAttributeSection(); 166 virtual void emitInst(uint32_t Inst, char Suffix = '\0'); 167 168 virtual void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE); 169 170 virtual void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value); 171 172 void emitConstantPools() override; 173 174 virtual void emitARMWinCFIAllocStack(unsigned Size, bool Wide); 175 virtual void emitARMWinCFISaveRegMask(unsigned Mask, bool Wide); 176 virtual void emitARMWinCFISaveSP(unsigned Reg); 177 virtual void emitARMWinCFISaveFRegs(unsigned First, unsigned Last); 178 virtual void emitARMWinCFISaveLR(unsigned Offset); 179 virtual void emitARMWinCFIPrologEnd(bool Fragment); 180 virtual void emitARMWinCFINop(bool Wide); 181 virtual void emitARMWinCFIEpilogStart(unsigned Condition); 182 virtual void emitARMWinCFIEpilogEnd(); 183 virtual void emitARMWinCFICustom(unsigned Opcode); 184 185 /// Reset any state between object emissions, i.e. the equivalent of 186 /// MCStreamer's reset method. 187 virtual void reset(); 188 189 /// Callback used to implement the ldr= pseudo. 190 /// Add a new entry to the constant pool for the current section and return an 191 /// MCExpr that can be used to refer to the constant pool location. 192 const MCExpr *addConstantPoolEntry(const MCExpr *, SMLoc Loc); 193 194 /// Callback used to implement the .ltorg directive. 195 /// Emit contents of constant pool for the current section. 196 void emitCurrentConstantPool(); 197 198 private: 199 std::unique_ptr<AssemblerConstantPools> ConstantPools; 200 }; 201 202 /// Streaming machine code generation interface. 203 /// 204 /// This interface is intended to provide a programmatic interface that is very 205 /// similar to the level that an assembler .s file provides. It has callbacks 206 /// to emit bytes, handle directives, etc. The implementation of this interface 207 /// retains state to know what the current section is etc. 208 /// 209 /// There are multiple implementations of this interface: one for writing out 210 /// a .s file, and implementations that write out .o files of various formats. 211 /// 212 class MCStreamer { 213 MCContext &Context; 214 std::unique_ptr<MCTargetStreamer> TargetStreamer; 215 216 std::vector<MCDwarfFrameInfo> DwarfFrameInfos; 217 MCDwarfFrameInfo *getCurrentDwarfFrameInfo(); 218 219 /// Similar to DwarfFrameInfos, but for SEH unwind info. Chained frames may 220 /// refer to each other, so use std::unique_ptr to provide pointer stability. 221 std::vector<std::unique_ptr<WinEH::FrameInfo>> WinFrameInfos; 222 223 WinEH::FrameInfo *CurrentWinFrameInfo; 224 size_t CurrentProcWinFrameInfoStartIndex; 225 226 /// Tracks an index to represent the order a symbol was emitted in. 227 /// Zero means we did not emit that symbol. 228 DenseMap<const MCSymbol *, unsigned> SymbolOrdering; 229 230 /// This is stack of current and previous section values saved by 231 /// pushSection. 232 SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack; 233 234 /// Pointer to the parser's SMLoc if available. This is used to provide 235 /// locations for diagnostics. 236 const SMLoc *StartTokLocPtr = nullptr; 237 238 /// The next unique ID to use when creating a WinCFI-related section (.pdata 239 /// or .xdata). This ID ensures that we have a one-to-one mapping from 240 /// code section to unwind info section, which MSVC's incremental linker 241 /// requires. 242 unsigned NextWinCFIID = 0; 243 244 bool UseAssemblerInfoForParsing; 245 246 /// Is the assembler allowed to insert padding automatically? For 247 /// correctness reasons, we sometimes need to ensure instructions aren't 248 /// separated in unexpected ways. At the moment, this feature is only 249 /// useable from an integrated assembler, but assembly syntax is under 250 /// discussion for future inclusion. 251 bool AllowAutoPadding = false; 252 253 protected: 254 MCStreamer(MCContext &Ctx); 255 256 virtual void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame); 257 virtual void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame); 258 259 WinEH::FrameInfo *getCurrentWinFrameInfo() { 260 return CurrentWinFrameInfo; 261 } 262 263 virtual void emitWindowsUnwindTables(WinEH::FrameInfo *Frame); 264 265 virtual void emitWindowsUnwindTables(); 266 267 virtual void emitRawTextImpl(StringRef String); 268 269 /// Returns true if the the .cv_loc directive is in the right section. 270 bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc); 271 272 public: 273 MCStreamer(const MCStreamer &) = delete; 274 MCStreamer &operator=(const MCStreamer &) = delete; 275 virtual ~MCStreamer(); 276 277 void visitUsedExpr(const MCExpr &Expr); 278 virtual void visitUsedSymbol(const MCSymbol &Sym); 279 280 void setTargetStreamer(MCTargetStreamer *TS) { 281 TargetStreamer.reset(TS); 282 } 283 284 void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; } 285 SMLoc getStartTokLoc() const { 286 return StartTokLocPtr ? *StartTokLocPtr : SMLoc(); 287 } 288 289 /// State management 290 /// 291 virtual void reset(); 292 293 MCContext &getContext() const { return Context; } 294 295 virtual MCAssembler *getAssemblerPtr() { return nullptr; } 296 297 void setUseAssemblerInfoForParsing(bool v) { UseAssemblerInfoForParsing = v; } 298 bool getUseAssemblerInfoForParsing() { return UseAssemblerInfoForParsing; } 299 300 MCTargetStreamer *getTargetStreamer() { 301 return TargetStreamer.get(); 302 } 303 304 void setAllowAutoPadding(bool v) { AllowAutoPadding = v; } 305 bool getAllowAutoPadding() const { return AllowAutoPadding; } 306 307 /// When emitting an object file, create and emit a real label. When emitting 308 /// textual assembly, this should do nothing to avoid polluting our output. 309 virtual MCSymbol *emitCFILabel(); 310 311 /// Retrieve the current frame info if one is available and it is not yet 312 /// closed. Otherwise, issue an error and return null. 313 WinEH::FrameInfo *EnsureValidWinFrameInfo(SMLoc Loc); 314 315 unsigned getNumFrameInfos(); 316 ArrayRef<MCDwarfFrameInfo> getDwarfFrameInfos() const; 317 318 bool hasUnfinishedDwarfFrameInfo(); 319 320 unsigned getNumWinFrameInfos() { return WinFrameInfos.size(); } 321 ArrayRef<std::unique_ptr<WinEH::FrameInfo>> getWinFrameInfos() const { 322 return WinFrameInfos; 323 } 324 325 void generateCompactUnwindEncodings(MCAsmBackend *MAB); 326 327 /// \name Assembly File Formatting. 328 /// @{ 329 330 /// Return true if this streamer supports verbose assembly and if it is 331 /// enabled. 332 virtual bool isVerboseAsm() const { return false; } 333 334 /// Return true if this asm streamer supports emitting unformatted text 335 /// to the .s file with EmitRawText. 336 virtual bool hasRawTextSupport() const { return false; } 337 338 /// Is the integrated assembler required for this streamer to function 339 /// correctly? 340 virtual bool isIntegratedAssemblerRequired() const { return false; } 341 342 /// Add a textual comment. 343 /// 344 /// Typically for comments that can be emitted to the generated .s 345 /// file if applicable as a QoI issue to make the output of the compiler 346 /// more readable. This only affects the MCAsmStreamer, and only when 347 /// verbose assembly output is enabled. 348 /// 349 /// If the comment includes embedded \n's, they will each get the comment 350 /// prefix as appropriate. The added comment should not end with a \n. 351 /// By default, each comment is terminated with an end of line, i.e. the 352 /// EOL param is set to true by default. If one prefers not to end the 353 /// comment with a new line then the EOL param should be passed 354 /// with a false value. 355 virtual void AddComment(const Twine &T, bool EOL = true) {} 356 357 /// Return a raw_ostream that comments can be written to. Unlike 358 /// AddComment, you are required to terminate comments with \n if you use this 359 /// method. 360 virtual raw_ostream &getCommentOS(); 361 362 /// Print T and prefix it with the comment string (normally #) and 363 /// optionally a tab. This prints the comment immediately, not at the end of 364 /// the current line. It is basically a safe version of EmitRawText: since it 365 /// only prints comments, the object streamer ignores it instead of asserting. 366 virtual void emitRawComment(const Twine &T, bool TabPrefix = true); 367 368 /// Add explicit comment T. T is required to be a valid 369 /// comment in the output and does not need to be escaped. 370 virtual void addExplicitComment(const Twine &T); 371 372 /// Emit added explicit comments. 373 virtual void emitExplicitComments(); 374 375 /// Emit a blank line to a .s file to pretty it up. 376 virtual void addBlankLine() {} 377 378 /// @} 379 380 /// \name Symbol & Section Management 381 /// @{ 382 383 /// Return the current section that the streamer is emitting code to. 384 MCSectionSubPair getCurrentSection() const { 385 if (!SectionStack.empty()) 386 return SectionStack.back().first; 387 return MCSectionSubPair(); 388 } 389 MCSection *getCurrentSectionOnly() const { return getCurrentSection().first; } 390 391 /// Return the previous section that the streamer is emitting code to. 392 MCSectionSubPair getPreviousSection() const { 393 if (!SectionStack.empty()) 394 return SectionStack.back().second; 395 return MCSectionSubPair(); 396 } 397 398 /// Returns an index to represent the order a symbol was emitted in. 399 /// (zero if we did not emit that symbol) 400 unsigned getSymbolOrder(const MCSymbol *Sym) const { 401 return SymbolOrdering.lookup(Sym); 402 } 403 404 /// Update streamer for a new active section. 405 /// 406 /// This is called by popSection and switchSection, if the current 407 /// section changes. 408 virtual void changeSection(MCSection *, const MCExpr *); 409 410 /// Save the current and previous section on the section stack. 411 void pushSection() { 412 SectionStack.push_back( 413 std::make_pair(getCurrentSection(), getPreviousSection())); 414 } 415 416 /// Restore the current and previous section from the section stack. 417 /// Calls changeSection as needed. 418 /// 419 /// Returns false if the stack was empty. 420 bool popSection() { 421 if (SectionStack.size() <= 1) 422 return false; 423 auto I = SectionStack.end(); 424 --I; 425 MCSectionSubPair OldSection = I->first; 426 --I; 427 MCSectionSubPair NewSection = I->first; 428 429 if (NewSection.first && OldSection != NewSection) 430 changeSection(NewSection.first, NewSection.second); 431 SectionStack.pop_back(); 432 return true; 433 } 434 435 bool subSection(const MCExpr *Subsection) { 436 if (SectionStack.empty()) 437 return false; 438 439 switchSection(SectionStack.back().first.first, Subsection); 440 return true; 441 } 442 443 /// Set the current section where code is being emitted to \p Section. This 444 /// is required to update CurSection. 445 /// 446 /// This corresponds to assembler directives like .section, .text, etc. 447 virtual void switchSection(MCSection *Section, 448 const MCExpr *Subsection = nullptr); 449 450 /// Set the current section where code is being emitted to \p Section. 451 /// This is required to update CurSection. This version does not call 452 /// changeSection. 453 void switchSectionNoChange(MCSection *Section, 454 const MCExpr *Subsection = nullptr) { 455 assert(Section && "Cannot switch to a null section!"); 456 MCSectionSubPair curSection = SectionStack.back().first; 457 SectionStack.back().second = curSection; 458 if (MCSectionSubPair(Section, Subsection) != curSection) 459 SectionStack.back().first = MCSectionSubPair(Section, Subsection); 460 } 461 462 /// Create the default sections and set the initial one. 463 virtual void initSections(bool NoExecStack, const MCSubtargetInfo &STI); 464 465 MCSymbol *endSection(MCSection *Section); 466 467 /// Sets the symbol's section. 468 /// 469 /// Each emitted symbol will be tracked in the ordering table, 470 /// so we can sort on them later. 471 void assignFragment(MCSymbol *Symbol, MCFragment *Fragment); 472 473 /// Returns the mnemonic for \p MI, if the streamer has access to a 474 /// instruction printer and returns an empty string otherwise. 475 virtual StringRef getMnemonic(MCInst &MI) { return ""; } 476 477 /// Emit a label for \p Symbol into the current section. 478 /// 479 /// This corresponds to an assembler statement such as: 480 /// foo: 481 /// 482 /// \param Symbol - The symbol to emit. A given symbol should only be 483 /// emitted as a label once, and symbols emitted as a label should never be 484 /// used in an assignment. 485 // FIXME: These emission are non-const because we mutate the symbol to 486 // add the section we're emitting it to later. 487 virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()); 488 489 virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol); 490 491 /// Note in the output the specified \p Flag. 492 virtual void emitAssemblerFlag(MCAssemblerFlag Flag); 493 494 /// Emit the given list \p Options of strings as linker 495 /// options into the output. 496 virtual void emitLinkerOptions(ArrayRef<std::string> Kind) {} 497 498 /// Note in the output the specified region \p Kind. 499 virtual void emitDataRegion(MCDataRegionType Kind) {} 500 501 /// Specify the Mach-O minimum deployment target version. 502 virtual void emitVersionMin(MCVersionMinType Type, unsigned Major, 503 unsigned Minor, unsigned Update, 504 VersionTuple SDKVersion) {} 505 506 /// Emit/Specify Mach-O build version command. 507 /// \p Platform should be one of MachO::PlatformType. 508 virtual void emitBuildVersion(unsigned Platform, unsigned Major, 509 unsigned Minor, unsigned Update, 510 VersionTuple SDKVersion) {} 511 512 virtual void emitDarwinTargetVariantBuildVersion(unsigned Platform, 513 unsigned Major, 514 unsigned Minor, 515 unsigned Update, 516 VersionTuple SDKVersion) {} 517 518 void emitVersionForTarget(const Triple &Target, 519 const VersionTuple &SDKVersion, 520 const Triple *DarwinTargetVariantTriple, 521 const VersionTuple &DarwinTargetVariantSDKVersion); 522 523 /// Note in the output that the specified \p Func is a Thumb mode 524 /// function (ARM target only). 525 virtual void emitThumbFunc(MCSymbol *Func); 526 527 /// Emit an assignment of \p Value to \p Symbol. 528 /// 529 /// This corresponds to an assembler statement such as: 530 /// symbol = value 531 /// 532 /// The assignment generates no code, but has the side effect of binding the 533 /// value in the current context. For the assembly streamer, this prints the 534 /// binding into the .s file. 535 /// 536 /// \param Symbol - The symbol being assigned to. 537 /// \param Value - The value for the symbol. 538 virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value); 539 540 /// Emit an assignment of \p Value to \p Symbol, but only if \p Value is also 541 /// emitted. 542 virtual void emitConditionalAssignment(MCSymbol *Symbol, const MCExpr *Value); 543 544 /// Emit an weak reference from \p Alias to \p Symbol. 545 /// 546 /// This corresponds to an assembler statement such as: 547 /// .weakref alias, symbol 548 /// 549 /// \param Alias - The alias that is being created. 550 /// \param Symbol - The symbol being aliased. 551 virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol); 552 553 /// Add the given \p Attribute to \p Symbol. 554 virtual bool emitSymbolAttribute(MCSymbol *Symbol, 555 MCSymbolAttr Attribute) = 0; 556 557 /// Set the \p DescValue for the \p Symbol. 558 /// 559 /// \param Symbol - The symbol to have its n_desc field set. 560 /// \param DescValue - The value to set into the n_desc field. 561 virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue); 562 563 /// Start emitting COFF symbol definition 564 /// 565 /// \param Symbol - The symbol to have its External & Type fields set. 566 virtual void beginCOFFSymbolDef(const MCSymbol *Symbol); 567 568 /// Emit the storage class of the symbol. 569 /// 570 /// \param StorageClass - The storage class the symbol should have. 571 virtual void emitCOFFSymbolStorageClass(int StorageClass); 572 573 /// Emit the type of the symbol. 574 /// 575 /// \param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h) 576 virtual void emitCOFFSymbolType(int Type); 577 578 /// Marks the end of the symbol definition. 579 virtual void endCOFFSymbolDef(); 580 581 virtual void emitCOFFSafeSEH(MCSymbol const *Symbol); 582 583 /// Emits the symbol table index of a Symbol into the current section. 584 virtual void emitCOFFSymbolIndex(MCSymbol const *Symbol); 585 586 /// Emits a COFF section index. 587 /// 588 /// \param Symbol - Symbol the section number relocation should point to. 589 virtual void emitCOFFSectionIndex(MCSymbol const *Symbol); 590 591 /// Emits a COFF section relative relocation. 592 /// 593 /// \param Symbol - Symbol the section relative relocation should point to. 594 virtual void emitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset); 595 596 /// Emits a COFF image relative relocation. 597 /// 598 /// \param Symbol - Symbol the image relative relocation should point to. 599 virtual void emitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset); 600 601 /// Emits an lcomm directive with XCOFF csect information. 602 /// 603 /// \param LabelSym - Label on the block of storage. 604 /// \param Size - The size of the block of storage. 605 /// \param CsectSym - Csect name for the block of storage. 606 /// \param ByteAlignment - The alignment of the symbol in bytes. Must be a 607 /// power of 2. 608 virtual void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size, 609 MCSymbol *CsectSym, 610 unsigned ByteAlignment); 611 612 /// Emit a symbol's linkage and visibility with a linkage directive for XCOFF. 613 /// 614 /// \param Symbol - The symbol to emit. 615 /// \param Linkage - The linkage of the symbol to emit. 616 /// \param Visibility - The visibility of the symbol to emit or MCSA_Invalid 617 /// if the symbol does not have an explicit visibility. 618 virtual void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol, 619 MCSymbolAttr Linkage, 620 MCSymbolAttr Visibility); 621 622 /// Emit a XCOFF .rename directive which creates a synonym for an illegal or 623 /// undesirable name. 624 /// 625 /// \param Name - The name used internally in the assembly for references to 626 /// the symbol. 627 /// \param Rename - The value to which the Name parameter is 628 /// changed at the end of assembly. 629 virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename); 630 631 /// Emit a XCOFF .ref directive which creates R_REF type entry in the 632 /// relocation table for one or more symbols. 633 /// 634 /// \param Sym - The symbol on the .ref directive. 635 virtual void emitXCOFFRefDirective(StringRef Sym); 636 637 /// Emit an ELF .size directive. 638 /// 639 /// This corresponds to an assembler statement such as: 640 /// .size symbol, expression 641 virtual void emitELFSize(MCSymbol *Symbol, const MCExpr *Value); 642 643 /// Emit an ELF .symver directive. 644 /// 645 /// This corresponds to an assembler statement such as: 646 /// .symver _start, foo@@SOME_VERSION 647 virtual void emitELFSymverDirective(const MCSymbol *OriginalSym, 648 StringRef Name, bool KeepOriginalSym); 649 650 /// Emit a Linker Optimization Hint (LOH) directive. 651 /// \param Args - Arguments of the LOH. 652 virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {} 653 654 /// Emit a .gnu_attribute directive. 655 virtual void emitGNUAttribute(unsigned Tag, unsigned Value) {} 656 657 /// Emit a common symbol. 658 /// 659 /// \param Symbol - The common symbol to emit. 660 /// \param Size - The size of the common symbol. 661 /// \param ByteAlignment - The alignment of the symbol if 662 /// non-zero. This must be a power of 2. 663 virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 664 unsigned ByteAlignment) = 0; 665 666 /// Emit a local common (.lcomm) symbol. 667 /// 668 /// \param Symbol - The common symbol to emit. 669 /// \param Size - The size of the common symbol. 670 /// \param ByteAlignment - The alignment of the common symbol in bytes. 671 virtual void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 672 unsigned ByteAlignment); 673 674 /// Emit the zerofill section and an optional symbol. 675 /// 676 /// \param Section - The zerofill section to create and or to put the symbol 677 /// \param Symbol - The zerofill symbol to emit, if non-NULL. 678 /// \param Size - The size of the zerofill symbol. 679 /// \param ByteAlignment - The alignment of the zerofill symbol if 680 /// non-zero. This must be a power of 2 on some targets. 681 virtual void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr, 682 uint64_t Size = 0, unsigned ByteAlignment = 0, 683 SMLoc Loc = SMLoc()) = 0; 684 685 /// Emit a thread local bss (.tbss) symbol. 686 /// 687 /// \param Section - The thread local common section. 688 /// \param Symbol - The thread local common symbol to emit. 689 /// \param Size - The size of the symbol. 690 /// \param ByteAlignment - The alignment of the thread local common symbol 691 /// if non-zero. This must be a power of 2 on some targets. 692 virtual void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, 693 uint64_t Size, unsigned ByteAlignment = 0); 694 695 /// @} 696 /// \name Generating Data 697 /// @{ 698 699 /// Emit the bytes in \p Data into the output. 700 /// 701 /// This is used to implement assembler directives such as .byte, .ascii, 702 /// etc. 703 virtual void emitBytes(StringRef Data); 704 705 /// Functionally identical to EmitBytes. When emitting textual assembly, this 706 /// method uses .byte directives instead of .ascii or .asciz for readability. 707 virtual void emitBinaryData(StringRef Data); 708 709 /// Emit the expression \p Value into the output as a native 710 /// integer of the given \p Size bytes. 711 /// 712 /// This is used to implement assembler directives such as .word, .quad, 713 /// etc. 714 /// 715 /// \param Value - The value to emit. 716 /// \param Size - The size of the integer (in bytes) to emit. This must 717 /// match a native machine width. 718 /// \param Loc - The location of the expression for error reporting. 719 virtual void emitValueImpl(const MCExpr *Value, unsigned Size, 720 SMLoc Loc = SMLoc()); 721 722 void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()); 723 724 /// Special case of EmitValue that avoids the client having 725 /// to pass in a MCExpr for constant integers. 726 virtual void emitIntValue(uint64_t Value, unsigned Size); 727 virtual void emitIntValue(APInt Value); 728 729 /// Special case of EmitValue that avoids the client having to pass 730 /// in a MCExpr for constant integers & prints in Hex format for certain 731 /// modes. 732 virtual void emitIntValueInHex(uint64_t Value, unsigned Size) { 733 emitIntValue(Value, Size); 734 } 735 736 void emitInt8(uint64_t Value) { emitIntValue(Value, 1); } 737 void emitInt16(uint64_t Value) { emitIntValue(Value, 2); } 738 void emitInt32(uint64_t Value) { emitIntValue(Value, 4); } 739 void emitInt64(uint64_t Value) { emitIntValue(Value, 8); } 740 741 /// Special case of EmitValue that avoids the client having to pass 742 /// in a MCExpr for constant integers & prints in Hex format for certain 743 /// modes, pads the field with leading zeros to Size width 744 virtual void emitIntValueInHexWithPadding(uint64_t Value, unsigned Size) { 745 emitIntValue(Value, Size); 746 } 747 748 virtual void emitULEB128Value(const MCExpr *Value); 749 750 virtual void emitSLEB128Value(const MCExpr *Value); 751 752 /// Special case of EmitULEB128Value that avoids the client having to 753 /// pass in a MCExpr for constant integers. 754 void emitULEB128IntValue(uint64_t Value, unsigned PadTo = 0); 755 756 /// Special case of EmitSLEB128Value that avoids the client having to 757 /// pass in a MCExpr for constant integers. 758 void emitSLEB128IntValue(int64_t Value); 759 760 /// Special case of EmitValue that avoids the client having to pass in 761 /// a MCExpr for MCSymbols. 762 void emitSymbolValue(const MCSymbol *Sym, unsigned Size, 763 bool IsSectionRelative = false); 764 765 /// Emit the expression \p Value into the output as a dtprel 766 /// (64-bit DTP relative) value. 767 /// 768 /// This is used to implement assembler directives such as .dtpreldword on 769 /// targets that support them. 770 virtual void emitDTPRel64Value(const MCExpr *Value); 771 772 /// Emit the expression \p Value into the output as a dtprel 773 /// (32-bit DTP relative) value. 774 /// 775 /// This is used to implement assembler directives such as .dtprelword on 776 /// targets that support them. 777 virtual void emitDTPRel32Value(const MCExpr *Value); 778 779 /// Emit the expression \p Value into the output as a tprel 780 /// (64-bit TP relative) value. 781 /// 782 /// This is used to implement assembler directives such as .tpreldword on 783 /// targets that support them. 784 virtual void emitTPRel64Value(const MCExpr *Value); 785 786 /// Emit the expression \p Value into the output as a tprel 787 /// (32-bit TP relative) value. 788 /// 789 /// This is used to implement assembler directives such as .tprelword on 790 /// targets that support them. 791 virtual void emitTPRel32Value(const MCExpr *Value); 792 793 /// Emit the expression \p Value into the output as a gprel64 (64-bit 794 /// GP relative) value. 795 /// 796 /// This is used to implement assembler directives such as .gpdword on 797 /// targets that support them. 798 virtual void emitGPRel64Value(const MCExpr *Value); 799 800 /// Emit the expression \p Value into the output as a gprel32 (32-bit 801 /// GP relative) value. 802 /// 803 /// This is used to implement assembler directives such as .gprel32 on 804 /// targets that support them. 805 virtual void emitGPRel32Value(const MCExpr *Value); 806 807 /// Emit NumBytes bytes worth of the value specified by FillValue. 808 /// This implements directives such as '.space'. 809 void emitFill(uint64_t NumBytes, uint8_t FillValue); 810 811 /// Emit \p Size bytes worth of the value specified by \p FillValue. 812 /// 813 /// This is used to implement assembler directives such as .space or .skip. 814 /// 815 /// \param NumBytes - The number of bytes to emit. 816 /// \param FillValue - The value to use when filling bytes. 817 /// \param Loc - The location of the expression for error reporting. 818 virtual void emitFill(const MCExpr &NumBytes, uint64_t FillValue, 819 SMLoc Loc = SMLoc()); 820 821 /// Emit \p NumValues copies of \p Size bytes. Each \p Size bytes is 822 /// taken from the lowest order 4 bytes of \p Expr expression. 823 /// 824 /// This is used to implement assembler directives such as .fill. 825 /// 826 /// \param NumValues - The number of copies of \p Size bytes to emit. 827 /// \param Size - The size (in bytes) of each repeated value. 828 /// \param Expr - The expression from which \p Size bytes are used. 829 virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr, 830 SMLoc Loc = SMLoc()); 831 832 virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength, 833 SMLoc Loc, const MCSubtargetInfo& STI); 834 835 /// Emit NumBytes worth of zeros. 836 /// This function properly handles data in virtual sections. 837 void emitZeros(uint64_t NumBytes); 838 839 /// Emit some number of copies of \p Value until the byte alignment \p 840 /// ByteAlignment is reached. 841 /// 842 /// If the number of bytes need to emit for the alignment is not a multiple 843 /// of \p ValueSize, then the contents of the emitted fill bytes is 844 /// undefined. 845 /// 846 /// This used to implement the .align assembler directive. 847 /// 848 /// \param ByteAlignment - The alignment to reach. This must be a power of 849 /// two on some targets. 850 /// \param Value - The value to use when filling bytes. 851 /// \param ValueSize - The size of the integer (in bytes) to emit for 852 /// \p Value. This must match a native machine width. 853 /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If 854 /// the alignment cannot be reached in this many bytes, no bytes are 855 /// emitted. 856 virtual void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, 857 unsigned ValueSize = 1, 858 unsigned MaxBytesToEmit = 0); 859 860 /// Emit nops until the byte alignment \p ByteAlignment is reached. 861 /// 862 /// This used to align code where the alignment bytes may be executed. This 863 /// can emit different bytes for different sizes to optimize execution. 864 /// 865 /// \param ByteAlignment - The alignment to reach. This must be a power of 866 /// two on some targets. 867 /// \param STI - The MCSubtargetInfo in operation when padding is emitted. 868 /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If 869 /// the alignment cannot be reached in this many bytes, no bytes are 870 /// emitted. 871 virtual void emitCodeAlignment(unsigned ByteAlignment, 872 const MCSubtargetInfo *STI, 873 unsigned MaxBytesToEmit = 0); 874 875 /// Emit some number of copies of \p Value until the byte offset \p 876 /// Offset is reached. 877 /// 878 /// This is used to implement assembler directives such as .org. 879 /// 880 /// \param Offset - The offset to reach. This may be an expression, but the 881 /// expression must be associated with the current section. 882 /// \param Value - The value to use when filling bytes. 883 virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value, 884 SMLoc Loc); 885 886 /// @} 887 888 /// Switch to a new logical file. This is used to implement the '.file 889 /// "foo.c"' assembler directive. 890 virtual void emitFileDirective(StringRef Filename); 891 892 /// Emit ".file assembler diretive with additioal info. 893 virtual void emitFileDirective(StringRef Filename, StringRef CompilerVerion, 894 StringRef TimeStamp, StringRef Description); 895 896 /// Emit the "identifiers" directive. This implements the 897 /// '.ident "version foo"' assembler directive. 898 virtual void emitIdent(StringRef IdentString) {} 899 900 /// Associate a filename with a specified logical file number. This 901 /// implements the DWARF2 '.file 4 "foo.c"' assembler directive. 902 unsigned emitDwarfFileDirective(unsigned FileNo, StringRef Directory, 903 StringRef Filename, 904 Optional<MD5::MD5Result> Checksum = None, 905 Optional<StringRef> Source = None, 906 unsigned CUID = 0) { 907 return cantFail( 908 tryEmitDwarfFileDirective(FileNo, Directory, Filename, Checksum, 909 Source, CUID)); 910 } 911 912 /// Associate a filename with a specified logical file number. 913 /// Also associate a directory, optional checksum, and optional source 914 /// text with the logical file. This implements the DWARF2 915 /// '.file 4 "dir/foo.c"' assembler directive, and the DWARF5 916 /// '.file 4 "dir/foo.c" md5 "..." source "..."' assembler directive. 917 virtual Expected<unsigned> tryEmitDwarfFileDirective( 918 unsigned FileNo, StringRef Directory, StringRef Filename, 919 Optional<MD5::MD5Result> Checksum = None, Optional<StringRef> Source = None, 920 unsigned CUID = 0); 921 922 /// Specify the "root" file of the compilation, using the ".file 0" extension. 923 virtual void emitDwarfFile0Directive(StringRef Directory, StringRef Filename, 924 Optional<MD5::MD5Result> Checksum, 925 Optional<StringRef> Source, 926 unsigned CUID = 0); 927 928 virtual void emitCFIBKeyFrame(); 929 virtual void emitCFIMTETaggedFrame(); 930 931 /// This implements the DWARF2 '.loc fileno lineno ...' assembler 932 /// directive. 933 virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line, 934 unsigned Column, unsigned Flags, 935 unsigned Isa, unsigned Discriminator, 936 StringRef FileName); 937 938 /// Associate a filename with a specified logical file number, and also 939 /// specify that file's checksum information. This implements the '.cv_file 4 940 /// "foo.c"' assembler directive. Returns true on success. 941 virtual bool emitCVFileDirective(unsigned FileNo, StringRef Filename, 942 ArrayRef<uint8_t> Checksum, 943 unsigned ChecksumKind); 944 945 /// Introduces a function id for use with .cv_loc. 946 virtual bool emitCVFuncIdDirective(unsigned FunctionId); 947 948 /// Introduces an inline call site id for use with .cv_loc. Includes 949 /// extra information for inline line table generation. 950 virtual bool emitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc, 951 unsigned IAFile, unsigned IALine, 952 unsigned IACol, SMLoc Loc); 953 954 /// This implements the CodeView '.cv_loc' assembler directive. 955 virtual void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, 956 unsigned Line, unsigned Column, 957 bool PrologueEnd, bool IsStmt, 958 StringRef FileName, SMLoc Loc); 959 960 /// This implements the CodeView '.cv_linetable' assembler directive. 961 virtual void emitCVLinetableDirective(unsigned FunctionId, 962 const MCSymbol *FnStart, 963 const MCSymbol *FnEnd); 964 965 /// This implements the CodeView '.cv_inline_linetable' assembler 966 /// directive. 967 virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId, 968 unsigned SourceFileId, 969 unsigned SourceLineNum, 970 const MCSymbol *FnStartSym, 971 const MCSymbol *FnEndSym); 972 973 /// This implements the CodeView '.cv_def_range' assembler 974 /// directive. 975 virtual void emitCVDefRangeDirective( 976 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, 977 StringRef FixedSizePortion); 978 979 virtual void emitCVDefRangeDirective( 980 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, 981 codeview::DefRangeRegisterRelHeader DRHdr); 982 983 virtual void emitCVDefRangeDirective( 984 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, 985 codeview::DefRangeSubfieldRegisterHeader DRHdr); 986 987 virtual void emitCVDefRangeDirective( 988 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, 989 codeview::DefRangeRegisterHeader DRHdr); 990 991 virtual void emitCVDefRangeDirective( 992 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, 993 codeview::DefRangeFramePointerRelHeader DRHdr); 994 995 /// This implements the CodeView '.cv_stringtable' assembler directive. 996 virtual void emitCVStringTableDirective() {} 997 998 /// This implements the CodeView '.cv_filechecksums' assembler directive. 999 virtual void emitCVFileChecksumsDirective() {} 1000 1001 /// This implements the CodeView '.cv_filechecksumoffset' assembler 1002 /// directive. 1003 virtual void emitCVFileChecksumOffsetDirective(unsigned FileNo) {} 1004 1005 /// This implements the CodeView '.cv_fpo_data' assembler directive. 1006 virtual void emitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc = {}) {} 1007 1008 /// Emit the absolute difference between two symbols. 1009 /// 1010 /// \pre Offset of \c Hi is greater than the offset \c Lo. 1011 virtual void emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, 1012 unsigned Size); 1013 1014 /// Emit the absolute difference between two symbols encoded with ULEB128. 1015 virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, 1016 const MCSymbol *Lo); 1017 1018 virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID); 1019 virtual void emitCFISections(bool EH, bool Debug); 1020 void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc()); 1021 void emitCFIEndProc(); 1022 virtual void emitCFIDefCfa(int64_t Register, int64_t Offset); 1023 virtual void emitCFIDefCfaOffset(int64_t Offset); 1024 virtual void emitCFIDefCfaRegister(int64_t Register); 1025 virtual void emitCFILLVMDefAspaceCfa(int64_t Register, int64_t Offset, 1026 int64_t AddressSpace); 1027 virtual void emitCFIOffset(int64_t Register, int64_t Offset); 1028 virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding); 1029 virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding); 1030 virtual void emitCFIRememberState(); 1031 virtual void emitCFIRestoreState(); 1032 virtual void emitCFISameValue(int64_t Register); 1033 virtual void emitCFIRestore(int64_t Register); 1034 virtual void emitCFIRelOffset(int64_t Register, int64_t Offset); 1035 virtual void emitCFIAdjustCfaOffset(int64_t Adjustment); 1036 virtual void emitCFIEscape(StringRef Values); 1037 virtual void emitCFIReturnColumn(int64_t Register); 1038 virtual void emitCFIGnuArgsSize(int64_t Size); 1039 virtual void emitCFISignalFrame(); 1040 virtual void emitCFIUndefined(int64_t Register); 1041 virtual void emitCFIRegister(int64_t Register1, int64_t Register2); 1042 virtual void emitCFIWindowSave(); 1043 virtual void emitCFINegateRAState(); 1044 1045 virtual void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc()); 1046 virtual void emitWinCFIEndProc(SMLoc Loc = SMLoc()); 1047 /// This is used on platforms, such as Windows on ARM64, that require function 1048 /// or funclet sizes to be emitted in .xdata before the End marker is emitted 1049 /// for the frame. We cannot use the End marker, as it is not set at the 1050 /// point of emitting .xdata, in order to indicate that the frame is active. 1051 virtual void emitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc()); 1052 virtual void emitWinCFIStartChained(SMLoc Loc = SMLoc()); 1053 virtual void emitWinCFIEndChained(SMLoc Loc = SMLoc()); 1054 virtual void emitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc()); 1055 virtual void emitWinCFISetFrame(MCRegister Register, unsigned Offset, 1056 SMLoc Loc = SMLoc()); 1057 virtual void emitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc()); 1058 virtual void emitWinCFISaveReg(MCRegister Register, unsigned Offset, 1059 SMLoc Loc = SMLoc()); 1060 virtual void emitWinCFISaveXMM(MCRegister Register, unsigned Offset, 1061 SMLoc Loc = SMLoc()); 1062 virtual void emitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc()); 1063 virtual void emitWinCFIEndProlog(SMLoc Loc = SMLoc()); 1064 virtual void emitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except, 1065 SMLoc Loc = SMLoc()); 1066 virtual void emitWinEHHandlerData(SMLoc Loc = SMLoc()); 1067 1068 virtual void emitCGProfileEntry(const MCSymbolRefExpr *From, 1069 const MCSymbolRefExpr *To, uint64_t Count); 1070 1071 /// Get the .pdata section used for the given section. Typically the given 1072 /// section is either the main .text section or some other COMDAT .text 1073 /// section, but it may be any section containing code. 1074 MCSection *getAssociatedPDataSection(const MCSection *TextSec); 1075 1076 /// Get the .xdata section used for the given section. 1077 MCSection *getAssociatedXDataSection(const MCSection *TextSec); 1078 1079 virtual void emitSyntaxDirective(); 1080 1081 /// Record a relocation described by the .reloc directive. Return None if 1082 /// succeeded. Otherwise, return a pair (Name is invalid, error message). 1083 virtual Optional<std::pair<bool, std::string>> 1084 emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, 1085 SMLoc Loc, const MCSubtargetInfo &STI) { 1086 return None; 1087 } 1088 1089 virtual void emitAddrsig() {} 1090 virtual void emitAddrsigSym(const MCSymbol *Sym) {} 1091 1092 /// Emit the given \p Instruction into the current section. 1093 virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI); 1094 1095 /// Emit the a pseudo probe into the current section. 1096 virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, 1097 uint64_t Attr, 1098 const MCPseudoProbeInlineStack &InlineStack); 1099 1100 /// Set the bundle alignment mode from now on in the section. 1101 /// The argument is the power of 2 to which the alignment is set. The 1102 /// value 0 means turn the bundle alignment off. 1103 virtual void emitBundleAlignMode(unsigned AlignPow2); 1104 1105 /// The following instructions are a bundle-locked group. 1106 /// 1107 /// \param AlignToEnd - If true, the bundle-locked group will be aligned to 1108 /// the end of a bundle. 1109 virtual void emitBundleLock(bool AlignToEnd); 1110 1111 /// Ends a bundle-locked group. 1112 virtual void emitBundleUnlock(); 1113 1114 /// If this file is backed by a assembly streamer, this dumps the 1115 /// specified string in the output .s file. This capability is indicated by 1116 /// the hasRawTextSupport() predicate. By default this aborts. 1117 void emitRawText(const Twine &String); 1118 1119 /// Streamer specific finalization. 1120 virtual void finishImpl(); 1121 /// Finish emission of machine code. 1122 void finish(SMLoc EndLoc = SMLoc()); 1123 1124 virtual bool mayHaveInstructions(MCSection &Sec) const { return true; } 1125 1126 /// Emit a special value of 0xffffffff if producing 64-bit debugging info. 1127 void maybeEmitDwarf64Mark(); 1128 1129 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen 1130 /// according to the settings. 1131 virtual void emitDwarfUnitLength(uint64_t Length, const Twine &Comment); 1132 1133 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen 1134 /// according to the settings. 1135 /// Return the end symbol generated inside, the caller needs to emit it. 1136 virtual MCSymbol *emitDwarfUnitLength(const Twine &Prefix, 1137 const Twine &Comment); 1138 1139 /// Emit the debug line start label. 1140 virtual void emitDwarfLineStartLabel(MCSymbol *StartSym); 1141 1142 /// Emit the debug line end entry. 1143 virtual void emitDwarfLineEndEntry(MCSection *Section, MCSymbol *LastLabel) {} 1144 1145 /// If targets does not support representing debug line section by .loc/.file 1146 /// directives in assembly output, we need to populate debug line section with 1147 /// raw debug line contents. 1148 virtual void emitDwarfAdvanceLineAddr(int64_t LineDelta, 1149 const MCSymbol *LastLabel, 1150 const MCSymbol *Label, 1151 unsigned PointerSize) {} 1152 1153 /// Do finalization for the streamer at the end of a section. 1154 virtual void doFinalizationAtSectionEnd(MCSection *Section) {} 1155 }; 1156 1157 /// Create a dummy machine code streamer, which does nothing. This is useful for 1158 /// timing the assembler front end. 1159 MCStreamer *createNullStreamer(MCContext &Ctx); 1160 1161 } // end namespace llvm 1162 1163 #endif // LLVM_MC_MCSTREAMER_H 1164