Hardcode host-specific name for LTO plugin
[platform/upstream/binutils.git] / ld / ldcref.c
1 /* ldcref.c -- output a cross reference table
2    Copyright (C) 1996-2014 Free Software Foundation, Inc.
3    Written by Ian Lance Taylor <ian@cygnus.com>
4
5    This file is part of the GNU Binutils.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22
23 /* This file holds routines that manage the cross reference table.
24    The table is used to generate cross reference reports.  It is also
25    used to implement the NOCROSSREFS command in the linker script.  */
26
27 #include "sysdep.h"
28 #include "bfd.h"
29 #include "bfdlink.h"
30 #include "libiberty.h"
31 #include "demangle.h"
32 #include "objalloc.h"
33
34 #include "ld.h"
35 #include "ldmain.h"
36 #include "ldmisc.h"
37 #include "ldexp.h"
38 #include "ldlang.h"
39
40 /* We keep an instance of this structure for each reference to a
41    symbol from a given object.  */
42
43 struct cref_ref
44 {
45   /* The next reference.  */
46   struct cref_ref *next;
47   /* The object.  */
48   bfd *abfd;
49   /* True if the symbol is defined.  */
50   unsigned int def : 1;
51   /* True if the symbol is common.  */
52   unsigned int common : 1;
53   /* True if the symbol is undefined.  */
54   unsigned int undef : 1;
55 };
56
57 /* We keep a hash table of symbols.  Each entry looks like this.  */
58
59 struct cref_hash_entry
60 {
61   struct bfd_hash_entry root;
62   /* The demangled name.  */
63   const char *demangled;
64   /* References to and definitions of this symbol.  */
65   struct cref_ref *refs;
66 };
67
68 /* This is what the hash table looks like.  */
69
70 struct cref_hash_table
71 {
72   struct bfd_hash_table root;
73 };
74
75 /* Forward declarations.  */
76
77 static void output_one_cref (FILE *, struct cref_hash_entry *);
78 static void check_local_sym_xref (lang_input_statement_type *);
79 static bfd_boolean check_nocrossref (struct cref_hash_entry *, void *);
80 static void check_refs (const char *, bfd_boolean, asection *, bfd *,
81                         struct lang_nocrossrefs *);
82 static void check_reloc_refs (bfd *, asection *, void *);
83
84 /* Look up an entry in the cref hash table.  */
85
86 #define cref_hash_lookup(table, string, create, copy)           \
87   ((struct cref_hash_entry *)                                   \
88    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
89
90 /* Traverse the cref hash table.  */
91
92 #define cref_hash_traverse(table, func, info)                           \
93   (bfd_hash_traverse                                                    \
94    (&(table)->root,                                                     \
95     (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func),         \
96     (info)))
97
98 /* The cref hash table.  */
99
100 static struct cref_hash_table cref_table;
101
102 /* Whether the cref hash table has been initialized.  */
103
104 static bfd_boolean cref_initialized;
105
106 /* The number of symbols seen so far.  */
107
108 static size_t cref_symcount;
109
110 /* Used to take a snapshot of the cref hash table when starting to
111    add syms from an as-needed library.  */
112 static struct bfd_hash_entry **old_table;
113 static unsigned int old_size;
114 static unsigned int old_count;
115 static void * old_tab;
116 static void * alloc_mark;
117 static size_t tabsize, entsize, refsize;
118 static size_t old_symcount;
119
120 /* Create an entry in a cref hash table.  */
121
122 static struct bfd_hash_entry *
123 cref_hash_newfunc (struct bfd_hash_entry *entry,
124                    struct bfd_hash_table *table,
125                    const char *string)
126 {
127   struct cref_hash_entry *ret = (struct cref_hash_entry *) entry;
128
129   /* Allocate the structure if it has not already been allocated by a
130      subclass.  */
131   if (ret == NULL)
132     ret = ((struct cref_hash_entry *)
133            bfd_hash_allocate (table, sizeof (struct cref_hash_entry)));
134   if (ret == NULL)
135     return NULL;
136
137   /* Call the allocation method of the superclass.  */
138   ret = ((struct cref_hash_entry *)
139          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
140   if (ret != NULL)
141     {
142       /* Set local fields.  */
143       ret->demangled = NULL;
144       ret->refs = NULL;
145
146       /* Keep a count of the number of entries created in the hash
147          table.  */
148       ++cref_symcount;
149     }
150
151   return &ret->root;
152 }
153
154 /* Add a symbol to the cref hash table.  This is called for every
155    global symbol that is seen during the link.  */
156
157 void
158 add_cref (const char *name,
159           bfd *abfd,
160           asection *section,
161           bfd_vma value ATTRIBUTE_UNUSED)
162 {
163   struct cref_hash_entry *h;
164   struct cref_ref *r;
165
166   if (! cref_initialized)
167     {
168       if (!bfd_hash_table_init (&cref_table.root, cref_hash_newfunc,
169                                 sizeof (struct cref_hash_entry)))
170         einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));
171       cref_initialized = TRUE;
172     }
173
174   h = cref_hash_lookup (&cref_table, name, TRUE, FALSE);
175   if (h == NULL)
176     einfo (_("%X%P: cref_hash_lookup failed: %E\n"));
177
178   for (r = h->refs; r != NULL; r = r->next)
179     if (r->abfd == abfd)
180       break;
181
182   if (r == NULL)
183     {
184       r = (struct cref_ref *) bfd_hash_allocate (&cref_table.root, sizeof *r);
185       if (r == NULL)
186         einfo (_("%X%P: cref alloc failed: %E\n"));
187       r->next = h->refs;
188       h->refs = r;
189       r->abfd = abfd;
190       r->def = FALSE;
191       r->common = FALSE;
192       r->undef = FALSE;
193     }
194
195   if (bfd_is_und_section (section))
196     r->undef = TRUE;
197   else if (bfd_is_com_section (section))
198     r->common = TRUE;
199   else
200     r->def = TRUE;
201 }
202
203 /* Called before loading an as-needed library to take a snapshot of
204    the cref hash table, and after we have loaded or found that the
205    library was not needed.  */
206
207 bfd_boolean
208 handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED,
209                       enum notice_asneeded_action act)
210 {
211   unsigned int i;
212
213   if (!cref_initialized)
214     return TRUE;
215
216   if (act == notice_as_needed)
217     {
218       char *old_ent, *old_ref;
219
220       for (i = 0; i < cref_table.root.size; i++)
221         {
222           struct bfd_hash_entry *p;
223           struct cref_hash_entry *c;
224           struct cref_ref *r;
225
226           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
227             {
228               entsize += cref_table.root.entsize;
229               c = (struct cref_hash_entry *) p;
230               for (r = c->refs; r != NULL; r = r->next)
231                 refsize += sizeof (struct cref_ref);
232             }
233         }
234
235       tabsize = cref_table.root.size * sizeof (struct bfd_hash_entry *);
236       old_tab = xmalloc (tabsize + entsize + refsize);
237
238       alloc_mark = bfd_hash_allocate (&cref_table.root, 1);
239       if (alloc_mark == NULL)
240         return FALSE;
241
242       memcpy (old_tab, cref_table.root.table, tabsize);
243       old_ent = (char *) old_tab + tabsize;
244       old_ref = (char *) old_ent + entsize;
245       old_table = cref_table.root.table;
246       old_size = cref_table.root.size;
247       old_count = cref_table.root.count;
248       old_symcount = cref_symcount;
249
250       for (i = 0; i < cref_table.root.size; i++)
251         {
252           struct bfd_hash_entry *p;
253           struct cref_hash_entry *c;
254           struct cref_ref *r;
255
256           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
257             {
258               memcpy (old_ent, p, cref_table.root.entsize);
259               old_ent = (char *) old_ent + cref_table.root.entsize;
260               c = (struct cref_hash_entry *) p;
261               for (r = c->refs; r != NULL; r = r->next)
262                 {
263                   memcpy (old_ref, r, sizeof (struct cref_ref));
264                   old_ref = (char *) old_ref + sizeof (struct cref_ref);
265                 }
266             }
267         }
268       return TRUE;
269     }
270
271   if (act == notice_not_needed)
272     {
273       char *old_ent, *old_ref;
274
275       if (old_tab == NULL)
276         {
277           /* The only way old_tab can be NULL is if the cref hash table
278              had not been initialised when notice_as_needed.  */
279           bfd_hash_table_free (&cref_table.root);
280           cref_initialized = FALSE;
281           return TRUE;
282         }
283
284       old_ent = (char *) old_tab + tabsize;
285       old_ref = (char *) old_ent + entsize;
286       cref_table.root.table = old_table;
287       cref_table.root.size = old_size;
288       cref_table.root.count = old_count;
289       memcpy (cref_table.root.table, old_tab, tabsize);
290       cref_symcount = old_symcount;
291
292       for (i = 0; i < cref_table.root.size; i++)
293         {
294           struct bfd_hash_entry *p;
295           struct cref_hash_entry *c;
296           struct cref_ref *r;
297
298           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
299             {
300               memcpy (p, old_ent, cref_table.root.entsize);
301               old_ent = (char *) old_ent + cref_table.root.entsize;
302               c = (struct cref_hash_entry *) p;
303               for (r = c->refs; r != NULL; r = r->next)
304                 {
305                   memcpy (r, old_ref, sizeof (struct cref_ref));
306                   old_ref = (char *) old_ref + sizeof (struct cref_ref);
307                 }
308             }
309         }
310
311       objalloc_free_block ((struct objalloc *) cref_table.root.memory,
312                            alloc_mark);
313     }
314   else if (act != notice_needed)
315     return FALSE;
316
317   free (old_tab);
318   old_tab = NULL;
319   return TRUE;
320 }
321
322 /* Copy the addresses of the hash table entries into an array.  This
323    is called via cref_hash_traverse.  We also fill in the demangled
324    name.  */
325
326 static bfd_boolean
327 cref_fill_array (struct cref_hash_entry *h, void *data)
328 {
329   struct cref_hash_entry ***pph = (struct cref_hash_entry ***) data;
330
331   ASSERT (h->demangled == NULL);
332   h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,
333                                DMGL_ANSI | DMGL_PARAMS);
334   if (h->demangled == NULL)
335     h->demangled = h->root.string;
336
337   **pph = h;
338
339   ++*pph;
340
341   return TRUE;
342 }
343
344 /* Sort an array of cref hash table entries by name.  */
345
346 static int
347 cref_sort_array (const void *a1, const void *a2)
348 {
349   const struct cref_hash_entry * const *p1 =
350       (const struct cref_hash_entry * const *) a1;
351   const struct cref_hash_entry * const *p2 =
352       (const struct cref_hash_entry * const *) a2;
353
354   if (demangling)
355     return strcmp ((*p1)->demangled, (*p2)->demangled);
356   else
357     return strcmp ((*p1)->root.string, (*p2)->root.string);
358 }
359
360 /* Write out the cref table.  */
361
362 #define FILECOL (50)
363
364 void
365 output_cref (FILE *fp)
366 {
367   int len;
368   struct cref_hash_entry **csyms, **csym_fill, **csym, **csym_end;
369   const char *msg;
370
371   fprintf (fp, _("\nCross Reference Table\n\n"));
372   msg = _("Symbol");
373   fprintf (fp, "%s", msg);
374   len = strlen (msg);
375   while (len < FILECOL)
376     {
377       putc (' ', fp);
378       ++len;
379     }
380   fprintf (fp, _("File\n"));
381
382   if (! cref_initialized)
383     {
384       fprintf (fp, _("No symbols\n"));
385       return;
386     }
387
388   csyms = (struct cref_hash_entry **) xmalloc (cref_symcount * sizeof (*csyms));
389
390   csym_fill = csyms;
391   cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);
392   ASSERT ((size_t) (csym_fill - csyms) == cref_symcount);
393
394   qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array);
395
396   csym_end = csyms + cref_symcount;
397   for (csym = csyms; csym < csym_end; csym++)
398     output_one_cref (fp, *csym);
399 }
400
401 /* Output one entry in the cross reference table.  */
402
403 static void
404 output_one_cref (FILE *fp, struct cref_hash_entry *h)
405 {
406   int len;
407   struct bfd_link_hash_entry *hl;
408   struct cref_ref *r;
409
410   hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
411                              FALSE, TRUE);
412   if (hl == NULL)
413     einfo ("%P: symbol `%T' missing from main hash table\n",
414            h->root.string);
415   else
416     {
417       /* If this symbol is defined in a dynamic object but never
418          referenced by a normal object, then don't print it.  */
419       if (hl->type == bfd_link_hash_defined)
420         {
421           if (hl->u.def.section->output_section == NULL)
422             return;
423           if (hl->u.def.section->owner != NULL
424               && (hl->u.def.section->owner->flags & DYNAMIC) != 0)
425             {
426               for (r = h->refs; r != NULL; r = r->next)
427                 if ((r->abfd->flags & DYNAMIC) == 0)
428                   break;
429               if (r == NULL)
430                 return;
431             }
432         }
433     }
434
435   if (demangling)
436     {
437       fprintf (fp, "%s ", h->demangled);
438       len = strlen (h->demangled) + 1;
439     }
440   else
441     {
442       fprintf (fp, "%s ", h->root.string);
443       len = strlen (h->root.string) + 1;
444     }
445
446   for (r = h->refs; r != NULL; r = r->next)
447     {
448       if (r->def)
449         {
450           while (len < FILECOL)
451             {
452               putc (' ', fp);
453               ++len;
454             }
455           lfinfo (fp, "%B\n", r->abfd);
456           len = 0;
457         }
458     }
459
460   for (r = h->refs; r != NULL; r = r->next)
461     {
462       if (r->common)
463         {
464           while (len < FILECOL)
465             {
466               putc (' ', fp);
467               ++len;
468             }
469           lfinfo (fp, "%B\n", r->abfd);
470           len = 0;
471         }
472     }
473
474   for (r = h->refs; r != NULL; r = r->next)
475     {
476       if (! r->def && ! r->common)
477         {
478           while (len < FILECOL)
479             {
480               putc (' ', fp);
481               ++len;
482             }
483           lfinfo (fp, "%B\n", r->abfd);
484           len = 0;
485         }
486     }
487
488   ASSERT (len == 0);
489 }
490
491 /* Check for prohibited cross references.  */
492
493 void
494 check_nocrossrefs (void)
495 {
496   if (! cref_initialized)
497     return;
498
499   cref_hash_traverse (&cref_table, check_nocrossref, NULL);
500
501   lang_for_each_file (check_local_sym_xref);
502 }
503
504 /* Check for prohibited cross references to local and section symbols.  */
505
506 static void
507 check_local_sym_xref (lang_input_statement_type *statement)
508 {
509   bfd *abfd;
510   asymbol **syms;
511
512   abfd = statement->the_bfd;
513   if (abfd == NULL)
514     return;
515
516   if (!bfd_generic_link_read_symbols (abfd))
517     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
518
519   for (syms = bfd_get_outsymbols (abfd); *syms; ++syms)
520     {
521       asymbol *sym = *syms;
522       if (sym->flags & (BSF_GLOBAL | BSF_WARNING | BSF_INDIRECT | BSF_FILE))
523         continue;
524       if ((sym->flags & (BSF_LOCAL | BSF_SECTION_SYM)) != 0
525           && sym->section->output_section != NULL)
526         {
527           const char *outsecname, *symname;
528           struct lang_nocrossrefs *ncrs;
529           struct lang_nocrossref *ncr;
530
531           outsecname = sym->section->output_section->name;
532           symname = NULL;
533           if ((sym->flags & BSF_SECTION_SYM) == 0)
534             symname = sym->name;
535           for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
536             for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
537               if (strcmp (ncr->name, outsecname) == 0)
538                 check_refs (symname, FALSE, sym->section, abfd, ncrs);
539         }
540     }
541 }
542
543 /* Check one symbol to see if it is a prohibited cross reference.  */
544
545 static bfd_boolean
546 check_nocrossref (struct cref_hash_entry *h, void *ignore ATTRIBUTE_UNUSED)
547 {
548   struct bfd_link_hash_entry *hl;
549   asection *defsec;
550   const char *defsecname;
551   struct lang_nocrossrefs *ncrs;
552   struct lang_nocrossref *ncr;
553   struct cref_ref *ref;
554
555   hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
556                              FALSE, TRUE);
557   if (hl == NULL)
558     {
559       einfo (_("%P: symbol `%T' missing from main hash table\n"),
560              h->root.string);
561       return TRUE;
562     }
563
564   if (hl->type != bfd_link_hash_defined
565       && hl->type != bfd_link_hash_defweak)
566     return TRUE;
567
568   defsec = hl->u.def.section->output_section;
569   if (defsec == NULL)
570     return TRUE;
571   defsecname = bfd_get_section_name (defsec->owner, defsec);
572
573   for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
574     for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
575       if (strcmp (ncr->name, defsecname) == 0)
576         for (ref = h->refs; ref != NULL; ref = ref->next)
577           check_refs (hl->root.string, TRUE, hl->u.def.section,
578                       ref->abfd, ncrs);
579
580   return TRUE;
581 }
582
583 /* The struct is used to pass information from check_refs to
584    check_reloc_refs through bfd_map_over_sections.  */
585
586 struct check_refs_info {
587   const char *sym_name;
588   asection *defsec;
589   struct lang_nocrossrefs *ncrs;
590   asymbol **asymbols;
591   bfd_boolean global;
592 };
593
594 /* This function is called for each symbol defined in a section which
595    prohibits cross references.  We need to look through all references
596    to this symbol, and ensure that the references are not from
597    prohibited sections.  */
598
599 static void
600 check_refs (const char *name,
601             bfd_boolean global,
602             asection *sec,
603             bfd *abfd,
604             struct lang_nocrossrefs *ncrs)
605 {
606   struct check_refs_info info;
607
608   /* We need to look through the relocations for this BFD, to see
609      if any of the relocations which refer to this symbol are from
610      a prohibited section.  Note that we need to do this even for
611      the BFD in which the symbol is defined, since even a single
612      BFD might contain a prohibited cross reference.  */
613
614   if (!bfd_generic_link_read_symbols (abfd))
615     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
616
617   info.sym_name = name;
618   info.global = global;
619   info.defsec = sec;
620   info.ncrs = ncrs;
621   info.asymbols = bfd_get_outsymbols (abfd);
622   bfd_map_over_sections (abfd, check_reloc_refs, &info);
623 }
624
625 /* This is called via bfd_map_over_sections.  INFO->SYM_NAME is a symbol
626    defined in INFO->DEFSECNAME.  If this section maps into any of the
627    sections listed in INFO->NCRS, other than INFO->DEFSECNAME, then we
628    look through the relocations.  If any of the relocations are to
629    INFO->SYM_NAME, then we report a prohibited cross reference error.  */
630
631 static void
632 check_reloc_refs (bfd *abfd, asection *sec, void *iarg)
633 {
634   struct check_refs_info *info = (struct check_refs_info *) iarg;
635   asection *outsec;
636   const char *outsecname;
637   asection *outdefsec;
638   const char *outdefsecname;
639   struct lang_nocrossref *ncr;
640   const char *symname;
641   bfd_boolean global;
642   long relsize;
643   arelent **relpp;
644   long relcount;
645   arelent **p, **pend;
646
647   outsec = sec->output_section;
648   outsecname = bfd_get_section_name (outsec->owner, outsec);
649
650   outdefsec = info->defsec->output_section;
651   outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec);
652
653   /* The section where the symbol is defined is permitted.  */
654   if (strcmp (outsecname, outdefsecname) == 0)
655     return;
656
657   for (ncr = info->ncrs->list; ncr != NULL; ncr = ncr->next)
658     if (strcmp (outsecname, ncr->name) == 0)
659       break;
660
661   if (ncr == NULL)
662     return;
663
664   /* This section is one for which cross references are prohibited.
665      Look through the relocations, and see if any of them are to
666      INFO->SYM_NAME.  If INFO->SYMNAME is NULL, check for relocations
667      against the section symbol.  If INFO->GLOBAL is TRUE, the
668      definition is global, check for relocations against the global
669      symbols.  Otherwise check for relocations against the local and
670      section symbols.  */
671
672   symname = info->sym_name;
673   global = info->global;
674
675   relsize = bfd_get_reloc_upper_bound (abfd, sec);
676   if (relsize < 0)
677     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
678   if (relsize == 0)
679     return;
680
681   relpp = (arelent **) xmalloc (relsize);
682   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
683   if (relcount < 0)
684     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
685
686   p = relpp;
687   pend = p + relcount;
688   for (; p < pend && *p != NULL; p++)
689     {
690       arelent *q = *p;
691
692       if (q->sym_ptr_ptr != NULL
693           && *q->sym_ptr_ptr != NULL
694           && ((global
695                && (bfd_is_und_section (bfd_get_section (*q->sym_ptr_ptr))
696                    || bfd_is_com_section (bfd_get_section (*q->sym_ptr_ptr))
697                    || ((*q->sym_ptr_ptr)->flags & (BSF_GLOBAL
698                                                    | BSF_WEAK)) != 0))
699               || (!global
700                   && ((*q->sym_ptr_ptr)->flags & (BSF_LOCAL
701                                                   | BSF_SECTION_SYM)) != 0
702                   && bfd_get_section (*q->sym_ptr_ptr) == info->defsec))
703           && (symname != NULL
704               ? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0
705               : ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0))
706         {
707           /* We found a reloc for the symbol.  The symbol is defined
708              in OUTSECNAME.  This reloc is from a section which is
709              mapped into a section from which references to OUTSECNAME
710              are prohibited.  We must report an error.  */
711           einfo (_("%X%C: prohibited cross reference from %s to `%T' in %s\n"),
712                  abfd, sec, q->address, outsecname,
713                  bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname);
714         }
715     }
716
717   free (relpp);
718 }