1/* Scan linker error messages for missing template instantiations and provide
2 them.
3
| 1/* Scan linker error messages for missing template instantiations and provide
2 them.
3
|
4 Copyright (C) 1995, 1998 Free Software Foundation, Inc.
| 4 Copyright (C) 1995, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
|
5 Contributed by Jason Merrill (jason@cygnus.com).
6
| 5 Contributed by Jason Merrill (jason@cygnus.com).
6
|
7This file is part of GNU CC.
| 7This file is part of GCC.
|
8
| 8
|
9GNU CC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
| 9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 2, or (at your option) any later
12version.
|
13
| 13
|
14GNU CC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
| 14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
|
18
19You should have received a copy of the GNU General Public License
| 18
19You should have received a copy of the GNU General Public License
|
20along with GNU CC; see the file COPYING. If not, write to
21the Free Software Foundation, 59 Temple Place - Suite 330,
22Boston, MA 02111-1307, USA. */
| 20along with GCC; see the file COPYING. If not, write to the Free
21Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2202111-1307, USA. */
|
23
24#include "config.h"
25#include "system.h"
| 23
24#include "config.h"
25#include "system.h"
|
| 26#include "intl.h"
|
26#include "hash.h"
27#include "demangle.h"
| 27#include "hash.h"
28#include "demangle.h"
|
28#include "toplev.h"
| |
29#include "collect2.h"
30
31#define MAX_ITERATIONS 17
32
33/* Obstack allocation and deallocation routines. */
34#define obstack_chunk_alloc xmalloc
35#define obstack_chunk_free free
36
| 29#include "collect2.h"
30
31#define MAX_ITERATIONS 17
32
33/* Obstack allocation and deallocation routines. */
34#define obstack_chunk_alloc xmalloc
35#define obstack_chunk_free free
36
|
37/* Defined in collect2.c. */
38extern int vflag, debug;
39extern char *ldout;
40extern char *c_file_name;
41extern struct obstack temporary_obstack;
42extern struct obstack permanent_obstack;
43extern char * temporary_firstobj;
44
| |
45/* Defined in the automatically-generated underscore.c. */
46extern int prepends_underscore;
47
48static int tlink_verbose;
49
50/* Hash table boilerplate for working with hash.[ch]. We have hash tables
51 for symbol names, file names, and demangled symbols. */
52
53typedef struct symbol_hash_entry
54{
55 struct hash_entry root;
56 struct file_hash_entry *file;
57 int chosen;
58 int tweaking;
59 int tweaked;
60} symbol;
61
62typedef struct file_hash_entry
63{
64 struct hash_entry root;
65 const char *args;
66 const char *dir;
67 const char *main;
68 int tweaking;
69} file;
70
71typedef struct demangled_hash_entry
72{
73 struct hash_entry root;
74 const char *mangled;
75} demangled;
76
77static struct hash_table symbol_table;
78
79static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
80 struct hash_table *,
81 hash_table_key));
82static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
| 37/* Defined in the automatically-generated underscore.c. */
38extern int prepends_underscore;
39
40static int tlink_verbose;
41
42/* Hash table boilerplate for working with hash.[ch]. We have hash tables
43 for symbol names, file names, and demangled symbols. */
44
45typedef struct symbol_hash_entry
46{
47 struct hash_entry root;
48 struct file_hash_entry *file;
49 int chosen;
50 int tweaking;
51 int tweaked;
52} symbol;
53
54typedef struct file_hash_entry
55{
56 struct hash_entry root;
57 const char *args;
58 const char *dir;
59 const char *main;
60 int tweaking;
61} file;
62
63typedef struct demangled_hash_entry
64{
65 struct hash_entry root;
66 const char *mangled;
67} demangled;
68
69static struct hash_table symbol_table;
70
71static struct hash_entry * symbol_hash_newfunc PARAMS ((struct hash_entry *,
72 struct hash_table *,
73 hash_table_key));
74static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
|
83 boolean));
| 75 int));
|
84static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
85 struct hash_table *,
86 hash_table_key));
87static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
88static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
89 struct hash_table *,
90 hash_table_key));
91static struct demangled_hash_entry *
| 76static struct hash_entry * file_hash_newfunc PARAMS ((struct hash_entry *,
77 struct hash_table *,
78 hash_table_key));
79static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
80static struct hash_entry * demangled_hash_newfunc PARAMS ((struct hash_entry *,
81 struct hash_table *,
82 hash_table_key));
83static struct demangled_hash_entry *
|
92 demangled_hash_lookup PARAMS ((const char *, boolean));
| 84 demangled_hash_lookup PARAMS ((const char *, int));
|
93static void symbol_push PARAMS ((symbol *));
94static symbol * symbol_pop PARAMS ((void));
95static void file_push PARAMS ((file *));
96static file * file_pop PARAMS ((void));
97static void tlink_init PARAMS ((void));
| 85static void symbol_push PARAMS ((symbol *));
86static symbol * symbol_pop PARAMS ((void));
87static void file_push PARAMS ((file *));
88static file * file_pop PARAMS ((void));
89static void tlink_init PARAMS ((void));
|
98static int tlink_execute PARAMS ((char *, char **, char *));
99static char * frob_extension PARAMS ((char *, const char *));
| 90static int tlink_execute PARAMS ((const char *, char **, const char *));
91static char * frob_extension PARAMS ((const char *, const char *));
|
100static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
101static char * tfgets PARAMS ((FILE *));
102static char * pfgets PARAMS ((FILE *));
103static void freadsym PARAMS ((FILE *, file *, int));
104static void read_repo_file PARAMS ((file *));
105static void maybe_tweak PARAMS ((char *, file *));
106static int recompile_files PARAMS ((void));
107static int read_repo_files PARAMS ((char **));
108static void demangle_new_symbols PARAMS ((void));
109static int scan_linker_output PARAMS ((const char *));
110
111/* Create a new entry for the symbol hash table.
112 Passed to hash_table_init. */
113
114static struct hash_entry *
115symbol_hash_newfunc (entry, table, string)
116 struct hash_entry *entry;
117 struct hash_table *table;
| 92static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
93static char * tfgets PARAMS ((FILE *));
94static char * pfgets PARAMS ((FILE *));
95static void freadsym PARAMS ((FILE *, file *, int));
96static void read_repo_file PARAMS ((file *));
97static void maybe_tweak PARAMS ((char *, file *));
98static int recompile_files PARAMS ((void));
99static int read_repo_files PARAMS ((char **));
100static void demangle_new_symbols PARAMS ((void));
101static int scan_linker_output PARAMS ((const char *));
102
103/* Create a new entry for the symbol hash table.
104 Passed to hash_table_init. */
105
106static struct hash_entry *
107symbol_hash_newfunc (entry, table, string)
108 struct hash_entry *entry;
109 struct hash_table *table;
|
118 hash_table_key string;
| 110 hash_table_key string ATTRIBUTE_UNUSED;
|
119{
120 struct symbol_hash_entry *ret = (struct symbol_hash_entry *) entry;
121 if (ret == NULL)
122 {
123 ret = ((struct symbol_hash_entry *)
124 hash_allocate (table, sizeof (struct symbol_hash_entry)));
125 if (ret == NULL)
126 return NULL;
127 }
128 ret->file = NULL;
129 ret->chosen = 0;
130 ret->tweaking = 0;
131 ret->tweaked = 0;
132 return (struct hash_entry *) ret;
133}
134
135/* Look up an entry in the symbol hash table. */
136
137static struct symbol_hash_entry *
138symbol_hash_lookup (string, create)
139 const char *string;
| 111{
112 struct symbol_hash_entry *ret = (struct symbol_hash_entry *) entry;
113 if (ret == NULL)
114 {
115 ret = ((struct symbol_hash_entry *)
116 hash_allocate (table, sizeof (struct symbol_hash_entry)));
117 if (ret == NULL)
118 return NULL;
119 }
120 ret->file = NULL;
121 ret->chosen = 0;
122 ret->tweaking = 0;
123 ret->tweaked = 0;
124 return (struct hash_entry *) ret;
125}
126
127/* Look up an entry in the symbol hash table. */
128
129static struct symbol_hash_entry *
130symbol_hash_lookup (string, create)
131 const char *string;
|
140 boolean create;
| 132 int create;
|
141{
142 return ((struct symbol_hash_entry *)
| 133{
134 return ((struct symbol_hash_entry *)
|
143 hash_lookup (&symbol_table, (hash_table_key) string,
144 create, &string_copy));
| 135 hash_lookup (&symbol_table, (const hash_table_key) string,
136 create, string_copy));
|
145}
146
147static struct hash_table file_table;
148
149/* Create a new entry for the file hash table.
150 Passed to hash_table_init. */
151
152static struct hash_entry *
153file_hash_newfunc (entry, table, string)
154 struct hash_entry *entry;
155 struct hash_table *table;
| 137}
138
139static struct hash_table file_table;
140
141/* Create a new entry for the file hash table.
142 Passed to hash_table_init. */
143
144static struct hash_entry *
145file_hash_newfunc (entry, table, string)
146 struct hash_entry *entry;
147 struct hash_table *table;
|
156 hash_table_key string;
| 148 hash_table_key string ATTRIBUTE_UNUSED;
|
157{
158 struct file_hash_entry *ret = (struct file_hash_entry *) entry;
159 if (ret == NULL)
160 {
161 ret = ((struct file_hash_entry *)
162 hash_allocate (table, sizeof (struct file_hash_entry)));
163 if (ret == NULL)
164 return NULL;
165 }
166 ret->args = NULL;
167 ret->dir = NULL;
168 ret->main = NULL;
169 ret->tweaking = 0;
170 return (struct hash_entry *) ret;
171}
172
173/* Look up an entry in the file hash table. */
174
175static struct file_hash_entry *
176file_hash_lookup (string)
177 const char *string;
178{
179 return ((struct file_hash_entry *)
| 149{
150 struct file_hash_entry *ret = (struct file_hash_entry *) entry;
151 if (ret == NULL)
152 {
153 ret = ((struct file_hash_entry *)
154 hash_allocate (table, sizeof (struct file_hash_entry)));
155 if (ret == NULL)
156 return NULL;
157 }
158 ret->args = NULL;
159 ret->dir = NULL;
160 ret->main = NULL;
161 ret->tweaking = 0;
162 return (struct hash_entry *) ret;
163}
164
165/* Look up an entry in the file hash table. */
166
167static struct file_hash_entry *
168file_hash_lookup (string)
169 const char *string;
170{
171 return ((struct file_hash_entry *)
|
180 hash_lookup (&file_table, (hash_table_key) string, true,
181 &string_copy));
| 172 hash_lookup (&file_table, (const hash_table_key) string, true,
173 string_copy));
|
182}
183
184static struct hash_table demangled_table;
185
186/* Create a new entry for the demangled name hash table.
187 Passed to hash_table_init. */
188
189static struct hash_entry *
190demangled_hash_newfunc (entry, table, string)
191 struct hash_entry *entry;
192 struct hash_table *table;
| 174}
175
176static struct hash_table demangled_table;
177
178/* Create a new entry for the demangled name hash table.
179 Passed to hash_table_init. */
180
181static struct hash_entry *
182demangled_hash_newfunc (entry, table, string)
183 struct hash_entry *entry;
184 struct hash_table *table;
|
193 hash_table_key string;
| 185 hash_table_key string ATTRIBUTE_UNUSED;
|
194{
195 struct demangled_hash_entry *ret = (struct demangled_hash_entry *) entry;
196 if (ret == NULL)
197 {
198 ret = ((struct demangled_hash_entry *)
199 hash_allocate (table, sizeof (struct demangled_hash_entry)));
200 if (ret == NULL)
201 return NULL;
202 }
203 ret->mangled = NULL;
204 return (struct hash_entry *) ret;
205}
206
207/* Look up an entry in the demangled name hash table. */
208
209static struct demangled_hash_entry *
210demangled_hash_lookup (string, create)
211 const char *string;
| 186{
187 struct demangled_hash_entry *ret = (struct demangled_hash_entry *) entry;
188 if (ret == NULL)
189 {
190 ret = ((struct demangled_hash_entry *)
191 hash_allocate (table, sizeof (struct demangled_hash_entry)));
192 if (ret == NULL)
193 return NULL;
194 }
195 ret->mangled = NULL;
196 return (struct hash_entry *) ret;
197}
198
199/* Look up an entry in the demangled name hash table. */
200
201static struct demangled_hash_entry *
202demangled_hash_lookup (string, create)
203 const char *string;
|
212 boolean create;
| 204 int create;
|
213{
214 return ((struct demangled_hash_entry *)
| 205{
206 return ((struct demangled_hash_entry *)
|
215 hash_lookup (&demangled_table, (hash_table_key) string,
216 create, &string_copy));
| 207 hash_lookup (&demangled_table, (const hash_table_key) string,
208 create, string_copy));
|
217}
218
219/* Stack code. */
220
221struct symbol_stack_entry
222{
223 symbol *value;
224 struct symbol_stack_entry *next;
225};
226struct obstack symbol_stack_obstack;
227struct symbol_stack_entry *symbol_stack;
228
229struct file_stack_entry
230{
231 file *value;
232 struct file_stack_entry *next;
233};
234struct obstack file_stack_obstack;
235struct file_stack_entry *file_stack;
236
237static void
238symbol_push (p)
239 symbol *p;
240{
241 struct symbol_stack_entry *ep = (struct symbol_stack_entry *) obstack_alloc
242 (&symbol_stack_obstack, sizeof (struct symbol_stack_entry));
243 ep->value = p;
244 ep->next = symbol_stack;
245 symbol_stack = ep;
246}
247
248static symbol *
249symbol_pop ()
250{
251 struct symbol_stack_entry *ep = symbol_stack;
252 symbol *p;
253 if (ep == NULL)
254 return NULL;
255 p = ep->value;
256 symbol_stack = ep->next;
257 obstack_free (&symbol_stack_obstack, ep);
258 return p;
259}
260
261static void
262file_push (p)
263 file *p;
264{
265 struct file_stack_entry *ep;
266
267 if (p->tweaking)
268 return;
269
270 ep = (struct file_stack_entry *) obstack_alloc
271 (&file_stack_obstack, sizeof (struct file_stack_entry));
272 ep->value = p;
273 ep->next = file_stack;
274 file_stack = ep;
275 p->tweaking = 1;
276}
277
278static file *
279file_pop ()
280{
281 struct file_stack_entry *ep = file_stack;
282 file *p;
283 if (ep == NULL)
284 return NULL;
285 p = ep->value;
286 file_stack = ep->next;
287 obstack_free (&file_stack_obstack, ep);
288 p->tweaking = 0;
289 return p;
290}
291
292/* Other machinery. */
293
294/* Initialize the tlink machinery. Called from do_tlink. */
295
296static void
297tlink_init ()
298{
| 209}
210
211/* Stack code. */
212
213struct symbol_stack_entry
214{
215 symbol *value;
216 struct symbol_stack_entry *next;
217};
218struct obstack symbol_stack_obstack;
219struct symbol_stack_entry *symbol_stack;
220
221struct file_stack_entry
222{
223 file *value;
224 struct file_stack_entry *next;
225};
226struct obstack file_stack_obstack;
227struct file_stack_entry *file_stack;
228
229static void
230symbol_push (p)
231 symbol *p;
232{
233 struct symbol_stack_entry *ep = (struct symbol_stack_entry *) obstack_alloc
234 (&symbol_stack_obstack, sizeof (struct symbol_stack_entry));
235 ep->value = p;
236 ep->next = symbol_stack;
237 symbol_stack = ep;
238}
239
240static symbol *
241symbol_pop ()
242{
243 struct symbol_stack_entry *ep = symbol_stack;
244 symbol *p;
245 if (ep == NULL)
246 return NULL;
247 p = ep->value;
248 symbol_stack = ep->next;
249 obstack_free (&symbol_stack_obstack, ep);
250 return p;
251}
252
253static void
254file_push (p)
255 file *p;
256{
257 struct file_stack_entry *ep;
258
259 if (p->tweaking)
260 return;
261
262 ep = (struct file_stack_entry *) obstack_alloc
263 (&file_stack_obstack, sizeof (struct file_stack_entry));
264 ep->value = p;
265 ep->next = file_stack;
266 file_stack = ep;
267 p->tweaking = 1;
268}
269
270static file *
271file_pop ()
272{
273 struct file_stack_entry *ep = file_stack;
274 file *p;
275 if (ep == NULL)
276 return NULL;
277 p = ep->value;
278 file_stack = ep->next;
279 obstack_free (&file_stack_obstack, ep);
280 p->tweaking = 0;
281 return p;
282}
283
284/* Other machinery. */
285
286/* Initialize the tlink machinery. Called from do_tlink. */
287
288static void
289tlink_init ()
290{
|
299 char *p;
| 291 const char *p;
|
300
| 292
|
301 hash_table_init (&symbol_table, symbol_hash_newfunc, &string_hash,
302 &string_compare);
303 hash_table_init (&file_table, file_hash_newfunc, &string_hash,
304 &string_compare);
| 293 hash_table_init (&symbol_table, symbol_hash_newfunc, string_hash,
294 string_compare);
295 hash_table_init (&file_table, file_hash_newfunc, string_hash,
296 string_compare);
|
305 hash_table_init (&demangled_table, demangled_hash_newfunc,
| 297 hash_table_init (&demangled_table, demangled_hash_newfunc,
|
306 &string_hash, &string_compare);
| 298 string_hash, string_compare);
|
307 obstack_begin (&symbol_stack_obstack, 0);
308 obstack_begin (&file_stack_obstack, 0);
309
310 p = getenv ("TLINK_VERBOSE");
311 if (p)
312 tlink_verbose = atoi (p);
313 else
314 {
315 tlink_verbose = 1;
316 if (vflag)
317 tlink_verbose = 2;
318 if (debug)
319 tlink_verbose = 3;
320 }
321}
322
323static int
324tlink_execute (prog, argv, redir)
| 299 obstack_begin (&symbol_stack_obstack, 0);
300 obstack_begin (&file_stack_obstack, 0);
301
302 p = getenv ("TLINK_VERBOSE");
303 if (p)
304 tlink_verbose = atoi (p);
305 else
306 {
307 tlink_verbose = 1;
308 if (vflag)
309 tlink_verbose = 2;
310 if (debug)
311 tlink_verbose = 3;
312 }
313}
314
315static int
316tlink_execute (prog, argv, redir)
|
325 char *prog;
| 317 const char *prog;
|
326 char **argv;
| 318 char **argv;
|
327 char *redir;
| 319 const char *redir;
|
328{
329 collect_execute (prog, argv, redir);
330 return collect_wait (prog);
331}
332
333static char *
334frob_extension (s, ext)
| 320{
321 collect_execute (prog, argv, redir);
322 return collect_wait (prog);
323}
324
325static char *
326frob_extension (s, ext)
|
335 char *s;
| 327 const char *s;
|
336 const char *ext;
337{
| 328 const char *ext;
329{
|
338 char *p = rindex (s, '/');
| 330 const char *p = strrchr (s, '/');
|
339 if (! p)
340 p = s;
| 331 if (! p)
332 p = s;
|
341 p = rindex (p, '.');
| 333 p = strrchr (p, '.');
|
342 if (! p)
343 p = s + strlen (s);
344
345 obstack_grow (&temporary_obstack, s, p - s);
346 return obstack_copy0 (&temporary_obstack, ext, strlen (ext));
347}
348
349static char *
350obstack_fgets (stream, ob)
351 FILE *stream;
352 struct obstack *ob;
353{
354 int c;
355 while ((c = getc (stream)) != EOF && c != '\n')
356 obstack_1grow (ob, c);
357 if (obstack_object_size (ob) == 0)
358 return NULL;
359 obstack_1grow (ob, '\0');
360 return obstack_finish (ob);
361}
362
363static char *
364tfgets (stream)
365 FILE *stream;
366{
367 return obstack_fgets (stream, &temporary_obstack);
368}
369
370static char *
371pfgets (stream)
372 FILE *stream;
373{
374 return obstack_fgets (stream, &permanent_obstack);
375}
376
377/* Real tlink code. */
378
379/* Subroutine of read_repo_file. We are reading the repo file for file F,
380 which is coming in on STREAM, and the symbol that comes next in STREAM
381 is offerred, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
382
383 XXX "provided" is unimplemented, both here and in the compiler. */
384
385static void
386freadsym (stream, f, chosen)
387 FILE *stream;
388 file *f;
389 int chosen;
390{
391 symbol *sym;
392
393 {
| 334 if (! p)
335 p = s + strlen (s);
336
337 obstack_grow (&temporary_obstack, s, p - s);
338 return obstack_copy0 (&temporary_obstack, ext, strlen (ext));
339}
340
341static char *
342obstack_fgets (stream, ob)
343 FILE *stream;
344 struct obstack *ob;
345{
346 int c;
347 while ((c = getc (stream)) != EOF && c != '\n')
348 obstack_1grow (ob, c);
349 if (obstack_object_size (ob) == 0)
350 return NULL;
351 obstack_1grow (ob, '\0');
352 return obstack_finish (ob);
353}
354
355static char *
356tfgets (stream)
357 FILE *stream;
358{
359 return obstack_fgets (stream, &temporary_obstack);
360}
361
362static char *
363pfgets (stream)
364 FILE *stream;
365{
366 return obstack_fgets (stream, &permanent_obstack);
367}
368
369/* Real tlink code. */
370
371/* Subroutine of read_repo_file. We are reading the repo file for file F,
372 which is coming in on STREAM, and the symbol that comes next in STREAM
373 is offerred, chosen or provided if CHOSEN is 0, 1 or 2, respectively.
374
375 XXX "provided" is unimplemented, both here and in the compiler. */
376
377static void
378freadsym (stream, f, chosen)
379 FILE *stream;
380 file *f;
381 int chosen;
382{
383 symbol *sym;
384
385 {
|
394 char *name = tfgets (stream);
| 386 const char *name = tfgets (stream);
|
395 sym = symbol_hash_lookup (name, true);
396 }
397
398 if (sym->file == NULL)
399 {
400 /* We didn't have this symbol already, so we choose this file. */
401
402 symbol_push (sym);
403 sym->file = f;
404 sym->chosen = chosen;
405 }
406 else if (chosen)
407 {
408 /* We want this file; cast aside any pretender. */
409
410 if (sym->chosen && sym->file != f)
411 {
412 if (sym->chosen == 1)
413 file_push (sym->file);
414 else
415 {
416 file_push (f);
417 f = sym->file;
418 chosen = sym->chosen;
419 }
420 }
421 sym->file = f;
422 sym->chosen = chosen;
423 }
424}
425
426/* Read in the repo file denoted by F, and record all its information. */
427
428static void
429read_repo_file (f)
430 file *f;
431{
432 char c;
433 FILE *stream = fopen ((char*) f->root.key, "r");
434
435 if (tlink_verbose >= 2)
| 387 sym = symbol_hash_lookup (name, true);
388 }
389
390 if (sym->file == NULL)
391 {
392 /* We didn't have this symbol already, so we choose this file. */
393
394 symbol_push (sym);
395 sym->file = f;
396 sym->chosen = chosen;
397 }
398 else if (chosen)
399 {
400 /* We want this file; cast aside any pretender. */
401
402 if (sym->chosen && sym->file != f)
403 {
404 if (sym->chosen == 1)
405 file_push (sym->file);
406 else
407 {
408 file_push (f);
409 f = sym->file;
410 chosen = sym->chosen;
411 }
412 }
413 sym->file = f;
414 sym->chosen = chosen;
415 }
416}
417
418/* Read in the repo file denoted by F, and record all its information. */
419
420static void
421read_repo_file (f)
422 file *f;
423{
424 char c;
425 FILE *stream = fopen ((char*) f->root.key, "r");
426
427 if (tlink_verbose >= 2)
|
436 fprintf (stderr, "collect: reading %s\n",
| 428 fprintf (stderr, _("collect: reading %s\n"),
|
437 (char*) f->root.key);
438
439 while (fscanf (stream, "%c ", &c) == 1)
440 {
441 switch (c)
442 {
443 case 'A':
444 f->args = pfgets (stream);
445 break;
446 case 'D':
447 f->dir = pfgets (stream);
448 break;
449 case 'M':
450 f->main = pfgets (stream);
451 break;
452 case 'P':
453 freadsym (stream, f, 2);
454 break;
455 case 'C':
456 freadsym (stream, f, 1);
457 break;
458 case 'O':
459 freadsym (stream, f, 0);
460 break;
461 }
462 obstack_free (&temporary_obstack, temporary_firstobj);
463 }
464 fclose (stream);
465 if (f->args == NULL)
466 f->args = getenv ("COLLECT_GCC_OPTIONS");
467 if (f->dir == NULL)
468 f->dir = ".";
469}
470
471/* We might want to modify LINE, which is a symbol line from file F. We do
472 this if either we saw an error message referring to the symbol in
473 question, or we have already allocated the symbol to another file and
474 this one wants to emit it as well. */
475
476static void
477maybe_tweak (line, f)
478 char *line;
479 file *f;
480{
481 symbol *sym = symbol_hash_lookup (line + 2, false);
482
483 if ((sym->file == f && sym->tweaking)
484 || (sym->file != f && line[0] == 'C'))
485 {
486 sym->tweaking = 0;
487 sym->tweaked = 1;
488
489 if (line[0] == 'O')
490 line[0] = 'C';
491 else
492 line[0] = 'O';
493 }
494}
495
496/* Update the repo files for each of the object files we have adjusted and
497 recompile.
498
499 XXX Should this use collect_execute instead of system? */
500
501static int
502recompile_files ()
503{
504 file *f;
505
| 429 (char*) f->root.key);
430
431 while (fscanf (stream, "%c ", &c) == 1)
432 {
433 switch (c)
434 {
435 case 'A':
436 f->args = pfgets (stream);
437 break;
438 case 'D':
439 f->dir = pfgets (stream);
440 break;
441 case 'M':
442 f->main = pfgets (stream);
443 break;
444 case 'P':
445 freadsym (stream, f, 2);
446 break;
447 case 'C':
448 freadsym (stream, f, 1);
449 break;
450 case 'O':
451 freadsym (stream, f, 0);
452 break;
453 }
454 obstack_free (&temporary_obstack, temporary_firstobj);
455 }
456 fclose (stream);
457 if (f->args == NULL)
458 f->args = getenv ("COLLECT_GCC_OPTIONS");
459 if (f->dir == NULL)
460 f->dir = ".";
461}
462
463/* We might want to modify LINE, which is a symbol line from file F. We do
464 this if either we saw an error message referring to the symbol in
465 question, or we have already allocated the symbol to another file and
466 this one wants to emit it as well. */
467
468static void
469maybe_tweak (line, f)
470 char *line;
471 file *f;
472{
473 symbol *sym = symbol_hash_lookup (line + 2, false);
474
475 if ((sym->file == f && sym->tweaking)
476 || (sym->file != f && line[0] == 'C'))
477 {
478 sym->tweaking = 0;
479 sym->tweaked = 1;
480
481 if (line[0] == 'O')
482 line[0] = 'C';
483 else
484 line[0] = 'O';
485 }
486}
487
488/* Update the repo files for each of the object files we have adjusted and
489 recompile.
490
491 XXX Should this use collect_execute instead of system? */
492
493static int
494recompile_files ()
495{
496 file *f;
497
|
| 498 putenv (xstrdup ("COMPILER_PATH"));
499 putenv (xstrdup ("LIBRARY_PATH"));
500
|
506 while ((f = file_pop ()) != NULL)
507 {
508 char *line, *command;
509 FILE *stream = fopen ((char*) f->root.key, "r");
| 501 while ((f = file_pop ()) != NULL)
502 {
503 char *line, *command;
504 FILE *stream = fopen ((char*) f->root.key, "r");
|
510 char *outname = frob_extension ((char*) f->root.key, ".rnw");
| 505 const char *const outname = frob_extension ((char*) f->root.key, ".rnw");
|
511 FILE *output = fopen (outname, "w");
512
513 while ((line = tfgets (stream)) != NULL)
514 {
515 switch (line[0])
516 {
517 case 'C':
518 case 'O':
519 maybe_tweak (line, f);
520 }
521 fprintf (output, "%s\n", line);
522 }
523 fclose (stream);
524 fclose (output);
525 rename (outname, (char*) f->root.key);
526
527 obstack_grow (&temporary_obstack, "cd ", 3);
528 obstack_grow (&temporary_obstack, f->dir, strlen (f->dir));
529 obstack_grow (&temporary_obstack, "; ", 2);
530 obstack_grow (&temporary_obstack, c_file_name, strlen (c_file_name));
531 obstack_1grow (&temporary_obstack, ' ');
532 obstack_grow (&temporary_obstack, f->args, strlen (f->args));
533 obstack_1grow (&temporary_obstack, ' ');
534 command = obstack_copy0 (&temporary_obstack, f->main, strlen (f->main));
535
536 if (tlink_verbose)
| 506 FILE *output = fopen (outname, "w");
507
508 while ((line = tfgets (stream)) != NULL)
509 {
510 switch (line[0])
511 {
512 case 'C':
513 case 'O':
514 maybe_tweak (line, f);
515 }
516 fprintf (output, "%s\n", line);
517 }
518 fclose (stream);
519 fclose (output);
520 rename (outname, (char*) f->root.key);
521
522 obstack_grow (&temporary_obstack, "cd ", 3);
523 obstack_grow (&temporary_obstack, f->dir, strlen (f->dir));
524 obstack_grow (&temporary_obstack, "; ", 2);
525 obstack_grow (&temporary_obstack, c_file_name, strlen (c_file_name));
526 obstack_1grow (&temporary_obstack, ' ');
527 obstack_grow (&temporary_obstack, f->args, strlen (f->args));
528 obstack_1grow (&temporary_obstack, ' ');
529 command = obstack_copy0 (&temporary_obstack, f->main, strlen (f->main));
530
531 if (tlink_verbose)
|
537 fprintf (stderr, "collect: recompiling %s\n", f->main);
| 532 fprintf (stderr, _("collect: recompiling %s\n"), f->main);
|
538 if (tlink_verbose >= 3)
539 fprintf (stderr, "%s\n", command);
540
541 if (system (command) != 0)
542 return 0;
543
544 read_repo_file (f);
545
546 obstack_free (&temporary_obstack, temporary_firstobj);
547 }
548 return 1;
549}
550
551/* The first phase of processing: determine which object files have
552 .rpo files associated with them, and read in the information. */
553
554static int
555read_repo_files (object_lst)
556 char **object_lst;
557{
558 char **object = object_lst;
559
560 for (; *object; object++)
561 {
| 533 if (tlink_verbose >= 3)
534 fprintf (stderr, "%s\n", command);
535
536 if (system (command) != 0)
537 return 0;
538
539 read_repo_file (f);
540
541 obstack_free (&temporary_obstack, temporary_firstobj);
542 }
543 return 1;
544}
545
546/* The first phase of processing: determine which object files have
547 .rpo files associated with them, and read in the information. */
548
549static int
550read_repo_files (object_lst)
551 char **object_lst;
552{
553 char **object = object_lst;
554
555 for (; *object; object++)
556 {
|
562 char *p = frob_extension (*object, ".rpo");
| 557 const char *p;
|
563 file *f;
564
| 558 file *f;
559
|
| 560 /* Don't bother trying for ld flags. */
561 if (*object[0] == '-')
562 continue;
563
564 p = frob_extension (*object, ".rpo");
565
|
565 if (! file_exists (p))
566 continue;
567
568 f = file_hash_lookup (p);
569
570 read_repo_file (f);
571 }
572
573 if (file_stack != NULL && ! recompile_files ())
574 return 0;
575
576 return (symbol_stack != NULL);
577}
578
579/* Add the demangled forms of any new symbols to the hash table. */
580
581static void
582demangle_new_symbols ()
583{
584 symbol *sym;
585
586 while ((sym = symbol_pop ()) != NULL)
587 {
588 demangled *dem;
| 566 if (! file_exists (p))
567 continue;
568
569 f = file_hash_lookup (p);
570
571 read_repo_file (f);
572 }
573
574 if (file_stack != NULL && ! recompile_files ())
575 return 0;
576
577 return (symbol_stack != NULL);
578}
579
580/* Add the demangled forms of any new symbols to the hash table. */
581
582static void
583demangle_new_symbols ()
584{
585 symbol *sym;
586
587 while ((sym = symbol_pop ()) != NULL)
588 {
589 demangled *dem;
|
589 char *p = cplus_demangle ((char*) sym->root.key,
| 590 const char *p = cplus_demangle ((char*) sym->root.key,
|
590 DMGL_PARAMS | DMGL_ANSI);
591
592 if (! p)
593 continue;
594
595 dem = demangled_hash_lookup (p, true);
596 dem->mangled = (char*) sym->root.key;
597 }
598}
599
600/* Step through the output of the linker, in the file named FNAME, and
601 adjust the settings for each symbol encountered. */
602
603static int
604scan_linker_output (fname)
605 const char *fname;
606{
607 FILE *stream = fopen (fname, "r");
608 char *line;
609
610 while ((line = tfgets (stream)) != NULL)
611 {
612 char *p = line, *q;
613 symbol *sym;
614 int end;
615
616 while (*p && ISSPACE ((unsigned char)*p))
617 ++p;
618
619 if (! *p)
620 continue;
621
622 for (q = p; *q && ! ISSPACE ((unsigned char)*q); ++q)
623 ;
624
625 /* Try the first word on the line. */
626 if (*p == '.')
627 ++p;
628 if (*p == '_' && prepends_underscore)
629 ++p;
630
631 end = ! *q;
632 *q = 0;
633 sym = symbol_hash_lookup (p, false);
634
| 591 DMGL_PARAMS | DMGL_ANSI);
592
593 if (! p)
594 continue;
595
596 dem = demangled_hash_lookup (p, true);
597 dem->mangled = (char*) sym->root.key;
598 }
599}
600
601/* Step through the output of the linker, in the file named FNAME, and
602 adjust the settings for each symbol encountered. */
603
604static int
605scan_linker_output (fname)
606 const char *fname;
607{
608 FILE *stream = fopen (fname, "r");
609 char *line;
610
611 while ((line = tfgets (stream)) != NULL)
612 {
613 char *p = line, *q;
614 symbol *sym;
615 int end;
616
617 while (*p && ISSPACE ((unsigned char)*p))
618 ++p;
619
620 if (! *p)
621 continue;
622
623 for (q = p; *q && ! ISSPACE ((unsigned char)*q); ++q)
624 ;
625
626 /* Try the first word on the line. */
627 if (*p == '.')
628 ++p;
629 if (*p == '_' && prepends_underscore)
630 ++p;
631
632 end = ! *q;
633 *q = 0;
634 sym = symbol_hash_lookup (p, false);
635
|
| 636 /* Some SVR4 linkers produce messages like
637 ld: 0711-317 ERROR: Undefined symbol: .g__t3foo1Zi
638 */
639 if (! sym && ! end && strstr (q+1, "Undefined symbol: "))
640 {
641 char *p = strrchr (q+1, ' ');
642 p++;
643 if (*p == '.')
644 p++;
645 if (*p == '_' && prepends_underscore)
646 p++;
647 sym = symbol_hash_lookup (p, false);
648 }
649
|
635 if (! sym && ! end)
636 /* Try a mangled name in quotes. */
637 {
| 650 if (! sym && ! end)
651 /* Try a mangled name in quotes. */
652 {
|
638 char *oldq = q+1;
| 653 const char *oldq = q+1;
|
639 demangled *dem = 0;
640 q = 0;
641
642 /* First try `GNU style'. */
| 654 demangled *dem = 0;
655 q = 0;
656
657 /* First try `GNU style'. */
|
643 p = index (oldq, '`');
| 658 p = strchr (oldq, '`');
|
644 if (p)
| 659 if (p)
|
645 p++, q = index (p, '\'');
| 660 p++, q = strchr (p, '\'');
|
646 /* Then try "double quotes". */
| 661 /* Then try "double quotes". */
|
647 else if (p = index (oldq, '"'), p)
648 p++, q = index (p, '"');
| 662 else if (p = strchr (oldq, '"'), p)
663 p++, q = strchr (p, '"');
|
649
| 664
|
650 if (q)
| 665 /* Don't let the strstr's below see the demangled name; we
666 might get spurious matches. */
667 if (p)
668 p[-1] = '\0';
669
670 /* We need to check for certain error keywords here, or we would
671 mistakenly use GNU ld's "In function `foo':" message. */
672 if (q && (strstr (oldq, "ndefined")
673 || strstr (oldq, "nresolved")
674 || strstr (oldq, "nsatisfied")
675 || strstr (oldq, "ultiple")))
|
651 {
652 *q = 0;
653 dem = demangled_hash_lookup (p, false);
654 if (dem)
655 sym = symbol_hash_lookup (dem->mangled, false);
656 else
657 {
658 if (*p == '_' && prepends_underscore)
659 ++p;
660 sym = symbol_hash_lookup (p, false);
661 }
662 }
663 }
664
665 if (sym && sym->tweaked)
666 {
667 fclose (stream);
668 return 0;
669 }
670 if (sym && !sym->tweaking)
671 {
672 if (tlink_verbose >= 2)
| 676 {
677 *q = 0;
678 dem = demangled_hash_lookup (p, false);
679 if (dem)
680 sym = symbol_hash_lookup (dem->mangled, false);
681 else
682 {
683 if (*p == '_' && prepends_underscore)
684 ++p;
685 sym = symbol_hash_lookup (p, false);
686 }
687 }
688 }
689
690 if (sym && sym->tweaked)
691 {
692 fclose (stream);
693 return 0;
694 }
695 if (sym && !sym->tweaking)
696 {
697 if (tlink_verbose >= 2)
|
673 fprintf (stderr, "collect: tweaking %s in %s\n",
| 698 fprintf (stderr, _("collect: tweaking %s in %s\n"),
|
674 (char*) sym->root.key, (char*) sym->file->root.key);
675 sym->tweaking = 1;
676 file_push (sym->file);
677 }
678
679 obstack_free (&temporary_obstack, temporary_firstobj);
680 }
681
682 fclose (stream);
683 return (file_stack != NULL);
684}
685
686/* Entry point for tlink. Called from main in collect2.c.
687
688 Iteratively try to provide definitions for all the unresolved symbols
689 mentioned in the linker error messages.
690
691 LD_ARGV is an array of arguments for the linker.
692 OBJECT_LST is an array of object files that we may be able to recompile
693 to provide missing definitions. Currently ignored. */
694
695void
696do_tlink (ld_argv, object_lst)
| 699 (char*) sym->root.key, (char*) sym->file->root.key);
700 sym->tweaking = 1;
701 file_push (sym->file);
702 }
703
704 obstack_free (&temporary_obstack, temporary_firstobj);
705 }
706
707 fclose (stream);
708 return (file_stack != NULL);
709}
710
711/* Entry point for tlink. Called from main in collect2.c.
712
713 Iteratively try to provide definitions for all the unresolved symbols
714 mentioned in the linker error messages.
715
716 LD_ARGV is an array of arguments for the linker.
717 OBJECT_LST is an array of object files that we may be able to recompile
718 to provide missing definitions. Currently ignored. */
719
720void
721do_tlink (ld_argv, object_lst)
|
697 char **ld_argv, **object_lst;
| 722 char **ld_argv, **object_lst ATTRIBUTE_UNUSED;
|
698{
699 int exit = tlink_execute ("ld", ld_argv, ldout);
700
701 tlink_init ();
702
703 if (exit)
704 {
705 int i = 0;
706
707 /* Until collect does a better job of figuring out which are object
708 files, assume that everything on the command line could be. */
709 if (read_repo_files (ld_argv))
710 while (exit && i++ < MAX_ITERATIONS)
711 {
712 if (tlink_verbose >= 3)
713 dump_file (ldout);
714 demangle_new_symbols ();
715 if (! scan_linker_output (ldout))
716 break;
717 if (! recompile_files ())
718 break;
719 if (tlink_verbose)
| 723{
724 int exit = tlink_execute ("ld", ld_argv, ldout);
725
726 tlink_init ();
727
728 if (exit)
729 {
730 int i = 0;
731
732 /* Until collect does a better job of figuring out which are object
733 files, assume that everything on the command line could be. */
734 if (read_repo_files (ld_argv))
735 while (exit && i++ < MAX_ITERATIONS)
736 {
737 if (tlink_verbose >= 3)
738 dump_file (ldout);
739 demangle_new_symbols ();
740 if (! scan_linker_output (ldout))
741 break;
742 if (! recompile_files ())
743 break;
744 if (tlink_verbose)
|
720 fprintf (stderr, "collect: relinking\n");
| 745 fprintf (stderr, _("collect: relinking\n"));
|
721 exit = tlink_execute ("ld", ld_argv, ldout);
722 }
723 }
724
725 dump_file (ldout);
726 unlink (ldout);
727 if (exit)
728 {
729 error ("ld returned %d exit status", exit);
730 collect_exit (exit);
731 }
732}
| 746 exit = tlink_execute ("ld", ld_argv, ldout);
747 }
748 }
749
750 dump_file (ldout);
751 unlink (ldout);
752 if (exit)
753 {
754 error ("ld returned %d exit status", exit);
755 collect_exit (exit);
756 }
757}
|