summaryrefslogtreecommitdiff
path: root/clang/examples/clang-interpreter
diff options
context:
space:
mode:
authorCarlo Zancanaro <carlo@pc-4w14-0.cs.usyd.edu.au>2012-10-15 17:10:06 +1100
committerCarlo Zancanaro <carlo@pc-4w14-0.cs.usyd.edu.au>2012-10-15 17:10:06 +1100
commitbe1de4be954c80875ad4108e0a33e8e131b2f2c0 (patch)
tree1fbbecf276bf7c7bdcbb4dd446099d6d90eaa516 /clang/examples/clang-interpreter
parentc4626a62754862d20b41e8a46a3574264ea80e6d (diff)
parentf1bd2e48c5324d3f7cda4090c87f8a5b6f463ce2 (diff)
Merge branch 'master' of ssh://bitbucket.org/czan/honours
Diffstat (limited to 'clang/examples/clang-interpreter')
-rw-r--r--clang/examples/clang-interpreter/CMakeLists.txt34
-rw-r--r--clang/examples/clang-interpreter/Makefile26
-rw-r--r--clang/examples/clang-interpreter/README.txt17
-rw-r--r--clang/examples/clang-interpreter/main.cpp156
4 files changed, 233 insertions, 0 deletions
diff --git a/clang/examples/clang-interpreter/CMakeLists.txt b/clang/examples/clang-interpreter/CMakeLists.txt
new file mode 100644
index 0000000..809e324
--- /dev/null
+++ b/clang/examples/clang-interpreter/CMakeLists.txt
@@ -0,0 +1,34 @@
+set(LLVM_USED_LIBS
+ clangFrontend
+ clangSerialization
+ clangDriver
+ clangCodeGen
+ clangSema
+ clangStaticAnalyzerFrontend
+ clangStaticAnalyzerCheckers
+ clangStaticAnalyzerCore
+ clangAnalysis
+ clangRewrite
+ clangAST
+ clangParse
+ clangLex
+ clangBasic
+ )
+
+set(LLVM_LINK_COMPONENTS
+ jit
+ interpreter
+ nativecodegen
+ asmparser
+ bitreader
+ bitwriter
+ codegen
+ ipo
+ linker
+ selectiondag
+ )
+
+add_clang_executable(clang-interpreter
+ main.cpp
+ )
+add_dependencies(clang-interpreter clang-headers)
diff --git a/clang/examples/clang-interpreter/Makefile b/clang/examples/clang-interpreter/Makefile
new file mode 100644
index 0000000..420a066
--- /dev/null
+++ b/clang/examples/clang-interpreter/Makefile
@@ -0,0 +1,26 @@
+##===- examples/clang-interpreter/Makefile -----------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+CLANG_LEVEL := ../..
+
+TOOLNAME = clang-interpreter
+NO_INSTALL = 1
+
+# No plugins, optimize startup time.
+TOOL_NO_EXPORTS = 1
+
+LINK_COMPONENTS := jit interpreter nativecodegen bitreader bitwriter ipo \
+ linker selectiondag asmparser instrumentation
+USEDLIBS = clangFrontend.a clangSerialization.a clangDriver.a clangCodeGen.a \
+ clangParse.a clangSema.a clangStaticAnalyzerFrontend.a \
+ clangStaticAnalyzerCheckers.a clangStaticAnalyzerCore.a \
+ clangAnalysis.a clangRewrite.a \
+ clangEdit.a clangAST.a clangLex.a clangBasic.a
+
+include $(CLANG_LEVEL)/Makefile
diff --git a/clang/examples/clang-interpreter/README.txt b/clang/examples/clang-interpreter/README.txt
new file mode 100644
index 0000000..7dd45fa
--- /dev/null
+++ b/clang/examples/clang-interpreter/README.txt
@@ -0,0 +1,17 @@
+This is an example of Clang based interpreter, for executing standalone C
+programs.
+
+It demonstrates the following features:
+ 1. Parsing standard compiler command line arguments using the Driver library.
+
+ 2. Constructing a Clang compiler instance, using the appropriate arguments
+ derived in step #1.
+
+ 3. Invoking the Clang compiler to lex, parse, syntax check, and then generate
+ LLVM code.
+
+ 4. Use the LLVM JIT functionality to execute the final module.
+
+The implementation has many limitations and is not designed to be a full fledged
+C interpreter. It is designed to demonstrate a simple but functional use of the
+Clang compiler libraries.
diff --git a/clang/examples/clang-interpreter/main.cpp b/clang/examples/clang-interpreter/main.cpp
new file mode 100644
index 0000000..c39468a
--- /dev/null
+++ b/clang/examples/clang-interpreter/main.cpp
@@ -0,0 +1,156 @@
+//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/CodeGen/CodeGenAction.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Frontend/CompilerInvocation.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/DiagnosticOptions.h"
+#include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+
+#include "llvm/Module.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ExecutionEngine/JIT.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/TargetSelect.h"
+using namespace clang;
+using namespace clang::driver;
+
+// This function isn't referenced outside its translation unit, but it
+// can't use the "static" keyword because its address is used for
+// GetMainExecutable (since some platforms don't support taking the
+// address of main, and some platforms can't implement GetMainExecutable
+// without being given the address of a function in the main executable).
+llvm::sys::Path GetExecutablePath(const char *Argv0) {
+ // This just needs to be some symbol in the binary; C++ doesn't
+ // allow taking the address of ::main however.
+ void *MainAddr = (void*) (intptr_t) GetExecutablePath;
+ return llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
+}
+
+static int Execute(llvm::Module *Mod, char * const *envp) {
+ llvm::InitializeNativeTarget();
+
+ std::string Error;
+ OwningPtr<llvm::ExecutionEngine> EE(
+ llvm::ExecutionEngine::createJIT(Mod, &Error));
+ if (!EE) {
+ llvm::errs() << "unable to make execution engine: " << Error << "\n";
+ return 255;
+ }
+
+ llvm::Function *EntryFn = Mod->getFunction("main");
+ if (!EntryFn) {
+ llvm::errs() << "'main' function not found in module.\n";
+ return 255;
+ }
+
+ // FIXME: Support passing arguments.
+ std::vector<std::string> Args;
+ Args.push_back(Mod->getModuleIdentifier());
+
+ return EE->runFunctionAsMain(EntryFn, Args, envp);
+}
+
+int main(int argc, const char **argv, char * const *envp) {
+ void *MainAddr = (void*) (intptr_t) GetExecutablePath;
+ llvm::sys::Path Path = GetExecutablePath(argv[0]);
+ TextDiagnosticPrinter *DiagClient =
+ new TextDiagnosticPrinter(llvm::errs(), DiagnosticOptions());
+
+ IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+ DiagnosticsEngine Diags(DiagID, DiagClient);
+ Driver TheDriver(Path.str(), llvm::sys::getDefaultTargetTriple(),
+ "a.out", /*IsProduction=*/false, Diags);
+ TheDriver.setTitle("clang interpreter");
+
+ // FIXME: This is a hack to try to force the driver to do something we can
+ // recognize. We need to extend the driver library to support this use model
+ // (basically, exactly one input, and the operation mode is hard wired).
+ llvm::SmallVector<const char *, 16> Args(argv, argv + argc);
+ Args.push_back("-fsyntax-only");
+ OwningPtr<Compilation> C(TheDriver.BuildCompilation(Args));
+ if (!C)
+ return 0;
+
+ // FIXME: This is copied from ASTUnit.cpp; simplify and eliminate.
+
+ // We expect to get back exactly one command job, if we didn't something
+ // failed. Extract that job from the compilation.
+ const driver::JobList &Jobs = C->getJobs();
+ if (Jobs.size() != 1 || !isa<driver::Command>(*Jobs.begin())) {
+ SmallString<256> Msg;
+ llvm::raw_svector_ostream OS(Msg);
+ C->PrintJob(OS, C->getJobs(), "; ", true);
+ Diags.Report(diag::err_fe_expected_compiler_job) << OS.str();
+ return 1;
+ }
+
+ const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin());
+ if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") {
+ Diags.Report(diag::err_fe_expected_clang_command);
+ return 1;
+ }
+
+ // Initialize a compiler invocation object from the clang (-cc1) arguments.
+ const driver::ArgStringList &CCArgs = Cmd->getArguments();
+ OwningPtr<CompilerInvocation> CI(new CompilerInvocation);
+ CompilerInvocation::CreateFromArgs(*CI,
+ const_cast<const char **>(CCArgs.data()),
+ const_cast<const char **>(CCArgs.data()) +
+ CCArgs.size(),
+ Diags);
+
+ // Show the invocation, with -v.
+ if (CI->getHeaderSearchOpts().Verbose) {
+ llvm::errs() << "clang invocation:\n";
+ C->PrintJob(llvm::errs(), C->getJobs(), "\n", true);
+ llvm::errs() << "\n";
+ }
+
+ // FIXME: This is copied from cc1_main.cpp; simplify and eliminate.
+
+ // Create a compiler instance to handle the actual work.
+ CompilerInstance Clang;
+ Clang.setInvocation(CI.take());
+
+ // Create the compilers actual diagnostics engine.
+ Clang.createDiagnostics(int(CCArgs.size()),const_cast<char**>(CCArgs.data()));
+ if (!Clang.hasDiagnostics())
+ return 1;
+
+ // Infer the builtin include path if unspecified.
+ if (Clang.getHeaderSearchOpts().UseBuiltinIncludes &&
+ Clang.getHeaderSearchOpts().ResourceDir.empty())
+ Clang.getHeaderSearchOpts().ResourceDir =
+ CompilerInvocation::GetResourcesPath(argv[0], MainAddr);
+
+ // Create and execute the frontend to generate an LLVM bitcode module.
+ OwningPtr<CodeGenAction> Act(new EmitLLVMOnlyAction());
+ if (!Clang.ExecuteAction(*Act))
+ return 1;
+
+ int Res = 255;
+ if (llvm::Module *Module = Act->takeModule())
+ Res = Execute(Module, envp);
+
+ // Shutdown.
+
+ llvm::llvm_shutdown();
+
+ return Res;
+}