I have written a test for this patch and run it (it works correctly). I
guess there is no reason why it should not be accepted now.
To recap, this patch add a void * data field to the pragma handler,
allowing to pass extra data. If we want to use this field, we need to
use the function c_register_pragma_with_data or
c_register_pragma_with_expansion_and_data. The old
c_register_pragma(_with_expansion) is kept compatible.
I give two diff and two ChangeLog, the first are for the patch itself,
the second are for the test.
I have tried to make things as good as possible, if there is a remark,
please, send me it. Especially, I am not sure about the format of my
ChangeLog, if there is an issue, I am ready to change it.
Changelog gcc:
2011-06-08 Pierre Vittet <pier...@pvittet.com>
* c-pragma.h (pragma_handler_1arg, pragma_handler_2arg,
gen_pragma_handler, internal_pragma_handler, c_register_pragma,
c_register_pragma_with_data, c_register_pragma_with_expansion,
c_register_pragma_with_expansion_and_data): allows to add data to a
pragma handler using a new c_register. Old c_register keep old
behaviour for compatibility.
* c-pragma.c (registered_pragmas, c_register_pragma_1,
c_register_pragma, c_register_pragma_with_data,
c_register_pragma_with_expansion,
c_register_pragma_with_expansion_and_data, c_invoke_pragma_handler,
init_pragma): allows to add data to a pragma handler using a new
c_register. Old registers keep old behaviour for compatibility.
Changelog testsuite
2011-06-08 Pierre Vittet <pier...@pvittet.com>
* g++.dg/plugin/pragma_plugin_with_data.c: New test.
Thanks!
Pierre Vittet
Index: gcc/c-family/c-pragma.c
===================================================================
--- gcc/c-family/c-pragma.c (revision 174521)
+++ gcc/c-family/c-pragma.c (working copy)
@@ -1148,12 +1148,12 @@ handle_pragma_float_const_decimal64 (cpp_reader *A
}
/* A vector of registered pragma callbacks. */
+/* This is never freed as we need it during the whole execution. */
+DEF_VEC_O (internal_pragma_handler);
+DEF_VEC_ALLOC_O (internal_pragma_handler, heap);
-DEF_VEC_O (pragma_handler);
-DEF_VEC_ALLOC_O (pragma_handler, heap);
+static VEC(internal_pragma_handler, heap) *registered_pragmas;
-static VEC(pragma_handler, heap) *registered_pragmas;
-
typedef struct
{
const char *space;
@@ -1216,7 +1216,7 @@ c_pp_lookup_pragma (unsigned int id, const char **
static void
c_register_pragma_1 (const char *space, const char *name,
- pragma_handler handler, bool allow_expansion)
+ internal_pragma_handler ihandler, bool allow_expansion)
{
unsigned id;
@@ -1235,8 +1235,9 @@ c_register_pragma_1 (const char *space, const char
}
else
{
- VEC_safe_push (pragma_handler, heap, registered_pragmas, &handler);
- id = VEC_length (pragma_handler, registered_pragmas);
+ VEC_safe_push (internal_pragma_handler, heap, registered_pragmas,
+ &ihandler);
+ id = VEC_length (internal_pragma_handler, registered_pragmas);
id += PRAGMA_FIRST_EXTERNAL - 1;
/* The C++ front end allocates 6 bits in cp_token; the C front end
@@ -1248,28 +1249,90 @@ c_register_pragma_1 (const char *space, const char
allow_expansion, false);
}
+/* Register a C pragma handler, using a space and a name. It disallows pragma
+expansion (if you want it, use c_register_pragma_with_expansion instead). */
void
-c_register_pragma (const char *space, const char *name, pragma_handler handler)
+c_register_pragma (const char *space, const char *name,
+ pragma_handler_1arg handler)
{
- c_register_pragma_1 (space, name, handler, false);
+ internal_pragma_handler ihandler;
+
+ ihandler.handler.handler_1arg = handler;
+ ihandler.extra_data = false;
+ ihandler.data = NULL;
+ c_register_pragma_1 (space, name, ihandler, false);
}
+/* Register a C pragma handler, using a space and a name, it also carries an
+extra data field which can be used by the handler. It disallows pragma
+expansion (if you want it, use c_register_pragma_with_expansion instead). */
void
+c_register_pragma_with_data (const char *space, const char *name,
+ pragma_handler_2arg handler, void * data)
+{
+ internal_pragma_handler ihandler;
+
+ ihandler.handler.handler_2arg = handler;
+ ihandler.extra_data = true;
+ ihandler.data = data;
+ c_register_pragma_1 (space, name, ihandler, false);
+}
+
+/* Register a C pragma handler, using a space and a name. It allows pragma
+expansion as in the following exemple:
+ #define NUMBER 10
+ #pragma count (NUMBER)
+Name expansion is still disallowed. */
+void
c_register_pragma_with_expansion (const char *space, const char *name,
- pragma_handler handler)
+ pragma_handler_1arg handler)
{
- c_register_pragma_1 (space, name, handler, true);
+ internal_pragma_handler ihandler;
+
+ ihandler.handler.handler_1arg = handler;
+ ihandler.extra_data = false;
+ ihandler.data = NULL;
+ c_register_pragma_1 (space, name, ihandler, true);
}
+/* Register a C pragma handler, using a space and a name, it also carries an
+extra data field which can be used by the handler. It allows pragma expansion
+as in the following exemple:
+ #define NUMBER 10
+ #pragma count (NUMBER)
+Name expansion is still disallowed. */
void
+c_register_pragma_with_expansion_and_data (const char *space, const char *name,
+ pragma_handler_2arg handler,
+ void * data)
+{
+ internal_pragma_handler ihandler;
+
+ ihandler.handler.handler_2arg = handler;
+ ihandler.extra_data = true;
+ ihandler.data = data;
+ c_register_pragma_1 (space, name, ihandler, true);
+}
+
+void
c_invoke_pragma_handler (unsigned int id)
{
- pragma_handler handler;
+ internal_pragma_handler * ihandler;
+ pragma_handler_1arg handler_1arg;
+ pragma_handler_2arg handler_2arg;
id -= PRAGMA_FIRST_EXTERNAL;
- handler = *VEC_index (pragma_handler, registered_pragmas, id);
-
- handler (parse_in);
+ ihandler = VEC_index (internal_pragma_handler, registered_pragmas, id);
+ if (ihandler->extra_data)
+ {
+ handler_2arg = ihandler->handler.handler_2arg;
+ handler_2arg (parse_in, ihandler->data);
+ }
+ else
+ {
+ handler_1arg = ihandler->handler.handler_1arg;
+ handler_1arg (parse_in);
+ }
}
/* Set up front-end pragmas. */
@@ -1308,7 +1371,8 @@ init_pragma (void)
c_register_pragma ("STDC", "FLOAT_CONST_DECIMAL64",
handle_pragma_float_const_decimal64);
- c_register_pragma_with_expansion (0, "redefine_extname",
handle_pragma_redefine_extname);
+ c_register_pragma_with_expansion (0, "redefine_extname",
+ handle_pragma_redefine_extname);
c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);
c_register_pragma_with_expansion (0, "message", handle_pragma_message);
Index: gcc/c-family/c-pragma.h
===================================================================
--- gcc/c-family/c-pragma.h (revision 174521)
+++ gcc/c-family/c-pragma.h (working copy)
@@ -84,10 +84,39 @@ extern bool pop_visibility (int);
extern void init_pragma (void);
/* Front-end wrappers for pragma registration. */
-typedef void (*pragma_handler)(struct cpp_reader *);
-extern void c_register_pragma (const char *, const char *, pragma_handler);
-extern void c_register_pragma_with_expansion (const char *, const char *,
- pragma_handler);
+typedef void (*pragma_handler_1arg)(struct cpp_reader *);
+/* A second pragma handler, which adds a void * argument allowing to pass extra
+data to the handler. */
+typedef void (*pragma_handler_2arg)(struct cpp_reader *, void *);
+
+/* This union permits abstact the different handlers. */
+union gen_pragma_handler {
+ pragma_handler_1arg handler_1arg;
+ pragma_handler_2arg handler_2arg;
+};
+/* Internally use to keep the data of the handler. The field extra_data permit
+to know if handler is a pragma_handler_1arg (extra_data is false), or a
+pragma_handler_2arg (extra_data is true). */
+struct internal_pragma_handler_d {
+ union gen_pragma_handler handler;
+ bool extra_data;
+ void * data;
+};
+typedef struct internal_pragma_handler_d internal_pragma_handler;
+
+extern void c_register_pragma (const char * space, const char * name,
+ pragma_handler_1arg handler);
+extern void c_register_pragma_with_data (const char * space, const char * name,
+ pragma_handler_2arg handler,
+ void * data);
+
+extern void c_register_pragma_with_expansion (const char * space,
+ const char * name,
+ pragma_handler_1arg handler);
+extern void c_register_pragma_with_expansion_and_data (const char * space,
+ const char * name,
+ pragma_handler_2arg handler,
+ void * data);
extern void c_invoke_pragma_handler (unsigned int);
extern void maybe_apply_pragma_weak (tree);
Index: gcc/testsuite/g++.dg/plugin/plugin.exp
===================================================================
--- gcc/testsuite/g++.dg/plugin/plugin.exp (revision 174521)
+++ gcc/testsuite/g++.dg/plugin/plugin.exp (working copy)
@@ -49,6 +49,7 @@ load_lib plugin-support.exp
set plugin_test_list [list \
{ attribute_plugin.c attribute_plugin-test-1.C } \
{ pragma_plugin.c pragma_plugin-test-1.C } \
+ { pragma_plugin_with_data.c pragma_plugin_with_data-test-1.C } \
{ selfassign.c self-assign-test-1.C self-assign-test-2.C
self-assign-test-3.C } \
{ dumb_plugin.c dumb-plugin-test-1.C } \
{ header_plugin.c header-plugin-test.C } ]
Index: gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c
===================================================================
--- gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c (revision 0)
+++ gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data.c (revision 0)
@@ -0,0 +1,102 @@
+/* Test pragma adding using an extra data field. */
+
+#include "gcc-plugin.h"
+#include <stdlib.h>
+#include "function.h"
+#include "c-family/c-pragma.h"
+#include "intl.h"
+
+
+
+int plugin_is_GPL_compatible;
+
+
+
+#define GCC_PRAGMA_BAD(gmsgid) \
+ do { warning (OPT_Wpragmas, gmsgid); goto end; } while (0)
+
+/* handler of #pragma SPACE NAME command (arg1, arg2, ...) or of type
+ * #pragma SPACE NAME command .
+ */
+
+static void
+handle_pragma_gen (cpp_reader *ARG_UNUSED(dummy), void * data)
+{
+ char * plugin_name = (char *) data;
+
+ warning (0, G_("The name of the pass: %s"),
+ plugin_name);
+
+ enum cpp_ttype token;
+ tree x;
+ const char * command;
+
+ token = pragma_lex (&x);
+ if(token != CPP_NAME)
+ GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+
+ command = IDENTIFIER_POINTER(x);
+
+ /*If the pragma has the form #pragma SPACE NAME cmd (...) then command
+ contains "cmd".
+ Next element should be a parenthese opening or an end of line */
+ token = pragma_lex (&x);
+ if (token != CPP_OPEN_PAREN)
+ {
+ if (token != CPP_EOF)
+ GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+
+ else /* we have a pragma of the type '#pragma SPACE NAME command' */
+ {
+ /* We have recover our pragma. */
+ warning (OPT_Wpragmas, "%<#pragma GCCPLUGIN newPragma%> a simple \
+instruction: %s", command);
+ return;
+ }
+ }
+ else
+ { /* opening parenthesis */
+ do
+ {
+ token = pragma_lex (&x);
+ if(token != CPP_NAME && token != CPP_STRING && token != CPP_NUMBER)
+ GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+
+ token = pragma_lex (&x);
+
+ } while (token == CPP_COMMA);
+
+ if (token == CPP_CLOSE_PAREN && pragma_lex(&x) == CPP_EOF)
+ {
+ /* We have recover our pragma. */
+ warning (OPT_Wpragmas, "%<#pragma GCCPLUGIN newPragma%> a more complex
\
+instruction: %s", command);
+ return;
+ }
+ else
+ GCC_PRAGMA_BAD ("malformed #pragma melt, ignored");
+ }
+end: return;
+}
+
+/* Plugin callback called during pragma registration */
+
+static void
+register_my_pragma (void *event_data, void *data)
+{
+ warning (0, G_("Callback to register pragmas"));
+ c_register_pragma_with_data ("GCCPLUGIN", "newPragma",
+ handle_pragma_gen, data);
+}
+
+/* Init the plugin. */
+int
+plugin_init (struct plugin_name_args *plugin_info,
+ struct plugin_gcc_version *version)
+{
+ const char *plugin_name = plugin_info->base_name;
+
+ register_callback (plugin_name, PLUGIN_PRAGMAS, register_my_pragma,
+ (void *) plugin_name);
+ return 0;
+}
Index: gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C
===================================================================
--- gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C
(revision 0)
+++ gcc/testsuite/g++.dg/plugin/pragma_plugin_with_data-test-1.C
(revision 0)
@@ -0,0 +1,8 @@
+// { dg-warning "Callback to register pragmas" "" { target *-*-* } 0 }
+// { dg-warning "The name of the pass: pragma_plugin_with_data" "" {target
*-*-* } 5 }
+// { dg-warning "The name of the pass: pragma_plugin_with_data" "" {target
*-*-* } 7 }
+
+#pragma GCCPLUGIN newPragma do_smt // { dg-warning "'#pragma GCCPLUGIN
newPragma' a simple instruction: do_smt" }
+
+#pragma GCCPLUGIN newPragma do_smt_else (test ,"test", 2) // { dg-warning
"'#pragma GCCPLUGIN newPragma' a more complex instruction: do_smt_else" }
+
