LLVM  17.0.0git
X86AsmPrinter.h
Go to the documentation of this file.
1 //===-- X86AsmPrinter.h - X86 implementation of AsmPrinter ------*- 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 #ifndef LLVM_LIB_TARGET_X86_X86ASMPRINTER_H
10 #define LLVM_LIB_TARGET_X86_X86ASMPRINTER_H
11 
13 #include "llvm/CodeGen/FaultMaps.h"
14 #include "llvm/CodeGen/StackMaps.h"
15 
16 // Implemented in X86MCInstLower.cpp
17 namespace {
18  class X86MCInstLower;
19 }
20 
21 namespace llvm {
22 class MCCodeEmitter;
23 class MCStreamer;
24 class X86Subtarget;
25 class TargetMachine;
26 
28  const X86Subtarget *Subtarget = nullptr;
29  FaultMaps FM;
30  std::unique_ptr<MCCodeEmitter> CodeEmitter;
31  bool EmitFPOData = false;
32  bool ShouldEmitWeakSwiftAsyncExtendedFramePointerFlags = false;
33  bool IndCSPrefix = false;
34 
35  // This utility class tracks the length of a stackmap instruction's 'shadow'.
36  // It is used by the X86AsmPrinter to ensure that the stackmap shadow
37  // invariants (i.e. no other stackmaps, patchpoints, or control flow within
38  // the shadow) are met, while outputting a minimal number of NOPs for padding.
39  //
40  // To minimise the number of NOPs used, the shadow tracker counts the number
41  // of instruction bytes output since the last stackmap. Only if there are too
42  // few instruction bytes to cover the shadow are NOPs used for padding.
43  class StackMapShadowTracker {
44  public:
45  void startFunction(MachineFunction &MF) {
46  this->MF = &MF;
47  }
48  void count(MCInst &Inst, const MCSubtargetInfo &STI,
49  MCCodeEmitter *CodeEmitter);
50 
51  // Called to signal the start of a shadow of RequiredSize bytes.
52  void reset(unsigned RequiredSize) {
53  RequiredShadowSize = RequiredSize;
54  CurrentShadowSize = 0;
55  InShadow = true;
56  }
57 
58  // Called before every stackmap/patchpoint, and at the end of basic blocks,
59  // to emit any necessary padding-NOPs.
60  void emitShadowPadding(MCStreamer &OutStreamer, const MCSubtargetInfo &STI);
61  private:
62  const MachineFunction *MF = nullptr;
63  bool InShadow = false;
64 
65  // RequiredShadowSize holds the length of the shadow specified in the most
66  // recently encountered STACKMAP instruction.
67  // CurrentShadowSize counts the number of bytes encoded since the most
68  // recently encountered STACKMAP, stopping when that number is greater than
69  // or equal to RequiredShadowSize.
70  unsigned RequiredShadowSize = 0, CurrentShadowSize = 0;
71  };
72 
73  StackMapShadowTracker SMShadowTracker;
74 
75  // All instructions emitted by the X86AsmPrinter should use this helper
76  // method.
77  //
78  // This helper function invokes the SMShadowTracker on each instruction before
79  // outputting it to the OutStream. This allows the shadow tracker to minimise
80  // the number of NOPs used for stackmap padding.
81  void EmitAndCountInstruction(MCInst &Inst);
82  void LowerSTACKMAP(const MachineInstr &MI);
83  void LowerPATCHPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
84  void LowerSTATEPOINT(const MachineInstr &MI, X86MCInstLower &MCIL);
85  void LowerFAULTING_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
86  void LowerPATCHABLE_OP(const MachineInstr &MI, X86MCInstLower &MCIL);
87 
88  void LowerTlsAddr(X86MCInstLower &MCInstLowering, const MachineInstr &MI);
89 
90  // XRay-specific lowering for X86.
91  void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI,
92  X86MCInstLower &MCIL);
93  void LowerPATCHABLE_RET(const MachineInstr &MI, X86MCInstLower &MCIL);
94  void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
95  void LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
96  void LowerPATCHABLE_TYPED_EVENT_CALL(const MachineInstr &MI,
97  X86MCInstLower &MCIL);
98 
99  void LowerFENTRY_CALL(const MachineInstr &MI, X86MCInstLower &MCIL);
100 
101  // KCFI specific lowering for X86.
102  uint32_t MaskKCFIType(uint32_t Value);
103  void EmitKCFITypePadding(const MachineFunction &MF, bool HasType = true);
104  void LowerKCFI_CHECK(const MachineInstr &MI);
105 
106  // Address sanitizer specific lowering for X86.
107  void LowerASAN_CHECK_MEMACCESS(const MachineInstr &MI);
108 
109  // Choose between emitting .seh_ directives and .cv_fpo_ directives.
110  void EmitSEHInstruction(const MachineInstr *MI);
111 
112  void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &O) override;
113  void PrintOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
114  void PrintModifiedOperand(const MachineInstr *MI, unsigned OpNo,
115  raw_ostream &O, const char *Modifier);
116  void PrintPCRelImm(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
117  void PrintLeaMemReference(const MachineInstr *MI, unsigned OpNo,
118  raw_ostream &O, const char *Modifier);
119  void PrintMemReference(const MachineInstr *MI, unsigned OpNo, raw_ostream &O,
120  const char *Modifier);
121  void PrintIntelMemReference(const MachineInstr *MI, unsigned OpNo,
122  raw_ostream &O, const char *Modifier);
123 
124 public:
125  X86AsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer);
126 
127  StringRef getPassName() const override {
128  return "X86 Assembly Printer";
129  }
130 
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 
139  void emitBasicBlockEnd(const MachineBasicBlock &MBB) override;
140 
141  bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
142  const char *ExtraCode, raw_ostream &O) override;
143  bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
144  const char *ExtraCode, raw_ostream &O) override;
145 
146  bool doInitialization(Module &M) override {
147  SMShadowTracker.reset(0);
148  SM.reset();
149  FM.reset();
151  }
152 
153  bool runOnMachineFunction(MachineFunction &MF) override;
154  void emitFunctionBodyStart() override;
155  void emitFunctionBodyEnd() override;
156  void emitKCFITypeId(const MachineFunction &MF) override;
157 
159  return ShouldEmitWeakSwiftAsyncExtendedFramePointerFlags;
160  }
161 };
162 
163 } // end namespace llvm
164 
165 #endif
AsmPrinter.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:109
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::X86Subtarget
Definition: X86Subtarget.h:52
llvm::FaultMaps
Definition: FaultMaps.h:21
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::X86AsmPrinter::getPassName
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: X86AsmPrinter.h:127
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:212
llvm::X86AsmPrinter::shouldEmitWeakSwiftAsyncExtendedFramePointerFlags
bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const override
Definition: X86AsmPrinter.h:158
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::X86AsmPrinter
Definition: X86AsmPrinter.h:27
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:272
llvm::FaultMaps::reset
void reset()
Definition: FaultMaps.h:37
llvm::count
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Definition: STLExtras.h:1896
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MachineFunction
Definition: MachineFunction.h:258
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
uint32_t
LLVM_LIBRARY_VISIBILITY
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library,...
Definition: Compiler.h:126
llvm::X86AsmPrinter::doInitialization
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: X86AsmPrinter.h:146
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::MCCodeEmitter
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:21
StackMaps.h
llvm::AsmPrinter
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
llvm::X86AsmPrinter::getSubtarget
const X86Subtarget & getSubtarget() const
Definition: X86AsmPrinter.h:131
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
FaultMaps.h
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:76
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AsmPrinter::doInitialization
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:419