//===- AsmPrinter.cpp - Common AsmPrinter code ----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements the AsmPrinter class. // //===----------------------------------------------------------------------===// #include "llvm/CodeGen/AsmPrinter.h" #include "CodeViewDebug.h" #include "DwarfDebug.h" #include "DwarfException.h" #include "PseudoProbePrinter.h" #include "WasmException.h" #include "WinCFGuard.h" #include "WinException.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/TinyPtrVector.h" #include "llvm/ADT/Twine.h" #include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/MemoryLocation.h" #include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/BinaryFormat/COFF.h" #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/BinaryFormat/ELF.h" #include "llvm/CodeGen/GCMetadata.h" #include "llvm/CodeGen/GCMetadataPrinter.h" #include "llvm/CodeGen/LazyMachineBlockFrequencyInfo.h" #include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineBranchProbabilityInfo.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineDominators.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/MachineInstrBundle.h" #include "llvm/CodeGen/MachineJumpTableInfo.h" #include "llvm/CodeGen/MachineLoopInfo.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineModuleInfoImpls.h" #include "llvm/CodeGen/MachineOperand.h" #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h" #include "llvm/CodeGen/StackMaps.h" #include "llvm/CodeGen/TargetFrameLowering.h" #include "llvm/CodeGen/TargetInstrInfo.h" #include "llvm/CodeGen/TargetLowering.h" #include "llvm/CodeGen/TargetOpcodes.h" #include "llvm/CodeGen/TargetRegisterInfo.h" #include "llvm/CodeGen/TargetSubtargetInfo.h" #include "llvm/Config/config.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/Comdat.h" #include "llvm/IR/Constant.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/EHPersonalities.h" #include "llvm/IR/Function.h" #include "llvm/IR/GCStrategy.h" #include "llvm/IR/GlobalAlias.h" #include "llvm/IR/GlobalIFunc.h" #include "llvm/IR/GlobalObject.h" #include "llvm/IR/GlobalValue.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/Mangler.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Module.h" #include "llvm/IR/Operator.h" #include "llvm/IR/PseudoProbe.h" #include "llvm/IR/Type.h" #include "llvm/IR/Value.h" #include "llvm/IR/ValueHandle.h" #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCDirectives.h" #include "llvm/MC/MCExpr.h" #include "llvm/MC/MCInst.h" #include "llvm/MC/MCSection.h" #include "llvm/MC/MCSectionCOFF.h" #include "llvm/MC/MCSectionELF.h" #include "llvm/MC/MCSectionMachO.h" #include "llvm/MC/MCSectionXCOFF.h" #include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCSubtargetInfo.h" #include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCSymbolCOFF.h" #include "llvm/MC/MCSymbolELF.h" #include "llvm/MC/MCTargetOptions.h" #include "llvm/MC/MCValue.h" #include "llvm/MC/SectionKind.h" #include "llvm/Object/ELFTypes.h" #include "llvm/Pass.h" #include "llvm/Remarks/RemarkStreamer.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/Format.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/Path.h" #include "llvm/Support/VCSRevision.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <cassert> #include <cinttypes> #include <cstdint> #include <iterator> #include <memory> #include <optional> #include <string> #include <utility> #include <vector> usingnamespacellvm; #define DEBUG_TYPE … // This is a replication of fields of object::PGOAnalysisMap::Features. It // should match the order of the fields so that // `object::PGOAnalysisMap::Features::decode(PgoAnalysisMapFeatures.getBits())` // succeeds. enum class PGOMapFeaturesEnum { … }; static cl::bits<PGOMapFeaturesEnum> PgoAnalysisMapFeatures( "pgo-analysis-map", cl::Hidden, cl::CommaSeparated, cl::values(clEnumValN(PGOMapFeaturesEnum::FuncEntryCount, "func-entry-count", "Function Entry Count"), clEnumValN(PGOMapFeaturesEnum::BBFreq, "bb-freq", "Basic Block Frequency"), clEnumValN(PGOMapFeaturesEnum::BrProb, "br-prob", "Branch Probability")), cl::desc( "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is " "extracted from PGO related analysis.")); static cl::opt<bool> EmitJumpTableSizesSection( "emit-jump-table-sizes-section", cl::desc("Emit a section containing jump table addresses and sizes"), cl::Hidden, cl::init(false)); STATISTIC(EmittedInsts, "Number of machine instrs printed"); char AsmPrinter::ID = …; namespace { class AddrLabelMapCallbackPtr final : CallbackVH { … }; } // namespace class llvm::AddrLabelMap { … }; ArrayRef<MCSymbol *> AddrLabelMap::getAddrLabelSymbolToEmit(BasicBlock *BB) { … } /// If we have any deleted symbols for F, return them. void AddrLabelMap::takeDeletedSymbolsForFunction( Function *F, std::vector<MCSymbol *> &Result) { … } //===- Address of Block Management ----------------------------------------===// ArrayRef<MCSymbol *> AsmPrinter::getAddrLabelSymbolToEmit(const BasicBlock *BB) { … } void AsmPrinter::takeDeletedSymbolsForFunction( const Function *F, std::vector<MCSymbol *> &Result) { … } void AddrLabelMap::UpdateForDeletedBlock(BasicBlock *BB) { … } void AddrLabelMap::UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New) { … } void AddrLabelMapCallbackPtr::deleted() { … } void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) { … } /// getGVAlignment - Return the alignment to use for the specified global /// value. This rounds up to the preferred alignment if possible and legal. Align AsmPrinter::getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign) { … } AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer) : … { … } AsmPrinter::~AsmPrinter() { … } bool AsmPrinter::isPositionIndependent() const { … } /// getFunctionNumber - Return a unique ID for the current function. unsigned AsmPrinter::getFunctionNumber() const { … } const TargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { … } const DataLayout &AsmPrinter::getDataLayout() const { … } // Do not use the cached DataLayout because some client use it without a Module // (dsymutil, llvm-dwarfdump). unsigned AsmPrinter::getPointerSize() const { … } const MCSubtargetInfo &AsmPrinter::getSubtargetInfo() const { … } void AsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) { … } void AsmPrinter::emitInitialRawDwarfLocDirective(const MachineFunction &MF) { … } /// getCurrentSection() - Return the current section we are emitting to. const MCSection *AsmPrinter::getCurrentSection() const { … } void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { … } bool AsmPrinter::doInitialization(Module &M) { … } static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) { … } void AsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const { … } void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name, const GlobalValue *GV) const { … } MCSymbol *AsmPrinter::getSymbol(const GlobalValue *GV) const { … } MCSymbol *AsmPrinter::getSymbolPreferLocal(const GlobalValue &GV) const { … } /// EmitGlobalVariable - Emit the specified global variable to the .s file. void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { … } /// Emit the directive and value for debug thread local expression /// /// \p Value - The value to emit. /// \p Size - The size of the integer (in bytes) to emit. void AsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const { … } void AsmPrinter::emitFunctionHeaderComment() { … } void AsmPrinter::emitFunctionPrefix(ArrayRef<const Constant *> Prefix) { … } /// EmitFunctionHeader - This method emits the header for the current /// function. void AsmPrinter::emitFunctionHeader() { … } /// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the /// function. This can be overridden by targets as required to do custom stuff. void AsmPrinter::emitFunctionEntryLabel() { … } /// emitComments - Pretty-print comments for instructions. static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) { … } /// emitImplicitDef - This method emits the specified machine instruction /// that is an implicit def. void AsmPrinter::emitImplicitDef(const MachineInstr *MI) const { … } static void emitKill(const MachineInstr *MI, AsmPrinter &AP) { … } static void emitFakeUse(const MachineInstr *MI, AsmPrinter &AP) { … } /// emitDebugValueComment - This method handles the target-independent form /// of DBG_VALUE, returning true if it was able to do so. A false return /// means the target will need to handle MI in EmitInstruction. static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) { … } /// This method handles the target-independent form of DBG_LABEL, returning /// true if it was able to do so. A false return means the target will need /// to handle MI in EmitInstruction. static bool emitDebugLabelComment(const MachineInstr *MI, AsmPrinter &AP) { … } AsmPrinter::CFISection AsmPrinter::getFunctionCFISectionType(const Function &F) const { … } AsmPrinter::CFISection AsmPrinter::getFunctionCFISectionType(const MachineFunction &MF) const { … } bool AsmPrinter::needsSEHMoves() { … } bool AsmPrinter::usesCFIWithoutEH() const { … } void AsmPrinter::emitCFIInstruction(const MachineInstr &MI) { … } void AsmPrinter::emitFrameAlloc(const MachineInstr &MI) { … } /// Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section /// for a given basic block. This can be used to capture more precise profile /// information. static uint32_t getBBAddrMapMetadata(const MachineBasicBlock &MBB) { … } static llvm::object::BBAddrMap::Features getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges) { … } void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) { … } void AsmPrinter::emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol) { … } void AsmPrinter::emitKCFITypeId(const MachineFunction &MF) { … } void AsmPrinter::emitPseudoProbe(const MachineInstr &MI) { … } void AsmPrinter::emitStackSizeSection(const MachineFunction &MF) { … } void AsmPrinter::emitStackUsage(const MachineFunction &MF) { … } void AsmPrinter::emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD) { … } void AsmPrinter::emitPCSections(const MachineFunction &MF) { … } /// Returns true if function begin and end labels should be emitted. static bool needFuncLabels(const MachineFunction &MF, const AsmPrinter &Asm) { … } /// EmitFunctionBody - This method emits the body and trailer for a /// function. void AsmPrinter::emitFunctionBody() { … } /// Compute the number of Global Variables that uses a Constant. static unsigned getNumGlobalVariableUses(const Constant *C) { … } /// Only consider global GOT equivalents if at least one user is a /// cstexpr inside an initializer of another global variables. Also, don't /// handle cstexpr inside instructions. During global variable emission, /// candidates are skipped and are emitted later in case at least one cstexpr /// isn't replaced by a PC relative GOT entry access. static bool isGOTEquivalentCandidate(const GlobalVariable *GV, unsigned &NumGOTEquivUsers) { … } /// Unnamed constant global variables solely contaning a pointer to /// another globals variable is equivalent to a GOT table entry; it contains the /// the address of another symbol. Optimize it and replace accesses to these /// "GOT equivalents" by using the GOT entry for the final global instead. /// Compute GOT equivalent candidates among all global variables to avoid /// emitting them if possible later on, after it use is replaced by a GOT entry /// access. void AsmPrinter::computeGlobalGOTEquivs(Module &M) { … } /// Constant expressions using GOT equivalent globals may not be eligible /// for PC relative GOT entry conversion, in such cases we need to emit such /// globals we previously omitted in EmitGlobalVariable. void AsmPrinter::emitGlobalGOTEquivs() { … } void AsmPrinter::emitGlobalAlias(const Module &M, const GlobalAlias &GA) { … } void AsmPrinter::emitGlobalIFunc(Module &M, const GlobalIFunc &GI) { … } void AsmPrinter::emitRemarksSection(remarks::RemarkStreamer &RS) { … } bool AsmPrinter::doFinalization(Module &M) { … } MCSymbol *AsmPrinter::getMBBExceptionSym(const MachineBasicBlock &MBB) { … } void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { … } namespace { // Keep track the alignment, constpool entries per Section. struct SectionCPs { … }; } // end anonymous namespace /// EmitConstantPool - Print to the current output stream assembly /// representations of the constants in the constant pool MCP. This is /// used to print out constants which have been "spilled to memory" by /// the code generator. void AsmPrinter::emitConstantPool() { … } // Print assembly representations of the jump tables used by the current // function. void AsmPrinter::emitJumpTableInfo() { … } void AsmPrinter::emitJumpTableSizesSection(const MachineJumpTableInfo *MJTI, const Function &F) const { … } /// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the /// current stream. void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo *MJTI, const MachineBasicBlock *MBB, unsigned UID) const { … } /// EmitSpecialLLVMGlobal - Check to see if the specified global is a /// special global used by LLVM. If so, emit it and return true, otherwise /// do nothing and return false. bool AsmPrinter::emitSpecialLLVMGlobal(const GlobalVariable *GV) { … } /// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each /// global in the specified llvm.used list. void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) { … } void AsmPrinter::preprocessXXStructorList(const DataLayout &DL, const Constant *List, SmallVector<Structor, 8> &Structors) { … } /// EmitXXStructorList - Emit the ctor or dtor list taking into account the init /// priority. void AsmPrinter::emitXXStructorList(const DataLayout &DL, const Constant *List, bool IsCtor) { … } void AsmPrinter::emitModuleIdents(Module &M) { … } void AsmPrinter::emitModuleCommandLines(Module &M) { … } //===--------------------------------------------------------------------===// // Emission and print routines // /// Emit a byte directive and value. /// void AsmPrinter::emitInt8(int Value) const { … } /// Emit a short directive and value. void AsmPrinter::emitInt16(int Value) const { … } /// Emit a long directive and value. void AsmPrinter::emitInt32(int Value) const { … } /// EmitSLEB128 - emit the specified signed leb128 value. void AsmPrinter::emitSLEB128(int64_t Value, const char *Desc) const { … } void AsmPrinter::emitULEB128(uint64_t Value, const char *Desc, unsigned PadTo) const { … } /// Emit a long long directive and value. void AsmPrinter::emitInt64(uint64_t Value) const { … } /// Emit something like ".long Hi-Lo" where the size in bytes of the directive /// is specified by Size and Hi/Lo specify the labels. This implicitly uses /// .set if it avoids relocations. void AsmPrinter::emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const { … } /// Emit something like ".uleb128 Hi-Lo". void AsmPrinter::emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const { … } /// EmitLabelPlusOffset - Emit something like ".long Label+Offset" /// where the size in bytes of the directive is specified by Size and Label /// specifies the label. This implicitly uses .set if it is available. void AsmPrinter::emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative) const { … } //===----------------------------------------------------------------------===// // EmitAlignment - Emit an alignment directive to the specified power of // two boundary. If a global value is specified, and if that global has // an explicit alignment requested, it will override the alignment request // if required for correctness. void AsmPrinter::emitAlignment(Align Alignment, const GlobalObject *GV, unsigned MaxBytesToEmit) const { … } //===----------------------------------------------------------------------===// // Constant emission. //===----------------------------------------------------------------------===// const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) { … } static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C, AsmPrinter &AP, const Constant *BaseCV = nullptr, uint64_t Offset = 0, AsmPrinter::AliasMapTy *AliasList = nullptr); static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP); static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP); /// isRepeatedByteSequence - Determine whether the given value is /// composed of a repeated sequence of identical bytes and return the /// byte value. If it is not a repeated sequence, return -1. static int isRepeatedByteSequence(const ConstantDataSequential *V) { … } /// isRepeatedByteSequence - Determine whether the given value is /// composed of a repeated sequence of identical bytes and return the /// byte value. If it is not a repeated sequence, return -1. static int isRepeatedByteSequence(const Value *V, const DataLayout &DL) { … } static void emitGlobalAliasInline(AsmPrinter &AP, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList) { … } static void emitGlobalConstantDataSequential( const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList) { … } static void emitGlobalConstantArray(const DataLayout &DL, const ConstantArray *CA, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList) { … } static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP); static void emitGlobalConstantVector(const DataLayout &DL, const ConstantVector *CV, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList) { … } static void emitGlobalConstantStruct(const DataLayout &DL, const ConstantStruct *CS, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList) { … } static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) { … } static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) { … } static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) { … } /// Transform a not absolute MCExpr containing a reference to a GOT /// equivalent global, by a target specific GOT pc relative access to the /// final symbol. static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME, const Constant *BaseCst, uint64_t Offset) { … } static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList) { … } /// EmitGlobalConstant - Print a general LLVM constant to the .s file. void AsmPrinter::emitGlobalConstant(const DataLayout &DL, const Constant *CV, AliasMapTy *AliasList) { … } void AsmPrinter::emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { … } void AsmPrinter::printOffset(int64_t Offset, raw_ostream &OS) const { … } void AsmPrinter::emitNops(unsigned N) { … } //===----------------------------------------------------------------------===// // Symbol Lowering Routines. //===----------------------------------------------------------------------===// MCSymbol *AsmPrinter::createTempSymbol(const Twine &Name) const { … } MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const { … } MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const { … } const MCExpr *AsmPrinter::lowerBlockAddressConstant(const BlockAddress &BA) { … } /// GetCPISymbol - Return the symbol for the specified constant pool entry. MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { … } /// GetJTISymbol - Return the symbol for the specified jump table entry. MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { … } /// GetJTSetSymbol - Return the symbol for the specified jump table .set /// FIXME: privatize to AsmPrinter. MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { … } MCSymbol *AsmPrinter::getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const { … } /// Return the MCSymbol for the specified ExternalSymbol. MCSymbol *AsmPrinter::GetExternalSymbolSymbol(Twine Sym) const { … } /// PrintParentLoopComment - Print comments about parent loops of this one. static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber) { … } /// PrintChildLoopComment - Print comments about child loops within /// the loop for this basic block, with nesting. static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber) { … } /// emitBasicBlockLoopComments - Pretty-print comments for basic blocks. static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, const MachineLoopInfo *LI, const AsmPrinter &AP) { … } /// emitBasicBlockStart - This method prints the label for the specified /// MachineBasicBlock, an alignment (if present) and a comment describing /// it if appropriate. void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { … } void AsmPrinter::emitBasicBlockEnd(const MachineBasicBlock &MBB) { … } void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition) const { … } bool AsmPrinter::shouldEmitLabelForBasicBlock( const MachineBasicBlock &MBB) const { … } /// isBlockOnlyReachableByFallthough - Return true if the basic block has /// exactly one predecessor and the control transfer mechanism between /// the predecessor and this block is a fall-through. bool AsmPrinter:: isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { … } GCMetadataPrinter *AsmPrinter::getOrCreateGCPrinter(GCStrategy &S) { … } void AsmPrinter::emitStackMaps() { … } void AsmPrinter::addAsmPrinterHandler( std::unique_ptr<AsmPrinterHandler> Handler) { … } void AsmPrinter::addDebugHandler(std::unique_ptr<DebugHandlerBase> Handler) { … } /// Pin vtable to this file. AsmPrinterHandler::~AsmPrinterHandler() = default; void AsmPrinterHandler::markFunctionEnd() { … } // In the binary's "xray_instr_map" section, an array of these function entries // describes each instrumentation point. When XRay patches your code, the index // into this table will be given to your handler as a patch point identifier. void AsmPrinter::XRayFunctionEntry::emit(int Bytes, MCStreamer *Out) const { … } void AsmPrinter::emitXRayTable() { … } void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version) { … } void AsmPrinter::emitPatchableFunctionEntries() { … } uint16_t AsmPrinter::getDwarfVersion() const { … } void AsmPrinter::setDwarfVersion(uint16_t Version) { … } bool AsmPrinter::isDwarf64() const { … } unsigned int AsmPrinter::getDwarfOffsetByteSize() const { … } dwarf::FormParams AsmPrinter::getDwarfFormParams() const { … } unsigned int AsmPrinter::getUnitLengthFieldByteSize() const { … } std::tuple<const MCSymbol *, uint64_t, const MCSymbol *, codeview::JumpTableEntrySize> AsmPrinter::getCodeViewJumpTableInfo(int JTI, const MachineInstr *BranchInstr, const MCSymbol *BranchLabel) const { … }
Codebase Browser
llvm