/* Interface between GCC C++ FE and GDB

  Copyright (C) 2014-2024 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 */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.