1 //===-- X86AsmPrinter.h - X86 implementation of AsmPrinter ------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLVM_LIB_TARGET_X86_X86ASMPRINTER_H 11 #define LLVM_LIB_TARGET_X86_X86ASMPRINTER_H 12 13 #include "X86Subtarget.h" 14 #include "llvm/CodeGen/AsmPrinter.h" 15 #include "llvm/CodeGen/FaultMaps.h" 16 #include "llvm/CodeGen/StackMaps.h" 17 #include "llvm/Target/TargetMachine.h" 18 19 // Implemented in X86MCInstLower.cpp 20 namespace { 21 class X86MCInstLower; 22 } 23 24 namespace llvm { 25 class MCStreamer; 26 class MCSymbol; 27 28 class LLVM_LIBRARY_VISIBILITY X86AsmPrinter : public AsmPrinter { 29 const X86Subtarget *Subtarget; 30 StackMaps SM; 31 FaultMaps FM; 32 33 // This utility class tracks the length of a stackmap instruction's 'shadow'. 34 // It is used by the X86AsmPrinter to ensure that the stackmap shadow 35 // invariants (i.e. no other stackmaps, patchpoints, or control flow within 36 // the shadow) are met, while outputting a minimal number of NOPs for padding. 37 // 38 // To minimise the number of NOPs used, the shadow tracker counts the number 39 // of instruction bytes output since the last stackmap. Only if there are too 40 // few instruction bytes to cover the shadow are NOPs used for padding. 41 class StackMapShadowTracker { 42 public: 43 StackMapShadowTracker(TargetMachine &TM); 44 ~StackMapShadowTracker(); 45 void startFunction(MachineFunction &MF); 46 void count(MCInst &Inst, const MCSubtargetInfo &STI); 47 48 // Called to signal the start of a shadow of RequiredSize bytes. reset(unsigned RequiredSize)49 void reset(unsigned RequiredSize) { 50 RequiredShadowSize = RequiredSize; 51 CurrentShadowSize = 0; 52 InShadow = true; 53 } 54 55 // Called before every stackmap/patchpoint, and at the end of basic blocks, 56 // to emit any necessary padding-NOPs. 57 void emitShadowPadding(MCStreamer &OutStreamer, const MCSubtargetInfo &STI); 58 private: 59 TargetMachine &TM; 60 const MachineFunction *MF; 61 std::unique_ptr<MCCodeEmitter> CodeEmitter; 62 bool InShadow; 63 64 // RequiredShadowSize holds the length of the shadow specified in the most 65 // recently encountered STACKMAP instruction. 66 // CurrentShadowSize counts the number of bytes encoded since the most 67 // recently encountered STACKMAP, stopping when that number is greater than 68 // or equal to RequiredShadowSize. 69 unsigned RequiredShadowSize, CurrentShadowSize; 70 }; 71 72 StackMapShadowTracker SMShadowTracker; 73 74 // All instructions emitted by the X86AsmPrinter should use this helper 75 // method. 76 // 77 // This helper function invokes the SMShadowTracker on each instruction before 78 // outputting it to the OutStream. This allows the shadow tracker to minimise 79 // the number of NOPs used for stackmap padding. 80 void EmitAndCountInstruction(MCInst &Inst); 81 void LowerSTACKMAP(const MachineInstr &MI); 82 void LowerPATCHPOINT(const MachineInstr &MI, X86MCInstLower &MCIL); 83 void LowerSTATEPOINT(const MachineInstr &MI, X86MCInstLower &MCIL); 84 void LowerFAULTING_LOAD_OP(const MachineInstr &MI, X86MCInstLower &MCIL); 85 86 void LowerTlsAddr(X86MCInstLower &MCInstLowering, const MachineInstr &MI); 87 88 public: X86AsmPrinter(TargetMachine & TM,std::unique_ptr<MCStreamer> Streamer)89 explicit X86AsmPrinter(TargetMachine &TM, 90 std::unique_ptr<MCStreamer> Streamer) 91 : AsmPrinter(TM, std::move(Streamer)), SM(*this), FM(*this), 92 SMShadowTracker(TM) {} 93 getPassName()94 const char *getPassName() const override { 95 return "X86 Assembly / Object Emitter"; 96 } 97 getSubtarget()98 const X86Subtarget &getSubtarget() const { return *Subtarget; } 99 100 void EmitStartOfAsmFile(Module &M) override; 101 102 void EmitEndOfAsmFile(Module &M) override; 103 104 void EmitInstruction(const MachineInstr *MI) override; 105 EmitBasicBlockEnd(const MachineBasicBlock & MBB)106 void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override { 107 SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo()); 108 } 109 110 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 111 unsigned AsmVariant, const char *ExtraCode, 112 raw_ostream &OS) override; 113 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 114 unsigned AsmVariant, const char *ExtraCode, 115 raw_ostream &OS) override; 116 117 /// \brief Return the symbol for the specified constant pool entry. 118 MCSymbol *GetCPISymbol(unsigned CPID) const override; 119 doInitialization(Module & M)120 bool doInitialization(Module &M) override { 121 SMShadowTracker.reset(0); 122 SM.reset(); 123 return AsmPrinter::doInitialization(M); 124 } 125 126 bool runOnMachineFunction(MachineFunction &F) override; 127 }; 128 129 } // end namespace llvm 130 131 #endif 132