1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/*========================== begin_copyright_notice ============================
Copyright (C) 2024-2025 Intel Corporation
SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/
#include "llvm/ADT/Triple.h"
#include "llvm/CodeGen/CommandFlags.h"
#include "llvm/Passes/PassBuilder.h"
#include "llvm/Passes/PassPlugin.h"
#include "llvm/Target/TargetOptions.h"
#include "vc/GenXCodeGen/GenXLowerAggrCopies.h"
#include "vc/GenXCodeGen/GenXVerify.h"
#include "vc/GenXOpts/GenXOptsNewPM.h"
#include "vc/Support/BackendConfig.h"
#include "vc/GenXCodeGen/GenXRegionCollapsing.h"
#include "vc/GenXCodeGen/GenXTarget.h"
#include "vc/GenXCodeGen/TargetMachine.h"
#include "GenXTargetMachine.h"
using namespace llvm;
namespace {
static TargetMachine *GetTargetMachine(Triple TheTriple, StringRef CPUStr,
StringRef FeaturesStr,
const TargetOptions &Options) {
std::string Error;
const Target *TheTarget =
TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
// Some modules don't specify a triple, and this is okay.
if (!TheTarget) {
llvm::errs() << Error << "\n";
return nullptr;
}
return TheTarget->createTargetMachine(
TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
Options, codegen::getExplicitRelocModel(),
codegen::getExplicitCodeModel(), CodeGenOpt::Default);
}
void registerPluginPasses(PassBuilder &PB) {
LLVMInitializeGenXTarget();
LLVMInitializeGenXTargetInfo();
PB.registerAnalysisRegistrationCallback([=](ModuleAnalysisManager &MAM) {
MAM.registerPass([&] { return CMABIAnalysisPass(); });
MAM.registerPass([&] { return GenXBackendConfigPass(); });
});
auto *BC = new GenXBackendConfig;
const TargetOptions Options;
auto TheTriple = Triple("genx64-unknown-unknown");
std::string Error = "";
std::string CPUStr = "";
std::string FeaturesStr = "";
llvm::TargetMachine *TM =
GetTargetMachine(TheTriple, CPUStr, FeaturesStr, Options);
auto *GTM = static_cast<GenXTargetMachine *>(TM);
#define ADD_PASS(NAME, CREATE_PASS) \
if (Name == NAME) { \
PM.addPass(CREATE_PASS); \
return true; \
}
PB.registerPipelineParsingCallback(
[=](StringRef Name, CGSCCPassManager &PM,
ArrayRef<PassBuilder::PipelineElement>) {
#define CGSCC_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
#include "GenXPassRegistry.h"
#undef CGSCC_PASS
return false;
});
PB.registerPipelineParsingCallback(
[=](StringRef Name, ModulePassManager &PM,
ArrayRef<PassBuilder::PipelineElement>) {
#define MODULE_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
#include "GenXPassRegistry.h"
#undef MODULE_PASS
return false;
});
PB.registerPipelineParsingCallback(
[=](StringRef Name, FunctionPassManager &PM,
ArrayRef<PassBuilder::PipelineElement>) {
#define FUNCTION_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
#include "GenXPassRegistry.h"
#undef FUNCTION_PASS
return false;
});
}
} // namespace
#ifdef __GNUC__
#define DLL_PUBLIC __attribute__((visibility("default")))
#else
#define DLL_PUBLIC __declspec(dllexport)
#endif
extern "C" {
PassPluginLibraryInfo DLL_PUBLIC getNewPMPluginInfo() {
return {LLVM_PLUGIN_API_VERSION, "NewPMPlugin", "v0.1", registerPluginPasses};
}
#if !(defined(_WIN64) || defined(_WIN32))
LLVM_ATTRIBUTE_WEAK DLL_PUBLIC PassPluginLibraryInfo llvmGetPassPluginInfo() {
return getNewPMPluginInfo();
}
#endif
}
|
