merge from gcc

This commit is contained in:
DJ Delorie 2014-10-28 00:02:00 +00:00
parent b7749822ed
commit 158f8b34a1
4 changed files with 552 additions and 0 deletions

View File

@ -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> 2014-10-15 David Malcolm <dmalcolm@redhat.com>
* libiberty.h (choose_tmpdir): New prototype. * libiberty.h (choose_tmpdir): New prototype.

197
include/gcc-c-fe.def Normal file
View File

@ -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. */

220
include/gcc-c-interface.h Normal file
View File

@ -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 */

127
include/gcc-interface.h Normal file
View File

@ -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 */