/* Scan linker error messages for missing template instantiations and provide
them.
- Copyright (C) 1995, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Jason Merrill (jason@cygnus.com).
This file is part of GNU CC.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include "config.h"
#include "system.h"
+#include "intl.h"
#include "hash.h"
#include "demangle.h"
-#include "toplev.h"
#include "collect2.h"
#define MAX_ITERATIONS 17
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
-/* Defined in collect2.c. */
-extern int vflag, debug;
-extern char *ldout;
-extern char *c_file_name;
-extern struct obstack temporary_obstack;
-extern struct obstack permanent_obstack;
-extern char * temporary_firstobj;
-
/* Defined in the automatically-generated underscore.c. */
extern int prepends_underscore;
static int tlink_verbose;
\f
-/* Hash table code. */
+/* Hash table boilerplate for working with hash.[ch]. We have hash tables
+ for symbol names, file names, and demangled symbols. */
typedef struct symbol_hash_entry
{
static struct hash_table symbol_table;
+static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
+ struct hash_table *,
+ hash_table_key));
+static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
+ int));
+static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
+ struct hash_table *,
+ hash_table_key));
+static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
+static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
+ struct hash_table *,
+ hash_table_key));
+static struct demangled_hash_entry *
+ demangled_hash_lookup PARAMS ((const char *, int));
+static void symbol_push PARAMS ((symbol *));
+static symbol * symbol_pop PARAMS ((void));
+static void file_push PARAMS ((file *));
+static file * file_pop PARAMS ((void));
+static void tlink_init PARAMS ((void));
+static int tlink_execute PARAMS ((const char *, char **, const char *));
+static char * frob_extension PARAMS ((const char *, const char *));
+static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
+static char * tfgets PARAMS ((FILE *));
+static char * pfgets PARAMS ((FILE *));
+static void freadsym PARAMS ((FILE *, file *, int));
+static void read_repo_file PARAMS ((file *));
+static void maybe_tweak PARAMS ((char *, file *));
+static int recompile_files PARAMS ((void));
+static int read_repo_files PARAMS ((char **));
+static void demangle_new_symbols PARAMS ((void));
+static int scan_linker_output PARAMS ((const char *));
+
+/* Create a new entry for the symbol hash table.
+ Passed to hash_table_init. */
+
static struct hash_entry *
symbol_hash_newfunc (entry, table, string)
struct hash_entry *entry;
struct hash_table *table;
- const char *string;
+ hash_table_key string ATTRIBUTE_UNUSED;
{
struct symbol_hash_entry *ret = (struct symbol_hash_entry *) entry;
if (ret == NULL)
if (ret == NULL)
return NULL;
}
- ret = ((struct symbol_hash_entry *)
- hash_newfunc ((struct hash_entry *) ret, table,
- (hash_table_key) string));
ret->file = NULL;
ret->chosen = 0;
ret->tweaking = 0;
return (struct hash_entry *) ret;
}
+/* Look up an entry in the symbol hash table. */
+
static struct symbol_hash_entry *
symbol_hash_lookup (string, create)
const char *string;
- boolean create;
+ int create;
{
return ((struct symbol_hash_entry *)
- hash_lookup (&symbol_table, (hash_table_key) string,
- create, &string_copy));
+ hash_lookup (&symbol_table, (const hash_table_key) string,
+ create, string_copy));
}
static struct hash_table file_table;
+/* Create a new entry for the file hash table.
+ Passed to hash_table_init. */
+
static struct hash_entry *
file_hash_newfunc (entry, table, string)
struct hash_entry *entry;
struct hash_table *table;
- const char *string;
+ hash_table_key string ATTRIBUTE_UNUSED;
{
struct file_hash_entry *ret = (struct file_hash_entry *) entry;
if (ret == NULL)
if (ret == NULL)
return NULL;
}
- ret = ((struct file_hash_entry *)
- hash_newfunc ((struct hash_entry *) ret, table,
- (hash_table_key) string));
ret->args = NULL;
ret->dir = NULL;
ret->main = NULL;
return (struct hash_entry *) ret;
}
+/* Look up an entry in the file hash table. */
+
static struct file_hash_entry *
file_hash_lookup (string)
const char *string;
{
return ((struct file_hash_entry *)
- hash_lookup (&file_table, (hash_table_key) string, true,
- &string_copy));
+ hash_lookup (&file_table, (const hash_table_key) string, true,
+ string_copy));
}
static struct hash_table demangled_table;
+/* Create a new entry for the demangled name hash table.
+ Passed to hash_table_init. */
+
static struct hash_entry *
demangled_hash_newfunc (entry, table, string)
struct hash_entry *entry;
struct hash_table *table;
- const char *string;
+ hash_table_key string ATTRIBUTE_UNUSED;
{
struct demangled_hash_entry *ret = (struct demangled_hash_entry *) entry;
if (ret == NULL)
if (ret == NULL)
return NULL;
}
- ret = ((struct demangled_hash_entry *)
- hash_newfunc ((struct hash_entry *) ret, table,
- (hash_table_key) string));
ret->mangled = NULL;
return (struct hash_entry *) ret;
}
+/* Look up an entry in the demangled name hash table. */
+
static struct demangled_hash_entry *
demangled_hash_lookup (string, create)
const char *string;
- boolean create;
+ int create;
{
return ((struct demangled_hash_entry *)
- hash_lookup (&demangled_table, (hash_table_key) string,
- create, &string_copy));
+ hash_lookup (&demangled_table, (const hash_table_key) string,
+ create, string_copy));
}
\f
/* Stack code. */
\f
/* Other machinery. */
+/* Initialize the tlink machinery. Called from do_tlink. */
+
static void
tlink_init ()
{
- char *p;
+ const char *p;
- hash_table_init (&symbol_table, symbol_hash_newfunc, &string_hash,
- &string_compare);
- hash_table_init (&file_table, file_hash_newfunc, &string_hash,
- &string_compare);
+ hash_table_init (&symbol_table, symbol_hash_newfunc, string_hash,
+ string_compare);
+ hash_table_init (&file_table, file_hash_newfunc, string_hash,
+ string_compare);
hash_table_init (&demangled_table, demangled_hash_newfunc,
- &string_hash, &string_compare);
+ string_hash, string_compare);
obstack_begin (&symbol_stack_obstack, 0);
obstack_begin (&file_stack_obstack, 0);
static int
tlink_execute (prog, argv, redir)
- char *prog;
+ const char *prog;
char **argv;
- char *redir;
+ const char *redir;
{
collect_execute (prog, argv, redir);
return collect_wait (prog);
static char *
frob_extension (s, ext)
- char *s, *ext;
+ const char *s;
+ const char *ext;
{
- char *p = rindex (s, '/');
+ const char *p = strrchr (s, '/');
if (! p)
p = s;
- p = rindex (p, '.');
+ p = strrchr (p, '.');
if (! p)
p = s + strlen (s);
\f
/* Real tlink code. */
+/* Subroutine of read_repo_file. We are reading the repo file for file F,
+ which is coming in on STREAM, and the symbol that comes next in STREAM
+ is offerred, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
+
+ XXX "provided" is unimplemented, both here and in the compiler. */
+
static void
freadsym (stream, f, chosen)
FILE *stream;
symbol *sym;
{
- char *name = tfgets (stream);
+ const char *name = tfgets (stream);
sym = symbol_hash_lookup (name, true);
}
if (sym->file == NULL)
{
+ /* We didn't have this symbol already, so we choose this file. */
+
symbol_push (sym);
sym->file = f;
sym->chosen = chosen;
}
else if (chosen)
{
+ /* We want this file; cast aside any pretender. */
+
if (sym->chosen && sym->file != f)
{
if (sym->chosen == 1)
}
}
+/* Read in the repo file denoted by F, and record all its information. */
+
static void
read_repo_file (f)
file *f;
FILE *stream = fopen ((char*) f->root.key, "r");
if (tlink_verbose >= 2)
- fprintf (stderr, "collect: reading %s\n",
+ fprintf (stderr, _("collect: reading %s\n"),
(char*) f->root.key);
while (fscanf (stream, "%c ", &c) == 1)
f->dir = ".";
}
+/* We might want to modify LINE, which is a symbol line from file F. We do
+ this if either we saw an error message referring to the symbol in
+ question, or we have already allocated the symbol to another file and
+ this one wants to emit it as well. */
+
static void
maybe_tweak (line, f)
char *line;
}
}
+/* Update the repo files for each of the object files we have adjusted and
+ recompile.
+
+ XXX Should this use collect_execute instead of system? */
+
static int
recompile_files ()
{
{
char *line, *command;
FILE *stream = fopen ((char*) f->root.key, "r");
- char *outname = frob_extension ((char*) f->root.key, ".rnw");
+ const char *outname = frob_extension ((char*) f->root.key, ".rnw");
FILE *output = fopen (outname, "w");
while ((line = tfgets (stream)) != NULL)
command = obstack_copy0 (&temporary_obstack, f->main, strlen (f->main));
if (tlink_verbose)
- fprintf (stderr, "collect: recompiling %s\n", f->main);
+ fprintf (stderr, _("collect: recompiling %s\n"), f->main);
if (tlink_verbose >= 3)
fprintf (stderr, "%s\n", command);
return 1;
}
+/* The first phase of processing: determine which object files have
+ .rpo files associated with them, and read in the information. */
+
static int
read_repo_files (object_lst)
char **object_lst;
for (; *object; object++)
{
- char *p = frob_extension (*object, ".rpo");
+ const char *p;
file *f;
+ /* Don't bother trying for ld flags. */
+ if (*object[0] == '-')
+ continue;
+
+ p = frob_extension (*object, ".rpo");
+
if (! file_exists (p))
continue;
return (symbol_stack != NULL);
}
+/* Add the demangled forms of any new symbols to the hash table. */
+
static void
demangle_new_symbols ()
{
while ((sym = symbol_pop ()) != NULL)
{
demangled *dem;
- char *p = cplus_demangle ((char*) sym->root.key,
+ const char *p = cplus_demangle ((char*) sym->root.key,
DMGL_PARAMS | DMGL_ANSI);
if (! p)
}
}
+/* Step through the output of the linker, in the file named FNAME, and
+ adjust the settings for each symbol encountered. */
+
static int
scan_linker_output (fname)
- char *fname;
+ const char *fname;
{
FILE *stream = fopen (fname, "r");
char *line;
*q = 0;
sym = symbol_hash_lookup (p, false);
+ /* Some SVR4 linkers produce messages like
+ ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
+ */
+ if (! sym && ! end && strstr (q+1, "Undefined symbol: "))
+ {
+ char *p = strrchr (q+1, ' ');
+ p++;
+ if (*p == '.')
+ p++;
+ if (*p == '_' && prepends_underscore)
+ p++;
+ sym = symbol_hash_lookup (p, false);
+ }
+
if (! sym && ! end)
/* Try a mangled name in quotes. */
{
- char *oldq = q+1;
+ const char *oldq = q+1;
demangled *dem = 0;
q = 0;
/* First try `GNU style'. */
- p = index (oldq, '`');
+ p = strchr (oldq, '`');
if (p)
- p++, q = index (p, '\'');
+ p++, q = strchr (p, '\'');
/* Then try "double quotes". */
- else if (p = index (oldq, '"'), p)
- p++, q = index (p, '"');
+ else if (p = strchr (oldq, '"'), p)
+ p++, q = strchr (p, '"');
+
+ /* Don't let the strstr's below see the demangled name; we
+ might get spurious matches. */
+ if (p)
+ p[-1] = '\0';
- if (q)
+ /* We need to check for certain error keywords here, or we would
+ mistakenly use GNU ld's "In function `foo':" message. */
+ if (q && (strstr (oldq, "ndefined")
+ || strstr (oldq, "nresolved")
+ || strstr (oldq, "ultiple")))
{
*q = 0;
dem = demangled_hash_lookup (p, false);
if (dem)
sym = symbol_hash_lookup (dem->mangled, false);
else
- sym = symbol_hash_lookup (p, false);
+ {
+ if (*p == '_' && prepends_underscore)
+ ++p;
+ sym = symbol_hash_lookup (p, false);
+ }
}
}
if (sym && !sym->tweaking)
{
if (tlink_verbose >= 2)
- fprintf (stderr, "collect: tweaking %s in %s\n",
+ fprintf (stderr, _("collect: tweaking %s in %s\n"),
(char*) sym->root.key, (char*) sym->file->root.key);
sym->tweaking = 1;
file_push (sym->file);
return (file_stack != NULL);
}
+/* Entry point for tlink. Called from main in collect2.c.
+
+ Iteratively try to provide definitions for all the unresolved symbols
+ mentioned in the linker error messages.
+
+ LD_ARGV is an array of arguments for the linker.
+ OBJECT_LST is an array of object files that we may be able to recompile
+ to provide missing definitions. Currently ignored. */
+
void
do_tlink (ld_argv, object_lst)
- char **ld_argv, **object_lst;
+ char **ld_argv, **object_lst ATTRIBUTE_UNUSED;
{
int exit = tlink_execute ("ld", ld_argv, ldout);
if (! recompile_files ())
break;
if (tlink_verbose)
- fprintf (stderr, "collect: relinking\n");
+ fprintf (stderr, _("collect: relinking\n"));
exit = tlink_execute ("ld", ld_argv, ldout);
}
}
OSDN Git Service
