From patchwork Thu May 3 18:41:49 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Keith Seitz X-Patchwork-Id: 27091 Received: (qmail 13976 invoked by alias); 3 May 2018 18:49:57 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 13873 invoked by uid 89); 3 May 2018 18:49:56 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, KAM_STOCKGEN, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=4199, sk:finish_ X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 03 May 2018 18:49:53 +0000 Received: from smtp.corp.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.26]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E217881127 for ; Thu, 3 May 2018 18:41:55 +0000 (UTC) Received: from theo.uglyboxes.com (ovpn04.gateway.prod.ext.phx2.redhat.com [10.5.9.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id A61A930012B6 for ; Thu, 3 May 2018 18:41:55 +0000 (UTC) From: Keith Seitz To: gdb-patches@sourceware.org Subject: [PATCH 4/8] Add a C++ wrapper for GCC C plug-in Date: Thu, 3 May 2018 11:41:49 -0700 Message-Id: <20180503184153.31183-5-keiths@redhat.com> In-Reply-To: <20180503184153.31183-1-keiths@redhat.com> References: <20180503184153.31183-1-keiths@redhat.com> X-IsSubscribed: yes This patch introduces a new class which wraps the GCC C compile plug-in. It is a little unfortunate that this all happened in between the time that GCC moved to C++ and GDB moved to C++, leaving us with an ABI promise to support a C-like interface. The hope is to isolate GDB from some of this should it change in the future. Broadly, what this does is replace calls like: C_CTX (context)->c_ops->operation (C_CTX (context), ...); with calls that now look like: context->c_plugin->operation (...); This API will be further refined in following patches when struct compile_instance/compile_c_instance are changed into classes. gdb/ChangeLog: * Makefile.in (HFILES_NO_SRCDIR): Add compile/gcc-c-plugin.h. * compile/compile-c-types.c: Define GCC_METHODN macros and include gcc-c-fe.def to define C plugin. (delete_instance): Delete `c_plugin'. (new_compile_instance): Initialize `c_plugin'. * compile/compile-c.h: Include gcc_c_plugin.h. (struct compile_c_instance) : New member. * gcc-c-plugin.h: New file. Update all callers with API change. --- gdb/Makefile.in | 1 + gdb/compile/compile-c-symbols.c | 30 ++++---- gdb/compile/compile-c-types.c | 153 ++++++++++++++++++++++------------------ gdb/compile/compile-c.h | 9 ++- gdb/compile/gcc-c-plugin.h | 64 +++++++++++++++++ 5 files changed, 168 insertions(+), 89 deletions(-) create mode 100644 gdb/compile/gcc-c-plugin.h diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 67fff669ba..56883a0acd 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -1456,6 +1456,7 @@ HFILES_NO_SRCDIR = \ compile/compile-internal.h \ compile/compile-object-load.h \ compile/compile-object-run.h \ + compile/gcc-c-plugin.h \ config/nm-linux.h \ config/nm-nto.h \ config/djgpp/langinfo.h \ diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c index c82e008659..abd829838b 100644 --- a/gdb/compile/compile-c-symbols.c +++ b/gdb/compile/compile-c-symbols.c @@ -161,9 +161,8 @@ convert_one_symbol (struct compile_c_instance *context, if (SYMBOL_DOMAIN (sym.symbol) == STRUCT_DOMAIN) { /* Binding a tag, so we don't need to build a decl. */ - C_CTX (context)->c_ops->tagbind (C_CTX (context), - SYMBOL_NATURAL_NAME (sym.symbol), - sym_type, filename, line); + context->c_plugin->tagbind (SYMBOL_NATURAL_NAME (sym.symbol), + sym_type, filename, line); } else { @@ -196,9 +195,8 @@ convert_one_symbol (struct compile_c_instance *context, /* Already handled by convert_enum. */ return; } - C_CTX (context)->c_ops->build_constant - (C_CTX (context), - sym_type, SYMBOL_NATURAL_NAME (sym.symbol), + context->c_plugin->build_constant + (sym_type, SYMBOL_NATURAL_NAME (sym.symbol), SYMBOL_VALUE (sym.symbol), filename, line); return; @@ -285,15 +283,14 @@ convert_one_symbol (struct compile_c_instance *context, if (context->base.scope != COMPILE_I_RAW_SCOPE || symbol_name == NULL) { - decl = C_CTX (context)->c_ops->build_decl - (C_CTX (context), - SYMBOL_NATURAL_NAME (sym.symbol), + decl = context->c_plugin->build_decl + (SYMBOL_NATURAL_NAME (sym.symbol), kind, sym_type, symbol_name.get (), addr, filename, line); - C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global); + context->c_plugin->bind (decl, is_global); } } } @@ -402,11 +399,10 @@ convert_symbol_bmsym (struct compile_c_instance *context, } sym_type = convert_type (context, type); - decl = C_CTX (context)->c_ops->build_decl (C_CTX (context), - MSYMBOL_NATURAL_NAME (msym), - kind, sym_type, NULL, addr, - NULL, 0); - C_CTX (context)->c_ops->bind (C_CTX (context), decl, 1 /* is_global */); + decl = context->c_plugin->build_decl (MSYMBOL_NATURAL_NAME (msym), + kind, sym_type, NULL, addr, + NULL, 0); + context->c_plugin->bind (decl, 1 /* is_global */); } /* See compile-internal.h. */ @@ -463,7 +459,7 @@ gcc_convert_symbol (void *datum, CATCH (e, RETURN_MASK_ALL) { - C_CTX (context)->c_ops->error (C_CTX (context), e.message); + context->c_plugin->error (e.message); } END_CATCH @@ -525,7 +521,7 @@ gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context, CATCH (e, RETURN_MASK_ERROR) { - C_CTX (context)->c_ops->error (C_CTX (context), e.message); + context->c_plugin->error (e.message); } END_CATCH diff --git a/gdb/compile/compile-c-types.c b/gdb/compile/compile-c-types.c index 46b9f2b3b4..927445208a 100644 --- a/gdb/compile/compile-c-types.c +++ b/gdb/compile/compile-c-types.c @@ -99,8 +99,7 @@ convert_pointer (struct compile_c_instance *context, struct type *type) { gcc_type target = convert_type (context, TYPE_TARGET_TYPE (type)); - return C_CTX (context)->c_ops->build_pointer_type (C_CTX (context), - target); + return context->c_plugin->build_pointer_type (target); } /* Convert an array type to its gcc representation. */ @@ -114,13 +113,11 @@ convert_array (struct compile_c_instance *context, struct type *type) element_type = convert_type (context, TYPE_TARGET_TYPE (type)); if (TYPE_LOW_BOUND_KIND (range) != PROP_CONST) - return C_CTX (context)->c_ops->error (C_CTX (context), - _("array type with non-constant" - " lower bound is not supported")); + return context->c_plugin->error (_("array type with non-constant" + " lower bound is not supported")); if (TYPE_LOW_BOUND (range) != 0) - return C_CTX (context)->c_ops->error (C_CTX (context), - _("cannot convert array type with " - "non-zero lower bound to C")); + return context->c_plugin->error (_("cannot convert array type with " + "non-zero lower bound to C")); if (TYPE_HIGH_BOUND_KIND (range) == PROP_LOCEXPR || TYPE_HIGH_BOUND_KIND (range) == PROP_LOCLIST) @@ -128,15 +125,13 @@ convert_array (struct compile_c_instance *context, struct type *type) gcc_type result; if (TYPE_VECTOR (type)) - return C_CTX (context)->c_ops->error (C_CTX (context), - _("variably-sized vector type" - " is not supported")); + return context->c_plugin->error (_("variably-sized vector type" + " is not supported")); std::string upper_bound = c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high); - result = C_CTX (context)->c_ops->build_vla_array_type (C_CTX (context), - element_type, - upper_bound.c_str ()); + result = context->c_plugin->build_vla_array_type (element_type, + upper_bound.c_str ()); return result; } else @@ -152,11 +147,8 @@ convert_array (struct compile_c_instance *context, struct type *type) } if (TYPE_VECTOR (type)) - return C_CTX (context)->c_ops->build_vector_type (C_CTX (context), - element_type, - count); - return C_CTX (context)->c_ops->build_array_type (C_CTX (context), - element_type, count); + return context->c_plugin->build_vector_type (element_type, count); + return context->c_plugin->build_array_type (element_type, count); } } @@ -171,11 +163,11 @@ convert_struct_or_union (struct compile_c_instance *context, struct type *type) /* First we create the resulting type and enter it into our hash table. This lets recursive types work. */ if (TYPE_CODE (type) == TYPE_CODE_STRUCT) - result = C_CTX (context)->c_ops->build_record_type (C_CTX (context)); + result = context->c_plugin->build_record_type (); else { gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION); - result = C_CTX (context)->c_ops->build_union_type (C_CTX (context)); + result = context->c_plugin->build_union_type (); } insert_type (context, type, result); @@ -187,15 +179,14 @@ convert_struct_or_union (struct compile_c_instance *context, struct type *type) field_type = convert_type (context, TYPE_FIELD_TYPE (type, i)); if (bitsize == 0) bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type, i)); - C_CTX (context)->c_ops->build_add_field (C_CTX (context), result, - TYPE_FIELD_NAME (type, i), - field_type, - bitsize, - TYPE_FIELD_BITPOS (type, i)); + context->c_plugin->build_add_field (result, + TYPE_FIELD_NAME (type, i), + field_type, + bitsize, + TYPE_FIELD_BITPOS (type, i)); } - C_CTX (context)->c_ops->finish_record_or_union (C_CTX (context), result, - TYPE_LENGTH (type)); + context->c_plugin->finish_record_or_union (result, TYPE_LENGTH (type)); return result; } @@ -206,22 +197,20 @@ convert_enum (struct compile_c_instance *context, struct type *type) { gcc_type int_type, result; int i; - struct gcc_c_context *ctx = C_CTX (context); + const gcc_c_plugin *plugin = context->c_plugin; - int_type = ctx->c_ops->int_type_v0 (ctx, - TYPE_UNSIGNED (type), - TYPE_LENGTH (type)); + int_type = plugin->int_type_v0 (TYPE_UNSIGNED (type), + TYPE_LENGTH (type)); - result = ctx->c_ops->build_enum_type (ctx, int_type); + result = plugin->build_enum_type (int_type); for (i = 0; i < TYPE_NFIELDS (type); ++i) { - ctx->c_ops->build_add_enum_constant (ctx, - result, - TYPE_FIELD_NAME (type, i), - TYPE_FIELD_ENUMVAL (type, i)); + plugin->build_add_enum_constant (result, + TYPE_FIELD_NAME (type, i), + TYPE_FIELD_ENUMVAL (type, i)); } - ctx->c_ops->finish_enum_type (ctx, result); + plugin->finish_enum_type (result); return result; } @@ -261,9 +250,8 @@ convert_func (struct compile_c_instance *context, struct type *type) for (i = 0; i < TYPE_NFIELDS (type); ++i) array.elements[i] = convert_type (context, TYPE_FIELD_TYPE (type, i)); - result = C_CTX (context)->c_ops->build_function_type (C_CTX (context), - return_type, - &array, is_varargs); + result = context->c_plugin->build_function_type (return_type, + &array, is_varargs); xfree (array.elements); return result; @@ -274,22 +262,20 @@ convert_func (struct compile_c_instance *context, struct type *type) static gcc_type convert_int (struct compile_c_instance *context, struct type *type) { - if (C_CTX (context)->c_ops->c_version >= GCC_C_FE_VERSION_1) + if (context->c_plugin->version () >= GCC_C_FE_VERSION_1) { if (TYPE_NOSIGN (type)) { gdb_assert (TYPE_LENGTH (type) == 1); - return C_CTX (context)->c_ops->char_type (C_CTX (context)); + return context->c_plugin->char_type (); } - return C_CTX (context)->c_ops->int_type (C_CTX (context), - TYPE_UNSIGNED (type), - TYPE_LENGTH (type), - TYPE_NAME (type)); + return context->c_plugin->int_type (TYPE_UNSIGNED (type), + TYPE_LENGTH (type), + TYPE_NAME (type)); } else - return C_CTX (context)->c_ops->int_type_v0 (C_CTX (context), - TYPE_UNSIGNED (type), - TYPE_LENGTH (type)); + return context->c_plugin->int_type_v0 (TYPE_UNSIGNED (type), + TYPE_LENGTH (type)); } /* Convert a floating-point type to its gcc representation. */ @@ -297,13 +283,11 @@ convert_int (struct compile_c_instance *context, struct type *type) static gcc_type convert_float (struct compile_c_instance *context, struct type *type) { - if (C_CTX (context)->c_ops->c_version >= GCC_C_FE_VERSION_1) - return C_CTX (context)->c_ops->float_type (C_CTX (context), - TYPE_LENGTH (type), - TYPE_NAME (type)); + if (context->c_plugin->version () >= GCC_C_FE_VERSION_1) + return context->c_plugin->float_type (TYPE_LENGTH (type), + TYPE_NAME (type)); else - return C_CTX (context)->c_ops->float_type_v0 (C_CTX (context), - TYPE_LENGTH (type)); + return context->c_plugin->float_type_v0 (TYPE_LENGTH (type)); } /* Convert the 'void' type to its gcc representation. */ @@ -311,7 +295,7 @@ convert_float (struct compile_c_instance *context, struct type *type) static gcc_type convert_void (struct compile_c_instance *context, struct type *type) { - return C_CTX (context)->c_ops->void_type (C_CTX (context)); + return context->c_plugin->void_type (); } /* Convert a boolean type to its gcc representation. */ @@ -319,7 +303,7 @@ convert_void (struct compile_c_instance *context, struct type *type) static gcc_type convert_bool (struct compile_c_instance *context, struct type *type) { - return C_CTX (context)->c_ops->bool_type (C_CTX (context)); + return context->c_plugin->bool_type (); } /* Convert a qualified type to its gcc representation. */ @@ -340,9 +324,7 @@ convert_qualified (struct compile_c_instance *context, struct type *type) if (TYPE_RESTRICT (type)) quals |= GCC_QUALIFIER_RESTRICT; - return C_CTX (context)->c_ops->build_qualified_type (C_CTX (context), - unqual_converted, - quals); + return context->c_plugin->build_qualified_type (unqual_converted, quals); } /* Convert a complex type to its gcc representation. */ @@ -352,7 +334,7 @@ convert_complex (struct compile_c_instance *context, struct type *type) { gcc_type base = convert_type (context, TYPE_TARGET_TYPE (type)); - return C_CTX (context)->c_ops->build_complex_type (C_CTX (context), base); + return context->c_plugin->build_complex_type (base); } /* A helper function which knows how to convert most types from their @@ -419,9 +401,7 @@ convert_type_basic (struct compile_c_instance *context, struct type *type) } } - return C_CTX (context)->c_ops->error (C_CTX (context), - _("cannot convert gdb type " - "to gcc type")); + return context->c_plugin->error (_("cannot convert gdb type to gcc type")); } /* See compile-internal.h. */ @@ -456,6 +436,7 @@ delete_instance (struct compile_instance *c) struct compile_c_instance *context = (struct compile_c_instance *) c; context->base.fe->ops->destroy (context->base.fe); + delete context->c_plugin; htab_delete (context->type_map); if (context->symbol_err_map != NULL) htab_delete (context->symbol_err_map); @@ -481,8 +462,46 @@ new_compile_instance (struct gcc_c_context *fe) eq_type_map_instance, xfree, xcalloc, xfree); - fe->c_ops->set_callbacks (fe, gcc_convert_symbol, - gcc_symbol_address, result); + result->c_plugin = new gcc_c_plugin (fe); + + result->c_plugin->set_callbacks (gcc_convert_symbol, gcc_symbol_address, + result); return &result->base; } + +/* C plug-in wrapper. */ + +#define FORWARD(OP,...) m_context->c_ops->OP(m_context, ##__VA_ARGS__) +#define GCC_METHOD0(R, N) \ + R gcc_c_plugin::N () const \ + { return FORWARD (N); } +#define GCC_METHOD1(R, N, A) \ + R gcc_c_plugin::N (A a) const \ + { return FORWARD (N, a); } +#define GCC_METHOD2(R, N, A, B) \ + R gcc_c_plugin::N (A a, B b) const \ + { return FORWARD (N, a, b); } +#define GCC_METHOD3(R, N, A, B, C) \ + R gcc_c_plugin::N (A a, B b, C c) const \ + { return FORWARD (N, a, b, c); } +#define GCC_METHOD4(R, N, A, B, C, D) \ + R gcc_c_plugin::N (A a, B b, C c, D d) const \ + { return FORWARD (N, a, b, c, d); } +#define GCC_METHOD5(R, N, A, B, C, D, E) \ + R gcc_c_plugin::N (A a, B b, C c, D d, E e) const \ + { return FORWARD (N, a, b, c, d, e); } +#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ + R gcc_c_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \ + { return FORWARD (N, a, b, c, d, e, f, g); } + +#include "gcc-c-fe.def" + +#undef GCC_METHOD0 +#undef GCC_METHOD1 +#undef GCC_METHOD2 +#undef GCC_METHOD3 +#undef GCC_METHOD4 +#undef GCC_METHOD5 +#undef GCC_METHOD7 +#undef FORWARD diff --git a/gdb/compile/compile-c.h b/gdb/compile/compile-c.h index cff2aef906..ffa58021e2 100644 --- a/gdb/compile/compile-c.h +++ b/gdb/compile/compile-c.h @@ -18,6 +18,7 @@ #define GDB_COMPILE_C_H #include "common/enum-flags.h" +#include "gcc-c-plugin.h" #include "hashtab.h" /* enum-flags wrapper. */ @@ -46,12 +47,10 @@ struct compile_c_instance /* Map from gdb symbols to gcc error messages to emit. */ htab_t symbol_err_map; -}; - -/* A helper macro that takes a compile_c_instance and returns its - corresponding gcc_c_context. */ -#define C_CTX(I) ((struct gcc_c_context *) ((I)->base.fe)) + /* GCC C plugin. */ + gcc_c_plugin *c_plugin; +}; /* Emit code to compute the address for all the local variables in scope at PC in BLOCK. Returns a malloc'd vector, indexed by gdb diff --git a/gdb/compile/gcc-c-plugin.h b/gdb/compile/gcc-c-plugin.h new file mode 100644 index 0000000000..12d422f6aa --- /dev/null +++ b/gdb/compile/gcc-c-plugin.h @@ -0,0 +1,64 @@ +/* GCC C plug-in wrapper for GDB. + + Copyright (C) 2018 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +/* A class representing the C plug-in. */ + +class gcc_c_plugin +{ +public: + + explicit gcc_c_plugin (struct gcc_c_context *gcc_c) + : m_context (gcc_c) + { + } + + /* Set the oracle callbacks to be used by the compiler plug-in. */ + void set_callbacks (gcc_c_oracle_function *binding_oracle, + gcc_c_symbol_address_function *address_oracle, + void *datum) + { + m_context->c_ops->set_callbacks (m_context, binding_oracle, + address_oracle, datum); + } + + /* Returns the interface version of the compiler plug-in. */ + int version () const { return m_context->c_ops->c_version; } + +#define GCC_METHOD0(R, N) R N () const; +#define GCC_METHOD1(R, N, A) R N (A) const; +#define GCC_METHOD2(R, N, A, B) R N (A, B) const; +#define GCC_METHOD3(R, N, A, B, C) R N (A, B, C) const; +#define GCC_METHOD4(R, N, A, B, C, D) R N (A, B, C, D) const; +#define GCC_METHOD5(R, N, A, B, C, D, E) R N (A, B, C, D, E) const; +#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) R N (A, B, C, D, E, F, G) const; + +#include "gcc-c-fe.def" + +#undef GCC_METHOD0 +#undef GCC_METHOD1 +#undef GCC_METHOD2 +#undef GCC_METHOD3 +#undef GCC_METHOD4 +#undef GCC_METHOD5 +#undef GCC_METHOD7 + +private: + /* The GCC C context. */ + struct gcc_c_context *m_context; +};