1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * llvm C frontend for perf. Support dynamically compile C file
4 *
5 * Inspired by clang example code:
6 * http://llvm.org/svn/llvm-project/cfe/trunk/examples/clang-interpreter/main.cpp
7 *
8 * Copyright (C) 2016 Wang Nan <wangnan0@huawei.com>
9 * Copyright (C) 2016 Huawei Inc.
10 */
11
12 #include "clang/Basic/Version.h"
13 #include "clang/CodeGen/CodeGenAction.h"
14 #include "clang/Frontend/CompilerInvocation.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Frontend/TextDiagnosticPrinter.h"
17 #include "clang/Tooling/Tooling.h"
18 #include "llvm/IR/LegacyPassManager.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Option/Option.h"
21 #include "llvm/Support/FileSystem.h"
22 #include "llvm/Support/ManagedStatic.h"
23 #include "llvm/Support/TargetRegistry.h"
24 #include "llvm/Support/TargetSelect.h"
25 #include "llvm/Target/TargetMachine.h"
26 #include "llvm/Target/TargetOptions.h"
27 #include <memory>
28
29 #include "clang.h"
30 #include "clang-c.h"
31
32 namespace perf {
33
34 static std::unique_ptr<llvm::LLVMContext> LLVMCtx;
35
36 using namespace clang;
37
38 static CompilerInvocation *
createCompilerInvocation(llvm::opt::ArgStringList CFlags,StringRef & Path,DiagnosticsEngine & Diags)39 createCompilerInvocation(llvm::opt::ArgStringList CFlags, StringRef& Path,
40 DiagnosticsEngine& Diags)
41 {
42 llvm::opt::ArgStringList CCArgs {
43 "-cc1",
44 "-triple", "bpf-pc-linux",
45 "-fsyntax-only",
46 "-ferror-limit", "19",
47 "-fmessage-length", "127",
48 "-O2",
49 "-nostdsysteminc",
50 "-nobuiltininc",
51 "-vectorize-loops",
52 "-vectorize-slp",
53 "-Wno-unused-value",
54 "-Wno-pointer-sign",
55 "-x", "c"};
56
57 CCArgs.append(CFlags.begin(), CFlags.end());
58 CompilerInvocation *CI = tooling::newInvocation(&Diags, CCArgs);
59
60 FrontendOptions& Opts = CI->getFrontendOpts();
61 Opts.Inputs.clear();
62 Opts.Inputs.emplace_back(Path,
63 FrontendOptions::getInputKindForExtension("c"));
64 return CI;
65 }
66
67 static std::unique_ptr<llvm::Module>
getModuleFromSource(llvm::opt::ArgStringList CFlags,StringRef Path,IntrusiveRefCntPtr<vfs::FileSystem> VFS)68 getModuleFromSource(llvm::opt::ArgStringList CFlags,
69 StringRef Path, IntrusiveRefCntPtr<vfs::FileSystem> VFS)
70 {
71 CompilerInstance Clang;
72 Clang.createDiagnostics();
73
74 #if CLANG_VERSION_MAJOR < 9
75 Clang.setVirtualFileSystem(&*VFS);
76 #else
77 Clang.createFileManager(&*VFS);
78 #endif
79
80 #if CLANG_VERSION_MAJOR < 4
81 IntrusiveRefCntPtr<CompilerInvocation> CI =
82 createCompilerInvocation(std::move(CFlags), Path,
83 Clang.getDiagnostics());
84 Clang.setInvocation(&*CI);
85 #else
86 std::shared_ptr<CompilerInvocation> CI(
87 createCompilerInvocation(std::move(CFlags), Path,
88 Clang.getDiagnostics()));
89 Clang.setInvocation(CI);
90 #endif
91
92 std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction(&*LLVMCtx));
93 if (!Clang.ExecuteAction(*Act))
94 return std::unique_ptr<llvm::Module>(nullptr);
95
96 return Act->takeModule();
97 }
98
99 std::unique_ptr<llvm::Module>
getModuleFromSource(llvm::opt::ArgStringList CFlags,StringRef Name,StringRef Content)100 getModuleFromSource(llvm::opt::ArgStringList CFlags,
101 StringRef Name, StringRef Content)
102 {
103 using namespace vfs;
104
105 llvm::IntrusiveRefCntPtr<OverlayFileSystem> OverlayFS(
106 new OverlayFileSystem(getRealFileSystem()));
107 llvm::IntrusiveRefCntPtr<InMemoryFileSystem> MemFS(
108 new InMemoryFileSystem(true));
109
110 /*
111 * pushOverlay helps setting working dir for MemFS. Must call
112 * before addFile.
113 */
114 OverlayFS->pushOverlay(MemFS);
115 MemFS->addFile(Twine(Name), 0, llvm::MemoryBuffer::getMemBuffer(Content));
116
117 return getModuleFromSource(std::move(CFlags), Name, OverlayFS);
118 }
119
120 std::unique_ptr<llvm::Module>
getModuleFromSource(llvm::opt::ArgStringList CFlags,StringRef Path)121 getModuleFromSource(llvm::opt::ArgStringList CFlags, StringRef Path)
122 {
123 IntrusiveRefCntPtr<vfs::FileSystem> VFS(vfs::getRealFileSystem());
124 return getModuleFromSource(std::move(CFlags), Path, VFS);
125 }
126
127 std::unique_ptr<llvm::SmallVectorImpl<char>>
getBPFObjectFromModule(llvm::Module * Module)128 getBPFObjectFromModule(llvm::Module *Module)
129 {
130 using namespace llvm;
131
132 std::string TargetTriple("bpf-pc-linux");
133 std::string Error;
134 const Target* Target = TargetRegistry::lookupTarget(TargetTriple, Error);
135 if (!Target) {
136 llvm::errs() << Error;
137 return std::unique_ptr<llvm::SmallVectorImpl<char>>(nullptr);
138 }
139
140 llvm::TargetOptions Opt;
141 TargetMachine *TargetMachine =
142 Target->createTargetMachine(TargetTriple,
143 "generic", "",
144 Opt, Reloc::Static);
145
146 Module->setDataLayout(TargetMachine->createDataLayout());
147 Module->setTargetTriple(TargetTriple);
148
149 std::unique_ptr<SmallVectorImpl<char>> Buffer(new SmallVector<char, 0>());
150 raw_svector_ostream ostream(*Buffer);
151
152 legacy::PassManager PM;
153 bool NotAdded;
154 #if CLANG_VERSION_MAJOR < 7
155 NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream,
156 TargetMachine::CGFT_ObjectFile);
157 #else
158 NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream, nullptr,
159 TargetMachine::CGFT_ObjectFile);
160 #endif
161 if (NotAdded) {
162 llvm::errs() << "TargetMachine can't emit a file of this type\n";
163 return std::unique_ptr<llvm::SmallVectorImpl<char>>(nullptr);
164 }
165 PM.run(*Module);
166
167 return Buffer;
168 }
169
170 }
171
172 extern "C" {
perf_clang__init(void)173 void perf_clang__init(void)
174 {
175 perf::LLVMCtx.reset(new llvm::LLVMContext());
176 LLVMInitializeBPFTargetInfo();
177 LLVMInitializeBPFTarget();
178 LLVMInitializeBPFTargetMC();
179 LLVMInitializeBPFAsmPrinter();
180 }
181
perf_clang__cleanup(void)182 void perf_clang__cleanup(void)
183 {
184 perf::LLVMCtx.reset(nullptr);
185 llvm::llvm_shutdown();
186 }
187
perf_clang__compile_bpf(const char * filename,void ** p_obj_buf,size_t * p_obj_buf_sz)188 int perf_clang__compile_bpf(const char *filename,
189 void **p_obj_buf,
190 size_t *p_obj_buf_sz)
191 {
192 using namespace perf;
193
194 if (!p_obj_buf || !p_obj_buf_sz)
195 return -EINVAL;
196
197 llvm::opt::ArgStringList CFlags;
198 auto M = getModuleFromSource(std::move(CFlags), filename);
199 if (!M)
200 return -EINVAL;
201 auto O = getBPFObjectFromModule(&*M);
202 if (!O)
203 return -EINVAL;
204
205 size_t size = O->size_in_bytes();
206 void *buffer;
207
208 buffer = malloc(size);
209 if (!buffer)
210 return -ENOMEM;
211 memcpy(buffer, O->data(), size);
212 *p_obj_buf = buffer;
213 *p_obj_buf_sz = size;
214 return 0;
215 }
216 }
217