1//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//
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#include "clang/Basic/DiagnosticOptions.h"
10#include "clang/CodeGen/CodeGenAction.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/Driver.h"
13#include "clang/Driver/Tool.h"
14#include "clang/Frontend/CompilerInstance.h"
15#include "clang/Frontend/CompilerInvocation.h"
16#include "clang/Frontend/FrontendDiagnostic.h"
17#include "clang/Frontend/TextDiagnosticPrinter.h"
18#include "llvm/ADT/SmallString.h"
19#include "llvm/ExecutionEngine/ExecutionEngine.h"
20#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
21#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
22#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
23#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
24#include "llvm/ExecutionEngine/SectionMemoryManager.h"
25#include "llvm/IR/DataLayout.h"
26#include "llvm/IR/Mangler.h"
27#include "llvm/IR/Module.h"
28#include "llvm/Support/FileSystem.h"
29#include "llvm/Support/Host.h"
30#include "llvm/Support/ManagedStatic.h"
31#include "llvm/Support/Path.h"
32#include "llvm/Support/TargetSelect.h"
33#include "llvm/Support/raw_ostream.h"
34#include "llvm/Target/TargetMachine.h"
35
36using namespace clang;
37using namespace clang::driver;
38
39// This function isn't referenced outside its translation unit, but it
40// can't use the "static" keyword because its address is used for
41// GetMainExecutable (since some platforms don't support taking the
42// address of main, and some platforms can't implement GetMainExecutable
43// without being given the address of a function in the main executable).
44std::string GetExecutablePath(const char *Argv0, void *MainAddr) {
45 return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
46}
47
48namespace llvm {
49namespace orc {
50
51class SimpleJIT {
52private:
53 ExecutionSession ES;
54 std::unique_ptr<TargetMachine> TM;
55 const DataLayout DL;
56 MangleAndInterner Mangle{ES, DL};
57 JITDylib &MainJD{ES.createBareJITDylib("<main>")};
58 RTDyldObjectLinkingLayer ObjectLayer{ES, createMemMgr};
59 IRCompileLayer CompileLayer{ES, ObjectLayer,
60 std::make_unique<SimpleCompiler>(*TM)};
61
62 static std::unique_ptr<SectionMemoryManager> createMemMgr() {
63 return std::make_unique<SectionMemoryManager>();
64 }
65
66 SimpleJIT(
67 std::unique_ptr<TargetMachine> TM, DataLayout DL,
68 std::unique_ptr<DynamicLibrarySearchGenerator> ProcessSymbolsGenerator)
69 : TM(std::move(TM)), DL(std::move(DL)) {
70 llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
71 MainJD.addGenerator(std::move(ProcessSymbolsGenerator));
72 }
73
74public:
75 ~SimpleJIT() {
76 if (auto Err = ES.endSession())
77 ES.reportError(std::move(Err));
78 }
79
80 static Expected<std::unique_ptr<SimpleJIT>> Create() {
81 auto JTMB = JITTargetMachineBuilder::detectHost();
82 if (!JTMB)
83 return JTMB.takeError();
84
85 auto TM = JTMB->createTargetMachine();
86 if (!TM)
87 return TM.takeError();
88
89 auto DL = (*TM)->createDataLayout();
90
91 auto ProcessSymbolsGenerator =
92 DynamicLibrarySearchGenerator::GetForCurrentProcess(
93 DL.getGlobalPrefix());
94
95 if (!ProcessSymbolsGenerator)
96 return ProcessSymbolsGenerator.takeError();
97
98 return std::unique_ptr<SimpleJIT>(new SimpleJIT(
99 std::move(*TM), std::move(DL), std::move(*ProcessSymbolsGenerator)));
100 }
101
102 const TargetMachine &getTargetMachine() const { return *TM; }
103
104 Error addModule(ThreadSafeModule M) {
105 return CompileLayer.add(MainJD, std::move(M));
106 }
107
108 Expected<JITEvaluatedSymbol> findSymbol(const StringRef &Name) {
109 return ES.lookup({&MainJD}, Mangle(Name));
110 }
111
112 Expected<JITTargetAddress> getSymbolAddress(const StringRef &Name) {
113 auto Sym = findSymbol(Name);
114 if (!Sym)
115 return Sym.takeError();
116 return Sym->getAddress();
117 }
118};
119
120} // end namespace orc
121} // end namespace llvm
122
123llvm::ExitOnError ExitOnErr;
124
125int main(int argc, const char **argv) {
126 // This just needs to be some symbol in the binary; C++ doesn't
127 // allow taking the address of ::main however.
128 void *MainAddr = (void*) (intptr_t) GetExecutablePath;
129 std::string Path = GetExecutablePath(argv[0], MainAddr);
130 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
131 TextDiagnosticPrinter *DiagClient =
132 new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
133
134 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
135 DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
136
137 const std::string TripleStr = llvm::sys::getProcessTriple();
138 llvm::Triple T(TripleStr);
139
140 // Use ELF on Windows-32 and MingW for now.
141#ifndef CLANG_INTERPRETER_COFF_FORMAT
142 if (T.isOSBinFormatCOFF())
143 T.setObjectFormat(llvm::Triple::ELF);
144#endif
145
146 ExitOnErr.setBanner("clang interpreter");
147
148 Driver TheDriver(Path, T.str(), Diags);
149 TheDriver.setTitle("clang interpreter");
150 TheDriver.setCheckInputsExist(false);
151
152 // FIXME: This is a hack to try to force the driver to do something we can
153 // recognize. We need to extend the driver library to support this use model
154 // (basically, exactly one input, and the operation mode is hard wired).
155 SmallVector<const char *, 16> Args(argv, argv + argc);
156 Args.push_back("-fsyntax-only");
157 std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Args));
158 if (!C)
159 return 0;
160
161 // FIXME: This is copied from ASTUnit.cpp; simplify and eliminate.
162
163 // We expect to get back exactly one command job, if we didn't something
164 // failed. Extract that job from the compilation.
165 const driver::JobList &Jobs = C->getJobs();
166 if (Jobs.size() != 1 || !isa<driver::Command>(*Jobs.begin())) {
167 SmallString<256> Msg;
168 llvm::raw_svector_ostream OS(Msg);
169 Jobs.Print(OS, "; ", true);
170 Diags.Report(diag::err_fe_expected_compiler_job) << OS.str();
171 return 1;
172 }
173
174 const driver::Command &Cmd = cast<driver::Command>(*Jobs.begin());
175 if (llvm::StringRef(Cmd.getCreator().getName()) != "clang") {
176 Diags.Report(diag::err_fe_expected_clang_command);
177 return 1;
178 }
179
180 // Initialize a compiler invocation object from the clang (-cc1) arguments.
181 const llvm::opt::ArgStringList &CCArgs = Cmd.getArguments();
182 std::unique_ptr<CompilerInvocation> CI(new CompilerInvocation);
183 CompilerInvocation::CreateFromArgs(*CI, CCArgs, Diags);
184
185 // Show the invocation, with -v.
186 if (CI->getHeaderSearchOpts().Verbose) {
187 llvm::errs() << "clang invocation:\n";
188 Jobs.Print(llvm::errs(), "\n", true);
189 llvm::errs() << "\n";
190 }
191
192 // FIXME: This is copied from cc1_main.cpp; simplify and eliminate.
193
194 // Create a compiler instance to handle the actual work.
195 CompilerInstance Clang;
196 Clang.setInvocation(std::move(CI));
197
198 // Create the compilers actual diagnostics engine.
199 Clang.createDiagnostics();
200 if (!Clang.hasDiagnostics())
201 return 1;
202
203 // Infer the builtin include path if unspecified.
204 if (Clang.getHeaderSearchOpts().UseBuiltinIncludes &&
205 Clang.getHeaderSearchOpts().ResourceDir.empty())
206 Clang.getHeaderSearchOpts().ResourceDir =
207 CompilerInvocation::GetResourcesPath(argv[0], MainAddr);
208
209 // Create and execute the frontend to generate an LLVM bitcode module.
210 std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());
211 if (!Clang.ExecuteAction(*Act))
212 return 1;
213
214 llvm::InitializeNativeTarget();
215 llvm::InitializeNativeTargetAsmPrinter();
216
217 int Res = 255;
218 std::unique_ptr<llvm::LLVMContext> Ctx(Act->takeLLVMContext());
219 std::unique_ptr<llvm::Module> Module = Act->takeModule();
220
221 if (Module) {
222 auto J = ExitOnErr(llvm::orc::SimpleJIT::Create());
223
224 ExitOnErr(J->addModule(
225 llvm::orc::ThreadSafeModule(std::move(Module), std::move(Ctx))));
226 auto Main = (int (*)(...))ExitOnErr(J->getSymbolAddress("main"));
227 Res = Main();
228 }
229
230 // Shutdown.
231 llvm::llvm_shutdown();
232
233 return Res;
234}
235