1//===- TargetPassRegistry.inc - Registry of passes --------------*- 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 is used as the registry of passes in registerPassBuilderCallbacks 10// Just put the following lines in the body of registerPassBuilderCallbacks: 11// #define GET_PASS_REGISTRY "<Target>PassRegistry.def" 12// #include "llvm/Passes/TargetPassRegistry.inc" 13// 14//===----------------------------------------------------------------------===// 15 16// NOTE: NO INCLUDE GUARD DESIRED! 17 18#ifdef GET_PASS_REGISTRY 19 20#if !__has_include(GET_PASS_REGISTRY) 21#error "must provide <Target>PassRegistry.def" 22#endif 23 24if (PopulateClassToPassNames) { 25 auto *PIC = PB.getPassInstrumentationCallbacks(); 26 27#define ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) \ 28 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 29#define ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) \ 30 PIC->addClassToPassName(CLASS, NAME); 31 32#define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 33 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 34#define MODULE_PASS(NAME, CREATE_PASS) \ 35 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 36#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 37 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) 38#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 39 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 40#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 41 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 42#define FUNCTION_PASS(NAME, CREATE_PASS) \ 43 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 44#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 45 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) 46#define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 47 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 48#define LOOP_PASS(NAME, CREATE_PASS) \ 49 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 50#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 51 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 52#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \ 53 ADD_CLASS_PASS_TO_PASS_NAME(NAME, CREATE_PASS) 54#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \ 55 PARAMS) \ 56 ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS(NAME, CLASS) 57#include GET_PASS_REGISTRY 58#undef MODULE_ANALYSIS 59#undef MODULE_PASS 60#undef MODULE_PASS_WITH_PARAMS 61#undef FUNCTION_ANALYSIS 62#undef FUNCTION_ALIAS_ANALYSIS 63#undef FUNCTION_PASS 64#undef FUNCTION_PASS_WITH_PARAMS 65#undef LOOP_ANALYSIS 66#undef LOOP_PASS 67#undef MACHINE_FUNCTION_ANALYSIS 68#undef MACHINE_FUNCTION_PASS 69#undef MACHINE_FUNCTION_PASS_WITH_PARAMS 70#undef ADD_CLASS_PASS_TO_PASS_NAME 71#undef ADD_CLASS_PASS_TO_PASS_NAME_WITH_PARAMS 72} 73 74#define ADD_PASS(NAME, CREATE_PASS) \ 75 if (Name == NAME) { \ 76 PM.addPass(CREATE_PASS); \ 77 return true; \ 78 } 79 80#define ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) \ 81 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \ 82 auto Params = PassBuilder::parsePassParameters(PARSER, Name, NAME); \ 83 if (!Params) { \ 84 errs() << NAME ": " << toString(Params.takeError()) << '\n'; \ 85 return false; \ 86 } \ 87 PM.addPass(CREATE_PASS(Params.get())); \ 88 return true; \ 89 } 90 91PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM, 92 ArrayRef<PassBuilder::PipelineElement>) { 93#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS) 94#include GET_PASS_REGISTRY 95#undef MODULE_PASS 96 return false; 97}); 98 99PB.registerPipelineParsingCallback([=](StringRef Name, ModulePassManager &PM, 100 ArrayRef<PassBuilder::PipelineElement>) { 101#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 102 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) 103#include GET_PASS_REGISTRY 104#undef MODULE_PASS_WITH_PARAMS 105 return false; 106}); 107 108PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM, 109 ArrayRef<PassBuilder::PipelineElement>) { 110#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS) 111#include GET_PASS_REGISTRY 112#undef FUNCTION_PASS 113 return false; 114}); 115 116PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM, 117 ArrayRef<PassBuilder::PipelineElement>) { 118#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 119 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) 120#include GET_PASS_REGISTRY 121#undef FUNCTION_PASS_WITH_PARAMS 122 return false; 123}); 124 125PB.registerPipelineParsingCallback([=](StringRef Name, LoopPassManager &PM, 126 ArrayRef<PassBuilder::PipelineElement>) { 127#define LOOP_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS) 128#include GET_PASS_REGISTRY 129 return false; 130}); 131 132PB.registerPipelineParsingCallback([=](StringRef Name, 133 MachineFunctionPassManager &PM, 134 ArrayRef<PassBuilder::PipelineElement>) { 135#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS) 136#include GET_PASS_REGISTRY 137 return false; 138}); 139 140PB.registerPipelineParsingCallback([=](StringRef Name, FunctionPassManager &PM, 141 ArrayRef<PassBuilder::PipelineElement>) { 142#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \ 143 PARAMS) \ 144 ADD_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER) 145#include GET_PASS_REGISTRY 146#undef MACHINE_FUNCTION_PASS_WITH_PARAMS 147 return false; 148}); 149 150#undef ADD_PASS 151#undef ADD_PASS_WITH_PARAMS 152 153PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &AM) { 154#define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 155 AM.registerPass([&] { return CREATE_PASS; }); 156#include GET_PASS_REGISTRY 157#undef MODULE_ANALYSIS 158}); 159 160PB.registerAnalysisRegistrationCallback([](FunctionAnalysisManager &AM) { 161#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 162 AM.registerPass([&] { return CREATE_PASS; }); 163#include GET_PASS_REGISTRY 164#undef FUNCTION_ANALYSIS 165}); 166 167PB.registerParseAACallback([](StringRef Name, AAManager &AM) { 168#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 169 if (Name == NAME) { \ 170 AM.registerFunctionAnalysis< \ 171 std::remove_reference_t<decltype(CREATE_PASS)>>(); \ 172 return true; \ 173 } 174#include GET_PASS_REGISTRY 175#undef FUNCTION_ALIAS_ANALYSIS 176 return false; 177}); 178 179PB.registerAnalysisRegistrationCallback([](LoopAnalysisManager &AM) { 180#define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 181 AM.registerPass([&] { return CREATE_PASS; }); 182#include GET_PASS_REGISTRY 183#undef LOOP_ANALYSIS 184}); 185 186PB.registerAnalysisRegistrationCallback([](MachineFunctionAnalysisManager &AM) { 187#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 188 AM.registerPass([&] { return CREATE_PASS; }); 189#include GET_PASS_REGISTRY 190#undef MACHINE_FUNCTION_ANALYSIS 191}); 192 193#undef GET_PASS_REGISTRY 194#endif // GET_PASS_REGISTRY 195