LCOV - code coverage report
Current view: top level - gcc - collect2.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 415 799 51.9 %
Date: 2020-03-28 11:57:23 Functions: 11 26 42.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.