LLVM 17.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,
31 CodeGenOpt::Level OptLevel);
32
33/// This pass initializes a global base register for PIC on x86-32.
34FunctionPass *createX86GlobalBaseRegPass();
35
36/// This pass combines multiple accesses to local-dynamic TLS variables so that
37/// the TLS base address for the module is only fetched once per execution path
38/// through the function.
40
41/// This function returns a pass which converts floating-point register
42/// references and pseudo instructions into floating-point stack references and
43/// physical instructions.
45
46/// This pass inserts AVX vzeroupper instructions before each call to avoid
47/// transition penalty between functions encoded with AVX and SSE.
48FunctionPass *createX86IssueVZeroUpperPass();
49
50/// This pass inserts ENDBR instructions before indirect jump/call
51/// destinations as part of CET IBT mechanism.
53
54/// This pass inserts KCFI checks before indirect calls.
55FunctionPass *createX86KCFIPass();
56
57/// Return a pass that pads short functions with NOOPs.
58/// This will prevent a stall when returning on the Atom.
59FunctionPass *createX86PadShortFunctions();
60
61/// Return a pass that selectively replaces certain instructions (like add,
62/// sub, inc, dec, some shifts, and some multiplies) by equivalent LEA
63/// instructions, in order to eliminate execution delays in some processors.
64FunctionPass *createX86FixupLEAs();
65
66/// Return a pass that removes redundant LEA instructions and redundant address
67/// recalculations.
68FunctionPass *createX86OptimizeLEAs();
69
70/// Return a pass that transforms setcc + movzx pairs into xor + setcc.
71FunctionPass *createX86FixupSetCC();
72
73/// Return a pass that avoids creating store forward block issues in the hardware.
75
76/// Return a pass that lowers EFLAGS copy pseudo instructions.
77FunctionPass *createX86FlagsCopyLoweringPass();
78
79/// Return a pass that expands DynAlloca pseudo-instructions.
80FunctionPass *createX86DynAllocaExpander();
81
82/// Return a pass that config the tile registers.
83FunctionPass *createX86TileConfigPass();
84
85/// Return a pass that preconfig the tile registers before fast reg allocation.
86FunctionPass *createX86FastPreTileConfigPass();
87
88/// Return a pass that config the tile registers after fast reg allocation.
89FunctionPass *createX86FastTileConfigPass();
90
91/// Return a pass that insert pseudo tile config instruction.
92FunctionPass *createX86PreTileConfigPass();
93
94/// Return a pass that lower the tile copy instruction.
95FunctionPass *createX86LowerTileCopyPass();
96
97/// Return a pass that inserts int3 at the end of the function if it ends with a
98/// CALL instruction. The pass does the same for each funclet as well. This
99/// ensures that the open interval of function start and end PCs contains all
100/// return addresses for the benefit of the Windows x64 unwinder.
101FunctionPass *createX86AvoidTrailingCallPass();
102
103/// Return a pass that optimizes the code-size of x86 call sequences. This is
104/// done by replacing esp-relative movs with pushes.
105FunctionPass *createX86CallFrameOptimization();
106
107/// Return an IR pass that inserts EH registration stack objects and explicit
108/// EH state updates. This pass must run after EH preparation, which does
109/// Windows-specific but architecture-neutral preparation.
110FunctionPass *createX86WinEHStatePass();
111
112/// Return a Machine IR pass that expands X86-specific pseudo
113/// instructions into a sequence of actual instructions. This pass
114/// must run after prologue/epilogue insertion and before lowering
115/// the MachineInstr to MC.
116FunctionPass *createX86ExpandPseudoPass();
117
118/// This pass converts X86 cmov instructions into branch when profitable.
119FunctionPass *createX86CmovConverterPass();
120
121/// Return a Machine IR pass that selectively replaces
122/// certain byte and word instructions by equivalent 32 bit instructions,
123/// in order to eliminate partial register usage, false dependences on
124/// the upper portions of registers, and to save code size.
125FunctionPass *createX86FixupBWInsts();
126
127/// Return a Machine IR pass that reassigns instruction chains from one domain
128/// to another, when profitable.
130
131/// This pass replaces EVEX encoded of AVX-512 instructiosn by VEX
132/// encoding when possible in order to reduce code size.
134
135/// This pass creates the thunks for the retpoline feature.
137
138/// This pass replaces ret instructions with jmp's to __x86_return thunk.
140
141/// This pass ensures instructions featuring a memory operand
142/// have distinctive <LineNumber, Discriminator> (with respect to eachother)
144
145/// This pass applies profiling information to insert cache prefetches.
147
148/// This pass insert wait instruction after X87 instructions which could raise
149/// fp exceptions when strict-fp enabled.
151
152/// This pass optimizes arithmetic based on knowledge that is only used by
153/// a reduction sequence and is therefore safe to reassociate in interesting
154/// ways.
156
158 X86Subtarget &,
160
165
197
198namespace X86AS {
199enum : unsigned {
200 GS = 256,
201 FS = 257,
202 SS = 258,
205 PTR64 = 272
207} // End X86AS namespace
208
209} // End llvm namespace
210
211#endif
const char LLVMTargetMachineRef TM
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:308
Provides the logic to select generic machine instructions.
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
This class provides the information for the target register banks.
Level
Code generation optimization level.
Definition: CodeGen.h:57
@ SS
Definition: X86.h:202
@ PTR32_UPTR
Definition: X86.h:204
@ FS
Definition: X86.h:201
@ PTR64
Definition: X86.h:205
@ PTR32_SPTR
Definition: X86.h:203
@ GS
Definition: X86.h:200
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 * createX86ISelDag(X86TargetMachine &TM, CodeGenOpt::Level OptLevel)
This pass converts a legalized DAG into a X86-specific DAG, ready for instruction scheduling.
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 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,...
void initializeX86KCFIPass(PassRegistry &)
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 * createX86EvexToVexInsts()
This pass replaces EVEX encoded of AVX-512 instructiosn by VEX encoding when possible in order to red...
void initializeX86ExpandPseudoPass(PassRegistry &)
void initializeX86AvoidTrailingCallPassPass(PassRegistry &)
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...
void initializeEvexToVexInstPassPass(PassRegistry &)
void initializeX86LowerTileCopyPass(PassRegistry &)
void initializeX86OptimizeLEAPassPass(PassRegistry &)
void initializeX86PreAMXConfigPassPass(PassRegistry &)
FunctionPass * createX86KCFIPass()
This pass inserts KCFI checks before indirect calls.
Definition: X86KCFI.cpp:55
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 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 &)
FunctionPass * createX86OptimizeLEAs()
Return a pass that removes redundant LEA instructions and redundant address recalculations.
FunctionPass * createX86IndirectThunksPass()
This pass creates the thunks for the retpoline feature.
void initializeX86DAGToDAGISelPass(PassRegistry &)
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 &)