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