Tcwg-commits July 2015

tcwg-commits@lists.linaro.org

2 participants
1355 discussions

[gcc] branch trunk updated (8a93a82 -> d145b68)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch trunk in repository gcc. from 8a93a82 gcc/ * target-insns.def (reload_load_address): New targetm i [...] new d145b68 gcc/ 2015-07-28 David Sherwood <david.sherwood(a)arm.com> The 1 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 23 +++++++++++++++++++++++ gcc/config/arm/arm.c | 13 ++++--------- gcc/config/i386/i386.c | 11 +++++------ gcc/config/spu/spu.c | 4 +--- gcc/expmed.c | 4 ---- gcc/fold-const.c | 2 +- gcc/genmodes.c | 4 ++-- gcc/lto-streamer-out.c | 4 ++-- gcc/machmode.h | 20 ++++++-------------- gcc/rtlanal.c | 5 +---- gcc/simplify-rtx.c | 10 +++------- gcc/stor-layout.c | 14 +------------- 12 files changed, 49 insertions(+), 65 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] branch trunk updated (4dd7c28 -> 8a93a82)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch trunk in repository gcc. from 4dd7c28 gcc/ * target-insns.def (can_extend, ptr_extend): New target [...] new f37fec3 gcc/ * target-insns.def (atomic_test_and_set): New targetm i [...] new 8a93a82 gcc/ * target-insns.def (reload_load_address): New targetm i [...] The 2 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 13 +++++++++++++ gcc/optabs.c | 15 +++++---------- gcc/reload1.c | 6 ++---- gcc/target-insns.def | 2 ++ 4 files changed, 22 insertions(+), 14 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] branch master updated (4dd7c28 -> 8a93a82)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch master in repository gcc. from 4dd7c28 gcc/ * target-insns.def (can_extend, ptr_extend): New target [...] new f37fec3 gcc/ * target-insns.def (atomic_test_and_set): New targetm i [...] new 8a93a82 gcc/ * target-insns.def (reload_load_address): New targetm i [...] The 2 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 13 +++++++++++++ gcc/optabs.c | 15 +++++---------- gcc/reload1.c | 6 ++---- gcc/target-insns.def | 2 ++ 4 files changed, 22 insertions(+), 14 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] branch master updated (68aee03 -> 4dd7c28)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch master in repository gcc. from 68aee03 gcc/ * config/fr30/fr30.md (indirect_jump): Use pmode_regist [...] new de4e153 gcc/ * target-insns.def (indirect_jump): New targetm instruc [...] new f027535 gcc/ * target-insns.def (eh_return): New targetm instruction [...] new 4dd7c28 gcc/ * target-insns.def (can_extend, ptr_extend): New target [...] The 3 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 24 ++++++++++++++++++++++++ gcc/emit-rtl.c | 7 ++++--- gcc/except.c | 6 ++---- gcc/function.c | 2 -- gcc/optabs.c | 17 +++++++---------- gcc/rtlanal.c | 10 ++++++---- gcc/simplify-rtx.c | 10 ++++++---- gcc/target-insns.def | 4 ++++ 8 files changed, 53 insertions(+), 27 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] branch trunk updated (68aee03 -> 4dd7c28)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch trunk in repository gcc. from 68aee03 gcc/ * config/fr30/fr30.md (indirect_jump): Use pmode_regist [...] new de4e153 gcc/ * target-insns.def (indirect_jump): New targetm instruc [...] new f027535 gcc/ * target-insns.def (eh_return): New targetm instruction [...] new 4dd7c28 gcc/ * target-insns.def (can_extend, ptr_extend): New target [...] The 3 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 24 ++++++++++++++++++++++++ gcc/emit-rtl.c | 7 ++++--- gcc/except.c | 6 ++---- gcc/function.c | 2 -- gcc/optabs.c | 17 +++++++---------- gcc/rtlanal.c | 10 ++++++---- gcc/simplify-rtx.c | 10 ++++++---- gcc/target-insns.def | 4 ++++ 8 files changed, 53 insertions(+), 27 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] branch trunk updated (63593ac -> 68aee03)

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a change to branch trunk in repository gcc. from 63593ac 2015-07-28 Eric Gallager <egall(a)gwmail.gwu.edu> new 68aee03 gcc/ * config/fr30/fr30.md (indirect_jump): Use pmode_regist [...] The 1 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Summary of changes: gcc/ChangeLog | 5 +++++ gcc/config/fr30/fr30.md | 4 ++-- 2 files changed, 7 insertions(+), 2 deletions(-) -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] 13/20: Revamp the libcp1plugin API to support classes and namespaces.

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a commit to branch aoliva/libcp1 in repository gcc. commit 7b24d7dbc6e5863cb3769ff2fbb0c8dc10d464d0 Author: Alexandre Oliva <aoliva(a)redhat.com> Date: Mon Jun 29 06:28:09 2015 -0300 Revamp the libcp1plugin API to support classes and namespaces. --- include/gcc-cp-fe.def | 152 +++++++++++------ include/gcc-cp-interface.h | 57 +++++-- libcc1/libcc1.cc | 14 +- libcc1/libcp1.cc | 14 +- libcc1/libcp1plugin.cc | 403 +++++++++++++++++++++++++++++++++------------ libcc1/marshall-cp.hh | 81 +++++++++ libcc1/marshall.cc | 57 ++++++- libcc1/marshall.hh | 6 + libcc1/names.cc | 20 ++- libcc1/names.hh | 18 +- libcc1/rpc.hh | 39 +++++ 11 files changed, 667 insertions(+), 194 deletions(-) diff --git a/include/gcc-cp-fe.def b/include/gcc-cp-fe.def index 63b5378..56dc079 100644 --- a/include/gcc-cp-fe.def +++ b/include/gcc-cp-fe.def @@ -19,8 +19,29 @@ -/* Create a new "decl" in GCC. A decl is a declaration, basically a - kind of symbol. +/* Push namespace NAME as the current binding level, to which + newly-introduced decls will be bound. An empty string identifies + the global namespace, whereas NULL identifies an anonymous + namespace. A namespace named NAME is created in the current scope, + if needed. */ + +GCC_METHOD1 (int, push_namespace, + const char *) /* Argument NAME. */ + +// FIXME: inline namespaces, anyone? + +/* Pop the namespace last entered with push_namespace, restoring the + binding level in effect before the matching push_namespace. */ + +GCC_METHOD0 (int, pop_namespace) + +/* Return the NAMESPACE_DECL, TYPE_DECL or FUNCTION_DECL of the + current binding level. */ + +GCC_METHOD0 (gcc_decl, get_current_binding_level) + +/* Create a new "decl" in GCC, and bind it in the current binding + level. A decl is a declaration, basically a kind of symbol. NAME is the name of the new symbol. SYM_KIND is the kind of symbol being requested. SYM_TYPE is the new symbol's C++ type; @@ -31,82 +52,103 @@ an address (e.g., functions), ADDRESS is the address. FILENAME and LINE_NUMBER refer to the symbol's source location. If this is not known, FILENAME can be NULL and LINE_NUMBER can be 0. - This function returns the new decl. */ - -GCC_METHOD7 (gcc_decl, build_decl, + This function returns the new decl. + + Use this function to register typedefs, functions and variables to + namespace and local binding levels, and typedefs, member functions + (static or not), and static data members to class binding levels. + Note that, since access controls are disabled, we have no means to + express private, protected and public. + + FIXME: we would benefit from a gcc_decl argument, to be able to + introduce friend declarations (what for? we disable access + control), using declarations, using directives and namespace + aliases. + + FIXME: How about override and final virtual functions; =delete and + =default ctor, dtor and copy-assignment declarations; explicit + ctors and conversion operators; thread_local variables; other + attributes? Do we need an extra flags parameter, or just + additional gcc_cp_symbol_kinds? */ + +GCC_METHOD7 (gcc_decl, new_decl, const char *, /* Argument NAME. */ - enum gcc_cp_symbol_kind,/* Argument SYM_KIND. */ + enum gcc_cp_symbol_kind, /* Argument SYM_KIND. */ gcc_type, /* Argument SYM_TYPE. */ const char *, /* Argument SUBSTITUTION_NAME. */ gcc_address, /* Argument ADDRESS. */ const char *, /* Argument FILENAME. */ unsigned int) /* Argument LINE_NUMBER. */ -/* Insert a GCC decl into the symbol table. DECL is the decl to - insert. IS_GLOBAL is true if this is an outermost binding, and - false if it is a possibly-shadowing binding. */ +/* Return the type of a pointer to a given base type. */ -GCC_METHOD2 (int /* bool */, bind, - gcc_decl, /* Argument DECL. */ - int /* bool */) /* Argument IS_GLOBAL. */ -/* FIXME: do we want a namespace instead of IS_GLOBAL? */ +GCC_METHOD1 (gcc_type, build_pointer_type, + gcc_type) /* Argument BASE_TYPE. */ -/* Insert a tagged type into the symbol table. NAME is the tag name - of the type and TAGGED_TYPE is the type itself. TAGGED_TYPE must - be either a struct, union, or enum type, as these are the only - types that have tags. FILENAME and LINE_NUMBER refer to the type's - source location. If this is not known, FILENAME can be NULL and - LINE_NUMBER can be 0. */ +// FIXME: we need reference types and pointer-to-member types. -GCC_METHOD4 (int /* bool */, tagbind, +/* Create a new 'class' (or 'struct') type, record it in the current + binding level, and enter its own binding level. Initially it has + no fields. + + NAME is the class name. BASE_CLASSES indicate the base classes of + class NAME. FILENAME and LINE_NUMBER specify the source location + associated with the class. */ + +GCC_METHOD4 (gcc_type, start_new_class_type, const char *, /* Argument NAME. */ - gcc_type, /* Argument TAGGED_TYPE. */ + const struct gcc_vbase_array *,/* Argument BASE_CLASSES. */ const char *, /* Argument FILENAME. */ unsigned int) /* Argument LINE_NUMBER. */ -/* Return the type of a pointer to a given base type. */ - -GCC_METHOD1 (gcc_type, build_pointer_type, - gcc_type) /* Argument BASE_TYPE. */ +// FIXME: do we need a flag to distinguish structs and classes? This +// would be beneficial at least for error messages. -/* Create a new 'struct' type. Initially it has no fields. */ +/* Create a new 'union' type, record it in the current binding level, + and enter its own binding level. Initially it has no fields. -GCC_METHOD0 (gcc_type, build_record_type) + NAME is the union name. FILENAME and LINE_NUMBER specify its + source location. */ -/* Create a new 'union' type. Initially it has no fields. */ +GCC_METHOD3 (gcc_type, start_new_union_type, + const char *, /* Argument NAME. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ -GCC_METHOD0 (gcc_type, build_union_type) +/* Add a non-static data member to a struct or union type. FIELD_NAME + is the field's name. FIELD_TYPE is the type of the field. BITSIZE + and BITPOS indicate where in the struct the field occurs. -/* Add a field to a struct or union type. FIELD_NAME is the field's - name. FIELD_TYPE is the type of the field. BITSIZE and BITPOS - indicate where in the struct the field occurs. */ + FIXME: how about mutable data members? */ -GCC_METHOD5 (int /* bool */, build_add_field, +GCC_METHOD5 (int /* bool */, new_field, gcc_type, /* Argument RECORD_OR_UNION_TYPE. */ const char *, /* Argument FIELD_NAME. */ gcc_type, /* Argument FIELD_TYPE. */ unsigned long, /* Argument BITSIZE. */ unsigned long) /* Argument BITPOS. */ -/* FIXME: can we use the above for member functions, particularly - virtual ones? */ - -/* FIXME: we need some means to add base classes. */ - -/* FIXME: we need some means to introduce namespaces. */ -/* After all the fields have been added to a struct or union, the - struct or union type must be "finished". This does some final - cleanups in GCC. */ +/* After all the fields have been added to a struct, class or union, + the struct or union type must be "finished". This does some final + cleanups in GCC, and pops to the binding level that was in effect + before the matching build_class_type or build_union_type. */ GCC_METHOD2 (int /* bool */, finish_record_or_union, gcc_type, /* Argument RECORD_OR_UNION_TYPE. */ unsigned long) /* Argument SIZE_IN_BYTES. */ -/* Create a new 'enum' type. The new type initially has no - associated constants. */ +/* Create a new 'enum' type, and record it in the current binding + level. The new type initially has no associated constants. -GCC_METHOD1 (gcc_type, build_enum_type, - gcc_type) /* Argument UNDERLYING_INT_TYPE. */ + NAME is the enum name. FILENAME and LINE_NUMBER specify its source + location. */ + +GCC_METHOD5 (gcc_type, start_new_enum_type, + const char *, /* Argument NAME. */ + gcc_type, /* Argument UNDERLYING_INT_TYPE. */ + int /* bool */, /* Argument SCOPED_ENUM_P. */ + const char *, /* Argument FILENAME. */ + unsigned int) /* Argument LINE_NUMBER. */ /* Add a new constant to an enum type. NAME is the constant's name and VALUE is its value. */ @@ -129,13 +171,25 @@ GCC_METHOD1 (int /* bool */, finish_enum_type, GCC_METHOD3 (gcc_type, build_function_type, gcc_type, /* Argument RETURN_TYPE. */ - const struct gcc_type_array *, /* Argument ARGUMENT_TYPES. */ - int /* bool */) /* Argument IS_VARARGS. */ + const struct gcc_type_array *,/* Argument ARGUMENT_TYPES. */ + int /* bool */) /* Argument IS_VARARGS. */ + +/* Create a new non-static member function type. FUNC_TYPE is the + method prototype, without the implicit THIS pointer, added as a + pointer to the QUALS-qualified CLASS_TYPE. */ + +GCC_METHOD4 (gcc_type, build_method_type, + gcc_type, /* Argument CLASS_TYPE. */ + gcc_type, /* Argument FUNC_TYPE. */ + enum gcc_cp_qualifiers, /* Argument QUALS. */ + enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ + +// FIXME: add a type-variant builder to add exception type specifiers. /* Return an integer type with the given properties. */ GCC_METHOD2 (gcc_type, int_type, - int /* bool */, /* Argument IS_UNSIGNED. */ + int /* bool */, /* Argument IS_UNSIGNED. */ unsigned long) /* Argument SIZE_IN_BYTES. */ /* Return a floating point type with the given properties. */ diff --git a/include/gcc-cp-interface.h b/include/gcc-cp-interface.h index 264a56c..a4b3be0 100644 --- a/include/gcc-cp-interface.h +++ b/include/gcc-cp-interface.h @@ -34,14 +34,14 @@ extern "C" { struct gcc_cp_context; /* - * Definitions and declarations for the C front end. + * Definitions and declarations for the C++ front end. */ -/* Defined versions of the C front-end API. */ +/* Defined versions of the C++ front-end API. */ enum gcc_cp_api_version { - GCC_CP_FE_VERSION_0 = 1 + GCC_CP_FE_VERSION_0 = 0xffffffff-1 }; /* Qualifiers. */ @@ -53,6 +53,32 @@ enum gcc_cp_qualifiers GCC_CP_QUALIFIER_RESTRICT = 4 }; +/* Ref qualifiers. */ + +enum gcc_cp_ref_qualifiers { + GCC_CP_REF_QUAL_NONE = 0, + GCC_CP_REF_QUAL_LVALUE = 1, + GCC_CP_REF_QUAL_RVALUE = 2 +}; + +/* An array of types used for creating lists of base classes. */ + +struct gcc_vbase_array +{ + /* Number of elements. */ + + int n_elements; + + /* The base classes. */ + + gcc_type *elements; + + /* Indicate virtual base classes. + Take elements[i] as a virtual base class iff virtualp[i]. */ + + char /* bool */ *virtualp; +}; + /* This enumerates the kinds of decls that GDB can create. */ enum gcc_cp_symbol_kind @@ -71,7 +97,14 @@ enum gcc_cp_symbol_kind /* A label. */ - GCC_CP_SYMBOL_LABEL + GCC_CP_SYMBOL_LABEL, + + /* A virtual member function. */ + + GCC_CP_SYMBOL_VIRTUAL_FUNCTION + + // FIXME: should we have separate symbol kinds for operator + // functions, ctors, dtors, vtables, rtti, etc? }; /* This enumerates the types of symbols that GCC might request from @@ -80,11 +113,13 @@ enum gcc_cp_symbol_kind enum gcc_cp_oracle_request { /* An ordinary symbol -- a variable, function, typedef, or enum - constant. */ + constant. All namespace-scoped symbols with the requested name + should be defined in response to this request. */ GCC_CP_ORACLE_SYMBOL, - /* A struct, union, or enum tag. */ + /* A struct, union, or enum tag. All members of the tagged type + should be defined in response to this request. */ GCC_CP_ORACLE_TAG, @@ -100,16 +135,16 @@ enum gcc_cp_oracle_request being requested, and IDENTIFIER is the name of the symbol. */ typedef void gcc_cp_oracle_function (void *datum, - struct gcc_cp_context *context, - enum gcc_cp_oracle_request request, - const char *identifier); + struct gcc_cp_context *context, + enum gcc_cp_oracle_request request, + const char *identifier); /* The type of the function called by GCC to ask GDB for a symbol's address. This should return 0 if the address is not known. */ typedef gcc_address gcc_cp_symbol_address_function (void *datum, - struct gcc_cp_context *ctxt, - const char *identifier); + struct gcc_cp_context *ctxt, + const char *identifier); /* The vtable used by the C front end. */ diff --git a/libcc1/libcc1.cc b/libcc1/libcc1.cc index 9db9624..efbd711 100644 --- a/libcc1/libcc1.cc +++ b/libcc1/libcc1.cc @@ -249,19 +249,19 @@ static const struct gcc_c_fe_vtable c_vtable = set_callbacks, #define GCC_METHOD0(R, N) \ - rpc<R, cc1_plugin::N>, + rpc<R, cc1_plugin::c::N>, #define GCC_METHOD1(R, N, A) \ - rpc<R, cc1_plugin::N, A>, + rpc<R, cc1_plugin::c::N, A>, #define GCC_METHOD2(R, N, A, B) \ - rpc<R, cc1_plugin::N, A, B>, + rpc<R, cc1_plugin::c::N, A, B>, #define GCC_METHOD3(R, N, A, B, C) \ - rpc<R, cc1_plugin::N, A, B, C>, + rpc<R, cc1_plugin::c::N, A, B, C>, #define GCC_METHOD4(R, N, A, B, C, D) \ - rpc<R, cc1_plugin::N, A, B, C, D>, + rpc<R, cc1_plugin::c::N, A, B, C, D>, #define GCC_METHOD5(R, N, A, B, C, D, E) \ - rpc<R, cc1_plugin::N, A, B, C, D, E>, + rpc<R, cc1_plugin::c::N, A, B, C, D, E>, #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ - rpc<R, cc1_plugin::N, A, B, C, D, E, F, G>, + rpc<R, cc1_plugin::c::N, A, B, C, D, E, F, G>, #include "gcc-c-fe.def" diff --git a/libcc1/libcp1.cc b/libcc1/libcp1.cc index 4ee5825..3827be3 100644 --- a/libcc1/libcp1.cc +++ b/libcc1/libcp1.cc @@ -249,19 +249,19 @@ static const struct gcc_cp_fe_vtable cp_vtable = set_callbacks, #define GCC_METHOD0(R, N) \ - rpc<R, cc1_plugin::N>, + rpc<R, cc1_plugin::cp::N>, #define GCC_METHOD1(R, N, A) \ - rpc<R, cc1_plugin::N, A>, + rpc<R, cc1_plugin::cp::N, A>, #define GCC_METHOD2(R, N, A, B) \ - rpc<R, cc1_plugin::N, A, B>, + rpc<R, cc1_plugin::cp::N, A, B>, #define GCC_METHOD3(R, N, A, B, C) \ - rpc<R, cc1_plugin::N, A, B, C>, + rpc<R, cc1_plugin::cp::N, A, B, C>, #define GCC_METHOD4(R, N, A, B, C, D) \ - rpc<R, cc1_plugin::N, A, B, C, D>, + rpc<R, cc1_plugin::cp::N, A, B, C, D>, #define GCC_METHOD5(R, N, A, B, C, D, E) \ - rpc<R, cc1_plugin::N, A, B, C, D, E>, + rpc<R, cc1_plugin::cp::N, A, B, C, D, E>, #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ - rpc<R, cc1_plugin::N, A, B, C, D, E, F, G>, + rpc<R, cc1_plugin::cp::N, A, B, C, D, E, F, G>, #include "gcc-cp-fe.def" diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc index 9acfe16..173b21d 100644 --- a/libcc1/libcp1plugin.cc +++ b/libcc1/libcp1plugin.cc @@ -348,15 +348,93 @@ rewrite_decls_to_addresses (void *function_in, void *) +static inline tree +safe_pushtag (tree name, tree type, tag_scope scope) +{ + void (*save_oracle) (enum cp_oracle_request, tree identifier); + + save_oracle = cp_binding_oracle; + cp_binding_oracle = NULL; + + tree ret = pushtag (name, type, scope); + + cp_binding_oracle = save_oracle; + + return ret; +} + +static inline tree +safe_pushdecl_maybe_friend (tree decl, bool is_friend) +{ + void (*save_oracle) (enum cp_oracle_request, tree identifier); + + save_oracle = cp_binding_oracle; + cp_binding_oracle = NULL; + + tree ret = pushdecl_maybe_friend (decl, is_friend); + + cp_binding_oracle = save_oracle; + + return ret; +} + + + +int +plugin_push_namespace (cc1_plugin::connection *self, + const char *name) +{ + (void)self; + + if (name && !*name) + push_to_top_level (); + else + push_namespace (name ? get_identifier (name) : NULL); + + return 0; +} + +int +plugin_pop_namespace (cc1_plugin::connection *self) +{ + (void)self; + + if (toplevel_bindings_p () && current_namespace == global_namespace) + pop_from_top_level (); + else + pop_namespace (); + + return 0; +} + +gcc_decl +plugin_get_current_binding_level (cc1_plugin::connection *self) +{ + (void)self; + + tree decl; + + if (current_class_type) + decl = TYPE_NAME (current_class_type); + else if (current_function_decl) + decl = current_function_decl; + else if (toplevel_bindings_p ()) + decl = current_namespace; + else + gcc_unreachable (); + + return convert_out (decl); +} + gcc_decl -plugin_build_decl (cc1_plugin::connection *self, - const char *name, - enum gcc_cp_symbol_kind sym_kind, - gcc_type sym_type_in, - const char *substitution_name, - gcc_address address, - const char *filename, - unsigned int line_number) +plugin_new_decl (cc1_plugin::connection *self, + const char *name, + enum gcc_cp_symbol_kind sym_kind, + gcc_type sym_type_in, + const char *substitution_name, + gcc_address address, + const char *filename, + unsigned int line_number) { plugin_context *ctx = static_cast<plugin_context *> (self); { // FIXME in gdb: @@ -438,64 +516,11 @@ plugin_build_decl (cc1_plugin::connection *self, **slot = value; } - return convert_out (ctx->preserve (decl)); -} - -int -plugin_bind (cc1_plugin::connection *, - gcc_decl decl_in, int is_global) -{ - tree decl = convert_in (decl_in); - - if (is_global) - push_nested_namespace (global_namespace); + decl = safe_pushdecl_maybe_friend (decl, false); - pushdecl_maybe_friend (decl, false); + rest_of_decl_compilation (decl, toplevel_bindings_p (), 0); - if (is_global) - pop_nested_namespace (global_namespace); - - rest_of_decl_compilation (decl, is_global, 0); - return 1; -} - -// g++ really wants types to have names, even when they're anonymous. -// FIXME: we can't tell actual anonymous types. We should have type -// names specified earlier, otherwise we'll create wrong bindings -// within class defs. Maybe have a separate call to set scope, name -// and base classes wouldn't be a bad idea. - -static tree -get_placeholder_identifier () -{ - static tree name_placeholder; - if (!name_placeholder) - name_placeholder = get_identifier ("name placeholder"); - return name_placeholder; -} - -void -cp_pushtag (location_t loc, tree name, tree type) -{ - tree decl = TYPE_NAME (type); - DECL_SOURCE_LOCATION (decl) = loc; - gcc_assert (DECL_NAME (decl) == name - || DECL_NAME (decl) == get_placeholder_identifier ()); - DECL_NAME (decl) = name; // FIXME: drop name_placeholder - pushtag (name, type, ts_global); -} - -int -plugin_tagbind (cc1_plugin::connection *self, - const char *name, gcc_type tagged_type, - const char *filename, unsigned int line_number) -{ - plugin_context *ctx = static_cast<plugin_context *> (self); - push_nested_namespace (global_namespace); // FIXME - cp_pushtag (ctx->get_source_location (filename, line_number), - get_identifier (name), convert_in (tagged_type)); - pop_nested_namespace (global_namespace); // FIXME - return 1; + return convert_out (ctx->preserve (decl)); } gcc_type @@ -509,41 +534,74 @@ plugin_build_pointer_type (cc1_plugin::connection *, // TYPE_NAME needs to be a valid pointer, even if there is no name available. static tree -build_named_class_type (enum tree_code code) +build_named_class_type (enum tree_code code, + const char *name, + const gcc_vbase_array *base_classes, + source_location loc) { - tree node; - push_nested_namespace (global_namespace); // FIXME - node = make_class_type (code); - tree type_decl = build_decl (input_location, TYPE_DECL, - get_placeholder_identifier (), node); - TYPE_NAME (node) = type_decl; - TYPE_STUB_DECL (node) = type_decl; - xref_basetypes (node, NULL); - begin_class_definition (node); - return node; + tree type = make_class_type (code); + tree id = name ? get_identifier (name) : make_anon_name (); + tree type_decl = build_decl (loc, TYPE_DECL, id, type); + TYPE_NAME (type) = type_decl; + TYPE_STUB_DECL (type) = type_decl; + safe_pushtag (id, type, ts_current); + + tree bases = NULL; + if (base_classes) + { + for (int i = 0; i < base_classes->n_elements; i++) + { + tree base = finish_base_specifier + (convert_in (base_classes->elements[i]), + access_default_node, base_classes->virtualp[i]); + TREE_CHAIN (base) = bases; + bases = base; + } + bases = nreverse (bases); + } + xref_basetypes (type, bases); + begin_class_definition (type); + return type; } gcc_type -plugin_build_record_type (cc1_plugin::connection *self) +plugin_start_new_class_type (cc1_plugin::connection *self, + const char *name, + const gcc_vbase_array *base_classes, + const char *filename, + unsigned int line_number) { plugin_context *ctx = static_cast<plugin_context *> (self); - return convert_out (ctx->preserve (build_named_class_type (RECORD_TYPE))); + + tree type = build_named_class_type (RECORD_TYPE, name, base_classes, + ctx->get_source_location (filename, + line_number)); + + return convert_out (ctx->preserve (type)); } gcc_type -plugin_build_union_type (cc1_plugin::connection *self) +plugin_start_new_union_type (cc1_plugin::connection *self, + const char *name, + const char *filename, + unsigned int line_number) { plugin_context *ctx = static_cast<plugin_context *> (self); - return convert_out (ctx->preserve (build_named_class_type (UNION_TYPE))); + + tree type = build_named_class_type (UNION_TYPE, name, NULL, + ctx->get_source_location (filename, + line_number)); + + return convert_out (ctx->preserve (type)); } int -plugin_build_add_field (cc1_plugin::connection *, - gcc_type record_or_union_type_in, - const char *field_name, - gcc_type field_type_in, - unsigned long bitsize, - unsigned long bitpos) +plugin_new_field (cc1_plugin::connection *, + gcc_type record_or_union_type_in, + const char *field_name, + gcc_type field_type_in, + unsigned long bitsize, + unsigned long bitpos) { tree record_or_union_type = convert_in (record_or_union_type_in); tree field_type = convert_in (field_type_in); @@ -580,9 +638,6 @@ plugin_build_add_field (cc1_plugin::connection *, DECL_CHAIN (decl) = TYPE_FIELDS (record_or_union_type); TYPE_FIELDS (record_or_union_type) = decl; - // Now we may have to retrofit the newly-added binding into the - // active bindings. - return 1; } @@ -597,8 +652,6 @@ plugin_finish_record_or_union (cc1_plugin::connection *, finish_struct (record_or_union_type, NULL); - pop_nested_namespace (global_namespace); // FIXME - gcc_assert (compare_tree_int (TYPE_SIZE_UNIT (record_or_union_type), size_in_bytes) == 0); @@ -606,26 +659,36 @@ plugin_finish_record_or_union (cc1_plugin::connection *, } gcc_type -plugin_build_enum_type (cc1_plugin::connection *self, - gcc_type underlying_int_type_in) +plugin_start_new_enum_type (cc1_plugin::connection *self, + const char *name, + gcc_type underlying_int_type_in, + int scoped_enum_p, + const char *filename, + unsigned int line_number) { + plugin_context *ctx = static_cast<plugin_context *> (self); tree underlying_int_type = convert_in (underlying_int_type_in); if (underlying_int_type == error_mark_node) return convert_out (error_mark_node); bool is_new_type = false; - bool scoped_enum_p = false; // FIXME - push_nested_namespace (global_namespace); // FIXME + tree id = name ? get_identifier (name) : make_anon_name (); - tree result = start_enum (get_placeholder_identifier (), NULL_TREE, - underlying_int_type, scoped_enum_p, &is_new_type); + tree type = start_enum (id, NULL_TREE, + underlying_int_type, !!scoped_enum_p, &is_new_type); gcc_assert (is_new_type); - plugin_context *ctx = static_cast<plugin_context *> (self); - return convert_out (ctx->preserve (result)); + source_location loc = ctx->get_source_location (filename, line_number); + tree type_decl = build_decl (loc, TYPE_DECL, id, type); + TYPE_NAME (type) = type_decl; + TYPE_STUB_DECL (type) = type_decl; + + safe_pushtag (DECL_NAME (type_decl), type, ts_current); + + return convert_out (ctx->preserve (type)); } int @@ -653,8 +716,6 @@ plugin_finish_enum_type (cc1_plugin::connection *, finish_enum_value_list (enum_type); finish_enum (enum_type); - pop_nested_namespace (global_namespace); // FIXME - return 1; } @@ -688,6 +749,45 @@ plugin_build_function_type (cc1_plugin::connection *self, } gcc_type +plugin_build_method_type (cc1_plugin::connection *self, + gcc_type class_type_in, + gcc_type func_type_in, + enum gcc_cp_qualifiers quals_in, + enum gcc_cp_ref_qualifiers rquals_in) +{ + tree class_type = convert_in (class_type_in); + tree func_type = convert_in (func_type_in); + cp_cv_quals quals = 0; + cp_ref_qualifier rquals; + + if ((quals_in & GCC_CP_QUALIFIER_CONST) != 0) + quals |= TYPE_QUAL_CONST; + if ((quals_in & GCC_CP_QUALIFIER_VOLATILE) != 0) + quals |= TYPE_QUAL_VOLATILE; + gcc_assert ((quals_in & GCC_CP_QUALIFIER_RESTRICT) == 0); + + switch (rquals_in) + { + case GCC_CP_REF_QUAL_NONE: + rquals = REF_QUAL_NONE; + break; + case GCC_CP_REF_QUAL_LVALUE: + rquals = REF_QUAL_LVALUE; + break; + case GCC_CP_REF_QUAL_RVALUE: + rquals = REF_QUAL_RVALUE; + break; + default: + gcc_unreachable (); + } + + tree method_type = build_memfn_type (class_type, func_type, quals, rquals); + + plugin_context *ctx = static_cast<plugin_context *> (self); + return convert_out (ctx->preserve (method_type)); +} + +gcc_type plugin_int_type (cc1_plugin::connection *self, int is_unsigned, unsigned long size_in_bytes) { @@ -768,7 +868,7 @@ plugin_build_qualified_type (cc1_plugin::connection *, enum gcc_cp_qualifiers qualifiers) { tree unqualified_type = convert_in (unqualified_type_in); - int quals = 0; + cp_cv_quals quals = 0; if ((qualifiers & GCC_CP_QUALIFIER_CONST) != 0) quals |= TYPE_QUAL_CONST; @@ -814,7 +914,7 @@ plugin_build_constant (cc1_plugin::connection *self, gcc_type type_in, TREE_STATIC (decl) = 1; TREE_READONLY (decl) = 1; cp_finish_decl (decl, cst, true, NULL, LOOKUP_ONLYCONVERTING); - pushdecl_maybe_friend (decl, false); + safe_pushdecl_maybe_friend (decl, false); return 1; } @@ -827,6 +927,105 @@ plugin_error (cc1_plugin::connection *, return convert_out (error_mark_node); } +#if 0 // FIXME: remove me. +gcc_decl +plugin_build_member_decl (cc1_plugin::connection *self, + gcc_decl scope_in, + const char *name, + enum gcc_cp_symbol_kind sym_kind, + gcc_type sym_type_in, + gcc_address address, + const char *filename, + unsigned int line_number) +{ + tree scope = convert_in (scope_in); + tree sym_type = convert_in (sym_type_in); + tree decl; + tree identifier; + + if (!scope) + scope = global_namespace; + + if (name) + identifier = get_identifier (name); + else + identifier = NULL_TREE; + + source_location loc = ctx->get_source_location (filename, line_number); + + switch (sym_kind) { + case GCC_CP_SYMBOL_TYPEDEF: + gcc_assert (identifier); + gcc_assert (!address); + decl = build_decl (loc, TYPE_DECL, identifier, sym_type); + break; + + case GCC_CP_SYMBOL_VARIABLE: + gcc_assert (TREE_CODE (scope) == NAMESPACE_SCOPE + || RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); + gcc_assert (identifier); + gcc_assert (address); + decl = build_decl (loc, VAR_DECL, identifier, sym_type); + DECL_EXTERN (decl) = 1; + break; + + case GCC_CP_SYMBOL_FUNCTION: + { + bool method_p = TREE_CODE (sym_type) == METHOD_TYPE; + bool abstract_p = method_p && !address; + bool virtual_p = abstract_p || method_p && (address & 1) != 0; + + gcc_assert (identifier); + if (method_p) + gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); + else + { + gcc_assert (address); + gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL + || RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); + } + + if (virtual_p && !abstract_p) + address--; + + decl = build_lang_decl (FUNCTION_DECL, identifier, sym_type); + DECL_EXTERN (decl) = 1; + } + break; + + case GCC_CP_SYMBOL_BASE_CLASS: + gcc_assert (!identifier); + gcc_assert (!address); + gcc_assert (sym_type); + // FIXME: xref_basetypes takes a list + return scope_in; + + case GCC_CP_SYMBOL_NAMESPACE: + gcc_assert (!address); + gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL); + decl = build_lang_decl (NAMESPACE_DECL, identifier, void_type_node); + if (identifier && !decl_anon_ns_mem_p (scope)) + TREE_PUBLIC (decl) = 1; + break; + + case GCC_CP_SYMBOL_TYPENAME: + + + case GCC_CP_SYMBOL_LABEL: + default: + error: + gcc_unreachable (); + } + + TREE_USED (decl) = 1; + TREE_ADDRESSABLE (decl) = 1; + DECL_CONTEXT (decl) = FROB_CONTEXT (scope); + /* add the decl and set its address. */ + + return convert_out (ctx->preserve (decl)); +} +#endif + // Perform GC marking. diff --git a/libcc1/marshall-cp.hh b/libcc1/marshall-cp.hh index 45a9dc6..d600ff9 100644 --- a/libcc1/marshall-cp.hh +++ b/libcc1/marshall-cp.hh @@ -54,6 +54,87 @@ namespace cc1_plugin *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->virtualp[0]), + a->virtualp); + } + + // 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; + } + + *result = new gcc_vbase_array; + + (*result)->n_elements = len; + (*result)->elements = new gcc_type[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof ((*result)->elements[0]), + (*result)->elements)) + { + delete[] (*result)->elements; + delete *result; + return FAIL; + } + + (*result)->virtualp = new char[len]; + + if (!unmarshall_array_elmts (conn, + len * sizeof ((*result)->virtualp[0]), + (*result)->virtualp)) + { + delete[] (*result)->virtualp; + delete[] (*result)->elements; + delete *result; + return FAIL; + } + + return OK; + } } #endif // CC1_PLUGIN_MARSHALL_CP_HH diff --git a/libcc1/marshall.cc b/libcc1/marshall.cc index 0e4b77c..9c62c40 100644 --- a/libcc1/marshall.cc +++ b/libcc1/marshall.cc @@ -98,34 +98,77 @@ cc1_plugin::unmarshall (connection *conn, char **result) } cc1_plugin::status -cc1_plugin::marshall (connection *conn, const gcc_type_array *a) +cc1_plugin::marshall_array_start (connection *conn, char id, + size_t n_elements) { - if (!conn->send ('a')) + if (!conn->send (id)) return FAIL; - unsigned long long r = a->n_elements; + unsigned long long r = n_elements; if (!conn->send (&r, sizeof (r))) return FAIL; - return conn->send (a->elements, r * sizeof (a->elements[0])); + return OK; } cc1_plugin::status -cc1_plugin::unmarshall (connection *conn, gcc_type_array **result) +cc1_plugin::marshall_array_elmts (connection *conn, size_t n_bytes, + void *elements) +{ + return conn->send (elements, n_bytes); +} + +cc1_plugin::status +cc1_plugin::unmarshall_array_start (connection *conn, char id, + size_t *n_elements) { unsigned long long len; - if (!conn->require ('a')) + if (!conn->require (id)) return FAIL; if (!conn->get (&len, sizeof (len))) return FAIL; + + *n_elements = len; + + return OK; +} + +cc1_plugin::status +cc1_plugin::unmarshall_array_elmts (connection *conn, size_t n_bytes, + void *elements) +{ + return conn->get (elements, n_bytes); +} + +cc1_plugin::status +cc1_plugin::marshall (connection *conn, const gcc_type_array *a) +{ + size_t len = a->n_elements; + + if (!marshall_array_start (conn, 'a', len)) + return FAIL; + + return marshall_array_elmts (conn, len * sizeof (a->elements[0]), + a->elements); +} + +cc1_plugin::status +cc1_plugin::unmarshall (connection *conn, gcc_type_array **result) +{ + size_t len; + + if (!unmarshall_array_start (conn, 'a', &len)) + return FAIL; *result = new gcc_type_array; (*result)->n_elements = len; (*result)->elements = new gcc_type[len]; - if (!conn->get ((*result)->elements, len * sizeof ((*result)->elements[0]))) + if (!unmarshall_array_elmts (conn, + len * sizeof ((*result)->elements[0]), + (*result)->elements)) { delete[] (*result)->elements; delete *result; diff --git a/libcc1/marshall.hh b/libcc1/marshall.hh index 021ac96..b4a20c5 100644 --- a/libcc1/marshall.hh +++ b/libcc1/marshall.hh @@ -44,6 +44,12 @@ namespace cc1_plugin // integer store it in the out argument. status unmarshall_intlike (connection *, protocol_int *); + status marshall_array_start (connection *, char, size_t); + status marshall_array_elmts (connection *, size_t, void *); + + status unmarshall_array_start (connection *, char, size_t *); + status unmarshall_array_elmts (connection *, size_t, void *); + // A template function that can handle marshalling various integer // objects to the connection. template<typename T> diff --git a/libcc1/names.cc b/libcc1/names.cc index 5ddfa7b..bc635f8 100644 --- a/libcc1/names.cc +++ b/libcc1/names.cc @@ -21,21 +21,27 @@ along with GCC; see the file COPYING3. If not see #include "names.hh" #define GCC_METHOD0(R, N) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD1(R, N, A) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD2(R, N, A, B) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD3(R, N, A, B, C) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD4(R, N, A, B, C, D) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD5(R, N, A, B, C, D, E) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ - const char *cc1_plugin::N = # N; + const char *cc1_plugin::LANG::N = # N; +#define LANG c #include "gcc-c-fe.def" +#undef LANG + +#define LANG cp +#include "gcc-cp-fe.def" +#undef LANG #undef GCC_METHOD0 #undef GCC_METHOD1 diff --git a/libcc1/names.hh b/libcc1/names.hh index 9bda8d5..1a8f352 100644 --- a/libcc1/names.hh +++ b/libcc1/names.hh @@ -22,10 +22,6 @@ along with GCC; see the file COPYING3. If not see namespace cc1_plugin { - // This code defines global string constants, one for each method in - // gcc-c-fe.def. This is needed so that they can be used as - // template arguments elsewhere. - #define GCC_METHOD0(R, N) \ extern const char *N; #define GCC_METHOD1(R, N, A) \ @@ -41,7 +37,21 @@ namespace cc1_plugin #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ extern const char *N; + namespace c + { + // This code defines global string constants, one for each method in + // gcc-c-fe.def. This is needed so that they can be used as + // template arguments elsewhere. #include "gcc-c-fe.def" + } + + namespace cp + { + // This code defines global string constants, one for each method in + // gcc-cp-fe.def. This is needed so that they can be used as + // template arguments elsewhere. +#include "gcc-cp-fe.def" + } #undef GCC_METHOD0 #undef GCC_METHOD1 diff --git a/libcc1/rpc.hh b/libcc1/rpc.hh index 43182a9..be81c49 100644 --- a/libcc1/rpc.hh +++ b/libcc1/rpc.hh @@ -125,6 +125,45 @@ namespace cc1_plugin argument_wrapper &operator= (const argument_wrapper &); }; +#ifdef GCC_CP_INTERFACE_H + // Specialization for gcc_type_array. + template<> + class argument_wrapper<const gcc_vbase_array *> + { + public: + argument_wrapper () : m_object (NULL) { } + ~argument_wrapper () + { + // It would be nicer if gcc_type_array could have a destructor. + // But, it is in code shared with gdb and cannot. + if (m_object != NULL) + { + delete[] m_object->virtualp; + delete[] m_object->elements; + } + delete m_object; + } + + operator const gcc_vbase_array * () const + { + return m_object; + } + + status unmarshall (connection *conn) + { + return ::cc1_plugin::unmarshall (conn, &m_object); + } + + private: + + gcc_vbase_array *m_object; + + // No copying or assignment allowed. + argument_wrapper (const argument_wrapper &); + argument_wrapper &operator= (const argument_wrapper &); + }; +#endif /* GCC_CP_INTERFACE_H */ + // There are two kinds of template functions here: "call" and // "callback". They are each repeated multiple times to handle // different numbers of arguments. (This would be improved with -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] 20/20: libcp1plugin: drop obsolete plugin_build_member_decl draft

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a commit to branch aoliva/libcp1 in repository gcc. commit 86a02fbec424630bc534f738a759568452b5a02b Author: Alexandre Oliva <aoliva(a)redhat.com> Date: Tue Jul 28 16:35:34 2015 -0300 libcp1plugin: drop obsolete plugin_build_member_decl draft --- libcc1/libcp1plugin.cc | 99 -------------------------------------------------- 1 file changed, 99 deletions(-) diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc index b4d9ee28..d7b181d 100644 --- a/libcc1/libcp1plugin.cc +++ b/libcc1/libcp1plugin.cc @@ -1026,105 +1026,6 @@ plugin_error (cc1_plugin::connection *, return convert_out (error_mark_node); } -#if 0 // FIXME: remove me. -gcc_decl -plugin_build_member_decl (cc1_plugin::connection *self, - gcc_decl scope_in, - const char *name, - enum gcc_cp_symbol_kind sym_kind, - gcc_type sym_type_in, - gcc_address address, - const char *filename, - unsigned int line_number) -{ - tree scope = convert_in (scope_in); - tree sym_type = convert_in (sym_type_in); - tree decl; - tree identifier; - - if (!scope) - scope = global_namespace; - - if (name) - identifier = get_identifier (name); - else - identifier = NULL_TREE; - - source_location loc = ctx->get_source_location (filename, line_number); - - switch (sym_kind) { - case GCC_CP_SYMBOL_TYPEDEF: - gcc_assert (identifier); - gcc_assert (!address); - decl = build_decl (loc, TYPE_DECL, identifier, sym_type); - break; - - case GCC_CP_SYMBOL_VARIABLE: - gcc_assert (TREE_CODE (scope) == NAMESPACE_SCOPE - || RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); - gcc_assert (identifier); - gcc_assert (address); - decl = build_decl (loc, VAR_DECL, identifier, sym_type); - DECL_EXTERN (decl) = 1; - break; - - case GCC_CP_SYMBOL_FUNCTION: - { - bool method_p = TREE_CODE (sym_type) == METHOD_TYPE; - bool abstract_p = method_p && !address; - bool virtual_p = abstract_p || method_p && (address & 1) != 0; - - gcc_assert (identifier); - if (method_p) - gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); - else - { - gcc_assert (address); - gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL - || RECORD_OR_UNION_CODE_P (TREE_CODE (scope))); - } - - if (virtual_p && !abstract_p) - address--; - - decl = build_lang_decl (FUNCTION_DECL, identifier, sym_type); - DECL_EXTERN (decl) = 1; - } - break; - - case GCC_CP_SYMBOL_BASE_CLASS: - gcc_assert (!identifier); - gcc_assert (!address); - gcc_assert (sym_type); - // FIXME: xref_basetypes takes a list - return scope_in; - - case GCC_CP_SYMBOL_NAMESPACE: - gcc_assert (!address); - gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL); - decl = build_lang_decl (NAMESPACE_DECL, identifier, void_type_node); - if (identifier && !decl_anon_ns_mem_p (scope)) - TREE_PUBLIC (decl) = 1; - break; - - case GCC_CP_SYMBOL_TYPENAME: - - - case GCC_CP_SYMBOL_LABEL: - default: - error: - gcc_unreachable (); - } - - TREE_USED (decl) = 1; - TREE_ADDRESSABLE (decl) = 1; - DECL_CONTEXT (decl) = FROB_CONTEXT (scope); - /* add the decl and set its address. */ - - return convert_out (ctx->preserve (decl)); -} -#endif - // Perform GC marking. -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] 19/20: libcc1 interface: add C++ refs, memptrs, throw specs

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a commit to branch aoliva/libcp1 in repository gcc. commit 48daf62502f4e8ebc6be3c1e4475e484f99009f8 Author: Alexandre Oliva <aoliva(a)redhat.com> Date: Thu Jul 23 08:09:19 2015 -0300 libcc1 interface: add C++ refs, memptrs, throw specs Add support for reference types, pointers to members, and exception specifications for function and method types. Bumped GCC_CP_FE_VERSION_0. --- include/gcc-cp-fe.def | 49 ++++++++++++++++++++++++-------- include/gcc-cp-interface.h | 2 +- libcc1/libcp1plugin.cc | 69 +++++++++++++++++++++++++++++++++++++++++++++- libcc1/marshall.cc | 16 ++++++++++- 4 files changed, 122 insertions(+), 14 deletions(-) diff --git a/include/gcc-cp-fe.def b/include/gcc-cp-fe.def index 0dc3867..7471581 100644 --- a/include/gcc-cp-fe.def +++ b/include/gcc-cp-fe.def @@ -60,9 +60,11 @@ GCC_METHOD0 (gcc_decl, get_current_binding_level) Note that, since access controls are disabled, we have no means to express private, protected and public. + We have no means to introduce friend declarations, but since we + disable access control, they make no difference whatsoever. + FIXME: we would benefit from a gcc_decl argument, to be able to - introduce friend declarations (what for? we disable access - control), using declarations, using directives and namespace + introduce using declarations, using directives and namespace aliases. FIXME: How about override and final virtual functions; =delete and @@ -85,7 +87,21 @@ GCC_METHOD7 (gcc_decl, new_decl, GCC_METHOD1 (gcc_type, build_pointer_type, gcc_type) /* Argument BASE_TYPE. */ -// FIXME: we need reference types and pointer-to-member types. +/* Return the type of a reference to a given base type. */ + +GCC_METHOD2 (gcc_type, build_reference_type, + gcc_type, /* Argument BASE_TYPE. */ + enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ + +/* Create a new pointer-to-member type. MEMBER_TYPE is the data + member type, while CLASS_TYPE is the class type containing the data + member. For pointers to member functions, MEMBER_TYPE must be a + method type, and CLASS_TYPE must be specified even though it might + be possible to extract it from the method type. */ + +GCC_METHOD2 (gcc_type, build_pointer_to_member_type, + gcc_type, /* Argument CLASS_TYPE. */ + gcc_type) /* Argument MEMBER_TYPE. */ /* Create a new 'class' (or 'struct') type, record it in the current binding level, and enter its own binding level. Initially it has @@ -167,21 +183,32 @@ GCC_METHOD1 (int /* bool */, finish_enum_type, /* Create a new function type. RETURN_TYPE is the type returned by the function, and ARGUMENT_TYPES is a vector, of length NARGS, of the argument types. IS_VARARGS is true if the function is - varargs. - - FIXME: C++ allows such stuff as "typedef int f() const;" to create - a cv-qualified (member) function type not associated with any - specific class, which can then be used to declare member functions - and pointers to member functions. Our API doesn't support this. */ + varargs. */ GCC_METHOD3 (gcc_type, build_function_type, gcc_type, /* Argument RETURN_TYPE. */ const struct gcc_type_array *,/* Argument ARGUMENT_TYPES. */ int /* bool */) /* Argument IS_VARARGS. */ +/* Create a variant of a function type with an exception + specification. FUNCTION_TYPE is a function or method type. + EXCEPT_TYPES is an array with the list of exception types. Zero as + the array length implies throw() AKA noexcept(true); NULL as the + pointer to gcc_type_array implies noexcept(false), which is almost + equivalent (but distinguishable by the compiler) to an unspecified + exception list. */ + +GCC_METHOD2 (gcc_type, build_exception_spec_variant, + gcc_type, /* Argument FUNCTION_TYPE. */ + const struct gcc_type_array *)/* Argument EXCEPT_TYPES. */ + /* Create a new non-static member function type. FUNC_TYPE is the method prototype, without the implicit THIS pointer, added as a - pointer to the QUALS-qualified CLASS_TYPE. */ + pointer to the QUALS-qualified CLASS_TYPE. If CLASS_TYPE is NULL, + this creates a cv-qualified (member) function type not associated + with any specific class, as needed to support "typedef void f(int) + const;", which can later be used to declare member functions and + pointers to member functions. */ GCC_METHOD4 (gcc_type, build_method_type, gcc_type, /* Argument CLASS_TYPE. */ @@ -189,7 +216,7 @@ GCC_METHOD4 (gcc_type, build_method_type, enum gcc_cp_qualifiers, /* Argument QUALS. */ enum gcc_cp_ref_qualifiers) /* Argument RQUALS. */ -// FIXME: add a type-variant builder to add exception type specifiers. +// FIXME: add default expressions for function arguments? /* Return an integer type with the given properties. */ diff --git a/include/gcc-cp-interface.h b/include/gcc-cp-interface.h index a4b3be0..cb297b6 100644 --- a/include/gcc-cp-interface.h +++ b/include/gcc-cp-interface.h @@ -41,7 +41,7 @@ struct gcc_cp_context; enum gcc_cp_api_version { - GCC_CP_FE_VERSION_0 = 0xffffffff-1 + GCC_CP_FE_VERSION_0 = 0xffffffff-2 }; /* Qualifiers. */ diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc index c868142..b4d9ee28 100644 --- a/libcc1/libcp1plugin.cc +++ b/libcc1/libcp1plugin.cc @@ -563,6 +563,31 @@ plugin_build_pointer_type (cc1_plugin::connection *, return convert_out (build_pointer_type (convert_in (base_type))); } +gcc_type +plugin_build_reference_type (cc1_plugin::connection *, + gcc_type base_type_in, + enum gcc_cp_ref_qualifiers rquals) +{ + bool rval; + + switch (rquals) + { + case GCC_CP_REF_QUAL_LVALUE: + rval = false; + break; + case GCC_CP_REF_QUAL_RVALUE: + rval = true; + break; + case GCC_CP_REF_QUAL_NONE: + default: + gcc_unreachable (); + } + + tree rtype = cp_build_reference_type (convert_in (base_type_in), rval); + + return convert_out (rtype); +} + // TYPE_NAME needs to be a valid pointer, even if there is no name available. static tree @@ -781,6 +806,32 @@ plugin_build_function_type (cc1_plugin::connection *self, } gcc_type +plugin_build_exception_spec_variant (cc1_plugin::connection *self, + gcc_type function_type_in, + const struct gcc_type_array *except_types_in) +{ + tree function_type = convert_in (function_type_in); + tree except_types = NULL_TREE; + + if (!except_types_in) + except_types = noexcept_false_spec; + else if (!except_types_in->n_elements) + except_types = empty_except_spec; + else + for (int i = 0; i < except_types_in->n_elements; i++) + except_types = add_exception_specifier (except_types, + convert_in + (except_types_in->elements[i]), + 0); + + function_type = build_exception_variant (function_type, + except_types); + + plugin_context *ctx = static_cast<plugin_context *> (self); + return convert_out (ctx->preserve (function_type)); +} + +gcc_type plugin_build_method_type (cc1_plugin::connection *self, gcc_type class_type_in, gcc_type func_type_in, @@ -813,13 +864,29 @@ plugin_build_method_type (cc1_plugin::connection *self, gcc_unreachable (); } - tree method_type = build_memfn_type (func_type, class_type, quals, rquals); + tree method_type = class_type + ? build_memfn_type (func_type, class_type, quals, rquals) + : apply_memfn_quals (func_type, quals, rquals); plugin_context *ctx = static_cast<plugin_context *> (self); return convert_out (ctx->preserve (method_type)); } gcc_type +plugin_build_pointer_to_member_type (cc1_plugin::connection *self, + gcc_type class_type_in, + gcc_type member_type_in) +{ + tree class_type = convert_in (class_type_in); + tree member_type = convert_in (member_type_in); + + tree memptr_type = build_ptrmem_type (class_type, member_type); + + plugin_context *ctx = static_cast<plugin_context *> (self); + return convert_out (ctx->preserve (memptr_type)); +} + +gcc_type plugin_int_type (cc1_plugin::connection *self, int is_unsigned, unsigned long size_in_bytes) { diff --git a/libcc1/marshall.cc b/libcc1/marshall.cc index 9c62c40..4d81f14 100644 --- a/libcc1/marshall.cc +++ b/libcc1/marshall.cc @@ -144,11 +144,19 @@ cc1_plugin::unmarshall_array_elmts (connection *conn, size_t [...] cc1_plugin::status cc1_plugin::marshall (connection *conn, const gcc_type_array *a) { - size_t len = a->n_elements; + size_t len; + + if (a) + len = a->n_elements; + else + len = (size_t)-1; if (!marshall_array_start (conn, 'a', len)) return FAIL; + if (!a) + return OK; + return marshall_array_elmts (conn, len * sizeof (a->elements[0]), a->elements); } @@ -161,6 +169,12 @@ cc1_plugin::unmarshall (connection *conn, gcc_type_array **result) if (!unmarshall_array_start (conn, 'a', &len)) return FAIL; + if (len == (size_t)-1) + { + *result = NULL; + return OK; + } + *result = new gcc_type_array; (*result)->n_elements = len; -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

[gcc] 16/20: Fix plugin_new_decl

by git

This is an automated email from the git hooks/post-receive script. unknown user pushed a commit to branch aoliva/libcp1 in repository gcc. commit 11c12cca8fd5591e56bb40e771b505436c937c92 Author: Alexandre Oliva <aoliva(a)redhat.com> Date: Fri Jul 3 13:30:46 2015 -0300 Fix plugin_new_decl Tested and fixed static data members, member functions, member typedefs, and nested classes. --- libcc1/libcp1plugin.cc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/libcc1/libcp1plugin.cc b/libcc1/libcp1plugin.cc index 0e71c0e..862803e 100644 --- a/libcc1/libcp1plugin.cc +++ b/libcc1/libcp1plugin.cc @@ -504,7 +504,8 @@ plugin_new_decl (cc1_plugin::connection *self, decl = build_lang_decl_loc (loc, code, identifier, sym_type); if (TREE_CODE (sym_type) == VAR_DECL) { - // This block does the same as: + DECL_THIS_STATIC (decl) = 1; + // The remainder of this block does the same as: // set_linkage_for_static_data_member (decl); TREE_PUBLIC (decl) = 1; TREE_STATIC (decl) = 1; @@ -551,10 +552,10 @@ plugin_new_decl (cc1_plugin::connection *self, } } - decl = safe_pushdecl_maybe_friend (decl, false); - if (class_member_p) finish_member_declaration (decl); + else + decl = safe_pushdecl_maybe_friend (decl, false); rest_of_decl_compilation (decl, toplevel_bindings_p (), 0); -- To stop receiving notification emails like this one, please contact the administrator of this repository.

9 years, 3 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

Tcwg-commits July 2015