diff --git a/docs/ClangPlugins.html b/docs/ClangPlugins.html
--- a/docs/ClangPlugins.html
+++ b/docs/ClangPlugins.html
@@ -16,65 +16,79 @@
<p>Clang Plugins make it possible to run extra user defined actions during
a compilation. This document will provide a basic walkthrough of how to write
and run a Clang Plugin.</p>
<!-- ======================================================================= -->
<h2 id="intro">Introduction</h2>
<!-- ======================================================================= -->
-<p>Clang Plugins run FrontendActions over code. See the
-<a href="RAVFrontendAction.html">FrontendAction tutorial</a> on how to write a
-FrontendAction using the RecursiveASTVisitor. In this tutorial, we'll
+<p>Clang Plugins run a set of callbacks over code. These callbacks are functions
+that the plugin exports that the compiler uses over the course of compiling
+code. These functions need not be implemented (except for clang_plugin_init). By
+use of these hooks, compilers can affect or observer the course of compilation
+by using several callbacks. The most important callback is the ASTConsumer
+callback, which allows plugins to interact with the abstract syntax tree of
+code. See the
+<a href="RAVFrontendAction.html#consumer">FrontendAction tutorial</a> for how to
+write an ASTConsumer using the RecursiveASTVisitor. In this tutorial, we'll
demonstrate how to write a simple clang plugin.
</p>
<!-- ======================================================================= -->
-<h2 id="pluginactions">Writing a PluginASTAction</h2>
+<h2 id="init">Arguments and initialization</h2>
<!-- ======================================================================= -->
-<p>The main difference from writing normal FrontendActions is that you can
-handle plugin command line options. The
-PluginASTAction base class declares a ParseArgs method which you have to
-implement in your plugin.
-</p>
+<p>The first function called when a plugin is loaded is clang_plugin_init. This
+function returns a boolean indicating whether or not the plugin can run on the
+code. As arguments, this function is given the arguments of the plugin as well
+as the version of clang being run. An example looks like this:</p>
<pre>
- bool ParseArgs(const CompilerInstance &CI,
- const std::vector<std::string>& args) {
- for (unsigned i = 0, e = args.size(); i != e; ++i) {
- if (args[i] == "-some-arg") {
- // Handle the command line argument.
+ bool clang_plugin_init(int argc, plugin::PluginArg *argv,
+ plugin::Version *version) {
+ // Check the version of clang
+ if (version->major != CLANG_VERSION_MAJOR ||
+ version->minor != CLANG_VERSION_MINOR)
+ return false;
+
+ for (int i = 0; i < argc; ++i) {
+ if (!strcmp(argv[i].name, "-some-arg")) {
+ // Handle the command line argument
}
}
return true;
}
</pre>
<!-- ======================================================================= -->
-<h2 id="registerplugin">Registering a plugin</h2>
+<h2 id="callbacks">Setting callbacks</h2>
<!-- ======================================================================= -->
-<p>A plugin is loaded from a dynamic library at runtime by the compiler. To register
-a plugin in a library, use FrontendPluginRegistry::Add:</p>
+<p>The most important plugin hook is the one that is called before each file is
+compiled: clang_plugin_begin_file. This allows plugins to add their own custom
+ASTConsumer (among other compiler hooks).</p>
<pre>
- static FrontendPluginRegistry::Add<MyPlugin> X("my-plugin-name", "my plugin description");
+ void clang_plugin_begin_file(llvm::StringRef fileName,
+ const CompilerInstance &CI, plugin::PluginFileCallbacks *callbacks) {
+ callbacks->astConsumer = new PrintFunctionsConsumer();
+ }
</pre>
<!-- ======================================================================= -->
<h2 id="example">Putting it all together</h2>
<!-- ======================================================================= -->
<p>Let's look at an example plugin that prints top-level function names.
This example is also checked into the clang repository; please also take a look
at the latest <a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/PrintFunctionNames.cpp?view=markup";>checked in version of PrintFunctionNames.cpp</a>.</p>
<pre>
-#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Basic/Plugin.h"
+#include "clang/Basic/Version.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/AST.h"
-#include "clang/Frontend/CompilerInstance.h"
#include "llvm/Support/raw_ostream.h"
using namespace clang;
namespace {
class PrintFunctionsConsumer : public ASTConsumer {
public:
virtual bool HandleTopLevelDecl(DeclGroupRef DG) {
@@ -83,85 +97,57 @@ public:
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
llvm::errs() << "top-level-decl: \"" << ND->getNameAsString() << "\"\n";
}
return true;
}
};
-class PrintFunctionNamesAction : public PluginASTAction {
-protected:
- ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) {
- return new PrintFunctionsConsumer();
- }
+bool clang_plugin_init(int argc, plugin::PluginArg *argv,
+ plugin::Version *version) {
+ // It is dangerous to use plugins with versions that it wasn't compiled for.
+ // This causes us to bail out before we can do things like crash clang.
+ if (version->major != CLANG_VERSION_MAJOR ||
+ version->minor != CLANG_VERSION_MINOR)
+ return false;
- bool ParseArgs(const CompilerInstance &CI,
- const std::vector<std::string>& args) {
- for (unsigned i = 0, e = args.size(); i != e; ++i) {
- llvm::errs() << "PrintFunctionNames arg = " << args[i] << "\n";
-
- // Example error handling.
- if (args[i] == "-an-error") {
- DiagnosticsEngine &D = CI.getDiagnostics();
- unsigned DiagID = D.getCustomDiagID(
- DiagnosticsEngine::Error, "invalid argument '" + args[i] + "'");
- D.Report(DiagID);
- return false;
- }
- }
- if (args.size() && args[0] == "help")
- PrintHelp(llvm::errs());
-
- return true;
- }
- void PrintHelp(llvm::raw_ostream& ros) {
- ros << "Help for PrintFunctionNames plugin goes here\n";
- }
-
-};
-
+ llvm::errs() << "Number of arguments: " << argc << '\n';
+ for (int i = 0; i < argc; ++i)
+ llvm::errs() << "Plugin argument: arg " << argv[i].name
+ << " is set to value " << argv[i].value << '\n';
+ return true;
}
-static FrontendPluginRegistry::Add<PrintFunctionNamesAction>
-X("print-fns", "print function names");
+void clang_plugin_begin_file(llvm::StringRef fileName,
+ const CompilerInstance &CI, plugin::PluginFileCallbacks *callbacks) {
+ llvm::errs() << "Found when compiling " << fileName << ":\n";
+ callbacks->astConsumer = new PrintFunctionsConsumer();
+}
</pre>
<!-- ======================================================================= -->
<h2 id="running">Running the plugin</h2>
<!-- ======================================================================= -->
-<p>To run a plugin, the dynamic library containing the plugin registry must be
-loaded via the -load command line option. This will load all plugins that are
-registered, and you can select the plugins to run by specifying the -plugin
-option. Additional parameters for the plugins can be passed with -plugin-arg-<plugin-name>.</p>
+<p>To run a plugin, you merely need to specify the plugin to be loaded using the
+-fplugin command line options. Additional parameters for the plugins can be passed with -fplugin-arg-<plugin-name>-<arg>=<value> or
+-fplugin-arg<plugin-name>-<arg>. These options work the same when both run
+with the normal driver and the cc1 process.</p>
-<p>Note that those options must reach clang's cc1 process. There are two
-ways to do so:</p>
-<ul>
-<li>
-Directly call the parsing process by using the -cc1 option; this has the
-downside of not configuring the default header search paths, so you'll need to
-specify the full system path configuration on the command line.
-</li>
-<li>
-Use clang as usual, but prefix all arguments to the cc1 process with -Xclang.
-</li>
-</ul>
<p>For example, to run the print-function-names plugin over a source file in clang,
first build the plugin, and then call clang with the plugin from the source tree:</p>
<pre>
$ export BD=/path/to/build/directory
$ (cd $BD && make PrintFunctionNames )
$ clang++ -D_GNU_SOURCE -D_DEBUG -D__STDC_CONSTANT_MACROS \
-D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D_GNU_SOURCE \
-I$BD/tools/clang/include -Itools/clang/include -I$BD/include -Iinclude \
tools/clang/tools/clang-check/ClangCheck.cpp -fsyntax-only \
- -Xclang -load -Xclang $BD/lib/PrintFunctionNames.so -Xclang \
- -plugin -Xclang print-fns
+ -fplugin=$BD/lib/PrintFunctionNames.so
</pre>
<p>Also see the print-function-name plugin example's
<a href="http://llvm.org/viewvc/llvm-project/cfe/trunk/examples/PrintFunctionNames/README.txt?view=markup";>README</a></p>
</div>
diff --git a/examples/PrintFunctionNames/PrintFunctionNames.cpp b/examples/PrintFunctionNames/PrintFunctionNames.cpp
--- a/examples/PrintFunctionNames/PrintFunctionNames.cpp
+++ b/examples/PrintFunctionNames/PrintFunctionNames.cpp
@@ -7,20 +7,20 @@
//
//===----------------------------------------------------------------------===//
//
// Example clang plugin which simply prints the names of all the top-level decls
// in the input file.
//
//===----------------------------------------------------------------------===//
-#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Basic/Plugin.h"
+#include "clang/Basic/Version.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/AST.h"
-#include "clang/Frontend/CompilerInstance.h"
#include "llvm/Support/raw_ostream.h"
using namespace clang;
namespace {
class PrintFunctionsConsumer : public ASTConsumer {
public:
virtual bool HandleTopLevelDecl(DeclGroupRef DG) {
@@ -29,43 +29,30 @@ public:
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
llvm::errs() << "top-level-decl: \"" << ND->getNameAsString() << "\"\n";
}
return true;
}
};
-class PrintFunctionNamesAction : public PluginASTAction {
-protected:
- ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) {
- return new PrintFunctionsConsumer();
- }
-
- bool ParseArgs(const CompilerInstance &CI,
- const std::vector<std::string>& args) {
- for (unsigned i = 0, e = args.size(); i != e; ++i) {
- llvm::errs() << "PrintFunctionNames arg = " << args[i] << "\n";
-
- // Example error handling.
- if (args[i] == "-an-error") {
- DiagnosticsEngine &D = CI.getDiagnostics();
- unsigned DiagID = D.getCustomDiagID(
- DiagnosticsEngine::Error, "invalid argument '" + args[i] + "'");
- D.Report(DiagID);
- return false;
- }
- }
- if (args.size() && args[0] == "help")
- PrintHelp(llvm::errs());
-
- return true;
- }
- void PrintHelp(llvm::raw_ostream& ros) {
- ros << "Help for PrintFunctionNames plugin goes here\n";
- }
-
-};
-
}
-static FrontendPluginRegistry::Add<PrintFunctionNamesAction>
-X("print-fns", "print function names");
+bool clang_plugin_init(int argc, plugin::PluginArg *argv,
+ plugin::Version *version) {
+ // It is dangerous to use plugins with versions that it wasn't compiled for.
+ // This causes us to bail out before we can do things like crash clang.
+ if (version->major != CLANG_VERSION_MAJOR ||
+ version->minor != CLANG_VERSION_MINOR)
+ return false;
+
+ llvm::errs() << "Number of arguments: " << argc << '\n';
+ for (int i = 0; i < argc; ++i)
+ llvm::errs() << "Plugin argument: arg " << argv[i].name
+ << " is set to value " << argv[i].value << '\n';
+ return true;
+}
+
+void clang_plugin_begin_file(llvm::StringRef fileName,
+ const CompilerInstance &CI, plugin::PluginFileCallbacks *callbacks) {
+ llvm::errs() << "Found when compiling " << fileName << ":\n";
+ callbacks->astConsumer = new PrintFunctionsConsumer();
+}
diff --git a/examples/PrintFunctionNames/PrintFunctionNames.exports b/examples/PrintFunctionNames/PrintFunctionNames.exports
--- a/examples/PrintFunctionNames/PrintFunctionNames.exports
+++ b/examples/PrintFunctionNames/PrintFunctionNames.exports
@@ -1,1 +1,1 @@
-_ZN4llvm8Registry*
+clang_plugin_*
diff --git a/examples/PrintFunctionNames/README.txt b/examples/PrintFunctionNames/README.txt
--- a/examples/PrintFunctionNames/README.txt
+++ b/examples/PrintFunctionNames/README.txt
@@ -1,16 +1,16 @@
This is a simple example demonstrating how to use clang's facility for
providing AST consumers using a plugin.
Build the plugin by running `make` in this directory.
Once the plugin is built, you can run it using:
--
Linux:
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.so -plugin print-fns some-input-file.c
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.so -plugin print-fns -plugin-arg-print-fns help -plugin-arg-print-fns --example-argument some-input-file.c
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.so -plugin print-fns -plugin-arg-print-fns -an-error some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.so some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.so -fplugin-arg-libPrintFunctionNames-example=some-input some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.so -fplugin-arg-libPrintFunctionNames-example2 some-input-file.c
Mac:
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.dylib -plugin print-fns some-input-file.c
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.dylib -plugin print-fns -plugin-arg-print-fns help -plugin-arg-print-fns --example-argument some-input-file.c
-$ clang -cc1 -load ../../Debug+Asserts/lib/libPrintFunctionNames.dylib -plugin print-fns -plugin-arg-print-fns -an-error some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.dylib some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.dylib -fplugin-arg-libPrintFunctionNames-example=some-input some-input-file.c
+$ clang -fplugin=../../Debug+Asserts/lib/libPrintFunctionNames.dylib -fplugin-arg-libPrintFunctionNames-example2 some-input-file.c
diff --git a/include/clang/Basic/Plugin.h b/include/clang/Basic/Plugin.h
new file mode 100644
--- /dev/null
+++ b/include/clang/Basic/Plugin.h
@@ -0,0 +1,129 @@
+//===--- Plugin.h -----------------------------------------------*- C++ -*_===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_PLUGIN_H
+#define LLVM_CLANG_BASIC_PLUGIN_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+ class StringRef;
+}
+
+namespace clang {
+
+ class ASTConsumer;
+ class CompilerInstance;
+ class DiagnosticConsumer;
+ class PPCallbacks;
+
+namespace plugin {
+
+/**
+ * An individual argument for a plugin.
+ *
+ * Plugin arguments are specified as -fplugin-arg-<plugin>-<name>=<value> or
+ * -fplugin-arg-<plugin>-<name> attributes. In the latter case, the value
+ * attribute would be an empty string.
+ */
+struct PluginArg {
+ const char *name;
+ const char *value;
+};
+
+/**
+ * A struct representing the version of clang.
+ *
+ * This version is different from other accessors that clang exposes in order to
+ * retain ABI compatibility.
+ */
+struct Version {
+ /// The major version of clang (corresponds to CLANG_VERSION_MAJOR)
+ unsigned major;
+ /// The minor version of clang (corresponds to CLANG_VERSION_MINOR)
+ unsigned minor;
+ /// The patch level version of clang, if present. This value shouldn't affect
+ /// API or ABI-level compatibility with clang for most uses. This corresponds
+ /// to CLANG_VERSION_PATCHLEVEL if it is defined.
+ unsigned subminor;
+};
+
+/**
+ * This is a set of callbacks which should be filled in by the plugin to
+ * hook into various parts of the compiler.
+ */
+struct PluginFileCallbacks {
+ /// A callback that allows plugins to view (but not modify) the AST of a file.
+ ASTConsumer *astConsumer;
+ /// A callback that allows plugins to be notified of preprocessor directives.
+ PPCallbacks *ppCallback;
+ /// A callback that allows plugins to be notified of warnings and errors.
+ DiagnosticConsumer *diagnostics;
+};
+
+} // namespace plugin
+} // namespace clang
+
+// The following functions are not implemented within clang itself, but are
+// prototypes of the various functions that may be implemented by plugins.
+// Including it in a header file allows these hooks to be documented with
+// doxygen, and the use of extern "C" on declarations allows people who forget
+// to define these functions with extern "C" to still have them work.
+extern "C" {
+/**
+ * Callback to initialize the plugin.
+ *
+ * \note This is the only function whose ABI compatibility is guaranteed to
+ * remain stable. All plugins should verify that the version passed into
+ * this function is the same version that they were compiled with and
+ * abort if this is not the case. To detect the version compiled with,
+ * include clang/Basic/Version.h and check CLANG_VERSION_MAJOR and
+ * CLANG_VERSION_MINOR.
+ *
+ * \arg argc The number of arguments in the argv array
+ * \arg argv An array of the arguments passed to this plugin from the
+ * command line.
+ * \arg version The version of the compiler being called.
+ * \return Whether or not the plugin initialization succeeded. If initialization
+ * fails, the compilation process is terminated.
+ */
+extern bool clang_plugin_init(int argc, clang::plugin::PluginArg *argv,
+ clang::plugin::Version *version);
+
+/**
+ * Callback that is called before a file is compiled.
+ *
+ * Before this function is called, the callbacks object will have all of its
+ * pointers set to null. All non-null callbacks will be deleted by the compiler
+ * internally, so one should always return a new pointer for every file.
+ *
+ * \arg fileName The name of the function being called.
+ * \arg CI The compiler instance, which contains information about how
+ * the file is being compiled and other utility classes.
+ * \arg callbacks The pointer to the callbacks that this plugin will define for
+ * this file.
+ */
+extern void clang_plugin_begin_file(llvm::StringRef fileName,
+ const clang::CompilerInstance &CI,
+ clang::plugin::PluginFileCallbacks *callbacks);
+
+/**
+ * Callback that is called after a file has been compiled.
+ *
+ * \arg fileName The name of the file that was just compiled.
+ */
+extern void clang_plugin_end_file(llvm::StringRef fileName);
+
+/**
+ * Callback that is called after all files have been compiled.
+ */
+extern void clang_plugin_destroy();
+}
+
+#endif
diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td
--- a/include/clang/Driver/Options.td
+++ b/include/clang/Driver/Options.td
@@ -586,16 +586,18 @@ def fpack_struct_EQ : Joined<"-fpack-str
HelpText<"Specify the default maximum struct packing alignment">;
def fpascal_strings : Flag<"-fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Recognize and construct Pascal-style string literals">;
def fpch_preprocess : Flag<"-fpch-preprocess">, Group<f_Group>;
def fpic : Flag<"-fpic">, Group<f_Group>;
def fno_pic : Flag<"-fno-pic">, Group<f_Group>;
def fpie : Flag<"-fpie">, Group<f_Group>;
def fno_pie : Flag<"-fno-pie">, Group<f_Group>;
+def fplugin : Joined<"-fplugin=">, Group<f_Group>, Flags<[CC1Option]>;
+def fplugin_arg : Joined<"-fplugin-arg-">, Group<f_Group>, Flags<[CC1Option]>;
def fprofile_arcs : Flag<"-fprofile-arcs">, Group<f_Group>;
def fprofile_generate : Flag<"-fprofile-generate">, Group<f_Group>;
def framework : Separate<"-framework">, Flags<[LinkerInput]>;
def frandom_seed_EQ : Joined<"-frandom-seed=">, Group<clang_ignored_f_Group>;
def frtti : Flag<"-frtti">, Group<f_Group>;
def fsched_interblock : Flag<"-fsched-interblock">, Group<clang_ignored_f_Group>;
def fshort_enums : Flag<"-fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
diff --git a/include/clang/Frontend/FrontendOptions.h b/include/clang/Frontend/FrontendOptions.h
--- a/include/clang/Frontend/FrontendOptions.h
+++ b/include/clang/Frontend/FrontendOptions.h
@@ -160,16 +160,23 @@ public:
std::vector<std::string> AddPluginActions;
/// Args to pass to the additional plugins
std::vector<std::vector<std::string> > AddPluginArgs;
/// The list of plugins to load.
std::vector<std::string> Plugins;
+ /// The list of compiler plugins to load.
+ std::vector<std::string> CompilerPlugins;
+
+ /// Argments for the above compiler plugins
+ std::vector<std::vector<std::pair<std::string, std::string> > >
+ CompilerPluginArgs;
+
/// \brief The list of AST files to merge.
std::vector<std::string> ASTMergeFiles;
/// \brief A list of arguments to forward to LLVM's option processing; this
/// should only be used for debugging and experimental features.
std::vector<std::string> LLVMArgs;
/// \brief File name of the file that will provide record layouts
diff --git a/lib/Driver/Tools.cpp b/lib/Driver/Tools.cpp
--- a/lib/Driver/Tools.cpp
+++ b/lib/Driver/Tools.cpp
@@ -1591,16 +1591,20 @@ void Clang::ConstructJob(Compilation &C,
CmdArgs.push_back("-w");
// Add -Xanalyzer arguments when running as analyzer.
Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
}
CheckCodeGenerationOptions(D, Args);
+ // Pass through plugins
+ Args.AddAllArgs(CmdArgs, options::OPT_fplugin);
+ Args.AddAllArgs(CmdArgs, options::OPT_fplugin_arg);
+
// Perform argument translation for LLVM backend. This
// takes some care in reconciling with llvm-gcc. The
// issue is that llvm-gcc translates these options based on
// the values in cc1, whereas we are processing based on
// the driver arguments.
// This comes from the default translation the driver + cc1
// would do to enable flag_pic.
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
--- a/lib/Frontend/CompilerInvocation.cpp
+++ b/lib/Frontend/CompilerInvocation.cpp
@@ -1476,16 +1476,56 @@ static InputKind ParseFrontendArgs(Front
for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
end = Args.filtered_end(); it != end; ++it) {
if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
}
}
+ Opts.CompilerPlugins = Args.getAllArgValues(OPT_fplugin);
+ Opts.CompilerPluginArgs.resize(Opts.CompilerPlugins.size());
+
+ // Parse the plugin arguments
+ std::vector<std::pair<std::string, std::string> > ParsedPluginArgs;
+ for (arg_iterator it = Args.filtered_begin(OPT_fplugin_arg),
+ end = Args.filtered_end(); it != end; ++it) {
+ std::string value = (*it)->getValue(Args);
+ size_t boundary = value.find('-');
+ if (boundary == std::string::npos) {
+ Diags.Report(diag::err_drv_unknown_argument) << value;
+ continue;
+ }
+ ParsedPluginArgs.push_back(std::pair<std::string, std::string>(
+ value.substr(0, boundary), value.substr(boundary + 1)));
+ }
+
+ // Add the plugin arguments to a parsedPluginArgs
+ for (int i = 0, e = Opts.CompilerPlugins.size(); i != e; ++i) {
+ std::string base = llvm::sys::path::stem(Opts.CompilerPlugins[i]);
+ for (std::vector<std::pair<std::string, std::string> >::iterator
+ it = ParsedPluginArgs.begin(), end = ParsedPluginArgs.end();
+ it != end; ++it) {
+ if (it->first == base) {
+ std::string argpair = it->second;
+ size_t boundary = argpair.find("=");
+ // Treat no '=' as an arg with no value
+ if (boundary == std::string::npos) {
+ Opts.CompilerPluginArgs[i].push_back(
+ std::pair<std::string, std::string>(argpair, ""));
+ } else {
+ Opts.CompilerPluginArgs[i].push_back(
+ std::pair<std::string, std::string>(argpair.substr(0, boundary),
+ argpair.substr(boundary + 1)));
+ }
+ }
+ }
+ }
+
+
if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
Opts.CodeCompletionAt =
ParsedSourceLocation::FromString(A->getValue(Args));
if (Opts.CodeCompletionAt.FileName.empty())
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue(Args);
}
Opts.DisableFree = Args.hasArg(OPT_disable_free);
diff --git a/lib/FrontendTool/ExecuteCompilerInvocation.cpp b/lib/FrontendTool/ExecuteCompilerInvocation.cpp
--- a/lib/FrontendTool/ExecuteCompilerInvocation.cpp
+++ b/lib/FrontendTool/ExecuteCompilerInvocation.cpp
@@ -10,29 +10,143 @@
// This file holds ExecuteCompilerInvocation(). It is split into its own file to
// minimize the impact of pulling in essentially everything else in Clang.
//
//===----------------------------------------------------------------------===//
#include "clang/FrontendTool/Utils.h"
#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
#include "clang/ARCMigrate/ARCMTActions.h"
+#include "clang/Basic/Plugin.h"
+#include "clang/Basic/Version.inc"
#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Driver/Options.h"
#include "clang/Driver/OptTable.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Frontend/ChainedDiagnosticConsumer.h"
#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Frontend/MultiplexConsumer.h"
#include "clang/Rewrite/FrontendActions.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/DynamicLibrary.h"
using namespace clang;
+namespace {
+ // A class that holds data associated with a single plugin.
+ class Plugin {
+ llvm::sys::DynamicLibrary PluginLibrary;
+ clang::plugin::PluginFileCallbacks callbacks;
+ public:
+ Plugin(llvm::sys::DynamicLibrary library) : PluginLibrary(library) {}
+ clang::plugin::PluginFileCallbacks *getCallbacks() { return &callbacks; }
+ intptr_t getFunctionCall(const char *name) {
+ return (intptr_t)PluginLibrary.getAddressOfSymbol(name);
+ }
+
+/// Helper function to call a given function in a plugin.
+#define CALL_PLUGIN_FUNCTION(plugin, fname, args) \
+ do { \
+ Plugin::fname func_ = (Plugin::fname)(plugin)->getFunctionCall(#fname); \
+ if (func_) \
+ func_ args; \
+ } while (0)
+
+ // These typedefs must have the same signatures as the ones in
+ // clang/Basic/Plugin.h, including the same name (it makes the helper macro
+ // above work properly).
+ typedef void (*clang_plugin_begin_file)(StringRef, const CompilerInstance &,
+ clang::plugin::PluginFileCallbacks*);
+ typedef void (*clang_plugin_end_file)(StringRef);
+ typedef void (*clang_plugin_destroy)();
+ };
+
+ // The wrapper action that manages all plugin invocations. This is what we use
+ // as the main FrontendAction for the CompilerInstance.
+ class PluginWrapperAction : public WrapperFrontendAction {
+ std::vector<Plugin> plugins;
+ std::string CurrentFile;
+ public:
+ PluginWrapperAction(FrontendAction *WrappedAction,
+ std::vector<Plugin> &plugins)
+ : WrapperFrontendAction(WrappedAction), plugins(plugins) {}
+
+ virtual bool BeginSourceFileAction(CompilerInstance &CI,
+ StringRef Filename);
+ virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
+ StringRef InFile);
+ virtual void EndSourceFileAction();
+
+ void CallPluginDestroy();
+ };
+}
+
+bool PluginWrapperAction::BeginSourceFileAction(CompilerInstance &CI,
+ StringRef Filename) {
+ if (!WrapperFrontendAction::BeginSourceFileAction(CI, Filename))
+ return false;
+
+ CurrentFile = Filename;
+ for (std::vector<Plugin>::iterator it = plugins.begin(); it != plugins.end();
+ ++it) {
+ // Retrieve the callbacks, and clear all of the values to NULL
+ clang::plugin::PluginFileCallbacks *callbacks = it->getCallbacks();
+ memset(callbacks, 0, sizeof(clang::plugin::PluginFileCallbacks));
+
+ // Get the callbacks from the plugin
+ CALL_PLUGIN_FUNCTION(it, clang_plugin_begin_file, (Filename, CI, callbacks));
+
+ // ASTConsumer is handled by GetASTConsumer; others are handled now
+ if (callbacks->ppCallback)
+ CI.getPreprocessor().addPPCallbacks(callbacks->ppCallback);
+ if (callbacks->diagnostics)
+ {
+ // The front end has already run this, so let's do this now.
+ callbacks->diagnostics->BeginSourceFile(CI.getLangOpts(),
+ &CI.getPreprocessor());
+ CI.getDiagnostics().setClient(new ChainedDiagnosticConsumer(
+ &CI.getDiagnosticClient(), callbacks->diagnostics));
+ }
+ }
+
+ return true;
+}
+
+ASTConsumer *PluginWrapperAction::CreateASTConsumer(CompilerInstance &CI,
+ StringRef InFile) {
+ std::vector<ASTConsumer*> Consumers(1,
+ WrapperFrontendAction::CreateASTConsumer(CI, InFile));
+ for (std::vector<Plugin>::iterator it = plugins.begin(); it != plugins.end();
+ ++it) {
+ if (ASTConsumer *consumer = it->getCallbacks()->astConsumer) {
+ Consumers.push_back(consumer);
+ }
+ }
+ return new MultiplexConsumer(Consumers);
+}
+
+void PluginWrapperAction::EndSourceFileAction()
+{
+ WrapperFrontendAction::EndSourceFileAction();
+ for (std::vector<Plugin>::iterator it = plugins.begin(); it != plugins.end();
+ ++it) {
+ CALL_PLUGIN_FUNCTION(it, clang_plugin_end_file, (CurrentFile));
+ }
+}
+
+void PluginWrapperAction::CallPluginDestroy() {
+ for (std::vector<Plugin>::iterator it = plugins.begin(); it != plugins.end();
+ ++it) {
+ CALL_PLUGIN_FUNCTION(it, clang_plugin_destroy, ());
+ }
+}
+
static FrontendAction *CreateFrontendBaseAction(CompilerInstance &CI) {
using namespace clang::frontend;
switch (CI.getFrontendOpts().ProgramAction) {
case ASTDump: return new ASTDumpAction();
case ASTDumpXML: return new ASTDumpXMLAction();
case ASTPrint: return new ASTPrintAction();
case ASTView: return new ASTViewAction();
@@ -153,16 +267,68 @@ bool clang::ExecuteCompilerInvocation(Co
e = Clang->getFrontendOpts().Plugins.size(); i != e; ++i) {
const std::string &Path = Clang->getFrontendOpts().Plugins[i];
std::string Error;
if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error))
Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
<< Path << Error;
}
+ std::vector<Plugin> plugins;
+ for (unsigned i = 0,
+ e = Clang->getFrontendOpts().CompilerPlugins.size(); i != e; ++i) {
+ const std::string &Path = Clang->getFrontendOpts().CompilerPlugins[i];
+
+ // Try loading the library
+ std::string Error;
+ llvm::sys::DynamicLibrary plugin =
+ llvm::sys::DynamicLibrary::getPermanentLibrary(Path.c_str(), &Error);
+ if (!plugin.isValid()) {
+ Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
+ << Path << Error;
+ continue;
+ }
+
+ // If the library has been loaded, it's time to run plugin_init.
+ // Construct the version
+ clang::plugin::Version pluginVersion = {
+ CLANG_VERSION_MAJOR,
+ CLANG_VERSION_MINOR,
+#ifdef CLANG_VERSION_PATCHLEVEL
+ CLANG_VERSION_PATCHLEVEL
+#else
+ 0
+#endif
+ };
+
+ // Construct the arguments
+ std::vector<std::pair<std::string, std::string> > &pluginArgs =
+ Clang->getFrontendOpts().CompilerPluginArgs[i];
+ plugin::PluginArg *args = new plugin::PluginArg[pluginArgs.size()];
+ for (unsigned i = 0; i < pluginArgs.size(); i++) {
+ args[i].name = pluginArgs[i].first.c_str();
+ args[i].value = pluginArgs[i].second.c_str();
+ }
+ typedef bool (*init_func)(int argc, clang::plugin::PluginArg *argv,
+ clang::plugin::Version *version);
+ init_func plugin_init = (init_func)(intptr_t)
+ plugin.getAddressOfSymbol("clang_plugin_init");
+ if (!plugin_init) {
+ Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
+ << Path << "Could not find clang_plugin_init";
+ } else if (!plugin_init(pluginArgs.size(), args, &pluginVersion)) {
+ Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
+ << Path << "Plugin initialization failed";
+ } else {
+ plugins.push_back(Plugin(plugin));
+ }
+
+ delete [] args;
+ }
+
// Honor -mllvm.
//
// FIXME: Remove this, one day.
// This should happen AFTER plugins have been loaded!
if (!Clang->getFrontendOpts().LLVMArgs.empty()) {
unsigned NumArgs = Clang->getFrontendOpts().LLVMArgs.size();
const char **Args = new const char*[NumArgs + 2];
Args[0] = "clang (LLVM option parsing)";
@@ -178,18 +344,20 @@ bool clang::ExecuteCompilerInvocation(Co
ento::printCheckerHelp(llvm::outs(), Clang->getFrontendOpts().Plugins);
return 0;
}
// If there were errors in processing arguments, don't do anything else.
bool Success = false;
if (!Clang->getDiagnostics().hasErrorOccurred()) {
// Create and execute the frontend action.
- OwningPtr<FrontendAction> Act(CreateFrontendAction(*Clang));
+ OwningPtr<PluginWrapperAction> Act(
+ new PluginWrapperAction(CreateFrontendAction(*Clang), plugins));
if (Act) {
Success = Clang->ExecuteAction(*Act);
+ Act->CallPluginDestroy();
if (Clang->getFrontendOpts().DisableFree)
Act.take();
}
}
return Success;
}
_______________________________________________
cfe-commits mailing list
[email protected]
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
