[PATCH v4 02/14] add gcc/gdb interface files

Jan Kratochvil
2014-11-23T19:27:40Z

From: Tom Tromey <tromey@redhat.com>

The gcc plugin is split into two parts. One part is an ordinary gcc
plugin. The other part is a shared library that is loaded by gdb.

This patch adds some files that define the interface exported by this
shared library to gdb. These files also define the internal API by
which the gdb- and gcc-sides communicate.

These files will be kept in sync between gcc and gdb like much of
include/.

The exported API has been intentionally kept very simple. In
particular only a single function is exported from the gdb-side
library; symbol visibility is used to hide everything else. This
exported symbol is a function which is called to return a structure
holding function pointers that gdb then uses. This structure is
versioned so that changes can be made without necessarily requiring a
simultaneous gdb upgrade.

Note that the C compiler API is broken out separately. This lets us
extend it to other GCC front ends as desired. We plan to investigate
C++ in the future.

2014-10-07 Phil Muldoon <pmuldoon@redhat.com>
Jan Kratochvil <jan.kratochvil@redhat.com>
Tom Tromey <tromey@redhat.com>

* gcc-c-fe.def: New file.
* gcc-c-interface.h: New file.
* gcc-interface.h: New file.
---
include/ChangeLog | 8 ++
include/gcc-c-fe.def | 197 ++++++++++++++++++++++++++++++++++++++++
include/gcc-c-interface.h | 220 +++++++++++++++++++++++++++++++++++++++++++++
include/gcc-interface.h | 127 ++++++++++++++++++++++++++
4 files changed, 552 insertions(+)
create mode 100644 include/gcc-c-fe.def
create mode 100644 include/gcc-c-interface.h
create mode 100644 include/gcc-interface.h

diff --git a/include/ChangeLog b/include/ChangeLog
index 4c3d652..f7d0f4a 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,11 @@
+2014-10-07 Phil Muldoon <pmuldoon@redhat.com>
+ Jan Kratochvil <jan.kratochvil@redhat.com>
+ Tom Tromey <tromey@redhat.com>
+
+ * gcc-c-fe.def: New file.
+ * gcc-c-interface.h: New file.
+ * gcc-interface.h: New file.
+
2014-11-21 Shinichiro Hamaji <shinichiro.hamaji@gmail.com>

* dwarf2.def (DW_AT_APPLE_optimized, DW_AT_APPLE_flags)
diff --git a/include/gcc-c-fe.def b/include/gcc-c-fe.def
new file mode 100644
index 0000000..19cb867
--- /dev/null
+++ b/include/gcc-c-fe.def
@@ -0,0 +1,197 @@
+/* Interface between GCC C FE and GDB -*- c -*-
+
+ Copyright (C) 2014 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/>. */
+
+
+
+/* Create a new "decl" in GCC. 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;
+ except for labels, where this is not meaningful and should be
+ zero. If SUBSTITUTION_NAME is not NULL, then a reference to this
+ decl in the source will later be substituted with a dereference
+ of a variable of the given name. Otherwise, for symbols having
+ 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,
+ const char *, /* Argument NAME. */
+ enum gcc_c_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. */
+
+GCC_METHOD2 (int /* bool */, bind,
+ gcc_decl, /* Argument DECL. */
+ int /* bool */) /* Argument IS_GLOBAL. */
+
+/* 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. */
+
+GCC_METHOD4 (int /* bool */, tagbind,
+ const char *, /* Argument NAME. */
+ gcc_type, /* Argument TAGGED_TYPE. */
+ 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. */
+
+/* Create a new 'struct' type. Initially it has no fields. */
+
+GCC_METHOD0 (gcc_type, build_record_type)
+
+/* Create a new 'union' type. Initially it has no fields. */
+
+GCC_METHOD0 (gcc_type, build_union_type)
+
+/* 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. */
+
+GCC_METHOD5 (int /* bool */, build_add_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. */
+
+/* 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. */
+
+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. */
+
+GCC_METHOD1 (gcc_type, build_enum_type,
+ gcc_type) /* Argument UNDERLYING_INT_TYPE. */
+
+/* Add a new constant to an enum type. NAME is the constant's
+ name and VALUE is its value. */
+
+GCC_METHOD3 (int /* bool */, build_add_enum_constant,
+ gcc_type, /* Argument ENUM_TYPE. */
+ const char *, /* Argument NAME. */
+ unsigned long) /* Argument VALUE. */
+
+/* After all the constants have been added to an enum, the type must
+ be "finished". This does some final cleanups in GCC. */
+
+GCC_METHOD1 (int /* bool */, finish_enum_type,
+ gcc_type) /* Argument 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. */
+
+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. */
+
+/* Return an integer type with the given properties. */
+
+GCC_METHOD2 (gcc_type, int_type,
+ int /* bool */, /* Argument IS_UNSIGNED. */
+ unsigned long) /* Argument SIZE_IN_BYTES. */
+
+/* Return a floating point type with the given properties. */
+
+GCC_METHOD1 (gcc_type, float_type,
+ unsigned long) /* Argument SIZE_IN_BYTES. */
+
+/* Return the 'void' type. */
+
+GCC_METHOD0 (gcc_type, void_type)
+
+/* Return the 'bool' type. */
+
+GCC_METHOD0 (gcc_type, bool_type)
+
+/* Create a new array type. If NUM_ELEMENTS is -1, then the array
+ is assumed to have an unknown length. */
+
+GCC_METHOD2 (gcc_type, build_array_type,
+ gcc_type, /* Argument ELEMENT_TYPE. */
+ int) /* Argument NUM_ELEMENTS. */
+
+/* Create a new variably-sized array type. UPPER_BOUND_NAME is the
+ name of a local variable that holds the upper bound of the array;
+ it is one less than the array size. */
+
+GCC_METHOD2 (gcc_type, build_vla_array_type,
+ gcc_type, /* Argument ELEMENT_TYPE. */
+ const char *) /* Argument UPPER_BOUND_NAME. */
+
+/* Return a qualified variant of a given base type. QUALIFIERS says
+ which qualifiers to use; it is composed of or'd together
+ constants from 'enum gcc_qualifiers'. */
+
+GCC_METHOD2 (gcc_type, build_qualified_type,
+ gcc_type, /* Argument UNQUALIFIED_TYPE. */
+ enum gcc_qualifiers) /* Argument QUALIFIERS. */
+
+/* Build a complex type given its element type. */
+
+GCC_METHOD1 (gcc_type, build_complex_type,
+ gcc_type) /* Argument ELEMENT_TYPE. */
+
+/* Build a vector type given its element type and number of
+ elements. */
+
+GCC_METHOD2 (gcc_type, build_vector_type,
+ gcc_type, /* Argument ELEMENT_TYPE. */
+ int) /* Argument NUM_ELEMENTS. */
+
+/* Build a constant. NAME is the constant's name and VALUE is its
+ value. 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. */
+
+GCC_METHOD5 (int /* bool */, build_constant,
+ gcc_type, /* Argument TYPE. */
+ const char *, /* Argument NAME. */
+ unsigned long, /* Argument VALUE. */
+ const char *, /* Argument FILENAME. */
+ unsigned int) /* Argument LINE_NUMBER. */
+
+/* Emit an error and return an error type object. */
+
+GCC_METHOD1 (gcc_type, error,
+ const char *) /* Argument MESSAGE. */
diff --git a/include/gcc-c-interface.h b/include/gcc-c-interface.h
new file mode 100644
index 0000000..25ef62f
--- /dev/null
+++ b/include/gcc-c-interface.h
@@ -0,0 +1,220 @@
+/* Interface between GCC C FE and GDB
+
+ Copyright (C) 2014 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_C_INTERFACE_H
+#define GCC_C_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_c_context;
+
+/*
+ * Definitions and declarations for the C front end.
+ */
+
+/* Defined versions of the C front-end API. */
+
+enum gcc_c_api_version
+{
+ GCC_C_FE_VERSION_0 = 0
+};
+
+/* Qualifiers. */
+
+enum gcc_qualifiers
+{
+ GCC_QUALIFIER_CONST = 1,
+ GCC_QUALIFIER_VOLATILE = 2,
+ GCC_QUALIFIER_RESTRICT = 4
+};
+
+/* This enumerates the kinds of decls that GDB can create. */
+
+enum gcc_c_symbol_kind
+{
+ /* A function. */
+
+ GCC_C_SYMBOL_FUNCTION,
+
+ /* A variable. */
+
+ GCC_C_SYMBOL_VARIABLE,
+
+ /* A typedef. */
+
+ GCC_C_SYMBOL_TYPEDEF,
+
+ /* A label. */
+
+ GCC_C_SYMBOL_LABEL
+};
+
+/* This enumerates the types of symbols that GCC might request from
+ GDB. */
+
+enum gcc_c_oracle_request
+{
+ /* An ordinary symbol -- a variable, function, typedef, or enum
+ constant. */
+
+ GCC_C_ORACLE_SYMBOL,
+
+ /* A struct, union, or enum tag. */
+
+ GCC_C_ORACLE_TAG,
+
+ /* A label. */
+
+ GCC_C_ORACLE_LABEL
+};
+
+/* 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_c_oracle_function (void *datum,
+ struct gcc_c_context *context,
+ enum gcc_c_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_c_symbol_address_function (void *datum,
+ struct gcc_c_context *ctxt,
+ const char *identifier);
+
+/* An array of types used for creating a function type. */
+
+struct gcc_type_array
+{
+ /* Number of elements. */
+
+ int n_elements;
+
+ /* The elements. */
+
+ gcc_type *elements;
+};
+
+/* The vtable used by the C front end. */
+
+struct gcc_c_fe_vtable
+{
+ /* The version of the C interface. The value is one of the
+ gcc_c_api_version constants. */
+
+ unsigned int c_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_c_fe_interface
+ API.
+
+ The address oracle is called whenever the C parser needs to look
+ up a symbol. This is only called for symbols not provided by the
+ symbol oracle -- that is, just built-in functions where GCC
+ provides the declaration.
+
+ DATUM is an arbitrary piece of data that is passed back verbatim
+ to the callbakcs in requests. */
+
+ void (*set_callbacks) (struct gcc_c_context *self,
+ gcc_c_oracle_function *binding_oracle,
+ gcc_c_symbol_address_function *address_oracle,
+ void *datum);
+
+#define GCC_METHOD0(R, N) \
+ R (*N) (struct gcc_c_context *);
+#define GCC_METHOD1(R, N, A) \
+ R (*N) (struct gcc_c_context *, A);
+#define GCC_METHOD2(R, N, A, B) \
+ R (*N) (struct gcc_c_context *, A, B);
+#define GCC_METHOD3(R, N, A, B, C) \
+ R (*N) (struct gcc_c_context *, A, B, C);
+#define GCC_METHOD4(R, N, A, B, C, D) \
+ R (*N) (struct gcc_c_context *, A, B, C, D);
+#define GCC_METHOD5(R, N, A, B, C, D, E) \
+ R (*N) (struct gcc_c_context *, A, B, C, D, E);
+#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
+ R (*N) (struct gcc_c_context *, A, B, C, D, E, F, G);
+
+#include "gcc-c-fe.def"
+
+#undef GCC_METHOD0
+#undef GCC_METHOD1
+#undef GCC_METHOD2
+#undef GCC_METHOD3
+#undef GCC_METHOD4
+#undef GCC_METHOD5
+#undef GCC_METHOD7
+
+};
+
+/* The C front end object. */
+
+struct gcc_c_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_c_fe_vtable *c_ops;
+};
+
+/* The name of the .so that the compiler builds. We dlopen this
+ later. */
+
+#define GCC_C_FE_LIBCC libcc1.so
+
+/* The compiler exports a single initialization function. This macro
+ holds its name as a symbol. */
+
+#define GCC_C_FE_CONTEXT gcc_c_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_c_context *gcc_c_fe_context_function
+ (enum gcc_base_api_version,
+ enum gcc_c_api_version);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GCC_C_INTERFACE_H */
diff --git a/include/gcc-interface.h b/include/gcc-interface.h
new file mode 100644
index 0000000..34010f2
--- /dev/null
+++ b/include/gcc-interface.h
@@ -0,0 +1,127 @@
+/* Generic interface between GCC and GDB
+
+ Copyright (C) 2014 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_INTERFACE_H
+#define 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
+
+/* Opaque typedefs for objects passed through the interface. */
+
+typedef unsigned long long gcc_type;
+typedef unsigned long long gcc_decl;
+
+/* An address in the inferior. */
+
+typedef unsigned long long gcc_address;
+
+/* Forward declaration. */
+
+struct gcc_base_context;
+
+/* Defined versions of the generic API. */
+
+enum gcc_base_api_version
+{
+ GCC_FE_VERSION_0 = 0
+};
+
+/* The operations defined by the GCC base API. This is the vtable for
+ the real context structure which is passed around.
+
+ The "base" API is concerned with basics shared by all compiler
+ front ends: setting command-line arguments, the file names, etc.
+
+ Front-end-specific interfaces inherit from this one. */
+
+struct gcc_base_vtable
+{
+ /* The actual version implemented in this interface. This field can
+ be relied on not to move, so users can always check it if they
+ desire. The value is one of the gcc_base_api_version constants.
+ */
+
+ unsigned int version;
+
+ /* Set the compiler's command-line options for the next compilation.
+ TRIPLET_REGEXP is a regular expression that is used to match the
+ configury triplet prefix to the compiler.
+ The arguments are copied by GCC. ARGV need not be
+ NULL-terminated. The arguments must be set separately for each
+ compilation; that is, after a compile is requested, the
+ previously-set arguments cannot be reused.
+
+ This returns NULL on success. On failure, returns a malloc()d
+ error message. The caller is responsible for freeing it. */
+
+ char *(*set_arguments) (struct gcc_base_context *self,
+ const char *triplet_regexp,
+ int argc, char **argv);
+
+ /* Set the file name of the program to compile. The string is
+ copied by the method implementation, but the caller must
+ guarantee that the file exists through the compilation. */
+
+ void (*set_source_file) (struct gcc_base_context *self, const char *file);
+
+ /* Set a callback to use for printing error messages. DATUM is
+ passed through to the callback unchanged. */
+
+ void (*set_print_callback) (struct gcc_base_context *self,
+ void (*print_function) (void *datum,
+ const char *message),
+ void *datum);
+
+ /* Perform the compilation. FILENAME is the name of the resulting
+ object file. VERBOSE can be set to cause GCC to print some
+ information as it works. Returns true on success, false on
+ error. */
+
+ int /* bool */ (*compile) (struct gcc_base_context *self,
+ const char *filename,
+ int /* bool */ verbose);
+
+ /* Destroy this object. */
+
+ void (*destroy) (struct gcc_base_context *self);
+};
+
+/* The GCC object. */
+
+struct gcc_base_context
+{
+ /* The virtual table. */
+
+ const struct gcc_base_vtable *ops;
+};
+
+/* The name of the dummy wrapper function generated by gdb. */
+
+#define GCC_FE_WRAPPER_FUNCTION "_gdb_expr"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GCC_INTERFACE_H */