LLVM  8.0.0svn
X86AsmPrinter.h
Go to the documentation of this file.
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"
15 #include "llvm/CodeGen/FaultMaps.h"
16 #include "llvm/CodeGen/StackMaps.h"
17 #include "llvm/MC/MCCodeEmitter.h"
19 
20 // Implemented in X86MCInstLower.cpp
21 namespace {
22  class X86MCInstLower;
23 }
24 
25 namespace llvm {
26 class MCStreamer;
27 class MCSymbol;
28 
30  const X86Subtarget *Subtarget;
31  StackMaps SM;
32  FaultMaps FM;
33  std::unique_ptr<MCCodeEmitter> CodeEmitter;
34  bool EmitFPOData = false;
35  bool NeedsRetpoline = false;
36 
37  // This utility class tracks the length of a stackmap instruction's 'shadow'.
38  // It is used by the X86AsmPrinter to ensure that the stackmap shadow
39  // invariants (i.e. no other stackmaps, patchpoints, or control flow within
40  // the shadow) are met, while outputting a minimal number of NOPs for padding.
41  //
42  // To minimise the number of NOPs used, the shadow tracker counts the number
43  // of instruction bytes output since the last stackmap. Only if there are too
44  // few instruction bytes to cover the shadow are NOPs used for padding.
45  class StackMapShadowTracker {
46  public:
47  void startFunction(MachineFunction &MF) {
48  this->MF = &MF;
49  }
50  void count(MCInst &Inst, const MCSubtargetInfo &STI,
51  MCCodeEmitter *CodeEmitter);
52 
53  // Called to signal the start of a shadow of RequiredSize bytes.
54  void reset(unsigned RequiredSize) {
55  RequiredShadowSize = RequiredSize;
56  CurrentShadowSize = 0;
57  InShadow = true;
58  }
59 
60  // Called before every stackmap/patchpoint, and at the end of basic blocks,
61  // to emit any necessary padding-NOPs.
62  void emitShadowPadding(MCStreamer &OutStreamer, const MCSubtargetInfo &STI);
63  private:
64  const MachineFunction *MF;
65  bool InShadow = false;
66 
67  // RequiredShadowSize holds the length of the shadow specified in the most
68  // recently encountered STACKMAP instruction.
69  // CurrentShadowSize counts the number of bytes encoded since the most
70  // recently encountered STACKMAP, stopping when that number is greater than
71  // or equal to RequiredShadowSize.
72  unsigned RequiredShadowSize = 0, CurrentShadowSize = 0;
73  };
74 
75  StackMapShadowTracker SMShadowTracker;
76 
77  // All instructions emitted by the X86AsmPrinter should use this helper
78  // method.
79  //
80  // This helper function invokes the SMShadowTracker on each instruction before
81  // outputting it to the OutStream. This allows the shadow tracker to minimise
82  // the number of NOPs used for stackmap padding.
83  void EmitAndCountInstruction(MCInst &Inst);
84  void LowerSTACKMAP(const MachineInstr &MI);
85  void LowerPATCHPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
86  void LowerSTATEPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
87  void LowerFAULTING_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
88  void LowerPATCHABLE_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
89 
90  void LowerTlsAddr(X86MCInstLower &MCInstLowering, const MachineInstr &MI);
91 
92  // XRay-specific lowering for X86.
93  void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI,
94  X86MCInstLower &MCIL);
95  void LowerPATCHABLE_RET(const MachineInstr &MI, X86MCInstLower &MCIL);
96  void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
97  void LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
98  void LowerPATCHABLE_TYPED_EVENT_CALL(const MachineInstr &MI,
99  X86MCInstLower &MCIL);
100 
101  void LowerFENTRY_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
102 
103  // Choose between emitting .seh_ directives and .cv_fpo_ directives.
104  void EmitSEHInstruction(const MachineInstr *MI);
105 
106 public:
107  X86AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
108 
109  StringRef getPassName() const override {
110  return "X86 Assembly Printer";
111  }
112 
113  const X86Subtarget &getSubtarget() const { return *Subtarget; }
114 
115  void EmitStartOfAsmFile(Module &M) override;
116 
117  void EmitEndOfAsmFile(Module &M) override;
118 
119  void EmitInstruction(const MachineInstr *MI) override;
120 
121  void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override {
122  AsmPrinter::EmitBasicBlockEnd(MBB);
123  SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
124  }
125 
126  bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
127  unsigned AsmVariant, const char *ExtraCode,
128  raw_ostream &OS) override;
129  bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
130  unsigned AsmVariant, const char *ExtraCode,
131  raw_ostream &OS) override;
132 
133  bool doInitialization(Module &M) override {
134  SMShadowTracker.reset(0);
135  SM.reset();
136  FM.reset();
137  return AsmPrinter::doInitialization(M);
138  }
139 
140  bool runOnMachineFunction(MachineFunction &F) override;
141  void EmitFunctionBodyStart() override;
142  void EmitFunctionBodyEnd() override;
143 };
144 
145 } // end namespace llvm
146 
147 #endif
This class represents lattice values for constants.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
F(f)
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
void reset()
Definition: FaultMaps.h:42
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:161
auto count(R &&Range, const E &Element) -> typename std::iterator_traits< decltype(adl_begin(Range))>::difference_type
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1242
Streaming machine code generation interface.
Definition: MCStreamer.h:188
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:22
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:79
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Representation of each machine instruction.
Definition: MachineInstr.h:64
void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override
Targets can override this to emit stuff at the end of a basic block.
Generic base class for all target subtargets.
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
Definition: Compiler.h:108
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:59
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
const X86Subtarget & getSubtarget() const