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 *getenv ();
 249 extern char *mktemp ();
 250 extern FILE *fdopen ();
 251
 252 #ifndef GET_ENVIRONMENT
 253 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ENV_VALUE = getenv (ENV_NAME)
 254 #endif
 255
 256 /* Structure to hold all the directories in which to search for files to
 257    execute.  */
 258
 259 struct prefix_list
 260 {
 261   char *prefix;               /* String to prepend to the path.  */
 262   struct prefix_list *next;   /* Next in linked list.  */
 263 };
 264
 265 struct path_prefix
 266 {
 267   struct prefix_list *plist;  /* List of prefixes to try */
 268   int max_len;                /* Max length of a prefix in PLIST */
 269   char *name;                 /* Name of this list (used in config stuff) */
 270 };
 271
 272 #ifdef COLLECT_EXPORT_LIST
 273 /* Lists to keep libraries to be scanned for global constructors/destructors. */
 274 static struct head libs;                    /* list of libraries */
 275 static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
 276 static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
 277 static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
 278                                           &libpath_lib_dirs, NULL};
 279 static char *libexts[3] = {"a", "so", NULL};  /* possible library extentions */
 280 #endif
 281
 282 void collect_exit               PROTO((int));
 283 void collect_execute            PROTO((char *, char **, char *));
 284 void dump_file                  PROTO((char *));
 285 static void handler             PROTO((int));
 286 static int is_ctor_dtor         PROTO((char *));
 287 static char *find_a_file        PROTO((struct path_prefix *, char *));
 288 static void add_prefix          PROTO((struct path_prefix *, char *));
 289 static void prefix_from_env     PROTO((char *, struct path_prefix *));
 290 static void prefix_from_string  PROTO((char *, struct path_prefix *));
 291 static void do_wait             PROTO((char *));
 292 static void fork_execute        PROTO((char *, char **));
 293 static void maybe_unlink        PROTO((char *));
 294 static void add_to_list         PROTO((struct head *, char *));
 295 static void write_list          PROTO((FILE *, char *, struct id *));
 296 static void dump_list           PROTO((FILE *, char *, struct id *));
 297 static void dump_prefix_list    PROTO((FILE *, char *, struct prefix_list *));
 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 || ! do_collecting)
1432     {
1433 #ifdef COLLECT_EXPORT_LIST
1434       /* But make sure we delete the export file we may have created.  */
1435       if (export_file != 0 && export_file[0])
1436         maybe_unlink (export_file);
1437       if (import_file != 0 && import_file[0])
1438         maybe_unlink (import_file);
1439 #endif
1440       return 0;
1441     }
1442
1443   /* Examine the namelist with nm and search it for static constructors
1444      and destructors to call.
1445      Write the constructor and destructor tables to a .s file and reload.  */
1446
1447   /* On AIX we already done scanning for global constructors/destructors.  */
1448 #ifndef COLLECT_EXPORT_LIST
1449   scan_prog_file (output_file, PASS_FIRST);
1450 #endif
1451
1452 #ifdef SCAN_LIBRARIES
1453   scan_libraries (output_file);
1454 #endif
1455
1456   if (debug)
1457     {
1458       fprintf (stderr, "%d constructor(s) found\n", constructors.number);
1459       fprintf (stderr, "%d destructor(s)  found\n", destructors.number);
1460     }
1461
1462   if (constructors.number == 0 && destructors.number == 0
1463       && frame_tables.number == 0
1464 #if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
1465       /* If we will be running these functions ourselves, we want to emit
1466          stubs into the shared library so that we do not have to relink
1467          dependent programs when we add static objects.  */
1468       && ! shared_obj
1469 #endif
1470       )
1471     {
1472 #ifdef COLLECT_EXPORT_LIST
1473       /* Doing tlink without additional code generation */
1474       do_tlink (ld1_argv, object_lst);
1475 #endif
1476       /* Strip now if it was requested on the command line.  */
1477       if (strip_flag)
1478         {
1479           char **strip_argv = (char **) xcalloc (sizeof (char *), 3);
1480           strip_argv[0] = strip_file_name;
1481           strip_argv[1] = output_file;
1482           strip_argv[2] = (char *) 0;
1483           fork_execute ("strip", strip_argv);
1484         }
1485
1486 #ifdef COLLECT_EXPORT_LIST
1487       maybe_unlink (export_file);
1488       maybe_unlink (import_file);
1489 #endif
1490       return 0;
1491     }
1492
1493   maybe_unlink(output_file);
1494   outf = fopen (c_file, "w");
1495   if (outf == (FILE *) 0)
1496     fatal_perror ("%s", c_file);
1497
1498   write_c_file (outf, c_file);
1499
1500   if (fclose (outf))
1501     fatal_perror ("closing %s", c_file);
1502
1503   /* Tell the linker that we have initializer and finalizer functions.  */
1504 #ifdef LD_INIT_SWITCH
1505   *ld2++ = LD_INIT_SWITCH;
1506   *ld2++ = initname;
1507   *ld2++ = LD_FINI_SWITCH;
1508   *ld2++ = fininame;
1509 #endif
1510   *ld2 = (char*) 0;
1511
1512 #ifdef COLLECT_EXPORT_LIST
1513   if (shared_obj)
1514     {
1515       add_to_list (&exports, initname);
1516       add_to_list (&exports, fininame);
1517       add_to_list (&exports, "_GLOBAL__DI");
1518       add_to_list (&exports, "_GLOBAL__DD");
1519       exportf = fopen (export_file, "w");
1520       if (exportf == (FILE *) 0)
1521         fatal_perror ("%s", export_file);
1522       write_export_file (exportf);
1523       if (fclose (exportf))
1524         fatal_perror ("closing %s", export_file);
1525     }
1526 #endif
1527
1528   if (debug)
1529     {
1530       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
1531                output_file, c_file);
1532       write_c_file (stderr, "stderr");
1533       fprintf (stderr, "========== end of c_file\n\n");
1534 #ifdef COLLECT_EXPORT_LIST
1535       fprintf (stderr, "\n========== export_file = %s\n", export_file);
1536       write_export_file (stderr);
1537       fprintf (stderr, "========== end of export_file\n\n");
1538 #endif
1539     }
1540
1541   /* Assemble the constructor and destructor tables.
1542      Link the tables in with the rest of the program.  */
1543
1544   fork_execute ("gcc",  c_argv);
1545 #ifdef COLLECT_EXPORT_LIST
1546   /* On AIX we must call tlink because of possible templates resolution */
1547   do_tlink (ld2_argv, object_lst);
1548 #else
1549   /* Otherwise, simply call ld because tlink is already done */
1550   fork_execute ("ld", ld2_argv);
1551
1552   /* Let scan_prog_file do any final mods (OSF/rose needs this for
1553      constructors/destructors in shared libraries.  */
1554   scan_prog_file (output_file, PASS_SECOND);
1555 #endif
1556
1557   maybe_unlink (c_file);
1558   maybe_unlink (o_file);
1559
1560 #ifdef COLLECT_EXPORT_LIST
1561   maybe_unlink (export_file);
1562   maybe_unlink (import_file);
1563 #endif
1564
1565   return 0;
1566 }
1567
1568 \f
1569 /* Wait for a process to finish, and exit if a non-zero status is found.  */
1570
1571 int
1572 collect_wait (prog)
1573      char *prog;
1574 {
1575   int status;
1576
1577   wait (&status);
1578   if (status)
1579     {
1580       if (WIFSIGNALED (status))
1581         {
1582           int sig = WTERMSIG (status);
1583 #ifdef NO_SYS_SIGLIST
1584           error ("%s terminated with signal %d %s",
1585                  prog,
1586                  sig,
1587                  (status & 0200) ? ", core dumped" : "");
1588 #else
1589           error ("%s terminated with signal %d [%s]%s",
1590                  prog,
1591                  sig,
1592                  sys_siglist[sig],
1593                  (status & 0200) ? ", core dumped" : "");
1594 #endif
1595
1596           collect_exit (FATAL_EXIT_CODE);
1597         }
1598
1599       if (WIFEXITED (status))
1600         return WEXITSTATUS (status);
1601     }
1602   return 0;
1603 }
1604
1605 static void
1606 do_wait (prog)
1607      char *prog;
1608 {
1609   int ret = collect_wait (prog);
1610   if (ret != 0)
1611     {
1612       error ("%s returned %d exit status", prog, ret);
1613       collect_exit (ret);
1614     }
1615 }
1616
1617 \f
1618 /* Fork and execute a program, and wait for the reply.  */
1619
1620 void
1621 collect_execute (prog, argv, redir)
1622      char *prog;
1623      char **argv;
1624      char *redir;
1625 {
1626   int pid;
1627
1628   if (vflag || debug)
1629     {
1630       char **p_argv;
1631       char *str;
1632
1633       if (argv[0])
1634         fprintf (stderr, "%s", argv[0]);
1635       else
1636         fprintf (stderr, "[cannot find %s]", prog);
1637
1638       for (p_argv = &argv[1]; (str = *p_argv) != (char *) 0; p_argv++)
1639         fprintf (stderr, " %s", str);
1640
1641       fprintf (stderr, "\n");
1642     }
1643
1644   fflush (stdout);
1645   fflush (stderr);
1646
1647   /* If we cannot find a program we need, complain error.  Do this here
1648      since we might not end up needing something that we could not find.  */
1649
1650   if (argv[0] == 0)
1651     fatal ("cannot find `%s'", prog);
1652
1653 #ifndef __CYGWIN32__
1654   pid = vfork ();
1655   if (pid == -1)
1656     {
1657 #ifdef vfork
1658       fatal_perror ("fork");
1659 #else
1660       fatal_perror ("vfork");
1661 #endif
1662     }
1663
1664   if (pid == 0)                 /* child context */
1665     {
1666       if (redir)
1667         {
1668           unlink (redir);
1669           if (freopen (redir, "a", stdout) == NULL)
1670             fatal_perror ("redirecting stdout: %s", redir);
1671           if (freopen (redir, "a", stderr) == NULL)
1672             fatal_perror ("redirecting stderr: %s", redir);
1673         }
1674
1675       execvp (argv[0], argv);
1676       fatal_perror ("executing %s", prog);
1677     }
1678 #else
1679   pid = _spawnvp (_P_NOWAIT, argv[0], argv);
1680   if (pid == -1)
1681     fatal ("spawnvp failed");
1682 #endif
1683 }
1684
1685 static void
1686 fork_execute (prog, argv)
1687      char *prog;
1688      char **argv;
1689 {
1690   collect_execute (prog, argv, NULL);
1691   do_wait (prog);
1692 }
1693 \f
1694 /* Unlink a file unless we are debugging.  */
1695
1696 static void
1697 maybe_unlink (file)
1698      char *file;
1699 {
1700   if (!debug)
1701     unlink (file);
1702   else
1703     fprintf (stderr, "[Leaving %s]\n", file);
1704 }
1705
1706 \f
1707 /* Add a name to a linked list.  */
1708
1709 static void
1710 add_to_list (head_ptr, name)
1711      struct head *head_ptr;
1712      char *name;
1713 {
1714   struct id *newid
1715     = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
1716   struct id *p;
1717   static long sequence_number = 0;
1718   strcpy (newid->name, name);
1719
1720   if (head_ptr->first)
1721     head_ptr->last->next = newid;
1722   else
1723     head_ptr->first = newid;
1724
1725   /* Check for duplicate symbols.  */
1726   for (p = head_ptr->first;
1727        strcmp (name, p->name) != 0;
1728        p = p->next)
1729     ;
1730   if (p != newid)
1731     {
1732       head_ptr->last->next = 0;
1733       free (newid);
1734       return;
1735     }
1736
1737   newid->sequence = ++sequence_number;
1738   head_ptr->last = newid;
1739   head_ptr->number++;
1740 }
1741
1742 /* Write: `prefix', the names on list LIST, `suffix'.  */
1743
1744 static void
1745 write_list (stream, prefix, list)
1746      FILE *stream;
1747      char *prefix;
1748      struct id *list;
1749 {
1750   while (list)
1751     {
1752       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
1753       list = list->next;
1754     }
1755 }
1756
1757 #ifdef COLLECT_EXPORT_LIST
1758 /* This function is really used only on AIX, but may be useful.  */
1759 static int
1760 is_in_list (prefix, list)
1761      char *prefix;
1762      struct id *list;
1763 {
1764   while (list)
1765     {
1766       if (!strcmp (prefix, list->name)) return 1;
1767       list = list->next;
1768     }
1769     return 0;
1770 }
1771 #endif
1772
1773 /* Added for debugging purpose.  */
1774 static void
1775 dump_list (stream, prefix, list)
1776      FILE *stream;
1777      char *prefix;
1778      struct id *list;
1779 {
1780   while (list)
1781     {
1782       fprintf (stream, "%s%s,\n", prefix, list->name);
1783       list = list->next;
1784     }
1785 }
1786
1787 static void
1788 dump_prefix_list (stream, prefix, list)
1789      FILE *stream;
1790      char *prefix;
1791      struct prefix_list *list;
1792 {
1793   while (list)
1794     {
1795       fprintf (stream, "%s%s,\n", prefix, list->prefix);
1796       list = list->next;
1797     }
1798 }
1799
1800 static void
1801 write_list_with_asm (stream, prefix, list)
1802      FILE *stream;
1803      char *prefix;
1804      struct id *list;
1805 {
1806   while (list)
1807     {
1808       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
1809                prefix, list->sequence, list->name);
1810       list = list->next;
1811     }
1812 }
1813
1814 /* Write out the constructor and destructor tables statically (for a shared
1815    object), along with the functions to execute them.  */
1816
1817 static void
1818 write_c_file_stat (stream, name)
1819      FILE *stream;
1820      char *name;
1821 {
1822   char *prefix, *p, *q;
1823   int frames = (frame_tables.number > 0);
1824
1825   /* Figure out name of output_file, stripping off .so version.  */
1826   p = rindex (output_file, '/');
1827   if (p == 0)
1828     p = (char *) output_file;
1829   else
1830     p++;
1831   q = p;
1832   while (q)
1833     {
1834       q = index (q,'.');
1835       if (q == 0)
1836         {
1837           q = p + strlen (p);
1838           break;
1839         }
1840       else
1841         {
1842           if (strncmp (q, ".so", 3) == 0)
1843             {
1844               q += 3;
1845               break;
1846             }
1847           else
1848             q++;
1849         }
1850     }
1851   /* q points to null at end of the string (or . of the .so version) */
1852   prefix = xmalloc (q - p + 1);
1853   strncpy (prefix, p, q - p);
1854   prefix[q - p] = 0;
1855   for (q = prefix; *q; q++)
1856     if (!isalnum (*q))
1857       *q = '_';
1858   if (debug)
1859     fprintf (stderr, "\nwrite_c_file - output name is %s, prefix is %s\n",
1860              output_file, prefix);
1861
1862 #define INIT_NAME_FORMAT "_GLOBAL__FI_%s"
1863   initname = xmalloc (strlen (prefix) + sizeof (INIT_NAME_FORMAT) - 2);
1864   sprintf (initname, INIT_NAME_FORMAT, prefix);
1865
1866 #define FINI_NAME_FORMAT "_GLOBAL__FD_%s"
1867   fininame = xmalloc (strlen (prefix) + sizeof (FINI_NAME_FORMAT) - 2);
1868   sprintf (fininame, FINI_NAME_FORMAT, prefix);
1869
1870   free (prefix);
1871
1872   /* Write the tables as C code  */
1873
1874   fprintf (stream, "static int count;\n");
1875   fprintf (stream, "typedef void entry_pt();\n");
1876   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1877
1878   if (frames)
1879     {
1880       write_list_with_asm (stream, "extern void *", frame_tables.first);
1881
1882       fprintf (stream, "\tstatic void *frame_table[] = {\n");
1883       write_list (stream, "\t\t&", frame_tables.first);
1884       fprintf (stream, "\t0\n};\n");
1885
1886       /* This must match what's in frame.h.  */
1887       fprintf (stream, "struct object {\n");
1888       fprintf (stream, "  void *pc_begin;\n");
1889       fprintf (stream, "  void *pc_end;\n");
1890       fprintf (stream, "  void *fde_begin;\n");
1891       fprintf (stream, "  void *fde_array;\n");
1892       fprintf (stream, "  __SIZE_TYPE__ count;\n");
1893       fprintf (stream, "  struct object *next;\n");
1894       fprintf (stream, "};\n");
1895
1896       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1897       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1898
1899       fprintf (stream, "static void reg_frame () {\n");
1900       fprintf (stream, "\tstatic struct object ob;\n");
1901       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1902       fprintf (stream, "\t}\n");
1903
1904       fprintf (stream, "static void dereg_frame () {\n");
1905       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1906       fprintf (stream, "\t}\n");
1907     }
1908
1909   fprintf (stream, "void %s() {\n", initname);
1910   if (constructors.number > 0 || frames)
1911     {
1912       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
1913       write_list (stream, "\t\t", constructors.first);
1914       if (frames)
1915         fprintf (stream, "\treg_frame,\n");
1916       fprintf (stream, "\t};\n");
1917       fprintf (stream, "\tentry_pt **p;\n");
1918       fprintf (stream, "\tif (count++ != 0) return;\n");
1919       fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
1920       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
1921     }
1922   else
1923     fprintf (stream, "\t++count;\n");
1924   fprintf (stream, "}\n");
1925   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
1926   fprintf (stream, "void %s() {\n", fininame);
1927   if (destructors.number > 0 || frames)
1928     {
1929       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
1930       write_list (stream, "\t\t", destructors.first);
1931       if (frames)
1932         fprintf (stream, "\tdereg_frame,\n");
1933       fprintf (stream, "\t};\n");
1934       fprintf (stream, "\tentry_pt **p;\n");
1935       fprintf (stream, "\tif (--count != 0) return;\n");
1936       fprintf (stream, "\tp = dtors;\n");
1937       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
1938                destructors.number + frames);
1939     }
1940   fprintf (stream, "}\n");
1941
1942   if (shared_obj)
1943     {
1944       fprintf (stream, "void _GLOBAL__DI() {\n\t%s();\n}\n", initname);
1945       fprintf (stream, "void _GLOBAL__DD() {\n\t%s();\n}\n", fininame);
1946     }
1947 }
1948
1949 /* Write the constructor/destructor tables.  */
1950
1951 #ifndef LD_INIT_SWITCH
1952 static void
1953 write_c_file_glob (stream, name)
1954      FILE *stream;
1955      char *name;
1956 {
1957   /* Write the tables as C code  */
1958
1959   int frames = (frame_tables.number > 0);
1960
1961   fprintf (stream, "typedef void entry_pt();\n\n");
1962
1963   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
1964
1965   if (frames)
1966     {
1967       write_list_with_asm (stream, "extern void *", frame_tables.first);
1968
1969       fprintf (stream, "\tstatic void *frame_table[] = {\n");
1970       write_list (stream, "\t\t&", frame_tables.first);
1971       fprintf (stream, "\t0\n};\n");
1972
1973       /* This must match what's in frame.h.  */
1974       fprintf (stream, "struct object {\n");
1975       fprintf (stream, "  void *pc_begin;\n");
1976       fprintf (stream, "  void *pc_end;\n");
1977       fprintf (stream, "  void *fde_begin;\n");
1978       fprintf (stream, "  void *fde_array;\n");
1979       fprintf (stream, "  __SIZE_TYPE__ count;\n");
1980       fprintf (stream, "  struct object *next;\n");
1981       fprintf (stream, "};\n");
1982
1983       fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
1984       fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
1985
1986       fprintf (stream, "static void reg_frame () {\n");
1987       fprintf (stream, "\tstatic struct object ob;\n");
1988       fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
1989       fprintf (stream, "\t}\n");
1990
1991       fprintf (stream, "static void dereg_frame () {\n");
1992       fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
1993       fprintf (stream, "\t}\n");
1994     }
1995
1996   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
1997   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
1998   write_list (stream, "\t", constructors.first);
1999   if (frames)
2000     fprintf (stream, "\treg_frame,\n");
2001   fprintf (stream, "\t0\n};\n\n");
2002
2003   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
2004
2005   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
2006   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
2007   write_list (stream, "\t", destructors.first);
2008   if (frames)
2009     fprintf (stream, "\tdereg_frame,\n");
2010   fprintf (stream, "\t0\n};\n\n");
2011
2012   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
2013   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
2014 }
2015 #endif /* ! LD_INIT_SWITCH */
2016
2017 static void
2018 write_c_file (stream, name)
2019      FILE *stream;
2020      char *name;
2021 {
2022   fprintf (stream, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n");
2023 #ifndef LD_INIT_SWITCH
2024   if (! shared_obj)
2025     write_c_file_glob (stream, name);
2026   else
2027 #endif
2028     write_c_file_stat (stream, name);
2029   fprintf (stream, "#ifdef __cplusplus\n}\n#endif\n");
2030 }
2031
2032 #ifdef COLLECT_EXPORT_LIST
2033 static void
2034 write_export_file (stream)
2035      FILE *stream;
2036 {
2037   struct id *list = exports.first;
2038   for (; list; list = list->next)
2039     fprintf (stream, "%s\n", list->name);
2040 }
2041
2042 static void
2043 write_import_file (stream)
2044      FILE *stream;
2045 {
2046   struct id *list = imports.first;
2047   fprintf (stream, "%s\n", "#! .");
2048   for (; list; list = list->next)
2049     fprintf (stream, "%s\n", list->name);
2050 }
2051 #endif
2052 \f
2053 #ifdef OBJECT_FORMAT_NONE
2054
2055 /* Generic version to scan the name list of the loaded program for
2056    the symbols g++ uses for static constructors and destructors.
2057
2058    The constructor table begins at __CTOR_LIST__ and contains a count
2059    of the number of pointers (or -1 if the constructors are built in a
2060    separate section by the linker), followed by the pointers to the
2061    constructor functions, terminated with a null pointer.  The
2062    destructor table has the same format, and begins at __DTOR_LIST__.  */
2063
2064 static void
2065 scan_prog_file (prog_name, which_pass)
2066      char *prog_name;
2067      enum pass which_pass;
2068 {
2069   void (*int_handler) ();
2070   void (*quit_handler) ();
2071   char *nm_argv[4];
2072   int pid;
2073   int argc = 0;
2074   int pipe_fd[2];
2075   char *p, buf[1024];
2076   FILE *inf;
2077
2078   if (which_pass == PASS_SECOND)
2079     return;
2080
2081   /* If we do not have an `nm', complain.  */
2082   if (nm_file_name == 0)
2083     fatal ("cannot find `nm'");
2084
2085   nm_argv[argc++] = nm_file_name;
2086   if (NM_FLAGS[0] != '\0')
2087     nm_argv[argc++] = NM_FLAGS;
2088
2089   nm_argv[argc++] = prog_name;
2090   nm_argv[argc++] = (char *) 0;
2091
2092   if (pipe (pipe_fd) < 0)
2093     fatal_perror ("pipe");
2094
2095   inf = fdopen (pipe_fd[0], "r");
2096   if (inf == (FILE *) 0)
2097     fatal_perror ("fdopen");
2098
2099   /* Trace if needed.  */
2100   if (vflag)
2101     {
2102       char **p_argv;
2103       char *str;
2104
2105       for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2106         fprintf (stderr, " %s", str);
2107
2108       fprintf (stderr, "\n");
2109     }
2110
2111   fflush (stdout);
2112   fflush (stderr);
2113
2114   /* Spawn child nm on pipe */
2115   pid = vfork ();
2116   if (pid == -1)
2117     {
2118 #ifdef vfork
2119       fatal_perror ("fork");
2120 #else
2121       fatal_perror ("vfork");
2122 #endif
2123     }
2124
2125   if (pid == 0)                 /* child context */
2126     {
2127       /* setup stdout */
2128       if (dup2 (pipe_fd[1], 1) < 0)
2129         fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
2130
2131       if (close (pipe_fd[0]) < 0)
2132         fatal_perror ("close (%d)", pipe_fd[0]);
2133
2134       if (close (pipe_fd[1]) < 0)
2135         fatal_perror ("close (%d)", pipe_fd[1]);
2136
2137       execv (nm_file_name, nm_argv);
2138       fatal_perror ("executing %s", nm_file_name);
2139     }
2140
2141   /* Parent context from here on.  */
2142   int_handler  = (void (*) ())signal (SIGINT,  SIG_IGN);
2143 #ifdef SIGQUIT
2144   quit_handler = (void (*) ())signal (SIGQUIT, SIG_IGN);
2145 #endif
2146
2147   if (close (pipe_fd[1]) < 0)
2148     fatal_perror ("close (%d)", pipe_fd[1]);
2149
2150   if (debug)
2151     fprintf (stderr, "\nnm output with constructors/destructors.\n");
2152
2153   /* Read each line of nm output.  */
2154   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2155     {
2156       int ch, ch2;
2157       char *name, *end;
2158
2159       /* If it contains a constructor or destructor name, add the name
2160          to the appropriate list.  */
2161
2162       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
2163         if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
2164           break;
2165
2166       if (ch != '_')
2167         continue;
2168
2169       name = p;
2170       /* Find the end of the symbol name.
2171          Do not include `|', because Encore nm can tack that on the end.  */
2172       for (end = p; (ch2 = *end) != '\0' && !isspace (ch2) && ch2 != '|';
2173            end++)
2174         continue;
2175
2176
2177       *end = '\0';
2178       switch (is_ctor_dtor (name))
2179         {
2180         case 1:
2181           if (which_pass != PASS_LIB)
2182             add_to_list (&constructors, name);
2183           break;
2184
2185         case 2:
2186           if (which_pass != PASS_LIB)
2187             add_to_list (&destructors, name);
2188           break;
2189
2190         case 3:
2191           if (which_pass != PASS_LIB)
2192             fatal ("init function found in object %s", prog_name);
2193 #ifndef LD_INIT_SWITCH
2194           add_to_list (&constructors, name);
2195 #endif
2196           break;
2197
2198         case 4:
2199           if (which_pass != PASS_LIB)
2200             fatal ("fini function found in object %s", prog_name);
2201 #ifndef LD_FINI_SWITCH
2202           add_to_list (&destructors, name);
2203 #endif
2204           break;
2205
2206         case 5:
2207           if (which_pass != PASS_LIB)
2208             add_to_list (&frame_tables, name);
2209
2210         default:                /* not a constructor or destructor */
2211           continue;
2212         }
2213
2214       if (debug)
2215         fprintf (stderr, "\t%s\n", buf);
2216     }
2217
2218   if (debug)
2219     fprintf (stderr, "\n");
2220
2221   if (fclose (inf) != 0)
2222     fatal_perror ("fclose of pipe");
2223
2224   do_wait (nm_file_name);
2225
2226   signal (SIGINT,  int_handler);
2227 #ifdef SIGQUIT
2228   signal (SIGQUIT, quit_handler);
2229 #endif
2230 }
2231
2232 #if SUNOS4_SHARED_LIBRARIES
2233
2234 /* Routines to scan the SunOS 4 _DYNAMIC structure to find shared libraries
2235    that the output file depends upon and their initialization/finalization
2236    routines, if any.  */
2237
2238 #include <a.out.h>
2239 #include <fcntl.h>
2240 #include <link.h>
2241 #include <sys/mman.h>
2242 #include <sys/param.h>
2243 #include <unistd.h>
2244 #include <sys/dir.h>
2245
2246 /* pointers to the object file */
2247 unsigned object;        /* address of memory mapped file */
2248 unsigned objsize;       /* size of memory mapped to file */
2249 char * code;            /* pointer to code segment */
2250 char * data;            /* pointer to data segment */
2251 struct nlist *symtab;   /* pointer to symbol table */
2252 struct link_dynamic *ld;
2253 struct link_dynamic_2 *ld_2;
2254 struct head libraries;
2255
2256 /* Map the file indicated by NAME into memory and store its address.  */
2257
2258 static void
2259 mapfile (name)
2260      char *name;
2261 {
2262   int fp;
2263   struct stat s;
2264   if ((fp = open (name, O_RDONLY)) == -1)
2265     fatal ("unable to open file '%s'", name);
2266   if (fstat (fp, &s) == -1)
2267     fatal ("unable to stat file '%s'", name);
2268
2269   objsize = s.st_size;
2270   object = (unsigned) mmap (0, objsize, PROT_READ|PROT_WRITE, MAP_PRIVATE,
2271                             fp, 0);
2272   if (object == -1)
2273     fatal ("unable to mmap file '%s'", name);
2274
2275   close (fp);
2276 }
2277
2278 /* Helpers for locatelib.  */
2279
2280 static char *libname;
2281
2282 static int
2283 libselect (d)
2284      struct direct *d;
2285 {
2286   return (strncmp (libname, d->d_name, strlen (libname)) == 0);
2287 }
2288
2289 /* If one file has an additional numeric extension past LIBNAME, then put
2290    that one first in the sort.  If both files have additional numeric
2291    extensions, then put the one with the higher number first in the sort.
2292
2293    We must verify that the extension is numeric, because Sun saves the
2294    original versions of patched libraries with a .FCS extension.  Files with
2295    invalid extensions must go last in the sort, so that they will not be used.  */
2296
2297 static int
2298 libcompare (d1, d2)
2299      struct direct **d1, **d2;
2300 {
2301   int i1, i2 = strlen (libname);
2302   char *e1 = (*d1)->d_name + i2;
2303   char *e2 = (*d2)->d_name + i2;
2304
2305   while (*e1 && *e2 && *e1 == '.' && *e2 == '.'
2306          && e1[1] && isdigit (e1[1]) && e2[1] && isdigit (e2[1]))
2307     {
2308       ++e1;
2309       ++e2;
2310       i1 = strtol (e1, &e1, 10);
2311       i2 = strtol (e2, &e2, 10);
2312       if (i1 != i2)
2313         return i1 - i2;
2314     }
2315
2316   if (*e1)
2317     {
2318       /* It has a valid numeric extension, prefer this one.  */
2319       if (*e1 == '.' && e1[1] && isdigit (e1[1]))
2320         return 1;
2321       /* It has a invalid numeric extension, must prefer the other one.  */
2322       else
2323         return -1;
2324     }
2325   else if (*e2)
2326     {
2327       /* It has a valid numeric extension, prefer this one.  */
2328       if (*e2 == '.' && e2[1] && isdigit (e2[1]))
2329         return -1;
2330       /* It has a invalid numeric extension, must prefer the other one.  */
2331       else
2332         return 1;
2333     }
2334   else
2335     return 0;
2336 }
2337
2338 /* Given the name NAME of a dynamic dependency, find its pathname and add
2339    it to the list of libraries.  */
2340
2341 static void
2342 locatelib (name)
2343      char *name;
2344 {
2345   static char **l;
2346   static int cnt;
2347   char buf[MAXPATHLEN];
2348   char *p, *q;
2349   char **pp;
2350
2351   if (l == 0)
2352     {
2353       char *ld_rules;
2354       char *ldr = 0;
2355       /* counting elements in array, need 1 extra for null */
2356       cnt = 1;
2357       ld_rules = (char *) (ld_2->ld_rules + code);
2358       if (ld_rules)
2359         {
2360           cnt++;
2361           for (; *ld_rules != 0; ld_rules++)
2362             if (*ld_rules == ':')
2363               cnt++;
2364           ld_rules = (char *) (ld_2->ld_rules + code);
2365           ldr = (char *) malloc (strlen (ld_rules) + 1);
2366           strcpy (ldr, ld_rules);
2367         }
2368       p = getenv ("LD_LIBRARY_PATH");
2369       q = 0;
2370       if (p)
2371         {
2372           cnt++;
2373           for (q = p ; *q != 0; q++)
2374             if (*q == ':')
2375               cnt++;
2376           q = (char *) malloc (strlen (p) + 1);
2377           strcpy (q, p);
2378         }
2379       l = (char **) malloc ((cnt + 3) * sizeof (char *));
2380       pp = l;
2381       if (ldr)
2382         {
2383           *pp++ = ldr;
2384           for (; *ldr != 0; ldr++)
2385             if (*ldr == ':')
2386               {
2387                 *ldr++ = 0;
2388                 *pp++ = ldr;
2389               }
2390         }
2391       if (q)
2392         {
2393           *pp++ = q;
2394           for (; *q != 0; q++)
2395             if (*q == ':')
2396               {
2397                 *q++ = 0;
2398                 *pp++ = q;
2399               }
2400         }
2401       /* built in directories are /lib, /usr/lib, and /usr/local/lib */
2402       *pp++ = "/lib";
2403       *pp++ = "/usr/lib";
2404       *pp++ = "/usr/local/lib";
2405       *pp = 0;
2406     }
2407   libname = name;
2408   for (pp = l; *pp != 0 ; pp++)
2409     {
2410       struct direct **namelist;
2411       int entries;
2412       if ((entries = scandir (*pp, &namelist, libselect, libcompare)) > 0)
2413         {
2414           sprintf (buf, "%s/%s", *pp, namelist[entries - 1]->d_name);
2415           add_to_list (&libraries, buf);
2416           if (debug)
2417             fprintf (stderr, "%s\n", buf);
2418           break;
2419         }
2420     }
2421   if (*pp == 0)
2422     {
2423       if (debug)
2424         fprintf (stderr, "not found\n");
2425       else
2426         fatal ("dynamic dependency %s not found", name);
2427     }
2428 }
2429
2430 /* Scan the _DYNAMIC structure of the output file to find shared libraries
2431    that it depends upon and any constructors or destructors they contain.  */
2432
2433 static void
2434 scan_libraries (prog_name)
2435      char *prog_name;
2436 {
2437   struct exec *header;
2438   char *base;
2439   struct link_object *lo;
2440   char buff[MAXPATHLEN];
2441   struct id *list;
2442
2443   mapfile (prog_name);
2444   header = (struct exec *)object;
2445   if (N_BADMAG (*header))
2446     fatal ("bad magic number in file '%s'", prog_name);
2447   if (header->a_dynamic == 0)
2448     return;
2449
2450   code = (char *) (N_TXTOFF (*header) + (long) header);
2451   data = (char *) (N_DATOFF (*header) + (long) header);
2452   symtab = (struct nlist *) (N_SYMOFF (*header) + (long) header);
2453
2454   if (header->a_magic == ZMAGIC && header->a_entry == 0x20)
2455     {
2456       /* shared object */
2457       ld = (struct link_dynamic *) (symtab->n_value + code);
2458       base = code;
2459     }
2460   else
2461     {
2462       /* executable */
2463       ld = (struct link_dynamic *) data;
2464       base = code-PAGSIZ;
2465     }
2466
2467   if (debug)
2468     fprintf (stderr, "dynamic dependencies.\n");
2469
2470   ld_2 = (struct link_dynamic_2 *) ((long) ld->ld_un.ld_2 + (long)base);
2471   for (lo = (struct link_object *) ld_2->ld_need; lo;
2472        lo = (struct link_object *) lo->lo_next)
2473     {
2474       char *name;
2475       lo = (struct link_object *) ((long) lo + code);
2476       name = (char *) (code + lo->lo_name);
2477       if (lo->lo_library)
2478         {
2479           if (debug)
2480             fprintf (stderr, "\t-l%s.%d => ", name, lo->lo_major);
2481           sprintf (buff, "lib%s.so.%d.%d", name, lo->lo_major, lo->lo_minor);
2482           locatelib (buff);
2483         }
2484       else
2485         {
2486           if (debug)
2487             fprintf (stderr, "\t%s\n", name);
2488           add_to_list (&libraries, name);
2489         }
2490     }
2491
2492   if (debug)
2493     fprintf (stderr, "\n");
2494
2495   /* now iterate through the library list adding their symbols to
2496      the list.  */
2497   for (list = libraries.first; list; list = list->next)
2498     scan_prog_file (list->name, PASS_LIB);
2499 }
2500
2501 #else  /* SUNOS4_SHARED_LIBRARIES */
2502 #ifdef LDD_SUFFIX
2503
2504 /* Use the List Dynamic Dependencies program to find shared libraries that
2505    the output file depends upon and their initialization/finalization
2506    routines, if any.  */
2507
2508 static void
2509 scan_libraries (prog_name)
2510      char *prog_name;
2511 {
2512   static struct head libraries;         /* list of shared libraries found */
2513   struct id *list;
2514   void (*int_handler) ();
2515   void (*quit_handler) ();
2516   char *ldd_argv[4];
2517   int pid;
2518   int argc = 0;
2519   int pipe_fd[2];
2520   char buf[1024];
2521   FILE *inf;
2522
2523   /* If we do not have an `ldd', complain.  */
2524   if (ldd_file_name == 0)
2525     {
2526       error ("cannot find `ldd'");
2527       return;
2528     }
2529
2530   ldd_argv[argc++] = ldd_file_name;
2531   ldd_argv[argc++] = prog_name;
2532   ldd_argv[argc++] = (char *) 0;
2533
2534   if (pipe (pipe_fd) < 0)
2535     fatal_perror ("pipe");
2536
2537   inf = fdopen (pipe_fd[0], "r");
2538   if (inf == (FILE *) 0)
2539     fatal_perror ("fdopen");
2540
2541   /* Trace if needed.  */
2542   if (vflag)
2543     {
2544       char **p_argv;
2545       char *str;
2546
2547       for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
2548         fprintf (stderr, " %s", str);
2549
2550       fprintf (stderr, "\n");
2551     }
2552
2553   fflush (stdout);
2554   fflush (stderr);
2555
2556   /* Spawn child ldd on pipe */
2557   pid = vfork ();
2558   if (pid == -1)
2559     {
2560 #ifdef vfork
2561       fatal_perror ("fork");
2562 #else
2563       fatal_perror ("vfork");
2564 #endif
2565     }
2566
2567   if (pid == 0)                 /* child context */
2568     {
2569       /* setup stdout */
2570       if (dup2 (pipe_fd[1], 1) < 0)
2571         fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
2572
2573       if (close (pipe_fd[0]) < 0)
2574         fatal_perror ("close (%d)", pipe_fd[0]);
2575
2576       if (close (pipe_fd[1]) < 0)
2577         fatal_perror ("close (%d)", pipe_fd[1]);
2578
2579       execv (ldd_file_name, ldd_argv);
2580       fatal_perror ("executing %s", ldd_file_name);
2581     }
2582
2583   /* Parent context from here on.  */
2584   int_handler  = (void (*) ()) signal (SIGINT,  SIG_IGN);
2585 #ifdef SIGQUIT
2586   quit_handler = (void (*) ()) signal (SIGQUIT, SIG_IGN);
2587 #endif
2588
2589   if (close (pipe_fd[1]) < 0)
2590     fatal_perror ("close (%d)", pipe_fd[1]);
2591
2592   if (debug)
2593     fprintf (stderr, "\nldd output with constructors/destructors.\n");
2594
2595   /* Read each line of ldd output.  */
2596   while (fgets (buf, sizeof buf, inf) != (char *) 0)
2597     {
2598       int ch, ch2;
2599       char *name, *end, *p = buf;
2600
2601       /* Extract names of libraries and add to list.  */
2602       PARSE_LDD_OUTPUT (p);
2603       if (p == 0)
2604         continue;
2605
2606       name = p;
2607       if (strncmp (name, "not found", sizeof ("not found") - 1) == 0)
2608         fatal ("dynamic dependency %s not found", buf);
2609
2610       /* Find the end of the symbol name.  */
2611       for (end = p;
2612            (ch2 = *end) != '\0' && ch2 != '\n' && !isspace (ch2) && ch2 != '|';
2613            end++)
2614         continue;
2615       *end = '\0';
2616
2617       if (access (name, R_OK) == 0)
2618         add_to_list (&libraries, name);
2619       else
2620         fatal ("unable to open dynamic dependency '%s'", buf);
2621
2622       if (debug)
2623         fprintf (stderr, "\t%s\n", buf);
2624     }
2625   if (debug)
2626     fprintf (stderr, "\n");
2627
2628   if (fclose (inf) != 0)
2629     fatal_perror ("fclose of pipe");
2630
2631   do_wait (ldd_file_name);
2632
2633   signal (SIGINT,  int_handler);
2634 #ifdef SIGQUIT
2635   signal (SIGQUIT, quit_handler);
2636 #endif
2637
2638   /* now iterate through the library list adding their symbols to
2639      the list.  */
2640   for (list = libraries.first; list; list = list->next)
2641     scan_prog_file (list->name, PASS_LIB);
2642 }
2643
2644 #endif /* LDD_SUFFIX */
2645 #endif /* SUNOS4_SHARED_LIBRARIES */
2646
2647 #endif /* OBJECT_FORMAT_NONE */
2648
2649 \f
2650 /*
2651  * COFF specific stuff.
2652  */
2653
2654 #ifdef OBJECT_FORMAT_COFF
2655
2656 #if defined(EXTENDED_COFF)
2657 #   define GCC_SYMBOLS(X)       (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
2658 #   define GCC_SYMENT           SYMR
2659 #   define GCC_OK_SYMBOL(X)     ((X).st == stProc && (X).sc == scText)
2660 #   define GCC_SYMINC(X)        (1)
2661 #   define GCC_SYMZERO(X)       (SYMHEADER(X).isymMax)
2662 #   define GCC_CHECK_HDR(X)     (PSYMTAB(X) != 0)
2663 #else
2664 #   define GCC_SYMBOLS(X)       (HEADER(ldptr).f_nsyms)
2665 #   define GCC_SYMENT           SYMENT
2666 #   define GCC_OK_SYMBOL(X) \
2667      (((X).n_sclass == C_EXT) && \
2668       ((X).n_scnum > N_UNDEF) && \
2669       (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) || \
2670        ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))
2671 #   define GCC_UNDEF_SYMBOL(X) \
2672      (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2673 #   define GCC_SYMINC(X)        ((X).n_numaux+1)
2674 #   define GCC_SYMZERO(X)       0
2675 #   define GCC_CHECK_HDR(X)     (1)
2676 #endif
2677
2678 extern char *ldgetname ();
2679
2680 /* COFF version to scan the name list of the loaded program for
2681    the symbols g++ uses for static constructors and destructors.
2682
2683    The constructor table begins at __CTOR_LIST__ and contains a count
2684    of the number of pointers (or -1 if the constructors are built in a
2685    separate section by the linker), followed by the pointers to the
2686    constructor functions, terminated with a null pointer.  The
2687    destructor table has the same format, and begins at __DTOR_LIST__.  */
2688
2689 static void
2690 scan_prog_file (prog_name, which_pass)
2691      char *prog_name;
2692      enum pass which_pass;
2693 {
2694   LDFILE *ldptr = NULL;
2695   int sym_index, sym_count;
2696   int is_shared = 0;
2697 #ifdef COLLECT_EXPORT_LIST
2698   /* Should we generate an import list for given prog_name?  */
2699   int import_flag = (which_pass == PASS_OBJ ? 0 : use_import_list (prog_name));
2700 #endif
2701
2702   if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
2703     return;
2704
2705 #ifdef COLLECT_EXPORT_LIST
2706   /* We do not need scanning for some standard C libraries.  */
2707   if (which_pass == PASS_FIRST && ignore_library (prog_name))
2708     return;
2709
2710   /* On AIX we have a loop, because there is not much difference
2711      between an object and an archive. This trick allows us to
2712      eliminate scan_libraries() function.  */
2713   do
2714     {
2715 #endif
2716       if ((ldptr = ldopen (prog_name, ldptr)) != NULL)
2717         {
2718
2719           if (!MY_ISCOFF (HEADER (ldptr).f_magic))
2720             fatal ("%s: not a COFF file", prog_name);
2721
2722 #ifdef COLLECT_EXPORT_LIST
2723           /* Is current archive member a shared object?  */
2724           is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2725 #endif
2726           if (GCC_CHECK_HDR (ldptr))
2727             {
2728               sym_count = GCC_SYMBOLS (ldptr);
2729               sym_index = GCC_SYMZERO (ldptr);
2730               while (sym_index < sym_count)
2731                 {
2732                   GCC_SYMENT symbol;
2733
2734                   if (ldtbread (ldptr, sym_index, &symbol) <= 0)
2735                     break;
2736                   sym_index += GCC_SYMINC (symbol);
2737
2738                   if (GCC_OK_SYMBOL (symbol))
2739                     {
2740                       char *name;
2741
2742                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
2743                         continue;               /* should never happen */
2744
2745 #ifdef XCOFF_DEBUGGING_INFO
2746                       /* All AIX function names have a duplicate entry
2747                          beginning with a dot.  */
2748                       if (*name == '.')
2749                         ++name;
2750 #endif
2751
2752                       switch (is_ctor_dtor (name))
2753                         {
2754                         case 1:
2755                           if (! is_shared) add_to_list (&constructors, name);
2756 #ifdef COLLECT_EXPORT_LIST
2757                           if (which_pass == PASS_OBJ)
2758                             add_to_list (&exports, name);
2759                           /* If this symbol was undefined and we are building
2760                              an import list, we should add a symbol to this
2761                              list.  */
2762                           else
2763                             if (import_flag
2764                                 && is_in_list (name, undefined.first))
2765                               add_to_list (&imports, name);
2766 #endif
2767                           break;
2768
2769                         case 2:
2770                           if (! is_shared) add_to_list (&destructors, name);
2771 #ifdef COLLECT_EXPORT_LIST
2772                           if (which_pass == PASS_OBJ)
2773                             add_to_list (&exports, name);
2774                           /* If this symbol was undefined and we are building
2775                              an import list, we should add a symbol to this
2776                              list.  */
2777                           else
2778                             if (import_flag
2779                                 && is_in_list (name, undefined.first))
2780                               add_to_list (&imports, name);
2781 #endif
2782                           break;
2783
2784 #ifdef COLLECT_EXPORT_LIST
2785                         case 3:
2786                           if (is_shared)
2787                             add_to_list (&constructors, name);
2788                           break;
2789
2790                         case 4:
2791                           if (is_shared)
2792                             add_to_list (&destructors, name);
2793                           break;
2794 #endif
2795
2796                         default:        /* not a constructor or destructor */
2797 #ifdef COLLECT_EXPORT_LIST
2798                           /* If we are building a shared object on AIX we need
2799                              to explicitly export all global symbols or add
2800                              them to import list.  */
2801                           if (shared_obj)
2802                             {
2803                               if (which_pass == PASS_OBJ && (! export_flag))
2804                                 add_to_list (&exports, name);
2805                               else if (! is_shared && which_pass == PASS_FIRST
2806                                        && import_flag
2807                                        && is_in_list(name, undefined.first))
2808                                 add_to_list (&imports, name);
2809                             }
2810 #endif
2811                           continue;
2812                         }
2813
2814 #if !defined(EXTENDED_COFF)
2815                       if (debug)
2816                         fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
2817                                  symbol.n_scnum, symbol.n_sclass,
2818                                  (symbol.n_type ? "0" : ""), symbol.n_type,
2819                                  name);
2820 #else
2821                       if (debug)
2822                         fprintf (stderr,
2823                                  "\tiss = %5d, value = %5d, index = %5d, name = %s\n",
2824                                  symbol.iss, symbol.value, symbol.index, name);
2825 #endif
2826                     }
2827 #ifdef COLLECT_EXPORT_LIST
2828                   /* If we are building a shared object we should collect
2829                      information about undefined symbols for later
2830                      import list generation.  */
2831                   else if (shared_obj && GCC_UNDEF_SYMBOL (symbol))
2832                     {
2833                       char *name;
2834
2835                       if ((name = ldgetname (ldptr, &symbol)) == NULL)
2836                         continue;               /* should never happen */
2837
2838                       /* All AIX function names have a duplicate entry
2839                          beginning with a dot.  */
2840                       if (*name == '.')
2841                         ++name;
2842                       add_to_list (&undefined, name);
2843                     }
2844 #endif
2845                 }
2846             }
2847         }
2848       else
2849         {
2850           fatal ("%s: cannot open as COFF file", prog_name);
2851         }
2852 #ifdef COLLECT_EXPORT_LIST
2853       /* On AIX loop continues while there are more members in archive.  */
2854     }
2855   while (ldclose (ldptr) == FAILURE);
2856 #else
2857   /* Otherwise we simply close ldptr.  */
2858   (void) ldclose(ldptr);
2859 #endif
2860 }
2861
2862
2863 #ifdef COLLECT_EXPORT_LIST
2864
2865 /* This new function is used to decide whether we should
2866    generate import list for an object or to use it directly.  */
2867 static int
2868 use_import_list (prog_name)
2869      char *prog_name;
2870 {
2871   char *p;
2872
2873   /* If we do not build a shared object then import list should not be used.  */
2874   if (! shared_obj) return 0;
2875
2876   /* Currently we check only for libgcc, but this can be changed in future.  */
2877   p = strstr (prog_name, "libgcc.a");
2878   if (p != 0 && (strlen (p) == sizeof ("libgcc.a") - 1))
2879     return 1;
2880   return 0;
2881 }
2882
2883 /* Given a library name without "lib" prefix, this function
2884    returns a full library name including a path.  */
2885 static char *
2886 resolve_lib_name (name)
2887      char *name;
2888 {
2889   char *lib_buf;
2890   int i, j, l = 0;
2891
2892   for (i = 0; libpaths[i]; i++)
2893     if (libpaths[i]->max_len > l)
2894       l = libpaths[i]->max_len;
2895
2896   lib_buf = xmalloc (l + strlen(name) + 10);
2897
2898   for (i = 0; libpaths[i]; i++)
2899     {
2900       struct prefix_list *list = libpaths[i]->plist;
2901       for (; list; list = list->next)
2902         {
2903           for (j = 0; libexts[j]; j++)
2904             {
2905               /* The following lines are needed because path_prefix list
2906                  may contain directories both with trailing '/' and
2907                  without it.  */
2908               char *p = "";
2909               if (list->prefix[strlen(list->prefix)-1] != '/')
2910                 p = "/";
2911               sprintf (lib_buf, "%s%slib%s.%s",
2912                        list->prefix, p, name, libexts[j]);
2913 if (debug) fprintf (stderr, "searching for: %s\n", lib_buf);
2914               if (file_exists (lib_buf))
2915                 {
2916 if (debug) fprintf (stderr, "found: %s\n", lib_buf);
2917                   return (lib_buf);
2918                 }
2919             }
2920         }
2921     }
2922   if (debug)
2923     fprintf (stderr, "not found\n");
2924   else
2925     fatal ("Library lib%s not found", name);
2926   return (NULL);
2927 }
2928
2929 /* Array of standard AIX libraries which should not
2930    be scanned for ctors/dtors.  */
2931 static char* aix_std_libs[] = {
2932   "/unix",
2933   "/lib/libc.a",
2934   "/lib/libc_r.a",
2935   "/usr/lib/libc.a",
2936   "/usr/lib/libc_r.a",
2937   "/usr/lib/threads/libc.a",
2938   "/usr/ccs/lib/libc.a",
2939   "/usr/ccs/lib/libc_r.a",
2940   NULL
2941 };
2942
2943 /* This function checks the filename and returns 1
2944    if this name matches the location of a standard AIX library. */
2945 static int
2946 ignore_library (name)
2947      char *name;
2948 {
2949   char **p = &aix_std_libs[0];
2950   while (*p++ != NULL)
2951     if (! strcmp (name, *p)) return 1;
2952   return 0;
2953 }
2954
2955 #endif
2956
2957 #endif /* OBJECT_FORMAT_COFF */
2958
2959 \f
2960 /*
2961  * OSF/rose specific stuff.
2962  */
2963
2964 #ifdef OBJECT_FORMAT_ROSE
2965
2966 /* Union of the various load commands */
2967
2968 typedef union load_union
2969 {
2970   ldc_header_t                  hdr;    /* common header */
2971   load_cmd_map_command_t        map;    /* map indexing other load cmds */
2972   interpreter_command_t         iprtr;  /* interpreter pathname */
2973   strings_command_t             str;    /* load commands strings section */
2974   region_command_t              region; /* region load command */
2975   reloc_command_t               reloc;  /* relocation section */
2976   package_command_t             pkg;    /* package load command */
2977   symbols_command_t             sym;    /* symbol sections */
2978   entry_command_t               ent;    /* program start section */
2979   gen_info_command_t            info;   /* object information */
2980   func_table_command_t          func;   /* function constructors/destructors */
2981 } load_union_t;
2982
2983 /* Structure to point to load command and data section in memory.  */
2984
2985 typedef struct load_all
2986 {
2987   load_union_t *load;                   /* load command */
2988   char *section;                        /* pointer to section */
2989 } load_all_t;
2990
2991 /* Structure to contain information about a file mapped into memory.  */
2992
2993 struct file_info
2994 {
2995   char *start;                          /* start of map */
2996   char *name;                           /* filename */
2997   long  size;                           /* size of the file */
2998   long  rounded_size;                   /* size rounded to page boundary */
2999   int   fd;                             /* file descriptor */
3000   int   rw;                             /* != 0 if opened read/write */
3001   int   use_mmap;                       /* != 0 if mmap'ed */
3002 };
3003
3004 extern int decode_mach_o_hdr ();
3005 extern int encode_mach_o_hdr ();
3006
3007 static void add_func_table      PROTO((mo_header_t *, load_all_t *,
3008                                        symbol_info_t *, int));
3009 static void print_header        PROTO((mo_header_t *));
3010 static void print_load_command  PROTO((load_union_t *, size_t, int));
3011 static void bad_header          PROTO((int));
3012 static struct file_info *read_file  PROTO((char *, int, int));
3013 static void end_file            PROTO((struct file_info *));
3014 \f
3015 /* OSF/rose specific version to scan the name list of the loaded
3016    program for the symbols g++ uses for static constructors and
3017    destructors.
3018
3019    The constructor table begins at __CTOR_LIST__ and contains a count
3020    of the number of pointers (or -1 if the constructors are built in a
3021    separate section by the linker), followed by the pointers to the
3022    constructor functions, terminated with a null pointer.  The
3023    destructor table has the same format, and begins at __DTOR_LIST__.  */
3024
3025 static void
3026 scan_prog_file (prog_name, which_pass)
3027      char *prog_name;
3028      enum pass which_pass;
3029 {
3030   char *obj;
3031   mo_header_t hdr;
3032   load_all_t *load_array;
3033   load_all_t *load_end;
3034   load_all_t *load_cmd;
3035   int symbol_load_cmds;
3036   off_t offset;
3037   int i;
3038   int num_syms;
3039   int status;
3040   char *str_sect;
3041   struct file_info *obj_file;
3042   int prog_fd;
3043   mo_lcid_t cmd_strings   = -1;
3044   symbol_info_t *main_sym = 0;
3045   int rw                  = (which_pass != PASS_FIRST);
3046
3047   prog_fd = open (prog_name, (rw) ? O_RDWR : O_RDONLY);
3048   if (prog_fd < 0)
3049     fatal_perror ("cannot read %s", prog_name);
3050
3051   obj_file = read_file (prog_name, prog_fd, rw);
3052   obj = obj_file->start;
3053
3054   status = decode_mach_o_hdr (obj, MO_SIZEOF_RAW_HDR, MOH_HEADER_VERSION, &hdr);
3055   if (status != MO_HDR_CONV_SUCCESS)
3056     bad_header (status);
3057
3058
3059   /* Do some basic sanity checks.  Note we explicitly use the big endian magic number,
3060      since the hardware will automatically swap bytes for us on loading little endian
3061      integers.  */
3062
3063 #ifndef CROSS_COMPILE
3064   if (hdr.moh_magic != MOH_MAGIC_MSB
3065       || hdr.moh_header_version != MOH_HEADER_VERSION
3066       || hdr.moh_byte_order != OUR_BYTE_ORDER
3067       || hdr.moh_data_rep_id != OUR_DATA_REP_ID
3068       || hdr.moh_cpu_type != OUR_CPU_TYPE
3069       || hdr.moh_cpu_subtype != OUR_CPU_SUBTYPE
3070       || hdr.moh_vendor_type != OUR_VENDOR_TYPE)
3071     {
3072       fatal ("incompatibilities between object file & expected values");
3073     }
3074 #endif
3075
3076   if (debug)
3077     print_header (&hdr);
3078
3079   offset = hdr.moh_first_cmd_off;
3080   load_end = load_array
3081     = (load_all_t *) xcalloc (sizeof (load_all_t), hdr.moh_n_load_cmds + 2);
3082
3083   /* Build array of load commands, calculating the offsets */
3084   for (i = 0; i < hdr.moh_n_load_cmds; i++)
3085     {
3086       load_union_t *load_hdr;           /* load command header */
3087
3088       load_cmd = load_end++;
3089       load_hdr = (load_union_t *) (obj + offset);
3090
3091       /* If modifying the program file, copy the header.  */
3092       if (rw)
3093         {
3094           load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
3095           bcopy ((char *)load_hdr, (char *)ptr, load_hdr->hdr.ldci_cmd_size);
3096           load_hdr = ptr;
3097
3098           /* null out old command map, because we will rewrite at the end.  */
3099           if (ptr->hdr.ldci_cmd_type == LDC_CMD_MAP)
3100             {
3101               cmd_strings = ptr->map.lcm_ld_cmd_strings;
3102               ptr->hdr.ldci_cmd_type = LDC_UNDEFINED;
3103             }
3104         }
3105
3106       load_cmd->load = load_hdr;
3107       if (load_hdr->hdr.ldci_section_off > 0)
3108         load_cmd->section = obj + load_hdr->hdr.ldci_section_off;
3109
3110       if (debug)
3111         print_load_command (load_hdr, offset, i);
3112
3113       offset += load_hdr->hdr.ldci_cmd_size;
3114     }
3115
3116   /* If the last command is the load command map and is not undefined,
3117      decrement the count of load commands.  */
3118   if (rw && load_end[-1].load->hdr.ldci_cmd_type == LDC_UNDEFINED)
3119     {
3120       load_end--;
3121       hdr.moh_n_load_cmds--;
3122     }
3123
3124   /* Go through and process each symbol table section.  */
3125   symbol_load_cmds = 0;
3126   for (load_cmd = load_array; load_cmd < load_end; load_cmd++)
3127     {
3128       load_union_t *load_hdr = load_cmd->load;
3129
3130       if (load_hdr->hdr.ldci_cmd_type == LDC_SYMBOLS)
3131         {
3132           symbol_load_cmds++;
3133
3134           if (debug)
3135             {
3136               char *kind = "unknown";
3137
3138               switch (load_hdr->sym.symc_kind)
3139                 {
3140                 case SYMC_IMPORTS:         kind = "imports"; break;
3141                 case SYMC_DEFINED_SYMBOLS: kind = "defined"; break;
3142                 case SYMC_STABS:           kind = "stabs";   break;
3143                 }
3144
3145               fprintf (stderr, "\nProcessing symbol table #%d, offset = 0x%.8lx, kind = %s\n",
3146                        symbol_load_cmds, load_hdr->hdr.ldci_section_off, kind);
3147             }
3148
3149           if (load_hdr->sym.symc_kind != SYMC_DEFINED_SYMBOLS)
3150             continue;
3151
3152           str_sect = load_array[load_hdr->sym.symc_strings_section].section;
3153           if (str_sect == (char *) 0)
3154             fatal ("string section missing");
3155
3156           if (load_cmd->section == (char *) 0)
3157             fatal ("section pointer missing");
3158
3159           num_syms = load_hdr->sym.symc_nentries;
3160           for (i = 0; i < num_syms; i++)
3161             {
3162               symbol_info_t *sym = ((symbol_info_t *) load_cmd->section) + i;
3163               char *name = sym->si_name.symbol_name + str_sect;
3164
3165               if (name[0] != '_')
3166                 continue;
3167
3168               if (rw)
3169                 {
3170                   char *n = name + strlen (name) - strlen (NAME__MAIN);
3171
3172                   if ((n - name) < 0 || strcmp (n, NAME__MAIN))
3173                     continue;
3174                   while (n != name)
3175                     if (*--n != '_')
3176                       continue;
3177
3178                   main_sym = sym;
3179                 }
3180               else
3181                 {
3182                   switch (is_ctor_dtor (name))
3183                     {
3184                     case 1:
3185                       add_to_list (&constructors, name);
3186                       break;
3187
3188                     case 2:
3189                       add_to_list (&destructors, name);
3190                       break;
3191
3192                     default:    /* not a constructor or destructor */
3193                       continue;
3194                     }
3195                 }
3196
3197               if (debug)
3198                 fprintf (stderr, "\ttype = 0x%.4x, sc = 0x%.2x, flags = 0x%.8x, name = %.30s\n",
3199                          sym->si_type, sym->si_sc_type, sym->si_flags, name);
3200             }
3201         }
3202     }
3203
3204   if (symbol_load_cmds == 0)
3205     fatal ("no symbol table found");
3206
3207   /* Update the program file now, rewrite header and load commands.  At present,
3208      we assume that there is enough space after the last load command to insert
3209      one more.  Since the first section written out is page aligned, and the
3210      number of load commands is small, this is ok for the present.  */
3211
3212   if (rw)
3213     {
3214       load_union_t *load_map;
3215       size_t size;
3216
3217       if (cmd_strings == -1)
3218         fatal ("no cmd_strings found");
3219
3220       /* Add __main to initializer list.
3221          If we are building a program instead of a shared library, do not
3222          do anything, since in the current version, you cannot do mallocs
3223          and such in the constructors.  */
3224
3225       if (main_sym != (symbol_info_t *) 0
3226           && ((hdr.moh_flags & MOH_EXECABLE_F) == 0))
3227         add_func_table (&hdr, load_array, main_sym, FNTC_INITIALIZATION);
3228
3229       if (debug)
3230         fprintf (stderr, "\nUpdating header and load commands.\n\n");
3231
3232       hdr.moh_n_load_cmds++;
3233       size = sizeof (load_cmd_map_command_t) + (sizeof (mo_offset_t) * (hdr.moh_n_load_cmds - 1));
3234
3235       /* Create new load command map.  */
3236       if (debug)
3237         fprintf (stderr, "load command map, %d cmds, new size %ld.\n",
3238                  (int)hdr.moh_n_load_cmds, (long)size);
3239
3240       load_map = (load_union_t *) xcalloc (1, size);
3241       load_map->map.ldc_header.ldci_cmd_type = LDC_CMD_MAP;
3242       load_map->map.ldc_header.ldci_cmd_size = size;
3243       load_map->map.lcm_ld_cmd_strings = cmd_strings;
3244       load_map->map.lcm_nentries = hdr.moh_n_load_cmds;
3245       load_array[hdr.moh_n_load_cmds-1].load = load_map;
3246
3247       offset = hdr.moh_first_cmd_off;
3248       for (i = 0; i < hdr.moh_n_load_cmds; i++)
3249         {
3250           load_map->map.lcm_map[i] = offset;
3251           if (load_array[i].load->hdr.ldci_cmd_type == LDC_CMD_MAP)
3252             hdr.moh_load_map_cmd_off = offset;
3253
3254           offset += load_array[i].load->hdr.ldci_cmd_size;
3255         }
3256
3257       hdr.moh_sizeofcmds = offset - MO_SIZEOF_RAW_HDR;
3258
3259       if (debug)
3260         print_header (&hdr);
3261
3262       /* Write header */
3263       status = encode_mach_o_hdr (&hdr, obj, MO_SIZEOF_RAW_HDR);
3264       if (status != MO_HDR_CONV_SUCCESS)
3265         bad_header (status);
3266
3267       if (debug)
3268         fprintf (stderr, "writing load commands.\n\n");
3269
3270       /* Write load commands */
3271       offset = hdr.moh_first_cmd_off;
3272       for (i = 0; i < hdr.moh_n_load_cmds; i++)
3273         {
3274           load_union_t *load_hdr = load_array[i].load;
3275           size_t size = load_hdr->hdr.ldci_cmd_size;
3276
3277           if (debug)
3278             print_load_command (load_hdr, offset, i);
3279
3280           bcopy ((char *) load_hdr, (char *) (obj + offset), size);
3281           offset += size;
3282         }
3283     }
3284
3285   end_file (obj_file);
3286
3287   if (close (prog_fd))
3288     fatal_perror ("closing %s", prog_name);
3289
3290   if (debug)
3291     fprintf (stderr, "\n");
3292 }
3293
3294 \f
3295 /* Add a function table to the load commands to call a function
3296    on initiation or termination of the process.  */
3297
3298 static void
3299 add_func_table (hdr_p, load_array, sym, type)
3300      mo_header_t *hdr_p;                /* pointer to global header */
3301      load_all_t *load_array;            /* array of ptrs to load cmds */
3302      symbol_info_t *sym;                /* pointer to symbol entry */
3303      int type;                          /* fntc_type value */
3304 {
3305   /* Add a new load command.  */
3306   int num_cmds = ++hdr_p->moh_n_load_cmds;
3307   int load_index = num_cmds - 1;
3308   size_t size = sizeof (func_table_command_t) + sizeof (mo_addr_t);
3309   load_union_t *ptr = xcalloc (1, size);
3310   load_all_t *load_cmd;
3311   int i;
3312
3313   /* Set the unresolved address bit in the header to force the loader to be
3314      used, since kernel exec does not call the initialization functions.  */
3315   hdr_p->moh_flags |= MOH_UNRESOLVED_F;
3316
3317   load_cmd = &load_array[load_index];
3318   load_cmd->load = ptr;
3319   load_cmd->section = (char *) 0;
3320
3321   /* Fill in func table load command.  */
3322   ptr->func.ldc_header.ldci_cmd_type = LDC_FUNC_TABLE;
3323   ptr->func.ldc_header.ldci_cmd_size = size;
3324   ptr->func.ldc_header.ldci_section_off = 0;
3325   ptr->func.ldc_header.ldci_section_len = 0;
3326   ptr->func.fntc_type = type;
3327   ptr->func.fntc_nentries = 1;
3328
3329   /* copy address, turn it from abs. address to (region,offset) if necessary.  */
3330   /* Is the symbol already expressed as (region, offset)?  */
3331   if ((sym->si_flags & SI_ABSOLUTE_VALUE_F) == 0)
3332     {
3333       ptr->func.fntc_entry_loc[i].adr_lcid = sym->si_value.def_val.adr_lcid;
3334       ptr->func.fntc_entry_loc[i].adr_sctoff = sym->si_value.def_val.adr_sctoff;
3335     }
3336
3337   /* If not, figure out which region it's in.  */
3338   else
3339     {
3340       mo_vm_addr_t addr = sym->si_value.abs_val;
3341       int found = 0;
3342
3343       for (i = 0; i < load_index; i++)
3344         {
3345           if (load_array[i].load->hdr.ldci_cmd_type == LDC_REGION)
3346             {
3347               region_command_t *region_ptr = &load_array[i].load->region;
3348
3349               if ((region_ptr->regc_flags & REG_ABS_ADDR_F) != 0
3350                   && addr >= region_ptr->regc_addr.vm_addr
3351                   && addr <= region_ptr->regc_addr.vm_addr + region_ptr->regc_vm_size)
3352                 {
3353                   ptr->func.fntc_entry_loc[0].adr_lcid = i;
3354                   ptr->func.fntc_entry_loc[0].adr_sctoff = addr - region_ptr->regc_addr.vm_addr;
3355                   found++;
3356                   break;
3357                 }
3358             }
3359         }
3360
3361       if (!found)
3362         fatal ("could not convert 0x%l.8x into a region", addr);
3363     }
3364
3365   if (debug)
3366     fprintf (stderr,
3367              "%s function, region %d, offset = %ld (0x%.8lx)\n",
3368              (type == FNTC_INITIALIZATION) ? "init" : "term",
3369              (int)ptr->func.fntc_entry_loc[i].adr_lcid,
3370              (long)ptr->func.fntc_entry_loc[i].adr_sctoff,
3371              (long)ptr->func.fntc_entry_loc[i].adr_sctoff);
3372
3373 }
3374
3375 \f
3376 /* Print the global header for an OSF/rose object.  */
3377
3378 static void
3379 print_header (hdr_ptr)
3380      mo_header_t *hdr_ptr;
3381 {
3382   fprintf (stderr, "\nglobal header:\n");
3383   fprintf (stderr, "\tmoh_magic            = 0x%.8lx\n", hdr_ptr->moh_magic);
3384   fprintf (stderr, "\tmoh_major_version    = %d\n", (int)hdr_ptr->moh_major_version);
3385   fprintf (stderr, "\tmoh_minor_version    = %d\n", (int)hdr_ptr->moh_minor_version);
3386   fprintf (stderr, "\tmoh_header_version   = %d\n", (int)hdr_ptr->moh_header_version);
3387   fprintf (stderr, "\tmoh_max_page_size    = %d\n", (int)hdr_ptr->moh_max_page_size);
3388   fprintf (stderr, "\tmoh_byte_order       = %d\n", (int)hdr_ptr->moh_byte_order);
3389   fprintf (stderr, "\tmoh_data_rep_id      = %d\n", (int)hdr_ptr->moh_data_rep_id);
3390   fprintf (stderr, "\tmoh_cpu_type         = %d\n", (int)hdr_ptr->moh_cpu_type);
3391   fprintf (stderr, "\tmoh_cpu_subtype      = %d\n", (int)hdr_ptr->moh_cpu_subtype);
3392   fprintf (stderr, "\tmoh_vendor_type      = %d\n", (int)hdr_ptr->moh_vendor_type);
3393   fprintf (stderr, "\tmoh_load_map_cmd_off = %d\n", (int)hdr_ptr->moh_load_map_cmd_off);
3394   fprintf (stderr, "\tmoh_first_cmd_off    = %d\n", (int)hdr_ptr->moh_first_cmd_off);
3395   fprintf (stderr, "\tmoh_sizeofcmds       = %d\n", (int)hdr_ptr->moh_sizeofcmds);
3396   fprintf (stderr, "\tmon_n_load_cmds      = %d\n", (int)hdr_ptr->moh_n_load_cmds);
3397   fprintf (stderr, "\tmoh_flags            = 0x%.8lx", (long)hdr_ptr->moh_flags);
3398
3399   if (hdr_ptr->moh_flags & MOH_RELOCATABLE_F)
3400     fprintf (stderr, ", relocatable");
3401
3402   if (hdr_ptr->moh_flags & MOH_LINKABLE_F)
3403     fprintf (stderr, ", linkable");
3404
3405   if (hdr_ptr->moh_flags & MOH_EXECABLE_F)
3406     fprintf (stderr, ", execable");
3407
3408   if (hdr_ptr->moh_flags & MOH_EXECUTABLE_F)
3409     fprintf (stderr, ", executable");
3410
3411   if (hdr_ptr->moh_flags & MOH_UNRESOLVED_F)
3412     fprintf (stderr, ", unresolved");
3413
3414   fprintf (stderr, "\n\n");
3415   return;
3416 }
3417
3418 \f
3419 /* Print a short summary of a load command.  */
3420
3421 static void
3422 print_load_command (load_hdr, offset, number)
3423      load_union_t *load_hdr;
3424      size_t offset;
3425      int number;
3426 {
3427   mo_long_t type = load_hdr->hdr.ldci_cmd_type;
3428   char *type_str = (char *) 0;
3429
3430   switch (type)
3431     {
3432     case LDC_UNDEFINED:   type_str = "UNDEFINED";       break;
3433     case LDC_CMD_MAP:     type_str = "CMD_MAP";         break;
3434     case LDC_INTERPRETER: type_str = "INTERPRETER";     break;
3435     case LDC_STRINGS:     type_str = "STRINGS";         break;
3436     case LDC_REGION:      type_str = "REGION";          break;
3437     case LDC_RELOC:       type_str = "RELOC";           break;
3438     case LDC_PACKAGE:     type_str = "PACKAGE";         break;
3439     case LDC_SYMBOLS:     type_str = "SYMBOLS";         break;
3440     case LDC_ENTRY:       type_str = "ENTRY";           break;
3441     case LDC_FUNC_TABLE:  type_str = "FUNC_TABLE";      break;
3442     case LDC_GEN_INFO:    type_str = "GEN_INFO";        break;
3443     }
3444
3445   fprintf (stderr,
3446            "cmd %2d, sz: 0x%.2lx, coff: 0x%.3lx, doff: 0x%.6lx, dlen: 0x%.6lx",
3447            number,
3448            (long) load_hdr->hdr.ldci_cmd_size,
3449            (long) offset,
3450            (long) load_hdr->hdr.ldci_section_off,
3451            (long) load_hdr->hdr.ldci_section_len);
3452
3453   if (type_str == (char *) 0)
3454     fprintf (stderr, ", ty: unknown (%ld)\n", (long) type);
3455
3456   else if (type != LDC_REGION)
3457     fprintf (stderr, ", ty: %s\n", type_str);
3458
3459   else
3460     {
3461       char *region = "";
3462       switch (load_hdr->region.regc_usage_type)
3463         {
3464         case REG_TEXT_T:        region = ", .text";     break;
3465         case REG_DATA_T:        region = ", .data";     break;
3466         case REG_BSS_T:         region = ", .bss";      break;
3467         case REG_GLUE_T:        region = ", .glue";     break;
3468 #if defined (REG_RDATA_T) && defined (REG_SDATA_T) && defined (REG_SBSS_T) /*mips*/
3469         case REG_RDATA_T:       region = ", .rdata";    break;
3470         case REG_SDATA_T:       region = ", .sdata";    break;
3471         case REG_SBSS_T:        region = ", .sbss";     break;
3472 #endif
3473         }
3474
3475       fprintf (stderr, ", ty: %s, vaddr: 0x%.8lx, vlen: 0x%.6lx%s\n",
3476                type_str,
3477                (long) load_hdr->region.regc_vm_addr,
3478                (long) load_hdr->region.regc_vm_size,
3479                region);
3480     }
3481
3482   return;
3483 }
3484
3485 \f
3486 /* Fatal error when {en,de}code_mach_o_header fails.  */
3487
3488 static void
3489 bad_header (status)
3490      int status;
3491 {
3492   char *msg = (char *) 0;
3493
3494   switch (status)
3495     {
3496     case MO_ERROR_BAD_MAGIC:            msg = "bad magic number";               break;
3497     case MO_ERROR_BAD_HDR_VERS:         msg = "bad header version";             break;
3498     case MO_ERROR_BAD_RAW_HDR_VERS:     msg = "bad raw header version";         break;
3499     case MO_ERROR_BUF2SML:              msg = "raw header buffer too small";    break;
3500     case MO_ERROR_OLD_RAW_HDR_FILE:     msg = "old raw header file";            break;
3501     case MO_ERROR_UNSUPPORTED_VERS:     msg = "unsupported version";            break;
3502     }
3503
3504   if (msg == (char *) 0)
3505     fatal ("unknown {de,en}code_mach_o_hdr return value %d", status);
3506   else
3507     fatal ("%s", msg);
3508 }
3509
3510 \f
3511 /* Read a file into a memory buffer.  */
3512
3513 static struct file_info *
3514 read_file (name, fd, rw)
3515      char *name;                /* filename */
3516      int fd;                    /* file descriptor */
3517      int rw;                    /* read/write */
3518 {
3519   struct stat stat_pkt;
3520   struct file_info *p = (struct file_info *) xcalloc (sizeof (struct file_info), 1);
3521 #ifdef USE_MMAP
3522   static int page_size;
3523 #endif
3524
3525   if (fstat (fd, &stat_pkt) < 0)
3526     fatal_perror ("fstat %s", name);
3527
3528   p->name         = name;
3529   p->size         = stat_pkt.st_size;
3530   p->rounded_size = stat_pkt.st_size;
3531   p->fd           = fd;
3532   p->rw           = rw;
3533
3534 #ifdef USE_MMAP
3535   if (debug)
3536     fprintf (stderr, "mmap %s, %s\n", name, (rw) ? "read/write" : "read-only");
3537
3538   if (page_size == 0)
3539     page_size = sysconf (_SC_PAGE_SIZE);
3540
3541   p->rounded_size = ((p->size + page_size - 1) / page_size) * page_size;
3542   p->start = mmap ((caddr_t) 0,
3543                    (rw) ? p->rounded_size : p->size,
3544                    (rw) ? (PROT_READ | PROT_WRITE) : PROT_READ,
3545                    MAP_FILE | MAP_VARIABLE | MAP_SHARED,
3546                    fd,
3547                    0L);
3548
3549   if (p->start != (char *) 0 && p->start != (char *) -1)
3550     p->use_mmap = 1;
3551
3552   else
3553 #endif /* USE_MMAP */
3554     {
3555       long len;
3556
3557       if (debug)
3558         fprintf (stderr, "read %s\n", name);
3559
3560       p->use_mmap = 0;
3561       p->start = xmalloc (p->size);
3562       if (lseek (fd, 0L, SEEK_SET) < 0)
3563         fatal_perror ("lseek to 0 on %s", name);
3564
3565       len = read (fd, p->start, p->size);
3566       if (len < 0)
3567         fatal_perror ("read %s", name);
3568
3569       if (len != p->size)
3570         fatal ("read %ld bytes, expected %ld, from %s", len, p->size, name);
3571     }
3572
3573   return p;
3574 }
3575 \f
3576 /* Do anything necessary to write a file back from memory.  */
3577
3578 static void
3579 end_file (ptr)
3580      struct file_info *ptr;     /* file information block */
3581 {
3582 #ifdef USE_MMAP
3583   if (ptr->use_mmap)
3584     {
3585       if (ptr->rw)
3586         {
3587           if (debug)
3588             fprintf (stderr, "msync %s\n", ptr->name);
3589
3590           if (msync (ptr->start, ptr->rounded_size, MS_ASYNC))
3591             fatal_perror ("msync %s", ptr->name);
3592         }
3593
3594       if (debug)
3595         fprintf (stderr, "munmap %s\n", ptr->name);
3596
3597       if (munmap (ptr->start, ptr->size))
3598         fatal_perror ("munmap %s", ptr->name);
3599     }
3600   else
3601 #endif /* USE_MMAP */
3602     {
3603       if (ptr->rw)
3604         {
3605           long len;
3606
3607           if (debug)
3608             fprintf (stderr, "write %s\n", ptr->name);
3609
3610           if (lseek (ptr->fd, 0L, SEEK_SET) < 0)
3611             fatal_perror ("lseek to 0 on %s", ptr->name);
3612
3613           len = write (ptr->fd, ptr->start, ptr->size);
3614           if (len < 0)
3615             fatal_perror ("write %s", ptr->name);
3616
3617           if (len != ptr->size)
3618             fatal ("wrote %ld bytes, expected %ld, to %s", len, ptr->size, ptr->name);
3619         }
3620
3621       free (ptr->start);
3622     }
3623
3624   free (ptr);
3625 }
3626
3627 #endif /* OBJECT_FORMAT_ROSE */