Home | History | Annotate | Download | only in src
      1 /* Copyright (C) 2001, 2002, 2003, 2004 Red Hat, Inc.
      2    Written by Ulrich Drepper <drepper (at) redhat.com>, 2001.
      3 
      4    This program is Open Source software; you can redistribute it and/or
      5    modify it under the terms of the Open Software License version 1.0 as
      6    published by the Open Source Initiative.
      7 
      8    You should have received a copy of the Open Software License along
      9    with this program; if not, you may obtain a copy of the Open Software
     10    License version 1.0 from http://www.opensource.org/licenses/osl.php or
     11    by writing the Open Source Initiative c/o Lawrence Rosen, Esq.,
     12    3001 King Ranch Road, Ukiah, CA 95482.   */
     13 
     14 #ifdef HAVE_CONFIG_H
     15 # include <config.h>
     16 #endif
     17 
     18 #include <assert.h>
     19 #include <dlfcn.h>
     20 #include <errno.h>
     21 #include <error.h>
     22 #include <fcntl.h>
     23 #include <fnmatch.h>
     24 #include <gelf.h>
     25 #include <inttypes.h>
     26 #include <libintl.h>
     27 #include <stdbool.h>
     28 #include <stdio_ext.h>
     29 #include <stdlib.h>
     30 #include <string.h>
     31 #include <unistd.h>
     32 #include <sys/param.h>
     33 #include <sys/stat.h>
     34 
     35 #include <system.h>
     36 #include "ld.h"
     37 #include "list.h"
     38 
     39 
     40 /* Prototypes for local functions.  */
     41 static const char **ld_generic_lib_extensions (struct ld_state *)
     42      __attribute__ ((__const__));
     43 static int ld_generic_file_close (struct usedfiles *fileinfo,
     44 				  struct ld_state *statep);
     45 static int ld_generic_file_process (int fd, struct usedfiles *fileinfo,
     46 				    struct ld_state *statep,
     47 				    struct usedfiles **nextp);
     48 static void ld_generic_generate_sections (struct ld_state *statep);
     49 static void ld_generic_create_sections (struct ld_state *statep);
     50 static int ld_generic_flag_unresolved (struct ld_state *statep);
     51 static int ld_generic_open_outfile (struct ld_state *statep, int machine,
     52 				    int class, int data);
     53 static int ld_generic_create_outfile (struct ld_state *statep);
     54 static void ld_generic_relocate_section (struct ld_state *statep,
     55 					 Elf_Scn *outscn,
     56 					 struct scninfo *firstp,
     57 					 const Elf32_Word *dblindirect);
     58 static int ld_generic_finalize (struct ld_state *statep);
     59 static bool ld_generic_special_section_number_p (struct ld_state *statep,
     60 						 size_t number);
     61 static bool ld_generic_section_type_p (struct ld_state *statep,
     62 				       XElf_Word type);
     63 static XElf_Xword ld_generic_dynamic_section_flags (struct ld_state *statep);
     64 static void ld_generic_initialize_plt (struct ld_state *statep, Elf_Scn *scn);
     65 static void ld_generic_initialize_pltrel (struct ld_state *statep,
     66 					  Elf_Scn *scn);
     67 static void ld_generic_initialize_got (struct ld_state *statep, Elf_Scn *scn);
     68 static void ld_generic_finalize_plt (struct ld_state *statep, size_t nsym,
     69 				     size_t nsym_dyn);
     70 static int ld_generic_rel_type (struct ld_state *statep);
     71 static void ld_generic_count_relocations (struct ld_state *statep,
     72 					  struct scninfo *scninfo);
     73 static void ld_generic_create_relocations (struct ld_state *statep,
     74 					   const Elf32_Word *dblindirect);
     75 
     76 static int file_process2 (struct usedfiles *fileinfo);
     77 static void mark_section_used (struct scninfo *scninfo, Elf32_Word shndx,
     78 			       struct scninfo **grpscnp);
     79 
     80 
     81 /* Map symbol index to struct symbol record.  */
     82 static struct symbol **ndxtosym;
     83 
     84 /* String table reference to all symbols in the symbol table.  */
     85 static struct Ebl_Strent **symstrent;
     86 
     87 
     88 /* Check whether file associated with FD is a DSO.  */
     89 static bool
     90 is_dso_p (int fd)
     91 {
     92   /* We have to read the 'e_type' field.  It has the same size (16
     93      bits) in 32- and 64-bit ELF.  */
     94   XElf_Half e_type;
     95 
     96   return (pread (fd, &e_type, sizeof (e_type), offsetof (XElf_Ehdr, e_type))
     97 	  == sizeof (e_type)
     98 	  && e_type == ET_DYN);
     99 }
    100 
    101 
    102 /* Print the complete name of a file, including the archive it is
    103    contained in.  */
    104 static int
    105 print_file_name (FILE *s, struct usedfiles *fileinfo, int first_level,
    106 		 int newline)
    107 {
    108   int npar = 0;
    109 
    110   if (fileinfo->archive_file != NULL)
    111     {
    112       npar = print_file_name (s, fileinfo->archive_file, 0, 0) + 1;
    113       fputc_unlocked ('(', s);
    114       fputs_unlocked (fileinfo->rfname, s);
    115 
    116       if (first_level)
    117 	while (npar-- > 0)
    118 	  fputc_unlocked (')', s);
    119     }
    120   else
    121     fputs_unlocked (fileinfo->rfname, s);
    122 
    123   if (first_level && newline)
    124     fputc_unlocked ('\n', s);
    125 
    126   return npar;
    127 }
    128 
    129 
    130 /* Function to determine whether an object will be dynamically linked.  */
    131 bool
    132 dynamically_linked_p (void)
    133 {
    134   return (ld_state.file_type == dso_file_type || ld_state.nplt > 0
    135 	  || ld_state.ngot > 0);
    136 }
    137 
    138 
    139 bool
    140 linked_from_dso_p (struct scninfo *scninfo, int symidx)
    141 {
    142   struct usedfiles *file = scninfo->fileinfo;
    143 
    144   /* If this symbol is not undefined in this file it cannot come from
    145      a DSO.  */
    146   if (symidx < file->nlocalsymbols)
    147     return false;
    148 
    149   struct symbol *sym = file->symref[symidx];
    150 
    151   return sym->defined && sym->in_dso;
    152 }
    153 
    154 
    155 /* Initialize state object.  This callback function is called after the
    156    parameters are parsed but before any file is searched for.  */
    157 int
    158 ld_prepare_state (const char *emulation)
    159 {
    160   /* When generating DSO we normally allow undefined symbols.  */
    161   ld_state.nodefs = true;
    162 
    163   /* To be able to detect problems we add a .comment section entry by
    164      default.  */
    165   ld_state.add_ld_comment = true;
    166 
    167   /* XXX We probably should find a better place for this.  The index
    168      of the first user-defined version is 2.  */
    169   ld_state.nextveridx = 2;
    170 
    171   /* Pick an not too small number for the initial size of the tables.  */
    172   ld_symbol_tab_init (&ld_state.symbol_tab, 1027);
    173   ld_section_tab_init (&ld_state.section_tab, 67);
    174   ld_version_str_tab_init (&ld_state.version_str_tab, 67);
    175 
    176   /* Initialize the section header string table.  */
    177   ld_state.shstrtab = ebl_strtabinit (true);
    178   if (ld_state.shstrtab == NULL)
    179     error (EXIT_FAILURE, errno, gettext ("cannot create string table"));
    180 
    181   /* Initialize the callbacks.  These are the defaults, the appropriate
    182      backend can later install its own callbacks.  */
    183   ld_state.callbacks.lib_extensions = ld_generic_lib_extensions;
    184   ld_state.callbacks.file_process = ld_generic_file_process;
    185   ld_state.callbacks.file_close = ld_generic_file_close;
    186   ld_state.callbacks.generate_sections = ld_generic_generate_sections;
    187   ld_state.callbacks.create_sections = ld_generic_create_sections;
    188   ld_state.callbacks.flag_unresolved = ld_generic_flag_unresolved;
    189   ld_state.callbacks.open_outfile = ld_generic_open_outfile;
    190   ld_state.callbacks.create_outfile = ld_generic_create_outfile;
    191   ld_state.callbacks.relocate_section = ld_generic_relocate_section;
    192   ld_state.callbacks.finalize = ld_generic_finalize;
    193   ld_state.callbacks.special_section_number_p =
    194     ld_generic_special_section_number_p;
    195   ld_state.callbacks.section_type_p = ld_generic_section_type_p;
    196   ld_state.callbacks.dynamic_section_flags = ld_generic_dynamic_section_flags;
    197   ld_state.callbacks.initialize_plt = ld_generic_initialize_plt;
    198   ld_state.callbacks.initialize_pltrel = ld_generic_initialize_pltrel;
    199   ld_state.callbacks.initialize_got = ld_generic_initialize_got;
    200   ld_state.callbacks.finalize_plt = ld_generic_finalize_plt;
    201   ld_state.callbacks.rel_type = ld_generic_rel_type;
    202   ld_state.callbacks.count_relocations = ld_generic_count_relocations;
    203   ld_state.callbacks.create_relocations = ld_generic_create_relocations;
    204 
    205 #ifndef BASE_ELF_NAME
    206   /* Find the ld backend library.  Use EBL to determine the name if
    207      the user hasn't provided one on the command line.  */
    208   if (emulation == NULL)
    209     {
    210       emulation = ebl_backend_name (ld_state.ebl);
    211       assert (emulation != NULL);
    212     }
    213   size_t emulation_len = strlen (emulation);
    214 
    215   /* Construct the file name.  */
    216   char *fname = (char *) alloca (sizeof "libld_" - 1 + emulation_len
    217 				 + sizeof ".so");
    218   strcpy (mempcpy (stpcpy (fname, "libld_"), emulation, emulation_len), ".so");
    219 
    220   /* Try loading.  */
    221   void *h = dlopen (fname, RTLD_LAZY);
    222   if (h == NULL)
    223     error (EXIT_FAILURE, 0,
    224 	   gettext ("cannot load ld backend library '%s': %s"),
    225 	   fname, dlerror ());
    226 
    227   /* Find the initializer.  It must be present.  */
    228   char *initname = (char *) alloca (emulation_len + sizeof "_ld_init");
    229   strcpy (mempcpy (initname, emulation, emulation_len), "_ld_init");
    230   int (*initfct) (struct ld_state *)
    231     = (int (*) (struct ld_state *)) dlsym (h, initname);
    232 
    233   if (initfct == NULL)
    234     error (EXIT_FAILURE, 0, gettext ("\
    235 cannot find init function in ld backend library '%s': %s"),
    236 	   fname, dlerror ());
    237 
    238   /* Store the handle.  */
    239   ld_state.ldlib = h;
    240 
    241   /* Call the init function.  */
    242   return initfct (&ld_state);
    243 #else
    244 # define INIT_FCT_NAME(base) _INIT_FCT_NAME(base)
    245 # define _INIT_FCT_NAME(base) base##_ld_init
    246   /* Declare and call the initialization function.  */
    247   extern int INIT_FCT_NAME(BASE_ELF_NAME) (struct ld_state *);
    248   return INIT_FCT_NAME(BASE_ELF_NAME) (&ld_state);
    249 #endif
    250 }
    251 
    252 
    253 static int
    254 check_for_duplicate2 (struct usedfiles *newp, struct usedfiles *list)
    255 {
    256   struct usedfiles *first;
    257   struct usedfiles *prevp;
    258 
    259   if (list == NULL)
    260     return 0;
    261 
    262   prevp = list;
    263   list = first = list->next;
    264   do
    265     {
    266       /* When searching the needed list we might come across entries
    267 	 for files which are not yet opened.  Stop then, there is
    268 	 nothing more to test.  */
    269       if (likely (list->status == not_opened))
    270 	break;
    271 
    272       if (unlikely (list->ino == newp->ino)
    273 	  && unlikely (list->dev == newp->dev))
    274 	{
    275 	  close (newp->fd);
    276 	  newp->fd = -1;
    277 	  newp->status = closed;
    278 	  if (newp->file_type == relocatable_file_type)
    279 	    error (0, 0, gettext ("%s listed more than once as input"),
    280 		   newp->rfname);
    281 
    282 	  return 1;
    283 	}
    284       list = list->next;
    285     }
    286   while (likely (list != first));
    287 
    288   return 0;
    289 }
    290 
    291 
    292 static int
    293 check_for_duplicate (struct usedfiles *newp)
    294 {
    295   struct stat st;
    296 
    297   if (unlikely (fstat (newp->fd, &st) < 0))
    298     {
    299       close (newp->fd);
    300       return errno;
    301     }
    302 
    303   newp->dev = st.st_dev;
    304   newp->ino = st.st_ino;
    305 
    306   return (check_for_duplicate2 (newp, ld_state.relfiles)
    307 	  || check_for_duplicate2 (newp, ld_state.dsofiles)
    308 	  || check_for_duplicate2 (newp, ld_state.needed));
    309 }
    310 
    311 
    312 /* Find a file along the path described in the state.  */
    313 static int
    314 open_along_path2 (struct usedfiles *fileinfo, struct pathelement *path)
    315 {
    316   const char *fname = fileinfo->fname;
    317   size_t fnamelen = strlen (fname);
    318   int err = ENOENT;
    319   struct pathelement *firstp = path;
    320 
    321   if (path == NULL)
    322     /* Cannot find anything since we have no path.  */
    323     return ENOENT;
    324 
    325   do
    326     {
    327       if (likely (path->exist >= 0))
    328 	{
    329 	  /* Create the file name.  */
    330 	  char *rfname = NULL;
    331 	  size_t dirlen = strlen (path->pname);
    332 	  int fd = -1;
    333 
    334 	  if (fileinfo->file_type == archive_file_type)
    335 	    {
    336 	      const char **exts = (ld_state.statically
    337 				   ? (const char *[2]) { ".a", NULL }
    338 				   : LIB_EXTENSION (&ld_state));
    339 
    340 	      /* We have to create the actual file name.  We prepend "lib"
    341 		 and add one of the extensions the platform has.  */
    342 	      while (*exts != NULL)
    343 		{
    344 		  size_t extlen = strlen (*exts);
    345 		  rfname = (char *) alloca (dirlen + 5 + fnamelen + extlen);
    346 		  memcpy (mempcpy (stpcpy (mempcpy (rfname, path->pname,
    347 						    dirlen),
    348 					   "/lib"),
    349 				   fname, fnamelen),
    350 			  *exts, extlen + 1);
    351 
    352 		  fd = open (rfname, O_RDONLY);
    353 		  if (likely (fd != -1) || errno != ENOENT)
    354 		    {
    355 		      err = fd == -1 ? errno : 0;
    356 		      break;
    357 		    }
    358 
    359 		  /* Next extension.  */
    360 		  ++exts;
    361 		}
    362 	    }
    363 	  else
    364 	    {
    365 	      assert (fileinfo->file_type == dso_file_type
    366 		      || fileinfo->file_type == dso_needed_file_type);
    367 
    368 	      rfname = (char *) alloca (dirlen + 1 + fnamelen + 1);
    369 	      memcpy (stpcpy (mempcpy (rfname, path->pname, dirlen), "/"),
    370 		      fname, fnamelen + 1);
    371 
    372 	      fd = open (rfname, O_RDONLY);
    373 	      if (unlikely (fd == -1))
    374 		err = errno;
    375 	    }
    376 
    377 	  if (likely (fd != -1))
    378 	    {
    379 	      /* We found the file.  This also means the directory
    380 		 exists.  */
    381 	      fileinfo->fd = fd;
    382 	      path->exist = 1;
    383 
    384 	      /* Check whether we have this file already loaded.  */
    385 	      if (unlikely (check_for_duplicate (fileinfo) != 0))
    386 		return EAGAIN;
    387 
    388 	      /* Make a copy of the name.  */
    389 	      fileinfo->rfname = obstack_strdup (&ld_state.smem, rfname);
    390 
    391 	      if (unlikely (ld_state.trace_files))
    392 		printf (fileinfo->file_type == archive_file_type
    393 			? gettext ("%s (for -l%s)\n")
    394 			: gettext ("%s (for DT_NEEDED %s)\n"),
    395 			rfname, fname);
    396 
    397 	      return 0;
    398 	    }
    399 
    400 	  /* The file does not exist.  Maybe the whole directory doesn't.
    401 	     Check it unless we know it exists.  */
    402 	  if (unlikely (path->exist == 0))
    403 	    {
    404 	      struct stat st;
    405 
    406 	      /* Keep only the directory name.  Note that the path
    407 		 might be relative.  This doesn't matter here.  We do
    408 		 the test in any case even if there is the chance that
    409 		 somebody wants to change the programs working
    410 		 directory at some point which would make the result
    411 		 of this test void.  Since changing the working
    412 		 directory is completely wrong we are not taking this
    413 		 case into account.  */
    414 	      rfname[dirlen] = '\0';
    415 	      if (unlikely (stat (rfname, &st) < 0) || ! S_ISDIR (st.st_mode))
    416 		/* The directory does not exist or the named file is no
    417 		   directory.  */
    418 		path->exist = -1;
    419 	      else
    420 		path->exist = 1;
    421 	    }
    422 	}
    423 
    424       /* Next path element.  */
    425       path = path->next;
    426     }
    427   while (likely (err == ENOENT && path != firstp));
    428 
    429   return err;
    430 }
    431 
    432 
    433 static int
    434 open_along_path (struct usedfiles *fileinfo)
    435 {
    436   const char *fname = fileinfo->fname;
    437   int err = ENOENT;
    438 
    439   if (fileinfo->file_type == relocatable_file_type)
    440     {
    441       /* Only libraries are searched along the path.  */
    442       fileinfo->fd = open (fname, O_RDONLY);
    443 
    444       if (likely (fileinfo->fd != -1))
    445 	{
    446 	  /* We found the file.  */
    447 	  if (unlikely (ld_state.trace_files))
    448 	    print_file_name (stdout, fileinfo, 1, 1);
    449 
    450 	  return check_for_duplicate (fileinfo);
    451 	}
    452 
    453       /* If the name is an absolute path we are done.  */
    454       err = errno;
    455     }
    456   else
    457     {
    458       /* If the user specified two parts to the LD_LIBRARY_PATH variable
    459 	 try the first part now.  */
    460       err = open_along_path2 (fileinfo, ld_state.ld_library_path1);
    461 
    462       /* Try the user-specified path next.  */
    463       if (err == ENOENT)
    464 	err = open_along_path2 (fileinfo,
    465 				fileinfo->file_type == archive_file_type
    466 				? ld_state.paths : ld_state.rpath_link);
    467 
    468       /* Then the second part of the LD_LIBRARY_PATH value.  */
    469       if (unlikely (err == ENOENT))
    470 	{
    471 	  err = open_along_path2 (fileinfo, ld_state.ld_library_path2);
    472 
    473 	  /* In case we look for a DSO handle now the RUNPATH.  */
    474 	  if (err == ENOENT)
    475 	    {
    476 	      if (fileinfo->file_type == dso_file_type)
    477 		err = open_along_path2 (fileinfo, ld_state.runpath_link);
    478 
    479 	      /* Finally the path from the default linker script.  */
    480 	      if (err == ENOENT)
    481 		err = open_along_path2 (fileinfo, ld_state.default_paths);
    482 	    }
    483 	}
    484     }
    485 
    486   if (unlikely (err != 0)
    487       && (err != EAGAIN || fileinfo->file_type == relocatable_file_type))
    488     error (0, err, gettext ("cannot open %s"), fileinfo->fname);
    489 
    490   return err;
    491 }
    492 
    493 
    494 static void
    495 check_type_and_size (const XElf_Sym *sym, struct usedfiles *fileinfo,
    496 		     struct symbol *oldp)
    497 {
    498   /* We check the type and size of the symbols.  In both cases the
    499      information can be missing (size is zero, type is STT_NOTYPE) in
    500      which case we issue no warnings.  Otherwise everything must
    501      match.  If the type does not match there is no point in checking
    502      the size.  */
    503 
    504   if (XELF_ST_TYPE (sym->st_info) != STT_NOTYPE && oldp->type != STT_NOTYPE
    505       && unlikely (oldp->type != XELF_ST_TYPE (sym->st_info)))
    506     {
    507       char buf1[64];
    508       char buf2[64];
    509 
    510       error (0, 0, gettext ("\
    511 Warning: type of `%s' changed from %s in %s to %s in %s"),
    512 	     oldp->name,
    513 	     ebl_symbol_type_name (ld_state.ebl, oldp->type,
    514 				   buf1, sizeof (buf1)),
    515 	     oldp->file->rfname,
    516 	     ebl_symbol_type_name (ld_state.ebl, XELF_ST_TYPE (sym->st_info),
    517 				   buf2, sizeof (buf2)),
    518 	     fileinfo->rfname);
    519     }
    520   else if (XELF_ST_TYPE (sym->st_info) == STT_OBJECT
    521 	   && oldp->size != 0
    522 	   && unlikely (oldp->size != sym->st_size))
    523     error (0, 0, gettext ("\
    524 Warning: size of `%s' changed from %" PRIu64 " in %s to %" PRIu64 " in %s"),
    525 	   oldp->name, (uint64_t) oldp->size, oldp->file->rfname,
    526 	   (uint64_t) sym->st_size, fileinfo->rfname);
    527 }
    528 
    529 
    530 static int
    531 check_definition (const XElf_Sym *sym, size_t symidx,
    532 		  struct usedfiles *fileinfo, struct symbol *oldp)
    533 {
    534   int result = 0;
    535   bool old_in_dso = FILEINFO_EHDR (oldp->file->ehdr).e_type == ET_DYN;
    536   bool new_in_dso = FILEINFO_EHDR (fileinfo->ehdr).e_type == ET_DYN;
    537   bool use_new_def = false;
    538 
    539   if (sym->st_shndx != SHN_UNDEF
    540       && (! oldp->defined
    541 	  || (sym->st_shndx != SHN_COMMON && oldp->common && ! new_in_dso)
    542 	  || (old_in_dso && ! new_in_dso)))
    543     {
    544       /* We found a definition for a previously undefined symbol or a
    545 	 real definition for a previous common-only definition or a
    546 	 redefinition of a symbol definition in an object file
    547 	 previously defined in a DSO.  First perform some tests which
    548 	 will show whether the common is really matching the
    549 	 definition.  */
    550       check_type_and_size (sym, fileinfo, oldp);
    551 
    552       /* We leave the next element intact to not interrupt the list
    553 	 with the unresolved symbols.  Whoever walks the list will
    554 	 have to check the `defined' flag.  But we remember that this
    555 	 list element is not unresolved anymore.  */
    556       if (! oldp->defined)
    557 	{
    558 	  /* Remove from the list.  */
    559 	  --ld_state.nunresolved;
    560 	  if (! oldp->weak)
    561 	    --ld_state.nunresolved_nonweak;
    562 	  CDBL_LIST_DEL (ld_state.unresolved, oldp);
    563 	}
    564       else if (oldp->common)
    565 	/* Remove from the list.  */
    566 	CDBL_LIST_DEL (ld_state.common_syms, oldp);
    567 
    568       /* Use the values of the definition from now on.  */
    569       use_new_def = true;
    570     }
    571   else if (sym->st_shndx != SHN_UNDEF
    572 	   && unlikely (! oldp->common)
    573 	   && oldp->defined
    574 	   && sym->st_shndx != SHN_COMMON
    575 	   /* Multiple definitions are no fatal errors if the -z muldefs flag
    576 	      is used.  We don't warn about the multiple definition unless we
    577 	      are told to be verbose.  */
    578 	   && (!ld_state.muldefs || verbose)
    579 	   && ! old_in_dso && fileinfo->file_type == relocatable_file_type)
    580     {
    581       /* We have a double definition.  This is a problem.  */
    582       char buf[64];
    583       XElf_Sym_vardef (oldsym);
    584       struct usedfiles *oldfile;
    585       const char *scnname;
    586       Elf32_Word xndx;
    587       size_t shndx;
    588       size_t shnum;
    589 
    590       if (elf_getshnum (fileinfo->elf, &shnum) < 0)
    591 	error (EXIT_FAILURE, 0,
    592 	       gettext ("cannot determine number of sections: %s"),
    593 	       elf_errmsg (-1));
    594 
    595       /* XXX Use only ebl_section_name.  */
    596       if (sym->st_shndx < SHN_LORESERVE // || sym->st_shndx > SHN_HIRESERVE
    597 	  && sym->st_shndx < shnum)
    598 	scnname = elf_strptr (fileinfo->elf,
    599 			      fileinfo->shstrndx,
    600 			      SCNINFO_SHDR (fileinfo->scninfo[sym->st_shndx].shdr).sh_name);
    601       else
    602 	// XXX extended section
    603 	scnname = ebl_section_name (ld_state.ebl, sym->st_shndx, 0,
    604 				    buf, sizeof (buf), NULL, shnum);
    605 
    606       /* XXX Print source file and line number.  */
    607       print_file_name (stderr, fileinfo, 1, 0);
    608       fprintf (stderr,
    609 	       gettext ("(%s+%#" PRIx64 "): multiple definition of %s `%s'\n"),
    610 	       scnname,
    611 	       (uint64_t) sym->st_value,
    612 	       ebl_symbol_type_name (ld_state.ebl, XELF_ST_TYPE (sym->st_info),
    613 				     buf, sizeof (buf)),
    614 	       oldp->name);
    615 
    616       oldfile = oldp->file;
    617       xelf_getsymshndx (oldfile->symtabdata, oldfile->xndxdata, oldp->symidx,
    618 			oldsym, xndx);
    619       if (oldsym == NULL)
    620 	/* This should never happen since the same call
    621 	   succeeded before.  */
    622 	abort ();
    623 
    624       shndx = oldsym->st_shndx;
    625       if (unlikely (oldsym->st_shndx == SHN_XINDEX))
    626 	shndx = xndx;
    627 
    628       /* XXX Use only ebl_section_name.  */
    629       if (shndx < SHN_LORESERVE || shndx > SHN_HIRESERVE)
    630 	scnname = elf_strptr (oldfile->elf,
    631 			      oldfile->shstrndx,
    632 			      SCNINFO_SHDR (oldfile->scninfo[shndx].shdr).sh_name);
    633       else
    634 	scnname = ebl_section_name (ld_state.ebl, oldsym->st_shndx, shndx, buf,
    635 				    sizeof (buf), NULL, shnum);
    636 
    637       /* XXX Print source file and line number.  */
    638       print_file_name (stderr, oldfile, 1, 0);
    639       fprintf (stderr, gettext ("(%s+%#" PRIx64 "): first defined here\n"),
    640 	       scnname, (uint64_t) oldsym->st_value);
    641 
    642       if (likely (!ld_state.muldefs))
    643 	result = 1;
    644     }
    645   else if (old_in_dso && fileinfo->file_type == relocatable_file_type
    646 	   && sym->st_shndx != SHN_UNDEF)
    647     /* We use the definition from a normal relocatable file over the
    648        definition in a DSO.  This is what the dynamic linker would
    649        do, too.  */
    650     use_new_def = true;
    651   else if (old_in_dso && !new_in_dso && oldp->defined && !oldp->on_dsolist)
    652     {
    653       CDBL_LIST_ADD_REAR (ld_state.from_dso, oldp);
    654       ++ld_state.nfrom_dso;
    655 
    656       /* If the object is a function we allocate a PLT entry,
    657 	 otherwise only a GOT entry.  */
    658       if (oldp->type == STT_FUNC)
    659 	++ld_state.nplt;
    660       else
    661 	++ld_state.ngot;
    662 
    663       oldp->on_dsolist = 1;
    664     }
    665   else if (oldp->common && sym->st_shndx == SHN_COMMON)
    666     {
    667       /* The symbol size is the largest of all common definitions.  */
    668       oldp->size = MAX (oldp->size, sym->st_size);
    669       /* Similarly for the alignment.  */
    670       oldp->merge.value = MAX (oldp->merge.value, sym->st_value);
    671     }
    672 
    673   if (unlikely (use_new_def))
    674     {
    675       /* Adjust the symbol record appropriately and remove
    676 	 the symbol from the list of symbols which are taken from DSOs.  */
    677       if (old_in_dso && fileinfo->file_type == relocatable_file_type)
    678 	{
    679 	  CDBL_LIST_DEL (ld_state.from_dso, oldp);
    680 	  --ld_state.nfrom_dso;
    681 
    682 	  if (likely (oldp->type == STT_FUNC))
    683 	    --ld_state.nplt;
    684 	  else
    685 	    --ld_state.ngot;
    686 
    687 	  oldp->on_dsolist = 0;
    688 	}
    689 
    690       /* Use the values of the definition from now on.  */
    691       oldp->size = sym->st_size;
    692       oldp->type = XELF_ST_TYPE (sym->st_info);
    693       oldp->symidx = symidx;
    694       oldp->scndx = sym->st_shndx;
    695       //oldp->symscndx = THESYMSCNDX must be passed;
    696       oldp->file = fileinfo;
    697       oldp->defined = 1;
    698       oldp->in_dso = new_in_dso;
    699       oldp->common = sym->st_shndx == SHN_COMMON;
    700       if (likely (fileinfo->file_type == relocatable_file_type))
    701 	{
    702 	  /* If the definition comes from a DSO we pertain the weak flag
    703 	     and it's indicating whether the reference is weak or not.  */
    704 	  oldp->weak = XELF_ST_BIND (sym->st_info) == STB_WEAK;
    705 
    706 	  if (sym->st_shndx != SHN_COMMON)
    707 	    {
    708 	      struct scninfo *ignore;
    709 	      mark_section_used (&fileinfo->scninfo[sym->st_shndx],
    710 				 sym->st_shndx, &ignore);
    711 	    }
    712 	}
    713 
    714       /* Add to the list of symbols used from DSOs if necessary.  */
    715       if (new_in_dso && !old_in_dso)
    716 	{
    717 	  CDBL_LIST_ADD_REAR (ld_state.from_dso, oldp);
    718 	  ++ld_state.nfrom_dso;
    719 
    720 	  /* If the object is a function we allocate a PLT entry,
    721 	     otherwise only a GOT entry.  */
    722 	  if (oldp->type == STT_FUNC)
    723 	    ++ld_state.nplt;
    724 	  else
    725 	    ++ld_state.ngot;
    726 
    727 	  oldp->on_dsolist = 1;
    728 	}
    729       else if (sym->st_shndx == SHN_COMMON)
    730 	{
    731 	  /* Store the alignment.  */
    732 	  oldp->merge.value = sym->st_value;
    733 
    734 	  CDBL_LIST_ADD_REAR (ld_state.common_syms, oldp);
    735 	}
    736     }
    737 
    738   return result;
    739 }
    740 
    741 
    742 static struct scninfo *
    743 find_section_group (struct usedfiles *fileinfo, Elf32_Word shndx,
    744 		    Elf_Data **datap)
    745 {
    746   struct scninfo *runp;
    747 
    748   for (runp = fileinfo->groups; runp != NULL; runp = runp->next)
    749     if (!runp->used)
    750       {
    751 	Elf32_Word *grpref;
    752 	size_t cnt;
    753 	Elf_Data *data;
    754 
    755 	data = elf_getdata (runp->scn, NULL);
    756 	if (data == NULL)
    757 	  error (EXIT_FAILURE, 0,
    758 		 gettext ("%s: cannot get section group data: %s"),
    759 		 fileinfo->fname, elf_errmsg (-1));
    760 
    761 	/* There cannot be another data block.  */
    762 	assert (elf_getdata (runp->scn, data) == NULL);
    763 
    764 	grpref = (Elf32_Word *) data->d_buf;
    765 	cnt = data->d_size / sizeof (Elf32_Word);
    766 	/* Note that we stop after looking at index 1 since index 0
    767 	   contains the flags for the section group.  */
    768 	while (cnt > 1)
    769 	  if (grpref[--cnt] == shndx)
    770 	    {
    771 	      *datap = data;
    772 	      return runp;
    773 	    }
    774       }
    775 
    776   /* If we come here no section group contained the given section
    777      despite the SHF_GROUP flag.  This is an error in the input
    778      file.  */
    779   error (EXIT_FAILURE, 0, gettext ("\
    780 %s: section '%s' with group flag set does not belong to any group"),
    781 	 fileinfo->fname,
    782 	 elf_strptr (fileinfo->elf, fileinfo->shstrndx,
    783 		     SCNINFO_SHDR (fileinfo->scninfo[shndx].shdr).sh_name));
    784   return NULL;
    785 }
    786 
    787 
    788 /* Mark all sections which belong to the same group as section SHNDX
    789    as used.  */
    790 static void
    791 mark_section_group (struct usedfiles *fileinfo, Elf32_Word shndx,
    792 		    struct scninfo **grpscnp)
    793 {
    794   /* First locate the section group.  There can be several (many) of
    795      them.  */
    796   size_t cnt;
    797   Elf32_Word *grpref;
    798   Elf_Data *data;
    799   struct scninfo *grpscn = find_section_group (fileinfo, shndx, &data);
    800   *grpscnp = grpscn;
    801 
    802   /* Mark all the sections as used.
    803 
    804      XXX Two possible problems here:
    805 
    806      - the gABI says "The section must be referenced by a section of type
    807        SHT_GROUP".  I hope everybody reads this as "exactly one section".
    808 
    809      - section groups are also useful to mark the debugging section which
    810        belongs to a text section.  Unconditionally adding debugging sections
    811        is therefore probably not what is wanted if stripping is required.  */
    812 
    813   /* Mark the section group as handled.  */
    814   grpscn->used = true;
    815 
    816   grpref = (Elf32_Word *) data->d_buf;
    817   cnt = data->d_size / sizeof (Elf32_Word);
    818   while (cnt > 1)
    819     {
    820       Elf32_Word idx = grpref[--cnt];
    821       XElf_Shdr *shdr = &SCNINFO_SHDR (fileinfo->scninfo[idx].shdr);
    822 
    823       if (fileinfo->scninfo[idx].grpid != 0)
    824 	error (EXIT_FAILURE, 0, gettext ("\
    825 %s: section [%2d] '%s' is in more than one section group"),
    826 	       fileinfo->fname, (int) idx,
    827 	       elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name));
    828 
    829       fileinfo->scninfo[idx].grpid = grpscn->grpid;
    830 
    831       if (ld_state.strip == strip_none
    832 	  /* If we are stripping, remove debug sections.  */
    833 	  || (!ebl_debugscn_p (ld_state.ebl,
    834 			       elf_strptr (fileinfo->elf, fileinfo->shstrndx,
    835 					   shdr->sh_name))
    836 	      /* And the relocation sections for the debug sections.  */
    837 	      && ((shdr->sh_type != SHT_RELA && shdr->sh_type != SHT_REL)
    838 		  || !ebl_debugscn_p (ld_state.ebl,
    839 				      elf_strptr (fileinfo->elf,
    840 						  fileinfo->shstrndx,
    841 						  SCNINFO_SHDR (fileinfo->scninfo[shdr->sh_info].shdr).sh_name)))))
    842 	{
    843 	  struct scninfo *ignore;
    844 
    845 	  mark_section_used (&fileinfo->scninfo[idx], idx, &ignore);
    846 	}
    847     }
    848 }
    849 
    850 
    851 static void
    852 mark_section_used (struct scninfo *scninfo, Elf32_Word shndx,
    853 		   struct scninfo **grpscnp)
    854 {
    855   if (likely (scninfo->used))
    856     /* Nothing to be done.  */
    857     return;
    858 
    859   /* We need this section.  */
    860   scninfo->used = true;
    861 
    862   /* Make sure the section header has been read from the file.  */
    863   XElf_Shdr *shdr = &SCNINFO_SHDR (scninfo->shdr);
    864 #if NATIVE_ELF
    865   if (unlikely (scninfo->shdr == NULL))
    866 #else
    867   if (unlikely (scninfo->shdr.sh_type == SHT_NULL))
    868 #endif
    869     {
    870 #if NATIVE_ELF != 0
    871       shdr = xelf_getshdr (scninfo->scn, scninfo->shdr);
    872 #else
    873       xelf_getshdr_copy (scninfo->scn, shdr, scninfo->shdr);
    874 #endif
    875       if (unlikely (shdr == NULL))
    876 	/* Something is very wrong.  The calling code will notice it
    877 	   soon and print a message.  */
    878 	return;
    879     }
    880 
    881   /* Handle section linked by 'sh_link'.  */
    882   if (unlikely (shdr->sh_link != 0))
    883     {
    884       struct scninfo *ignore;
    885       mark_section_used (&scninfo->fileinfo->scninfo[shdr->sh_link],
    886 			 shdr->sh_link, &ignore);
    887     }
    888 
    889   /* Handle section linked by 'sh_info'.  */
    890   if (unlikely (shdr->sh_info != 0) && (shdr->sh_flags & SHF_INFO_LINK))
    891     {
    892       struct scninfo *ignore;
    893       mark_section_used (&scninfo->fileinfo->scninfo[shdr->sh_info],
    894 			 shdr->sh_info, &ignore);
    895     }
    896 
    897   if (unlikely (shdr->sh_flags & SHF_GROUP) && ld_state.gc_sections)
    898     /* Find the section group which contains this section.  */
    899     mark_section_group (scninfo->fileinfo, shndx, grpscnp);
    900 }
    901 
    902 
    903 /* We collect all sections in a hashing table.  All sections with the
    904    same name are collected in a list.  Note that we do not determine
    905    which sections are finally collected in the same output section
    906    here.  This would be terribly inefficient.  It will be done later.  */
    907 static void
    908 add_section (struct usedfiles *fileinfo, struct scninfo *scninfo)
    909 {
    910   struct scnhead *queued;
    911   struct scnhead search;
    912   unsigned long int hval;
    913   XElf_Shdr *shdr = &SCNINFO_SHDR (scninfo->shdr);
    914   struct scninfo *grpscn = NULL;
    915   Elf_Data *grpscndata = NULL;
    916 
    917   /* See whether we can determine right away whether we need this
    918      section in the output.
    919 
    920      XXX I assume here that --gc-sections only affects extraction
    921      from an archive.  If it also affects objects files given on
    922      the command line then somebody must explain to me how the
    923      dependency analysis should work.  Should the entry point be
    924      the root?  What if it is a numeric value?  */
    925   if (!scninfo->used
    926       && (ld_state.strip == strip_none
    927 	  || (shdr->sh_flags & SHF_ALLOC) != 0
    928 	  || shdr->sh_type == SHT_NOTE
    929 	  || (shdr->sh_type == SHT_PROGBITS
    930 	      && strcmp (elf_strptr (fileinfo->elf,
    931 				     fileinfo->shstrndx,
    932 				     shdr->sh_name), ".comment") == 0))
    933       && (fileinfo->status != in_archive || !ld_state.gc_sections))
    934     /* Mark as used and handle reference recursively if necessary.  */
    935     mark_section_used (scninfo, elf_ndxscn (scninfo->scn), &grpscn);
    936 
    937   if ((shdr->sh_flags & SHF_GROUP) && grpscn == NULL)
    938     /* Determine the symbol which name constitutes the signature
    939        for the section group.  */
    940     grpscn = find_section_group (fileinfo, elf_ndxscn (scninfo->scn),
    941 				 &grpscndata);
    942   assert (grpscn == NULL || grpscn->symbols->name != NULL);
    943 
    944   /* Determine the section name.  */
    945   search.name = elf_strptr (fileinfo->elf, fileinfo->shstrndx, shdr->sh_name);
    946   search.type = shdr->sh_type;
    947   search.flags = shdr->sh_flags;
    948   search.entsize = shdr->sh_entsize;
    949   search.grp_signature = grpscn != NULL ? grpscn->symbols->name : NULL;
    950   search.kind = scn_normal;
    951   hval = elf_hash (search.name);
    952 
    953   /* Find already queued sections.  */
    954   queued = ld_section_tab_find (&ld_state.section_tab, hval, &search);
    955   if (queued != NULL)
    956     {
    957       bool is_comdat = false;
    958 
    959       /* If this section is part of a COMDAT section group we simply
    960 	 ignore it since we already have a copy.  */
    961       if (unlikely (shdr->sh_flags & SHF_GROUP))
    962 	{
    963 	  /* Get the data of the section group section.  */
    964 	  if (grpscndata == NULL)
    965 	    {
    966 	      grpscndata = elf_getdata (grpscn->scn, NULL);
    967 	      assert (grpscndata != NULL);
    968 	    }
    969 
    970 	  /* XXX Possibly unaligned memory access.  */
    971 	  is_comdat = ((Elf32_Word *) grpscndata->d_buf)[0] & GRP_COMDAT;
    972 	}
    973 
    974       if (!is_comdat)
    975 	{
    976 	  /* No COMDAT section, we use the data.  */
    977 	  scninfo->next = queued->last->next;
    978 	  queued->last = queued->last->next = scninfo;
    979 
    980 	  queued->flags = SH_FLAGS_COMBINE (queued->flags, shdr->sh_flags);
    981 	  queued->align = MAX (queued->align, shdr->sh_addralign);
    982 	}
    983     }
    984   else
    985     {
    986       /* We do not use obstacks here since the memory might be
    987 	 deallocated.  */
    988       queued = (struct scnhead *) xcalloc (sizeof (struct scnhead), 1);
    989       queued->kind = scn_normal;
    990       queued->name = search.name;
    991       queued->type = shdr->sh_type;
    992       queued->flags = shdr->sh_flags;
    993       queued->align = shdr->sh_addralign;
    994       queued->entsize = shdr->sh_entsize;
    995       queued->grp_signature = grpscn != NULL ? grpscn->symbols->name : NULL;
    996       queued->segment_nr = ~0;
    997       queued->last = scninfo->next = scninfo;
    998 
    999       /* Add to the hash table and possibly overwrite existing value.  */
   1000       ld_section_tab_insert (&ld_state.section_tab, hval, queued);
   1001     }
   1002 }
   1003 
   1004 
   1005 static int
   1006 add_relocatable_file (struct usedfiles *fileinfo, int secttype)
   1007 {
   1008   size_t scncnt;
   1009   size_t cnt;
   1010   Elf_Data *symtabdata = NULL;
   1011   Elf_Data *xndxdata = NULL;
   1012   Elf_Data *versymdata = NULL;
   1013   Elf_Data *verdefdata = NULL;
   1014   Elf_Data *verneeddata = NULL;
   1015   size_t symstridx = 0;
   1016   size_t nsymbols = 0;
   1017   size_t nlocalsymbols = 0;
   1018   bool has_merge_sections = false;
   1019 
   1020   /* Prerequisites.  */
   1021   assert (fileinfo->elf != NULL);
   1022 
   1023   /* Allocate memory for the sections.  */
   1024   if (unlikely (elf_getshnum (fileinfo->elf, &scncnt) < 0))
   1025     error (EXIT_FAILURE, 0,
   1026 	   gettext ("cannot determine number of sections: %s"),
   1027 	   elf_errmsg (-1));
   1028 
   1029   fileinfo->scninfo = (struct scninfo *)
   1030     obstack_calloc (&ld_state.smem, scncnt * sizeof (struct scninfo));
   1031 
   1032   /* Read all the section headers and find the symbol table.  Note
   1033      that we don't skip the section with index zero.  Even though the
   1034      section itself is always empty the section header contains
   1035      informaton for the case when the section index for the section
   1036      header string table is too large to fit in the ELF header.  */
   1037   for (cnt = 0; cnt < scncnt; ++cnt)
   1038     {
   1039       /* Store the handle for the section.  */
   1040       fileinfo->scninfo[cnt].scn = elf_getscn (fileinfo->elf, cnt);
   1041 
   1042       /* Get the ELF section header and data.  */
   1043       XElf_Shdr *shdr;
   1044 #if NATIVE_ELF != 0
   1045       if (fileinfo->scninfo[cnt].shdr == NULL)
   1046 #else
   1047       if (fileinfo->scninfo[cnt].shdr.sh_type == SHT_NULL)
   1048 #endif
   1049 	{
   1050 #if NATIVE_ELF != 0
   1051 	  shdr = xelf_getshdr (fileinfo->scninfo[cnt].scn,
   1052 			       fileinfo->scninfo[cnt].shdr);
   1053 #else
   1054 	  xelf_getshdr_copy (fileinfo->scninfo[cnt].scn, shdr,
   1055 			     fileinfo->scninfo[cnt].shdr);
   1056 #endif
   1057 	  if (shdr == NULL)
   1058 	    {
   1059 	      /* This should never happen.  */
   1060 	      fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1061 		       fileinfo->rfname, __FILE__, __LINE__);
   1062 	      return 1;
   1063 	    }
   1064 	}
   1065       else
   1066 	shdr = &SCNINFO_SHDR (fileinfo->scninfo[cnt].shdr);
   1067 
   1068       Elf_Data *data = elf_getdata (fileinfo->scninfo[cnt].scn, NULL);
   1069 
   1070       /* Check whether this section is marked as merge-able.  */
   1071       has_merge_sections |= (shdr->sh_flags & SHF_MERGE) != 0;
   1072 
   1073       /* Get the ELF section header and data.  */
   1074       /* Make the file structure available.  */
   1075       fileinfo->scninfo[cnt].fileinfo = fileinfo;
   1076 
   1077       if (unlikely (shdr->sh_type == SHT_SYMTAB)
   1078 	  || unlikely (shdr->sh_type == SHT_DYNSYM))
   1079 	{
   1080 	  if (shdr->sh_type == SHT_SYMTAB)
   1081 	    {
   1082 	      assert (fileinfo->symtabdata == NULL);
   1083 	      fileinfo->symtabdata = data;
   1084 	      fileinfo->nsymtab = shdr->sh_size / shdr->sh_entsize;
   1085 	      fileinfo->nlocalsymbols = shdr->sh_info;
   1086 	      fileinfo->symstridx = shdr->sh_link;
   1087 	    }
   1088 	  else
   1089 	    {
   1090 	      assert (fileinfo->dynsymtabdata == NULL);
   1091 	      fileinfo->dynsymtabdata = data;
   1092 	      fileinfo->ndynsymtab = shdr->sh_size / shdr->sh_entsize;
   1093 	      fileinfo->dynsymstridx = shdr->sh_link;
   1094 	    }
   1095 
   1096 	  /* If we are looking for the normal symbol table we just
   1097 	     found it.  */
   1098 	  if (secttype == shdr->sh_type)
   1099 	    {
   1100 	      assert (symtabdata == NULL);
   1101 	      symtabdata = data;
   1102 	      symstridx = shdr->sh_link;
   1103 	      nsymbols = shdr->sh_size / shdr->sh_entsize;
   1104 	      nlocalsymbols = shdr->sh_info;
   1105 	    }
   1106 	}
   1107       else if (unlikely (shdr->sh_type == SHT_SYMTAB_SHNDX))
   1108 	{
   1109 	  assert (xndxdata == NULL);
   1110 	  fileinfo->xndxdata = xndxdata = data;
   1111 	}
   1112       else if (unlikely (shdr->sh_type == SHT_GNU_versym))
   1113 	{
   1114 	  assert (versymdata == 0);
   1115 	  fileinfo->versymdata = versymdata = data;
   1116 	}
   1117       else if (unlikely (shdr->sh_type == SHT_GNU_verdef))
   1118 	{
   1119 	  size_t nversions;
   1120 
   1121 	  assert (verdefdata == 0);
   1122 	  fileinfo->verdefdata = verdefdata = data;
   1123 
   1124 	  /* Allocate the arrays flagging the use of the version and
   1125 	     to track of allocated names.  */
   1126 	  fileinfo->nverdef = nversions = shdr->sh_info;
   1127 	  /* We have NVERSIONS + 1 because the indeces used to access the
   1128 	     sectino start with one; zero represents local binding.  */
   1129 	  fileinfo->verdefused = (XElf_Versym *)
   1130 	    obstack_calloc (&ld_state.smem,
   1131 			    sizeof (XElf_Versym) * (nversions + 1));
   1132 	  fileinfo->verdefent = (struct Ebl_Strent **)
   1133 	    obstack_alloc (&ld_state.smem,
   1134 			   sizeof (struct Ebl_Strent *) * (nversions + 1));
   1135 	}
   1136       else if (unlikely (shdr->sh_type == SHT_GNU_verneed))
   1137 	{
   1138 	  assert (verneeddata == 0);
   1139 	  fileinfo->verneeddata = verneeddata = data;
   1140 	}
   1141       else if (unlikely (shdr->sh_type == SHT_DYNAMIC))
   1142 	{
   1143 	  assert (fileinfo->dynscn == NULL);
   1144 	  fileinfo->dynscn = fileinfo->scninfo[cnt].scn;
   1145 	}
   1146       else if (unlikely (shdr->sh_type == SHT_GROUP))
   1147 	{
   1148 	  Elf_Scn *symscn;
   1149 	  XElf_Shdr_vardef (symshdr);
   1150 	  Elf_Data *symdata;
   1151 
   1152 	  if (FILEINFO_EHDR (fileinfo->ehdr).e_type != ET_REL)
   1153 	    error (EXIT_FAILURE, 0, gettext ("\
   1154 %s: only files of type ET_REL might contain section groups"),
   1155 		   fileinfo->fname);
   1156 
   1157 	  fileinfo->scninfo[cnt].next = fileinfo->groups;
   1158 	  fileinfo->scninfo[cnt].grpid = cnt;
   1159 	  fileinfo->groups = &fileinfo->scninfo[cnt];
   1160 
   1161 	  /* Determine the signature.  We create a symbol record for
   1162 	     it.  Only the name element is important.  */
   1163 	  fileinfo->scninfo[cnt].symbols = (struct symbol *)
   1164 	    obstack_calloc (&ld_state.smem, sizeof (struct symbol));
   1165 
   1166 	  symscn = elf_getscn (fileinfo->elf, shdr->sh_link);
   1167 	  xelf_getshdr (symscn, symshdr);
   1168 	  symdata = elf_getdata (symscn, NULL);
   1169 	  if (symshdr != NULL)
   1170 	    {
   1171 	      XElf_Sym_vardef (sym);
   1172 
   1173 	      /* We don't need the section index and therefore we don't
   1174 		 have to use 'xelf_getsymshndx'.  */
   1175 	      xelf_getsym (symdata, shdr->sh_info, sym);
   1176 	      if (sym != NULL)
   1177 		{
   1178 		  struct symbol *symbol = fileinfo->scninfo[cnt].symbols;
   1179 
   1180 		  symbol->name = elf_strptr (fileinfo->elf, symshdr->sh_link,
   1181 					     sym->st_name);
   1182 		  symbol->symidx = shdr->sh_info;
   1183 		  symbol->file = fileinfo;
   1184 		}
   1185 	    }
   1186 	  if (fileinfo->scninfo[cnt].symbols->name == NULL)
   1187 	    error (EXIT_FAILURE, 0, gettext ("\
   1188 %s: cannot determine signature of section group [%2zd] '%s': %s"),
   1189 		   fileinfo->fname,
   1190 		   elf_ndxscn (fileinfo->scninfo[cnt].scn),
   1191 		   elf_strptr (fileinfo->elf, fileinfo->shstrndx,
   1192 			       shdr->sh_name),
   1193 		   elf_errmsg (-1));
   1194 
   1195 	  /* The 'used' flag is used to indicate when the information
   1196 	     in the section group is used to mark all other sections
   1197 	     as used.  So it must not be true yet.  */
   1198 	  assert (fileinfo->scninfo[cnt].used == false);
   1199 	}
   1200       else if (! SECTION_TYPE_P (&ld_state, shdr->sh_type)
   1201 	       && unlikely ((shdr->sh_flags & SHF_OS_NONCONFORMING) != 0))
   1202 	/* According to the gABI it is a fatal error if the file contains
   1203 	   a section with unknown type and the SHF_OS_NONCONFORMING flag
   1204 	   set.  */
   1205 	error (EXIT_FAILURE, 0,
   1206 	       gettext ("%s: section '%s' has unknown type: %d"),
   1207 	       fileinfo->fname,
   1208 	       elf_strptr (fileinfo->elf, fileinfo->shstrndx,
   1209 			   shdr->sh_name),
   1210 	       (int) shdr->sh_type);
   1211       /* We don't have to add a few section types here.  These will be
   1212 	 generated from scratch for the new output file.  We also
   1213 	 don't add the sections of DSOs here since these sections are
   1214 	 not used in the resulting object file.  */
   1215       else if (likely (fileinfo->file_type == relocatable_file_type)
   1216 	       && likely (cnt > 0)
   1217 	       && likely (shdr->sh_type == SHT_PROGBITS
   1218 			  || shdr->sh_type == SHT_RELA
   1219 			  || shdr->sh_type == SHT_REL
   1220 			  || shdr->sh_type == SHT_NOTE
   1221 			  || shdr->sh_type == SHT_NOBITS
   1222 			  || shdr->sh_type == SHT_INIT_ARRAY
   1223 			  || shdr->sh_type == SHT_FINI_ARRAY
   1224 			  || shdr->sh_type == SHT_PREINIT_ARRAY))
   1225 	add_section (fileinfo, &fileinfo->scninfo[cnt]);
   1226     }
   1227 
   1228   /* Handle the symbols.  Record defined and undefined symbols in the
   1229      hash table.  In theory there can be a file without any symbol
   1230      table.  */
   1231   if (likely (symtabdata != NULL))
   1232     {
   1233       /* In case this file contains merge-able sections we have to
   1234 	 locate the symbols which are in these sections.  */
   1235       fileinfo->has_merge_sections = has_merge_sections;
   1236       if (likely (has_merge_sections))
   1237 	{
   1238 	  fileinfo->symref = (struct symbol **)
   1239 	    obstack_calloc (&ld_state.smem,
   1240 			    nsymbols * sizeof (struct symbol *));
   1241 
   1242 	  /* Only handle the local symbols here.  */
   1243 	  for (cnt = 0; cnt < nlocalsymbols; ++cnt)
   1244 	    {
   1245 	      Elf32_Word shndx;
   1246 	      XElf_Sym_vardef (sym);
   1247 
   1248 	      xelf_getsymshndx (symtabdata, xndxdata, cnt, sym, shndx);
   1249 	      if (sym == NULL)
   1250 		{
   1251 		  /* This should never happen.  */
   1252 		  fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1253 			   fileinfo->rfname, __FILE__, __LINE__);
   1254 		  return 1;
   1255 		}
   1256 
   1257 	      if (likely (shndx != SHN_XINDEX))
   1258 		shndx = sym->st_shndx;
   1259 	      else if (unlikely (shndx == 0))
   1260 		{
   1261 		  fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1262 			   fileinfo->rfname, __FILE__, __LINE__);
   1263 		  return 1;
   1264 		}
   1265 
   1266 	      if (XELF_ST_TYPE (sym->st_info) != STT_SECTION
   1267 		  && (shndx < SHN_LORESERVE || shndx > SHN_HIRESERVE)
   1268 		  && (SCNINFO_SHDR (fileinfo->scninfo[shndx].shdr).sh_flags
   1269 		      & SHF_MERGE))
   1270 		{
   1271 		  /* Create a symbol record for this symbol and add it
   1272 		     to the list for this section.  */
   1273 		  struct symbol *newp;
   1274 
   1275 		  newp = (struct symbol *)
   1276 		    obstack_calloc (&ld_state.smem, sizeof (struct symbol));
   1277 
   1278 		  newp->symidx = cnt;
   1279 		  newp->scndx = shndx;
   1280 		  newp->file = fileinfo;
   1281 		  fileinfo->symref[cnt] = newp;
   1282 
   1283 		  if (fileinfo->scninfo[shndx].symbols == NULL)
   1284 		    fileinfo->scninfo[shndx].symbols = newp->next_in_scn
   1285 		      = newp;
   1286 		  else
   1287 		    {
   1288 		      newp->next_in_scn
   1289 			= fileinfo->scninfo[shndx].symbols->next_in_scn;
   1290 		      fileinfo->scninfo[shndx].symbols
   1291 			= fileinfo->scninfo[shndx].symbols->next_in_scn = newp;
   1292 		    }
   1293 		}
   1294 	    }
   1295 	}
   1296       else
   1297 	/* Create array with pointers to the symbol definitions.  Note
   1298 	   that we only allocate memory for the non-local symbols
   1299 	   since we have no merge-able sections.  But we store the
   1300 	   pointer as if it was for the whole symbol table.  This
   1301 	   saves some memory.  */
   1302 	fileinfo->symref = (struct symbol **)
   1303 	  obstack_calloc (&ld_state.smem, ((nsymbols - nlocalsymbols)
   1304 					   * sizeof (struct symbol *)))
   1305 	  - nlocalsymbols;
   1306 
   1307       /* Don't handle local symbols here.  It's either not necessary
   1308 	 at all or has already happened.  */
   1309       for (cnt = nlocalsymbols; cnt < nsymbols; ++cnt)
   1310 	{
   1311 	  XElf_Sym_vardef (sym);
   1312 	  Elf32_Word shndx;
   1313 	  xelf_getsymshndx (symtabdata, xndxdata, cnt, sym, shndx);
   1314 
   1315 	  if (sym == NULL)
   1316 	    {
   1317 	      /* This should never happen.  */
   1318 	      fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1319 		       fileinfo->rfname, __FILE__, __LINE__);
   1320 	      return 1;
   1321 	    }
   1322 
   1323 	  if (likely (shndx != SHN_XINDEX))
   1324 	    shndx = sym->st_shndx;
   1325 	  else if (unlikely (shndx == 0))
   1326 	    {
   1327 	      fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1328 		       fileinfo->rfname, __FILE__, __LINE__);
   1329 	      return 1;
   1330 	    }
   1331 
   1332 	  /* We ignore ABS symbols from DSOs.  */
   1333 	  // XXX Is this correct?
   1334 	  if (unlikely (shndx == SHN_ABS) && secttype == SHT_DYNSYM)
   1335 	    continue;
   1336 
   1337 	  /* If the DSO uses symbols determine whether this is the default
   1338 	     version.  Otherwise we'll ignore the symbol.  */
   1339 	  if (versymdata != NULL)
   1340 	    {
   1341 	      XElf_Versym versym;
   1342 
   1343 	      if (xelf_getversym_copy (versymdata, cnt, versym) == NULL)
   1344 		/* XXX Should we handle faulty input files more graceful?  */
   1345 		assert (! "xelf_getversym failed");
   1346 
   1347 	      if ((versym & 0x8000) != 0)
   1348 		/* Ignore the symbol, it's not the default version.  */
   1349 		continue;
   1350 	    }
   1351 
   1352 	  /* See whether we know anything about this symbol.  */
   1353 	  struct symbol search;
   1354 	  search.name = elf_strptr (fileinfo->elf, symstridx, sym->st_name);
   1355 	  unsigned long int hval = elf_hash (search.name);
   1356 
   1357 	  /* We ignore the symbols the linker generates.  This are
   1358 	     _GLOBAL_OFFSET_TABLE_, _DYNAMIC.  */
   1359 	  // XXX This loop is hot and the following tests hardly ever match.
   1360 	  // XXX Maybe move the tests somewhere they are executed less often.
   1361 	  if (((unlikely (hval == 165832675)
   1362 		&& strcmp (search.name, "_DYNAMIC") == 0)
   1363 	       || (unlikely (hval == 102264335)
   1364 		   && strcmp (search.name, "_GLOBAL_OFFSET_TABLE_") == 0))
   1365 	      && sym->st_shndx != SHN_UNDEF
   1366 	      /* If somebody defines such a variable in a relocatable we
   1367 		 don't ignore it.  Let the user get what s/he deserves.  */
   1368 	      && fileinfo->file_type != relocatable_file_type)
   1369 	    continue;
   1370 
   1371 	  struct symbol *oldp = ld_symbol_tab_find (&ld_state.symbol_tab,
   1372 						    hval, &search);
   1373 	  struct symbol *newp;
   1374 	  if (likely (oldp == NULL))
   1375 	    {
   1376 	      /* No symbol of this name know.  Add it.  */
   1377 	      newp = (struct symbol *) obstack_alloc (&ld_state.smem,
   1378 						      sizeof (*newp));
   1379 	      newp->name = search.name;
   1380 	      newp->size = sym->st_size;
   1381 	      newp->type = XELF_ST_TYPE (sym->st_info);
   1382 	      newp->symidx = cnt;
   1383 	      newp->outsymidx = 0;
   1384 	      newp->outdynsymidx = 0;
   1385 	      newp->scndx = shndx;
   1386 	      newp->file = fileinfo;
   1387 	      newp->defined = newp->scndx != SHN_UNDEF;
   1388 	      newp->common = newp->scndx == SHN_COMMON;
   1389 	      newp->weak = XELF_ST_BIND (sym->st_info) == STB_WEAK;
   1390 	      newp->added = 0;
   1391 	      newp->merged = 0;
   1392 	      newp->need_copy = 0;
   1393 	      newp->on_dsolist = 0;
   1394 	      newp->in_dso = secttype == SHT_DYNSYM;
   1395 	      newp->next_in_scn = NULL;
   1396 #ifndef NDEBUG
   1397 	      newp->next = NULL;
   1398 	      newp->previous = NULL;
   1399 #endif
   1400 
   1401 	      if (newp->scndx == SHN_UNDEF)
   1402 		{
   1403 		  CDBL_LIST_ADD_REAR (ld_state.unresolved, newp);
   1404 		  ++ld_state.nunresolved;
   1405 		  if (! newp->weak)
   1406 		    ++ld_state.nunresolved_nonweak;
   1407 		}
   1408 	      else if (newp->scndx == SHN_COMMON)
   1409 		{
   1410 		  /* Store the alignment requirement.  */
   1411 		  newp->merge.value = sym->st_value;
   1412 
   1413 		  CDBL_LIST_ADD_REAR (ld_state.common_syms, newp);
   1414 		}
   1415 
   1416 	      /* Insert the new symbol.  */
   1417 	      if (unlikely (ld_symbol_tab_insert (&ld_state.symbol_tab,
   1418 						  hval, newp) != 0))
   1419 		/* This cannot happen.  */
   1420 		abort ();
   1421 
   1422 	      fileinfo->symref[cnt] = newp;
   1423 
   1424 	      /* We have a few special symbols to recognize.  The symbols
   1425 		 _init and _fini are the initialization and finalization
   1426 		 functions respectively.  They have to be made known in
   1427 		 the dynamic section and therefore we have to find out
   1428 		 now whether these functions exist or not.  */
   1429 	      if (hval == 6685956 && strcmp (newp->name, "_init") == 0)
   1430 		ld_state.init_symbol = newp;
   1431 	      else if (hval == 6672457 && strcmp (newp->name, "_fini") == 0)
   1432 		ld_state.fini_symbol = newp;
   1433 	    }
   1434 	  else if (unlikely (check_definition (sym, cnt, fileinfo, oldp) != 0))
   1435 	    /* A fatal error (multiple definition of a symbol)
   1436 	       occurred, no need to continue.  */
   1437 	    return 1;
   1438 	  else
   1439 	    /* Use the previously allocated symbol record.  It has
   1440 	       been updated in check_definition(), if necessary.  */
   1441 	    newp = fileinfo->symref[cnt] = oldp;
   1442 
   1443 	  /* Mark the section the symbol we need comes from as used.  */
   1444 	  if (shndx != SHN_UNDEF
   1445 	      && (shndx < SHN_LORESERVE || shndx > SHN_HIRESERVE))
   1446 	    {
   1447 	      struct scninfo *ignore;
   1448 
   1449 #ifndef NDEBUG
   1450 	      size_t shnum;
   1451 	      assert (elf_getshnum (fileinfo->elf, &shnum) == 0);
   1452 	      assert (shndx < shnum);
   1453 #endif
   1454 
   1455 	      /* Mark section (and all dependencies) as used.  */
   1456 	      mark_section_used (&fileinfo->scninfo[shndx], shndx, &ignore);
   1457 
   1458 	      /* Check whether the section is merge-able.  In this case we
   1459 		 have to record the symbol.  */
   1460 	      if (SCNINFO_SHDR (fileinfo->scninfo[shndx].shdr).sh_flags
   1461 		  & SHF_MERGE)
   1462 		{
   1463 		  if (fileinfo->scninfo[shndx].symbols == NULL)
   1464 		    fileinfo->scninfo[shndx].symbols = newp->next_in_scn
   1465 		      = newp;
   1466 		  else
   1467 		    {
   1468 		      newp->next_in_scn
   1469 			= fileinfo->scninfo[shndx].symbols->next_in_scn;
   1470 		      fileinfo->scninfo[shndx].symbols
   1471 			= fileinfo->scninfo[shndx].symbols->next_in_scn = newp;
   1472 		    }
   1473 		}
   1474 	    }
   1475 	}
   1476 
   1477       /* This file is used.  */
   1478       if (likely (fileinfo->file_type == relocatable_file_type))
   1479 	{
   1480 	  if (unlikely (ld_state.relfiles == NULL))
   1481 	    ld_state.relfiles = fileinfo->next = fileinfo;
   1482 	  else
   1483 	    {
   1484 	      fileinfo->next = ld_state.relfiles->next;
   1485 	      ld_state.relfiles = ld_state.relfiles->next = fileinfo;
   1486 	    }
   1487 
   1488 	  /* Update some summary information in the state structure.  */
   1489 	  ld_state.nsymtab += fileinfo->nsymtab;
   1490 	  ld_state.nlocalsymbols += fileinfo->nlocalsymbols;
   1491 	}
   1492       else if (likely (fileinfo->file_type == dso_file_type))
   1493 	{
   1494 	  CSNGL_LIST_ADD_REAR (ld_state.dsofiles, fileinfo);
   1495 	  ++ld_state.ndsofiles;
   1496 
   1497 	  if (fileinfo->lazyload)
   1498 	    /* We have to create another dynamic section entry for the
   1499 	       DT_POSFLAG_1 entry.
   1500 
   1501 	       XXX Once more functionality than the lazyloading flag
   1502 	       are suppported the test must be extended.  */
   1503 	    ++ld_state.ndsofiles;
   1504 	}
   1505     }
   1506 
   1507   return 0;
   1508 }
   1509 
   1510 
   1511 int
   1512 ld_handle_filename_list (struct filename_list *fnames)
   1513 {
   1514   struct filename_list *runp;
   1515   int res = 0;
   1516 
   1517   for (runp = fnames; runp != NULL; runp = runp->next)
   1518     {
   1519       struct usedfiles *curp;
   1520 
   1521       /* Create a record for the new file.  */
   1522       curp = runp->real = ld_new_inputfile (runp->name, relocatable_file_type);
   1523 
   1524       /* Set flags for group handling.  */
   1525       runp->real->group_start = runp->group_start;
   1526       runp->real->group_end = runp->group_end;
   1527 
   1528       /* Read the file and everything else which comes up, including
   1529 	 handling groups.  */
   1530       do
   1531 	res |= FILE_PROCESS (-1, curp, &ld_state, &curp);
   1532       while (curp != NULL);
   1533     }
   1534 
   1535   /* Free the list.  */
   1536   while (fnames != NULL)
   1537     {
   1538       runp = fnames;
   1539       fnames = fnames->next;
   1540       free (runp);
   1541     }
   1542 
   1543   return res;
   1544 }
   1545 
   1546 
   1547 /* Handle opening of the given file with ELF descriptor.  */
   1548 static int
   1549 open_elf (struct usedfiles *fileinfo, Elf *elf)
   1550 {
   1551   int res = 0;
   1552 
   1553   if (elf == NULL)
   1554     error (EXIT_FAILURE, 0,
   1555 	   gettext ("cannot get descriptor for ELF file (%s:%d): %s\n"),
   1556 	   __FILE__, __LINE__, elf_errmsg (-1));
   1557 
   1558   if (unlikely (elf_kind (elf) == ELF_K_NONE))
   1559     {
   1560       struct filename_list *fnames;
   1561 
   1562       /* We don't have to look at this file again.  */
   1563       fileinfo->status = closed;
   1564 
   1565       /* Let's see whether this is a linker script.  */
   1566       if (fileinfo->fd != -1)
   1567 	/* Create a stream from the file handle we know.  */
   1568 	ldin = fdopen (fileinfo->fd, "r");
   1569       else
   1570 	{
   1571 	  /* Get the memory for the archive member.  */
   1572 	  char *content;
   1573 	  size_t contentsize;
   1574 
   1575 	  /* Get the content of the file.  */
   1576 	  content = elf_rawfile (elf, &contentsize);
   1577 	  if (content == NULL)
   1578 	    {
   1579 	      fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1580 		       fileinfo->rfname, __FILE__, __LINE__);
   1581 	      return 1;
   1582 	    }
   1583 
   1584 	  /* The content of the file is available in memory.  Read the
   1585 	     memory region as a stream.  */
   1586 	  ldin = fmemopen (content, contentsize, "r");
   1587 	}
   1588 
   1589       /* No need for locking.  */
   1590       __fsetlocking (ldin, FSETLOCKING_BYCALLER);
   1591 
   1592       if (ldin == NULL)
   1593 	error (EXIT_FAILURE, errno, gettext ("cannot open \"%s\""),
   1594 	       fileinfo->rfname);
   1595 
   1596       /* Parse the file.  If it is a linker script no problems will be
   1597 	 reported.  */
   1598       ld_state.srcfiles = NULL;
   1599       ldlineno = 1;
   1600       ld_scan_version_script = 0;
   1601       ldin_fname = fileinfo->rfname;
   1602       res = ldparse ();
   1603 
   1604       fclose (ldin);
   1605       if (fileinfo->fd != -1 && !fileinfo->fd_passed)
   1606 	{
   1607 	  /* We won't need the file descriptor again.  */
   1608 	  close (fileinfo->fd);
   1609 	  fileinfo->fd = -1;
   1610 	}
   1611 
   1612       elf_end (elf);
   1613 
   1614       if (unlikely (res != 0))
   1615 	/* Something went wrong during parsing.  */
   1616 	return 1;
   1617 
   1618       /* This is no ELF file.  */
   1619       fileinfo->elf = NULL;
   1620 
   1621       /* Now we have to handle eventual INPUT and GROUP statements in
   1622 	 the script.  Read the files mentioned.  */
   1623       fnames = ld_state.srcfiles;
   1624       if (fnames != NULL)
   1625 	{
   1626 	  struct filename_list *oldp;
   1627 
   1628 	  /* Convert the list into a normal single-linked list.  */
   1629 	  oldp = fnames;
   1630 	  fnames = fnames->next;
   1631 	  oldp->next = NULL;
   1632 
   1633 	  /* Remove the list from the state structure.  */
   1634 	  ld_state.srcfiles = NULL;
   1635 
   1636 	  if (unlikely (ld_handle_filename_list (fnames) != 0))
   1637 	    return 1;
   1638 	}
   1639 
   1640       return 0;
   1641     }
   1642 
   1643   /* Store the file info.  */
   1644   fileinfo->elf = elf;
   1645 
   1646   /* The file is ready for action.  */
   1647   fileinfo->status = opened;
   1648 
   1649   return 0;
   1650 }
   1651 
   1652 
   1653 static int
   1654 add_whole_archive (struct usedfiles *fileinfo)
   1655 {
   1656   Elf *arelf;
   1657   Elf_Cmd cmd = ELF_C_READ_MMAP_PRIVATE;
   1658   int res = 0;
   1659 
   1660   while ((arelf = elf_begin (fileinfo->fd, cmd, fileinfo->elf)) != NULL)
   1661     {
   1662       Elf_Arhdr *arhdr = elf_getarhdr (arelf);
   1663       struct usedfiles *newp;
   1664 
   1665       if (arhdr == NULL)
   1666 	abort ();
   1667 
   1668       /* Just to be sure; since these are no files in the archive
   1669 	 these names should never be returned.  */
   1670       assert (strcmp (arhdr->ar_name, "/") != 0);
   1671       assert (strcmp (arhdr->ar_name, "//") != 0);
   1672 
   1673       newp = ld_new_inputfile (arhdr->ar_name, relocatable_file_type);
   1674       newp->archive_file = fileinfo;
   1675 
   1676       if (unlikely (ld_state.trace_files))
   1677 	print_file_name (stdout, newp, 1, 1);
   1678 
   1679       /* This shows that this file is contained in an archive.  */
   1680       newp->fd = -1;
   1681       /* Store the ELF descriptor.  */
   1682       newp->elf = arelf;
   1683       /* Show that we are open for business.  */
   1684       newp->status = opened;
   1685 
   1686       /* Proces the file, add all the symbols etc.  */
   1687       res = file_process2 (newp);
   1688       if (unlikely (res != 0))
   1689 	    break;
   1690 
   1691       /* Advance to the next archive element.  */
   1692       cmd = elf_next (arelf);
   1693     }
   1694 
   1695   return res;
   1696 }
   1697 
   1698 
   1699 static int
   1700 extract_from_archive (struct usedfiles *fileinfo)
   1701 {
   1702   static int archive_seq;
   1703   int res = 0;
   1704 
   1705   /* This is an archive we are not using completely.  Give it a
   1706      unique number.  */
   1707   fileinfo->archive_seq = ++archive_seq;
   1708 
   1709   /* If there are no unresolved symbols don't do anything.  */
   1710   if ((likely (ld_state.extract_rule == defaultextract)
   1711        && ld_state.nunresolved_nonweak == 0)
   1712       || (unlikely (ld_state.extract_rule == weakextract)
   1713 	  && ld_state.nunresolved == 0))
   1714     return 0;
   1715 
   1716   Elf_Arsym *syms;
   1717   size_t nsyms;
   1718 
   1719   /* Get all the symbols.  */
   1720   syms = elf_getarsym (fileinfo->elf, &nsyms);
   1721   if (syms == NULL)
   1722     {
   1723     cannot_read_archive:
   1724       error (0, 0, gettext ("cannot read archive `%s': %s"),
   1725 	     fileinfo->rfname, elf_errmsg (-1));
   1726 
   1727       /* We cannot use this archive anymore.  */
   1728       fileinfo->status = closed;
   1729 
   1730       return 1;
   1731     }
   1732 
   1733   /* Now add all the symbols to the hash table.  Note that there
   1734      can potentially be duplicate definitions.  We'll always use
   1735      the first definition.  */
   1736   // XXX Is this a compatible behavior?
   1737   bool any_used;
   1738   int nround = 0;
   1739   do
   1740     {
   1741       any_used = false;
   1742 
   1743       size_t cnt;
   1744       for (cnt = 0; cnt < nsyms; ++cnt)
   1745 	{
   1746 	  struct symbol search = { .name = syms[cnt].as_name };
   1747 	  struct symbol *sym = ld_symbol_tab_find (&ld_state.symbol_tab,
   1748 						   syms[cnt].as_hash, &search);
   1749 	  if (sym != NULL && ! sym->defined)
   1750 	    {
   1751 	      /* The symbol is referenced and not defined.  */
   1752 	      Elf *arelf;
   1753 	      Elf_Arhdr *arhdr;
   1754 	      struct usedfiles *newp;
   1755 
   1756 	      /* Find the archive member for this symbol.  */
   1757 	      if (unlikely (elf_rand (fileinfo->elf, syms[cnt].as_off)
   1758 			    != syms[cnt].as_off))
   1759 		goto cannot_read_archive;
   1760 
   1761 	      /* Note: no test of a failing 'elf_begin' call.  That's fine
   1762 		 since 'elf'getarhdr' will report the problem.  */
   1763 	      arelf = elf_begin (fileinfo->fd, ELF_C_READ_MMAP_PRIVATE,
   1764 				 fileinfo->elf);
   1765 	      arhdr = elf_getarhdr (arelf);
   1766 	      if (arhdr == NULL)
   1767 		goto cannot_read_archive;
   1768 
   1769 	      /* We have all the information and an ELF handle for the
   1770 		 archive member.  Create the normal data structure for
   1771 		 a file now.  */
   1772 	      newp = ld_new_inputfile (obstack_strdup (&ld_state.smem,
   1773 						       arhdr->ar_name),
   1774 				       relocatable_file_type);
   1775 	      newp->archive_file = fileinfo;
   1776 
   1777 	      if (unlikely (ld_state.trace_files))
   1778 		print_file_name (stdout, newp, 1, 1);
   1779 
   1780 	      /* This shows that this file is contained in an archive.  */
   1781 	      newp->fd = -1;
   1782 	      /* Store the ELF descriptor.  */
   1783 	      newp->elf = arelf;
   1784 	      /* Show that we are open for business.  */
   1785 	      newp->status = in_archive;
   1786 
   1787 	      /* Now read the file and add all the symbols.  */
   1788 	      res = file_process2 (newp);
   1789 	      if (unlikely (res != 0))
   1790 		return res;
   1791 
   1792 	      any_used = true;
   1793 	    }
   1794 	}
   1795 
   1796       if (++nround == 1)
   1797 	{
   1798 	  /* This is an archive therefore it must have a number.  */
   1799 	  assert (fileinfo->archive_seq != 0);
   1800 	  ld_state.last_archive_used = fileinfo->archive_seq;
   1801 	}
   1802     }
   1803   while (any_used);
   1804 
   1805   return res;
   1806 }
   1807 
   1808 
   1809 static int
   1810 file_process2 (struct usedfiles *fileinfo)
   1811 {
   1812   int res;
   1813 
   1814   if (likely (elf_kind (fileinfo->elf) == ELF_K_ELF))
   1815     {
   1816       /* The first time we get here we read the ELF header.  */
   1817 #if NATIVE_ELF != 0
   1818       if (likely (fileinfo->ehdr == NULL))
   1819 #else
   1820       if (likely (FILEINFO_EHDR (fileinfo->ehdr).e_type == ET_NONE))
   1821 #endif
   1822 	{
   1823 	  XElf_Ehdr *ehdr;
   1824 #if NATIVE_ELF != 0
   1825 	  ehdr = xelf_getehdr (fileinfo->elf, fileinfo->ehdr);
   1826 #else
   1827 	  xelf_getehdr_copy (fileinfo->elf, ehdr, fileinfo->ehdr);
   1828 #endif
   1829 	  if (ehdr == NULL)
   1830 	    {
   1831 	      fprintf (stderr, gettext ("%s: invalid ELF file (%s:%d)\n"),
   1832 		       fileinfo->rfname, __FILE__, __LINE__);
   1833 	      fileinfo->status = closed;
   1834 	      return 1;
   1835 	    }
   1836 
   1837 	  if (FILEINFO_EHDR (fileinfo->ehdr).e_type != ET_REL
   1838 	      && unlikely (FILEINFO_EHDR (fileinfo->ehdr).e_type != ET_DYN))
   1839 	    /* XXX Add ebl* function to query types which are allowed
   1840 	       to link in.  */
   1841 	    {
   1842 	      char buf[64];
   1843 
   1844 	      print_file_name (stderr, fileinfo, 1, 0);
   1845 	      fprintf (stderr,
   1846 		       gettext ("file of type %s cannot be linked in\n"),
   1847 		       ebl_object_type_name (ld_state.ebl,
   1848 					     FILEINFO_EHDR (fileinfo->ehdr).e_type,
   1849 					     buf, sizeof (buf)));
   1850 	      fileinfo->status = closed;
   1851 	      return 1;
   1852 	    }
   1853 
   1854 	  /* Determine the section header string table section index.  */
   1855 	  if (unlikely (elf_getshstrndx (fileinfo->elf, &fileinfo->shstrndx)
   1856 			< 0))
   1857 	    {
   1858 	      fprintf (stderr, gettext ("\
   1859 %s: cannot get section header string table index: %s\n"),
   1860 		       fileinfo->rfname, elf_errmsg (-1));
   1861 	      fileinfo->status = closed;
   1862 	      return 1;
   1863 	    }
   1864 	}
   1865 
   1866       /* Now handle the different types of files.  */
   1867       if (FILEINFO_EHDR (fileinfo->ehdr).e_type == ET_REL)
   1868 	{
   1869 	  /* Add all the symbol.  Relocatable files have symbol
   1870 	     tables.  */
   1871 	  res = add_relocatable_file (fileinfo, SHT_SYMTAB);
   1872 	}
   1873       else
   1874 	{
   1875 	  bool has_l_name = fileinfo->file_type == archive_file_type;
   1876 
   1877 	  assert (FILEINFO_EHDR (fileinfo->ehdr).e_type == ET_DYN);
   1878 
   1879 	  /* If the file is a DT_NEEDED dependency then the type is
   1880 	     already correctly specified.  */
   1881 	  if (fileinfo->file_type != dso_needed_file_type)
   1882 	    fileinfo->file_type = dso_file_type;
   1883 
   1884 	  /* We cannot use DSOs when generating relocatable objects.  */
   1885 	  if (ld_state.file_type == relocatable_file_type)
   1886 	    {
   1887 	      error (0, 0, gettext ("\
   1888 cannot use DSO '%s' when generating relocatable object file"),
   1889 		     fileinfo->fname);
   1890 	      return 1;
   1891 	    }
   1892 
   1893 	  /* Add all the symbols.  For DSOs we are looking at the
   1894 	     dynamic symbol table.  */
   1895 	  res = add_relocatable_file (fileinfo, SHT_DYNSYM);
   1896 
   1897 	  /* We always have to have a dynamic section.  */
   1898 	  assert (fileinfo->dynscn != NULL);
   1899 
   1900 	  /* We have to remember the dependencies for this object.  It
   1901 	     is necessary to look them up.  */
   1902 	  XElf_Shdr_vardef (dynshdr);
   1903 	  xelf_getshdr (fileinfo->dynscn, dynshdr);
   1904 
   1905 	  Elf_Data *dyndata = elf_getdata (fileinfo->dynscn, NULL);
   1906 	  /* XXX Should we flag the failure to get the dynamic section?  */
   1907 	  if (dynshdr != NULL)
   1908 	    {
   1909 	      int cnt = dynshdr->sh_size / dynshdr->sh_entsize;
   1910 	      XElf_Dyn_vardef (dyn);
   1911 
   1912 	      while (--cnt >= 0)
   1913 		{
   1914 		  xelf_getdyn (dyndata, cnt, dyn);
   1915 		  if (dyn != NULL)
   1916 		    {
   1917 		      if(dyn->d_tag == DT_NEEDED)
   1918 			{
   1919 			  struct usedfiles *newp;
   1920 
   1921 			  newp = ld_new_inputfile (elf_strptr (fileinfo->elf,
   1922 							       dynshdr->sh_link,
   1923 							       dyn->d_un.d_val),
   1924 						   dso_needed_file_type);
   1925 
   1926 			  /* Enqueue the newly found dependencies.  */
   1927 			  // XXX Check that there not already a file with the
   1928 			  // same name.
   1929 			  CSNGL_LIST_ADD_REAR (ld_state.needed, newp);
   1930 			}
   1931 		      else if (dyn->d_tag == DT_SONAME)
   1932 			{
   1933 			  /* We use the DT_SONAME (this is what's there
   1934 			     for).  */
   1935 			  fileinfo->soname = elf_strptr (fileinfo->elf,
   1936 							 dynshdr->sh_link,
   1937 							 dyn->d_un.d_val);
   1938 			  has_l_name = false;
   1939 			}
   1940 		    }
   1941 		}
   1942 	    }
   1943 
   1944 	  /* Construct the file name if the DSO has no SONAME and the
   1945 	     file name comes from a -lXX parameter on the comment
   1946 	     line.  */
   1947 	  if (unlikely (has_l_name))
   1948 	    {
   1949 	      /* The FNAME is the parameter the user specified on the
   1950 		 command line.  We prepend "lib" and append ".so".  */
   1951 	      size_t len = strlen (fileinfo->fname) + 7;
   1952 	      char *newp;
   1953 
   1954 	      newp = (char *) obstack_alloc (&ld_state.smem, len);
   1955 	      strcpy (stpcpy (stpcpy (newp, "lib"), fileinfo->fname), ".so");
   1956 
   1957 	      fileinfo->soname = newp;
   1958 	    }
   1959 	}
   1960     }
   1961   else if (likely (elf_kind (fileinfo->elf) == ELF_K_AR))
   1962     {
   1963       if (unlikely (ld_state.extract_rule == allextract))
   1964 	/* Which this option enabled we have to add all the object
   1965 	   files in the archive.  */
   1966 	res = add_whole_archive (fileinfo);
   1967       else if (ld_state.file_type == relocatable_file_type)
   1968 	{
   1969 	  /* When generating a relocatable object we don't find files
   1970 	     in archives.  */
   1971 	  if (verbose)
   1972 	    error (0, 0, gettext ("input file '%s' ignored"), fileinfo->fname);
   1973 
   1974 	  res = 0;
   1975 	}
   1976       else
   1977 	/* Extract only the members from the archive which are
   1978 	   currently referenced by unresolved symbols.  */
   1979 	res = extract_from_archive (fileinfo);
   1980     }
   1981   else
   1982     /* This should never happen, we know about no other types.  */
   1983     abort ();
   1984 
   1985   return res;
   1986 }
   1987 
   1988 
   1989 /* Process a given file.  The first parameter is a file descriptor for
   1990    the file which can be -1 to indicate the file has not yet been
   1991    found.  The second parameter describes the file to be opened, the
   1992    last one is the state of the linker which among other information
   1993    contain the paths we look at.  */
   1994 static int
   1995 ld_generic_file_process (int fd, struct usedfiles *fileinfo,
   1996 			 struct ld_state *statep, struct usedfiles **nextp)
   1997 {
   1998   int res = 0;
   1999 
   2000   /* By default we go to the next file in the list.  */
   2001   *nextp = fileinfo->next;
   2002 
   2003   /* Set the flag to signal we are looking for a group start.  */
   2004   if (unlikely (fileinfo->group_start))
   2005     {
   2006       ld_state.group_start_requested = true;
   2007       fileinfo->group_start = false;
   2008     }
   2009 
   2010   /* If the file isn't open yet, open it now.  */
   2011   if (likely (fileinfo->status == not_opened))
   2012     {
   2013       bool fd_passed = true;
   2014 
   2015       if (likely (fd == -1))
   2016 	{
   2017 	  /* Find the file ourselves.  */
   2018 	  int err = open_along_path (fileinfo);
   2019 	  if (unlikely (err != 0))
   2020 	    /* We allow libraries and DSOs to be named more than once.
   2021 	       Don't report an error to the caller.  */
   2022 	    return err == EAGAIN ? 0 : err;
   2023 
   2024 	  fd_passed = false;
   2025 	}
   2026       else
   2027 	fileinfo->fd = fd;
   2028 
   2029       /* Remember where we got the descriptor from.  */
   2030       fileinfo->fd_passed = fd_passed;
   2031 
   2032       /* We found the file.  Now test whether it is a file type we can
   2033 	 handle.
   2034 
   2035 	 XXX Do we have to have the ability to start from a given
   2036 	 position in the search path again to look for another file if
   2037 	 the one found has not the right type?  */
   2038       res = open_elf (fileinfo, elf_begin (fileinfo->fd,
   2039 					   is_dso_p (fileinfo->fd)
   2040 					   ? ELF_C_READ_MMAP
   2041 					   : ELF_C_READ_MMAP_PRIVATE, NULL));
   2042       if (unlikely (res != 0))
   2043 	return res;
   2044     }
   2045 
   2046   /* Now that we have opened the file start processing it.  */
   2047   if (likely (fileinfo->status != closed))
   2048     res = file_process2 (fileinfo);
   2049 
   2050   /* Determine which file to look at next.  */
   2051   if (unlikely (fileinfo->group_backref != NULL))
   2052     {
   2053       /* We only go back if an archive other than the one we would go
   2054 	 back to has been used in the last round.  */
   2055       if (ld_state.last_archive_used > fileinfo->group_backref->archive_seq)
   2056 	{
   2057 	  *nextp = fileinfo->group_backref;
   2058 	  ld_state.last_archive_used = 0;
   2059 	}
   2060       else
   2061 	{
   2062 	  /* If we come here this means that the archives we read so
   2063 	     far are not needed anymore.  We can free some of the data
   2064 	     now.  */
   2065 	  struct usedfiles *runp = ld_state.archives;
   2066 
   2067 	  do
   2068 	    {
   2069 	      /* We don't need the ELF descriptor anymore.  Unless there
   2070 		 are no files from the archive used this will not free
   2071 		 the whole file but only some data structures.  */
   2072 	      elf_end (runp->elf);
   2073 	      runp->elf = NULL;
   2074 
   2075 	      runp = runp->next;
   2076 	    }
   2077 	  while (runp != fileinfo->next);
   2078 	}
   2079     }
   2080   else if (unlikely (fileinfo->group_end))
   2081     {
   2082       /* This is the end of a group.  We possibly of to go back.
   2083 	 Determine which file we would go back to and see whether it
   2084 	 makes sense.  If there has not been an archive we don't have
   2085 	 to do anything.  */
   2086       if (!ld_state.group_start_requested)
   2087 	{
   2088 	  if (ld_state.group_start_archive != ld_state.tailarchives)
   2089 	    /* The loop would include more than one archive, add the
   2090 	       pointer.  */
   2091 	    {
   2092 	      *nextp = ld_state.tailarchives->group_backref =
   2093 		ld_state.group_start_archive;
   2094 	      ld_state.last_archive_used = 0;
   2095 	    }
   2096 	  else
   2097 	    /* We might still have to go back to the beginning of the
   2098 	       group if since the last archive other files have been
   2099 	       added.  But we go back exactly once.  */
   2100 	    if (ld_state.tailarchives != fileinfo)
   2101 	      {
   2102 		*nextp = ld_state.group_start_archive;
   2103 		ld_state.last_archive_used = 0;
   2104 	      }
   2105 	}
   2106 
   2107       /* Clear the flags.  */
   2108       ld_state.group_start_requested = false;
   2109       fileinfo->group_end = false;
   2110     }
   2111 
   2112   return res;
   2113 }
   2114 
   2115 
   2116 /* Library names passed to the linker as -lXX represent files named
   2117    libXX.YY.  The YY part can have different forms, depending on the
   2118    platform.  The generic set is .so and .a (in this order).  */
   2119 static const char **
   2120 ld_generic_lib_extensions (struct ld_state *statep __attribute__ ((__unused__)))
   2121 {
   2122   static const char *exts[] =
   2123     {
   2124       ".so", ".a", NULL
   2125     };
   2126 
   2127   return exts;
   2128 }
   2129 
   2130 
   2131 /* Flag unresolved symbols.  */
   2132 static int
   2133 ld_generic_flag_unresolved (struct ld_state *statep)
   2134 {
   2135   int retval = 0;
   2136 
   2137   if (ld_state.nunresolved_nonweak > 0)
   2138     {
   2139       /* Go through the list and determine the unresolved symbols.  */
   2140       struct symbol *first;
   2141       struct symbol *s;
   2142 
   2143       s = first = ld_state.unresolved->next;
   2144       do
   2145 	{
   2146 	  if (! s->defined && ! s->weak)
   2147 	    {
   2148 	      /* Two special symbol we recognize: the symbol for the
   2149 		 GOT and the dynamic section.  */
   2150 	      if (strcmp (s->name, "_GLOBAL_OFFSET_TABLE_") == 0
   2151 		  || strcmp (s->name, "_DYNAMIC") == 0)
   2152 		{
   2153 		  /* We will have to fill in more information later.  */
   2154 		  ld_state.need_got = true;
   2155 
   2156 		  /* Remember that we found it.  */
   2157 		  if (s->name[1] == 'G')
   2158 		    ld_state.got_symbol = s;
   2159 		  else
   2160 		    ld_state.dyn_symbol = s;
   2161 		}
   2162 	      else if (ld_state.file_type != dso_file_type || !ld_state.nodefs)
   2163 		{
   2164 		  /* XXX The error message should get better.  It should use
   2165 		     the debugging information if present to tell where in the
   2166 		     sources the undefined reference is.  */
   2167 		  error (0, 0, gettext ("undefined symbol `%s' in %s"),
   2168 			 s->name, s->file->fname);
   2169 
   2170 		  retval = 1;
   2171 		}
   2172 	    }
   2173 
   2174 	  /* We cannot decide here what to do with undefined
   2175 	     references which will come from DSO since we do not know
   2176 	     what kind of symbol we expect.  Only when looking at the
   2177 	     relocations we can see whether we need a PLT entry or
   2178 	     only a GOT entry.  */
   2179 
   2180 	  s = s->next;
   2181 	}
   2182       while (s != first);
   2183     }
   2184 
   2185   return retval;
   2186 }
   2187 
   2188 
   2189 /* Close the given file.  */
   2190 static int
   2191 ld_generic_file_close (struct usedfiles *fileinfo, struct ld_state *statep)
   2192 {
   2193   /* Close the ELF descriptor.  */
   2194   elf_end (fileinfo->elf);
   2195 
   2196   /* If we have opened the file descriptor close it.  But we might
   2197      have done this already in which case FD is -1.  */
   2198   if (!fileinfo->fd_passed && fileinfo->fd != -1)
   2199     close (fileinfo->fd);
   2200 
   2201   /* We allocated the resolved file name.  */
   2202   if (fileinfo->fname != fileinfo->rfname)
   2203     free ((char *) fileinfo->rfname);
   2204 
   2205   return 0;
   2206 }
   2207 
   2208 
   2209 static void
   2210 new_generated_scn (enum scn_kind kind, const char *name, int type, int flags,
   2211 		   int entsize, int align)
   2212 {
   2213   struct scnhead *newp;
   2214 
   2215   newp = (struct scnhead *) obstack_calloc (&ld_state.smem,
   2216 					    sizeof (struct scnhead));
   2217   newp->kind = kind;
   2218   newp->name = name;
   2219   newp->nameent = ebl_strtabadd (ld_state.shstrtab, name, 0);
   2220   newp->type = type;
   2221   newp->flags = flags;
   2222   newp->entsize = entsize;
   2223   newp->align = align;
   2224   newp->grp_signature = NULL;
   2225   newp->used = true;
   2226 
   2227   /* All is well.  Create now the data for the section and insert it
   2228      into the section table.  */
   2229   ld_section_tab_insert (&ld_state.section_tab, elf_hash (name), newp);
   2230 }
   2231 
   2232 
   2233 /* Create the sections which are generated by the linker and are not
   2234    present in the input file.  */
   2235 static void
   2236 ld_generic_generate_sections (struct ld_state *statep)
   2237 {
   2238   /* The relocation section type.  */
   2239   int rel_type = REL_TYPE (&ld_state) == DT_REL ? SHT_REL : SHT_RELA;
   2240 
   2241   /* When building dynamically linked object we have to include a
   2242      section containing a string describing the interpreter.  This
   2243      should be at the very beginning of the file together with the
   2244      other information the ELF loader (kernel or wherever) has to look
   2245      at.  We put it as the first section in the file.
   2246 
   2247      We also have to create the dynamic segment which is a special
   2248      section the dynamic linker locates through an entry in the
   2249      program header.  */
   2250   if (dynamically_linked_p ())
   2251     {
   2252       int ndt_needed;
   2253       /* Use any versioning (defined or required)?  */
   2254       bool use_versioning = false;
   2255       /* Use version requirements?  */
   2256       bool need_version = false;
   2257 
   2258       /* First the .interp section.  */
   2259       new_generated_scn (scn_dot_interp, ".interp", SHT_PROGBITS, SHF_ALLOC,
   2260 			 0, 1);
   2261 
   2262       /* Now the .dynamic section.  */
   2263       new_generated_scn (scn_dot_dynamic, ".dynamic", SHT_DYNAMIC,
   2264 			 DYNAMIC_SECTION_FLAGS (&ld_state),
   2265 			 xelf_fsize (ld_state.outelf, ELF_T_DYN, 1),
   2266 			 xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2267 
   2268       /* We will need in any case the dynamic symbol table (even in
   2269 	 the unlikely case that no symbol is exported or referenced
   2270 	 from a DSO).  */
   2271       ld_state.need_dynsym = true;
   2272       new_generated_scn (scn_dot_dynsym, ".dynsym", SHT_DYNSYM, SHF_ALLOC,
   2273 			 xelf_fsize (ld_state.outelf, ELF_T_SYM, 1),
   2274 			 xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2275       /* It comes with a string table.  */
   2276       new_generated_scn (scn_dot_dynstr, ".dynstr", SHT_STRTAB, SHF_ALLOC,
   2277 			 0, 1);
   2278       /* And a hashing table.  */
   2279       // XXX For Linux/Alpha we need other sizes unless they change...
   2280       new_generated_scn (scn_dot_hash, ".hash", SHT_HASH, SHF_ALLOC,
   2281 			 sizeof (Elf32_Word), sizeof (Elf32_Word));
   2282 
   2283       /* By default we add all DSOs provided on the command line.  If
   2284 	 the user added '-z ignore' to the command line we only add
   2285 	 those which are actually used.  */
   2286       ndt_needed = ld_state.ignore_unused_dsos ? 0 : ld_state.ndsofiles;
   2287 
   2288       /* Create the section associated with the PLT if necessary.  */
   2289       if (ld_state.nplt > 0)
   2290 	{
   2291 	  /* Create the .plt section.  */
   2292 	  /* XXX We might need a function which returns the section flags.  */
   2293 	  new_generated_scn (scn_dot_plt, ".plt", SHT_PROGBITS,
   2294 			     SHF_ALLOC | SHF_EXECINSTR,
   2295 			     /* XXX Is the size correct?  */
   2296 			     xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1),
   2297 			     xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2298 
   2299 	  /* Create the relocation section for the .plt.  This is always
   2300 	     separate even if the other relocation sections are combined.  */
   2301 	  new_generated_scn (scn_dot_pltrel, ".rel.plt", rel_type, SHF_ALLOC,
   2302 			     rel_type == SHT_REL
   2303 			     ? xelf_fsize (ld_state.outelf, ELF_T_REL, 1)
   2304 			     : xelf_fsize (ld_state.outelf, ELF_T_RELA, 1),
   2305 			     xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2306 
   2307 	  /* This means we will also need the .got section.  */
   2308 	  ld_state.need_got = true;
   2309 
   2310 	  /* Mark all used DSOs as used.  Determine whether any referenced
   2311 	     object uses symbol versioning.  */
   2312 	  if (ld_state.from_dso != NULL)
   2313 	    {
   2314 	      struct symbol *srunp = ld_state.from_dso;
   2315 
   2316 	      do
   2317 		{
   2318 		  srunp->file->used = true;
   2319 
   2320 		  if (srunp->file->verdefdata != NULL)
   2321 		    {
   2322 		      XElf_Versym versym;
   2323 
   2324 		      /* The input DSO uses versioning.  */
   2325 		      use_versioning = true;
   2326 		      /* We reference versions.  */
   2327 		      need_version = true;
   2328 
   2329 		      if (xelf_getversym_copy (srunp->file->versymdata,
   2330 					       srunp->symidx, versym) == NULL)
   2331 			assert (! "xelf_getversym failed");
   2332 
   2333 		      /* We cannot link explicitly with an older
   2334 			 version of a symbol.  */
   2335 		      assert ((versym & 0x8000) == 0);
   2336 		      /* We cannot reference local (index 0) or plain
   2337 			 global (index 1) versions.  */
   2338 		      assert (versym > 1);
   2339 
   2340 		      /* Check whether we have already seen the
   2341 			 version and if not add it to the referenced
   2342 			 versions in the output file.  */
   2343 		      if (! srunp->file->verdefused[versym])
   2344 			{
   2345 			  srunp->file->verdefused[versym] = 1;
   2346 
   2347 			  if (++srunp->file->nverdefused == 1)
   2348 			    /* Count the file if it is using versioning.  */
   2349 			    ++ld_state.nverdeffile;
   2350 			  ++ld_state.nverdefused;
   2351 			}
   2352 		    }
   2353 		}
   2354 	      while ((srunp = srunp->next) != ld_state.from_dso);
   2355 	    }
   2356 
   2357 	  /* Create the sections used to record version dependencies.  */
   2358 	  if (need_version)
   2359 	    new_generated_scn (scn_dot_version_r, ".gnu.version_r",
   2360 			       SHT_GNU_verneed, SHF_ALLOC, 0,
   2361 			       xelf_fsize (ld_state.outelf, ELF_T_WORD, 1));
   2362 
   2363 	  /* Now count the used DSOs since this is what the user
   2364 	     wants.  */
   2365 	  ndt_needed = 0;
   2366 	  if (ld_state.ndsofiles > 0)
   2367 	    {
   2368 	      struct usedfiles *frunp = ld_state.dsofiles;
   2369 
   2370 	      do
   2371 		if (! ld_state.ignore_unused_dsos || frunp->used)
   2372 		  {
   2373 		    ++ndt_needed;
   2374 		    if (frunp->lazyload)
   2375 		      /* We have to create another dynamic section
   2376 			 entry for the DT_POSFLAG_1 entry.
   2377 
   2378 			 XXX Once more functionality than the
   2379 			 lazyloading flag are suppported the test
   2380 			 must be extended.  */
   2381 		      ++ndt_needed;
   2382 		  }
   2383 	      while ((frunp = frunp->next) != ld_state.dsofiles);
   2384 	    }
   2385 	}
   2386 
   2387       if (use_versioning)
   2388 	new_generated_scn (scn_dot_version, ".gnu.version", SHT_GNU_versym,
   2389 			   SHF_ALLOC,
   2390 			   xelf_fsize (ld_state.outelf, ELF_T_HALF, 1),
   2391 			   xelf_fsize (ld_state.outelf, ELF_T_HALF, 1));
   2392 
   2393       /* We need some entries all the time.  */
   2394       ld_state.ndynamic = (7 + (ld_state.runpath != NULL
   2395 				|| ld_state.rpath != NULL)
   2396 			   + ndt_needed
   2397 			   + (ld_state.init_symbol != NULL ? 1 : 0)
   2398 			   + (ld_state.fini_symbol != NULL ? 1 : 0)
   2399 			   + (use_versioning ? 1 : 0)
   2400 			   + (need_version ? 2 : 0)
   2401 			   + (ld_state.nplt > 0 ? 4 : 0)
   2402 			   + (ld_state.relsize_total > 0 ? 3 : 0));
   2403     }
   2404 
   2405   /* When creating a relocatable file or when we are not stripping the
   2406      output file we create a symbol table.  */
   2407   ld_state.need_symtab = (ld_state.file_type == relocatable_file_type
   2408 			  || ld_state.strip == strip_none);
   2409 
   2410   /* Add the .got section if needed.  */
   2411   if (ld_state.need_got)
   2412     /* XXX We might need a function which returns the section flags.  */
   2413     new_generated_scn (scn_dot_got, ".got", SHT_PROGBITS,
   2414 		       SHF_ALLOC | SHF_WRITE,
   2415 		       xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1),
   2416 		       xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2417 
   2418   /* Add the .rel.dyn section.  */
   2419   if (ld_state.relsize_total > 0)
   2420     new_generated_scn (scn_dot_dynrel, ".rel.dyn", rel_type, SHF_ALLOC,
   2421 		       rel_type == SHT_REL
   2422 		       ? xelf_fsize (ld_state.outelf, ELF_T_REL, 1)
   2423 		       : xelf_fsize (ld_state.outelf, ELF_T_RELA, 1),
   2424 		       xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1));
   2425 }
   2426 
   2427 
   2428 /* Callback function registered with on_exit to make sure the temporary
   2429    files gets removed if something goes wrong.  */
   2430 static void
   2431 remove_tempfile (int status, void *arg)
   2432 {
   2433   if (status != 0 && ld_state.tempfname != NULL)
   2434     unlink (ld_state.tempfname);
   2435 }
   2436 
   2437 
   2438 /* Create the output file.  The file name is given or "a.out".  We
   2439    create as much of the ELF structure as possible.  */
   2440 static int
   2441 ld_generic_open_outfile (struct ld_state *statep, int machine, int klass,
   2442 			 int data)
   2443 {
   2444   /* We do not create the new file right away with the final name.
   2445      This would destroy an existing file with this name before a
   2446      replacement is finalized.  We create instead a temporary file in
   2447      the same directory.  */
   2448   if (ld_state.outfname == NULL)
   2449     ld_state.outfname = "a.out";
   2450 
   2451   size_t outfname_len = strlen (ld_state.outfname);
   2452   char *tempfname = (char *) obstack_alloc (&ld_state.smem,
   2453 					    outfname_len + sizeof (".XXXXXX"));
   2454   ld_state.tempfname = tempfname;
   2455 
   2456   int fd;
   2457   int try = 0;
   2458   while (1)
   2459     {
   2460       strcpy (mempcpy (tempfname, ld_state.outfname, outfname_len), ".XXXXXX");
   2461 
   2462       /* The useof mktemp() here is fine.  We do not want to use
   2463 	 mkstemp() since then the umask isn't used.  And the output
   2464 	 file will have these permissions anyhow.  Any intruder could
   2465 	 change the file later if it would be possible now.  */
   2466       if (mktemp (tempfname) != NULL
   2467 	  && (fd = open (tempfname, O_RDWR | O_EXCL | O_CREAT | O_NOFOLLOW,
   2468 			 ld_state.file_type == relocatable_file_type
   2469 			 ? DEFFILEMODE : ACCESSPERMS)) != -1)
   2470 	break;
   2471 
   2472       /* Failed this round.  We keep trying a number of times.  */
   2473       if (++try >= 10)
   2474 	error (EXIT_FAILURE, errno, gettext ("cannot create output file"));
   2475     }
   2476   ld_state.outfd = fd;
   2477 
   2478   /* Make sure we remove the temporary file in case something goes
   2479      wrong.  */
   2480   on_exit (remove_tempfile, NULL);
   2481 
   2482   /* Create the ELF file data for the output file.  */
   2483   Elf *elf = ld_state.outelf = elf_begin (fd,
   2484 					  conserve_memory
   2485 					  ? ELF_C_WRITE : ELF_C_WRITE_MMAP,
   2486 					  NULL);
   2487   if (elf == NULL)
   2488     error (EXIT_FAILURE, 0,
   2489 	   gettext ("cannot create ELF descriptor for output file: %s"),
   2490 	   elf_errmsg (-1));
   2491 
   2492   /* Create the basic data structures.  */
   2493   if (! xelf_newehdr (elf, klass))
   2494     /* Couldn't create the ELF header.  Very bad.  */
   2495     error (EXIT_FAILURE, 0,
   2496 	   gettext ("could not create ELF header for output file: %s"),
   2497 	   elf_errmsg (-1));
   2498 
   2499   /* And get the current header so that we can modify it.  */
   2500   XElf_Ehdr_vardef (ehdr);
   2501   xelf_getehdr (elf, ehdr);
   2502   assert (ehdr != NULL);
   2503 
   2504   /* Set the machine type.  */
   2505   ehdr->e_machine = machine;
   2506 
   2507   /* Modify it according to the info we have here and now.  */
   2508   if (ld_state.file_type == executable_file_type)
   2509     ehdr->e_type = ET_EXEC;
   2510   else if (ld_state.file_type == dso_file_type)
   2511     ehdr->e_type = ET_DYN;
   2512   else
   2513     {
   2514       assert (ld_state.file_type == relocatable_file_type);
   2515       ehdr->e_type = ET_REL;
   2516     }
   2517 
   2518   /* Set the ELF version.  */
   2519   ehdr->e_version = EV_CURRENT;
   2520 
   2521   /* Set the endianness.  */
   2522   ehdr->e_ident[EI_DATA] = data;
   2523 
   2524   /* Write the ELF header information back.  */
   2525   (void) xelf_update_ehdr (elf, ehdr);
   2526 
   2527   return 0;
   2528 }
   2529 
   2530 
   2531 /* We compute the offsets of the various copied objects and the total
   2532    size of the memory needed.  */
   2533 // XXX The method used here is simple: go from front to back and pack
   2534 // the objects in this order.  A more space efficient way would
   2535 // actually trying to pack the objects as dense as possible.  But this
   2536 // is more expensive.
   2537 static void
   2538 compute_copy_reloc_offset (XElf_Shdr *shdr)
   2539 {
   2540   struct symbol *runp = ld_state.from_dso;
   2541   assert (runp != NULL);
   2542 
   2543   XElf_Off maxalign = 1;
   2544   XElf_Off offset = 0;
   2545 
   2546   do
   2547     if (runp->need_copy)
   2548       {
   2549 	/* Determine alignment for the symbol.  */
   2550 	// XXX The question is how?  The symbol record itself does not
   2551 	// have the information.  So we have to be conservative and
   2552 	// assume the alignment of the section the symbol is in.
   2553 
   2554 	// XXX We can be more precise.  Use the offset from the beginning
   2555 	// of the section and determine the largest power of two with
   2556 	// module zero.
   2557 	XElf_Off symalign = MAX (SCNINFO_SHDR (runp->file->scninfo[runp->scndx].shdr).sh_addralign, 1);
   2558 	/* Keep track of the maximum alignment requirement.  */
   2559 	maxalign = MAX (maxalign, symalign);
   2560 
   2561 	/* Align current position.  */
   2562 	offset = (offset + symalign - 1) & ~(symalign - 1);
   2563 
   2564 	runp->merge.value = offset;
   2565 
   2566 	offset += runp->size;
   2567       }
   2568   while ((runp = runp->next) != ld_state.from_dso);
   2569 
   2570   shdr->sh_type = SHT_NOBITS;
   2571   shdr->sh_size = offset;
   2572   shdr->sh_addralign = maxalign;
   2573 }
   2574 
   2575 
   2576 static void
   2577 compute_common_symbol_offset (XElf_Shdr *shdr)
   2578 {
   2579   struct symbol *runp = ld_state.common_syms;
   2580   assert (runp != NULL);
   2581 
   2582   XElf_Off maxalign = 1;
   2583   XElf_Off offset = 0;
   2584 
   2585   do
   2586     {
   2587       /* Determine alignment for the symbol.  */
   2588       XElf_Off symalign = runp->merge.value;
   2589 
   2590       /* Keep track of the maximum alignment requirement.  */
   2591       maxalign = MAX (maxalign, symalign);
   2592 
   2593       /* Align current position.  */
   2594       offset = (offset + symalign - 1) & ~(symalign - 1);
   2595 
   2596       runp->merge.value = offset;
   2597 
   2598       offset += runp->size;
   2599     }
   2600   while ((runp = runp->next) != ld_state.common_syms);
   2601 
   2602   shdr->sh_type = SHT_NOBITS;
   2603   shdr->sh_size = offset;
   2604   shdr->sh_addralign = maxalign;
   2605 }
   2606 
   2607 
   2608 static void
   2609 sort_sections_generic (void)
   2610 {
   2611   /* XXX TBI */
   2612   abort ();
   2613 }
   2614 
   2615 
   2616 static int
   2617 match_section (const char *osectname, struct filemask_section_name *sectmask,
   2618 	       struct scnhead **scnhead, bool new_section, size_t segment_nr)
   2619 {
   2620   struct scninfo *prevp;
   2621   struct scninfo *runp;
   2622   struct scninfo *notused;
   2623 
   2624   if (fnmatch (sectmask->section_name->name, (*scnhead)->name, 0) != 0)
   2625     /* The section name does not match.  */
   2626     return new_section;
   2627 
   2628   /* If this is a section generated by the linker it doesn't contain
   2629      the regular information (i.e., input section data etc) and must
   2630      be handle special.  */
   2631   if ((*scnhead)->kind != scn_normal)
   2632     {
   2633       (*scnhead)->name = osectname;
   2634       (*scnhead)->segment_nr = segment_nr;
   2635 
   2636       /* We have to count note section since they get their own
   2637 	 program header entry.  */
   2638       if ((*scnhead)->type == SHT_NOTE)
   2639 	++ld_state.nnotesections;
   2640 
   2641       ld_state.allsections[ld_state.nallsections++] = (*scnhead);
   2642       return true;
   2643     }
   2644 
   2645   /* Now we have to match the file names of the input files.  Some of
   2646      the sections here might not match.    */
   2647   runp = (*scnhead)->last->next;
   2648   prevp = (*scnhead)->last;
   2649   notused = NULL;
   2650 
   2651   do
   2652     {
   2653       /* Base of the file name the section comes from.  */
   2654       const char *brfname = basename (runp->fileinfo->rfname);
   2655 
   2656       /* If the section isn't used, the name doesn't match the positive
   2657 	 inclusion list or the name does match the negative inclusion
   2658 	 list, ignore the section.  */
   2659       if (!runp->used
   2660 	  || (sectmask->filemask != NULL
   2661 	      && fnmatch (sectmask->filemask, brfname, 0) != 0)
   2662 	  || (sectmask->excludemask != NULL
   2663 	      && fnmatch (sectmask->excludemask, brfname, 0) == 0))
   2664 	{
   2665 	  /* This file does not match the file name masks.  */
   2666 	  if (notused == NULL)
   2667 	    notused = runp;
   2668 
   2669 	  prevp = runp;
   2670 	  runp = runp->next;
   2671 	  if (runp == notused)
   2672 	    runp = NULL;
   2673 	}
   2674       /* The section fulfills all requirements, add it to the output
   2675 	 file with the correct section name etc.  */
   2676       else
   2677 	{
   2678 	  struct scninfo *found = runp;
   2679 
   2680 	  /* Remove this input section data buffer from the list.  */
   2681 	  if (prevp != runp)
   2682 	    runp = prevp->next = runp->next;
   2683 	  else
   2684 	    {
   2685 	      free (*scnhead);
   2686 	      *scnhead = NULL;
   2687 	      runp = NULL;
   2688 	    }
   2689 
   2690 	  /* Create a new section for the output file if the 'new_section'
   2691 	     flag says so.  Otherwise append the buffer to the last
   2692 	     section which we created in one of the last calls.  */
   2693 	  if (new_section)
   2694 	    {
   2695 	      struct scnhead *newp;
   2696 
   2697 	      newp = (struct scnhead *) obstack_calloc (&ld_state.smem,
   2698 							sizeof (*newp));
   2699 	      newp->kind = scn_normal;
   2700 	      newp->name = osectname;
   2701 	      newp->type = SCNINFO_SHDR (found->shdr).sh_type;
   2702 	      newp->flags = SCNINFO_SHDR (found->shdr).sh_flags;
   2703 	      newp->segment_nr = segment_nr;
   2704 	      newp->last = found->next = found;
   2705 	      newp->used = true;
   2706 	      newp->relsize = found->relsize;
   2707 	      newp->entsize = SCNINFO_SHDR (found->shdr).sh_entsize;
   2708 
   2709 	      /* We have to count note section since they get their own
   2710 		 program header entry.  */
   2711 	      if (newp->type == SHT_NOTE)
   2712 		++ld_state.nnotesections;
   2713 
   2714 	      ld_state.allsections[ld_state.nallsections++] = newp;
   2715 	      new_section = false;
   2716 	    }
   2717 	  else
   2718 	    {
   2719 	      struct scnhead *queued;
   2720 
   2721 	      queued = ld_state.allsections[ld_state.nallsections - 1];
   2722 
   2723 	      found->next = queued->last->next;
   2724 	      queued->last = queued->last->next = found;
   2725 
   2726 	      /* If the linker script forces us to add incompatible
   2727 		 sections together do so.  But reflect this in the
   2728 		 type and flags of the resulting file.  */
   2729 	      if (queued->type != SCNINFO_SHDR (found->shdr).sh_type)
   2730 		/* XXX Any better choice?  */
   2731 		queued->type = SHT_PROGBITS;
   2732 	      if (queued->flags != SCNINFO_SHDR (found->shdr).sh_flags)
   2733 		queued->flags = ebl_sh_flags_combine (ld_state.ebl,
   2734 						      queued->flags,
   2735 						      SCNINFO_SHDR (found->shdr).sh_flags);
   2736 
   2737 	      /* Accumulate the relocation section size.  */
   2738 	      queued->relsize += found->relsize;
   2739 	    }
   2740 	}
   2741     }
   2742   while (runp != NULL);
   2743 
   2744   return new_section;
   2745 }
   2746 
   2747 
   2748 static void
   2749 sort_sections_lscript (void)
   2750 {
   2751   struct scnhead *temp[ld_state.nallsections];
   2752 
   2753   /* Make a copy of the section head pointer array.  */
   2754   memcpy (temp, ld_state.allsections,
   2755 	  ld_state.nallsections * sizeof (temp[0]));
   2756   size_t nallsections = ld_state.nallsections;
   2757 
   2758   /* Convert the output segment list in a single-linked list.  */
   2759   struct output_segment *segment = ld_state.output_segments->next;
   2760   ld_state.output_segments->next = NULL;
   2761   ld_state.output_segments = segment;
   2762 
   2763   /* Put the sections in the correct order in the array in the state
   2764      structure.  This might involve merging of sections and also
   2765      renaming the containing section in the output file.  */
   2766   ld_state.nallsections = 0;
   2767   size_t segment_nr;
   2768   size_t last_writable = ~0;
   2769   for (segment_nr = 0; segment != NULL; segment = segment->next, ++segment_nr)
   2770     {
   2771       struct output_rule *orule;
   2772 
   2773       for (orule = segment->output_rules; orule != NULL; orule = orule->next)
   2774 	if (orule->tag == output_section)
   2775 	  {
   2776 	    struct input_rule *irule;
   2777 	    bool new_section = true;
   2778 
   2779 	    for (irule = orule->val.section.input; irule != NULL;
   2780 		 irule = irule->next)
   2781 	      if (irule->tag == input_section)
   2782 		{
   2783 		  size_t cnt;
   2784 
   2785 		  for (cnt = 0; cnt < nallsections; ++cnt)
   2786 		    if (temp[cnt] != NULL)
   2787 		      new_section =
   2788 			match_section (orule->val.section.name,
   2789 				       irule->val.section, &temp[cnt],
   2790 				       new_section, segment_nr);
   2791 		}
   2792 	  }
   2793 
   2794       if ((segment->mode & PF_W) != 0)
   2795 	last_writable = ld_state.nallsections - 1;
   2796     }
   2797 
   2798   /* In case we have to create copy relocations or we have common
   2799      symbols, find the last writable segment and add one more data
   2800      block.  It will be a NOBITS block and take up no disk space.
   2801      This is why it is important to get the last block.  */
   2802   if (ld_state.ncopy > 0 || ld_state.common_syms !=  NULL)
   2803     {
   2804       if (last_writable == ~0)
   2805 	error (EXIT_FAILURE, 0, "no writable segment");
   2806 
   2807       if (ld_state.allsections[last_writable]->type != SHT_NOBITS)
   2808 	{
   2809 	  /* Make room in the ALLSECTIONS array for a new section.
   2810 	     There is guaranteed room in the array.  We add the new
   2811 	     entry after the last writable section.  */
   2812 	  ++last_writable;
   2813 	  memmove (&ld_state.allsections[last_writable + 1],
   2814 		   &ld_state.allsections[last_writable],
   2815 		   (ld_state.nallsections - last_writable)
   2816 		   * sizeof (ld_state.allsections[0]));
   2817 
   2818 	  ld_state.allsections[last_writable] = (struct scnhead *)
   2819 	    obstack_calloc (&ld_state.smem, sizeof (struct scnhead));
   2820 
   2821 	  /* Name for the new section.  */
   2822 	  ld_state.allsections[last_writable]->name = ".bss";
   2823 	  /* Type: NOBITS.  */
   2824 	  ld_state.allsections[last_writable]->type = SHT_NOBITS;
   2825 	  /* Same segment as the last writable section.  */
   2826 	  ld_state.allsections[last_writable]->segment_nr
   2827 	    = ld_state.allsections[last_writable - 1]->segment_nr;
   2828 	}
   2829     }
   2830 
   2831   /* Create common symbol data block.  */
   2832   if (ld_state.ncopy > 0)
   2833     {
   2834 #if NATIVE_ELF
   2835       struct scninfo *si = (struct scninfo *)
   2836 	obstack_calloc (&ld_state.smem, sizeof (*si) + sizeof (XElf_Shdr));
   2837       si->shdr = (XElf_Shdr *) (si + 1);
   2838 #else
   2839       struct scninfo *si = (struct scninfo *) obstack_calloc (&ld_state.smem,
   2840 							      sizeof (*si));
   2841 #endif
   2842 
   2843       /* Get the information regarding the symbols with copy relocations.  */
   2844       compute_copy_reloc_offset (&SCNINFO_SHDR (si->shdr));
   2845 
   2846       /* This section is needed.  */
   2847       si->used = true;
   2848       /* Remember for later the section data structure.  */
   2849       ld_state.copy_section = si;
   2850 
   2851       if (likely (ld_state.allsections[last_writable]->last != NULL))
   2852 	{
   2853 	  si->next = ld_state.allsections[last_writable]->last->next;
   2854 	  ld_state.allsections[last_writable]->last->next = si;
   2855 	  ld_state.allsections[last_writable]->last = si;
   2856 	}
   2857       else
   2858 	ld_state.allsections[last_writable]->last = si->next = si;
   2859     }
   2860 
   2861   /* Create common symbol data block.  */
   2862   if (ld_state.common_syms != NULL)
   2863     {
   2864 #if NATIVE_ELF
   2865       struct scninfo *si = (struct scninfo *)
   2866 	obstack_calloc (&ld_state.smem, sizeof (*si) + sizeof (XElf_Shdr));
   2867       si->shdr = (XElf_Shdr *) (si + 1);
   2868 #else
   2869       struct scninfo *si = (struct scninfo *) obstack_calloc (&ld_state.smem,
   2870 							      sizeof (*si));
   2871 #endif
   2872 
   2873       /* Get the information regarding the symbols with copy relocations.  */
   2874       compute_common_symbol_offset (&SCNINFO_SHDR (si->shdr));
   2875 
   2876       /* This section is needed.  */
   2877       si->used = true;
   2878       /* Remember for later the section data structure.  */
   2879       ld_state.common_section = si;
   2880 
   2881       if (likely (ld_state.allsections[last_writable]->last != NULL))
   2882 	{
   2883 	  si->next = ld_state.allsections[last_writable]->last->next;
   2884 	  ld_state.allsections[last_writable]->last->next = si;
   2885 	  ld_state.allsections[last_writable]->last = si;
   2886 	}
   2887       else
   2888 	ld_state.allsections[last_writable]->last = si->next = si;
   2889     }
   2890 }
   2891 
   2892 
   2893 /* Create the output sections now.  This requires knowledge about all
   2894    the sections we will need.  It may be necessary to sort sections in
   2895    the order they are supposed to appear in the executable.  The
   2896    sorting use many different kinds of information to optimize the
   2897    resulting binary.  Important is to respect segment boundaries and
   2898    the needed alignment.  The mode of the segments will be determined
   2899    afterwards automatically by the output routines.
   2900 
   2901    The generic sorting routines work in one of two possible ways:
   2902 
   2903    - if a linker script specifies the sections to be used in the
   2904      output and assigns them to a segment this information is used;
   2905 
   2906    - otherwise the linker will order the sections based on permissions
   2907      and some special knowledge about section names.*/
   2908 static void
   2909 ld_generic_create_sections (struct ld_state *statep)
   2910 {
   2911   struct scngroup *groups;
   2912   size_t cnt;
   2913 
   2914   /* For relocatable object we don't have to bother sorting the
   2915      sections and we do want to preserve the relocation sections as
   2916      they appear in the input files.  */
   2917   if (ld_state.file_type != relocatable_file_type)
   2918     {
   2919       /* Collect all the relocation sections.  They are handled
   2920 	 separately.  */
   2921       struct scninfo *list = NULL;
   2922       for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
   2923 	if ((ld_state.allsections[cnt]->type == SHT_REL
   2924 	     || ld_state.allsections[cnt]->type == SHT_RELA)
   2925 	    /* The generated relocation sections are not of any
   2926 	       interest here.  */
   2927 	    && ld_state.allsections[cnt]->last != NULL)
   2928 	  {
   2929 	    if (list == NULL)
   2930 	      list = ld_state.allsections[cnt]->last;
   2931 	    else
   2932 	      {
   2933 		/* Merge the sections list.  */
   2934 		struct scninfo *first = list->next;
   2935 		list->next = ld_state.allsections[cnt]->last->next;
   2936 		ld_state.allsections[cnt]->last->next = first;
   2937 		list = ld_state.allsections[cnt]->last;
   2938 	      }
   2939 
   2940 	    /* Remove the entry from the section list.  */
   2941 	    ld_state.allsections[cnt] = NULL;
   2942 	  }
   2943       ld_state.rellist = list;
   2944 
   2945       if (ld_state.output_segments == NULL)
   2946 	/* Sort using builtin rules.  */
   2947 	sort_sections_generic ();
   2948       else
   2949 	sort_sections_lscript ();
   2950     }
   2951 
   2952   /* Now iterate over the input sections and create the sections in the
   2953      order they are required in the output file.  */
   2954   for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
   2955     {
   2956       struct scnhead *head = ld_state.allsections[cnt];
   2957       Elf_Scn *scn;
   2958       XElf_Shdr_vardef (shdr);
   2959 
   2960       /* Don't handle unused sections.  */
   2961       if (!head->used)
   2962 	continue;
   2963 
   2964       /* We first have to create the section group if necessary.
   2965 	 Section group sections must come (in section index order)
   2966 	 before any of the section contained.  This all is necessary
   2967 	 only for relocatable object as other object types are not
   2968 	 allowed to contain section groups.  */
   2969       if (ld_state.file_type == relocatable_file_type
   2970 	  && unlikely (head->flags & SHF_GROUP))
   2971 	{
   2972 	  /* There is at least one section which is contained in a
   2973 	     section group in the input file.  This means we must
   2974 	     create a section group here as well.  The only problem is
   2975 	     that not all input files have to have to same kind of
   2976 	     partitioning of the sections.  I.e., sections A and B in
   2977 	     one input file and sections B and C in another input file
   2978 	     can be in one group.  That will result in a group
   2979 	     containing the sections A, B, and C in the output
   2980 	     file.  */
   2981 	  struct scninfo *runp;
   2982 	  Elf32_Word here_groupidx = 0;
   2983 	  struct scngroup *here_group;
   2984 	  struct member *newp;
   2985 
   2986 	  /* First check whether any section is already in a group.
   2987 	     In this case we have to add this output section, too.  */
   2988 	  runp = head->last;
   2989 	  do
   2990 	    {
   2991 	      assert (runp->grpid != 0);
   2992 
   2993 	      here_groupidx = runp->fileinfo->scninfo[runp->grpid].outscnndx;
   2994 	      if (here_groupidx != 0)
   2995 		break;
   2996 	    }
   2997 	  while ((runp = runp->next) != head->last);
   2998 
   2999 	  if (here_groupidx == 0)
   3000 	    {
   3001 	      /* We need a new section group section.  */
   3002 	      scn = elf_newscn (ld_state.outelf);
   3003 	      xelf_getshdr (scn, shdr);
   3004 	      if (shdr == NULL)
   3005 		error (EXIT_FAILURE, 0,
   3006 		       gettext ("cannot create section for output file: %s"),
   3007 		       elf_errmsg (-1));
   3008 
   3009 	      here_group = (struct scngroup *) xmalloc (sizeof (*here_group));
   3010 	      here_group->outscnidx = here_groupidx = elf_ndxscn (scn);
   3011 	      here_group->nscns = 0;
   3012 	      here_group->member = NULL;
   3013 	      here_group->next = ld_state.groups;
   3014 	      /* Pick a name for the section.  To keep it meaningful
   3015 		 we use a name used in the input files.  If the
   3016 		 section group in the output file should contain
   3017 		 section which were in section groups of different
   3018 		 names in the input files this is the users
   3019 		 problem.  */
   3020 	      here_group->nameent
   3021 		= ebl_strtabadd (ld_state.shstrtab,
   3022 				 elf_strptr (runp->fileinfo->elf,
   3023 					     runp->fileinfo->shstrndx,
   3024 					     SCNINFO_SHDR (runp->shdr).sh_name),
   3025 				 0);
   3026 	      /* Signature symbol.  */
   3027 	      here_group->symbol
   3028 		= runp->fileinfo->scninfo[runp->grpid].symbols;
   3029 
   3030 	      ld_state.groups = here_group;
   3031 	    }
   3032 	  else
   3033 	    {
   3034 	      /* Search for the group with this index.  */
   3035 	      here_group = ld_state.groups;
   3036 	      while (here_group->outscnidx != here_groupidx)
   3037 		here_group = here_group->next;
   3038 	    }
   3039 
   3040 	  /* Add the new output section.  */
   3041 	  newp = (struct member *) alloca (sizeof (*newp));
   3042 	  newp->scn = head;
   3043 #ifndef NDT_NEEDED
   3044 	  newp->next = NULL;
   3045 #endif
   3046 	  CSNGL_LIST_ADD_REAR (here_group->member, newp);
   3047 	  ++here_group->nscns;
   3048 
   3049 	  /* Store the section group index in all input files.  */
   3050 	  runp = head->last;
   3051 	  do
   3052 	    {
   3053 	      assert (runp->grpid != 0);
   3054 
   3055 	      if (runp->fileinfo->scninfo[runp->grpid].outscnndx == 0)
   3056 		runp->fileinfo->scninfo[runp->grpid].outscnndx = here_groupidx;
   3057 	      else
   3058 		assert (runp->fileinfo->scninfo[runp->grpid].outscnndx
   3059 			== here_groupidx);
   3060 	    }
   3061 	  while ((runp = runp->next) != head->last);
   3062 	}
   3063 
   3064       /* We'll use this section so get it's name in the section header
   3065 	 string table.  */
   3066       if (head->kind == scn_normal)
   3067 	head->nameent = ebl_strtabadd (ld_state.shstrtab, head->name, 0);
   3068 
   3069       /* Create a new section in the output file and add all data
   3070 	 from all the sections we read.  */
   3071       scn = elf_newscn (ld_state.outelf);
   3072       head->scnidx = elf_ndxscn (scn);
   3073       xelf_getshdr (scn, shdr);
   3074       if (shdr == NULL)
   3075 	error (EXIT_FAILURE, 0,
   3076 	       gettext ("cannot create section for output file: %s"),
   3077 	       elf_errmsg (-1));
   3078 
   3079       assert (head->type != SHT_NULL);
   3080       assert (head->type != SHT_SYMTAB);
   3081       assert (head->type != SHT_DYNSYM || head->kind != scn_normal);
   3082       assert (head->type != SHT_STRTAB || head->kind != scn_normal);
   3083       assert (head->type != SHT_GROUP);
   3084       shdr->sh_type = head->type;
   3085       shdr->sh_flags = head->flags;
   3086       shdr->sh_addralign = head->align;
   3087       shdr->sh_entsize = head->entsize;
   3088       assert (shdr->sh_entsize != 0 || (shdr->sh_flags & SHF_MERGE) == 0);
   3089       (void) xelf_update_shdr (scn, shdr);
   3090 
   3091       /* We have to know the section index of the dynamic symbol table
   3092 	 right away.  */
   3093       if (head->kind == scn_dot_dynsym)
   3094 	ld_state.dynsymscnidx = elf_ndxscn (scn);
   3095     }
   3096 
   3097   /* Actually create the section group sections.  */
   3098   groups = ld_state.groups;
   3099   while (groups != NULL)
   3100     {
   3101       Elf_Scn *scn;
   3102       Elf_Data *data;
   3103       Elf32_Word *grpdata;
   3104       struct member *runp;
   3105 
   3106       scn = elf_getscn (ld_state.outelf, groups->outscnidx);
   3107       assert (scn != NULL);
   3108 
   3109       data = elf_newdata (scn);
   3110       if (data == NULL)
   3111 	error (EXIT_FAILURE, 0,
   3112 	       gettext ("cannot create section for output file: %s"),
   3113 	       elf_errmsg (-1));
   3114 
   3115       data->d_size = (groups->nscns + 1) * sizeof (Elf32_Word);
   3116       data->d_buf = grpdata = (Elf32_Word *) xmalloc (data->d_size);
   3117       data->d_type = ELF_T_WORD;
   3118       data->d_version = EV_CURRENT;
   3119       data->d_off = 0;
   3120       /* XXX What better to use?  */
   3121       data->d_align = sizeof (Elf32_Word);
   3122 
   3123       /* The first word in the section is the flag word.  */
   3124       /* XXX Set COMDATA flag is necessary.  */
   3125       grpdata[0] = 0;
   3126 
   3127       runp = groups->member->next;
   3128       cnt = 1;
   3129       do
   3130 	/* Fill in the index of the section.  */
   3131 	grpdata[cnt++] = runp->scn->scnidx;
   3132       while ((runp = runp->next) != groups->member->next);
   3133 
   3134       groups = groups->next;
   3135     }
   3136 }
   3137 
   3138 
   3139 static bool
   3140 reduce_symbol_p (XElf_Sym *sym, struct Ebl_Strent *strent)
   3141 {
   3142   const char *str;
   3143   const char *version;
   3144   struct id_list search;
   3145   struct id_list *verp;
   3146   bool result = ld_state.default_bind_local;
   3147 
   3148   if (XELF_ST_BIND (sym->st_info) == STB_LOCAL || sym->st_shndx == SHN_UNDEF)
   3149     /* We don't have to do anything to local symbols here.  */
   3150     /* XXX Any section value in [SHN_LORESERVER,SHN_XINDEX) need
   3151        special treatment?  */
   3152     return false;
   3153 
   3154   /* XXX Handle other symbol bindings.  */
   3155   assert (XELF_ST_BIND (sym->st_info) == STB_GLOBAL
   3156 	  || XELF_ST_BIND (sym->st_info) == STB_WEAK);
   3157 
   3158   str = ebl_string (strent);
   3159   version = strchr (str, VER_CHR);
   3160   if (version != NULL)
   3161     {
   3162       search.id = strndupa (str, version - str);
   3163       if (*++version == VER_CHR)
   3164 	/* Skip the second '@' signalling a default definition.  */
   3165 	++version;
   3166     }
   3167   else
   3168     {
   3169       search.id = str;
   3170       version = "";
   3171     }
   3172 
   3173   verp = ld_version_str_tab_find (&ld_state.version_str_tab,
   3174 				  elf_hash (search.id), &search);
   3175   while (verp != NULL)
   3176     {
   3177       /* We have this symbol in the version hash table.  Now match the
   3178 	 version name.  */
   3179       if (strcmp (verp->u.s.versionname, version) == 0)
   3180 	/* Match!  */
   3181 	return verp->u.s.local;
   3182 
   3183       verp = verp->next;
   3184     }
   3185 
   3186   /* XXX Add test for wildcard version symbols.  */
   3187 
   3188   return result;
   3189 }
   3190 
   3191 
   3192 static XElf_Addr
   3193 eval_expression (struct expression *expr, XElf_Addr addr)
   3194 {
   3195   XElf_Addr val = ~((XElf_Addr) 0);
   3196 
   3197   switch (expr->tag)
   3198     {
   3199     case exp_num:
   3200       val = expr->val.num;
   3201       break;
   3202 
   3203     case exp_sizeof_headers:
   3204       {
   3205 	/* The 'elf_update' call determine the offset of the first
   3206 	   section.  The the size of the header.  */
   3207 	XElf_Shdr_vardef (shdr);
   3208 
   3209 	xelf_getshdr (elf_getscn (ld_state.outelf, 1), shdr);
   3210 	assert (shdr != NULL);
   3211 
   3212 	val = shdr->sh_offset;
   3213       }
   3214       break;
   3215 
   3216     case exp_pagesize:
   3217       val = ld_state.pagesize;
   3218       break;
   3219 
   3220     case exp_id:
   3221       /* We are here computing only address expressions.  It seems not
   3222 	 to be necessary to handle any variable but ".".  Let's avoid
   3223 	 the complication.  If it turns up to be needed we can add
   3224 	 it.  */
   3225       if (strcmp (expr->val.str, ".") != 0)
   3226 	error (EXIT_FAILURE, 0, gettext ("\
   3227 address computation expression contains variable '%s'"),
   3228 	       expr->val.str);
   3229 
   3230       val = addr;
   3231       break;
   3232 
   3233     case exp_mult:
   3234       val = (eval_expression (expr->val.binary.left, addr)
   3235 	     * eval_expression (expr->val.binary.right, addr));
   3236       break;
   3237 
   3238     case exp_div:
   3239       val = (eval_expression (expr->val.binary.left, addr)
   3240 	     / eval_expression (expr->val.binary.right, addr));
   3241       break;
   3242 
   3243     case exp_mod:
   3244       val = (eval_expression (expr->val.binary.left, addr)
   3245 	     % eval_expression (expr->val.binary.right, addr));
   3246       break;
   3247 
   3248     case exp_plus:
   3249       val = (eval_expression (expr->val.binary.left, addr)
   3250 	     + eval_expression (expr->val.binary.right, addr));
   3251       break;
   3252 
   3253     case exp_minus:
   3254       val = (eval_expression (expr->val.binary.left, addr)
   3255 	     - eval_expression (expr->val.binary.right, addr));
   3256       break;
   3257 
   3258     case exp_and:
   3259       val = (eval_expression (expr->val.binary.left, addr)
   3260 	     & eval_expression (expr->val.binary.right, addr));
   3261       break;
   3262 
   3263     case exp_or:
   3264       val = (eval_expression (expr->val.binary.left, addr)
   3265 	     | eval_expression (expr->val.binary.right, addr));
   3266       break;
   3267 
   3268     case exp_align:
   3269       val = eval_expression (expr->val.child, addr);
   3270       if ((val & (val - 1)) != 0)
   3271 	error (EXIT_FAILURE, 0, gettext ("argument '%" PRIuMAX "' of ALIGN in address computation expression is no power of two"),
   3272 	       (uintmax_t) val);
   3273       val = (addr + val - 1) & ~(val - 1);
   3274       break;
   3275     }
   3276 
   3277   return val;
   3278 }
   3279 
   3280 
   3281 /* Find a good as possible size for the hash table so that all the
   3282    non-zero entries in HASHCODES don't collide too much and the table
   3283    isn't too large.  There is no exact formular for this so we use a
   3284    heuristic.  Depending on the optimization level the search is
   3285    longer or shorter.  */
   3286 static size_t
   3287 optimal_bucket_size (Elf32_Word *hashcodes, size_t maxcnt, int optlevel)
   3288 {
   3289   size_t minsize;
   3290   size_t maxsize;
   3291   size_t bestsize;
   3292   uint64_t bestcost;
   3293   size_t size;
   3294   uint32_t *counts;
   3295   uint32_t *lengths;
   3296 
   3297   if (maxcnt == 0)
   3298     return 0;
   3299 
   3300   /* When we are not optimizing we run only very few tests.  */
   3301   if (optlevel <= 0)
   3302     {
   3303       minsize = maxcnt;
   3304       maxsize = maxcnt + 10000 / maxcnt;
   3305     }
   3306   else
   3307     {
   3308       /* Does not make much sense to start with a smaller table than
   3309 	 one which has at least four collisions.  */
   3310       minsize = MAX (1, maxcnt / 4);
   3311       /* We look for a best fit in the range of up to eigth times the
   3312 	 number of elements.  */
   3313       maxsize = 2 * maxcnt + (6 * MIN (optlevel, 100) * maxcnt) / 100;
   3314     }
   3315   bestsize = maxcnt;
   3316   bestcost = UINT_MAX;
   3317 
   3318   /* Array for counting the collisions and chain lengths.  */
   3319   counts = (uint32_t *) xmalloc ((maxcnt + 1 + maxsize) * sizeof (uint32_t));
   3320   lengths = &counts[maxcnt + 1];
   3321 
   3322   for (size = minsize; size <= maxsize; ++size)
   3323     {
   3324       size_t inner;
   3325       uint64_t cost;
   3326       uint32_t maxlength;
   3327       uint64_t success;
   3328       uint32_t acc;
   3329       double factor;
   3330 
   3331       memset (lengths, '\0', size * sizeof (uint32_t));
   3332       memset (counts, '\0', (maxcnt + 1) * sizeof (uint32_t));
   3333 
   3334       /* Determine how often each hash bucket is used.  */
   3335       for (inner = 0; inner < maxcnt; ++inner)
   3336 	++lengths[hashcodes[inner] % size];
   3337 
   3338       /* Determine the lengths.  */
   3339       maxlength = 0;
   3340       for (inner = 0; inner < size; ++inner)
   3341 	{
   3342 	  ++counts[lengths[inner]];
   3343 
   3344 	  if (lengths[inner] > maxlength)
   3345 	    maxlength = lengths[inner];
   3346 	}
   3347 
   3348       /* Determine successful lookup length.  */
   3349       acc = 0;
   3350       success = 0;
   3351       for (inner = 0; inner <= maxlength; ++inner)
   3352 	{
   3353 	  acc += inner;
   3354 	  success += counts[inner] * acc;
   3355 	}
   3356 
   3357       /* We can compute two factors now: the average length of a
   3358 	 positive search and the average length of a negative search.
   3359 	 We count the number of comparisons which have to look at the
   3360 	 names themselves.  Recognizing that the chain ended is not
   3361 	 accounted for since it's almost for free.
   3362 
   3363 	 Which lookup is more important depends on the kind of DSO.
   3364 	 If it is a system DSO like libc it is expected that most
   3365 	 lookups succeed.  Otherwise most lookups fail.  */
   3366       if (ld_state.is_system_library)
   3367 	factor = (1.0 * (double) success / (double) maxcnt
   3368 		  + 0.3 * (double) maxcnt / (double) size);
   3369       else
   3370 	factor = (0.3 * (double) success / (double) maxcnt
   3371 		  + 1.0 * (double) maxcnt / (double) size);
   3372 
   3373       /* Combine the lookup cost factor.  The 1/16th addend adds
   3374 	 penalties for too large table sizes.  */
   3375       cost = (2 + maxcnt + size) * (factor + 1.0 / 16.0);
   3376 
   3377 #if 0
   3378       printf ("maxcnt = %d, size = %d, cost = %Ld, success = %g, fail = %g, factor = %g\n",
   3379 	      maxcnt, size, cost, (double) success / (double) maxcnt, (double) maxcnt / (double) size, factor);
   3380 #endif
   3381 
   3382       /* Compare with current best results.  */
   3383       if (cost < bestcost)
   3384 	{
   3385 	  bestcost = cost;
   3386 	  bestsize = size;
   3387 	}
   3388     }
   3389 
   3390   free (counts);
   3391 
   3392   return bestsize;
   3393 }
   3394 
   3395 
   3396 static XElf_Addr
   3397 find_entry_point (void)
   3398 {
   3399   XElf_Addr result;
   3400 
   3401   if (ld_state.entry != NULL)
   3402     {
   3403       struct symbol search = { .name = ld_state.entry };
   3404       struct symbol *syment;
   3405 
   3406       syment = ld_symbol_tab_find (&ld_state.symbol_tab,
   3407 				   elf_hash (ld_state.entry), &search);
   3408       if (syment != NULL && syment->defined)
   3409 	{
   3410 	  /* We found the symbol.  */
   3411 	  Elf_Data *data = elf_getdata (elf_getscn (ld_state.outelf,
   3412 						    ld_state.symscnidx), NULL);
   3413 
   3414 	  XElf_Sym_vardef (sym);
   3415 
   3416 	  sym = NULL;
   3417 	  if (data != NULL)
   3418 	    xelf_getsym (data, ld_state.dblindirect[syment->outsymidx], sym);
   3419 
   3420 	  if (sym == NULL && ld_state.need_dynsym && syment->outdynsymidx != 0)
   3421 	    {
   3422 	      /* Use the dynamic symbol table if available.  */
   3423 	      data = elf_getdata (elf_getscn (ld_state.outelf,
   3424 					      ld_state.dynsymscnidx), NULL);
   3425 
   3426 	      sym = NULL;
   3427 	      if (data != NULL)
   3428 		xelf_getsym (data, syment->outdynsymidx, sym);
   3429 	    }
   3430 
   3431 	  if (sym != NULL)
   3432 	    return sym->st_value;
   3433 
   3434 	  /* XXX What to do if the output has no non-dynamic symbol
   3435 	     table and the dynamic symbol table does not contain the
   3436 	     symbol?  */
   3437 	  assert (ld_state.need_symtab);
   3438 	  assert (ld_state.symscnidx != 0);
   3439 	}
   3440     }
   3441 
   3442   /* We couldn't find the symbol or none was given.  Use the first
   3443      address of the ".text" section then.  */
   3444 
   3445 
   3446   result = 0;
   3447 
   3448   /* In DSOs this is no fatal error.  They usually have no entry
   3449      points.  In this case we set the entry point to zero, which makes
   3450      sure it will always fail.  */
   3451   if (ld_state.file_type == executable_file_type)
   3452     {
   3453       if (ld_state.entry != NULL)
   3454 	error (0, 0, gettext ("\
   3455 cannot find entry symbol \"%s\": defaulting to %#0*" PRIx64),
   3456 	       ld_state.entry,
   3457 	       xelf_getclass (ld_state.outelf) == ELFCLASS32 ? 10 : 18,
   3458 	       (uint64_t) result);
   3459       else
   3460 	error (0, 0, gettext ("\
   3461 no entry symbol specified: defaulting to %#0*" PRIx64),
   3462 	       xelf_getclass (ld_state.outelf) == ELFCLASS32 ? 10 : 18,
   3463 	       (uint64_t) result);
   3464     }
   3465 
   3466   return result;
   3467 }
   3468 
   3469 
   3470 static void
   3471 fillin_special_symbol (struct symbol *symst, size_t scnidx, size_t nsym,
   3472 		       Elf_Data *symdata, struct Ebl_Strtab *strtab)
   3473 {
   3474   assert (ld_state.file_type != relocatable_file_type);
   3475 
   3476   XElf_Sym_vardef (sym);
   3477   xelf_getsym_ptr (symdata, nsym, sym);
   3478 
   3479   /* The name offset will be filled in later.  */
   3480   sym->st_name = 0;
   3481   /* Traditionally: globally visible.  */
   3482   sym->st_info = XELF_ST_INFO (STB_GLOBAL, symst->type);
   3483   /* No special visibility or so.  */
   3484   sym->st_other = 0;
   3485   /* Reference to the GOT or dynamic section.  Since the GOT and
   3486      dynamic section are only created for executables and DSOs it
   3487      cannot be that the section index is too large.  */
   3488   assert (scnidx != 0);
   3489   assert (scnidx < SHN_LORESERVE || scnidx == SHN_ABS);
   3490   sym->st_shndx = scnidx;
   3491   /* We want the beginning of the section.  */
   3492   sym->st_value = 0;
   3493 
   3494   /* Determine the size of the section.  */
   3495   if (scnidx != SHN_ABS)
   3496     {
   3497       Elf_Data *data = elf_getdata (elf_getscn (ld_state.outelf, scnidx),
   3498 				    NULL);
   3499       assert (data != NULL);
   3500       sym->st_size = data->d_size;
   3501       /* Make sure there is no second data block.  */
   3502       assert (elf_getdata (elf_getscn (ld_state.outelf, scnidx), data)
   3503 	      == NULL);
   3504     }
   3505 
   3506   /* Insert symbol into the symbol table.  Note that we do not have to
   3507      use xelf_update_symshdx.  */
   3508   (void) xelf_update_sym (symdata, nsym, sym);
   3509 
   3510   /* Cross-references.  */
   3511   ndxtosym[nsym] = symst;
   3512   symst->outsymidx = nsym;
   3513 
   3514   /* Add the name to the string table.  */
   3515   symstrent[nsym] = ebl_strtabadd (strtab, symst->name, 0);
   3516 }
   3517 
   3518 
   3519 static void
   3520 new_dynamic_entry (Elf_Data *data, int idx, XElf_Sxword tag, XElf_Addr val)
   3521 {
   3522   XElf_Dyn_vardef (dyn);
   3523   xelf_getdyn_ptr (data, idx, dyn);
   3524   dyn->d_tag = tag;
   3525   dyn->d_un.d_ptr = val;
   3526   (void) xelf_update_dyn (data, idx, dyn);
   3527 }
   3528 
   3529 
   3530 static void
   3531 allocate_version_names (struct usedfiles *runp, struct Ebl_Strtab *dynstrtab)
   3532 {
   3533   /* If this DSO has no versions skip it.  */
   3534   if (runp->status != opened || runp->verdefdata == NULL)
   3535     return;
   3536 
   3537   /* Add the object name.  */
   3538   int offset = 0;
   3539   while (1)
   3540     {
   3541       XElf_Verdef_vardef (def);
   3542       XElf_Verdaux_vardef (aux);
   3543 
   3544       /* Get data at the next offset.  */
   3545       xelf_getverdef (runp->verdefdata, offset, def);
   3546       assert (def != NULL);
   3547       xelf_getverdaux (runp->verdefdata, offset + def->vd_aux, aux);
   3548       assert (aux != NULL);
   3549 
   3550       assert (def->vd_ndx <= runp->nverdef);
   3551       if (def->vd_ndx == 1 || runp->verdefused[def->vd_ndx] != 0)
   3552 	{
   3553 	  runp->verdefent[def->vd_ndx]
   3554 	    = ebl_strtabadd (dynstrtab, elf_strptr (runp->elf,
   3555 						    runp->dynsymstridx,
   3556 						    aux->vda_name), 0);
   3557 
   3558 	  if (def->vd_ndx > 1)
   3559 	    runp->verdefused[def->vd_ndx] = ld_state.nextveridx++;
   3560 	}
   3561 
   3562       if (def->vd_next == 0)
   3563 	/* That were all versions.  */
   3564 	break;
   3565 
   3566       offset += def->vd_next;
   3567     }
   3568 }
   3569 
   3570 
   3571 XElf_Off
   3572 create_verneed_data (XElf_Off offset, Elf_Data *verneeddata,
   3573 		     struct usedfiles *runp, int *ntotal)
   3574 {
   3575 	  size_t verneed_size = xelf_fsize (ld_state.outelf, ELF_T_VNEED, 1);
   3576 	  size_t vernaux_size = xelf_fsize (ld_state.outelf, ELF_T_VNAUX, 1);
   3577 	      int need_offset;
   3578 	      bool filled = false;
   3579 	      GElf_Verneed verneed;
   3580 	      GElf_Vernaux vernaux;
   3581 	      int ndef = 0;
   3582 size_t cnt;
   3583 
   3584 	      /* If this DSO has no versions skip it.  */
   3585 	      if (runp->nverdefused == 0)
   3586 		return offset;
   3587 
   3588 	      /* We fill in the Verneed record last.  Remember the
   3589 		 offset.  */
   3590 	      need_offset = offset;
   3591 	      offset += verneed_size;
   3592 
   3593 	      for (cnt = 2; cnt <= runp->nverdef; ++cnt)
   3594 		if (runp->verdefused[cnt] != 0)
   3595 		  {
   3596 		    assert (runp->verdefent[cnt] != NULL);
   3597 
   3598 		    if (filled)
   3599 		      {
   3600 			vernaux.vna_next = vernaux_size;
   3601 			(void) gelf_update_vernaux (verneeddata, offset,
   3602 						    &vernaux);
   3603 			offset += vernaux_size;
   3604 		      }
   3605 
   3606 		    vernaux.vna_hash
   3607 		      = elf_hash (ebl_string (runp->verdefent[cnt]));
   3608 		    vernaux.vna_flags = 0;
   3609 		    vernaux.vna_other = runp->verdefused[cnt];
   3610 		    vernaux.vna_name = ebl_strtaboffset (runp->verdefent[cnt]);
   3611 		    filled = true;
   3612 		    ++ndef;
   3613 		  }
   3614 
   3615 	      assert (filled);
   3616 	      vernaux.vna_next = 0;
   3617 	      (void) gelf_update_vernaux (verneeddata, offset, &vernaux);
   3618 	      offset += vernaux_size;
   3619 
   3620 	      verneed.vn_version = VER_NEED_CURRENT;
   3621 	      verneed.vn_cnt = ndef;
   3622 	      verneed.vn_file = ebl_strtaboffset (runp->verdefent[1]);
   3623 	      /* The first auxiliary entry is always found directly
   3624 		 after the verneed entry.  */
   3625 	      verneed.vn_aux = verneed_size;
   3626 	      verneed.vn_next = --*ntotal > 0 ? offset - need_offset : 0;
   3627 	      (void) gelf_update_verneed (verneeddata, need_offset,
   3628 					  &verneed);
   3629 
   3630 	      return offset;
   3631 }
   3632 
   3633 
   3634 /* Create the output file.
   3635 
   3636    For relocatable files what basically has to happen is that all
   3637    sections from all input files are written into the output file.
   3638    Sections with the same name are combined (offsets adjusted
   3639    accordingly).  The symbol tables are combined in one single table.
   3640    When stripping certain symbol table entries are omitted.
   3641 
   3642    For executables (shared or not) we have to create the program header,
   3643    additional sections like the .interp, eventually (in addition) create
   3644    a dynamic symbol table and a dynamic section.  Also the relocations
   3645 have to be processed differently.  */
   3646 static int
   3647 ld_generic_create_outfile (struct ld_state *statep)
   3648 {
   3649   struct scnlist
   3650   {
   3651     size_t scnidx;
   3652     struct scninfo *scninfo;
   3653     struct scnlist *next;
   3654   };
   3655   struct scnlist *rellist = NULL;
   3656   size_t cnt;
   3657   Elf_Scn *symscn = NULL;
   3658   Elf_Scn *xndxscn = NULL;
   3659   Elf_Scn *strscn = NULL;
   3660   struct Ebl_Strtab *strtab = NULL;
   3661   struct Ebl_Strtab *dynstrtab = NULL;
   3662   XElf_Shdr_vardef (shdr);
   3663   Elf_Data *data;
   3664   Elf_Data *symdata = NULL;
   3665   Elf_Data *xndxdata = NULL;
   3666   struct usedfiles *file;
   3667   size_t nsym;
   3668   size_t nsym_local;
   3669   size_t nsym_allocated;
   3670   size_t nsym_dyn = 0;
   3671   Elf32_Word *dblindirect = NULL;
   3672 #ifndef NDEBUG
   3673   bool need_xndx;
   3674 #endif
   3675   Elf_Scn *shstrtab_scn;
   3676   size_t shstrtab_ndx;
   3677   XElf_Ehdr_vardef (ehdr);
   3678   struct Ebl_Strent *symtab_ent = NULL;
   3679   struct Ebl_Strent *xndx_ent = NULL;
   3680   struct Ebl_Strent *strtab_ent = NULL;
   3681   struct Ebl_Strent *shstrtab_ent;
   3682   struct scngroup *groups;
   3683   Elf_Scn *dynsymscn = NULL;
   3684   Elf_Data *dynsymdata = NULL;
   3685   Elf_Data *dynstrdata = NULL;
   3686   Elf32_Word *hashcodes = NULL;
   3687   size_t nsym_dyn_allocated = 0;
   3688   Elf_Scn *versymscn = NULL;
   3689   Elf_Data *versymdata = NULL;
   3690 
   3691   if (ld_state.need_symtab)
   3692     {
   3693       /* First create the symbol table.  We need the symbol section itself
   3694 	 and the string table for it.  */
   3695       symscn = elf_newscn (ld_state.outelf);
   3696       ld_state.symscnidx = elf_ndxscn (symscn);
   3697       symdata = elf_newdata (symscn);
   3698       if (symdata == NULL)
   3699 	error (EXIT_FAILURE, 0,
   3700 	       gettext ("cannot create symbol table for output file: %s"),
   3701 	       elf_errmsg (-1));
   3702 
   3703       symdata->d_type = ELF_T_SYM;
   3704       /* This is an estimated size, but it will definitely cap the real value.
   3705 	 We might have to adjust the number later.  */
   3706       nsym_allocated = (1 + ld_state.nsymtab + ld_state.nplt + ld_state.ngot
   3707 			+ ld_state.nusedsections + ld_state.nlscript_syms);
   3708       symdata->d_size = xelf_fsize (ld_state.outelf, ELF_T_SYM,
   3709 				    nsym_allocated);
   3710 
   3711       /* Optionally the extended section table.  */
   3712       /* XXX Is SHN_LORESERVE correct?  Do we need some other sections?  */
   3713       if (unlikely (ld_state.nusedsections >= SHN_LORESERVE))
   3714 	{
   3715 	  xndxscn = elf_newscn (ld_state.outelf);
   3716 	  ld_state.xndxscnidx = elf_ndxscn (xndxscn);
   3717 
   3718 	  xndxdata = elf_newdata (xndxscn);
   3719 	  if (xndxdata == NULL)
   3720 	    error (EXIT_FAILURE, 0,
   3721 		   gettext ("cannot create symbol table for output file: %s"),
   3722 		   elf_errmsg (-1));
   3723 
   3724 	  /* The following relies on the fact that Elf32_Word and Elf64_Word
   3725 	     have the same size.  */
   3726 	  xndxdata->d_type = ELF_T_WORD;
   3727 	  /* This is an estimated size, but it will definitely cap the
   3728 	     real value.  we might have to adjust the number later.  */
   3729 	  xndxdata->d_size = xelf_fsize (ld_state.outelf, ELF_T_WORD,
   3730 					 nsym_allocated);
   3731 	  /* The first entry is left empty, clear it here and now.  */
   3732 	  xndxdata->d_buf = memset (xmalloc (xndxdata->d_size), '\0',
   3733 				    xelf_fsize (ld_state.outelf, ELF_T_WORD,
   3734 						1));
   3735 	  xndxdata->d_off = 0;
   3736 	  /* XXX Should use an ebl function.  */
   3737 	  xndxdata->d_align = sizeof (Elf32_Word);
   3738 	}
   3739     }
   3740   else
   3741     {
   3742       assert (ld_state.need_dynsym);
   3743 
   3744       /* First create the symbol table.  We need the symbol section itself
   3745 	 and the string table for it.  */
   3746       symscn = elf_getscn (ld_state.outelf, ld_state.dynsymscnidx);
   3747       symdata = elf_newdata (symscn);
   3748       if (symdata == NULL)
   3749 	error (EXIT_FAILURE, 0,
   3750 	       gettext ("cannot create symbol table for output file: %s"),
   3751 	       elf_errmsg (-1));
   3752 
   3753       symdata->d_version = EV_CURRENT;
   3754       symdata->d_type = ELF_T_SYM;
   3755       /* This is an estimated size, but it will definitely cap the real value.
   3756 	 We might have to adjust the number later.  */
   3757       nsym_allocated = (1 + ld_state.nsymtab + ld_state.nplt + ld_state.ngot
   3758 			- ld_state.nlocalsymbols + ld_state.nlscript_syms);
   3759       symdata->d_size = xelf_fsize (ld_state.outelf, ELF_T_SYM,
   3760 				    nsym_allocated);
   3761     }
   3762 
   3763   /* The first entry is left empty, clear it here and now.  */
   3764   symdata->d_buf = memset (xmalloc (symdata->d_size), '\0',
   3765 			   xelf_fsize (ld_state.outelf, ELF_T_SYM, 1));
   3766   symdata->d_off = 0;
   3767   /* XXX This is ugly but how else can it be done.  */
   3768   symdata->d_align = xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1);
   3769 
   3770   /* Allocate another array to keep track of the handles for the symbol
   3771      names.  */
   3772   symstrent = (struct Ebl_Strent **) xcalloc (nsym_allocated,
   3773 					      sizeof (struct Ebl_Strent *));
   3774 
   3775   /* By starting at 1 we effectively add a null entry.  */
   3776   nsym = 1;
   3777 
   3778   /* Iteration over all sections.  */
   3779   for (cnt = 0; cnt < ld_state.nallsections; ++cnt)
   3780     {
   3781       struct scnhead *head = ld_state.allsections[cnt];
   3782       Elf_Scn *scn;
   3783       struct scninfo *runp;
   3784       XElf_Off offset;
   3785       Elf32_Word xndx;
   3786 
   3787       /* Don't handle unused sections at all.  */
   3788       if (!head->used)
   3789 	continue;
   3790 
   3791       /* Get the section handle.  */
   3792       scn = elf_getscn (ld_state.outelf, head->scnidx);
   3793 
   3794       if (unlikely (head->kind == scn_dot_interp))
   3795 	{
   3796 	  Elf_Data *outdata = elf_newdata (scn);
   3797 	  if (outdata == NULL)
   3798 	    error (EXIT_FAILURE, 0,
   3799 		   gettext ("cannot create section for output file: %s"),
   3800 		   elf_errmsg (-1));
   3801 
   3802 	  /* This is the string we'll put in the section.  */
   3803 	  const char *interp = ld_state.interp ?: "/lib/ld.so.1";
   3804 
   3805 	  /* Create the section data.  */
   3806 	  outdata->d_buf = (void *) interp;
   3807 	  outdata->d_size = strlen (interp) + 1;
   3808 	  outdata->d_type = ELF_T_BYTE;
   3809 	  outdata->d_off = 0;
   3810 	  outdata->d_align = 1;
   3811 	  outdata->d_version = EV_CURRENT;
   3812 
   3813 	  /* Remember the index of this section.  */
   3814 	  ld_state.interpscnidx = head->scnidx;
   3815 
   3816 	  continue;
   3817 	}
   3818 
   3819       if (unlikely (head->kind == scn_dot_got))
   3820 	{
   3821 	  /* Remember the index of this section.  */
   3822 	  ld_state.gotscnidx = elf_ndxscn (scn);
   3823 
   3824 	  /* Give the backend the change to initialize the section.  */
   3825 	  INITIALIZE_GOT (&ld_state, scn);
   3826 
   3827 	  continue;
   3828 	}
   3829 
   3830       if (unlikely (head->kind == scn_dot_dynrel))
   3831 	{
   3832 	  Elf_Data *outdata;
   3833 
   3834 	  outdata = elf_newdata (scn);
   3835 	  if (outdata == NULL)
   3836 	    error (EXIT_FAILURE, 0,
   3837 		   gettext ("cannot create section for output file: %s"),
   3838 		   elf_errmsg (-1));
   3839 
   3840 	  outdata->d_size = ld_state.relsize_total;
   3841 	  outdata->d_buf = xmalloc (outdata->d_size);
   3842 	  outdata->d_type = (REL_TYPE (&ld_state) == DT_REL
   3843 			     ? ELF_T_REL : ELF_T_RELA);
   3844 	  outdata->d_off = 0;
   3845 	  outdata->d_align = xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1);
   3846 
   3847 	  /* Remember the index of this section.  */
   3848 	  ld_state.reldynscnidx = elf_ndxscn (scn);
   3849 
   3850 	  continue;
   3851 	}
   3852 
   3853       if (unlikely (head->kind == scn_dot_dynamic))
   3854 	{
   3855 	  /* Only create the data for now.  */
   3856 	  Elf_Data *outdata;
   3857 
   3858 	  /* Account for a few more entries we have to add.  */
   3859 	  if (ld_state.dt_flags != 0)
   3860 	    ++ld_state.ndynamic;
   3861 	  if (ld_state.dt_flags_1 != 0)
   3862 	    ++ld_state.ndynamic;
   3863 	  if (ld_state.dt_feature_1 != 0)
   3864 	    ++ld_state.ndynamic;
   3865 
   3866 	  outdata = elf_newdata (scn);
   3867 	  if (outdata == NULL)
   3868 	    error (EXIT_FAILURE, 0,
   3869 		   gettext ("cannot create section for output file: %s"),
   3870 		   elf_errmsg (-1));
   3871 
   3872 	  /* Create the section data.  */
   3873 	  outdata->d_size = xelf_fsize (ld_state.outelf, ELF_T_DYN,
   3874 					ld_state.ndynamic);
   3875 	  outdata->d_buf = xcalloc (1, outdata->d_size);
   3876 	  outdata->d_type = ELF_T_DYN;
   3877 	  outdata->d_off = 0;
   3878 	  outdata->d_align = xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1);
   3879 
   3880 	  /* Remember the index of this section.  */
   3881 	  ld_state.dynamicscnidx = elf_ndxscn (scn);
   3882 
   3883 	  continue;
   3884 	}
   3885 
   3886       if (unlikely (head->kind == scn_dot_dynsym))
   3887 	{
   3888 	  /* We already know the section index.  */
   3889 	  assert (ld_state.dynsymscnidx == elf_ndxscn (scn));
   3890 
   3891 	  continue;
   3892 	}
   3893 
   3894       if (unlikely (head->kind == scn_dot_dynstr))
   3895 	{
   3896 	  /* Remember the index of this section.  */
   3897 	  ld_state.dynstrscnidx = elf_ndxscn (scn);
   3898 
   3899 	  /* Create the string table.  */
   3900 	  dynstrtab = ebl_strtabinit (true);
   3901 
   3902 	  /* XXX TBI
   3903 	     We have to add all the strings which are needed in the
   3904 	     dynamic section here.  This means DT_FILTER,
   3905 	     DT_AUXILIARY, ... entries.  */
   3906 	  if (ld_state.ndsofiles > 0)
   3907 	    {
   3908 	      struct usedfiles *frunp = ld_state.dsofiles;
   3909 
   3910 	      do
   3911 		if (! ld_state.ignore_unused_dsos || frunp->used)
   3912 		  frunp->sonameent = ebl_strtabadd (dynstrtab, frunp->soname,
   3913 						    0);
   3914 	      while ((frunp = frunp->next) != ld_state.dsofiles);
   3915 	    }
   3916 
   3917 
   3918 	  /* Add the runtime path information.  The strings are stored
   3919 	     in the .dynstr section.  If both rpath and runpath are defined
   3920 	     the runpath information is used.  */
   3921 	  if (ld_state.runpath != NULL || ld_state.rpath != NULL)
   3922 	    {
   3923 	      struct pathelement *startp;
   3924 	      struct pathelement *prunp;
   3925 	      int tag;
   3926 	      size_t len;
   3927 	      char *str;
   3928 	      char *cp;
   3929 
   3930 	      if (ld_state.runpath != NULL)
   3931 		{
   3932 		  startp = ld_state.runpath;
   3933 		  tag = DT_RUNPATH;
   3934 		}
   3935 	      else
   3936 		{
   3937 		  startp = ld_state.rpath;
   3938 		  tag = DT_RPATH;
   3939 		}
   3940 
   3941 	      /* Determine how long the string will be.  */
   3942 	      for (len = 0, prunp = startp; prunp != NULL; prunp = prunp->next)
   3943 		len += strlen (prunp->pname) + 1;
   3944 
   3945 	      cp = str = (char *) obstack_alloc (&ld_state.smem, len);
   3946 	      /* Copy the string.  */
   3947 	      for (prunp = startp; prunp != NULL; prunp = prunp->next)
   3948 		{
   3949 		  cp = stpcpy (cp, prunp->pname);
   3950 		  *cp++ = ':';
   3951 		}
   3952 	      /* Remove the last colon.  */
   3953 	      cp[-1] = '\0';
   3954 
   3955 	      /* Remember the values until we can generate the dynamic
   3956 		 section.  */
   3957 	      ld_state.rxxpath_strent = ebl_strtabadd (dynstrtab, str, len);
   3958 	      ld_state.rxxpath_tag = tag;
   3959 	    }
   3960 
   3961 	  continue;
   3962 	}
   3963 
   3964       if (unlikely (head->kind == scn_dot_hash))
   3965 	{
   3966 	  /* Remember the index of this section.  */
   3967 	  ld_state.hashscnidx = elf_ndxscn (scn);
   3968 
   3969 	  continue;
   3970 	}
   3971 
   3972       if (unlikely (head->kind == scn_dot_plt))
   3973 	{
   3974 	  /* Remember the index of this section.  */
   3975 	  ld_state.pltscnidx = elf_ndxscn (scn);
   3976 
   3977 	  /* Give the backend the change to initialize the section.  */
   3978 	  INITIALIZE_PLT (&ld_state, scn);
   3979 
   3980 	  continue;
   3981 	}
   3982 
   3983       if (unlikely (head->kind == scn_dot_pltrel))
   3984 	{
   3985 	  /* Remember the index of this section.  */
   3986 	  ld_state.pltrelscnidx = elf_ndxscn (scn);
   3987 
   3988 	  /* Give the backend the change to initialize the section.  */
   3989 	  INITIALIZE_PLTREL (&ld_state, scn);
   3990 
   3991 	  continue;
   3992 	}
   3993 
   3994       if (unlikely (head->kind == scn_dot_version))
   3995 	{
   3996 	  /* Remember the index of this section.  */
   3997 	  ld_state.versymscnidx = elf_ndxscn (scn);
   3998 
   3999 	  continue;
   4000 	}
   4001 
   4002       if (unlikely (head->kind == scn_dot_version_r))
   4003 	{
   4004 	  /* Remember the index of this section.  */
   4005 	  ld_state.verneedscnidx = elf_ndxscn (scn);
   4006 
   4007 	  continue;
   4008 	}
   4009 
   4010       /* If we come here we must be handling a normal section.  */
   4011       assert (head->kind == scn_normal);
   4012 
   4013       /* Create an STT_SECTION entry in the symbol table.  But not for
   4014 	 the symbolic symbol table.  */
   4015       if (ld_state.need_symtab)
   4016 	{
   4017 	  /* XXX Can we be cleverer and do this only if needed?  */
   4018 	  XElf_Sym_vardef (sym);
   4019 
   4020 	  /* Optimization ahead: in the native linker we get a pointer
   4021 	     to the final location so that the following code writes
   4022 	     directly in the correct place.  Otherwise we write into
   4023 	     the local variable first.  */
   4024 	  xelf_getsym_ptr (symdata, nsym, sym);
   4025 
   4026 	  /* Usual section symbol: local, no specific information,
   4027 	     except the section index.  The offset here is zero, the
   4028 	     start address will later be added.  */
   4029 	  sym->st_name = 0;
   4030 	  sym->st_info = XELF_ST_INFO (STB_LOCAL, STT_SECTION);
   4031 	  sym->st_other = 0;
   4032 	  sym->st_value = 0;
   4033 	  sym->st_size = 0;
   4034 	  /* In relocatable files the section index can be too big for
   4035 	     the ElfXX_Sym struct.  we have to deal with the extended
   4036 	     symbol table.  */
   4037 	  if (likely (head->scnidx < SHN_LORESERVE))
   4038 	    {
   4039 	      sym->st_shndx = head->scnidx;
   4040 	      xndx = 0;
   4041 	    }
   4042 	  else
   4043 	    {
   4044 	      sym->st_shndx = SHN_XINDEX;
   4045 	      xndx = head->scnidx;
   4046 	    }
   4047 	  /* Commit the change.  See the optimization above, this does
   4048 	     not change the symbol table entry.  But the extended
   4049 	     section index table entry is always written, if there is
   4050 	     such a table.  */
   4051 	  assert (nsym < nsym_allocated);
   4052 	  xelf_update_symshndx (symdata, xndxdata, nsym, sym, xndx, 0);
   4053 
   4054 	  /* Remember the symbol's index in the symbol table.  */
   4055 	  head->scnsymidx = nsym++;
   4056 	}
   4057 
   4058       if (head->type == SHT_REL || head->type == SHT_RELA)
   4059 	{
   4060 	  /* Remember that we have to fill in the symbol table section
   4061 	     index.  */
   4062 	  if (ld_state.file_type == relocatable_file_type)
   4063 	    {
   4064 	      struct scnlist *newp;
   4065 
   4066 	      newp = (struct scnlist *) alloca (sizeof (*newp));
   4067 	      newp->scnidx = head->scnidx;
   4068 	      newp->scninfo = head->last->next;
   4069 #ifndef NDEBUG
   4070 	      newp->next = NULL;
   4071 #endif
   4072 	      SNGL_LIST_PUSH (rellist, newp);
   4073 	    }
   4074 	  else
   4075 	    {
   4076 	      /* When we create an executable or a DSO we don't simply
   4077 		 copy the existing relocations.  Instead many will be
   4078 		 resolved, others will be converted.  Create a data buffer
   4079 		 large enough to contain the contents which we will fill
   4080 		 in later.  */
   4081 	      int type = head->type == SHT_REL ? ELF_T_REL : ELF_T_RELA;
   4082 
   4083 	      data = elf_newdata (scn);
   4084 	      if (data == NULL)
   4085 		error (EXIT_FAILURE, 0,
   4086 		       gettext ("cannot create section for output file: %s"),
   4087 		       elf_errmsg (-1));
   4088 
   4089 	      data->d_size = xelf_fsize (ld_state.outelf, type, head->relsize);
   4090 	      data->d_buf = xcalloc (data->d_size, 1);
   4091 	      data->d_type = type;
   4092 	      data->d_align = xelf_fsize (ld_state.outelf, ELF_T_ADDR, 1);
   4093 	      data->d_off = 0;
   4094 
   4095 	      continue;
   4096 	    }
   4097 	}
   4098 
   4099       /* Recognize string and merge flag and handle them.  */
   4100       if (head->flags & SHF_MERGE)
   4101 	{
   4102 	  /* We merge the contents of the sections.  For this we do
   4103 	     not look at the contents of section directly.  Instead we
   4104 	     look at the symbols of the section.  */
   4105 	  Elf_Data *outdata;
   4106 
   4107 	  /* Concatenate the lists of symbols for all sections.
   4108 
   4109 	     XXX In case any input section has no symbols associated
   4110 	     (this happens for debug sections) we cannot use this
   4111 	     method.  Implement parsing the other debug sections and
   4112 	     find the string pointers.  For now we don't merge.  */
   4113 	  runp = head->last->next;
   4114 	  if (runp->symbols == NULL)
   4115 	    {
   4116 	      head->flags &= ~SHF_MERGE;
   4117 	      goto no_merge;
   4118 	    }
   4119 	  head->symbols = runp->symbols;
   4120 
   4121 	  while ((runp = runp->next) != head->last->next)
   4122 	    {
   4123 	      if (runp->symbols == NULL)
   4124 		{
   4125 		  head->flags &= ~SHF_MERGE;
   4126 		  head->symbols = NULL;
   4127 		  goto no_merge;
   4128 		}
   4129 
   4130 	      struct symbol *oldhead = head->symbols->next_in_scn;
   4131 
   4132 	      head->symbols->next_in_scn = runp->symbols->next_in_scn;
   4133 	      runp->symbols->next_in_scn = oldhead;
   4134 	      head->symbols = runp->symbols;
   4135 	    }
   4136 
   4137 	  /* Create the output section.  */
   4138 	  outdata = elf_newdata (scn);
   4139 	  if (outdata == NULL)
   4140 	    error (EXIT_FAILURE, 0,
   4141 		   gettext ("cannot create section for output file: %s"),
   4142 		   elf_errmsg (-1));
   4143 
   4144 	  /* We use different merging algorithms for performance
   4145 	     reasons.  We can easily handle single-byte and
   4146 	     wchar_t-wide character strings.  All other cases (which
   4147 	     really should happen in real life) are handled by the
   4148 	     generic code.  */
   4149 	  if (SCNINFO_SHDR (head->last->shdr).sh_entsize == 1
   4150 	      && (head->flags & SHF_STRINGS))
   4151 	    {
   4152 	      /* Simple, single-byte string matching.  */
   4153 	      struct Ebl_Strtab *mergestrtab;
   4154 	      struct symbol *symrunp;
   4155 	      Elf_Data *locsymdata = NULL;
   4156 	      Elf_Data *locdata = NULL;
   4157 
   4158 	      mergestrtab = ebl_strtabinit (false);
   4159 
   4160 	      symrunp = head->symbols->next_in_scn;
   4161 	      file = NULL;
   4162 	      do
   4163 		{
   4164 		  /* Accelarate the loop.  We cache the file
   4165 		     information since it might very well be the case
   4166 		     that the previous entry was from the same
   4167 		     file.  */
   4168 		  if (symrunp->file != file)
   4169 		    {
   4170 		      /* Remember the file.  */
   4171 		      file = symrunp->file;
   4172 		      /* Symbol table data from that file.  */
   4173 		      locsymdata = file->symtabdata;
   4174 		      /* String section data.  */
   4175 		      locdata = elf_rawdata (file->scninfo[symrunp->scndx].scn,
   4176 					     NULL);
   4177 		      assert (locdata != NULL);
   4178 		      /* While we are at it, remember the output