gcc/collect2.c

   1 /* Collect static initialization info into data structures that can be
   2    traversed by C++ initialization and finalization routines.
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   5    Free Software Foundation, Inc.
   6    Contributed by Chris Smith (csmith@convex.com).
   7    Heavily modified by Michael Meissner (meissner@cygnus.com),
   8    Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
   9
  10 This file is part of GCC.
  11
  12 GCC is free software; you can redistribute it and/or modify it under
  13 the terms of the GNU General Public License as published by the Free
  14 Software Foundation; either version 3, or (at your option) any later
  15 version.
  16
  17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GCC; see the file COPYING3.  If not see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26
  27 /* Build tables of static constructors and destructors and run ld.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include <signal.h>
  34 #if ! defined( SIGCHLD ) && defined( SIGCLD )
  35 #  define SIGCHLD SIGCLD
  36 #endif
  37
  38 #ifndef LIBRARY_PATH_ENV
  39 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
  40 #endif
  41
  42 #define COLLECT
  43
  44 #include "collect2.h"
  45 #include "collect2-aix.h"
  46 #include "demangle.h"
  47 #include "obstack.h"
  48 #include "intl.h"
  49 #include "version.h"
  50 \f
  51 /* On certain systems, we have code that works by scanning the object file
  52    directly.  But this code uses system-specific header files and library
  53    functions, so turn it off in a cross-compiler.  Likewise, the names of
  54    the utilities are not correct for a cross-compiler; we have to hope that
  55    cross-versions are in the proper directories.  */
  56
  57 #ifdef CROSS_DIRECTORY_STRUCTURE
  58 #ifndef CROSS_AIX_SUPPORT
  59 #undef OBJECT_FORMAT_COFF
  60 #endif
  61 #undef MD_EXEC_PREFIX
  62 #undef REAL_LD_FILE_NAME
  63 #undef REAL_NM_FILE_NAME
  64 #undef REAL_STRIP_FILE_NAME
  65 #endif
  66
  67 /* If we cannot use a special method, use the ordinary one:
  68    run nm to find what symbols are present.
  69    In a cross-compiler, this means you need a cross nm,
  70    but that is not quite as unpleasant as special headers.  */
  71
  72 #if !defined (OBJECT_FORMAT_COFF)
  73 #define OBJECT_FORMAT_NONE
  74 #endif
  75
  76 #ifdef OBJECT_FORMAT_COFF
  77
  78 #ifndef CROSS_DIRECTORY_STRUCTURE
  79 #include <a.out.h>
  80 #include <ar.h>
  81
  82 #ifdef UMAX
  83 #include <sgs.h>
  84 #endif
  85
  86 /* Many versions of ldfcn.h define these.  */
  87 #ifdef FREAD
  88 #undef FREAD
  89 #undef FWRITE
  90 #endif
  91
  92 #include <ldfcn.h>
  93 #endif
  94
  95 /* Some systems have an ISCOFF macro, but others do not.  In some cases
  96    the macro may be wrong.  MY_ISCOFF is defined in tm.h files for machines
  97    that either do not have an ISCOFF macro in /usr/include or for those
  98    where it is wrong.  */
  99
 100 #ifndef MY_ISCOFF
 101 #define MY_ISCOFF(X) ISCOFF (X)
 102 #endif
 103
 104 #endif /* OBJECT_FORMAT_COFF */
 105
 106 #ifdef OBJECT_FORMAT_NONE
 107
 108 /* Default flags to pass to nm.  */
 109 #ifndef NM_FLAGS
 110 #define NM_FLAGS "-n"
 111 #endif
 112
 113 #endif /* OBJECT_FORMAT_NONE */
 114
 115 /* Some systems use __main in a way incompatible with its use in gcc, in these
 116    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
 117    give the same symbol without quotes for an alternative entry point.  */
 118 #ifndef NAME__MAIN
 119 #define NAME__MAIN "__main"
 120 #endif
 121
 122 /* This must match tree.h.  */
 123 #define DEFAULT_INIT_PRIORITY 65535
 124
 125 #ifndef COLLECT_SHARED_INIT_FUNC
 126 #define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC) \
 127   fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC))
 128 #endif
 129 #ifndef COLLECT_SHARED_FINI_FUNC
 130 #define COLLECT_SHARED_FINI_FUNC(STREAM, FUNC) \
 131   fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
 132 #endif
 133
 134 #ifdef LDD_SUFFIX
 135 #define SCAN_LIBRARIES
 136 #endif
 137
 138 #ifndef SHLIB_SUFFIX
 139 #define SHLIB_SUFFIX ".so"
 140 #endif
 141
 142 #ifdef USE_COLLECT2
 143 int do_collecting = 1;
 144 #else
 145 int do_collecting = 0;
 146 #endif
 147
 148 /* Nonzero if we should suppress the automatic demangling of identifiers
 149    in linker error messages.  Set from COLLECT_NO_DEMANGLE.  */
 150 int no_demangle;
 151 \f
 152 /* Linked lists of constructor and destructor names.  */
 153
 154 struct id
 155 {
 156   struct id *next;
 157   int sequence;
 158   char name[1];
 159 };
 160
 161 struct head
 162 {
 163   struct id *first;
 164   struct id *last;
 165   int number;
 166 };
 167
 168 /* Enumeration giving which pass this is for scanning the program file.  */
 169
 170 enum pass {
 171   PASS_FIRST,                           /* without constructors */
 172   PASS_OBJ,                             /* individual objects */
 173   PASS_LIB,                             /* looking for shared libraries */
 174   PASS_SECOND                           /* with constructors linked in */
 175 };
 176
 177 int vflag;                              /* true if -v */
 178 static int rflag;                       /* true if -r */
 179 static int strip_flag;                  /* true if -s */
 180 static const char *demangle_flag;
 181 #ifdef COLLECT_EXPORT_LIST
 182 static int export_flag;                 /* true if -bE */
 183 static int aix64_flag;                  /* true if -b64 */
 184 static int aixrtl_flag;                 /* true if -brtl */
 185 #endif
 186
 187 int debug;                              /* true if -debug */
 188
 189 static int shared_obj;                  /* true if -shared */
 190
 191 static const char *c_file;              /* <xxx>.c for constructor/destructor list.  */
 192 static const char *o_file;              /* <xxx>.o for constructor/destructor list.  */
 193 #ifdef COLLECT_EXPORT_LIST
 194 static const char *export_file;         /* <xxx>.x for AIX export list.  */
 195 #endif
 196 const char *ldout;                      /* File for ld stdout.  */
 197 const char *lderrout;                   /* File for ld stderr.  */
 198 static const char *output_file;         /* Output file for ld.  */
 199 static const char *nm_file_name;        /* pathname of nm */
 200 #ifdef LDD_SUFFIX
 201 static const char *ldd_file_name;       /* pathname of ldd (or equivalent) */
 202 #endif
 203 static const char *strip_file_name;             /* pathname of strip */
 204 const char *c_file_name;                /* pathname of gcc */
 205 static char *initname, *fininame;       /* names of init and fini funcs */
 206
 207 static struct head constructors;        /* list of constructors found */
 208 static struct head destructors;         /* list of destructors found */
 209 #ifdef COLLECT_EXPORT_LIST
 210 static struct head exports;             /* list of exported symbols */
 211 #endif
 212 static struct head frame_tables;        /* list of frame unwind info tables */
 213
 214 static bool at_file_supplied;           /* Whether to use @file arguments */
 215 static char *response_file;             /* Name of any current response file */
 216
 217 struct obstack temporary_obstack;
 218 char * temporary_firstobj;
 219
 220 /* A string that must be prepended to a target OS path in order to find
 221    it on the host system.  */
 222 #ifdef TARGET_SYSTEM_ROOT
 223 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 224 #else
 225 static const char *target_system_root = "";
 226 #endif
 227
 228 /* Structure to hold all the directories in which to search for files to
 229    execute.  */
 230
 231 struct prefix_list
 232 {
 233   const char *prefix;         /* String to prepend to the path.  */
 234   struct prefix_list *next;   /* Next in linked list.  */
 235 };
 236
 237 struct path_prefix
 238 {
 239   struct prefix_list *plist;  /* List of prefixes to try */
 240   int max_len;                /* Max length of a prefix in PLIST */
 241   const char *name;           /* Name of this list (used in config stuff) */
 242 };
 243
 244 #ifdef COLLECT_EXPORT_LIST
 245 /* Lists to keep libraries to be scanned for global constructors/destructors.  */
 246 static struct head libs;                    /* list of libraries */
 247 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
 248 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
 249 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
 250                                           &libpath_lib_dirs, NULL};
 251 #endif
 252
 253 /* Special kinds of symbols that a name may denote.  */
 254
 255 typedef enum {
 256   SYM_REGULAR = 0,  /* nothing special  */
 257
 258   SYM_CTOR = 1,  /* constructor */
 259   SYM_DTOR = 2,  /* destructor  */
 260   SYM_INIT = 3,  /* shared object routine that calls all the ctors  */
 261   SYM_FINI = 4,  /* shared object routine that calls all the dtors  */
 262   SYM_DWEH = 5   /* DWARF exception handling table  */
 263 } symkind;
 264
 265 static symkind is_ctor_dtor (const char *);
 266
 267 static void handler (int);
 268 static char *find_a_file (struct path_prefix *, const char *);
 269 static void add_prefix (struct path_prefix *, const char *);
 270 static void prefix_from_env (const char *, struct path_prefix *);
 271 static void prefix_from_string (const char *, struct path_prefix *);
 272 static void do_wait (const char *, struct pex_obj *);
 273 static void fork_execute (const char *, char **);
 274 static void maybe_unlink (const char *);
 275 static void add_to_list (struct head *, const char *);
 276 static int extract_init_priority (const char *);
 277 static void sort_ids (struct head *);
 278 static void write_list (FILE *, const char *, struct id *);
 279 #ifdef COLLECT_EXPORT_LIST
 280 static void dump_list (FILE *, const char *, struct id *);
 281 #endif
 282 #if 0
 283 static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
 284 #endif
 285 static void write_list_with_asm (FILE *, const char *, struct id *);
 286 static void write_c_file (FILE *, const char *);
 287 static void write_c_file_stat (FILE *, const char *);
 288 #ifndef LD_INIT_SWITCH
 289 static void write_c_file_glob (FILE *, const char *);
 290 #endif
 291 static void scan_prog_file (const char *, enum pass);
 292 #ifdef SCAN_LIBRARIES
 293 static void scan_libraries (const char *);
 294 #endif
 295 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
 296 static int is_in_args (const char *, const char **, const char **);
 297 #endif
 298 #ifdef COLLECT_EXPORT_LIST
 299 #if 0
 300 static int is_in_list (const char *, struct id *);
 301 #endif
 302 static void write_aix_file (FILE *, struct id *);
 303 static char *resolve_lib_name (const char *);
 304 #endif
 305 static char *extract_string (const char **);
 306 \f
 307 /* Delete tempfiles and exit function.  */
 308
 309 void
 310 collect_exit (int status)
 311 {
 312   if (c_file != 0 && c_file[0])
 313     maybe_unlink (c_file);
 314
 315   if (o_file != 0 && o_file[0])
 316     maybe_unlink (o_file);
 317
 318 #ifdef COLLECT_EXPORT_LIST
 319   if (export_file != 0 && export_file[0])
 320     maybe_unlink (export_file);
 321 #endif
 322
 323   if (ldout != 0 && ldout[0])
 324     {
 325       dump_file (ldout, stdout);
 326       maybe_unlink (ldout);
 327     }
 328
 329   if (lderrout != 0 && lderrout[0])
 330     {
 331       dump_file (lderrout, stderr);
 332       maybe_unlink (lderrout);
 333     }
 334
 335   if (status != 0 && output_file != 0 && output_file[0])
 336     maybe_unlink (output_file);
 337
 338   if (response_file)
 339     maybe_unlink (response_file);
 340
 341   exit (status);
 342 }
 343
 344 \f
 345 /* Notify user of a non-error.  */
 346 void
 347 notice (const char *cmsgid, ...)
 348 {
 349   va_list ap;
 350
 351   va_start (ap, cmsgid);
 352   vfprintf (stderr, _(cmsgid), ap);
 353   va_end (ap);
 354 }
 355
 356 /* Die when sys call fails.  */
 357
 358 void
 359 fatal_perror (const char * cmsgid, ...)
 360 {
 361   int e = errno;
 362   va_list ap;
 363
 364   va_start (ap, cmsgid);
 365   fprintf (stderr, "collect2: ");
 366   vfprintf (stderr, _(cmsgid), ap);
 367   fprintf (stderr, ": %s\n", xstrerror (e));
 368   va_end (ap);
 369
 370   collect_exit (FATAL_EXIT_CODE);
 371 }
 372
 373 /* Just die.  */
 374
 375 void
 376 fatal (const char * cmsgid, ...)
 377 {
 378   va_list ap;
 379
 380   va_start (ap, cmsgid);
 381   fprintf (stderr, "collect2: ");
 382   vfprintf (stderr, _(cmsgid), ap);
 383   fprintf (stderr, "\n");
 384   va_end (ap);
 385
 386   collect_exit (FATAL_EXIT_CODE);
 387 }
 388
 389 /* Write error message.  */
 390
 391 void
 392 error (const char * gmsgid, ...)
 393 {
 394   va_list ap;
 395
 396   va_start (ap, gmsgid);
 397   fprintf (stderr, "collect2: ");
 398   vfprintf (stderr, _(gmsgid), ap);
 399   fprintf (stderr, "\n");
 400   va_end(ap);
 401 }
 402
 403 /* In case obstack is linked in, and abort is defined to fancy_abort,
 404    provide a default entry.  */
 405
 406 void
 407 fancy_abort (const char *file, int line, const char *func)
 408 {
 409   fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
 410 }
 411 \f
 412 static void
 413 handler (int signo)
 414 {
 415   if (c_file != 0 && c_file[0])
 416     maybe_unlink (c_file);
 417
 418   if (o_file != 0 && o_file[0])
 419     maybe_unlink (o_file);
 420
 421   if (ldout != 0 && ldout[0])
 422     maybe_unlink (ldout);
 423
 424   if (lderrout != 0 && lderrout[0])
 425     maybe_unlink (lderrout);
 426
 427 #ifdef COLLECT_EXPORT_LIST
 428   if (export_file != 0 && export_file[0])
 429     maybe_unlink (export_file);
 430 #endif
 431
 432   if (response_file)
 433     maybe_unlink (response_file);
 434
 435   signal (signo, SIG_DFL);
 436   raise (signo);
 437 }
 438
 439 \f
 440 int
 441 file_exists (const char *name)
 442 {
 443   return access (name, R_OK) == 0;
 444 }
 445
 446 /* Parse a reasonable subset of shell quoting syntax.  */
 447
 448 static char *
 449 extract_string (const char **pp)
 450 {
 451   const char *p = *pp;
 452   int backquote = 0;
 453   int inside = 0;
 454
 455   for (;;)
 456     {
 457       char c = *p;
 458       if (c == '\0')
 459         break;
 460       ++p;
 461       if (backquote)
 462         obstack_1grow (&temporary_obstack, c);
 463       else if (! inside && c == ' ')
 464         break;
 465       else if (! inside && c == '\\')
 466         backquote = 1;
 467       else if (c == '\'')
 468         inside = !inside;
 469       else
 470         obstack_1grow (&temporary_obstack, c);
 471     }
 472
 473   obstack_1grow (&temporary_obstack, '\0');
 474   *pp = p;
 475   return XOBFINISH (&temporary_obstack, char *);
 476 }
 477 \f
 478 void
 479 dump_file (const char *name, FILE *to)
 480 {
 481   FILE *stream = fopen (name, "r");
 482
 483   if (stream == 0)
 484     return;
 485   while (1)
 486     {
 487       int c;
 488       while (c = getc (stream),
 489              c != EOF && (ISIDNUM (c) || c == '$' || c == '.'))
 490         obstack_1grow (&temporary_obstack, c);
 491       if (obstack_object_size (&temporary_obstack) > 0)
 492         {
 493           const char *word, *p;
 494           char *result;
 495           obstack_1grow (&temporary_obstack, '\0');
 496           word = XOBFINISH (&temporary_obstack, const char *);
 497
 498           if (*word == '.')
 499             ++word, putc ('.', to);
 500           p = word;
 501           if (!strncmp (p, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)))
 502             p += strlen (USER_LABEL_PREFIX);
 503
 504 #ifdef HAVE_LD_DEMANGLE
 505           result = 0;
 506 #else
 507           if (no_demangle)
 508             result = 0;
 509           else
 510             result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE);
 511 #endif
 512
 513           if (result)
 514             {
 515               int diff;
 516               fputs (result, to);
 517
 518               diff = strlen (word) - strlen (result);
 519               while (diff > 0 && c == ' ')
 520                 --diff, putc (' ', to);
 521               if (diff < 0 && c == ' ')
 522                 {
 523                   while (diff < 0 && c == ' ')
 524                     ++diff, c = getc (stream);
 525                   if (!ISSPACE (c))
 526                     {
 527                       /* Make sure we output at least one space, or
 528                          the demangled symbol name will run into
 529                          whatever text follows.  */
 530                       putc (' ', to);
 531                     }
 532                 }
 533
 534               free (result);
 535             }
 536           else
 537             fputs (word, to);
 538
 539           fflush (to);
 540           obstack_free (&temporary_obstack, temporary_firstobj);
 541         }
 542       if (c == EOF)
 543         break;
 544       putc (c, to);
 545     }
 546   fclose (stream);
 547 }
 548 \f
 549 /* Return the kind of symbol denoted by name S.  */
 550
 551 static symkind
 552 is_ctor_dtor (const char *s)
 553 {
 554   struct names { const char *const name; const int len; symkind ret;
 555     const int two_underscores; };
 556
 557   const struct names *p;
 558   int ch;
 559   const char *orig_s = s;
 560
 561   static const struct names special[] = {
 562 #ifndef NO_DOLLAR_IN_LABEL
 563     { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
 564     { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
 565 #else
 566 #ifndef NO_DOT_IN_LABEL
 567     { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
 568     { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
 569 #endif /* NO_DOT_IN_LABEL */
 570 #endif /* NO_DOLLAR_IN_LABEL */
 571     { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
 572     { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
 573     { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
 574     { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
 575     { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
 576     { NULL, 0, SYM_REGULAR, 0 }
 577   };
 578
 579   while ((ch = *s) == '_')
 580     ++s;
 581
 582   if (s == orig_s)
 583     return SYM_REGULAR;
 584
 585   for (p = &special[0]; p->len > 0; p++)
 586     {
 587       if (ch == p->name[0]
 588           && (!p->two_underscores || ((s - orig_s) >= 2))
 589           && strncmp(s, p->name, p->len) == 0)
 590         {
 591           return p->ret;
 592         }
 593     }
 594   return SYM_REGULAR;
 595 }
 596 \f
 597 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
 598    and one from the PATH variable.  */
 599
 600 static struct path_prefix cpath, path;
 601
 602 #ifdef CROSS_DIRECTORY_STRUCTURE
 603 /* This is the name of the target machine.  We use it to form the name
 604    of the files to execute.  */
 605
 606 static const char *const target_machine = TARGET_MACHINE;
 607 #endif
 608
 609 /* Search for NAME using prefix list PPREFIX.  We only look for executable
 610    files.
 611
 612    Return 0 if not found, otherwise return its name, allocated with malloc.  */
 613
 614 static char *
 615 find_a_file (struct path_prefix *pprefix, const char *name)
 616 {
 617   char *temp;
 618   struct prefix_list *pl;
 619   int len = pprefix->max_len + strlen (name) + 1;
 620
 621   if (debug)
 622     fprintf (stderr, "Looking for '%s'\n", name);
 623
 624 #ifdef HOST_EXECUTABLE_SUFFIX
 625   len += strlen (HOST_EXECUTABLE_SUFFIX);
 626 #endif
 627
 628   temp = XNEWVEC (char, len);
 629
 630   /* Determine the filename to execute (special case for absolute paths).  */
 631
 632   if (IS_ABSOLUTE_PATH (name))
 633     {
 634       if (access (name, X_OK) == 0)
 635         {
 636           strcpy (temp, name);
 637
 638           if (debug)
 639             fprintf (stderr, "  - found: absolute path\n");
 640
 641           return temp;
 642         }
 643
 644 #ifdef HOST_EXECUTABLE_SUFFIX
 645         /* Some systems have a suffix for executable files.
 646            So try appending that.  */
 647       strcpy (temp, name);
 648         strcat (temp, HOST_EXECUTABLE_SUFFIX);
 649
 650         if (access (temp, X_OK) == 0)
 651           return temp;
 652 #endif
 653
 654       if (debug)
 655         fprintf (stderr, "  - failed to locate using absolute path\n");
 656     }
 657   else
 658     for (pl = pprefix->plist; pl; pl = pl->next)
 659       {
 660         struct stat st;
 661
 662         strcpy (temp, pl->prefix);
 663         strcat (temp, name);
 664
 665         if (stat (temp, &st) >= 0
 666             && ! S_ISDIR (st.st_mode)
 667             && access (temp, X_OK) == 0)
 668           return temp;
 669
 670 #ifdef HOST_EXECUTABLE_SUFFIX
 671         /* Some systems have a suffix for executable files.
 672            So try appending that.  */
 673         strcat (temp, HOST_EXECUTABLE_SUFFIX);
 674
 675         if (stat (temp, &st) >= 0
 676             && ! S_ISDIR (st.st_mode)
 677             && access (temp, X_OK) == 0)
 678           return temp;
 679 #endif
 680       }
 681
 682   if (debug && pprefix->plist == NULL)
 683     fprintf (stderr, "  - failed: no entries in prefix list\n");
 684
 685   free (temp);
 686   return 0;
 687 }
 688
 689 /* Add an entry for PREFIX to prefix list PPREFIX.  */
 690
 691 static void
 692 add_prefix (struct path_prefix *pprefix, const char *prefix)
 693 {
 694   struct prefix_list *pl, **prev;
 695   int len;
 696
 697   if (pprefix->plist)
 698     {
 699       for (pl = pprefix->plist; pl->next; pl = pl->next)
 700         ;
 701       prev = &pl->next;
 702     }
 703   else
 704     prev = &pprefix->plist;
 705
 706   /* Keep track of the longest prefix.  */
 707
 708   len = strlen (prefix);
 709   if (len > pprefix->max_len)
 710     pprefix->max_len = len;
 711
 712   pl = XNEW (struct prefix_list);
 713   pl->prefix = xstrdup (prefix);
 714
 715   if (*prev)
 716     pl->next = *prev;
 717   else
 718     pl->next = (struct prefix_list *) 0;
 719   *prev = pl;
 720 }
 721 \f
 722 /* Take the value of the environment variable ENV, break it into a path, and
 723    add of the entries to PPREFIX.  */
 724
 725 static void
 726 prefix_from_env (const char *env, struct path_prefix *pprefix)
 727 {
 728   const char *p;
 729   GET_ENVIRONMENT (p, env);
 730
 731   if (p)
 732     prefix_from_string (p, pprefix);
 733 }
 734
 735 static void
 736 prefix_from_string (const char *p, struct path_prefix *pprefix)
 737 {
 738   const char *startp, *endp;
 739   char *nstore = XNEWVEC (char, strlen (p) + 3);
 740
 741   if (debug)
 742     fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
 743
 744   startp = endp = p;
 745   while (1)
 746     {
 747       if (*endp == PATH_SEPARATOR || *endp == 0)
 748         {
 749           strncpy (nstore, startp, endp-startp);
 750           if (endp == startp)
 751             {
 752               strcpy (nstore, "./");
 753             }
 754           else if (! IS_DIR_SEPARATOR (endp[-1]))
 755             {
 756               nstore[endp-startp] = DIR_SEPARATOR;
 757               nstore[endp-startp+1] = 0;
 758             }
 759           else
 760             nstore[endp-startp] = 0;
 761
 762           if (debug)
 763             fprintf (stderr, "  - add prefix: %s\n", nstore);
 764
 765           add_prefix (pprefix, nstore);
 766           if (*endp == 0)
 767             break;
 768           endp = startp = endp + 1;
 769         }
 770       else
 771         endp++;
 772     }
 773   free (nstore);
 774 }
 775 \f
 776 /* Main program.  */
 777
 778 int
 779 main (int argc, char **argv)
 780 {
 781   static const char *const ld_suffix    = "ld";
 782   static const char *const real_ld_suffix = "real-ld";
 783   static const char *const collect_ld_suffix = "collect-ld";
 784   static const char *const nm_suffix    = "nm";
 785   static const char *const gnm_suffix   = "gnm";
 786 #ifdef LDD_SUFFIX
 787   static const char *const ldd_suffix   = LDD_SUFFIX;
 788 #endif
 789   static const char *const strip_suffix = "strip";
 790   static const char *const gstrip_suffix = "gstrip";
 791
 792 #ifdef CROSS_DIRECTORY_STRUCTURE
 793   /* If we look for a program in the compiler directories, we just use
 794      the short name, since these directories are already system-specific.
 795      But it we look for a program in the system directories, we need to
 796      qualify the program name with the target machine.  */
 797
 798   const char *const full_ld_suffix =
 799     concat(target_machine, "-", ld_suffix, NULL);
 800   const char *const full_nm_suffix =
 801     concat (target_machine, "-", nm_suffix, NULL);
 802   const char *const full_gnm_suffix =
 803     concat (target_machine, "-", gnm_suffix, NULL);
 804 #ifdef LDD_SUFFIX
 805   const char *const full_ldd_suffix =
 806     concat (target_machine, "-", ldd_suffix, NULL);
 807 #endif
 808   const char *const full_strip_suffix =
 809     concat (target_machine, "-", strip_suffix, NULL);
 810   const char *const full_gstrip_suffix =
 811     concat (target_machine, "-", gstrip_suffix, NULL);
 812 #else
 813   const char *const full_ld_suffix      = ld_suffix;
 814   const char *const full_nm_suffix      = nm_suffix;
 815   const char *const full_gnm_suffix     = gnm_suffix;
 816 #ifdef LDD_SUFFIX
 817   const char *const full_ldd_suffix     = ldd_suffix;
 818 #endif
 819   const char *const full_strip_suffix   = strip_suffix;
 820   const char *const full_gstrip_suffix  = gstrip_suffix;
 821 #endif /* CROSS_DIRECTORY_STRUCTURE */
 822
 823   const char *arg;
 824   FILE *outf;
 825 #ifdef COLLECT_EXPORT_LIST
 826   FILE *exportf;
 827 #endif
 828   const char *ld_file_name;
 829   const char *p;
 830   char **c_argv;
 831   const char **c_ptr;
 832   char **ld1_argv;
 833   const char **ld1;
 834   char **ld2_argv;
 835   const char **ld2;
 836   char **object_lst;
 837   const char **object;
 838   int first_file;
 839   int num_c_args;
 840   char **old_argv;
 841
 842   old_argv = argv;
 843   expandargv (&argc, &argv);
 844   if (argv != old_argv)
 845     at_file_supplied = 1;
 846
 847   num_c_args = argc + 9;
 848
 849   no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
 850
 851   /* Suppress demangling by the real linker, which may be broken.  */
 852   putenv (xstrdup ("COLLECT_NO_DEMANGLE="));
 853
 854 #if defined (COLLECT2_HOST_INITIALIZATION)
 855   /* Perform system dependent initialization, if necessary.  */
 856   COLLECT2_HOST_INITIALIZATION;
 857 #endif
 858
 859 #ifdef SIGCHLD
 860   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
 861      receive the signal.  A different setting is inheritable */
 862   signal (SIGCHLD, SIG_DFL);
 863 #endif
 864
 865   /* Unlock the stdio streams.  */
 866   unlock_std_streams ();
 867
 868   gcc_init_libintl ();
 869
 870   /* Do not invoke xcalloc before this point, since locale needs to be
 871      set first, in case a diagnostic is issued.  */
 872
 873   ld1_argv = XCNEWVEC (char *, argc + 4);
 874   ld1 = CONST_CAST2 (const char **, char **, ld1_argv);
 875   ld2_argv = XCNEWVEC (char *, argc + 11);
 876   ld2 = CONST_CAST2 (const char **, char **, ld2_argv);
 877   object_lst = XCNEWVEC (char *, argc);
 878   object = CONST_CAST2 (const char **, char **, object_lst);
 879
 880 #ifdef DEBUG
 881   debug = 1;
 882 #endif
 883
 884   /* Parse command line early for instances of -debug.  This allows
 885      the debug flag to be set before functions like find_a_file()
 886      are called.  */
 887   {
 888     int i;
 889
 890     for (i = 1; argv[i] != NULL; i ++)
 891       {
 892         if (! strcmp (argv[i], "-debug"))
 893           debug = 1;
 894       }
 895     vflag = debug;
 896   }
 897
 898 #ifndef DEFAULT_A_OUT_NAME
 899   output_file = "a.out";
 900 #else
 901   output_file = DEFAULT_A_OUT_NAME;
 902 #endif
 903
 904   obstack_begin (&temporary_obstack, 0);
 905   temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
 906
 907 #ifndef HAVE_LD_DEMANGLE
 908   current_demangling_style = auto_demangling;
 909 #endif
 910   p = getenv ("COLLECT_GCC_OPTIONS");
 911   while (p && *p)
 912     {
 913       const char *q = extract_string (&p);
 914       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
 915         num_c_args++;
 916     }
 917   obstack_free (&temporary_obstack, temporary_firstobj);
 918
 919   /* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
 920      -fno-exceptions -w */
 921   num_c_args += 5;
 922
 923   c_argv = XCNEWVEC (char *, num_c_args);
 924   c_ptr = CONST_CAST2 (const char **, char **, c_argv);
 925
 926   if (argc < 2)
 927     fatal ("no arguments");
 928
 929 #ifdef SIGQUIT
 930   if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
 931     signal (SIGQUIT, handler);
 932 #endif
 933   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
 934     signal (SIGINT, handler);
 935 #ifdef SIGALRM
 936   if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
 937     signal (SIGALRM, handler);
 938 #endif
 939 #ifdef SIGHUP
 940   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
 941     signal (SIGHUP, handler);
 942 #endif
 943   if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
 944     signal (SIGSEGV, handler);
 945 #ifdef SIGBUS
 946   if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
 947     signal (SIGBUS, handler);
 948 #endif
 949
 950   /* Extract COMPILER_PATH and PATH into our prefix list.  */
 951   prefix_from_env ("COMPILER_PATH", &cpath);
 952   prefix_from_env ("PATH", &path);
 953
 954   /* Try to discover a valid linker/nm/strip to use.  */
 955
 956   /* Maybe we know the right file to use (if not cross).  */
 957   ld_file_name = 0;
 958 #ifdef DEFAULT_LINKER
 959   if (access (DEFAULT_LINKER, X_OK) == 0)
 960     ld_file_name = DEFAULT_LINKER;
 961   if (ld_file_name == 0)
 962 #endif
 963 #ifdef REAL_LD_FILE_NAME
 964   ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
 965   if (ld_file_name == 0)
 966 #endif
 967   /* Search the (target-specific) compiler dirs for ld'.  */
 968   ld_file_name = find_a_file (&cpath, real_ld_suffix);
 969   /* Likewise for `collect-ld'.  */
 970   if (ld_file_name == 0)
 971     ld_file_name = find_a_file (&cpath, collect_ld_suffix);
 972   /* Search the compiler directories for `ld'.  We have protection against
 973      recursive calls in find_a_file.  */
 974   if (ld_file_name == 0)
 975     ld_file_name = find_a_file (&cpath, ld_suffix);
 976   /* Search the ordinary system bin directories
 977      for `ld' (if native linking) or `TARGET-ld' (if cross).  */
 978   if (ld_file_name == 0)
 979     ld_file_name = find_a_file (&path, full_ld_suffix);
 980
 981 #ifdef REAL_NM_FILE_NAME
 982   nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
 983   if (nm_file_name == 0)
 984 #endif
 985   nm_file_name = find_a_file (&cpath, gnm_suffix);
 986   if (nm_file_name == 0)
 987     nm_file_name = find_a_file (&path, full_gnm_suffix);
 988   if (nm_file_name == 0)
 989     nm_file_name = find_a_file (&cpath, nm_suffix);
 990   if (nm_file_name == 0)
 991     nm_file_name = find_a_file (&path, full_nm_suffix);
 992
 993 #ifdef LDD_SUFFIX
 994   ldd_file_name = find_a_file (&cpath, ldd_suffix);
 995   if (ldd_file_name == 0)
 996     ldd_file_name = find_a_file (&path, full_ldd_suffix);
 997 #endif
 998
 999 #ifdef REAL_STRIP_FILE_NAME
1000   strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1001   if (strip_file_name == 0)
1002 #endif
1003   strip_file_name = find_a_file (&cpath, gstrip_suffix);
1004   if (strip_file_name == 0)
1005     strip_file_name = find_a_file (&path, full_gstrip_suffix);
1006   if (strip_file_name == 0)
1007     strip_file_name = find_a_file (&cpath, strip_suffix);
1008   if (strip_file_name == 0)
1009     strip_file_name = find_a_file (&path, full_strip_suffix);
1010
1011   /* Determine the full path name of the C compiler to use.  */
1012   c_file_name = getenv ("COLLECT_GCC");
1013   if (c_file_name == 0)
1014     {
1015 #ifdef CROSS_DIRECTORY_STRUCTURE
1016       c_file_name = concat (target_machine, "-gcc", NULL);
1017 #else
1018       c_file_name = "gcc";
1019 #endif
1020     }
1021
1022   p = find_a_file (&cpath, c_file_name);
1023
1024   /* Here it should be safe to use the system search path since we should have
1025      already qualified the name of the compiler when it is needed.  */
1026   if (p == 0)
1027     p = find_a_file (&path, c_file_name);
1028
1029   if (p)
1030     c_file_name = p;
1031
1032   *ld1++ = *ld2++ = ld_file_name;
1033
1034   /* Make temp file names.  */
1035   c_file = make_temp_file (".c");
1036   o_file = make_temp_file (".o");
1037 #ifdef COLLECT_EXPORT_LIST
1038   export_file = make_temp_file (".x");
1039 #endif
1040   ldout = make_temp_file (".ld");
1041   lderrout = make_temp_file (".le");
1042   *c_ptr++ = c_file_name;
1043   *c_ptr++ = "-x";
1044   *c_ptr++ = "c";
1045   *c_ptr++ = "-c";
1046   *c_ptr++ = "-o";
1047   *c_ptr++ = o_file;
1048
1049 #ifdef COLLECT_EXPORT_LIST
1050   /* Generate a list of directories from LIBPATH.  */
1051   prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1052   /* Add to this list also two standard directories where
1053      AIX loader always searches for libraries.  */
1054   add_prefix (&libpath_lib_dirs, "/lib");
1055   add_prefix (&libpath_lib_dirs, "/usr/lib");
1056 #endif
1057
1058   /* Get any options that the upper GCC wants to pass to the sub-GCC.
1059
1060      AIX support needs to know if -shared has been specified before
1061      parsing commandline arguments.  */
1062
1063   p = getenv ("COLLECT_GCC_OPTIONS");
1064   while (p && *p)
1065     {
1066       const char *q = extract_string (&p);
1067       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1068         *c_ptr++ = xstrdup (q);
1069       if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
1070         *c_ptr++ = xstrdup (q);
1071       if (strcmp (q, "-shared") == 0)
1072         shared_obj = 1;
1073       if (*q == '-' && q[1] == 'B')
1074         {
1075           *c_ptr++ = xstrdup (q);
1076           if (q[2] == 0)
1077             {
1078               q = extract_string (&p);
1079               *c_ptr++ = xstrdup (q);
1080             }
1081         }
1082     }
1083   obstack_free (&temporary_obstack, temporary_firstobj);
1084   *c_ptr++ = "-fno-profile-arcs";
1085   *c_ptr++ = "-fno-test-coverage";
1086   *c_ptr++ = "-fno-branch-probabilities";
1087   *c_ptr++ = "-fno-exceptions";
1088   *c_ptr++ = "-w";
1089
1090   /* !!! When GCC calls collect2,
1091      it does not know whether it is calling collect2 or ld.
1092      So collect2 cannot meaningfully understand any options
1093      except those ld understands.
1094      If you propose to make GCC pass some other option,
1095      just imagine what will happen if ld is really ld!!!  */
1096
1097   /* Parse arguments.  Remember output file spec, pass the rest to ld.  */
1098   /* After the first file, put in the c++ rt0.  */
1099
1100   first_file = 1;
1101 #ifdef HAVE_LD_DEMANGLE
1102   if (!demangle_flag && !no_demangle)
1103     demangle_flag = "--demangle";
1104   if (demangle_flag)
1105     *ld1++ = *ld2++ = demangle_flag;
1106 #endif
1107   while ((arg = *++argv) != (char *) 0)
1108     {
1109       *ld1++ = *ld2++ = arg;
1110
1111       if (arg[0] == '-')
1112         {
1113           switch (arg[1])
1114             {
1115 #ifdef COLLECT_EXPORT_LIST
1116             /* We want to disable automatic exports on AIX when user
1117                explicitly puts an export list in command line */
1118             case 'b':
1119               if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1120                 export_flag = 1;
1121               else if (arg[2] == '6' && arg[3] == '4')
1122                 aix64_flag = 1;
1123               else if (arg[2] == 'r' && arg[3] == 't' && arg[4] == 'l')
1124                 aixrtl_flag = 1;
1125               break;
1126 #endif
1127
1128             case 'd':
1129               if (!strcmp (arg, "-debug"))
1130                 {
1131                   /* Already parsed.  */
1132                   ld1--;
1133                   ld2--;
1134                 }
1135               if (!strcmp (arg, "-dynamic-linker") && argv[1])
1136                 {
1137                   ++argv;
1138                   *ld1++ = *ld2++ = *argv;
1139                 }
1140               break;
1141
1142             case 'l':
1143               if (first_file)
1144                 {
1145                   /* place o_file BEFORE this argument! */
1146                   first_file = 0;
1147                   ld2--;
1148                   *ld2++ = o_file;
1149                   *ld2++ = arg;
1150                 }
1151 #ifdef COLLECT_EXPORT_LIST
1152               {
1153                 /* Resolving full library name.  */
1154                 const char *s = resolve_lib_name (arg+2);
1155
1156                 /* Saving a full library name.  */
1157                 add_to_list (&libs, s);
1158               }
1159 #endif
1160               break;
1161
1162 #ifdef COLLECT_EXPORT_LIST
1163             /* Saving directories where to search for libraries.  */
1164             case 'L':
1165               add_prefix (&cmdline_lib_dirs, arg+2);
1166               break;
1167 #else
1168 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1169             case 'L':
1170               if (is_in_args (arg,
1171                               CONST_CAST2 (const char **, char **, ld1_argv),
1172                               ld1 - 1))
1173                 --ld1;
1174               break;
1175 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1176 #endif
1177
1178             case 'o':
1179               if (arg[2] == '\0')
1180                 output_file = *ld1++ = *ld2++ = *++argv;
1181               else if (1
1182 #ifdef SWITCHES_NEED_SPACES
1183                        && ! strchr (SWITCHES_NEED_SPACES, arg[1])
1184 #endif
1185                        )
1186
1187                 output_file = &arg[2];
1188               break;
1189
1190             case 'r':
1191               if (arg[2] == '\0')
1192                 rflag = 1;
1193               break;
1194
1195             case 's':
1196               if (arg[2] == '\0' && do_collecting)
1197                 {
1198                   /* We must strip after the nm run, otherwise C++ linking
1199                      will not work.  Thus we strip in the second ld run, or
1200                      else with strip if there is no second ld run.  */
1201                   strip_flag = 1;
1202                   ld1--;
1203                 }
1204               break;
1205
1206             case 'v':
1207               if (arg[2] == '\0')
1208                 vflag = 1;
1209               break;
1210
1211             case '-':
1212               if (strcmp (arg, "--no-demangle") == 0)
1213                 {
1214                   demangle_flag = arg;
1215                   no_demangle = 1;
1216                   ld1--;
1217                   ld2--;
1218                 }
1219               else if (strncmp (arg, "--demangle", 10) == 0)
1220                 {
1221                   demangle_flag = arg;
1222                   no_demangle = 0;
1223 #ifndef HAVE_LD_DEMANGLE
1224                   if (arg[10] == '=')
1225                     {
1226                       enum demangling_styles style
1227                         = cplus_demangle_name_to_style (arg+11);
1228                       if (style == unknown_demangling)
1229                         error ("unknown demangling style '%s'", arg+11);
1230                       else
1231                         current_demangling_style = style;
1232                     }
1233 #endif
1234                   ld1--;
1235                   ld2--;
1236                 }
1237               else if (strncmp (arg, "--sysroot=", 10) == 0)
1238                 target_system_root = arg + 10;
1239               break;
1240             }
1241         }
1242       else if ((p = strrchr (arg, '.')) != (char *) 0
1243                && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1244                    || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
1245                    || strcmp (p, ".obj") == 0))
1246         {
1247           if (first_file)
1248             {
1249               first_file = 0;
1250               if (p[1] == 'o')
1251                 *ld2++ = o_file;
1252               else
1253                 {
1254                   /* place o_file BEFORE this argument! */
1255                   ld2--;
1256                   *ld2++ = o_file;
1257                   *ld2++ = arg;
1258                 }
1259             }
1260           if (p[1] == 'o' || p[1] == 'l')
1261             *object++ = arg;
1262 #ifdef COLLECT_EXPORT_LIST
1263           /* libraries can be specified directly, i.e. without -l flag.  */
1264           else
1265             {
1266               /* Saving a full library name.  */
1267               add_to_list (&libs, arg);
1268             }
1269 #endif
1270         }
1271     }
1272
1273 #ifdef COLLECT_EXPORT_LIST
1274   /* This is added only for debugging purposes.  */
1275   if (debug)
1276     {
1277       fprintf (stderr, "List of libraries:\n");
1278       dump_list (stderr, "\t", libs.first);
1279     }
1280
1281   /* The AIX linker will discard static constructors in object files if
1282      nothing else in the file is referenced, so look at them first.  */
1283   {
1284       const char **export_object_lst = (const char **)object_lst;
1285
1286       while (export_object_lst < object)
1287         scan_prog_file (*export_object_lst++, PASS_OBJ);
1288   }
1289   {
1290     struct id *list = libs.first;
1291
1292     for (; list; list = list->next)
1293       scan_prog_file (list->name, PASS_FIRST);
1294   }
1295
1296   if (exports.first)
1297     {
1298       char *buf = concat ("-bE:", export_file, NULL);
1299
1300       *ld1++ = buf;
1301       *ld2++ = buf;
1302
1303       exportf = fopen (export_file, "w");
1304       if (exportf == (FILE *) 0)
1305         fatal_perror ("fopen %s", export_file);
1306       write_aix_file (exportf, exports.first);
1307       if (fclose (exportf))
1308         fatal_perror ("fclose %s", export_file);
1309     }
1310 #endif
1311
1312   *c_ptr++ = c_file;
1313   *c_ptr = *ld1 = *object = (char *) 0;
1314
1315   if (vflag)
1316     {
1317       notice ("collect2 version %s", version_string);
1318 #ifdef TARGET_VERSION
1319       TARGET_VERSION;
1320 #endif
1321       fprintf (stderr, "\n");
1322     }
1323
1324   if (debug)
1325     {
1326       const char *ptr;
1327       fprintf (stderr, "ld_file_name        = %s\n",
1328                (ld_file_name ? ld_file_name : "not found"));
1329       fprintf (stderr, "c_file_name         = %s\n",
1330                (c_file_name ? c_file_name : "not found"));
1331       fprintf (stderr, "nm_file_name        = %s\n",
1332                (nm_file_name ? nm_file_name : "not found"));
1333 #ifdef LDD_SUFFIX
1334       fprintf (stderr, "ldd_file_name       = %s\n",
1335                (ldd_file_name ? ldd_file_name : "not found"));
1336 #endif
1337       fprintf (stderr, "strip_file_name     = %s\n",
1338                (strip_file_name ? strip_file_name : "not found"));
1339       fprintf (stderr, "c_file              = %s\n",
1340                (c_file ? c_file : "not found"));
1341       fprintf (stderr, "o_file              = %s\n",
1342                (o_file ? o_file : "not found"));
1343
1344       ptr = getenv ("COLLECT_GCC_OPTIONS");
1345       if (ptr)
1346         fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1347
1348       ptr = getenv ("COLLECT_GCC");
1349       if (ptr)
1350         fprintf (stderr, "COLLECT_GCC         = %s\n", ptr);
1351
1352       ptr = getenv ("COMPILER_PATH");
1353       if (ptr)
1354         fprintf (stderr, "COMPILER_PATH       = %s\n", ptr);
1355
1356       ptr = getenv (LIBRARY_PATH_ENV);
1357       if (ptr)
1358         fprintf (stderr, "%-20s= %s\n", LIBRARY_PATH_ENV, ptr);
1359
1360       fprintf (stderr, "\n");
1361     }
1362
1363   /* Load the program, searching all libraries and attempting to provide
1364      undefined symbols from repository information.  */
1365
1366   /* On AIX we do this later.  */
1367 #ifndef COLLECT_EXPORT_LIST
1368   do_tlink (ld1_argv, object_lst);
1369 #endif
1370
1371   /* If -r or they will be run via some other method, do not build the
1372      constructor or destructor list, just return now.  */
1373   if (rflag
1374 #ifndef COLLECT_EXPORT_LIST
1375       || ! do_collecting
1376 #endif
1377       )
1378     {
1379 #ifdef COLLECT_EXPORT_LIST
1380       /* Do the link we avoided above if we are exiting.  */
1381       do_tlink (ld1_argv, object_lst);
1382
1383       /* But make sure we delete the export file we may have created.  */
1384       if (export_file != 0 && export_file[0])
1385         maybe_unlink (export_file);
1386 #endif
1387       maybe_unlink (c_file);
1388       maybe_unlink (o_file);
1389       return 0;
1390     }
1391
1392   /* Examine the namelist with nm and search it for static constructors
1393      and destructors to call.
1394      Write the constructor and destructor tables to a .s file and reload.  */
1395
1396   /* On AIX we already scanned for global constructors/destructors.  */
1397 #ifndef COLLECT_EXPORT_LIST
1398   scan_prog_file (output_file, PASS_FIRST);
1399 #endif
1400
1401 #ifdef SCAN_LIBRARIES
1402   scan_libraries (output_file);
1403 #endif
1404
1405   if (debug)
1406     {
1407       notice ("%d constructor(s) found\n", constructors.number);
1408       notice ("%d destructor(s)  found\n", destructors.number);
1409       notice ("%d frame table(s) found\n", frame_tables.number);
1410     }
1411
1412   if (constructors.number == 0 && destructors.number == 0
1413       && frame_tables.number == 0
1414 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1415       /* If we will be running these functions ourselves, we want to emit
1416          stubs into the shared library so that we do not have to relink
1417          dependent programs when we add static objects.  */
1418       && ! shared_obj
1419 #endif
1420       )
1421     {
1422 #ifdef COLLECT_EXPORT_LIST
1423       /* Do tlink without additional code generation.  */
1424       do_tlink (ld1_argv, object_lst);
1425 #endif
1426       /* Strip now if it was requested on the command line.  */
1427       if (strip_flag)
1428         {
1429           char **real_strip_argv = XCNEWVEC (char *, 3);
1430           const char ** strip_argv = CONST_CAST2 (const char **, char **,
1431                                                   real_strip_argv);
1432
1433           strip_argv[0] = strip_file_name;
1434           strip_argv[1] = output_file;
1435           strip_argv[2] = (char *) 0;
1436           fork_execute ("strip", real_strip_argv);
1437         }
1438
1439 #ifdef COLLECT_EXPORT_LIST
1440       maybe_unlink (export_file);
1441 #endif
1442       maybe_unlink (c_file);
1443       maybe_unlink (o_file);
1444       return 0;
1445     }
1446
1447   /* Sort ctor and dtor lists by priority.  */
1448   sort_ids (&constructors);
1449   sort_ids (&destructors);
1450
1451   maybe_unlink(output_file);
1452   outf = fopen (c_file, "w");
1453   if (outf == (FILE *) 0)
1454     fatal_perror ("fopen %s", c_file);
1455
1456   write_c_file (outf, c_file);
1457
1458   if (fclose (outf))
1459     fatal_perror ("fclose %s", c_file);
1460
1461   /* Tell the linker that we have initializer and finalizer functions.  */
1462 #ifdef LD_INIT_SWITCH
1463 #ifdef COLLECT_EXPORT_LIST
1464   *ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL);
1465 #else
1466   *ld2++ = LD_INIT_SWITCH;
1467   *ld2++ = initname;
1468   *ld2++ = LD_FINI_SWITCH;
1469   *ld2++ = fininame;
1470 #endif
1471 #endif
1472
1473 #ifdef COLLECT_EXPORT_LIST
1474   if (shared_obj)
1475     {
1476       /* If we did not add export flag to link arguments before, add it to
1477          second link phase now.  No new exports should have been added.  */
1478       if (! exports.first)
1479         *ld2++ = concat ("-bE:", export_file, NULL);
1480
1481 #ifndef LD_INIT_SWITCH
1482       add_to_list (&exports, initname);
1483       add_to_list (&exports, fininame);
1484       add_to_list (&exports, "_GLOBAL__DI");
1485       add_to_list (&exports, "_GLOBAL__DD");
1486 #endif
1487       exportf = fopen (export_file, "w");
1488       if (exportf == (FILE *) 0)
1489         fatal_perror ("fopen %s", export_file);
1490       write_aix_file (exportf, exports.first);
1491       if (fclose (exportf))
1492         fatal_perror ("fclose %s", export_file);
1493     }
1494 #endif
1495
1496   /* End of arguments to second link phase.  */
1497   *ld2 = (char*) 0;
1498
1499   if (debug)
1500     {
1501       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1502                output_file, c_file);
1503       write_c_file (stderr, "stderr");
1504       fprintf (stderr, "========== end of c_file\n\n");
1505 #ifdef COLLECT_EXPORT_LIST
1506       fprintf (stderr, "\n========== export_file = %s\n", export_file);
1507       write_aix_file (stderr, exports.first);
1508       fprintf (stderr, "========== end of export_file\n\n");
1509 #endif
1510     }
1511
1512   /* Assemble the constructor and destructor tables.
1513      Link the tables in with the rest of the program.  */
1514
1515   fork_execute ("gcc",  c_argv);
1516 #ifdef COLLECT_EXPORT_LIST
1517   /* On AIX we must call tlink because of possible templates resolution.  */
1518   do_tlink (ld2_argv, object_lst);
1519 #else
1520   /* Otherwise, simply call ld because tlink is already done.  */
1521   fork_execute ("ld", ld2_argv);
1522
1523   /* Let scan_prog_file do any final mods (OSF/rose needs this for
1524      constructors/destructors in shared libraries.  */
1525   scan_prog_file (output_file, PASS_SECOND);
1526 #endif
1527
1528   maybe_unlink (c_file);
1529   maybe_unlink (o_file);
1530
1531 #ifdef COLLECT_EXPORT_LIST
1532   maybe_unlink (export_file);
1533 #endif
1534
1535   return 0;
1536 }
1537
1538 \f
1539 /* Wait for a process to finish, and exit if a nonzero status is found.  */
1540
1541 int
1542 collect_wait (const char *prog, struct pex_obj *pex)
1543 {
1544   int status;
1545
1546   if (!pex_get_status (pex, 1, &status))
1547     fatal_perror ("can't get program status");
1548   pex_free (pex);
1549
1550   if (status)
1551     {
1552       if (WIFSIGNALED (status))
1553         {
1554           int sig = WTERMSIG (status);
1555           error ("%s terminated with signal %d [%s]%s",
1556                  prog, sig, strsignal(sig),
1557                  WCOREDUMP(status) ? ", core dumped" : "");
1558           collect_exit (FATAL_EXIT_CODE);
1559         }
1560
1561       if (WIFEXITED (status))
1562         return WEXITSTATUS (status);
1563     }
1564   return 0;
1565 }
1566
1567 static void
1568 do_wait (const char *prog, struct pex_obj *pex)
1569 {
1570   int ret = collect_wait (prog, pex);
1571   if (ret != 0)
1572     {
1573       error ("%s returned %d exit status", prog, ret);
1574       collect_exit (ret);
1575     }
1576
1577   if (response_file)
1578     {
1579       unlink (response_file);
1580       response_file = NULL;
1581     }
1582 }
1583
1584 \f
1585 /* Execute a program, and wait for the reply.  */
1586
1587 struct pex_obj *
1588 collect_execute (const char *prog, char **argv, const char *outname,
1589                  const char *errname)
1590 {
1591   struct pex_obj *pex;
1592   const char *errmsg;
1593   int err;
1594   char *response_arg = NULL;
1595   char *response_argv[3] ATTRIBUTE_UNUSED;
1596
1597   if (HAVE_GNU_LD && at_file_supplied && argv[0] != NULL)
1598     {
1599       /* If using @file arguments, create a temporary file and put the
1600          contents of argv into it.  Then change argv to an array corresponding
1601          to a single argument @FILE, where FILE is the temporary filename.  */
1602
1603       char **current_argv = argv + 1;
1604       char *argv0 = argv[0];
1605       int status;
1606       FILE *f;
1607
1608       /* Note: we assume argv contains at least one element; this is
1609          checked above.  */
1610
1611       response_file = make_temp_file ("");
1612
1613       f = fopen (response_file, "w");
1614
1615       if (f == NULL)
1616         fatal ("could not open response file %s", response_file);
1617
1618       status = writeargv (current_argv, f);
1619
1620       if (status)
1621         fatal ("could not write to response file %s", response_file);
1622
1623       status = fclose (f);
1624
1625       if (EOF == status)
1626         fatal ("could not close response file %s", response_file);
1627
1628       response_arg = concat ("@", response_file, NULL);
1629       response_argv[0] = argv0;
1630       response_argv[1] = response_arg;
1631       response_argv[2] = NULL;
1632
1633       argv = response_argv;
1634     }
1635
1636   if (vflag || debug)
1637     {
1638       char **p_argv;
1639       const char *str;
1640
1641       if (argv[0])
1642         fprintf (stderr, "%s", argv[0]);
1643       else
1644         notice ("[cannot find %s]", prog);
1645
1646       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1647         fprintf (stderr, " %s", str);
1648
1649       fprintf (stderr, "\n");
1650     }
1651
1652   fflush (stdout);
1653   fflush (stderr);
1654
1655   /* If we cannot find a program we need, complain error.  Do this here
1656      since we might not end up needing something that we could not find.  */
1657
1658   if (argv[0] == 0)
1659     fatal ("cannot find '%s'", prog);
1660
1661   pex = pex_init (0, "collect2", NULL);
1662   if (pex == NULL)
1663     fatal_perror ("pex_init failed");
1664
1665   errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], argv, outname,
1666                     errname, &err);
1667   if (errmsg != NULL)
1668     {
1669       if (err != 0)
1670         {
1671           errno = err;
1672           fatal_perror (errmsg);
1673         }
1674       else
1675         fatal (errmsg);
1676     }
1677
1678   if (response_arg)
1679     free (response_arg);
1680
1681   return pex;
1682 }
1683
1684 static void
1685 fork_execute (const char *prog, char **argv)
1686 {
1687   struct pex_obj *pex;
1688
1689   pex = collect_execute (prog, argv, NULL, NULL);
1690   do_wait (prog, pex);
1691 }
1692 \f
1693 /* Unlink a file unless we are debugging.  */
1694
1695 static void
1696 maybe_unlink (const char *file)
1697 {
1698   if (!debug)
1699     unlink_if_ordinary (file);
1700   else
1701     notice ("[Leaving %s]\n", file);
1702 }
1703
1704 \f
1705 static long sequence_number = 0;
1706
1707 /* Add a name to a linked list.  */
1708
1709 static void
1710 add_to_list (struct head *head_ptr, const char *name)
1711 {
1712   struct id *newid
1713     = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
1714   struct id *p;
1715   strcpy (newid->name, name);
1716
1717   if (head_ptr->first)
1718     head_ptr->last->next = newid;
1719   else
1720     head_ptr->first = newid;
1721
1722   /* Check for duplicate symbols.  */
1723   for (p = head_ptr->first;
1724        strcmp (name, p->name) != 0;
1725        p = p->next)
1726     ;
1727   if (p != newid)
1728     {
1729       head_ptr->last->next = 0;
1730       free (newid);
1731       return;
1732     }
1733
1734   newid->sequence = ++sequence_number;
1735   head_ptr->last = newid;
1736   head_ptr->number++;
1737 }
1738
1739 /* Grab the init priority number from an init function name that
1740    looks like "_GLOBAL_.I.12345.foo".  */
1741
1742 static int
1743 extract_init_priority (const char *name)
1744 {
1745   int pos = 0, pri;
1746
1747   while (name[pos] == '_')
1748     ++pos;
1749   pos += 10; /* strlen ("GLOBAL__X_") */
1750
1751   /* Extract init_p number from ctor/dtor name.  */
1752   pri = atoi (name + pos);
1753   return pri ? pri : DEFAULT_INIT_PRIORITY;
1754 }
1755
1756 /* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
1757    ctors will be run from right to left, dtors from left to right.  */
1758
1759 static void
1760 sort_ids (struct head *head_ptr)
1761 {
1762   /* id holds the current element to insert.  id_next holds the next
1763      element to insert.  id_ptr iterates through the already sorted elements
1764      looking for the place to insert id.  */
1765   struct id *id, *id_next, **id_ptr;
1766
1767   id = head_ptr->first;
1768
1769   /* We don't have any sorted elements yet.  */
1770   head_ptr->first = NULL;
1771
1772   for (; id; id = id_next)
1773     {
1774       id_next = id->next;
1775       id->sequence = extract_init_priority (id->name);
1776
1777       for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
1778         if (*id_ptr == NULL
1779             /* If the sequence numbers are the same, we put the id from the
1780                file later on the command line later in the list.  */
1781             || id->sequence > (*id_ptr)->sequence
1782             /* Hack: do lexical compare, too.
1783             || (id->sequence == (*id_ptr)->sequence
1784                 && strcmp (id->name, (*id_ptr)->name) > 0) */
1785             )
1786           {
1787             id->next = *id_ptr;
1788             *id_ptr = id;
1789             break;
1790           }
1791     }
1792
1793   /* Now set the sequence numbers properly so write_c_file works.  */
1794   for (id = head_ptr->first; id; id = id->next)
1795     id->sequence = ++sequence_number;
1796 }
1797
1798 /* Write: `prefix', the names on list LIST, `suffix'.  */
1799
1800 static void
1801 write_list (FILE *stream, const char *prefix, struct id *list)
1802 {
1803   while (list)
1804     {
1805       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1806       list = list->next;
1807     }
1808 }
1809
1810 #if LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
1811 /* Given a STRING, return nonzero if it occurs in the list in range
1812    [ARGS_BEGIN,ARGS_END).  */
1813
1814 static int
1815 is_in_args (const char *string, const char **args_begin,
1816             const char **args_end)
1817 {
1818   const char **args_pointer;
1819   for (args_pointer = args_begin; args_pointer != args_end; ++args_pointer)
1820     if (strcmp (string, *args_pointer) == 0)
1821       return 1;
1822   return 0;
1823 }
1824 #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
1825
1826 #ifdef COLLECT_EXPORT_LIST
1827 /* This function is really used only on AIX, but may be useful.  */
1828 #if 0
1829 static int
1830 is_in_list (const char *prefix, struct id *list)
1831 {
1832   while (list)
1833     {
1834       if (!strcmp (prefix, list->name)) return 1;
1835       list = list->next;
1836     }
1837     return 0;
1838 }
1839 #endif
1840 #endif /* COLLECT_EXPORT_LIST */
1841
1842 /* Added for debugging purpose.  */
1843 #ifdef COLLECT_EXPORT_LIST
1844 static void
1845 dump_list (FILE *stream, const char *prefix, struct id *list)
1846 {
1847   while (list)
1848     {
1849       fprintf (stream, "%s%s,\n", prefix, list->name);
1850       list = list->next;
1851     }
1852 }
1853 #endif
1854
1855 #if 0
1856 static void
1857 dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
1858 {
1859   while (list)
1860     {
1861       fprintf (stream, "%s%s,\n", prefix, list->prefix);
1862       list = list->next;
1863     }
1864 }
1865 #endif
1866
1867 static void
1868 write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
1869 {
1870   while (list)
1871     {
1872       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1873                prefix, list->sequence, list->name);
1874       list = list->next;
1875     }
1876 }
1877
1878 /* Write out the constructor and destructor tables statically (for a shared
1879    object), along with the functions to execute them.  */
1880
1881 static void
1882 write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
1883 {
1884   const char *p, *q;
1885   char *prefix, *r;
1886   int frames = (frame_tables.number > 0);
1887
1888   /* Figure out name of output_file, stripping off .so version.  */
1889   p = strrchr (output_file, '/');
1890   if (p == 0)
1891     p = output_file;
1892   else
1893     p++;
1894   q = p;
1895   while (q)
1896     {
1897       q = strchr (q,'.');
1898       if (q == 0)
1899         {
1900           q = p + strlen (p);
1901           break;
1902         }
1903       else
1904         {
1905           if (strncmp (q, SHLIB_SUFFIX, strlen (SHLIB_SUFFIX)) == 0)
1906             {
1907               q += strlen (SHLIB_SUFFIX);
1908               break;
1909             }
1910           else
1911             q++;
1912         }
1913     }
1914   /* q points to null at end of the string (or . of the .so version) */
1915   prefix = XNEWVEC (char, q - p + 1);
1916   strncpy (prefix, p, q - p);
1917   prefix[q - p] = 0;
1918   for (r = prefix; *r; r++)
1919     if (!ISALNUM ((unsigned char)*r))
1920       *r = '_';
1921   if (debug)
1922     notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
1923             output_file, prefix);
1924
1925   initname = concat ("_GLOBAL__FI_", prefix, NULL);
1926   fininame = concat ("_GLOBAL__FD_", prefix, NULL);
1927
1928   free (prefix);
1929
1930   /* Write the tables as C code.  */
1931
1932   fprintf (stream, "static int count;\n");
1933   fprintf (stream, "typedef void entry_pt();\n");
1934   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1935
1936   if (frames)
1937     {
1938       write_list_with_asm (stream, "extern void *", frame_tables.first);
1939
1940       fprintf (stream, "\tstatic void *frame_table[] = {\n");
1941       write_list (stream, "\t\t&", frame_tables.first);
1942       fprintf (stream, "\t0\n};\n");
1943
1944       /* This must match what's in frame.h.  */
1945       fprintf (stream, "struct object {\n");
1946       fprintf (stream, "  void *pc_begin;\n");
1947       fprintf (stream, "  void *pc_end;\n");
1948       fprintf (stream, "  void *fde_begin;\n");
1949       fprintf (stream, "  void *fde_array;\n");
1950       fprintf (stream, "  __SIZE_TYPE__ count;\n");
1951       fprintf (stream, "  struct object *next;\n");
1952       fprintf (stream, "};\n");
1953
1954       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1955       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1956
1957       fprintf (stream, "static void reg_frame () {\n");
1958       fprintf (stream, "\tstatic struct object ob;\n");
1959       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1960       fprintf (stream, "\t}\n");
1961
1962       fprintf (stream, "static void dereg_frame () {\n");
1963       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1964       fprintf (stream, "\t}\n");
1965     }
1966
1967   fprintf (stream, "void %s() {\n", initname);
1968   if (constructors.number > 0 || frames)
1969     {
1970       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1971       write_list (stream, "\t\t", constructors.first);
1972       if (frames)
1973         fprintf (stream, "\treg_frame,\n");
1974       fprintf (stream, "\t};\n");
1975       fprintf (stream, "\tentry_pt **p;\n");
1976       fprintf (stream, "\tif (count++ != 0) return;\n");
1977       fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1978       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1979     }
1980   else
1981     fprintf (stream, "\t++count;\n");
1982   fprintf (stream, "}\n");
1983   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1984   fprintf (stream, "void %s() {\n", fininame);
1985   if (destructors.number > 0 || frames)
1986     {
1987       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1988       write_list (stream, "\t\t", destructors.first);
1989       if (frames)
1990         fprintf (stream, "\tdereg_frame,\n");
1991       fprintf (stream, "\t};\n");
1992       fprintf (stream, "\tentry_pt **p;\n");
1993       fprintf (stream, "\tif (--count != 0) return;\n");
1994       fprintf (stream, "\tp = dtors;\n");
1995       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1996                destructors.number + frames);
1997     }
1998   fprintf (stream, "}\n");
1999
2000   if (shared_obj)
2001     {
2002       COLLECT_SHARED_INIT_FUNC(stream, initname);
2003       COLLECT_SHARED_FINI_FUNC(stream, fininame);
2004     }
2005 }
2006
2007 /* Write the constructor/destructor tables.  */
2008
2009 #ifndef LD_INIT_SWITCH
2010 static void
2011 write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED)
2012 {
2013   /* Write the tables as C code.  */
2014
2015   int frames = (frame_tables.number > 0);
2016
2017   fprintf (stream, "typedef void entry_pt();\n\n");
2018
2019   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
2020
2021   if (frames)
2022     {
2023       write_list_with_asm (stream, "extern void *", frame_tables.first);
2024
2025       fprintf (stream, "\tstatic void *frame_table[] = {\n");
2026       write_list (stream, "\t\t&", frame_tables.first);
2027       fprintf (stream, "\t0\n};\n");
2028
2029       /* This must match what's in frame.h.  */
2030       fprintf (stream, "struct object {\n");
2031       fprintf (stream, "  void *pc_begin;\n");
2032       fprintf (stream, "  void *pc_end;\n");
2033       fprintf (stream, "  void *fde_begin;\n");
2034       fprintf (stream, "  void *fde_array;\n");
2035       fprintf (stream, "  __SIZE_TYPE__ count;\n");
2036       fprintf (stream, "  struct object *next;\n");
2037       fprintf (stream, "};\n");
2038
2039       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
2040       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2041
2042       fprintf (stream, "static void reg_frame () {\n");
2043       fprintf (stream, "\tstatic struct object ob;\n");
2044       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2045       fprintf (stream, "\t}\n");
2046
2047       fprintf (stream, "static void dereg_frame () {\n");
2048       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2049       fprintf (stream, "\t}\n");
2050     }
2051
2052   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2053   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2054   write_list (stream, "\t", constructors.first);
2055   if (frames)
2056     fprintf (stream, "\treg_frame,\n");
2057   fprintf (stream, "\t0\n};\n\n");
2058
2059   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2060
2061   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2062   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2063   write_list (stream, "\t", destructors.first);
2064   if (frames)
2065     fprintf (stream, "\tdereg_frame,\n");
2066   fprintf (stream, "\t0\n};\n\n");
2067
2068   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2069   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2070 }
2071 #endif /* ! LD_INIT_SWITCH */
2072
2073 static void
2074 write_c_file (FILE *stream, const char *name)
2075 {
2076 #ifndef LD_INIT_SWITCH
2077   if (! shared_obj)
2078     write_c_file_glob (stream, name);
2079   else
2080 #endif
2081     write_c_file_stat (stream, name);
2082 }
2083
2084 #ifdef COLLECT_EXPORT_LIST
2085 static void
2086 write_aix_file (FILE *stream, struct id *list)
2087 {
2088   for (; list; list = list->next)
2089     {
2090       fputs (list->name, stream);
2091       putc ('\n', stream);
2092     }
2093 }
2094 #endif
2095 \f
2096 #ifdef OBJECT_FORMAT_NONE
2097
2098 /* Generic version to scan the name list of the loaded program for
2099    the symbols g++ uses for static constructors and destructors.
2100
2101    The constructor table begins at __CTOR_LIST__ and contains a count
2102    of the number of pointers (or -1 if the constructors are built in a
2103    separate section by the linker), followed by the pointers to the
2104    constructor functions, terminated with a null pointer.  The
2105    destructor table has the same format, and begins at __DTOR_LIST__.  */
2106
2107 static void
2108 scan_prog_file (const char *prog_name, enum pass which_pass)
2109 {
2110   void (*int_handler) (int);
2111 #ifdef SIGQUIT
2112   void (*quit_handler) (int);
2113 #endif
2114   char *real_nm_argv[4];
2115   const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv);
2116   int argc = 0;
2117   struct pex_obj *pex;
2118   const char *errmsg;
2119   int err;
2120   char *p, buf[1024];
2121   FILE *inf;
2122
2123   if (which_pass == PASS_SECOND)
2124     return;
2125
2126   /* If we do not have an `nm', complain.  */
2127   if (nm_file_name == 0)
2128     fatal ("cannot find 'nm'");
2129
2130   nm_argv[argc++] = nm_file_name;
2131   if (NM_FLAGS[0] != '\0')
2132     nm_argv[argc++] = NM_FLAGS;
2133
2134   nm_argv[argc++] = prog_name;
2135   nm_argv[argc++] = (char *) 0;
2136
2137   /* Trace if needed.  */
2138   if (vflag)
2139     {
2140       const char **p_argv;
2141       const char *str;
2142
2143       for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2144         fprintf (stderr, " %s", str);
2145
2146       fprintf (stderr, "\n");
2147     }
2148
2149   fflush (stdout);
2150   fflush (stderr);
2151
2152   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2153   if (pex == NULL)
2154     fatal_perror ("pex_init failed");
2155
2156   errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL, NULL, &err);
2157   if (errmsg != NULL)
2158     {
2159       if (err != 0)
2160         {
2161           errno = err;
2162           fatal_perror (errmsg);
2163         }
2164       else
2165         fatal (errmsg);
2166     }
2167
2168   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2169 #ifdef SIGQUIT
2170   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2171 #endif
2172
2173   inf = pex_read_output (pex, 0);
2174   if (inf == NULL)
2175     fatal_perror ("can't open nm output");
2176
2177   if (debug)
2178     fprintf (stderr, "\nnm output with constructors/destructors.\n");
2179
2180   /* Read each line of nm output.  */
2181   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2182     {
2183       int ch, ch2;
2184       char *name, *end;
2185
2186       /* If it contains a constructor or destructor name, add the name
2187          to the appropriate list.  */
2188
2189       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2190         if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2191           break;
2192
2193       if (ch != '_')
2194         continue;
2195
2196       name = p;
2197       /* Find the end of the symbol name.
2198          Do not include `|', because Encore nm can tack that on the end.  */
2199       for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2200            end++)
2201         continue;
2202
2203
2204       *end = '\0';
2205       switch (is_ctor_dtor (name))
2206         {
2207         case SYM_CTOR:
2208           if (which_pass != PASS_LIB)
2209             add_to_list (&constructors, name);
2210           break;
2211
2212         case SYM_DTOR:
2213           if (which_pass != PASS_LIB)
2214             add_to_list (&destructors, name);
2215           break;
2216
2217         case SYM_INIT:
2218           if (which_pass != PASS_LIB)
2219             fatal ("init function found in object %s", prog_name);
2220 #ifndef LD_INIT_SWITCH
2221           add_to_list (&constructors, name);
2222 #endif
2223           break;
2224
2225         case SYM_FINI:
2226           if (which_pass != PASS_LIB)
2227             fatal ("fini function found in object %s", prog_name);
2228 #ifndef LD_FINI_SWITCH
2229           add_to_list (&destructors, name);
2230 #endif
2231           break;
2232
2233         case SYM_DWEH:
2234           if (which_pass != PASS_LIB)
2235             add_to_list (&frame_tables, name);
2236           break;
2237
2238         default:                /* not a constructor or destructor */
2239           continue;
2240         }
2241
2242       if (debug)
2243         fprintf (stderr, "\t%s\n", buf);
2244     }
2245
2246   if (debug)
2247     fprintf (stderr, "\n");
2248
2249   do_wait (nm_file_name, pex);
2250
2251   signal (SIGINT,  int_handler);
2252 #ifdef SIGQUIT
2253   signal (SIGQUIT, quit_handler);
2254 #endif
2255 }
2256
2257 #ifdef LDD_SUFFIX
2258
2259 /* Use the List Dynamic Dependencies program to find shared libraries that
2260    the output file depends upon and their initialization/finalization
2261    routines, if any.  */
2262
2263 static void
2264 scan_libraries (const char *prog_name)
2265 {
2266   static struct head libraries;         /* list of shared libraries found */
2267   struct id *list;
2268   void (*int_handler) (int);
2269 #ifdef SIGQUIT
2270   void (*quit_handler) (int);
2271 #endif
2272   char *real_ldd_argv[4];
2273   const char **ldd_argv = (const char **) real_ldd_argv;
2274   int argc = 0;
2275   struct pex_obj *pex;
2276   const char *errmsg;
2277   int err;
2278   char buf[1024];
2279   FILE *inf;
2280
2281   /* If we do not have an `ldd', complain.  */
2282   if (ldd_file_name == 0)
2283     {
2284       error ("cannot find 'ldd'");
2285       return;
2286     }
2287
2288   ldd_argv[argc++] = ldd_file_name;
2289   ldd_argv[argc++] = prog_name;
2290   ldd_argv[argc++] = (char *) 0;
2291
2292   /* Trace if needed.  */
2293   if (vflag)
2294     {
2295       const char **p_argv;
2296       const char *str;
2297
2298       for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2299         fprintf (stderr, " %s", str);
2300
2301       fprintf (stderr, "\n");
2302     }
2303
2304   fflush (stdout);
2305   fflush (stderr);
2306
2307   pex = pex_init (PEX_USE_PIPES, "collect2", NULL);
2308   if (pex == NULL)
2309     fatal_perror ("pex_init failed");
2310
2311   errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL, NULL, &err);
2312   if (errmsg != NULL)
2313     {
2314       if (err != 0)
2315         {
2316           errno = err;
2317           fatal_perror (errmsg);
2318         }
2319       else
2320         fatal (errmsg);
2321     }
2322
2323   int_handler  = (void (*) (int)) signal (SIGINT,  SIG_IGN);
2324 #ifdef SIGQUIT
2325   quit_handler = (void (*) (int)) signal (SIGQUIT, SIG_IGN);
2326 #endif
2327
2328   inf = pex_read_output (pex, 0);
2329   if (inf == NULL)
2330     fatal_perror ("can't open ldd output");
2331
2332   if (debug)
2333     notice ("\nldd output with constructors/destructors.\n");
2334
2335   /* Read each line of ldd output.  */
2336   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2337     {
2338       int ch2;
2339       char *name, *end, *p = buf;
2340
2341       /* Extract names of libraries and add to list.  */
2342       PARSE_LDD_OUTPUT (p);
2343       if (p == 0)
2344         continue;
2345
2346       name = p;
2347       if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2348         fatal ("dynamic dependency %s not found", buf);
2349
2350       /* Find the end of the symbol name.  */
2351       for (end = p;
2352            (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2353            end++)
2354         continue;
2355       *end = '\0';
2356
2357       if (access (name, R_OK) == 0)
2358         add_to_list (&libraries, name);
2359       else
2360         fatal ("unable to open dynamic dependency '%s'", buf);
2361
2362       if (debug)
2363         fprintf (stderr, "\t%s\n", buf);
2364     }
2365   if (debug)
2366     fprintf (stderr, "\n");
2367
2368   do_wait (ldd_file_name, pex);
2369
2370   signal (SIGINT,  int_handler);
2371 #ifdef SIGQUIT
2372   signal (SIGQUIT, quit_handler);
2373 #endif
2374
2375   /* Now iterate through the library list adding their symbols to
2376      the list.  */
2377   for (list = libraries.first; list; list = list->next)
2378     scan_prog_file (list->name, PASS_LIB);
2379 }
2380
2381 #endif /* LDD_SUFFIX */
2382
2383 #endif /* OBJECT_FORMAT_NONE */
2384
2385 \f
2386 /*
2387  * COFF specific stuff.
2388  */
2389
2390 #ifdef OBJECT_FORMAT_COFF
2391
2392 #if defined (EXTENDED_COFF)
2393
2394 #   define GCC_SYMBOLS(X)       (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2395 #   define GCC_SYMENT           SYMR
2396 #   define GCC_OK_SYMBOL(X)     ((X).st == stProc || (X).st == stGlobal)
2397 #   define GCC_SYMINC(X)        (1)
2398 #   define GCC_SYMZERO(X)       (SYMHEADER(X).isymMax)
2399 #   define GCC_CHECK_HDR(X)     (PSYMTAB(X) != 0)
2400
2401 #else
2402
2403 #   define GCC_SYMBOLS(X)       (HEADER(ldptr).f_nsyms)
2404 #   define GCC_SYMENT           SYMENT
2405 #   if defined (C_WEAKEXT)
2406 #     define GCC_OK_SYMBOL(X) \
2407        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2408         ((X).n_scnum > N_UNDEF) && \
2409         (aix64_flag \
2410          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2411              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2412 #     define GCC_UNDEF_SYMBOL(X) \
2413        (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
2414         ((X).n_scnum == N_UNDEF))
2415 #   else
2416 #     define GCC_OK_SYMBOL(X) \
2417        (((X).n_sclass == C_EXT) && \
2418         ((X).n_scnum > N_UNDEF) && \
2419         (aix64_flag \
2420          || (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
2421              || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2422 #     define GCC_UNDEF_SYMBOL(X) \
2423        (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2424 #   endif
2425 #   define GCC_SYMINC(X)        ((X).n_numaux+1)
2426 #   define GCC_SYMZERO(X)       0
2427
2428 /* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2429 #if TARGET_AIX_VERSION >= 51
2430 #   define GCC_CHECK_HDR(X) \
2431      ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2432       || (HEADER (X).f_magic == 0767 && aix64_flag))
2433 #else
2434 #   define GCC_CHECK_HDR(X) \
2435      ((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
2436       || (HEADER (X).f_magic == 0757 && aix64_flag))
2437 #endif
2438
2439 #endif
2440
2441 #ifdef COLLECT_EXPORT_LIST
2442 /* Array of standard AIX libraries which should not
2443    be scanned for ctors/dtors.  */
2444 static const char *const aix_std_libs[] = {
2445   "/unix",
2446   "/lib/libc.a",
2447   "/lib/libm.a",
2448   "/lib/libc_r.a",
2449   "/lib/libm_r.a",
2450   "/usr/lib/libc.a",
2451   "/usr/lib/libm.a",
2452   "/usr/lib/libc_r.a",
2453   "/usr/lib/libm_r.a",
2454   "/usr/lib/threads/libc.a",
2455   "/usr/ccs/lib/libc.a",
2456   "/usr/ccs/lib/libm.a",
2457   "/usr/ccs/lib/libc_r.a",
2458   "/usr/ccs/lib/libm_r.a",
2459   NULL
2460 };
2461
2462 /* This function checks the filename and returns 1
2463    if this name matches the location of a standard AIX library.  */
2464 static int ignore_library (const char *);
2465 static int
2466 ignore_library (const char *name)
2467 {
2468   const char *const *p;
2469   size_t length;
2470
2471   if (target_system_root[0] != '\0')
2472     {
2473       length = strlen (target_system_root);
2474       if (strncmp (name, target_system_root, length) != 0)
2475         return 0;
2476       name += length;
2477     }
2478   for (p = &aix_std_libs[0]; *p != NULL; ++p)
2479     if (strcmp (name, *p) == 0)
2480       return 1;
2481   return 0;
2482 }
2483 #endif /* COLLECT_EXPORT_LIST */
2484
2485 #if defined (HAVE_DECL_LDGETNAME) && !HAVE_DECL_LDGETNAME
2486 extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2487 #endif
2488
2489 /* COFF version to scan the name list of the loaded program for
2490    the symbols g++ uses for static constructors and destructors.
2491
2492    The constructor table begins at __CTOR_LIST__ and contains a count
2493    of the number of pointers (or -1 if the constructors are built in a
2494    separate section by the linker), followed by the pointers to the
2495    constructor functions, terminated with a null pointer.  The
2496    destructor table has the same format, and begins at __DTOR_LIST__.  */
2497
2498 static void
2499 scan_prog_file (const char *prog_name, enum pass which_pass)
2500 {
2501   LDFILE *ldptr = NULL;
2502   int sym_index, sym_count;
2503   int is_shared = 0;
2504
2505   if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2506     return;
2507
2508 #ifdef COLLECT_EXPORT_LIST
2509   /* We do not need scanning for some standard C libraries.  */
2510   if (which_pass == PASS_FIRST && ignore_library (prog_name))
2511     return;
2512
2513   /* On AIX we have a loop, because there is not much difference
2514      between an object and an archive. This trick allows us to
2515      eliminate scan_libraries() function.  */
2516   do
2517     {
2518 #endif
2519       /* Some platforms (e.g. OSF4) declare ldopen as taking a
2520          non-const char * filename parameter, even though it will not
2521          modify that string.  So we must cast away const-ness here,
2522          using CONST_CAST to prevent complaints from -Wcast-qual.  */
2523       if ((ldptr = ldopen (CONST_CAST (char *, prog_name), ldptr)) != NULL)
2524         {
2525           if (! MY_ISCOFF (HEADER (ldptr).f_magic))
2526             fatal ("%s: not a COFF file", prog_name);
2527
2528           if (GCC_CHECK_HDR (ldptr))
2529             {
2530               sym_count = GCC_SYMBOLS (ldptr);
2531               sym_index = GCC_SYMZERO (ldptr);
2532
2533 #ifdef COLLECT_EXPORT_LIST
2534               /* Is current archive member a shared object?  */
2535               is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2536 #endif
2537
2538               while (sym_index < sym_count)
2539                 {
2540                   GCC_SYMENT symbol;
2541
2542                   if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2543                     break;
2544                   sym_index += GCC_SYMINC (symbol);
2545
2546                   if (GCC_OK_SYMBOL (symbol))
2547                     {
2548                       char *name;
2549
2550                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
2551                         continue;               /* Should never happen.  */
2552
2553 #ifdef XCOFF_DEBUGGING_INFO
2554                       /* All AIX function names have a duplicate entry
2555                          beginning with a dot.  */
2556                       if (*name == '.')
2557                         ++name;
2558 #endif
2559
2560                       switch (is_ctor_dtor (name))
2561                         {
2562                         case SYM_CTOR:
2563                           if (! is_shared)
2564                             add_to_list (&constructors, name);
2565 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2566                           if (which_pass == PASS_OBJ)
2567                             add_to_list (&exports, name);
2568 #endif
2569                           break;
2570
2571                         case SYM_DTOR:
2572                           if (! is_shared)
2573                             add_to_list (&destructors, name);
2574 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2575                           if (which_pass == PASS_OBJ)
2576                             add_to_list (&exports, name);
2577 #endif
2578                           break;
2579
2580 #ifdef COLLECT_EXPORT_LIST
2581                         case SYM_INIT:
2582 #ifndef LD_INIT_SWITCH
2583                           if (is_shared)
2584                             add_to_list (&constructors, name);
2585 #endif
2586                           break;
2587
2588                         case SYM_FINI:
2589 #ifndef LD_INIT_SWITCH
2590                           if (is_shared)
2591                             add_to_list (&destructors, name);
2592 #endif
2593                           break;
2594 #endif
2595
2596                         case SYM_DWEH:
2597                           if (! is_shared)
2598                             add_to_list (&frame_tables, name);
2599 #if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
2600                           if (which_pass == PASS_OBJ)
2601                             add_to_list (&exports, name);
2602 #endif
2603                           break;
2604
2605                         default:        /* not a constructor or destructor */
2606 #ifdef COLLECT_EXPORT_LIST
2607                           /* Explicitly export all global symbols when
2608                              building a shared object on AIX, but do not
2609                              re-export symbols from another shared object
2610                              and do not export symbols if the user
2611                              provides an explicit export list.  */
2612                           if (shared_obj && !is_shared
2613                               && which_pass == PASS_OBJ && !export_flag)
2614                             add_to_list (&exports, name);
2615 #endif
2616                           continue;
2617                         }
2618
2619                       if (debug)
2620 #if !defined(EXTENDED_COFF)
2621                         fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2622                                  symbol.n_scnum, symbol.n_sclass,
2623                                  (symbol.n_type ? "0" : ""), symbol.n_type,
2624                                  name);
2625 #else
2626                         fprintf (stderr,
2627                                  "\tiss = %5d, value = %5ld, index = %5d, name = %s\n",
2628                                  symbol.iss, (long) symbol.value, symbol.index, name);
2629 #endif
2630                     }
2631                 }
2632             }
2633 #ifdef COLLECT_EXPORT_LIST
2634           else
2635             {
2636               /* If archive contains both 32-bit and 64-bit objects,
2637                  we want to skip objects in other mode so mismatch normal.  */
2638               if (debug)
2639                 fprintf (stderr, "%s : magic=%o aix64=%d mismatch\n",
2640                          prog_name, HEADER (ldptr).f_magic, aix64_flag);
2641             }
2642 #endif
2643         }
2644       else
2645         {
2646           fatal ("%s: cannot open as COFF file", prog_name);
2647         }
2648 #ifdef COLLECT_EXPORT_LIST
2649       /* On AIX loop continues while there are more members in archive.  */
2650     }
2651   while (ldclose (ldptr) == FAILURE);
2652 #else
2653   /* Otherwise we simply close ldptr.  */
2654   (void) ldclose(ldptr);
2655 #endif
2656 }
2657 #endif /* OBJECT_FORMAT_COFF */
2658
2659 #ifdef COLLECT_EXPORT_LIST
2660 /* Given a library name without "lib" prefix, this function
2661    returns a full library name including a path.  */
2662 static char *
2663 resolve_lib_name (const char *name)
2664 {
2665   char *lib_buf;
2666   int i, j, l = 0;
2667   /* Library extensions for AIX dynamic linking.  */
2668   const char * const libexts[2] = {"a", "so"};
2669
2670   for (i = 0; libpaths[i]; i++)
2671     if (libpaths[i]->max_len > l)
2672       l = libpaths[i]->max_len;
2673
2674   lib_buf = XNEWVEC (char, l + strlen(name) + 10);
2675
2676   for (i = 0; libpaths[i]; i++)
2677     {
2678       struct prefix_list *list = libpaths[i]->plist;
2679       for (; list; list = list->next)
2680         {
2681           /* The following lines are needed because path_prefix list
2682              may contain directories both with trailing '/' and
2683              without it.  */
2684           const char *p = "";
2685           if (list->prefix[strlen(list->prefix)-1] != '/')
2686             p = "/";
2687           for (j = 0; j < 2; j++)
2688             {
2689               sprintf (lib_buf, "%s%slib%s.%s",
2690                        list->prefix, p, name,
2691                        libexts[(j + aixrtl_flag) % 2]);
2692               if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2693               if (file_exists (lib_buf))
2694                 {
2695                   if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2696                   return (lib_buf);
2697                 }
2698             }
2699         }
2700     }
2701   if (debug)
2702     fprintf (stderr, "not found\n");
2703   else
2704     fatal ("library lib%s not found", name);
2705   return (NULL);
2706 }
2707 #endif /* COLLECT_EXPORT_LIST */