From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14395 invoked by alias); 8 Jun 2011 21:27:13 -0000 Received: (qmail 14386 invoked by uid 22791); 8 Jun 2011 21:27:11 -0000 X-SWARE-Spam-Status: No, hits=-1.9 required=5.0 tests=BAYES_00 X-Spam-Check-By: sourceware.org Received: from 20.97.mail-out.ovh.net (HELO 97.mail-out.ovh.net) (46.105.39.189) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 08 Jun 2011 21:26:55 +0000 Received: from mail185.ha.ovh.net (b9.ovh.net [213.186.33.59]) by 97.mail-out.ovh.net (Postfix) with SMTP id BD8B64A670B for ; Wed, 8 Jun 2011 23:27:24 +0200 (CEST) Received: from b0.ovh.net (HELO queueout) (213.186.33.50) by b0.ovh.net with SMTP; 8 Jun 2011 23:26:53 +0200 Received: from unknown (HELO ?85.69.132.55?) (piervit@pvittet.com@85.69.132.55) by ns0.ovh.net with SMTP; 8 Jun 2011 23:26:52 +0200 Message-ID: <4DEFE90F.5020607@pvittet.com> Date: Wed, 08 Jun 2011 21:35:00 -0000 From: Pierre Vittet User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.9) Gecko/20100515 Lightning/1.0b1 Icedove/3.0.4 MIME-Version: 1.0 To: gcc-patches@gcc.gnu.org, tromey@redhat.com, joseph@codesourcery.com, Basile Starynkevitch Subject: Re: [PATCH] c-pragma: adding a data field to pragma_handler References: <4DE66ECE.5030102@laposte.net> <4DE8FE4D.6050404@pvittet.com> In-Reply-To: <4DE8FE4D.6050404@pvittet.com> Content-Type: multipart/mixed; boundary="------------080905010100030307080800" X-Ovh-Tracer-Id: 16797019235846193310 X-Ovh-Remote: 85.69.132.55 () X-Ovh-Local: 213.186.33.20 (ns0.ovh.net) X-VR-SPAMSTATE: OK X-VR-SPAMSCORE: -100 X-VR-SPAMCAUSE: Vade Retro 01.320.21 AV+AS Profile: OVH; Bailout: 300; @!Recipients (-100) X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2011-06/txt/msg00684.txt.bz2 This is a multi-part message in MIME format. --------------080905010100030307080800 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 1743 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 * 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 * g++.dg/plugin/pragma_plugin_with_data.c: New test. Thanks! Pierre Vittet --------------080905010100030307080800 Content-Type: text/plain; name="addDataToPragmaHandler-174521.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="addDataToPragmaHandler-174521.diff" Content-length: 7632 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); --------------080905010100030307080800 Content-Type: text/plain; name="addDataToPragmaHandler-test-174521.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="addDataToPragmaHandler-test-174521.diff" Content-length: 4466 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 +#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" } + --------------080905010100030307080800--