OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Back out of TYPE_FLAG_FUND_TYPE change, solve the problem in valprint.c by 

just printing the type name from the type if it is not otherwise handled.
Implement new handling of the ".syms" file for reusable symbol files.
This commit is contained in:
Fred Fish 1992-04-18 02:30:28 +00:00
parent c3089ec904
commit 1867b3be84
5 changed files with 152 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
gdb/c-exp.y
View File

@ -1568,71 +1568,71 @@ _initialize_c_exp ()
{
builtin_type_void =
init_type (TYPE_CODE_VOID, 1,
TYPE_FLAG_FUND_TYPE,
0,
"void", (struct objfile *) NULL);
builtin_type_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"char", (struct objfile *) NULL);
builtin_type_signed_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed char", (struct objfile *) NULL);
builtin_type_unsigned_char =
init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned char", (struct objfile *) NULL);
builtin_type_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"short", (struct objfile *) NULL);
builtin_type_unsigned_short =
init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned short", (struct objfile *) NULL);
builtin_type_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"int", (struct objfile *) NULL);
builtin_type_unsigned_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned int", (struct objfile *) NULL);
builtin_type_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long", (struct objfile *) NULL);
builtin_type_unsigned_long =
init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned long", (struct objfile *) NULL);
builtin_type_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long long", (struct objfile *) NULL);
builtin_type_unsigned_long_long =
init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned long long", (struct objfile *) NULL);
builtin_type_float =
init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"float", (struct objfile *) NULL);
builtin_type_double =
init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"double", (struct objfile *) NULL);
builtin_type_long_double =
init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long double", (struct objfile *) NULL);
builtin_type_complex =
init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"complex", (struct objfile *) NULL);
builtin_type_double_complex =
init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"double complex", (struct objfile *) NULL);
add_language (&c_language_defn);

52
gdb/gdbtypes.c
View File

@ -804,157 +804,157 @@ lookup_fundamental_type (objfile, typeid)
case FT_VOID:
type = init_type (TYPE_CODE_VOID,
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"void", objfile);
break;
case FT_BOOLEAN:
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"boolean", objfile);
break;
case FT_STRING:
type = init_type (TYPE_CODE_PASCAL_ARRAY,
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"string", objfile);
break;
case FT_CHAR:
type = init_type (TYPE_CODE_INT,
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"char", objfile);
break;
case FT_SIGNED_CHAR:
type = init_type (TYPE_CODE_INT,
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed char", objfile);
break;
case FT_UNSIGNED_CHAR:
type = init_type (TYPE_CODE_INT,
TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned char", objfile);
break;
case FT_SHORT:
type = init_type (TYPE_CODE_INT,
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"short", objfile);
break;
case FT_SIGNED_SHORT:
type = init_type (TYPE_CODE_INT,
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed short", objfile);
break;
case FT_UNSIGNED_SHORT:
type = init_type (TYPE_CODE_INT,
TARGET_SHORT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned short", objfile);
break;
case FT_INTEGER:
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"int", objfile);
break;
case FT_SIGNED_INTEGER:
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed int", objfile);
break;
case FT_UNSIGNED_INTEGER:
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned int", objfile);
break;
case FT_FIXED_DECIMAL:
type = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"fixed decimal", objfile);
break;
case FT_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long", objfile);
break;
case FT_SIGNED_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed long", objfile);
break;
case FT_UNSIGNED_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned long", objfile);
break;
case FT_LONG_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long long", objfile);
break;
case FT_SIGNED_LONG_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_SIGNED,
TYPE_FLAG_SIGNED,
"signed long long", objfile);
break;
case FT_UNSIGNED_LONG_LONG:
type = init_type (TYPE_CODE_INT,
TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"unsigned long long", objfile);
break;
case FT_FLOAT:
type = init_type (TYPE_CODE_FLT,
TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"float", objfile);
break;
case FT_DBL_PREC_FLOAT:
type = init_type (TYPE_CODE_FLT,
TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"double", objfile);
break;
case FT_FLOAT_DECIMAL:
type = init_type (TYPE_CODE_FLT,
TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"floating decimal", objfile);
break;
case FT_EXT_PREC_FLOAT:
type = init_type (TYPE_CODE_FLT,
TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long double", objfile);
break;
case FT_COMPLEX:
type = init_type (TYPE_CODE_FLT,
TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"complex", objfile);
break;
case FT_DBL_PREC_COMPLEX:
type = init_type (TYPE_CODE_FLT,
TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"double complex", objfile);
break;
case FT_EXT_PREC_COMPLEX:
type = init_type (TYPE_CODE_FLT,
TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"long double complex", objfile);
break;
}

4
gdb/gdbtypes.h
View File

@ -99,11 +99,7 @@ enum type_code
#define TYPE_FLAG_STUB (1 << 2)
/* This type is a fundamental type in the current source language. */
#define TYPE_FLAG_FUND_TYPE (1 << 3)
struct type
{

10
gdb/m2-exp.y
View File

@ -1236,23 +1236,23 @@ _initialize_m2_exp ()
/* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */
builtin_type_m2_int =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"INTEGER", (struct objfile *) NULL);
builtin_type_m2_card =
init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"CARDINAL", (struct objfile *) NULL);
builtin_type_m2_real =
init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE,
0,
"REAL", (struct objfile *) NULL);
builtin_type_m2_char =
init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"CHAR", (struct objfile *) NULL);
builtin_type_m2_bool =
init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
TYPE_FLAG_FUND_TYPE | TYPE_FLAG_UNSIGNED,
TYPE_FLAG_UNSIGNED,
"BOOLEAN", (struct objfile *) NULL);
TYPE_NFIELDS(builtin_type_m2_bool) = 2;

140
gdb/objfiles.c
View File

@ -34,12 +34,23 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Prototypes for local functions */
#if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
static int
open_existing_mapped_file PARAMS ((char *, long, int));
static int
open_mapped_file PARAMS ((char *filename, long mtime, int mapped));
static CORE_ADDR
map_to_address PARAMS ((void));
#endif /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
/* Message to be printed before the error message, when an error occurs. */
extern char *error_pre_print;
/* Externally visible variables that are owned by this module.
See declarations in objfile.h for more info. */
@ -359,6 +370,57 @@ have_minimal_symbols ()
return 0;
}
#if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
/* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
of the corresponding symbol file in MTIME, try to open an existing file
with the name SYMSFILENAME and verify it is more recent than the base
file by checking it's timestamp against MTIME.
If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
If SYMSFILENAME does exist, but is out of date, we check to see if the
user has specified creation of a mapped file. If so, we don't issue
any warning message because we will be creating a new mapped file anyway,
overwriting the old one. If not, then we issue a warning message so that
the user will know why we aren't using this existing mapped symbol file.
In either case, we return -1.
If SYMSFILENAME does exist and is not out of date, but can't be opened for
some reason, then prints an appropriate system error message and returns -1.
Otherwise, returns the open file descriptor. */
static int
open_existing_mapped_file (symsfilename, mtime, mapped)
char *symsfilename;
long mtime;
int mapped;
{
int fd = -1;
struct stat sbuf;
if (stat (symsfilename, &sbuf) == 0)
{
if (sbuf.st_mtime < mtime)
{
if (!mapped)
{
warning ("mapped symbol file `%s' is out of date", symsfilename);
}
}
else if ((fd = open (symsfilename, O_RDWR)) < 0)
{
if (error_pre_print)
{
printf (error_pre_print);
}
print_sys_errmsg (symsfilename, errno);
}
}
return (fd);
}
/* Look for a mapped symbol file that corresponds to FILENAME and is more
recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
use a mapped symbol file for this file, so create a new one if one does
@ -369,7 +431,19 @@ have_minimal_symbols ()
This routine is responsible for implementing the policy that generates
the name of the mapped symbol file from the name of a file containing
symbols that gdb would like to read. */
symbols that gdb would like to read. Currently this policy is to append
".syms" to the name of the file.
This routine is also responsible for implementing the policy that
determines where the mapped symbol file is found (the search path).
This policy is that when reading an existing mapped file, a file of
the correct name in the current directory takes precedence over a
file of the correct name in the same directory as the symbol file.
When creating a new mapped file, it is always created in the current
directory. This helps to minimize the chances of a user unknowingly
creating big mapped files in places like /bin and /usr/local/bin, and
allows a local copy to override a manually installed global copy (in
/bin for example). */
static int
open_mapped_file (filename, mtime, mapped)
@ -378,53 +452,44 @@ open_mapped_file (filename, mtime, mapped)
int mapped;
{
int fd;
char *symfilename;
struct stat sbuf;
char *symsfilename;
/* For now, all we do is look in the local directory for a file with
the name of the base file and an extension of ".syms" */
/* First try to open an existing file in the current directory, and
then try the directory where the symbol file is located. */
symfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
/* Check to see if the desired file already exists and is more recent than
the corresponding base file (specified by the passed MTIME parameter).
The open will fail if the file does not already exist. */
if ((fd = open (symfilename, O_RDWR)) >= 0)
symsfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
if ((fd = open_existing_mapped_file (symsfilename, mtime, mapped)) < 0)
{
if (fstat (fd, &sbuf) != 0)
{
(void) close (fd);
perror_with_name (symfilename);
}
else if (sbuf.st_mtime > mtime)
{
return (fd);
}
else
{
(void) close (fd);
fd = -1;
}
free (symsfilename);
symsfilename = concat (filename, ".syms", (char *) NULL);
fd = open_existing_mapped_file (symsfilename, mtime, mapped);
}
/* Either the file does not already exist, or the base file has changed
since it was created. In either case, if the user has specified use of
a mapped file, then create a new mapped file, truncating any existing
one.
In the case where there is an existing file, but it is out of date, and
the user did not specify mapped, the existing file is just silently
ignored. Perhaps we should warn about this case (FIXME?).
/* If we don't have an open file by now, then either the file does not
already exist, or the base file has changed since it was created. In
either case, if the user has specified use of a mapped file, then
create a new mapped file, truncating any existing one. If we can't
create one, print a system error message saying why we can't.
By default the file is rw for everyone, with the user's umask taking
care of turning off the permissions the user wants off. */
if (mapped)
if ((fd < 0) && mapped)
{
fd = open (symfilename, O_RDWR | O_CREAT | O_TRUNC, 0666);
free (symsfilename);
symsfilename = concat ("./", basename (filename), ".syms",
(char *) NULL);
if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
{
if (error_pre_print)
{
printf (error_pre_print);
}
print_sys_errmsg (symsfilename, errno);
}
}
free (symsfilename);
return (fd);
}
@ -472,3 +537,6 @@ map_to_address ()
#endif
}
#endif /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */