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, 93-97, 1998 Free Software Foundation, Inc.
   4    Contributed by Chris Smith (csmith@convex.com).
   5    Heavily modified by Michael Meissner (meissner@cygnus.com),
   6    Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).
   7
   8 This file is part of GNU CC.
   9
  10 GNU CC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GNU CC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU CC; see the file COPYING.  If not, write to
  22 the Free Software Foundation, 59 Temple Place - Suite 330,
  23 Boston, MA 02111-1307, USA.  */
  24
  25
  26 /* Build tables of static constructors and destructors and run ld.  */
  27
  28 #include "config.h"
  29 #include "system.h"
  30 #include <signal.h>
  31 #include <sys/stat.h>
  32
  33 #define COLLECT
  34
  35 #include "demangle.h"
  36 #include "obstack.h"
  37 #include "gansidecl.h"
  38 #ifdef __CYGWIN32__
  39 #include <process.h>
  40 #endif
  41
  42 #ifndef HAVE_STRERROR
  43 extern char *sys_errlist[];
  44 extern int sys_nerr;
  45 #else
  46 char *strerror();
  47 #endif
  48
  49 /* Obstack allocation and deallocation routines.  */
  50 #define obstack_chunk_alloc xmalloc
  51 #define obstack_chunk_free free
  52
  53 #ifdef USG
  54 #define vfork fork
  55 #endif
  56
  57 #ifndef WIFSIGNALED
  58 #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f)
  59 #endif
  60 #ifndef WTERMSIG
  61 #define WTERMSIG(S) ((S) & 0x7f)
  62 #endif
  63 #ifndef WIFEXITED
  64 #define WIFEXITED(S) (((S) & 0xff) == 0)
  65 #endif
  66 #ifndef WEXITSTATUS
  67 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
  68 #endif
  69
  70 extern char *choose_temp_base ();
  71 \f
  72 /* On certain systems, we have code that works by scanning the object file
  73    directly.  But this code uses system-specific header files and library
  74    functions, so turn it off in a cross-compiler.  Likewise, the names of
  75    the utilities are not correct for a cross-compiler; we have to hope that
  76    cross-versions are in the proper directories.  */
  77
  78 #ifdef CROSS_COMPILE
  79 #undef SUNOS4_SHARED_LIBRARIES
  80 #undef OBJECT_FORMAT_COFF
  81 #undef OBJECT_FORMAT_ROSE
  82 #undef MD_EXEC_PREFIX
  83 #undef REAL_LD_FILE_NAME
  84 #undef REAL_NM_FILE_NAME
  85 #undef REAL_STRIP_FILE_NAME
  86 #endif
  87
  88 /* If we cannot use a special method, use the ordinary one:
  89    run nm to find what symbols are present.
  90    In a cross-compiler, this means you need a cross nm,
  91    but that is not quite as unpleasant as special headers.  */
  92
  93 #if !defined (OBJECT_FORMAT_COFF) && !defined (OBJECT_FORMAT_ROSE)
  94 #define OBJECT_FORMAT_NONE
  95 #endif
  96
  97 #ifdef OBJECT_FORMAT_COFF
  98
  99 #include <a.out.h>
 100 #include <ar.h>
 101
 102 #ifdef UMAX
 103 #include <sgs.h>
 104 #endif
 105
 106 /* Many versions of ldfcn.h define these.  */
 107 #ifdef FREAD
 108 #undef FREAD
 109 #undef FWRITE
 110 #endif
 111
 112 #include <ldfcn.h>
 113
 114 /* Some systems have an ISCOFF macro, but others do not.  In some cases
 115    the macro may be wrong.  MY_ISCOFF is defined in tm.h files for machines
 116    that either do not have an ISCOFF macro in /usr/include or for those
 117    where it is wrong.  */
 118
 119 #ifndef MY_ISCOFF
 120 #define MY_ISCOFF(X) ISCOFF (X)
 121 #endif
 122
 123 #endif /* OBJECT_FORMAT_COFF */
 124
 125 #ifdef OBJECT_FORMAT_ROSE
 126
 127 #ifdef _OSF_SOURCE
 128 #define USE_MMAP
 129 #endif
 130
 131 #ifdef USE_MMAP
 132 #include <sys/mman.h>
 133 #endif
 134
 135 #include <unistd.h>
 136 #include <mach_o_format.h>
 137 #include <mach_o_header.h>
 138 #include <mach_o_vals.h>
 139 #include <mach_o_types.h>
 140
 141 #endif /* OBJECT_FORMAT_ROSE */
 142
 143 #ifdef OBJECT_FORMAT_NONE
 144
 145 /* Default flags to pass to nm.  */
 146 #ifndef NM_FLAGS
 147 #define NM_FLAGS "-p"
 148 #endif
 149
 150 #endif /* OBJECT_FORMAT_NONE */
 151
 152 /* Some systems use __main in a way incompatible with its use in gcc, in these
 153    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
 154    give the same symbol without quotes for an alternative entry point.  You
 155    must define both, or neither.  */
 156 #ifndef NAME__MAIN
 157 #define NAME__MAIN "__main"
 158 #define SYMBOL__MAIN __main
 159 #endif
 160
 161 #if defined (LDD_SUFFIX) || SUNOS4_SHARED_LIBRARIES
 162 #define SCAN_LIBRARIES
 163 #endif
 164
 165 #ifdef USE_COLLECT2
 166 int do_collecting = 1;
 167 #else
 168 int do_collecting = 0;
 169 #endif
 170 \f
 171 /* Linked lists of constructor and destructor names.  */
 172
 173 struct id
 174 {
 175   struct id *next;
 176   int sequence;
 177   char name[1];
 178 };
 179
 180 struct head
 181 {
 182   struct id *first;
 183   struct id *last;
 184   int number;
 185 };
 186
 187 /* Enumeration giving which pass this is for scanning the program file.  */
 188
 189 enum pass {
 190   PASS_FIRST,                           /* without constructors */
 191   PASS_OBJ,                             /* individual objects */
 192   PASS_LIB,                             /* looking for shared libraries */
 193   PASS_SECOND                           /* with constructors linked in */
 194 };
 195
 196 #ifndef NO_SYS_SIGLIST
 197 #ifndef SYS_SIGLIST_DECLARED
 198 extern char *sys_siglist[];
 199 #endif
 200 #endif
 201 extern char *version_string;
 202
 203 int vflag;                              /* true if -v */
 204 static int rflag;                       /* true if -r */
 205 static int strip_flag;                  /* true if -s */
 206 #ifdef COLLECT_EXPORT_LIST
 207 static int export_flag;                 /* true if -bE */
 208 #endif
 209
 210 int debug;                              /* true if -debug */
 211
 212 static int shared_obj;                  /* true if -shared */
 213
 214 static int   temp_filename_length;      /* Length of temp_filename */
 215 static char *temp_filename;             /* Base of temp filenames */
 216 static char *c_file;                    /* <xxx>.c for constructor/destructor list.  */
 217 static char *o_file;                    /* <xxx>.o for constructor/destructor list.  */
 218 #ifdef COLLECT_EXPORT_LIST
 219 static char *export_file;               /* <xxx>.x for AIX export list.  */
 220 static char *import_file;               /* <xxx>.p for AIX import list.  */
 221 #endif
 222 char *ldout;                            /* File for ld errors.  */
 223 static char *output_file;               /* Output file for ld.  */
 224 static char *nm_file_name;              /* pathname of nm */
 225 #ifdef LDD_SUFFIX
 226 static char *ldd_file_name;             /* pathname of ldd (or equivalent) */
 227 #endif
 228 static char *strip_file_name;           /* pathname of strip */
 229 char *c_file_name;                      /* pathname of gcc */
 230 static char *initname, *fininame;       /* names of init and fini funcs */
 231
 232 static struct head constructors;        /* list of constructors found */
 233 static struct head destructors;         /* list of destructors found */
 234 #ifdef COLLECT_EXPORT_LIST
 235 static struct head exports;             /* list of exported symbols */
 236 static struct head imports;             /* list of imported symbols */
 237 static struct head undefined;           /* list of undefined symbols */
 238 #endif
 239 static struct head frame_tables;        /* list of frame unwind info tables */
 240
 241 struct obstack temporary_obstack;
 242 struct obstack permanent_obstack;
 243 char * temporary_firstobj;
 244
 245 /* Defined in the automatically-generated underscore.c.  */
 246 extern int prepends_underscore;
 247
 248 extern char *mktemp ();
 249 extern FILE *fdopen ();
 250
 251 #ifndef GET_ENVIRONMENT
 252 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ENV_VALUE = getenv (ENV_NAME)
 253 #endif
 254
 255 /* Structure to hold all the directories in which to search for files to
 256    execute.  */
 257
 258 struct prefix_list
 259 {
 260   char *prefix;               /* String to prepend to the path.  */
 261   struct prefix_list *next;   /* Next in linked list.  */
 262 };
 263
 264 struct path_prefix
 265 {
 266   struct prefix_list *plist;  /* List of prefixes to try */
 267   int max_len;                /* Max length of a prefix in PLIST */
 268   char *name;                 /* Name of this list (used in config stuff) */
 269 };
 270
 271 #ifdef COLLECT_EXPORT_LIST
 272 /* Lists to keep libraries to be scanned for global constructors/destructors. */
 273 static struct head libs;                    /* list of libraries */
 274 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
 275 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
 276 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
 277                                           &libpath_lib_dirs, NULL};
 278 static char *libexts[3] = {"a", "so", NULL};  /* possible library extentions */
 279 #endif
 280
 281 static void handler             PROTO((int));
 282 static int is_ctor_dtor         PROTO((char *));
 283 static char *find_a_file        PROTO((struct path_prefix *, char *));
 284 static void add_prefix          PROTO((struct path_prefix *, char *));
 285 static void prefix_from_env     PROTO((char *, struct path_prefix *));
 286 static void prefix_from_string  PROTO((char *, struct path_prefix *));
 287 static void do_wait             PROTO((char *));
 288 static void fork_execute        PROTO((char *, char **));
 289 static void maybe_unlink        PROTO((char *));
 290 static void add_to_list         PROTO((struct head *, char *));
 291 static void write_list          PROTO((FILE *, char *, struct id *));
 292 #ifdef COLLECT_EXPORT_LIST
 293 static void dump_list           PROTO((FILE *, char *, struct id *));
 294 #endif
 295 #if 0
 296 static void dump_prefix_list    PROTO((FILE *, char *, struct prefix_list *));
 297 #endif
 298 static void write_list_with_asm PROTO((FILE *, char *, struct id *));
 299 static void write_c_file        PROTO((FILE *, char *));
 300 static void scan_prog_file      PROTO((char *, enum pass));
 301 #ifdef SCAN_LIBRARIES
 302 static void scan_libraries      PROTO((char *));
 303 #endif
 304 #ifdef COLLECT_EXPORT_LIST
 305 static int is_in_list           PROTO((char *, struct id *));
 306 static void write_export_file   PROTO((FILE *));
 307 static void write_import_file   PROTO((FILE *));
 308 static char *resolve_lib_name   PROTO((char *));
 309 static int use_import_list      PROTO((char *));
 310 static int ignore_library       PROTO((char *));
 311 #endif
 312
 313 char *xcalloc ();
 314 char *xmalloc ();
 315
 316 \f
 317 #ifdef NO_DUP2
 318 int
 319 dup2 (oldfd, newfd)
 320      int oldfd;
 321      int newfd;
 322 {
 323   int fdtmp[256];
 324   int fdx = 0;
 325   int fd;
 326
 327   if (oldfd == newfd)
 328     return oldfd;
 329   close (newfd);
 330   while ((fd = dup (oldfd)) != newfd && fd >= 0) /* good enough for low fd's */
 331     fdtmp[fdx++] = fd;
 332   while (fdx > 0)
 333     close (fdtmp[--fdx]);
 334
 335   return fd;
 336 }
 337 #endif
 338
 339 char *
 340 my_strerror (e)
 341      int e;
 342 {
 343
 344 #ifdef HAVE_STRERROR
 345   return strerror (e);
 346
 347 #else
 348
 349   static char buffer[30];
 350   if (!e)
 351     return "";
 352
 353   if (e > 0 && e < sys_nerr)
 354     return sys_errlist[e];
 355
 356   sprintf (buffer, "Unknown error %d", e);
 357   return buffer;
 358 #endif
 359 }
 360 \f
 361 /* Delete tempfiles and exit function.  */
 362
 363 void
 364 collect_exit (status)
 365      int status;
 366 {
 367   if (c_file != 0 && c_file[0])
 368     maybe_unlink (c_file);
 369
 370   if (o_file != 0 && o_file[0])
 371     maybe_unlink (o_file);
 372
 373 #ifdef COLLECT_EXPORT_LIST
 374   if (export_file != 0 && export_file[0])
 375     maybe_unlink (export_file);
 376
 377   if (import_file != 0 && import_file[0])
 378     maybe_unlink (import_file);
 379 #endif
 380
 381   if (ldout != 0 && ldout[0])
 382     {
 383       dump_file (ldout);
 384       maybe_unlink (ldout);
 385     }
 386
 387   if (status != 0 && output_file != 0 && output_file[0])
 388     maybe_unlink (output_file);
 389
 390   exit (status);
 391 }
 392
 393 \f
 394 /* Die when sys call fails.  */
 395
 396 void
 397 fatal_perror (string, arg1, arg2, arg3)
 398      char *string, *arg1, *arg2, *arg3;
 399 {
 400   int e = errno;
 401
 402   fprintf (stderr, "collect2: ");
 403   fprintf (stderr, string, arg1, arg2, arg3);
 404   fprintf (stderr, ": %s\n", my_strerror (e));
 405   collect_exit (FATAL_EXIT_CODE);
 406 }
 407
 408 /* Just die.  */
 409
 410 void
 411 fatal (string, arg1, arg2, arg3)
 412      char *string, *arg1, *arg2, *arg3;
 413 {
 414   fprintf (stderr, "collect2: ");
 415   fprintf (stderr, string, arg1, arg2, arg3);
 416   fprintf (stderr, "\n");
 417   collect_exit (FATAL_EXIT_CODE);
 418 }
 419
 420 /* Write error message.  */
 421
 422 void
 423 error (string, arg1, arg2, arg3, arg4)
 424      char *string, *arg1, *arg2, *arg3, *arg4;
 425 {
 426   fprintf (stderr, "collect2: ");
 427   fprintf (stderr, string, arg1, arg2, arg3, arg4);
 428   fprintf (stderr, "\n");
 429 }
 430
 431 /* In case obstack is linked in, and abort is defined to fancy_abort,
 432    provide a default entry.  */
 433
 434 void
 435 fancy_abort ()
 436 {
 437   fatal ("internal error");
 438 }
 439
 440 \f
 441 static void
 442 handler (signo)
 443      int signo;
 444 {
 445   if (c_file != 0 && c_file[0])
 446     maybe_unlink (c_file);
 447
 448   if (o_file != 0 && o_file[0])
 449     maybe_unlink (o_file);
 450
 451   if (ldout != 0 && ldout[0])
 452     maybe_unlink (ldout);
 453
 454 #ifdef COLLECT_EXPORT_LIST
 455   if (export_file != 0 && export_file[0])
 456     maybe_unlink (export_file);
 457
 458   if (import_file != 0 && import_file[0])
 459     maybe_unlink (import_file);
 460 #endif
 461
 462   signal (signo, SIG_DFL);
 463   kill (getpid (), signo);
 464 }
 465
 466 \f
 467 char *
 468 xcalloc (size1, size2)
 469      int size1, size2;
 470 {
 471   char *ptr = (char *) calloc (size1, size2);
 472   if (ptr)
 473     return ptr;
 474
 475   fatal ("out of memory");
 476   return (char *) 0;
 477 }
 478
 479 char *
 480 xmalloc (size)
 481      unsigned size;
 482 {
 483   char *ptr = (char *) malloc (size);
 484   if (ptr)
 485     return ptr;
 486
 487   fatal ("out of memory");
 488   return (char *) 0;
 489 }
 490
 491 char *
 492 xrealloc (ptr, size)
 493      char *ptr;
 494      unsigned size;
 495 {
 496   register char *value = (char *) realloc (ptr, size);
 497   if (value == 0)
 498     fatal ("virtual memory exhausted");
 499   return value;
 500 }
 501
 502 int
 503 file_exists (name)
 504      char *name;
 505 {
 506   return access (name, R_OK) == 0;
 507 }
 508
 509 /* Make a copy of a string INPUT with size SIZE.  */
 510
 511 char *
 512 savestring (input, size)
 513      char *input;
 514      int size;
 515 {
 516   char *output = (char *) xmalloc (size + 1);
 517   bcopy (input, output, size);
 518   output[size] = 0;
 519   return output;
 520 }
 521
 522 /* Parse a reasonable subset of shell quoting syntax.  */
 523
 524 static char *
 525 extract_string (pp)
 526      char **pp;
 527 {
 528   char *p = *pp;
 529   int backquote = 0;
 530   int inside = 0;
 531
 532   for (;;)
 533     {
 534       char c = *p;
 535       if (c == '\0')
 536         break;
 537       ++p;
 538       if (backquote)
 539         obstack_1grow (&temporary_obstack, c);
 540       else if (! inside && c == ' ')
 541         break;
 542       else if (! inside && c == '\\')
 543         backquote = 1;
 544       else if (c == '\'')
 545         inside = !inside;
 546       else
 547         obstack_1grow (&temporary_obstack, c);
 548     }
 549
 550   obstack_1grow (&temporary_obstack, '\0');
 551   *pp = p;
 552   return obstack_finish (&temporary_obstack);
 553 }
 554 \f
 555 void
 556 dump_file (name)
 557      char *name;
 558 {
 559   FILE *stream = fopen (name, "r");
 560   int no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");
 561
 562   if (stream == 0)
 563     return;
 564   while (1)
 565     {
 566       int c;
 567       while (c = getc (stream),
 568              c != EOF && (ISALNUM (c) || c == '_' || c == '$' || c == '.'))
 569         obstack_1grow (&temporary_obstack, c);
 570       if (obstack_object_size (&temporary_obstack) > 0)
 571         {
 572           char *word, *p, *result;
 573           obstack_1grow (&temporary_obstack, '\0');
 574           word = obstack_finish (&temporary_obstack);
 575
 576           if (*word == '.')
 577             ++word, putc ('.', stderr);
 578           p = word;
 579           if (*p == '_' && prepends_underscore)
 580             ++p;
 581
 582           if (no_demangle)
 583             result = 0;
 584           else
 585             result = cplus_demangle (p, DMGL_PARAMS | DMGL_ANSI);
 586
 587           if (result)
 588             {
 589               int diff;
 590               fputs (result, stderr);
 591
 592               diff = strlen (word) - strlen (result);
 593               while (diff > 0)
 594                 --diff, putc (' ', stderr);
 595               while (diff < 0 && c == ' ')
 596                 ++diff, c = getc (stream);
 597
 598               free (result);
 599             }
 600           else
 601             fputs (word, stderr);
 602
 603           fflush (stderr);
 604           obstack_free (&temporary_obstack, temporary_firstobj);
 605         }
 606       if (c == EOF)
 607         break;
 608       putc (c, stderr);
 609     }
 610   fclose (stream);
 611 }
 612 \f
 613 /* Decide whether the given symbol is:
 614    a constructor (1), a destructor (2), or neither (0).  */
 615
 616 static int
 617 is_ctor_dtor (s)
 618      char *s;
 619 {
 620   struct names { char *name; int len; int ret; int two_underscores; };
 621
 622   register struct names *p;
 623   register int ch;
 624   register char *orig_s = s;
 625
 626   static struct names special[] = {
 627 #ifdef NO_DOLLAR_IN_LABEL
 628 #ifdef NO_DOT_IN_LABEL
 629     { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
 630     { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
 631     { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, 5, 0 },
 632 #else
 633     { "GLOBAL_.I.", sizeof ("GLOBAL_.I.")-1, 1, 0 },
 634     { "GLOBAL_.D.", sizeof ("GLOBAL_.D.")-1, 2, 0 },
 635     { "GLOBAL_.F.", sizeof ("GLOBAL_.F.")-1, 5, 0 },
 636 #endif
 637 #else
 638     { "GLOBAL_$I$", sizeof ("GLOBAL_$I$")-1, 1, 0 },
 639     { "GLOBAL_$D$", sizeof ("GLOBAL_$D$")-1, 2, 0 },
 640     { "GLOBAL_$F$", sizeof ("GLOBAL_$F$")-1, 5, 0 },
 641 #endif
 642     { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
 643     { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
 644 #ifdef CFRONT_LOSSAGE /* Do not collect cfront initialization functions.
 645                          cfront has its own linker procedure to collect them;
 646                          if collect2 gets them too, they get collected twice
 647                          when the cfront procedure is run and the compiler used
 648                          for linking happens to be GCC.  */
 649     { "sti__", sizeof ("sti__")-1, 1, 1 },
 650     { "std__", sizeof ("std__")-1, 2, 1 },
 651 #endif /* CFRONT_LOSSAGE */
 652     { NULL, 0, 0, 0 }
 653   };
 654
 655   while ((ch = *s) == '_')
 656     ++s;
 657
 658   if (s == orig_s)
 659     return 0;
 660
 661   for (p = &special[0]; p->len > 0; p++)
 662     {
 663       if (ch == p->name[0]
 664           && (!p->two_underscores || ((s - orig_s) >= 2))
 665           && strncmp(s, p->name, p->len) == 0)
 666         {
 667           return p->ret;
 668         }
 669     }
 670   return 0;
 671 }
 672 \f
 673 /* Routine to add variables to the environment.  */
 674
 675 #ifndef HAVE_PUTENV
 676
 677 int
 678 putenv (str)
 679      char *str;
 680 {
 681 #ifndef VMS                     /* nor about VMS */
 682
 683   extern char **environ;
 684   char **old_environ = environ;
 685   char **envp;
 686   int num_envs = 0;
 687   int name_len = 1;
 688   char *p = str;
 689   int ch;
 690
 691   while ((ch = *p++) != '\0' && ch != '=')
 692     name_len++;
 693
 694   if (!ch)
 695     abort ();
 696
 697   /* Search for replacing an existing environment variable, and
 698      count the number of total environment variables.  */
 699   for (envp = old_environ; *envp; envp++)
 700     {
 701       num_envs++;
 702       if (!strncmp (str, *envp, name_len))
 703         {
 704           *envp = str;
 705           return 0;
 706         }
 707     }
 708
 709   /* Add a new environment variable */
 710   environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
 711   *environ = str;
 712   bcopy ((char *) old_environ, (char *) (environ + 1),
 713          sizeof (char *) * (num_envs+1));
 714
 715   return 0;
 716 #endif  /* VMS */
 717 }
 718
 719 #endif  /* HAVE_PUTENV */
 720 \f
 721 /* By default, colon separates directories in a path.  */
 722 #ifndef PATH_SEPARATOR
 723 #define PATH_SEPARATOR ':'
 724 #endif
 725
 726 /* We maintain two prefix lists: one from COMPILER_PATH environment variable
 727    and one from the PATH variable.  */
 728
 729 static struct path_prefix cpath, path;
 730
 731 #ifdef CROSS_COMPILE
 732 /* This is the name of the target machine.  We use it to form the name
 733    of the files to execute.  */
 734
 735 static char *target_machine = TARGET_MACHINE;
 736 #endif
 737
 738 /* Search for NAME using prefix list PPREFIX.  We only look for executable
 739    files.
 740
 741    Return 0 if not found, otherwise return its name, allocated with malloc.  */
 742
 743 static char *
 744 find_a_file (pprefix, name)
 745      struct path_prefix *pprefix;
 746      char *name;
 747 {
 748   char *temp;
 749   struct prefix_list *pl;
 750   int len = pprefix->max_len + strlen (name) + 1;
 751
 752   if (debug)
 753     fprintf (stderr, "Looking for '%s'\n", name);
 754
 755 #ifdef EXECUTABLE_SUFFIX
 756   len += strlen (EXECUTABLE_SUFFIX);
 757 #endif
 758
 759   temp = xmalloc (len);
 760
 761   /* Determine the filename to execute (special case for absolute paths).  */
 762
 763   if (*name == '/'
 764 #ifdef DIR_SEPARATOR
 765       || (DIR_SEPARATOR == '\\' && name[1] == ':'
 766       && (name[2] == DIR_SEPARATOR || name[2] == '/'))
 767 #endif
 768       )
 769     {
 770       if (access (name, X_OK) == 0)
 771         {
 772           strcpy (temp, name);
 773
 774           if (debug)
 775             fprintf (stderr, "  - found: absolute path\n");
 776
 777           return temp;
 778         }
 779
 780       if (debug)
 781         fprintf (stderr, "  - failed to locate using absolute path\n");
 782     }
 783   else
 784     for (pl = pprefix->plist; pl; pl = pl->next)
 785       {
 786         strcpy (temp, pl->prefix);
 787         strcat (temp, name);
 788
 789         if (access (temp, X_OK) == 0)
 790           return temp;
 791
 792 #ifdef EXECUTABLE_SUFFIX
 793         /* Some systems have a suffix for executable files.
 794            So try appending that.  */
 795         strcat (temp, EXECUTABLE_SUFFIX);
 796
 797         if (access (temp, X_OK) == 0)
 798           return temp;
 799 #endif
 800       }
 801
 802   if (debug && pprefix->plist == NULL)
 803     fprintf (stderr, "  - failed: no entries in prefix list\n");
 804
 805   free (temp);
 806   return 0;
 807 }
 808
 809 /* Add an entry for PREFIX to prefix list PPREFIX.  */
 810
 811 static void
 812 add_prefix (pprefix, prefix)
 813      struct path_prefix *pprefix;
 814      char *prefix;
 815 {
 816   struct prefix_list *pl, **prev;
 817   int len;
 818
 819   if (pprefix->plist)
 820     {
 821       for (pl = pprefix->plist; pl->next; pl = pl->next)
 822         ;
 823       prev = &pl->next;
 824     }
 825   else
 826     prev = &pprefix->plist;
 827
 828   /* Keep track of the longest prefix */
 829
 830   len = strlen (prefix);
 831   if (len > pprefix->max_len)
 832     pprefix->max_len = len;
 833
 834   pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
 835   pl->prefix = savestring (prefix, len);
 836
 837   if (*prev)
 838     pl->next = *prev;
 839   else
 840     pl->next = (struct prefix_list *) 0;
 841   *prev = pl;
 842 }
 843 \f
 844 /* Take the value of the environment variable ENV, break it into a path, and
 845    add of the entries to PPREFIX.  */
 846
 847 static void
 848 prefix_from_env (env, pprefix)
 849      char *env;
 850      struct path_prefix *pprefix;
 851 {
 852   char *p;
 853   GET_ENVIRONMENT (p, env);
 854
 855   if (p)
 856     prefix_from_string (p, pprefix);
 857 }
 858
 859 static void
 860 prefix_from_string (p, pprefix)
 861      char *p;
 862      struct path_prefix *pprefix;
 863 {
 864   char *startp, *endp;
 865   char *nstore = (char *) xmalloc (strlen (p) + 3);
 866
 867   if (debug)
 868     fprintf (stderr, "Convert string '%s' into prefixes, separator = '%c'\n", p, PATH_SEPARATOR);
 869
 870   startp = endp = p;
 871   while (1)
 872     {
 873       if (*endp == PATH_SEPARATOR || *endp == 0)
 874         {
 875           strncpy (nstore, startp, endp-startp);
 876           if (endp == startp)
 877             {
 878               strcpy (nstore, "./");
 879             }
 880           else if (endp[-1] != '/')
 881             {
 882               nstore[endp-startp] = '/';
 883               nstore[endp-startp+1] = 0;
 884             }
 885           else
 886             nstore[endp-startp] = 0;
 887
 888           if (debug)
 889             fprintf (stderr, "  - add prefix: %s\n", nstore);
 890
 891           add_prefix (pprefix, nstore);
 892           if (*endp == 0)
 893             break;
 894           endp = startp = endp + 1;
 895         }
 896       else
 897         endp++;
 898     }
 899 }
 900 \f
 901 /* Main program.  */
 902
 903 int
 904 main (argc, argv)
 905      int argc;
 906      char *argv[];
 907 {
 908   char *ld_suffix       = "ld";
 909   char *full_ld_suffix  = ld_suffix;
 910   char *real_ld_suffix  = "real-ld";
 911   char *collect_ld_suffix = "collect-ld";
 912   char *nm_suffix       = "nm";
 913   char *full_nm_suffix  = nm_suffix;
 914   char *gnm_suffix      = "gnm";
 915   char *full_gnm_suffix = gnm_suffix;
 916 #ifdef LDD_SUFFIX
 917   char *ldd_suffix      = LDD_SUFFIX;
 918   char *full_ldd_suffix = ldd_suffix;
 919 #endif
 920   char *strip_suffix    = "strip";
 921   char *full_strip_suffix = strip_suffix;
 922   char *gstrip_suffix   = "gstrip";
 923   char *full_gstrip_suffix = gstrip_suffix;
 924   char *arg;
 925   FILE *outf;
 926 #ifdef COLLECT_EXPORT_LIST
 927   FILE *exportf;
 928   FILE *importf;
 929 #endif
 930   char *ld_file_name;
 931   char *p;
 932   char **c_argv;
 933   char **c_ptr;
 934   char **ld1_argv       = (char **) xcalloc (sizeof (char *), argc+3);
 935   char **ld1            = ld1_argv;
 936   char **ld2_argv       = (char **) xcalloc (sizeof (char *), argc+6);
 937   char **ld2            = ld2_argv;
 938   char **object_lst     = (char **) xcalloc (sizeof (char *), argc);
 939   char **object         = object_lst;
 940   int first_file;
 941   int num_c_args        = argc+7;
 942
 943 #ifdef DEBUG
 944   debug = 1;
 945 #endif
 946
 947   /* Parse command line early for instances of -debug.  This allows
 948      the debug flag to be set before functions like find_a_file()
 949      are called.  */
 950   {
 951     int i;
 952
 953     for (i = 1; argv[i] != NULL; i ++)
 954       if (! strcmp (argv[i], "-debug"))
 955         debug = 1;
 956     vflag = debug;
 957   }
 958
 959 #ifndef DEFAULT_A_OUT_NAME
 960   output_file = "a.out";
 961 #else
 962   output_file = DEFAULT_A_OUT_NAME;
 963 #endif
 964
 965   obstack_begin (&temporary_obstack, 0);
 966   obstack_begin (&permanent_obstack, 0);
 967   temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
 968
 969   current_demangling_style = gnu_demangling;
 970   p = getenv ("COLLECT_GCC_OPTIONS");
 971   while (p && *p)
 972     {
 973       char *q = extract_string (&p);
 974       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
 975         num_c_args++;
 976     }
 977   obstack_free (&temporary_obstack, temporary_firstobj);
 978   ++num_c_args;
 979
 980   c_ptr = c_argv = (char **) xcalloc (sizeof (char *), num_c_args);
 981
 982   if (argc < 2)
 983     fatal ("no arguments");
 984
 985 #ifdef SIGQUIT
 986   if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
 987     signal (SIGQUIT, handler);
 988 #endif
 989   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
 990     signal (SIGINT, handler);
 991 #ifdef SIGALRM
 992   if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
 993     signal (SIGALRM, handler);
 994 #endif
 995 #ifdef SIGHUP
 996   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
 997     signal (SIGHUP, handler);
 998 #endif
 999   if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
1000     signal (SIGSEGV, handler);
1001 #ifdef SIGBUS
1002   if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
1003     signal (SIGBUS, handler);
1004 #endif
1005
1006   /* Extract COMPILER_PATH and PATH into our prefix list.  */
1007   prefix_from_env ("COMPILER_PATH", &cpath);
1008   prefix_from_env ("PATH", &path);
1009
1010 #ifdef CROSS_COMPILE
1011   /* If we look for a program in the compiler directories, we just use
1012      the short name, since these directories are already system-specific.
1013      But it we look for a program in the system directories, we need to
1014      qualify the program name with the target machine.  */
1015
1016   full_ld_suffix
1017     = xcalloc (strlen (ld_suffix) + strlen (target_machine) + 2, 1);
1018   strcpy (full_ld_suffix, target_machine);
1019   strcat (full_ld_suffix, "-");
1020   strcat (full_ld_suffix, ld_suffix);
1021
1022 #if 0
1023   full_gld_suffix
1024     = xcalloc (strlen (gld_suffix) + strlen (target_machine) + 2, 1);
1025   strcpy (full_gld_suffix, target_machine);
1026   strcat (full_gld_suffix, "-");
1027   strcat (full_gld_suffix, gld_suffix);
1028 #endif
1029
1030   full_nm_suffix
1031     = xcalloc (strlen (nm_suffix) + strlen (target_machine) + 2, 1);
1032   strcpy (full_nm_suffix, target_machine);
1033   strcat (full_nm_suffix, "-");
1034   strcat (full_nm_suffix, nm_suffix);
1035
1036   full_gnm_suffix
1037     = xcalloc (strlen (gnm_suffix) + strlen (target_machine) + 2, 1);
1038   strcpy (full_gnm_suffix, target_machine);
1039   strcat (full_gnm_suffix, "-");
1040   strcat (full_gnm_suffix, gnm_suffix);
1041
1042 #ifdef LDD_SUFFIX
1043   full_ldd_suffix
1044     = xcalloc (strlen (ldd_suffix) + strlen (target_machine) + 2, 1);
1045   strcpy (full_ldd_suffix, target_machine);
1046   strcat (full_ldd_suffix, "-");
1047   strcat (full_ldd_suffix, ldd_suffix);
1048 #endif
1049
1050   full_strip_suffix
1051     = xcalloc (strlen (strip_suffix) + strlen (target_machine) + 2, 1);
1052   strcpy (full_strip_suffix, target_machine);
1053   strcat (full_strip_suffix, "-");
1054   strcat (full_strip_suffix, strip_suffix);
1055
1056   full_gstrip_suffix
1057     = xcalloc (strlen (gstrip_suffix) + strlen (target_machine) + 2, 1);
1058   strcpy (full_gstrip_suffix, target_machine);
1059   strcat (full_gstrip_suffix, "-");
1060   strcat (full_gstrip_suffix, gstrip_suffix);
1061 #endif /* CROSS_COMPILE */
1062
1063   /* Try to discover a valid linker/nm/strip to use.  */
1064
1065   /* Maybe we know the right file to use (if not cross).  */
1066 #ifdef REAL_LD_FILE_NAME
1067   ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
1068   if (ld_file_name == 0)
1069 #endif
1070   /* Search the (target-specific) compiler dirs for ld'.  */
1071   ld_file_name = find_a_file (&cpath, real_ld_suffix);
1072   /* Likewise for `collect-ld'.  */
1073   if (ld_file_name == 0)
1074     ld_file_name = find_a_file (&cpath, collect_ld_suffix);
1075   /* Search the compiler directories for `ld'.  We have protection against
1076      recursive calls in find_a_file.  */
1077   if (ld_file_name == 0)
1078     ld_file_name = find_a_file (&cpath, ld_suffix);
1079   /* Search the ordinary system bin directories
1080      for `ld' (if native linking) or `TARGET-ld' (if cross).  */
1081   if (ld_file_name == 0)
1082     ld_file_name = find_a_file (&path, full_ld_suffix);
1083
1084 #ifdef REAL_NM_FILE_NAME
1085   nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
1086   if (nm_file_name == 0)
1087 #endif
1088   nm_file_name = find_a_file (&cpath, gnm_suffix);
1089   if (nm_file_name == 0)
1090     nm_file_name = find_a_file (&path, full_gnm_suffix);
1091   if (nm_file_name == 0)
1092     nm_file_name = find_a_file (&cpath, nm_suffix);
1093   if (nm_file_name == 0)
1094     nm_file_name = find_a_file (&path, full_nm_suffix);
1095
1096 #ifdef LDD_SUFFIX
1097   ldd_file_name = find_a_file (&cpath, ldd_suffix);
1098   if (ldd_file_name == 0)
1099     ldd_file_name = find_a_file (&path, full_ldd_suffix);
1100 #endif
1101
1102 #ifdef REAL_STRIP_FILE_NAME
1103   strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
1104   if (strip_file_name == 0)
1105 #endif
1106   strip_file_name = find_a_file (&cpath, gstrip_suffix);
1107   if (strip_file_name == 0)
1108     strip_file_name = find_a_file (&path, full_gstrip_suffix);
1109   if (strip_file_name == 0)
1110     strip_file_name = find_a_file (&cpath, strip_suffix);
1111   if (strip_file_name == 0)
1112     strip_file_name = find_a_file (&path, full_strip_suffix);
1113
1114   /* Determine the full path name of the C compiler to use.  */
1115   c_file_name = getenv ("COLLECT_GCC");
1116   if (c_file_name == 0)
1117     {
1118 #ifdef CROSS_COMPILE
1119       c_file_name = xcalloc (sizeof ("gcc-") + strlen (target_machine) + 1, 1);
1120       strcpy (c_file_name, target_machine);
1121       strcat (c_file_name, "-gcc");
1122 #else
1123       c_file_name = "gcc";
1124 #endif
1125     }
1126
1127   p = find_a_file (&cpath, c_file_name);
1128
1129   /* Here it should be safe to use the system search path since we should have
1130      already qualified the name of the compiler when it is needed.  */
1131   if (p == 0)
1132     p = find_a_file (&path, c_file_name);
1133
1134   if (p)
1135     c_file_name = p;
1136
1137   *ld1++ = *ld2++ = ld_file_name;
1138
1139   /* Make temp file names.  */
1140   temp_filename = choose_temp_base ();
1141   temp_filename_length = strlen (temp_filename);
1142   c_file = xcalloc (temp_filename_length + sizeof (".c"), 1);
1143   o_file = xcalloc (temp_filename_length + sizeof (".o"), 1);
1144 #ifdef COLLECT_EXPORT_LIST
1145   export_file = xmalloc (temp_filename_length + sizeof (".x"));
1146   import_file = xmalloc (temp_filename_length + sizeof (".p"));
1147 #endif
1148   ldout = xmalloc (temp_filename_length + sizeof (".ld"));
1149   sprintf (ldout, "%s.ld", temp_filename);
1150   sprintf (c_file, "%s.c", temp_filename);
1151   sprintf (o_file, "%s.o", temp_filename);
1152 #ifdef COLLECT_EXPORT_LIST
1153   sprintf (export_file, "%s.x", temp_filename);
1154   sprintf (import_file, "%s.p", temp_filename);
1155 #endif
1156   *c_ptr++ = c_file_name;
1157   *c_ptr++ = "-c";
1158   *c_ptr++ = "-o";
1159   *c_ptr++ = o_file;
1160
1161 #ifdef COLLECT_EXPORT_LIST
1162   /* Generate a list of directories from LIBPATH.  */
1163   prefix_from_env ("LIBPATH", &libpath_lib_dirs);
1164   /* Add to this list also two standard directories where
1165      AIX loader always searches for libraries.  */
1166   add_prefix (&libpath_lib_dirs, "/lib");
1167   add_prefix (&libpath_lib_dirs, "/usr/lib");
1168 #endif
1169
1170   /* Get any options that the upper GCC wants to pass to the sub-GCC.
1171
1172      AIX support needs to know if -shared has been specified before
1173      parsing commandline arguments.  */
1174
1175   p = getenv ("COLLECT_GCC_OPTIONS");
1176   while (p && *p)
1177     {
1178       char *q = extract_string (&p);
1179       if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
1180         *c_ptr++ = obstack_copy0 (&permanent_obstack, q, strlen (q));
1181       if (strncmp (q, "-shared", sizeof ("-shared") - 1) == 0)
1182         shared_obj = 1;
1183     }
1184   obstack_free (&temporary_obstack, temporary_firstobj);
1185   *c_ptr++ = "-fno-exceptions";
1186
1187   /* !!! When GCC calls collect2,
1188      it does not know whether it is calling collect2 or ld.
1189      So collect2 cannot meaningfully understand any options
1190      except those ld understands.
1191      If you propose to make GCC pass some other option,
1192      just imagine what will happen if ld is really ld!!!  */
1193
1194   /* Parse arguments.  Remember output file spec, pass the rest to ld.  */
1195   /* After the first file, put in the c++ rt0.  */
1196
1197   first_file = 1;
1198   while ((arg = *++argv) != (char *) 0)
1199     {
1200       *ld1++ = *ld2++ = arg;
1201
1202       if (arg[0] == '-')
1203         {
1204           switch (arg[1])
1205             {
1206 #ifdef COLLECT_EXPORT_LIST
1207             /* We want to disable automatic exports on AIX when user
1208                explicitly puts an export list in command line */
1209             case 'b':
1210               if (arg[2] == 'E' || strncmp (&arg[2], "export", 6) == 0)
1211                 export_flag = 1;
1212               break;
1213 #endif
1214
1215             case 'd':
1216               if (!strcmp (arg, "-debug"))
1217                 {
1218                   /* Already parsed.  */
1219                   ld1--;
1220                   ld2--;
1221                 }
1222               break;
1223
1224             case 'l':
1225               if (first_file)
1226                 {
1227                   /* place o_file BEFORE this argument! */
1228                   first_file = 0;
1229                   ld2--;
1230                   *ld2++ = o_file;
1231                   *ld2++ = arg;
1232                 }
1233 #ifdef COLLECT_EXPORT_LIST
1234               {
1235                 /* Resolving full library name.  */
1236                 char *s = resolve_lib_name (arg+2);
1237
1238                 /* If we will use an import list for this library,
1239                    we should exclude it from ld args.  */
1240                 if (use_import_list (s))
1241                   {
1242                     ld1--;
1243                     ld2--;
1244                   }
1245
1246                 /* Saving a full library name.  */
1247                 add_to_list (&libs, s);
1248               }
1249 #endif
1250               break;
1251
1252 #ifdef COLLECT_EXPORT_LIST
1253             /* Saving directories where to search for libraries.  */
1254             case 'L':
1255               add_prefix (&cmdline_lib_dirs, arg+2);
1256               break;
1257 #endif
1258
1259             case 'o':
1260               if (arg[2] == '\0')
1261                 output_file = *ld1++ = *ld2++ = *++argv;
1262               else
1263                 output_file = &arg[2];
1264               break;
1265
1266             case 'r':
1267               if (arg[2] == '\0')
1268                 rflag = 1;
1269               break;
1270
1271             case 's':
1272               if (arg[2] == '\0' && do_collecting)
1273                 {
1274                   /* We must strip after the nm run, otherwise C++ linking
1275                      will not work.  Thus we strip in the second ld run, or
1276                      else with strip if there is no second ld run.  */
1277                   strip_flag = 1;
1278                   ld1--;
1279                 }
1280               break;
1281
1282             case 'v':
1283               if (arg[2] == '\0')
1284                 vflag = 1;
1285               break;
1286             }
1287         }
1288       else if ((p = rindex (arg, '.')) != (char *) 0
1289                && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
1290                    || strcmp (p, ".so") == 0))
1291         {
1292           if (first_file)
1293             {
1294               first_file = 0;
1295               if (p[1] == 'o')
1296                 *ld2++ = o_file;
1297               else
1298                 {
1299                   /* place o_file BEFORE this argument! */
1300                   ld2--;
1301                   *ld2++ = o_file;
1302                   *ld2++ = arg;
1303                 }
1304             }
1305           if (p[1] == 'o')
1306             *object++ = arg;
1307 #ifdef COLLECT_EXPORT_LIST
1308           /* libraries can be specified directly, i.e. without -l flag.  */
1309           else
1310             {
1311               /* If we will use an import list for this library,
1312                  we should exclude it from ld args.  */
1313               if (use_import_list (arg))
1314                 {
1315                   ld1--;
1316                   ld2--;
1317                 }
1318
1319               /* Saving a full library name.  */
1320               add_to_list (&libs, arg);
1321             }
1322 #endif
1323         }
1324     }
1325
1326 #ifdef COLLECT_EXPORT_LIST
1327   /* This is added only for debugging purposes.  */
1328   if (debug)
1329     {
1330       fprintf (stderr, "List of libraries:\n");
1331       dump_list (stderr, "\t", libs.first);
1332     }
1333
1334   /* The AIX linker will discard static constructors in object files if
1335      nothing else in the file is referenced, so look at them first.  */
1336   {
1337       char **export_object_lst = object_lst;
1338       while (export_object_lst < object)
1339         scan_prog_file (*export_object_lst++, PASS_OBJ);
1340   }
1341   {
1342     struct id *list = libs.first;
1343     for (; list; list = list->next)
1344       scan_prog_file (list->name, PASS_FIRST);
1345   }
1346   {
1347     char *buf1 = alloca (strlen (export_file) + 5);
1348     char *buf2 = alloca (strlen (import_file) + 5);
1349     sprintf (buf1, "-bE:%s", export_file);
1350     sprintf (buf2, "-bI:%s", import_file);
1351     *ld1++ = buf1;
1352     *ld2++ = buf1;
1353     *ld1++ = buf2;
1354     *ld2++ = buf2;
1355     exportf = fopen (export_file, "w");
1356     if (exportf == (FILE *) 0)
1357       fatal_perror ("%s", export_file);
1358     write_export_file (exportf);
1359     if (fclose (exportf))
1360       fatal_perror ("closing %s", export_file);
1361     importf = fopen (import_file, "w");
1362     if (importf == (FILE *) 0)
1363       fatal_perror ("%s", import_file);
1364     write_import_file (importf);
1365     if (fclose (importf))
1366       fatal_perror ("closing %s", import_file);
1367   }
1368 #endif
1369
1370   *c_ptr++ = c_file;
1371   *object = *c_ptr = *ld1 = (char *) 0;
1372
1373   if (vflag)
1374     {
1375       fprintf (stderr, "collect2 version %s", version_string);
1376 #ifdef TARGET_VERSION
1377       TARGET_VERSION;
1378 #endif
1379       fprintf (stderr, "\n");
1380     }
1381
1382   if (debug)
1383     {
1384       char *ptr;
1385       fprintf (stderr, "ld_file_name        = %s\n",
1386                (ld_file_name ? ld_file_name : "not found"));
1387       fprintf (stderr, "c_file_name         = %s\n",
1388                (c_file_name ? c_file_name : "not found"));
1389       fprintf (stderr, "nm_file_name        = %s\n",
1390                (nm_file_name ? nm_file_name : "not found"));
1391 #ifdef LDD_SUFFIX
1392       fprintf (stderr, "ldd_file_name       = %s\n",
1393                (ldd_file_name ? ldd_file_name : "not found"));
1394 #endif
1395       fprintf (stderr, "strip_file_name     = %s\n",
1396                (strip_file_name ? strip_file_name : "not found"));
1397       fprintf (stderr, "c_file              = %s\n",
1398                (c_file ? c_file : "not found"));
1399       fprintf (stderr, "o_file              = %s\n",
1400                (o_file ? o_file : "not found"));
1401
1402       ptr = getenv ("COLLECT_GCC_OPTIONS");
1403       if (ptr)
1404         fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
1405
1406       ptr = getenv ("COLLECT_GCC");
1407       if (ptr)
1408         fprintf (stderr, "COLLECT_GCC         = %s\n", ptr);
1409
1410       ptr = getenv ("COMPILER_PATH");
1411       if (ptr)
1412         fprintf (stderr, "COMPILER_PATH       = %s\n", ptr);
1413
1414       ptr = getenv ("LIBRARY_PATH");
1415       if (ptr)
1416         fprintf (stderr, "LIBRARY_PATH        = %s\n", ptr);
1417
1418       fprintf (stderr, "\n");
1419     }
1420
1421   /* Load the program, searching all libraries and attempting to provide
1422      undefined symbols from repository information.  */
1423
1424   /* On AIX we do this later.  */
1425 #ifndef COLLECT_EXPORT_LIST
1426   do_tlink (ld1_argv, object_lst);
1427 #endif
1428
1429   /* If -r or they will be run via some other method, do not build the
1430      constructor or destructor list, just return now.  */
1431   if (rflag
1432 #ifndef COLLECT_EXPORT_LIST
1433       || ! do_collecting
1434 #endif
1435       )
1436     {
1437 #ifdef COLLECT_EXPORT_LIST
1438       /* But make sure we delete the export file we may have created.  */
1439       if (export_file != 0 && export_file[0])
1440         maybe_unlink (export_file);
1441       if (import_file != 0 && import_file[0])
1442         maybe_unlink (import_file);
1443 #endif
1444       return 0;
1445     }
1446
1447   /* Examine the namelist with nm and search it for static constructors
1448      and destructors to call.
1449      Write the constructor and destructor tables to a .s file and reload.  */
1450
1451   /* On AIX we already done scanning for global constructors/destructors.  */
1452 #ifndef COLLECT_EXPORT_LIST
1453   scan_prog_file (output_file, PASS_FIRST);
1454 #endif
1455
1456 #ifdef SCAN_LIBRARIES
1457   scan_libraries (output_file);
1458 #endif
1459
1460   if (debug)
1461     {
1462       fprintf (stderr, "%d constructor(s) found\n", constructors.number);
1463       fprintf (stderr, "%d destructor(s)  found\n", destructors.number);
1464     }
1465
1466   if (constructors.number == 0 && destructors.number == 0
1467       && frame_tables.number == 0
1468 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1469       /* If we will be running these functions ourselves, we want to emit
1470          stubs into the shared library so that we do not have to relink
1471          dependent programs when we add static objects.  */
1472       && ! shared_obj
1473 #endif
1474       )
1475     {
1476 #ifdef COLLECT_EXPORT_LIST
1477       /* Doing tlink without additional code generation */
1478       do_tlink (ld1_argv, object_lst);
1479 #endif
1480       /* Strip now if it was requested on the command line.  */
1481       if (strip_flag)
1482         {
1483           char **strip_argv = (char **) xcalloc (sizeof (char *), 3);
1484           strip_argv[0] = strip_file_name;
1485           strip_argv[1] = output_file;
1486           strip_argv[2] = (char *) 0;
1487           fork_execute ("strip", strip_argv);
1488         }
1489
1490 #ifdef COLLECT_EXPORT_LIST
1491       maybe_unlink (export_file);
1492       maybe_unlink (import_file);
1493 #endif
1494       return 0;
1495     }
1496
1497   maybe_unlink(output_file);
1498   outf = fopen (c_file, "w");
1499   if (outf == (FILE *) 0)
1500     fatal_perror ("%s", c_file);
1501
1502   write_c_file (outf, c_file);
1503
1504   if (fclose (outf))
1505     fatal_perror ("closing %s", c_file);
1506
1507   /* Tell the linker that we have initializer and finalizer functions.  */
1508 #ifdef LD_INIT_SWITCH
1509   *ld2++ = LD_INIT_SWITCH;
1510   *ld2++ = initname;
1511   *ld2++ = LD_FINI_SWITCH;
1512   *ld2++ = fininame;
1513 #endif
1514   *ld2 = (char*) 0;
1515
1516 #ifdef COLLECT_EXPORT_LIST
1517   if (shared_obj)
1518     {
1519       add_to_list (&exports, initname);
1520       add_to_list (&exports, fininame);
1521       add_to_list (&exports, "_GLOBAL__DI");
1522       add_to_list (&exports, "_GLOBAL__DD");
1523       exportf = fopen (export_file, "w");
1524       if (exportf == (FILE *) 0)
1525         fatal_perror ("%s", export_file);
1526       write_export_file (exportf);
1527       if (fclose (exportf))
1528         fatal_perror ("closing %s", export_file);
1529     }
1530 #endif
1531
1532   if (debug)
1533     {
1534       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1535                output_file, c_file);
1536       write_c_file (stderr, "stderr");
1537       fprintf (stderr, "========== end of c_file\n\n");
1538 #ifdef COLLECT_EXPORT_LIST
1539       fprintf (stderr, "\n========== export_file = %s\n", export_file);
1540       write_export_file (stderr);
1541       fprintf (stderr, "========== end of export_file\n\n");
1542 #endif
1543     }
1544
1545   /* Assemble the constructor and destructor tables.
1546      Link the tables in with the rest of the program.  */
1547
1548   fork_execute ("gcc",  c_argv);
1549 #ifdef COLLECT_EXPORT_LIST
1550   /* On AIX we must call tlink because of possible templates resolution */
1551   do_tlink (ld2_argv, object_lst);
1552 #else
1553   /* Otherwise, simply call ld because tlink is already done */
1554   fork_execute ("ld", ld2_argv);
1555
1556   /* Let scan_prog_file do any final mods (OSF/rose needs this for
1557      constructors/destructors in shared libraries.  */
1558   scan_prog_file (output_file, PASS_SECOND);
1559 #endif
1560
1561   maybe_unlink (c_file);
1562   maybe_unlink (o_file);
1563
1564 #ifdef COLLECT_EXPORT_LIST
1565   maybe_unlink (export_file);
1566   maybe_unlink (import_file);
1567 #endif
1568
1569   return 0;
1570 }
1571
1572 \f
1573 /* Wait for a process to finish, and exit if a non-zero status is found.  */
1574
1575 int
1576 collect_wait (prog)
1577      char *prog;
1578 {
1579   int status;
1580
1581   wait (&status);
1582   if (status)
1583     {
1584       if (WIFSIGNALED (status))
1585         {
1586           int sig = WTERMSIG (status);
1587 #ifdef NO_SYS_SIGLIST
1588           error ("%s terminated with signal %d %s",
1589                  prog,
1590                  sig,
1591                  (status & 0200) ? ", core dumped" : "");
1592 #else
1593           error ("%s terminated with signal %d [%s]%s",
1594                  prog,
1595                  sig,
1596                  sys_siglist[sig],
1597                  (status & 0200) ? ", core dumped" : "");
1598 #endif
1599
1600           collect_exit (FATAL_EXIT_CODE);
1601         }
1602
1603       if (WIFEXITED (status))
1604         return WEXITSTATUS (status);
1605     }
1606   return 0;
1607 }
1608
1609 static void
1610 do_wait (prog)
1611      char *prog;
1612 {
1613   int ret = collect_wait (prog);
1614   if (ret != 0)
1615     {
1616       error ("%s returned %d exit status", prog, ret);
1617       collect_exit (ret);
1618     }
1619 }
1620
1621 \f
1622 /* Fork and execute a program, and wait for the reply.  */
1623
1624 void
1625 collect_execute (prog, argv, redir)
1626      char *prog;
1627      char **argv;
1628      char *redir;
1629 {
1630   int pid;
1631
1632   if (vflag || debug)
1633     {
1634       char **p_argv;
1635       char *str;
1636
1637       if (argv[0])
1638         fprintf (stderr, "%s", argv[0]);
1639       else
1640         fprintf (stderr, "[cannot find %s]", prog);
1641
1642       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1643         fprintf (stderr, " %s", str);
1644
1645       fprintf (stderr, "\n");
1646     }
1647
1648   fflush (stdout);
1649   fflush (stderr);
1650
1651   /* If we cannot find a program we need, complain error.  Do this here
1652      since we might not end up needing something that we could not find.  */
1653
1654   if (argv[0] == 0)
1655     fatal ("cannot find `%s'", prog);
1656
1657 #ifndef __CYGWIN32__
1658   pid = vfork ();
1659   if (pid == -1)
1660     {
1661 #ifdef vfork
1662       fatal_perror ("fork");
1663 #else
1664       fatal_perror ("vfork");
1665 #endif
1666     }
1667
1668   if (pid == 0)                 /* child context */
1669     {
1670       if (redir)
1671         {
1672           unlink (redir);
1673           if (freopen (redir, "a", stdout) == NULL)
1674             fatal_perror ("redirecting stdout: %s", redir);
1675           if (freopen (redir, "a", stderr) == NULL)
1676             fatal_perror ("redirecting stderr: %s", redir);
1677         }
1678
1679       execvp (argv[0], argv);
1680       fatal_perror ("executing %s", prog);
1681     }
1682 #else
1683   pid = _spawnvp (_P_NOWAIT, argv[0], argv);
1684   if (pid == -1)
1685     fatal ("spawnvp failed");
1686 #endif
1687 }
1688
1689 static void
1690 fork_execute (prog, argv)
1691      char *prog;
1692      char **argv;
1693 {
1694   collect_execute (prog, argv, NULL);
1695   do_wait (prog);
1696 }
1697 \f
1698 /* Unlink a file unless we are debugging.  */
1699
1700 static void
1701 maybe_unlink (file)
1702      char *file;
1703 {
1704   if (!debug)
1705     unlink (file);
1706   else
1707     fprintf (stderr, "[Leaving %s]\n", file);
1708 }
1709
1710 \f
1711 /* Add a name to a linked list.  */
1712
1713 static void
1714 add_to_list (head_ptr, name)
1715      struct head *head_ptr;
1716      char *name;
1717 {
1718   struct id *newid
1719     = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
1720   struct id *p;
1721   static long sequence_number = 0;
1722   strcpy (newid->name, name);
1723
1724   if (head_ptr->first)
1725     head_ptr->last->next = newid;
1726   else
1727     head_ptr->first = newid;
1728
1729   /* Check for duplicate symbols.  */
1730   for (p = head_ptr->first;
1731        strcmp (name, p->name) != 0;
1732        p = p->next)
1733     ;
1734   if (p != newid)
1735     {
1736       head_ptr->last->next = 0;
1737       free (newid);
1738       return;
1739     }
1740
1741   newid->sequence = ++sequence_number;
1742   head_ptr->last = newid;
1743   head_ptr->number++;
1744 }
1745
1746 /* Write: `prefix', the names on list LIST, `suffix'.  */
1747
1748 static void
1749 write_list (stream, prefix, list)
1750      FILE *stream;
1751      char *prefix;
1752      struct id *list;
1753 {
1754   while (list)
1755     {
1756       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1757       list = list->next;
1758     }
1759 }
1760
1761 #ifdef COLLECT_EXPORT_LIST
1762 /* This function is really used only on AIX, but may be useful.  */
1763 static int
1764 is_in_list (prefix, list)
1765      char *prefix;
1766      struct id *list;
1767 {
1768   while (list)
1769     {
1770       if (!strcmp (prefix, list->name)) return 1;
1771       list = list->next;
1772     }
1773     return 0;
1774 }
1775 #endif
1776
1777 /* Added for debugging purpose.  */
1778 #ifdef COLLECT_EXPORT_LIST
1779 static void
1780 dump_list (stream, prefix, list)
1781      FILE *stream;
1782      char *prefix;
1783      struct id *list;
1784 {
1785   while (list)
1786     {
1787       fprintf (stream, "%s%s,\n", prefix, list->name);
1788       list = list->next;
1789     }
1790 }
1791 #endif
1792
1793 #if 0
1794 static void
1795 dump_prefix_list (stream, prefix, list)
1796      FILE *stream;
1797      char *prefix;
1798      struct prefix_list *list;
1799 {
1800   while (list)
1801     {
1802       fprintf (stream, "%s%s,\n", prefix, list->prefix);
1803       list = list->next;
1804     }
1805 }
1806 #endif
1807
1808 static void
1809 write_list_with_asm (stream, prefix, list)
1810      FILE *stream;
1811      char *prefix;
1812      struct id *list;
1813 {
1814   while (list)
1815     {
1816       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1817                prefix, list->sequence, list->name);
1818       list = list->next;
1819     }
1820 }
1821
1822 /* Write out the constructor and destructor tables statically (for a shared
1823    object), along with the functions to execute them.  */
1824
1825 static void
1826 write_c_file_stat (stream, name)
1827      FILE *stream;
1828      char *name;
1829 {
1830   char *prefix, *p, *q;
1831   int frames = (frame_tables.number > 0);
1832
1833   /* Figure out name of output_file, stripping off .so version.  */
1834   p = rindex (output_file, '/');
1835   if (p == 0)
1836     p = (char *) output_file;
1837   else
1838     p++;
1839   q = p;
1840   while (q)
1841     {
1842       q = index (q,'.');
1843       if (q == 0)
1844         {
1845           q = p + strlen (p);
1846           break;
1847         }
1848       else
1849         {
1850           if (strncmp (q, ".so", 3) == 0)
1851             {
1852               q += 3;
1853               break;
1854             }
1855           else
1856             q++;
1857         }
1858     }
1859   /* q points to null at end of the string (or . of the .so version) */
1860   prefix = xmalloc (q - p + 1);
1861   strncpy (prefix, p, q - p);
1862   prefix[q - p] = 0;
1863   for (q = prefix; *q; q++)
1864     if (!ISALNUM (*q))
1865       *q = '_';
1866   if (debug)
1867     fprintf (stderr, "\nwrite_c_file - output name is %s, prefix is %s\n",
1868              output_file, prefix);
1869
1870 #define INIT_NAME_FORMAT "_GLOBAL__FI_%s"
1871   initname = xmalloc (strlen (prefix) + sizeof (INIT_NAME_FORMAT) - 2);
1872   sprintf (initname, INIT_NAME_FORMAT, prefix);
1873
1874 #define FINI_NAME_FORMAT "_GLOBAL__FD_%s"
1875   fininame = xmalloc (strlen (prefix) + sizeof (FINI_NAME_FORMAT) - 2);
1876   sprintf (fininame, FINI_NAME_FORMAT, prefix);
1877
1878   free (prefix);
1879
1880   /* Write the tables as C code  */
1881
1882   fprintf (stream, "static int count;\n");
1883   fprintf (stream, "typedef void entry_pt();\n");
1884   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1885
1886   if (frames)
1887     {
1888       write_list_with_asm (stream, "extern void *", frame_tables.first);
1889
1890       fprintf (stream, "\tstatic void *frame_table[] = {\n");
1891       write_list (stream, "\t\t&", frame_tables.first);
1892       fprintf (stream, "\t0\n};\n");
1893
1894       /* This must match what's in frame.h.  */
1895       fprintf (stream, "struct object {\n");
1896       fprintf (stream, "  void *pc_begin;\n");
1897       fprintf (stream, "  void *pc_end;\n");
1898       fprintf (stream, "  void *fde_begin;\n");
1899       fprintf (stream, "  void *fde_array;\n");
1900       fprintf (stream, "  __SIZE_TYPE__ count;\n");
1901       fprintf (stream, "  struct object *next;\n");
1902       fprintf (stream, "};\n");
1903
1904       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1905       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1906
1907       fprintf (stream, "static void reg_frame () {\n");
1908       fprintf (stream, "\tstatic struct object ob;\n");
1909       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1910       fprintf (stream, "\t}\n");
1911
1912       fprintf (stream, "static void dereg_frame () {\n");
1913       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1914       fprintf (stream, "\t}\n");
1915     }
1916
1917   fprintf (stream, "void %s() {\n", initname);
1918   if (constructors.number > 0 || frames)
1919     {
1920       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1921       write_list (stream, "\t\t", constructors.first);
1922       if (frames)
1923         fprintf (stream, "\treg_frame,\n");
1924       fprintf (stream, "\t};\n");
1925       fprintf (stream, "\tentry_pt **p;\n");
1926       fprintf (stream, "\tif (count++ != 0) return;\n");
1927       fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1928       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1929     }
1930   else
1931     fprintf (stream, "\t++count;\n");
1932   fprintf (stream, "}\n");
1933   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1934   fprintf (stream, "void %s() {\n", fininame);
1935   if (destructors.number > 0 || frames)
1936     {
1937       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1938       write_list (stream, "\t\t", destructors.first);
1939       if (frames)
1940         fprintf (stream, "\tdereg_frame,\n");
1941       fprintf (stream, "\t};\n");
1942       fprintf (stream, "\tentry_pt **p;\n");
1943       fprintf (stream, "\tif (--count != 0) return;\n");
1944       fprintf (stream, "\tp = dtors;\n");
1945       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1946                destructors.number + frames);
1947     }
1948   fprintf (stream, "}\n");
1949
1950   if (shared_obj)
1951     {
1952       fprintf (stream, "void _GLOBAL__DI() {\n\t%s();\n}\n", initname);
1953       fprintf (stream, "void _GLOBAL__DD() {\n\t%s();\n}\n", fininame);
1954     }
1955 }
1956
1957 /* Write the constructor/destructor tables.  */
1958
1959 #ifndef LD_INIT_SWITCH
1960 static void
1961 write_c_file_glob (stream, name)
1962      FILE *stream;
1963      char *name;
1964 {
1965   /* Write the tables as C code  */
1966
1967   int frames = (frame_tables.number > 0);
1968
1969   fprintf (stream, "typedef void entry_pt();\n\n");
1970
1971   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1972
1973   if (frames)
1974     {
1975       write_list_with_asm (stream, "extern void *", frame_tables.first);
1976
1977       fprintf (stream, "\tstatic void *frame_table[] = {\n");
1978       write_list (stream, "\t\t&", frame_tables.first);
1979       fprintf (stream, "\t0\n};\n");
1980
1981       /* This must match what's in frame.h.  */
1982       fprintf (stream, "struct object {\n");
1983       fprintf (stream, "  void *pc_begin;\n");
1984       fprintf (stream, "  void *pc_end;\n");
1985       fprintf (stream, "  void *fde_begin;\n");
1986       fprintf (stream, "  void *fde_array;\n");
1987       fprintf (stream, "  __SIZE_TYPE__ count;\n");
1988       fprintf (stream, "  struct object *next;\n");
1989       fprintf (stream, "};\n");
1990
1991       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1992       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1993
1994       fprintf (stream, "static void reg_frame () {\n");
1995       fprintf (stream, "\tstatic struct object ob;\n");
1996       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1997       fprintf (stream, "\t}\n");
1998
1999       fprintf (stream, "static void dereg_frame () {\n");
2000       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
2001       fprintf (stream, "\t}\n");
2002     }
2003
2004   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
2005   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
2006   write_list (stream, "\t", constructors.first);
2007   if (frames)
2008     fprintf (stream, "\treg_frame,\n");
2009   fprintf (stream, "\t0\n};\n\n");
2010
2011   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2012
2013   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2014   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2015   write_list (stream, "\t", destructors.first);
2016   if (frames)
2017     fprintf (stream, "\tdereg_frame,\n");
2018   fprintf (stream, "\t0\n};\n\n");
2019
2020   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2021   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2022 }
2023 #endif /* ! LD_INIT_SWITCH */
2024
2025 static void
2026 write_c_file (stream, name)
2027      FILE *stream;
2028      char *name;
2029 {
2030   fprintf (stream, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
2031 #ifndef LD_INIT_SWITCH
2032   if (! shared_obj)
2033     write_c_file_glob (stream, name);
2034   else
2035 #endif
2036     write_c_file_stat (stream, name);
2037   fprintf (stream, "#ifdef __cplusplus\n}\n#endif\n");
2038 }
2039
2040 #ifdef COLLECT_EXPORT_LIST
2041 static void
2042 write_export_file (stream)
2043      FILE *stream;
2044 {
2045   struct id *list = exports.first;
2046   for (; list; list = list->next)
2047     fprintf (stream, "%s\n", list->name);
2048 }
2049
2050 static void
2051 write_import_file (stream)
2052      FILE *stream;
2053 {
2054   struct id *list = imports.first;
2055   fprintf (stream, "%s\n", "#! .");
2056   for (; list; list = list->next)
2057     fprintf (stream, "%s\n", list->name);
2058 }
2059 #endif
2060 \f
2061 #ifdef OBJECT_FORMAT_NONE
2062
2063 /* Generic version to scan the name list of the loaded program for
2064    the symbols g++ uses for static constructors and destructors.
2065
2066    The constructor table begins at __CTOR_LIST__ and contains a count
2067    of the number of pointers (or -1 if the constructors are built in a
2068    separate section by the linker), followed by the pointers to the
2069    constructor functions, terminated with a null pointer.  The
2070    destructor table has the same format, and begins at __DTOR_LIST__.  */
2071
2072 static void
2073 scan_prog_file (prog_name, which_pass)
2074      char *prog_name;
2075      enum pass which_pass;
2076 {
2077   void (*int_handler) ();
2078   void (*quit_handler) ();
2079   char *nm_argv[4];
2080   int pid;
2081   int argc = 0;
2082   int pipe_fd[2];
2083   char *p, buf[1024];
2084   FILE *inf;
2085
2086   if (which_pass == PASS_SECOND)
2087     return;
2088
2089   /* If we do not have an `nm', complain.  */
2090   if (nm_file_name == 0)
2091     fatal ("cannot find `nm'");
2092
2093   nm_argv[argc++] = nm_file_name;
2094   if (NM_FLAGS[0] != '\0')
2095     nm_argv[argc++] = NM_FLAGS;
2096
2097   nm_argv[argc++] = prog_name;
2098   nm_argv[argc++] = (char *) 0;
2099
2100   if (pipe (pipe_fd) < 0)
2101     fatal_perror ("pipe");
2102
2103   inf = fdopen (pipe_fd[0], "r");
2104   if (inf == (FILE *) 0)
2105     fatal_perror ("fdopen");
2106
2107   /* Trace if needed.  */
2108   if (vflag)
2109     {
2110       char **p_argv;
2111       char *str;
2112
2113       for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2114         fprintf (stderr, " %s", str);
2115
2116       fprintf (stderr, "\n");
2117     }
2118
2119   fflush (stdout);
2120   fflush (stderr);
2121
2122   /* Spawn child nm on pipe */
2123   pid = vfork ();
2124   if (pid == -1)
2125     {
2126 #ifdef vfork
2127       fatal_perror ("fork");
2128 #else
2129       fatal_perror ("vfork");
2130 #endif
2131     }
2132
2133   if (pid == 0)                 /* child context */
2134     {
2135       /* setup stdout */
2136       if (dup2 (pipe_fd[1], 1) < 0)
2137         fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
2138
2139       if (close (pipe_fd[0]) < 0)
2140         fatal_perror ("close (%d)", pipe_fd[0]);
2141
2142       if (close (pipe_fd[1]) < 0)
2143         fatal_perror ("close (%d)", pipe_fd[1]);
2144
2145       execv (nm_file_name, nm_argv);
2146       fatal_perror ("executing %s", nm_file_name);
2147     }
2148
2149   /* Parent context from here on.  */
2150   int_handler  = (void (*) ())signal (SIGINT,  SIG_IGN);
2151 #ifdef SIGQUIT
2152   quit_handler = (void (*) ())signal (SIGQUIT, SIG_IGN);
2153 #endif
2154
2155   if (close (pipe_fd[1]) < 0)
2156     fatal_perror ("close (%d)", pipe_fd[1]);
2157
2158   if (debug)
2159     fprintf (stderr, "\nnm output with constructors/destructors.\n");
2160
2161   /* Read each line of nm output.  */
2162   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2163     {
2164       int ch, ch2;
2165       char *name, *end;
2166
2167       /* If it contains a constructor or destructor name, add the name
2168          to the appropriate list.  */
2169
2170       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2171         if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2172           break;
2173
2174       if (ch != '_')
2175         continue;
2176
2177       name = p;
2178       /* Find the end of the symbol name.
2179          Do not include `|', because Encore nm can tack that on the end.  */
2180       for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2) && ch2 != '|';
2181            end++)
2182         continue;
2183
2184
2185       *end = '\0';
2186       switch (is_ctor_dtor (name))
2187         {
2188         case 1:
2189           if (which_pass != PASS_LIB)
2190             add_to_list (&constructors, name);
2191           break;
2192
2193         case 2:
2194           if (which_pass != PASS_LIB)
2195             add_to_list (&destructors, name);
2196           break;
2197
2198         case 3:
2199           if (which_pass != PASS_LIB)
2200             fatal ("init function found in object %s", prog_name);
2201 #ifndef LD_INIT_SWITCH
2202           add_to_list (&constructors, name);
2203 #endif
2204           break;
2205
2206         case 4:
2207           if (which_pass != PASS_LIB)
2208             fatal ("fini function found in object %s", prog_name);
2209 #ifndef LD_FINI_SWITCH
2210           add_to_list (&destructors, name);
2211 #endif
2212           break;
2213
2214         case 5:
2215           if (which_pass != PASS_LIB)
2216             add_to_list (&frame_tables, name);
2217
2218         default:                /* not a constructor or destructor */
2219           continue;
2220         }
2221
2222       if (debug)
2223         fprintf (stderr, "\t%s\n", buf);
2224     }
2225
2226   if (debug)
2227     fprintf (stderr, "\n");
2228
2229   if (fclose (inf) != 0)
2230     fatal_perror ("fclose of pipe");
2231
2232   do_wait (nm_file_name);
2233
2234   signal (SIGINT,  int_handler);
2235 #ifdef SIGQUIT
2236   signal (SIGQUIT, quit_handler);
2237 #endif
2238 }
2239
2240 #if SUNOS4_SHARED_LIBRARIES
2241
2242 /* Routines to scan the SunOS 4 _DYNAMIC structure to find shared libraries
2243    that the output file depends upon and their initialization/finalization
2244    routines, if any.  */
2245
2246 #include <a.out.h>
2247 #include <fcntl.h>
2248 #include <link.h>
2249 #include <sys/mman.h>
2250 #include <sys/param.h>
2251 #include <unistd.h>
2252 #include <sys/dir.h>
2253
2254 /* pointers to the object file */
2255 unsigned object;        /* address of memory mapped file */
2256 unsigned objsize;       /* size of memory mapped to file */
2257 char * code;            /* pointer to code segment */
2258 char * data;            /* pointer to data segment */
2259 struct nlist *symtab;   /* pointer to symbol table */
2260 struct link_dynamic *ld;
2261 struct link_dynamic_2 *ld_2;
2262 struct head libraries;
2263
2264 /* Map the file indicated by NAME into memory and store its address.  */
2265
2266 static void
2267 mapfile (name)
2268      char *name;
2269 {
2270   int fp;
2271   struct stat s;
2272   if ((fp = open (name, O_RDONLY)) == -1)
2273     fatal ("unable to open file '%s'", name);
2274   if (fstat (fp, &s) == -1)
2275     fatal ("unable to stat file '%s'", name);
2276
2277   objsize = s.st_size;
2278   object = (unsigned) mmap (0, objsize, PROT_READ|PROT_WRITE, MAP_PRIVATE,
2279                             fp, 0);
2280   if (object == -1)
2281     fatal ("unable to mmap file '%s'", name);
2282
2283   close (fp);
2284 }
2285
2286 /* Helpers for locatelib.  */
2287
2288 static char *libname;
2289
2290 static int
2291 libselect (d)
2292      struct direct *d;
2293 {
2294   return (strncmp (libname, d->d_name, strlen (libname)) == 0);
2295 }
2296
2297 /* If one file has an additional numeric extension past LIBNAME, then put
2298    that one first in the sort.  If both files have additional numeric
2299    extensions, then put the one with the higher number first in the sort.
2300
2301    We must verify that the extension is numeric, because Sun saves the
2302    original versions of patched libraries with a .FCS extension.  Files with
2303    invalid extensions must go last in the sort, so that they will not be used.  */
2304
2305 static int
2306 libcompare (d1, d2)
2307      struct direct **d1, **d2;
2308 {
2309   int i1, i2 = strlen (libname);
2310   char *e1 = (*d1)->d_name + i2;
2311   char *e2 = (*d2)->d_name + i2;
2312
2313   while (*e1 && *e2 && *e1 == '.' && *e2 == '.'
2314          && e1[1] && ISDIGIT (e1[1]) && e2[1] && ISDIGIT (e2[1]))
2315     {
2316       ++e1;
2317       ++e2;
2318       i1 = strtol (e1, &e1, 10);
2319       i2 = strtol (e2, &e2, 10);
2320       if (i1 != i2)
2321         return i1 - i2;
2322     }
2323
2324   if (*e1)
2325     {
2326       /* It has a valid numeric extension, prefer this one.  */
2327       if (*e1 == '.' && e1[1] && ISDIGIT (e1[1]))
2328         return 1;
2329       /* It has a invalid numeric extension, must prefer the other one.  */
2330       else
2331         return -1;
2332     }
2333   else if (*e2)
2334     {
2335       /* It has a valid numeric extension, prefer this one.  */
2336       if (*e2 == '.' && e2[1] && ISDIGIT (e2[1]))
2337         return -1;
2338       /* It has a invalid numeric extension, must prefer the other one.  */
2339       else
2340         return 1;
2341     }
2342   else
2343     return 0;
2344 }
2345
2346 /* Given the name NAME of a dynamic dependency, find its pathname and add
2347    it to the list of libraries.  */
2348
2349 static void
2350 locatelib (name)
2351      char *name;
2352 {
2353   static char **l;
2354   static int cnt;
2355   char buf[MAXPATHLEN];
2356   char *p, *q;
2357   char **pp;
2358
2359   if (l == 0)
2360     {
2361       char *ld_rules;
2362       char *ldr = 0;
2363       /* counting elements in array, need 1 extra for null */
2364       cnt = 1;
2365       ld_rules = (char *) (ld_2->ld_rules + code);
2366       if (ld_rules)
2367         {
2368           cnt++;
2369           for (; *ld_rules != 0; ld_rules++)
2370             if (*ld_rules == ':')
2371               cnt++;
2372           ld_rules = (char *) (ld_2->ld_rules + code);
2373           ldr = (char *) malloc (strlen (ld_rules) + 1);
2374           strcpy (ldr, ld_rules);
2375         }
2376       p = getenv ("LD_LIBRARY_PATH");
2377       q = 0;
2378       if (p)
2379         {
2380           cnt++;
2381           for (q = p ; *q != 0; q++)
2382             if (*q == ':')
2383               cnt++;
2384           q = (char *) malloc (strlen (p) + 1);
2385           strcpy (q, p);
2386         }
2387       l = (char **) malloc ((cnt + 3) * sizeof (char *));
2388       pp = l;
2389       if (ldr)
2390         {
2391           *pp++ = ldr;
2392           for (; *ldr != 0; ldr++)
2393             if (*ldr == ':')
2394               {
2395                 *ldr++ = 0;
2396                 *pp++ = ldr;
2397               }
2398         }
2399       if (q)
2400         {
2401           *pp++ = q;
2402           for (; *q != 0; q++)
2403             if (*q == ':')
2404               {
2405                 *q++ = 0;
2406                 *pp++ = q;
2407               }
2408         }
2409       /* built in directories are /lib, /usr/lib, and /usr/local/lib */
2410       *pp++ = "/lib";
2411       *pp++ = "/usr/lib";
2412       *pp++ = "/usr/local/lib";
2413       *pp = 0;
2414     }
2415   libname = name;
2416   for (pp = l; *pp != 0 ; pp++)
2417     {
2418       struct direct **namelist;
2419       int entries;
2420       if ((entries = scandir (*pp, &namelist, libselect, libcompare)) > 0)
2421         {
2422           sprintf (buf, "%s/%s", *pp, namelist[entries - 1]->d_name);
2423           add_to_list (&libraries, buf);
2424           if (debug)
2425             fprintf (stderr, "%s\n", buf);
2426           break;
2427         }
2428     }
2429   if (*pp == 0)
2430     {
2431       if (debug)
2432         fprintf (stderr, "not found\n");
2433       else
2434         fatal ("dynamic dependency %s not found", name);
2435     }
2436 }
2437
2438 /* Scan the _DYNAMIC structure of the output file to find shared libraries
2439    that it depends upon and any constructors or destructors they contain.  */
2440
2441 static void
2442 scan_libraries (prog_name)
2443      char *prog_name;
2444 {
2445   struct exec *header;
2446   char *base;
2447   struct link_object *lo;
2448   char buff[MAXPATHLEN];
2449   struct id *list;
2450
2451   mapfile (prog_name);
2452   header = (struct exec *)object;
2453   if (N_BADMAG (*header))
2454     fatal ("bad magic number in file '%s'", prog_name);
2455   if (header->a_dynamic == 0)
2456     return;
2457
2458   code = (char *) (N_TXTOFF (*header) + (long) header);
2459   data = (char *) (N_DATOFF (*header) + (long) header);
2460   symtab = (struct nlist *) (N_SYMOFF (*header) + (long) header);
2461
2462   if (header->a_magic == ZMAGIC && header->a_entry == 0x20)
2463     {
2464       /* shared object */
2465       ld = (struct link_dynamic *) (symtab->n_value + code);
2466       base = code;
2467     }
2468   else
2469     {
2470       /* executable */
2471       ld = (struct link_dynamic *) data;
2472       base = code-PAGSIZ;
2473     }
2474
2475   if (debug)
2476     fprintf (stderr, "dynamic dependencies.\n");
2477
2478   ld_2 = (struct link_dynamic_2 *) ((long) ld->ld_un.ld_2 + (long)base);
2479   for (lo = (struct link_object *) ld_2->ld_need; lo;
2480        lo = (struct link_object *) lo->lo_next)
2481     {
2482       char *name;
2483       lo = (struct link_object *) ((long) lo + code);
2484       name = (char *) (code + lo->lo_name);
2485       if (lo->lo_library)
2486         {
2487           if (debug)
2488             fprintf (stderr, "\t-l%s.%d => ", name, lo->lo_major);
2489           sprintf (buff, "lib%s.so.%d.%d", name, lo->lo_major, lo->lo_minor);
2490           locatelib (buff);
2491         }
2492       else
2493         {
2494           if (debug)
2495             fprintf (stderr, "\t%s\n", name);
2496           add_to_list (&libraries, name);
2497         }
2498     }
2499
2500   if (debug)
2501     fprintf (stderr, "\n");
2502
2503   /* now iterate through the library list adding their symbols to
2504      the list.  */
2505   for (list = libraries.first; list; list = list->next)
2506     scan_prog_file (list->name, PASS_LIB);
2507 }
2508
2509 #else  /* SUNOS4_SHARED_LIBRARIES */
2510 #ifdef LDD_SUFFIX
2511
2512 /* Use the List Dynamic Dependencies program to find shared libraries that
2513    the output file depends upon and their initialization/finalization
2514    routines, if any.  */
2515
2516 static void
2517 scan_libraries (prog_name)
2518      char *prog_name;
2519 {
2520   static struct head libraries;         /* list of shared libraries found */
2521   struct id *list;
2522   void (*int_handler) ();
2523   void (*quit_handler) ();
2524   char *ldd_argv[4];
2525   int pid;
2526   int argc = 0;
2527   int pipe_fd[2];
2528   char buf[1024];
2529   FILE *inf;
2530
2531   /* If we do not have an `ldd', complain.  */
2532   if (ldd_file_name == 0)
2533     {
2534       error ("cannot find `ldd'");
2535       return;
2536     }
2537
2538   ldd_argv[argc++] = ldd_file_name;
2539   ldd_argv[argc++] = prog_name;
2540   ldd_argv[argc++] = (char *) 0;
2541
2542   if (pipe (pipe_fd) < 0)
2543     fatal_perror ("pipe");
2544
2545   inf = fdopen (pipe_fd[0], "r");
2546   if (inf == (FILE *) 0)
2547     fatal_perror ("fdopen");
2548
2549   /* Trace if needed.  */
2550   if (vflag)
2551     {
2552       char **p_argv;
2553       char *str;
2554
2555       for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2556         fprintf (stderr, " %s", str);
2557
2558       fprintf (stderr, "\n");
2559     }
2560
2561   fflush (stdout);
2562   fflush (stderr);
2563
2564   /* Spawn child ldd on pipe */
2565   pid = vfork ();
2566   if (pid == -1)
2567     {
2568 #ifdef vfork
2569       fatal_perror ("fork");
2570 #else
2571       fatal_perror ("vfork");
2572 #endif
2573     }
2574
2575   if (pid == 0)                 /* child context */
2576     {
2577       /* setup stdout */
2578       if (dup2 (pipe_fd[1], 1) < 0)
2579         fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
2580
2581       if (close (pipe_fd[0]) < 0)
2582         fatal_perror ("close (%d)", pipe_fd[0]);
2583
2584       if (close (pipe_fd[1]) < 0)
2585         fatal_perror ("close (%d)", pipe_fd[1]);
2586
2587       execv (ldd_file_name, ldd_argv);
2588       fatal_perror ("executing %s", ldd_file_name);
2589     }
2590
2591   /* Parent context from here on.  */
2592   int_handler  = (void (*) ()) signal (SIGINT,  SIG_IGN);
2593 #ifdef SIGQUIT
2594   quit_handler = (void (*) ()) signal (SIGQUIT, SIG_IGN);
2595 #endif
2596
2597   if (close (pipe_fd[1]) < 0)
2598     fatal_perror ("close (%d)", pipe_fd[1]);
2599
2600   if (debug)
2601     fprintf (stderr, "\nldd output with constructors/destructors.\n");
2602
2603   /* Read each line of ldd output.  */
2604   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2605     {
2606       int ch, ch2;
2607       char *name, *end, *p = buf;
2608
2609       /* Extract names of libraries and add to list.  */
2610       PARSE_LDD_OUTPUT (p);
2611       if (p == 0)
2612         continue;
2613
2614       name = p;
2615       if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2616         fatal ("dynamic dependency %s not found", buf);
2617
2618       /* Find the end of the symbol name.  */
2619       for (end = p;
2620            (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2) && ch2 != '|';
2621            end++)
2622         continue;
2623       *end = '\0';
2624
2625       if (access (name, R_OK) == 0)
2626         add_to_list (&libraries, name);
2627       else
2628         fatal ("unable to open dynamic dependency '%s'", buf);
2629
2630       if (debug)
2631         fprintf (stderr, "\t%s\n", buf);
2632     }
2633   if (debug)
2634     fprintf (stderr, "\n");
2635
2636   if (fclose (inf) != 0)
2637     fatal_perror ("fclose of pipe");
2638
2639   do_wait (ldd_file_name);
2640
2641   signal (SIGINT,  int_handler);
2642 #ifdef SIGQUIT
2643   signal (SIGQUIT, quit_handler);
2644 #endif
2645
2646   /* now iterate through the library list adding their symbols to
2647      the list.  */
2648   for (list = libraries.first; list; list = list->next)
2649     scan_prog_file (list->name, PASS_LIB);
2650 }
2651
2652 #endif /* LDD_SUFFIX */
2653 #endif /* SUNOS4_SHARED_LIBRARIES */
2654
2655 #endif /* OBJECT_FORMAT_NONE */
2656
2657 \f
2658 /*
2659  * COFF specific stuff.
2660  */
2661
2662 #ifdef OBJECT_FORMAT_COFF
2663
2664 #if defined(EXTENDED_COFF)
2665 #   define GCC_SYMBOLS(X)       (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2666 #   define GCC_SYMENT           SYMR
2667 #   define GCC_OK_SYMBOL(X)     ((X).st == stProc && (X).sc == scText)
2668 #   define GCC_SYMINC(X)        (1)
2669 #   define GCC_SYMZERO(X)       (SYMHEADER(X).isymMax)
2670 #   define GCC_CHECK_HDR(X)     (PSYMTAB(X) != 0)
2671 #else
2672 #   define GCC_SYMBOLS(X)       (HEADER(ldptr).f_nsyms)
2673 #   define GCC_SYMENT           SYMENT
2674 #   define GCC_OK_SYMBOL(X) \
2675      (((X).n_sclass == C_EXT) && \
2676       ((X).n_scnum > N_UNDEF) && \
2677       (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) || \
2678        ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))
2679 #   define GCC_UNDEF_SYMBOL(X) \
2680      (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2681 #   define GCC_SYMINC(X)        ((X).n_numaux+1)
2682 #   define GCC_SYMZERO(X)       0
2683 #   define GCC_CHECK_HDR(X)     (1)
2684 #endif
2685
2686 extern char *ldgetname ();
2687
2688 /* COFF version to scan the name list of the loaded program for
2689    the symbols g++ uses for static constructors and destructors.
2690
2691    The constructor table begins at __CTOR_LIST__ and contains a count
2692    of the number of pointers (or -1 if the constructors are built in a
2693    separate section by the linker), followed by the pointers to the
2694    constructor functions, terminated with a null pointer.  The
2695    destructor table has the same format, and begins at __DTOR_LIST__.  */
2696
2697 static void
2698 scan_prog_file (prog_name, which_pass)
2699      char *prog_name;
2700      enum pass which_pass;
2701 {
2702   LDFILE *ldptr = NULL;
2703   int sym_index, sym_count;
2704   int is_shared = 0;
2705 #ifdef COLLECT_EXPORT_LIST
2706   /* Should we generate an import list for given prog_name?  */
2707   int import_flag = (which_pass == PASS_OBJ ? 0 : use_import_list (prog_name));
2708 #endif
2709
2710   if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2711     return;
2712
2713 #ifdef COLLECT_EXPORT_LIST
2714   /* We do not need scanning for some standard C libraries.  */
2715   if (which_pass == PASS_FIRST && ignore_library (prog_name))
2716     return;
2717
2718   /* On AIX we have a loop, because there is not much difference
2719      between an object and an archive. This trick allows us to
2720      eliminate scan_libraries() function.  */
2721   do
2722     {
2723 #endif
2724       if ((ldptr = ldopen (prog_name, ldptr)) != NULL)
2725         {
2726
2727           if (!MY_ISCOFF (HEADER (ldptr).f_magic))
2728             fatal ("%s: not a COFF file", prog_name);
2729
2730 #ifdef COLLECT_EXPORT_LIST
2731           /* Is current archive member a shared object?  */
2732           is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2733 #endif
2734           if (GCC_CHECK_HDR (ldptr))
2735             {
2736               sym_count = GCC_SYMBOLS (ldptr);
2737               sym_index = GCC_SYMZERO (ldptr);
2738               while (sym_index < sym_count)
2739                 {
2740                   GCC_SYMENT symbol;
2741
2742                   if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2743                     break;
2744                   sym_index += GCC_SYMINC (symbol);
2745
2746                   if (GCC_OK_SYMBOL (symbol))
2747                     {
2748                       char *name;
2749
2750                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
2751                         continue;               /* should never happen */
2752
2753 #ifdef XCOFF_DEBUGGING_INFO
2754                       /* All AIX function names have a duplicate entry
2755                          beginning with a dot.  */
2756                       if (*name == '.')
2757                         ++name;
2758 #endif
2759
2760                       switch (is_ctor_dtor (name))
2761                         {
2762                         case 1:
2763                           if (! is_shared) add_to_list (&constructors, name);
2764 #ifdef COLLECT_EXPORT_LIST
2765                           if (which_pass == PASS_OBJ)
2766                             add_to_list (&exports, name);
2767                           /* If this symbol was undefined and we are building
2768                              an import list, we should add a symbol to this
2769                              list.  */
2770                           else
2771                             if (import_flag
2772                                 && is_in_list (name, undefined.first))
2773                               add_to_list (&imports, name);
2774 #endif
2775                           break;
2776
2777                         case 2:
2778                           if (! is_shared) add_to_list (&destructors, name);
2779 #ifdef COLLECT_EXPORT_LIST
2780                           if (which_pass == PASS_OBJ)
2781                             add_to_list (&exports, name);
2782                           /* If this symbol was undefined and we are building
2783                              an import list, we should add a symbol to this
2784                              list.  */
2785                           else
2786                             if (import_flag
2787                                 && is_in_list (name, undefined.first))
2788                               add_to_list (&imports, name);
2789 #endif
2790                           break;
2791
2792 #ifdef COLLECT_EXPORT_LIST
2793                         case 3:
2794                           if (is_shared)
2795                             add_to_list (&constructors, name);
2796                           break;
2797
2798                         case 4:
2799                           if (is_shared)
2800                             add_to_list (&destructors, name);
2801                           break;
2802 #endif
2803
2804                         default:        /* not a constructor or destructor */
2805 #ifdef COLLECT_EXPORT_LIST
2806                           /* If we are building a shared object on AIX we need
2807                              to explicitly export all global symbols or add
2808                              them to import list.  */
2809                           if (shared_obj)
2810                             {
2811                               if (which_pass == PASS_OBJ && (! export_flag))
2812                                 add_to_list (&exports, name);
2813                               else if (! is_shared && which_pass == PASS_FIRST
2814                                        && import_flag
2815                                        && is_in_list(name, undefined.first))
2816                                 add_to_list (&imports, name);
2817                             }
2818 #endif
2819                           continue;
2820                         }
2821
2822 #if !defined(EXTENDED_COFF)
2823                       if (debug)
2824                         fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2825                                  symbol.n_scnum, symbol.n_sclass,
2826                                  (symbol.n_type ? "0" : ""), symbol.n_type,
2827                                  name);
2828 #else
2829                       if (debug)
2830                         fprintf (stderr,
2831                                  "\tiss = %5d, value = %5d, index = %5d, name = %s\n",
2832                                  symbol.iss, symbol.value, symbol.index, name);
2833 #endif
2834                     }
2835 #ifdef COLLECT_EXPORT_LIST
2836                   /* If we are building a shared object we should collect
2837                      information about undefined symbols for later
2838                      import list generation.  */
2839                   else if (shared_obj && GCC_UNDEF_SYMBOL (symbol))
2840                     {
2841                       char *name;
2842
2843                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
2844                         continue;               /* should never happen */
2845
2846                       /* All AIX function names have a duplicate entry
2847                          beginning with a dot.  */
2848                       if (*name == '.')
2849                         ++name;
2850                       add_to_list (&undefined, name);
2851                     }
2852 #endif
2853                 }
2854             }
2855         }
2856       else
2857         {
2858           fatal ("%s: cannot open as COFF file", prog_name);
2859         }
2860 #ifdef COLLECT_EXPORT_LIST
2861       /* On AIX loop continues while there are more members in archive.  */
2862     }
2863   while (ldclose (ldptr) == FAILURE);
2864 #else
2865   /* Otherwise we simply close ldptr.  */
2866   (void) ldclose(ldptr);
2867 #endif
2868 }
2869
2870
2871 #ifdef COLLECT_EXPORT_LIST
2872
2873 /* This new function is used to decide whether we should
2874    generate import list for an object or to use it directly.  */
2875 static int
2876 use_import_list (prog_name)
2877      char *prog_name;
2878 {
2879   char *p;
2880
2881   /* If we do not build a shared object then import list should not be used.  */
2882   if (! shared_obj) return 0;
2883
2884   /* Currently we check only for libgcc, but this can be changed in future.  */
2885   p = strstr (prog_name, "libgcc.a");
2886   if (p != 0 && (strlen (p) == sizeof ("libgcc.a") - 1))
2887     return 1;
2888   return 0;
2889 }
2890
2891 /* Given a library name without "lib" prefix, this function
2892    returns a full library name including a path.  */
2893 static char *
2894 resolve_lib_name (name)
2895      char *name;
2896 {
2897   char *lib_buf;
2898   int i, j, l = 0;
2899
2900   for (i = 0; libpaths[i]; i++)
2901     if (libpaths[i]->max_len > l)
2902       l = libpaths[i]->max_len;
2903
2904   lib_buf = xmalloc (l + strlen(name) + 10);
2905
2906   for (i = 0; libpaths[i]; i++)
2907     {
2908       struct prefix_list *list = libpaths[i]->plist;
2909       for (; list; list = list->next)
2910         {
2911           for (j = 0; libexts[j]; j++)
2912             {
2913               /* The following lines are needed because path_prefix list
2914                  may contain directories both with trailing '/' and
2915                  without it.  */
2916               char *p = "";
2917               if (list->prefix[strlen(list->prefix)-1] != '/')
2918                 p = "/";
2919               sprintf (lib_buf, "%s%slib%s.%s",
2920                        list->prefix, p, name, libexts[j]);
2921 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2922               if (file_exists (lib_buf))
2923                 {
2924 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2925                   return (lib_buf);
2926                 }
2927             }
2928         }
2929     }
2930   if (debug)
2931     fprintf (stderr, "not found\n");
2932   else
2933     fatal ("Library lib%s not found", name);
2934   return (NULL);
2935 }
2936
2937 /* Array of standard AIX libraries which should not
2938    be scanned for ctors/dtors.  */
2939 static char* aix_std_libs[] = {
2940   "/unix",
2941   "/lib/libc.a",
2942   "/lib/libc_r.a",
2943   "/usr/lib/libc.a",
2944   "/usr/lib/libc_r.a",
2945   "/usr/lib/threads/libc.a",
2946   "/usr/ccs/lib/libc.a",
2947   "/usr/ccs/lib/libc_r.a",
2948   NULL
2949 };
2950
2951 /* This function checks the filename and returns 1
2952    if this name matches the location of a standard AIX library. */
2953 static int
2954 ignore_library (name)
2955      char *name;
2956 {
2957   char **p = &aix_std_libs[0];
2958   while (*p++ != NULL)
2959     if (! strcmp (name, *p)) return 1;
2960   return 0;
2961 }
2962
2963 #endif
2964
2965 #endif /* OBJECT_FORMAT_COFF */
2966
2967 \f
2968 /*
2969  * OSF/rose specific stuff.
2970  */
2971
2972 #ifdef OBJECT_FORMAT_ROSE
2973
2974 /* Union of the various load commands */
2975
2976 typedef union load_union
2977 {
2978   ldc_header_t                  hdr;    /* common header */
2979   load_cmd_map_command_t        map;    /* map indexing other load cmds */
2980   interpreter_command_t         iprtr;  /* interpreter pathname */
2981   strings_command_t             str;    /* load commands strings section */
2982   region_command_t              region; /* region load command */
2983   reloc_command_t               reloc;  /* relocation section */
2984   package_command_t             pkg;    /* package load command */
2985   symbols_command_t             sym;    /* symbol sections */
2986   entry_command_t               ent;    /* program start section */
2987   gen_info_command_t            info;   /* object information */
2988   func_table_command_t          func;   /* function constructors/destructors */
2989 } load_union_t;
2990
2991 /* Structure to point to load command and data section in memory.  */
2992
2993 typedef struct load_all
2994 {
2995   load_union_t *load;                   /* load command */
2996   char *section;                        /* pointer to section */
2997 } load_all_t;
2998
2999 /* Structure to contain information about a file mapped into memory.  */
3000
3001 struct file_info
3002 {
3003   char *start;                          /* start of map */
3004   char *name;                           /* filename */
3005   long  size;                           /* size of the file */
3006   long  rounded_size;                   /* size rounded to page boundary */
3007   int   fd;                             /* file descriptor */
3008   int   rw;                             /* != 0 if opened read/write */
3009   int   use_mmap;                       /* != 0 if mmap'ed */
3010 };
3011
3012 extern int decode_mach_o_hdr ();
3013 extern int encode_mach_o_hdr ();
3014
3015 static void add_func_table      PROTO((mo_header_t *, load_all_t *,
3016                                        symbol_info_t *, int));
3017 static void print_header        PROTO((mo_header_t *));
3018 static void print_load_command  PROTO((load_union_t *, size_t, int));
3019 static void bad_header          PROTO((int));
3020 static struct file_info *read_file  PROTO((char *, int, int));
3021 static void end_file            PROTO((struct file_info *));
3022 \f
3023 /* OSF/rose specific version to scan the name list of the loaded
3024    program for the symbols g++ uses for static constructors and
3025    destructors.
3026
3027    The constructor table begins at __CTOR_LIST__ and contains a count
3028    of the number of pointers (or -1 if the constructors are built in a
3029    separate section by the linker), followed by the pointers to the
3030    constructor functions, terminated with a null pointer.  The
3031    destructor table has the same format, and begins at __DTOR_LIST__.  */
3032
3033 static void
3034 scan_prog_file (prog_name, which_pass)
3035      char *prog_name;
3036      enum pass which_pass;
3037 {
3038   char *obj;
3039   mo_header_t hdr;
3040   load_all_t *load_array;
3041   load_all_t *load_end;
3042   load_all_t *load_cmd;
3043   int symbol_load_cmds;
3044   off_t offset;
3045   int i;
3046   int num_syms;
3047   int status;
3048   char *str_sect;
3049   struct file_info *obj_file;
3050   int prog_fd;
3051   mo_lcid_t cmd_strings   = -1;
3052   symbol_info_t *main_sym = 0;
3053   int rw                  = (which_pass != PASS_FIRST);
3054
3055   prog_fd = open (prog_name, (rw) ? O_RDWR : O_RDONLY);
3056   if (prog_fd < 0)
3057     fatal_perror ("cannot read %s", prog_name);
3058
3059   obj_file = read_file (prog_name, prog_fd, rw);
3060   obj = obj_file->start;
3061
3062   status = decode_mach_o_hdr (obj, MO_SIZEOF_RAW_HDR, MOH_HEADER_VERSION, &hdr);
3063   if (status != MO_HDR_CONV_SUCCESS)
3064     bad_header (status);
3065
3066
3067   /* Do some basic sanity checks.  Note we explicitly use the big endian magic number,
3068      since the hardware will automatically swap bytes for us on loading little endian
3069      integers.  */
3070
3071 #ifndef CROSS_COMPILE
3072   if (hdr.moh_magic != MOH_MAGIC_MSB
3073       || hdr.moh_header_version != MOH_HEADER_VERSION
3074       || hdr.moh_byte_order != OUR_BYTE_ORDER
3075       || hdr.moh_data_rep_id != OUR_DATA_REP_ID
3076       || hdr.moh_cpu_type != OUR_CPU_TYPE
3077       || hdr.moh_cpu_subtype != OUR_CPU_SUBTYPE
3078       || hdr.moh_vendor_type != OUR_VENDOR_TYPE)
3079     {
3080       fatal ("incompatibilities between object file & expected values");
3081     }
3082 #endif
3083
3084   if (debug)
3085     print_header (&hdr);
3086
3087   offset = hdr.moh_first_cmd_off;
3088   load_end = load_array
3089     = (load_all_t *) xcalloc (sizeof (load_all_t), hdr.moh_n_load_cmds + 2);
3090
3091   /* Build array of load commands, calculating the offsets */
3092   for (i = 0; i < hdr.moh_n_load_cmds; i++)
3093     {
3094       load_union_t *load_hdr;           /* load command header */
3095
3096       load_cmd = load_end++;
3097       load_hdr = (load_union_t *) (obj + offset);
3098
3099       /* If modifying the program file, copy the header.  */
3100       if (rw)
3101         {
3102           load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
3103           bcopy ((char *)load_hdr, (char *)ptr, load_hdr->hdr.ldci_cmd_size);
3104           load_hdr = ptr;
3105
3106           /* null out old command map, because we will rewrite at the end.  */
3107           if (ptr->hdr.ldci_cmd_type == LDC_CMD_MAP)
3108             {
3109               cmd_strings = ptr->map.lcm_ld_cmd_strings;
3110               ptr->hdr.ldci_cmd_type = LDC_UNDEFINED;
3111             }
3112         }
3113
3114       load_cmd->load = load_hdr;
3115       if (load_hdr->hdr.ldci_section_off > 0)
3116         load_cmd->section = obj + load_hdr->hdr.ldci_section_off;
3117
3118       if (debug)
3119         print_load_command (load_hdr, offset, i);
3120
3121       offset += load_hdr->hdr.ldci_cmd_size;
3122     }
3123
3124   /* If the last command is the load command map and is not undefined,
3125      decrement the count of load commands.  */
3126   if (rw && load_end[-1].load->hdr.ldci_cmd_type == LDC_UNDEFINED)
3127     {
3128       load_end--;
3129       hdr.moh_n_load_cmds--;
3130     }
3131
3132   /* Go through and process each symbol table section.  */
3133   symbol_load_cmds = 0;
3134   for (load_cmd = load_array; load_cmd < load_end; load_cmd++)
3135     {
3136       load_union_t *load_hdr = load_cmd->load;
3137
3138       if (load_hdr->hdr.ldci_cmd_type == LDC_SYMBOLS)
3139         {
3140           symbol_load_cmds++;
3141
3142           if (debug)
3143             {
3144               char *kind = "unknown";
3145
3146               switch (load_hdr->sym.symc_kind)
3147                 {
3148                 case SYMC_IMPORTS:         kind = "imports"; break;
3149                 case SYMC_DEFINED_SYMBOLS: kind = "defined"; break;
3150                 case SYMC_STABS:           kind = "stabs";   break;
3151                 }
3152
3153               fprintf (stderr, "\nProcessing symbol table #%d, offset = 0x%.8lx, kind = %s\n",
3154                        symbol_load_cmds, load_hdr->hdr.ldci_section_off, kind);
3155             }
3156
3157           if (load_hdr->sym.symc_kind != SYMC_DEFINED_SYMBOLS)
3158             continue;
3159
3160           str_sect = load_array[load_hdr->sym.symc_strings_section].section;
3161           if (str_sect == (char *) 0)
3162             fatal ("string section missing");
3163
3164           if (load_cmd->section == (char *) 0)
3165             fatal ("section pointer missing");
3166
3167           num_syms = load_hdr->sym.symc_nentries;
3168           for (i = 0; i < num_syms; i++)
3169             {
3170               symbol_info_t *sym = ((symbol_info_t *) load_cmd->section) + i;
3171               char *name = sym->si_name.symbol_name + str_sect;
3172
3173               if (name[0] != '_')
3174                 continue;
3175
3176               if (rw)
3177                 {
3178                   char *n = name + strlen (name) - strlen (NAME__MAIN);
3179
3180                   if ((n - name) < 0 || strcmp (n, NAME__MAIN))
3181                     continue;
3182                   while (n != name)
3183                     if (*--n != '_')
3184                       continue;
3185
3186                   main_sym = sym;
3187                 }
3188               else
3189                 {
3190                   switch (is_ctor_dtor (name))
3191                     {
3192                     case 1:
3193                       add_to_list (&constructors, name);
3194                       break;
3195
3196                     case 2:
3197                       add_to_list (&destructors, name);
3198                       break;
3199
3200                     default:    /* not a constructor or destructor */
3201                       continue;
3202                     }
3203                 }
3204
3205               if (debug)
3206                 fprintf (stderr, "\ttype = 0x%.4x, sc = 0x%.2x, flags = 0x%.8x, name = %.30s\n",
3207                          sym->si_type, sym->si_sc_type, sym->si_flags, name);
3208             }
3209         }
3210     }
3211
3212   if (symbol_load_cmds == 0)
3213     fatal ("no symbol table found");
3214
3215   /* Update the program file now, rewrite header and load commands.  At present,
3216      we assume that there is enough space after the last load command to insert
3217      one more.  Since the first section written out is page aligned, and the
3218      number of load commands is small, this is ok for the present.  */
3219
3220   if (rw)
3221     {
3222       load_union_t *load_map;
3223       size_t size;
3224
3225       if (cmd_strings == -1)
3226         fatal ("no cmd_strings found");
3227
3228       /* Add __main to initializer list.
3229          If we are building a program instead of a shared library, do not
3230          do anything, since in the current version, you cannot do mallocs
3231          and such in the constructors.  */
3232
3233       if (main_sym != (symbol_info_t *) 0
3234           && ((hdr.moh_flags & MOH_EXECABLE_F) == 0))
3235         add_func_table (&hdr, load_array, main_sym, FNTC_INITIALIZATION);
3236
3237       if (debug)
3238         fprintf (stderr, "\nUpdating header and load commands.\n\n");
3239
3240       hdr.moh_n_load_cmds++;
3241       size = sizeof (load_cmd_map_command_t) + (sizeof (mo_offset_t) * (hdr.moh_n_load_cmds - 1));
3242
3243       /* Create new load command map.  */
3244       if (debug)
3245         fprintf (stderr, "load command map, %d cmds, new size %ld.\n",
3246                  (int)hdr.moh_n_load_cmds, (long)size);
3247
3248       load_map = (load_union_t *) xcalloc (1, size);
3249       load_map->map.ldc_header.ldci_cmd_type = LDC_CMD_MAP;
3250       load_map->map.ldc_header.ldci_cmd_size = size;
3251       load_map->map.lcm_ld_cmd_strings = cmd_strings;
3252       load_map->map.lcm_nentries = hdr.moh_n_load_cmds;
3253       load_array[hdr.moh_n_load_cmds-1].load = load_map;
3254
3255       offset = hdr.moh_first_cmd_off;
3256       for (i = 0; i < hdr.moh_n_load_cmds; i++)
3257         {
3258           load_map->map.lcm_map[i] = offset;
3259           if (load_array[i].load->hdr.ldci_cmd_type == LDC_CMD_MAP)
3260             hdr.moh_load_map_cmd_off = offset;
3261
3262           offset += load_array[i].load->hdr.ldci_cmd_size;
3263         }
3264
3265       hdr.moh_sizeofcmds = offset - MO_SIZEOF_RAW_HDR;
3266
3267       if (debug)
3268         print_header (&hdr);
3269
3270       /* Write header */
3271       status = encode_mach_o_hdr (&hdr, obj, MO_SIZEOF_RAW_HDR);
3272       if (status != MO_HDR_CONV_SUCCESS)
3273         bad_header (status);
3274
3275       if (debug)
3276         fprintf (stderr, "writing load commands.\n\n");
3277
3278       /* Write load commands */
3279       offset = hdr.moh_first_cmd_off;
3280       for (i = 0; i < hdr.moh_n_load_cmds; i++)
3281         {
3282           load_union_t *load_hdr = load_array[i].load;
3283           size_t size = load_hdr->hdr.ldci_cmd_size;
3284
3285           if (debug)
3286             print_load_command (load_hdr, offset, i);
3287
3288           bcopy ((char *) load_hdr, (char *) (obj + offset), size);
3289           offset += size;
3290         }
3291     }
3292
3293   end_file (obj_file);
3294
3295   if (close (prog_fd))
3296     fatal_perror ("closing %s", prog_name);
3297
3298   if (debug)
3299     fprintf (stderr, "\n");
3300 }
3301
3302 \f
3303 /* Add a function table to the load commands to call a function
3304    on initiation or termination of the process.  */
3305
3306 static void
3307 add_func_table (hdr_p, load_array, sym, type)
3308      mo_header_t *hdr_p;                /* pointer to global header */
3309      load_all_t *load_array;            /* array of ptrs to load cmds */
3310      symbol_info_t *sym;                /* pointer to symbol entry */
3311      int type;                          /* fntc_type value */
3312 {
3313   /* Add a new load command.  */
3314   int num_cmds = ++hdr_p->moh_n_load_cmds;
3315   int load_index = num_cmds - 1;
3316   size_t size = sizeof (func_table_command_t) + sizeof (mo_addr_t);
3317   load_union_t *ptr = xcalloc (1, size);
3318   load_all_t *load_cmd;
3319   int i;
3320
3321   /* Set the unresolved address bit in the header to force the loader to be
3322      used, since kernel exec does not call the initialization functions.  */
3323   hdr_p->moh_flags |= MOH_UNRESOLVED_F;
3324
3325   load_cmd = &load_array[load_index];
3326   load_cmd->load = ptr;
3327   load_cmd->section = (char *) 0;
3328
3329   /* Fill in func table load command.  */
3330   ptr->func.ldc_header.ldci_cmd_type = LDC_FUNC_TABLE;
3331   ptr->func.ldc_header.ldci_cmd_size = size;
3332   ptr->func.ldc_header.ldci_section_off = 0;
3333   ptr->func.ldc_header.ldci_section_len = 0;
3334   ptr->func.fntc_type = type;
3335   ptr->func.fntc_nentries = 1;
3336
3337   /* copy address, turn it from abs. address to (region,offset) if necessary.  */
3338   /* Is the symbol already expressed as (region, offset)?  */
3339   if ((sym->si_flags & SI_ABSOLUTE_VALUE_F) == 0)
3340     {
3341       ptr->func.fntc_entry_loc[i].adr_lcid = sym->si_value.def_val.adr_lcid;
3342       ptr->func.fntc_entry_loc[i].adr_sctoff = sym->si_value.def_val.adr_sctoff;
3343     }
3344
3345   /* If not, figure out which region it's in.  */
3346   else
3347     {
3348       mo_vm_addr_t addr = sym->si_value.abs_val;
3349       int found = 0;
3350
3351       for (i = 0; i < load_index; i++)
3352         {
3353           if (load_array[i].load->hdr.ldci_cmd_type == LDC_REGION)
3354             {
3355               region_command_t *region_ptr = &load_array[i].load->region;
3356
3357               if ((region_ptr->regc_flags & REG_ABS_ADDR_F) != 0
3358                   && addr >= region_ptr->regc_addr.vm_addr
3359                   && addr <= region_ptr->regc_addr.vm_addr + region_ptr->regc_vm_size)
3360                 {
3361                   ptr->func.fntc_entry_loc[0].adr_lcid = i;
3362                   ptr->func.fntc_entry_loc[0].adr_sctoff = addr - region_ptr->regc_addr.vm_addr;
3363                   found++;
3364                   break;
3365                 }
3366             }
3367         }
3368
3369       if (!found)
3370         fatal ("could not convert 0x%l.8x into a region", addr);
3371     }
3372
3373   if (debug)
3374     fprintf (stderr,
3375              "%s function, region %d, offset = %ld (0x%.8lx)\n",
3376              (type == FNTC_INITIALIZATION) ? "init" : "term",
3377              (int)ptr->func.fntc_entry_loc[i].adr_lcid,
3378              (long)ptr->func.fntc_entry_loc[i].adr_sctoff,
3379              (long)ptr->func.fntc_entry_loc[i].adr_sctoff);
3380
3381 }
3382
3383 \f
3384 /* Print the global header for an OSF/rose object.  */
3385
3386 static void
3387 print_header (hdr_ptr)
3388      mo_header_t *hdr_ptr;
3389 {
3390   fprintf (stderr, "\nglobal header:\n");
3391   fprintf (stderr, "\tmoh_magic            = 0x%.8lx\n", hdr_ptr->moh_magic);
3392   fprintf (stderr, "\tmoh_major_version    = %d\n", (int)hdr_ptr->moh_major_version);
3393   fprintf (stderr, "\tmoh_minor_version    = %d\n", (int)hdr_ptr->moh_minor_version);
3394   fprintf (stderr, "\tmoh_header_version   = %d\n", (int)hdr_ptr->moh_header_version);
3395   fprintf (stderr, "\tmoh_max_page_size    = %d\n", (int)hdr_ptr->moh_max_page_size);
3396   fprintf (stderr, "\tmoh_byte_order       = %d\n", (int)hdr_ptr->moh_byte_order);
3397   fprintf (stderr, "\tmoh_data_rep_id      = %d\n", (int)hdr_ptr->moh_data_rep_id);
3398   fprintf (stderr, "\tmoh_cpu_type         = %d\n", (int)hdr_ptr->moh_cpu_type);
3399   fprintf (stderr, "\tmoh_cpu_subtype      = %d\n", (int)hdr_ptr->moh_cpu_subtype);
3400   fprintf (stderr, "\tmoh_vendor_type      = %d\n", (int)hdr_ptr->moh_vendor_type);
3401   fprintf (stderr, "\tmoh_load_map_cmd_off = %d\n", (int)hdr_ptr->moh_load_map_cmd_off);
3402   fprintf (stderr, "\tmoh_first_cmd_off    = %d\n", (int)hdr_ptr->moh_first_cmd_off);
3403   fprintf (stderr, "\tmoh_sizeofcmds       = %d\n", (int)hdr_ptr->moh_sizeofcmds);
3404   fprintf (stderr, "\tmon_n_load_cmds      = %d\n", (int)hdr_ptr->moh_n_load_cmds);
3405   fprintf (stderr, "\tmoh_flags            = 0x%.8lx", (long)hdr_ptr->moh_flags);
3406
3407   if (hdr_ptr->moh_flags & MOH_RELOCATABLE_F)
3408     fprintf (stderr, ", relocatable");
3409
3410   if (hdr_ptr->moh_flags & MOH_LINKABLE_F)
3411     fprintf (stderr, ", linkable");
3412
3413   if (hdr_ptr->moh_flags & MOH_EXECABLE_F)
3414     fprintf (stderr, ", execable");
3415
3416   if (hdr_ptr->moh_flags & MOH_EXECUTABLE_F)
3417     fprintf (stderr, ", executable");
3418
3419   if (hdr_ptr->moh_flags & MOH_UNRESOLVED_F)
3420     fprintf (stderr, ", unresolved");
3421
3422   fprintf (stderr, "\n\n");
3423   return;
3424 }
3425
3426 \f
3427 /* Print a short summary of a load command.  */
3428
3429 static void
3430 print_load_command (load_hdr, offset, number)
3431      load_union_t *load_hdr;
3432      size_t offset;
3433      int number;
3434 {
3435   mo_long_t type = load_hdr->hdr.ldci_cmd_type;
3436   char *type_str = (char *) 0;
3437
3438   switch (type)
3439     {
3440     case LDC_UNDEFINED:   type_str = "UNDEFINED";       break;
3441     case LDC_CMD_MAP:     type_str = "CMD_MAP";         break;
3442     case LDC_INTERPRETER: type_str = "INTERPRETER";     break;
3443     case LDC_STRINGS:     type_str = "STRINGS";         break;
3444     case LDC_REGION:      type_str = "REGION";          break;
3445     case LDC_RELOC:       type_str = "RELOC";           break;
3446     case LDC_PACKAGE:     type_str = "PACKAGE";         break;
3447     case LDC_SYMBOLS:     type_str = "SYMBOLS";         break;
3448     case LDC_ENTRY:       type_str = "ENTRY";           break;
3449     case LDC_FUNC_TABLE:  type_str = "FUNC_TABLE";      break;
3450     case LDC_GEN_INFO:    type_str = "GEN_INFO";        break;
3451     }
3452
3453   fprintf (stderr,
3454            "cmd %2d, sz: 0x%.2lx, coff: 0x%.3lx, doff: 0x%.6lx, dlen: 0x%.6lx",
3455            number,
3456            (long) load_hdr->hdr.ldci_cmd_size,
3457            (long) offset,
3458            (long) load_hdr->hdr.ldci_section_off,
3459            (long) load_hdr->hdr.ldci_section_len);
3460
3461   if (type_str == (char *) 0)
3462     fprintf (stderr, ", ty: unknown (%ld)\n", (long) type);
3463
3464   else if (type != LDC_REGION)
3465     fprintf (stderr, ", ty: %s\n", type_str);
3466
3467   else
3468     {
3469       char *region = "";
3470       switch (load_hdr->region.regc_usage_type)
3471         {
3472         case REG_TEXT_T:        region = ", .text";     break;
3473         case REG_DATA_T:        region = ", .data";     break;
3474         case REG_BSS_T:         region = ", .bss";      break;
3475         case REG_GLUE_T:        region = ", .glue";     break;
3476 #if defined (REG_RDATA_T) && defined (REG_SDATA_T) && defined (REG_SBSS_T) /*mips*/
3477         case REG_RDATA_T:       region = ", .rdata";    break;
3478         case REG_SDATA_T:       region = ", .sdata";    break;
3479         case REG_SBSS_T:        region = ", .sbss";     break;
3480 #endif
3481         }
3482
3483       fprintf (stderr, ", ty: %s, vaddr: 0x%.8lx, vlen: 0x%.6lx%s\n",
3484                type_str,
3485                (long) load_hdr->region.regc_vm_addr,
3486                (long) load_hdr->region.regc_vm_size,
3487                region);
3488     }
3489
3490   return;
3491 }
3492
3493 \f
3494 /* Fatal error when {en,de}code_mach_o_header fails.  */
3495
3496 static void
3497 bad_header (status)
3498      int status;
3499 {
3500   char *msg = (char *) 0;
3501
3502   switch (status)
3503     {
3504     case MO_ERROR_BAD_MAGIC:            msg = "bad magic number";               break;
3505     case MO_ERROR_BAD_HDR_VERS:         msg = "bad header version";             break;
3506     case MO_ERROR_BAD_RAW_HDR_VERS:     msg = "bad raw header version";         break;
3507     case MO_ERROR_BUF2SML:              msg = "raw header buffer too small";    break;
3508     case MO_ERROR_OLD_RAW_HDR_FILE:     msg = "old raw header file";            break;
3509     case MO_ERROR_UNSUPPORTED_VERS:     msg = "unsupported version";            break;
3510     }
3511
3512   if (msg == (char *) 0)
3513     fatal ("unknown {de,en}code_mach_o_hdr return value %d", status);
3514   else
3515     fatal ("%s", msg);
3516 }
3517
3518 \f
3519 /* Read a file into a memory buffer.  */
3520
3521 static struct file_info *
3522 read_file (name, fd, rw)
3523      char *name;                /* filename */
3524      int fd;                    /* file descriptor */
3525      int rw;                    /* read/write */
3526 {
3527   struct stat stat_pkt;
3528   struct file_info *p = (struct file_info *) xcalloc (sizeof (struct file_info), 1);
3529 #ifdef USE_MMAP
3530   static int page_size;
3531 #endif
3532
3533   if (fstat (fd, &stat_pkt) < 0)
3534     fatal_perror ("fstat %s", name);
3535
3536   p->name         = name;
3537   p->size         = stat_pkt.st_size;
3538   p->rounded_size = stat_pkt.st_size;
3539   p->fd           = fd;
3540   p->rw           = rw;
3541
3542 #ifdef USE_MMAP
3543   if (debug)
3544     fprintf (stderr, "mmap %s, %s\n", name, (rw) ? "read/write" : "read-only");
3545
3546   if (page_size == 0)
3547     page_size = sysconf (_SC_PAGE_SIZE);
3548
3549   p->rounded_size = ((p->size + page_size - 1) / page_size) * page_size;
3550   p->start = mmap ((caddr_t) 0,
3551                    (rw) ? p->rounded_size : p->size,
3552                    (rw) ? (PROT_READ | PROT_WRITE) : PROT_READ,
3553                    MAP_FILE | MAP_VARIABLE | MAP_SHARED,
3554                    fd,
3555                    0L);
3556
3557   if (p->start != (char *) 0 && p->start != (char *) -1)
3558     p->use_mmap = 1;
3559
3560   else
3561 #endif /* USE_MMAP */
3562     {
3563       long len;
3564
3565       if (debug)
3566         fprintf (stderr, "read %s\n", name);
3567
3568       p->use_mmap = 0;
3569       p->start = xmalloc (p->size);
3570       if (lseek (fd, 0L, SEEK_SET) < 0)
3571         fatal_perror ("lseek to 0 on %s", name);
3572
3573       len = read (fd, p->start, p->size);
3574       if (len < 0)
3575         fatal_perror ("read %s", name);
3576
3577       if (len != p->size)
3578         fatal ("read %ld bytes, expected %ld, from %s", len, p->size, name);
3579     }
3580
3581   return p;
3582 }
3583 \f
3584 /* Do anything necessary to write a file back from memory.  */
3585
3586 static void
3587 end_file (ptr)
3588      struct file_info *ptr;     /* file information block */
3589 {
3590 #ifdef USE_MMAP
3591   if (ptr->use_mmap)
3592     {
3593       if (ptr->rw)
3594         {
3595           if (debug)
3596             fprintf (stderr, "msync %s\n", ptr->name);
3597
3598           if (msync (ptr->start, ptr->rounded_size, MS_ASYNC))
3599             fatal_perror ("msync %s", ptr->name);
3600         }
3601
3602       if (debug)
3603         fprintf (stderr, "munmap %s\n", ptr->name);
3604
3605       if (munmap (ptr->start, ptr->size))
3606         fatal_perror ("munmap %s", ptr->name);
3607     }
3608   else
3609 #endif /* USE_MMAP */
3610     {
3611       if (ptr->rw)
3612         {
3613           long len;
3614
3615           if (debug)
3616             fprintf (stderr, "write %s\n", ptr->name);
3617
3618           if (lseek (ptr->fd, 0L, SEEK_SET) < 0)
3619             fatal_perror ("lseek to 0 on %s", ptr->name);
3620
3621           len = write (ptr->fd, ptr->start, ptr->size);
3622           if (len < 0)
3623             fatal_perror ("write %s", ptr->name);
3624
3625           if (len != ptr->size)
3626             fatal ("wrote %ld bytes, expected %ld, to %s", len, ptr->size, ptr->name);
3627         }
3628
3629       free (ptr->start);
3630     }
3631
3632   free (ptr);
3633 }
3634
3635 #endif /* OBJECT_FORMAT_ROSE */