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.

5 files changed, 152 insertions, 88 deletions

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 4026d04..b3bf309 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -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);
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 0d3782d..fcc673a 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -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;
 	    }
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 5d26033..51099bf 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -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
 {
 
diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 54a6bda..1c3d900 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -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;
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index 9842615..4443c5d 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -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) */
+