1 //===- NewPMDriver.cpp - Driver for llc using new PM ----------------------===//
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 ///
10 /// This file is just a split of the code that logically belongs in llc.cpp but
11 /// that includes the new pass manager headers.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "NewPMDriver.h"
16 #include "llvm/Analysis/CGSCCPassManager.h"
17 #include "llvm/Analysis/TargetLibraryInfo.h"
18 #include "llvm/CodeGen/CodeGenPassBuilder.h"
19 #include "llvm/CodeGen/CommandFlags.h"
20 #include "llvm/CodeGen/MIRParser/MIRParser.h"
21 #include "llvm/CodeGen/MIRPrinter.h"
22 #include "llvm/CodeGen/MachineModuleInfo.h"
23 #include "llvm/CodeGen/MachinePassManager.h"
24 #include "llvm/CodeGen/TargetPassConfig.h"
25 #include "llvm/IR/DiagnosticInfo.h"
26 #include "llvm/IR/DiagnosticPrinter.h"
27 #include "llvm/IR/IRPrintingPasses.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/Module.h"
30 #include "llvm/IR/PassManager.h"
31 #include "llvm/IR/Verifier.h"
32 #include "llvm/IRReader/IRReader.h"
33 #include "llvm/Passes/PassBuilder.h"
34 #include "llvm/Passes/StandardInstrumentations.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/Error.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/ToolOutputFile.h"
41 #include "llvm/Support/WithColor.h"
42 #include "llvm/Target/CGPassBuilderOption.h"
43 #include "llvm/Target/TargetMachine.h"
44 #include "llvm/Target/TargetOptions.h"
45 #include "llvm/Transforms/Scalar/LoopPassManager.h"
46 #include "llvm/Transforms/Utils/Cloning.h"
47 
48 namespace llvm {
49 extern cl::opt<bool> PrintPipelinePasses;
50 } // namespace llvm
51 
52 using namespace llvm;
53 
54 static cl::opt<std::string>
55     RegAlloc("regalloc-npm",
56              cl::desc("Register allocator to use for new pass manager"),
57              cl::Hidden, cl::init("default"));
58 
59 static cl::opt<bool>
60     DebugPM("debug-pass-manager", cl::Hidden,
61             cl::desc("Print pass management debugging information"));
62 
63 bool LLCDiagnosticHandler::handleDiagnostics(const DiagnosticInfo &DI) {
64   DiagnosticHandler::handleDiagnostics(DI);
65   if (DI.getKind() == llvm::DK_SrcMgr) {
66     const auto &DISM = cast<DiagnosticInfoSrcMgr>(DI);
67     const SMDiagnostic &SMD = DISM.getSMDiag();
68 
69     SMD.print(nullptr, errs());
70 
71     // For testing purposes, we print the LocCookie here.
72     if (DISM.isInlineAsmDiag() && DISM.getLocCookie())
73       WithColor::note() << "!srcloc = " << DISM.getLocCookie() << "\n";
74 
75     return true;
76   }
77 
78   if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI))
79     if (!Remark->isEnabled())
80       return true;
81 
82   DiagnosticPrinterRawOStream DP(errs());
83   errs() << LLVMContext::getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
84   DI.print(DP);
85   errs() << "\n";
86   return true;
87 }
88 
89 static llvm::ExitOnError ExitOnErr;
90 
91 static void RunPasses(bool BOS, ToolOutputFile *Out, Module *M,
92                       LLVMContext &Context, SmallString<0> &Buffer,
93                       ModulePassManager *MPM, ModuleAnalysisManager *MAM,
94                       MachineFunctionPassManager &MFPM,
95                       MachineFunctionAnalysisManager &MFAM) {
96   assert(M && "invalid input module!");
97 
98   // Before executing passes, print the final values of the LLVM options.
99   cl::PrintOptionValues();
100 
101   if (MPM) {
102     assert(MAM && "expect a ModuleAnalysisManager!");
103     MPM->run(*M, *MAM);
104   }
105 
106   ExitOnErr(MFPM.run(*M, MFAM));
107 
108   if (Context.getDiagHandlerPtr()->HasErrors)
109     exit(1);
110 
111   if (BOS)
112     Out->os() << Buffer;
113 }
114 
115 int llvm::compileModuleWithNewPM(
116     StringRef Arg0, std::unique_ptr<Module> M, std::unique_ptr<MIRParser> MIR,
117     std::unique_ptr<TargetMachine> Target, std::unique_ptr<ToolOutputFile> Out,
118     std::unique_ptr<ToolOutputFile> DwoOut, LLVMContext &Context,
119     const TargetLibraryInfoImpl &TLII, bool NoVerify, StringRef PassPipeline,
120     CodeGenFileType FileType) {
121 
122   if (!PassPipeline.empty() && TargetPassConfig::hasLimitedCodeGenPipeline()) {
123     WithColor::warning(errs(), Arg0)
124         << "--passes cannot be used with "
125         << TargetPassConfig::getLimitedCodeGenPipelineReason() << ".\n";
126     return 1;
127   }
128 
129   LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine &>(*Target);
130 
131   raw_pwrite_stream *OS = &Out->os();
132 
133   // Manually do the buffering rather than using buffer_ostream,
134   // so we can memcmp the contents in CompileTwice mode in future.
135   SmallString<0> Buffer;
136   std::unique_ptr<raw_svector_ostream> BOS;
137   if ((codegen::getFileType() != CodeGenFileType::AssemblyFile &&
138        !Out->os().supportsSeeking())) {
139     BOS = std::make_unique<raw_svector_ostream>(Buffer);
140     OS = BOS.get();
141   }
142 
143   // Fetch options from TargetPassConfig
144   CGPassBuilderOption Opt = getCGPassBuilderOption();
145   Opt.DisableVerify = NoVerify;
146   Opt.DebugPM = DebugPM;
147   Opt.RegAlloc = RegAlloc;
148 
149   PassInstrumentationCallbacks PIC;
150   StandardInstrumentations SI(Context, Opt.DebugPM);
151   SI.registerCallbacks(PIC);
152   registerCodeGenCallback(PIC, LLVMTM);
153 
154   LoopAnalysisManager LAM;
155   FunctionAnalysisManager FAM;
156   CGSCCAnalysisManager CGAM;
157   ModuleAnalysisManager MAM;
158   PassBuilder PB(Target.get(), PipelineTuningOptions(), std::nullopt, &PIC);
159   PB.registerModuleAnalyses(MAM);
160   PB.registerCGSCCAnalyses(CGAM);
161   PB.registerFunctionAnalyses(FAM);
162   PB.registerLoopAnalyses(LAM);
163   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
164 
165   FAM.registerPass([&] { return TargetLibraryAnalysis(TLII); });
166   MAM.registerPass([&] { return MachineModuleAnalysis(&LLVMTM); });
167 
168   MachineFunctionAnalysisManager MFAM(FAM, MAM);
169 
170   if (!PassPipeline.empty()) {
171     // Construct a custom pass pipeline that starts after instruction
172     // selection.
173 
174     if (!MIR) {
175       WithColor::warning(errs(), Arg0) << "-passes is for .mir file only.\n";
176       return 1;
177     }
178 
179     MachineFunctionPassManager MFPM;
180     ExitOnErr(PB.parsePassPipeline(MFPM, PassPipeline));
181     MFPM.addPass(PrintMIRPass(*OS));
182     MFPM.addPass(FreeMachineFunctionPass());
183 
184     auto &MMI = MFAM.getResult<MachineModuleAnalysis>(*M);
185     if (MIR->parseMachineFunctions(*M, MMI))
186       return 1;
187 
188     RunPasses(BOS.get(), Out.get(), M.get(), Context, Buffer, nullptr, nullptr,
189               MFPM, MFAM);
190   } else {
191     ModulePassManager MPM;
192     MachineFunctionPassManager MFPM;
193 
194     ExitOnErr(LLVMTM.buildCodeGenPipeline(MPM, MFPM, MFAM, *OS,
195                                           DwoOut ? &DwoOut->os() : nullptr,
196                                           FileType, Opt, &PIC));
197 
198     auto StartStopInfo = TargetPassConfig::getStartStopInfo(PIC);
199     assert(StartStopInfo && "Expect StartStopInfo!");
200     // Add IR or MIR printing pass according the pass type.
201 
202     if (auto StopPassName = StartStopInfo->StopPass; !StopPassName.empty()) {
203       MFPM.addPass(PrintMIRPass(*OS));
204       MFPM.addPass(FreeMachineFunctionPass());
205     }
206 
207     if (PrintPipelinePasses) {
208       std::string IRPipeline;
209       raw_string_ostream IRSOS(IRPipeline);
210       MPM.printPipeline(IRSOS, [&PIC](StringRef ClassName) {
211         auto PassName = PIC.getPassNameForClassName(ClassName);
212         return PassName.empty() ? ClassName : PassName;
213       });
214       outs() << "IR pipeline: " << IRPipeline << '\n';
215 
216       std::string MIRPipeline;
217       raw_string_ostream MIRSOS(MIRPipeline);
218       MFPM.printPipeline(MIRSOS, [&PIC](StringRef ClassName) {
219         auto PassName = PIC.getPassNameForClassName(ClassName);
220         return PassName.empty() ? ClassName : PassName;
221       });
222       outs() << "MIR pipeline: " << MIRPipeline << '\n';
223       return 0;
224     }
225 
226     RunPasses(BOS.get(), Out.get(), M.get(), Context, Buffer, &MPM, &MAM, MFPM,
227               MFAM);
228   }
229 
230   // Declare success.
231   Out->keep();
232   if (DwoOut)
233     DwoOut->keep();
234 
235   return 0;
236 }
237