/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/collect2.cc

Bug Summary

File:	build/gcc/collect2.cc
Warning:	line 2049, column 3 Null pointer passed to 2nd parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name collect2.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D TARGET_MACHINE="x86_64-pc-linux-gnu" -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-HsAV95.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/collect2.cc
1/* Collect static initialization info into data structures that can be
 traversed by C++ initialization and finalization routines.
 Copyright (C) 1992-2023 Free Software Foundation, Inc.
 Contributed by Chris Smith (csmith@convex.com).
 Heavily modified by Michael Meissner (meissner@cygnus.com),
 Per Bothner (bothner@cygnus.com), and John Gilmore (gnu@cygnus.com).

8This file is part of GCC.

10GCC is free software; you can redistribute it and/or modify it under
11the terms of the GNU General Public License as published by the Free
12Software Foundation; either version 3, or (at your option) any later
13version.

15GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16WARRANTY; without even the implied warranty of MERCHANTABILITY or
17FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18for more details.

20You should have received a copy of the GNU General Public License
21along with GCC; see the file COPYING3.  If not see
22<http://www.gnu.org/licenses/>.  */


25/* Build tables of static constructors and destructors and run ld.  */

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"

36/* TARGET_64BIT may be defined to use driver specific functionality. */
37#undef TARGET_64BIT((1UL << 1) | (1UL << 4))
38#define TARGET_64BIT((1UL << 1) | (1UL << 4)) TARGET_64BIT_DEFAULT((1UL << 1) | (1UL << 4))

40#ifndef LIBRARY_PATH_ENV"LIBRARY_PATH"
41#define LIBRARY_PATH_ENV"LIBRARY_PATH" "LIBRARY_PATH"
42#endif

44#define COLLECT

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
 directly.  But this code uses system-specific header files and library
 functions, so turn it off in a cross-compiler.  Likewise, the names of
 the utilities are not correct for a cross-compiler; we have to hope that
 cross-versions are in the proper directories.  */

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

71/* If we cannot use a special method, use the ordinary one:
 run nm to find what symbols are present.
 In a cross-compiler, this means you need a cross nm,
 but that is not quite as unpleasant as special headers.  */

76#if !defined (OBJECT_FORMAT_COFF)
77#define OBJECT_FORMAT_NONE
78#endif

80#ifdef OBJECT_FORMAT_COFF

82#ifndef CROSS_DIRECTORY_STRUCTURE
83#include <a.out.h>
84#include <ar.h>

86#ifdef UMAX
87#include <sgs.h>
88#endif

90/* Many versions of ldfcn.h define these.  */
91#ifdef FREAD
92#undef FREAD
93#undef FWRITE
94#endif

96#include <ldfcn.h>
97#endif

99/* Some systems have an ISCOFF macro, but others do not.  In some cases
 the macro may be wrong.  MY_ISCOFF is defined in tm.h files for machines
 that either do not have an ISCOFF macro in /usr/include or for those
 where it is wrong.  */

104#ifndef MY_ISCOFF
105#define MY_ISCOFF(X) ISCOFF (X)
106#endif

108#endif /* OBJECT_FORMAT_COFF */

110#ifdef OBJECT_FORMAT_NONE

112/* Default flags to pass to nm.  */
113#ifndef NM_FLAGS"-n"
114#define NM_FLAGS"-n" "-n"
115#endif

117#endif /* OBJECT_FORMAT_NONE */

119/* Some systems use __main in a way incompatible with its use in gcc, in these
 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
 give the same symbol without quotes for an alternative entry point.  */
122#ifndef NAME__MAIN"__main"
123#define NAME__MAIN"__main" "__main"
124#endif

126/* This must match tree.h.  */
127#define DEFAULT_INIT_PRIORITY65535 65535

129#ifndef COLLECT_SHARED_INIT_FUNC
130#define COLLECT_SHARED_INIT_FUNC(STREAM, FUNC)fprintf ((STREAM), "void _GLOBAL__DI() {\n\t%s();\n}\n", (FUNC
)) \
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)fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC
)) \
fprintf ((STREAM), "void _GLOBAL__DD() {\n\t%s();\n}\n", (FUNC))
136#endif

138#ifdef LDD_SUFFIX
139#define SCAN_LIBRARIES
140#endif

142#ifndef SHLIB_SUFFIX".so"
143#define SHLIB_SUFFIX".so" ".so"
144#endif

146#ifdef USE_COLLECT2
147int do_collecting = 1;
148#else
149int do_collecting = 0;
150#endif

152/* Cook up an always defined indication of whether we proceed the
 "EXPORT_LIST" way.  */

155#ifdef COLLECT_EXPORT_LIST
156#define DO_COLLECT_EXPORT_LIST0 1
157#else
158#define DO_COLLECT_EXPORT_LIST0 0
159#endif

161/* Nonzero if we should suppress the automatic demangling of identifiers
 in linker error messages.  Set from COLLECT_NO_DEMANGLE.  */
163int no_demangle;
164
165/* Linked lists of constructor and destructor names.  */

167struct id
168{
struct id *next;
int sequence;
char name[1];
172};

174struct head
175{
struct id *first;
struct id *last;
int number;
179};

181static int rflag;			/* true if -r */
182static int strip_flag;			/* true if -s */
183#ifdef COLLECT_EXPORT_LIST
184static int export_flag;                 /* true if -bE */
185static int aix64_flag;			/* true if -b64 */
186static int aixrtl_flag;			/* true if -brtl */
187static int aixlazy_flag;		/* true if -blazy */
188static int visibility_flag;		/* true if -fvisibility */
189#endif

191enum lto_mode_d {
LTO_MODE_NONE,			/* Not doing LTO.  */
LTO_MODE_LTO,				/* Normal LTO.  */
LTO_MODE_WHOPR			/* WHOPR.  */
195};

197/* Current LTO mode.  */
198#ifdef ENABLE_LTO1
199static enum lto_mode_d lto_mode = LTO_MODE_WHOPR;
200#else
201static enum lto_mode_d lto_mode = LTO_MODE_NONE;
202#endif

204bool helpflag;			/* true if --help */

206static int shared_obj;			/* true if -shared */
207static int static_obj;			/* true if -static */

209static const char *c_file;		/* <xxx>.c for constructor/destructor list.  */
210static const char *o_file;		/* <xxx>.o for constructor/destructor list.  */
211#ifdef COLLECT_EXPORT_LIST
212static const char *export_file;		/* <xxx>.x for AIX export list.  */
213#endif
214static char **lto_o_files;		/* Output files for LTO.  */
215static const char *output_file;		/* Output file for ld.  */
216static const char *nm_file_name;	/* pathname of nm */
217#ifdef LDD_SUFFIX
218static const char *ldd_file_name;	/* pathname of ldd (or equivalent) */
219#endif
220static const char *strip_file_name;		/* pathname of strip */
221const char *c_file_name;		/* pathname of gcc */
222static char *initname, *fininame;	/* names of init and fini funcs */


225#ifdef TARGET_AIX_VERSION
226static char *aix_shared_initname;
227static char *aix_shared_fininame;       /* init/fini names as per the scheme
			   described in config/rs6000/aix.h */
229#endif

231static struct head constructors;	/* list of constructors found */
232static struct head destructors;		/* list of destructors found */
233#ifdef COLLECT_EXPORT_LIST
234static struct head exports;		/* list of exported symbols */
235#endif
236static struct head frame_tables;	/* list of frame unwind info tables */

238bool at_file_supplied;		/* Whether to use @file arguments */

240struct obstack temporary_obstack;
241char * temporary_firstobj;

243/* A string that must be prepended to a target OS path in order to find
 it on the host system.  */
245#ifdef TARGET_SYSTEM_ROOT
246static const char *target_system_root = TARGET_SYSTEM_ROOT;
247#else
248static const char *target_system_root = "";
249#endif

251/* Whether we may unlink the output file, which should be set as soon as we
 know we have successfully produced it.  This is typically useful to prevent
 blindly attempting to unlink a read-only output that the target linker
 would leave untouched.  */
255bool may_unlink_output_file = false;

257#ifdef COLLECT_EXPORT_LIST
258/* Lists to keep libraries to be scanned for global constructors/destructors.  */
259static struct head libs;                    /* list of libraries */
260static struct head static_libs;             /* list of statically linked libraries */
261static struct path_prefix cmdline_lib_dirs; /* directories specified with -L */
262static struct path_prefix libpath_lib_dirs; /* directories in LIBPATH */
263static struct path_prefix *libpaths[3] = {&cmdline_lib_dirs,
			  &libpath_lib_dirs, NULL__null};
265#endif

267/* List of names of object files containing LTO information.
 These are a subset of the object file names appearing on the
 command line, and must be identical, in the sense of pointer
 equality, with the names passed to maybe_run_lto_and_relink().  */

272struct lto_object
273{
const char *name;		/* Name of object file.  */
struct lto_object *next;	/* Next in linked list.  */
276};

278struct lto_object_list
279{
struct lto_object *first;	/* First list element.  */
struct lto_object *last;	/* Last list element.  */
282};

284static struct lto_object_list lto_objects;

286/* Special kinds of symbols that a name may denote.  */

288enum symkind {
SYM_REGULAR = 0,  /* nothing special  */

SYM_CTOR = 1,  /* constructor */
SYM_DTOR = 2,  /* destructor  */
SYM_INIT = 3,  /* shared object routine that calls all the ctors  */
SYM_FINI = 4,  /* shared object routine that calls all the dtors  */
SYM_DWEH = 5,  /* DWARF exception handling table  */
SYM_AIXI = 6,
SYM_AIXD = 7
298};

300const char tool_name[] = "collect2";

302static symkind is_ctor_dtor (const char *);

304static void maybe_unlink_list (char **);
305static void add_to_list (struct head *, const char *);
306static int extract_init_priority (const char *);
307static void sort_ids (struct head *);
308static void write_list (FILE *, const char *, struct id *);
309#ifdef COLLECT_EXPORT_LIST
310static void dump_list (FILE *, const char *, struct id *);
311#endif
312#if 0
313static void dump_prefix_list (FILE *, const char *, struct prefix_list *);
314#endif
315static void write_list_with_asm (FILE *, const char *, struct id *);
316static void write_c_file (FILE *, const char *);
317static void write_c_file_stat (FILE *, const char *);
318#ifndef LD_INIT_SWITCH
319static void write_c_file_glob (FILE *, const char *);
320#endif
321#ifdef SCAN_LIBRARIES
322static void scan_libraries (const char *);
323#endif
324#ifdef COLLECT_EXPORT_LIST
325static int is_in_list (const char *, struct id *);
326static void write_aix_file (FILE *, struct id *);
327static char *resolve_lib_name (const char *);
328#endif
329static char *extract_string (const char **);
330static void post_ld_pass (bool);
331static void process_args (int *argcp, char **argv);

333/* Enumerations describing which pass this is for scanning the
 program file ...  */

336enum scanpass {
PASS_FIRST,				/* without constructors */
PASS_OBJ,				/* individual objects */
PASS_LIB,				/* looking for shared libraries */
PASS_SECOND,				/* with constructors linked in */
PASS_LTOINFO				/* looking for objects with LTO info */
342};

344/* ... and which kinds of symbols are to be considered.  */

346enum scanfilter_masks {
SCAN_NOTHING = 0,

SCAN_CTOR = 1 << SYM_CTOR,
SCAN_DTOR = 1 << SYM_DTOR,
SCAN_INIT = 1 << SYM_INIT,
SCAN_FINI = 1 << SYM_FINI,
SCAN_DWEH = 1 << SYM_DWEH,
SCAN_AIXI = 1 << SYM_AIXI,
SCAN_AIXD = 1 << SYM_AIXD,
SCAN_ALL  = ~0
357};

359/* This type is used for parameters and variables which hold
 combinations of the flags in enum scanfilter_masks.  */
361typedef int scanfilter;

363/* Scan the name list of the loaded program for the symbols g++ uses for
 static constructors and destructors.

 The SCANPASS argument tells which collect processing pass this is for and
 the SCANFILTER argument tells which kinds of symbols to consider in this
 pass.  Symbols of a special kind not in the filter mask are considered as
 regular ones.

 The constructor table begins at __CTOR_LIST__ and contains a count of the
 number of pointers (or -1 if the constructors are built in a separate
 section by the linker), followed by the pointers to the constructor
 functions, terminated with a null pointer.  The destructor table has the
 same format, and begins at __DTOR_LIST__.  */

377static void scan_prog_file (const char *, scanpass, scanfilter);

379
380/* Delete tempfiles and exit function.  */

382void
383tool_cleanup (bool from_signal)
384{
/* maybe_unlink may call notice, which is not signal safe.  */
if (from_signal)
  verbose = false;

if (c_file != 0 && c_file[0])
  maybe_unlink (c_file);

if (o_file != 0 && o_file[0])
  maybe_unlink (o_file);

395#ifdef COLLECT_EXPORT_LIST
if (export_file != 0 && export_file[0])
  maybe_unlink (export_file);
398#endif

if (lto_o_files)
  maybe_unlink_list (lto_o_files);
402}

404static void
405collect_atexit (void)
406{
tool_cleanup (false);
408}

410/* Notify user of a non-error, without translating the format string.  */
411void
412notice_translated (const char *cmsgid, ...)
413{
va_list ap;

va_start (ap, cmsgid)__builtin_va_start(ap, cmsgid);
vfprintf (stderrstderr, cmsgid, ap);
va_end (ap)__builtin_va_end(ap);
419}
420
421int
422file_exists (const char *name)
423{
return access (name, R_OK4) == 0;
425}

427/* Parse a reasonable subset of shell quoting syntax.  */

429static char *
430extract_string (const char **pp)
431{
const char *p = *pp;
int backquote = 0;
int inside = 0;

for (;;)
  {
    char c = *p;
    if (c == '\0')
break;
    ++p;
    if (backquote)
obstack_1grow (&temporary_obstack, c)__extension__ ({ struct obstack *__o = (&temporary_obstack
); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < 1
) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)
++ = (c))); });
    else if (! inside && c == ' ')
break;
    else if (! inside && c == '\\')
backquote = 1;
    else if (c == '\'')
inside = !inside;
    else
obstack_1grow (&temporary_obstack, c)__extension__ ({ struct obstack *__o = (&temporary_obstack
); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < 1
) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)
++ = (c))); });
  }

obstack_1grow (&temporary_obstack, '\0')__extension__ ({ struct obstack *__o = (&temporary_obstack
); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < 1
) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)
++ = ('\0'))); });
*pp = p;
return XOBFINISH (&temporary_obstack, char *)((char *) __extension__ ({ struct obstack *__o1 = ((&temporary_obstack
)); void *__value = (void *) __o1->object_base; if (__o1->
next_free == __value) __o1->maybe_empty_object = 1; __o1->
next_free = (sizeof (ptrdiff_t) < sizeof (void *) ? ((__o1
->object_base) + (((__o1->next_free) - (__o1->object_base
) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))) : (char *) (((ptrdiff_t) (__o1->next_free) + (__o1->
alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t
) (__o1->next_free - (char *) __o1->chunk) > (size_t
) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; __value; }));
457}
458
459/* Return the kind of symbol denoted by name S.  */

461static symkind
462is_ctor_dtor (const char *s)
463{
struct names { const char *const name; const int len; symkind ret;
  const int two_underscores; };

const struct names *p;
int ch;
const char *orig_s = s;

static const struct names special[] = {
472#ifndef NO_DOLLAR_IN_LABEL
  { "GLOBAL__I$", sizeof ("GLOBAL__I$")-1, SYM_CTOR, 0 },
  { "GLOBAL__D$", sizeof ("GLOBAL__D$")-1, SYM_DTOR, 0 },
475#else
476#ifndef NO_DOT_IN_LABEL
  { "GLOBAL__I.", sizeof ("GLOBAL__I.")-1, SYM_CTOR, 0 },
  { "GLOBAL__D.", sizeof ("GLOBAL__D.")-1, SYM_DTOR, 0 },
479#endif /* NO_DOT_IN_LABEL */
480#endif /* NO_DOLLAR_IN_LABEL */
  { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, SYM_CTOR, 0 },
  { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, SYM_DTOR, 0 },
  { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, SYM_DWEH, 0 },
  { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, SYM_INIT, 0 },
  { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, SYM_FINI, 0 },
486#ifdef TARGET_AIX_VERSION
  { "GLOBAL__AIXI_", sizeof ("GLOBAL__AIXI_")-1, SYM_AIXI, 0 },
  { "GLOBAL__AIXD_", sizeof ("GLOBAL__AIXD_")-1, SYM_AIXD, 0 },
489#endif
  { NULL__null, 0, SYM_REGULAR, 0 }
};

while ((ch = *s) == '_')
  ++s;

if (s == orig_s)
  return SYM_REGULAR;

for (p = &special[0]; p->len > 0; p++)
  {
    if (ch == p->name[0]
 && (!p->two_underscores || ((s - orig_s) >= 2))
 && strncmp (s, p->name, p->len) == 0)
{
 return p->ret;
}
  }
return SYM_REGULAR;
509}
510
511/* We maintain two prefix lists: one from COMPILER_PATH environment variable
 and one from the PATH variable.  */

514static struct path_prefix cpath, path;

516#ifdef CROSS_DIRECTORY_STRUCTURE
517/* This is the name of the target machine.  We use it to form the name
 of the files to execute.  */

520static const char *const target_machine = TARGET_MACHINE"x86_64-pc-linux-gnu";
521#endif

523/* Search for NAME using prefix list PPREFIX.  We only look for executable
 files.

 Return 0 if not found, otherwise return its name, allocated with malloc.  */

528#ifdef OBJECT_FORMAT_NONE

530/* Add an entry for the object file NAME to object file list LIST.
 New entries are added at the end of the list. The original pointer
 value of NAME is preserved, i.e., no string copy is performed.  */

534static void
535add_lto_object (struct lto_object_list *list, const char *name)
536{
struct lto_object *n = XNEW (struct lto_object)((struct lto_object *) xmalloc (sizeof (struct lto_object)));
n->name = name;
n->next = NULL__null;

if (list->last)
  list->last->next = n;
else
  list->first = n;

list->last = n;
547}
548#endif /* OBJECT_FORMAT_NONE */


551/* Perform a link-time recompilation and relink if any of the object
 files contain LTO info.  The linker command line LTO_LD_ARGV
 represents the linker command that would produce a final executable
 without the use of LTO. OBJECT_LST is a vector of object file names
 appearing in LTO_LD_ARGV that are to be considered for link-time
 recompilation, where OBJECT is a pointer to the last valid element.
 (This awkward convention avoids an impedance mismatch with the
 usage of similarly-named variables in main().)  The elements of
 OBJECT_LST must be identical, i.e., pointer equal, to the
 corresponding arguments in LTO_LD_ARGV.

 Upon entry, at least one linker run has been performed without the
 use of any LTO info that might be present.  Any recompilations
 necessary for template instantiations have been performed, and
 initializer/finalizer tables have been created if needed and
 included in the linker command line LTO_LD_ARGV. If any of the
 object files contain LTO info, we run the LTO back end on all such
 files, and perform the final link with the LTO back end output
 substituted for the LTO-optimized files.  In some cases, a final
 link with all link-time generated code has already been performed,
 so there is no need to relink if no LTO info is found.  In other
 cases, our caller has not produced the final executable, and is
 relying on us to perform the required link whether LTO info is
 present or not.  In that case, the FORCE argument should be true.
 Note that the linker command line argument LTO_LD_ARGV passed into
 this function may be modified in place.  */

578static void
579maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
	  const char **object, bool force)
581{
const char **object_file = CONST_CAST2 (const char **, char **, object_lst)(const_cast<const char **> (object_lst));

int num_lto_c_args = 1;    /* Allow space for the terminating NULL.  */

while (object_file < object)
{
  /* If file contains LTO info, add it to the list of LTO objects.  */
  scan_prog_file (*object_file++, PASS_LTOINFO, SCAN_ALL);

  /* Increment the argument count by the number of object file arguments
     we will add.  An upper bound suffices, so just count all of the
     object files regardless of whether they contain LTO info.  */
  num_lto_c_args++;
}

if (lto_objects.first)
  {
    char **lto_c_argv;
    const char **lto_c_ptr;
    char **p;
    char **lto_o_ptr;
    struct lto_object *list;
    char *lto_wrapper = getenv ("COLLECT_LTO_WRAPPER");
    struct pex_obj *pex;
    const char *prog = "lto-wrapper";
    int lto_ld_argv_size = 0;
    char **out_lto_ld_argv;
    int out_lto_ld_argv_size;
    size_t num_files;

    if (!lto_wrapper)
fatal_error (input_location, "environment variable "
     "%<COLLECT_LTO_WRAPPER%> must be set");

    num_lto_c_args++;

    /* There is at least one object file containing LTO info,
       so we need to run the LTO back end and relink.

To do so we build updated ld arguments with first
LTO object replaced by all partitions and other LTO
objects removed.  */

    lto_c_argv = (char **) xcalloc (sizeof (char *), num_lto_c_args);
    lto_c_ptr = CONST_CAST2 (const char **, char **, lto_c_argv)(const_cast<const char **> (lto_c_argv));

    *lto_c_ptr++ = lto_wrapper;

    /* Add LTO objects to the wrapper command line.  */
    for (list = lto_objects.first; list; list = list->next)
*lto_c_ptr++ = list->name;

    *lto_c_ptr = NULL__null;

    /* Run the LTO back end.  */
    pex = collect_execute (prog, lto_c_argv, NULL__null, NULL__null, PEX_SEARCH0x2,
	     at_file_supplied, "lto_args");
    {
int c;
FILE *stream;
size_t i;
char *start, *end;

stream = pex_read_output (pex, 0);
gcc_assert (stream)((void)(!(stream) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/collect2.cc"
, 646, __FUNCTION__), 0 : 0));

num_files = 0;
while ((c = getc (stream)) != EOF(-1))
 {
   obstack_1grow (&temporary_obstack, c)__extension__ ({ struct obstack *__o = (&temporary_obstack
); if (__extension__ ({ struct obstack const *__o1 = (__o); (
size_t) (__o1->chunk_limit - __o1->next_free); }) < 1
) _obstack_newchunk (__o, 1); ((void) (*((__o)->next_free)
++ = (c))); });
   if (c == '\n')
     ++num_files;
 }

/* signal handler may access uninitialized memory
  and delete whatever it points to, if lto_o_files
  is not allocated with calloc.  */
lto_o_files = XCNEWVEC (char *, num_files + 1)((char * *) xcalloc ((num_files + 1), sizeof (char *)));
lto_o_files[num_files] = NULL__null;
start = XOBFINISH (&temporary_obstack, char *)((char *) __extension__ ({ struct obstack *__o1 = ((&temporary_obstack
)); void *__value = (void *) __o1->object_base; if (__o1->
next_free == __value) __o1->maybe_empty_object = 1; __o1->
next_free = (sizeof (ptrdiff_t) < sizeof (void *) ? ((__o1
->object_base) + (((__o1->next_free) - (__o1->object_base
) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))) : (char *) (((ptrdiff_t) (__o1->next_free) + (__o1->
alignment_mask)) & ~(__o1->alignment_mask))); if ((size_t
) (__o1->next_free - (char *) __o1->chunk) > (size_t
) (__o1->chunk_limit - (char *) __o1->chunk)) __o1->
next_free = __o1->chunk_limit; __o1->object_base = __o1
->next_free; __value; }));
for (i = 0; i < num_files; ++i)
 {
   end = start;
   while (*end != '\n')
     ++end;
   *end = '\0';

   lto_o_files[i] = xstrdup (start);

   start = end + 1;
 }

obstack_free (&temporary_obstack, temporary_firstobj)__extension__ ({ struct obstack *__o = (&temporary_obstack
); void *__obj = (void *) (temporary_firstobj); if (__obj >
 (void *) __o->chunk && __obj < (void *) __o->
chunk_limit) __o->next_free = __o->object_base = (char *
) __obj; else _obstack_free (__o, __obj); });
    }
    do_wait (prog, pex);
    pex = NULL__null;

    /* Compute memory needed for new LD arguments.  At most number of original arguments
plus number of partitions.  */
    for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
;
    out_lto_ld_argv = XCNEWVEC (char *, num_files + lto_ld_argv_size + 1)((char * *) xcalloc ((num_files + lto_ld_argv_size + 1), sizeof
 (char *)));
    out_lto_ld_argv_size = 0;

    /* After running the LTO back end, we will relink, substituting
the LTO output for the object files that we submitted to the
LTO. Here, we modify the linker command line for the relink.  */

    /* Copy all arguments until we find first LTO file.  */
    p = lto_ld_argv;
    while (*p != NULL__null)
      {
        for (list = lto_objects.first; list; list = list->next)
          if (*p == list->name) /* Note test for pointer equality!  */
     break;
 if (list)
   break;
 out_lto_ld_argv[out_lto_ld_argv_size++] = *p++;
      }

    /* Now insert all LTO partitions.  */
    lto_o_ptr = lto_o_files;
    while (*lto_o_ptr)
out_lto_ld_argv[out_lto_ld_argv_size++] = *lto_o_ptr++;

    /* ... and copy the rest.  */
    while (*p != NULL__null)
      {
        for (list = lto_objects.first; list; list = list->next)
          if (*p == list->name) /* Note test for pointer equality!  */
     break;
 if (!list)
   out_lto_ld_argv[out_lto_ld_argv_size++] = *p;
 p++;
      }
    out_lto_ld_argv[out_lto_ld_argv_size++] = 0;

    /* Run the linker again, this time replacing the object files
       optimized by the LTO with the temporary file generated by the LTO.  */
    fork_execute ("ld", out_lto_ld_argv, HAVE_GNU_LD1 && at_file_supplied,
    "ld_args");
    /* We assume that temp files were created, and therefore we need to take
       that into account (maybe run dsymutil).  */
    post_ld_pass (/*temp_file*/true);
    free (lto_ld_argv);

    maybe_unlink_list (lto_o_files);
  }
else if (force)
  {
    /* Our caller is relying on us to do the link
       even though there is no LTO back end work to be done.  */
    fork_execute ("ld", lto_ld_argv, HAVE_GNU_LD1 && at_file_supplied,
    "ld_args");
    /* No LTO objects were found, so no new temp file.  */
    post_ld_pass (/*temp_file*/false);
  }
else
  post_ld_pass (false); /* No LTO objects were found, no temp file.  */
741}
742/* Entry point for linker invoation.  Called from main in collect2.cc.
 LD_ARGV is an array of arguments for the linker.  */

745static void
746do_link (char **ld_argv, const char *atsuffix)
747{
struct pex_obj *pex;
const char *prog = "ld";
pex = collect_execute (prog, ld_argv, NULL__null, NULL__null,
	 PEX_LAST0x1 | PEX_SEARCH0x2,
	 HAVE_GNU_LD1 && at_file_supplied, atsuffix);
int ret = collect_wait (prog, pex);
if (ret)
  {
    error ("ld returned %d exit status", ret);
    exit (ret);
  }
else
  {
    /* We have just successfully produced an output file, so assume that we
may unlink it if need be for now on.  */
    may_unlink_output_file = true;
  }
765}
766
767/* Main program.  */

769int
770main (int argc, char **argv)
771{
enum linker_select
  {
    USE_DEFAULT_LD,
    USE_PLUGIN_LD,
    USE_GOLD_LD,
    USE_BFD_LD,
    USE_LLD_LD,
    USE_MOLD_LD,
    USE_LD_MAX
  } selected_linker = USE_DEFAULT_LD;
static const char *const ld_suffixes[USE_LD_MAX] =
  {
    "ld",
    PLUGIN_LD_SUFFIX"ld",
    "ld.gold",
    "ld.bfd",
    "ld.lld",
    "ld.mold"
  };
static const char *const real_ld_suffix = "real-ld";
static const char *const collect_ld_suffix = "collect-ld";
static const char *const nm_suffix	= "nm";
static const char *const gnm_suffix	= "gnm";
795#ifdef LDD_SUFFIX
static const char *const ldd_suffix	= LDD_SUFFIX;
797#endif
static const char *const strip_suffix = "strip";
static const char *const gstrip_suffix = "gstrip";

const char *full_ld_suffixes[USE_LD_MAX];
802#ifdef CROSS_DIRECTORY_STRUCTURE
/* If we look for a program in the compiler directories, we just use
   the short name, since these directories are already system-specific.
   But it we look for a program in the system directories, we need to
   qualify the program name with the target machine.  */

const char *const full_nm_suffix =
  concat (target_machine, "-", nm_suffix, NULL__null);
const char *const full_gnm_suffix =
  concat (target_machine, "-", gnm_suffix, NULL__null);
812#ifdef LDD_SUFFIX
const char *const full_ldd_suffix =
  concat (target_machine, "-", ldd_suffix, NULL__null);
815#endif
const char *const full_strip_suffix =
  concat (target_machine, "-", strip_suffix, NULL__null);
const char *const full_gstrip_suffix =
  concat (target_machine, "-", gstrip_suffix, NULL__null);
820#else
821#ifdef LDD_SUFFIX
const char *const full_ldd_suffix	= ldd_suffix;
823#endif
const char *const full_nm_suffix	= nm_suffix;
const char *const full_gnm_suffix	= gnm_suffix;
const char *const full_strip_suffix	= strip_suffix;
const char *const full_gstrip_suffix	= gstrip_suffix;
828#endif /* CROSS_DIRECTORY_STRUCTURE */

const char *arg;
FILE *outf;
832#ifdef COLLECT_EXPORT_LIST
FILE *exportf;
834#endif
const char *ld_file_name;
const char *p;
char **c_argv;
const char **c_ptr;
char **ld1_argv;
const char **ld1;
bool use_plugin = false;
bool use_collect_ld = false;

/* The kinds of symbols we will have to consider when scanning the
   outcome of a first pass link.  This is ALL to start with, then might
   be adjusted before getting to the first pass link per se, typically on
   AIX where we perform an early scan of objects and libraries to fetch
   the list of global ctors/dtors and make sure they are not garbage
   collected.  */
scanfilter ld1_filter = SCAN_ALL;

char **ld2_argv;
const char **ld2;
char **object_lst;
const char **object;
856#ifdef TARGET_AIX_VERSION
int object_nbr = argc;
858#endif
int first_file;
int num_c_args;
char **old_argv;
862#ifdef COLLECT_EXPORT_LIST
bool is_static = false;
864#endif
int i;

for (i = 0; i < USE_LD_MAX; i++)
  full_ld_suffixes[i]
869#ifdef CROSS_DIRECTORY_STRUCTURE
    = concat (target_machine, "-", ld_suffixes[i], NULL__null);
871#else
    = ld_suffixes[i];
873#endif

p = argv[0] + strlen (argv[0]);
while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])(((p[-1]) == '/') || (((p[-1]) == '\\') && (0))))
  --p;
progname = p;

xmalloc_set_program_name (progname);

old_argv = argv;
expandargv (&argc, &argv);
if (argv != old_argv)
  at_file_supplied = 1;

process_args (&argc, argv);

num_c_args = argc + 9;

891#ifndef HAVE_LD_DEMANGLE1
no_demangle = !! getenv ("COLLECT_NO_DEMANGLE");

/* Suppress demangling by the real linker, which may be broken.  */
putenv (xstrdup ("COLLECT_NO_DEMANGLE=1"));
896#endif

898#if defined (COLLECT2_HOST_INITIALIZATION)
/* Perform system dependent initialization, if necessary.  */
COLLECT2_HOST_INITIALIZATION;
901#endif

setup_signals ();

/* Unlock the stdio streams.  */
unlock_std_streams ();

gcc_init_libintl ();

diagnostic_initialize (global_dc, 0);

if (atexit (collect_atexit) != 0)
  fatal_error (input_location, "atexit failed");

/* Do not invoke xcalloc before this point, since locale needs to be
   set first, in case a diagnostic is issued.  */

ld1_argv = XCNEWVEC (char *, argc + 4)((char * *) xcalloc ((argc + 4), sizeof (char *)));
ld1 = CONST_CAST2 (const char **, char **, ld1_argv)(const_cast<const char **> (ld1_argv));
ld2_argv = XCNEWVEC (char *, argc + 11)((char * *) xcalloc ((argc + 11), sizeof (char *)));
ld2 = CONST_CAST2 (const char **, char **, ld2_argv)(const_cast<const char **> (ld2_argv));
object_lst = XCNEWVEC (char *, argc)((char * *) xcalloc ((argc), sizeof (char *)));
object = CONST_CAST2 (const char **, char **, object_lst)(const_cast<const char **> (object_lst));

925#ifdef DEBUG
debug = true;
927#endif

save_temps = false;
verbose = false;

932#ifndef DEFAULT_A_OUT_NAME
output_file = "a.out";
934#else
output_file = DEFAULT_A_OUT_NAME;
936#endif

/* Parse command line / environment for flags we want early.
   This allows the debug flag to be set before functions like find_a_file()
   are called. */
{
  bool no_partition = false;

  for (i = 1; argv[i] != NULL__null; i ++)
    {
if (! strcmp (argv[i], "-debug"))
 debug = true;
else if (startswith (argv[i], "-fno-lto"))
 lto_mode = LTO_MODE_NONE;
      else if (! strcmp (argv[i], "-plugin"))
 {
   use_plugin = true;
   if (selected_linker == USE_DEFAULT_LD)
     selected_linker = USE_PLUGIN_LD;
 }
else if (strcmp (argv[i], "-fuse-ld=bfd") == 0)
 selected_linker = USE_BFD_LD;
else if (strcmp (argv[i], "-fuse-ld=gold") == 0)
 selected_linker = USE_GOLD_LD;
else if (strcmp (argv[i], "-fuse-ld=lld") == 0)
 selected_linker = USE_LLD_LD;
else if (strcmp (argv[i], "-fuse-ld=mold") == 0)
 selected_linker = USE_MOLD_LD;
else if (startswith (argv[i], "-o"))
 {
   /* Parse the output filename if it's given so that we can make
      meaningful temp filenames.  */
   if (argv[i][2] != '\0')
     output_file = &argv[i][2];
   else if (argv[i+1] != NULL__null)
     output_file = argv[++i];
 }

974#ifdef COLLECT_EXPORT_LIST
/* These flags are position independent, although their order
  is important - subsequent flags override earlier ones. */
else if (strcmp (argv[i], "-b64") == 0)
 aix64_flag = 1;
/* -bexport:filename always needs the :filename */
else if (startswith (argv[i], "-bE:")
 || startswith (argv[i], "-bexport:"))
 export_flag = 1;
else if (strcmp (argv[i], "-brtl") == 0
     || strcmp (argv[i], "-bsvr4") == 0
     || strcmp (argv[i], "-G") == 0)
 aixrtl_flag = 1;
else if (strcmp (argv[i], "-bnortl") == 0)
 aixrtl_flag = 0;
else if (strcmp (argv[i], "-blazy") == 0)
 aixlazy_flag = 1;
991#endif
    }

  obstack_begin (&temporary_obstack, 0)_obstack_begin ((&temporary_obstack), (0), 0, (mempool_obstack_chunk_alloc
), (mempool_obstack_chunk_free));
  temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0)__extension__ ({ struct obstack *__h = (&temporary_obstack
); __extension__ ({ struct obstack *__o = (__h); size_t __len
 = ((0)); if (__extension__ ({ struct obstack const *__o1 = (
__o); (size_t) (__o1->chunk_limit - __o1->next_free); }
) < __len) _obstack_newchunk (__o, __len); ((void) ((__o)->
next_free += (__len))); }); __extension__ ({ struct obstack *
__o1 = (__h); void *__value = (void *) __o1->object_base; if
 (__o1->next_free == __value) __o1->maybe_empty_object =
 1; __o1->next_free = (sizeof (ptrdiff_t) < sizeof (void
 *) ? ((__o1->object_base) + (((__o1->next_free) - (__o1
->object_base) + (__o1->alignment_mask)) & ~(__o1->
alignment_mask))) : (char *) (((ptrdiff_t) (__o1->next_free
) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))); if ((size_t) (__o1->next_free - (char *) __o1->chunk
) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk
)) __o1->next_free = __o1->chunk_limit; __o1->object_base
 = __o1->next_free; __value; }); });

997#ifndef HAVE_LD_DEMANGLE1
current_demangling_style = auto_demangling;
999#endif

  /* Now pick up any flags we want early from COLLECT_GCC_OPTIONS
     The LTO options are passed here as are other options that might
     be unsuitable for ld (e.g. -save-temps).  */
  p = getenv ("COLLECT_GCC_OPTIONS");
  while (p && *p)
    {
const char *q = extract_string (&p);
if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
 num_c_args++;
if (startswith (q, "-flto-partition=none"))
 no_partition = true;
else if (startswith (q, "-fno-lto"))
 lto_mode = LTO_MODE_NONE;
else if (startswith (q, "-save-temps"))
 /* FIXME: Honour =obj.  */
 save_temps = true;
else if (strcmp (q, "-dumpdir") == 0)
 dumppfx = xstrdup (extract_string (&p));
else if (strcmp (q, "-o") == 0
 || strcmp (q, "-B") == 0
 || strcmp (q, "-isystem") == 0)
 (void) extract_string (&p);
  }
  obstack_free (&temporary_obstack, temporary_firstobj)__extension__ ({ struct obstack *__o = (&temporary_obstack
); void *__obj = (void *) (temporary_firstobj); if (__obj >
 (void *) __o->chunk && __obj < (void *) __o->
chunk_limit) __o->next_free = __o->object_base = (char *
) __obj; else _obstack_free (__o, __obj); });

  verbose = verbose || debug;
  save_temps = save_temps || debug;
  find_file_set_debug (debug);
  if (use_plugin)
    lto_mode = LTO_MODE_NONE;
  if (no_partition && lto_mode == LTO_MODE_WHOPR)
    lto_mode = LTO_MODE_LTO;
}

/* -fno-profile-arcs -fno-test-coverage -fno-branch-probabilities
   -fno-exceptions -w -fno-whole-program */
num_c_args += 6;

c_argv = XCNEWVEC (char *, num_c_args)((char * *) xcalloc ((num_c_args), sizeof (char *)));
c_ptr = CONST_CAST2 (const char **, char **, c_argv)(const_cast<const char **> (c_argv));

if (argc < 2)
  fatal_error (input_location, "no arguments");

/* Extract COMPILER_PATH and PATH into our prefix list.  */
prefix_from_env ("COMPILER_PATH", &cpath);
prefix_from_env ("PATH", &path);

/* Try to discover a valid linker/nm/strip to use.  */

/* Maybe we know the right file to use (if not cross).  */
ld_file_name = 0;
1053#ifdef DEFAULT_LINKER
if (selected_linker == USE_BFD_LD || selected_linker == USE_GOLD_LD ||
    selected_linker == USE_LLD_LD || selected_linker == USE_MOLD_LD)
  {
    char *linker_name;
1058# ifdef HOST_EXECUTABLE_SUFFIX
    int len = (sizeof (DEFAULT_LINKER)
 - sizeof (HOST_EXECUTABLE_SUFFIX));
    linker_name = NULL__null;
    if (len > 0)
{
 char *default_linker = xstrdup (DEFAULT_LINKER);
 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
    HOST_EXECUTABLE_SUFFIX.  */
 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
   {
     default_linker[len] = '\0';
     linker_name = concat (default_linker,
		    &ld_suffixes[selected_linker][2],
		    HOST_EXECUTABLE_SUFFIX, NULL__null);
   }
}
    if (linker_name == NULL__null)
1076# endif
    linker_name = concat (DEFAULT_LINKER,
	    &ld_suffixes[selected_linker][2],
	    NULL__null);
    if (access (linker_name, X_OK1) == 0)
ld_file_name = linker_name;
  }
if (ld_file_name == 0 && access (DEFAULT_LINKER, X_OK1) == 0)
  ld_file_name = DEFAULT_LINKER;
if (ld_file_name == 0)
1086#endif
1087#ifdef REAL_LD_FILE_NAME
ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME, X_OK1);
if (ld_file_name == 0)
1090#endif
/* Search the (target-specific) compiler dirs for ld'.  */
ld_file_name = find_a_file (&cpath, real_ld_suffix, X_OK1);
/* Likewise for `collect-ld'.  */
if (ld_file_name == 0)
  {
    ld_file_name = find_a_file (&cpath, collect_ld_suffix, X_OK1);
    use_collect_ld = ld_file_name != 0;
  }
/* Search the compiler directories for `ld'.  We have protection against
   recursive calls in find_a_file.  */
if (ld_file_name == 0)
  ld_file_name = find_a_file (&cpath, ld_suffixes[selected_linker], X_OK1);
/* Search the ordinary system bin directories
   for `ld' (if native linking) or `TARGET-ld' (if cross).  */
if (ld_file_name == 0)
  ld_file_name = find_a_file (&path, full_ld_suffixes[selected_linker], X_OK1);

1108#ifdef REAL_NM_FILE_NAME
nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME, X_OK1);
if (nm_file_name == 0)
1111#endif
nm_file_name = find_a_file (&cpath, gnm_suffix, X_OK1);
if (nm_file_name == 0)
  nm_file_name = find_a_file (&path, full_gnm_suffix, X_OK1);
if (nm_file_name == 0)
  nm_file_name = find_a_file (&cpath, nm_suffix, X_OK1);
if (nm_file_name == 0)
  nm_file_name = find_a_file (&path, full_nm_suffix, X_OK1);

1120#ifdef LDD_SUFFIX
ldd_file_name = find_a_file (&cpath, ldd_suffix, X_OK1);
if (ldd_file_name == 0)
  ldd_file_name = find_a_file (&path, full_ldd_suffix, X_OK1);
1124#endif

1126#ifdef REAL_STRIP_FILE_NAME
strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME, X_OK1);
if (strip_file_name == 0)
1129#endif
strip_file_name = find_a_file (&cpath, gstrip_suffix, X_OK1);
if (strip_file_name == 0)
  strip_file_name = find_a_file (&path, full_gstrip_suffix, X_OK1);
if (strip_file_name == 0)
  strip_file_name = find_a_file (&cpath, strip_suffix, X_OK1);
if (strip_file_name == 0)
  strip_file_name = find_a_file (&path, full_strip_suffix, X_OK1);

/* Determine the full path name of the C compiler to use.  */
c_file_name = getenv ("COLLECT_GCC");
if (c_file_name == 0)
  {
1142#ifdef CROSS_DIRECTORY_STRUCTURE
    c_file_name = concat (target_machine, "-gcc", NULL__null);
1144#else
    c_file_name = "gcc";
1146#endif
  }

p = find_a_file (&cpath, c_file_name, X_OK1);

/* Here it should be safe to use the system search path since we should have
   already qualified the name of the compiler when it is needed.  */
if (p == 0)
  p = find_a_file (&path, c_file_name, X_OK1);

if (p)
  c_file_name = p;

*ld1++ = *ld2++ = ld_file_name;

/* Make temp file names.  */
if (save_temps)
  {
    c_file = concat (output_file, ".cdtor.c", NULL__null);
    o_file = concat (output_file, ".cdtor.o", NULL__null);
1166#ifdef COLLECT_EXPORT_LIST
    export_file = concat (output_file, ".x", NULL__null);
1168#endif
  }
else
  {
    c_file = make_temp_file (".cdtor.c");
    o_file = make_temp_file (".cdtor.o");
1174#ifdef COLLECT_EXPORT_LIST
    export_file = make_temp_file (".x");
1176#endif
  }
/* Build the command line to compile the ctor/dtor list.  */
*c_ptr++ = c_file_name;
*c_ptr++ = "-x";
*c_ptr++ = "c";
*c_ptr++ = "-c";
*c_ptr++ = "-o";
*c_ptr++ = o_file;

1186#ifdef COLLECT_EXPORT_LIST
/* Generate a list of directories from LIBPATH.  */
prefix_from_env ("LIBPATH", &libpath_lib_dirs);
/* Add to this list also two standard directories where
   AIX loader always searches for libraries.  */
add_prefix (&libpath_lib_dirs, "/lib");
add_prefix (&libpath_lib_dirs, "/usr/lib");
1193#endif

/* Get any options that the upper GCC wants to pass to the sub-GCC.

   AIX support needs to know if -shared has been specified before
   parsing commandline arguments.  */

p = getenv ("COLLECT_GCC_OPTIONS");
while (p && *p)
  {
    const char *q = extract_string (&p);
    if (*q == '-' && (q[1] == 'm' || q[1] == 'f'))
*c_ptr++ = xstrdup (q);
    if (strcmp (q, "-EL") == 0 || strcmp (q, "-EB") == 0)
*c_ptr++ = xstrdup (q);
    if (strcmp (q, "-shared") == 0)
shared_obj = 1;
    if (strcmp (q, "-static") == 0)
static_obj = 1;
    if (*q == '-' && q[1] == 'B')
{
 *c_ptr++ = xstrdup (q);
 if (q[2] == 0)
   {
     q = extract_string (&p);
     *c_ptr++ = xstrdup (q);
   }
}
    else if (strcmp (q, "-o") == 0
      || strcmp (q, "-dumpdir") == 0
      || strcmp (q, "-isystem") == 0)
(void) extract_string (&p);
1225#ifdef COLLECT_EXPORT_LIST
    /* Detect any invocation with -fvisibility.  */
    if (startswith (q, "-fvisibility"))
visibility_flag = 1;
1229#endif
  }
obstack_free (&temporary_obstack, temporary_firstobj)__extension__ ({ struct obstack *__o = (&temporary_obstack
); void *__obj = (void *) (temporary_firstobj); if (__obj >
 (void *) __o->chunk && __obj < (void *) __o->
chunk_limit) __o->next_free = __o->object_base = (char *
) __obj; else _obstack_free (__o, __obj); });
*c_ptr++ = "-fno-profile-arcs";
*c_ptr++ = "-fno-test-coverage";
*c_ptr++ = "-fno-branch-probabilities";
*c_ptr++ = "-fno-exceptions";
*c_ptr++ = "-w";
*c_ptr++ = "-fno-whole-program";

/* !!! When GCC calls collect2,
   it does not know whether it is calling collect2 or ld.
   So collect2 cannot meaningfully understand any options
   except those ld understands.
   If you propose to make GCC pass some other option,
   just imagine what will happen if ld is really ld!!!  */

/* Parse arguments.  Remember output file spec, pass the rest to ld.  */
/* After the first file, put in the c++ rt0.  */

1249#ifdef COLLECT_EXPORT_LIST
is_static = static_obj;
1251#endif
first_file = 1;
while ((arg = *++argv) != (char *) 0)
  {
    *ld1++ = *ld2++ = arg;

    if (arg[0] == '-')
{
 switch (arg[1])
   {
   case 'd':
     if (!strcmp (arg, "-debug"))
{
  /* Already parsed.  */
  ld1--;
  ld2--;
}
     if (!strcmp (arg, "-dynamic-linker") && argv[1])
{
  ++argv;
  *ld1++ = *ld2++ = *argv;
}
     break;

          case 'f':
     if (startswith (arg, "-flto"))
{
1278#ifdef ENABLE_LTO1
  /* Do not pass LTO flag to the linker. */
  ld1--;
  ld2--;
1282#else
  error ("LTO support has not been enabled in this "
	 "configuration");
1285#endif
}
     else if (!use_collect_ld
       && startswith (arg, "-fuse-ld="))
{
  /* Do not pass -fuse-ld={bfd|gold|lld|mold} to the linker. */
  ld1--;
  ld2--;
}
     else if (startswith (arg, "-fno-lto"))
{
  /* Do not pass -fno-lto to the linker. */
  ld1--;
  ld2--;
}
1300#ifdef TARGET_AIX_VERSION
     else
{
  /* File containing a list of input files to process.  */

  FILE *stream;
                char buf[MAXPATHLEN4096 + 2];
  /* Number of additionnal object files.  */
  int add_nbr = 0;
  /* Maximum of additionnal object files before vector
     expansion.  */
  int add_max = 0;
  const char *list_filename = arg + 2;

  /* Accept -fFILENAME and -f FILENAME.  */
  if (*list_filename == '\0' && argv[1])
    {
      ++argv;
      list_filename = *argv;
      *ld1++ = *ld2++ = *argv;
    }

  stream = fopen (list_filename, "r");
  if (stream == NULL__null)
    fatal_error (input_location, "cannot open %s: %m",
		 list_filename);

  while (fgets (buf, sizeof buf, stream) != NULL__null)
    {
      /* Remove end of line.  */
      int len = strlen (buf);
      if (len >= 1 && buf[len - 1] =='\n')
	buf[len - 1] = '\0';

      /* Put on object vector.
	 Note: we only expanse vector here, so we must keep
	 extra space for remaining arguments.  */
      if (add_nbr >= add_max)
	{
	  int pos =
	    object - CONST_CAST2 (const char **, char **,(const_cast<const char **> (object_lst))
				  object_lst)(const_cast<const char **> (object_lst));
	  add_max = (add_max == 0) ? 16 : add_max * 2;
	  object_lst = XRESIZEVEC (char *, object_lst,((char * *) xrealloc ((void *) (object_lst), sizeof (char *) *
 (object_nbr + add_max)))
                                                 object_nbr + add_max)((char * *) xrealloc ((void *) (object_lst), sizeof (char *) *
 (object_nbr + add_max)));
	  object = CONST_CAST2 (const char **, char **,(const_cast<const char **> (object_lst))
				object_lst)(const_cast<const char **> (object_lst)) + pos;
	  object_nbr += add_max;
	}
      *object++ = xstrdup (buf);
      add_nbr++;
    }
  fclose (stream);
}
1354#endif
            break;

1357#ifdef COLLECT_EXPORT_LIST
   case 'b':
     if (!strcmp (arg, "-bstatic"))
{
  is_static = true;
}
     else if (!strcmp (arg, "-bdynamic") || !strcmp (arg, "-bshared"))
{
  is_static = false;
}
     break;
1368#endif
   case 'l':
     if (first_file)
{
  /* place o_file BEFORE this argument! */
  first_file = 0;
  ld2--;
  *ld2++ = o_file;
  *ld2++ = arg;
}
1378#ifdef COLLECT_EXPORT_LIST
     {
/* Resolving full library name.  */
const char *s = resolve_lib_name (arg+2);

/* Saving a full library name.  */
add_to_list (&libs, s);
if (is_static)
    add_to_list (&static_libs, s);
     }
1388#endif
     break;

1391#ifdef COLLECT_EXPORT_LIST
   /* Saving directories where to search for libraries.  */
   case 'L':
     add_prefix (&cmdline_lib_dirs, arg+2);
     break;
1396#endif

   case 'o':
     if (arg[2] != '\0')
output_file = &arg[2];
     else if (argv[1])
output_file = *ld1++ = *ld2++ = *++argv;
     break;

   case 'r':
     if (arg[2] == '\0')
rflag = 1;
     break;

   case 's':
     if (arg[2] == '\0' && do_collecting)
{
  /* We must strip after the nm run, otherwise C++ linking
     will not work.  Thus we strip in the second ld run, or
     else with strip if there is no second ld run.  */
  strip_flag = 1;
  ld1--;
}
     break;

   case 'v':
     if (arg[2] == '\0')
verbose = true;
     break;

   case '-':
     if (strcmp (arg, "--no-demangle") == 0)
{
1429#ifndef HAVE_LD_DEMANGLE1
  no_demangle = 1;
  ld1--;
  ld2--;
1433#endif
}
     else if (startswith (arg, "--demangle"))
{
1437#ifndef HAVE_LD_DEMANGLE1
  no_demangle = 0;
  if (arg[10] == '=')
    {
      enum demangling_styles style
	= cplus_demangle_name_to_style (arg+11);
      if (style == unknown_demangling)
	error ("unknown demangling style %qs", arg+11);
      else
	current_demangling_style = style;
    }
  ld1--;
  ld2--;
1450#endif
}
     else if (startswith (arg, "--sysroot="))
target_system_root = arg + 10;
     else if (strcmp (arg, "--version") == 0)
verbose = true;
     else if (strcmp (arg, "--help") == 0)
helpflag = true;
     break;
   }
}
    else if ((p = strrchr (arg, '.')) != (char *) 0
      && (strcmp (p, ".o") == 0 || strcmp (p, ".a") == 0
   || strcmp (p, ".so") == 0 || strcmp (p, ".lo") == 0
   || strcmp (p, ".obj") == 0))
{
 if (first_file)
   {
     first_file = 0;
     if (p[1] == 'o')
*ld2++ = o_file;
     else
{
  /* place o_file BEFORE this argument! */
  ld2--;
  *ld2++ = o_file;
  *ld2++ = arg;
}
   }
 if (p[1] == 'o' || p[1] == 'l')
   *object++ = arg;
1481#ifdef COLLECT_EXPORT_LIST
 /* libraries can be specified directly, i.e. without -l flag.  */
 else
   {
     /* Saving a full library name.  */
     add_to_list (&libs, arg);
     if (is_static)
add_to_list (&static_libs, arg);
   }
1490#endif
}
  }

1494#ifdef COLLECT_EXPORT_LIST
/* This is added only for debugging purposes.  */
if (debug)
  {
    fprintf (stderrstderr, "List of libraries:\n");
    dump_list (stderrstderr, "\t", libs.first);
    fprintf (stderrstderr, "List of statically linked libraries:\n");
    dump_list (stderrstderr, "\t", static_libs.first);
  }

/* The AIX linker will discard static constructors in object files if
   nothing else in the file is referenced, so look at them first.  Unless
   we are building a shared object, ignore the eh frame tables, as we
   would otherwise reference them all, hence drag all the corresponding
   objects even if nothing else is referenced.  */
{
  const char **export_object_lst
    = CONST_CAST2 (const char **, char **, object_lst)(const_cast<const char **> (object_lst));

  struct id *list = libs.first;

  /* Compute the filter to use from the current one, do scan, then adjust
     the "current" filter to remove what we just included here.  This will
     control whether we need a first pass link later on or not, and what
     will remain to be scanned there.  */

  scanfilter this_filter = ld1_filter;
1521#if HAVE_AS_REF
  if (!shared_obj)
    this_filter &= ~SCAN_DWEH;
1524#endif

  /* Scan object files.  */
  while (export_object_lst < object)
    scan_prog_file (*export_object_lst++, PASS_OBJ, this_filter);

  /* Scan libraries.  */
  for (; list; list = list->next)
    scan_prog_file (list->name, PASS_FIRST, this_filter);

  ld1_filter = ld1_filter & ~this_filter;
}

if (exports.first)
  {
    char *buf = concat ("-bE:", export_file, NULL__null);

    *ld1++ = buf;
    *ld2++ = buf;

    exportf = fopen (export_file, "w");
    if (exportf == (FILE *) 0)
fatal_error (input_location, "fopen %s: %m", export_file);
    write_aix_file (exportf, exports.first);
    if (fclose (exportf))
fatal_error (input_location, "fclose %s: %m", export_file);
  }
1551#endif

*c_ptr++ = c_file;
*c_ptr = *ld1 = *object = (char *) 0;

if (verbose)
  notice ("collect2 version %s\n", version_string"13.0.1 20230327 (experimental)");

if (helpflag)
  {
    printf ("Usage: collect2 [options]\n");
    printf (" Wrap linker and generate constructor code if needed.\n");
    printf (" Options:\n");
    printf ("  -debug          Enable debug output\n");
    printf ("  --help          Display this information\n");
    printf ("  -v, --version   Display this program's version number\n");
    printf ("\n");
    printf ("Overview: https://gcc.gnu.org/onlinedocs/gccint/Collect2.html\n");
    printf ("Report bugs: %s\n", bug_report_url"<https://gcc.gnu.org/bugs/>");
    printf ("\n");
  }

if (debug)
  {
    const char *ptr;
    fprintf (stderrstderr, "ld_file_name        = %s\n",
      (ld_file_name ? ld_file_name : "not found"));
    fprintf (stderrstderr, "c_file_name         = %s\n",
      (c_file_name ? c_file_name : "not found"));
    fprintf (stderrstderr, "nm_file_name        = %s\n",
      (nm_file_name ? nm_file_name : "not found"));
1582#ifdef LDD_SUFFIX
    fprintf (stderrstderr, "ldd_file_name       = %s\n",
      (ldd_file_name ? ldd_file_name : "not found"));
1585#endif
    fprintf (stderrstderr, "strip_file_name     = %s\n",
      (strip_file_name ? strip_file_name : "not found"));
    fprintf (stderrstderr, "c_file              = %s\n",
      (c_file ? c_file : "not found"));
    fprintf (stderrstderr, "o_file              = %s\n",
      (o_file ? o_file : "not found"));

    ptr = getenv ("COLLECT_GCC_OPTIONS");
    if (ptr)
fprintf (stderrstderr, "COLLECT_GCC_OPTIONS = %s\n", ptr);

    ptr = getenv ("COLLECT_GCC");
    if (ptr)
fprintf (stderrstderr, "COLLECT_GCC         = %s\n", ptr);

    ptr = getenv ("COMPILER_PATH");
    if (ptr)
fprintf (stderrstderr, "COMPILER_PATH       = %s\n", ptr);

    ptr = getenv (LIBRARY_PATH_ENV"LIBRARY_PATH");
    if (ptr)
fprintf (stderrstderr, "%-20s= %s\n", LIBRARY_PATH_ENV"LIBRARY_PATH", ptr);

    fprintf (stderrstderr, "\n");
  }

/* Load the program, searching all libraries and attempting to provide
   undefined symbols from repository information.

   If -r or they will be run via some other method, do not build the
   constructor or destructor list, just return now.  */
{
  bool early_exit
    = rflag || (! DO_COLLECT_EXPORT_LIST0 && ! do_collecting);

  /* Perform the first pass link now, if we're about to exit or if we need
     to scan for things we haven't collected yet before pursuing further.

     On AIX, the latter typically includes nothing for shared objects or
     frame tables for an executable, out of what the required early scan on
     objects and libraries has performed above.  In the !shared_obj case, we
     expect the relevant tables to be dragged together with their associated
     functions from precise cross reference insertions by the compiler.  */

  if (early_exit || ld1_filter != SCAN_NOTHING)
    do_link (ld1_argv, "ld1_args");

  if (early_exit)
    {
1635#ifdef COLLECT_EXPORT_LIST
/* Make sure we delete the export file we may have created.  */
if (export_file != 0 && export_file[0])
 maybe_unlink (export_file);
1639#endif
if (lto_mode != LTO_MODE_NONE)
 maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);
else
 post_ld_pass (/*temp_file*/false);

return 0;
    }
}

/* Unless we have done it all already, examine the namelist and search for
   static constructors and destructors to call.  Write the constructor and
   destructor tables to a .s file and reload.  */

if (ld1_filter != SCAN_NOTHING)
  scan_prog_file (output_file, PASS_FIRST, ld1_filter);

1656#ifdef SCAN_LIBRARIES
scan_libraries (output_file);
1658#endif

if (debug)
  {
    notice_translated (ngettext ("%d constructor found\n",
                                 "%d constructors found\n",
                                 constructors.number),
                       constructors.number);
    notice_translated (ngettext ("%d destructor found\n",
                                 "%d destructors found\n",
                                 destructors.number),
                       destructors.number);
    notice_translated (ngettext ("%d frame table found\n",
                                 "%d frame tables found\n",
		   frame_tables.number),
                       frame_tables.number);
  }

/* If the scan exposed nothing of special interest, there's no need to
   generate the glue code and relink so return now.  */

if (constructors.number == 0 && destructors.number == 0
    && frame_tables.number == 0
1681#if defined (SCAN_LIBRARIES) || defined (COLLECT_EXPORT_LIST)
    /* If we will be running these functions ourselves, we want to emit
stubs into the shared library so that we do not have to relink
dependent programs when we add static objects.  */
    && ! shared_obj
1686#endif
    )
  {
    /* Do link without additional code generation now if we didn't
do it earlier for scanning purposes.  */
    if (ld1_filter == SCAN_NOTHING)
do_link (ld1_argv, "ld1_args");

    if (lto_mode)
      maybe_run_lto_and_relink (ld1_argv, object_lst, object, false);

    /* Strip now if it was requested on the command line.  */
    if (strip_flag)
{
 char **real_strip_argv = XCNEWVEC (char *, 3)((char * *) xcalloc ((3), sizeof (char *)));
 const char ** strip_argv = CONST_CAST2 (const char **, char **,(const_cast<const char **> (real_strip_argv))
				  real_strip_argv)(const_cast<const char **> (real_strip_argv));

 strip_argv[0] = strip_file_name;
 strip_argv[1] = output_file;
 strip_argv[2] = (char *) 0;
 fork_execute ("strip", real_strip_argv, false, NULL__null);
}

1710#ifdef COLLECT_EXPORT_LIST
    maybe_unlink (export_file);
1712#endif
    post_ld_pass (/*temp_file*/false);
    return 0;
  }

/* Sort ctor and dtor lists by priority.  */
sort_ids (&constructors);
sort_ids (&destructors);

maybe_unlink (output_file);
outf = fopen (c_file, "w");
if (outf == (FILE *) 0)
  fatal_error (input_location, "fopen %s: %m", c_file);

write_c_file (outf, c_file);

if (fclose (outf))
  fatal_error (input_location, "fclose %s: %m", c_file);

/* Tell the linker that we have initializer and finalizer functions.  */
1732#ifdef LD_INIT_SWITCH
1733#ifdef COLLECT_EXPORT_LIST
*ld2++ = concat (LD_INIT_SWITCH, ":", initname, ":", fininame, NULL__null);
1735#else
*ld2++ = LD_INIT_SWITCH;
*ld2++ = initname;
*ld2++ = LD_FINI_SWITCH;
*ld2++ = fininame;
1740#endif
1741#endif

1743#ifdef COLLECT_EXPORT_LIST
if (shared_obj)
  {
    /* If we did not add export flag to link arguments before, add it to
second link phase now.  No new exports should have been added.  */
    if (! exports.first)
*ld2++ = concat ("-bE:", export_file, NULL__null);

1751#ifdef TARGET_AIX_VERSION
    add_to_list (&exports, aix_shared_initname);
    add_to_list (&exports, aix_shared_fininame);
1754#endif

1756#ifndef LD_INIT_SWITCH
    add_to_list (&exports, initname);
    add_to_list (&exports, fininame);
    add_to_list (&exports, "_GLOBAL__DI");
    add_to_list (&exports, "_GLOBAL__DD");
1761#endif
    exportf = fopen (export_file, "w");
    if (exportf == (FILE *) 0)
fatal_error (input_location, "fopen %s: %m", export_file);
    write_aix_file (exportf, exports.first);
    if (fclose (exportf))
fatal_error (input_location, "fclose %s: %m", export_file);
  }
1769#endif

/* End of arguments to second link phase.  */
*ld2 = (char*) 0;

if (debug)
  {
    fprintf (stderrstderr, "\n========== output_file = %s, c_file = %s\n",
      output_file, c_file);
    write_c_file (stderrstderr, "stderr");
    fprintf (stderrstderr, "========== end of c_file\n\n");
1780#ifdef COLLECT_EXPORT_LIST
    fprintf (stderrstderr, "\n========== export_file = %s\n", export_file);
    write_aix_file (stderrstderr, exports.first);
    fprintf (stderrstderr, "========== end of export_file\n\n");
1784#endif
  }

/* Assemble the constructor and destructor tables.
   Link the tables in with the rest of the program.  */

fork_execute ("gcc",  c_argv, at_file_supplied, "gcc_args");
1791#ifdef COLLECT_EXPORT_LIST
/* On AIX we must call link because of possible templates resolution.  */
do_link (ld2_argv, "ld2_args");

if (lto_mode)
  maybe_run_lto_and_relink (ld2_argv, object_lst, object, false);
1797#else
/* Otherwise, simply call ld because link is already done.  */
if (lto_mode)
  maybe_run_lto_and_relink (ld2_argv, object_lst, object, true);
else
  {
    fork_execute ("ld", ld2_argv, HAVE_GNU_LD1 && at_file_supplied, "ld_args");
    post_ld_pass (/*temp_file*/false);
  }

/* Let scan_prog_file do any final mods (OSF/rose needs this for
   constructors/destructors in shared libraries.  */
scan_prog_file (output_file, PASS_SECOND, SCAN_ALL);
1810#endif

return 0;
1813}

1815
1816/* Unlink FILE unless we are debugging or this is the output_file
 and we may not unlink it.  */

1819void
1820maybe_unlink (const char *file)
1821{
if (save_temps && file_exists (file))
  {
    if (verbose)
notice ("[Leaving %s]\n", file);
    return;
  }

if (file == output_file && !may_unlink_output_file)
  return;

unlink_if_ordinary (file);
1833}

1835/* Call maybe_unlink on the NULL-terminated list, FILE_LIST.  */

1837static void
1838maybe_unlink_list (char **file_list)
1839{
char **tmp = file_list;

while (*tmp)
  maybe_unlink (*(tmp++));
1844}

1846
1847static long sequence_number = 0;

1849/* Add a name to a linked list.  */

1851static void
1852add_to_list (struct head *head_ptr, const char *name)
1853{
struct id *newid
  = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1);
struct id *p;
strcpy (newid->name, name);

if (head_ptr->first)
  head_ptr->last->next = newid;
else
  head_ptr->first = newid;

/* Check for duplicate symbols.  */
for (p = head_ptr->first;
     strcmp (name, p->name) != 0;
     p = p->next)
  ;
if (p != newid)
  {
    head_ptr->last->next = 0;
    free (newid);
    return;
  }

newid->sequence = ++sequence_number;
head_ptr->last = newid;
head_ptr->number++;
1879}

1881/* Grab the init priority number from an init function name that
 looks like "_GLOBAL_.I.12345.foo".  */

1884static int
1885extract_init_priority (const char *name)
1886{
int pos = 0, pri;

1889#ifdef TARGET_AIX_VERSION
/* Run dependent module initializers before any constructors in this
   module.  */
switch (is_ctor_dtor (name))
  {
  case SYM_AIXI:
  case SYM_AIXD:
    return INT_MIN(-2147483647 -1);
  default:
    break;
  }
1900#endif

while (name[pos] == '_')
  ++pos;
pos += 10; /* strlen ("GLOBAL__X_") */

/* Extract init_p number from ctor/dtor name.  */
pri = atoi (name + pos);
return pri ? pri : DEFAULT_INIT_PRIORITY65535;
1909}

1911/* Insertion sort the ids from ctor/dtor list HEAD_PTR in descending order.
 ctors will be run from right to left, dtors from left to right.  */

1914static void
1915sort_ids (struct head *head_ptr)
1916{
/* id holds the current element to insert.  id_next holds the next
   element to insert.  id_ptr iterates through the already sorted elements
   looking for the place to insert id.  */
struct id *id, *id_next, **id_ptr;

id = head_ptr->first;

/* We don't have any sorted elements yet.  */
head_ptr->first = NULL__null;

for (; id; id = id_next)
  {
    id_next = id->next;
    id->sequence = extract_init_priority (id->name);

    for (id_ptr = &(head_ptr->first); ; id_ptr = &((*id_ptr)->next))
if (*id_ptr == NULL__null
   /* If the sequence numbers are the same, we put the id from the
      file later on the command line later in the list.  */
   || id->sequence > (*id_ptr)->sequence
   /* Hack: do lexical compare, too.
   || (id->sequence == (*id_ptr)->sequence
&& strcmp (id->name, (*id_ptr)->name) > 0) */
   )
 {
   id->next = *id_ptr;
   *id_ptr = id;
   break;
 }
  }

/* Now set the sequence numbers properly so write_c_file works.  */
for (id = head_ptr->first; id; id = id->next)
  id->sequence = ++sequence_number;
1951}

1953/* Write: `prefix', the names on list LIST, `suffix'.  */

1955static void
1956write_list (FILE *stream, const char *prefix, struct id *list)
1957{
while (list)
  {
    fprintf (stream, "%sx%d,\n", prefix, list->sequence);
    list = list->next;
  }
1963}

1965#ifdef COLLECT_EXPORT_LIST
1966/* This function is really used only on AIX, but may be useful.  */
1967static int
1968is_in_list (const char *prefix, struct id *list)
1969{
while (list)
  {
    if (!strcmp (prefix, list->name)) return 1;
    list = list->next;
  }
  return 0;
1976}
1977#endif /* COLLECT_EXPORT_LIST */

1979/* Added for debugging purpose.  */
1980#ifdef COLLECT_EXPORT_LIST
1981static void
1982dump_list (FILE *stream, const char *prefix, struct id *list)
1983{
while (list)
  {
    fprintf (stream, "%s%s,\n", prefix, list->name);
    list = list->next;
  }
1989}
1990#endif

1992#if 0
1993static void
1994dump_prefix_list (FILE *stream, const char *prefix, struct prefix_list *list)
1995{
while (list)
  {
    fprintf (stream, "%s%s,\n", prefix, list->prefix);
    list = list->next;
  }
2001}
2002#endif

2004static void
2005write_list_with_asm (FILE *stream, const char *prefix, struct id *list)
2006{
while (list)
  {
    fprintf (stream, "%sx%d __asm__ (\"%s\");\n",
      prefix, list->sequence, list->name);
    list = list->next;
  }
2013}

2015/* Write out the constructor and destructor tables statically (for a shared
 object), along with the functions to execute them.  */

2018static void
2019write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2020{
const char *p, *q;
char *prefix, *r;
int frames = (frame_tables.number > 0);
4
←
Assuming field 'number' is <= 0→

/* Figure out name of output_file, stripping off .so version.  */
q = p = lbasename (output_file);
5
←
Value assigned to 'p'→

while (q)
6
←
Assuming pointer value is null→
7
←
Loop condition is false. Execution continues on line 2048→
  {
    q = strchr (q,'.');
    if (q == 0)
{
 q = p + strlen (p);
 break;
}
    else
{
 if (filename_ncmp (q, SHLIB_SUFFIX".so", strlen (SHLIB_SUFFIX".so")) == 0)
   {
     q += strlen (SHLIB_SUFFIX".so");
     break;
   }
 else
   q++;
}
  }
/* q points to null at end of the string (or . of the .so version) */
prefix = XNEWVEC (char, q - p + 1)((char *) xmalloc (sizeof (char) * (q - p + 1)));
strncpy (prefix, p, q - p);
8
←
Null pointer passed to 2nd parameter expecting 'nonnull'
prefix[q - p] = 0;
for (r = prefix; *r; r++)
  if (!ISALNUM ((unsigned char)*r)(_sch_istable[((unsigned char)*r) & 0xff] & (unsigned
 short)(_sch_isalnum)))
    *r = '_';
if (debug)
  notice ("\nwrite_c_file - output name is %s, prefix is %s\n",
   output_file, prefix);

initname = concat ("_GLOBAL__FI_", prefix, NULL__null);
fininame = concat ("_GLOBAL__FD_", prefix, NULL__null);
2060#ifdef TARGET_AIX_VERSION
aix_shared_initname = concat ("_GLOBAL__AIXI_", prefix, NULL__null);
aix_shared_fininame = concat ("_GLOBAL__AIXD_", prefix, NULL__null);
2063#endif

free (prefix);

/* Write the tables as C code.  */

/* This count variable is used to prevent multiple calls to the
   constructors/destructors.
   This guard against multiple calls is important on AIX as the initfini
   functions are deliberately invoked multiple times as part of the
   mechanisms GCC uses to order constructors across different dependent
   shared libraries (see config/rs6000/aix.h).
 */
fprintf (stream, "static int count;\n");
fprintf (stream, "typedef void entry_pt();\n");
write_list_with_asm (stream, "extern entry_pt ", constructors.first);

if (frames)
  {
    write_list_with_asm (stream, "extern void *", frame_tables.first);

    fprintf (stream, "\tstatic void *frame_table[] = {\n");
    write_list (stream, "\t\t&", frame_tables.first);
    fprintf (stream, "\t0\n};\n");

    /* This must match what's in frame.h.  */
    fprintf (stream, "struct object {\n");
    fprintf (stream, "  void *pc_begin;\n");
    fprintf (stream, "  void *pc_end;\n");
    fprintf (stream, "  void *fde_begin;\n");
    fprintf (stream, "  void *fde_array;\n");
    fprintf (stream, "  __SIZE_TYPE__ count;\n");
    fprintf (stream, "  struct object *next;\n");
    fprintf (stream, "};\n");

    fprintf (stream, "extern void __register_frame_info_table_bases (void *, struct object *, void *tbase, void *dbase);\n");
    fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
    fprintf (stream, "extern void *__deregister_frame_info (void *);\n");
2101#ifdef TARGET_AIX_VERSION
    fprintf (stream, "extern void *__gcc_unwind_dbase;\n");
2103#endif

    fprintf (stream, "static void reg_frame () {\n");
    fprintf (stream, "\tstatic struct object ob;\n");
2107#ifdef TARGET_AIX_VERSION
    /* Use __gcc_unwind_dbase as the base address for data on AIX.
This might not be the start of the segment, signed offsets assumed.
     */
    fprintf (stream, "\t__register_frame_info_table_bases (frame_table, &ob, (void *)0, &__gcc_unwind_dbase);\n");
2112#else
    fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
2114#endif
    fprintf (stream, "\t}\n");

    fprintf (stream, "static void dereg_frame () {\n");
    fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
    fprintf (stream, "\t}\n");
  }

2122#ifdef COLLECT_EXPORT_LIST
/* Set visibility of initializers to default.  */
if (visibility_flag)
  fprintf (stream, "#pragma GCC visibility push(default)\n");
2126#endif
fprintf (stream, "void %s() {\n", initname);
if (constructors.number > 0 || frames)
  {
    fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
    write_list (stream, "\t\t", constructors.first);
    if (frames)
fprintf (stream, "\treg_frame,\n");
    fprintf (stream, "\t};\n");
    fprintf (stream, "\tentry_pt **p;\n");
    fprintf (stream, "\tif (count++ != 0) return;\n");
    fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
    fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
  }
else
  fprintf (stream, "\t++count;\n");
fprintf (stream, "}\n");
write_list_with_asm (stream, "extern entry_pt ", destructors.first);
fprintf (stream, "void %s() {\n", fininame);
if (destructors.number > 0 || frames)
  {
    fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
    write_list (stream, "\t\t", destructors.first);
    if (frames)
fprintf (stream, "\tdereg_frame,\n");
    fprintf (stream, "\t};\n");
    fprintf (stream, "\tentry_pt **p;\n");
    fprintf (stream, "\tif (--count != 0) return;\n");
    fprintf (stream, "\tp = dtors;\n");
    fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
      destructors.number + frames);
  }
fprintf (stream, "}\n");
2159#ifdef COLLECT_EXPORT_LIST
if (visibility_flag)
  fprintf (stream, "#pragma GCC visibility pop\n");
2162#endif

if (shared_obj)
  {
2166#ifdef COLLECT_EXPORT_LIST
    /* Set visibility of initializers to default.  */
    if (visibility_flag)
fprintf (stream, "#pragma GCC visibility push(default)\n");
2170#endif
    COLLECT_SHARED_INIT_FUNC (stream, initname)fprintf ((stream), "void _GLOBAL__DI() {\n\t%s();\n}\n", (initname
));
    COLLECT_SHARED_FINI_FUNC (stream, fininame)fprintf ((stream), "void _GLOBAL__DD() {\n\t%s();\n}\n", (fininame
));
2173#ifdef COLLECT_EXPORT_LIST
    if (visibility_flag)
fprintf (stream, "#pragma GCC visibility pop\n");
2176#endif
  }
2178}

2180/* Write the constructor/destructor tables.  */

2182#ifndef LD_INIT_SWITCH
2183static void
2184write_c_file_glob (FILE *stream, const char *name ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2185{
/* Write the tables as C code.  */

int frames = (frame_tables.number > 0);

fprintf (stream, "typedef void entry_pt();\n\n");

write_list_with_asm (stream, "extern entry_pt ", constructors.first);

if (frames)
  {
    write_list_with_asm (stream, "extern void *", frame_tables.first);

    fprintf (stream, "\tstatic void *frame_table[] = {\n");
    write_list (stream, "\t\t&", frame_tables.first);
    fprintf (stream, "\t0\n};\n");

    /* This must match what's in frame.h.  */
    fprintf (stream, "struct object {\n");
    fprintf (stream, "  void *pc_begin;\n");
    fprintf (stream, "  void *pc_end;\n");
    fprintf (stream, "  void *fde_begin;\n");
    fprintf (stream, "  void *fde_array;\n");
    fprintf (stream, "  __SIZE_TYPE__ count;\n");
    fprintf (stream, "  struct object *next;\n");
    fprintf (stream, "};\n");

    fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
    fprintf (stream, "extern void *__deregister_frame_info (void *);\n");

    fprintf (stream, "static void reg_frame () {\n");
    fprintf (stream, "\tstatic struct object ob;\n");
    fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
    fprintf (stream, "\t}\n");

    fprintf (stream, "static void dereg_frame () {\n");
    fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
    fprintf (stream, "\t}\n");
  }

fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
write_list (stream, "\t", constructors.first);
if (frames)
  fprintf (stream, "\treg_frame,\n");
fprintf (stream, "\t0\n};\n\n");

write_list_with_asm (stream, "extern entry_pt ", destructors.first);

fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
write_list (stream, "\t", destructors.first);
if (frames)
  fprintf (stream, "\tdereg_frame,\n");
fprintf (stream, "\t0\n};\n\n");

fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN"__main");
fprintf (stream, "entry_pt *__main_reference = %s;\n\n", NAME__MAIN"__main");
2243}
2244#endif /* ! LD_INIT_SWITCH */

2246static void
2247write_c_file (FILE *stream, const char *name)
2248{
2249#ifndef LD_INIT_SWITCH
if (! shared_obj)
1
Assuming 'shared_obj' is not equal to 0→
2
←
Taking false branch→
  write_c_file_glob (stream, name);
else
2253#endif
  write_c_file_stat (stream, name);
3
←
Calling 'write_c_file_stat'→
2255}

2257#ifdef COLLECT_EXPORT_LIST
2258static void
2259write_aix_file (FILE *stream, struct id *list)
2260{
for (; list; list = list->next)
  {
    fputs (list->name, stream);
    putc ('\n', stream);
  }
2266}
2267#endif
2268
2269#ifdef OBJECT_FORMAT_NONE

2271/* Check to make sure the file is an LTO object file.  */

2273static int
2274has_lto_section (void *data, const char *name ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 off_t offset ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 off_t length ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
2277{
int *found = (int *) data;

if (!startswith (name, LTO_SECTION_NAME_PREFIX".gnu.lto_")
    && !startswith (name, OFFLOAD_SECTION_NAME_PREFIX".gnu.offload_lto_"))
  return 1;

*found = 1;

/* Stop iteration.  */
return 0;
2288}

2290static bool
2291is_lto_object_file (const char *prog_name)
2292{
const char *errmsg;
int err;
int found = 0;
off_t inoff = 0;
int infd = open (prog_name, O_RDONLY00 | O_BINARY0);

if (infd == -1)
  return false;

simple_object_read *inobj = simple_object_start_read (infd, inoff,
					LTO_SEGMENT_NAME"__GNU_LTO",
					&errmsg, &err);
if (!inobj)
  {
    close (infd);
    return false;
  }

errmsg = simple_object_find_sections (inobj, has_lto_section,
			(void *) &found, &err);
simple_object_release_read (inobj);
close (infd);
if (! errmsg && found)
  return true;

if (errmsg)
  fatal_error (0, "%s: %s", errmsg, xstrerror (err));
return false;
2321}

2323/* Generic version to scan the name list of the loaded program for
 the symbols g++ uses for static constructors and destructors.  */

2326static void
2327scan_prog_file (const char *prog_name, scanpass which_pass,
scanfilter filter)
2329{
void (*int_handler) (int);
2331#ifdef SIGQUIT3
void (*quit_handler) (int);
2333#endif
char *real_nm_argv[4];
const char **nm_argv = CONST_CAST2 (const char **, char**, real_nm_argv)(const_cast<const char **> (real_nm_argv));
int argc = 0;
struct pex_obj *pex;
const char *errmsg;
int err;
char *p, buf[1024];
FILE *inf;

if (which_pass == PASS_SECOND)
  return;

/* LTO objects must be in a known format.  This check prevents
   us from accepting an archive containing LTO objects, which
   gcc cannot currently handle.  */
if (which_pass == PASS_LTOINFO)
  {
    if(is_lto_object_file (prog_name)) {
add_lto_object (&lto_objects, prog_name);
    }
    return;
  }

/* If we do not have an `nm', complain.  */
if (nm_file_name == 0)
  fatal_error (input_location, "cannot find %<nm%>");

nm_argv[argc++] = nm_file_name;
if (NM_FLAGS"-n"[0] != '\0')
  nm_argv[argc++] = NM_FLAGS"-n";

nm_argv[argc++] = prog_name;
nm_argv[argc++] = (char *) 0;

/* Trace if needed.  */
if (verbose)
  {
    const char **p_argv;
    const char *str;

    for (p_argv = &nm_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
fprintf (stderrstderr, " %s", str);

    fprintf (stderrstderr, "\n");
  }

fflush (stdoutstdout);
fflush (stderrstderr);

pex = pex_init (PEX_USE_PIPES0x2, "collect2", NULL__null);
if (pex == NULL__null)
  fatal_error (input_location, "%<pex_init%> failed: %m");

errmsg = pex_run (pex, 0, nm_file_name, real_nm_argv, NULL__null, HOST_BIT_BUCKET"/dev/null",
    &err);
if (errmsg != NULL__null)
  {
    if (err != 0)
{
 errno(*__errno_location ()) = err;
 fatal_error (input_location, "%s: %m", _(errmsg)gettext (errmsg));
}
    else
fatal_error (input_location, errmsg);
  }

int_handler  = (void (*) (int)) signal (SIGINT2,  SIG_IGN((__sighandler_t) 1));
2401#ifdef SIGQUIT3
quit_handler = (void (*) (int)) signal (SIGQUIT3, SIG_IGN((__sighandler_t) 1));
2403#endif

inf = pex_read_output (pex, 0);
if (inf == NULL__null)
  fatal_error (input_location, "cannot open nm output: %m");

if (debug)
  fprintf (stderrstderr, "\nnm output with constructors/destructors.\n");

/* Read each line of nm output.  */
while (fgets (buf, sizeof buf, inf) != (char *) 0)
  {
    int ch, ch2;
    char *name, *end;

    if (debug)
      fprintf (stderrstderr, "\t%s\n", buf);

    /* If it contains a constructor or destructor name, add the name
to the appropriate list unless this is a kind of symbol we're
not supposed to even consider.  */

    for (p = buf; (ch = *p) != '\0' && ch != '\n' && ch != '_'; p++)
if (ch == ' ' && p[1] == 'U' && p[2] == ' ')
 break;

    if (ch != '_')
continue;

    name = p;
    /* Find the end of the symbol name.
Do not include `|', because Encore nm can tack that on the end.  */
    for (end = p; (ch2 = *end) != '\0' && !ISSPACE (ch2)(_sch_istable[(ch2) & 0xff] & (unsigned short)(_sch_isspace
)) && ch2 != '|';
  end++)
continue;


    *end = '\0';

    switch (is_ctor_dtor (name))
{
case SYM_CTOR:
 if (! (filter & SCAN_CTOR))
   break;
 if (which_pass != PASS_LIB)
   add_to_list (&constructors, name);
 break;

case SYM_DTOR:
 if (! (filter & SCAN_DTOR))
   break;
 if (which_pass != PASS_LIB)
   add_to_list (&destructors, name);
 break;

case SYM_INIT:
 if (! (filter & SCAN_INIT))
   break;
 if (which_pass != PASS_LIB)
   fatal_error (input_location, "init function found in object %s",
	 prog_name);
2464#ifndef LD_INIT_SWITCH
 add_to_list (&constructors, name);
2466#endif
 break;

case SYM_FINI:
 if (! (filter & SCAN_FINI))
   break;
 if (which_pass != PASS_LIB)
   fatal_error (input_location, "fini function found in object %s",
	 prog_name);
2475#ifndef LD_FINI_SWITCH
 add_to_list (&destructors, name);
2477#endif
 break;

case SYM_DWEH:
 if (! (filter & SCAN_DWEH))
   break;
 if (which_pass != PASS_LIB)
   add_to_list (&frame_tables, name);
 break;

default:		/* not a constructor or destructor */
 continue;
}
  }

if (debug)
  fprintf (stderrstderr, "\n");

do_wait (nm_file_name, pex);

signal (SIGINT2,  int_handler);
2498#ifdef SIGQUIT3
signal (SIGQUIT3, quit_handler);
2500#endif
2501}

2503#ifdef LDD_SUFFIX

2505/* Use the List Dynamic Dependencies program to find shared libraries that
 the output file depends upon and their initialization/finalization
 routines, if any.  */

2509static void
2510scan_libraries (const char *prog_name)
2511{
static struct head libraries;		/* list of shared libraries found */
struct id *list;
void (*int_handler) (int);
2515#ifdef SIGQUIT3
void (*quit_handler) (int);
2517#endif
char *real_ldd_argv[4];
const char **ldd_argv = CONST_CAST2 (const char **, char **, real_ldd_argv)(const_cast<const char **> (real_ldd_argv));
int argc = 0;
struct pex_obj *pex;
const char *errmsg;
int err;
char buf[1024];
FILE *inf;

/* If we do not have an `ldd', complain.  */
if (ldd_file_name == 0)
  {
    error ("cannot find %<ldd%>");
    return;
  }

ldd_argv[argc++] = ldd_file_name;
ldd_argv[argc++] = prog_name;
ldd_argv[argc++] = (char *) 0;

/* Trace if needed.  */
if (verbose)
  {
    const char **p_argv;
    const char *str;

    for (p_argv = &ldd_argv[0]; (str = *p_argv) != (char *) 0; p_argv++)
fprintf (stderrstderr, " %s", str);

    fprintf (stderrstderr, "\n");
  }

fflush (stdoutstdout);
fflush (stderrstderr);

pex = pex_init (PEX_USE_PIPES0x2, "collect2", NULL__null);
if (pex == NULL__null)
  fatal_error (input_location, "%<pex_init%> failed: %m");

errmsg = pex_run (pex, 0, ldd_file_name, real_ldd_argv, NULL__null, NULL__null, &err);
if (errmsg != NULL__null)
  {
    if (err != 0)
{
 errno(*__errno_location ()) = err;
 fatal_error (input_location, "%s: %m", _(errmsg)gettext (errmsg));
}
    else
fatal_error (input_location, errmsg);
  }

int_handler  = (void (*) (int)) signal (SIGINT2,  SIG_IGN((__sighandler_t) 1));
2570#ifdef SIGQUIT3
quit_handler = (void (*) (int)) signal (SIGQUIT3, SIG_IGN((__sighandler_t) 1));
2572#endif

inf = pex_read_output (pex, 0);
if (inf == NULL__null)
  fatal_error (input_location, "cannot open ldd output: %m");

if (debug)
  notice ("\nldd output with constructors/destructors.\n");

/* Read each line of ldd output.  */
while (fgets (buf, sizeof buf, inf) != (char *) 0)
  {
    int ch2;
    char *name, *end, *p = buf;

    /* Extract names of libraries and add to list.  */
    PARSE_LDD_OUTPUT (p);
    if (p == 0)
continue;

    name = p;
    if (startswith (name, "not found"))
fatal_error (input_location, "dynamic dependency %s not found", buf);

    /* Find the end of the symbol name.  */
    for (end = p;
  (ch2 = *end) != '\0' && ch2 != '\n' && !ISSPACE (ch2)(_sch_istable[(ch2) & 0xff] & (unsigned short)(_sch_isspace
)) && ch2 != '|';
  end++)
continue;
    *end = '\0';

    if (access (name, R_OK4) == 0)
add_to_list (&libraries, name);
    else
fatal_error (input_location, "unable to open dynamic dependency "
     "%qs", buf);

    if (debug)
fprintf (stderrstderr, "\t%s\n", buf);
  }
if (debug)
  fprintf (stderrstderr, "\n");

do_wait (ldd_file_name, pex);

signal (SIGINT2,  int_handler);
2618#ifdef SIGQUIT3
signal (SIGQUIT3, quit_handler);
2620#endif

/* Now iterate through the library list adding their symbols to
   the list.  */
for (list = libraries.first; list; list = list->next)
  scan_prog_file (list->name, PASS_LIB, SCAN_ALL);
2626}

2628#endif /* LDD_SUFFIX */

2630#endif /* OBJECT_FORMAT_NONE */

2632
2633/*
* COFF specific stuff.
*/

2637#ifdef OBJECT_FORMAT_COFF

2639#   define GCC_SYMBOLS(X)	(HEADER (ldptr).f_nsyms)
2640#   define GCC_SYMENT		SYMENT
2641#   if defined (C_WEAKEXT)
2642#     define GCC_OK_SYMBOL(X) \
     (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
((X).n_scnum > N_UNDEF) && \
(aix64_flag \
|| (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
    || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2648#     define GCC_UNDEF_SYMBOL(X) \
     (((X).n_sclass == C_EXT || (X).n_sclass == C_WEAKEXT) && \
((X).n_scnum == N_UNDEF))
2651#   else
2652#     define GCC_OK_SYMBOL(X) \
     (((X).n_sclass == C_EXT) && \
((X).n_scnum > N_UNDEF) && \
(aix64_flag \
|| (((X).n_type & N_TMASK) == (DT_NON << N_BTSHFT) \
    || ((X).n_type & N_TMASK) == (DT_FCN << N_BTSHFT))))
2658#     define GCC_UNDEF_SYMBOL(X) \
     (((X).n_sclass == C_EXT) && ((X).n_scnum == N_UNDEF))
2660#   endif
2661#   define GCC_SYMINC(X)	((X).n_numaux+1)
2662#   define GCC_SYMZERO(X)	0

2664/* 0757 = U803XTOCMAGIC (AIX 4.3) and 0767 = U64_TOCMAGIC (AIX V5) */
2665#if TARGET_AIX_VERSION >= 51
2666#   define GCC_CHECK_HDR(X) \
   (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
     || (HEADER (X).f_magic == 0767 && aix64_flag)) \
    && !(HEADER (X).f_flags & F_LOADONLY))
2670#else
2671#   define GCC_CHECK_HDR(X) \
   (((HEADER (X).f_magic == U802TOCMAGIC && ! aix64_flag) \
     || (HEADER (X).f_magic == 0757 && aix64_flag)) \
    && !(HEADER (X).f_flags & F_LOADONLY))
2675#endif

2677#ifdef COLLECT_EXPORT_LIST
2678/* Array of standard AIX libraries which should not
 be scanned for ctors/dtors.  */
2680static const char *const aix_std_libs[] = {
"/unix",
"/lib/libc.a",
"/lib/libm.a",
"/lib/libc_r.a",
"/lib/libm_r.a",
"/usr/lib/libc.a",
"/usr/lib/libm.a",
"/usr/lib/libc_r.a",
"/usr/lib/libm_r.a",
"/usr/lib/threads/libc.a",
"/usr/ccs/lib/libc.a",
"/usr/ccs/lib/libm.a",
"/usr/ccs/lib/libc_r.a",
"/usr/ccs/lib/libm_r.a",
NULL__null
2696};

2698/* This function checks the filename and returns 1
 if this name matches the location of a standard AIX library.  */
2700static int ignore_library (const char *);
2701static int
2702ignore_library (const char *name)
2703{
const char *const *p;
size_t length;

if (target_system_root[0] != '\0')
  {
    length = strlen (target_system_root);
    if (strncmp (name, target_system_root, length) != 0)
return 0;
    name += length;
  }
for (p = &aix_std_libs[0]; *p != NULL__null; ++p)
  if (strcmp (name, *p) == 0)
    return 1;
return 0;
2718}
2719#endif /* COLLECT_EXPORT_LIST */

2721#if defined (HAVE_DECL_LDGETNAME0) && !HAVE_DECL_LDGETNAME0
2722extern char *ldgetname (LDFILE *, GCC_SYMENT *);
2723#endif

2725/* COFF version to scan the name list of the loaded program for
 the symbols g++ uses for static constructors and destructors.  */

2728static void
2729scan_prog_file (const char *prog_name, scanpass which_pass,
scanfilter filter)
2731{
LDFILE *ldptr = NULL__null;
int sym_index, sym_count;
int is_shared = 0;

if (which_pass != PASS_FIRST && which_pass != PASS_OBJ)
  return;

2739#ifdef COLLECT_EXPORT_LIST
/* We do not need scanning for some standard C libraries.  */
if (which_pass == PASS_FIRST && ignore_library (prog_name))
  return;

/* On AIX we have a loop, because there is not much difference
   between an object and an archive. This trick allows us to
   eliminate scan_libraries() function.  */
do
  {
2749#endif
    /* Some platforms (e.g. OSF4) declare ldopen as taking a
non-const char * filename parameter, even though it will not
modify that string.  So we must cast away const-ness here,
using CONST_CAST to prevent complaints from -Wcast-qual.  */
    if ((ldptr = ldopen (CONST_CAST (char *, prog_name)(const_cast<char *> ((prog_name))), ldptr)) != NULL__null)
{
 if (! MY_ISCOFF (HEADER (ldptr).f_magic))
   {
     warning (0, "%s: not a COFF file", prog_name);
     continue;
   }

 if (GCC_CHECK_HDR (ldptr))
   {
     sym_count = GCC_SYMBOLS (ldptr);
     sym_index = GCC_SYMZERO (ldptr);

2767#ifdef COLLECT_EXPORT_LIST
     /* Is current archive member a shared object?  */
     is_shared = HEADER (ldptr).f_flags & F_SHROBJ;
2770#endif

     while (sym_index < sym_count)
{
  GCC_SYMENT symbol;

  if (ldtbread (ldptr, sym_index, &symbol) <= 0)
    break;
  sym_index += GCC_SYMINC (symbol);

  if (GCC_OK_SYMBOL (symbol))
    {
      char *name;

      if ((name = ldgetname (ldptr, &symbol)) == NULL__null)
	continue;		/* Should never happen.  */

2787#ifdef XCOFF_DEBUGGING_INFO
      /* All AIX function names have a duplicate entry
	 beginning with a dot.  */
      if (*name == '.')
	++name;
2792#endif

      switch (is_ctor_dtor (name))
	{
2796#if TARGET_AIX_VERSION
      /* Add AIX shared library initalisers/finalisers
	 to the constructors/destructors list of the
	 current module.  */
	case SYM_AIXI:
	  if (! (filter & SCAN_CTOR))
	    break;
	  if (is_shared && !aixlazy_flag
2804#ifdef COLLECT_EXPORT_LIST
	      && ! static_obj
	      && ! is_in_list (prog_name, static_libs.first)
2807#endif
	      )
	    add_to_list (&constructors, name);
	  break;

	case SYM_AIXD:
	  if (! (filter & SCAN_DTOR))
	    break;
	  if (is_shared && !aixlazy_flag)
	    add_to_list (&destructors, name);
	  break;
2818#endif

	case SYM_CTOR:
	  if (! (filter & SCAN_CTOR))
	    break;
	  if (! is_shared)
	    add_to_list (&constructors, name);
2825#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
	  if (which_pass == PASS_OBJ)
	    add_to_list (&exports, name);
2828#endif
	  break;

	case SYM_DTOR:
	  if (! (filter & SCAN_DTOR))
	    break;
	  if (! is_shared)
	    add_to_list (&destructors, name);
2836#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
	  if (which_pass == PASS_OBJ)
	    add_to_list (&exports, name);
2839#endif
	  break;

2842#ifdef COLLECT_EXPORT_LIST
	case SYM_INIT:
	  if (! (filter & SCAN_INIT))
	    break;
2846#ifndef LD_INIT_SWITCH
	  if (is_shared)
	    add_to_list (&constructors, name);
2849#endif
	  break;

	case SYM_FINI:
	  if (! (filter & SCAN_FINI))
	    break;
2855#ifndef LD_INIT_SWITCH
	  if (is_shared)
	    add_to_list (&destructors, name);
2858#endif
	  break;
2860#endif

	case SYM_DWEH:
	  if (! (filter & SCAN_DWEH))
	    break;
	  if (! is_shared)
	    add_to_list (&frame_tables, name);
2867#if defined (COLLECT_EXPORT_LIST) && !defined (LD_INIT_SWITCH)
	  if (which_pass == PASS_OBJ)
	    add_to_list (&exports, name);
2870#endif
	  break;

	default:	/* not a constructor or destructor */
2874#ifdef COLLECT_EXPORT_LIST
	  /* Explicitly export all global symbols when
	     building a shared object on AIX, but do not
	     re-export symbols from another shared object
	     and do not export symbols if the user
	     provides an explicit export list.  */
	  if (shared_obj && !is_shared
	      && which_pass == PASS_OBJ && !export_flag)
	    {
	      /* Do not auto-export __dso_handle or
		 __gcc_unwind_dbase.  They are required
		 to be local to each module.  */
	      if (strcmp(name, "__dso_handle") != 0
		  && strcmp(name, "__gcc_unwind_dbase") != 0)
		{
		  add_to_list (&exports, name);
		}
	    }
2892#endif
	  continue;
	}

      if (debug)
	fprintf (stderrstderr, "\tsec=%d class=%d type=%s%o %s\n",
		 symbol.n_scnum, symbol.n_sclass,
		 (symbol.n_type ? "0" : ""), symbol.n_type,
		 name);
    }
}
   }
2904#ifdef COLLECT_EXPORT_LIST
 else
   {
     /* If archive contains both 32-bit and 64-bit objects,
 we want to skip objects in other mode so mismatch normal.  */
     if (debug)
fprintf (stderrstderr, "%s : magic=%o aix64=%d mismatch\n",
	 prog_name, HEADER (ldptr).f_magic, aix64_flag);
   }
2913#endif
}
    else
{
 fatal_error (input_location, "%s: cannot open as COFF file",
       prog_name);
}
2920#ifdef COLLECT_EXPORT_LIST
    /* On AIX loop continues while there are more members in archive.  */
  }
while (ldclose (ldptr) == FAILURE);
2924#else
/* Otherwise we simply close ldptr.  */
(void) ldclose (ldptr);
2927#endif
2928}
2929#endif /* OBJECT_FORMAT_COFF */

2931#ifdef COLLECT_EXPORT_LIST
2932/* Given a library name without "lib" prefix, this function
 returns a full library name including a path.  */
2934static char *
2935resolve_lib_name (const char *name)
2936{
char *lib_buf;
int i, j, l = 0;
/* Library extensions for AIX dynamic linking.  */
const char * const libexts[2] = {"a", "so"};

for (i = 0; libpaths[i]; i++)
  if (libpaths[i]->max_len > l)
    l = libpaths[i]->max_len;

lib_buf = XNEWVEC (char, l + strlen (name) + 10)((char *) xmalloc (sizeof (char) * (l + strlen (name) + 10)));

for (i = 0; libpaths[i]; i++)
  {
    struct prefix_list *list = libpaths[i]->plist;
    for (; list; list = list->next)
{
 /* The following lines are needed because path_prefix list
    may contain directories both with trailing DIR_SEPARATOR and
    without it.  */
 const char *p = "";
 if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1])(((list->prefix[strlen (list->prefix)-1]) == '/') || ((
(list->prefix[strlen (list->prefix)-1]) == '\\') &&
 (0))))
   p = "/";
 for (j = 0; j < 2; j++)
   {
     sprintf (lib_buf, "%s%slib%s.%s",
       list->prefix, p, name,
       libexts[(j + aixrtl_flag) % 2]);
     if (debug) fprintf (stderrstderr, "searching for: %s\n", lib_buf);
     if (file_exists (lib_buf))
{
  if (debug) fprintf (stderrstderr, "found: %s\n", lib_buf);
  return (lib_buf);
}
   }
}
  }
if (debug)
  fprintf (stderrstderr, "not found\n");
else
  fatal_error (input_location, "library lib%s not found", name);
return (NULL__null);
2978}
2979#endif /* COLLECT_EXPORT_LIST */

2981#ifdef COLLECT_RUN_DSYMUTIL
2982static int flag_dsym = false;
2983static int flag_idsym = false;

2985static void
2986process_args (int *argcp, char **argv) {
int i, j;
int argc = *argcp;
for (i=0; i<argc; ++i)
  {
    if (strcmp (argv[i], "-dsym") == 0)
{
 flag_dsym = true;
 /* Remove the flag, as we handle all processing for it.  */
 j = i;
 do
   argv[j] = argv[j+1];
 while (++j < argc);
 --i;
 argc = --(*argcp);
}
    else if (strcmp (argv[i], "-idsym") == 0)
{
 flag_idsym = true;
 /* Remove the flag, as we handle all processing for it.  */
 j = i;
 do
   argv[j] = argv[j+1];
 while (++j < argc);
 --i;
 argc = --(*argcp);
}
  }
3014}

3016static void
3017do_dsymutil (const char *output_file) {
const char *dsymutil = 0;
struct pex_obj *pex;
char **real_argv = XCNEWVEC (char *, verbose ? 4 : 3)((char * *) xcalloc ((verbose ? 4 : 3), sizeof (char *)));
const char ** argv = CONST_CAST2 (const char **, char **,(const_cast<const char **> (real_argv))
		    real_argv)(const_cast<const char **> (real_argv));
3023/* For cross-builds search the PATH using target-qualified name if we
 have not already found a suitable dsymutil.  In practice, all modern
 versions of dsymutil handle all supported archs, however the approach
 here is consistent with the way other installations work (and one can
 always symlink a multitarget dsymutil with a target-specific name).  */
const char *dsname = "dsymutil";
3029#ifdef CROSS_DIRECTORY_STRUCTURE
const char *qname = concat (target_machine, "-", dsname, NULL__null);
3031#else
const char *qname = dsname;
3033#endif
3034#ifdef DEFAULT_DSYMUTIL
/* Configured default takes priority.  */
if (dsymutil == 0 && access (DEFAULT_DSYMUTIL, X_OK1) == 0)
  dsymutil = DEFAULT_DSYMUTIL;
if (dsymutil == 0)
3039#endif
3040#ifdef DSYMUTIL
/* Followed by one supplied in the target header, somewhat like the
   REAL_XX_NAME used elsewhere.  */
  dsymutil = find_a_file (&cpath, DSYMUTIL, X_OK1);
if (dsymutil == 0)
  dsymutil = find_a_file (&path, DSYMUTIL, X_OK1);
if (dsymutil == 0)
3047#endif
  dsymutil = find_a_file (&cpath, dsname, X_OK1);
if (dsymutil == 0)
  dsymutil = find_a_file (&path, qname, X_OK1);

argv[0] = dsymutil;
argv[1] = output_file;
if (verbose)
  {
    argv[2] = "-v";
    argv[3] = (char *) 0;
  }
else
  argv[2] = (char *) 0;

pex = collect_execute (dsymutil, real_argv, NULL__null, NULL__null,
	 PEX_LAST0x1 | PEX_SEARCH0x2, false, NULL__null);
do_wait (dsymutil, pex);
3065}

3067static void
3068post_ld_pass (bool temp_file) {
if (!(temp_file && flag_idsym) && !flag_dsym)
  return;
    
do_dsymutil (output_file);
3073}
3074#else
3075static void
3076process_args (int *argcp ATTRIBUTE_UNUSED__attribute__ ((__unused__)), char **argv ATTRIBUTE_UNUSED__attribute__ ((__unused__))) { }
3077static void post_ld_pass (bool temp_file ATTRIBUTE_UNUSED__attribute__ ((__unused__))) { }
3078#endif