diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/ChangeLog | 8 | ||||
| -rw-r--r-- | include/gcc-c-fe.def | 197 | ||||
| -rw-r--r-- | include/gcc-c-interface.h | 220 | ||||
| -rw-r--r-- | include/gcc-interface.h | 127 |
4 files changed, 552 insertions, 0 deletions
diff --git a/include/ChangeLog b/include/ChangeLog index 5198c249e7c..441ea3daded 100644 --- a/include/ChangeLog +++ b/include/ChangeLog @@ -1,3 +1,11 @@ +2014-10-27 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-10-15 David Malcolm <dmalcolm@redhat.com> * libiberty.h (choose_tmpdir): New prototype. diff --git a/include/gcc-c-fe.def b/include/gcc-c-fe.def new file mode 100644 index 00000000000..19cb8674db9 --- /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 00000000000..25ef62f6e81 --- /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 00000000000..34010f24704 --- /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 */ |