+2014-12-12 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-12-06 Eric Botcazou <ebotcazou@adacore.com>
* dis-asm.h (print_insn_visium): Declare.
--- /dev/null
+/* 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. */
--- /dev/null
+/* 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 */
--- /dev/null
+/* 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 */
projects / binutils-gdb.git / commitdiff