Return to collect2.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/collect2.c, revision 1.1

1.1     ! root        1: /* Collect static initialization info into data structures
        !             2:    that can be traversed by C++ initialization and finalization
        !             3:    routines.
        !             4: 
        !             5:    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
        !             6:    Contributed by Chris Smith ([email protected]).
        !             7:    Heavily modified by Michael Meissner ([email protected]),
        !             8:    Per Bothner ([email protected]), and John Gilmore ([email protected]).
        !             9: 
        !            10: This file is part of GNU CC.
        !            11: 
        !            12: GNU CC is free software; you can redistribute it and/or modify
        !            13: it under the terms of the GNU General Public License as published by
        !            14: the Free Software Foundation; either version 2, or (at your option)
        !            15: any later version.
        !            16: 
        !            17: GNU CC is distributed in the hope that it will be useful,
        !            18: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            19: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            20: GNU General Public License for more details.
        !            21: 
        !            22: You should have received a copy of the GNU General Public License
        !            23: along with GNU CC; see the file COPYING.  If not, write to
        !            24: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            25: 
        !            26: 
        !            27: /* Build tables of static constructors and destructors and run ld. */
        !            28: 
        !            29: #include <sys/types.h>
        !            30: #include <stdio.h>
        !            31: #include <ctype.h>
        !            32: #include <errno.h>
        !            33: #include <signal.h>
        !            34: #include <sys/file.h>
        !            35: #include <sys/stat.h>
        !            36: #ifdef NO_WAIT_H
        !            37: #include <sys/wait.h>
        !            38: #endif
        !            39: 
        !            40: #ifndef errno
        !            41: extern int errno;
        !            42: #endif
        !            43: 
        !            44: #if defined(bsd4_4)
        !            45: extern const char *const sys_errlist[];
        !            46: #else
        !            47: extern char *sys_errlist[];
        !            48: #endif
        !            49: extern int sys_nerr;
        !            50: 
        !            51: #define COLLECT
        !            52: 
        !            53: #include "config.h"
        !            54: 
        !            55: #ifndef __STDC__
        !            56: #define generic char
        !            57: #define const
        !            58: 
        !            59: #else
        !            60: #define generic void
        !            61: #endif
        !            62: 
        !            63: #ifdef USG
        !            64: #define vfork fork
        !            65: #endif
        !            66: 
        !            67: /* Add prototype support.  */
        !            68: #ifndef PROTO
        !            69: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
        !            70: #define PROTO(ARGS) ARGS
        !            71: #else
        !            72: #define PROTO(ARGS) ()
        !            73: #endif
        !            74: #endif
        !            75: 
        !            76: #ifndef R_OK
        !            77: #define R_OK 4
        !            78: #define W_OK 2
        !            79: #define X_OK 1
        !            80: #endif
        !            81: 
        !            82: /* On MSDOS, write temp files in current dir
        !            83:    because there's no place else we can expect to use.  */
        !            84: #if __MSDOS__
        !            85: #ifndef P_tmpdir
        !            86: #define P_tmpdir "./"
        !            87: #endif
        !            88: #endif
        !            89: 
        !            90: /* On certain systems, we have code that works by scanning the object file
        !            91:    directly.  But this code uses system-specific header files and library
        !            92:    functions, so turn it off in a cross-compiler.  Likewise, the names of
        !            93:    the utilities aren't correct for a cross-compiler; we have to hope that
        !            94:    cross-versions are in the proper directories.  */
        !            95: 
        !            96: #ifdef CROSS_COMPILE
        !            97: #undef OBJECT_FORMAT_COFF
        !            98: #undef OBJECT_FORMAT_ROSE
        !            99: #undef MD_EXEC_PREFIX
        !           100: #undef REAL_LD_FILE_NAME
        !           101: #undef REAL_NM_FILE_NAME
        !           102: #undef REAL_STRIP_FILE_NAME
        !           103: #endif
        !           104: 
        !           105: /* If we can't use a special method, use the ordinary one:
        !           106:    run nm to find what symbols are present.
        !           107:    In a cross-compiler, this means you need a cross nm,
        !           108:    but that isn't quite as unpleasant as special headers.  */
        !           109: 
        !           110: #if !defined (OBJECT_FORMAT_COFF) && !defined (OBJECT_FORMAT_ROSE)
        !           111: #define OBJECT_FORMAT_NONE
        !           112: #endif
        !           113: 
        !           114: #ifdef OBJECT_FORMAT_COFF
        !           115: 
        !           116: #include <a.out.h>
        !           117: #include <ar.h>
        !           118: 
        !           119: #ifdef UMAX
        !           120: #include <sgs.h>
        !           121: #endif
        !           122: 
        !           123: /* Many versions of ldfcn.h define these.  */
        !           124: #ifdef FREAD
        !           125: #undef FREAD
        !           126: #undef FWRITE
        !           127: #endif
        !           128: 
        !           129: #include <ldfcn.h>
        !           130: 
        !           131: /* Some systems have an ISCOFF macro, but others do not.  In some cases
        !           132:    the macro may be wrong.  MY_ISCOFF is defined in tm.h files for machines
        !           133:    that either do not have an ISCOFF macro in /usr/include or for those 
        !           134:    where it is wrong.  */
        !           135: 
        !           136: #ifndef MY_ISCOFF
        !           137: #define MY_ISCOFF(X) ISCOFF (X)
        !           138: #endif
        !           139: 
        !           140: #endif /* OBJECT_FORMAT_COFF */
        !           141: 
        !           142: #ifdef OBJECT_FORMAT_ROSE
        !           143: 
        !           144: #ifdef _OSF_SOURCE
        !           145: #define USE_MMAP
        !           146: #endif
        !           147: 
        !           148: #ifdef USE_MMAP
        !           149: #include <sys/mman.h>
        !           150: #endif
        !           151: 
        !           152: #include <unistd.h>
        !           153: #include <mach_o_format.h>
        !           154: #include <mach_o_header.h>
        !           155: #include <mach_o_vals.h>
        !           156: #include <mach_o_types.h>
        !           157: 
        !           158: #endif /* OBJECT_FORMAT_ROSE */
        !           159: 
        !           160: #ifdef OBJECT_FORMAT_NONE
        !           161: 
        !           162: /* Default flags to pass to nm.  */
        !           163: #ifndef NM_FLAGS
        !           164: #define NM_FLAGS "-p"
        !           165: #endif
        !           166: 
        !           167: #endif /* OBJECT_FORMAT_NONE */
        !           168: 
        !           169: /* Some systems use __main in a way incompatible with its use in gcc, in these
        !           170:    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
        !           171:    give the same symbol without quotes for an alternative entry point.  You
        !           172:    must define both, or niether. */
        !           173: #ifndef NAME__MAIN
        !           174: #define NAME__MAIN "__main"
        !           175: #define SYMBOL__MAIN __main
        !           176: #endif
        !           177: 
        !           178: 
        !           179: /* Linked lists of constructor and destructor names. */
        !           180: 
        !           181: struct id 
        !           182: {
        !           183:   struct id *next;
        !           184:   int sequence;
        !           185:   char name[1];
        !           186: };
        !           187: 
        !           188: struct head
        !           189: {
        !           190:   struct id *first;
        !           191:   struct id *last;
        !           192:   int number;
        !           193: };
        !           194: 
        !           195: /* Enumeration giving which pass this is for scanning the program file.  */
        !           196: 
        !           197: enum pass {
        !           198:   PASS_FIRST,                          /* without constructors */
        !           199:   PASS_SECOND                          /* with constructors linked in */
        !           200: };
        !           201: 
        !           202: #ifndef NO_SYS_SIGLIST
        !           203: extern char *sys_siglist[];
        !           204: #endif
        !           205: extern char *version_string;
        !           206: 
        !           207: static int vflag;                      /* true if -v */
        !           208: static int rflag;                      /* true if -r */
        !           209: static int strip_flag;                 /* true if -s */
        !           210: 
        !           211: static int debug;                      /* true if -debug */
        !           212: 
        !           213: static int   temp_filename_length;     /* Length of temp_filename */
        !           214: static char *temp_filename;            /* Base of temp filenames */
        !           215: static char *c_file;                   /* <xxx>.c for constructor/destructor list. */
        !           216: static char *o_file;                   /* <xxx>.o for constructor/destructor list. */
        !           217: static char *output_file;              /* Output file for ld.  */
        !           218: static char *nm_file_name;             /* pathname of nm */
        !           219: static char *strip_file_name;          /* pathname of strip */
        !           220: 
        !           221: static struct head constructors;       /* list of constructors found */
        !           222: static struct head destructors;                /* list of destructors found */
        !           223: 
        !           224: extern char *getenv ();
        !           225: extern char *mktemp ();
        !           226: extern FILE *fdopen ();
        !           227: 
        !           228: /* Structure to hold all the directories in which to search for files to
        !           229:    execute.  */
        !           230: 
        !           231: struct prefix_list
        !           232: {
        !           233:   char *prefix;               /* String to prepend to the path. */
        !           234:   struct prefix_list *next;   /* Next in linked list. */
        !           235: };
        !           236: 
        !           237: struct path_prefix
        !           238: {
        !           239:   struct prefix_list *plist;  /* List of prefixes to try */
        !           240:   int max_len;                /* Max length of a prefix in PLIST */
        !           241:   char *name;                 /* Name of this list (used in config stuff) */
        !           242: };
        !           243: 
        !           244: static void my_exit            PROTO((int));
        !           245: static void handler            PROTO((int));
        !           246: static int is_ctor_dtor                PROTO((char *));
        !           247: static void choose_temp_base   PROTO((void));
        !           248: static int is_in_prefix_list   PROTO((struct path_prefix *, char *, int));
        !           249: static char *find_a_file       PROTO((struct path_prefix *, char *));
        !           250: static void add_prefix         PROTO((struct path_prefix *, char *));
        !           251: static void prefix_from_env    PROTO((char *, struct path_prefix *));
        !           252: static void do_wait            PROTO((char *));
        !           253: static void fork_execute       PROTO((char *, char **));
        !           254: static void maybe_unlink       PROTO((char *));
        !           255: static void add_to_list                PROTO((struct head *, char *));
        !           256: static void write_list         PROTO((FILE *, char *, struct id *));
        !           257: static void write_list_with_asm PROTO((FILE *, char *, struct id *));
        !           258: static void write_c_file       PROTO((FILE *, char *));
        !           259: static void scan_prog_file     PROTO((char *, enum pass));
        !           260: 
        !           261: generic *xcalloc ();
        !           262: generic *xmalloc ();
        !           263: 
        !           264: extern char *index ();
        !           265: extern char *rindex ();
        !           266: 
        !           267: #ifdef NO_DUP2
        !           268: int
        !           269: dup2 (oldfd, newfd)
        !           270:      int oldfd;
        !           271:      int newfd;
        !           272: {
        !           273:   int fdtmp[256];
        !           274:   int fdx = 0;
        !           275:   int fd;
        !           276:  
        !           277:   if (oldfd == newfd)
        !           278:     return 0;
        !           279:   close (newfd);
        !           280:   while ((fd = dup (oldfd)) != newfd) /* good enough for low fd's */
        !           281:     fdtmp[fdx++] = fd;
        !           282:   while (fdx > 0)
        !           283:     close (fdtmp[--fdx]);
        !           284: 
        !           285:   return 0;
        !           286: }
        !           287: #endif
        !           288: 
        !           289: char *
        !           290: my_strerror (e)
        !           291:      int e;
        !           292: {
        !           293:   static char buffer[30];
        !           294: 
        !           295:   if (!e)
        !           296:     return "";
        !           297: 
        !           298:   if (e > 0 && e < sys_nerr)
        !           299:     return sys_errlist[e];
        !           300: 
        !           301:   sprintf (buffer, "Unknown error %d", e);
        !           302:   return buffer;
        !           303: }
        !           304: 
        !           305: /* Delete tempfiles and exit function.  */
        !           306: 
        !           307: static void
        !           308: my_exit (status)
        !           309:      int status;
        !           310: {
        !           311:   if (c_file != 0 && c_file[0])
        !           312:     maybe_unlink (c_file);
        !           313: 
        !           314:   if (o_file != 0 && o_file[0])
        !           315:     maybe_unlink (o_file);
        !           316: 
        !           317:   if (status != 0 && output_file != 0 && output_file[0])
        !           318:     maybe_unlink (output_file);
        !           319: 
        !           320:   exit (status);
        !           321: }
        !           322: 
        !           323: 
        !           324: /* Die when sys call fails. */
        !           325: 
        !           326: static void
        !           327: fatal_perror (string, arg1, arg2, arg3)
        !           328:      char *string;
        !           329: {
        !           330:   int e = errno;
        !           331: 
        !           332:   fprintf (stderr, "collect2: ");
        !           333:   fprintf (stderr, string, arg1, arg2, arg3);
        !           334:   fprintf (stderr, ": %s\n", my_strerror (e));
        !           335:   my_exit (1);
        !           336: }
        !           337: 
        !           338: /* Just die. */
        !           339: 
        !           340: static void
        !           341: fatal (string, arg1, arg2, arg3)
        !           342:      char *string;
        !           343: {
        !           344:   fprintf (stderr, "collect2: ");
        !           345:   fprintf (stderr, string, arg1, arg2, arg3);
        !           346:   fprintf (stderr, "\n");
        !           347:   my_exit (1);
        !           348: }
        !           349: 
        !           350: /* Write error message.  */
        !           351: 
        !           352: static void
        !           353: error (string, arg1, arg2, arg3, arg4)
        !           354:      char *string;
        !           355: {
        !           356:   fprintf (stderr, "collect2: ");
        !           357:   fprintf (stderr, string, arg1, arg2, arg3, arg4);
        !           358:   fprintf (stderr, "\n");
        !           359: }
        !           360: 
        !           361: /* In case obstack is linked in, and abort is defined to fancy_abort,
        !           362:    provide a default entry.  */
        !           363: 
        !           364: void
        !           365: fancy_abort ()
        !           366: {
        !           367:   fatal ("internal error");
        !           368: }
        !           369: 
        !           370: 
        !           371: static void
        !           372: handler (signo)
        !           373:      int signo;
        !           374: {
        !           375:   if (c_file != 0 && c_file[0])
        !           376:     maybe_unlink (c_file);
        !           377: 
        !           378:   if (o_file != 0 && o_file[0])
        !           379:     maybe_unlink (o_file);
        !           380: 
        !           381:   signal (signo, SIG_DFL);
        !           382:   kill (getpid (), signo);
        !           383: }
        !           384: 
        !           385: 
        !           386: generic *
        !           387: xcalloc (size1, size2)
        !           388:      int size1, size2;
        !           389: {
        !           390:   generic *ptr = (generic *) calloc (size1, size2);
        !           391:   if (ptr)
        !           392:     return ptr;
        !           393: 
        !           394:   fatal ("out of memory");
        !           395:   return (generic *)0;
        !           396: }
        !           397: 
        !           398: generic *
        !           399: xmalloc (size)
        !           400:      int size;
        !           401: {
        !           402:   generic *ptr = (generic *) malloc (size);
        !           403:   if (ptr)
        !           404:     return ptr;
        !           405: 
        !           406:   fatal ("out of memory");
        !           407:   return (generic *)0;
        !           408: }
        !           409: 
        !           410: /* Make a copy of a string INPUT with size SIZE.  */
        !           411: 
        !           412: char *
        !           413: savestring (input, size)
        !           414:      char *input;
        !           415:      int size;
        !           416: {
        !           417:   char *output = (char *) xmalloc (size + 1);
        !           418:   bcopy (input, output, size);
        !           419:   output[size] = 0;
        !           420:   return output;
        !           421: }
        !           422: 
        !           423: /* Decide whether the given symbol is:
        !           424:    a constructor (1), a destructor (2), or neither (0).  */
        !           425: 
        !           426: static int
        !           427: is_ctor_dtor (s)
        !           428:      char *s;
        !           429: {
        !           430:   struct names { char *name; int len; int ret; int two_underscores; };
        !           431: 
        !           432:   register struct names *p;
        !           433:   register int ch;
        !           434:   register char *orig_s = s;
        !           435: 
        !           436:   static struct names special[] = {
        !           437: #ifdef NO_DOLLAR_IN_LABEL
        !           438: #ifdef NO_DOT_IN_LABEL
        !           439:     { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
        !           440:     { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
        !           441: #else
        !           442:     { "GLOBAL_.I.", sizeof ("GLOBAL_.I.")-1, 1, 0 },
        !           443:     { "GLOBAL_.D.", sizeof ("GLOBAL_.D.")-1, 2, 0 },
        !           444: #endif
        !           445: #else
        !           446:     { "GLOBAL_$I$", sizeof ("GLOBAL_$I$")-1, 1, 0 },
        !           447:     { "GLOBAL_$D$", sizeof ("GLOBAL_$D$")-1, 2, 0 },
        !           448: #endif
        !           449: #ifdef CFRONT_LOSSAGE /* Don't collect cfront initialization functions.
        !           450:                         cfront has its own linker procedure to collect them;
        !           451:                         if collect2 gets them too, they get collected twice
        !           452:                         when the cfront procedure is run and the compiler used
        !           453:                         for linking happens to be GCC.  */
        !           454:     { "sti__", sizeof ("sti__")-1, 1, 1 },
        !           455:     { "std__", sizeof ("std__")-1, 2, 1 },
        !           456: #endif /* CFRONT_LOSSAGE */
        !           457:     { NULL, 0, 0, 0 }
        !           458:   };
        !           459: 
        !           460:   while ((ch = *s) == '_')
        !           461:     ++s;
        !           462: 
        !           463:   if (s == orig_s)
        !           464:     return 0;
        !           465: 
        !           466:   for (p = &special[0]; p->len > 0; p++)
        !           467:     {
        !           468:       if (ch == p->name[0]
        !           469:          && (!p->two_underscores || ((s - orig_s) >= 2))
        !           470:          && strncmp(s, p->name, p->len) == 0)
        !           471:        {
        !           472:          return p->ret;
        !           473:        }
        !           474:     }
        !           475:   return 0;
        !           476: }
        !           477: 
        !           478: 
        !           479: /* Compute a string to use as the base of all temporary file names.
        !           480:    It is substituted for %g.  */
        !           481: 
        !           482: static void
        !           483: choose_temp_base ()
        !           484: {
        !           485:   char *base = getenv ("TMPDIR");
        !           486:   int len;
        !           487: 
        !           488:   if (base == (char *)0)
        !           489:     {
        !           490: #ifdef P_tmpdir
        !           491:       if (access (P_tmpdir, R_OK | W_OK) == 0)
        !           492:        base = P_tmpdir;
        !           493: #endif
        !           494:       if (base == (char *)0)
        !           495:        {
        !           496:          if (access ("/usr/tmp", R_OK | W_OK) == 0)
        !           497:            base = "/usr/tmp/";
        !           498:          else
        !           499:            base = "/tmp/";
        !           500:        }
        !           501:     }
        !           502: 
        !           503:   len = strlen (base);
        !           504:   temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
        !           505:   strcpy (temp_filename, base);
        !           506:   if (len > 0 && temp_filename[len-1] != '/')
        !           507:     temp_filename[len++] = '/';
        !           508:   strcpy (temp_filename + len, "ccXXXXXX");
        !           509: 
        !           510:   mktemp (temp_filename);
        !           511:   temp_filename_length = strlen (temp_filename);
        !           512: }
        !           513: 
        !           514: /* Routine to add variables to the environment.  */
        !           515: 
        !           516: #ifndef HAVE_PUTENV
        !           517: 
        !           518: int
        !           519: putenv (str)
        !           520:      char *str;
        !           521: {
        !           522: #ifndef VMS                    /* nor about VMS */
        !           523: 
        !           524:   extern char **environ;
        !           525:   char **old_environ = environ;
        !           526:   char **envp;
        !           527:   int num_envs = 0;
        !           528:   int name_len = 1;
        !           529:   int str_len = strlen (str);
        !           530:   char *p = str;
        !           531:   int ch;
        !           532: 
        !           533:   while ((ch = *p++) != '\0' && ch != '=')
        !           534:     name_len++;
        !           535: 
        !           536:   if (!ch)
        !           537:     abort ();
        !           538: 
        !           539:   /* Search for replacing an existing environment variable, and
        !           540:      count the number of total environment variables.  */
        !           541:   for (envp = old_environ; *envp; envp++)
        !           542:     {
        !           543:       num_envs++;
        !           544:       if (!strncmp (str, *envp, name_len))
        !           545:        {
        !           546:          *envp = str;
        !           547:          return 0;
        !           548:        }
        !           549:     }
        !           550: 
        !           551:   /* Add a new environment variable */
        !           552:   environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
        !           553:   *environ = str;
        !           554:   bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
        !           555:   return 0;
        !           556: #endif /* VMS */
        !           557: }
        !           558: 
        !           559: #endif /* HAVE_PUTENV */
        !           560: 
        !           561: /* By default, colon separates directories in a path.  */
        !           562: #ifndef PATH_SEPARATOR
        !           563: #define PATH_SEPARATOR ':'
        !           564: #endif
        !           565: 
        !           566: /* We maintain two prefix lists: one from COMPILER_PATH environment variable
        !           567:    and one from the PATH variable.  */
        !           568: 
        !           569: static struct path_prefix cpath, path;
        !           570: 
        !           571: #ifdef CROSS_COMPILE
        !           572: /* This is the name of the target machine.  We use it to form the name
        !           573:    of the files to execute.  */
        !           574: 
        !           575: static char *target_machine = TARGET_MACHINE;
        !           576: #endif
        !           577: 
        !           578: /* Names under which we were executed.  Never return one of those files in our
        !           579:    searches.  */
        !           580: 
        !           581: static struct path_prefix our_file_names;
        !           582: 
        !           583: /* Determine if STRING is in PPREFIX.
        !           584: 
        !           585:    This utility is currently only used to look up file names.  Prefix lists
        !           586:    record directory names.  This matters to us because the latter has a 
        !           587:    trailing slash, so I've added a flag to handle both.  */
        !           588: 
        !           589: static int
        !           590: is_in_prefix_list (pprefix, string, filep)
        !           591:      struct path_prefix *pprefix;
        !           592:      char *string;
        !           593:      int filep;
        !           594: {
        !           595:   struct prefix_list *pl;
        !           596: 
        !           597:   if (filep)
        !           598:     {
        !           599:       int len = strlen (string);
        !           600: 
        !           601:       for (pl = pprefix->plist; pl; pl = pl->next)
        !           602:        {
        !           603:          if (strncmp (pl->prefix, string, len) == 0
        !           604:              && strcmp (pl->prefix + len, "/") == 0)
        !           605:            return 1;
        !           606:        }
        !           607:     }
        !           608:   else
        !           609:     {
        !           610:       for (pl = pprefix->plist; pl; pl = pl->next)
        !           611:        {
        !           612:          if (strcmp (pl->prefix, string) == 0)
        !           613:            return 1;
        !           614:        }
        !           615:     }
        !           616: 
        !           617:   return 0;
        !           618: }
        !           619: 
        !           620: /* Search for NAME using prefix list PPREFIX.  We only look for executable
        !           621:    files. 
        !           622: 
        !           623:    Return 0 if not found, otherwise return its name, allocated with malloc. */
        !           624: 
        !           625: static char *
        !           626: find_a_file (pprefix, name)
        !           627:      struct path_prefix *pprefix;
        !           628:      char *name;
        !           629: {
        !           630:   char *temp;
        !           631:   struct prefix_list *pl;
        !           632:   int len = pprefix->max_len + strlen (name) + 1;
        !           633: 
        !           634: #ifdef EXECUTABLE_SUFFIX
        !           635:   len += strlen (EXECUTABLE_SUFFIX);
        !           636: #endif
        !           637: 
        !           638:   temp = xmalloc (len);
        !           639: 
        !           640:   /* Determine the filename to execute (special case for absolute paths).  */
        !           641: 
        !           642:   if (*name == '/')
        !           643:     {
        !           644:       if (access (name, X_OK) == 0)
        !           645:        {
        !           646:          strcpy (temp, name);
        !           647:          return temp;
        !           648:        }
        !           649:     }
        !           650:   else
        !           651:     for (pl = pprefix->plist; pl; pl = pl->next)
        !           652:       {
        !           653:        strcpy (temp, pl->prefix);
        !           654:        strcat (temp, name);
        !           655:        if (! is_in_prefix_list (&our_file_names, temp, 1)
        !           656:            /* This is a kludge, but there seems no way around it.  */
        !           657:            && strcmp (temp, "./ld") != 0
        !           658:            && access (temp, X_OK) == 0)
        !           659:          return temp;
        !           660: 
        !           661: #ifdef EXECUTABLE_SUFFIX
        !           662:        /* Some systems have a suffix for executable files.
        !           663:           So try appending that.  */
        !           664:        strcat (temp, EXECUTABLE_SUFFIX);
        !           665:        if (! is_in_prefix_list (&our_file_names, temp, 1)
        !           666:            && access (temp, X_OK) == 0)
        !           667:          return temp;
        !           668: #endif
        !           669:       }
        !           670: 
        !           671:   free (temp);
        !           672:   return 0;
        !           673: }
        !           674: 
        !           675: /* Add an entry for PREFIX to prefix list PPREFIX.  */
        !           676: 
        !           677: static void
        !           678: add_prefix (pprefix, prefix)
        !           679:      struct path_prefix *pprefix;
        !           680:      char *prefix;
        !           681: {
        !           682:   struct prefix_list *pl, **prev;
        !           683:   int len;
        !           684: 
        !           685:   if (pprefix->plist)
        !           686:     {
        !           687:       for (pl = pprefix->plist; pl->next; pl = pl->next)
        !           688:        ;
        !           689:       prev = &pl->next;
        !           690:     }
        !           691:   else
        !           692:     prev = &pprefix->plist;
        !           693: 
        !           694:   /* Keep track of the longest prefix */
        !           695: 
        !           696:   len = strlen (prefix);
        !           697:   if (len > pprefix->max_len)
        !           698:     pprefix->max_len = len;
        !           699: 
        !           700:   pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
        !           701:   pl->prefix = savestring (prefix, len);
        !           702: 
        !           703:   if (*prev)
        !           704:     pl->next = *prev;
        !           705:   else
        !           706:     pl->next = (struct prefix_list *) 0;
        !           707:   *prev = pl;
        !           708: }
        !           709: 
        !           710: /* Take the value of the environment variable ENV, break it into a path, and
        !           711:    add of the entries to PPREFIX.  */
        !           712: 
        !           713: static void
        !           714: prefix_from_env (env, pprefix)
        !           715:      char *env;
        !           716:      struct path_prefix *pprefix;
        !           717: {
        !           718:   char *p = getenv (env);
        !           719: 
        !           720:   if (p)
        !           721:     {
        !           722:       char *startp, *endp;
        !           723:       char *nstore = (char *) xmalloc (strlen (p) + 3);
        !           724: 
        !           725:       startp = endp = p;
        !           726:       while (1)
        !           727:        {
        !           728:          if (*endp == PATH_SEPARATOR || *endp == 0)
        !           729:            {
        !           730:              strncpy (nstore, startp, endp-startp);
        !           731:              if (endp == startp)
        !           732:                {
        !           733:                  strcpy (nstore, "./");
        !           734:                }
        !           735:              else if (endp[-1] != '/')
        !           736:                {
        !           737:                  nstore[endp-startp] = '/';
        !           738:                  nstore[endp-startp+1] = 0;
        !           739:                }
        !           740:              else
        !           741:                nstore[endp-startp] = 0;
        !           742: 
        !           743:              add_prefix (pprefix, nstore);
        !           744:              if (*endp == 0)
        !           745:                break;
        !           746:              endp = startp = endp + 1;
        !           747:            }
        !           748:          else
        !           749:            endp++;
        !           750:        }
        !           751:     }
        !           752: }
        !           753: 
        !           754: /* Main program. */
        !           755: 
        !           756: int
        !           757: main (argc, argv)
        !           758:      int argc;
        !           759:      char *argv[];
        !           760: {
        !           761:   char *ld_suffix      = "ld";
        !           762:   char *full_ld_suffix = ld_suffix;
        !           763:   char *real_ld_suffix = "real-ld";
        !           764:   char *full_real_ld_suffix = real_ld_suffix;
        !           765: #if 0
        !           766:   char *gld_suffix     = "gld";
        !           767:   char *full_gld_suffix        = gld_suffix;
        !           768: #endif
        !           769:   char *nm_suffix      = "nm";
        !           770:   char *full_nm_suffix = nm_suffix;
        !           771:   char *gnm_suffix     = "gnm";
        !           772:   char *full_gnm_suffix        = gnm_suffix;
        !           773:   char *strip_suffix   = "strip";
        !           774:   char *full_strip_suffix = strip_suffix;
        !           775:   char *gstrip_suffix  = "gstrip";
        !           776:   char *full_gstrip_suffix = gstrip_suffix;
        !           777:   char *arg;
        !           778:   FILE *outf;
        !           779:   char *ld_file_name;
        !           780:   char *c_file_name;
        !           781:   char *collect_name;
        !           782:   char *collect_names;
        !           783:   char *p;
        !           784:   char **c_argv;
        !           785:   char **c_ptr;
        !           786:   char **ld1_argv      = (char **) xcalloc (sizeof (char *), argc+2);
        !           787:   char **ld1           = ld1_argv;
        !           788:   char **ld2_argv      = (char **) xcalloc (sizeof (char *), argc+5);
        !           789:   char **ld2           = ld2_argv;
        !           790:   int first_file;
        !           791:   int num_c_args       = argc+7;
        !           792:   int len;
        !           793:   int clen;
        !           794: 
        !           795: #ifdef DEBUG
        !           796:   debug = 1;
        !           797:   vflag = 1;
        !           798: #endif
        !           799: 
        !           800:   output_file = "a.out";
        !           801: 
        !           802:   /* We must check that we do not call ourselves in an infinite
        !           803:      recursion loop. We append the name used for us to the COLLECT_NAMES
        !           804:      environment variable.
        !           805: 
        !           806:      In practice, collect will rarely invoke itself.  This can happen now
        !           807:      that we are no longer called gld.  A perfect example is when running
        !           808:      gcc in a build directory that has been installed.  When looking for 
        !           809:      ld's, we'll find our installed version and believe that's the real ld.  */
        !           810: 
        !           811:   /* We must also append COLLECT_NAME to COLLECT_NAMES to watch for the
        !           812:      previous version of collect (the one that used COLLECT_NAME and only
        !           813:      handled two levels of recursion).  If we don't we may mutually recurse
        !           814:      forever.  This can happen (I think) when bootstrapping the old version
        !           815:      and a new one is installed (rare, but we should handle it).
        !           816:      ??? Hopefully references to COLLECT_NAME can be removed at some point.  */
        !           817: 
        !           818:   collect_name = (char *) getenv ("COLLECT_NAME");
        !           819:   collect_names = (char *) getenv ("COLLECT_NAMES");
        !           820: 
        !           821:   p = (char *) xmalloc (strlen ("COLLECT_NAMES=")
        !           822:                        + (collect_name ? strlen (collect_name) + 1 : 0)
        !           823:                        + (collect_names ? strlen (collect_names) + 1 : 0)
        !           824:                        + strlen (argv[0]) + 1);
        !           825:   strcpy (p, "COLLECT_NAMES=");
        !           826:   if (collect_name != 0)
        !           827:     sprintf (p + strlen (p), "%s%c", collect_name, PATH_SEPARATOR);
        !           828:   if (collect_names != 0)
        !           829:     sprintf (p + strlen (p), "%s%c", collect_names, PATH_SEPARATOR);
        !           830:   strcat (p, argv[0]);
        !           831:   putenv (p);
        !           832: 
        !           833:   prefix_from_env ("COLLECT_NAMES", &our_file_names);
        !           834: 
        !           835:   /* Set environment variable COLLECT_NAME to our name so the previous version
        !           836:      of collect won't find us.  If it does we'll mutually recurse forever.
        !           837:      This can happen when bootstrapping the new version and an old version is
        !           838:      installed.
        !           839:      ??? Hopefully this bit of code can be removed at some point.  */
        !           840: 
        !           841:   p = xmalloc (strlen ("COLLECT_NAME=") + strlen (argv[0]) + 1);
        !           842:   sprintf (p, "COLLECT_NAME=%s", argv[0]);
        !           843:   putenv (p);
        !           844: 
        !           845:   p = (char *) getenv ("COLLECT_GCC_OPTIONS");
        !           846:   if (p)
        !           847:     while (*p)
        !           848:       {
        !           849:        char *q = p;
        !           850:        while (*q && *q != ' ') q++;
        !           851:        if (*p == '-' && p[1] == 'm')
        !           852:          num_c_args++;
        !           853: 
        !           854:        if (*q) q++;
        !           855:        p = q;
        !           856:       }
        !           857: 
        !           858:   c_ptr = c_argv = (char **) xcalloc (sizeof (char *), num_c_args);
        !           859: 
        !           860:   if (argc < 2)
        !           861:     fatal ("no arguments");
        !           862: 
        !           863: #ifdef SIGQUIT
        !           864:   if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
        !           865:     signal (SIGQUIT, handler);
        !           866: #endif
        !           867:   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
        !           868:     signal (SIGINT, handler);
        !           869: #ifdef SIGALRM
        !           870:   if (signal (SIGALRM, SIG_IGN) != SIG_IGN)
        !           871:     signal (SIGALRM, handler);
        !           872: #endif
        !           873: #ifdef SIGHUP
        !           874:   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
        !           875:     signal (SIGHUP, handler);
        !           876: #endif
        !           877:   if (signal (SIGSEGV, SIG_IGN) != SIG_IGN)
        !           878:     signal (SIGSEGV, handler);
        !           879: #ifdef SIGBUS
        !           880:   if (signal (SIGBUS, SIG_IGN) != SIG_IGN)
        !           881:     signal (SIGBUS, handler);
        !           882: #endif
        !           883: 
        !           884:   /* Extract COMPILER_PATH and PATH into our prefix list.  */
        !           885:   prefix_from_env ("COMPILER_PATH", &cpath);
        !           886:   prefix_from_env ("PATH", &path);
        !           887: 
        !           888: #ifdef CROSS_COMPILE
        !           889:   /* If we look for a program in the compiler directories, we just use
        !           890:      the short name, since these directories are already system-specific.
        !           891:      But it we look for a took in the system directories, we need to
        !           892:      qualify the program name with the target machine.  */
        !           893: 
        !           894:   full_ld_suffix
        !           895:     = xcalloc (strlen (ld_suffix) + strlen (target_machine) + 2, 1);
        !           896:   strcpy (full_ld_suffix, target_machine);
        !           897:   strcat (full_ld_suffix, "-");
        !           898:   strcat (full_ld_suffix, ld_suffix);
        !           899: 
        !           900:   full_real_ld_suffix
        !           901:     = xcalloc (strlen (real_ld_suffix) + strlen (target_machine) + 2, 1);
        !           902:   strcpy (full_real_ld_suffix, target_machine);
        !           903:   strcat (full_real_ld_suffix, "-");
        !           904:   strcat (full_real_ld_suffix, real_ld_suffix);
        !           905: 
        !           906: #if 0
        !           907:   full_gld_suffix
        !           908:     = xcalloc (strlen (gld_suffix) + strlen (target_machine) + 2, 1);
        !           909:   strcpy (full_gld_suffix, target_machine);
        !           910:   strcat (full_gld_suffix, "-");
        !           911:   strcat (full_gld_suffix, gld_suffix);
        !           912: #endif
        !           913: 
        !           914:   full_nm_suffix
        !           915:     = xcalloc (strlen (nm_suffix) + strlen (target_machine) + 2, 1);
        !           916:   strcpy (full_nm_suffix, target_machine);
        !           917:   strcat (full_nm_suffix, "-");
        !           918:   strcat (full_nm_suffix, nm_suffix);
        !           919: 
        !           920:   full_gnm_suffix
        !           921:     = xcalloc (strlen (gnm_suffix) + strlen (target_machine) + 2, 1);
        !           922:   strcpy (full_gnm_suffix, target_machine);
        !           923:   strcat (full_gnm_suffix, "-");
        !           924:   strcat (full_gnm_suffix, gnm_suffix);
        !           925: 
        !           926:   full_strip_suffix
        !           927:     = xcalloc (strlen (strip_suffix) + strlen (target_machine) + 2, 1);
        !           928:   strcpy (full_strip_suffix, target_machine);
        !           929:   strcat (full_strip_suffix, "-");
        !           930:   strcat (full_strip_suffix, strip_suffix);
        !           931:   
        !           932:   full_gstrip_suffix
        !           933:     = xcalloc (strlen (gstrip_suffix) + strlen (target_machine) + 2, 1);
        !           934:   strcpy (full_gstrip_suffix, target_machine);
        !           935:   strcat (full_gstrip_suffix, "-");
        !           936:   strcat (full_gstrip_suffix, gstrip_suffix);
        !           937: #endif /* CROSS_COMPILE */
        !           938: 
        !           939:   /* Try to discover a valid linker/nm/strip to use.  */
        !           940: 
        !           941: #if 0
        !           942:   /* Search the (target-specific) compiler dirs for `gld'.  */
        !           943:   ld_file_name = find_a_file (&cpath, gld_suffix);
        !           944:   /* Search the ordinary system bin directories
        !           945:      for `gld' (if native linking) or `TARGET-gld' (if cross).  */
        !           946:   if (ld_file_name == 0)
        !           947:     ld_file_name = find_a_file (&path, full_gld_suffix);
        !           948: #else
        !           949:   ld_file_name = 0;
        !           950: #endif
        !           951:   /* Likewise for `real-ld'.  */
        !           952:   if (ld_file_name == 0)
        !           953:     ld_file_name = find_a_file (&cpath, real_ld_suffix);
        !           954:   if (ld_file_name == 0)
        !           955:     ld_file_name = find_a_file (&path, full_real_ld_suffix);
        !           956:   /* Maybe we know the right file to use (if not cross).  */
        !           957: #ifdef REAL_LD_FILE_NAME
        !           958:   if (ld_file_name == 0)
        !           959:     ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME);
        !           960: #endif
        !           961:   if (ld_file_name == 0)
        !           962:     ld_file_name = find_a_file (&cpath, full_ld_suffix);
        !           963:   /* Search the ordinary system bin directories
        !           964:      for `ld' (if native linking) or `TARGET-ld' (if cross).  */
        !           965:   if (ld_file_name == 0)
        !           966:     ld_file_name = find_a_file (&path, full_ld_suffix);
        !           967: 
        !           968:   /* If we've invoked ourselves, try again with LD_FILE_NAME.  */
        !           969: 
        !           970:   if (collect_names != 0)
        !           971:     {
        !           972:       if (ld_file_name != 0)
        !           973:        {
        !           974:          argv[0] = ld_file_name;
        !           975:          execvp (argv[0], argv);
        !           976:        }
        !           977:       fatal ("cannot find `ld'");
        !           978:     }
        !           979: 
        !           980:   nm_file_name = find_a_file (&cpath, gnm_suffix);
        !           981:   if (nm_file_name == 0)
        !           982:     nm_file_name = find_a_file (&path, full_gnm_suffix);
        !           983:   if (nm_file_name == 0)
        !           984:     nm_file_name = find_a_file (&cpath, nm_suffix);
        !           985: #ifdef REAL_NM_FILE_NAME
        !           986:   if (nm_file_name == 0)
        !           987:     nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME);
        !           988: #endif
        !           989:   if (nm_file_name == 0)
        !           990:     nm_file_name = find_a_file (&path, full_nm_suffix);
        !           991: 
        !           992:   strip_file_name = find_a_file (&cpath, gstrip_suffix);
        !           993:   if (strip_file_name == 0)
        !           994:     strip_file_name = find_a_file (&path, full_gstrip_suffix);
        !           995:   if (strip_file_name == 0)
        !           996:     strip_file_name = find_a_file (&cpath, strip_suffix);
        !           997: #ifdef REAL_STRIP_FILE_NAME
        !           998:   if (strip_file_name == 0)
        !           999:     strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME);
        !          1000: #endif
        !          1001:   if (strip_file_name == 0)
        !          1002:     strip_file_name = find_a_file (&path, full_strip_suffix);
        !          1003: 
        !          1004:   /* Determine the full path name of the C compiler to use.  */
        !          1005:   c_file_name = getenv ("COLLECT_GCC");
        !          1006:   if (c_file_name == 0)
        !          1007:     {
        !          1008: #ifdef CROSS_COMPILE
        !          1009:       c_file_name = xcalloc (sizeof ("gcc-") + strlen (target_machine) + 1, 1);
        !          1010:       strcpy (c_file_name, target_machine);
        !          1011:       strcat (c_file_name, "-gcc");
        !          1012: #else
        !          1013:       c_file_name = "gcc";
        !          1014: #endif
        !          1015:     }
        !          1016: 
        !          1017:   p = find_a_file (&cpath, c_file_name);
        !          1018: 
        !          1019:   /* Here it should be safe to use the system search path since we should have
        !          1020:      already qualified the name of the compiler when it is needed.  */
        !          1021:   if (p == 0)
        !          1022:     p = find_a_file (&path, c_file_name);
        !          1023: 
        !          1024:   if (p)
        !          1025:     c_file_name = p;
        !          1026: 
        !          1027:   *ld1++ = *ld2++ = ld_file_name;
        !          1028: 
        !          1029:   /* Make temp file names. */
        !          1030:   choose_temp_base ();
        !          1031:   c_file = xcalloc (temp_filename_length + sizeof (".c"), 1);
        !          1032:   o_file = xcalloc (temp_filename_length + sizeof (".o"), 1);
        !          1033:   sprintf (c_file, "%s.c", temp_filename);
        !          1034:   sprintf (o_file, "%s.o", temp_filename);
        !          1035:   *c_ptr++ = c_file_name;
        !          1036:   *c_ptr++ = "-c";
        !          1037:   *c_ptr++ = "-o";
        !          1038:   *c_ptr++ = o_file;
        !          1039: 
        !          1040:   /* !!! When GCC calls collect2,
        !          1041:      it does not know whether it is calling collect2 or ld.
        !          1042:      So collect2 cannot meaningfully understand any options
        !          1043:      except those ld understands.
        !          1044:      If you propose to make GCC pass some other option,
        !          1045:      just imagine what will happen if ld is really ld!!!  */
        !          1046: 
        !          1047:   /* Parse arguments.  Remember output file spec, pass the rest to ld. */
        !          1048:   /* After the first file, put in the c++ rt0.  */
        !          1049: 
        !          1050:   first_file = 1;
        !          1051:   while ((arg = *++argv) != (char *)0)
        !          1052:     {
        !          1053:       *ld1++ = *ld2++ = arg;
        !          1054: 
        !          1055:       if (arg[0] == '-')
        !          1056:          switch (arg[1])
        !          1057:            {
        !          1058:            case 'd':
        !          1059:              if (!strcmp (arg, "-debug"))
        !          1060:                {
        !          1061:                  debug = 1;
        !          1062:                  vflag = 1;
        !          1063:                  ld1--;
        !          1064:                  ld2--;
        !          1065:                }
        !          1066:              break;
        !          1067: 
        !          1068:            case 'o':
        !          1069:              output_file = (arg[2] == '\0') ? argv[1] : &arg[2];
        !          1070:              break;
        !          1071: 
        !          1072:            case 'r':
        !          1073:              if (arg[2] == '\0')
        !          1074:                rflag = 1;
        !          1075:              break;
        !          1076: 
        !          1077:            case 's':
        !          1078:              if (arg[2] == '\0')
        !          1079:                {
        !          1080:                  /* We must strip after the nm run, otherwise C++ linking
        !          1081:                     won't work.  Thus we strip in the second ld run, or
        !          1082:                     else with strip if there is no second ld run.  */
        !          1083:                  strip_flag = 1;
        !          1084:                  ld1--;
        !          1085:                }
        !          1086:              break;
        !          1087: 
        !          1088:            case 'v':
        !          1089:              if (arg[2] == '\0')
        !          1090:                vflag = 1;
        !          1091:              break;
        !          1092:            }
        !          1093: 
        !          1094:       else if (first_file
        !          1095:               && (p = rindex (arg, '.')) != (char *)0
        !          1096:               && strcmp (p, ".o") == 0)
        !          1097:        {
        !          1098:          first_file = 0;
        !          1099:          *ld2++ = o_file;
        !          1100:        }
        !          1101:     }
        !          1102: 
        !          1103:   /* Get any options that the upper GCC wants to pass to the sub-GCC.  */
        !          1104:   p = (char *) getenv ("COLLECT_GCC_OPTIONS");
        !          1105:   if (p)
        !          1106:     while (*p)
        !          1107:       {
        !          1108:        char *q = p;
        !          1109:        while (*q && *q != ' ') q++;
        !          1110:        if (*p == '-' && (p[1] == 'm' || p[1] == 'f'))
        !          1111:          *c_ptr++ = savestring (p, q - p);
        !          1112: 
        !          1113:        if (*q) q++;
        !          1114:        p = q;
        !          1115:       }
        !          1116: 
        !          1117:   *c_ptr++ = c_file;
        !          1118:   *c_ptr = *ld1 = *ld2 = (char *)0;
        !          1119: 
        !          1120:   if (vflag)
        !          1121:     {
        !          1122:       fprintf (stderr, "collect2 version %s", version_string);
        !          1123: #ifdef TARGET_VERSION
        !          1124:       TARGET_VERSION;
        !          1125: #endif
        !          1126:       fprintf (stderr, "\n");
        !          1127:     }
        !          1128: 
        !          1129:   if (debug)
        !          1130:     {
        !          1131:       char *ptr;
        !          1132:       fprintf (stderr, "ld_file_name        = %s\n",
        !          1133:               (ld_file_name ? ld_file_name : "not found"));
        !          1134:       fprintf (stderr, "c_file_name         = %s\n",
        !          1135:               (c_file_name ? c_file_name : "not found"));
        !          1136:       fprintf (stderr, "nm_file_name        = %s\n",
        !          1137:               (nm_file_name ? nm_file_name : "not found"));
        !          1138:       fprintf (stderr, "strip_file_name     = %s\n",
        !          1139:               (strip_file_name ? strip_file_name : "not found"));
        !          1140:       fprintf (stderr, "c_file              = %s\n",
        !          1141:               (c_file ? c_file : "not found"));
        !          1142:       fprintf (stderr, "o_file              = %s\n",
        !          1143:               (o_file ? o_file : "not found"));
        !          1144: 
        !          1145:       ptr = getenv ("COLLECT_NAMES");
        !          1146:       if (ptr)
        !          1147:        fprintf (stderr, "COLLECT_NAMES       = %s\n", ptr);
        !          1148: 
        !          1149:       ptr = getenv ("COLLECT_GCC_OPTIONS");
        !          1150:       if (ptr)
        !          1151:        fprintf (stderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);
        !          1152: 
        !          1153:       ptr = getenv ("COLLECT_GCC");
        !          1154:       if (ptr)
        !          1155:        fprintf (stderr, "COLLECT_GCC         = %s\n", ptr);
        !          1156: 
        !          1157:       ptr = getenv ("COMPILER_PATH");
        !          1158:       if (ptr)
        !          1159:        fprintf (stderr, "COMPILER_PATH       = %s\n", ptr);
        !          1160: 
        !          1161:       ptr = getenv ("LIBRARY_PATH");
        !          1162:       if (ptr)
        !          1163:        fprintf (stderr, "LIBRARY_PATH        = %s\n", ptr);
        !          1164: 
        !          1165:       fprintf (stderr, "\n");
        !          1166:     }
        !          1167: 
        !          1168:   /* Load the program, searching all libraries.
        !          1169:      Examine the namelist with nm and search it for static constructors
        !          1170:      and destructors to call.
        !          1171:      Write the constructor and destructor tables to a .s file and reload. */
        !          1172: 
        !          1173:   fork_execute ("ld", ld1_argv);
        !          1174: 
        !          1175:   /* If -r, don't build the constructor or destructor list, just return now.  */
        !          1176:   if (rflag)
        !          1177:     return 0;
        !          1178: 
        !          1179:   scan_prog_file (output_file, PASS_FIRST);
        !          1180: 
        !          1181:   if (debug)
        !          1182:     {
        !          1183:       fprintf (stderr, "%d constructor(s) found\n", constructors.number);
        !          1184:       fprintf (stderr, "%d destructor(s)  found\n", destructors.number);
        !          1185:     }
        !          1186: 
        !          1187:   if (constructors.number == 0 && destructors.number == 0)
        !          1188:     {
        !          1189:       /* Strip now if it was requested on the command line.  */
        !          1190:       if (strip_flag)
        !          1191:        {
        !          1192:          char **strip_argv = (char **) xcalloc (sizeof (char *), 3);
        !          1193:          strip_argv[0] = strip_file_name;
        !          1194:          strip_argv[1] = output_file;
        !          1195:          strip_argv[2] = (char *) 0;
        !          1196:          fork_execute ("strip", strip_argv);
        !          1197:        }
        !          1198:       return 0;
        !          1199:     }
        !          1200: 
        !          1201:   outf = fopen (c_file, "w");
        !          1202:   if (outf == (FILE *)0)
        !          1203:     fatal_perror ("%s", c_file);
        !          1204: 
        !          1205:   write_c_file (outf, c_file);
        !          1206: 
        !          1207:   if (fclose (outf))
        !          1208:     fatal_perror ("closing %s", c_file);
        !          1209: 
        !          1210:   if (debug)
        !          1211:     {
        !          1212:       fprintf (stderr, "\n========== output_file = %s, c_file = %s\n",
        !          1213:               output_file, c_file);
        !          1214:       write_c_file (stderr, "stderr");
        !          1215:       fprintf (stderr, "========== end of c_file\n\n");
        !          1216:     }
        !          1217: 
        !          1218:   /* Assemble the constructor and destructor tables.
        !          1219:      Link the tables in with the rest of the program. */
        !          1220: 
        !          1221:   fork_execute ("gcc",  c_argv);
        !          1222:   fork_execute ("ld", ld2_argv);
        !          1223: 
        !          1224:   /* Let scan_prog_file do any final mods (OSF/rose needs this for
        !          1225:      constructors/destructors in shared libraries.  */
        !          1226:   scan_prog_file (output_file, PASS_SECOND);
        !          1227: 
        !          1228:   maybe_unlink (c_file);
        !          1229:   maybe_unlink (o_file);
        !          1230:   return 0;
        !          1231: }
        !          1232: 
        !          1233: 
        !          1234: /* Wait for a process to finish, and exit if a non-zero status is found. */
        !          1235: 
        !          1236: static void
        !          1237: do_wait (prog)
        !          1238:      char *prog;
        !          1239: {
        !          1240:   int status;
        !          1241: 
        !          1242:   wait (&status);
        !          1243:   if (status)
        !          1244:     {
        !          1245:       int sig = status & 0x7F;
        !          1246:       int ret;
        !          1247: 
        !          1248:       if (sig != -1 && sig != 0)
        !          1249:        {
        !          1250: #ifdef NO_SYS_SIGLIST
        !          1251:          error ("%s terminated with signal %d %s",
        !          1252:                 prog,
        !          1253:                 sig,
        !          1254:                 (status & 0200) ? ", core dumped" : "");
        !          1255: #else
        !          1256:          error ("%s terminated with signal %d [%s]%s",
        !          1257:                 prog,
        !          1258:                 sig,
        !          1259:                 sys_siglist[sig],
        !          1260:                 (status & 0200) ? ", core dumped" : "");
        !          1261: #endif
        !          1262: 
        !          1263:          my_exit (127);
        !          1264:        }
        !          1265: 
        !          1266:       ret = ((status & 0xFF00) >> 8);
        !          1267:       if (ret != -1 && ret != 0)
        !          1268:        {
        !          1269:          error ("%s returned %d exit status", prog, ret);
        !          1270:          my_exit (ret);
        !          1271:        }
        !          1272:     }
        !          1273: }
        !          1274: 
        !          1275: 
        !          1276: /* Fork and execute a program, and wait for the reply.  */
        !          1277: 
        !          1278: static void
        !          1279: fork_execute (prog, argv)
        !          1280:      char *prog;
        !          1281:      char **argv;
        !          1282: {
        !          1283:   int pid;
        !          1284: 
        !          1285:   if (vflag || debug)
        !          1286:     {
        !          1287:       char **p_argv;
        !          1288:       char *str;
        !          1289: 
        !          1290:       if (argv[0])
        !          1291:        fprintf (stderr, "%s", argv[0]);
        !          1292:       else
        !          1293:        fprintf (stderr, "[cannot find %s]", prog);
        !          1294: 
        !          1295:       for (p_argv = &argv[1]; (str = *p_argv) != (char *)0; p_argv++)
        !          1296:        fprintf (stderr, " %s", str);
        !          1297: 
        !          1298:       fprintf (stderr, "\n");
        !          1299:     }
        !          1300: 
        !          1301:   fflush (stdout);
        !          1302:   fflush (stderr);
        !          1303: 
        !          1304:   /* If we can't find a program we need, complain error.  Do this here
        !          1305:      since we might not end up needing something that we couldn't find.  */
        !          1306: 
        !          1307:   if (argv[0] == 0)
        !          1308:     fatal ("cannot find `%s'", prog);
        !          1309: 
        !          1310:   pid = vfork ();
        !          1311:   if (pid == -1)
        !          1312:     {
        !          1313: #ifdef vfork
        !          1314:       fatal_perror ("fork");
        !          1315: #else
        !          1316:       fatal_perror ("vfork");
        !          1317: #endif
        !          1318:     }
        !          1319: 
        !          1320:   if (pid == 0)                        /* child context */
        !          1321:     {
        !          1322:       execvp (argv[0], argv);
        !          1323:       fatal_perror ("executing %s", prog);
        !          1324:     }
        !          1325: 
        !          1326:   do_wait (prog);
        !          1327: }
        !          1328: 
        !          1329: 
        !          1330: /* Unlink a file unless we are debugging.  */
        !          1331: 
        !          1332: static void
        !          1333: maybe_unlink (file)
        !          1334:      char *file;
        !          1335: {
        !          1336:   if (!debug)
        !          1337:     unlink (file);
        !          1338:   else
        !          1339:     fprintf (stderr, "[Leaving %s]\n", file);
        !          1340: }
        !          1341: 
        !          1342: 
        !          1343: /* Add a name to a linked list.  */
        !          1344: 
        !          1345: static void
        !          1346: add_to_list (head_ptr, name)
        !          1347:      struct head *head_ptr;
        !          1348:      char *name;
        !          1349: {
        !          1350:   struct id *newid = (struct id *) xcalloc (sizeof (*newid) + strlen (name), 1);
        !          1351:   static long sequence_number = 0;
        !          1352:   newid->sequence = ++sequence_number;
        !          1353:   strcpy (newid->name, name);
        !          1354: 
        !          1355:   if (head_ptr->first)
        !          1356:     head_ptr->last->next = newid;
        !          1357:   else
        !          1358:     head_ptr->first = newid;
        !          1359: 
        !          1360:   head_ptr->last = newid;
        !          1361:   head_ptr->number++;
        !          1362: }
        !          1363: 
        !          1364: /* Write: `prefix', the names on list LIST, `suffix'.  */
        !          1365: 
        !          1366: static void
        !          1367: write_list (stream, prefix, list)
        !          1368:      FILE *stream;
        !          1369:      char *prefix;
        !          1370:      struct id *list;
        !          1371: {
        !          1372:   while (list)
        !          1373:     {
        !          1374:       fprintf (stream, "%sx%d,\n", prefix, list->sequence);
        !          1375:       list = list->next;
        !          1376:     }
        !          1377: }
        !          1378: 
        !          1379: static void
        !          1380: write_list_with_asm (stream, prefix, list)
        !          1381:      FILE *stream;
        !          1382:      char *prefix;
        !          1383:      struct id *list;
        !          1384: {
        !          1385:   while (list)
        !          1386:     {
        !          1387:       fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
        !          1388:               prefix, list->sequence, list->name);
        !          1389:       list = list->next;
        !          1390:     }
        !          1391: }
        !          1392: 
        !          1393: /* Write the constructor/destructor tables. */
        !          1394: 
        !          1395: static void
        !          1396: write_c_file (stream, name)
        !          1397:      FILE *stream;
        !          1398:      char *name;
        !          1399: {
        !          1400:   /* Write the tables as C code  */
        !          1401: 
        !          1402:   fprintf (stream, "typedef void entry_pt();\n\n");
        !          1403:     
        !          1404:   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
        !          1405:     
        !          1406:   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
        !          1407:   fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number);
        !          1408:   write_list (stream, "\t", constructors.first);
        !          1409:   fprintf (stream, "\t0\n};\n\n");
        !          1410: 
        !          1411:   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
        !          1412: 
        !          1413:   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
        !          1414:   fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number);
        !          1415:   write_list (stream, "\t", destructors.first);
        !          1416:   fprintf (stream, "\t0\n};\n\n");
        !          1417: 
        !          1418:   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
        !          1419:   fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN);
        !          1420: }
        !          1421: 
        !          1422: 
        !          1423: #ifdef OBJECT_FORMAT_NONE
        !          1424: 
        !          1425: /* Generic version to scan the name list of the loaded program for
        !          1426:    the symbols g++ uses for static constructors and destructors.
        !          1427: 
        !          1428:    The constructor table begins at __CTOR_LIST__ and contains a count
        !          1429:    of the number of pointers (or -1 if the constructors are built in a
        !          1430:    separate section by the linker), followed by the pointers to the
        !          1431:    constructor functions, terminated with a null pointer.  The
        !          1432:    destructor table has the same format, and begins at __DTOR_LIST__.  */
        !          1433: 
        !          1434: static void
        !          1435: scan_prog_file (prog_name, which_pass)
        !          1436:      char *prog_name;
        !          1437:      enum pass which_pass;
        !          1438: {
        !          1439:   void (*int_handler) ();
        !          1440:   void (*quit_handler) ();
        !          1441:   char *nm_argv[4];
        !          1442:   int pid;
        !          1443:   int argc = 0;
        !          1444:   int pipe_fd[2];
        !          1445:   char *p, buf[1024];
        !          1446:   FILE *inf;
        !          1447: 
        !          1448:   if (which_pass != PASS_FIRST)
        !          1449:     return;
        !          1450: 
        !          1451:   /* If we don't have an `nm', complain.  */
        !          1452:   if (nm_file_name == 0)
        !          1453:     fatal ("cannot find `nm'");
        !          1454: 
        !          1455:   nm_argv[argc++] = "nm";
        !          1456:   if (NM_FLAGS[0] != '\0')
        !          1457:     nm_argv[argc++] = NM_FLAGS;
        !          1458: 
        !          1459:   nm_argv[argc++] = prog_name;
        !          1460:   nm_argv[argc++] = (char *)0;
        !          1461: 
        !          1462:   if (pipe (pipe_fd) < 0)
        !          1463:     fatal_perror ("pipe");
        !          1464: 
        !          1465:   inf = fdopen (pipe_fd[0], "r");
        !          1466:   if (inf == (FILE *)0)
        !          1467:     fatal_perror ("fdopen");
        !          1468: 
        !          1469:   /* Trace if needed.  */
        !          1470:   if (vflag)
        !          1471:     {
        !          1472:       char **p_argv;
        !          1473:       char *str;
        !          1474: 
        !          1475:       fprintf (stderr, "%s", nm_file_name);
        !          1476:       for (p_argv = &nm_argv[1]; (str = *p_argv) != (char *)0; p_argv++)
        !          1477:        fprintf (stderr, " %s", str);
        !          1478: 
        !          1479:       fprintf (stderr, "\n");
        !          1480:     }
        !          1481: 
        !          1482:   fflush (stdout);
        !          1483:   fflush (stderr);
        !          1484: 
        !          1485:   /* Spawn child nm on pipe */
        !          1486:   pid = vfork ();
        !          1487:   if (pid == -1)
        !          1488:     {
        !          1489: #ifdef vfork
        !          1490:       fatal_perror ("fork");
        !          1491: #else
        !          1492:       fatal_perror ("vfork");
        !          1493: #endif
        !          1494:     }
        !          1495: 
        !          1496:   if (pid == 0)                        /* child context */
        !          1497:     {
        !          1498:       /* setup stdout */
        !          1499:       if (dup2 (pipe_fd[1], 1) < 0)
        !          1500:        fatal_perror ("dup2 (%d, 1)", pipe_fd[1]);
        !          1501: 
        !          1502:       if (close (pipe_fd[0]) < 0)
        !          1503:        fatal_perror ("close (%d)", pipe_fd[0]);
        !          1504: 
        !          1505:       if (close (pipe_fd[1]) < 0)
        !          1506:        fatal_perror ("close (%d)", pipe_fd[1]);
        !          1507: 
        !          1508:       execv (nm_file_name, nm_argv);
        !          1509:       fatal_perror ("executing %s", nm_file_name);
        !          1510:     }
        !          1511: 
        !          1512:   /* Parent context from here on.  */
        !          1513:   int_handler  = (void (*) ())signal (SIGINT,  SIG_IGN);
        !          1514: #ifdef SIGQUIT
        !          1515:   quit_handler = (void (*) ())signal (SIGQUIT, SIG_IGN);
        !          1516: #endif
        !          1517: 
        !          1518:   if (close (pipe_fd[1]) < 0)
        !          1519:     fatal_perror ("close (%d)", pipe_fd[1]);
        !          1520: 
        !          1521:   if (debug)
        !          1522:     fprintf (stderr, "\nnm output with constructors/destructors.\n");
        !          1523: 
        !          1524:   /* Read each line of nm output.  */
        !          1525:   while (fgets (buf, sizeof buf, inf) != (char *)0)
        !          1526:     {
        !          1527:       int ch, ch2;
        !          1528:       char *name, *end;
        !          1529: 
        !          1530:       /* If it contains a constructor or destructor name, add the name
        !          1531:         to the appropriate list. */
        !          1532: 
        !          1533:       for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
        !          1534:        ;
        !          1535: 
        !          1536:       if (ch == '\0' || ch == '\n')
        !          1537:        continue;
        !          1538:   
        !          1539:       name = p;
        !          1540:       /* Find the end of the symbol name.
        !          1541:         Don't include `|', because Encore nm can tack that on the end.  */
        !          1542:       for (end = p; (ch2 = *end) != '\0' && !isspace (ch2) && ch2 != '|';
        !          1543:           end++)
        !          1544:        continue;
        !          1545: 
        !          1546:       *end = '\0';
        !          1547:       switch (is_ctor_dtor (name))
        !          1548:        {
        !          1549:        case 1:
        !          1550:          add_to_list (&constructors, name);
        !          1551:          break;
        !          1552: 
        !          1553:        case 2:
        !          1554:          add_to_list (&destructors, name);
        !          1555:          break;
        !          1556: 
        !          1557:        default:                /* not a constructor or destructor */
        !          1558:          continue;
        !          1559:        }
        !          1560: 
        !          1561:       if (debug)
        !          1562:        fprintf (stderr, "\t%s\n", buf);
        !          1563:     }
        !          1564: 
        !          1565:   if (debug)
        !          1566:     fprintf (stderr, "\n");
        !          1567: 
        !          1568:   if (fclose (inf) != 0)
        !          1569:     fatal_perror ("fclose of pipe");
        !          1570: 
        !          1571:   do_wait (nm_file_name);
        !          1572: 
        !          1573:   signal (SIGINT,  int_handler);
        !          1574: #ifdef SIGQUIT
        !          1575:   signal (SIGQUIT, quit_handler);
        !          1576: #endif
        !          1577: }
        !          1578: 
        !          1579: #endif /* OBJECT_FORMAT_NONE */
        !          1580: 
        !          1581: 
        !          1582: /*
        !          1583:  * COFF specific stuff.
        !          1584:  */
        !          1585: 
        !          1586: #ifdef OBJECT_FORMAT_COFF
        !          1587: 
        !          1588: #if defined(EXTENDED_COFF)
        !          1589: #   define GCC_SYMBOLS(X)      (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
        !          1590: #   define GCC_SYMENT          SYMR
        !          1591: #   define GCC_OK_SYMBOL(X)    ((X).st == stProc && (X).sc == scText)
        !          1592: #   define GCC_SYMINC(X)       (1)
        !          1593: #   define GCC_SYMZERO(X)      (SYMHEADER(X).isymMax)
        !          1594: #   define GCC_CHECK_HDR(X)    (PSYMTAB(X) != 0)
        !          1595: #else
        !          1596: #   define GCC_SYMBOLS(X)      (HEADER(ldptr).f_nsyms)
        !          1597: #   define GCC_SYMENT          SYMENT
        !          1598: #   define GCC_OK_SYMBOL(X) \
        !          1599:      (((X).n_sclass == C_EXT) && \
        !          1600:         (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) || \
        !          1601:          ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT)))
        !          1602: #   define GCC_SYMINC(X)       ((X).n_numaux+1)
        !          1603: #   define GCC_SYMZERO(X)      0
        !          1604: #   define GCC_CHECK_HDR(X)    (1)
        !          1605: #endif
        !          1606: 
        !          1607: extern char *ldgetname ();
        !          1608: 
        !          1609: /* COFF version to scan the name list of the loaded program for
        !          1610:    the symbols g++ uses for static constructors and destructors.
        !          1611: 
        !          1612:    The constructor table begins at __CTOR_LIST__ and contains a count
        !          1613:    of the number of pointers (or -1 if the constructors are built in a
        !          1614:    separate section by the linker), followed by the pointers to the
        !          1615:    constructor functions, terminated with a null pointer.  The
        !          1616:    destructor table has the same format, and begins at __DTOR_LIST__.  */
        !          1617: 
        !          1618: static void
        !          1619: scan_prog_file (prog_name, which_pass)
        !          1620:      char *prog_name;
        !          1621:      enum pass which_pass;
        !          1622: {
        !          1623:   LDFILE *ldptr = NULL;
        !          1624:   int sym_index, sym_count;
        !          1625: 
        !          1626:   if (which_pass != PASS_FIRST)
        !          1627:     return;
        !          1628: 
        !          1629:   if ((ldptr = ldopen (prog_name, ldptr)) == NULL)
        !          1630:     fatal ("%s: can't open as COFF file", prog_name);
        !          1631:       
        !          1632:   if (!MY_ISCOFF (HEADER (ldptr).f_magic))
        !          1633:     fatal ("%s: not a COFF file", prog_name);
        !          1634: 
        !          1635:   if (GCC_CHECK_HDR (ldptr))
        !          1636:     {
        !          1637:       sym_count = GCC_SYMBOLS (ldptr);
        !          1638:       sym_index = GCC_SYMZERO (ldptr);
        !          1639:       while (sym_index < sym_count)
        !          1640:        {
        !          1641:          GCC_SYMENT symbol;
        !          1642: 
        !          1643:          if (ldtbread (ldptr, sym_index, &symbol) <= 0)
        !          1644:            break;
        !          1645:          sym_index += GCC_SYMINC (symbol);
        !          1646: 
        !          1647:          if (GCC_OK_SYMBOL (symbol))
        !          1648:            {
        !          1649:              char *name;
        !          1650: 
        !          1651:              if ((name = ldgetname (ldptr, &symbol)) == NULL)
        !          1652:                continue;               /* should never happen */
        !          1653: 
        !          1654: #ifdef _AIX
        !          1655:              /* All AIX function names begin with a dot. */
        !          1656:              if (*name++ != '.')
        !          1657:                continue;
        !          1658: #endif
        !          1659: 
        !          1660:              switch (is_ctor_dtor (name))
        !          1661:                {
        !          1662:                case 1:
        !          1663:                  add_to_list (&constructors, name);
        !          1664:                  break;
        !          1665: 
        !          1666:                case 2:
        !          1667:                  add_to_list (&destructors, name);
        !          1668:                  break;
        !          1669: 
        !          1670:                default:                /* not a constructor or destructor */
        !          1671:                  continue;
        !          1672:                }
        !          1673: 
        !          1674: #if !defined(EXTENDED_COFF)
        !          1675:              if (debug)
        !          1676:                fprintf (stderr, "\tsec=%d class=%d type=%s%o %s\n",
        !          1677:                         symbol.n_scnum, symbol.n_sclass,
        !          1678:                         (symbol.n_type ? "0" : ""), symbol.n_type,
        !          1679:                         name);
        !          1680: #else
        !          1681:              if (debug)
        !          1682:                fprintf (stderr, "\tiss = %5d, value = %5d, index = %5d, name = %s\n",
        !          1683:                         symbol.iss, symbol.value, symbol.index, name);
        !          1684: #endif
        !          1685:            }
        !          1686:        }
        !          1687:     }
        !          1688: 
        !          1689:   (void) ldclose(ldptr);
        !          1690: }
        !          1691: 
        !          1692: #endif /* OBJECT_FORMAT_COFF */
        !          1693: 
        !          1694: 
        !          1695: /*
        !          1696:  * OSF/rose specific stuff.
        !          1697:  */
        !          1698: 
        !          1699: #ifdef OBJECT_FORMAT_ROSE
        !          1700: 
        !          1701: /* Union of the various load commands */
        !          1702: 
        !          1703: typedef union load_union
        !          1704: {
        !          1705:   ldc_header_t                 hdr;    /* common header */
        !          1706:   load_cmd_map_command_t       map;    /* map indexing other load cmds */
        !          1707:   interpreter_command_t                iprtr;  /* interpreter pathname */
        !          1708:   strings_command_t            str;    /* load commands strings section */
        !          1709:   region_command_t             region; /* region load command */
        !          1710:   reloc_command_t              reloc;  /* relocation section */
        !          1711:   package_command_t            pkg;    /* package load command */
        !          1712:   symbols_command_t            sym;    /* symbol sections */
        !          1713:   entry_command_t              ent;    /* program start section */
        !          1714:   gen_info_command_t           info;   /* object information */
        !          1715:   func_table_command_t         func;   /* function constructors/destructors */
        !          1716: } load_union_t;
        !          1717: 
        !          1718: /* Structure to point to load command and data section in memory.  */
        !          1719: 
        !          1720: typedef struct load_all
        !          1721: {
        !          1722:   load_union_t *load;                  /* load command */
        !          1723:   char *section;                       /* pointer to section */
        !          1724: } load_all_t;
        !          1725: 
        !          1726: /* Structure to contain information about a file mapped into memory.  */
        !          1727: 
        !          1728: struct file_info
        !          1729: {
        !          1730:   char *start;                         /* start of map */
        !          1731:   char *name;                          /* filename */
        !          1732:   long size;                           /* size of the file */
        !          1733:   long  rounded_size;                  /* size rounded to page boundary */
        !          1734:   int  fd;                             /* file descriptor */
        !          1735:   int  rw;                             /* != 0 if opened read/write */
        !          1736:   int  use_mmap;                       /* != 0 if mmap'ed */
        !          1737: };
        !          1738: 
        !          1739: extern int decode_mach_o_hdr ();
        !          1740: extern int encode_mach_o_hdr ();
        !          1741: 
        !          1742: static void add_func_table     PROTO((mo_header_t *, load_all_t *,
        !          1743:                                       symbol_info_t *, int));
        !          1744: static void print_header       PROTO((mo_header_t *));
        !          1745: static void print_load_command PROTO((load_union_t*, size_t, int));
        !          1746: static void bad_header         PROTO((int));
        !          1747: static struct file_info        *read_file  PROTO((char *, int, int));
        !          1748: static void end_file           PROTO((struct file_info *));
        !          1749: 
        !          1750: /* OSF/rose specific version to scan the name list of the loaded
        !          1751:    program for the symbols g++ uses for static constructors and
        !          1752:    destructors.
        !          1753: 
        !          1754:    The constructor table begins at __CTOR_LIST__ and contains a count
        !          1755:    of the number of pointers (or -1 if the constructors are built in a
        !          1756:    separate section by the linker), followed by the pointers to the
        !          1757:    constructor functions, terminated with a null pointer.  The
        !          1758:    destructor table has the same format, and begins at __DTOR_LIST__.  */
        !          1759: 
        !          1760: static void
        !          1761: scan_prog_file (prog_name, which_pass)
        !          1762:      char *prog_name;
        !          1763:      enum pass which_pass;
        !          1764: {
        !          1765:   char *obj;
        !          1766:   mo_header_t hdr;
        !          1767:   load_all_t *load_array;
        !          1768:   load_all_t *load_end;
        !          1769:   load_all_t *load_cmd;
        !          1770:   int symbol_load_cmds;
        !          1771:   off_t offset;
        !          1772:   int i;
        !          1773:   int num_syms;
        !          1774:   int status;
        !          1775:   char *str_sect;
        !          1776:   struct file_info *obj_file;
        !          1777:   int prog_fd;
        !          1778:   mo_lcid_t cmd_strings          = -1;
        !          1779:   symbol_info_t *main_sym = 0;
        !          1780:   int rw                 = (which_pass != PASS_FIRST);
        !          1781: 
        !          1782:   prog_fd = open (prog_name, (rw) ? O_RDWR : O_RDONLY);
        !          1783:   if (prog_fd < 0)
        !          1784:     fatal_perror ("can't read %s", prog_name);
        !          1785: 
        !          1786:   obj_file = read_file (prog_name, prog_fd, rw);
        !          1787:   obj = obj_file->start;
        !          1788: 
        !          1789:   status = decode_mach_o_hdr (obj, MO_SIZEOF_RAW_HDR, MOH_HEADER_VERSION, &hdr);
        !          1790:   if (status != MO_HDR_CONV_SUCCESS)
        !          1791:     bad_header (status);
        !          1792: 
        !          1793: 
        !          1794:   /* Do some basic sanity checks.  Note we explicitly use the big endian magic number,
        !          1795:      since the hardware will automatically swap bytes for us on loading little endian
        !          1796:      integers.  */
        !          1797: 
        !          1798: #ifndef CROSS_COMPILE
        !          1799:   if (hdr.moh_magic != MOH_MAGIC_MSB
        !          1800:       || hdr.moh_header_version != MOH_HEADER_VERSION
        !          1801:       || hdr.moh_byte_order != OUR_BYTE_ORDER
        !          1802:       || hdr.moh_data_rep_id != OUR_DATA_REP_ID
        !          1803:       || hdr.moh_cpu_type != OUR_CPU_TYPE
        !          1804:       || hdr.moh_cpu_subtype != OUR_CPU_SUBTYPE
        !          1805:       || hdr.moh_vendor_type != OUR_VENDOR_TYPE)
        !          1806:     {
        !          1807:       fatal ("incompatibilities between object file & expected values");
        !          1808:     }
        !          1809: #endif
        !          1810: 
        !          1811:   if (debug)
        !          1812:     print_header (&hdr);
        !          1813: 
        !          1814:   offset = hdr.moh_first_cmd_off;
        !          1815:   load_end = load_array
        !          1816:     = (load_all_t *) xcalloc (sizeof (load_all_t), hdr.moh_n_load_cmds + 2);
        !          1817: 
        !          1818:   /* Build array of load commands, calculating the offsets */
        !          1819:   for (i = 0; i < hdr.moh_n_load_cmds; i++)
        !          1820:     {
        !          1821:       load_union_t *load_hdr;          /* load command header */
        !          1822: 
        !          1823:       load_cmd = load_end++;
        !          1824:       load_hdr = (load_union_t *) (obj + offset);
        !          1825: 
        !          1826:       /* If modifying the program file, copy the header.  */
        !          1827:       if (rw)
        !          1828:        {
        !          1829:          load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
        !          1830:          bcopy ((generic *)load_hdr, (generic *)ptr, load_hdr->hdr.ldci_cmd_size);
        !          1831:          load_hdr = ptr;
        !          1832: 
        !          1833:          /* null out old command map, because we will rewrite at the end.  */
        !          1834:          if (ptr->hdr.ldci_cmd_type == LDC_CMD_MAP)
        !          1835:            {
        !          1836:              cmd_strings = ptr->map.lcm_ld_cmd_strings;
        !          1837:              ptr->hdr.ldci_cmd_type = LDC_UNDEFINED;
        !          1838:            }
        !          1839:        }
        !          1840: 
        !          1841:       load_cmd->load = load_hdr;
        !          1842:       if (load_hdr->hdr.ldci_section_off > 0)
        !          1843:        load_cmd->section = obj + load_hdr->hdr.ldci_section_off;
        !          1844: 
        !          1845:       if (debug)
        !          1846:        print_load_command (load_hdr, offset, i);
        !          1847: 
        !          1848:       offset += load_hdr->hdr.ldci_cmd_size;
        !          1849:     }
        !          1850: 
        !          1851:   /* If the last command is the load command map and is not undefined,
        !          1852:      decrement the count of load commands.  */
        !          1853:   if (rw && load_end[-1].load->hdr.ldci_cmd_type == LDC_UNDEFINED)
        !          1854:     {
        !          1855:       load_end--;
        !          1856:       hdr.moh_n_load_cmds--;
        !          1857:     }
        !          1858: 
        !          1859:   /* Go through and process each symbol table section.  */
        !          1860:   symbol_load_cmds = 0;
        !          1861:   for (load_cmd = load_array; load_cmd < load_end; load_cmd++)
        !          1862:     {
        !          1863:       load_union_t *load_hdr = load_cmd->load;
        !          1864: 
        !          1865:       if (load_hdr->hdr.ldci_cmd_type == LDC_SYMBOLS)
        !          1866:        {
        !          1867:          symbol_load_cmds++;
        !          1868: 
        !          1869:          if (debug)
        !          1870:            {
        !          1871:              char *kind = "unknown";
        !          1872: 
        !          1873:              switch (load_hdr->sym.symc_kind)
        !          1874:                {
        !          1875:                case SYMC_IMPORTS:         kind = "imports"; break;
        !          1876:                case SYMC_DEFINED_SYMBOLS: kind = "defined"; break;
        !          1877:                case SYMC_STABS:           kind = "stabs";   break;
        !          1878:                }
        !          1879: 
        !          1880:              fprintf (stderr, "\nProcessing symbol table #%d, offset = 0x%.8lx, kind = %s\n",
        !          1881:                       symbol_load_cmds, load_hdr->hdr.ldci_section_off, kind);
        !          1882:            }
        !          1883: 
        !          1884:          if (load_hdr->sym.symc_kind != SYMC_DEFINED_SYMBOLS)
        !          1885:            continue;
        !          1886: 
        !          1887:          str_sect = load_array[load_hdr->sym.symc_strings_section].section;
        !          1888:          if (str_sect == (char *)0)
        !          1889:            fatal ("string section missing");
        !          1890: 
        !          1891:          if (load_cmd->section == (char *)0)
        !          1892:            fatal ("section pointer missing");
        !          1893: 
        !          1894:          num_syms = load_hdr->sym.symc_nentries;
        !          1895:          for (i = 0; i < num_syms; i++)
        !          1896:            {
        !          1897:              symbol_info_t *sym = ((symbol_info_t *) load_cmd->section) + i;
        !          1898:              char *name = sym->si_name.symbol_name + str_sect;
        !          1899: 
        !          1900:              if (name[0] != '_')
        !          1901:                continue;
        !          1902: 
        !          1903:              if (rw)
        !          1904:                {
        !          1905:                  char *n = name + strlen (name) - strlen (NAME__MAIN);
        !          1906: 
        !          1907:                  if ((n - name) < 0 || strcmp (n, NAME__MAIN))
        !          1908:                    continue;
        !          1909:                  while (n != name)
        !          1910:                    if (*--n != '_')
        !          1911:                      continue;
        !          1912: 
        !          1913:                  main_sym = sym;
        !          1914:                }
        !          1915:              else
        !          1916:                {
        !          1917:                  switch (is_ctor_dtor (name))
        !          1918:                    {
        !          1919:                    case 1:
        !          1920:                      add_to_list (&constructors, name);
        !          1921:                      break;
        !          1922: 
        !          1923:                    case 2:
        !          1924:                      add_to_list (&destructors, name);
        !          1925:                      break;
        !          1926: 
        !          1927:                    default:    /* not a constructor or destructor */
        !          1928:                      continue;
        !          1929:                    }
        !          1930:                }
        !          1931: 
        !          1932:              if (debug)
        !          1933:                fprintf (stderr, "\ttype = 0x%.4x, sc = 0x%.2x, flags = 0x%.8x, name = %.30s\n",
        !          1934:                         sym->si_type, sym->si_sc_type, sym->si_flags, name);
        !          1935:            }
        !          1936:        }
        !          1937:     }
        !          1938: 
        !          1939:   if (symbol_load_cmds == 0)
        !          1940:     fatal ("no symbol table found");
        !          1941: 
        !          1942:   /* Update the program file now, rewrite header and load commands.  At present,
        !          1943:      we assume that there is enough space after the last load command to insert
        !          1944:      one more.  Since the first section written out is page aligned, and the
        !          1945:      number of load commands is small, this is ok for the present.  */
        !          1946: 
        !          1947:   if (rw)
        !          1948:     {
        !          1949:       load_union_t *load_map;
        !          1950:       size_t size;
        !          1951: 
        !          1952:       if (cmd_strings == -1)
        !          1953:        fatal ("no cmd_strings found");
        !          1954: 
        !          1955:       /* Add __main to initializer list.
        !          1956:         If we are building a program instead of a shared library, don't
        !          1957:         do anything, since in the current version, you cannot do mallocs
        !          1958:         and such in the constructors.  */
        !          1959: 
        !          1960:       if (main_sym != (symbol_info_t *)0
        !          1961:          && ((hdr.moh_flags & MOH_EXECABLE_F) == 0))
        !          1962:        add_func_table (&hdr, load_array, main_sym, FNTC_INITIALIZATION);
        !          1963: 
        !          1964:       if (debug)
        !          1965:        fprintf (stderr, "\nUpdating header and load commands.\n\n");
        !          1966: 
        !          1967:       hdr.moh_n_load_cmds++;
        !          1968:       size = sizeof (load_cmd_map_command_t) + (sizeof (mo_offset_t) * (hdr.moh_n_load_cmds - 1));
        !          1969: 
        !          1970:       /* Create new load command map.  */
        !          1971:       if (debug)
        !          1972:        fprintf (stderr, "load command map, %d cmds, new size %ld.\n",
        !          1973:                 (int)hdr.moh_n_load_cmds, (long)size);
        !          1974: 
        !          1975:       load_map = (load_union_t *) xcalloc (1, size);
        !          1976:       load_map->map.ldc_header.ldci_cmd_type = LDC_CMD_MAP;
        !          1977:       load_map->map.ldc_header.ldci_cmd_size = size;
        !          1978:       load_map->map.lcm_ld_cmd_strings = cmd_strings;
        !          1979:       load_map->map.lcm_nentries = hdr.moh_n_load_cmds;
        !          1980:       load_array[hdr.moh_n_load_cmds-1].load = load_map;
        !          1981: 
        !          1982:       offset = hdr.moh_first_cmd_off;
        !          1983:       for (i = 0; i < hdr.moh_n_load_cmds; i++)
        !          1984:        {
        !          1985:          load_map->map.lcm_map[i] = offset;
        !          1986:          if (load_array[i].load->hdr.ldci_cmd_type == LDC_CMD_MAP)
        !          1987:            hdr.moh_load_map_cmd_off = offset;
        !          1988: 
        !          1989:          offset += load_array[i].load->hdr.ldci_cmd_size;
        !          1990:        }
        !          1991: 
        !          1992:       hdr.moh_sizeofcmds = offset - MO_SIZEOF_RAW_HDR;
        !          1993: 
        !          1994:       if (debug)
        !          1995:        print_header (&hdr);
        !          1996: 
        !          1997:       /* Write header */
        !          1998:       status = encode_mach_o_hdr (&hdr, obj, MO_SIZEOF_RAW_HDR);
        !          1999:       if (status != MO_HDR_CONV_SUCCESS)
        !          2000:        bad_header (status);
        !          2001: 
        !          2002:       if (debug)
        !          2003:        fprintf (stderr, "writing load commands.\n\n");
        !          2004: 
        !          2005:       /* Write load commands */
        !          2006:       offset = hdr.moh_first_cmd_off;
        !          2007:       for (i = 0; i < hdr.moh_n_load_cmds; i++)
        !          2008:        {
        !          2009:          load_union_t *load_hdr = load_array[i].load;
        !          2010:          size_t size = load_hdr->hdr.ldci_cmd_size;
        !          2011: 
        !          2012:          if (debug)
        !          2013:            print_load_command (load_hdr, offset, i);
        !          2014: 
        !          2015:          bcopy ((generic *)load_hdr, (generic *)(obj + offset), size);
        !          2016:          offset += size;
        !          2017:        }
        !          2018:     }
        !          2019: 
        !          2020:   end_file (obj_file);
        !          2021: 
        !          2022:   if (close (prog_fd))
        !          2023:     fatal_perror ("closing %s", prog_name);
        !          2024: 
        !          2025:   if (debug)
        !          2026:     fprintf (stderr, "\n");
        !          2027: }
        !          2028: 
        !          2029: 
        !          2030: /* Add a function table to the load commands to call a function
        !          2031:    on initiation or termination of the process.  */
        !          2032: 
        !          2033: static void
        !          2034: add_func_table (hdr_p, load_array, sym, type)
        !          2035:      mo_header_t *hdr_p;               /* pointer to global header */
        !          2036:      load_all_t *load_array;           /* array of ptrs to load cmds */
        !          2037:      symbol_info_t *sym;               /* pointer to symbol entry */
        !          2038:      int type;                         /* fntc_type value */
        !          2039: {
        !          2040:   /* Add a new load command.  */
        !          2041:   int num_cmds = ++hdr_p->moh_n_load_cmds;
        !          2042:   int load_index = num_cmds - 1;
        !          2043:   size_t size = sizeof (func_table_command_t) + sizeof (mo_addr_t);
        !          2044:   load_union_t *ptr = xcalloc (1, size);
        !          2045:   load_all_t *load_cmd;
        !          2046:   int i;
        !          2047: 
        !          2048:   /* Set the unresolved address bit in the header to force the loader to be
        !          2049:      used, since kernel exec does not call the initialization functions.  */
        !          2050:   hdr_p->moh_flags |= MOH_UNRESOLVED_F;
        !          2051: 
        !          2052:   load_cmd = &load_array[load_index];
        !          2053:   load_cmd->load = ptr;
        !          2054:   load_cmd->section = (char *)0;
        !          2055: 
        !          2056:   /* Fill in func table load command.  */
        !          2057:   ptr->func.ldc_header.ldci_cmd_type = LDC_FUNC_TABLE;
        !          2058:   ptr->func.ldc_header.ldci_cmd_size = size;
        !          2059:   ptr->func.ldc_header.ldci_section_off = 0;
        !          2060:   ptr->func.ldc_header.ldci_section_len = 0;
        !          2061:   ptr->func.fntc_type = type;
        !          2062:   ptr->func.fntc_nentries = 1;
        !          2063: 
        !          2064:   /* copy address, turn it from abs. address to (region,offset) if necessary.  */
        !          2065:   /* Is the symbol already expressed as (region, offset)?  */
        !          2066:   if ((sym->si_flags & SI_ABSOLUTE_VALUE_F) == 0)
        !          2067:     {
        !          2068:       ptr->func.fntc_entry_loc[i].adr_lcid = sym->si_value.def_val.adr_lcid;
        !          2069:       ptr->func.fntc_entry_loc[i].adr_sctoff = sym->si_value.def_val.adr_sctoff;
        !          2070:     }
        !          2071: 
        !          2072:   /* If not, figure out which region it's in.  */
        !          2073:   else
        !          2074:     {
        !          2075:       mo_vm_addr_t addr = sym->si_value.abs_val;
        !          2076:       int found = 0;
        !          2077: 
        !          2078:       for (i = 0; i < load_index; i++)
        !          2079:        {
        !          2080:          if (load_array[i].load->hdr.ldci_cmd_type == LDC_REGION)
        !          2081:            {
        !          2082:              region_command_t *region_ptr = &load_array[i].load->region;
        !          2083: 
        !          2084:              if ((region_ptr->regc_flags & REG_ABS_ADDR_F) != 0
        !          2085:                  && addr >= region_ptr->regc_addr.vm_addr
        !          2086:                  && addr <= region_ptr->regc_addr.vm_addr + region_ptr->regc_vm_size)
        !          2087:                {
        !          2088:                  ptr->func.fntc_entry_loc[0].adr_lcid = i;
        !          2089:                  ptr->func.fntc_entry_loc[0].adr_sctoff = addr - region_ptr->regc_addr.vm_addr;
        !          2090:                  found++;
        !          2091:                  break;
        !          2092:                }
        !          2093:            }
        !          2094:        }
        !          2095: 
        !          2096:       if (!found)
        !          2097:        fatal ("could not convert 0x%l.8x into a region", addr);
        !          2098:     }
        !          2099: 
        !          2100:   if (debug)
        !          2101:     fprintf (stderr,
        !          2102:             "%s function, region %d, offset = %ld (0x%.8lx)\n",
        !          2103:             (type == FNTC_INITIALIZATION) ? "init" : "term",
        !          2104:             (int)ptr->func.fntc_entry_loc[i].adr_lcid,
        !          2105:             (long)ptr->func.fntc_entry_loc[i].adr_sctoff,
        !          2106:             (long)ptr->func.fntc_entry_loc[i].adr_sctoff);
        !          2107: 
        !          2108: }
        !          2109: 
        !          2110: 
        !          2111: /* Print the global header for an OSF/rose object.  */
        !          2112: 
        !          2113: static void
        !          2114: print_header (hdr_ptr)
        !          2115:      mo_header_t *hdr_ptr;
        !          2116: {
        !          2117:   fprintf (stderr, "\nglobal header:\n");
        !          2118:   fprintf (stderr, "\tmoh_magic            = 0x%.8lx\n", hdr_ptr->moh_magic);
        !          2119:   fprintf (stderr, "\tmoh_major_version    = %d\n", (int)hdr_ptr->moh_major_version);
        !          2120:   fprintf (stderr, "\tmoh_minor_version    = %d\n", (int)hdr_ptr->moh_minor_version);
        !          2121:   fprintf (stderr, "\tmoh_header_version   = %d\n", (int)hdr_ptr->moh_header_version);
        !          2122:   fprintf (stderr, "\tmoh_max_page_size    = %d\n", (int)hdr_ptr->moh_max_page_size);
        !          2123:   fprintf (stderr, "\tmoh_byte_order       = %d\n", (int)hdr_ptr->moh_byte_order);
        !          2124:   fprintf (stderr, "\tmoh_data_rep_id      = %d\n", (int)hdr_ptr->moh_data_rep_id);
        !          2125:   fprintf (stderr, "\tmoh_cpu_type         = %d\n", (int)hdr_ptr->moh_cpu_type);
        !          2126:   fprintf (stderr, "\tmoh_cpu_subtype      = %d\n", (int)hdr_ptr->moh_cpu_subtype);
        !          2127:   fprintf (stderr, "\tmoh_vendor_type      = %d\n", (int)hdr_ptr->moh_vendor_type);
        !          2128:   fprintf (stderr, "\tmoh_load_map_cmd_off = %d\n", (int)hdr_ptr->moh_load_map_cmd_off);
        !          2129:   fprintf (stderr, "\tmoh_first_cmd_off    = %d\n", (int)hdr_ptr->moh_first_cmd_off);
        !          2130:   fprintf (stderr, "\tmoh_sizeofcmds       = %d\n", (int)hdr_ptr->moh_sizeofcmds);
        !          2131:   fprintf (stderr, "\tmon_n_load_cmds      = %d\n", (int)hdr_ptr->moh_n_load_cmds);
        !          2132:   fprintf (stderr, "\tmoh_flags            = 0x%.8lx", (long)hdr_ptr->moh_flags);
        !          2133: 
        !          2134:   if (hdr_ptr->moh_flags & MOH_RELOCATABLE_F)
        !          2135:     fprintf (stderr, ", relocatable");
        !          2136: 
        !          2137:   if (hdr_ptr->moh_flags & MOH_LINKABLE_F)
        !          2138:     fprintf (stderr, ", linkable");
        !          2139: 
        !          2140:   if (hdr_ptr->moh_flags & MOH_EXECABLE_F)
        !          2141:     fprintf (stderr, ", execable");
        !          2142: 
        !          2143:   if (hdr_ptr->moh_flags & MOH_EXECUTABLE_F)
        !          2144:     fprintf (stderr, ", executable");
        !          2145: 
        !          2146:   if (hdr_ptr->moh_flags & MOH_UNRESOLVED_F)
        !          2147:     fprintf (stderr, ", unresolved");
        !          2148: 
        !          2149:   fprintf (stderr, "\n\n");
        !          2150:   return;
        !          2151: }
        !          2152: 
        !          2153: 
        !          2154: /* Print a short summary of a load command.  */
        !          2155: 
        !          2156: static void
        !          2157: print_load_command (load_hdr, offset, number)
        !          2158:      load_union_t *load_hdr;
        !          2159:      size_t offset;
        !          2160:      int number;
        !          2161: {
        !          2162:   mo_long_t type = load_hdr->hdr.ldci_cmd_type;
        !          2163:   char *type_str = (char *)0;
        !          2164: 
        !          2165:   switch (type)
        !          2166:     {
        !          2167:     case LDC_UNDEFINED:   type_str = "UNDEFINED";      break;
        !          2168:     case LDC_CMD_MAP:    type_str = "CMD_MAP";         break;
        !          2169:     case LDC_INTERPRETER: type_str = "INTERPRETER";    break;
        !          2170:     case LDC_STRINGS:    type_str = "STRINGS";         break;
        !          2171:     case LDC_REGION:     type_str = "REGION";          break;
        !          2172:     case LDC_RELOC:      type_str = "RELOC";           break;
        !          2173:     case LDC_PACKAGE:    type_str = "PACKAGE";         break;
        !          2174:     case LDC_SYMBOLS:    type_str = "SYMBOLS";         break;
        !          2175:     case LDC_ENTRY:      type_str = "ENTRY";           break;
        !          2176:     case LDC_FUNC_TABLE:  type_str = "FUNC_TABLE";     break;
        !          2177:     case LDC_GEN_INFO:   type_str = "GEN_INFO";        break;
        !          2178:     }
        !          2179: 
        !          2180:   fprintf (stderr,
        !          2181:           "cmd %2d, sz: 0x%.2lx, coff: 0x%.3lx, doff: 0x%.6lx, dlen: 0x%.6lx",
        !          2182:           number,
        !          2183:           (long) load_hdr->hdr.ldci_cmd_size,
        !          2184:           (long) offset,
        !          2185:           (long) load_hdr->hdr.ldci_section_off,
        !          2186:           (long) load_hdr->hdr.ldci_section_len);
        !          2187: 
        !          2188:   if (type_str == (char *)0)
        !          2189:     fprintf (stderr, ", ty: unknown (%ld)\n", (long) type);
        !          2190: 
        !          2191:   else if (type != LDC_REGION)
        !          2192:     fprintf (stderr, ", ty: %s\n", type_str);
        !          2193: 
        !          2194:   else
        !          2195:     {
        !          2196:       char *region = "";
        !          2197:       switch (load_hdr->region.regc_usage_type)
        !          2198:        {
        !          2199:        case REG_TEXT_T:        region = ", .text";     break;
        !          2200:        case REG_DATA_T:        region = ", .data";     break;
        !          2201:        case REG_BSS_T:         region = ", .bss";      break;
        !          2202:        case REG_GLUE_T:        region = ", .glue";     break;
        !          2203: #if defined (REG_RDATA_T) && defined (REG_SDATA_T) && defined (REG_SBSS_T) /*mips*/
        !          2204:        case REG_RDATA_T:       region = ", .rdata";    break;
        !          2205:        case REG_SDATA_T:       region = ", .sdata";    break;
        !          2206:        case REG_SBSS_T:        region = ", .sbss";     break;
        !          2207: #endif
        !          2208:        }
        !          2209: 
        !          2210:       fprintf (stderr, ", ty: %s, vaddr: 0x%.8lx, vlen: 0x%.6lx%s\n",
        !          2211:               type_str,
        !          2212:               (long) load_hdr->region.regc_vm_addr,
        !          2213:               (long) load_hdr->region.regc_vm_size,
        !          2214:               region);
        !          2215:     }
        !          2216: 
        !          2217:   return;
        !          2218: }
        !          2219: 
        !          2220: 
        !          2221: /* Fatal error when {en,de}code_mach_o_header fails.  */
        !          2222: 
        !          2223: static void
        !          2224: bad_header (status)
        !          2225:      int status;
        !          2226: {
        !          2227:   char *msg = (char *)0;
        !          2228: 
        !          2229:   switch (status)
        !          2230:     {
        !          2231:     case MO_ERROR_BAD_MAGIC:           msg = "bad magic number";               break;
        !          2232:     case MO_ERROR_BAD_HDR_VERS:                msg = "bad header version";             break;
        !          2233:     case MO_ERROR_BAD_RAW_HDR_VERS:    msg = "bad raw header version";         break;
        !          2234:     case MO_ERROR_BUF2SML:             msg = "raw header buffer too small";    break;
        !          2235:     case MO_ERROR_OLD_RAW_HDR_FILE:    msg = "old raw header file";            break;
        !          2236:     case MO_ERROR_UNSUPPORTED_VERS:    msg = "unsupported version";            break;
        !          2237:     }
        !          2238: 
        !          2239:   if (msg == (char *)0)
        !          2240:     fatal ("unknown {de,en}code_mach_o_hdr return value %d", status);
        !          2241:   else
        !          2242:     fatal ("%s", msg);
        !          2243: }
        !          2244: 
        !          2245: 
        !          2246: /* Read a file into a memory buffer.  */
        !          2247: 
        !          2248: static struct file_info *
        !          2249: read_file (name, fd, rw)
        !          2250:      char *name;               /* filename */
        !          2251:      int fd;                   /* file descriptor */
        !          2252:      int rw;                   /* read/write */
        !          2253: {
        !          2254:   struct stat stat_pkt;
        !          2255:   struct file_info *p = (struct file_info *) xcalloc (sizeof (struct file_info), 1);
        !          2256: #ifdef USE_MMAP
        !          2257:   static int page_size;
        !          2258: #endif
        !          2259: 
        !          2260:   if (fstat (fd, &stat_pkt) < 0)
        !          2261:     fatal_perror ("fstat %s", name);
        !          2262: 
        !          2263:   p->name        = name;
        !          2264:   p->size        = stat_pkt.st_size;
        !          2265:   p->rounded_size = stat_pkt.st_size;
        !          2266:   p->fd                  = fd;
        !          2267:   p->rw                  = rw;
        !          2268: 
        !          2269: #ifdef USE_MMAP
        !          2270:   if (debug)
        !          2271:     fprintf (stderr, "mmap %s, %s\n", name, (rw) ? "read/write" : "read-only");
        !          2272: 
        !          2273:   if (page_size == 0)
        !          2274:     page_size = sysconf (_SC_PAGE_SIZE);
        !          2275: 
        !          2276:   p->rounded_size = ((p->size + page_size - 1) / page_size) * page_size;
        !          2277:   p->start = mmap ((caddr_t)0,
        !          2278:                   (rw) ? p->rounded_size : p->size,
        !          2279:                   (rw) ? (PROT_READ | PROT_WRITE) : PROT_READ,
        !          2280:                   MAP_FILE | MAP_VARIABLE | MAP_SHARED,
        !          2281:                   fd,
        !          2282:                   0L);
        !          2283: 
        !          2284:   if (p->start != (char *)0 && p->start != (char *)-1)
        !          2285:     p->use_mmap = 1;
        !          2286: 
        !          2287:   else
        !          2288: #endif /* USE_MMAP */
        !          2289:     {
        !          2290:       long len;
        !          2291: 
        !          2292:       if (debug)
        !          2293:        fprintf (stderr, "read %s\n", name);
        !          2294: 
        !          2295:       p->use_mmap = 0;
        !          2296:       p->start = xmalloc (p->size);
        !          2297:       if (lseek (fd, 0L, SEEK_SET) < 0)
        !          2298:        fatal_perror ("lseek to 0 on %s", name);
        !          2299: 
        !          2300:       len = read (fd, p->start, p->size);
        !          2301:       if (len < 0)
        !          2302:        fatal_perror ("read %s", name);
        !          2303: 
        !          2304:       if (len != p->size)
        !          2305:        fatal ("read %ld bytes, expected %ld, from %s", len, p->size, name);
        !          2306:     }
        !          2307: 
        !          2308:   return p;
        !          2309: }
        !          2310: 
        !          2311: /* Do anything necessary to write a file back from memory.  */
        !          2312: 
        !          2313: static void
        !          2314: end_file (ptr)
        !          2315:      struct file_info *ptr;    /* file information block */
        !          2316: {
        !          2317: #ifdef USE_MMAP
        !          2318:   if (ptr->use_mmap)
        !          2319:     {
        !          2320:       if (ptr->rw)
        !          2321:        {
        !          2322:          if (debug)
        !          2323:            fprintf (stderr, "msync %s\n", ptr->name);
        !          2324: 
        !          2325:          if (msync (ptr->start, ptr->rounded_size, MS_ASYNC))
        !          2326:            fatal_perror ("msync %s", ptr->name);
        !          2327:        }
        !          2328: 
        !          2329:       if (debug)
        !          2330:        fprintf (stderr, "munmap %s\n", ptr->name);
        !          2331: 
        !          2332:       if (munmap (ptr->start, ptr->size))
        !          2333:        fatal_perror ("munmap %s", ptr->name);
        !          2334:     }
        !          2335:   else
        !          2336: #endif /* USE_MMAP */
        !          2337:     {
        !          2338:       if (ptr->rw)
        !          2339:        {
        !          2340:          long len;
        !          2341: 
        !          2342:          if (debug)
        !          2343:            fprintf (stderr, "write %s\n", ptr->name);
        !          2344: 
        !          2345:          if (lseek (ptr->fd, 0L, SEEK_SET) < 0)
        !          2346:            fatal_perror ("lseek to 0 on %s", ptr->name);
        !          2347: 
        !          2348:          len = write (ptr->fd, ptr->start, ptr->size);
        !          2349:          if (len < 0)
        !          2350:            fatal_perror ("read %s", ptr->name);
        !          2351: 
        !          2352:          if (len != ptr->size)
        !          2353:            fatal ("wrote %ld bytes, expected %ld, to %s", len, ptr->size, ptr->name);
        !          2354:        }
        !          2355: 
        !          2356:       free ((generic *)ptr->start);
        !          2357:     }
        !          2358: 
        !          2359:   free ((generic *)ptr);
        !          2360: }
        !          2361: 
        !          2362: #endif /* OBJECT_FORMAT_ROSE */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.