|
| 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 | +using namespace llvm; |
| 49 | + |
| 50 | +static cl::opt<RegAllocType> RegAlloc( |
| 51 | + "regalloc-npm", cl::desc("Register allocator to use for new pass manager"), |
| 52 | + cl::Hidden, cl::ValueOptional, cl::init(RegAllocType::Default), |
| 53 | + cl::values( |
| 54 | + clEnumValN(RegAllocType::Default, "default", |
| 55 | + "pick register allocator based on -O option"), |
| 56 | + clEnumValN(RegAllocType::Basic, "basic", "basic register allocator"), |
| 57 | + clEnumValN(RegAllocType::Fast, "fast", "fast register allocator"), |
| 58 | + clEnumValN(RegAllocType::Greedy, "greedy", "greedy register allocator"), |
| 59 | + clEnumValN(RegAllocType::PBQP, "pbqp", "PBQP register allocator"))); |
| 60 | + |
| 61 | +static cl::opt<bool> |
| 62 | + DebugPM("debug-pass-manager", cl::Hidden, |
| 63 | + cl::desc("Print pass management debugging information")); |
| 64 | + |
| 65 | +bool LLCDiagnosticHandler::handleDiagnostics(const DiagnosticInfo &DI) { |
| 66 | + if (DI.getKind() == llvm::DK_SrcMgr) { |
| 67 | + const auto &DISM = cast<DiagnosticInfoSrcMgr>(DI); |
| 68 | + const SMDiagnostic &SMD = DISM.getSMDiag(); |
| 69 | + |
| 70 | + if (SMD.getKind() == SourceMgr::DK_Error) |
| 71 | + *HasError = true; |
| 72 | + |
| 73 | + SMD.print(nullptr, errs()); |
| 74 | + |
| 75 | + // For testing purposes, we print the LocCookie here. |
| 76 | + if (DISM.isInlineAsmDiag() && DISM.getLocCookie()) |
| 77 | + WithColor::note() << "!srcloc = " << DISM.getLocCookie() << "\n"; |
| 78 | + |
| 79 | + return true; |
| 80 | + } |
| 81 | + |
| 82 | + if (DI.getSeverity() == DS_Error) |
| 83 | + *HasError = true; |
| 84 | + |
| 85 | + if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) |
| 86 | + if (!Remark->isEnabled()) |
| 87 | + return true; |
| 88 | + |
| 89 | + DiagnosticPrinterRawOStream DP(errs()); |
| 90 | + errs() << LLVMContext::getDiagnosticMessagePrefix(DI.getSeverity()) << ": "; |
| 91 | + DI.print(DP); |
| 92 | + errs() << "\n"; |
| 93 | + return true; |
| 94 | +} |
| 95 | + |
| 96 | +static llvm::ExitOnError ExitOnErr; |
| 97 | + |
| 98 | +static void RunPasses(bool BOS, ToolOutputFile *Out, Module *M, |
| 99 | + LLVMContext &Context, SmallString<0> &Buffer, |
| 100 | + ModulePassManager *MPM, ModuleAnalysisManager *MAM, |
| 101 | + MachineFunctionPassManager &MFPM, |
| 102 | + MachineFunctionAnalysisManager &MFAM) { |
| 103 | + assert(MAM && ""); |
| 104 | + assert(M && "invalid input module!"); |
| 105 | + |
| 106 | + // Before executing passes, print the final values of the LLVM options. |
| 107 | + cl::PrintOptionValues(); |
| 108 | + |
| 109 | + if (MPM) { |
| 110 | + assert(MAM); |
| 111 | + MPM->run(*M, *MAM); |
| 112 | + } |
| 113 | + |
| 114 | + ExitOnErr(MFPM.run(*M, MFAM)); |
| 115 | + |
| 116 | + auto HasError = |
| 117 | + ((const LLCDiagnosticHandler *)(Context.getDiagHandlerPtr()))->HasError; |
| 118 | + if (*HasError) |
| 119 | + exit(1); |
| 120 | + |
| 121 | + if (BOS) |
| 122 | + Out->os() << Buffer; |
| 123 | +} |
| 124 | + |
| 125 | +int llvm::compileModuleWithNewPM( |
| 126 | + StringRef Arg0, std::unique_ptr<Module> M, std::unique_ptr<MIRParser> MIR, |
| 127 | + std::unique_ptr<TargetMachine> Target, std::unique_ptr<ToolOutputFile> Out, |
| 128 | + std::unique_ptr<ToolOutputFile> DwoOut, LLVMContext &Context, |
| 129 | + const TargetLibraryInfoImpl &TLII, bool NoVerify, |
| 130 | + const std::vector<std::string> &RunPassNames, CodeGenFileType FileType) { |
| 131 | + |
| 132 | + if (!RunPassNames.empty() && TargetPassConfig::hasLimitedCodeGenPipeline()) { |
| 133 | + WithColor::warning(errs(), Arg0) |
| 134 | + << "run-pass cannot be used with " |
| 135 | + << TargetPassConfig::getLimitedCodeGenPipelineReason(" and ") << ".\n"; |
| 136 | + return 1; |
| 137 | + } |
| 138 | + |
| 139 | + LLVMTargetMachine &LLVMTM = static_cast<LLVMTargetMachine &>(*Target); |
| 140 | + |
| 141 | + { |
| 142 | + raw_pwrite_stream *OS = &Out->os(); |
| 143 | + |
| 144 | + // Manually do the buffering rather than using buffer_ostream, |
| 145 | + // so we can memcmp the contents in CompileTwice mode in future. |
| 146 | + SmallString<0> Buffer; |
| 147 | + std::unique_ptr<raw_svector_ostream> BOS; |
| 148 | + if ((codegen::getFileType() != CodeGenFileType::AssemblyFile && |
| 149 | + !Out->os().supportsSeeking())) { |
| 150 | + BOS = std::make_unique<raw_svector_ostream>(Buffer); |
| 151 | + OS = BOS.get(); |
| 152 | + } |
| 153 | + |
| 154 | + // Fetch options from TargetPassConfig |
| 155 | + CGPassBuilderOption Opt = getCGPassBuilderOption(); |
| 156 | + Opt.DisableVerify = NoVerify; |
| 157 | + Opt.DebugPM = DebugPM; |
| 158 | + Opt.RegAlloc = RegAlloc; |
| 159 | + |
| 160 | + PassInstrumentationCallbacks PIC; |
| 161 | + StandardInstrumentations SI(Context, Opt.DebugPM); |
| 162 | + SI.registerCallbacks(PIC); |
| 163 | + registerCodeGenCallback(PIC, LLVMTM); |
| 164 | + |
| 165 | + LoopAnalysisManager LAM; |
| 166 | + FunctionAnalysisManager FAM; |
| 167 | + CGSCCAnalysisManager CGAM; |
| 168 | + ModuleAnalysisManager MAM; |
| 169 | + PassBuilder PB(Target.get(), PipelineTuningOptions(), std::nullopt, &PIC); |
| 170 | + PB.registerModuleAnalyses(MAM); |
| 171 | + PB.registerCGSCCAnalyses(CGAM); |
| 172 | + PB.registerFunctionAnalyses(FAM); |
| 173 | + PB.registerLoopAnalyses(LAM); |
| 174 | + PB.crossRegisterProxies(LAM, FAM, CGAM, MAM); |
| 175 | + |
| 176 | + FAM.registerPass([&] { return TargetLibraryAnalysis(TLII); }); |
| 177 | + MAM.registerPass([&] { return MachineModuleAnalysis(&LLVMTM); }); |
| 178 | + |
| 179 | + MachineFunctionAnalysisManager MFAM(FAM, MAM); |
| 180 | + |
| 181 | + if (!RunPassNames.empty()) { |
| 182 | + // Construct a custom pass pipeline that starts after instruction |
| 183 | + // selection. |
| 184 | + |
| 185 | + if (!MIR) { |
| 186 | + WithColor::warning(errs(), Arg0) << "run-pass is for .mir file only.\n"; |
| 187 | + return 1; |
| 188 | + } |
| 189 | + |
| 190 | + MachineFunctionPassManager MFPM; |
| 191 | + ExitOnErr(LLVMTM.parseMIRPipeline(MFPM, llvm::join(RunPassNames, ","), |
| 192 | + Opt, MFAM, &PIC)); |
| 193 | + MFPM.addPass(PrintMIRPass(*OS)); |
| 194 | + MFPM.addPass(FreeMachineFunctionPass()); |
| 195 | + |
| 196 | + auto &MMI = MFAM.getResult<MachineModuleAnalysis>(*M); |
| 197 | + if (MIR->parseMachineFunctions(*M, MMI)) |
| 198 | + return 1; |
| 199 | + |
| 200 | + RunPasses(BOS.get(), Out.get(), M.get(), Context, Buffer, nullptr, |
| 201 | + nullptr, MFPM, MFAM); |
| 202 | + } else { |
| 203 | + ModulePassManager MPM; |
| 204 | + MachineFunctionPassManager MFPM; |
| 205 | + |
| 206 | + ExitOnErr(LLVMTM.buildCodeGenPipeline(MPM, MFPM, MFAM, *OS, |
| 207 | + DwoOut ? &DwoOut->os() : nullptr, |
| 208 | + FileType, Opt, &PIC)); |
| 209 | + |
| 210 | + // Add IR or MIR printing pass according the pass type. |
| 211 | + if (PIC.isStartStopInfoRegistered()) { |
| 212 | + auto &Info = PIC.getStartStopInfo(); |
| 213 | + if (!Info.willCompleteCodeGenPipeline()) { |
| 214 | + if (Info.isStopMachineFunctionPass()) |
| 215 | + MFPM.addPass(PrintMIRPass(*OS)); |
| 216 | + else |
| 217 | + MPM.addPass(PrintModulePass(*OS)); |
| 218 | + } |
| 219 | + } |
| 220 | + |
| 221 | + RunPasses(BOS.get(), Out.get(), M.get(), Context, Buffer, &MPM, &MAM, |
| 222 | + MFPM, MFAM); |
| 223 | + } |
| 224 | + } |
| 225 | + |
| 226 | + // Declare success. |
| 227 | + Out->keep(); |
| 228 | + if (DwoOut) |
| 229 | + DwoOut->keep(); |
| 230 | + |
| 231 | + return 0; |
| 232 | +} |
0 commit comments