123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496 |
- /* Interface between GCC C++ FE and GDB
- Copyright (C) 2014-2022 Free Software Foundation, Inc.
- This file is part of GCC.
- 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 <http://www.gnu.org/licenses/>. */
- #ifndef GCC_CP_INTERFACE_H
- #define GCC_CP_INTERFACE_H
- #include "gcc-interface.h"
- /* This header defines the interface to the GCC API. It must be both
- valid C and valid C++, because it is included by both programs. */
- #ifdef __cplusplus
- extern "C" {
- #endif
- /* Forward declaration. */
- struct gcc_cp_context;
- /*
- * Definitions and declarations for the C++ front end.
- */
- /* Defined versions of the C++ front-end API. */
- enum gcc_cp_api_version
- {
- GCC_CP_FE_VERSION_0 = 0
- };
- /* Qualifiers. */
- enum gcc_cp_qualifiers
- {
- GCC_CP_QUALIFIER_CONST = 1,
- GCC_CP_QUALIFIER_VOLATILE = 2,
- 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
- };
- /* Opaque typedef for unbound class templates. They are used for
- template arguments, and defaults for template template
- parameters. */
- typedef unsigned long long gcc_utempl;
- /* Opaque typedef for expressions. They are used for template
- arguments, defaults for non-type template parameters, and defaults
- for function arguments. */
- typedef unsigned long long gcc_expr;
- typedef enum
- { GCC_CP_TPARG_VALUE, GCC_CP_TPARG_CLASS,
- GCC_CP_TPARG_TEMPL, GCC_CP_TPARG_PACK }
- gcc_cp_template_arg_kind;
- typedef union
- { gcc_expr value; gcc_type type; gcc_utempl templ; gcc_type pack; }
- gcc_cp_template_arg;
- /* An array of template arguments. */
- struct gcc_cp_template_args
- {
- /* Number of elements. */
- int n_elements;
- /* kind[i] indicates what kind of template argument type[i] is. */
- char /* gcc_cp_template_arg_kind */ *kinds;
- /* The template arguments. */
- gcc_cp_template_arg *elements;
- };
- /* An array of (default) function arguments. */
- struct gcc_cp_function_args
- {
- /* Number of elements. */
- int n_elements;
- /* The (default) values for each argument. */
- gcc_expr *elements;
- };
- /* This enumerates the kinds of decls that GDB can create. */
- enum gcc_cp_symbol_kind
- {
- /* A function. */
- GCC_CP_SYMBOL_FUNCTION,
- /* A variable. */
- GCC_CP_SYMBOL_VARIABLE,
- /* A typedef, or an alias declaration (including template ones). */
- GCC_CP_SYMBOL_TYPEDEF,
- /* A label. */
- GCC_CP_SYMBOL_LABEL,
- /* A class, forward declared in build_decl (to be later defined in
- start_class_definition), or, in a template parameter list scope,
- a declaration of a template class, closing the parameter
- list. */
- GCC_CP_SYMBOL_CLASS,
- /* A union, forward declared in build_decl (to be later defined in
- start_class_definition). */
- GCC_CP_SYMBOL_UNION,
- /* An enumeration type being introduced with start_new_enum_type. */
- GCC_CP_SYMBOL_ENUM,
- /* A nonstatic data member being introduced with new_field. */
- GCC_CP_SYMBOL_FIELD,
- /* A base class in a gcc_vbase_array. */
- GCC_CP_SYMBOL_BASECLASS,
- /* A using declaration in new_using_decl. */
- GCC_CP_SYMBOL_USING,
- /* A (lambda) closure class type. In many regards this is just like
- a regular class, but it's not supposed to have base classes, some
- of the member functions that are usually implicitly-defined are
- deleted, and it should have an operator() member function that
- holds the lambda body. We can't instantiate objects of lambda
- types from the snippet, but we can interact with them in such
- ways as passing them to functions that take their types, and
- calling their body. */
- GCC_CP_SYMBOL_LAMBDA_CLOSURE,
- /* Marker to check that we haven't exceeded GCC_CP_SYMBOL_MASK. */
- GCC_CP_SYMBOL_END,
- GCC_CP_SYMBOL_MASK = 15,
- /* When defining a class member, at least one of the
- GCC_CP_ACCESS_MASK bits must be set; when defining a namespace-
- or union-scoped symbol, none of them must be set. */
- GCC_CP_ACCESS_PRIVATE,
- GCC_CP_ACCESS_PUBLIC = GCC_CP_ACCESS_PRIVATE << 1,
- GCC_CP_ACCESS_MASK = (GCC_CP_ACCESS_PUBLIC
- | GCC_CP_ACCESS_PRIVATE),
- GCC_CP_ACCESS_PROTECTED = GCC_CP_ACCESS_MASK,
- GCC_CP_ACCESS_NONE = 0,
- GCC_CP_FLAG_BASE = GCC_CP_ACCESS_PRIVATE << 2,
- /* Flags to be used along with GCC_CP_SYMBOL_FUNCTION: */
- /* This flag should be set for constructors, destructors and
- operators. */
- GCC_CP_FLAG_SPECIAL_FUNCTION = GCC_CP_FLAG_BASE,
- /* We intentionally cannot express inline, constexpr, or virtual
- override for functions. We can't inline or constexpr-replace
- without a source-level body. The override keyword is only
- meaningful within the definition of the containing class. */
- /* This indicates a "virtual" member function, explicitly or
- implicitly (due to a virtual function with the same name and
- prototype in a base class) declared as such. */
- GCC_CP_FLAG_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 1,
- /* The following two flags should only be set when the flag above is
- set. */
- /* This indicates a pure virtual member function, i.e., one that is
- declared with "= 0", even if a body is provided in the
- definition. */
- GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 2,
- /* This indicates a "final" virtual member function. */
- GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION = GCC_CP_FLAG_BASE << 3,
- /* This indicates a special member function should have its default
- implementation. This either means the function declaration
- contains the "= default" tokens, or that the member function was
- implicitly generated by the compiler, although the latter use is
- discouraged: just let the compiler implicitly introduce it.
- A member function defaulted after its first declaration has
- slightly different ABI implications from one implicitly generated
- or explicitly defaulted at the declaration (and definition)
- point. To avoid silent (possibly harmless) violation of the one
- definition rule, it is recommended that this flag not be used for
- such functions, and that the address of the definition be
- supplied instead. */
- GCC_CP_FLAG_DEFAULTED_FUNCTION = GCC_CP_FLAG_BASE << 4,
- /* This indicates a deleted member function, i.e., one that has been
- defined as "= delete" at its declaration point, or one that has
- been implicitly defined as deleted (with or without an explicit
- "= default" definition).
- This should not be used for implicitly-declared member functions
- that resolve to deleted definitions, as it may affect the
- implicit declaration of other member functions. */
- GCC_CP_FLAG_DELETED_FUNCTION = GCC_CP_FLAG_BASE << 5,
- /* This indicates a constructor or type-conversion operator declared
- as "explicit". */
- GCC_CP_FLAG_EXPLICIT_FUNCTION = GCC_CP_FLAG_BASE << 6,
- GCC_CP_FLAG_END_FUNCTION,
- GCC_CP_FLAG_MASK_FUNCTION = (((GCC_CP_FLAG_END_FUNCTION - 1) << 1)
- - GCC_CP_FLAG_BASE),
- /* Flags to be used along with GCC_CP_SYMBOL_VARIABLE: */
- /* This indicates a variable declared as "constexpr". */
- GCC_CP_FLAG_CONSTEXPR_VARIABLE = GCC_CP_FLAG_BASE,
- /* This indicates a variable declared as "thread_local". ??? What
- should the ADDRESS be? */
- GCC_CP_FLAG_THREAD_LOCAL_VARIABLE = GCC_CP_FLAG_BASE << 1,
- GCC_CP_FLAG_END_VARIABLE,
- GCC_CP_FLAG_MASK_VARIABLE = (((GCC_CP_FLAG_END_VARIABLE - 1) << 1)
- - GCC_CP_FLAG_BASE),
- /* Flags to be used when defining nonstatic data members of classes
- with new_field. */
- /* Use this when no flags are present. */
- GCC_CP_FLAG_FIELD_NOFLAG = 0,
- /* This indicates the field is declared as mutable. */
- GCC_CP_FLAG_FIELD_MUTABLE = GCC_CP_FLAG_BASE,
- GCC_CP_FLAG_END_FIELD,
- GCC_CP_FLAG_MASK_FIELD = (((GCC_CP_FLAG_END_FIELD - 1) << 1)
- - GCC_CP_FLAG_BASE),
- /* Flags to be used when defining an enum with
- start_new_enum_type. */
- /* This indicates an enum type without any flags. */
- GCC_CP_FLAG_ENUM_NOFLAG = 0,
- /* This indicates a scoped enum type. */
- GCC_CP_FLAG_ENUM_SCOPED = GCC_CP_FLAG_BASE,
- GCC_CP_FLAG_END_ENUM,
- GCC_CP_FLAG_MASK_ENUM = (((GCC_CP_FLAG_END_ENUM - 1) << 1)
- - GCC_CP_FLAG_BASE),
- /* Flags to be used when introducing a class or a class template
- with build_decl. */
- /* This indicates an enum type without any flags. */
- GCC_CP_FLAG_CLASS_NOFLAG = 0,
- /* This indicates the class is actually a struct. This has no
- effect whatsoever on access control in this interface, since all
- class members must have explicit access control bits set, but it
- may affect error messages. */
- GCC_CP_FLAG_CLASS_IS_STRUCT = GCC_CP_FLAG_BASE,
- GCC_CP_FLAG_END_CLASS,
- GCC_CP_FLAG_MASK_CLASS = (((GCC_CP_FLAG_END_CLASS - 1) << 1)
- - GCC_CP_FLAG_BASE),
- /* Flags to be used when introducing a virtual base class in a
- gcc_vbase_array. */
- /* This indicates an enum type without any flags. */
- GCC_CP_FLAG_BASECLASS_NOFLAG = 0,
- /* This indicates the class is actually a struct. This has no
- effect whatsoever on access control in this interface, since all
- class members must have explicit access control bits set, but it
- may affect error messages. */
- GCC_CP_FLAG_BASECLASS_VIRTUAL = GCC_CP_FLAG_BASE,
- GCC_CP_FLAG_END_BASECLASS,
- GCC_CP_FLAG_MASK_BASECLASS = (((GCC_CP_FLAG_END_BASECLASS - 1) << 1)
- - GCC_CP_FLAG_BASE),
- GCC_CP_FLAG_MASK = (GCC_CP_FLAG_MASK_FUNCTION
- | GCC_CP_FLAG_MASK_VARIABLE
- | GCC_CP_FLAG_MASK_FIELD
- | GCC_CP_FLAG_MASK_ENUM
- | GCC_CP_FLAG_MASK_CLASS
- | GCC_CP_FLAG_MASK_BASECLASS
- )
- };
- /* 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;
- /* Flags for each base class. Used to indicate access control and
- virtualness. */
- enum gcc_cp_symbol_kind *flags;
- };
- /* This enumerates the types of symbols that GCC might request from
- GDB. */
- enum gcc_cp_oracle_request
- {
- /* An identifier in namespace scope -- type, variable, function,
- namespace, template. All namespace-scoped symbols with the
- requested name, in any namespace (including the global
- namespace), should be defined in response to this request. */
- GCC_CP_ORACLE_IDENTIFIER
- };
- /* The type of the function called by GCC to ask GDB for a symbol's
- definition. DATUM is an arbitrary value supplied when the oracle
- function is registered. CONTEXT is the GCC context in which the
- request is being made. REQUEST specifies what sort of symbol is
- 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);
- /* 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);
- /* The type of the function called by GCC to ask GDB to enter or leave
- the user expression scope. */
- typedef void gcc_cp_enter_leave_user_expr_scope_function (void *datum,
- struct gcc_cp_context
- *context);
- /* The vtable used by the C front end. */
- struct gcc_cp_fe_vtable
- {
- /* The version of the C interface. The value is one of the
- gcc_cp_api_version constants. */
- unsigned int cp_version;
- /* Set the callbacks for this context.
- The binding oracle is called whenever the C++ parser needs to
- look up a symbol. This gives the caller a chance to lazily
- instantiate symbols using other parts of the gcc_cp_fe_interface
- API. The symbol is looked up without a scope, and the oracle
- must supply a definition for ALL namespace-scoped definitions
- bound to the symbol.
- The address oracle is called whenever the C++ parser needs to
- look up a symbol. This may be called for symbols not provided by
- the symbol oracle, such as built-in functions where GCC provides
- the declaration; other internal symbols, such as those related
- with thunks, rtti, and virtual tables are likely to be queried
- through this interface too. The identifier is a mangled symbol
- name.
- DATUM is an arbitrary piece of data that is passed back verbatim
- to the callbacks in requests. */
- void (*set_callbacks) (struct gcc_cp_context *self,
- gcc_cp_oracle_function *binding_oracle,
- gcc_cp_symbol_address_function *address_oracle,
- gcc_cp_enter_leave_user_expr_scope_function *enter_scope,
- gcc_cp_enter_leave_user_expr_scope_function *leave_scope,
- void *datum);
- #define GCC_METHOD0(R, N) \
- R (*N) (struct gcc_cp_context *);
- #define GCC_METHOD1(R, N, A) \
- R (*N) (struct gcc_cp_context *, A);
- #define GCC_METHOD2(R, N, A, B) \
- R (*N) (struct gcc_cp_context *, A, B);
- #define GCC_METHOD3(R, N, A, B, C) \
- R (*N) (struct gcc_cp_context *, A, B, C);
- #define GCC_METHOD4(R, N, A, B, C, D) \
- R (*N) (struct gcc_cp_context *, A, B, C, D);
- #define GCC_METHOD5(R, N, A, B, C, D, E) \
- R (*N) (struct gcc_cp_context *, A, B, C, D, E);
- #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
- R (*N) (struct gcc_cp_context *, A, B, C, D, E, F, G);
- #include "gcc-cp-fe.def"
- #undef GCC_METHOD0
- #undef GCC_METHOD1
- #undef GCC_METHOD2
- #undef GCC_METHOD3
- #undef GCC_METHOD4
- #undef GCC_METHOD5
- #undef GCC_METHOD7
- };
- /* The C front end object. */
- struct gcc_cp_context
- {
- /* Base class. */
- struct gcc_base_context base;
- /* Our vtable. This is a separate field because this is simpler
- than implementing a vtable inheritance scheme in C. */
- const struct gcc_cp_fe_vtable *cp_ops;
- };
- /* The name of the .so that the compiler builds. We dlopen this
- later. */
- #define GCC_CP_FE_LIBCC libcc1.so
- /* The compiler exports a single initialization function. This macro
- holds its name as a symbol. */
- #define GCC_CP_FE_CONTEXT gcc_cp_fe_context
- /* The type of the initialization function. The caller passes in the
- desired base version and desired C-specific version. If the
- request can be satisfied, a compatible gcc_context object will be
- returned. Otherwise, the function returns NULL. */
- typedef struct gcc_cp_context *gcc_cp_fe_context_function
- (enum gcc_base_api_version,
- enum gcc_cp_api_version);
- #ifdef __cplusplus
- }
- #endif
- #endif /* GCC_CP_INTERFACE_H */
|