From 37af486a23dbed5ff5003392c42495f4b68afb71 Mon Sep 17 00:00:00 2001 From: aoliva Date: Tue, 31 Jan 2017 01:02:03 +0000 Subject: Introduce C++ support in libcc1 Extend libcc1's with an API for C++ support. Extend libcc1's C API to distinguish between integral types with the same width, as in C++. Likewise for float types. Export small bits of functionality from the C++ front-end for use in libcc1. Add support for the C++ front-end to look up names and addresses using a libcc1-registered binding oracle. Add support for global friends. for gcc/cp/ChangeLog Introduce C++ support in libcc1. * cp-tree.h (struct lang_identifier): Add oracle_looked_up. (ansi_opname): Rename to... (cp_operator_id): ... this. Adjust all callers. (ansi_assopname): Rename to... (cp_assignment_operator_id): ... this. Adjust all callers. (cp_literal_operator_id): Declare. (set_global_friend): Declare. (is_global_friend): Declare. (enum cp_oracle_request): New type. (cp_binding_oracle_function): New type. (cp_binding_oracle): Declare. (cp_finish_injected_record_type): Declare. * friend.c (global_friend): New var. (set_global_friend): New fn. (is_global_friend): New fn. (is_friend): Call is_global_friend. * name-lookup.c (cp_binding_oracle): New var. (query_oracle): New fn. (qualified_lookup_using_namespace): Call query_oracle. (lookup_name_real_1): Likewise. * parser.c (cp_literal_operator_id): Drop static. * search.c (friend_accessible_p): Call is_global_friend. * semantics.c (is_this_parameter): Accept a variable if the binding oracle is enabled. for include/ChangeLog Introduce C++ support in libcc1. * gcc-c-fe.def (int_type_v0): Rename from... (int_type): ... this. Introduce new version. (float_type_v0): Rename from... (float_type): ... this. Introduce new version. (char_type): New. * gcc-c-interface.h (gcc_c_api_version): Add GCC_C_FE_VERSION_1. (gcc_type_array): Move... * gcc-interface.h: ... here. * gcc-cp-fe.def: New. * gcc-cp-interface.h: New. for libcc1/ChangeLog Introduce C++ support. * Makefile.am (AM_CPPFLAGS): Move some -I flags to... (CPPFLAGS_FOR_C_FAMILY, CPPFLAGS_FOR_C, CPPFLAGS_FOR_CXX): ... new macros. (plugin_LTLIBRARIES): Add libcp1plugin.la. (BUILT_SOURCES, MOSTLYCLEANFILES): Add... (cp-compiler-name.h): ... this. New. (c-compiler-name.h): Rename all over from... (compiler-name.h): ... this. Create it atomically. (marshall_c_source, marshall_cxx_source): New macros. (libcc1plugin_la_SOURCES): Rename plugin.cc to libcc1plugin.cc. Add marshall_c_source expansion. (libcc1plugin.lo_CPPFLAGS): New macro. (libcp1plugin_la_LDFLAGS): Likewise. (libcp1plugin_la_SOURCES): Likewise. (libcp1plugin.lo_CPPFLAGS): Likewise. (libcp1plugin_la_LIBADD): Likewise. (libcp1plugin_la_DEPENDENCIES): Likewise. (libcp1plugin_la_LINK): Likewise. (libcc1_la_SOURCES): Added marshall_c_source and marshall_cxx_source expansions. * Makefile.in: Rebuild. * compiler-name.h: Rename all over to... * c-compiler-name.h: ... this. Define C_COMPILER_NAME instead of COMPILER_NAME. * plugin.cc: Rename all over to... * libcc1plugin.cc: ... this. Include marshall-c.hh. (address_rewriter): Drop cleaning up of VLA sizes. (plugin_build_decl): Mark decls as external. (plugin_tagbind): Propagate name to all variants. (build_anonymous_node): New. (plugin_build_record_type): Use it instead of make_node. (plugin_build_union_type): Likewise. (plugin_build_enum_type): Likewise. (plugin_finish_record_or_union): Update all type variants. (safe_lookup_builtin_type): New. (plugin_int_check): Factor out of, and add checks to, ... (plugin_int_type): ... this. Rename to... (plugin_int_type_v0): ... this. (plugin_int_type): New interface, new implementation. (plugin_char_type): New. (plugin_float_type_v0): Rename from... (plugin_float_type): ... this. New interface, new implementation. (plugin_init): Bump handshake version. * libcc1.cc: Include marshall-c.hh. Drop gcc-interface.h. (call_binding_oracle): Rename to... (c_call_binding_oracle): ... this, into anonymous namespace. (call_symbol_address): Rename to... (c_call_symbol_address): ... this, likewise. (GCC_METHOD#): Move methods into cc1plugin::c:: namespace. (libcc1::compiler::find): Refer to C_COMPILER_NAME. (fork_exec): Bump to GCC_C_FE_VERSION_1. (libcc1_compile): Prefix callbacks with c_. (gcc_c_fe_context): Accept GCC_C_FE_VERSION_1. * libcc1.sym: Export gcc_cp_fe_context. * libcp1.cc: New, mostly copied and adjusted from libcc1.cc. * libcp1plugin.cc: New, initially copied from libcc1plugin.cc. * libcp1plugin.sym: New. * marshall-c.hh: New. Move C-specific types from... * marshall.cc: ... this. (cc1_plugin::marshall_array_start): New. (cc1_plugin::marshall_array_elmts): New. (cc1_plugin::marshall for gcc_type_array): Use the above. (cc1_plugin::unmarshall_array_start): New. (cc1_plugin::unmarshall_array_elmts): New. (cc1_plugin::unmarshall for gcc_type_array): Use the above. * marshall.hh: Declare the new array building blocks. Drop C-specific unmarshall declarations. * marshall-cp.hh: New. * names.cc (GCC_METHOD#): Add LANG:: to method names. (LANG): Define while including gcc-c-fe.def and gcc-cp-fe.def. * names.hh: Include gcc-c-fe.def and gcc-cp-fe.def in the corresponding namespaces. * rpc.hh: Don't include marshall.hh. [GCC_CP_INTERFACE_H] (argument_wrapper): Specialize for gcc_vbase_array, gcc_cp_template_args, gcc_cp_function_args. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@245051 138bc75d-0d04-0410-961f-82ee72b054a4 --- libcc1/marshall-cp.hh | 271 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 libcc1/marshall-cp.hh (limited to 'libcc1/marshall-cp.hh') diff --git a/libcc1/marshall-cp.hh b/libcc1/marshall-cp.hh new file mode 100644 index 00000000000..eec80f359a6 --- /dev/null +++ b/libcc1/marshall-cp.hh @@ -0,0 +1,271 @@ +/* Marshalling and unmarshalling of C++-specific types. + Copyright (C) 2014-2017 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC 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, or (at your option) any later +version. + +GCC 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 GCC; see the file COPYING3. If not see +. */ + +#ifndef CC1_PLUGIN_MARSHALL_CXX_HH +#define CC1_PLUGIN_MARSHALL_CXX_HH + +#include "marshall.hh" +#include "gcc-cp-interface.h" + +namespace cc1_plugin +{ + status + unmarshall (connection *conn, enum gcc_cp_symbol_kind *result) + { + protocol_int p; + if (!unmarshall_intlike (conn, &p)) + return FAIL; + *result = (enum gcc_cp_symbol_kind) p; + return OK; + } + + status + unmarshall (connection *conn, enum gcc_cp_oracle_request *result) + { + protocol_int p; + if (!unmarshall_intlike (conn, &p)) + return FAIL; + *result = (enum gcc_cp_oracle_request) p; + return OK; + } + + status + unmarshall (connection *conn, enum gcc_cp_qualifiers *result) + { + protocol_int p; + if (!unmarshall_intlike (conn, &p)) + return FAIL; + *result = (enum gcc_cp_qualifiers) p; + return OK; + } + + status + unmarshall (connection *conn, enum gcc_cp_ref_qualifiers *result) + { + protocol_int p; + if (!unmarshall_intlike (conn, &p)) + return FAIL; + *result = (enum gcc_cp_ref_qualifiers) p; + return OK; + } + + // Send a gcc_vbase_array marker followed by the array. + status + marshall (connection *conn, const gcc_vbase_array *a) + { + size_t len; + + if (a) + len = a->n_elements; + else + len = (size_t)-1; + + if (!marshall_array_start (conn, 'v', len)) + return FAIL; + + if (!a) + return OK; + + if (!marshall_array_elmts (conn, len * sizeof (a->elements[0]), + a->elements)) + return FAIL; + + return marshall_array_elmts (conn, len * sizeof (a->flags[0]), + a->flags); + } + + // Read a gcc_vbase_array marker, followed by a gcc_vbase_array. The + // resulting array must be freed by the caller, using 'delete[]' on + // elements and virtualp, and 'delete' on the array object itself. + status + unmarshall (connection *conn, struct gcc_vbase_array **result) + { + size_t len; + + if (!unmarshall_array_start (conn, 'v', &len)) + return FAIL; + + if (len == (size_t)-1) + { + *result = NULL; + return OK; + } + + struct gcc_vbase_array *gva = new gcc_vbase_array; + + gva->n_elements = len; + gva->elements = new gcc_type[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof (gva->elements[0]), + gva->elements)) + { + delete[] gva->elements; + delete gva; + return FAIL; + } + + gva->flags = new enum gcc_cp_symbol_kind[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof (gva->flags[0]), + gva->flags)) + { + delete[] gva->flags; + delete[] gva->elements; + delete gva; + return FAIL; + } + + *result = gva; + return OK; + } + + // Send a gcc_cp_template_args marker followed by the array. + status + marshall (connection *conn, const gcc_cp_template_args *a) + { + size_t len; + + if (a) + len = a->n_elements; + else + len = (size_t)-1; + + if (!marshall_array_start (conn, 't', len)) + return FAIL; + + if (!a) + return OK; + + if (!marshall_array_elmts (conn, len * sizeof (a->kinds[0]), + a->kinds)) + return FAIL; + + return marshall_array_elmts (conn, len * sizeof (a->elements[0]), + a->elements); + } + + // Read a gcc_vbase_array marker, followed by a gcc_vbase_array. The + // resulting array must be freed by the caller, using 'delete[]' on + // elements and virtualp, and 'delete' on the array object itself. + status + unmarshall (connection *conn, struct gcc_cp_template_args **result) + { + size_t len; + + if (!unmarshall_array_start (conn, 't', &len)) + return FAIL; + + if (len == (size_t)-1) + { + *result = NULL; + return OK; + } + + struct gcc_cp_template_args *gva = new gcc_cp_template_args; + + gva->n_elements = len; + gva->kinds = new char[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof (gva->kinds[0]), + gva->kinds)) + { + delete[] gva->kinds; + delete gva; + return FAIL; + } + + gva->elements = new gcc_cp_template_arg[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof (gva->elements[0]), + gva->elements)) + { + delete[] gva->elements; + delete[] gva->kinds; + delete gva; + return FAIL; + } + + *result = gva; + return OK; + } + + // Send a gcc_cp_function_args marker followed by the array. + status + marshall (connection *conn, const gcc_cp_function_args *a) + { + size_t len; + + if (a) + len = a->n_elements; + else + len = (size_t)-1; + + if (!marshall_array_start (conn, 'd', len)) + return FAIL; + + if (!a) + return OK; + + return marshall_array_elmts (conn, len * sizeof (a->elements[0]), + a->elements); + } + + // Read a gcc_cp_function_args marker, followed by a + // gcc_cp_function_args. The resulting array must be freed + // by the caller, using 'delete[]' on elements and virtualp, and + // 'delete' on the array object itself. + status + unmarshall (connection *conn, struct gcc_cp_function_args **result) + { + size_t len; + + if (!unmarshall_array_start (conn, 'd', &len)) + return FAIL; + + if (len == (size_t)-1) + { + *result = NULL; + return OK; + } + + struct gcc_cp_function_args *gva = new gcc_cp_function_args; + + gva->n_elements = len; + gva->elements = new gcc_expr[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof (gva->elements[0]), + gva->elements)) + { + delete[] gva->elements; + delete gva; + return FAIL; + } + + *result = gva; + + return OK; + } +} + +#endif // CC1_PLUGIN_MARSHALL_CP_HH -- cgit v1.2.1