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   std::unique_ptr<MCCodeEmitter> CodeEmitter;
33 
34   // This utility class tracks the length of a stackmap instruction's 'shadow'.
35   // It is used by the X86AsmPrinter to ensure that the stackmap shadow
36   // invariants (i.e. no other stackmaps, patchpoints, or control flow within
37   // the shadow) are met, while outputting a minimal number of NOPs for padding.
38   //
39   // To minimise the number of NOPs used, the shadow tracker counts the number
40   // of instruction bytes output since the last stackmap. Only if there are too
41   // few instruction bytes to cover the shadow are NOPs used for padding.
42   class StackMapShadowTracker {
43   public:
startFunction(MachineFunction & MF)44     void startFunction(MachineFunction &MF) {
45       this->MF = &MF;
46     }
47     void count(MCInst &Inst, const MCSubtargetInfo &STI,
48                MCCodeEmitter *CodeEmitter);
49 
50     // Called to signal the start of a shadow of RequiredSize bytes.
reset(unsigned RequiredSize)51     void reset(unsigned RequiredSize) {
52       RequiredShadowSize = RequiredSize;
53       CurrentShadowSize = 0;
54       InShadow = true;
55     }
56 
57     // Called before every stackmap/patchpoint, and at the end of basic blocks,
58     // to emit any necessary padding-NOPs.
59     void emitShadowPadding(MCStreamer &OutStreamer, const MCSubtargetInfo &STI);
60   private:
61     const MachineFunction *MF;
62     bool InShadow = false;
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 = 0, CurrentShadowSize = 0;
70   };
71 
72   StackMapShadowTracker SMShadowTracker;
73 
74   // This describes the kind of sled we're storing in the XRay table.
75   enum class SledKind : uint8_t {
76     FUNCTION_ENTER = 0,
77     FUNCTION_EXIT = 1,
78     TAIL_CALL = 2,
79   };
80 
81   // The table will contain these structs that point to the sled, the function
82   // containing the sled, and what kind of sled (and whether they should always
83   // be instrumented).
84   struct XRayFunctionEntry {
85     const MCSymbol *Sled;
86     const MCSymbol *Function;
87     SledKind Kind;
88     bool AlwaysInstrument;
89     const class Function *Fn;
90   };
91 
92   // All the sleds to be emitted.
93   std::vector<XRayFunctionEntry> Sleds;
94 
95   // All instructions emitted by the X86AsmPrinter should use this helper
96   // method.
97   //
98   // This helper function invokes the SMShadowTracker on each instruction before
99   // outputting it to the OutStream. This allows the shadow tracker to minimise
100   // the number of NOPs used for stackmap padding.
101   void EmitAndCountInstruction(MCInst &Inst);
102   void LowerSTACKMAP(const MachineInstr &MI);
103   void LowerPATCHPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
104   void LowerSTATEPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
105   void LowerFAULTING_LOAD_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
106   void LowerPATCHABLE_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
107 
108   void LowerTlsAddr(X86MCInstLower &MCInstLowering, const MachineInstr &MI);
109 
110   // XRay-specific lowering for X86.
111   void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI,
112                                      X86MCInstLower &MCIL);
113   void LowerPATCHABLE_RET(const MachineInstr &MI, X86MCInstLower &MCIL);
114   void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
115 
116   // Helper function that emits the XRay sleds we've collected for a particular
117   // function.
118   void EmitXRayTable();
119 
120   // Helper function to record a given XRay sled.
121   void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind);
122 public:
X86AsmPrinter(TargetMachine & TM,std::unique_ptr<MCStreamer> Streamer)123   explicit X86AsmPrinter(TargetMachine &TM,
124                          std::unique_ptr<MCStreamer> Streamer)
125       : AsmPrinter(TM, std::move(Streamer)), SM(*this), FM(*this) {}
126 
getPassName()127   const char *getPassName() const override {
128     return "X86 Assembly / Object Emitter";
129   }
130 
getSubtarget()131   const X86Subtarget &getSubtarget() const { return *Subtarget; }
132 
133   void EmitStartOfAsmFile(Module &M) override;
134 
135   void EmitEndOfAsmFile(Module &M) override;
136 
137   void EmitInstruction(const MachineInstr *MI) override;
138 
EmitBasicBlockEnd(const MachineBasicBlock & MBB)139   void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override {
140     SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
141   }
142 
143   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
144                        unsigned AsmVariant, const char *ExtraCode,
145                        raw_ostream &OS) override;
146   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
147                              unsigned AsmVariant, const char *ExtraCode,
148                              raw_ostream &OS) override;
149 
150   /// \brief Return the symbol for the specified constant pool entry.
151   MCSymbol *GetCPISymbol(unsigned CPID) const override;
152 
doInitialization(Module & M)153   bool doInitialization(Module &M) override {
154     SMShadowTracker.reset(0);
155     SM.reset();
156     return AsmPrinter::doInitialization(M);
157   }
158 
159   bool runOnMachineFunction(MachineFunction &F) override;
160 };
161 
162 } // end namespace llvm
163 
164 #endif
165