ld/ldsym.c

   1 /* All symbol handling for the linker
   2    Copyright (C) 1991 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain steve@cygnus.com
   4
   5 This file is part of GLD, the Gnu Linker.
   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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /*
  22    We keep a hash table of global symbols. Each entry in a hash table
  23    is called an ldsym_type. Each has three chains; a pointer to a
  24    chain of definitions for the symbol (hopefully one long), a pointer
  25    to a chain of references to the symbol, and a pointer to a chain of
  26    common symbols. Each pointer points into the canonical symbol table
  27    provided by bfd, each one of which points to an asymbol. During
  28    linkage, the linker uses the udata field to point to the next entry
  29    in a canonical table....
  30
  31
  32    ld_sym
  33                         |          |
  34    +----------+         +----------+
  35    | defs     |      a canonical symbol table
  36    +----------+         +----------+
  37    | refs     | ----->  | one entry|  -----> asymbol
  38    +----------+         +----------+       |         |
  39    | coms     |         |          |       +---------+
  40    +----------+         +----------+       | udata   |-----> another canonical
  41                                            +---------+          symbol
  42
  43
  44
  45    It is very simple to make all the symbol pointers point to the same
  46    definition - just run down the chain and make the asymbols pointers
  47    within the canonical table point to the asymbol attacthed to the
  48    definition of the symbol.
  49
  50 */
  51
  52 #include "bfd.h"
  53 #include "sysdep.h"
  54
  55 #include "ld.h"
  56 #include "ldsym.h"
  57 #include "ldmisc.h"
  58 #include "ldlang.h"
  59 /* IMPORT */
  60 extern int symbol_truncate;
  61 extern bfd *output_bfd;
  62 extern strip_symbols_type strip_symbols;
  63 extern discard_locals_type discard_locals;
  64 /* Head and tail of global symbol table chronological list */
  65
  66 ldsym_type *symbol_head = (ldsym_type *) NULL;
  67 ldsym_type **symbol_tail_ptr = &symbol_head;
  68 CONST char *keepsyms_file;
  69 int kept_syms;
  70
  71 extern ld_config_type config;
  72
  73 struct obstack global_sym_obstack;
  74 #define obstack_chunk_alloc ldmalloc
  75 #define obstack_chunk_free  free
  76
  77 /*
  78   incremented for each symbol in the ldsym_type table
  79   no matter what flavour it is
  80 */
  81 unsigned int global_symbol_count;
  82
  83 /* IMPORTS */
  84
  85 extern boolean option_longmap;
  86
  87 /* LOCALS */
  88 #define TABSIZE 1009
  89 static ldsym_type *global_symbol_hash_table[TABSIZE];
  90
  91 /* Compute the hash code for symbol name KEY.  */
  92 static
  93 #ifdef __GNUC__
  94   __inline
  95 #endif
  96
  97 int
  98 hash_string (key)
  99      CONST char *key;
 100 {
 101   register CONST char *cp;
 102   register int k;
 103   register int l = 0;
 104   cp = key;
 105   k = 0;
 106   while (*cp && l < symbol_truncate)
 107     {
 108       k = (((k << 1) + (k >> 14)) ^ (*cp++)) & 0x3fff;
 109       l++;
 110     }
 111   return k;
 112 }
 113
 114 static
 115 #ifdef __GNUC__
 116   __inline
 117 #endif
 118   ldsym_type *
 119 search (key, hashval)
 120      CONST char *key;
 121      int hashval;
 122 {
 123   ldsym_type *bp;
 124   for (bp = global_symbol_hash_table[hashval]; bp; bp = bp->link)
 125     if (!strncmp (key, bp->name, symbol_truncate))
 126       {
 127         if (bp->flags & SYM_INDIRECT)
 128           {
 129             /* Use the symbol we're aliased to instead */
 130             return (ldsym_type *) (bp->sdefs_chain);
 131           }
 132         return bp;
 133       }
 134   return 0;
 135 }
 136
 137
 138 /* Get the symbol table entry for the global symbol named KEY.
 139    Create one if there is none.  */
 140 ldsym_type *
 141 ldsym_get (key)
 142      CONST char *key;
 143 {
 144   register int hashval;
 145   register ldsym_type *bp;
 146
 147   /* Determine the proper bucket.  */
 148
 149   hashval = hash_string (key) % TABSIZE;
 150
 151   /* Search the bucket.  */
 152   bp = search (key, hashval);
 153   if (bp)
 154     {
 155       return bp;
 156     }
 157
 158   /* Nothing was found; create a new symbol table entry.  */
 159
 160   bp = (ldsym_type *) obstack_alloc (&global_sym_obstack, (bfd_size_type) (sizeof (ldsym_type)));
 161   bp->srefs_chain = (asymbol **) NULL;
 162   bp->sdefs_chain = (asymbol **) NULL;
 163   bp->scoms_chain = (asymbol **) NULL;
 164   bp->name = obstack_copy (&global_sym_obstack, key, strlen (key) + 1);
 165   bp->flags = 0;
 166   /* Add the entry to the bucket.  */
 167
 168   bp->link = global_symbol_hash_table[hashval];
 169   global_symbol_hash_table[hashval] = bp;
 170
 171   /* Keep the chronological list up to date too */
 172   *symbol_tail_ptr = bp;
 173   symbol_tail_ptr = &bp->next;
 174   bp->next = 0;
 175   global_symbol_count++;
 176
 177   return bp;
 178 }
 179
 180 /* Like `ldsym_get' but return 0 if the symbol is not already known.  */
 181
 182 ldsym_type *
 183 ldsym_get_soft (key)
 184      CONST char *key;
 185 {
 186   register int hashval;
 187   /* Determine which bucket.  */
 188
 189   hashval = hash_string (key) % TABSIZE;
 190
 191   /* Search the bucket.  */
 192   return search (key, hashval);
 193 }
 194
 195 static asymbol **
 196 process_keepsyms (table, size)
 197      asymbol **table;
 198      int size;
 199 {
 200   struct obstack obstack;
 201   char *start_of_obstack;
 202   FILE *ks_file = 0;
 203   asymbol **out = table;
 204   asymbol **end = table + size;
 205   asymbol **sym;
 206
 207   if (!keepsyms_file || size == 0)
 208     return end;
 209   obstack_init (&obstack);
 210   obstack_alloc (&obstack, 1);
 211   obstack_finish (&obstack);
 212   start_of_obstack = obstack_alloc (&obstack, 1);
 213   ks_file = fopen (keepsyms_file, "r");
 214   if (!ks_file)
 215     {
 216       info ("%X%P: can't open keep-symbols file `%s'\n", keepsyms_file);
 217       goto egress;
 218     }
 219   errno = 0;
 220
 221 #define KEEP(S) \
 222   do { asymbol **p = (S), *tmp = *out; *out = *p; *p = tmp; out++; } while (0)
 223
 224   while (!feof (ks_file) && !ferror (ks_file))
 225     {
 226       int c;
 227       char *ptr;
 228       int found = 0;
 229
 230       obstack_free (&obstack, start_of_obstack);
 231       do
 232         {
 233           c = getc (ks_file);
 234           if (c == '\n')
 235             c = 0;
 236           obstack_1grow (&obstack, c);
 237         }
 238       while (c > 0);
 239       if (c == EOF)
 240         {
 241           if (!feof (ks_file))
 242             /* error occurred */
 243             {
 244               info ("%X%P: error reading keep-symbols file `%s': %E\n",
 245                     keepsyms_file);
 246               out = end;
 247               goto egress;
 248             }
 249           if (obstack_next_free (&obstack) != obstack_base (&obstack) + 1)
 250             /* eof in middle of symbol */
 251             {
 252               info ("%X%P: eof reached mid-line while reading keep-symbols file `%s'\n",
 253                     keepsyms_file);
 254               out = end;
 255               goto egress;
 256             }
 257           /* All okay -- no incomplete lines, EOF reached.  */
 258           break;
 259         }
 260       ptr = obstack_next_free (&obstack) - 2;
 261       /* discard trailing trash */
 262       while (*ptr == ' '
 263              || *ptr == '\t')
 264         *ptr-- = 0;
 265       ptr = obstack_base (&obstack);
 266       for (sym = out; sym < end; sym++)
 267         if (!strncmp ((*sym)->name, ptr, symbol_truncate))
 268           {
 269             KEEP (sym);
 270             found = 1;
 271           }
 272       if (!found)
 273         info ("%P: symbol `%s' (requested to be kept) not found\n", ptr);
 274     }
 275   /* It'd be slightly faster to move this pass above the previous one,
 276      but that'd mean any symbols preserved in this pass would generate
 277      warnings if they were also listed in the keepsyms file.  */
 278   for (sym = out; sym < end; sym++)
 279     {
 280       asymbol *s = *sym;
 281       if (s->section == &bfd_und_section
 282           || bfd_is_com_section (s->section)
 283           || s->flags & BSF_KEEP_G)
 284         KEEP (sym);
 285     }
 286 egress:
 287   obstack_free (&obstack, start_of_obstack);
 288   if (ks_file)
 289     fclose (ks_file);
 290   return out;
 291 }
 292
 293 static void
 294 list_file_locals (entry)
 295      lang_input_statement_type *entry;
 296 {
 297   asymbol **q;
 298   fprintf (config.map_file, "\nLocal symbols of ");
 299   minfo ("%I", entry);
 300   fprintf (config.map_file, ":\n\n");
 301   if (entry->asymbols)
 302     {
 303       for (q = entry->asymbols; *q; q++)
 304         {
 305           asymbol *p = *q;
 306           /* If this is a definition,
 307            update it if necessary by this file's start address.  */
 308           if (p->flags & BSF_LOCAL)
 309             info ("  %V %s\n", p->value, p->name);
 310         }
 311     }
 312 }
 313
 314
 315 static void
 316 print_file_stuff (f)
 317      lang_input_statement_type * f;
 318 {
 319   fprintf (config.map_file, "  %s\n", f->filename);
 320   if (f->just_syms_flag)
 321     {
 322       fprintf (config.map_file, " symbols only\n");
 323     }
 324   else
 325     {
 326       asection *s;
 327       if (true || option_longmap)
 328         {
 329           for (s = f->the_bfd->sections;
 330                s != (asection *) NULL;
 331                s = s->next)
 332             {
 333               print_address (s->output_offset);
 334               if (s->reloc_done)
 335                 {
 336                   fprintf (config.map_file, " %08x 2**%2ud %s\n",
 337                            (unsigned) bfd_get_section_size_after_reloc (s),
 338                            s->alignment_power, s->name);
 339                 }
 340
 341               else
 342                 {
 343                   fprintf (config.map_file, " %08x 2**%2ud %s\n",
 344                            (unsigned) bfd_get_section_size_before_reloc (s),
 345                            s->alignment_power, s->name);
 346                 }
 347             }
 348         }
 349       else
 350         {
 351           for (s = f->the_bfd->sections;
 352                s != (asection *) NULL;
 353                s = s->next)
 354             {
 355               fprintf (config.map_file, "%s ", s->name);
 356               print_address (s->output_offset);
 357               fprintf (config.map_file, "(%x)", (unsigned) bfd_get_section_size_after_reloc (s));
 358             }
 359           fprintf (config.map_file, "hex \n");
 360         }
 361     }
 362   fprintf (config.map_file, "\n");
 363 }
 364
 365 void
 366 ldsym_print_symbol_table ()
 367 {
 368   fprintf (config.map_file, "**FILES**\n\n");
 369
 370   lang_for_each_file (print_file_stuff);
 371
 372   fprintf (config.map_file, "**GLOBAL SYMBOLS**\n\n");
 373   fprintf (config.map_file, "offset    section    offset   symbol\n");
 374   {
 375     register ldsym_type *sp;
 376
 377     for (sp = symbol_head; sp; sp = sp->next)
 378       {
 379         if (sp->flags & SYM_INDIRECT)
 380           {
 381             fprintf (config.map_file, "indirect %s to %s\n",
 382                      sp->name, (((ldsym_type *) (sp->sdefs_chain))->name));
 383           }
 384         else
 385           {
 386             if (sp->sdefs_chain)
 387               {
 388                 asymbol *defsym = *(sp->sdefs_chain);
 389                 asection *defsec = bfd_get_section (defsym);
 390                 print_address (defsym->value);
 391                 if (defsec)
 392                   {
 393                     fprintf (config.map_file, "  %-10s",
 394                              bfd_section_name (output_bfd,
 395                                                defsec));
 396                     print_space ();
 397                     print_address (defsym->value + defsec->vma);
 398
 399                   }
 400                 else
 401                   {
 402                     fprintf (config.map_file, "         .......");
 403                   }
 404
 405               }
 406
 407
 408             if (sp->scoms_chain)
 409               {
 410                 fprintf (config.map_file, "common               ");
 411                 print_address ((*(sp->scoms_chain))->value);
 412                 fprintf (config.map_file, " %s ", sp->name);
 413               }
 414             else if (sp->sdefs_chain)
 415               {
 416                 fprintf (config.map_file, " %s ", sp->name);
 417               }
 418             else
 419               {
 420                 fprintf (config.map_file, "undefined                     ");
 421                 fprintf (config.map_file, "%s ", sp->name);
 422
 423               }
 424           }
 425         print_nl ();
 426
 427       }
 428   }
 429   if (option_longmap)
 430     {
 431       lang_for_each_file (list_file_locals);
 432     }
 433 }
 434
 435 extern lang_output_section_statement_type *create_object_symbols;
 436 extern char lprefix;
 437 static asymbol **
 438 write_file_locals (output_buffer)
 439      asymbol **output_buffer;
 440 {
 441   LANG_FOR_EACH_INPUT_STATEMENT (entry)
 442   {
 443     /* Run trough the symbols and work out what to do with them */
 444     unsigned int i;
 445
 446     /* Add one for the filename symbol if needed */
 447     if (create_object_symbols
 448         != (lang_output_section_statement_type *) NULL)
 449       {
 450         asection *s;
 451         for (s = entry->the_bfd->sections;
 452              s != (asection *) NULL;
 453              s = s->next)
 454           {
 455             if (s->output_section == create_object_symbols->bfd_section)
 456               {
 457                 /* Add symbol to this section */
 458                 asymbol *newsym =
 459                 (asymbol *) bfd_make_empty_symbol (entry->the_bfd);
 460                 newsym->name = entry->local_sym_name;
 461                 /* The symbol belongs to the output file's text section */
 462
 463                 /* The value is the start of this section in the output file*/
 464                 newsym->value = 0;
 465                 /* FIXME: Usurping BSF_KEEP_G flag, since it's defined as
 466              "used by the linker" and I can't find any other code that
 467              uses it.  Should be a cleaner way of doing this (like an
 468              "application flags" field in the symbol structure?).  */
 469                 newsym->flags = BSF_LOCAL | BSF_KEEP_G;
 470                 newsym->section = s;
 471                 *output_buffer++ = newsym;
 472                 break;
 473               }
 474           }
 475       }
 476     for (i = 0; i < entry->symbol_count; i++)
 477       {
 478         asymbol *p = entry->asymbols[i];
 479         /* FIXME, temporary hack, since not all of ld knows about the new abs section convention */
 480
 481         if (p->section == 0)
 482           p->section = &bfd_abs_section;
 483         if (flag_is_global (p->flags))
 484           {
 485             /* We are only interested in outputting
 486            globals at this stage in special circumstances */
 487             if (bfd_asymbol_bfd (p) == entry->the_bfd
 488                 && flag_is_not_at_end (p->flags))
 489               {
 490                 /* And this is one of them */
 491                 *(output_buffer++) = p;
 492                 p->flags |= BSF_KEEP;
 493               }
 494           }
 495         else
 496           {
 497             if (p->section == &bfd_ind_section)
 498               {
 499                 /* Dont think about indirect symbols */
 500               }
 501             else if (flag_is_debugger (p->flags))
 502               {
 503                 /* Only keep the debugger symbols if no stripping required */
 504                 if (strip_symbols == STRIP_NONE)
 505                   {
 506                     *output_buffer++ = p;
 507                   }
 508               }
 509             else if (p->section == &bfd_und_section
 510                      || bfd_is_com_section (p->section))
 511               {
 512                 /* These must be global.  */
 513               }
 514             else if (flag_is_ordinary_local (p->flags))
 515               {
 516                 if (discard_locals == DISCARD_ALL)
 517                   {
 518                   }
 519                 else if (discard_locals == DISCARD_L &&
 520                          (p->name[0] == lprefix))
 521                   {
 522                   }
 523                 else if (p->flags == BSF_WARNING)
 524                   {
 525                   }
 526                 else
 527                   {
 528                     *output_buffer++ = p;
 529                   }
 530               }
 531             else if (p->flags & BSF_CONSTRUCTOR)
 532               {
 533                 if (strip_symbols != STRIP_ALL)
 534                   {
 535                     *output_buffer++ = p;
 536                   }
 537               }
 538             else
 539               {
 540                 FAIL ();
 541               }
 542           }
 543       }
 544
 545
 546   }
 547   return output_buffer;
 548 }
 549
 550
 551 static asymbol **
 552 write_file_globals (symbol_table)
 553      asymbol **symbol_table;
 554 {
 555   FOR_EACH_LDSYM (sp)
 556   {
 557     if (sp->flags & SYM_INDIRECT)
 558       {
 559         asymbol *bufp = (*(sp->srefs_chain));
 560         ldsym_type *aliased_to = (ldsym_type *) (sp->sdefs_chain);
 561         if (aliased_to->sdefs_chain)
 562           {
 563             asymbol *p = aliased_to->sdefs_chain[0];
 564             bufp->value = p->value;
 565             bufp->section = p->section;
 566             bufp->flags = p->flags;
 567           }
 568         else
 569           {
 570             bufp->value = 0;
 571             bufp->flags = 0;
 572             bufp->section = &bfd_und_section;
 573           }
 574         *symbol_table++ = bufp;
 575       }
 576     else if ((sp->flags & SYM_INDIRECT) == 0 && sp->sdefs_chain != (asymbol **) NULL)
 577       {
 578         asymbol *bufp = (*(sp->sdefs_chain));
 579
 580         if ((bufp->flags & BSF_KEEP) == 0)
 581           {
 582             ASSERT (bufp != (asymbol *) NULL);
 583
 584             bufp->name = sp->name;
 585
 586             if (sp->scoms_chain != (asymbol **) NULL)
 587
 588               {
 589                 /*
 590                  defined as common but not allocated, this happens
 591                  only with -r and not -d, write out a common
 592                  definition
 593                  */
 594                 bufp = *(sp->scoms_chain);
 595               }
 596             *symbol_table++ = bufp;
 597           }
 598       }
 599     else if (sp->scoms_chain != (asymbol **) NULL)
 600       {
 601         /* This symbol is a common - just output */
 602         asymbol *bufp = (*(sp->scoms_chain));
 603         *symbol_table++ = bufp;
 604       }
 605     else if (sp->srefs_chain != (asymbol **) NULL)
 606       {
 607         /* This symbol is undefined but has a reference */
 608         asymbol *bufp = (*(sp->srefs_chain));
 609         *symbol_table++ = bufp;
 610       }
 611     else
 612       {
 613         /*
 614            This symbol has neither defs nor refs, it must have come
 615            from the command line, since noone has used it it has no
 616            data attatched, so we'll ignore it
 617            */
 618       }
 619   }
 620   return symbol_table;
 621 }
 622
 623 void
 624 ldsym_write ()
 625 {
 626   if (keepsyms_file != 0
 627       && strip_symbols != STRIP_SOME)
 628     {
 629       info ("%P `-retain-symbols-file' overrides `-s' and `-S'\n");
 630       strip_symbols = STRIP_SOME;
 631     }
 632   if (strip_symbols != STRIP_ALL)
 633     {
 634       /* We know the maximum size of the symbol table -
 635        it's the size of all the global symbols ever seen +
 636        the size of all the symbols from all the files +
 637        the number of files (for the per file symbols)
 638        +1 (for the null at the end)
 639        */
 640       extern unsigned int total_files_seen;
 641       extern unsigned int total_symbols_seen;
 642
 643       asymbol **symbol_table = (asymbol **)
 644       ldmalloc ((bfd_size_type) (global_symbol_count +
 645                                  total_files_seen +
 646                               total_symbols_seen + 1) * sizeof (asymbol *));
 647       asymbol **tablep = write_file_locals (symbol_table);
 648
 649       tablep = write_file_globals (tablep);
 650       tablep = process_keepsyms (symbol_table, tablep - symbol_table);
 651
 652       *tablep = (asymbol *) NULL;
 653       bfd_set_symtab (output_bfd, symbol_table, (unsigned) (tablep - symbol_table));
 654     }
 655 }
 656
 657 /*
 658 return true if the supplied symbol name is not in the
 659 linker symbol table
 660 */
 661 boolean
 662 ldsym_undefined (sym)
 663      CONST char *sym;
 664 {
 665   ldsym_type *from_table = ldsym_get_soft (sym);
 666   if (from_table != (ldsym_type *) NULL)
 667     {
 668       if (from_table->sdefs_chain != (asymbol **) NULL)
 669         return false;
 670     }
 671   return true;
 672 }
 673
 674 void
 675 ldsym_init ()
 676 {
 677   obstack_begin (&global_sym_obstack, 20000);
 678 }