LLVM 19.0.0git
X86.h
Go to the documentation of this file.
1//===-- X86.h - Top-level interface for X86 representation ------*- 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// This file contains the entry points for global functions defined in the x86
10// target library, as used by the LLVM JIT.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_X86_X86_H
15#define LLVM_LIB_TARGET_X86_X86_H
16
18
19namespace llvm {
20
21class FunctionPass;
22class InstructionSelector;
23class PassRegistry;
24class X86RegisterBankInfo;
25class X86Subtarget;
26class X86TargetMachine;
27
28/// This pass converts a legalized DAG into a X86-specific DAG, ready for
29/// instruction scheduling.
30FunctionPass *createX86ISelDag(X86TargetMachine &TM, CodeGenOptLevel OptLevel);
31
32/// This pass initializes a global base register for PIC on x86-32.
33FunctionPass *createX86GlobalBaseRegPass();
34
35/// This pass combines multiple accesses to local-dynamic TLS variables so that
36/// the TLS base address for the module is only fetched once per execution path
37/// through the function.
39
40/// This function returns a pass which converts floating-point register
41/// references and pseudo instructions into floating-point stack references and
42/// physical instructions.
44
45/// This pass inserts AVX vzeroupper instructions before each call to avoid
46/// transition penalty between functions encoded with AVX and SSE.
47FunctionPass *createX86IssueVZeroUpperPass();
48
49/// This pass inserts ENDBR instructions before indirect jump/call
50/// destinations as part of CET IBT mechanism.
52
53/// Return a pass that pads short functions with NOOPs.
54/// This will prevent a stall when returning on the Atom.
55FunctionPass *createX86PadShortFunctions();
56
57/// Return a pass that selectively replaces certain instructions (like add,
58/// sub, inc, dec, some shifts, and some multiplies) by equivalent LEA
59/// instructions, in order to eliminate execution delays in some processors.
60FunctionPass *createX86FixupLEAs();
61
62/// Return a pass that replaces equivalent slower instructions with faster
63/// ones.
64FunctionPass *createX86FixupInstTuning();
65
66/// Return a pass that reduces the size of vector constant pool loads.
67FunctionPass *createX86FixupVectorConstants();
68
69/// Return a pass that removes redundant LEA instructions and redundant address
70/// recalculations.
71FunctionPass *createX86OptimizeLEAs();
72
73/// Return a pass that transforms setcc + movzx pairs into xor + setcc.
74FunctionPass *createX86FixupSetCC();
75
76/// Return a pass that avoids creating store forward block issues in the hardware.
78
79/// Return a pass that lowers EFLAGS copy pseudo instructions.
80FunctionPass *createX86FlagsCopyLoweringPass();
81
82/// Return a pass that expands DynAlloca pseudo-instructions.
83FunctionPass *createX86DynAllocaExpander();
84
85/// Return a pass that config the tile registers.
86FunctionPass *createX86TileConfigPass();
87
88/// Return a pass that preconfig the tile registers before fast reg allocation.
89FunctionPass *createX86FastPreTileConfigPass();
90
91/// Return a pass that config the tile registers after fast reg allocation.
92FunctionPass *createX86FastTileConfigPass();
93
94/// Return a pass that insert pseudo tile config instruction.
95FunctionPass *createX86PreTileConfigPass();
96
97/// Return a pass that lower the tile copy instruction.
98FunctionPass *createX86LowerTileCopyPass();
99
100/// Return a pass that inserts int3 at the end of the function if it ends with a
101/// CALL instruction. The pass does the same for each funclet as well. This
102/// ensures that the open interval of function start and end PCs contains all
103/// return addresses for the benefit of the Windows x64 unwinder.
104FunctionPass *createX86AvoidTrailingCallPass();
105
106/// Return a pass that optimizes the code-size of x86 call sequences. This is
107/// done by replacing esp-relative movs with pushes.
108FunctionPass *createX86CallFrameOptimization();
109
110/// Return an IR pass that inserts EH registration stack objects and explicit
111/// EH state updates. This pass must run after EH preparation, which does
112/// Windows-specific but architecture-neutral preparation.
113FunctionPass *createX86WinEHStatePass();
114
115/// Return a Machine IR pass that expands X86-specific pseudo
116/// instructions into a sequence of actual instructions. This pass
117/// must run after prologue/epilogue insertion and before lowering
118/// the MachineInstr to MC.
119FunctionPass *createX86ExpandPseudoPass();
120
121/// This pass converts X86 cmov instructions into branch when profitable.
122FunctionPass *createX86CmovConverterPass();
123
124/// Return a Machine IR pass that selectively replaces
125/// certain byte and word instructions by equivalent 32 bit instructions,
126/// in order to eliminate partial register usage, false dependences on
127/// the upper portions of registers, and to save code size.
128FunctionPass *createX86FixupBWInsts();
129
130/// Return a Machine IR pass that reassigns instruction chains from one domain
131/// to another, when profitable.
133
134/// This pass compress instructions from EVEX space to legacy/VEX/EVEX space when
135/// possible in order to reduce code size or facilitate HW decoding.
137
138/// This pass creates the thunks for the retpoline feature.
140
141/// This pass replaces ret instructions with jmp's to __x86_return thunk.
143
144/// This pass ensures instructions featuring a memory operand
145/// have distinctive <LineNumber, Discriminator> (with respect to eachother)
147
148/// This pass applies profiling information to insert cache prefetches.
150
151/// This pass insert wait instruction after X87 instructions which could raise
152/// fp exceptions when strict-fp enabled.
154
155/// This pass optimizes arithmetic based on knowledge that is only used by
156/// a reduction sequence and is therefore safe to reassociate in interesting
157/// ways.
159
161 X86Subtarget &,
163
169
202
203namespace X86AS {
204enum : unsigned {
205 GS = 256,
206 FS = 257,
207 SS = 258,
210 PTR64 = 272
212} // End X86AS namespace
213
214} // End llvm namespace
215
216#endif
const char LLVMTargetMachineRef TM
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:37
This class provides the information for the target register banks.
@ SS
Definition: X86.h:207
@ PTR32_UPTR
Definition: X86.h:209
@ FS
Definition: X86.h:206
@ PTR64
Definition: X86.h:210
@ PTR32_SPTR
Definition: X86.h:208
@ GS
Definition: X86.h:205
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createX86FloatingPointStackifierPass()
This function returns a pass which converts floating-point register references and pseudo instruction...
FunctionPass * createX86WinEHStatePass()
Return an IR pass that inserts EH registration stack objects and explicit EH state updates.
void initializeX86TileConfigPass(PassRegistry &)
void initializeX86PartialReductionPass(PassRegistry &)
void initializeX86CallFrameOptimizationPass(PassRegistry &)
void initializeFixupBWInstPassPass(PassRegistry &)
void initializeX86LoadValueInjectionRetHardeningPassPass(PassRegistry &)
FunctionPass * createX86LoadValueInjectionLoadHardeningPass()
FunctionPass * createX86IssueVZeroUpperPass()
This pass inserts AVX vzeroupper instructions before each call to avoid transition penalty between fu...
void initializeX86ArgumentStackSlotPassPass(PassRegistry &)
void initializeX86SpeculativeLoadHardeningPassPass(PassRegistry &)
void initializeWinEHStatePassPass(PassRegistry &)
FunctionPass * createX86InsertPrefetchPass()
This pass applies profiling information to insert cache prefetches.
FunctionPass * createX86GlobalBaseRegPass()
This pass initializes a global base register for PIC on x86-32.
FunctionPass * createX86FixupBWInsts()
Return a Machine IR pass that selectively replaces certain byte and word instructions by equivalent 3...
void initializeX86LowerAMXIntrinsicsLegacyPassPass(PassRegistry &)
FunctionPass * createX86DomainReassignmentPass()
Return a Machine IR pass that reassigns instruction chains from one domain to another,...
FunctionPass * createX86LoadValueInjectionRetHardeningPass()
FunctionPass * createX86SpeculativeExecutionSideEffectSuppression()
FunctionPass * createCleanupLocalDynamicTLSPass()
This pass combines multiple accesses to local-dynamic TLS variables so that the TLS base address for ...
FunctionPass * createX86FlagsCopyLoweringPass()
Return a pass that lowers EFLAGS copy pseudo instructions.
void initializeX86FastTileConfigPass(PassRegistry &)
InstructionSelector * createX86InstructionSelector(const X86TargetMachine &TM, X86Subtarget &, X86RegisterBankInfo &)
FunctionPass * createX86CompressEVEXPass()
This pass compress instructions from EVEX space to legacy/VEX/EVEX space when possible in order to re...
void initializeX86ExpandPseudoPass(PassRegistry &)
void initializeX86AvoidTrailingCallPassPass(PassRegistry &)
FunctionPass * createX86ArgumentStackSlotPass()
void initializeX86PreTileConfigPass(PassRegistry &)
FunctionPass * createX86CmovConverterPass()
This pass converts X86 cmov instructions into branch when profitable.
FunctionPass * createX86TileConfigPass()
Return a pass that config the tile registers.
FunctionPass * createX86PadShortFunctions()
Return a pass that pads short functions with NOOPs.
void initializeX86DomainReassignmentPass(PassRegistry &)
void initializeX86LoadValueInjectionLoadHardeningPassPass(PassRegistry &)
FunctionPass * createX86FastPreTileConfigPass()
Return a pass that preconfig the tile registers before fast reg allocation.
void initializeX86AvoidSFBPassPass(PassRegistry &)
FunctionPass * createX86LowerTileCopyPass()
Return a pass that lower the tile copy instruction.
void initializeX86FastPreTileConfigPass(PassRegistry &)
FunctionPass * createX86SpeculativeLoadHardeningPass()
FunctionPass * createX86FixupSetCC()
Return a pass that transforms setcc + movzx pairs into xor + setcc.
FunctionPass * createX86IndirectBranchTrackingPass()
This pass inserts ENDBR instructions before indirect jump/call destinations as part of CET IBT mechan...
FunctionPass * createX86InsertX87waitPass()
This pass insert wait instruction after X87 instructions which could raise fp exceptions when strict-...
void initializeX86FixupSetCCPassPass(PassRegistry &)
FunctionPass * createX86ExpandPseudoPass()
Return a Machine IR pass that expands X86-specific pseudo instructions into a sequence of actual inst...
FunctionPass * createX86FixupInstTuning()
Return a pass that replaces equivalent slower instructions with faster ones.
FunctionPass * createX86ISelDag(X86TargetMachine &TM, CodeGenOptLevel OptLevel)
This pass converts a legalized DAG into a X86-specific DAG, ready for instruction scheduling.
void initializeX86LowerTileCopyPass(PassRegistry &)
void initializeX86OptimizeLEAPassPass(PassRegistry &)
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
FunctionPass * createX86FastTileConfigPass()
Return a pass that config the tile registers after fast reg allocation.
FunctionPass * createX86PartialReductionPass()
This pass optimizes arithmetic based on knowledge that is only used by a reduction sequence and is th...
FunctionPass * createX86FixupLEAs()
Return a pass that selectively replaces certain instructions (like add, sub, inc, dec,...
void initializeX86FixupInstTuningPassPass(PassRegistry &)
void initializeX86LowerAMXTypeLegacyPassPass(PassRegistry &)
void initializeX86CmovConverterPassPass(PassRegistry &)
FunctionPass * createX86CallFrameOptimization()
Return a pass that optimizes the code-size of x86 call sequences.
void initializeX86FlagsCopyLoweringPassPass(PassRegistry &)
void initializeFPSPass(PassRegistry &)
FunctionPass * createX86AvoidTrailingCallPass()
Return a pass that inserts int3 at the end of the function if it ends with a CALL instruction.
FunctionPass * createX86DynAllocaExpander()
Return a pass that expands DynAlloca pseudo-instructions.
void initializeX86SpeculativeExecutionSideEffectSuppressionPass(PassRegistry &)
void initializeCompressEVEXPassPass(PassRegistry &)
FunctionPass * createX86OptimizeLEAs()
Return a pass that removes redundant LEA instructions and redundant address recalculations.
void initializeX86FixupVectorConstantsPassPass(PassRegistry &)
FunctionPass * createX86IndirectThunksPass()
This pass creates the thunks for the retpoline feature.
void initializeX86DAGToDAGISelPass(PassRegistry &)
FunctionPass * createX86FixupVectorConstants()
Return a pass that reduces the size of vector constant pool loads.
void initializeX86ExecutionDomainFixPass(PassRegistry &)
FunctionPass * createX86PreTileConfigPass()
Return a pass that insert pseudo tile config instruction.
FunctionPass * createX86ReturnThunksPass()
This pass replaces ret instructions with jmp's to __x86_return thunk.
FunctionPass * createX86AvoidStoreForwardingBlocks()
Return a pass that avoids creating store forward block issues in the hardware.
void initializeX86ReturnThunksPass(PassRegistry &)
FunctionPass * createX86DiscriminateMemOpsPass()
This pass ensures instructions featuring a memory operand have distinctive <LineNumber,...
void initializeFixupLEAPassPass(PassRegistry &)