1 //===- llvm/CodeGen/AsmPrinter.h - AsmPrinter Framework ---------*- 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 contains a class to be used as the base class for target specific 10 // asm writers. This class primarily handles common functionality used by 11 // all asm writers. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CODEGEN_ASMPRINTER_H 16 #define LLVM_CODEGEN_ASMPRINTER_H 17 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/DenseSet.h" 20 #include "llvm/ADT/MapVector.h" 21 #include "llvm/ADT/SmallVector.h" 22 #include "llvm/BinaryFormat/Dwarf.h" 23 #include "llvm/CodeGen/AsmPrinterHandler.h" 24 #include "llvm/CodeGen/DwarfStringPoolEntry.h" 25 #include "llvm/CodeGen/MachineFunctionPass.h" 26 #include "llvm/CodeGen/StackMaps.h" 27 #include "llvm/IR/InlineAsm.h" 28 #include "llvm/Support/ErrorHandling.h" 29 #include <cstdint> 30 #include <memory> 31 #include <utility> 32 #include <vector> 33 34 namespace llvm { 35 36 class AddrLabelMap; 37 class BasicBlock; 38 class BlockAddress; 39 class Constant; 40 class ConstantArray; 41 class DataLayout; 42 class DIE; 43 class DIEAbbrev; 44 class DwarfDebug; 45 class GCMetadataPrinter; 46 class GCStrategy; 47 class GlobalAlias; 48 class GlobalObject; 49 class GlobalValue; 50 class GlobalVariable; 51 class MachineBasicBlock; 52 class MachineConstantPoolValue; 53 class MachineDominatorTree; 54 class MachineFunction; 55 class MachineInstr; 56 class MachineJumpTableInfo; 57 class MachineLoopInfo; 58 class MachineModuleInfo; 59 class MachineOptimizationRemarkEmitter; 60 class MCAsmInfo; 61 class MCCFIInstruction; 62 class MCContext; 63 class MCExpr; 64 class MCInst; 65 class MCSection; 66 class MCStreamer; 67 class MCSubtargetInfo; 68 class MCSymbol; 69 class MCTargetOptions; 70 class MDNode; 71 class Module; 72 class PseudoProbeHandler; 73 class raw_ostream; 74 class StringRef; 75 class TargetLoweringObjectFile; 76 class TargetMachine; 77 class Twine; 78 79 namespace remarks { 80 class RemarkStreamer; 81 } 82 83 /// This class is intended to be used as a driving class for all asm writers. 84 class AsmPrinter : public MachineFunctionPass { 85 public: 86 /// Target machine description. 87 TargetMachine &TM; 88 89 /// Target Asm Printer information. 90 const MCAsmInfo *MAI = nullptr; 91 92 /// This is the context for the output file that we are streaming. This owns 93 /// all of the global MC-related objects for the generated translation unit. 94 MCContext &OutContext; 95 96 /// This is the MCStreamer object for the file we are generating. This 97 /// contains the transient state for the current translation unit that we are 98 /// generating (such as the current section etc). 99 std::unique_ptr<MCStreamer> OutStreamer; 100 101 /// The current machine function. 102 MachineFunction *MF = nullptr; 103 104 /// This is a pointer to the current MachineModuleInfo. 105 MachineModuleInfo *MMI = nullptr; 106 107 /// This is a pointer to the current MachineDominatorTree. 108 MachineDominatorTree *MDT = nullptr; 109 110 /// This is a pointer to the current MachineLoopInfo. 111 MachineLoopInfo *MLI = nullptr; 112 113 /// Optimization remark emitter. 114 MachineOptimizationRemarkEmitter *ORE = nullptr; 115 116 /// The symbol for the entry in __patchable_function_entires. 117 MCSymbol *CurrentPatchableFunctionEntrySym = nullptr; 118 119 /// The symbol for the current function. This is recalculated at the beginning 120 /// of each call to runOnMachineFunction(). 121 MCSymbol *CurrentFnSym = nullptr; 122 123 /// The symbol for the current function descriptor on AIX. This is created 124 /// at the beginning of each call to SetupMachineFunction(). 125 MCSymbol *CurrentFnDescSym = nullptr; 126 127 /// The symbol used to represent the start of the current function for the 128 /// purpose of calculating its size (e.g. using the .size directive). By 129 /// default, this is equal to CurrentFnSym. 130 MCSymbol *CurrentFnSymForSize = nullptr; 131 132 /// Map a basic block section ID to the begin and end symbols of that section 133 /// which determine the section's range. 134 struct MBBSectionRange { 135 MCSymbol *BeginLabel, *EndLabel; 136 }; 137 138 MapVector<unsigned, MBBSectionRange> MBBSectionRanges; 139 140 /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of 141 /// its number of uses by other globals. 142 using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>; 143 MapVector<const MCSymbol *, GOTEquivUsePair> GlobalGOTEquivs; 144 145 /// struct HandlerInfo and Handlers permit users or target extended 146 /// AsmPrinter to add their own handlers. 147 struct HandlerInfo { 148 std::unique_ptr<AsmPrinterHandler> Handler; 149 StringRef TimerName; 150 StringRef TimerDescription; 151 StringRef TimerGroupName; 152 StringRef TimerGroupDescription; 153 154 HandlerInfo(std::unique_ptr<AsmPrinterHandler> Handler, StringRef TimerName, 155 StringRef TimerDescription, StringRef TimerGroupName, 156 StringRef TimerGroupDescription) 157 : Handler(std::move(Handler)), TimerName(TimerName), 158 TimerDescription(TimerDescription), TimerGroupName(TimerGroupName), 159 TimerGroupDescription(TimerGroupDescription) {} 160 }; 161 162 // Flags representing which CFI section is required for a function/module. 163 enum class CFISection : unsigned { 164 None = 0, ///< Do not emit either .eh_frame or .debug_frame 165 EH = 1, ///< Emit .eh_frame 166 Debug = 2 ///< Emit .debug_frame 167 }; 168 169 private: 170 MCSymbol *CurrentFnEnd = nullptr; 171 172 /// Map a basic block section ID to the exception symbol associated with that 173 /// section. Map entries are assigned and looked up via 174 /// AsmPrinter::getMBBExceptionSym. 175 DenseMap<unsigned, MCSymbol *> MBBSectionExceptionSyms; 176 177 // The symbol used to represent the start of the current BB section of the 178 // function. This is used to calculate the size of the BB section. 179 MCSymbol *CurrentSectionBeginSym = nullptr; 180 181 /// This map keeps track of which symbol is being used for the specified basic 182 /// block's address of label. 183 std::unique_ptr<AddrLabelMap> AddrLabelSymbols; 184 185 /// The garbage collection metadata printer table. 186 DenseMap<GCStrategy *, std::unique_ptr<GCMetadataPrinter>> GCMetadataPrinters; 187 188 /// Emit comments in assembly output if this is true. 189 bool VerboseAsm; 190 191 /// Output stream for the stack usage file (i.e., .su file). 192 std::unique_ptr<raw_fd_ostream> StackUsageStream; 193 194 /// List of symbols to be inserted into PC sections. 195 DenseMap<const MDNode *, SmallVector<const MCSymbol *>> PCSectionsSymbols; 196 197 static char ID; 198 199 protected: 200 MCSymbol *CurrentFnBegin = nullptr; 201 202 /// For dso_local functions, the current $local alias for the function. 203 MCSymbol *CurrentFnBeginLocal = nullptr; 204 205 /// A vector of all debug/EH info emitters we should use. This vector 206 /// maintains ownership of the emitters. 207 std::vector<HandlerInfo> Handlers; 208 size_t NumUserHandlers = 0; 209 210 StackMaps SM; 211 212 private: 213 /// If generated on the fly this own the instance. 214 std::unique_ptr<MachineDominatorTree> OwnedMDT; 215 216 /// If generated on the fly this own the instance. 217 std::unique_ptr<MachineLoopInfo> OwnedMLI; 218 219 /// If the target supports dwarf debug info, this pointer is non-null. 220 DwarfDebug *DD = nullptr; 221 222 /// A handler that supports pseudo probe emission with embedded inline 223 /// context. 224 PseudoProbeHandler *PP = nullptr; 225 226 /// CFISection type the module needs i.e. either .eh_frame or .debug_frame. 227 CFISection ModuleCFISection = CFISection::None; 228 229 /// True if the module contains split-stack functions. This is used to 230 /// emit .note.GNU-split-stack section as required by the linker for 231 /// special handling split-stack function calling no-split-stack function. 232 bool HasSplitStack = false; 233 234 /// True if the module contains no-split-stack functions. This is used to emit 235 /// .note.GNU-no-split-stack section when it also contains functions without a 236 /// split stack prologue. 237 bool HasNoSplitStack = false; 238 239 /// Raw FDOstream for outputting machine basic block frequncies if the 240 /// --mbb-profile-dump flag is set for downstream cost modelling applications 241 std::unique_ptr<raw_fd_ostream> MBBProfileDumpFileOutput; 242 243 protected: 244 explicit AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer); 245 246 public: 247 ~AsmPrinter() override; 248 249 DwarfDebug *getDwarfDebug() { return DD; } 250 DwarfDebug *getDwarfDebug() const { return DD; } 251 252 uint16_t getDwarfVersion() const; 253 void setDwarfVersion(uint16_t Version); 254 255 bool isDwarf64() const; 256 257 /// Returns 4 for DWARF32 and 8 for DWARF64. 258 unsigned int getDwarfOffsetByteSize() const; 259 260 /// Returns 4 for DWARF32 and 12 for DWARF64. 261 unsigned int getUnitLengthFieldByteSize() const; 262 263 /// Returns information about the byte size of DW_FORM values. 264 dwarf::FormParams getDwarfFormParams() const; 265 266 bool isPositionIndependent() const; 267 268 /// Return true if assembly output should contain comments. 269 bool isVerbose() const { return VerboseAsm; } 270 271 /// Return a unique ID for the current function. 272 unsigned getFunctionNumber() const; 273 274 /// Return symbol for the function pseudo stack if the stack frame is not a 275 /// register based. 276 virtual const MCSymbol *getFunctionFrameSymbol() const { return nullptr; } 277 278 MCSymbol *getFunctionBegin() const { return CurrentFnBegin; } 279 MCSymbol *getFunctionEnd() const { return CurrentFnEnd; } 280 281 // Return the exception symbol associated with the MBB section containing a 282 // given basic block. 283 MCSymbol *getMBBExceptionSym(const MachineBasicBlock &MBB); 284 285 /// Return the symbol to be used for the specified basic block when its 286 /// address is taken. This cannot be its normal LBB label because the block 287 /// may be accessed outside its containing function. 288 MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) { 289 return getAddrLabelSymbolToEmit(BB).front(); 290 } 291 292 /// Return the symbol to be used for the specified basic block when its 293 /// address is taken. If other blocks were RAUW'd to this one, we may have 294 /// to emit them as well, return the whole set. 295 ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB); 296 297 /// If the specified function has had any references to address-taken blocks 298 /// generated, but the block got deleted, return the symbol now so we can 299 /// emit it. This prevents emitting a reference to a symbol that has no 300 /// definition. 301 void takeDeletedSymbolsForFunction(const Function *F, 302 std::vector<MCSymbol *> &Result); 303 304 /// Return information about object file lowering. 305 const TargetLoweringObjectFile &getObjFileLowering() const; 306 307 /// Return information about data layout. 308 const DataLayout &getDataLayout() const; 309 310 /// Return the pointer size from the TargetMachine 311 unsigned getPointerSize() const; 312 313 /// Return information about subtarget. 314 const MCSubtargetInfo &getSubtargetInfo() const; 315 316 void EmitToStreamer(MCStreamer &S, const MCInst &Inst); 317 318 /// Emits inital debug location directive. 319 void emitInitialRawDwarfLocDirective(const MachineFunction &MF); 320 321 /// Return the current section we are emitting to. 322 const MCSection *getCurrentSection() const; 323 324 void getNameWithPrefix(SmallVectorImpl<char> &Name, 325 const GlobalValue *GV) const; 326 327 MCSymbol *getSymbol(const GlobalValue *GV) const; 328 329 /// Similar to getSymbol() but preferred for references. On ELF, this uses a 330 /// local symbol if a reference to GV is guaranteed to be resolved to the 331 /// definition in the same module. 332 MCSymbol *getSymbolPreferLocal(const GlobalValue &GV) const; 333 334 bool doesDwarfUseRelocationsAcrossSections() const { 335 return DwarfUsesRelocationsAcrossSections; 336 } 337 338 void setDwarfUsesRelocationsAcrossSections(bool Enable) { 339 DwarfUsesRelocationsAcrossSections = Enable; 340 } 341 342 //===------------------------------------------------------------------===// 343 // XRay instrumentation implementation. 344 //===------------------------------------------------------------------===// 345 public: 346 // This describes the kind of sled we're storing in the XRay table. 347 enum class SledKind : uint8_t { 348 FUNCTION_ENTER = 0, 349 FUNCTION_EXIT = 1, 350 TAIL_CALL = 2, 351 LOG_ARGS_ENTER = 3, 352 CUSTOM_EVENT = 4, 353 TYPED_EVENT = 5, 354 }; 355 356 // The table will contain these structs that point to the sled, the function 357 // containing the sled, and what kind of sled (and whether they should always 358 // be instrumented). We also use a version identifier that the runtime can use 359 // to decide what to do with the sled, depending on the version of the sled. 360 struct XRayFunctionEntry { 361 const MCSymbol *Sled; 362 const MCSymbol *Function; 363 SledKind Kind; 364 bool AlwaysInstrument; 365 const class Function *Fn; 366 uint8_t Version; 367 368 void emit(int, MCStreamer *) const; 369 }; 370 371 // All the sleds to be emitted. 372 SmallVector<XRayFunctionEntry, 4> Sleds; 373 374 // Helper function to record a given XRay sled. 375 void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, 376 uint8_t Version = 0); 377 378 /// Emit a table with all XRay instrumentation points. 379 void emitXRayTable(); 380 381 void emitPatchableFunctionEntries(); 382 383 //===------------------------------------------------------------------===// 384 // MachineFunctionPass Implementation. 385 //===------------------------------------------------------------------===// 386 387 /// Record analysis usage. 388 void getAnalysisUsage(AnalysisUsage &AU) const override; 389 390 /// Set up the AsmPrinter when we are working on a new module. If your pass 391 /// overrides this, it must make sure to explicitly call this implementation. 392 bool doInitialization(Module &M) override; 393 394 /// Shut down the asmprinter. If you override this in your pass, you must make 395 /// sure to call it explicitly. 396 bool doFinalization(Module &M) override; 397 398 /// Emit the specified function out to the OutStreamer. 399 bool runOnMachineFunction(MachineFunction &MF) override { 400 SetupMachineFunction(MF); 401 emitFunctionBody(); 402 return false; 403 } 404 405 //===------------------------------------------------------------------===// 406 // Coarse grained IR lowering routines. 407 //===------------------------------------------------------------------===// 408 409 /// This should be called when a new MachineFunction is being processed from 410 /// runOnMachineFunction. 411 virtual void SetupMachineFunction(MachineFunction &MF); 412 413 /// This method emits the body and trailer for a function. 414 void emitFunctionBody(); 415 416 void emitCFIInstruction(const MachineInstr &MI); 417 418 void emitFrameAlloc(const MachineInstr &MI); 419 420 void emitStackSizeSection(const MachineFunction &MF); 421 422 void emitStackUsage(const MachineFunction &MF); 423 424 void emitBBAddrMapSection(const MachineFunction &MF); 425 426 void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol); 427 virtual void emitKCFITypeId(const MachineFunction &MF); 428 429 void emitPseudoProbe(const MachineInstr &MI); 430 431 void emitRemarksSection(remarks::RemarkStreamer &RS); 432 433 /// Emits a label as reference for PC sections. 434 void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD); 435 436 /// Emits the PC sections collected from instructions. 437 void emitPCSections(const MachineFunction &MF); 438 439 /// Get the CFISection type for a function. 440 CFISection getFunctionCFISectionType(const Function &F) const; 441 442 /// Get the CFISection type for a function. 443 CFISection getFunctionCFISectionType(const MachineFunction &MF) const; 444 445 /// Get the CFISection type for the module. 446 CFISection getModuleCFISectionType() const { return ModuleCFISection; } 447 448 bool needsSEHMoves(); 449 450 /// Since emitting CFI unwind information is entangled with supporting the 451 /// exceptions, this returns true for platforms which use CFI unwind 452 /// information for other purposes (debugging, sanitizers, ...) when 453 /// `MCAsmInfo::ExceptionsType == ExceptionHandling::None`. 454 bool usesCFIWithoutEH() const; 455 456 /// Print to the current output stream assembly representations of the 457 /// constants in the constant pool MCP. This is used to print out constants 458 /// which have been "spilled to memory" by the code generator. 459 virtual void emitConstantPool(); 460 461 /// Print assembly representations of the jump tables used by the current 462 /// function to the current output stream. 463 virtual void emitJumpTableInfo(); 464 465 /// Emit the specified global variable to the .s file. 466 virtual void emitGlobalVariable(const GlobalVariable *GV); 467 468 /// Check to see if the specified global is a special global used by LLVM. If 469 /// so, emit it and return true, otherwise do nothing and return false. 470 bool emitSpecialLLVMGlobal(const GlobalVariable *GV); 471 472 /// `llvm.global_ctors` and `llvm.global_dtors` are arrays of Structor 473 /// structs. 474 /// 475 /// Priority - init priority 476 /// Func - global initialization or global clean-up function 477 /// ComdatKey - associated data 478 struct Structor { 479 int Priority = 0; 480 Constant *Func = nullptr; 481 GlobalValue *ComdatKey = nullptr; 482 483 Structor() = default; 484 }; 485 486 /// This method gathers an array of Structors and then sorts them out by 487 /// Priority. 488 /// @param List The initializer of `llvm.global_ctors` or `llvm.global_dtors` 489 /// array. 490 /// @param[out] Structors Sorted Structor structs by Priority. 491 void preprocessXXStructorList(const DataLayout &DL, const Constant *List, 492 SmallVector<Structor, 8> &Structors); 493 494 /// This method emits `llvm.global_ctors` or `llvm.global_dtors` list. 495 virtual void emitXXStructorList(const DataLayout &DL, const Constant *List, 496 bool IsCtor); 497 498 /// Emit an alignment directive to the specified power of two boundary. If a 499 /// global value is specified, and if that global has an explicit alignment 500 /// requested, it will override the alignment request if required for 501 /// correctness. 502 void emitAlignment(Align Alignment, const GlobalObject *GV = nullptr, 503 unsigned MaxBytesToEmit = 0) const; 504 505 /// Lower the specified LLVM Constant to an MCExpr. 506 virtual const MCExpr *lowerConstant(const Constant *CV); 507 508 /// Print a general LLVM constant to the .s file. 509 /// On AIX, when an alias refers to a sub-element of a global variable, the 510 /// label of that alias needs to be emitted before the corresponding element. 511 using AliasMapTy = DenseMap<uint64_t, SmallVector<const GlobalAlias *, 1>>; 512 void emitGlobalConstant(const DataLayout &DL, const Constant *CV, 513 AliasMapTy *AliasList = nullptr); 514 515 /// Unnamed constant global variables solely contaning a pointer to 516 /// another globals variable act like a global variable "proxy", or GOT 517 /// equivalents, i.e., it's only used to hold the address of the latter. One 518 /// optimization is to replace accesses to these proxies by using the GOT 519 /// entry for the final global instead. Hence, we select GOT equivalent 520 /// candidates among all the module global variables, avoid emitting them 521 /// unnecessarily and finally replace references to them by pc relative 522 /// accesses to GOT entries. 523 void computeGlobalGOTEquivs(Module &M); 524 525 /// Constant expressions using GOT equivalent globals may not be 526 /// eligible for PC relative GOT entry conversion, in such cases we need to 527 /// emit the proxies we previously omitted in EmitGlobalVariable. 528 void emitGlobalGOTEquivs(); 529 530 /// Emit the stack maps. 531 void emitStackMaps(); 532 533 //===------------------------------------------------------------------===// 534 // Overridable Hooks 535 //===------------------------------------------------------------------===// 536 537 void addAsmPrinterHandler(HandlerInfo Handler) { 538 Handlers.insert(Handlers.begin(), std::move(Handler)); 539 NumUserHandlers++; 540 } 541 542 // Targets can, or in the case of EmitInstruction, must implement these to 543 // customize output. 544 545 /// This virtual method can be overridden by targets that want to emit 546 /// something at the start of their file. 547 virtual void emitStartOfAsmFile(Module &) {} 548 549 /// This virtual method can be overridden by targets that want to emit 550 /// something at the end of their file. 551 virtual void emitEndOfAsmFile(Module &) {} 552 553 /// Targets can override this to emit stuff before the first basic block in 554 /// the function. 555 virtual void emitFunctionBodyStart() {} 556 557 /// Targets can override this to emit stuff after the last basic block in the 558 /// function. 559 virtual void emitFunctionBodyEnd() {} 560 561 /// Targets can override this to emit stuff at the start of a basic block. 562 /// By default, this method prints the label for the specified 563 /// MachineBasicBlock, an alignment (if present) and a comment describing it 564 /// if appropriate. 565 virtual void emitBasicBlockStart(const MachineBasicBlock &MBB); 566 567 /// Targets can override this to emit stuff at the end of a basic block. 568 virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB); 569 570 /// Targets should implement this to emit instructions. 571 virtual void emitInstruction(const MachineInstr *) { 572 llvm_unreachable("EmitInstruction not implemented"); 573 } 574 575 /// Return the symbol for the specified constant pool entry. 576 virtual MCSymbol *GetCPISymbol(unsigned CPID) const; 577 578 virtual void emitFunctionEntryLabel(); 579 580 virtual void emitFunctionDescriptor() { 581 llvm_unreachable("Function descriptor is target-specific."); 582 } 583 584 virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV); 585 586 /// Targets can override this to change how global constants that are part of 587 /// a C++ static/global constructor list are emitted. 588 virtual void emitXXStructor(const DataLayout &DL, const Constant *CV) { 589 emitGlobalConstant(DL, CV); 590 } 591 592 /// Return true if the basic block has exactly one predecessor and the control 593 /// transfer mechanism between the predecessor and this block is a 594 /// fall-through. 595 virtual bool 596 isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const; 597 598 /// Targets can override this to customize the output of IMPLICIT_DEF 599 /// instructions in verbose mode. 600 virtual void emitImplicitDef(const MachineInstr *MI) const; 601 602 /// Emit N NOP instructions. 603 void emitNops(unsigned N); 604 605 //===------------------------------------------------------------------===// 606 // Symbol Lowering Routines. 607 //===------------------------------------------------------------------===// 608 609 MCSymbol *createTempSymbol(const Twine &Name) const; 610 611 /// Return the MCSymbol for a private symbol with global value name as its 612 /// base, with the specified suffix. 613 MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV, 614 StringRef Suffix) const; 615 616 /// Return the MCSymbol for the specified ExternalSymbol. 617 MCSymbol *GetExternalSymbolSymbol(StringRef Sym) const; 618 619 /// Return the symbol for the specified jump table entry. 620 MCSymbol *GetJTISymbol(unsigned JTID, bool isLinkerPrivate = false) const; 621 622 /// Return the symbol for the specified jump table .set 623 /// FIXME: privatize to AsmPrinter. 624 MCSymbol *GetJTSetSymbol(unsigned UID, unsigned MBBID) const; 625 626 /// Return the MCSymbol used to satisfy BlockAddress uses of the specified 627 /// basic block. 628 MCSymbol *GetBlockAddressSymbol(const BlockAddress *BA) const; 629 MCSymbol *GetBlockAddressSymbol(const BasicBlock *BB) const; 630 631 //===------------------------------------------------------------------===// 632 // Emission Helper Routines. 633 //===------------------------------------------------------------------===// 634 635 /// This is just convenient handler for printing offsets. 636 void printOffset(int64_t Offset, raw_ostream &OS) const; 637 638 /// Emit a byte directive and value. 639 void emitInt8(int Value) const; 640 641 /// Emit a short directive and value. 642 void emitInt16(int Value) const; 643 644 /// Emit a long directive and value. 645 void emitInt32(int Value) const; 646 647 /// Emit a long long directive and value. 648 void emitInt64(uint64_t Value) const; 649 650 /// Emit the specified signed leb128 value. 651 void emitSLEB128(int64_t Value, const char *Desc = nullptr) const; 652 653 /// Emit the specified unsigned leb128 value. 654 void emitULEB128(uint64_t Value, const char *Desc = nullptr, 655 unsigned PadTo = 0) const; 656 657 /// Emit something like ".long Hi-Lo" where the size in bytes of the directive 658 /// is specified by Size and Hi/Lo specify the labels. This implicitly uses 659 /// .set if it is available. 660 void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, 661 unsigned Size) const; 662 663 /// Emit something like ".uleb128 Hi-Lo". 664 void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, 665 const MCSymbol *Lo) const; 666 667 /// Emit something like ".long Label+Offset" where the size in bytes of the 668 /// directive is specified by Size and Label specifies the label. This 669 /// implicitly uses .set if it is available. 670 void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, 671 unsigned Size, bool IsSectionRelative = false) const; 672 673 /// Emit something like ".long Label" where the size in bytes of the directive 674 /// is specified by Size and Label specifies the label. 675 void emitLabelReference(const MCSymbol *Label, unsigned Size, 676 bool IsSectionRelative = false) const { 677 emitLabelPlusOffset(Label, 0, Size, IsSectionRelative); 678 } 679 680 //===------------------------------------------------------------------===// 681 // Dwarf Emission Helper Routines 682 //===------------------------------------------------------------------===// 683 684 /// Emit a .byte 42 directive that corresponds to an encoding. If verbose 685 /// assembly output is enabled, we output comments describing the encoding. 686 /// Desc is a string saying what the encoding is specifying (e.g. "LSDA"). 687 void emitEncodingByte(unsigned Val, const char *Desc = nullptr) const; 688 689 /// Return the size of the encoding in bytes. 690 unsigned GetSizeOfEncodedValue(unsigned Encoding) const; 691 692 /// Emit reference to a ttype global with a specified encoding. 693 virtual void emitTTypeReference(const GlobalValue *GV, unsigned Encoding); 694 695 /// Emit a reference to a symbol for use in dwarf. Different object formats 696 /// represent this in different ways. Some use a relocation others encode 697 /// the label offset in its section. 698 void emitDwarfSymbolReference(const MCSymbol *Label, 699 bool ForceOffset = false) const; 700 701 /// Emit the 4- or 8-byte offset of a string from the start of its section. 702 /// 703 /// When possible, emit a DwarfStringPool section offset without any 704 /// relocations, and without using the symbol. Otherwise, defers to \a 705 /// emitDwarfSymbolReference(). 706 /// 707 /// The length of the emitted value depends on the DWARF format. 708 void emitDwarfStringOffset(DwarfStringPoolEntry S) const; 709 710 /// Emit the 4-or 8-byte offset of a string from the start of its section. 711 void emitDwarfStringOffset(DwarfStringPoolEntryRef S) const { 712 emitDwarfStringOffset(S.getEntry()); 713 } 714 715 /// Emit something like ".long Label + Offset" or ".quad Label + Offset" 716 /// depending on the DWARF format. 717 void emitDwarfOffset(const MCSymbol *Label, uint64_t Offset) const; 718 719 /// Emit 32- or 64-bit value depending on the DWARF format. 720 void emitDwarfLengthOrOffset(uint64_t Value) const; 721 722 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen 723 /// according to the settings. 724 void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const; 725 726 /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen 727 /// according to the settings. 728 /// Return the end symbol generated inside, the caller needs to emit it. 729 MCSymbol *emitDwarfUnitLength(const Twine &Prefix, 730 const Twine &Comment) const; 731 732 /// Emit reference to a call site with a specified encoding 733 void emitCallSiteOffset(const MCSymbol *Hi, const MCSymbol *Lo, 734 unsigned Encoding) const; 735 /// Emit an integer value corresponding to the call site encoding 736 void emitCallSiteValue(uint64_t Value, unsigned Encoding) const; 737 738 /// Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified. 739 virtual unsigned getISAEncoding() { return 0; } 740 741 /// Emit the directive and value for debug thread local expression 742 /// 743 /// \p Value - The value to emit. 744 /// \p Size - The size of the integer (in bytes) to emit. 745 virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const; 746 747 //===------------------------------------------------------------------===// 748 // Dwarf Lowering Routines 749 //===------------------------------------------------------------------===// 750 751 /// Emit frame instruction to describe the layout of the frame. 752 void emitCFIInstruction(const MCCFIInstruction &Inst) const; 753 754 /// Emit Dwarf abbreviation table. 755 template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const { 756 // For each abbreviation. 757 for (const auto &Abbrev : Abbrevs) 758 emitDwarfAbbrev(*Abbrev); 759 760 // Mark end of abbreviations. 761 emitULEB128(0, "EOM(3)"); 762 } 763 764 void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const; 765 766 /// Recursively emit Dwarf DIE tree. 767 void emitDwarfDIE(const DIE &Die) const; 768 769 //===------------------------------------------------------------------===// 770 // Inline Asm Support 771 //===------------------------------------------------------------------===// 772 773 // These are hooks that targets can override to implement inline asm 774 // support. These should probably be moved out of AsmPrinter someday. 775 776 /// Print information related to the specified machine instr that is 777 /// independent of the operand, and may be independent of the instr itself. 778 /// This can be useful for portably encoding the comment character or other 779 /// bits of target-specific knowledge into the asmstrings. The syntax used is 780 /// ${:comment}. Targets can override this to add support for their own 781 /// strange codes. 782 virtual void PrintSpecial(const MachineInstr *MI, raw_ostream &OS, 783 StringRef Code) const; 784 785 /// Print the MachineOperand as a symbol. Targets with complex handling of 786 /// symbol references should override the base implementation. 787 virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS); 788 789 /// Print the specified operand of MI, an INLINEASM instruction, using the 790 /// specified assembler variant. Targets should override this to format as 791 /// appropriate. This method can return true if the operand is erroneous. 792 virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 793 const char *ExtraCode, raw_ostream &OS); 794 795 /// Print the specified operand of MI, an INLINEASM instruction, using the 796 /// specified assembler variant as an address. Targets should override this to 797 /// format as appropriate. This method can return true if the operand is 798 /// erroneous. 799 virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 800 const char *ExtraCode, raw_ostream &OS); 801 802 /// Let the target do anything it needs to do before emitting inlineasm. 803 /// \p StartInfo - the subtarget info before parsing inline asm 804 virtual void emitInlineAsmStart() const; 805 806 /// Let the target do anything it needs to do after emitting inlineasm. 807 /// This callback can be used restore the original mode in case the 808 /// inlineasm contains directives to switch modes. 809 /// \p StartInfo - the original subtarget info before inline asm 810 /// \p EndInfo - the final subtarget info after parsing the inline asm, 811 /// or NULL if the value is unknown. 812 virtual void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo, 813 const MCSubtargetInfo *EndInfo) const; 814 815 /// This emits visibility information about symbol, if this is supported by 816 /// the target. 817 void emitVisibility(MCSymbol *Sym, unsigned Visibility, 818 bool IsDefinition = true) const; 819 820 /// This emits linkage information about \p GVSym based on \p GV, if this is 821 /// supported by the target. 822 virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const; 823 824 /// Return the alignment for the specified \p GV. 825 static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, 826 Align InAlign = Align(1)); 827 828 private: 829 /// Private state for PrintSpecial() 830 // Assign a unique ID to this machine instruction. 831 mutable const MachineInstr *LastMI = nullptr; 832 mutable unsigned LastFn = 0; 833 mutable unsigned Counter = ~0U; 834 835 bool DwarfUsesRelocationsAcrossSections = false; 836 837 /// This method emits the header for the current function. 838 virtual void emitFunctionHeader(); 839 840 /// This method emits a comment next to header for the current function. 841 virtual void emitFunctionHeaderComment(); 842 843 /// Emit a blob of inline asm to the output streamer. 844 void 845 emitInlineAsm(StringRef Str, const MCSubtargetInfo &STI, 846 const MCTargetOptions &MCOptions, 847 const MDNode *LocMDNode = nullptr, 848 InlineAsm::AsmDialect AsmDialect = InlineAsm::AD_ATT) const; 849 850 /// This method formats and emits the specified machine instruction that is an 851 /// inline asm. 852 void emitInlineAsm(const MachineInstr *MI) const; 853 854 /// Add inline assembly info to the diagnostics machinery, so we can 855 /// emit file and position info. Returns SrcMgr memory buffer position. 856 unsigned addInlineAsmDiagBuffer(StringRef AsmStr, 857 const MDNode *LocMDNode) const; 858 859 //===------------------------------------------------------------------===// 860 // Internal Implementation Details 861 //===------------------------------------------------------------------===// 862 863 void emitJumpTableEntry(const MachineJumpTableInfo *MJTI, 864 const MachineBasicBlock *MBB, unsigned uid) const; 865 void emitLLVMUsedList(const ConstantArray *InitList); 866 /// Emit llvm.ident metadata in an '.ident' directive. 867 void emitModuleIdents(Module &M); 868 /// Emit bytes for llvm.commandline metadata. 869 virtual void emitModuleCommandLines(Module &M); 870 871 GCMetadataPrinter *getOrCreateGCPrinter(GCStrategy &S); 872 void emitGlobalAlias(Module &M, const GlobalAlias &GA); 873 void emitGlobalIFunc(Module &M, const GlobalIFunc &GI); 874 875 /// This method decides whether the specified basic block requires a label. 876 bool shouldEmitLabelForBasicBlock(const MachineBasicBlock &MBB) const; 877 878 protected: 879 virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const { 880 return false; 881 } 882 }; 883 884 } // end namespace llvm 885 886 #endif // LLVM_CODEGEN_ASMPRINTER_H 887