1//===-- X86CodeGenPassBuilder.cpp ---------------------------------*- 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/// \file
9/// This file contains X86 CodeGen pipeline builder.
10/// TODO: Port CodeGen passes to new pass manager.
11//===----------------------------------------------------------------------===//
12
13#include "X86.h"
14#include "X86AsmPrinter.h"
15#include "X86ISelDAGToDAG.h"
16#include "X86TargetMachine.h"
17
18#include "llvm/CodeGen/AtomicExpand.h"
19#include "llvm/CodeGen/EarlyIfConversion.h"
20#include "llvm/CodeGen/IndirectBrExpand.h"
21#include "llvm/CodeGen/InterleavedAccess.h"
22#include "llvm/CodeGen/JMCInstrumenter.h"
23#include "llvm/MC/MCStreamer.h"
24#include "llvm/Passes/CodeGenPassBuilder.h"
25#include "llvm/Passes/PassBuilder.h"
26#include "llvm/Support/CodeGen.h"
27#include "llvm/Transforms/CFGuard.h"
28
29using namespace llvm;
30
31extern cl::opt<bool> X86EnableMachineCombinerPass;
32
33namespace {
34
35class X86CodeGenPassBuilder
36 : public CodeGenPassBuilder<X86CodeGenPassBuilder, X86TargetMachine> {
37 using Base = CodeGenPassBuilder<X86CodeGenPassBuilder, X86TargetMachine>;
38
39public:
40 explicit X86CodeGenPassBuilder(X86TargetMachine &TM,
41 const CGPassBuilderOption &Opts,
42 PassInstrumentationCallbacks *PIC)
43 : CodeGenPassBuilder(TM, Opts, PIC) {}
44
45 void addIRPasses(PassManagerWrapper &PMW) const;
46 void addPreISel(PassManagerWrapper &PMW) const;
47 Error addInstSelector(PassManagerWrapper &PMW) const;
48 void addILPOpts(PassManagerWrapper &PMW) const;
49 void addMachineSSAOptimization(PassManagerWrapper &PMW) const;
50 void addPreRegAlloc(PassManagerWrapper &PMW) const;
51 // TODO(boomanaiden154): We need to add addPostFastRegAllocRewrite here once
52 // it is available to support AMX.
53 void addPostRegAlloc(PassManagerWrapper &PMW) const;
54 void addPreSched2(PassManagerWrapper &PMW) const;
55 void addPreEmitPass(PassManagerWrapper &PMW) const;
56 void addPreEmitPass2(PassManagerWrapper &PMW) const;
57 // TODO(boomanaiden154): We need to add addRegAssignAndRewriteOptimized here
58 // once it is available to support AMX.
59 void addAsmPrinterBegin(PassManagerWrapper &PMW,
60 CreateMCStreamer CreateStreamer) const;
61 void addAsmPrinter(PassManagerWrapper &PMW,
62 CreateMCStreamer CreateStreamer) const;
63 void addAsmPrinterEnd(PassManagerWrapper &PMW,
64 CreateMCStreamer CreateStreamer) const;
65};
66
67void X86CodeGenPassBuilder::addIRPasses(PassManagerWrapper &PMW) const {
68 addFunctionPass(Pass: AtomicExpandPass(TM), PMW);
69
70 // We add both pass anyway and when these two passes run, one will be a
71 // no-op based on the optimization level/attributes.
72 addFunctionPass(Pass: X86LowerAMXIntrinsicsPass(&TM), PMW);
73 addFunctionPass(Pass: X86LowerAMXTypePass(&TM), PMW);
74
75 Base::addIRPasses(PMW);
76
77 if (getOptLevel() != CodeGenOptLevel::None) {
78 addFunctionPass(Pass: InterleavedAccessPass(TM), PMW);
79 addFunctionPass(Pass: X86PartialReductionPass(&TM), PMW);
80 }
81
82 // Add passes that handle indirect branch removal and insertion of a retpoline
83 // thunk. These will be a no-op unless a function subtarget has the retpoline
84 // feature enabled.
85 addFunctionPass(Pass: IndirectBrExpandPass(TM), PMW);
86
87 // Add Control Flow Guard checks.
88 const Triple &TT = TM.getTargetTriple();
89 if (TT.isOSWindows())
90 addFunctionPass(Pass: CFGuardPass(TT.isX86_64() ? CFGuardPass::Mechanism::Dispatch
91 : CFGuardPass::Mechanism::Check),
92 PMW);
93
94 if (TM.Options.JMCInstrument) {
95 flushFPMsToMPM(PMW);
96 addModulePass(Pass: JMCInstrumenterPass(), PMW);
97 }
98}
99
100void X86CodeGenPassBuilder::addPreISel(PassManagerWrapper &PMW) const {
101 // Only add this pass for 32-bit x86 Windows.
102 const Triple &TT = TM.getTargetTriple();
103 if (TT.isOSWindows() && TT.isX86_32()) {
104 flushFPMsToMPM(PMW);
105 addModulePass(Pass: X86WinEHStatePass(), PMW);
106 }
107}
108
109Error X86CodeGenPassBuilder::addInstSelector(PassManagerWrapper &PMW) const {
110 addMachineFunctionPass(Pass: X86ISelDAGToDAGPass(TM), PMW);
111
112 // For ELF, cleanup any local-dynamic TLS accesses
113 if (TM.getTargetTriple().isOSBinFormatELF() &&
114 getOptLevel() != CodeGenOptLevel::None) {
115 addMachineFunctionPass(Pass: X86CleanupLocalDynamicTLSPass(), PMW);
116 }
117
118 addMachineFunctionPass(Pass: X86GlobalBaseRegPass(), PMW);
119 addMachineFunctionPass(Pass: X86ArgumentStackSlotPass(), PMW);
120 return Error::success();
121}
122
123void X86CodeGenPassBuilder::addILPOpts(PassManagerWrapper &PMW) const {
124 addMachineFunctionPass(Pass: EarlyIfConverterPass(), PMW);
125 if (X86EnableMachineCombinerPass) {
126 // TODO(boomanaiden154): Add the MachineCombinerPass here once it has been
127 // ported to the new pass manager.
128 }
129 addMachineFunctionPass(Pass: X86CmovConversionPass(), PMW);
130}
131
132void X86CodeGenPassBuilder::addMachineSSAOptimization(
133 PassManagerWrapper &PMW) const {
134 addMachineFunctionPass(Pass: X86DomainReassignmentPass(), PMW);
135 Base::addMachineSSAOptimization(PMW);
136}
137
138void X86CodeGenPassBuilder::addPreRegAlloc(PassManagerWrapper &PMW) const {
139 if (getOptLevel() != CodeGenOptLevel::None) {
140 addMachineFunctionPass(Pass: LiveRangeShrinkPass(), PMW);
141 addMachineFunctionPass(Pass: X86FixupSetCCPass(), PMW);
142 addMachineFunctionPass(Pass: X86CallFrameOptimizationPass(), PMW);
143 addMachineFunctionPass(Pass: X86AvoidStoreForwardingBlocksPass(), PMW);
144 }
145
146 addMachineFunctionPass(Pass: X86SuppressAPXForRelocationPass(), PMW);
147 addMachineFunctionPass(Pass: X86SpeculativeLoadHardeningPass(), PMW);
148 addMachineFunctionPass(Pass: X86FlagsCopyLoweringPass(), PMW);
149 addMachineFunctionPass(Pass: X86DynAllocaExpanderPass(), PMW);
150
151 if (getOptLevel() != CodeGenOptLevel::None)
152 addMachineFunctionPass(Pass: X86PreTileConfigPass(), PMW);
153 else
154 addMachineFunctionPass(Pass: X86FastPreTileConfigPass(), PMW);
155}
156
157void X86CodeGenPassBuilder::addPostRegAlloc(PassManagerWrapper &PMW) const {
158 addMachineFunctionPass(Pass: X86LowerTileCopyPass(), PMW);
159 addMachineFunctionPass(Pass: X86FPStackifierPass(), PMW);
160 // When -O0 is enabled, the Load Value Injection Hardening pass will fall back
161 // to using the Speculative Execution Side Effect Suppression pass for
162 // mitigation. This is to prevent slow downs due to
163 // analyses needed by the LVIHardening pass when compiling at -O0.
164 if (getOptLevel() != CodeGenOptLevel::None) {
165 addMachineFunctionPass(Pass: X86LoadValueInjectionLoadHardeningPass(), PMW);
166 }
167}
168
169void X86CodeGenPassBuilder::addPreSched2(PassManagerWrapper &PMW) const {
170 addMachineFunctionPass(Pass: X86ExpandPseudoPass(), PMW);
171 // TODO(boomanaiden154): Add KCFGPass here once it has been ported.
172}
173
174void X86CodeGenPassBuilder::addPreEmitPass(PassManagerWrapper &PMW) const {
175 if (getOptLevel() != CodeGenOptLevel::None) {
176 // TODO(boomanaiden154): Add X86ExecutionDomainFixPass here once it has
177 // been ported.
178 addMachineFunctionPass(Pass: BreakFalseDepsPass(), PMW);
179 }
180
181 addMachineFunctionPass(Pass: X86IndirectBranchTrackingPass(), PMW);
182 // TODO(boomanaiden154): Add X86IssueVZeroUpperPass here once it has been
183 // ported.
184
185 if (getOptLevel() != CodeGenOptLevel::None) {
186 addMachineFunctionPass(Pass: X86FixupBWInstsPass(), PMW);
187 // TODO(boomanaiden154): Add X86PadShortFunctionsPass here once it has been
188 // ported.
189 addMachineFunctionPass(Pass: X86FixupLEAsPass(), PMW);
190 addMachineFunctionPass(Pass: X86FixupInstTuningPass(), PMW);
191 addMachineFunctionPass(Pass: X86FixupVectorConstantsPass(), PMW);
192 }
193 addMachineFunctionPass(Pass: X86CompressEVEXPass(), PMW);
194 addMachineFunctionPass(Pass: X86InsertX87WaitPass(), PMW);
195}
196
197void X86CodeGenPassBuilder::addPreEmitPass2(PassManagerWrapper &PMW) const {
198 const Triple &TT = TM.getTargetTriple();
199 const MCAsmInfo *MAI = TM.getMCAsmInfo();
200
201 // The X86 Speculative Execution Pass must run after all control
202 // flow graph modifying passes. As a result it was listed to run right before
203 // the X86 Retpoline Thunks pass. The reason it must run after control flow
204 // graph modifications is that the model of LFENCE in LLVM has to be updated
205 // (FIXME: https://bugs.llvm.org/show_bug.cgi?id=45167). Currently the
206 // placement of this pass was hand checked to ensure that the subsequent
207 // passes don't move the code around the LFENCEs in a way that will hurt the
208 // correctness of this pass. This placement has been shown to work based on
209 // hand inspection of the codegen output.
210 addMachineFunctionPass(Pass: X86SpeculativeExecutionSideEffectSuppressionPass(),
211 PMW);
212 // TODO(boomanaiden154): Add X86IndirectThunksPass here
213 // once it has been ported.
214 addMachineFunctionPass(Pass: X86ReturnThunksPass(), PMW);
215
216 // Insert extra int3 instructions after trailing call instructions to avoid
217 // issues in the unwinder.
218 if (TT.isOSWindows() && TT.isX86_64())
219 addMachineFunctionPass(Pass: X86AvoidTrailingCallPass(), PMW);
220
221 // Verify basic block incoming and outgoing cfa offset and register values and
222 // correct CFA calculation rule where needed by inserting appropriate CFI
223 // instructions.
224 if (!TT.isOSDarwin() &&
225 (!TT.isOSWindows() ||
226 MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI)) {
227 // TODO(boomanaiden154): Add CFInstrInserterPass here when it has been
228 // ported.
229 }
230
231 if (TT.isOSWindows()) {
232 // Identify valid longjmp targets for Windows Control Flow Guard.
233 // TODO(boomanaiden154): Add CFGuardLongjmpPass here when it has been
234 // ported.
235 // Identify valid eh continuation targets for Windows EHCont Guard.
236 // TODO(boomanaiden154): Add EHContGuardTargetsPass when it has been
237 // ported.
238 }
239
240 addMachineFunctionPass(Pass: X86LoadValueInjectionRetHardeningPass(), PMW);
241
242 // Insert pseudo probe annotation for callsite profiling
243 // TODO(boomanaiden154): Add PseudoProberInserterPass here once it has been
244 // ported.
245
246 // KCFI indirect call checks are lowered to a bundle, and on Darwin platforms,
247 // also CALL_RVMARKER.
248 // TODO(boomanaiden154): Add UnpackMachineBundlesPass here once it has been
249 // ported.
250
251 // Analyzes and emits pseudos to support Win x64 Unwind V2. This pass must run
252 // after all real instructions have been added to the epilog.
253 if (TT.isOSWindows() && TT.isX86_64()) {
254 addMachineFunctionPass(Pass: X86WinEHUnwindV2Pass(), PMW);
255 }
256}
257
258void X86CodeGenPassBuilder::addAsmPrinterBegin(
259 PassManagerWrapper &PMW, CreateMCStreamer CreateStreamer) const {
260 addModulePass(Pass: X86AsmPrinterBeginPass(TM, CreateStreamer), PMW,
261 /*Force=*/true);
262}
263
264void X86CodeGenPassBuilder::addAsmPrinter(
265 PassManagerWrapper &PMW, CreateMCStreamer CreateStreamer) const {
266 addMachineFunctionPass(Pass: X86AsmPrinterPass(TM, CreateStreamer), PMW);
267}
268
269void X86CodeGenPassBuilder::addAsmPrinterEnd(
270 PassManagerWrapper &PMW, CreateMCStreamer CreateStreamer) const {
271 addModulePass(Pass: X86AsmPrinterEndPass(TM, CreateStreamer), PMW, /*Force=*/true);
272}
273
274} // namespace
275
276void X86TargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
277#define GET_PASS_REGISTRY "X86PassRegistry.def"
278#include "llvm/Passes/TargetPassRegistry.inc"
279 // TODO(boomanaiden154): Move this into the base CodeGenPassBuilder once all
280 // targets that currently implement it have a ported asm-printer pass.
281 if (PIC) {
282 PIC->addClassToPassName(ClassName: X86AsmPrinterBeginPass::name(),
283 PassName: "x86-asm-printer-begin");
284 PIC->addClassToPassName(ClassName: X86AsmPrinterPass::name(), PassName: "x86-asm-printer");
285 PIC->addClassToPassName(ClassName: X86AsmPrinterEndPass::name(),
286 PassName: "x86-asm-printer-end");
287 }
288}
289
290Error X86TargetMachine::buildCodeGenPipeline(
291 ModulePassManager &MPM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
292 CodeGenFileType FileType, const CGPassBuilderOption &Opt, MCContext &Ctx,
293 PassInstrumentationCallbacks *PIC) {
294 auto CGPB = X86CodeGenPassBuilder(*this, Opt, PIC);
295 return CGPB.buildPipeline(MPM, Out, DwoOut, FileType, Ctx);
296}
297