1 /* ELF executable support for BFD.
2 
3    Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 
5    This file is part of BFD, the Binary File Descriptor library.
6 
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11 
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16 
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21 
22 
23 /*
24 SECTION
25 	ELF backends
26 
27 	BFD support for ELF formats is being worked on.
28 	Currently, the best supported back ends are for sparc and i386
29 	(running svr4 or Solaris 2).
30 
31 	Documentation of the internals of the support code still needs
32 	to be written.  The code is changing quickly enough that we
33 	haven't bothered yet.  */
34 
35 /* For sparc64-cross-sparc32.  */
36 #define _SYSCALL32
37 #include "sysdep.h"
38 #include "bfd.h"
39 #include "bfdlink.h"
40 #include "libbfd.h"
41 #define ARCH_SIZE 0
42 #include "elf-bfd.h"
43 #include "libiberty.h"
44 #include "safe-ctype.h"
45 #include "elf-linux-core.h"
46 
47 #ifdef CORE_HEADER
48 #include CORE_HEADER
49 #endif
50 
51 static int elf_sort_sections (const void *, const void *);
52 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
53 static bfd_boolean prep_headers (bfd *);
54 static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ;
55 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
56 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
57 				    file_ptr offset);
58 
59 /* Swap version information in and out.  The version information is
60    currently size independent.  If that ever changes, this code will
61    need to move into elfcode.h.  */
62 
63 /* Swap in a Verdef structure.  */
64 
65 void
_bfd_elf_swap_verdef_in(bfd * abfd,const Elf_External_Verdef * src,Elf_Internal_Verdef * dst)66 _bfd_elf_swap_verdef_in (bfd *abfd,
67 			 const Elf_External_Verdef *src,
68 			 Elf_Internal_Verdef *dst)
69 {
70   dst->vd_version = H_GET_16 (abfd, src->vd_version);
71   dst->vd_flags   = H_GET_16 (abfd, src->vd_flags);
72   dst->vd_ndx     = H_GET_16 (abfd, src->vd_ndx);
73   dst->vd_cnt     = H_GET_16 (abfd, src->vd_cnt);
74   dst->vd_hash    = H_GET_32 (abfd, src->vd_hash);
75   dst->vd_aux     = H_GET_32 (abfd, src->vd_aux);
76   dst->vd_next    = H_GET_32 (abfd, src->vd_next);
77 }
78 
79 /* Swap out a Verdef structure.  */
80 
81 void
_bfd_elf_swap_verdef_out(bfd * abfd,const Elf_Internal_Verdef * src,Elf_External_Verdef * dst)82 _bfd_elf_swap_verdef_out (bfd *abfd,
83 			  const Elf_Internal_Verdef *src,
84 			  Elf_External_Verdef *dst)
85 {
86   H_PUT_16 (abfd, src->vd_version, dst->vd_version);
87   H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
88   H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
89   H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
90   H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
91   H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
92   H_PUT_32 (abfd, src->vd_next, dst->vd_next);
93 }
94 
95 /* Swap in a Verdaux structure.  */
96 
97 void
_bfd_elf_swap_verdaux_in(bfd * abfd,const Elf_External_Verdaux * src,Elf_Internal_Verdaux * dst)98 _bfd_elf_swap_verdaux_in (bfd *abfd,
99 			  const Elf_External_Verdaux *src,
100 			  Elf_Internal_Verdaux *dst)
101 {
102   dst->vda_name = H_GET_32 (abfd, src->vda_name);
103   dst->vda_next = H_GET_32 (abfd, src->vda_next);
104 }
105 
106 /* Swap out a Verdaux structure.  */
107 
108 void
_bfd_elf_swap_verdaux_out(bfd * abfd,const Elf_Internal_Verdaux * src,Elf_External_Verdaux * dst)109 _bfd_elf_swap_verdaux_out (bfd *abfd,
110 			   const Elf_Internal_Verdaux *src,
111 			   Elf_External_Verdaux *dst)
112 {
113   H_PUT_32 (abfd, src->vda_name, dst->vda_name);
114   H_PUT_32 (abfd, src->vda_next, dst->vda_next);
115 }
116 
117 /* Swap in a Verneed structure.  */
118 
119 void
_bfd_elf_swap_verneed_in(bfd * abfd,const Elf_External_Verneed * src,Elf_Internal_Verneed * dst)120 _bfd_elf_swap_verneed_in (bfd *abfd,
121 			  const Elf_External_Verneed *src,
122 			  Elf_Internal_Verneed *dst)
123 {
124   dst->vn_version = H_GET_16 (abfd, src->vn_version);
125   dst->vn_cnt     = H_GET_16 (abfd, src->vn_cnt);
126   dst->vn_file    = H_GET_32 (abfd, src->vn_file);
127   dst->vn_aux     = H_GET_32 (abfd, src->vn_aux);
128   dst->vn_next    = H_GET_32 (abfd, src->vn_next);
129 }
130 
131 /* Swap out a Verneed structure.  */
132 
133 void
_bfd_elf_swap_verneed_out(bfd * abfd,const Elf_Internal_Verneed * src,Elf_External_Verneed * dst)134 _bfd_elf_swap_verneed_out (bfd *abfd,
135 			   const Elf_Internal_Verneed *src,
136 			   Elf_External_Verneed *dst)
137 {
138   H_PUT_16 (abfd, src->vn_version, dst->vn_version);
139   H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
140   H_PUT_32 (abfd, src->vn_file, dst->vn_file);
141   H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
142   H_PUT_32 (abfd, src->vn_next, dst->vn_next);
143 }
144 
145 /* Swap in a Vernaux structure.  */
146 
147 void
_bfd_elf_swap_vernaux_in(bfd * abfd,const Elf_External_Vernaux * src,Elf_Internal_Vernaux * dst)148 _bfd_elf_swap_vernaux_in (bfd *abfd,
149 			  const Elf_External_Vernaux *src,
150 			  Elf_Internal_Vernaux *dst)
151 {
152   dst->vna_hash  = H_GET_32 (abfd, src->vna_hash);
153   dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
154   dst->vna_other = H_GET_16 (abfd, src->vna_other);
155   dst->vna_name  = H_GET_32 (abfd, src->vna_name);
156   dst->vna_next  = H_GET_32 (abfd, src->vna_next);
157 }
158 
159 /* Swap out a Vernaux structure.  */
160 
161 void
_bfd_elf_swap_vernaux_out(bfd * abfd,const Elf_Internal_Vernaux * src,Elf_External_Vernaux * dst)162 _bfd_elf_swap_vernaux_out (bfd *abfd,
163 			   const Elf_Internal_Vernaux *src,
164 			   Elf_External_Vernaux *dst)
165 {
166   H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
167   H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
168   H_PUT_16 (abfd, src->vna_other, dst->vna_other);
169   H_PUT_32 (abfd, src->vna_name, dst->vna_name);
170   H_PUT_32 (abfd, src->vna_next, dst->vna_next);
171 }
172 
173 /* Swap in a Versym structure.  */
174 
175 void
_bfd_elf_swap_versym_in(bfd * abfd,const Elf_External_Versym * src,Elf_Internal_Versym * dst)176 _bfd_elf_swap_versym_in (bfd *abfd,
177 			 const Elf_External_Versym *src,
178 			 Elf_Internal_Versym *dst)
179 {
180   dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
181 }
182 
183 /* Swap out a Versym structure.  */
184 
185 void
_bfd_elf_swap_versym_out(bfd * abfd,const Elf_Internal_Versym * src,Elf_External_Versym * dst)186 _bfd_elf_swap_versym_out (bfd *abfd,
187 			  const Elf_Internal_Versym *src,
188 			  Elf_External_Versym *dst)
189 {
190   H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
191 }
192 
193 /* Standard ELF hash function.  Do not change this function; you will
194    cause invalid hash tables to be generated.  */
195 
196 unsigned long
bfd_elf_hash(const char * namearg)197 bfd_elf_hash (const char *namearg)
198 {
199   const unsigned char *name = (const unsigned char *) namearg;
200   unsigned long h = 0;
201   unsigned long g;
202   int ch;
203 
204   while ((ch = *name++) != '\0')
205     {
206       h = (h << 4) + ch;
207       if ((g = (h & 0xf0000000)) != 0)
208 	{
209 	  h ^= g >> 24;
210 	  /* The ELF ABI says `h &= ~g', but this is equivalent in
211 	     this case and on some machines one insn instead of two.  */
212 	  h ^= g;
213 	}
214     }
215   return h & 0xffffffff;
216 }
217 
218 /* DT_GNU_HASH hash function.  Do not change this function; you will
219    cause invalid hash tables to be generated.  */
220 
221 unsigned long
bfd_elf_gnu_hash(const char * namearg)222 bfd_elf_gnu_hash (const char *namearg)
223 {
224   const unsigned char *name = (const unsigned char *) namearg;
225   unsigned long h = 5381;
226   unsigned char ch;
227 
228   while ((ch = *name++) != '\0')
229     h = (h << 5) + h + ch;
230   return h & 0xffffffff;
231 }
232 
233 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
234    the object_id field of an elf_obj_tdata field set to OBJECT_ID.  */
235 bfd_boolean
bfd_elf_allocate_object(bfd * abfd,size_t object_size,enum elf_target_id object_id)236 bfd_elf_allocate_object (bfd *abfd,
237 			 size_t object_size,
238 			 enum elf_target_id object_id)
239 {
240   BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
241   abfd->tdata.any = bfd_zalloc (abfd, object_size);
242   if (abfd->tdata.any == NULL)
243     return FALSE;
244 
245   elf_object_id (abfd) = object_id;
246   if (abfd->direction != read_direction)
247     {
248       struct output_elf_obj_tdata *o = bfd_zalloc (abfd, sizeof *o);
249       if (o == NULL)
250 	return FALSE;
251       elf_tdata (abfd)->o = o;
252       elf_program_header_size (abfd) = (bfd_size_type) -1;
253     }
254   return TRUE;
255 }
256 
257 
258 bfd_boolean
bfd_elf_make_object(bfd * abfd)259 bfd_elf_make_object (bfd *abfd)
260 {
261   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
262   return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
263 				  bed->target_id);
264 }
265 
266 bfd_boolean
bfd_elf_mkcorefile(bfd * abfd)267 bfd_elf_mkcorefile (bfd *abfd)
268 {
269   /* I think this can be done just like an object file.  */
270   if (!abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd))
271     return FALSE;
272   elf_tdata (abfd)->core = bfd_zalloc (abfd, sizeof (*elf_tdata (abfd)->core));
273   return elf_tdata (abfd)->core != NULL;
274 }
275 
276 static char *
bfd_elf_get_str_section(bfd * abfd,unsigned int shindex)277 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
278 {
279   Elf_Internal_Shdr **i_shdrp;
280   bfd_byte *shstrtab = NULL;
281   file_ptr offset;
282   bfd_size_type shstrtabsize;
283 
284   i_shdrp = elf_elfsections (abfd);
285   if (i_shdrp == 0
286       || shindex >= elf_numsections (abfd)
287       || i_shdrp[shindex] == 0)
288     return NULL;
289 
290   shstrtab = i_shdrp[shindex]->contents;
291   if (shstrtab == NULL)
292     {
293       /* No cached one, attempt to read, and cache what we read.  */
294       offset = i_shdrp[shindex]->sh_offset;
295       shstrtabsize = i_shdrp[shindex]->sh_size;
296 
297       /* Allocate and clear an extra byte at the end, to prevent crashes
298 	 in case the string table is not terminated.  */
299       if (shstrtabsize + 1 <= 1
300 	  || bfd_seek (abfd, offset, SEEK_SET) != 0
301 	  || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL)
302 	shstrtab = NULL;
303       else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
304 	{
305 	  if (bfd_get_error () != bfd_error_system_call)
306 	    bfd_set_error (bfd_error_file_truncated);
307 	  bfd_release (abfd, shstrtab);
308 	  shstrtab = NULL;
309 	  /* Once we've failed to read it, make sure we don't keep
310 	     trying.  Otherwise, we'll keep allocating space for
311 	     the string table over and over.  */
312 	  i_shdrp[shindex]->sh_size = 0;
313 	}
314       else
315 	shstrtab[shstrtabsize] = '\0';
316       i_shdrp[shindex]->contents = shstrtab;
317     }
318   return (char *) shstrtab;
319 }
320 
321 char *
bfd_elf_string_from_elf_section(bfd * abfd,unsigned int shindex,unsigned int strindex)322 bfd_elf_string_from_elf_section (bfd *abfd,
323 				 unsigned int shindex,
324 				 unsigned int strindex)
325 {
326   Elf_Internal_Shdr *hdr;
327 
328   if (strindex == 0)
329     return "";
330 
331   if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
332     return NULL;
333 
334   hdr = elf_elfsections (abfd)[shindex];
335 
336   if (hdr->contents == NULL)
337     {
338       if (hdr->sh_type != SHT_STRTAB && hdr->sh_type < SHT_LOOS)
339 	{
340 	  /* PR 17512: file: f057ec89.  */
341 	  _bfd_error_handler (_("%B: attempt to load strings from a non-string section (number %d)"),
342 			      abfd, shindex);
343 	  return NULL;
344 	}
345 
346       if (bfd_elf_get_str_section (abfd, shindex) == NULL)
347 	return NULL;
348     }
349 
350   if (strindex >= hdr->sh_size)
351     {
352       unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
353       (*_bfd_error_handler)
354 	(_("%B: invalid string offset %u >= %lu for section `%s'"),
355 	 abfd, strindex, (unsigned long) hdr->sh_size,
356 	 (shindex == shstrndx && strindex == hdr->sh_name
357 	  ? ".shstrtab"
358 	  : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
359       return NULL;
360     }
361 
362   return ((char *) hdr->contents) + strindex;
363 }
364 
365 /* Read and convert symbols to internal format.
366    SYMCOUNT specifies the number of symbols to read, starting from
367    symbol SYMOFFSET.  If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
368    are non-NULL, they are used to store the internal symbols, external
369    symbols, and symbol section index extensions, respectively.
370    Returns a pointer to the internal symbol buffer (malloced if necessary)
371    or NULL if there were no symbols or some kind of problem.  */
372 
373 Elf_Internal_Sym *
bfd_elf_get_elf_syms(bfd * ibfd,Elf_Internal_Shdr * symtab_hdr,size_t symcount,size_t symoffset,Elf_Internal_Sym * intsym_buf,void * extsym_buf,Elf_External_Sym_Shndx * extshndx_buf)374 bfd_elf_get_elf_syms (bfd *ibfd,
375 		      Elf_Internal_Shdr *symtab_hdr,
376 		      size_t symcount,
377 		      size_t symoffset,
378 		      Elf_Internal_Sym *intsym_buf,
379 		      void *extsym_buf,
380 		      Elf_External_Sym_Shndx *extshndx_buf)
381 {
382   Elf_Internal_Shdr *shndx_hdr;
383   void *alloc_ext;
384   const bfd_byte *esym;
385   Elf_External_Sym_Shndx *alloc_extshndx;
386   Elf_External_Sym_Shndx *shndx;
387   Elf_Internal_Sym *alloc_intsym;
388   Elf_Internal_Sym *isym;
389   Elf_Internal_Sym *isymend;
390   const struct elf_backend_data *bed;
391   size_t extsym_size;
392   bfd_size_type amt;
393   file_ptr pos;
394 
395   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
396     abort ();
397 
398   if (symcount == 0)
399     return intsym_buf;
400 
401   /* Normal syms might have section extension entries.  */
402   shndx_hdr = NULL;
403   if (elf_symtab_shndx_list (ibfd) != NULL)
404     {
405       elf_section_list * entry;
406       Elf_Internal_Shdr **sections = elf_elfsections (ibfd);
407 
408       /* Find an index section that is linked to this symtab section.  */
409       for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next)
410 	{
411 	  /* PR 20063.  */
412 	  if (entry->hdr.sh_link >= elf_numsections (ibfd))
413 	    continue;
414 
415 	  if (sections[entry->hdr.sh_link] == symtab_hdr)
416 	    {
417 	      shndx_hdr = & entry->hdr;
418 	      break;
419 	    };
420 	}
421 
422       if (shndx_hdr == NULL)
423 	{
424 	  if (symtab_hdr == & elf_symtab_hdr (ibfd))
425 	    /* Not really accurate, but this was how the old code used to work.  */
426 	    shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr;
427 	  /* Otherwise we do nothing.  The assumption is that
428 	     the index table will not be needed.  */
429 	}
430     }
431 
432   /* Read the symbols.  */
433   alloc_ext = NULL;
434   alloc_extshndx = NULL;
435   alloc_intsym = NULL;
436   bed = get_elf_backend_data (ibfd);
437   extsym_size = bed->s->sizeof_sym;
438   amt = (bfd_size_type) symcount * extsym_size;
439   pos = symtab_hdr->sh_offset + symoffset * extsym_size;
440   if (extsym_buf == NULL)
441     {
442       alloc_ext = bfd_malloc2 (symcount, extsym_size);
443       extsym_buf = alloc_ext;
444     }
445   if (extsym_buf == NULL
446       || bfd_seek (ibfd, pos, SEEK_SET) != 0
447       || bfd_bread (extsym_buf, amt, ibfd) != amt)
448     {
449       intsym_buf = NULL;
450       goto out;
451     }
452 
453   if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
454     extshndx_buf = NULL;
455   else
456     {
457       amt = (bfd_size_type) symcount * sizeof (Elf_External_Sym_Shndx);
458       pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
459       if (extshndx_buf == NULL)
460 	{
461 	  alloc_extshndx = (Elf_External_Sym_Shndx *)
462               bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
463 	  extshndx_buf = alloc_extshndx;
464 	}
465       if (extshndx_buf == NULL
466 	  || bfd_seek (ibfd, pos, SEEK_SET) != 0
467 	  || bfd_bread (extshndx_buf, amt, ibfd) != amt)
468 	{
469 	  intsym_buf = NULL;
470 	  goto out;
471 	}
472     }
473 
474   if (intsym_buf == NULL)
475     {
476       alloc_intsym = (Elf_Internal_Sym *)
477           bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
478       intsym_buf = alloc_intsym;
479       if (intsym_buf == NULL)
480 	goto out;
481     }
482 
483   /* Convert the symbols to internal form.  */
484   isymend = intsym_buf + symcount;
485   for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
486            shndx = extshndx_buf;
487        isym < isymend;
488        esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
489     if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
490       {
491 	symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
492 	(*_bfd_error_handler) (_("%B symbol number %lu references "
493 				 "nonexistent SHT_SYMTAB_SHNDX section"),
494 			       ibfd, (unsigned long) symoffset);
495 	if (alloc_intsym != NULL)
496 	  free (alloc_intsym);
497 	intsym_buf = NULL;
498 	goto out;
499       }
500 
501  out:
502   if (alloc_ext != NULL)
503     free (alloc_ext);
504   if (alloc_extshndx != NULL)
505     free (alloc_extshndx);
506 
507   return intsym_buf;
508 }
509 
510 /* Look up a symbol name.  */
511 const char *
bfd_elf_sym_name(bfd * abfd,Elf_Internal_Shdr * symtab_hdr,Elf_Internal_Sym * isym,asection * sym_sec)512 bfd_elf_sym_name (bfd *abfd,
513 		  Elf_Internal_Shdr *symtab_hdr,
514 		  Elf_Internal_Sym *isym,
515 		  asection *sym_sec)
516 {
517   const char *name;
518   unsigned int iname = isym->st_name;
519   unsigned int shindex = symtab_hdr->sh_link;
520 
521   if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
522       /* Check for a bogus st_shndx to avoid crashing.  */
523       && isym->st_shndx < elf_numsections (abfd))
524     {
525       iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
526       shindex = elf_elfheader (abfd)->e_shstrndx;
527     }
528 
529   name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
530   if (name == NULL)
531     name = "(null)";
532   else if (sym_sec && *name == '\0')
533     name = bfd_section_name (abfd, sym_sec);
534 
535   return name;
536 }
537 
538 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
539    sections.  The first element is the flags, the rest are section
540    pointers.  */
541 
542 typedef union elf_internal_group {
543   Elf_Internal_Shdr *shdr;
544   unsigned int flags;
545 } Elf_Internal_Group;
546 
547 /* Return the name of the group signature symbol.  Why isn't the
548    signature just a string?  */
549 
550 static const char *
group_signature(bfd * abfd,Elf_Internal_Shdr * ghdr)551 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
552 {
553   Elf_Internal_Shdr *hdr;
554   unsigned char esym[sizeof (Elf64_External_Sym)];
555   Elf_External_Sym_Shndx eshndx;
556   Elf_Internal_Sym isym;
557 
558   /* First we need to ensure the symbol table is available.  Make sure
559      that it is a symbol table section.  */
560   if (ghdr->sh_link >= elf_numsections (abfd))
561     return NULL;
562   hdr = elf_elfsections (abfd) [ghdr->sh_link];
563   if (hdr->sh_type != SHT_SYMTAB
564       || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
565     return NULL;
566 
567   /* Go read the symbol.  */
568   hdr = &elf_tdata (abfd)->symtab_hdr;
569   if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
570 			    &isym, esym, &eshndx) == NULL)
571     return NULL;
572 
573   return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
574 }
575 
576 /* Set next_in_group list pointer, and group name for NEWSECT.  */
577 
578 static bfd_boolean
setup_group(bfd * abfd,Elf_Internal_Shdr * hdr,asection * newsect)579 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
580 {
581   unsigned int num_group = elf_tdata (abfd)->num_group;
582 
583   /* If num_group is zero, read in all SHT_GROUP sections.  The count
584      is set to -1 if there are no SHT_GROUP sections.  */
585   if (num_group == 0)
586     {
587       unsigned int i, shnum;
588 
589       /* First count the number of groups.  If we have a SHT_GROUP
590 	 section with just a flag word (ie. sh_size is 4), ignore it.  */
591       shnum = elf_numsections (abfd);
592       num_group = 0;
593 
594 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize)	\
595 	(   (shdr)->sh_type == SHT_GROUP		\
596 	 && (shdr)->sh_size >= minsize			\
597 	 && (shdr)->sh_entsize == GRP_ENTRY_SIZE	\
598 	 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
599 
600       for (i = 0; i < shnum; i++)
601 	{
602 	  Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
603 
604 	  if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
605 	    num_group += 1;
606 	}
607 
608       if (num_group == 0)
609 	{
610 	  num_group = (unsigned) -1;
611 	  elf_tdata (abfd)->num_group = num_group;
612 	}
613       else
614 	{
615 	  /* We keep a list of elf section headers for group sections,
616 	     so we can find them quickly.  */
617 	  bfd_size_type amt;
618 
619 	  elf_tdata (abfd)->num_group = num_group;
620 	  elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
621               bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
622 	  if (elf_tdata (abfd)->group_sect_ptr == NULL)
623 	    return FALSE;
624 
625 	  num_group = 0;
626 	  for (i = 0; i < shnum; i++)
627 	    {
628 	      Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
629 
630 	      if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
631 		{
632 		  unsigned char *src;
633 		  Elf_Internal_Group *dest;
634 
635 		  /* Add to list of sections.  */
636 		  elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
637 		  num_group += 1;
638 
639 		  /* Read the raw contents.  */
640 		  BFD_ASSERT (sizeof (*dest) >= 4);
641 		  amt = shdr->sh_size * sizeof (*dest) / 4;
642 		  shdr->contents = (unsigned char *)
643                       bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
644 		  /* PR binutils/4110: Handle corrupt group headers.  */
645 		  if (shdr->contents == NULL)
646 		    {
647 		      _bfd_error_handler
648 			(_("%B: corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
649 		      bfd_set_error (bfd_error_bad_value);
650 		      -- num_group;
651 		      continue;
652 		    }
653 
654 		  memset (shdr->contents, 0, amt);
655 
656 		  if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
657 		      || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
658 			  != shdr->sh_size))
659 		    {
660 		      _bfd_error_handler
661 			(_("%B: invalid size field in group section header: 0x%lx"), abfd, shdr->sh_size);
662 		      bfd_set_error (bfd_error_bad_value);
663 		      -- num_group;
664 		      /* PR 17510: If the group contents are even partially
665 			 corrupt, do not allow any of the contents to be used.  */
666 		      memset (shdr->contents, 0, amt);
667 		      continue;
668 		    }
669 
670 		  /* Translate raw contents, a flag word followed by an
671 		     array of elf section indices all in target byte order,
672 		     to the flag word followed by an array of elf section
673 		     pointers.  */
674 		  src = shdr->contents + shdr->sh_size;
675 		  dest = (Elf_Internal_Group *) (shdr->contents + amt);
676 
677 		  while (1)
678 		    {
679 		      unsigned int idx;
680 
681 		      src -= 4;
682 		      --dest;
683 		      idx = H_GET_32 (abfd, src);
684 		      if (src == shdr->contents)
685 			{
686 			  dest->flags = idx;
687 			  if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
688 			    shdr->bfd_section->flags
689 			      |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
690 			  break;
691 			}
692 		      if (idx >= shnum)
693 			{
694 			  ((*_bfd_error_handler)
695 			   (_("%B: invalid SHT_GROUP entry"), abfd));
696 			  idx = 0;
697 			}
698 		      dest->shdr = elf_elfsections (abfd)[idx];
699 		    }
700 		}
701 	    }
702 
703 	  /* PR 17510: Corrupt binaries might contain invalid groups.  */
704 	  if (num_group != (unsigned) elf_tdata (abfd)->num_group)
705 	    {
706 	      elf_tdata (abfd)->num_group = num_group;
707 
708 	      /* If all groups are invalid then fail.  */
709 	      if (num_group == 0)
710 		{
711 		  elf_tdata (abfd)->group_sect_ptr = NULL;
712 		  elf_tdata (abfd)->num_group = num_group = -1;
713 		  (*_bfd_error_handler) (_("%B: no valid group sections found"), abfd);
714 		  bfd_set_error (bfd_error_bad_value);
715 		}
716 	    }
717 	}
718     }
719 
720   if (num_group != (unsigned) -1)
721     {
722       unsigned int i;
723 
724       for (i = 0; i < num_group; i++)
725 	{
726 	  Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
727 	  Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
728 	  unsigned int n_elt = shdr->sh_size / 4;
729 
730 	  /* Look through this group's sections to see if current
731 	     section is a member.  */
732 	  while (--n_elt != 0)
733 	    if ((++idx)->shdr == hdr)
734 	      {
735 		asection *s = NULL;
736 
737 		/* We are a member of this group.  Go looking through
738 		   other members to see if any others are linked via
739 		   next_in_group.  */
740 		idx = (Elf_Internal_Group *) shdr->contents;
741 		n_elt = shdr->sh_size / 4;
742 		while (--n_elt != 0)
743 		  if ((s = (++idx)->shdr->bfd_section) != NULL
744 		      && elf_next_in_group (s) != NULL)
745 		    break;
746 		if (n_elt != 0)
747 		  {
748 		    /* Snarf the group name from other member, and
749 		       insert current section in circular list.  */
750 		    elf_group_name (newsect) = elf_group_name (s);
751 		    elf_next_in_group (newsect) = elf_next_in_group (s);
752 		    elf_next_in_group (s) = newsect;
753 		  }
754 		else
755 		  {
756 		    const char *gname;
757 
758 		    gname = group_signature (abfd, shdr);
759 		    if (gname == NULL)
760 		      return FALSE;
761 		    elf_group_name (newsect) = gname;
762 
763 		    /* Start a circular list with one element.  */
764 		    elf_next_in_group (newsect) = newsect;
765 		  }
766 
767 		/* If the group section has been created, point to the
768 		   new member.  */
769 		if (shdr->bfd_section != NULL)
770 		  elf_next_in_group (shdr->bfd_section) = newsect;
771 
772 		i = num_group - 1;
773 		break;
774 	      }
775 	}
776     }
777 
778   if (elf_group_name (newsect) == NULL)
779     {
780       (*_bfd_error_handler) (_("%B: no group info for section %A"),
781 			     abfd, newsect);
782       return FALSE;
783     }
784   return TRUE;
785 }
786 
787 bfd_boolean
_bfd_elf_setup_sections(bfd * abfd)788 _bfd_elf_setup_sections (bfd *abfd)
789 {
790   unsigned int i;
791   unsigned int num_group = elf_tdata (abfd)->num_group;
792   bfd_boolean result = TRUE;
793   asection *s;
794 
795   /* Process SHF_LINK_ORDER.  */
796   for (s = abfd->sections; s != NULL; s = s->next)
797     {
798       Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
799       if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
800 	{
801 	  unsigned int elfsec = this_hdr->sh_link;
802 	  /* FIXME: The old Intel compiler and old strip/objcopy may
803 	     not set the sh_link or sh_info fields.  Hence we could
804 	     get the situation where elfsec is 0.  */
805 	  if (elfsec == 0)
806 	    {
807 	      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
808 	      if (bed->link_order_error_handler)
809 		bed->link_order_error_handler
810 		  (_("%B: warning: sh_link not set for section `%A'"),
811 		   abfd, s);
812 	    }
813 	  else
814 	    {
815 	      asection *linksec = NULL;
816 
817 	      if (elfsec < elf_numsections (abfd))
818 		{
819 		  this_hdr = elf_elfsections (abfd)[elfsec];
820 		  linksec = this_hdr->bfd_section;
821 		}
822 
823 	      /* PR 1991, 2008:
824 		 Some strip/objcopy may leave an incorrect value in
825 		 sh_link.  We don't want to proceed.  */
826 	      if (linksec == NULL)
827 		{
828 		  (*_bfd_error_handler)
829 		    (_("%B: sh_link [%d] in section `%A' is incorrect"),
830 		     s->owner, s, elfsec);
831 		  result = FALSE;
832 		}
833 
834 	      elf_linked_to_section (s) = linksec;
835 	    }
836 	}
837     }
838 
839   /* Process section groups.  */
840   if (num_group == (unsigned) -1)
841     return result;
842 
843   for (i = 0; i < num_group; i++)
844     {
845       Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
846       Elf_Internal_Group *idx;
847       unsigned int n_elt;
848 
849       /* PR binutils/18758: Beware of corrupt binaries with invalid group data.  */
850       if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL)
851 	{
852 	  (*_bfd_error_handler)
853 	    (_("%B: section group entry number %u is corrupt"),
854 	     abfd, i);
855 	  result = FALSE;
856 	  continue;
857 	}
858 
859       idx = (Elf_Internal_Group *) shdr->contents;
860       n_elt = shdr->sh_size / 4;
861 
862       while (--n_elt != 0)
863 	if ((++idx)->shdr->bfd_section)
864 	  elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
865 	else if (idx->shdr->sh_type == SHT_RELA
866 		 || idx->shdr->sh_type == SHT_REL)
867 	  /* We won't include relocation sections in section groups in
868 	     output object files. We adjust the group section size here
869 	     so that relocatable link will work correctly when
870 	     relocation sections are in section group in input object
871 	     files.  */
872 	  shdr->bfd_section->size -= 4;
873 	else
874 	  {
875 	    /* There are some unknown sections in the group.  */
876 	    (*_bfd_error_handler)
877 	      (_("%B: unknown [%d] section `%s' in group [%s]"),
878 	       abfd,
879 	       (unsigned int) idx->shdr->sh_type,
880 	       bfd_elf_string_from_elf_section (abfd,
881 						(elf_elfheader (abfd)
882 						 ->e_shstrndx),
883 						idx->shdr->sh_name),
884 	       shdr->bfd_section->name);
885 	    result = FALSE;
886 	  }
887     }
888   return result;
889 }
890 
891 bfd_boolean
bfd_elf_is_group_section(bfd * abfd ATTRIBUTE_UNUSED,const asection * sec)892 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
893 {
894   return elf_next_in_group (sec) != NULL;
895 }
896 
897 static char *
convert_debug_to_zdebug(bfd * abfd,const char * name)898 convert_debug_to_zdebug (bfd *abfd, const char *name)
899 {
900   unsigned int len = strlen (name);
901   char *new_name = bfd_alloc (abfd, len + 2);
902   if (new_name == NULL)
903     return NULL;
904   new_name[0] = '.';
905   new_name[1] = 'z';
906   memcpy (new_name + 2, name + 1, len);
907   return new_name;
908 }
909 
910 static char *
convert_zdebug_to_debug(bfd * abfd,const char * name)911 convert_zdebug_to_debug (bfd *abfd, const char *name)
912 {
913   unsigned int len = strlen (name);
914   char *new_name = bfd_alloc (abfd, len);
915   if (new_name == NULL)
916     return NULL;
917   new_name[0] = '.';
918   memcpy (new_name + 1, name + 2, len - 1);
919   return new_name;
920 }
921 
922 /* Make a BFD section from an ELF section.  We store a pointer to the
923    BFD section in the bfd_section field of the header.  */
924 
925 bfd_boolean
_bfd_elf_make_section_from_shdr(bfd * abfd,Elf_Internal_Shdr * hdr,const char * name,int shindex)926 _bfd_elf_make_section_from_shdr (bfd *abfd,
927 				 Elf_Internal_Shdr *hdr,
928 				 const char *name,
929 				 int shindex)
930 {
931   asection *newsect;
932   flagword flags;
933   const struct elf_backend_data *bed;
934 
935   if (hdr->bfd_section != NULL)
936     return TRUE;
937 
938   newsect = bfd_make_section_anyway (abfd, name);
939   if (newsect == NULL)
940     return FALSE;
941 
942   hdr->bfd_section = newsect;
943   elf_section_data (newsect)->this_hdr = *hdr;
944   elf_section_data (newsect)->this_idx = shindex;
945 
946   /* Always use the real type/flags.  */
947   elf_section_type (newsect) = hdr->sh_type;
948   elf_section_flags (newsect) = hdr->sh_flags;
949 
950   newsect->filepos = hdr->sh_offset;
951 
952   if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
953       || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
954       || ! bfd_set_section_alignment (abfd, newsect,
955 				      bfd_log2 (hdr->sh_addralign)))
956     return FALSE;
957 
958   flags = SEC_NO_FLAGS;
959   if (hdr->sh_type != SHT_NOBITS)
960     flags |= SEC_HAS_CONTENTS;
961   if (hdr->sh_type == SHT_GROUP)
962     flags |= SEC_GROUP | SEC_EXCLUDE;
963   if ((hdr->sh_flags & SHF_ALLOC) != 0)
964     {
965       flags |= SEC_ALLOC;
966       if (hdr->sh_type != SHT_NOBITS)
967 	flags |= SEC_LOAD;
968     }
969   if ((hdr->sh_flags & SHF_WRITE) == 0)
970     flags |= SEC_READONLY;
971   if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
972     flags |= SEC_CODE;
973   else if ((flags & SEC_LOAD) != 0)
974     flags |= SEC_DATA;
975   if ((hdr->sh_flags & SHF_MERGE) != 0)
976     {
977       flags |= SEC_MERGE;
978       newsect->entsize = hdr->sh_entsize;
979     }
980   if ((hdr->sh_flags & SHF_STRINGS) != 0)
981     flags |= SEC_STRINGS;
982   if (hdr->sh_flags & SHF_GROUP)
983     if (!setup_group (abfd, hdr, newsect))
984       return FALSE;
985   if ((hdr->sh_flags & SHF_TLS) != 0)
986     flags |= SEC_THREAD_LOCAL;
987   if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
988     flags |= SEC_EXCLUDE;
989 
990   if ((flags & SEC_ALLOC) == 0)
991     {
992       /* The debugging sections appear to be recognized only by name,
993 	 not any sort of flag.  Their SEC_ALLOC bits are cleared.  */
994       if (name [0] == '.')
995 	{
996 	  const char *p;
997 	  int n;
998 	  if (name[1] == 'd')
999 	    p = ".debug", n = 6;
1000 	  else if (name[1] == 'g' && name[2] == 'n')
1001 	    p = ".gnu.linkonce.wi.", n = 17;
1002 	  else if (name[1] == 'g' && name[2] == 'd')
1003 	    p = ".gdb_index", n = 11; /* yes we really do mean 11.  */
1004 	  else if (name[1] == 'l')
1005 	    p = ".line", n = 5;
1006 	  else if (name[1] == 's')
1007 	    p = ".stab", n = 5;
1008 	  else if (name[1] == 'z')
1009 	    p = ".zdebug", n = 7;
1010 	  else
1011 	    p = NULL, n = 0;
1012 	  if (p != NULL && strncmp (name, p, n) == 0)
1013 	    flags |= SEC_DEBUGGING;
1014 	}
1015     }
1016 
1017   /* As a GNU extension, if the name begins with .gnu.linkonce, we
1018      only link a single copy of the section.  This is used to support
1019      g++.  g++ will emit each template expansion in its own section.
1020      The symbols will be defined as weak, so that multiple definitions
1021      are permitted.  The GNU linker extension is to actually discard
1022      all but one of the sections.  */
1023   if (CONST_STRNEQ (name, ".gnu.linkonce")
1024       && elf_next_in_group (newsect) == NULL)
1025     flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1026 
1027   bed = get_elf_backend_data (abfd);
1028   if (bed->elf_backend_section_flags)
1029     if (! bed->elf_backend_section_flags (&flags, hdr))
1030       return FALSE;
1031 
1032   if (! bfd_set_section_flags (abfd, newsect, flags))
1033     return FALSE;
1034 
1035   /* We do not parse the PT_NOTE segments as we are interested even in the
1036      separate debug info files which may have the segments offsets corrupted.
1037      PT_NOTEs from the core files are currently not parsed using BFD.  */
1038   if (hdr->sh_type == SHT_NOTE)
1039     {
1040       bfd_byte *contents;
1041 
1042       if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
1043 	return FALSE;
1044 
1045       elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
1046       free (contents);
1047     }
1048 
1049   if ((flags & SEC_ALLOC) != 0)
1050     {
1051       Elf_Internal_Phdr *phdr;
1052       unsigned int i, nload;
1053 
1054       /* Some ELF linkers produce binaries with all the program header
1055 	 p_paddr fields zero.  If we have such a binary with more than
1056 	 one PT_LOAD header, then leave the section lma equal to vma
1057 	 so that we don't create sections with overlapping lma.  */
1058       phdr = elf_tdata (abfd)->phdr;
1059       for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1060 	if (phdr->p_paddr != 0)
1061 	  break;
1062 	else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
1063 	  ++nload;
1064       if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
1065 	return TRUE;
1066 
1067       phdr = elf_tdata (abfd)->phdr;
1068       for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
1069 	{
1070 	  if (((phdr->p_type == PT_LOAD
1071 		&& (hdr->sh_flags & SHF_TLS) == 0)
1072 	       || phdr->p_type == PT_TLS)
1073 	      && ELF_SECTION_IN_SEGMENT (hdr, phdr))
1074 	    {
1075 	      if ((flags & SEC_LOAD) == 0)
1076 		newsect->lma = (phdr->p_paddr
1077 				+ hdr->sh_addr - phdr->p_vaddr);
1078 	      else
1079 		/* We used to use the same adjustment for SEC_LOAD
1080 		   sections, but that doesn't work if the segment
1081 		   is packed with code from multiple VMAs.
1082 		   Instead we calculate the section LMA based on
1083 		   the segment LMA.  It is assumed that the
1084 		   segment will contain sections with contiguous
1085 		   LMAs, even if the VMAs are not.  */
1086 		newsect->lma = (phdr->p_paddr
1087 				+ hdr->sh_offset - phdr->p_offset);
1088 
1089 	      /* With contiguous segments, we can't tell from file
1090 		 offsets whether a section with zero size should
1091 		 be placed at the end of one segment or the
1092 		 beginning of the next.  Decide based on vaddr.  */
1093 	      if (hdr->sh_addr >= phdr->p_vaddr
1094 		  && (hdr->sh_addr + hdr->sh_size
1095 		      <= phdr->p_vaddr + phdr->p_memsz))
1096 		break;
1097 	    }
1098 	}
1099     }
1100 
1101   /* Compress/decompress DWARF debug sections with names: .debug_* and
1102      .zdebug_*, after the section flags is set.  */
1103   if ((flags & SEC_DEBUGGING)
1104       && ((name[1] == 'd' && name[6] == '_')
1105 	  || (name[1] == 'z' && name[7] == '_')))
1106     {
1107       enum { nothing, compress, decompress } action = nothing;
1108       int compression_header_size;
1109       bfd_size_type uncompressed_size;
1110       bfd_boolean compressed
1111 	= bfd_is_section_compressed_with_header (abfd, newsect,
1112 						 &compression_header_size,
1113 						 &uncompressed_size);
1114 
1115       if (compressed)
1116 	{
1117 	  /* Compressed section.  Check if we should decompress.  */
1118 	  if ((abfd->flags & BFD_DECOMPRESS))
1119 	    action = decompress;
1120 	}
1121 
1122       /* Compress the uncompressed section or convert from/to .zdebug*
1123 	 section.  Check if we should compress.  */
1124       if (action == nothing)
1125 	{
1126 	  if (newsect->size != 0
1127 	      && (abfd->flags & BFD_COMPRESS)
1128 	      && compression_header_size >= 0
1129 	      && uncompressed_size > 0
1130 	      && (!compressed
1131 		  || ((compression_header_size > 0)
1132 		      != ((abfd->flags & BFD_COMPRESS_GABI) != 0))))
1133 	    action = compress;
1134 	  else
1135 	    return TRUE;
1136 	}
1137 
1138       if (action == compress)
1139 	{
1140 	  if (!bfd_init_section_compress_status (abfd, newsect))
1141 	    {
1142 	      (*_bfd_error_handler)
1143 		(_("%B: unable to initialize compress status for section %s"),
1144 		 abfd, name);
1145 	      return FALSE;
1146 	    }
1147 	}
1148       else
1149 	{
1150 	  if (!bfd_init_section_decompress_status (abfd, newsect))
1151 	    {
1152 	      (*_bfd_error_handler)
1153 		(_("%B: unable to initialize decompress status for section %s"),
1154 		 abfd, name);
1155 	      return FALSE;
1156 	    }
1157 	}
1158 
1159       if (abfd->is_linker_input)
1160 	{
1161 	  if (name[1] == 'z'
1162 	      && (action == decompress
1163 		  || (action == compress
1164 		      && (abfd->flags & BFD_COMPRESS_GABI) != 0)))
1165 	    {
1166 	      /* Convert section name from .zdebug_* to .debug_* so
1167 		 that linker will consider this section as a debug
1168 		 section.  */
1169 	      char *new_name = convert_zdebug_to_debug (abfd, name);
1170 	      if (new_name == NULL)
1171 		return FALSE;
1172 	      bfd_rename_section (abfd, newsect, new_name);
1173 	    }
1174 	}
1175       else
1176 	/* For objdump, don't rename the section.  For objcopy, delay
1177 	   section rename to elf_fake_sections.  */
1178 	newsect->flags |= SEC_ELF_RENAME;
1179     }
1180 
1181   return TRUE;
1182 }
1183 
1184 const char *const bfd_elf_section_type_names[] =
1185 {
1186   "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1187   "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1188   "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1189 };
1190 
1191 /* ELF relocs are against symbols.  If we are producing relocatable
1192    output, and the reloc is against an external symbol, and nothing
1193    has given us any additional addend, the resulting reloc will also
1194    be against the same symbol.  In such a case, we don't want to
1195    change anything about the way the reloc is handled, since it will
1196    all be done at final link time.  Rather than put special case code
1197    into bfd_perform_relocation, all the reloc types use this howto
1198    function.  It just short circuits the reloc if producing
1199    relocatable output against an external symbol.  */
1200 
1201 bfd_reloc_status_type
bfd_elf_generic_reloc(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol,void * data ATTRIBUTE_UNUSED,asection * input_section,bfd * output_bfd,char ** error_message ATTRIBUTE_UNUSED)1202 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1203 		       arelent *reloc_entry,
1204 		       asymbol *symbol,
1205 		       void *data ATTRIBUTE_UNUSED,
1206 		       asection *input_section,
1207 		       bfd *output_bfd,
1208 		       char **error_message ATTRIBUTE_UNUSED)
1209 {
1210   if (output_bfd != NULL
1211       && (symbol->flags & BSF_SECTION_SYM) == 0
1212       && (! reloc_entry->howto->partial_inplace
1213 	  || reloc_entry->addend == 0))
1214     {
1215       reloc_entry->address += input_section->output_offset;
1216       return bfd_reloc_ok;
1217     }
1218 
1219   return bfd_reloc_continue;
1220 }
1221 
1222 /* Returns TRUE if section A matches section B.
1223    Names, addresses and links may be different, but everything else
1224    should be the same.  */
1225 
1226 static bfd_boolean
section_match(const Elf_Internal_Shdr * a,const Elf_Internal_Shdr * b)1227 section_match (const Elf_Internal_Shdr * a,
1228 	       const Elf_Internal_Shdr * b)
1229 {
1230   return
1231     a->sh_type         == b->sh_type
1232     && (a->sh_flags & ~ SHF_INFO_LINK)
1233     == (b->sh_flags & ~ SHF_INFO_LINK)
1234     && a->sh_addralign == b->sh_addralign
1235     && a->sh_size      == b->sh_size
1236     && a->sh_entsize   == b->sh_entsize
1237     /* FIXME: Check sh_addr ?  */
1238     ;
1239 }
1240 
1241 /* Find a section in OBFD that has the same characteristics
1242    as IHEADER.  Return the index of this section or SHN_UNDEF if
1243    none can be found.  Check's section HINT first, as this is likely
1244    to be the correct section.  */
1245 
1246 static unsigned int
find_link(const bfd * obfd,const Elf_Internal_Shdr * iheader,const unsigned int hint)1247 find_link (const bfd * obfd, const Elf_Internal_Shdr * iheader, const unsigned int hint)
1248 {
1249   Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd);
1250   unsigned int i;
1251 
1252   if (section_match (oheaders[hint], iheader))
1253     return hint;
1254 
1255   for (i = 1; i < elf_numsections (obfd); i++)
1256     {
1257       Elf_Internal_Shdr * oheader = oheaders[i];
1258 
1259       if (section_match (oheader, iheader))
1260 	/* FIXME: Do we care if there is a potential for
1261 	   multiple matches ?  */
1262 	return i;
1263     }
1264 
1265   return SHN_UNDEF;
1266 }
1267 
1268 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1269    Processor specific section, based upon a matching input section.
1270    Returns TRUE upon success, FALSE otherwise.  */
1271 
1272 static bfd_boolean
copy_special_section_fields(const bfd * ibfd,bfd * obfd,const Elf_Internal_Shdr * iheader,Elf_Internal_Shdr * oheader,const unsigned int secnum)1273 copy_special_section_fields (const bfd *ibfd,
1274 			     bfd *obfd,
1275 			     const Elf_Internal_Shdr *iheader,
1276 			     Elf_Internal_Shdr *oheader,
1277 			     const unsigned int secnum)
1278 {
1279   const struct elf_backend_data *bed = get_elf_backend_data (obfd);
1280   const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1281   bfd_boolean changed = FALSE;
1282   unsigned int sh_link;
1283 
1284   if (oheader->sh_type == SHT_NOBITS)
1285     {
1286       /* This is a feature for objcopy --only-keep-debug:
1287 	 When a section's type is changed to NOBITS, we preserve
1288 	 the sh_link and sh_info fields so that they can be
1289 	 matched up with the original.
1290 
1291 	 Note: Strictly speaking these assignments are wrong.
1292 	 The sh_link and sh_info fields should point to the
1293 	 relevent sections in the output BFD, which may not be in
1294 	 the same location as they were in the input BFD.  But
1295 	 the whole point of this action is to preserve the
1296 	 original values of the sh_link and sh_info fields, so
1297 	 that they can be matched up with the section headers in
1298 	 the original file.  So strictly speaking we may be
1299 	 creating an invalid ELF file, but it is only for a file
1300 	 that just contains debug info and only for sections
1301 	 without any contents.  */
1302       if (oheader->sh_link == 0)
1303 	oheader->sh_link = iheader->sh_link;
1304       if (oheader->sh_info == 0)
1305 	oheader->sh_info = iheader->sh_info;
1306       return TRUE;
1307     }
1308 
1309   /* Allow the target a chance to decide how these fields should be set.  */
1310   if (bed->elf_backend_copy_special_section_fields != NULL
1311       && bed->elf_backend_copy_special_section_fields
1312       (ibfd, obfd, iheader, oheader))
1313     return TRUE;
1314 
1315   /* We have an iheader which might match oheader, and which has non-zero
1316      sh_info and/or sh_link fields.  Attempt to follow those links and find
1317      the section in the output bfd which corresponds to the linked section
1318      in the input bfd.  */
1319   if (iheader->sh_link != SHN_UNDEF)
1320     {
1321       sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link);
1322       if (sh_link != SHN_UNDEF)
1323 	{
1324 	  oheader->sh_link = sh_link;
1325 	  changed = TRUE;
1326 	}
1327       else
1328 	/* FIXME: Should we install iheader->sh_link
1329 	   if we could not find a match ?  */
1330 	(* _bfd_error_handler)
1331 	  (_("%B: Failed to find link section for section %d"), obfd, secnum);
1332     }
1333 
1334   if (iheader->sh_info)
1335     {
1336       /* The sh_info field can hold arbitrary information, but if the
1337 	 SHF_LINK_INFO flag is set then it should be interpreted as a
1338 	 section index.  */
1339       if (iheader->sh_flags & SHF_INFO_LINK)
1340 	{
1341 	  sh_link = find_link (obfd, iheaders[iheader->sh_info],
1342 			       iheader->sh_info);
1343 	  if (sh_link != SHN_UNDEF)
1344 	    oheader->sh_flags |= SHF_INFO_LINK;
1345 	}
1346       else
1347 	/* No idea what it means - just copy it.  */
1348 	sh_link = iheader->sh_info;
1349 
1350       if (sh_link != SHN_UNDEF)
1351 	{
1352 	  oheader->sh_info = sh_link;
1353 	  changed = TRUE;
1354 	}
1355       else
1356 	(* _bfd_error_handler)
1357 	  (_("%B: Failed to find info section for section %d"), obfd, secnum);
1358     }
1359 
1360   return changed;
1361 }
1362 
1363 /* Copy the program header and other data from one object module to
1364    another.  */
1365 
1366 bfd_boolean
_bfd_elf_copy_private_bfd_data(bfd * ibfd,bfd * obfd)1367 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1368 {
1369   const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd);
1370   Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
1371   const struct elf_backend_data *bed;
1372   unsigned int i;
1373 
1374   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1375     || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1376     return TRUE;
1377 
1378   if (!elf_flags_init (obfd))
1379     {
1380       elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1381       elf_flags_init (obfd) = TRUE;
1382     }
1383 
1384   elf_gp (obfd) = elf_gp (ibfd);
1385 
1386   /* Also copy the EI_OSABI field.  */
1387   elf_elfheader (obfd)->e_ident[EI_OSABI] =
1388     elf_elfheader (ibfd)->e_ident[EI_OSABI];
1389 
1390   /* If set, copy the EI_ABIVERSION field.  */
1391   if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION])
1392     elf_elfheader (obfd)->e_ident[EI_ABIVERSION]
1393       = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION];
1394 
1395   /* Copy object attributes.  */
1396   _bfd_elf_copy_obj_attributes (ibfd, obfd);
1397 
1398   if (iheaders == NULL || oheaders == NULL)
1399     return TRUE;
1400 
1401   bed = get_elf_backend_data (obfd);
1402 
1403   /* Possibly copy other fields in the section header.  */
1404   for (i = 1; i < elf_numsections (obfd); i++)
1405     {
1406       unsigned int j;
1407       Elf_Internal_Shdr * oheader = oheaders[i];
1408 
1409       /* Ignore ordinary sections.  SHT_NOBITS sections are considered however
1410 	 because of a special case need for generating separate debug info
1411 	 files.  See below for more details.  */
1412       if (oheader == NULL
1413 	  || (oheader->sh_type != SHT_NOBITS
1414 	      && oheader->sh_type < SHT_LOOS))
1415 	continue;
1416 
1417       /* Ignore empty sections, and sections whose
1418 	 fields have already been initialised.  */
1419       if (oheader->sh_size == 0
1420 	  || (oheader->sh_info != 0 && oheader->sh_link != 0))
1421 	continue;
1422 
1423       /* Scan for the matching section in the input bfd.
1424 	 First we try for a direct mapping between the input and output sections.  */
1425       for (j = 1; j < elf_numsections (ibfd); j++)
1426 	{
1427 	  const Elf_Internal_Shdr * iheader = iheaders[j];
1428 
1429 	  if (iheader == NULL)
1430 	    continue;
1431 
1432 	  if (oheader->bfd_section != NULL
1433 	      && iheader->bfd_section != NULL
1434 	      && iheader->bfd_section->output_section != NULL
1435 	      && iheader->bfd_section->output_section == oheader->bfd_section)
1436 	    {
1437 	      /* We have found a connection from the input section to the
1438 		 output section.  Attempt to copy the header fields.  If
1439 		 this fails then do not try any further sections - there
1440 		 should only be a one-to-one mapping between input and output. */
1441 	      if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1442 		j = elf_numsections (ibfd);
1443 	      break;
1444 	    }
1445 	}
1446 
1447       if (j < elf_numsections (ibfd))
1448 	continue;
1449 
1450       /* That failed.  So try to deduce the corresponding input section.
1451 	 Unfortunately we cannot compare names as the output string table
1452 	 is empty, so instead we check size, address and type.  */
1453       for (j = 1; j < elf_numsections (ibfd); j++)
1454 	{
1455 	  const Elf_Internal_Shdr * iheader = iheaders[j];
1456 
1457 	  if (iheader == NULL)
1458 	    continue;
1459 
1460 	  /* Try matching fields in the input section's header.
1461 	     Since --only-keep-debug turns all non-debug sections into
1462 	     SHT_NOBITS sections, the output SHT_NOBITS type matches any
1463 	     input type.  */
1464 	  if ((oheader->sh_type == SHT_NOBITS
1465 	       || iheader->sh_type == oheader->sh_type)
1466 	      && (iheader->sh_flags & ~ SHF_INFO_LINK)
1467 	      == (oheader->sh_flags & ~ SHF_INFO_LINK)
1468 	      && iheader->sh_addralign == oheader->sh_addralign
1469 	      && iheader->sh_entsize == oheader->sh_entsize
1470 	      && iheader->sh_size == oheader->sh_size
1471 	      && iheader->sh_addr == oheader->sh_addr
1472 	      && (iheader->sh_info != oheader->sh_info
1473 		  || iheader->sh_link != oheader->sh_link))
1474 	    {
1475 	      if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i))
1476 		break;
1477 	    }
1478 	}
1479 
1480       if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS)
1481 	{
1482 	  /* Final attempt.  Call the backend copy function
1483 	     with a NULL input section.  */
1484 	  if (bed->elf_backend_copy_special_section_fields != NULL)
1485 	    bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
1486 	}
1487     }
1488 
1489   return TRUE;
1490 }
1491 
1492 static const char *
get_segment_type(unsigned int p_type)1493 get_segment_type (unsigned int p_type)
1494 {
1495   const char *pt;
1496   switch (p_type)
1497     {
1498     case PT_NULL: pt = "NULL"; break;
1499     case PT_LOAD: pt = "LOAD"; break;
1500     case PT_DYNAMIC: pt = "DYNAMIC"; break;
1501     case PT_INTERP: pt = "INTERP"; break;
1502     case PT_NOTE: pt = "NOTE"; break;
1503     case PT_SHLIB: pt = "SHLIB"; break;
1504     case PT_PHDR: pt = "PHDR"; break;
1505     case PT_TLS: pt = "TLS"; break;
1506     case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1507     case PT_GNU_STACK: pt = "STACK"; break;
1508     case PT_GNU_RELRO: pt = "RELRO"; break;
1509     default: pt = NULL; break;
1510     }
1511   return pt;
1512 }
1513 
1514 /* Print out the program headers.  */
1515 
1516 bfd_boolean
_bfd_elf_print_private_bfd_data(bfd * abfd,void * farg)1517 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1518 {
1519   FILE *f = (FILE *) farg;
1520   Elf_Internal_Phdr *p;
1521   asection *s;
1522   bfd_byte *dynbuf = NULL;
1523 
1524   p = elf_tdata (abfd)->phdr;
1525   if (p != NULL)
1526     {
1527       unsigned int i, c;
1528 
1529       fprintf (f, _("\nProgram Header:\n"));
1530       c = elf_elfheader (abfd)->e_phnum;
1531       for (i = 0; i < c; i++, p++)
1532 	{
1533 	  const char *pt = get_segment_type (p->p_type);
1534 	  char buf[20];
1535 
1536 	  if (pt == NULL)
1537 	    {
1538 	      sprintf (buf, "0x%lx", p->p_type);
1539 	      pt = buf;
1540 	    }
1541 	  fprintf (f, "%8s off    0x", pt);
1542 	  bfd_fprintf_vma (abfd, f, p->p_offset);
1543 	  fprintf (f, " vaddr 0x");
1544 	  bfd_fprintf_vma (abfd, f, p->p_vaddr);
1545 	  fprintf (f, " paddr 0x");
1546 	  bfd_fprintf_vma (abfd, f, p->p_paddr);
1547 	  fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1548 	  fprintf (f, "         filesz 0x");
1549 	  bfd_fprintf_vma (abfd, f, p->p_filesz);
1550 	  fprintf (f, " memsz 0x");
1551 	  bfd_fprintf_vma (abfd, f, p->p_memsz);
1552 	  fprintf (f, " flags %c%c%c",
1553 		   (p->p_flags & PF_R) != 0 ? 'r' : '-',
1554 		   (p->p_flags & PF_W) != 0 ? 'w' : '-',
1555 		   (p->p_flags & PF_X) != 0 ? 'x' : '-');
1556 	  if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1557 	    fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1558 	  fprintf (f, "\n");
1559 	}
1560     }
1561 
1562   s = bfd_get_section_by_name (abfd, ".dynamic");
1563   if (s != NULL)
1564     {
1565       unsigned int elfsec;
1566       unsigned long shlink;
1567       bfd_byte *extdyn, *extdynend;
1568       size_t extdynsize;
1569       void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1570 
1571       fprintf (f, _("\nDynamic Section:\n"));
1572 
1573       if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1574 	goto error_return;
1575 
1576       elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1577       if (elfsec == SHN_BAD)
1578 	goto error_return;
1579       shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1580 
1581       extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1582       swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1583 
1584       extdyn = dynbuf;
1585       /* PR 17512: file: 6f427532.  */
1586       if (s->size < extdynsize)
1587 	goto error_return;
1588       extdynend = extdyn + s->size;
1589       /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1590          Fix range check.  */
1591       for (; extdyn <= (extdynend - extdynsize); extdyn += extdynsize)
1592 	{
1593 	  Elf_Internal_Dyn dyn;
1594 	  const char *name = "";
1595 	  char ab[20];
1596 	  bfd_boolean stringp;
1597 	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1598 
1599 	  (*swap_dyn_in) (abfd, extdyn, &dyn);
1600 
1601 	  if (dyn.d_tag == DT_NULL)
1602 	    break;
1603 
1604 	  stringp = FALSE;
1605 	  switch (dyn.d_tag)
1606 	    {
1607 	    default:
1608 	      if (bed->elf_backend_get_target_dtag)
1609 		name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1610 
1611 	      if (!strcmp (name, ""))
1612 		{
1613 		  sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1614 		  name = ab;
1615 		}
1616 	      break;
1617 
1618 	    case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1619 	    case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1620 	    case DT_PLTGOT: name = "PLTGOT"; break;
1621 	    case DT_HASH: name = "HASH"; break;
1622 	    case DT_STRTAB: name = "STRTAB"; break;
1623 	    case DT_SYMTAB: name = "SYMTAB"; break;
1624 	    case DT_RELA: name = "RELA"; break;
1625 	    case DT_RELASZ: name = "RELASZ"; break;
1626 	    case DT_RELAENT: name = "RELAENT"; break;
1627 	    case DT_STRSZ: name = "STRSZ"; break;
1628 	    case DT_SYMENT: name = "SYMENT"; break;
1629 	    case DT_INIT: name = "INIT"; break;
1630 	    case DT_FINI: name = "FINI"; break;
1631 	    case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1632 	    case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1633 	    case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1634 	    case DT_REL: name = "REL"; break;
1635 	    case DT_RELSZ: name = "RELSZ"; break;
1636 	    case DT_RELENT: name = "RELENT"; break;
1637 	    case DT_PLTREL: name = "PLTREL"; break;
1638 	    case DT_DEBUG: name = "DEBUG"; break;
1639 	    case DT_TEXTREL: name = "TEXTREL"; break;
1640 	    case DT_JMPREL: name = "JMPREL"; break;
1641 	    case DT_BIND_NOW: name = "BIND_NOW"; break;
1642 	    case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1643 	    case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1644 	    case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1645 	    case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1646 	    case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1647 	    case DT_FLAGS: name = "FLAGS"; break;
1648 	    case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1649 	    case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1650 	    case DT_CHECKSUM: name = "CHECKSUM"; break;
1651 	    case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1652 	    case DT_MOVEENT: name = "MOVEENT"; break;
1653 	    case DT_MOVESZ: name = "MOVESZ"; break;
1654 	    case DT_FEATURE: name = "FEATURE"; break;
1655 	    case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1656 	    case DT_SYMINSZ: name = "SYMINSZ"; break;
1657 	    case DT_SYMINENT: name = "SYMINENT"; break;
1658 	    case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1659 	    case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1660 	    case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1661 	    case DT_PLTPAD: name = "PLTPAD"; break;
1662 	    case DT_MOVETAB: name = "MOVETAB"; break;
1663 	    case DT_SYMINFO: name = "SYMINFO"; break;
1664 	    case DT_RELACOUNT: name = "RELACOUNT"; break;
1665 	    case DT_RELCOUNT: name = "RELCOUNT"; break;
1666 	    case DT_FLAGS_1: name = "FLAGS_1"; break;
1667 	    case DT_VERSYM: name = "VERSYM"; break;
1668 	    case DT_VERDEF: name = "VERDEF"; break;
1669 	    case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1670 	    case DT_VERNEED: name = "VERNEED"; break;
1671 	    case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1672 	    case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1673 	    case DT_USED: name = "USED"; break;
1674 	    case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1675 	    case DT_GNU_HASH: name = "GNU_HASH"; break;
1676 	    }
1677 
1678 	  fprintf (f, "  %-20s ", name);
1679 	  if (! stringp)
1680 	    {
1681 	      fprintf (f, "0x");
1682 	      bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1683 	    }
1684 	  else
1685 	    {
1686 	      const char *string;
1687 	      unsigned int tagv = dyn.d_un.d_val;
1688 
1689 	      string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1690 	      if (string == NULL)
1691 		goto error_return;
1692 	      fprintf (f, "%s", string);
1693 	    }
1694 	  fprintf (f, "\n");
1695 	}
1696 
1697       free (dynbuf);
1698       dynbuf = NULL;
1699     }
1700 
1701   if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1702       || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1703     {
1704       if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1705 	return FALSE;
1706     }
1707 
1708   if (elf_dynverdef (abfd) != 0)
1709     {
1710       Elf_Internal_Verdef *t;
1711 
1712       fprintf (f, _("\nVersion definitions:\n"));
1713       for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1714 	{
1715 	  fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1716 		   t->vd_flags, t->vd_hash,
1717 		   t->vd_nodename ? t->vd_nodename : "<corrupt>");
1718 	  if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1719 	    {
1720 	      Elf_Internal_Verdaux *a;
1721 
1722 	      fprintf (f, "\t");
1723 	      for (a = t->vd_auxptr->vda_nextptr;
1724 		   a != NULL;
1725 		   a = a->vda_nextptr)
1726 		fprintf (f, "%s ",
1727 			 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1728 	      fprintf (f, "\n");
1729 	    }
1730 	}
1731     }
1732 
1733   if (elf_dynverref (abfd) != 0)
1734     {
1735       Elf_Internal_Verneed *t;
1736 
1737       fprintf (f, _("\nVersion References:\n"));
1738       for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1739 	{
1740 	  Elf_Internal_Vernaux *a;
1741 
1742 	  fprintf (f, _("  required from %s:\n"),
1743 		   t->vn_filename ? t->vn_filename : "<corrupt>");
1744 	  for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1745 	    fprintf (f, "    0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1746 		     a->vna_flags, a->vna_other,
1747 		     a->vna_nodename ? a->vna_nodename : "<corrupt>");
1748 	}
1749     }
1750 
1751   return TRUE;
1752 
1753  error_return:
1754   if (dynbuf != NULL)
1755     free (dynbuf);
1756   return FALSE;
1757 }
1758 
1759 /* Get version string.  */
1760 
1761 const char *
_bfd_elf_get_symbol_version_string(bfd * abfd,asymbol * symbol,bfd_boolean * hidden)1762 _bfd_elf_get_symbol_version_string (bfd *abfd, asymbol *symbol,
1763 				    bfd_boolean *hidden)
1764 {
1765   const char *version_string = NULL;
1766   if (elf_dynversym (abfd) != 0
1767       && (elf_dynverdef (abfd) != 0 || elf_dynverref (abfd) != 0))
1768     {
1769       unsigned int vernum = ((elf_symbol_type *) symbol)->version;
1770 
1771       *hidden = (vernum & VERSYM_HIDDEN) != 0;
1772       vernum &= VERSYM_VERSION;
1773 
1774       if (vernum == 0)
1775 	version_string = "";
1776       else if (vernum == 1)
1777 	version_string = "Base";
1778       else if (vernum <= elf_tdata (abfd)->cverdefs)
1779 	version_string =
1780 	  elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1781       else
1782 	{
1783 	  Elf_Internal_Verneed *t;
1784 
1785 	  version_string = "";
1786 	  for (t = elf_tdata (abfd)->verref;
1787 	       t != NULL;
1788 	       t = t->vn_nextref)
1789 	    {
1790 	      Elf_Internal_Vernaux *a;
1791 
1792 	      for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1793 		{
1794 		  if (a->vna_other == vernum)
1795 		    {
1796 		      version_string = a->vna_nodename;
1797 		      break;
1798 		    }
1799 		}
1800 	    }
1801 	}
1802     }
1803   return version_string;
1804 }
1805 
1806 /* Display ELF-specific fields of a symbol.  */
1807 
1808 void
bfd_elf_print_symbol(bfd * abfd,void * filep,asymbol * symbol,bfd_print_symbol_type how)1809 bfd_elf_print_symbol (bfd *abfd,
1810 		      void *filep,
1811 		      asymbol *symbol,
1812 		      bfd_print_symbol_type how)
1813 {
1814   FILE *file = (FILE *) filep;
1815   switch (how)
1816     {
1817     case bfd_print_symbol_name:
1818       fprintf (file, "%s", symbol->name);
1819       break;
1820     case bfd_print_symbol_more:
1821       fprintf (file, "elf ");
1822       bfd_fprintf_vma (abfd, file, symbol->value);
1823       fprintf (file, " %lx", (unsigned long) symbol->flags);
1824       break;
1825     case bfd_print_symbol_all:
1826       {
1827 	const char *section_name;
1828 	const char *name = NULL;
1829 	const struct elf_backend_data *bed;
1830 	unsigned char st_other;
1831 	bfd_vma val;
1832 	const char *version_string;
1833 	bfd_boolean hidden;
1834 
1835 	section_name = symbol->section ? symbol->section->name : "(*none*)";
1836 
1837 	bed = get_elf_backend_data (abfd);
1838 	if (bed->elf_backend_print_symbol_all)
1839 	  name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1840 
1841 	if (name == NULL)
1842 	  {
1843 	    name = symbol->name;
1844 	    bfd_print_symbol_vandf (abfd, file, symbol);
1845 	  }
1846 
1847 	fprintf (file, " %s\t", section_name);
1848 	/* Print the "other" value for a symbol.  For common symbols,
1849 	   we've already printed the size; now print the alignment.
1850 	   For other symbols, we have no specified alignment, and
1851 	   we've printed the address; now print the size.  */
1852 	if (symbol->section && bfd_is_com_section (symbol->section))
1853 	  val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1854 	else
1855 	  val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1856 	bfd_fprintf_vma (abfd, file, val);
1857 
1858 	/* If we have version information, print it.  */
1859 	version_string = _bfd_elf_get_symbol_version_string (abfd,
1860 							     symbol,
1861 							     &hidden);
1862 	if (version_string)
1863 	  {
1864 	    if (!hidden)
1865 	      fprintf (file, "  %-11s", version_string);
1866 	    else
1867 	      {
1868 		int i;
1869 
1870 		fprintf (file, " (%s)", version_string);
1871 		for (i = 10 - strlen (version_string); i > 0; --i)
1872 		  putc (' ', file);
1873 	      }
1874 	  }
1875 
1876 	/* If the st_other field is not zero, print it.  */
1877 	st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1878 
1879 	switch (st_other)
1880 	  {
1881 	  case 0: break;
1882 	  case STV_INTERNAL:  fprintf (file, " .internal");  break;
1883 	  case STV_HIDDEN:    fprintf (file, " .hidden");    break;
1884 	  case STV_PROTECTED: fprintf (file, " .protected"); break;
1885 	  default:
1886 	    /* Some other non-defined flags are also present, so print
1887 	       everything hex.  */
1888 	    fprintf (file, " 0x%02x", (unsigned int) st_other);
1889 	  }
1890 
1891 	fprintf (file, " %s", name);
1892       }
1893       break;
1894     }
1895 }
1896 
1897 /* ELF .o/exec file reading */
1898 
1899 /* Create a new bfd section from an ELF section header.  */
1900 
1901 bfd_boolean
bfd_section_from_shdr(bfd * abfd,unsigned int shindex)1902 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1903 {
1904   Elf_Internal_Shdr *hdr;
1905   Elf_Internal_Ehdr *ehdr;
1906   const struct elf_backend_data *bed;
1907   const char *name;
1908   bfd_boolean ret = TRUE;
1909   static bfd_boolean * sections_being_created = NULL;
1910   static bfd * sections_being_created_abfd = NULL;
1911   static unsigned int nesting = 0;
1912 
1913   if (shindex >= elf_numsections (abfd))
1914     return FALSE;
1915 
1916   if (++ nesting > 3)
1917     {
1918       /* PR17512: A corrupt ELF binary might contain a recursive group of
1919 	 sections, with each the string indicies pointing to the next in the
1920 	 loop.  Detect this here, by refusing to load a section that we are
1921 	 already in the process of loading.  We only trigger this test if
1922 	 we have nested at least three sections deep as normal ELF binaries
1923 	 can expect to recurse at least once.
1924 
1925 	 FIXME: It would be better if this array was attached to the bfd,
1926 	 rather than being held in a static pointer.  */
1927 
1928       if (sections_being_created_abfd != abfd)
1929 	sections_being_created = NULL;
1930       if (sections_being_created == NULL)
1931 	{
1932 	  /* FIXME: It would be more efficient to attach this array to the bfd somehow.  */
1933 	  sections_being_created = (bfd_boolean *)
1934 	    bfd_zalloc (abfd, elf_numsections (abfd) * sizeof (bfd_boolean));
1935 	  sections_being_created_abfd = abfd;
1936 	}
1937       if (sections_being_created [shindex])
1938 	{
1939 	  (*_bfd_error_handler)
1940 	    (_("%B: warning: loop in section dependencies detected"), abfd);
1941 	  return FALSE;
1942 	}
1943       sections_being_created [shindex] = TRUE;
1944     }
1945 
1946   hdr = elf_elfsections (abfd)[shindex];
1947   ehdr = elf_elfheader (abfd);
1948   name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1949 					  hdr->sh_name);
1950   if (name == NULL)
1951     goto fail;
1952 
1953   bed = get_elf_backend_data (abfd);
1954   switch (hdr->sh_type)
1955     {
1956     case SHT_NULL:
1957       /* Inactive section. Throw it away.  */
1958       goto success;
1959 
1960     case SHT_PROGBITS:		/* Normal section with contents.  */
1961     case SHT_NOBITS:		/* .bss section.  */
1962     case SHT_HASH:		/* .hash section.  */
1963     case SHT_NOTE:		/* .note section.  */
1964     case SHT_INIT_ARRAY:	/* .init_array section.  */
1965     case SHT_FINI_ARRAY:	/* .fini_array section.  */
1966     case SHT_PREINIT_ARRAY:	/* .preinit_array section.  */
1967     case SHT_GNU_LIBLIST:	/* .gnu.liblist section.  */
1968     case SHT_GNU_HASH:		/* .gnu.hash section.  */
1969       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1970       goto success;
1971 
1972     case SHT_DYNAMIC:	/* Dynamic linking information.  */
1973       if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1974 	goto fail;
1975 
1976       if (hdr->sh_link > elf_numsections (abfd))
1977 	{
1978 	  /* PR 10478: Accept Solaris binaries with a sh_link
1979 	     field set to SHN_BEFORE or SHN_AFTER.  */
1980 	  switch (bfd_get_arch (abfd))
1981 	    {
1982 	    case bfd_arch_i386:
1983 	    case bfd_arch_sparc:
1984 	      if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1985 		  || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1986 		break;
1987 	      /* Otherwise fall through.  */
1988 	    default:
1989 	      goto fail;
1990 	    }
1991 	}
1992       else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1993 	goto fail;
1994       else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1995 	{
1996 	  Elf_Internal_Shdr *dynsymhdr;
1997 
1998 	  /* The shared libraries distributed with hpux11 have a bogus
1999 	     sh_link field for the ".dynamic" section.  Find the
2000 	     string table for the ".dynsym" section instead.  */
2001 	  if (elf_dynsymtab (abfd) != 0)
2002 	    {
2003 	      dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
2004 	      hdr->sh_link = dynsymhdr->sh_link;
2005 	    }
2006 	  else
2007 	    {
2008 	      unsigned int i, num_sec;
2009 
2010 	      num_sec = elf_numsections (abfd);
2011 	      for (i = 1; i < num_sec; i++)
2012 		{
2013 		  dynsymhdr = elf_elfsections (abfd)[i];
2014 		  if (dynsymhdr->sh_type == SHT_DYNSYM)
2015 		    {
2016 		      hdr->sh_link = dynsymhdr->sh_link;
2017 		      break;
2018 		    }
2019 		}
2020 	    }
2021 	}
2022       goto success;
2023 
2024     case SHT_SYMTAB:		/* A symbol table.  */
2025       if (elf_onesymtab (abfd) == shindex)
2026 	goto success;
2027 
2028       if (hdr->sh_entsize != bed->s->sizeof_sym)
2029 	goto fail;
2030 
2031       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2032 	{
2033 	  if (hdr->sh_size != 0)
2034 	    goto fail;
2035 	  /* Some assemblers erroneously set sh_info to one with a
2036 	     zero sh_size.  ld sees this as a global symbol count
2037 	     of (unsigned) -1.  Fix it here.  */
2038 	  hdr->sh_info = 0;
2039 	  goto success;
2040 	}
2041 
2042       /* PR 18854: A binary might contain more than one symbol table.
2043 	 Unusual, but possible.  Warn, but continue.  */
2044       if (elf_onesymtab (abfd) != 0)
2045 	{
2046 	  (*_bfd_error_handler)
2047 	    (_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"),
2048 	     abfd, shindex);
2049 	  goto success;
2050 	}
2051       elf_onesymtab (abfd) = shindex;
2052       elf_symtab_hdr (abfd) = *hdr;
2053       elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd);
2054       abfd->flags |= HAS_SYMS;
2055 
2056       /* Sometimes a shared object will map in the symbol table.  If
2057 	 SHF_ALLOC is set, and this is a shared object, then we also
2058 	 treat this section as a BFD section.  We can not base the
2059 	 decision purely on SHF_ALLOC, because that flag is sometimes
2060 	 set in a relocatable object file, which would confuse the
2061 	 linker.  */
2062       if ((hdr->sh_flags & SHF_ALLOC) != 0
2063 	  && (abfd->flags & DYNAMIC) != 0
2064 	  && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2065 						shindex))
2066 	goto fail;
2067 
2068       /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2069 	 can't read symbols without that section loaded as well.  It
2070 	 is most likely specified by the next section header.  */
2071       {
2072 	elf_section_list * entry;
2073 	unsigned int i, num_sec;
2074 
2075 	for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2076 	  if (entry->hdr.sh_link == shindex)
2077 	    goto success;
2078 
2079 	num_sec = elf_numsections (abfd);
2080 	for (i = shindex + 1; i < num_sec; i++)
2081 	  {
2082 	    Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2083 
2084 	    if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2085 		&& hdr2->sh_link == shindex)
2086 	      break;
2087 	  }
2088 
2089 	if (i == num_sec)
2090 	  for (i = 1; i < shindex; i++)
2091 	    {
2092 	      Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2093 
2094 	      if (hdr2->sh_type == SHT_SYMTAB_SHNDX
2095 		  && hdr2->sh_link == shindex)
2096 		break;
2097 	    }
2098 
2099 	if (i != shindex)
2100 	  ret = bfd_section_from_shdr (abfd, i);
2101 	/* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2102 	goto success;
2103       }
2104 
2105     case SHT_DYNSYM:		/* A dynamic symbol table.  */
2106       if (elf_dynsymtab (abfd) == shindex)
2107 	goto success;
2108 
2109       if (hdr->sh_entsize != bed->s->sizeof_sym)
2110 	goto fail;
2111 
2112       if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
2113 	{
2114 	  if (hdr->sh_size != 0)
2115 	    goto fail;
2116 
2117 	  /* Some linkers erroneously set sh_info to one with a
2118 	     zero sh_size.  ld sees this as a global symbol count
2119 	     of (unsigned) -1.  Fix it here.  */
2120 	  hdr->sh_info = 0;
2121 	  goto success;
2122 	}
2123 
2124       /* PR 18854: A binary might contain more than one dynamic symbol table.
2125 	 Unusual, but possible.  Warn, but continue.  */
2126       if (elf_dynsymtab (abfd) != 0)
2127 	{
2128 	  (*_bfd_error_handler)
2129 	    (_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"),
2130 	     abfd, shindex);
2131 	  goto success;
2132 	}
2133       elf_dynsymtab (abfd) = shindex;
2134       elf_tdata (abfd)->dynsymtab_hdr = *hdr;
2135       elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
2136       abfd->flags |= HAS_SYMS;
2137 
2138       /* Besides being a symbol table, we also treat this as a regular
2139 	 section, so that objcopy can handle it.  */
2140       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2141       goto success;
2142 
2143     case SHT_SYMTAB_SHNDX:	/* Symbol section indices when >64k sections.  */
2144       {
2145 	elf_section_list * entry;
2146 
2147 	for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next)
2148 	  if (entry->ndx == shindex)
2149 	    goto success;
2150 
2151 	entry = bfd_alloc (abfd, sizeof * entry);
2152 	if (entry == NULL)
2153 	  goto fail;
2154 	entry->ndx = shindex;
2155 	entry->hdr = * hdr;
2156 	entry->next = elf_symtab_shndx_list (abfd);
2157 	elf_symtab_shndx_list (abfd) = entry;
2158 	elf_elfsections (abfd)[shindex] = & entry->hdr;
2159 	goto success;
2160       }
2161 
2162     case SHT_STRTAB:		/* A string table.  */
2163       if (hdr->bfd_section != NULL)
2164 	goto success;
2165 
2166       if (ehdr->e_shstrndx == shindex)
2167 	{
2168 	  elf_tdata (abfd)->shstrtab_hdr = *hdr;
2169 	  elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
2170 	  goto success;
2171 	}
2172 
2173       if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
2174 	{
2175 	symtab_strtab:
2176 	  elf_tdata (abfd)->strtab_hdr = *hdr;
2177 	  elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
2178 	  goto success;
2179 	}
2180 
2181       if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2182 	{
2183 	dynsymtab_strtab:
2184 	  elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2185 	  hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2186 	  elf_elfsections (abfd)[shindex] = hdr;
2187 	  /* We also treat this as a regular section, so that objcopy
2188 	     can handle it.  */
2189 	  ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2190 						 shindex);
2191 	  goto success;
2192 	}
2193 
2194       /* If the string table isn't one of the above, then treat it as a
2195 	 regular section.  We need to scan all the headers to be sure,
2196 	 just in case this strtab section appeared before the above.  */
2197       if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2198 	{
2199 	  unsigned int i, num_sec;
2200 
2201 	  num_sec = elf_numsections (abfd);
2202 	  for (i = 1; i < num_sec; i++)
2203 	    {
2204 	      Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2205 	      if (hdr2->sh_link == shindex)
2206 		{
2207 		  /* Prevent endless recursion on broken objects.  */
2208 		  if (i == shindex)
2209 		    goto fail;
2210 		  if (! bfd_section_from_shdr (abfd, i))
2211 		    goto fail;
2212 		  if (elf_onesymtab (abfd) == i)
2213 		    goto symtab_strtab;
2214 		  if (elf_dynsymtab (abfd) == i)
2215 		    goto dynsymtab_strtab;
2216 		}
2217 	    }
2218 	}
2219       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2220       goto success;
2221 
2222     case SHT_REL:
2223     case SHT_RELA:
2224       /* *These* do a lot of work -- but build no sections!  */
2225       {
2226 	asection *target_sect;
2227 	Elf_Internal_Shdr *hdr2, **p_hdr;
2228 	unsigned int num_sec = elf_numsections (abfd);
2229 	struct bfd_elf_section_data *esdt;
2230 
2231 	if (hdr->sh_entsize
2232 	    != (bfd_size_type) (hdr->sh_type == SHT_REL
2233 				? bed->s->sizeof_rel : bed->s->sizeof_rela))
2234 	  goto fail;
2235 
2236 	/* Check for a bogus link to avoid crashing.  */
2237 	if (hdr->sh_link >= num_sec)
2238 	  {
2239 	    ((*_bfd_error_handler)
2240 	     (_("%B: invalid link %lu for reloc section %s (index %u)"),
2241 	      abfd, hdr->sh_link, name, shindex));
2242 	    ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2243 						   shindex);
2244 	    goto success;
2245 	  }
2246 
2247 	/* For some incomprehensible reason Oracle distributes
2248 	   libraries for Solaris in which some of the objects have
2249 	   bogus sh_link fields.  It would be nice if we could just
2250 	   reject them, but, unfortunately, some people need to use
2251 	   them.  We scan through the section headers; if we find only
2252 	   one suitable symbol table, we clobber the sh_link to point
2253 	   to it.  I hope this doesn't break anything.
2254 
2255 	   Don't do it on executable nor shared library.  */
2256 	if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
2257 	    && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2258 	    && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2259 	  {
2260 	    unsigned int scan;
2261 	    int found;
2262 
2263 	    found = 0;
2264 	    for (scan = 1; scan < num_sec; scan++)
2265 	      {
2266 		if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2267 		    || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2268 		  {
2269 		    if (found != 0)
2270 		      {
2271 			found = 0;
2272 			break;
2273 		      }
2274 		    found = scan;
2275 		  }
2276 	      }
2277 	    if (found != 0)
2278 	      hdr->sh_link = found;
2279 	  }
2280 
2281 	/* Get the symbol table.  */
2282 	if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2283 	     || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2284 	    && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2285 	  goto fail;
2286 
2287 	/* If this reloc section does not use the main symbol table we
2288 	   don't treat it as a reloc section.  BFD can't adequately
2289 	   represent such a section, so at least for now, we don't
2290 	   try.  We just present it as a normal section.  We also
2291 	   can't use it as a reloc section if it points to the null
2292 	   section, an invalid section, another reloc section, or its
2293 	   sh_link points to the null section.  */
2294 	if (hdr->sh_link != elf_onesymtab (abfd)
2295 	    || hdr->sh_link == SHN_UNDEF
2296 	    || hdr->sh_info == SHN_UNDEF
2297 	    || hdr->sh_info >= num_sec
2298 	    || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2299 	    || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2300 	  {
2301 	    ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2302 						   shindex);
2303 	    goto success;
2304 	  }
2305 
2306 	if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2307 	  goto fail;
2308 
2309 	target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2310 	if (target_sect == NULL)
2311 	  goto fail;
2312 
2313 	esdt = elf_section_data (target_sect);
2314 	if (hdr->sh_type == SHT_RELA)
2315 	  p_hdr = &esdt->rela.hdr;
2316 	else
2317 	  p_hdr = &esdt->rel.hdr;
2318 
2319 	/* PR 17512: file: 0b4f81b7.  */
2320 	if (*p_hdr != NULL)
2321 	  goto fail;
2322 	hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
2323 	if (hdr2 == NULL)
2324 	  goto fail;
2325 	*hdr2 = *hdr;
2326 	*p_hdr = hdr2;
2327 	elf_elfsections (abfd)[shindex] = hdr2;
2328 	target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2329 	target_sect->flags |= SEC_RELOC;
2330 	target_sect->relocation = NULL;
2331 	target_sect->rel_filepos = hdr->sh_offset;
2332 	/* In the section to which the relocations apply, mark whether
2333 	   its relocations are of the REL or RELA variety.  */
2334 	if (hdr->sh_size != 0)
2335 	  {
2336 	    if (hdr->sh_type == SHT_RELA)
2337 	      target_sect->use_rela_p = 1;
2338 	  }
2339 	abfd->flags |= HAS_RELOC;
2340 	goto success;
2341       }
2342 
2343     case SHT_GNU_verdef:
2344       elf_dynverdef (abfd) = shindex;
2345       elf_tdata (abfd)->dynverdef_hdr = *hdr;
2346       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2347       goto success;
2348 
2349     case SHT_GNU_versym:
2350       if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2351 	goto fail;
2352 
2353       elf_dynversym (abfd) = shindex;
2354       elf_tdata (abfd)->dynversym_hdr = *hdr;
2355       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2356       goto success;
2357 
2358     case SHT_GNU_verneed:
2359       elf_dynverref (abfd) = shindex;
2360       elf_tdata (abfd)->dynverref_hdr = *hdr;
2361       ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2362       goto success;
2363 
2364     case SHT_SHLIB:
2365       goto success;
2366 
2367     case SHT_GROUP:
2368       if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
2369 	goto fail;
2370 
2371       if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2372 	goto fail;
2373 
2374       if (hdr->contents != NULL)
2375 	{
2376 	  Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2377 	  unsigned int n_elt = hdr->sh_size / sizeof (* idx);
2378 	  asection *s;
2379 
2380 	  if (n_elt == 0)
2381 	    goto fail;
2382 	  if (idx->flags & GRP_COMDAT)
2383 	    hdr->bfd_section->flags
2384 	      |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2385 
2386 	  /* We try to keep the same section order as it comes in.  */
2387 	  idx += n_elt;
2388 
2389 	  while (--n_elt != 0)
2390 	    {
2391 	      --idx;
2392 
2393 	      if (idx->shdr != NULL
2394 		  && (s = idx->shdr->bfd_section) != NULL
2395 		  && elf_next_in_group (s) != NULL)
2396 		{
2397 		  elf_next_in_group (hdr->bfd_section) = s;
2398 		  break;
2399 		}
2400 	    }
2401 	}
2402       goto success;
2403 
2404     default:
2405       /* Possibly an attributes section.  */
2406       if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2407 	  || hdr->sh_type == bed->obj_attrs_section_type)
2408 	{
2409 	  if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2410 	    goto fail;
2411 	  _bfd_elf_parse_attributes (abfd, hdr);
2412 	  goto success;
2413 	}
2414 
2415       /* Check for any processor-specific section types.  */
2416       if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2417 	goto success;
2418 
2419       if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2420 	{
2421 	  if ((hdr->sh_flags & SHF_ALLOC) != 0)
2422 	    /* FIXME: How to properly handle allocated section reserved
2423 	       for applications?  */
2424 	    (*_bfd_error_handler)
2425 	      (_("%B: don't know how to handle allocated, application "
2426 		 "specific section `%s' [0x%8x]"),
2427 	       abfd, name, hdr->sh_type);
2428 	  else
2429 	    {
2430 	      /* Allow sections reserved for applications.  */
2431 	      ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2432 						     shindex);
2433 	      goto success;
2434 	    }
2435 	}
2436       else if (hdr->sh_type >= SHT_LOPROC
2437 	       && hdr->sh_type <= SHT_HIPROC)
2438 	/* FIXME: We should handle this section.  */
2439 	(*_bfd_error_handler)
2440 	  (_("%B: don't know how to handle processor specific section "
2441 	     "`%s' [0x%8x]"),
2442 	   abfd, name, hdr->sh_type);
2443       else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2444 	{
2445 	  /* Unrecognised OS-specific sections.  */
2446 	  if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2447 	    /* SHF_OS_NONCONFORMING indicates that special knowledge is
2448 	       required to correctly process the section and the file should
2449 	       be rejected with an error message.  */
2450 	    (*_bfd_error_handler)
2451 	      (_("%B: don't know how to handle OS specific section "
2452 		 "`%s' [0x%8x]"),
2453 	       abfd, name, hdr->sh_type);
2454 	  else
2455 	    {
2456 	      /* Otherwise it should be processed.  */
2457 	      ret = _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2458 	      goto success;
2459 	    }
2460 	}
2461       else
2462 	/* FIXME: We should handle this section.  */
2463 	(*_bfd_error_handler)
2464 	  (_("%B: don't know how to handle section `%s' [0x%8x]"),
2465 	   abfd, name, hdr->sh_type);
2466 
2467       goto fail;
2468     }
2469 
2470  fail:
2471   ret = FALSE;
2472  success:
2473   if (sections_being_created && sections_being_created_abfd == abfd)
2474     sections_being_created [shindex] = FALSE;
2475   if (-- nesting == 0)
2476     {
2477       sections_being_created = NULL;
2478       sections_being_created_abfd = abfd;
2479     }
2480   return ret;
2481 }
2482 
2483 /* Return the local symbol specified by ABFD, R_SYMNDX.  */
2484 
2485 Elf_Internal_Sym *
bfd_sym_from_r_symndx(struct sym_cache * cache,bfd * abfd,unsigned long r_symndx)2486 bfd_sym_from_r_symndx (struct sym_cache *cache,
2487 		       bfd *abfd,
2488 		       unsigned long r_symndx)
2489 {
2490   unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2491 
2492   if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2493     {
2494       Elf_Internal_Shdr *symtab_hdr;
2495       unsigned char esym[sizeof (Elf64_External_Sym)];
2496       Elf_External_Sym_Shndx eshndx;
2497 
2498       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2499       if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2500 				&cache->sym[ent], esym, &eshndx) == NULL)
2501 	return NULL;
2502 
2503       if (cache->abfd != abfd)
2504 	{
2505 	  memset (cache->indx, -1, sizeof (cache->indx));
2506 	  cache->abfd = abfd;
2507 	}
2508       cache->indx[ent] = r_symndx;
2509     }
2510 
2511   return &cache->sym[ent];
2512 }
2513 
2514 /* Given an ELF section number, retrieve the corresponding BFD
2515    section.  */
2516 
2517 asection *
bfd_section_from_elf_index(bfd * abfd,unsigned int sec_index)2518 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2519 {
2520   if (sec_index >= elf_numsections (abfd))
2521     return NULL;
2522   return elf_elfsections (abfd)[sec_index]->bfd_section;
2523 }
2524 
2525 static const struct bfd_elf_special_section special_sections_b[] =
2526 {
2527   { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
2528   { NULL,                   0,  0, 0,            0 }
2529 };
2530 
2531 static const struct bfd_elf_special_section special_sections_c[] =
2532 {
2533   { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2534   { NULL,                       0, 0, 0,            0 }
2535 };
2536 
2537 static const struct bfd_elf_special_section special_sections_d[] =
2538 {
2539   { STRING_COMMA_LEN (".data"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2540   { STRING_COMMA_LEN (".data1"),         0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2541   /* There are more DWARF sections than these, but they needn't be added here
2542      unless you have to cope with broken compilers that don't emit section
2543      attributes or you want to help the user writing assembler.  */
2544   { STRING_COMMA_LEN (".debug"),         0, SHT_PROGBITS, 0 },
2545   { STRING_COMMA_LEN (".debug_line"),    0, SHT_PROGBITS, 0 },
2546   { STRING_COMMA_LEN (".debug_info"),    0, SHT_PROGBITS, 0 },
2547   { STRING_COMMA_LEN (".debug_abbrev"),  0, SHT_PROGBITS, 0 },
2548   { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2549   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  SHF_ALLOC },
2550   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   SHF_ALLOC },
2551   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   SHF_ALLOC },
2552   { NULL,                      0,        0, 0,            0 }
2553 };
2554 
2555 static const struct bfd_elf_special_section special_sections_f[] =
2556 {
2557   { STRING_COMMA_LEN (".fini"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2558   { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2559   { NULL,                          0, 0, 0,              0 }
2560 };
2561 
2562 static const struct bfd_elf_special_section special_sections_g[] =
2563 {
2564   { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS,      SHF_ALLOC + SHF_WRITE },
2565   { STRING_COMMA_LEN (".gnu.lto_"),       -1, SHT_PROGBITS,    SHF_EXCLUDE },
2566   { STRING_COMMA_LEN (".got"),             0, SHT_PROGBITS,    SHF_ALLOC + SHF_WRITE },
2567   { STRING_COMMA_LEN (".gnu.version"),     0, SHT_GNU_versym,  0 },
2568   { STRING_COMMA_LEN (".gnu.version_d"),   0, SHT_GNU_verdef,  0 },
2569   { STRING_COMMA_LEN (".gnu.version_r"),   0, SHT_GNU_verneed, 0 },
2570   { STRING_COMMA_LEN (".gnu.liblist"),     0, SHT_GNU_LIBLIST, SHF_ALLOC },
2571   { STRING_COMMA_LEN (".gnu.conflict"),    0, SHT_RELA,        SHF_ALLOC },
2572   { STRING_COMMA_LEN (".gnu.hash"),        0, SHT_GNU_HASH,    SHF_ALLOC },
2573   { NULL,                        0,        0, 0,               0 }
2574 };
2575 
2576 static const struct bfd_elf_special_section special_sections_h[] =
2577 {
2578   { STRING_COMMA_LEN (".hash"), 0, SHT_HASH,     SHF_ALLOC },
2579   { NULL,                    0, 0, 0,            0 }
2580 };
2581 
2582 static const struct bfd_elf_special_section special_sections_i[] =
2583 {
2584   { STRING_COMMA_LEN (".init"),       0, SHT_PROGBITS,   SHF_ALLOC + SHF_EXECINSTR },
2585   { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2586   { STRING_COMMA_LEN (".interp"),     0, SHT_PROGBITS,   0 },
2587   { NULL,                      0,     0, 0,              0 }
2588 };
2589 
2590 static const struct bfd_elf_special_section special_sections_l[] =
2591 {
2592   { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2593   { NULL,                    0, 0, 0,            0 }
2594 };
2595 
2596 static const struct bfd_elf_special_section special_sections_n[] =
2597 {
2598   { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2599   { STRING_COMMA_LEN (".note"),          -1, SHT_NOTE,     0 },
2600   { NULL,                    0,           0, 0,            0 }
2601 };
2602 
2603 static const struct bfd_elf_special_section special_sections_p[] =
2604 {
2605   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2606   { STRING_COMMA_LEN (".plt"),           0, SHT_PROGBITS,      SHF_ALLOC + SHF_EXECINSTR },
2607   { NULL,                   0,           0, 0,                 0 }
2608 };
2609 
2610 static const struct bfd_elf_special_section special_sections_r[] =
2611 {
2612   { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2613   { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2614   { STRING_COMMA_LEN (".rela"),   -1, SHT_RELA,     0 },
2615   { STRING_COMMA_LEN (".rel"),    -1, SHT_REL,      0 },
2616   { NULL,                   0,     0, 0,            0 }
2617 };
2618 
2619 static const struct bfd_elf_special_section special_sections_s[] =
2620 {
2621   { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2622   { STRING_COMMA_LEN (".strtab"),   0, SHT_STRTAB, 0 },
2623   { STRING_COMMA_LEN (".symtab"),   0, SHT_SYMTAB, 0 },
2624   /* See struct bfd_elf_special_section declaration for the semantics of
2625      this special case where .prefix_length != strlen (.prefix).  */
2626   { ".stabstr",			5,  3, SHT_STRTAB, 0 },
2627   { NULL,                       0,  0, 0,          0 }
2628 };
2629 
2630 static const struct bfd_elf_special_section special_sections_t[] =
2631 {
2632   { STRING_COMMA_LEN (".text"),  -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2633   { STRING_COMMA_LEN (".tbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_TLS },
2634   { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2635   { NULL,                     0,  0, 0,            0 }
2636 };
2637 
2638 static const struct bfd_elf_special_section special_sections_z[] =
2639 {
2640   { STRING_COMMA_LEN (".zdebug_line"),    0, SHT_PROGBITS, 0 },
2641   { STRING_COMMA_LEN (".zdebug_info"),    0, SHT_PROGBITS, 0 },
2642   { STRING_COMMA_LEN (".zdebug_abbrev"),  0, SHT_PROGBITS, 0 },
2643   { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2644   { NULL,                     0,  0, 0,            0 }
2645 };
2646 
2647 static const struct bfd_elf_special_section * const special_sections[] =
2648 {
2649   special_sections_b,		/* 'b' */
2650   special_sections_c,		/* 'c' */
2651   special_sections_d,		/* 'd' */
2652   NULL,				/* 'e' */
2653   special_sections_f,		/* 'f' */
2654   special_sections_g,		/* 'g' */
2655   special_sections_h,		/* 'h' */
2656   special_sections_i,		/* 'i' */
2657   NULL,				/* 'j' */
2658   NULL,				/* 'k' */
2659   special_sections_l,		/* 'l' */
2660   NULL,				/* 'm' */
2661   special_sections_n,		/* 'n' */
2662   NULL,				/* 'o' */
2663   special_sections_p,		/* 'p' */
2664   NULL,				/* 'q' */
2665   special_sections_r,		/* 'r' */
2666   special_sections_s,		/* 's' */
2667   special_sections_t,		/* 't' */
2668   NULL,				/* 'u' */
2669   NULL,				/* 'v' */
2670   NULL,				/* 'w' */
2671   NULL,				/* 'x' */
2672   NULL,				/* 'y' */
2673   special_sections_z		/* 'z' */
2674 };
2675 
2676 const struct bfd_elf_special_section *
_bfd_elf_get_special_section(const char * name,const struct bfd_elf_special_section * spec,unsigned int rela)2677 _bfd_elf_get_special_section (const char *name,
2678 			      const struct bfd_elf_special_section *spec,
2679 			      unsigned int rela)
2680 {
2681   int i;
2682   int len;
2683 
2684   len = strlen (name);
2685 
2686   for (i = 0; spec[i].prefix != NULL; i++)
2687     {
2688       int suffix_len;
2689       int prefix_len = spec[i].prefix_length;
2690 
2691       if (len < prefix_len)
2692 	continue;
2693       if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2694 	continue;
2695 
2696       suffix_len = spec[i].suffix_length;
2697       if (suffix_len <= 0)
2698 	{
2699 	  if (name[prefix_len] != 0)
2700 	    {
2701 	      if (suffix_len == 0)
2702 		continue;
2703 	      if (name[prefix_len] != '.'
2704 		  && (suffix_len == -2
2705 		      || (rela && spec[i].type == SHT_REL)))
2706 		continue;
2707 	    }
2708 	}
2709       else
2710 	{
2711 	  if (len < prefix_len + suffix_len)
2712 	    continue;
2713 	  if (memcmp (name + len - suffix_len,
2714 		      spec[i].prefix + prefix_len,
2715 		      suffix_len) != 0)
2716 	    continue;
2717 	}
2718       return &spec[i];
2719     }
2720 
2721   return NULL;
2722 }
2723 
2724 const struct bfd_elf_special_section *
_bfd_elf_get_sec_type_attr(bfd * abfd,asection * sec)2725 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2726 {
2727   int i;
2728   const struct bfd_elf_special_section *spec;
2729   const struct elf_backend_data *bed;
2730 
2731   /* See if this is one of the special sections.  */
2732   if (sec->name == NULL)
2733     return NULL;
2734 
2735   bed = get_elf_backend_data (abfd);
2736   spec = bed->special_sections;
2737   if (spec)
2738     {
2739       spec = _bfd_elf_get_special_section (sec->name,
2740 					   bed->special_sections,
2741 					   sec->use_rela_p);
2742       if (spec != NULL)
2743 	return spec;
2744     }
2745 
2746   if (sec->name[0] != '.')
2747     return NULL;
2748 
2749   i = sec->name[1] - 'b';
2750   if (i < 0 || i > 'z' - 'b')
2751     return NULL;
2752 
2753   spec = special_sections[i];
2754 
2755   if (spec == NULL)
2756     return NULL;
2757 
2758   return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2759 }
2760 
2761 bfd_boolean
_bfd_elf_new_section_hook(bfd * abfd,asection * sec)2762 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2763 {
2764   struct bfd_elf_section_data *sdata;
2765   const struct elf_backend_data *bed;
2766   const struct bfd_elf_special_section *ssect;
2767 
2768   sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2769   if (sdata == NULL)
2770     {
2771       sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2772                                                           sizeof (*sdata));
2773       if (sdata == NULL)
2774 	return FALSE;
2775       sec->used_by_bfd = sdata;
2776     }
2777 
2778   /* Indicate whether or not this section should use RELA relocations.  */
2779   bed = get_elf_backend_data (abfd);
2780   sec->use_rela_p = bed->default_use_rela_p;
2781 
2782   /* When we read a file, we don't need to set ELF section type and
2783      flags.  They will be overridden in _bfd_elf_make_section_from_shdr
2784      anyway.  We will set ELF section type and flags for all linker
2785      created sections.  If user specifies BFD section flags, we will
2786      set ELF section type and flags based on BFD section flags in
2787      elf_fake_sections.  Special handling for .init_array/.fini_array
2788      output sections since they may contain .ctors/.dtors input
2789      sections.  We don't want _bfd_elf_init_private_section_data to
2790      copy ELF section type from .ctors/.dtors input sections.  */
2791   if (abfd->direction != read_direction
2792       || (sec->flags & SEC_LINKER_CREATED) != 0)
2793     {
2794       ssect = (*bed->get_sec_type_attr) (abfd, sec);
2795       if (ssect != NULL
2796 	  && (!sec->flags
2797 	      || (sec->flags & SEC_LINKER_CREATED) != 0
2798 	      || ssect->type == SHT_INIT_ARRAY
2799 	      || ssect->type == SHT_FINI_ARRAY))
2800 	{
2801 	  elf_section_type (sec) = ssect->type;
2802 	  elf_section_flags (sec) = ssect->attr;
2803 	}
2804     }
2805 
2806   return _bfd_generic_new_section_hook (abfd, sec);
2807 }
2808 
2809 /* Create a new bfd section from an ELF program header.
2810 
2811    Since program segments have no names, we generate a synthetic name
2812    of the form segment<NUM>, where NUM is generally the index in the
2813    program header table.  For segments that are split (see below) we
2814    generate the names segment<NUM>a and segment<NUM>b.
2815 
2816    Note that some program segments may have a file size that is different than
2817    (less than) the memory size.  All this means is that at execution the
2818    system must allocate the amount of memory specified by the memory size,
2819    but only initialize it with the first "file size" bytes read from the
2820    file.  This would occur for example, with program segments consisting
2821    of combined data+bss.
2822 
2823    To handle the above situation, this routine generates TWO bfd sections
2824    for the single program segment.  The first has the length specified by
2825    the file size of the segment, and the second has the length specified
2826    by the difference between the two sizes.  In effect, the segment is split
2827    into its initialized and uninitialized parts.
2828 
2829  */
2830 
2831 bfd_boolean
_bfd_elf_make_section_from_phdr(bfd * abfd,Elf_Internal_Phdr * hdr,int hdr_index,const char * type_name)2832 _bfd_elf_make_section_from_phdr (bfd *abfd,
2833 				 Elf_Internal_Phdr *hdr,
2834 				 int hdr_index,
2835 				 const char *type_name)
2836 {
2837   asection *newsect;
2838   char *name;
2839   char namebuf[64];
2840   size_t len;
2841   int split;
2842 
2843   split = ((hdr->p_memsz > 0)
2844 	    && (hdr->p_filesz > 0)
2845 	    && (hdr->p_memsz > hdr->p_filesz));
2846 
2847   if (hdr->p_filesz > 0)
2848     {
2849       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2850       len = strlen (namebuf) + 1;
2851       name = (char *) bfd_alloc (abfd, len);
2852       if (!name)
2853 	return FALSE;
2854       memcpy (name, namebuf, len);
2855       newsect = bfd_make_section (abfd, name);
2856       if (newsect == NULL)
2857 	return FALSE;
2858       newsect->vma = hdr->p_vaddr;
2859       newsect->lma = hdr->p_paddr;
2860       newsect->size = hdr->p_filesz;
2861       newsect->filepos = hdr->p_offset;
2862       newsect->flags |= SEC_HAS_CONTENTS;
2863       newsect->alignment_power = bfd_log2 (hdr->p_align);
2864       if (hdr->p_type == PT_LOAD)
2865 	{
2866 	  newsect->flags |= SEC_ALLOC;
2867 	  newsect->flags |= SEC_LOAD;
2868 	  if (hdr->p_flags & PF_X)
2869 	    {
2870 	      /* FIXME: all we known is that it has execute PERMISSION,
2871 		 may be data.  */
2872 	      newsect->flags |= SEC_CODE;
2873 	    }
2874 	}
2875       if (!(hdr->p_flags & PF_W))
2876 	{
2877 	  newsect->flags |= SEC_READONLY;
2878 	}
2879     }
2880 
2881   if (hdr->p_memsz > hdr->p_filesz)
2882     {
2883       bfd_vma align;
2884 
2885       sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2886       len = strlen (namebuf) + 1;
2887       name = (char *) bfd_alloc (abfd, len);
2888       if (!name)
2889 	return FALSE;
2890       memcpy (name, namebuf, len);
2891       newsect = bfd_make_section (abfd, name);
2892       if (newsect == NULL)
2893 	return FALSE;
2894       newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2895       newsect->lma = hdr->p_paddr + hdr->p_filesz;
2896       newsect->size = hdr->p_memsz - hdr->p_filesz;
2897       newsect->filepos = hdr->p_offset + hdr->p_filesz;
2898       align = newsect->vma & -newsect->vma;
2899       if (align == 0 || align > hdr->p_align)
2900 	align = hdr->p_align;
2901       newsect->alignment_power = bfd_log2 (align);
2902       if (hdr->p_type == PT_LOAD)
2903 	{
2904 	  /* Hack for gdb.  Segments that have not been modified do
2905 	     not have their contents written to a core file, on the
2906 	     assumption that a debugger can find the contents in the
2907 	     executable.  We flag this case by setting the fake
2908 	     section size to zero.  Note that "real" bss sections will
2909 	     always have their contents dumped to the core file.  */
2910 	  if (bfd_get_format (abfd) == bfd_core)
2911 	    newsect->size = 0;
2912 	  newsect->flags |= SEC_ALLOC;
2913 	  if (hdr->p_flags & PF_X)
2914 	    newsect->flags |= SEC_CODE;
2915 	}
2916       if (!(hdr->p_flags & PF_W))
2917 	newsect->flags |= SEC_READONLY;
2918     }
2919 
2920   return TRUE;
2921 }
2922 
2923 bfd_boolean
bfd_section_from_phdr(bfd * abfd,Elf_Internal_Phdr * hdr,int hdr_index)2924 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2925 {
2926   const struct elf_backend_data *bed;
2927 
2928   switch (hdr->p_type)
2929     {
2930     case PT_NULL:
2931       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2932 
2933     case PT_LOAD:
2934       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2935 
2936     case PT_DYNAMIC:
2937       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2938 
2939     case PT_INTERP:
2940       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2941 
2942     case PT_NOTE:
2943       if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2944 	return FALSE;
2945       if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2946 	return FALSE;
2947       return TRUE;
2948 
2949     case PT_SHLIB:
2950       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2951 
2952     case PT_PHDR:
2953       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2954 
2955     case PT_GNU_EH_FRAME:
2956       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2957 					      "eh_frame_hdr");
2958 
2959     case PT_GNU_STACK:
2960       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2961 
2962     case PT_GNU_RELRO:
2963       return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2964 
2965     default:
2966       /* Check for any processor-specific program segment types.  */
2967       bed = get_elf_backend_data (abfd);
2968       return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2969     }
2970 }
2971 
2972 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2973    REL or RELA.  */
2974 
2975 Elf_Internal_Shdr *
_bfd_elf_single_rel_hdr(asection * sec)2976 _bfd_elf_single_rel_hdr (asection *sec)
2977 {
2978   if (elf_section_data (sec)->rel.hdr)
2979     {
2980       BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2981       return elf_section_data (sec)->rel.hdr;
2982     }
2983   else
2984     return elf_section_data (sec)->rela.hdr;
2985 }
2986 
2987 static bfd_boolean
_bfd_elf_set_reloc_sh_name(bfd * abfd,Elf_Internal_Shdr * rel_hdr,const char * sec_name,bfd_boolean use_rela_p)2988 _bfd_elf_set_reloc_sh_name (bfd *abfd,
2989 			    Elf_Internal_Shdr *rel_hdr,
2990 			    const char *sec_name,
2991 			    bfd_boolean use_rela_p)
2992 {
2993   char *name = (char *) bfd_alloc (abfd,
2994 				   sizeof ".rela" + strlen (sec_name));
2995   if (name == NULL)
2996     return FALSE;
2997 
2998   sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name);
2999   rel_hdr->sh_name =
3000     (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
3001 					FALSE);
3002   if (rel_hdr->sh_name == (unsigned int) -1)
3003     return FALSE;
3004 
3005   return TRUE;
3006 }
3007 
3008 /* Allocate and initialize a section-header for a new reloc section,
3009    containing relocations against ASECT.  It is stored in RELDATA.  If
3010    USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3011    relocations.  */
3012 
3013 static bfd_boolean
_bfd_elf_init_reloc_shdr(bfd * abfd,struct bfd_elf_section_reloc_data * reldata,const char * sec_name,bfd_boolean use_rela_p,bfd_boolean delay_st_name_p)3014 _bfd_elf_init_reloc_shdr (bfd *abfd,
3015 			  struct bfd_elf_section_reloc_data *reldata,
3016 			  const char *sec_name,
3017 			  bfd_boolean use_rela_p,
3018 			  bfd_boolean delay_st_name_p)
3019 {
3020   Elf_Internal_Shdr *rel_hdr;
3021   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3022 
3023   BFD_ASSERT (reldata->hdr == NULL);
3024   rel_hdr = bfd_zalloc (abfd, sizeof (*rel_hdr));
3025   reldata->hdr = rel_hdr;
3026 
3027   if (delay_st_name_p)
3028     rel_hdr->sh_name = (unsigned int) -1;
3029   else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name,
3030 					use_rela_p))
3031     return FALSE;
3032   rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
3033   rel_hdr->sh_entsize = (use_rela_p
3034 			 ? bed->s->sizeof_rela
3035 			 : bed->s->sizeof_rel);
3036   rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
3037   rel_hdr->sh_flags = 0;
3038   rel_hdr->sh_addr = 0;
3039   rel_hdr->sh_size = 0;
3040   rel_hdr->sh_offset = 0;
3041 
3042   return TRUE;
3043 }
3044 
3045 /* Return the default section type based on the passed in section flags.  */
3046 
3047 int
bfd_elf_get_default_section_type(flagword flags)3048 bfd_elf_get_default_section_type (flagword flags)
3049 {
3050   if ((flags & SEC_ALLOC) != 0
3051       && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3052     return SHT_NOBITS;
3053   return SHT_PROGBITS;
3054 }
3055 
3056 struct fake_section_arg
3057 {
3058   struct bfd_link_info *link_info;
3059   bfd_boolean failed;
3060 };
3061 
3062 /* Set up an ELF internal section header for a section.  */
3063 
3064 static void
elf_fake_sections(bfd * abfd,asection * asect,void * fsarg)3065 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
3066 {
3067   struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
3068   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3069   struct bfd_elf_section_data *esd = elf_section_data (asect);
3070   Elf_Internal_Shdr *this_hdr;
3071   unsigned int sh_type;
3072   const char *name = asect->name;
3073   bfd_boolean delay_st_name_p = FALSE;
3074 
3075   if (arg->failed)
3076     {
3077       /* We already failed; just get out of the bfd_map_over_sections
3078 	 loop.  */
3079       return;
3080     }
3081 
3082   this_hdr = &esd->this_hdr;
3083 
3084   if (arg->link_info)
3085     {
3086       /* ld: compress DWARF debug sections with names: .debug_*.  */
3087       if ((arg->link_info->compress_debug & COMPRESS_DEBUG)
3088 	  && (asect->flags & SEC_DEBUGGING)
3089 	  && name[1] == 'd'
3090 	  && name[6] == '_')
3091 	{
3092 	  /* Set SEC_ELF_COMPRESS to indicate this section should be
3093 	     compressed.  */
3094 	  asect->flags |= SEC_ELF_COMPRESS;
3095 
3096 	  /* If this section will be compressed, delay adding setion
3097 	     name to section name section after it is compressed in
3098 	     _bfd_elf_assign_file_positions_for_non_load.  */
3099 	  delay_st_name_p = TRUE;
3100 	}
3101     }
3102   else if ((asect->flags & SEC_ELF_RENAME))
3103     {
3104       /* objcopy: rename output DWARF debug section.  */
3105       if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI)))
3106 	{
3107 	  /* When we decompress or compress with SHF_COMPRESSED,
3108 	     convert section name from .zdebug_* to .debug_* if
3109 	     needed.  */
3110 	  if (name[1] == 'z')
3111 	    {
3112 	      char *new_name = convert_zdebug_to_debug (abfd, name);
3113 	      if (new_name == NULL)
3114 		{
3115 		  arg->failed = TRUE;
3116 		  return;
3117 		}
3118 	      name = new_name;
3119 	    }
3120 	}
3121       else if (asect->compress_status == COMPRESS_SECTION_DONE)
3122 	{
3123 	  /* PR binutils/18087: Compression does not always make a
3124 	     section smaller.  So only rename the section when
3125 	     compression has actually taken place.  If input section
3126 	     name is .zdebug_*, we should never compress it again.  */
3127 	  char *new_name = convert_debug_to_zdebug (abfd, name);
3128 	  if (new_name == NULL)
3129 	    {
3130 	      arg->failed = TRUE;
3131 	      return;
3132 	    }
3133 	  BFD_ASSERT (name[1] != 'z');
3134 	  name = new_name;
3135 	}
3136     }
3137 
3138   if (delay_st_name_p)
3139     this_hdr->sh_name = (unsigned int) -1;
3140   else
3141     {
3142       this_hdr->sh_name
3143 	= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3144 					      name, FALSE);
3145       if (this_hdr->sh_name == (unsigned int) -1)
3146 	{
3147 	  arg->failed = TRUE;
3148 	  return;
3149 	}
3150     }
3151 
3152   /* Don't clear sh_flags. Assembler may set additional bits.  */
3153 
3154   if ((asect->flags & SEC_ALLOC) != 0
3155       || asect->user_set_vma)
3156     this_hdr->sh_addr = asect->vma;
3157   else
3158     this_hdr->sh_addr = 0;
3159 
3160   this_hdr->sh_offset = 0;
3161   this_hdr->sh_size = asect->size;
3162   this_hdr->sh_link = 0;
3163   /* PR 17512: file: 0eb809fe, 8b0535ee.  */
3164   if (asect->alignment_power >= (sizeof (bfd_vma) * 8) - 1)
3165     {
3166       (*_bfd_error_handler)
3167 	(_("%B: error: Alignment power %d of section `%A' is too big"),
3168 	 abfd, asect, asect->alignment_power);
3169       arg->failed = TRUE;
3170       return;
3171     }
3172   this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
3173   /* The sh_entsize and sh_info fields may have been set already by
3174      copy_private_section_data.  */
3175 
3176   this_hdr->bfd_section = asect;
3177   this_hdr->contents = NULL;
3178 
3179   /* If the section type is unspecified, we set it based on
3180      asect->flags.  */
3181   if ((asect->flags & SEC_GROUP) != 0)
3182     sh_type = SHT_GROUP;
3183   else
3184     sh_type = bfd_elf_get_default_section_type (asect->flags);
3185 
3186   if (this_hdr->sh_type == SHT_NULL)
3187     this_hdr->sh_type = sh_type;
3188   else if (this_hdr->sh_type == SHT_NOBITS
3189 	   && sh_type == SHT_PROGBITS
3190 	   && (asect->flags & SEC_ALLOC) != 0)
3191     {
3192       /* Warn if we are changing a NOBITS section to PROGBITS, but
3193 	 allow the link to proceed.  This can happen when users link
3194 	 non-bss input sections to bss output sections, or emit data
3195 	 to a bss output section via a linker script.  */
3196       (*_bfd_error_handler)
3197 	(_("warning: section `%A' type changed to PROGBITS"), asect);
3198       this_hdr->sh_type = sh_type;
3199     }
3200 
3201   switch (this_hdr->sh_type)
3202     {
3203     default:
3204       break;
3205 
3206     case SHT_STRTAB:
3207     case SHT_NOTE:
3208     case SHT_NOBITS:
3209     case SHT_PROGBITS:
3210       break;
3211 
3212     case SHT_INIT_ARRAY:
3213     case SHT_FINI_ARRAY:
3214     case SHT_PREINIT_ARRAY:
3215       this_hdr->sh_entsize = bed->s->arch_size / 8;
3216       break;
3217 
3218     case SHT_HASH:
3219       this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
3220       break;
3221 
3222     case SHT_DYNSYM:
3223       this_hdr->sh_entsize = bed->s->sizeof_sym;
3224       break;
3225 
3226     case SHT_DYNAMIC:
3227       this_hdr->sh_entsize = bed->s->sizeof_dyn;
3228       break;
3229 
3230     case SHT_RELA:
3231       if (get_elf_backend_data (abfd)->may_use_rela_p)
3232 	this_hdr->sh_entsize = bed->s->sizeof_rela;
3233       break;
3234 
3235      case SHT_REL:
3236       if (get_elf_backend_data (abfd)->may_use_rel_p)
3237 	this_hdr->sh_entsize = bed->s->sizeof_rel;
3238       break;
3239 
3240      case SHT_GNU_versym:
3241       this_hdr->sh_entsize = sizeof (Elf_External_Versym);
3242       break;
3243 
3244      case SHT_GNU_verdef:
3245       this_hdr->sh_entsize = 0;
3246       /* objcopy or strip will copy over sh_info, but may not set
3247 	 cverdefs.  The linker will set cverdefs, but sh_info will be
3248 	 zero.  */
3249       if (this_hdr->sh_info == 0)
3250 	this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
3251       else
3252 	BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
3253 		    || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
3254       break;
3255 
3256     case SHT_GNU_verneed:
3257       this_hdr->sh_entsize = 0;
3258       /* objcopy or strip will copy over sh_info, but may not set
3259 	 cverrefs.  The linker will set cverrefs, but sh_info will be
3260 	 zero.  */
3261       if (this_hdr->sh_info == 0)
3262 	this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
3263       else
3264 	BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
3265 		    || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
3266       break;
3267 
3268     case SHT_GROUP:
3269       this_hdr->sh_entsize = GRP_ENTRY_SIZE;
3270       break;
3271 
3272     case SHT_GNU_HASH:
3273       this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
3274       break;
3275     }
3276 
3277   if ((asect->flags & SEC_ALLOC) != 0)
3278     this_hdr->sh_flags |= SHF_ALLOC;
3279   if ((asect->flags & SEC_READONLY) == 0)
3280     this_hdr->sh_flags |= SHF_WRITE;
3281   if ((asect->flags & SEC_CODE) != 0)
3282     this_hdr->sh_flags |= SHF_EXECINSTR;
3283   if ((asect->flags & SEC_MERGE) != 0)
3284     {
3285       this_hdr->sh_flags |= SHF_MERGE;
3286       this_hdr->sh_entsize = asect->entsize;
3287     }
3288   if ((asect->flags & SEC_STRINGS) != 0)
3289     this_hdr->sh_flags |= SHF_STRINGS;
3290   if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
3291     this_hdr->sh_flags |= SHF_GROUP;
3292   if ((asect->flags & SEC_THREAD_LOCAL) != 0)
3293     {
3294       this_hdr->sh_flags |= SHF_TLS;
3295       if (asect->size == 0
3296 	  && (asect->flags & SEC_HAS_CONTENTS) == 0)
3297 	{
3298 	  struct bfd_link_order *o = asect->map_tail.link_order;
3299 
3300 	  this_hdr->sh_size = 0;
3301 	  if (o != NULL)
3302 	    {
3303 	      this_hdr->sh_size = o->offset + o->size;
3304 	      if (this_hdr->sh_size != 0)
3305 		this_hdr->sh_type = SHT_NOBITS;
3306 	    }
3307 	}
3308     }
3309   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
3310     this_hdr->sh_flags |= SHF_EXCLUDE;
3311 
3312   /* If the section has relocs, set up a section header for the
3313      SHT_REL[A] section.  If two relocation sections are required for
3314      this section, it is up to the processor-specific back-end to
3315      create the other.  */
3316   if ((asect->flags & SEC_RELOC) != 0)
3317     {
3318       /* When doing a relocatable link, create both REL and RELA sections if
3319 	 needed.  */
3320       if (arg->link_info
3321 	  /* Do the normal setup if we wouldn't create any sections here.  */
3322 	  && esd->rel.count + esd->rela.count > 0
3323 	  && (bfd_link_relocatable (arg->link_info)
3324 	      || arg->link_info->emitrelocations))
3325 	{
3326 	  if (esd->rel.count && esd->rel.hdr == NULL
3327 	      && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name, FALSE,
3328 					    delay_st_name_p))
3329 	    {
3330 	      arg->failed = TRUE;
3331 	      return;
3332 	    }
3333 	  if (esd->rela.count && esd->rela.hdr == NULL
3334 	      && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name, TRUE,
3335 					    delay_st_name_p))
3336 	    {
3337 	      arg->failed = TRUE;
3338 	      return;
3339 	    }
3340 	}
3341       else if (!_bfd_elf_init_reloc_shdr (abfd,
3342 					  (asect->use_rela_p
3343 					   ? &esd->rela : &esd->rel),
3344 					  name,
3345 					  asect->use_rela_p,
3346 					  delay_st_name_p))
3347 	  arg->failed = TRUE;
3348     }
3349 
3350   /* Check for processor-specific section types.  */
3351   sh_type = this_hdr->sh_type;
3352   if (bed->elf_backend_fake_sections
3353       && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
3354     arg->failed = TRUE;
3355 
3356   if (sh_type == SHT_NOBITS && asect->size != 0)
3357     {
3358       /* Don't change the header type from NOBITS if we are being
3359 	 called for objcopy --only-keep-debug.  */
3360       this_hdr->sh_type = sh_type;
3361     }
3362 }
3363 
3364 /* Fill in the contents of a SHT_GROUP section.  Called from
3365    _bfd_elf_compute_section_file_positions for gas, objcopy, and
3366    when ELF targets use the generic linker, ld.  Called for ld -r
3367    from bfd_elf_final_link.  */
3368 
3369 void
bfd_elf_set_group_contents(bfd * abfd,asection * sec,void * failedptrarg)3370 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
3371 {
3372   bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
3373   asection *elt, *first;
3374   unsigned char *loc;
3375   bfd_boolean gas;
3376 
3377   /* Ignore linker created group section.  See elfNN_ia64_object_p in
3378      elfxx-ia64.c.  */
3379   if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
3380       || *failedptr)
3381     return;
3382 
3383   if (elf_section_data (sec)->this_hdr.sh_info == 0)
3384     {
3385       unsigned long symindx = 0;
3386 
3387       /* elf_group_id will have been set up by objcopy and the
3388 	 generic linker.  */
3389       if (elf_group_id (sec) != NULL)
3390 	symindx = elf_group_id (sec)->udata.i;
3391 
3392       if (symindx == 0)
3393 	{
3394 	  /* If called from the assembler, swap_out_syms will have set up
3395 	     elf_section_syms.  */
3396 	  BFD_ASSERT (elf_section_syms (abfd) != NULL);
3397 	  symindx = elf_section_syms (abfd)[sec->index]->udata.i;
3398 	}
3399       elf_section_data (sec)->this_hdr.sh_info = symindx;
3400     }
3401   else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
3402     {
3403       /* The ELF backend linker sets sh_info to -2 when the group
3404 	 signature symbol is global, and thus the index can't be
3405 	 set until all local symbols are output.  */
3406       asection *igroup = elf_sec_group (elf_next_in_group (sec));
3407       struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
3408       unsigned long symndx = sec_data->this_hdr.sh_info;
3409       unsigned long extsymoff = 0;
3410       struct elf_link_hash_entry *h;
3411 
3412       if (!elf_bad_symtab (igroup->owner))
3413 	{
3414 	  Elf_Internal_Shdr *symtab_hdr;
3415 
3416 	  symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
3417 	  extsymoff = symtab_hdr->sh_info;
3418 	}
3419       h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
3420       while (h->root.type == bfd_link_hash_indirect
3421 	     || h->root.type == bfd_link_hash_warning)
3422 	h = (struct elf_link_hash_entry *) h->root.u.i.link;
3423 
3424       elf_section_data (sec)->this_hdr.sh_info = h->indx;
3425     }
3426 
3427   /* The contents won't be allocated for "ld -r" or objcopy.  */
3428   gas = TRUE;
3429   if (sec->contents == NULL)
3430     {
3431       gas = FALSE;
3432       sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
3433 
3434       /* Arrange for the section to be written out.  */
3435       elf_section_data (sec)->this_hdr.contents = sec->contents;
3436       if (sec->contents == NULL)
3437 	{
3438 	  *failedptr = TRUE;
3439 	  return;
3440 	}
3441     }
3442 
3443   loc = sec->contents + sec->size;
3444 
3445   /* Get the pointer to the first section in the group that gas
3446      squirreled away here.  objcopy arranges for this to be set to the
3447      start of the input section group.  */
3448   first = elt = elf_next_in_group (sec);
3449 
3450   /* First element is a flag word.  Rest of section is elf section
3451      indices for all the sections of the group.  Write them backwards
3452      just to keep the group in the same order as given in .section
3453      directives, not that it matters.  */
3454   while (elt != NULL)
3455     {
3456       asection *s;
3457 
3458       s = elt;
3459       if (!gas)
3460 	s = s->output_section;
3461       if (s != NULL
3462 	  && !bfd_is_abs_section (s))
3463 	{
3464 	  unsigned int idx = elf_section_data (s)->this_idx;
3465 
3466 	  loc -= 4;
3467 	  H_PUT_32 (abfd, idx, loc);
3468 	}
3469       elt = elf_next_in_group (elt);
3470       if (elt == first)
3471 	break;
3472     }
3473 
3474   if ((loc -= 4) != sec->contents)
3475     abort ();
3476 
3477   H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
3478 }
3479 
3480 /* Return the section which RELOC_SEC applies to.  */
3481 
3482 asection *
_bfd_elf_get_reloc_section(asection * reloc_sec)3483 _bfd_elf_get_reloc_section (asection *reloc_sec)
3484 {
3485   const char *name;
3486   unsigned int type;
3487   bfd *abfd;
3488 
3489   if (reloc_sec == NULL)
3490     return NULL;
3491 
3492   type = elf_section_data (reloc_sec)->this_hdr.sh_type;
3493   if (type != SHT_REL && type != SHT_RELA)
3494     return NULL;
3495 
3496   /* We look up the section the relocs apply to by name.  */
3497   name = reloc_sec->name;
3498   if (type == SHT_REL)
3499     name += 4;
3500   else
3501     name += 5;
3502 
3503   /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3504      section apply to .got.plt section.  */
3505   abfd = reloc_sec->owner;
3506   if (get_elf_backend_data (abfd)->want_got_plt
3507       && strcmp (name, ".plt") == 0)
3508     {
3509       /* .got.plt is a linker created input section.  It may be mapped
3510 	 to some other output section.  Try two likely sections.  */
3511       name = ".got.plt";
3512       reloc_sec = bfd_get_section_by_name (abfd, name);
3513       if (reloc_sec != NULL)
3514 	return reloc_sec;
3515       name = ".got";
3516     }
3517 
3518   reloc_sec = bfd_get_section_by_name (abfd, name);
3519   return reloc_sec;
3520 }
3521 
3522 /* Assign all ELF section numbers.  The dummy first section is handled here
3523    too.  The link/info pointers for the standard section types are filled
3524    in here too, while we're at it.  */
3525 
3526 static bfd_boolean
assign_section_numbers(bfd * abfd,struct bfd_link_info * link_info)3527 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
3528 {
3529   struct elf_obj_tdata *t = elf_tdata (abfd);
3530   asection *sec;
3531   unsigned int section_number;
3532   Elf_Internal_Shdr **i_shdrp;
3533   struct bfd_elf_section_data *d;
3534   bfd_boolean need_symtab;
3535 
3536   section_number = 1;
3537 
3538   _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3539 
3540   /* SHT_GROUP sections are in relocatable files only.  */
3541   if (link_info == NULL || bfd_link_relocatable (link_info))
3542     {
3543       size_t reloc_count = 0;
3544 
3545       /* Put SHT_GROUP sections first.  */
3546       for (sec = abfd->sections; sec != NULL; sec = sec->next)
3547 	{
3548 	  d = elf_section_data (sec);
3549 
3550 	  if (d->this_hdr.sh_type == SHT_GROUP)
3551 	    {
3552 	      if (sec->flags & SEC_LINKER_CREATED)
3553 		{
3554 		  /* Remove the linker created SHT_GROUP sections.  */
3555 		  bfd_section_list_remove (abfd, sec);
3556 		  abfd->section_count--;
3557 		}
3558 	      else
3559 		d->this_idx = section_number++;
3560 	    }
3561 
3562 	  /* Count relocations.  */
3563 	  reloc_count += sec->reloc_count;
3564 	}
3565 
3566       /* Clear HAS_RELOC if there are no relocations.  */
3567       if (reloc_count == 0)
3568 	abfd->flags &= ~HAS_RELOC;
3569     }
3570 
3571   for (sec = abfd->sections; sec; sec = sec->next)
3572     {
3573       d = elf_section_data (sec);
3574 
3575       if (d->this_hdr.sh_type != SHT_GROUP)
3576 	d->this_idx = section_number++;
3577       if (d->this_hdr.sh_name != (unsigned int) -1)
3578 	_bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3579       if (d->rel.hdr)
3580 	{
3581 	  d->rel.idx = section_number++;
3582 	  if (d->rel.hdr->sh_name != (unsigned int) -1)
3583 	    _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
3584 	}
3585       else
3586 	d->rel.idx = 0;
3587 
3588       if (d->rela.hdr)
3589 	{
3590 	  d->rela.idx = section_number++;
3591 	  if (d->rela.hdr->sh_name != (unsigned int) -1)
3592 	    _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
3593 	}
3594       else
3595 	d->rela.idx = 0;
3596     }
3597 
3598   elf_shstrtab_sec (abfd) = section_number++;
3599   _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3600   elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
3601 
3602   need_symtab = (bfd_get_symcount (abfd) > 0
3603 		|| (link_info == NULL
3604 		    && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3605 			== HAS_RELOC)));
3606   if (need_symtab)
3607     {
3608       elf_onesymtab (abfd) = section_number++;
3609       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3610       if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
3611 	{
3612 	  elf_section_list * entry;
3613 
3614 	  BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL);
3615 
3616 	  entry = bfd_zalloc (abfd, sizeof * entry);
3617 	  entry->ndx = section_number++;
3618 	  elf_symtab_shndx_list (abfd) = entry;
3619 	  entry->hdr.sh_name
3620 	    = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3621 						  ".symtab_shndx", FALSE);
3622 	  if (entry->hdr.sh_name == (unsigned int) -1)
3623 	    return FALSE;
3624 	}
3625       elf_strtab_sec (abfd) = section_number++;
3626       _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3627     }
3628 
3629   if (section_number >= SHN_LORESERVE)
3630     {
3631       _bfd_error_handler (_("%B: too many sections: %u"),
3632 			  abfd, section_number);
3633       return FALSE;
3634     }
3635 
3636   elf_numsections (abfd) = section_number;
3637   elf_elfheader (abfd)->e_shnum = section_number;
3638 
3639   /* Set up the list of section header pointers, in agreement with the
3640      indices.  */
3641   i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3642                                                 sizeof (Elf_Internal_Shdr *));
3643   if (i_shdrp == NULL)
3644     return FALSE;
3645 
3646   i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3647                                                  sizeof (Elf_Internal_Shdr));
3648   if (i_shdrp[0] == NULL)
3649     {
3650       bfd_release (abfd, i_shdrp);
3651       return FALSE;
3652     }
3653 
3654   elf_elfsections (abfd) = i_shdrp;
3655 
3656   i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3657   if (need_symtab)
3658     {
3659       i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
3660       if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3661 	{
3662 	  elf_section_list * entry = elf_symtab_shndx_list (abfd);
3663 	  BFD_ASSERT (entry != NULL);
3664 	  i_shdrp[entry->ndx] = & entry->hdr;
3665 	  entry->hdr.sh_link = elf_onesymtab (abfd);
3666 	}
3667       i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3668       t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
3669     }
3670 
3671   for (sec = abfd->sections; sec; sec = sec->next)
3672     {
3673       asection *s;
3674 
3675       d = elf_section_data (sec);
3676 
3677       i_shdrp[d->this_idx] = &d->this_hdr;
3678       if (d->rel.idx != 0)
3679 	i_shdrp[d->rel.idx] = d->rel.hdr;
3680       if (d->rela.idx != 0)
3681 	i_shdrp[d->rela.idx] = d->rela.hdr;
3682 
3683       /* Fill in the sh_link and sh_info fields while we're at it.  */
3684 
3685       /* sh_link of a reloc section is the section index of the symbol
3686 	 table.  sh_info is the section index of the section to which
3687 	 the relocation entries apply.  */
3688       if (d->rel.idx != 0)
3689 	{
3690 	  d->rel.hdr->sh_link = elf_onesymtab (abfd);
3691 	  d->rel.hdr->sh_info = d->this_idx;
3692 	  d->rel.hdr->sh_flags |= SHF_INFO_LINK;
3693 	}
3694       if (d->rela.idx != 0)
3695 	{
3696 	  d->rela.hdr->sh_link = elf_onesymtab (abfd);
3697 	  d->rela.hdr->sh_info = d->this_idx;
3698 	  d->rela.hdr->sh_flags |= SHF_INFO_LINK;
3699 	}
3700 
3701       /* We need to set up sh_link for SHF_LINK_ORDER.  */
3702       if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3703 	{
3704 	  s = elf_linked_to_section (sec);
3705 	  if (s)
3706 	    {
3707 	      /* elf_linked_to_section points to the input section.  */
3708 	      if (link_info != NULL)
3709 		{
3710 		  /* Check discarded linkonce section.  */
3711 		  if (discarded_section (s))
3712 		    {
3713 		      asection *kept;
3714 		      (*_bfd_error_handler)
3715 			(_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3716 			 abfd, d->this_hdr.bfd_section,
3717 			 s, s->owner);
3718 		      /* Point to the kept section if it has the same
3719 			 size as the discarded one.  */
3720 		      kept = _bfd_elf_check_kept_section (s, link_info);
3721 		      if (kept == NULL)
3722 			{
3723 			  bfd_set_error (bfd_error_bad_value);
3724 			  return FALSE;
3725 			}
3726 		      s = kept;
3727 		    }
3728 
3729 		  s = s->output_section;
3730 		  BFD_ASSERT (s != NULL);
3731 		}
3732 	      else
3733 		{
3734 		  /* Handle objcopy. */
3735 		  if (s->output_section == NULL)
3736 		    {
3737 		      (*_bfd_error_handler)
3738 			(_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3739 			 abfd, d->this_hdr.bfd_section, s, s->owner);
3740 		      bfd_set_error (bfd_error_bad_value);
3741 		      return FALSE;
3742 		    }
3743 		  s = s->output_section;
3744 		}
3745 	      d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3746 	    }
3747 	  else
3748 	    {
3749 	      /* PR 290:
3750 		 The Intel C compiler generates SHT_IA_64_UNWIND with
3751 		 SHF_LINK_ORDER.  But it doesn't set the sh_link or
3752 		 sh_info fields.  Hence we could get the situation
3753 		 where s is NULL.  */
3754 	      const struct elf_backend_data *bed
3755 		= get_elf_backend_data (abfd);
3756 	      if (bed->link_order_error_handler)
3757 		bed->link_order_error_handler
3758 		  (_("%B: warning: sh_link not set for section `%A'"),
3759 		   abfd, sec);
3760 	    }
3761 	}
3762 
3763       switch (d->this_hdr.sh_type)
3764 	{
3765 	case SHT_REL:
3766 	case SHT_RELA:
3767 	  /* A reloc section which we are treating as a normal BFD
3768 	     section.  sh_link is the section index of the symbol
3769 	     table.  sh_info is the section index of the section to
3770 	     which the relocation entries apply.  We assume that an
3771 	     allocated reloc section uses the dynamic symbol table.
3772 	     FIXME: How can we be sure?  */
3773 	  s = bfd_get_section_by_name (abfd, ".dynsym");
3774 	  if (s != NULL)
3775 	    d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3776 
3777 	  s = get_elf_backend_data (abfd)->get_reloc_section (sec);
3778 	  if (s != NULL)
3779 	    {
3780 	      d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3781 	      d->this_hdr.sh_flags |= SHF_INFO_LINK;
3782 	    }
3783 	  break;
3784 
3785 	case SHT_STRTAB:
3786 	  /* We assume that a section named .stab*str is a stabs
3787 	     string section.  We look for a section with the same name
3788 	     but without the trailing ``str'', and set its sh_link
3789 	     field to point to this section.  */
3790 	  if (CONST_STRNEQ (sec->name, ".stab")
3791 	      && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3792 	    {
3793 	      size_t len;
3794 	      char *alc;
3795 
3796 	      len = strlen (sec->name);
3797 	      alc = (char *) bfd_malloc (len - 2);
3798 	      if (alc == NULL)
3799 		return FALSE;
3800 	      memcpy (alc, sec->name, len - 3);
3801 	      alc[len - 3] = '\0';
3802 	      s = bfd_get_section_by_name (abfd, alc);
3803 	      free (alc);
3804 	      if (s != NULL)
3805 		{
3806 		  elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3807 
3808 		  /* This is a .stab section.  */
3809 		  if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3810 		    elf_section_data (s)->this_hdr.sh_entsize
3811 		      = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3812 		}
3813 	    }
3814 	  break;
3815 
3816 	case SHT_DYNAMIC:
3817 	case SHT_DYNSYM:
3818 	case SHT_GNU_verneed:
3819 	case SHT_GNU_verdef:
3820 	  /* sh_link is the section header index of the string table
3821 	     used for the dynamic entries, or the symbol table, or the
3822 	     version strings.  */
3823 	  s = bfd_get_section_by_name (abfd, ".dynstr");
3824 	  if (s != NULL)
3825 	    d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3826 	  break;
3827 
3828 	case SHT_GNU_LIBLIST:
3829 	  /* sh_link is the section header index of the prelink library
3830 	     list used for the dynamic entries, or the symbol table, or
3831 	     the version strings.  */
3832 	  s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3833 					     ? ".dynstr" : ".gnu.libstr");
3834 	  if (s != NULL)
3835 	    d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3836 	  break;
3837 
3838 	case SHT_HASH:
3839 	case SHT_GNU_HASH:
3840 	case SHT_GNU_versym:
3841 	  /* sh_link is the section header index of the symbol table
3842 	     this hash table or version table is for.  */
3843 	  s = bfd_get_section_by_name (abfd, ".dynsym");
3844 	  if (s != NULL)
3845 	    d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3846 	  break;
3847 
3848 	case SHT_GROUP:
3849 	  d->this_hdr.sh_link = elf_onesymtab (abfd);
3850 	}
3851     }
3852 
3853   /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3854      _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3855      debug section name from .debug_* to .zdebug_* if needed.  */
3856 
3857   return TRUE;
3858 }
3859 
3860 static bfd_boolean
sym_is_global(bfd * abfd,asymbol * sym)3861 sym_is_global (bfd *abfd, asymbol *sym)
3862 {
3863   /* If the backend has a special mapping, use it.  */
3864   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3865   if (bed->elf_backend_sym_is_global)
3866     return (*bed->elf_backend_sym_is_global) (abfd, sym);
3867 
3868   return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3869 	  || bfd_is_und_section (bfd_get_section (sym))
3870 	  || bfd_is_com_section (bfd_get_section (sym)));
3871 }
3872 
3873 /* Don't output section symbols for sections that are not going to be
3874    output, that are duplicates or there is no BFD section.  */
3875 
3876 static bfd_boolean
ignore_section_sym(bfd * abfd,asymbol * sym)3877 ignore_section_sym (bfd *abfd, asymbol *sym)
3878 {
3879   elf_symbol_type *type_ptr;
3880 
3881   if ((sym->flags & BSF_SECTION_SYM) == 0)
3882     return FALSE;
3883 
3884   type_ptr = elf_symbol_from (abfd, sym);
3885   return ((type_ptr != NULL
3886 	   && type_ptr->internal_elf_sym.st_shndx != 0
3887 	   && bfd_is_abs_section (sym->section))
3888 	  || !(sym->section->owner == abfd
3889 	       || (sym->section->output_section->owner == abfd
3890 		   && sym->section->output_offset == 0)
3891 	       || bfd_is_abs_section (sym->section)));
3892 }
3893 
3894 /* Map symbol from it's internal number to the external number, moving
3895    all local symbols to be at the head of the list.  */
3896 
3897 static bfd_boolean
elf_map_symbols(bfd * abfd,unsigned int * pnum_locals)3898 elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
3899 {
3900   unsigned int symcount = bfd_get_symcount (abfd);
3901   asymbol **syms = bfd_get_outsymbols (abfd);
3902   asymbol **sect_syms;
3903   unsigned int num_locals = 0;
3904   unsigned int num_globals = 0;
3905   unsigned int num_locals2 = 0;
3906   unsigned int num_globals2 = 0;
3907   unsigned int max_index = 0;
3908   unsigned int idx;
3909   asection *asect;
3910   asymbol **new_syms;
3911 
3912 #ifdef DEBUG
3913   fprintf (stderr, "elf_map_symbols\n");
3914   fflush (stderr);
3915 #endif
3916 
3917   for (asect = abfd->sections; asect; asect = asect->next)
3918     {
3919       if (max_index < asect->index)
3920 	max_index = asect->index;
3921     }
3922 
3923   max_index++;
3924   sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3925   if (sect_syms == NULL)
3926     return FALSE;
3927   elf_section_syms (abfd) = sect_syms;
3928   elf_num_section_syms (abfd) = max_index;
3929 
3930   /* Init sect_syms entries for any section symbols we have already
3931      decided to output.  */
3932   for (idx = 0; idx < symcount; idx++)
3933     {
3934       asymbol *sym = syms[idx];
3935 
3936       if ((sym->flags & BSF_SECTION_SYM) != 0
3937 	  && sym->value == 0
3938 	  && !ignore_section_sym (abfd, sym)
3939 	  && !bfd_is_abs_section (sym->section))
3940 	{
3941 	  asection *sec = sym->section;
3942 
3943 	  if (sec->owner != abfd)
3944 	    sec = sec->output_section;
3945 
3946 	  sect_syms[sec->index] = syms[idx];
3947 	}
3948     }
3949 
3950   /* Classify all of the symbols.  */
3951   for (idx = 0; idx < symcount; idx++)
3952     {
3953       if (sym_is_global (abfd, syms[idx]))
3954 	num_globals++;
3955       else if (!ignore_section_sym (abfd, syms[idx]))
3956 	num_locals++;
3957     }
3958 
3959   /* We will be adding a section symbol for each normal BFD section.  Most
3960      sections will already have a section symbol in outsymbols, but
3961      eg. SHT_GROUP sections will not, and we need the section symbol mapped
3962      at least in that case.  */
3963   for (asect = abfd->sections; asect; asect = asect->next)
3964     {
3965       if (sect_syms[asect->index] == NULL)
3966 	{
3967 	  if (!sym_is_global (abfd, asect->symbol))
3968 	    num_locals++;
3969 	  else
3970 	    num_globals++;
3971 	}
3972     }
3973 
3974   /* Now sort the symbols so the local symbols are first.  */
3975   new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3976                                       sizeof (asymbol *));
3977 
3978   if (new_syms == NULL)
3979     return FALSE;
3980 
3981   for (idx = 0; idx < symcount; idx++)
3982     {
3983       asymbol *sym = syms[idx];
3984       unsigned int i;
3985 
3986       if (sym_is_global (abfd, sym))
3987 	i = num_locals + num_globals2++;
3988       else if (!ignore_section_sym (abfd, sym))
3989 	i = num_locals2++;
3990       else
3991 	continue;
3992       new_syms[i] = sym;
3993       sym->udata.i = i + 1;
3994     }
3995   for (asect = abfd->sections; asect; asect = asect->next)
3996     {
3997       if (sect_syms[asect->index] == NULL)
3998 	{
3999 	  asymbol *sym = asect->symbol;
4000 	  unsigned int i;
4001 
4002 	  sect_syms[asect->index] = sym;
4003 	  if (!sym_is_global (abfd, sym))
4004 	    i = num_locals2++;
4005 	  else
4006 	    i = num_locals + num_globals2++;
4007 	  new_syms[i] = sym;
4008 	  sym->udata.i = i + 1;
4009 	}
4010     }
4011 
4012   bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
4013 
4014   *pnum_locals = num_locals;
4015   return TRUE;
4016 }
4017 
4018 /* Align to the maximum file alignment that could be required for any
4019    ELF data structure.  */
4020 
4021 static inline file_ptr
align_file_position(file_ptr off,int align)4022 align_file_position (file_ptr off, int align)
4023 {
4024   return (off + align - 1) & ~(align - 1);
4025 }
4026 
4027 /* Assign a file position to a section, optionally aligning to the
4028    required section alignment.  */
4029 
4030 file_ptr
_bfd_elf_assign_file_position_for_section(Elf_Internal_Shdr * i_shdrp,file_ptr offset,bfd_boolean align)4031 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
4032 					   file_ptr offset,
4033 					   bfd_boolean align)
4034 {
4035   if (align && i_shdrp->sh_addralign > 1)
4036     offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
4037   i_shdrp->sh_offset = offset;
4038   if (i_shdrp->bfd_section != NULL)
4039     i_shdrp->bfd_section->filepos = offset;
4040   if (i_shdrp->sh_type != SHT_NOBITS)
4041     offset += i_shdrp->sh_size;
4042   return offset;
4043 }
4044 
4045 /* Compute the file positions we are going to put the sections at, and
4046    otherwise prepare to begin writing out the ELF file.  If LINK_INFO
4047    is not NULL, this is being called by the ELF backend linker.  */
4048 
4049 bfd_boolean
_bfd_elf_compute_section_file_positions(bfd * abfd,struct bfd_link_info * link_info)4050 _bfd_elf_compute_section_file_positions (bfd *abfd,
4051 					 struct bfd_link_info *link_info)
4052 {
4053   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4054   struct fake_section_arg fsargs;
4055   bfd_boolean failed;
4056   struct elf_strtab_hash *strtab = NULL;
4057   Elf_Internal_Shdr *shstrtab_hdr;
4058   bfd_boolean need_symtab;
4059 
4060   if (abfd->output_has_begun)
4061     return TRUE;
4062 
4063   /* Do any elf backend specific processing first.  */
4064   if (bed->elf_backend_begin_write_processing)
4065     (*bed->elf_backend_begin_write_processing) (abfd, link_info);
4066 
4067   if (! prep_headers (abfd))
4068     return FALSE;
4069 
4070   /* Post process the headers if necessary.  */
4071   (*bed->elf_backend_post_process_headers) (abfd, link_info);
4072 
4073   fsargs.failed = FALSE;
4074   fsargs.link_info = link_info;
4075   bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
4076   if (fsargs.failed)
4077     return FALSE;
4078 
4079   if (!assign_section_numbers (abfd, link_info))
4080     return FALSE;
4081 
4082   /* The backend linker builds symbol table information itself.  */
4083   need_symtab = (link_info == NULL
4084 		 && (bfd_get_symcount (abfd) > 0
4085 		     || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
4086 			 == HAS_RELOC)));
4087   if (need_symtab)
4088     {
4089       /* Non-zero if doing a relocatable link.  */
4090       int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
4091 
4092       if (! swap_out_syms (abfd, &strtab, relocatable_p))
4093 	return FALSE;
4094     }
4095 
4096   failed = FALSE;
4097   if (link_info == NULL)
4098     {
4099       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
4100       if (failed)
4101 	return FALSE;
4102     }
4103 
4104   shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
4105   /* sh_name was set in prep_headers.  */
4106   shstrtab_hdr->sh_type = SHT_STRTAB;
4107   shstrtab_hdr->sh_flags = bed->elf_strtab_flags;
4108   shstrtab_hdr->sh_addr = 0;
4109   /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load.  */
4110   shstrtab_hdr->sh_entsize = 0;
4111   shstrtab_hdr->sh_link = 0;
4112   shstrtab_hdr->sh_info = 0;
4113   /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load.  */
4114   shstrtab_hdr->sh_addralign = 1;
4115 
4116   if (!assign_file_positions_except_relocs (abfd, link_info))
4117     return FALSE;
4118 
4119   if (need_symtab)
4120     {
4121       file_ptr off;
4122       Elf_Internal_Shdr *hdr;
4123 
4124       off = elf_next_file_pos (abfd);
4125 
4126       hdr = & elf_symtab_hdr (abfd);
4127       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4128 
4129       if (elf_symtab_shndx_list (abfd) != NULL)
4130 	{
4131 	  hdr = & elf_symtab_shndx_list (abfd)->hdr;
4132 	  if (hdr->sh_size != 0)
4133 	    off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4134 	  /* FIXME: What about other symtab_shndx sections in the list ?  */
4135 	}
4136 
4137       hdr = &elf_tdata (abfd)->strtab_hdr;
4138       off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4139 
4140       elf_next_file_pos (abfd) = off;
4141 
4142       /* Now that we know where the .strtab section goes, write it
4143 	 out.  */
4144       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4145 	  || ! _bfd_elf_strtab_emit (abfd, strtab))
4146 	return FALSE;
4147       _bfd_elf_strtab_free (strtab);
4148     }
4149 
4150   abfd->output_has_begun = TRUE;
4151 
4152   return TRUE;
4153 }
4154 
4155 /* Make an initial estimate of the size of the program header.  If we
4156    get the number wrong here, we'll redo section placement.  */
4157 
4158 static bfd_size_type
get_program_header_size(bfd * abfd,struct bfd_link_info * info)4159 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
4160 {
4161   size_t segs;
4162   asection *s;
4163   const struct elf_backend_data *bed;
4164 
4165   /* Assume we will need exactly two PT_LOAD segments: one for text
4166      and one for data.  */
4167   segs = 2;
4168 
4169   s = bfd_get_section_by_name (abfd, ".interp");
4170   if (s != NULL && (s->flags & SEC_LOAD) != 0)
4171     {
4172       /* If we have a loadable interpreter section, we need a
4173 	 PT_INTERP segment.  In this case, assume we also need a
4174 	 PT_PHDR segment, although that may not be true for all
4175 	 targets.  */
4176       segs += 2;
4177     }
4178 
4179   if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4180     {
4181       /* We need a PT_DYNAMIC segment.  */
4182       ++segs;
4183     }
4184 
4185   if (info != NULL && info->relro)
4186     {
4187       /* We need a PT_GNU_RELRO segment.  */
4188       ++segs;
4189     }
4190 
4191   if (elf_eh_frame_hdr (abfd))
4192     {
4193       /* We need a PT_GNU_EH_FRAME segment.  */
4194       ++segs;
4195     }
4196 
4197   if (elf_stack_flags (abfd))
4198     {
4199       /* We need a PT_GNU_STACK segment.  */
4200       ++segs;
4201     }
4202 
4203   for (s = abfd->sections; s != NULL; s = s->next)
4204     {
4205       if ((s->flags & SEC_LOAD) != 0
4206 	  && CONST_STRNEQ (s->name, ".note"))
4207 	{
4208 	  /* We need a PT_NOTE segment.  */
4209 	  ++segs;
4210 	  /* Try to create just one PT_NOTE segment
4211 	     for all adjacent loadable .note* sections.
4212 	     gABI requires that within a PT_NOTE segment
4213 	     (and also inside of each SHT_NOTE section)
4214 	     each note is padded to a multiple of 4 size,
4215 	     so we check whether the sections are correctly
4216 	     aligned.  */
4217 	  if (s->alignment_power == 2)
4218 	    while (s->next != NULL
4219 		   && s->next->alignment_power == 2
4220 		   && (s->next->flags & SEC_LOAD) != 0
4221 		   && CONST_STRNEQ (s->next->name, ".note"))
4222 	      s = s->next;
4223 	}
4224     }
4225 
4226   for (s = abfd->sections; s != NULL; s = s->next)
4227     {
4228       if (s->flags & SEC_THREAD_LOCAL)
4229 	{
4230 	  /* We need a PT_TLS segment.  */
4231 	  ++segs;
4232 	  break;
4233 	}
4234     }
4235 
4236   /* Let the backend count up any program headers it might need.  */
4237   bed = get_elf_backend_data (abfd);
4238   if (bed->elf_backend_additional_program_headers)
4239     {
4240       int a;
4241 
4242       a = (*bed->elf_backend_additional_program_headers) (abfd, info);
4243       if (a == -1)
4244 	abort ();
4245       segs += a;
4246     }
4247 
4248   return segs * bed->s->sizeof_phdr;
4249 }
4250 
4251 /* Find the segment that contains the output_section of section.  */
4252 
4253 Elf_Internal_Phdr *
_bfd_elf_find_segment_containing_section(bfd * abfd,asection * section)4254 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
4255 {
4256   struct elf_segment_map *m;
4257   Elf_Internal_Phdr *p;
4258 
4259   for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
4260        m != NULL;
4261        m = m->next, p++)
4262     {
4263       int i;
4264 
4265       for (i = m->count - 1; i >= 0; i--)
4266 	if (m->sections[i] == section)
4267 	  return p;
4268     }
4269 
4270   return NULL;
4271 }
4272 
4273 /* Create a mapping from a set of sections to a program segment.  */
4274 
4275 static struct elf_segment_map *
make_mapping(bfd * abfd,asection ** sections,unsigned int from,unsigned int to,bfd_boolean phdr)4276 make_mapping (bfd *abfd,
4277 	      asection **sections,
4278 	      unsigned int from,
4279 	      unsigned int to,
4280 	      bfd_boolean phdr)
4281 {
4282   struct elf_segment_map *m;
4283   unsigned int i;
4284   asection **hdrpp;
4285   bfd_size_type amt;
4286 
4287   amt = sizeof (struct elf_segment_map);
4288   amt += (to - from - 1) * sizeof (asection *);
4289   m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4290   if (m == NULL)
4291     return NULL;
4292   m->next = NULL;
4293   m->p_type = PT_LOAD;
4294   for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
4295     m->sections[i - from] = *hdrpp;
4296   m->count = to - from;
4297 
4298   if (from == 0 && phdr)
4299     {
4300       /* Include the headers in the first PT_LOAD segment.  */
4301       m->includes_filehdr = 1;
4302       m->includes_phdrs = 1;
4303     }
4304 
4305   return m;
4306 }
4307 
4308 /* Create the PT_DYNAMIC segment, which includes DYNSEC.  Returns NULL
4309    on failure.  */
4310 
4311 struct elf_segment_map *
_bfd_elf_make_dynamic_segment(bfd * abfd,asection * dynsec)4312 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
4313 {
4314   struct elf_segment_map *m;
4315 
4316   m = (struct elf_segment_map *) bfd_zalloc (abfd,
4317                                              sizeof (struct elf_segment_map));
4318   if (m == NULL)
4319     return NULL;
4320   m->next = NULL;
4321   m->p_type = PT_DYNAMIC;
4322   m->count = 1;
4323   m->sections[0] = dynsec;
4324 
4325   return m;
4326 }
4327 
4328 /* Possibly add or remove segments from the segment map.  */
4329 
4330 static bfd_boolean
elf_modify_segment_map(bfd * abfd,struct bfd_link_info * info,bfd_boolean remove_empty_load)4331 elf_modify_segment_map (bfd *abfd,
4332 			struct bfd_link_info *info,
4333 			bfd_boolean remove_empty_load)
4334 {
4335   struct elf_segment_map **m;
4336   const struct elf_backend_data *bed;
4337 
4338   /* The placement algorithm assumes that non allocated sections are
4339      not in PT_LOAD segments.  We ensure this here by removing such
4340      sections from the segment map.  We also remove excluded
4341      sections.  Finally, any PT_LOAD segment without sections is
4342      removed.  */
4343   m = &elf_seg_map (abfd);
4344   while (*m)
4345     {
4346       unsigned int i, new_count;
4347 
4348       for (new_count = 0, i = 0; i < (*m)->count; i++)
4349 	{
4350 	  if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
4351 	      && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
4352 		  || (*m)->p_type != PT_LOAD))
4353 	    {
4354 	      (*m)->sections[new_count] = (*m)->sections[i];
4355 	      new_count++;
4356 	    }
4357 	}
4358       (*m)->count = new_count;
4359 
4360       if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
4361 	*m = (*m)->next;
4362       else
4363 	m = &(*m)->next;
4364     }
4365 
4366   bed = get_elf_backend_data (abfd);
4367   if (bed->elf_backend_modify_segment_map != NULL)
4368     {
4369       if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
4370 	return FALSE;
4371     }
4372 
4373   return TRUE;
4374 }
4375 
4376 /* Set up a mapping from BFD sections to program segments.  */
4377 
4378 bfd_boolean
_bfd_elf_map_sections_to_segments(bfd * abfd,struct bfd_link_info * info)4379 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
4380 {
4381   unsigned int count;
4382   struct elf_segment_map *m;
4383   asection **sections = NULL;
4384   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4385   bfd_boolean no_user_phdrs;
4386 
4387   no_user_phdrs = elf_seg_map (abfd) == NULL;
4388 
4389   if (info != NULL)
4390     info->user_phdrs = !no_user_phdrs;
4391 
4392   if (no_user_phdrs && bfd_count_sections (abfd) != 0)
4393     {
4394       asection *s;
4395       unsigned int i;
4396       struct elf_segment_map *mfirst;
4397       struct elf_segment_map **pm;
4398       asection *last_hdr;
4399       bfd_vma last_size;
4400       unsigned int phdr_index;
4401       bfd_vma maxpagesize;
4402       asection **hdrpp;
4403       bfd_boolean phdr_in_segment = TRUE;
4404       bfd_boolean writable;
4405       int tls_count = 0;
4406       asection *first_tls = NULL;
4407       asection *dynsec, *eh_frame_hdr;
4408       bfd_size_type amt;
4409       bfd_vma addr_mask, wrap_to = 0;
4410 
4411       /* Select the allocated sections, and sort them.  */
4412 
4413       sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
4414                                             sizeof (asection *));
4415       if (sections == NULL)
4416 	goto error_return;
4417 
4418       /* Calculate top address, avoiding undefined behaviour of shift
4419 	 left operator when shift count is equal to size of type
4420 	 being shifted.  */
4421       addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
4422       addr_mask = (addr_mask << 1) + 1;
4423 
4424       i = 0;
4425       for (s = abfd->sections; s != NULL; s = s->next)
4426 	{
4427 	  if ((s->flags & SEC_ALLOC) != 0)
4428 	    {
4429 	      sections[i] = s;
4430 	      ++i;
4431 	      /* A wrapping section potentially clashes with header.  */
4432 	      if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
4433 		wrap_to = (s->lma + s->size) & addr_mask;
4434 	    }
4435 	}
4436       BFD_ASSERT (i <= bfd_count_sections (abfd));
4437       count = i;
4438 
4439       qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
4440 
4441       /* Build the mapping.  */
4442 
4443       mfirst = NULL;
4444       pm = &mfirst;
4445 
4446       /* If we have a .interp section, then create a PT_PHDR segment for
4447 	 the program headers and a PT_INTERP segment for the .interp
4448 	 section.  */
4449       s = bfd_get_section_by_name (abfd, ".interp");
4450       if (s != NULL && (s->flags & SEC_LOAD) != 0)
4451 	{
4452 	  amt = sizeof (struct elf_segment_map);
4453 	  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4454 	  if (m == NULL)
4455 	    goto error_return;
4456 	  m->next = NULL;
4457 	  m->p_type = PT_PHDR;
4458 	  /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not.  */
4459 	  m->p_flags = PF_R | PF_X;
4460 	  m->p_flags_valid = 1;
4461 	  m->includes_phdrs = 1;
4462 
4463 	  *pm = m;
4464 	  pm = &m->next;
4465 
4466 	  amt = sizeof (struct elf_segment_map);
4467 	  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4468 	  if (m == NULL)
4469 	    goto error_return;
4470 	  m->next = NULL;
4471 	  m->p_type = PT_INTERP;
4472 	  m->count = 1;
4473 	  m->sections[0] = s;
4474 
4475 	  *pm = m;
4476 	  pm = &m->next;
4477 	}
4478 
4479       /* Look through the sections.  We put sections in the same program
4480 	 segment when the start of the second section can be placed within
4481 	 a few bytes of the end of the first section.  */
4482       last_hdr = NULL;
4483       last_size = 0;
4484       phdr_index = 0;
4485       maxpagesize = bed->maxpagesize;
4486       /* PR 17512: file: c8455299.
4487 	 Avoid divide-by-zero errors later on.
4488 	 FIXME: Should we abort if the maxpagesize is zero ?  */
4489       if (maxpagesize == 0)
4490 	maxpagesize = 1;
4491       writable = FALSE;
4492       dynsec = bfd_get_section_by_name (abfd, ".dynamic");
4493       if (dynsec != NULL
4494 	  && (dynsec->flags & SEC_LOAD) == 0)
4495 	dynsec = NULL;
4496 
4497       /* Deal with -Ttext or something similar such that the first section
4498 	 is not adjacent to the program headers.  This is an
4499 	 approximation, since at this point we don't know exactly how many
4500 	 program headers we will need.  */
4501       if (count > 0)
4502 	{
4503 	  bfd_size_type phdr_size = elf_program_header_size (abfd);
4504 
4505 	  if (phdr_size == (bfd_size_type) -1)
4506 	    phdr_size = get_program_header_size (abfd, info);
4507 	  phdr_size += bed->s->sizeof_ehdr;
4508 	  if ((abfd->flags & D_PAGED) == 0
4509 	      || (sections[0]->lma & addr_mask) < phdr_size
4510 	      || ((sections[0]->lma & addr_mask) % maxpagesize
4511 		  < phdr_size % maxpagesize)
4512 	      || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
4513 	    phdr_in_segment = FALSE;
4514 	}
4515 
4516       for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
4517 	{
4518 	  asection *hdr;
4519 	  bfd_boolean new_segment;
4520 
4521 	  hdr = *hdrpp;
4522 
4523 	  /* See if this section and the last one will fit in the same
4524 	     segment.  */
4525 
4526 	  if (last_hdr == NULL)
4527 	    {
4528 	      /* If we don't have a segment yet, then we don't need a new
4529 		 one (we build the last one after this loop).  */
4530 	      new_segment = FALSE;
4531 	    }
4532 	  else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
4533 	    {
4534 	      /* If this section has a different relation between the
4535 		 virtual address and the load address, then we need a new
4536 		 segment.  */
4537 	      new_segment = TRUE;
4538 	    }
4539 	  else if (hdr->lma < last_hdr->lma + last_size
4540 		   || last_hdr->lma + last_size < last_hdr->lma)
4541 	    {
4542 	      /* If this section has a load address that makes it overlap
4543 		 the previous section, then we need a new segment.  */
4544 	      new_segment = TRUE;
4545 	    }
4546 	  /* In the next test we have to be careful when last_hdr->lma is close
4547 	     to the end of the address space.  If the aligned address wraps
4548 	     around to the start of the address space, then there are no more
4549 	     pages left in memory and it is OK to assume that the current
4550 	     section can be included in the current segment.  */
4551 	  else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
4552 		    > last_hdr->lma)
4553 		   && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
4554 		       <= hdr->lma))
4555 	    {
4556 	      /* If putting this section in this segment would force us to
4557 		 skip a page in the segment, then we need a new segment.  */
4558 	      new_segment = TRUE;
4559 	    }
4560 	  else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
4561 		   && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0
4562 		   && ((abfd->flags & D_PAGED) == 0
4563 		       || (((last_hdr->lma + last_size - 1) & -maxpagesize)
4564 			   != (hdr->lma & -maxpagesize))))
4565 	    {
4566 	      /* We don't want to put a loaded section after a
4567 		 nonloaded (ie. bss style) section in the same segment
4568 		 as that will force the non-loaded section to be loaded.
4569 		 Consider .tbss sections as loaded for this purpose.
4570 		 However, like the writable/non-writable case below,
4571 		 if they are on the same page then they must be put
4572 		 in the same segment.  */
4573 	      new_segment = TRUE;
4574 	    }
4575 	  else if ((abfd->flags & D_PAGED) == 0)
4576 	    {
4577 	      /* If the file is not demand paged, which means that we
4578 		 don't require the sections to be correctly aligned in the
4579 		 file, then there is no other reason for a new segment.  */
4580 	      new_segment = FALSE;
4581 	    }
4582 	  else if (! writable
4583 		   && (hdr->flags & SEC_READONLY) == 0
4584 		   && (((last_hdr->lma + last_size - 1) & -maxpagesize)
4585 		       != (hdr->lma & -maxpagesize)))
4586 	    {
4587 	      /* We don't want to put a writable section in a read only
4588 		 segment, unless they are on the same page in memory
4589 		 anyhow.  We already know that the last section does not
4590 		 bring us past the current section on the page, so the
4591 		 only case in which the new section is not on the same
4592 		 page as the previous section is when the previous section
4593 		 ends precisely on a page boundary.  */
4594 	      new_segment = TRUE;
4595 	    }
4596 	  else
4597 	    {
4598 	      /* Otherwise, we can use the same segment.  */
4599 	      new_segment = FALSE;
4600 	    }
4601 
4602 	  /* Allow interested parties a chance to override our decision.  */
4603 	  if (last_hdr != NULL
4604 	      && info != NULL
4605 	      && info->callbacks->override_segment_assignment != NULL)
4606 	    new_segment
4607 	      = info->callbacks->override_segment_assignment (info, abfd, hdr,
4608 							      last_hdr,
4609 							      new_segment);
4610 
4611 	  if (! new_segment)
4612 	    {
4613 	      if ((hdr->flags & SEC_READONLY) == 0)
4614 		writable = TRUE;
4615 	      last_hdr = hdr;
4616 	      /* .tbss sections effectively have zero size.  */
4617 	      if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4618 		  != SEC_THREAD_LOCAL)
4619 		last_size = hdr->size;
4620 	      else
4621 		last_size = 0;
4622 	      continue;
4623 	    }
4624 
4625 	  /* We need a new program segment.  We must create a new program
4626 	     header holding all the sections from phdr_index until hdr.  */
4627 
4628 	  m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4629 	  if (m == NULL)
4630 	    goto error_return;
4631 
4632 	  *pm = m;
4633 	  pm = &m->next;
4634 
4635 	  if ((hdr->flags & SEC_READONLY) == 0)
4636 	    writable = TRUE;
4637 	  else
4638 	    writable = FALSE;
4639 
4640 	  last_hdr = hdr;
4641 	  /* .tbss sections effectively have zero size.  */
4642 	  if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
4643 	    last_size = hdr->size;
4644 	  else
4645 	    last_size = 0;
4646 	  phdr_index = i;
4647 	  phdr_in_segment = FALSE;
4648 	}
4649 
4650       /* Create a final PT_LOAD program segment, but not if it's just
4651 	 for .tbss.  */
4652       if (last_hdr != NULL
4653 	  && (i - phdr_index != 1
4654 	      || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4655 		  != SEC_THREAD_LOCAL)))
4656 	{
4657 	  m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4658 	  if (m == NULL)
4659 	    goto error_return;
4660 
4661 	  *pm = m;
4662 	  pm = &m->next;
4663 	}
4664 
4665       /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
4666       if (dynsec != NULL)
4667 	{
4668 	  m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4669 	  if (m == NULL)
4670 	    goto error_return;
4671 	  *pm = m;
4672 	  pm = &m->next;
4673 	}
4674 
4675       /* For each batch of consecutive loadable .note sections,
4676 	 add a PT_NOTE segment.  We don't use bfd_get_section_by_name,
4677 	 because if we link together nonloadable .note sections and
4678 	 loadable .note sections, we will generate two .note sections
4679 	 in the output file.  FIXME: Using names for section types is
4680 	 bogus anyhow.  */
4681       for (s = abfd->sections; s != NULL; s = s->next)
4682 	{
4683 	  if ((s->flags & SEC_LOAD) != 0
4684 	      && CONST_STRNEQ (s->name, ".note"))
4685 	    {
4686 	      asection *s2;
4687 
4688 	      count = 1;
4689 	      amt = sizeof (struct elf_segment_map);
4690 	      if (s->alignment_power == 2)
4691 		for (s2 = s; s2->next != NULL; s2 = s2->next)
4692 		  {
4693 		    if (s2->next->alignment_power == 2
4694 			&& (s2->next->flags & SEC_LOAD) != 0
4695 			&& CONST_STRNEQ (s2->next->name, ".note")
4696 			&& align_power (s2->lma + s2->size, 2)
4697 			   == s2->next->lma)
4698 		      count++;
4699 		    else
4700 		      break;
4701 		  }
4702 	      amt += (count - 1) * sizeof (asection *);
4703 	      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4704 	      if (m == NULL)
4705 		goto error_return;
4706 	      m->next = NULL;
4707 	      m->p_type = PT_NOTE;
4708 	      m->count = count;
4709 	      while (count > 1)
4710 		{
4711 		  m->sections[m->count - count--] = s;
4712 		  BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4713 		  s = s->next;
4714 		}
4715 	      m->sections[m->count - 1] = s;
4716 	      BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4717 	      *pm = m;
4718 	      pm = &m->next;
4719 	    }
4720 	  if (s->flags & SEC_THREAD_LOCAL)
4721 	    {
4722 	      if (! tls_count)
4723 		first_tls = s;
4724 	      tls_count++;
4725 	    }
4726 	}
4727 
4728       /* If there are any SHF_TLS output sections, add PT_TLS segment.  */
4729       if (tls_count > 0)
4730 	{
4731 	  amt = sizeof (struct elf_segment_map);
4732 	  amt += (tls_count - 1) * sizeof (asection *);
4733 	  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4734 	  if (m == NULL)
4735 	    goto error_return;
4736 	  m->next = NULL;
4737 	  m->p_type = PT_TLS;
4738 	  m->count = tls_count;
4739 	  /* Mandated PF_R.  */
4740 	  m->p_flags = PF_R;
4741 	  m->p_flags_valid = 1;
4742 	  s = first_tls;
4743 	  for (i = 0; i < (unsigned int) tls_count; ++i)
4744 	    {
4745 	      if ((s->flags & SEC_THREAD_LOCAL) == 0)
4746 		{
4747 		  _bfd_error_handler
4748 		    (_("%B: TLS sections are not adjacent:"), abfd);
4749 		  s = first_tls;
4750 		  i = 0;
4751 		  while (i < (unsigned int) tls_count)
4752 		    {
4753 		      if ((s->flags & SEC_THREAD_LOCAL) != 0)
4754 			{
4755 			  _bfd_error_handler (_("	    TLS: %A"), s);
4756 			  i++;
4757 			}
4758 		      else
4759 			_bfd_error_handler (_("	non-TLS: %A"), s);
4760 		      s = s->next;
4761 		    }
4762 		  bfd_set_error (bfd_error_bad_value);
4763 		  goto error_return;
4764 		}
4765 	      m->sections[i] = s;
4766 	      s = s->next;
4767 	    }
4768 
4769 	  *pm = m;
4770 	  pm = &m->next;
4771 	}
4772 
4773       /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4774 	 segment.  */
4775       eh_frame_hdr = elf_eh_frame_hdr (abfd);
4776       if (eh_frame_hdr != NULL
4777 	  && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4778 	{
4779 	  amt = sizeof (struct elf_segment_map);
4780 	  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4781 	  if (m == NULL)
4782 	    goto error_return;
4783 	  m->next = NULL;
4784 	  m->p_type = PT_GNU_EH_FRAME;
4785 	  m->count = 1;
4786 	  m->sections[0] = eh_frame_hdr->output_section;
4787 
4788 	  *pm = m;
4789 	  pm = &m->next;
4790 	}
4791 
4792       if (elf_stack_flags (abfd))
4793 	{
4794 	  amt = sizeof (struct elf_segment_map);
4795 	  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4796 	  if (m == NULL)
4797 	    goto error_return;
4798 	  m->next = NULL;
4799 	  m->p_type = PT_GNU_STACK;
4800 	  m->p_flags = elf_stack_flags (abfd);
4801 	  m->p_align = bed->stack_align;
4802 	  m->p_flags_valid = 1;
4803 	  m->p_align_valid = m->p_align != 0;
4804 	  if (info->stacksize > 0)
4805 	    {
4806 	      m->p_size = info->stacksize;
4807 	      m->p_size_valid = 1;
4808 	    }
4809 
4810 	  *pm = m;
4811 	  pm = &m->next;
4812 	}
4813 
4814       if (info != NULL && info->relro)
4815 	{
4816 	  for (m = mfirst; m != NULL; m = m->next)
4817 	    {
4818 	      if (m->p_type == PT_LOAD
4819 		  && m->count != 0
4820 		  && m->sections[0]->vma >= info->relro_start
4821 		  && m->sections[0]->vma < info->relro_end)
4822 		{
4823 		  i = m->count;
4824 		  while (--i != (unsigned) -1)
4825 		    if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
4826 			== (SEC_LOAD | SEC_HAS_CONTENTS))
4827 		      break;
4828 
4829 		  if (i != (unsigned) -1)
4830 		    break;
4831 		}
4832 	    }
4833 
4834 	  /* Make a PT_GNU_RELRO segment only when it isn't empty.  */
4835 	  if (m != NULL)
4836 	    {
4837 	      amt = sizeof (struct elf_segment_map);
4838 	      m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4839 	      if (m == NULL)
4840 		goto error_return;
4841 	      m->next = NULL;
4842 	      m->p_type = PT_GNU_RELRO;
4843 	      *pm = m;
4844 	      pm = &m->next;
4845 	    }
4846 	}
4847 
4848       free (sections);
4849       elf_seg_map (abfd) = mfirst;
4850     }
4851 
4852   if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4853     return FALSE;
4854 
4855   for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
4856     ++count;
4857   elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
4858 
4859   return TRUE;
4860 
4861  error_return:
4862   if (sections != NULL)
4863     free (sections);
4864   return FALSE;
4865 }
4866 
4867 /* Sort sections by address.  */
4868 
4869 static int
elf_sort_sections(const void * arg1,const void * arg2)4870 elf_sort_sections (const void *arg1, const void *arg2)
4871 {
4872   const asection *sec1 = *(const asection **) arg1;
4873   const asection *sec2 = *(const asection **) arg2;
4874   bfd_size_type size1, size2;
4875 
4876   /* Sort by LMA first, since this is the address used to
4877      place the section into a segment.  */
4878   if (sec1->lma < sec2->lma)
4879     return -1;
4880   else if (sec1->lma > sec2->lma)
4881     return 1;
4882 
4883   /* Then sort by VMA.  Normally the LMA and the VMA will be
4884      the same, and this will do nothing.  */
4885   if (sec1->vma < sec2->vma)
4886     return -1;
4887   else if (sec1->vma > sec2->vma)
4888     return 1;
4889 
4890   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
4891 
4892 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4893 
4894   if (TOEND (sec1))
4895     {
4896       if (TOEND (sec2))
4897 	{
4898 	  /* If the indicies are the same, do not return 0
4899 	     here, but continue to try the next comparison.  */
4900 	  if (sec1->target_index - sec2->target_index != 0)
4901 	    return sec1->target_index - sec2->target_index;
4902 	}
4903       else
4904 	return 1;
4905     }
4906   else if (TOEND (sec2))
4907     return -1;
4908 
4909 #undef TOEND
4910 
4911   /* Sort by size, to put zero sized sections
4912      before others at the same address.  */
4913 
4914   size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4915   size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4916 
4917   if (size1 < size2)
4918     return -1;
4919   if (size1 > size2)
4920     return 1;
4921 
4922   return sec1->target_index - sec2->target_index;
4923 }
4924 
4925 /* Ian Lance Taylor writes:
4926 
4927    We shouldn't be using % with a negative signed number.  That's just
4928    not good.  We have to make sure either that the number is not
4929    negative, or that the number has an unsigned type.  When the types
4930    are all the same size they wind up as unsigned.  When file_ptr is a
4931    larger signed type, the arithmetic winds up as signed long long,
4932    which is wrong.
4933 
4934    What we're trying to say here is something like ``increase OFF by
4935    the least amount that will cause it to be equal to the VMA modulo
4936    the page size.''  */
4937 /* In other words, something like:
4938 
4939    vma_offset = m->sections[0]->vma % bed->maxpagesize;
4940    off_offset = off % bed->maxpagesize;
4941    if (vma_offset < off_offset)
4942      adjustment = vma_offset + bed->maxpagesize - off_offset;
4943    else
4944      adjustment = vma_offset - off_offset;
4945 
4946    which can can be collapsed into the expression below.  */
4947 
4948 static file_ptr
vma_page_aligned_bias(bfd_vma vma,ufile_ptr off,bfd_vma maxpagesize)4949 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4950 {
4951   /* PR binutils/16199: Handle an alignment of zero.  */
4952   if (maxpagesize == 0)
4953     maxpagesize = 1;
4954   return ((vma - off) % maxpagesize);
4955 }
4956 
4957 static void
print_segment_map(const struct elf_segment_map * m)4958 print_segment_map (const struct elf_segment_map *m)
4959 {
4960   unsigned int j;
4961   const char *pt = get_segment_type (m->p_type);
4962   char buf[32];
4963 
4964   if (pt == NULL)
4965     {
4966       if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4967 	sprintf (buf, "LOPROC+%7.7x",
4968 		 (unsigned int) (m->p_type - PT_LOPROC));
4969       else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4970 	sprintf (buf, "LOOS+%7.7x",
4971 		 (unsigned int) (m->p_type - PT_LOOS));
4972       else
4973 	snprintf (buf, sizeof (buf), "%8.8x",
4974 		  (unsigned int) m->p_type);
4975       pt = buf;
4976     }
4977   fflush (stdout);
4978   fprintf (stderr, "%s:", pt);
4979   for (j = 0; j < m->count; j++)
4980     fprintf (stderr, " %s", m->sections [j]->name);
4981   putc ('\n',stderr);
4982   fflush (stderr);
4983 }
4984 
4985 static bfd_boolean
write_zeros(bfd * abfd,file_ptr pos,bfd_size_type len)4986 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4987 {
4988   void *buf;
4989   bfd_boolean ret;
4990 
4991   if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4992     return FALSE;
4993   buf = bfd_zmalloc (len);
4994   if (buf == NULL)
4995     return FALSE;
4996   ret = bfd_bwrite (buf, len, abfd) == len;
4997   free (buf);
4998   return ret;
4999 }
5000 
5001 /* Assign file positions to the sections based on the mapping from
5002    sections to segments.  This function also sets up some fields in
5003    the file header.  */
5004 
5005 static bfd_boolean
assign_file_positions_for_load_sections(bfd * abfd,struct bfd_link_info * link_info)5006 assign_file_positions_for_load_sections (bfd *abfd,
5007 					 struct bfd_link_info *link_info)
5008 {
5009   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5010   struct elf_segment_map *m;
5011   Elf_Internal_Phdr *phdrs;
5012   Elf_Internal_Phdr *p;
5013   file_ptr off;
5014   bfd_size_type maxpagesize;
5015   unsigned int alloc;
5016   unsigned int i, j;
5017   bfd_vma header_pad = 0;
5018 
5019   if (link_info == NULL
5020       && !_bfd_elf_map_sections_to_segments (abfd, link_info))
5021     return FALSE;
5022 
5023   alloc = 0;
5024   for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5025     {
5026       ++alloc;
5027       if (m->header_size)
5028 	header_pad = m->header_size;
5029     }
5030 
5031   if (alloc)
5032     {
5033       elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
5034       elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
5035     }
5036   else
5037     {
5038       /* PR binutils/12467.  */
5039       elf_elfheader (abfd)->e_phoff = 0;
5040       elf_elfheader (abfd)->e_phentsize = 0;
5041     }
5042 
5043   elf_elfheader (abfd)->e_phnum = alloc;
5044 
5045   if (elf_program_header_size (abfd) == (bfd_size_type) -1)
5046     elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
5047   else
5048     BFD_ASSERT (elf_program_header_size (abfd)
5049 		>= alloc * bed->s->sizeof_phdr);
5050 
5051   if (alloc == 0)
5052     {
5053       elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
5054       return TRUE;
5055     }
5056 
5057   /* We're writing the size in elf_program_header_size (abfd),
5058      see assign_file_positions_except_relocs, so make sure we have
5059      that amount allocated, with trailing space cleared.
5060      The variable alloc contains the computed need, while
5061      elf_program_header_size (abfd) contains the size used for the
5062      layout.
5063      See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5064      where the layout is forced to according to a larger size in the
5065      last iterations for the testcase ld-elf/header.  */
5066   BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
5067 	      == 0);
5068   phdrs = (Elf_Internal_Phdr *)
5069      bfd_zalloc2 (abfd,
5070                   (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
5071                   sizeof (Elf_Internal_Phdr));
5072   elf_tdata (abfd)->phdr = phdrs;
5073   if (phdrs == NULL)
5074     return FALSE;
5075 
5076   maxpagesize = 1;
5077   if ((abfd->flags & D_PAGED) != 0)
5078     maxpagesize = bed->maxpagesize;
5079 
5080   off = bed->s->sizeof_ehdr;
5081   off += alloc * bed->s->sizeof_phdr;
5082   if (header_pad < (bfd_vma) off)
5083     header_pad = 0;
5084   else
5085     header_pad -= off;
5086   off += header_pad;
5087 
5088   for (m = elf_seg_map (abfd), p = phdrs, j = 0;
5089        m != NULL;
5090        m = m->next, p++, j++)
5091     {
5092       asection **secpp;
5093       bfd_vma off_adjust;
5094       bfd_boolean no_contents;
5095 
5096       /* If elf_segment_map is not from map_sections_to_segments, the
5097 	 sections may not be correctly ordered.  NOTE: sorting should
5098 	 not be done to the PT_NOTE section of a corefile, which may
5099 	 contain several pseudo-sections artificially created by bfd.
5100 	 Sorting these pseudo-sections breaks things badly.  */
5101       if (m->count > 1
5102 	  && !(elf_elfheader (abfd)->e_type == ET_CORE
5103 	       && m->p_type == PT_NOTE))
5104 	qsort (m->sections, (size_t) m->count, sizeof (asection *),
5105 	       elf_sort_sections);
5106 
5107       /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5108 	 number of sections with contents contributing to both p_filesz
5109 	 and p_memsz, followed by a number of sections with no contents
5110 	 that just contribute to p_memsz.  In this loop, OFF tracks next
5111 	 available file offset for PT_LOAD and PT_NOTE segments.  */
5112       p->p_type = m->p_type;
5113       p->p_flags = m->p_flags;
5114 
5115       if (m->count == 0)
5116 	p->p_vaddr = 0;
5117       else
5118 	p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
5119 
5120       if (m->p_paddr_valid)
5121 	p->p_paddr = m->p_paddr;
5122       else if (m->count == 0)
5123 	p->p_paddr = 0;
5124       else
5125 	p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
5126 
5127       if (p->p_type == PT_LOAD
5128 	  && (abfd->flags & D_PAGED) != 0)
5129 	{
5130 	  /* p_align in demand paged PT_LOAD segments effectively stores
5131 	     the maximum page size.  When copying an executable with
5132 	     objcopy, we set m->p_align from the input file.  Use this
5133 	     value for maxpagesize rather than bed->maxpagesize, which
5134 	     may be different.  Note that we use maxpagesize for PT_TLS
5135 	     segment alignment later in this function, so we are relying
5136 	     on at least one PT_LOAD segment appearing before a PT_TLS
5137 	     segment.  */
5138 	  if (m->p_align_valid)
5139 	    maxpagesize = m->p_align;
5140 
5141 	  p->p_align = maxpagesize;
5142 	}
5143       else if (m->p_align_valid)
5144 	p->p_align = m->p_align;
5145       else if (m->count == 0)
5146 	p->p_align = 1 << bed->s->log_file_align;
5147       else
5148 	p->p_align = 0;
5149 
5150       no_contents = FALSE;
5151       off_adjust = 0;
5152       if (p->p_type == PT_LOAD
5153 	  && m->count > 0)
5154 	{
5155 	  bfd_size_type align;
5156 	  unsigned int align_power = 0;
5157 
5158 	  if (m->p_align_valid)
5159 	    align = p->p_align;
5160 	  else
5161 	    {
5162 	      for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5163 		{
5164 		  unsigned int secalign;
5165 
5166 		  secalign = bfd_get_section_alignment (abfd, *secpp);
5167 		  if (secalign > align_power)
5168 		    align_power = secalign;
5169 		}
5170 	      align = (bfd_size_type) 1 << align_power;
5171 	      if (align < maxpagesize)
5172 		align = maxpagesize;
5173 	    }
5174 
5175 	  for (i = 0; i < m->count; i++)
5176 	    if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
5177 	      /* If we aren't making room for this section, then
5178 		 it must be SHT_NOBITS regardless of what we've
5179 		 set via struct bfd_elf_special_section.  */
5180 	      elf_section_type (m->sections[i]) = SHT_NOBITS;
5181 
5182 	  /* Find out whether this segment contains any loadable
5183 	     sections.  */
5184 	  no_contents = TRUE;
5185 	  for (i = 0; i < m->count; i++)
5186 	    if (elf_section_type (m->sections[i]) != SHT_NOBITS)
5187 	      {
5188 		no_contents = FALSE;
5189 		break;
5190 	      }
5191 
5192 	  off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
5193 	  off += off_adjust;
5194 	  if (no_contents)
5195 	    {
5196 	      /* We shouldn't need to align the segment on disk since
5197 		 the segment doesn't need file space, but the gABI
5198 		 arguably requires the alignment and glibc ld.so
5199 		 checks it.  So to comply with the alignment
5200 		 requirement but not waste file space, we adjust
5201 		 p_offset for just this segment.  (OFF_ADJUST is
5202 		 subtracted from OFF later.)  This may put p_offset
5203 		 past the end of file, but that shouldn't matter.  */
5204 	    }
5205 	  else
5206 	    off_adjust = 0;
5207 	}
5208       /* Make sure the .dynamic section is the first section in the
5209 	 PT_DYNAMIC segment.  */
5210       else if (p->p_type == PT_DYNAMIC
5211 	       && m->count > 1
5212 	       && strcmp (m->sections[0]->name, ".dynamic") != 0)
5213 	{
5214 	  _bfd_error_handler
5215 	    (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
5216 	     abfd);
5217 	  bfd_set_error (bfd_error_bad_value);
5218 	  return FALSE;
5219 	}
5220       /* Set the note section type to SHT_NOTE.  */
5221       else if (p->p_type == PT_NOTE)
5222 	for (i = 0; i < m->count; i++)
5223 	  elf_section_type (m->sections[i]) = SHT_NOTE;
5224 
5225       p->p_offset = 0;
5226       p->p_filesz = 0;
5227       p->p_memsz = 0;
5228 
5229       if (m->includes_filehdr)
5230 	{
5231 	  if (!m->p_flags_valid)
5232 	    p->p_flags |= PF_R;
5233 	  p->p_filesz = bed->s->sizeof_ehdr;
5234 	  p->p_memsz = bed->s->sizeof_ehdr;
5235 	  if (m->count > 0)
5236 	    {
5237 	      if (p->p_vaddr < (bfd_vma) off)
5238 		{
5239 		  (*_bfd_error_handler)
5240 		    (_("%B: Not enough room for program headers, try linking with -N"),
5241 		     abfd);
5242 		  bfd_set_error (bfd_error_bad_value);
5243 		  return FALSE;
5244 		}
5245 
5246 	      p->p_vaddr -= off;
5247 	      if (!m->p_paddr_valid)
5248 		p->p_paddr -= off;
5249 	    }
5250 	}
5251 
5252       if (m->includes_phdrs)
5253 	{
5254 	  if (!m->p_flags_valid)
5255 	    p->p_flags |= PF_R;
5256 
5257 	  if (!m->includes_filehdr)
5258 	    {
5259 	      p->p_offset = bed->s->sizeof_ehdr;
5260 
5261 	      if (m->count > 0)
5262 		{
5263 		  p->p_vaddr -= off - p->p_offset;
5264 		  if (!m->p_paddr_valid)
5265 		    p->p_paddr -= off - p->p_offset;
5266 		}
5267 	    }
5268 
5269 	  p->p_filesz += alloc * bed->s->sizeof_phdr;
5270 	  p->p_memsz += alloc * bed->s->sizeof_phdr;
5271 	  if (m->count)
5272 	    {
5273 	      p->p_filesz += header_pad;
5274 	      p->p_memsz += header_pad;
5275 	    }
5276 	}
5277 
5278       if (p->p_type == PT_LOAD
5279 	  || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
5280 	{
5281 	  if (!m->includes_filehdr && !m->includes_phdrs)
5282 	    p->p_offset = off;
5283 	  else
5284 	    {
5285 	      file_ptr adjust;
5286 
5287 	      adjust = off - (p->p_offset + p->p_filesz);
5288 	      if (!no_contents)
5289 		p->p_filesz += adjust;
5290 	      p->p_memsz += adjust;
5291 	    }
5292 	}
5293 
5294       /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5295 	 maps.  Set filepos for sections in PT_LOAD segments, and in
5296 	 core files, for sections in PT_NOTE segments.
5297 	 assign_file_positions_for_non_load_sections will set filepos
5298 	 for other sections and update p_filesz for other segments.  */
5299       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
5300 	{
5301 	  asection *sec;
5302 	  bfd_size_type align;
5303 	  Elf_Internal_Shdr *this_hdr;
5304 
5305 	  sec = *secpp;
5306 	  this_hdr = &elf_section_data (sec)->this_hdr;
5307 	  align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
5308 
5309 	  if ((p->p_type == PT_LOAD
5310 	       || p->p_type == PT_TLS)
5311 	      && (this_hdr->sh_type != SHT_NOBITS
5312 		  || ((this_hdr->sh_flags & SHF_ALLOC) != 0
5313 		      && ((this_hdr->sh_flags & SHF_TLS) == 0
5314 			  || p->p_type == PT_TLS))))
5315 	    {
5316 	      bfd_vma p_start = p->p_paddr;
5317 	      bfd_vma p_end = p_start + p->p_memsz;
5318 	      bfd_vma s_start = sec->lma;
5319 	      bfd_vma adjust = s_start - p_end;
5320 
5321 	      if (adjust != 0
5322 		  && (s_start < p_end
5323 		      || p_end < p_start))
5324 		{
5325 		  (*_bfd_error_handler)
5326 		    (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
5327 		     (unsigned long) s_start, (unsigned long) p_end);
5328 		  adjust = 0;
5329 		  sec->lma = p_end;
5330 		}
5331 	      p->p_memsz += adjust;
5332 
5333 	      if (this_hdr->sh_type != SHT_NOBITS)
5334 		{
5335 		  if (p->p_filesz + adjust < p->p_memsz)
5336 		    {
5337 		      /* We have a PROGBITS section following NOBITS ones.
5338 		         Allocate file space for the NOBITS section(s) and
5339 			 zero it.  */
5340 		      adjust = p->p_memsz - p->p_filesz;
5341 		      if (!write_zeros (abfd, off, adjust))
5342 			return FALSE;
5343 		    }
5344 		  off += adjust;
5345 		  p->p_filesz += adjust;
5346 		}
5347 	    }
5348 
5349 	  if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
5350 	    {
5351 	      /* The section at i == 0 is the one that actually contains
5352 		 everything.  */
5353 	      if (i == 0)
5354 		{
5355 		  this_hdr->sh_offset = sec->filepos = off;
5356 		  off += this_hdr->sh_size;
5357 		  p->p_filesz = this_hdr->sh_size;
5358 		  p->p_memsz = 0;
5359 		  p->p_align = 1;
5360 		}
5361 	      else
5362 		{
5363 		  /* The rest are fake sections that shouldn't be written.  */
5364 		  sec->filepos = 0;
5365 		  sec->size = 0;
5366 		  sec->flags = 0;
5367 		  continue;
5368 		}
5369 	    }
5370 	  else
5371 	    {
5372 	      if (p->p_type == PT_LOAD)
5373 		{
5374 		  this_hdr->sh_offset = sec->filepos = off;
5375 		  if (this_hdr->sh_type != SHT_NOBITS)
5376 		    off += this_hdr->sh_size;
5377 		}
5378 	      else if (this_hdr->sh_type == SHT_NOBITS
5379 		       && (this_hdr->sh_flags & SHF_TLS) != 0
5380 		       && this_hdr->sh_offset == 0)
5381 		{
5382 		  /* This is a .tbss section that didn't get a PT_LOAD.
5383 		     (See _bfd_elf_map_sections_to_segments "Create a
5384 		     final PT_LOAD".)  Set sh_offset to the value it
5385 		     would have if we had created a zero p_filesz and
5386 		     p_memsz PT_LOAD header for the section.  This
5387 		     also makes the PT_TLS header have the same
5388 		     p_offset value.  */
5389 		  bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
5390 							  off, align);
5391 		  this_hdr->sh_offset = sec->filepos = off + adjust;
5392 		}
5393 
5394 	      if (this_hdr->sh_type != SHT_NOBITS)
5395 		{
5396 		  p->p_filesz += this_hdr->sh_size;
5397 		  /* A load section without SHF_ALLOC is something like
5398 		     a note section in a PT_NOTE segment.  These take
5399 		     file space but are not loaded into memory.  */
5400 		  if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5401 		    p->p_memsz += this_hdr->sh_size;
5402 		}
5403 	      else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
5404 		{
5405 		  if (p->p_type == PT_TLS)
5406 		    p->p_memsz += this_hdr->sh_size;
5407 
5408 		  /* .tbss is special.  It doesn't contribute to p_memsz of
5409 		     normal segments.  */
5410 		  else if ((this_hdr->sh_flags & SHF_TLS) == 0)
5411 		    p->p_memsz += this_hdr->sh_size;
5412 		}
5413 
5414 	      if (align > p->p_align
5415 		  && !m->p_align_valid
5416 		  && (p->p_type != PT_LOAD
5417 		      || (abfd->flags & D_PAGED) == 0))
5418 		p->p_align = align;
5419 	    }
5420 
5421 	  if (!m->p_flags_valid)
5422 	    {
5423 	      p->p_flags |= PF_R;
5424 	      if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
5425 		p->p_flags |= PF_X;
5426 	      if ((this_hdr->sh_flags & SHF_WRITE) != 0)
5427 		p->p_flags |= PF_W;
5428 	    }
5429 	}
5430 
5431       off -= off_adjust;
5432 
5433       /* Check that all sections are in a PT_LOAD segment.
5434 	 Don't check funky gdb generated core files.  */
5435       if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
5436 	{
5437 	  bfd_boolean check_vma = TRUE;
5438 
5439 	  for (i = 1; i < m->count; i++)
5440 	    if (m->sections[i]->vma == m->sections[i - 1]->vma
5441 		&& ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
5442 				       ->this_hdr), p) != 0
5443 		&& ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
5444 				       ->this_hdr), p) != 0)
5445 	      {
5446 		/* Looks like we have overlays packed into the segment.  */
5447 		check_vma = FALSE;
5448 		break;
5449 	      }
5450 
5451 	  for (i = 0; i < m->count; i++)
5452 	    {
5453 	      Elf_Internal_Shdr *this_hdr;
5454 	      asection *sec;
5455 
5456 	      sec = m->sections[i];
5457 	      this_hdr = &(elf_section_data(sec)->this_hdr);
5458 	      if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
5459 		  && !ELF_TBSS_SPECIAL (this_hdr, p))
5460 		{
5461 		  (*_bfd_error_handler)
5462 		    (_("%B: section `%A' can't be allocated in segment %d"),
5463 		     abfd, sec, j);
5464 		  print_segment_map (m);
5465 		}
5466 	    }
5467 	}
5468     }
5469 
5470   elf_next_file_pos (abfd) = off;
5471   return TRUE;
5472 }
5473 
5474 /* Assign file positions for the other sections.  */
5475 
5476 static bfd_boolean
assign_file_positions_for_non_load_sections(bfd * abfd,struct bfd_link_info * link_info)5477 assign_file_positions_for_non_load_sections (bfd *abfd,
5478 					     struct bfd_link_info *link_info)
5479 {
5480   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5481   Elf_Internal_Shdr **i_shdrpp;
5482   Elf_Internal_Shdr **hdrpp, **end_hdrpp;
5483   Elf_Internal_Phdr *phdrs;
5484   Elf_Internal_Phdr *p;
5485   struct elf_segment_map *m;
5486   struct elf_segment_map *hdrs_segment;
5487   bfd_vma filehdr_vaddr, filehdr_paddr;
5488   bfd_vma phdrs_vaddr, phdrs_paddr;
5489   file_ptr off;
5490   unsigned int count;
5491 
5492   i_shdrpp = elf_elfsections (abfd);
5493   end_hdrpp = i_shdrpp + elf_numsections (abfd);
5494   off = elf_next_file_pos (abfd);
5495   for (hdrpp = i_shdrpp + 1; hdrpp < end_hdrpp; hdrpp++)
5496     {
5497       Elf_Internal_Shdr *hdr;
5498 
5499       hdr = *hdrpp;
5500       if (hdr->bfd_section != NULL
5501 	  && (hdr->bfd_section->filepos != 0
5502 	      || (hdr->sh_type == SHT_NOBITS
5503 		  && hdr->contents == NULL)))
5504 	BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5505       else if ((hdr->sh_flags & SHF_ALLOC) != 0)
5506 	{
5507 	  if (hdr->sh_size != 0)
5508 	    (*_bfd_error_handler)
5509 	      (_("%B: warning: allocated section `%s' not in segment"),
5510 	       abfd,
5511 	       (hdr->bfd_section == NULL
5512 		? "*unknown*"
5513 		: hdr->bfd_section->name));
5514 	  /* We don't need to page align empty sections.  */
5515 	  if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5516 	    off += vma_page_aligned_bias (hdr->sh_addr, off,
5517 					  bed->maxpagesize);
5518 	  else
5519 	    off += vma_page_aligned_bias (hdr->sh_addr, off,
5520 					  hdr->sh_addralign);
5521 	  off = _bfd_elf_assign_file_position_for_section (hdr, off,
5522 							   FALSE);
5523 	}
5524       else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5525 		&& hdr->bfd_section == NULL)
5526 	       || (hdr->bfd_section != NULL
5527 		   && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5528 		   /* Compress DWARF debug sections.  */
5529 	       || hdr == i_shdrpp[elf_onesymtab (abfd)]
5530 	       || (elf_symtab_shndx_list (abfd) != NULL
5531 		   && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
5532 	       || hdr == i_shdrpp[elf_strtab_sec (abfd)]
5533 	       || hdr == i_shdrpp[elf_shstrtab_sec (abfd)])
5534 	hdr->sh_offset = -1;
5535       else
5536 	off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5537     }
5538 
5539   /* Now that we have set the section file positions, we can set up
5540      the file positions for the non PT_LOAD segments.  */
5541   count = 0;
5542   filehdr_vaddr = 0;
5543   filehdr_paddr = 0;
5544   phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
5545   phdrs_paddr = 0;
5546   hdrs_segment = NULL;
5547   phdrs = elf_tdata (abfd)->phdr;
5548   for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5549     {
5550       ++count;
5551       if (p->p_type != PT_LOAD)
5552 	continue;
5553 
5554       if (m->includes_filehdr)
5555 	{
5556 	  filehdr_vaddr = p->p_vaddr;
5557 	  filehdr_paddr = p->p_paddr;
5558 	}
5559       if (m->includes_phdrs)
5560 	{
5561 	  phdrs_vaddr = p->p_vaddr;
5562 	  phdrs_paddr = p->p_paddr;
5563 	  if (m->includes_filehdr)
5564 	    {
5565 	      hdrs_segment = m;
5566 	      phdrs_vaddr += bed->s->sizeof_ehdr;
5567 	      phdrs_paddr += bed->s->sizeof_ehdr;
5568 	    }
5569 	}
5570     }
5571 
5572   if (hdrs_segment != NULL && link_info != NULL)
5573     {
5574       /* There is a segment that contains both the file headers and the
5575 	 program headers, so provide a symbol __ehdr_start pointing there.
5576 	 A program can use this to examine itself robustly.  */
5577 
5578       struct elf_link_hash_entry *hash
5579 	= elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
5580 				FALSE, FALSE, TRUE);
5581       /* If the symbol was referenced and not defined, define it.  */
5582       if (hash != NULL
5583 	  && (hash->root.type == bfd_link_hash_new
5584 	      || hash->root.type == bfd_link_hash_undefined
5585 	      || hash->root.type == bfd_link_hash_undefweak
5586 	      || hash->root.type == bfd_link_hash_common))
5587 	{
5588 	  asection *s = NULL;
5589 	  if (hdrs_segment->count != 0)
5590 	    /* The segment contains sections, so use the first one.  */
5591 	    s = hdrs_segment->sections[0];
5592 	  else
5593 	    /* Use the first (i.e. lowest-addressed) section in any segment.  */
5594 	    for (m = elf_seg_map (abfd); m != NULL; m = m->next)
5595 	      if (m->count != 0)
5596 		{
5597 		  s = m->sections[0];
5598 		  break;
5599 		}
5600 
5601 	  if (s != NULL)
5602 	    {
5603 	      hash->root.u.def.value = filehdr_vaddr - s->vma;
5604 	      hash->root.u.def.section = s;
5605 	    }
5606 	  else
5607 	    {
5608 	      hash->root.u.def.value = filehdr_vaddr;
5609 	      hash->root.u.def.section = bfd_abs_section_ptr;
5610 	    }
5611 
5612 	  hash->root.type = bfd_link_hash_defined;
5613 	  hash->def_regular = 1;
5614 	  hash->non_elf = 0;
5615 	}
5616     }
5617 
5618   for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
5619     {
5620       if (p->p_type == PT_GNU_RELRO)
5621 	{
5622 	  const Elf_Internal_Phdr *lp;
5623 	  struct elf_segment_map *lm;
5624 
5625 	  if (link_info != NULL)
5626 	    {
5627 	      /* During linking the range of the RELRO segment is passed
5628 		 in link_info.  */
5629 	      for (lm = elf_seg_map (abfd), lp = phdrs;
5630 		   lm != NULL;
5631 		   lm = lm->next, lp++)
5632 		{
5633 		  if (lp->p_type == PT_LOAD
5634 		      && lp->p_vaddr < link_info->relro_end
5635 		      && lm->count != 0
5636 		      && lm->sections[0]->vma >= link_info->relro_start)
5637 		    break;
5638 		}
5639 
5640 	      BFD_ASSERT (lm != NULL);
5641 	    }
5642 	  else
5643 	    {
5644 	      /* Otherwise we are copying an executable or shared
5645 		 library, but we need to use the same linker logic.  */
5646 	      for (lp = phdrs; lp < phdrs + count; ++lp)
5647 		{
5648 		  if (lp->p_type == PT_LOAD
5649 		      && lp->p_paddr == p->p_paddr)
5650 		    break;
5651 		}
5652 	    }
5653 
5654 	  if (lp < phdrs + count)
5655 	    {
5656 	      p->p_vaddr = lp->p_vaddr;
5657 	      p->p_paddr = lp->p_paddr;
5658 	      p->p_offset = lp->p_offset;
5659 	      if (link_info != NULL)
5660 		p->p_filesz = link_info->relro_end - lp->p_vaddr;
5661 	      else if (m->p_size_valid)
5662 		p->p_filesz = m->p_size;
5663 	      else
5664 		abort ();
5665 	      p->p_memsz = p->p_filesz;
5666 	      /* Preserve the alignment and flags if they are valid. The
5667 	         gold linker generates RW/4 for the PT_GNU_RELRO section.
5668 		 It is better for objcopy/strip to honor these attributes
5669 		 otherwise gdb will choke when using separate debug files.
5670 	       */
5671 	      if (!m->p_align_valid)
5672 		p->p_align = 1;
5673 	      if (!m->p_flags_valid)
5674 		p->p_flags = PF_R;
5675 	    }
5676 	  else
5677 	    {
5678 	      memset (p, 0, sizeof *p);
5679 	      p->p_type = PT_NULL;
5680 	    }
5681 	}
5682       else if (p->p_type == PT_GNU_STACK)
5683 	{
5684 	  if (m->p_size_valid)
5685 	    p->p_memsz = m->p_size;
5686 	}
5687       else if (m->count != 0)
5688 	{
5689 	  unsigned int i;
5690 	  if (p->p_type != PT_LOAD
5691 	      && (p->p_type != PT_NOTE
5692 		  || bfd_get_format (abfd) != bfd_core))
5693 	    {
5694 	      if (m->includes_filehdr || m->includes_phdrs)
5695 		{
5696 		  /* PR 17512: file: 2195325e.  */
5697 		  (*_bfd_error_handler)
5698 		    (_("%B: warning: non-load segment includes file header and/or program header"),
5699 		     abfd);
5700 		  return FALSE;
5701 		}
5702 
5703 	      p->p_filesz = 0;
5704 	      p->p_offset = m->sections[0]->filepos;
5705 	      for (i = m->count; i-- != 0;)
5706 		{
5707 		  asection *sect = m->sections[i];
5708 		  Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
5709 		  if (hdr->sh_type != SHT_NOBITS)
5710 		    {
5711 		      p->p_filesz = (sect->filepos - m->sections[0]->filepos
5712 				     + hdr->sh_size);
5713 		      break;
5714 		    }
5715 		}
5716 	    }
5717 	}
5718       else if (m->includes_filehdr)
5719 	{
5720 	  p->p_vaddr = filehdr_vaddr;
5721 	  if (! m->p_paddr_valid)
5722 	    p->p_paddr = filehdr_paddr;
5723 	}
5724       else if (m->includes_phdrs)
5725 	{
5726 	  p->p_vaddr = phdrs_vaddr;
5727 	  if (! m->p_paddr_valid)
5728 	    p->p_paddr = phdrs_paddr;
5729 	}
5730     }
5731 
5732   elf_next_file_pos (abfd) = off;
5733 
5734   return TRUE;
5735 }
5736 
5737 static elf_section_list *
find_section_in_list(unsigned int i,elf_section_list * list)5738 find_section_in_list (unsigned int i, elf_section_list * list)
5739 {
5740   for (;list != NULL; list = list->next)
5741     if (list->ndx == i)
5742       break;
5743   return list;
5744 }
5745 
5746 /* Work out the file positions of all the sections.  This is called by
5747    _bfd_elf_compute_section_file_positions.  All the section sizes and
5748    VMAs must be known before this is called.
5749 
5750    Reloc sections come in two flavours: Those processed specially as
5751    "side-channel" data attached to a section to which they apply, and
5752    those that bfd doesn't process as relocations.  The latter sort are
5753    stored in a normal bfd section by bfd_section_from_shdr.   We don't
5754    consider the former sort here, unless they form part of the loadable
5755    image.  Reloc sections not assigned here will be handled later by
5756    assign_file_positions_for_relocs.
5757 
5758    We also don't set the positions of the .symtab and .strtab here.  */
5759 
5760 static bfd_boolean
assign_file_positions_except_relocs(bfd * abfd,struct bfd_link_info * link_info)5761 assign_file_positions_except_relocs (bfd *abfd,
5762 				     struct bfd_link_info *link_info)
5763 {
5764   struct elf_obj_tdata *tdata = elf_tdata (abfd);
5765   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5766   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5767 
5768   if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
5769       && bfd_get_format (abfd) != bfd_core)
5770     {
5771       Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
5772       unsigned int num_sec = elf_numsections (abfd);
5773       Elf_Internal_Shdr **hdrpp;
5774       unsigned int i;
5775       file_ptr off;
5776 
5777       /* Start after the ELF header.  */
5778       off = i_ehdrp->e_ehsize;
5779 
5780       /* We are not creating an executable, which means that we are
5781 	 not creating a program header, and that the actual order of
5782 	 the sections in the file is unimportant.  */
5783       for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
5784 	{
5785 	  Elf_Internal_Shdr *hdr;
5786 
5787 	  hdr = *hdrpp;
5788 	  if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5789 	       && hdr->bfd_section == NULL)
5790 	      || (hdr->bfd_section != NULL
5791 		  && (hdr->bfd_section->flags & SEC_ELF_COMPRESS))
5792 		  /* Compress DWARF debug sections.  */
5793 	      || i == elf_onesymtab (abfd)
5794 	      || (elf_symtab_shndx_list (abfd) != NULL
5795 		  && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx])
5796 	      || i == elf_strtab_sec (abfd)
5797 	      || i == elf_shstrtab_sec (abfd))
5798 	    {
5799 	      hdr->sh_offset = -1;
5800 	    }
5801 	  else
5802 	    off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5803 	}
5804 
5805       elf_next_file_pos (abfd) = off;
5806     }
5807   else
5808     {
5809       unsigned int alloc;
5810 
5811       /* Assign file positions for the loaded sections based on the
5812 	 assignment of sections to segments.  */
5813       if (!assign_file_positions_for_load_sections (abfd, link_info))
5814 	return FALSE;
5815 
5816       /* And for non-load sections.  */
5817       if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5818 	return FALSE;
5819 
5820       if (bed->elf_backend_modify_program_headers != NULL)
5821 	{
5822 	  if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5823 	    return FALSE;
5824 	}
5825 
5826       /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.  */
5827       if (link_info != NULL && bfd_link_pie (link_info))
5828 	{
5829 	  unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
5830 	  Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
5831 	  Elf_Internal_Phdr *end_segment = &segment[num_segments];
5832 
5833 	  /* Find the lowest p_vaddr in PT_LOAD segments.  */
5834 	  bfd_vma p_vaddr = (bfd_vma) -1;
5835 	  for (; segment < end_segment; segment++)
5836 	    if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
5837 	      p_vaddr = segment->p_vaddr;
5838 
5839 	  /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5840 	     segments is non-zero.  */
5841 	  if (p_vaddr)
5842 	    i_ehdrp->e_type = ET_EXEC;
5843 	}
5844 
5845       /* Write out the program headers.  */
5846       alloc = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
5847       if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5848 	  || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
5849 	return FALSE;
5850     }
5851 
5852   return TRUE;
5853 }
5854 
5855 static bfd_boolean
prep_headers(bfd * abfd)5856 prep_headers (bfd *abfd)
5857 {
5858   Elf_Internal_Ehdr *i_ehdrp;	/* Elf file header, internal form.  */
5859   struct elf_strtab_hash *shstrtab;
5860   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5861 
5862   i_ehdrp = elf_elfheader (abfd);
5863 
5864   shstrtab = _bfd_elf_strtab_init ();
5865   if (shstrtab == NULL)
5866     return FALSE;
5867 
5868   elf_shstrtab (abfd) = shstrtab;
5869 
5870   i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5871   i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5872   i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5873   i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5874 
5875   i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5876   i_ehdrp->e_ident[EI_DATA] =
5877     bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5878   i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5879 
5880   if ((abfd->flags & DYNAMIC) != 0)
5881     i_ehdrp->e_type = ET_DYN;
5882   else if ((abfd->flags & EXEC_P) != 0)
5883     i_ehdrp->e_type = ET_EXEC;
5884   else if (bfd_get_format (abfd) == bfd_core)
5885     i_ehdrp->e_type = ET_CORE;
5886   else
5887     i_ehdrp->e_type = ET_REL;
5888 
5889   switch (bfd_get_arch (abfd))
5890     {
5891     case bfd_arch_unknown:
5892       i_ehdrp->e_machine = EM_NONE;
5893       break;
5894 
5895       /* There used to be a long list of cases here, each one setting
5896 	 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5897 	 in the corresponding bfd definition.  To avoid duplication,
5898 	 the switch was removed.  Machines that need special handling
5899 	 can generally do it in elf_backend_final_write_processing(),
5900 	 unless they need the information earlier than the final write.
5901 	 Such need can generally be supplied by replacing the tests for
5902 	 e_machine with the conditions used to determine it.  */
5903     default:
5904       i_ehdrp->e_machine = bed->elf_machine_code;
5905     }
5906 
5907   i_ehdrp->e_version = bed->s->ev_current;
5908   i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5909 
5910   /* No program header, for now.  */
5911   i_ehdrp->e_phoff = 0;
5912   i_ehdrp->e_phentsize = 0;
5913   i_ehdrp->e_phnum = 0;
5914 
5915   /* Each bfd section is section header entry.  */
5916   i_ehdrp->e_entry = bfd_get_start_address (abfd);
5917   i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5918 
5919   /* If we're building an executable, we'll need a program header table.  */
5920   if (abfd->flags & EXEC_P)
5921     /* It all happens later.  */
5922     ;
5923   else
5924     {
5925       i_ehdrp->e_phentsize = 0;
5926       i_ehdrp->e_phoff = 0;
5927     }
5928 
5929   elf_tdata (abfd)->symtab_hdr.sh_name =
5930     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
5931   elf_tdata (abfd)->strtab_hdr.sh_name =
5932     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
5933   elf_tdata (abfd)->shstrtab_hdr.sh_name =
5934     (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
5935   if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5936       || elf_tdata (abfd)->strtab_hdr.sh_name == (unsigned int) -1
5937       || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
5938     return FALSE;
5939 
5940   return TRUE;
5941 }
5942 
5943 /* Assign file positions for all the reloc sections which are not part
5944    of the loadable file image, and the file position of section headers.  */
5945 
5946 static bfd_boolean
_bfd_elf_assign_file_positions_for_non_load(bfd * abfd)5947 _bfd_elf_assign_file_positions_for_non_load (bfd *abfd)
5948 {
5949   file_ptr off;
5950   Elf_Internal_Shdr **shdrpp, **end_shdrpp;
5951   Elf_Internal_Shdr *shdrp;
5952   Elf_Internal_Ehdr *i_ehdrp;
5953   const struct elf_backend_data *bed;
5954 
5955   off = elf_next_file_pos (abfd);
5956 
5957   shdrpp = elf_elfsections (abfd);
5958   end_shdrpp = shdrpp + elf_numsections (abfd);
5959   for (shdrpp++; shdrpp < end_shdrpp; shdrpp++)
5960     {
5961       shdrp = *shdrpp;
5962       if (shdrp->sh_offset == -1)
5963 	{
5964 	  asection *sec = shdrp->bfd_section;
5965 	  bfd_boolean is_rel = (shdrp->sh_type == SHT_REL
5966 				|| shdrp->sh_type == SHT_RELA);
5967 	  if (is_rel
5968 	      || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS)))
5969 	    {
5970 	      if (!is_rel)
5971 		{
5972 		  const char *name = sec->name;
5973 		  struct bfd_elf_section_data *d;
5974 
5975 		  /* Compress DWARF debug sections.  */
5976 		  if (!bfd_compress_section (abfd, sec,
5977 					     shdrp->contents))
5978 		    return FALSE;
5979 
5980 		  if (sec->compress_status == COMPRESS_SECTION_DONE
5981 		      && (abfd->flags & BFD_COMPRESS_GABI) == 0)
5982 		    {
5983 		      /* If section is compressed with zlib-gnu, convert
5984 			 section name from .debug_* to .zdebug_*.  */
5985 		      char *new_name
5986 			= convert_debug_to_zdebug (abfd, name);
5987 		      if (new_name == NULL)
5988 			return FALSE;
5989 		      name = new_name;
5990 		    }
5991 		  /* Add setion name to section name section.  */
5992 		  if (shdrp->sh_name != (unsigned int) -1)
5993 		    abort ();
5994 		  shdrp->sh_name
5995 		    = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
5996 							  name, FALSE);
5997 		  d = elf_section_data (sec);
5998 
5999 		  /* Add reloc setion name to section name section.  */
6000 		  if (d->rel.hdr
6001 		      && !_bfd_elf_set_reloc_sh_name (abfd,
6002 						      d->rel.hdr,
6003 						      name, FALSE))
6004 		    return FALSE;
6005 		  if (d->rela.hdr
6006 		      && !_bfd_elf_set_reloc_sh_name (abfd,
6007 						      d->rela.hdr,
6008 						      name, TRUE))
6009 		    return FALSE;
6010 
6011 		  /* Update section size and contents.  */
6012 		  shdrp->sh_size = sec->size;
6013 		  shdrp->contents = sec->contents;
6014 		  shdrp->bfd_section->contents = NULL;
6015 		}
6016 	      off = _bfd_elf_assign_file_position_for_section (shdrp,
6017 							       off,
6018 							       TRUE);
6019 	    }
6020 	}
6021     }
6022 
6023   /* Place section name section after DWARF debug sections have been
6024      compressed.  */
6025   _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
6026   shdrp = &elf_tdata (abfd)->shstrtab_hdr;
6027   shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
6028   off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
6029 
6030   /* Place the section headers.  */
6031   i_ehdrp = elf_elfheader (abfd);
6032   bed = get_elf_backend_data (abfd);
6033   off = align_file_position (off, 1 << bed->s->log_file_align);
6034   i_ehdrp->e_shoff = off;
6035   off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
6036   elf_next_file_pos (abfd) = off;
6037 
6038   return TRUE;
6039 }
6040 
6041 bfd_boolean
_bfd_elf_write_object_contents(bfd * abfd)6042 _bfd_elf_write_object_contents (bfd *abfd)
6043 {
6044   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6045   Elf_Internal_Shdr **i_shdrp;
6046   bfd_boolean failed;
6047   unsigned int count, num_sec;
6048   struct elf_obj_tdata *t;
6049 
6050   if (! abfd->output_has_begun
6051       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
6052     return FALSE;
6053 
6054   i_shdrp = elf_elfsections (abfd);
6055 
6056   failed = FALSE;
6057   bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
6058   if (failed)
6059     return FALSE;
6060 
6061   if (!_bfd_elf_assign_file_positions_for_non_load (abfd))
6062     return FALSE;
6063 
6064   /* After writing the headers, we need to write the sections too...  */
6065   num_sec = elf_numsections (abfd);
6066   for (count = 1; count < num_sec; count++)
6067     {
6068       i_shdrp[count]->sh_name
6069 	= _bfd_elf_strtab_offset (elf_shstrtab (abfd),
6070 				  i_shdrp[count]->sh_name);
6071       if (bed->elf_backend_section_processing)
6072 	(*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
6073       if (i_shdrp[count]->contents)
6074 	{
6075 	  bfd_size_type amt = i_shdrp[count]->sh_size;
6076 
6077 	  if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
6078 	      || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
6079 	    return FALSE;
6080 	}
6081     }
6082 
6083   /* Write out the section header names.  */
6084   t = elf_tdata (abfd);
6085   if (elf_shstrtab (abfd) != NULL
6086       && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
6087 	  || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
6088     return FALSE;
6089 
6090   if (bed->elf_backend_final_write_processing)
6091     (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
6092 
6093   if (!bed->s->write_shdrs_and_ehdr (abfd))
6094     return FALSE;
6095 
6096   /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0].  */
6097   if (t->o->build_id.after_write_object_contents != NULL)
6098     return (*t->o->build_id.after_write_object_contents) (abfd);
6099 
6100   return TRUE;
6101 }
6102 
6103 bfd_boolean
_bfd_elf_write_corefile_contents(bfd * abfd)6104 _bfd_elf_write_corefile_contents (bfd *abfd)
6105 {
6106   /* Hopefully this can be done just like an object file.  */
6107   return _bfd_elf_write_object_contents (abfd);
6108 }
6109 
6110 /* Given a section, search the header to find them.  */
6111 
6112 unsigned int
_bfd_elf_section_from_bfd_section(bfd * abfd,struct bfd_section * asect)6113 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
6114 {
6115   const struct elf_backend_data *bed;
6116   unsigned int sec_index;
6117 
6118   if (elf_section_data (asect) != NULL
6119       && elf_section_data (asect)->this_idx != 0)
6120     return elf_section_data (asect)->this_idx;
6121 
6122   if (bfd_is_abs_section (asect))
6123     sec_index = SHN_ABS;
6124   else if (bfd_is_com_section (asect))
6125     sec_index = SHN_COMMON;
6126   else if (bfd_is_und_section (asect))
6127     sec_index = SHN_UNDEF;
6128   else
6129     sec_index = SHN_BAD;
6130 
6131   bed = get_elf_backend_data (abfd);
6132   if (bed->elf_backend_section_from_bfd_section)
6133     {
6134       int retval = sec_index;
6135 
6136       if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
6137 	return retval;
6138     }
6139 
6140   if (sec_index == SHN_BAD)
6141     bfd_set_error (bfd_error_nonrepresentable_section);
6142 
6143   return sec_index;
6144 }
6145 
6146 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6147    on error.  */
6148 
6149 int
_bfd_elf_symbol_from_bfd_symbol(bfd * abfd,asymbol ** asym_ptr_ptr)6150 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
6151 {
6152   asymbol *asym_ptr = *asym_ptr_ptr;
6153   int idx;
6154   flagword flags = asym_ptr->flags;
6155 
6156   /* When gas creates relocations against local labels, it creates its
6157      own symbol for the section, but does put the symbol into the
6158      symbol chain, so udata is 0.  When the linker is generating
6159      relocatable output, this section symbol may be for one of the
6160      input sections rather than the output section.  */
6161   if (asym_ptr->udata.i == 0
6162       && (flags & BSF_SECTION_SYM)
6163       && asym_ptr->section)
6164     {
6165       asection *sec;
6166       int indx;
6167 
6168       sec = asym_ptr->section;
6169       if (sec->owner != abfd && sec->output_section != NULL)
6170 	sec = sec->output_section;
6171       if (sec->owner == abfd
6172 	  && (indx = sec->index) < elf_num_section_syms (abfd)
6173 	  && elf_section_syms (abfd)[indx] != NULL)
6174 	asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
6175     }
6176 
6177   idx = asym_ptr->udata.i;
6178 
6179   if (idx == 0)
6180     {
6181       /* This case can occur when using --strip-symbol on a symbol
6182 	 which is used in a relocation entry.  */
6183       (*_bfd_error_handler)
6184 	(_("%B: symbol `%s' required but not present"),
6185 	 abfd, bfd_asymbol_name (asym_ptr));
6186       bfd_set_error (bfd_error_no_symbols);
6187       return -1;
6188     }
6189 
6190 #if DEBUG & 4
6191   {
6192     fprintf (stderr,
6193 	     "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
6194 	     (long) asym_ptr, asym_ptr->name, idx, (long) flags);
6195     fflush (stderr);
6196   }
6197 #endif
6198 
6199   return idx;
6200 }
6201 
6202 /* Rewrite program header information.  */
6203 
6204 static bfd_boolean
rewrite_elf_program_header(bfd * ibfd,bfd * obfd)6205 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
6206 {
6207   Elf_Internal_Ehdr *iehdr;
6208   struct elf_segment_map *map;
6209   struct elf_segment_map *map_first;
6210   struct elf_segment_map **pointer_to_map;
6211   Elf_Internal_Phdr *segment;
6212   asection *section;
6213   unsigned int i;
6214   unsigned int num_segments;
6215   bfd_boolean phdr_included = FALSE;
6216   bfd_boolean p_paddr_valid;
6217   bfd_vma maxpagesize;
6218   struct elf_segment_map *phdr_adjust_seg = NULL;
6219   unsigned int phdr_adjust_num = 0;
6220   const struct elf_backend_data *bed;
6221 
6222   bed = get_elf_backend_data (ibfd);
6223   iehdr = elf_elfheader (ibfd);
6224 
6225   map_first = NULL;
6226   pointer_to_map = &map_first;
6227 
6228   num_segments = elf_elfheader (ibfd)->e_phnum;
6229   maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
6230 
6231   /* Returns the end address of the segment + 1.  */
6232 #define SEGMENT_END(segment, start)					\
6233   (start + (segment->p_memsz > segment->p_filesz			\
6234 	    ? segment->p_memsz : segment->p_filesz))
6235 
6236 #define SECTION_SIZE(section, segment)					\
6237   (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL))		\
6238     != SEC_THREAD_LOCAL || segment->p_type == PT_TLS)			\
6239    ? section->size : 0)
6240 
6241   /* Returns TRUE if the given section is contained within
6242      the given segment.  VMA addresses are compared.  */
6243 #define IS_CONTAINED_BY_VMA(section, segment)				\
6244   (section->vma >= segment->p_vaddr					\
6245    && (section->vma + SECTION_SIZE (section, segment)			\
6246        <= (SEGMENT_END (segment, segment->p_vaddr))))
6247 
6248   /* Returns TRUE if the given section is contained within
6249      the given segment.  LMA addresses are compared.  */
6250 #define IS_CONTAINED_BY_LMA(section, segment, base)			\
6251   (section->lma >= base							\
6252    && (section->lma + SECTION_SIZE (section, segment)			\
6253        <= SEGMENT_END (segment, base)))
6254 
6255   /* Handle PT_NOTE segment.  */
6256 #define IS_NOTE(p, s)							\
6257   (p->p_type == PT_NOTE							\
6258    && elf_section_type (s) == SHT_NOTE					\
6259    && (bfd_vma) s->filepos >= p->p_offset				\
6260    && ((bfd_vma) s->filepos + s->size					\
6261        <= p->p_offset + p->p_filesz))
6262 
6263   /* Special case: corefile "NOTE" section containing regs, prpsinfo
6264      etc.  */
6265 #define IS_COREFILE_NOTE(p, s)						\
6266   (IS_NOTE (p, s)							\
6267    && bfd_get_format (ibfd) == bfd_core					\
6268    && s->vma == 0							\
6269    && s->lma == 0)
6270 
6271   /* The complicated case when p_vaddr is 0 is to handle the Solaris
6272      linker, which generates a PT_INTERP section with p_vaddr and
6273      p_memsz set to 0.  */
6274 #define IS_SOLARIS_PT_INTERP(p, s)					\
6275   (p->p_vaddr == 0							\
6276    && p->p_paddr == 0							\
6277    && p->p_memsz == 0							\
6278    && p->p_filesz > 0							\
6279    && (s->flags & SEC_HAS_CONTENTS) != 0				\
6280    && s->size > 0							\
6281    && (bfd_vma) s->filepos >= p->p_offset				\
6282    && ((bfd_vma) s->filepos + s->size					\
6283        <= p->p_offset + p->p_filesz))
6284 
6285   /* Decide if the given section should be included in the given segment.
6286      A section will be included if:
6287        1. It is within the address space of the segment -- we use the LMA
6288 	  if that is set for the segment and the VMA otherwise,
6289        2. It is an allocated section or a NOTE section in a PT_NOTE
6290 	  segment.
6291        3. There is an output section associated with it,
6292        4. The section has not already been allocated to a previous segment.
6293        5. PT_GNU_STACK segments do not include any sections.
6294        6. PT_TLS segment includes only SHF_TLS sections.
6295        7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6296        8. PT_DYNAMIC should not contain empty sections at the beginning
6297 	  (with the possible exception of .dynamic).  */
6298 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed)		\
6299   ((((segment->p_paddr							\
6300       ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr)	\
6301       : IS_CONTAINED_BY_VMA (section, segment))				\
6302      && (section->flags & SEC_ALLOC) != 0)				\
6303     || IS_NOTE (segment, section))					\
6304    && segment->p_type != PT_GNU_STACK					\
6305    && (segment->p_type != PT_TLS					\
6306        || (section->flags & SEC_THREAD_LOCAL))				\
6307    && (segment->p_type == PT_LOAD					\
6308        || segment->p_type == PT_TLS					\
6309        || (section->flags & SEC_THREAD_LOCAL) == 0)			\
6310    && (segment->p_type != PT_DYNAMIC					\
6311        || SECTION_SIZE (section, segment) > 0				\
6312        || (segment->p_paddr						\
6313 	   ? segment->p_paddr != section->lma				\
6314 	   : segment->p_vaddr != section->vma)				\
6315        || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic")	\
6316 	   == 0))							\
6317    && !section->segment_mark)
6318 
6319 /* If the output section of a section in the input segment is NULL,
6320    it is removed from the corresponding output segment.   */
6321 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed)		\
6322   (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed)		\
6323    && section->output_section != NULL)
6324 
6325   /* Returns TRUE iff seg1 starts after the end of seg2.  */
6326 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field)			\
6327   (seg1->field >= SEGMENT_END (seg2, seg2->field))
6328 
6329   /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6330      their VMA address ranges and their LMA address ranges overlap.
6331      It is possible to have overlapping VMA ranges without overlapping LMA
6332      ranges.  RedBoot images for example can have both .data and .bss mapped
6333      to the same VMA range, but with the .data section mapped to a different
6334      LMA.  */
6335 #define SEGMENT_OVERLAPS(seg1, seg2)					\
6336   (   !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr)			\
6337 	|| SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr))			\
6338    && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr)			\
6339 	|| SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6340 
6341   /* Initialise the segment mark field.  */
6342   for (section = ibfd->sections; section != NULL; section = section->next)
6343     section->segment_mark = FALSE;
6344 
6345   /* The Solaris linker creates program headers in which all the
6346      p_paddr fields are zero.  When we try to objcopy or strip such a
6347      file, we get confused.  Check for this case, and if we find it
6348      don't set the p_paddr_valid fields.  */
6349   p_paddr_valid = FALSE;
6350   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6351        i < num_segments;
6352        i++, segment++)
6353     if (segment->p_paddr != 0)
6354       {
6355 	p_paddr_valid = TRUE;
6356 	break;
6357       }
6358 
6359   /* Scan through the segments specified in the program header
6360      of the input BFD.  For this first scan we look for overlaps
6361      in the loadable segments.  These can be created by weird
6362      parameters to objcopy.  Also, fix some solaris weirdness.  */
6363   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6364        i < num_segments;
6365        i++, segment++)
6366     {
6367       unsigned int j;
6368       Elf_Internal_Phdr *segment2;
6369 
6370       if (segment->p_type == PT_INTERP)
6371 	for (section = ibfd->sections; section; section = section->next)
6372 	  if (IS_SOLARIS_PT_INTERP (segment, section))
6373 	    {
6374 	      /* Mininal change so that the normal section to segment
6375 		 assignment code will work.  */
6376 	      segment->p_vaddr = section->vma;
6377 	      break;
6378 	    }
6379 
6380       if (segment->p_type != PT_LOAD)
6381 	{
6382 	  /* Remove PT_GNU_RELRO segment.  */
6383 	  if (segment->p_type == PT_GNU_RELRO)
6384 	    segment->p_type = PT_NULL;
6385 	  continue;
6386 	}
6387 
6388       /* Determine if this segment overlaps any previous segments.  */
6389       for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
6390 	{
6391 	  bfd_signed_vma extra_length;
6392 
6393 	  if (segment2->p_type != PT_LOAD
6394 	      || !SEGMENT_OVERLAPS (segment, segment2))
6395 	    continue;
6396 
6397 	  /* Merge the two segments together.  */
6398 	  if (segment2->p_vaddr < segment->p_vaddr)
6399 	    {
6400 	      /* Extend SEGMENT2 to include SEGMENT and then delete
6401 		 SEGMENT.  */
6402 	      extra_length = (SEGMENT_END (segment, segment->p_vaddr)
6403 			      - SEGMENT_END (segment2, segment2->p_vaddr));
6404 
6405 	      if (extra_length > 0)
6406 		{
6407 		  segment2->p_memsz += extra_length;
6408 		  segment2->p_filesz += extra_length;
6409 		}
6410 
6411 	      segment->p_type = PT_NULL;
6412 
6413 	      /* Since we have deleted P we must restart the outer loop.  */
6414 	      i = 0;
6415 	      segment = elf_tdata (ibfd)->phdr;
6416 	      break;
6417 	    }
6418 	  else
6419 	    {
6420 	      /* Extend SEGMENT to include SEGMENT2 and then delete
6421 		 SEGMENT2.  */
6422 	      extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
6423 			      - SEGMENT_END (segment, segment->p_vaddr));
6424 
6425 	      if (extra_length > 0)
6426 		{
6427 		  segment->p_memsz += extra_length;
6428 		  segment->p_filesz += extra_length;
6429 		}
6430 
6431 	      segment2->p_type = PT_NULL;
6432 	    }
6433 	}
6434     }
6435 
6436   /* The second scan attempts to assign sections to segments.  */
6437   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6438        i < num_segments;
6439        i++, segment++)
6440     {
6441       unsigned int section_count;
6442       asection **sections;
6443       asection *output_section;
6444       unsigned int isec;
6445       bfd_vma matching_lma;
6446       bfd_vma suggested_lma;
6447       unsigned int j;
6448       bfd_size_type amt;
6449       asection *first_section;
6450       bfd_boolean first_matching_lma;
6451       bfd_boolean first_suggested_lma;
6452 
6453       if (segment->p_type == PT_NULL)
6454 	continue;
6455 
6456       first_section = NULL;
6457       /* Compute how many sections might be placed into this segment.  */
6458       for (section = ibfd->sections, section_count = 0;
6459 	   section != NULL;
6460 	   section = section->next)
6461 	{
6462 	  /* Find the first section in the input segment, which may be
6463 	     removed from the corresponding output segment.   */
6464 	  if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
6465 	    {
6466 	      if (first_section == NULL)
6467 		first_section = section;
6468 	      if (section->output_section != NULL)
6469 		++section_count;
6470 	    }
6471 	}
6472 
6473       /* Allocate a segment map big enough to contain
6474 	 all of the sections we have selected.  */
6475       amt = sizeof (struct elf_segment_map);
6476       amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6477       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6478       if (map == NULL)
6479 	return FALSE;
6480 
6481       /* Initialise the fields of the segment map.  Default to
6482 	 using the physical address of the segment in the input BFD.  */
6483       map->next = NULL;
6484       map->p_type = segment->p_type;
6485       map->p_flags = segment->p_flags;
6486       map->p_flags_valid = 1;
6487 
6488       /* If the first section in the input segment is removed, there is
6489 	 no need to preserve segment physical address in the corresponding
6490 	 output segment.  */
6491       if (!first_section || first_section->output_section != NULL)
6492 	{
6493 	  map->p_paddr = segment->p_paddr;
6494 	  map->p_paddr_valid = p_paddr_valid;
6495 	}
6496 
6497       /* Determine if this segment contains the ELF file header
6498 	 and if it contains the program headers themselves.  */
6499       map->includes_filehdr = (segment->p_offset == 0
6500 			       && segment->p_filesz >= iehdr->e_ehsize);
6501       map->includes_phdrs = 0;
6502 
6503       if (!phdr_included || segment->p_type != PT_LOAD)
6504 	{
6505 	  map->includes_phdrs =
6506 	    (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6507 	     && (segment->p_offset + segment->p_filesz
6508 		 >= ((bfd_vma) iehdr->e_phoff
6509 		     + iehdr->e_phnum * iehdr->e_phentsize)));
6510 
6511 	  if (segment->p_type == PT_LOAD && map->includes_phdrs)
6512 	    phdr_included = TRUE;
6513 	}
6514 
6515       if (section_count == 0)
6516 	{
6517 	  /* Special segments, such as the PT_PHDR segment, may contain
6518 	     no sections, but ordinary, loadable segments should contain
6519 	     something.  They are allowed by the ELF spec however, so only
6520 	     a warning is produced.  */
6521 	  if (segment->p_type == PT_LOAD)
6522 	    (*_bfd_error_handler) (_("\
6523 %B: warning: Empty loadable segment detected, is this intentional ?"),
6524 				   ibfd);
6525 
6526 	  map->count = 0;
6527 	  *pointer_to_map = map;
6528 	  pointer_to_map = &map->next;
6529 
6530 	  continue;
6531 	}
6532 
6533       /* Now scan the sections in the input BFD again and attempt
6534 	 to add their corresponding output sections to the segment map.
6535 	 The problem here is how to handle an output section which has
6536 	 been moved (ie had its LMA changed).  There are four possibilities:
6537 
6538 	 1. None of the sections have been moved.
6539 	    In this case we can continue to use the segment LMA from the
6540 	    input BFD.
6541 
6542 	 2. All of the sections have been moved by the same amount.
6543 	    In this case we can change the segment's LMA to match the LMA
6544 	    of the first section.
6545 
6546 	 3. Some of the sections have been moved, others have not.
6547 	    In this case those sections which have not been moved can be
6548 	    placed in the current segment which will have to have its size,
6549 	    and possibly its LMA changed, and a new segment or segments will
6550 	    have to be created to contain the other sections.
6551 
6552 	 4. The sections have been moved, but not by the same amount.
6553 	    In this case we can change the segment's LMA to match the LMA
6554 	    of the first section and we will have to create a new segment
6555 	    or segments to contain the other sections.
6556 
6557 	 In order to save time, we allocate an array to hold the section
6558 	 pointers that we are interested in.  As these sections get assigned
6559 	 to a segment, they are removed from this array.  */
6560 
6561       sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
6562       if (sections == NULL)
6563 	return FALSE;
6564 
6565       /* Step One: Scan for segment vs section LMA conflicts.
6566 	 Also add the sections to the section array allocated above.
6567 	 Also add the sections to the current segment.  In the common
6568 	 case, where the sections have not been moved, this means that
6569 	 we have completely filled the segment, and there is nothing
6570 	 more to do.  */
6571       isec = 0;
6572       matching_lma = 0;
6573       suggested_lma = 0;
6574       first_matching_lma = TRUE;
6575       first_suggested_lma = TRUE;
6576 
6577       for (section = first_section, j = 0;
6578 	   section != NULL;
6579 	   section = section->next)
6580 	{
6581 	  if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
6582 	    {
6583 	      output_section = section->output_section;
6584 
6585 	      sections[j++] = section;
6586 
6587 	      /* The Solaris native linker always sets p_paddr to 0.
6588 		 We try to catch that case here, and set it to the
6589 		 correct value.  Note - some backends require that
6590 		 p_paddr be left as zero.  */
6591 	      if (!p_paddr_valid
6592 		  && segment->p_vaddr != 0
6593 		  && !bed->want_p_paddr_set_to_zero
6594 		  && isec == 0
6595 		  && output_section->lma != 0
6596 		  && output_section->vma == (segment->p_vaddr
6597 					     + (map->includes_filehdr
6598 						? iehdr->e_ehsize
6599 						: 0)
6600 					     + (map->includes_phdrs
6601 						? (iehdr->e_phnum
6602 						   * iehdr->e_phentsize)
6603 						: 0)))
6604 		map->p_paddr = segment->p_vaddr;
6605 
6606 	      /* Match up the physical address of the segment with the
6607 		 LMA address of the output section.  */
6608 	      if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
6609 		  || IS_COREFILE_NOTE (segment, section)
6610 		  || (bed->want_p_paddr_set_to_zero
6611 		      && IS_CONTAINED_BY_VMA (output_section, segment)))
6612 		{
6613 		  if (first_matching_lma || output_section->lma < matching_lma)
6614 		    {
6615 		      matching_lma = output_section->lma;
6616 		      first_matching_lma = FALSE;
6617 		    }
6618 
6619 		  /* We assume that if the section fits within the segment
6620 		     then it does not overlap any other section within that
6621 		     segment.  */
6622 		  map->sections[isec++] = output_section;
6623 		}
6624 	      else if (first_suggested_lma)
6625 		{
6626 		  suggested_lma = output_section->lma;
6627 		  first_suggested_lma = FALSE;
6628 		}
6629 
6630 	      if (j == section_count)
6631 		break;
6632 	    }
6633 	}
6634 
6635       BFD_ASSERT (j == section_count);
6636 
6637       /* Step Two: Adjust the physical address of the current segment,
6638 	 if necessary.  */
6639       if (isec == section_count)
6640 	{
6641 	  /* All of the sections fitted within the segment as currently
6642 	     specified.  This is the default case.  Add the segment to
6643 	     the list of built segments and carry on to process the next
6644 	     program header in the input BFD.  */
6645 	  map->count = section_count;
6646 	  *pointer_to_map = map;
6647 	  pointer_to_map = &map->next;
6648 
6649 	  if (p_paddr_valid
6650 	      && !bed->want_p_paddr_set_to_zero
6651 	      && matching_lma != map->p_paddr
6652 	      && !map->includes_filehdr
6653 	      && !map->includes_phdrs)
6654 	    /* There is some padding before the first section in the
6655 	       segment.  So, we must account for that in the output
6656 	       segment's vma.  */
6657 	    map->p_vaddr_offset = matching_lma - map->p_paddr;
6658 
6659 	  free (sections);
6660 	  continue;
6661 	}
6662       else
6663 	{
6664 	  if (!first_matching_lma)
6665 	    {
6666 	      /* At least one section fits inside the current segment.
6667 		 Keep it, but modify its physical address to match the
6668 		 LMA of the first section that fitted.  */
6669 	      map->p_paddr = matching_lma;
6670 	    }
6671 	  else
6672 	    {
6673 	      /* None of the sections fitted inside the current segment.
6674 		 Change the current segment's physical address to match
6675 		 the LMA of the first section.  */
6676 	      map->p_paddr = suggested_lma;
6677 	    }
6678 
6679 	  /* Offset the segment physical address from the lma
6680 	     to allow for space taken up by elf headers.  */
6681 	  if (map->includes_filehdr)
6682 	    {
6683 	      if (map->p_paddr >= iehdr->e_ehsize)
6684 		map->p_paddr -= iehdr->e_ehsize;
6685 	      else
6686 		{
6687 		  map->includes_filehdr = FALSE;
6688 		  map->includes_phdrs = FALSE;
6689 		}
6690 	    }
6691 
6692 	  if (map->includes_phdrs)
6693 	    {
6694 	      if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
6695 		{
6696 		  map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
6697 
6698 		  /* iehdr->e_phnum is just an estimate of the number
6699 		     of program headers that we will need.  Make a note
6700 		     here of the number we used and the segment we chose
6701 		     to hold these headers, so that we can adjust the
6702 		     offset when we know the correct value.  */
6703 		  phdr_adjust_num = iehdr->e_phnum;
6704 		  phdr_adjust_seg = map;
6705 		}
6706 	      else
6707 		map->includes_phdrs = FALSE;
6708 	    }
6709 	}
6710 
6711       /* Step Three: Loop over the sections again, this time assigning
6712 	 those that fit to the current segment and removing them from the
6713 	 sections array; but making sure not to leave large gaps.  Once all
6714 	 possible sections have been assigned to the current segment it is
6715 	 added to the list of built segments and if sections still remain
6716 	 to be assigned, a new segment is constructed before repeating
6717 	 the loop.  */
6718       isec = 0;
6719       do
6720 	{
6721 	  map->count = 0;
6722 	  suggested_lma = 0;
6723 	  first_suggested_lma = TRUE;
6724 
6725 	  /* Fill the current segment with sections that fit.  */
6726 	  for (j = 0; j < section_count; j++)
6727 	    {
6728 	      section = sections[j];
6729 
6730 	      if (section == NULL)
6731 		continue;
6732 
6733 	      output_section = section->output_section;
6734 
6735 	      BFD_ASSERT (output_section != NULL);
6736 
6737 	      if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
6738 		  || IS_COREFILE_NOTE (segment, section))
6739 		{
6740 		  if (map->count == 0)
6741 		    {
6742 		      /* If the first section in a segment does not start at
6743 			 the beginning of the segment, then something is
6744 			 wrong.  */
6745 		      if (output_section->lma
6746 			  != (map->p_paddr
6747 			      + (map->includes_filehdr ? iehdr->e_ehsize : 0)
6748 			      + (map->includes_phdrs
6749 				 ? iehdr->e_phnum * iehdr->e_phentsize
6750 				 : 0)))
6751 			abort ();
6752 		    }
6753 		  else
6754 		    {
6755 		      asection *prev_sec;
6756 
6757 		      prev_sec = map->sections[map->count - 1];
6758 
6759 		      /* If the gap between the end of the previous section
6760 			 and the start of this section is more than
6761 			 maxpagesize then we need to start a new segment.  */
6762 		      if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
6763 				      maxpagesize)
6764 			   < BFD_ALIGN (output_section->lma, maxpagesize))
6765 			  || (prev_sec->lma + prev_sec->size
6766 			      > output_section->lma))
6767 			{
6768 			  if (first_suggested_lma)
6769 			    {
6770 			      suggested_lma = output_section->lma;
6771 			      first_suggested_lma = FALSE;
6772 			    }
6773 
6774 			  continue;
6775 			}
6776 		    }
6777 
6778 		  map->sections[map->count++] = output_section;
6779 		  ++isec;
6780 		  sections[j] = NULL;
6781 		  section->segment_mark = TRUE;
6782 		}
6783 	      else if (first_suggested_lma)
6784 		{
6785 		  suggested_lma = output_section->lma;
6786 		  first_suggested_lma = FALSE;
6787 		}
6788 	    }
6789 
6790 	  BFD_ASSERT (map->count > 0);
6791 
6792 	  /* Add the current segment to the list of built segments.  */
6793 	  *pointer_to_map = map;
6794 	  pointer_to_map = &map->next;
6795 
6796 	  if (isec < section_count)
6797 	    {
6798 	      /* We still have not allocated all of the sections to
6799 		 segments.  Create a new segment here, initialise it
6800 		 and carry on looping.  */
6801 	      amt = sizeof (struct elf_segment_map);
6802 	      amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6803 	      map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6804 	      if (map == NULL)
6805 		{
6806 		  free (sections);
6807 		  return FALSE;
6808 		}
6809 
6810 	      /* Initialise the fields of the segment map.  Set the physical
6811 		 physical address to the LMA of the first section that has
6812 		 not yet been assigned.  */
6813 	      map->next = NULL;
6814 	      map->p_type = segment->p_type;
6815 	      map->p_flags = segment->p_flags;
6816 	      map->p_flags_valid = 1;
6817 	      map->p_paddr = suggested_lma;
6818 	      map->p_paddr_valid = p_paddr_valid;
6819 	      map->includes_filehdr = 0;
6820 	      map->includes_phdrs = 0;
6821 	    }
6822 	}
6823       while (isec < section_count);
6824 
6825       free (sections);
6826     }
6827 
6828   elf_seg_map (obfd) = map_first;
6829 
6830   /* If we had to estimate the number of program headers that were
6831      going to be needed, then check our estimate now and adjust
6832      the offset if necessary.  */
6833   if (phdr_adjust_seg != NULL)
6834     {
6835       unsigned int count;
6836 
6837       for (count = 0, map = map_first; map != NULL; map = map->next)
6838 	count++;
6839 
6840       if (count > phdr_adjust_num)
6841 	phdr_adjust_seg->p_paddr
6842 	  -= (count - phdr_adjust_num) * iehdr->e_phentsize;
6843     }
6844 
6845 #undef SEGMENT_END
6846 #undef SECTION_SIZE
6847 #undef IS_CONTAINED_BY_VMA
6848 #undef IS_CONTAINED_BY_LMA
6849 #undef IS_NOTE
6850 #undef IS_COREFILE_NOTE
6851 #undef IS_SOLARIS_PT_INTERP
6852 #undef IS_SECTION_IN_INPUT_SEGMENT
6853 #undef INCLUDE_SECTION_IN_SEGMENT
6854 #undef SEGMENT_AFTER_SEGMENT
6855 #undef SEGMENT_OVERLAPS
6856   return TRUE;
6857 }
6858 
6859 /* Copy ELF program header information.  */
6860 
6861 static bfd_boolean
copy_elf_program_header(bfd * ibfd,bfd * obfd)6862 copy_elf_program_header (bfd *ibfd, bfd *obfd)
6863 {
6864   Elf_Internal_Ehdr *iehdr;
6865   struct elf_segment_map *map;
6866   struct elf_segment_map *map_first;
6867   struct elf_segment_map **pointer_to_map;
6868   Elf_Internal_Phdr *segment;
6869   unsigned int i;
6870   unsigned int num_segments;
6871   bfd_boolean phdr_included = FALSE;
6872   bfd_boolean p_paddr_valid;
6873 
6874   iehdr = elf_elfheader (ibfd);
6875 
6876   map_first = NULL;
6877   pointer_to_map = &map_first;
6878 
6879   /* If all the segment p_paddr fields are zero, don't set
6880      map->p_paddr_valid.  */
6881   p_paddr_valid = FALSE;
6882   num_segments = elf_elfheader (ibfd)->e_phnum;
6883   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6884        i < num_segments;
6885        i++, segment++)
6886     if (segment->p_paddr != 0)
6887       {
6888 	p_paddr_valid = TRUE;
6889 	break;
6890       }
6891 
6892   for (i = 0, segment = elf_tdata (ibfd)->phdr;
6893        i < num_segments;
6894        i++, segment++)
6895     {
6896       asection *section;
6897       unsigned int section_count;
6898       bfd_size_type amt;
6899       Elf_Internal_Shdr *this_hdr;
6900       asection *first_section = NULL;
6901       asection *lowest_section;
6902 
6903       /* Compute how many sections are in this segment.  */
6904       for (section = ibfd->sections, section_count = 0;
6905 	   section != NULL;
6906 	   section = section->next)
6907 	{
6908 	  this_hdr = &(elf_section_data(section)->this_hdr);
6909 	  if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6910 	    {
6911 	      if (first_section == NULL)
6912 		first_section = section;
6913 	      section_count++;
6914 	    }
6915 	}
6916 
6917       /* Allocate a segment map big enough to contain
6918 	 all of the sections we have selected.  */
6919       amt = sizeof (struct elf_segment_map);
6920       if (section_count != 0)
6921 	amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6922       map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6923       if (map == NULL)
6924 	return FALSE;
6925 
6926       /* Initialize the fields of the output segment map with the
6927 	 input segment.  */
6928       map->next = NULL;
6929       map->p_type = segment->p_type;
6930       map->p_flags = segment->p_flags;
6931       map->p_flags_valid = 1;
6932       map->p_paddr = segment->p_paddr;
6933       map->p_paddr_valid = p_paddr_valid;
6934       map->p_align = segment->p_align;
6935       map->p_align_valid = 1;
6936       map->p_vaddr_offset = 0;
6937 
6938       if (map->p_type == PT_GNU_RELRO
6939 	  || map->p_type == PT_GNU_STACK)
6940 	{
6941 	  /* The PT_GNU_RELRO segment may contain the first a few
6942 	     bytes in the .got.plt section even if the whole .got.plt
6943 	     section isn't in the PT_GNU_RELRO segment.  We won't
6944 	     change the size of the PT_GNU_RELRO segment.
6945 	     Similarly, PT_GNU_STACK size is significant on uclinux
6946 	     systems.    */
6947 	  map->p_size = segment->p_memsz;
6948 	  map->p_size_valid = 1;
6949 	}
6950 
6951       /* Determine if this segment contains the ELF file header
6952 	 and if it contains the program headers themselves.  */
6953       map->includes_filehdr = (segment->p_offset == 0
6954 			       && segment->p_filesz >= iehdr->e_ehsize);
6955 
6956       map->includes_phdrs = 0;
6957       if (! phdr_included || segment->p_type != PT_LOAD)
6958 	{
6959 	  map->includes_phdrs =
6960 	    (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6961 	     && (segment->p_offset + segment->p_filesz
6962 		 >= ((bfd_vma) iehdr->e_phoff
6963 		     + iehdr->e_phnum * iehdr->e_phentsize)));
6964 
6965 	  if (segment->p_type == PT_LOAD && map->includes_phdrs)
6966 	    phdr_included = TRUE;
6967 	}
6968 
6969       lowest_section = NULL;
6970       if (section_count != 0)
6971 	{
6972 	  unsigned int isec = 0;
6973 
6974 	  for (section = first_section;
6975 	       section != NULL;
6976 	       section = section->next)
6977 	    {
6978 	      this_hdr = &(elf_section_data(section)->this_hdr);
6979 	      if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6980 		{
6981 		  map->sections[isec++] = section->output_section;
6982 		  if ((section->flags & SEC_ALLOC) != 0)
6983 		    {
6984 		      bfd_vma seg_off;
6985 
6986 		      if (lowest_section == NULL
6987 			  || section->lma < lowest_section->lma)
6988 			lowest_section = section;
6989 
6990 		      /* Section lmas are set up from PT_LOAD header
6991 			 p_paddr in _bfd_elf_make_section_from_shdr.
6992 			 If this header has a p_paddr that disagrees
6993 			 with the section lma, flag the p_paddr as
6994 			 invalid.  */
6995 		      if ((section->flags & SEC_LOAD) != 0)
6996 			seg_off = this_hdr->sh_offset - segment->p_offset;
6997 		      else
6998 			seg_off = this_hdr->sh_addr - segment->p_vaddr;
6999 		      if (section->lma - segment->p_paddr != seg_off)
7000 			map->p_paddr_valid = FALSE;
7001 		    }
7002 		  if (isec == section_count)
7003 		    break;
7004 		}
7005 	    }
7006 	}
7007 
7008       if (map->includes_filehdr && lowest_section != NULL)
7009 	/* We need to keep the space used by the headers fixed.  */
7010 	map->header_size = lowest_section->vma - segment->p_vaddr;
7011 
7012       if (!map->includes_phdrs
7013 	  && !map->includes_filehdr
7014 	  && map->p_paddr_valid)
7015 	/* There is some other padding before the first section.  */
7016 	map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
7017 			       - segment->p_paddr);
7018 
7019       map->count = section_count;
7020       *pointer_to_map = map;
7021       pointer_to_map = &map->next;
7022     }
7023 
7024   elf_seg_map (obfd) = map_first;
7025   return TRUE;
7026 }
7027 
7028 /* Copy private BFD data.  This copies or rewrites ELF program header
7029    information.  */
7030 
7031 static bfd_boolean
copy_private_bfd_data(bfd * ibfd,bfd * obfd)7032 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
7033 {
7034   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7035       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7036     return TRUE;
7037 
7038   if (elf_tdata (ibfd)->phdr == NULL)
7039     return TRUE;
7040 
7041   if (ibfd->xvec == obfd->xvec)
7042     {
7043       /* Check to see if any sections in the input BFD
7044 	 covered by ELF program header have changed.  */
7045       Elf_Internal_Phdr *segment;
7046       asection *section, *osec;
7047       unsigned int i, num_segments;
7048       Elf_Internal_Shdr *this_hdr;
7049       const struct elf_backend_data *bed;
7050 
7051       bed = get_elf_backend_data (ibfd);
7052 
7053       /* Regenerate the segment map if p_paddr is set to 0.  */
7054       if (bed->want_p_paddr_set_to_zero)
7055 	goto rewrite;
7056 
7057       /* Initialize the segment mark field.  */
7058       for (section = obfd->sections; section != NULL;
7059 	   section = section->next)
7060 	section->segment_mark = FALSE;
7061 
7062       num_segments = elf_elfheader (ibfd)->e_phnum;
7063       for (i = 0, segment = elf_tdata (ibfd)->phdr;
7064 	   i < num_segments;
7065 	   i++, segment++)
7066 	{
7067 	  /* PR binutils/3535.  The Solaris linker always sets the p_paddr
7068 	     and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7069 	     which severly confuses things, so always regenerate the segment
7070 	     map in this case.  */
7071 	  if (segment->p_paddr == 0
7072 	      && segment->p_memsz == 0
7073 	      && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
7074 	    goto rewrite;
7075 
7076 	  for (section = ibfd->sections;
7077 	       section != NULL; section = section->next)
7078 	    {
7079 	      /* We mark the output section so that we know it comes
7080 		 from the input BFD.  */
7081 	      osec = section->output_section;
7082 	      if (osec)
7083 		osec->segment_mark = TRUE;
7084 
7085 	      /* Check if this section is covered by the segment.  */
7086 	      this_hdr = &(elf_section_data(section)->this_hdr);
7087 	      if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
7088 		{
7089 		  /* FIXME: Check if its output section is changed or
7090 		     removed.  What else do we need to check?  */
7091 		  if (osec == NULL
7092 		      || section->flags != osec->flags
7093 		      || section->lma != osec->lma
7094 		      || section->vma != osec->vma
7095 		      || section->size != osec->size
7096 		      || section->rawsize != osec->rawsize
7097 		      || section->alignment_power != osec->alignment_power)
7098 		    goto rewrite;
7099 		}
7100 	    }
7101 	}
7102 
7103       /* Check to see if any output section do not come from the
7104 	 input BFD.  */
7105       for (section = obfd->sections; section != NULL;
7106 	   section = section->next)
7107 	{
7108 	  if (section->segment_mark == FALSE)
7109 	    goto rewrite;
7110 	  else
7111 	    section->segment_mark = FALSE;
7112 	}
7113 
7114       return copy_elf_program_header (ibfd, obfd);
7115     }
7116 
7117 rewrite:
7118   if (ibfd->xvec == obfd->xvec)
7119     {
7120       /* When rewriting program header, set the output maxpagesize to
7121 	 the maximum alignment of input PT_LOAD segments.  */
7122       Elf_Internal_Phdr *segment;
7123       unsigned int i;
7124       unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
7125       bfd_vma maxpagesize = 0;
7126 
7127       for (i = 0, segment = elf_tdata (ibfd)->phdr;
7128 	   i < num_segments;
7129 	   i++, segment++)
7130 	if (segment->p_type == PT_LOAD
7131 	    && maxpagesize < segment->p_align)
7132 	  {
7133 	    /* PR 17512: file: f17299af.  */
7134 	    if (segment->p_align > (bfd_vma) 1 << ((sizeof (bfd_vma) * 8) - 2))
7135 	      (*_bfd_error_handler) (_("\
7136 %B: warning: segment alignment of 0x%llx is too large"),
7137 				     ibfd, (long long) segment->p_align);
7138 	    else
7139 	      maxpagesize = segment->p_align;
7140 	  }
7141 
7142       if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
7143 	bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
7144     }
7145 
7146   return rewrite_elf_program_header (ibfd, obfd);
7147 }
7148 
7149 /* Initialize private output section information from input section.  */
7150 
7151 bfd_boolean
_bfd_elf_init_private_section_data(bfd * ibfd,asection * isec,bfd * obfd,asection * osec,struct bfd_link_info * link_info)7152 _bfd_elf_init_private_section_data (bfd *ibfd,
7153 				    asection *isec,
7154 				    bfd *obfd,
7155 				    asection *osec,
7156 				    struct bfd_link_info *link_info)
7157 
7158 {
7159   Elf_Internal_Shdr *ihdr, *ohdr;
7160   bfd_boolean final_link = (link_info != NULL
7161 			    && !bfd_link_relocatable (link_info));
7162 
7163   if (ibfd->xvec->flavour != bfd_target_elf_flavour
7164       || obfd->xvec->flavour != bfd_target_elf_flavour)
7165     return TRUE;
7166 
7167   BFD_ASSERT (elf_section_data (osec) != NULL);
7168 
7169   /* For objcopy and relocatable link, don't copy the output ELF
7170      section type from input if the output BFD section flags have been
7171      set to something different.  For a final link allow some flags
7172      that the linker clears to differ.  */
7173   if (elf_section_type (osec) == SHT_NULL
7174       && (osec->flags == isec->flags
7175 	  || (final_link
7176 	      && ((osec->flags ^ isec->flags)
7177 		  & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
7178     elf_section_type (osec) = elf_section_type (isec);
7179 
7180   /* FIXME: Is this correct for all OS/PROC specific flags?  */
7181   elf_section_flags (osec) |= (elf_section_flags (isec)
7182 			       & (SHF_MASKOS | SHF_MASKPROC));
7183 
7184   /* Set things up for objcopy and relocatable link.  The output
7185      SHT_GROUP section will have its elf_next_in_group pointing back
7186      to the input group members.  Ignore linker created group section.
7187      See elfNN_ia64_object_p in elfxx-ia64.c.  */
7188   if (!final_link)
7189     {
7190       if (elf_sec_group (isec) == NULL
7191 	  || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
7192 	{
7193 	  if (elf_section_flags (isec) & SHF_GROUP)
7194 	    elf_section_flags (osec) |= SHF_GROUP;
7195 	  elf_next_in_group (osec) = elf_next_in_group (isec);
7196 	  elf_section_data (osec)->group = elf_section_data (isec)->group;
7197 	}
7198 
7199       /* If not decompress, preserve SHF_COMPRESSED.  */
7200       if ((ibfd->flags & BFD_DECOMPRESS) == 0)
7201 	elf_section_flags (osec) |= (elf_section_flags (isec)
7202 				     & SHF_COMPRESSED);
7203     }
7204 
7205   ihdr = &elf_section_data (isec)->this_hdr;
7206 
7207   /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7208      don't use the output section of the linked-to section since it
7209      may be NULL at this point.  */
7210   if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
7211     {
7212       ohdr = &elf_section_data (osec)->this_hdr;
7213       ohdr->sh_flags |= SHF_LINK_ORDER;
7214       elf_linked_to_section (osec) = elf_linked_to_section (isec);
7215     }
7216 
7217   osec->use_rela_p = isec->use_rela_p;
7218 
7219   return TRUE;
7220 }
7221 
7222 /* Copy private section information.  This copies over the entsize
7223    field, and sometimes the info field.  */
7224 
7225 bfd_boolean
_bfd_elf_copy_private_section_data(bfd * ibfd,asection * isec,bfd * obfd,asection * osec)7226 _bfd_elf_copy_private_section_data (bfd *ibfd,
7227 				    asection *isec,
7228 				    bfd *obfd,
7229 				    asection *osec)
7230 {
7231   Elf_Internal_Shdr *ihdr, *ohdr;
7232 
7233   if (ibfd->xvec->flavour != bfd_target_elf_flavour
7234       || obfd->xvec->flavour != bfd_target_elf_flavour)
7235     return TRUE;
7236 
7237   ihdr = &elf_section_data (isec)->this_hdr;
7238   ohdr = &elf_section_data (osec)->this_hdr;
7239 
7240   ohdr->sh_entsize = ihdr->sh_entsize;
7241 
7242   if (ihdr->sh_type == SHT_SYMTAB
7243       || ihdr->sh_type == SHT_DYNSYM
7244       || ihdr->sh_type == SHT_GNU_verneed
7245       || ihdr->sh_type == SHT_GNU_verdef)
7246     ohdr->sh_info = ihdr->sh_info;
7247 
7248   return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
7249 					     NULL);
7250 }
7251 
7252 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7253    necessary if we are removing either the SHT_GROUP section or any of
7254    the group member sections.  DISCARDED is the value that a section's
7255    output_section has if the section will be discarded, NULL when this
7256    function is called from objcopy, bfd_abs_section_ptr when called
7257    from the linker.  */
7258 
7259 bfd_boolean
_bfd_elf_fixup_group_sections(bfd * ibfd,asection * discarded)7260 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
7261 {
7262   asection *isec;
7263 
7264   for (isec = ibfd->sections; isec != NULL; isec = isec->next)
7265     if (elf_section_type (isec) == SHT_GROUP)
7266       {
7267 	asection *first = elf_next_in_group (isec);
7268 	asection *s = first;
7269 	bfd_size_type removed = 0;
7270 
7271 	while (s != NULL)
7272 	  {
7273 	    /* If this member section is being output but the
7274 	       SHT_GROUP section is not, then clear the group info
7275 	       set up by _bfd_elf_copy_private_section_data.  */
7276 	    if (s->output_section != discarded
7277 		&& isec->output_section == discarded)
7278 	      {
7279 		elf_section_flags (s->output_section) &= ~SHF_GROUP;
7280 		elf_group_name (s->output_section) = NULL;
7281 	      }
7282 	    /* Conversely, if the member section is not being output
7283 	       but the SHT_GROUP section is, then adjust its size.  */
7284 	    else if (s->output_section == discarded
7285 		     && isec->output_section != discarded)
7286 	      removed += 4;
7287 	    s = elf_next_in_group (s);
7288 	    if (s == first)
7289 	      break;
7290 	  }
7291 	if (removed != 0)
7292 	  {
7293 	    if (discarded != NULL)
7294 	      {
7295 		/* If we've been called for ld -r, then we need to
7296 		   adjust the input section size.  This function may
7297 		   be called multiple times, so save the original
7298 		   size.  */
7299 		if (isec->rawsize == 0)
7300 		  isec->rawsize = isec->size;
7301 		isec->size = isec->rawsize - removed;
7302 	      }
7303 	    else
7304 	      {
7305 		/* Adjust the output section size when called from
7306 		   objcopy. */
7307 		isec->output_section->size -= removed;
7308 	      }
7309 	  }
7310       }
7311 
7312   return TRUE;
7313 }
7314 
7315 /* Copy private header information.  */
7316 
7317 bfd_boolean
_bfd_elf_copy_private_header_data(bfd * ibfd,bfd * obfd)7318 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
7319 {
7320   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7321       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7322     return TRUE;
7323 
7324   /* Copy over private BFD data if it has not already been copied.
7325      This must be done here, rather than in the copy_private_bfd_data
7326      entry point, because the latter is called after the section
7327      contents have been set, which means that the program headers have
7328      already been worked out.  */
7329   if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
7330     {
7331       if (! copy_private_bfd_data (ibfd, obfd))
7332 	return FALSE;
7333     }
7334 
7335   return _bfd_elf_fixup_group_sections (ibfd, NULL);
7336 }
7337 
7338 /* Copy private symbol information.  If this symbol is in a section
7339    which we did not map into a BFD section, try to map the section
7340    index correctly.  We use special macro definitions for the mapped
7341    section indices; these definitions are interpreted by the
7342    swap_out_syms function.  */
7343 
7344 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7345 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7346 #define MAP_STRTAB    (SHN_HIOS + 3)
7347 #define MAP_SHSTRTAB  (SHN_HIOS + 4)
7348 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7349 
7350 bfd_boolean
_bfd_elf_copy_private_symbol_data(bfd * ibfd,asymbol * isymarg,bfd * obfd,asymbol * osymarg)7351 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
7352 				   asymbol *isymarg,
7353 				   bfd *obfd,
7354 				   asymbol *osymarg)
7355 {
7356   elf_symbol_type *isym, *osym;
7357 
7358   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
7359       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
7360     return TRUE;
7361 
7362   isym = elf_symbol_from (ibfd, isymarg);
7363   osym = elf_symbol_from (obfd, osymarg);
7364 
7365   if (isym != NULL
7366       && isym->internal_elf_sym.st_shndx != 0
7367       && osym != NULL
7368       && bfd_is_abs_section (isym->symbol.section))
7369     {
7370       unsigned int shndx;
7371 
7372       shndx = isym->internal_elf_sym.st_shndx;
7373       if (shndx == elf_onesymtab (ibfd))
7374 	shndx = MAP_ONESYMTAB;
7375       else if (shndx == elf_dynsymtab (ibfd))
7376 	shndx = MAP_DYNSYMTAB;
7377       else if (shndx == elf_strtab_sec (ibfd))
7378 	shndx = MAP_STRTAB;
7379       else if (shndx == elf_shstrtab_sec (ibfd))
7380 	shndx = MAP_SHSTRTAB;
7381       else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd)))
7382 	shndx = MAP_SYM_SHNDX;
7383       osym->internal_elf_sym.st_shndx = shndx;
7384     }
7385 
7386   return TRUE;
7387 }
7388 
7389 /* Swap out the symbols.  */
7390 
7391 static bfd_boolean
swap_out_syms(bfd * abfd,struct elf_strtab_hash ** sttp,int relocatable_p)7392 swap_out_syms (bfd *abfd,
7393 	       struct elf_strtab_hash **sttp,
7394 	       int relocatable_p)
7395 {
7396   const struct elf_backend_data *bed;
7397   int symcount;
7398   asymbol **syms;
7399   struct elf_strtab_hash *stt;
7400   Elf_Internal_Shdr *symtab_hdr;
7401   Elf_Internal_Shdr *symtab_shndx_hdr;
7402   Elf_Internal_Shdr *symstrtab_hdr;
7403   struct elf_sym_strtab *symstrtab;
7404   bfd_byte *outbound_syms;
7405   bfd_byte *outbound_shndx;
7406   unsigned long outbound_syms_index;
7407   unsigned long outbound_shndx_index;
7408   int idx;
7409   unsigned int num_locals;
7410   bfd_size_type amt;
7411   bfd_boolean name_local_sections;
7412 
7413   if (!elf_map_symbols (abfd, &num_locals))
7414     return FALSE;
7415 
7416   /* Dump out the symtabs.  */
7417   stt = _bfd_elf_strtab_init ();
7418   if (stt == NULL)
7419     return FALSE;
7420 
7421   bed = get_elf_backend_data (abfd);
7422   symcount = bfd_get_symcount (abfd);
7423   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
7424   symtab_hdr->sh_type = SHT_SYMTAB;
7425   symtab_hdr->sh_entsize = bed->s->sizeof_sym;
7426   symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
7427   symtab_hdr->sh_info = num_locals + 1;
7428   symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
7429 
7430   symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
7431   symstrtab_hdr->sh_type = SHT_STRTAB;
7432 
7433   /* Allocate buffer to swap out the .strtab section.  */
7434   symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1)
7435 						    * sizeof (*symstrtab));
7436   if (symstrtab == NULL)
7437     {
7438       _bfd_elf_strtab_free (stt);
7439       return FALSE;
7440     }
7441 
7442   outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
7443                                            bed->s->sizeof_sym);
7444   if (outbound_syms == NULL)
7445     {
7446 error_return:
7447       _bfd_elf_strtab_free (stt);
7448       free (symstrtab);
7449       return FALSE;
7450     }
7451   symtab_hdr->contents = outbound_syms;
7452   outbound_syms_index = 0;
7453 
7454   outbound_shndx = NULL;
7455   outbound_shndx_index = 0;
7456 
7457   if (elf_symtab_shndx_list (abfd))
7458     {
7459       symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
7460       if (symtab_shndx_hdr->sh_name != 0)
7461 	{
7462 	  amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
7463 	  outbound_shndx =  (bfd_byte *)
7464 	    bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
7465 	  if (outbound_shndx == NULL)
7466 	    goto error_return;
7467 
7468 	  symtab_shndx_hdr->contents = outbound_shndx;
7469 	  symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
7470 	  symtab_shndx_hdr->sh_size = amt;
7471 	  symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
7472 	  symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
7473 	}
7474       /* FIXME: What about any other headers in the list ?  */
7475     }
7476 
7477   /* Now generate the data (for "contents").  */
7478   {
7479     /* Fill in zeroth symbol and swap it out.  */
7480     Elf_Internal_Sym sym;
7481     sym.st_name = 0;
7482     sym.st_value = 0;
7483     sym.st_size = 0;
7484     sym.st_info = 0;
7485     sym.st_other = 0;
7486     sym.st_shndx = SHN_UNDEF;
7487     sym.st_target_internal = 0;
7488     symstrtab[0].sym = sym;
7489     symstrtab[0].dest_index = outbound_syms_index;
7490     symstrtab[0].destshndx_index = outbound_shndx_index;
7491     outbound_syms_index++;
7492     if (outbound_shndx != NULL)
7493       outbound_shndx_index++;
7494   }
7495 
7496   name_local_sections
7497     = (bed->elf_backend_name_local_section_symbols
7498        && bed->elf_backend_name_local_section_symbols (abfd));
7499 
7500   syms = bfd_get_outsymbols (abfd);
7501   for (idx = 0; idx < symcount;)
7502     {
7503       Elf_Internal_Sym sym;
7504       bfd_vma value = syms[idx]->value;
7505       elf_symbol_type *type_ptr;
7506       flagword flags = syms[idx]->flags;
7507       int type;
7508 
7509       if (!name_local_sections
7510 	  && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
7511 	{
7512 	  /* Local section symbols have no name.  */
7513 	  sym.st_name = (unsigned long) -1;
7514 	}
7515       else
7516 	{
7517 	  /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7518 	     to get the final offset for st_name.  */
7519 	  sym.st_name
7520 	    = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name,
7521 						   FALSE);
7522 	  if (sym.st_name == (unsigned long) -1)
7523 	    goto error_return;
7524 	}
7525 
7526       type_ptr = elf_symbol_from (abfd, syms[idx]);
7527 
7528       if ((flags & BSF_SECTION_SYM) == 0
7529 	  && bfd_is_com_section (syms[idx]->section))
7530 	{
7531 	  /* ELF common symbols put the alignment into the `value' field,
7532 	     and the size into the `size' field.  This is backwards from
7533 	     how BFD handles it, so reverse it here.  */
7534 	  sym.st_size = value;
7535 	  if (type_ptr == NULL
7536 	      || type_ptr->internal_elf_sym.st_value == 0)
7537 	    sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
7538 	  else
7539 	    sym.st_value = type_ptr->internal_elf_sym.st_value;
7540 	  sym.st_shndx = _bfd_elf_section_from_bfd_section
7541 	    (abfd, syms[idx]->section);
7542 	}
7543       else
7544 	{
7545 	  asection *sec = syms[idx]->section;
7546 	  unsigned int shndx;
7547 
7548 	  if (sec->output_section)
7549 	    {
7550 	      value += sec->output_offset;
7551 	      sec = sec->output_section;
7552 	    }
7553 
7554 	  /* Don't add in the section vma for relocatable output.  */
7555 	  if (! relocatable_p)
7556 	    value += sec->vma;
7557 	  sym.st_value = value;
7558 	  sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
7559 
7560 	  if (bfd_is_abs_section (sec)
7561 	      && type_ptr != NULL
7562 	      && type_ptr->internal_elf_sym.st_shndx != 0)
7563 	    {
7564 	      /* This symbol is in a real ELF section which we did
7565 		 not create as a BFD section.  Undo the mapping done
7566 		 by copy_private_symbol_data.  */
7567 	      shndx = type_ptr->internal_elf_sym.st_shndx;
7568 	      switch (shndx)
7569 		{
7570 		case MAP_ONESYMTAB:
7571 		  shndx = elf_onesymtab (abfd);
7572 		  break;
7573 		case MAP_DYNSYMTAB:
7574 		  shndx = elf_dynsymtab (abfd);
7575 		  break;
7576 		case MAP_STRTAB:
7577 		  shndx = elf_strtab_sec (abfd);
7578 		  break;
7579 		case MAP_SHSTRTAB:
7580 		  shndx = elf_shstrtab_sec (abfd);
7581 		  break;
7582 		case MAP_SYM_SHNDX:
7583 		  if (elf_symtab_shndx_list (abfd))
7584 		    shndx = elf_symtab_shndx_list (abfd)->ndx;
7585 		  break;
7586 		default:
7587 		  shndx = SHN_ABS;
7588 		  break;
7589 		}
7590 	    }
7591 	  else
7592 	    {
7593 	      shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
7594 
7595 	      if (shndx == SHN_BAD)
7596 		{
7597 		  asection *sec2;
7598 
7599 		  /* Writing this would be a hell of a lot easier if
7600 		     we had some decent documentation on bfd, and
7601 		     knew what to expect of the library, and what to
7602 		     demand of applications.  For example, it
7603 		     appears that `objcopy' might not set the
7604 		     section of a symbol to be a section that is
7605 		     actually in the output file.  */
7606 		  sec2 = bfd_get_section_by_name (abfd, sec->name);
7607 		  if (sec2 == NULL)
7608 		    {
7609 		      _bfd_error_handler (_("\
7610 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7611 					  syms[idx]->name ? syms[idx]->name : "<Local sym>",
7612 					  sec->name);
7613 		      bfd_set_error (bfd_error_invalid_operation);
7614 		      goto error_return;
7615 		    }
7616 
7617 		  shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
7618 		  BFD_ASSERT (shndx != SHN_BAD);
7619 		}
7620 	    }
7621 
7622 	  sym.st_shndx = shndx;
7623 	}
7624 
7625       if ((flags & BSF_THREAD_LOCAL) != 0)
7626 	type = STT_TLS;
7627       else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
7628 	type = STT_GNU_IFUNC;
7629       else if ((flags & BSF_FUNCTION) != 0)
7630 	type = STT_FUNC;
7631       else if ((flags & BSF_OBJECT) != 0)
7632 	type = STT_OBJECT;
7633       else if ((flags & BSF_RELC) != 0)
7634 	type = STT_RELC;
7635       else if ((flags & BSF_SRELC) != 0)
7636 	type = STT_SRELC;
7637       else
7638 	type = STT_NOTYPE;
7639 
7640       if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
7641 	type = STT_TLS;
7642 
7643       /* Processor-specific types.  */
7644       if (type_ptr != NULL
7645 	  && bed->elf_backend_get_symbol_type)
7646 	type = ((*bed->elf_backend_get_symbol_type)
7647 		(&type_ptr->internal_elf_sym, type));
7648 
7649       if (flags & BSF_SECTION_SYM)
7650 	{
7651 	  if (flags & BSF_GLOBAL)
7652 	    sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
7653 	  else
7654 	    sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
7655 	}
7656       else if (bfd_is_com_section (syms[idx]->section))
7657 	{
7658 	  if (type != STT_TLS)
7659 	    {
7660 	      if ((abfd->flags & BFD_CONVERT_ELF_COMMON))
7661 		type = ((abfd->flags & BFD_USE_ELF_STT_COMMON)
7662 			? STT_COMMON : STT_OBJECT);
7663 	      else
7664 		type = ((flags & BSF_ELF_COMMON) != 0
7665 			? STT_COMMON : STT_OBJECT);
7666 	    }
7667 	  sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
7668 	}
7669       else if (bfd_is_und_section (syms[idx]->section))
7670 	sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
7671 				    ? STB_WEAK
7672 				    : STB_GLOBAL),
7673 				   type);
7674       else if (flags & BSF_FILE)
7675 	sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
7676       else
7677 	{
7678 	  int bind = STB_LOCAL;
7679 
7680 	  if (flags & BSF_LOCAL)
7681 	    bind = STB_LOCAL;
7682 	  else if (flags & BSF_GNU_UNIQUE)
7683 	    bind = STB_GNU_UNIQUE;
7684 	  else if (flags & BSF_WEAK)
7685 	    bind = STB_WEAK;
7686 	  else if (flags & BSF_GLOBAL)
7687 	    bind = STB_GLOBAL;
7688 
7689 	  sym.st_info = ELF_ST_INFO (bind, type);
7690 	}
7691 
7692       if (type_ptr != NULL)
7693 	{
7694 	  sym.st_other = type_ptr->internal_elf_sym.st_other;
7695 	  sym.st_target_internal
7696 	    = type_ptr->internal_elf_sym.st_target_internal;
7697 	}
7698       else
7699 	{
7700 	  sym.st_other = 0;
7701 	  sym.st_target_internal = 0;
7702 	}
7703 
7704       idx++;
7705       symstrtab[idx].sym = sym;
7706       symstrtab[idx].dest_index = outbound_syms_index;
7707       symstrtab[idx].destshndx_index = outbound_shndx_index;
7708 
7709       outbound_syms_index++;
7710       if (outbound_shndx != NULL)
7711 	outbound_shndx_index++;
7712     }
7713 
7714   /* Finalize the .strtab section.  */
7715   _bfd_elf_strtab_finalize (stt);
7716 
7717   /* Swap out the .strtab section.  */
7718   for (idx = 0; idx <= symcount; idx++)
7719     {
7720       struct elf_sym_strtab *elfsym = &symstrtab[idx];
7721       if (elfsym->sym.st_name == (unsigned long) -1)
7722 	elfsym->sym.st_name = 0;
7723       else
7724 	elfsym->sym.st_name = _bfd_elf_strtab_offset (stt,
7725 						      elfsym->sym.st_name);
7726       bed->s->swap_symbol_out (abfd, &elfsym->sym,
7727 			       (outbound_syms
7728 				+ (elfsym->dest_index
7729 				   * bed->s->sizeof_sym)),
7730 			       (outbound_shndx
7731 				+ (elfsym->destshndx_index
7732 				   * sizeof (Elf_External_Sym_Shndx))));
7733     }
7734   free (symstrtab);
7735 
7736   *sttp = stt;
7737   symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt);
7738   symstrtab_hdr->sh_type = SHT_STRTAB;
7739   symstrtab_hdr->sh_flags = bed->elf_strtab_flags;
7740   symstrtab_hdr->sh_addr = 0;
7741   symstrtab_hdr->sh_entsize = 0;
7742   symstrtab_hdr->sh_link = 0;
7743   symstrtab_hdr->sh_info = 0;
7744   symstrtab_hdr->sh_addralign = 1;
7745 
7746   return TRUE;
7747 }
7748 
7749 /* Return the number of bytes required to hold the symtab vector.
7750 
7751    Note that we base it on the count plus 1, since we will null terminate
7752    the vector allocated based on this size.  However, the ELF symbol table
7753    always has a dummy entry as symbol #0, so it ends up even.  */
7754 
7755 long
_bfd_elf_get_symtab_upper_bound(bfd * abfd)7756 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
7757 {
7758   long symcount;
7759   long symtab_size;
7760   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
7761 
7762   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
7763   symtab_size = (symcount + 1) * (sizeof (asymbol *));
7764   if (symcount > 0)
7765     symtab_size -= sizeof (asymbol *);
7766 
7767   return symtab_size;
7768 }
7769 
7770 long
_bfd_elf_get_dynamic_symtab_upper_bound(bfd * abfd)7771 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
7772 {
7773   long symcount;
7774   long symtab_size;
7775   Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
7776 
7777   if (elf_dynsymtab (abfd) == 0)
7778     {
7779       bfd_set_error (bfd_error_invalid_operation);
7780       return -1;
7781     }
7782 
7783   symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
7784   symtab_size = (symcount + 1) * (sizeof (asymbol *));
7785   if (symcount > 0)
7786     symtab_size -= sizeof (asymbol *);
7787 
7788   return symtab_size;
7789 }
7790 
7791 long
_bfd_elf_get_reloc_upper_bound(bfd * abfd ATTRIBUTE_UNUSED,sec_ptr asect)7792 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
7793 				sec_ptr asect)
7794 {
7795   return (asect->reloc_count + 1) * sizeof (arelent *);
7796 }
7797 
7798 /* Canonicalize the relocs.  */
7799 
7800 long
_bfd_elf_canonicalize_reloc(bfd * abfd,sec_ptr section,arelent ** relptr,asymbol ** symbols)7801 _bfd_elf_canonicalize_reloc (bfd *abfd,
7802 			     sec_ptr section,
7803 			     arelent **relptr,
7804 			     asymbol **symbols)
7805 {
7806   arelent *tblptr;
7807   unsigned int i;
7808   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7809 
7810   if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
7811     return -1;
7812 
7813   tblptr = section->relocation;
7814   for (i = 0; i < section->reloc_count; i++)
7815     *relptr++ = tblptr++;
7816 
7817   *relptr = NULL;
7818 
7819   return section->reloc_count;
7820 }
7821 
7822 long
_bfd_elf_canonicalize_symtab(bfd * abfd,asymbol ** allocation)7823 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
7824 {
7825   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7826   long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
7827 
7828   if (symcount >= 0)
7829     bfd_get_symcount (abfd) = symcount;
7830   return symcount;
7831 }
7832 
7833 long
_bfd_elf_canonicalize_dynamic_symtab(bfd * abfd,asymbol ** allocation)7834 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
7835 				      asymbol **allocation)
7836 {
7837   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7838   long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
7839 
7840   if (symcount >= 0)
7841     bfd_get_dynamic_symcount (abfd) = symcount;
7842   return symcount;
7843 }
7844 
7845 /* Return the size required for the dynamic reloc entries.  Any loadable
7846    section that was actually installed in the BFD, and has type SHT_REL
7847    or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7848    dynamic reloc section.  */
7849 
7850 long
_bfd_elf_get_dynamic_reloc_upper_bound(bfd * abfd)7851 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
7852 {
7853   long ret;
7854   asection *s;
7855 
7856   if (elf_dynsymtab (abfd) == 0)
7857     {
7858       bfd_set_error (bfd_error_invalid_operation);
7859       return -1;
7860     }
7861 
7862   ret = sizeof (arelent *);
7863   for (s = abfd->sections; s != NULL; s = s->next)
7864     if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7865 	&& (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7866 	    || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7867       ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
7868 	      * sizeof (arelent *));
7869 
7870   return ret;
7871 }
7872 
7873 /* Canonicalize the dynamic relocation entries.  Note that we return the
7874    dynamic relocations as a single block, although they are actually
7875    associated with particular sections; the interface, which was
7876    designed for SunOS style shared libraries, expects that there is only
7877    one set of dynamic relocs.  Any loadable section that was actually
7878    installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7879    dynamic symbol table, is considered to be a dynamic reloc section.  */
7880 
7881 long
_bfd_elf_canonicalize_dynamic_reloc(bfd * abfd,arelent ** storage,asymbol ** syms)7882 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
7883 				     arelent **storage,
7884 				     asymbol **syms)
7885 {
7886   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
7887   asection *s;
7888   long ret;
7889 
7890   if (elf_dynsymtab (abfd) == 0)
7891     {
7892       bfd_set_error (bfd_error_invalid_operation);
7893       return -1;
7894     }
7895 
7896   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
7897   ret = 0;
7898   for (s = abfd->sections; s != NULL; s = s->next)
7899     {
7900       if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
7901 	  && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7902 	      || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7903 	{
7904 	  arelent *p;
7905 	  long count, i;
7906 
7907 	  if (! (*slurp_relocs) (abfd, s, syms, TRUE))
7908 	    return -1;
7909 	  count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
7910 	  p = s->relocation;
7911 	  for (i = 0; i < count; i++)
7912 	    *storage++ = p++;
7913 	  ret += count;
7914 	}
7915     }
7916 
7917   *storage = NULL;
7918 
7919   return ret;
7920 }
7921 
7922 /* Read in the version information.  */
7923 
7924 bfd_boolean
_bfd_elf_slurp_version_tables(bfd * abfd,bfd_boolean default_imported_symver)7925 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
7926 {
7927   bfd_byte *contents = NULL;
7928   unsigned int freeidx = 0;
7929 
7930   if (elf_dynverref (abfd) != 0)
7931     {
7932       Elf_Internal_Shdr *hdr;
7933       Elf_External_Verneed *everneed;
7934       Elf_Internal_Verneed *iverneed;
7935       unsigned int i;
7936       bfd_byte *contents_end;
7937 
7938       hdr = &elf_tdata (abfd)->dynverref_hdr;
7939 
7940       if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verneed))
7941 	{
7942 error_return_bad_verref:
7943 	  (*_bfd_error_handler)
7944 	    (_("%B: .gnu.version_r invalid entry"), abfd);
7945 	  bfd_set_error (bfd_error_bad_value);
7946 error_return_verref:
7947 	  elf_tdata (abfd)->verref = NULL;
7948 	  elf_tdata (abfd)->cverrefs = 0;
7949 	  goto error_return;
7950 	}
7951 
7952       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7953       if (contents == NULL)
7954 	goto error_return_verref;
7955 
7956       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7957 	  || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7958 	goto error_return_verref;
7959 
7960       elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
7961 	bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
7962 
7963       if (elf_tdata (abfd)->verref == NULL)
7964 	goto error_return_verref;
7965 
7966       BFD_ASSERT (sizeof (Elf_External_Verneed)
7967 		  == sizeof (Elf_External_Vernaux));
7968       contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
7969       everneed = (Elf_External_Verneed *) contents;
7970       iverneed = elf_tdata (abfd)->verref;
7971       for (i = 0; i < hdr->sh_info; i++, iverneed++)
7972 	{
7973 	  Elf_External_Vernaux *evernaux;
7974 	  Elf_Internal_Vernaux *ivernaux;
7975 	  unsigned int j;
7976 
7977 	  _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7978 
7979 	  iverneed->vn_bfd = abfd;
7980 
7981 	  iverneed->vn_filename =
7982 	    bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7983 					     iverneed->vn_file);
7984 	  if (iverneed->vn_filename == NULL)
7985 	    goto error_return_bad_verref;
7986 
7987 	  if (iverneed->vn_cnt == 0)
7988 	    iverneed->vn_auxptr = NULL;
7989 	  else
7990 	    {
7991 	      iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7992                   bfd_alloc2 (abfd, iverneed->vn_cnt,
7993                               sizeof (Elf_Internal_Vernaux));
7994 	      if (iverneed->vn_auxptr == NULL)
7995 		goto error_return_verref;
7996 	    }
7997 
7998 	  if (iverneed->vn_aux
7999 	      > (size_t) (contents_end - (bfd_byte *) everneed))
8000 	    goto error_return_bad_verref;
8001 
8002 	  evernaux = ((Elf_External_Vernaux *)
8003 		      ((bfd_byte *) everneed + iverneed->vn_aux));
8004 	  ivernaux = iverneed->vn_auxptr;
8005 	  for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
8006 	    {
8007 	      _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
8008 
8009 	      ivernaux->vna_nodename =
8010 		bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8011 						 ivernaux->vna_name);
8012 	      if (ivernaux->vna_nodename == NULL)
8013 		goto error_return_bad_verref;
8014 
8015 	      if (ivernaux->vna_other > freeidx)
8016 		freeidx = ivernaux->vna_other;
8017 
8018 	      ivernaux->vna_nextptr = NULL;
8019 	      if (ivernaux->vna_next == 0)
8020 		{
8021 		  iverneed->vn_cnt = j + 1;
8022 		  break;
8023 		}
8024 	      if (j + 1 < iverneed->vn_cnt)
8025 		ivernaux->vna_nextptr = ivernaux + 1;
8026 
8027 	      if (ivernaux->vna_next
8028 		  > (size_t) (contents_end - (bfd_byte *) evernaux))
8029 		goto error_return_bad_verref;
8030 
8031 	      evernaux = ((Elf_External_Vernaux *)
8032 			  ((bfd_byte *) evernaux + ivernaux->vna_next));
8033 	    }
8034 
8035 	  iverneed->vn_nextref = NULL;
8036 	  if (iverneed->vn_next == 0)
8037 	    break;
8038 	  if (i + 1 < hdr->sh_info)
8039 	    iverneed->vn_nextref = iverneed + 1;
8040 
8041 	  if (iverneed->vn_next
8042 	      > (size_t) (contents_end - (bfd_byte *) everneed))
8043 	    goto error_return_bad_verref;
8044 
8045 	  everneed = ((Elf_External_Verneed *)
8046 		      ((bfd_byte *) everneed + iverneed->vn_next));
8047 	}
8048       elf_tdata (abfd)->cverrefs = i;
8049 
8050       free (contents);
8051       contents = NULL;
8052     }
8053 
8054   if (elf_dynverdef (abfd) != 0)
8055     {
8056       Elf_Internal_Shdr *hdr;
8057       Elf_External_Verdef *everdef;
8058       Elf_Internal_Verdef *iverdef;
8059       Elf_Internal_Verdef *iverdefarr;
8060       Elf_Internal_Verdef iverdefmem;
8061       unsigned int i;
8062       unsigned int maxidx;
8063       bfd_byte *contents_end_def, *contents_end_aux;
8064 
8065       hdr = &elf_tdata (abfd)->dynverdef_hdr;
8066 
8067       if (hdr->sh_info == 0 || hdr->sh_size < sizeof (Elf_External_Verdef))
8068 	{
8069 	error_return_bad_verdef:
8070 	  (*_bfd_error_handler)
8071 	    (_("%B: .gnu.version_d invalid entry"), abfd);
8072 	  bfd_set_error (bfd_error_bad_value);
8073 	error_return_verdef:
8074 	  elf_tdata (abfd)->verdef = NULL;
8075 	  elf_tdata (abfd)->cverdefs = 0;
8076 	  goto error_return;
8077 	}
8078 
8079       contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
8080       if (contents == NULL)
8081 	goto error_return_verdef;
8082       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
8083 	  || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
8084 	goto error_return_verdef;
8085 
8086       BFD_ASSERT (sizeof (Elf_External_Verdef)
8087 		  >= sizeof (Elf_External_Verdaux));
8088       contents_end_def = contents + hdr->sh_size
8089 			 - sizeof (Elf_External_Verdef);
8090       contents_end_aux = contents + hdr->sh_size
8091 			 - sizeof (Elf_External_Verdaux);
8092 
8093       /* We know the number of entries in the section but not the maximum
8094 	 index.  Therefore we have to run through all entries and find
8095 	 the maximum.  */
8096       everdef = (Elf_External_Verdef *) contents;
8097       maxidx = 0;
8098       for (i = 0; i < hdr->sh_info; ++i)
8099 	{
8100 	  _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8101 
8102 	  if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) == 0)
8103 	    goto error_return_bad_verdef;
8104 	  if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
8105 	    maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
8106 
8107 	  if (iverdefmem.vd_next == 0)
8108 	    break;
8109 
8110 	  if (iverdefmem.vd_next
8111 	      > (size_t) (contents_end_def - (bfd_byte *) everdef))
8112 	    goto error_return_bad_verdef;
8113 
8114 	  everdef = ((Elf_External_Verdef *)
8115 		     ((bfd_byte *) everdef + iverdefmem.vd_next));
8116 	}
8117 
8118       if (default_imported_symver)
8119 	{
8120 	  if (freeidx > maxidx)
8121 	    maxidx = ++freeidx;
8122 	  else
8123 	    freeidx = ++maxidx;
8124 	}
8125 
8126       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8127 	bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
8128       if (elf_tdata (abfd)->verdef == NULL)
8129 	goto error_return_verdef;
8130 
8131       elf_tdata (abfd)->cverdefs = maxidx;
8132 
8133       everdef = (Elf_External_Verdef *) contents;
8134       iverdefarr = elf_tdata (abfd)->verdef;
8135       for (i = 0; i < hdr->sh_info; i++)
8136 	{
8137 	  Elf_External_Verdaux *everdaux;
8138 	  Elf_Internal_Verdaux *iverdaux;
8139 	  unsigned int j;
8140 
8141 	  _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
8142 
8143 	  if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
8144 	    goto error_return_bad_verdef;
8145 
8146 	  iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
8147 	  memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd));
8148 
8149 	  iverdef->vd_bfd = abfd;
8150 
8151 	  if (iverdef->vd_cnt == 0)
8152 	    iverdef->vd_auxptr = NULL;
8153 	  else
8154 	    {
8155 	      iverdef->vd_auxptr = (struct elf_internal_verdaux *)
8156                   bfd_alloc2 (abfd, iverdef->vd_cnt,
8157                               sizeof (Elf_Internal_Verdaux));
8158 	      if (iverdef->vd_auxptr == NULL)
8159 		goto error_return_verdef;
8160 	    }
8161 
8162 	  if (iverdef->vd_aux
8163 	      > (size_t) (contents_end_aux - (bfd_byte *) everdef))
8164 	    goto error_return_bad_verdef;
8165 
8166 	  everdaux = ((Elf_External_Verdaux *)
8167 		      ((bfd_byte *) everdef + iverdef->vd_aux));
8168 	  iverdaux = iverdef->vd_auxptr;
8169 	  for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
8170 	    {
8171 	      _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
8172 
8173 	      iverdaux->vda_nodename =
8174 		bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
8175 						 iverdaux->vda_name);
8176 	      if (iverdaux->vda_nodename == NULL)
8177 		goto error_return_bad_verdef;
8178 
8179 	      iverdaux->vda_nextptr = NULL;
8180 	      if (iverdaux->vda_next == 0)
8181 		{
8182 		  iverdef->vd_cnt = j + 1;
8183 		  break;
8184 		}
8185 	      if (j + 1 < iverdef->vd_cnt)
8186 		iverdaux->vda_nextptr = iverdaux + 1;
8187 
8188 	      if (iverdaux->vda_next
8189 		  > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
8190 		goto error_return_bad_verdef;
8191 
8192 	      everdaux = ((Elf_External_Verdaux *)
8193 			  ((bfd_byte *) everdaux + iverdaux->vda_next));
8194 	    }
8195 
8196 	  iverdef->vd_nodename = NULL;
8197 	  if (iverdef->vd_cnt)
8198 	    iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
8199 
8200 	  iverdef->vd_nextdef = NULL;
8201 	  if (iverdef->vd_next == 0)
8202 	    break;
8203 	  if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
8204 	    iverdef->vd_nextdef = iverdef + 1;
8205 
8206 	  everdef = ((Elf_External_Verdef *)
8207 		     ((bfd_byte *) everdef + iverdef->vd_next));
8208 	}
8209 
8210       free (contents);
8211       contents = NULL;
8212     }
8213   else if (default_imported_symver)
8214     {
8215       if (freeidx < 3)
8216 	freeidx = 3;
8217       else
8218 	freeidx++;
8219 
8220       elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
8221           bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
8222       if (elf_tdata (abfd)->verdef == NULL)
8223 	goto error_return;
8224 
8225       elf_tdata (abfd)->cverdefs = freeidx;
8226     }
8227 
8228   /* Create a default version based on the soname.  */
8229   if (default_imported_symver)
8230     {
8231       Elf_Internal_Verdef *iverdef;
8232       Elf_Internal_Verdaux *iverdaux;
8233 
8234       iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
8235 
8236       iverdef->vd_version = VER_DEF_CURRENT;
8237       iverdef->vd_flags = 0;
8238       iverdef->vd_ndx = freeidx;
8239       iverdef->vd_cnt = 1;
8240 
8241       iverdef->vd_bfd = abfd;
8242 
8243       iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
8244       if (iverdef->vd_nodename == NULL)
8245 	goto error_return_verdef;
8246       iverdef->vd_nextdef = NULL;
8247       iverdef->vd_auxptr = ((struct elf_internal_verdaux *)
8248 			    bfd_zalloc (abfd, sizeof (Elf_Internal_Verdaux)));
8249       if (iverdef->vd_auxptr == NULL)
8250 	goto error_return_verdef;
8251 
8252       iverdaux = iverdef->vd_auxptr;
8253       iverdaux->vda_nodename = iverdef->vd_nodename;
8254     }
8255 
8256   return TRUE;
8257 
8258  error_return:
8259   if (contents != NULL)
8260     free (contents);
8261   return FALSE;
8262 }
8263 
8264 asymbol *
_bfd_elf_make_empty_symbol(bfd * abfd)8265 _bfd_elf_make_empty_symbol (bfd *abfd)
8266 {
8267   elf_symbol_type *newsym;
8268 
8269   newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof * newsym);
8270   if (!newsym)
8271     return NULL;
8272   newsym->symbol.the_bfd = abfd;
8273   return &newsym->symbol;
8274 }
8275 
8276 void
_bfd_elf_get_symbol_info(bfd * abfd ATTRIBUTE_UNUSED,asymbol * symbol,symbol_info * ret)8277 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
8278 			  asymbol *symbol,
8279 			  symbol_info *ret)
8280 {
8281   bfd_symbol_info (symbol, ret);
8282 }
8283 
8284 /* Return whether a symbol name implies a local symbol.  Most targets
8285    use this function for the is_local_label_name entry point, but some
8286    override it.  */
8287 
8288 bfd_boolean
_bfd_elf_is_local_label_name(bfd * abfd ATTRIBUTE_UNUSED,const char * name)8289 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
8290 			      const char *name)
8291 {
8292   /* Normal local symbols start with ``.L''.  */
8293   if (name[0] == '.' && name[1] == 'L')
8294     return TRUE;
8295 
8296   /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8297      DWARF debugging symbols starting with ``..''.  */
8298   if (name[0] == '.' && name[1] == '.')
8299     return TRUE;
8300 
8301   /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8302      emitting DWARF debugging output.  I suspect this is actually a
8303      small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8304      ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8305      underscore to be emitted on some ELF targets).  For ease of use,
8306      we treat such symbols as local.  */
8307   if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
8308     return TRUE;
8309 
8310   /* Treat assembler generated fake symbols, dollar local labels and
8311      forward-backward labels (aka local labels) as locals.
8312      These labels have the form:
8313 
8314        L0^A.*                                  (fake symbols)
8315 
8316        [.]?L[0123456789]+{^A|^B}[0123456789]*  (local labels)
8317 
8318      Versions which start with .L will have already been matched above,
8319      so we only need to match the rest.  */
8320   if (name[0] == 'L' && ISDIGIT (name[1]))
8321     {
8322       bfd_boolean ret = FALSE;
8323       const char * p;
8324       char c;
8325 
8326       for (p = name + 2; (c = *p); p++)
8327 	{
8328 	  if (c == 1 || c == 2)
8329 	    {
8330 	      if (c == 1 && p == name + 2)
8331 		/* A fake symbol.  */
8332 		return TRUE;
8333 
8334 	      /* FIXME: We are being paranoid here and treating symbols like
8335 		 L0^Bfoo as if there were non-local, on the grounds that the
8336 		 assembler will never generate them.  But can any symbol
8337 		 containing an ASCII value in the range 1-31 ever be anything
8338 		 other than some kind of local ?  */
8339 	      ret = TRUE;
8340 	    }
8341 
8342 	  if (! ISDIGIT (c))
8343 	    {
8344 	      ret = FALSE;
8345 	      break;
8346 	    }
8347 	}
8348       return ret;
8349     }
8350 
8351   return FALSE;
8352 }
8353 
8354 alent *
_bfd_elf_get_lineno(bfd * abfd ATTRIBUTE_UNUSED,asymbol * symbol ATTRIBUTE_UNUSED)8355 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
8356 		     asymbol *symbol ATTRIBUTE_UNUSED)
8357 {
8358   abort ();
8359   return NULL;
8360 }
8361 
8362 bfd_boolean
_bfd_elf_set_arch_mach(bfd * abfd,enum bfd_architecture arch,unsigned long machine)8363 _bfd_elf_set_arch_mach (bfd *abfd,
8364 			enum bfd_architecture arch,
8365 			unsigned long machine)
8366 {
8367   /* If this isn't the right architecture for this backend, and this
8368      isn't the generic backend, fail.  */
8369   if (arch != get_elf_backend_data (abfd)->arch
8370       && arch != bfd_arch_unknown
8371       && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
8372     return FALSE;
8373 
8374   return bfd_default_set_arch_mach (abfd, arch, machine);
8375 }
8376 
8377 /* Find the nearest line to a particular section and offset,
8378    for error reporting.  */
8379 
8380 bfd_boolean
_bfd_elf_find_nearest_line(bfd * abfd,asymbol ** symbols,asection * section,bfd_vma offset,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * line_ptr,unsigned int * discriminator_ptr)8381 _bfd_elf_find_nearest_line (bfd *abfd,
8382 			    asymbol **symbols,
8383 			    asection *section,
8384 			    bfd_vma offset,
8385 			    const char **filename_ptr,
8386 			    const char **functionname_ptr,
8387 			    unsigned int *line_ptr,
8388 			    unsigned int *discriminator_ptr)
8389 {
8390   bfd_boolean found;
8391 
8392   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
8393 				     filename_ptr, functionname_ptr,
8394 				     line_ptr, discriminator_ptr,
8395 				     dwarf_debug_sections, 0,
8396 				     &elf_tdata (abfd)->dwarf2_find_line_info)
8397       || _bfd_dwarf1_find_nearest_line (abfd, symbols, section, offset,
8398 					filename_ptr, functionname_ptr,
8399 					line_ptr))
8400     {
8401       if (!*functionname_ptr)
8402 	_bfd_elf_find_function (abfd, symbols, section, offset,
8403 				*filename_ptr ? NULL : filename_ptr,
8404 				functionname_ptr);
8405       return TRUE;
8406     }
8407 
8408   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
8409 					     &found, filename_ptr,
8410 					     functionname_ptr, line_ptr,
8411 					     &elf_tdata (abfd)->line_info))
8412     return FALSE;
8413   if (found && (*functionname_ptr || *line_ptr))
8414     return TRUE;
8415 
8416   if (symbols == NULL)
8417     return FALSE;
8418 
8419   if (! _bfd_elf_find_function (abfd, symbols, section, offset,
8420 				filename_ptr, functionname_ptr))
8421     return FALSE;
8422 
8423   *line_ptr = 0;
8424   return TRUE;
8425 }
8426 
8427 /* Find the line for a symbol.  */
8428 
8429 bfd_boolean
_bfd_elf_find_line(bfd * abfd,asymbol ** symbols,asymbol * symbol,const char ** filename_ptr,unsigned int * line_ptr)8430 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
8431 		    const char **filename_ptr, unsigned int *line_ptr)
8432 {
8433   return _bfd_dwarf2_find_nearest_line (abfd, symbols, symbol, NULL, 0,
8434 					filename_ptr, NULL, line_ptr, NULL,
8435 					dwarf_debug_sections, 0,
8436 					&elf_tdata (abfd)->dwarf2_find_line_info);
8437 }
8438 
8439 /* After a call to bfd_find_nearest_line, successive calls to
8440    bfd_find_inliner_info can be used to get source information about
8441    each level of function inlining that terminated at the address
8442    passed to bfd_find_nearest_line.  Currently this is only supported
8443    for DWARF2 with appropriate DWARF3 extensions. */
8444 
8445 bfd_boolean
_bfd_elf_find_inliner_info(bfd * abfd,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * line_ptr)8446 _bfd_elf_find_inliner_info (bfd *abfd,
8447 			    const char **filename_ptr,
8448 			    const char **functionname_ptr,
8449 			    unsigned int *line_ptr)
8450 {
8451   bfd_boolean found;
8452   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
8453 					 functionname_ptr, line_ptr,
8454 					 & elf_tdata (abfd)->dwarf2_find_line_info);
8455   return found;
8456 }
8457 
8458 int
_bfd_elf_sizeof_headers(bfd * abfd,struct bfd_link_info * info)8459 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
8460 {
8461   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8462   int ret = bed->s->sizeof_ehdr;
8463 
8464   if (!bfd_link_relocatable (info))
8465     {
8466       bfd_size_type phdr_size = elf_program_header_size (abfd);
8467 
8468       if (phdr_size == (bfd_size_type) -1)
8469 	{
8470 	  struct elf_segment_map *m;
8471 
8472 	  phdr_size = 0;
8473 	  for (m = elf_seg_map (abfd); m != NULL; m = m->next)
8474 	    phdr_size += bed->s->sizeof_phdr;
8475 
8476 	  if (phdr_size == 0)
8477 	    phdr_size = get_program_header_size (abfd, info);
8478 	}
8479 
8480       elf_program_header_size (abfd) = phdr_size;
8481       ret += phdr_size;
8482     }
8483 
8484   return ret;
8485 }
8486 
8487 bfd_boolean
_bfd_elf_set_section_contents(bfd * abfd,sec_ptr section,const void * location,file_ptr offset,bfd_size_type count)8488 _bfd_elf_set_section_contents (bfd *abfd,
8489 			       sec_ptr section,
8490 			       const void *location,
8491 			       file_ptr offset,
8492 			       bfd_size_type count)
8493 {
8494   Elf_Internal_Shdr *hdr;
8495   file_ptr pos;
8496 
8497   if (! abfd->output_has_begun
8498       && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
8499     return FALSE;
8500 
8501   if (!count)
8502     return TRUE;
8503 
8504   hdr = &elf_section_data (section)->this_hdr;
8505   if (hdr->sh_offset == (file_ptr) -1)
8506     {
8507       /* We must compress this section.  Write output to the buffer.  */
8508       unsigned char *contents = hdr->contents;
8509       if ((offset + count) > hdr->sh_size
8510 	  || (section->flags & SEC_ELF_COMPRESS) == 0
8511 	  || contents == NULL)
8512 	abort ();
8513       memcpy (contents + offset, location, count);
8514       return TRUE;
8515     }
8516   pos = hdr->sh_offset + offset;
8517   if (bfd_seek (abfd, pos, SEEK_SET) != 0
8518       || bfd_bwrite (location, count, abfd) != count)
8519     return FALSE;
8520 
8521   return TRUE;
8522 }
8523 
8524 void
_bfd_elf_no_info_to_howto(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr ATTRIBUTE_UNUSED,Elf_Internal_Rela * dst ATTRIBUTE_UNUSED)8525 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
8526 			   arelent *cache_ptr ATTRIBUTE_UNUSED,
8527 			   Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
8528 {
8529   abort ();
8530 }
8531 
8532 /* Try to convert a non-ELF reloc into an ELF one.  */
8533 
8534 bfd_boolean
_bfd_elf_validate_reloc(bfd * abfd,arelent * areloc)8535 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
8536 {
8537   /* Check whether we really have an ELF howto.  */
8538 
8539   if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
8540     {
8541       bfd_reloc_code_real_type code;
8542       reloc_howto_type *howto;
8543 
8544       /* Alien reloc: Try to determine its type to replace it with an
8545 	 equivalent ELF reloc.  */
8546 
8547       if (areloc->howto->pc_relative)
8548 	{
8549 	  switch (areloc->howto->bitsize)
8550 	    {
8551 	    case 8:
8552 	      code = BFD_RELOC_8_PCREL;
8553 	      break;
8554 	    case 12:
8555 	      code = BFD_RELOC_12_PCREL;
8556 	      break;
8557 	    case 16:
8558 	      code = BFD_RELOC_16_PCREL;
8559 	      break;
8560 	    case 24:
8561 	      code = BFD_RELOC_24_PCREL;
8562 	      break;
8563 	    case 32:
8564 	      code = BFD_RELOC_32_PCREL;
8565 	      break;
8566 	    case 64:
8567 	      code = BFD_RELOC_64_PCREL;
8568 	      break;
8569 	    default:
8570 	      goto fail;
8571 	    }
8572 
8573 	  howto = bfd_reloc_type_lookup (abfd, code);
8574 
8575 	  if (areloc->howto->pcrel_offset != howto->pcrel_offset)
8576 	    {
8577 	      if (howto->pcrel_offset)
8578 		areloc->addend += areloc->address;
8579 	      else
8580 		areloc->addend -= areloc->address; /* addend is unsigned!! */
8581 	    }
8582 	}
8583       else
8584 	{
8585 	  switch (areloc->howto->bitsize)
8586 	    {
8587 	    case 8:
8588 	      code = BFD_RELOC_8;
8589 	      break;
8590 	    case 14:
8591 	      code = BFD_RELOC_14;
8592 	      break;
8593 	    case 16:
8594 	      code = BFD_RELOC_16;
8595 	      break;
8596 	    case 26:
8597 	      code = BFD_RELOC_26;
8598 	      break;
8599 	    case 32:
8600 	      code = BFD_RELOC_32;
8601 	      break;
8602 	    case 64:
8603 	      code = BFD_RELOC_64;
8604 	      break;
8605 	    default:
8606 	      goto fail;
8607 	    }
8608 
8609 	  howto = bfd_reloc_type_lookup (abfd, code);
8610 	}
8611 
8612       if (howto)
8613 	areloc->howto = howto;
8614       else
8615 	goto fail;
8616     }
8617 
8618   return TRUE;
8619 
8620  fail:
8621   (*_bfd_error_handler)
8622     (_("%B: unsupported relocation type %s"),
8623      abfd, areloc->howto->name);
8624   bfd_set_error (bfd_error_bad_value);
8625   return FALSE;
8626 }
8627 
8628 bfd_boolean
_bfd_elf_close_and_cleanup(bfd * abfd)8629 _bfd_elf_close_and_cleanup (bfd *abfd)
8630 {
8631   struct elf_obj_tdata *tdata = elf_tdata (abfd);
8632   if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
8633     {
8634       if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
8635 	_bfd_elf_strtab_free (elf_shstrtab (abfd));
8636       _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
8637     }
8638 
8639   return _bfd_generic_close_and_cleanup (abfd);
8640 }
8641 
8642 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8643    in the relocation's offset.  Thus we cannot allow any sort of sanity
8644    range-checking to interfere.  There is nothing else to do in processing
8645    this reloc.  */
8646 
8647 bfd_reloc_status_type
_bfd_elf_rel_vtable_reloc_fn(bfd * abfd ATTRIBUTE_UNUSED,arelent * re ATTRIBUTE_UNUSED,struct bfd_symbol * symbol ATTRIBUTE_UNUSED,void * data ATTRIBUTE_UNUSED,asection * is ATTRIBUTE_UNUSED,bfd * obfd ATTRIBUTE_UNUSED,char ** errmsg ATTRIBUTE_UNUSED)8648 _bfd_elf_rel_vtable_reloc_fn
8649   (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
8650    struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
8651    void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
8652    bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
8653 {
8654   return bfd_reloc_ok;
8655 }
8656 
8657 /* Elf core file support.  Much of this only works on native
8658    toolchains, since we rely on knowing the
8659    machine-dependent procfs structure in order to pick
8660    out details about the corefile.  */
8661 
8662 #ifdef HAVE_SYS_PROCFS_H
8663 /* Needed for new procfs interface on sparc-solaris.  */
8664 # define _STRUCTURED_PROC 1
8665 # include <sys/procfs.h>
8666 #endif
8667 
8668 /* Return a PID that identifies a "thread" for threaded cores, or the
8669    PID of the main process for non-threaded cores.  */
8670 
8671 static int
elfcore_make_pid(bfd * abfd)8672 elfcore_make_pid (bfd *abfd)
8673 {
8674   int pid;
8675 
8676   pid = elf_tdata (abfd)->core->lwpid;
8677   if (pid == 0)
8678     pid = elf_tdata (abfd)->core->pid;
8679 
8680   return pid;
8681 }
8682 
8683 /* If there isn't a section called NAME, make one, using
8684    data from SECT.  Note, this function will generate a
8685    reference to NAME, so you shouldn't deallocate or
8686    overwrite it.  */
8687 
8688 static bfd_boolean
elfcore_maybe_make_sect(bfd * abfd,char * name,asection * sect)8689 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
8690 {
8691   asection *sect2;
8692 
8693   if (bfd_get_section_by_name (abfd, name) != NULL)
8694     return TRUE;
8695 
8696   sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
8697   if (sect2 == NULL)
8698     return FALSE;
8699 
8700   sect2->size = sect->size;
8701   sect2->filepos = sect->filepos;
8702   sect2->alignment_power = sect->alignment_power;
8703   return TRUE;
8704 }
8705 
8706 /* Create a pseudosection containing SIZE bytes at FILEPOS.  This
8707    actually creates up to two pseudosections:
8708    - For the single-threaded case, a section named NAME, unless
8709      such a section already exists.
8710    - For the multi-threaded case, a section named "NAME/PID", where
8711      PID is elfcore_make_pid (abfd).
8712    Both pseudosections have identical contents. */
8713 bfd_boolean
_bfd_elfcore_make_pseudosection(bfd * abfd,char * name,size_t size,ufile_ptr filepos)8714 _bfd_elfcore_make_pseudosection (bfd *abfd,
8715 				 char *name,
8716 				 size_t size,
8717 				 ufile_ptr filepos)
8718 {
8719   char buf[100];
8720   char *threaded_name;
8721   size_t len;
8722   asection *sect;
8723 
8724   /* Build the section name.  */
8725 
8726   sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
8727   len = strlen (buf) + 1;
8728   threaded_name = (char *) bfd_alloc (abfd, len);
8729   if (threaded_name == NULL)
8730     return FALSE;
8731   memcpy (threaded_name, buf, len);
8732 
8733   sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
8734 					     SEC_HAS_CONTENTS);
8735   if (sect == NULL)
8736     return FALSE;
8737   sect->size = size;
8738   sect->filepos = filepos;
8739   sect->alignment_power = 2;
8740 
8741   return elfcore_maybe_make_sect (abfd, name, sect);
8742 }
8743 
8744 /* prstatus_t exists on:
8745      solaris 2.5+
8746      linux 2.[01] + glibc
8747      unixware 4.2
8748 */
8749 
8750 #if defined (HAVE_PRSTATUS_T)
8751 
8752 static bfd_boolean
elfcore_grok_prstatus(bfd * abfd,Elf_Internal_Note * note)8753 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
8754 {
8755   size_t size;
8756   int offset;
8757 
8758   if (note->descsz == sizeof (prstatus_t))
8759     {
8760       prstatus_t prstat;
8761 
8762       size = sizeof (prstat.pr_reg);
8763       offset   = offsetof (prstatus_t, pr_reg);
8764       memcpy (&prstat, note->descdata, sizeof (prstat));
8765 
8766       /* Do not overwrite the core signal if it
8767 	 has already been set by another thread.  */
8768       if (elf_tdata (abfd)->core->signal == 0)
8769 	elf_tdata (abfd)->core->signal = prstat.pr_cursig;
8770       if (elf_tdata (abfd)->core->pid == 0)
8771 	elf_tdata (abfd)->core->pid = prstat.pr_pid;
8772 
8773       /* pr_who exists on:
8774 	 solaris 2.5+
8775 	 unixware 4.2
8776 	 pr_who doesn't exist on:
8777 	 linux 2.[01]
8778 	 */
8779 #if defined (HAVE_PRSTATUS_T_PR_WHO)
8780       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
8781 #else
8782       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
8783 #endif
8784     }
8785 #if defined (HAVE_PRSTATUS32_T)
8786   else if (note->descsz == sizeof (prstatus32_t))
8787     {
8788       /* 64-bit host, 32-bit corefile */
8789       prstatus32_t prstat;
8790 
8791       size = sizeof (prstat.pr_reg);
8792       offset   = offsetof (prstatus32_t, pr_reg);
8793       memcpy (&prstat, note->descdata, sizeof (prstat));
8794 
8795       /* Do not overwrite the core signal if it
8796 	 has already been set by another thread.  */
8797       if (elf_tdata (abfd)->core->signal == 0)
8798 	elf_tdata (abfd)->core->signal = prstat.pr_cursig;
8799       if (elf_tdata (abfd)->core->pid == 0)
8800 	elf_tdata (abfd)->core->pid = prstat.pr_pid;
8801 
8802       /* pr_who exists on:
8803 	 solaris 2.5+
8804 	 unixware 4.2
8805 	 pr_who doesn't exist on:
8806 	 linux 2.[01]
8807 	 */
8808 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
8809       elf_tdata (abfd)->core->lwpid = prstat.pr_who;
8810 #else
8811       elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
8812 #endif
8813     }
8814 #endif /* HAVE_PRSTATUS32_T */
8815   else
8816     {
8817       /* Fail - we don't know how to handle any other
8818 	 note size (ie. data object type).  */
8819       return TRUE;
8820     }
8821 
8822   /* Make a ".reg/999" section and a ".reg" section.  */
8823   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
8824 					  size, note->descpos + offset);
8825 }
8826 #endif /* defined (HAVE_PRSTATUS_T) */
8827 
8828 /* Create a pseudosection containing the exact contents of NOTE.  */
8829 static bfd_boolean
elfcore_make_note_pseudosection(bfd * abfd,char * name,Elf_Internal_Note * note)8830 elfcore_make_note_pseudosection (bfd *abfd,
8831 				 char *name,
8832 				 Elf_Internal_Note *note)
8833 {
8834   return _bfd_elfcore_make_pseudosection (abfd, name,
8835 					  note->descsz, note->descpos);
8836 }
8837 
8838 /* There isn't a consistent prfpregset_t across platforms,
8839    but it doesn't matter, because we don't have to pick this
8840    data structure apart.  */
8841 
8842 static bfd_boolean
elfcore_grok_prfpreg(bfd * abfd,Elf_Internal_Note * note)8843 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
8844 {
8845   return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8846 }
8847 
8848 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
8849    type of NT_PRXFPREG.  Just include the whole note's contents
8850    literally.  */
8851 
8852 static bfd_boolean
elfcore_grok_prxfpreg(bfd * abfd,Elf_Internal_Note * note)8853 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
8854 {
8855   return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8856 }
8857 
8858 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8859    with a note type of NT_X86_XSTATE.  Just include the whole note's
8860    contents literally.  */
8861 
8862 static bfd_boolean
elfcore_grok_xstatereg(bfd * abfd,Elf_Internal_Note * note)8863 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
8864 {
8865   return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
8866 }
8867 
8868 static bfd_boolean
elfcore_grok_ppc_vmx(bfd * abfd,Elf_Internal_Note * note)8869 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
8870 {
8871   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
8872 }
8873 
8874 static bfd_boolean
elfcore_grok_ppc_vsx(bfd * abfd,Elf_Internal_Note * note)8875 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
8876 {
8877   return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
8878 }
8879 
8880 static bfd_boolean
elfcore_grok_s390_high_gprs(bfd * abfd,Elf_Internal_Note * note)8881 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
8882 {
8883   return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
8884 }
8885 
8886 static bfd_boolean
elfcore_grok_s390_timer(bfd * abfd,Elf_Internal_Note * note)8887 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
8888 {
8889   return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
8890 }
8891 
8892 static bfd_boolean
elfcore_grok_s390_todcmp(bfd * abfd,Elf_Internal_Note * note)8893 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
8894 {
8895   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
8896 }
8897 
8898 static bfd_boolean
elfcore_grok_s390_todpreg(bfd * abfd,Elf_Internal_Note * note)8899 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
8900 {
8901   return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
8902 }
8903 
8904 static bfd_boolean
elfcore_grok_s390_ctrs(bfd * abfd,Elf_Internal_Note * note)8905 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
8906 {
8907   return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
8908 }
8909 
8910 static bfd_boolean
elfcore_grok_s390_prefix(bfd * abfd,Elf_Internal_Note * note)8911 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
8912 {
8913   return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
8914 }
8915 
8916 static bfd_boolean
elfcore_grok_s390_last_break(bfd * abfd,Elf_Internal_Note * note)8917 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
8918 {
8919   return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
8920 }
8921 
8922 static bfd_boolean
elfcore_grok_s390_system_call(bfd * abfd,Elf_Internal_Note * note)8923 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
8924 {
8925   return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
8926 }
8927 
8928 static bfd_boolean
elfcore_grok_s390_tdb(bfd * abfd,Elf_Internal_Note * note)8929 elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
8930 {
8931   return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
8932 }
8933 
8934 static bfd_boolean
elfcore_grok_s390_vxrs_low(bfd * abfd,Elf_Internal_Note * note)8935 elfcore_grok_s390_vxrs_low (bfd *abfd, Elf_Internal_Note *note)
8936 {
8937   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-low", note);
8938 }
8939 
8940 static bfd_boolean
elfcore_grok_s390_vxrs_high(bfd * abfd,Elf_Internal_Note * note)8941 elfcore_grok_s390_vxrs_high (bfd *abfd, Elf_Internal_Note *note)
8942 {
8943   return elfcore_make_note_pseudosection (abfd, ".reg-s390-vxrs-high", note);
8944 }
8945 
8946 static bfd_boolean
elfcore_grok_arm_vfp(bfd * abfd,Elf_Internal_Note * note)8947 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
8948 {
8949   return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
8950 }
8951 
8952 static bfd_boolean
elfcore_grok_aarch_tls(bfd * abfd,Elf_Internal_Note * note)8953 elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
8954 {
8955   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
8956 }
8957 
8958 static bfd_boolean
elfcore_grok_aarch_hw_break(bfd * abfd,Elf_Internal_Note * note)8959 elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
8960 {
8961   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
8962 }
8963 
8964 static bfd_boolean
elfcore_grok_aarch_hw_watch(bfd * abfd,Elf_Internal_Note * note)8965 elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
8966 {
8967   return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
8968 }
8969 
8970 #if defined (HAVE_PRPSINFO_T)
8971 typedef prpsinfo_t   elfcore_psinfo_t;
8972 #if defined (HAVE_PRPSINFO32_T)		/* Sparc64 cross Sparc32 */
8973 typedef prpsinfo32_t elfcore_psinfo32_t;
8974 #endif
8975 #endif
8976 
8977 #if defined (HAVE_PSINFO_T)
8978 typedef psinfo_t   elfcore_psinfo_t;
8979 #if defined (HAVE_PSINFO32_T)		/* Sparc64 cross Sparc32 */
8980 typedef psinfo32_t elfcore_psinfo32_t;
8981 #endif
8982 #endif
8983 
8984 /* return a malloc'ed copy of a string at START which is at
8985    most MAX bytes long, possibly without a terminating '\0'.
8986    the copy will always have a terminating '\0'.  */
8987 
8988 char *
_bfd_elfcore_strndup(bfd * abfd,char * start,size_t max)8989 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
8990 {
8991   char *dups;
8992   char *end = (char *) memchr (start, '\0', max);
8993   size_t len;
8994 
8995   if (end == NULL)
8996     len = max;
8997   else
8998     len = end - start;
8999 
9000   dups = (char *) bfd_alloc (abfd, len + 1);
9001   if (dups == NULL)
9002     return NULL;
9003 
9004   memcpy (dups, start, len);
9005   dups[len] = '\0';
9006 
9007   return dups;
9008 }
9009 
9010 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9011 static bfd_boolean
elfcore_grok_psinfo(bfd * abfd,Elf_Internal_Note * note)9012 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
9013 {
9014   if (note->descsz == sizeof (elfcore_psinfo_t))
9015     {
9016       elfcore_psinfo_t psinfo;
9017 
9018       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9019 
9020 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9021       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9022 #endif
9023       elf_tdata (abfd)->core->program
9024 	= _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9025 				sizeof (psinfo.pr_fname));
9026 
9027       elf_tdata (abfd)->core->command
9028 	= _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9029 				sizeof (psinfo.pr_psargs));
9030     }
9031 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9032   else if (note->descsz == sizeof (elfcore_psinfo32_t))
9033     {
9034       /* 64-bit host, 32-bit corefile */
9035       elfcore_psinfo32_t psinfo;
9036 
9037       memcpy (&psinfo, note->descdata, sizeof (psinfo));
9038 
9039 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9040       elf_tdata (abfd)->core->pid = psinfo.pr_pid;
9041 #endif
9042       elf_tdata (abfd)->core->program
9043 	= _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
9044 				sizeof (psinfo.pr_fname));
9045 
9046       elf_tdata (abfd)->core->command
9047 	= _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
9048 				sizeof (psinfo.pr_psargs));
9049     }
9050 #endif
9051 
9052   else
9053     {
9054       /* Fail - we don't know how to handle any other
9055 	 note size (ie. data object type).  */
9056       return TRUE;
9057     }
9058 
9059   /* Note that for some reason, a spurious space is tacked
9060      onto the end of the args in some (at least one anyway)
9061      implementations, so strip it off if it exists.  */
9062 
9063   {
9064     char *command = elf_tdata (abfd)->core->command;
9065     int n = strlen (command);
9066 
9067     if (0 < n && command[n - 1] == ' ')
9068       command[n - 1] = '\0';
9069   }
9070 
9071   return TRUE;
9072 }
9073 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9074 
9075 #if defined (HAVE_PSTATUS_T)
9076 static bfd_boolean
elfcore_grok_pstatus(bfd * abfd,Elf_Internal_Note * note)9077 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
9078 {
9079   if (note->descsz == sizeof (pstatus_t)
9080 #if defined (HAVE_PXSTATUS_T)
9081       || note->descsz == sizeof (pxstatus_t)
9082 #endif
9083       )
9084     {
9085       pstatus_t pstat;
9086 
9087       memcpy (&pstat, note->descdata, sizeof (pstat));
9088 
9089       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9090     }
9091 #if defined (HAVE_PSTATUS32_T)
9092   else if (note->descsz == sizeof (pstatus32_t))
9093     {
9094       /* 64-bit host, 32-bit corefile */
9095       pstatus32_t pstat;
9096 
9097       memcpy (&pstat, note->descdata, sizeof (pstat));
9098 
9099       elf_tdata (abfd)->core->pid = pstat.pr_pid;
9100     }
9101 #endif
9102   /* Could grab some more details from the "representative"
9103      lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9104      NT_LWPSTATUS note, presumably.  */
9105 
9106   return TRUE;
9107 }
9108 #endif /* defined (HAVE_PSTATUS_T) */
9109 
9110 #if defined (HAVE_LWPSTATUS_T)
9111 static bfd_boolean
elfcore_grok_lwpstatus(bfd * abfd,Elf_Internal_Note * note)9112 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
9113 {
9114   lwpstatus_t lwpstat;
9115   char buf[100];
9116   char *name;
9117   size_t len;
9118   asection *sect;
9119 
9120   if (note->descsz != sizeof (lwpstat)
9121 #if defined (HAVE_LWPXSTATUS_T)
9122       && note->descsz != sizeof (lwpxstatus_t)
9123 #endif
9124       )
9125     return TRUE;
9126 
9127   memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
9128 
9129   elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
9130   /* Do not overwrite the core signal if it has already been set by
9131      another thread.  */
9132   if (elf_tdata (abfd)->core->signal == 0)
9133     elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
9134 
9135   /* Make a ".reg/999" section.  */
9136 
9137   sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
9138   len = strlen (buf) + 1;
9139   name = bfd_alloc (abfd, len);
9140   if (name == NULL)
9141     return FALSE;
9142   memcpy (name, buf, len);
9143 
9144   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9145   if (sect == NULL)
9146     return FALSE;
9147 
9148 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9149   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
9150   sect->filepos = note->descpos
9151     + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
9152 #endif
9153 
9154 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9155   sect->size = sizeof (lwpstat.pr_reg);
9156   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
9157 #endif
9158 
9159   sect->alignment_power = 2;
9160 
9161   if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
9162     return FALSE;
9163 
9164   /* Make a ".reg2/999" section */
9165 
9166   sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
9167   len = strlen (buf) + 1;
9168   name = bfd_alloc (abfd, len);
9169   if (name == NULL)
9170     return FALSE;
9171   memcpy (name, buf, len);
9172 
9173   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9174   if (sect == NULL)
9175     return FALSE;
9176 
9177 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9178   sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
9179   sect->filepos = note->descpos
9180     + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
9181 #endif
9182 
9183 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9184   sect->size = sizeof (lwpstat.pr_fpreg);
9185   sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
9186 #endif
9187 
9188   sect->alignment_power = 2;
9189 
9190   return elfcore_maybe_make_sect (abfd, ".reg2", sect);
9191 }
9192 #endif /* defined (HAVE_LWPSTATUS_T) */
9193 
9194 static bfd_boolean
elfcore_grok_win32pstatus(bfd * abfd,Elf_Internal_Note * note)9195 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
9196 {
9197   char buf[30];
9198   char *name;
9199   size_t len;
9200   asection *sect;
9201   int type;
9202   int is_active_thread;
9203   bfd_vma base_addr;
9204 
9205   if (note->descsz < 728)
9206     return TRUE;
9207 
9208   if (! CONST_STRNEQ (note->namedata, "win32"))
9209     return TRUE;
9210 
9211   type = bfd_get_32 (abfd, note->descdata);
9212 
9213   switch (type)
9214     {
9215     case 1 /* NOTE_INFO_PROCESS */:
9216       /* FIXME: need to add ->core->command.  */
9217       /* process_info.pid */
9218       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
9219       /* process_info.signal */
9220       elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
9221       break;
9222 
9223     case 2 /* NOTE_INFO_THREAD */:
9224       /* Make a ".reg/999" section.  */
9225       /* thread_info.tid */
9226       sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
9227 
9228       len = strlen (buf) + 1;
9229       name = (char *) bfd_alloc (abfd, len);
9230       if (name == NULL)
9231 	return FALSE;
9232 
9233       memcpy (name, buf, len);
9234 
9235       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9236       if (sect == NULL)
9237 	return FALSE;
9238 
9239       /* sizeof (thread_info.thread_context) */
9240       sect->size = 716;
9241       /* offsetof (thread_info.thread_context) */
9242       sect->filepos = note->descpos + 12;
9243       sect->alignment_power = 2;
9244 
9245       /* thread_info.is_active_thread */
9246       is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
9247 
9248       if (is_active_thread)
9249 	if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
9250 	  return FALSE;
9251       break;
9252 
9253     case 3 /* NOTE_INFO_MODULE */:
9254       /* Make a ".module/xxxxxxxx" section.  */
9255       /* module_info.base_address */
9256       base_addr = bfd_get_32 (abfd, note->descdata + 4);
9257       sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
9258 
9259       len = strlen (buf) + 1;
9260       name = (char *) bfd_alloc (abfd, len);
9261       if (name == NULL)
9262 	return FALSE;
9263 
9264       memcpy (name, buf, len);
9265 
9266       sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9267 
9268       if (sect == NULL)
9269 	return FALSE;
9270 
9271       sect->size = note->descsz;
9272       sect->filepos = note->descpos;
9273       sect->alignment_power = 2;
9274       break;
9275 
9276     default:
9277       return TRUE;
9278     }
9279 
9280   return TRUE;
9281 }
9282 
9283 static bfd_boolean
elfcore_grok_note(bfd * abfd,Elf_Internal_Note * note)9284 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
9285 {
9286   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9287 
9288   switch (note->type)
9289     {
9290     default:
9291       return TRUE;
9292 
9293     case NT_PRSTATUS:
9294       if (bed->elf_backend_grok_prstatus)
9295 	if ((*bed->elf_backend_grok_prstatus) (abfd, note))
9296 	  return TRUE;
9297 #if defined (HAVE_PRSTATUS_T)
9298       return elfcore_grok_prstatus (abfd, note);
9299 #else
9300       return TRUE;
9301 #endif
9302 
9303 #if defined (HAVE_PSTATUS_T)
9304     case NT_PSTATUS:
9305       return elfcore_grok_pstatus (abfd, note);
9306 #endif
9307 
9308 #if defined (HAVE_LWPSTATUS_T)
9309     case NT_LWPSTATUS:
9310       return elfcore_grok_lwpstatus (abfd, note);
9311 #endif
9312 
9313     case NT_FPREGSET:		/* FIXME: rename to NT_PRFPREG */
9314       return elfcore_grok_prfpreg (abfd, note);
9315 
9316     case NT_WIN32PSTATUS:
9317       return elfcore_grok_win32pstatus (abfd, note);
9318 
9319     case NT_PRXFPREG:		/* Linux SSE extension */
9320       if (note->namesz == 6
9321 	  && strcmp (note->namedata, "LINUX") == 0)
9322 	return elfcore_grok_prxfpreg (abfd, note);
9323       else
9324 	return TRUE;
9325 
9326     case NT_X86_XSTATE:		/* Linux XSAVE extension */
9327       if (note->namesz == 6
9328 	  && strcmp (note->namedata, "LINUX") == 0)
9329 	return elfcore_grok_xstatereg (abfd, note);
9330       else
9331 	return TRUE;
9332 
9333     case NT_PPC_VMX:
9334       if (note->namesz == 6
9335 	  && strcmp (note->namedata, "LINUX") == 0)
9336 	return elfcore_grok_ppc_vmx (abfd, note);
9337       else
9338 	return TRUE;
9339 
9340     case NT_PPC_VSX:
9341       if (note->namesz == 6
9342           && strcmp (note->namedata, "LINUX") == 0)
9343         return elfcore_grok_ppc_vsx (abfd, note);
9344       else
9345         return TRUE;
9346 
9347     case NT_S390_HIGH_GPRS:
9348       if (note->namesz == 6
9349           && strcmp (note->namedata, "LINUX") == 0)
9350         return elfcore_grok_s390_high_gprs (abfd, note);
9351       else
9352         return TRUE;
9353 
9354     case NT_S390_TIMER:
9355       if (note->namesz == 6
9356           && strcmp (note->namedata, "LINUX") == 0)
9357         return elfcore_grok_s390_timer (abfd, note);
9358       else
9359         return TRUE;
9360 
9361     case NT_S390_TODCMP:
9362       if (note->namesz == 6
9363           && strcmp (note->namedata, "LINUX") == 0)
9364         return elfcore_grok_s390_todcmp (abfd, note);
9365       else
9366         return TRUE;
9367 
9368     case NT_S390_TODPREG:
9369       if (note->namesz == 6
9370           && strcmp (note->namedata, "LINUX") == 0)
9371         return elfcore_grok_s390_todpreg (abfd, note);
9372       else
9373         return TRUE;
9374 
9375     case NT_S390_CTRS:
9376       if (note->namesz == 6
9377           && strcmp (note->namedata, "LINUX") == 0)
9378         return elfcore_grok_s390_ctrs (abfd, note);
9379       else
9380         return TRUE;
9381 
9382     case NT_S390_PREFIX:
9383       if (note->namesz == 6
9384           && strcmp (note->namedata, "LINUX") == 0)
9385         return elfcore_grok_s390_prefix (abfd, note);
9386       else
9387         return TRUE;
9388 
9389     case NT_S390_LAST_BREAK:
9390       if (note->namesz == 6
9391           && strcmp (note->namedata, "LINUX") == 0)
9392         return elfcore_grok_s390_last_break (abfd, note);
9393       else
9394         return TRUE;
9395 
9396     case NT_S390_SYSTEM_CALL:
9397       if (note->namesz == 6
9398           && strcmp (note->namedata, "LINUX") == 0)
9399         return elfcore_grok_s390_system_call (abfd, note);
9400       else
9401         return TRUE;
9402 
9403     case NT_S390_TDB:
9404       if (note->namesz == 6
9405           && strcmp (note->namedata, "LINUX") == 0)
9406         return elfcore_grok_s390_tdb (abfd, note);
9407       else
9408         return TRUE;
9409 
9410     case NT_S390_VXRS_LOW:
9411       if (note->namesz == 6
9412 	  && strcmp (note->namedata, "LINUX") == 0)
9413 	return elfcore_grok_s390_vxrs_low (abfd, note);
9414       else
9415 	return TRUE;
9416 
9417     case NT_S390_VXRS_HIGH:
9418       if (note->namesz == 6
9419 	  && strcmp (note->namedata, "LINUX") == 0)
9420 	return elfcore_grok_s390_vxrs_high (abfd, note);
9421       else
9422 	return TRUE;
9423 
9424     case NT_ARM_VFP:
9425       if (note->namesz == 6
9426 	  && strcmp (note->namedata, "LINUX") == 0)
9427 	return elfcore_grok_arm_vfp (abfd, note);
9428       else
9429 	return TRUE;
9430 
9431     case NT_ARM_TLS:
9432       if (note->namesz == 6
9433 	  && strcmp (note->namedata, "LINUX") == 0)
9434 	return elfcore_grok_aarch_tls (abfd, note);
9435       else
9436 	return TRUE;
9437 
9438     case NT_ARM_HW_BREAK:
9439       if (note->namesz == 6
9440 	  && strcmp (note->namedata, "LINUX") == 0)
9441 	return elfcore_grok_aarch_hw_break (abfd, note);
9442       else
9443 	return TRUE;
9444 
9445     case NT_ARM_HW_WATCH:
9446       if (note->namesz == 6
9447 	  && strcmp (note->namedata, "LINUX") == 0)
9448 	return elfcore_grok_aarch_hw_watch (abfd, note);
9449       else
9450 	return TRUE;
9451 
9452     case NT_PRPSINFO:
9453     case NT_PSINFO:
9454       if (bed->elf_backend_grok_psinfo)
9455 	if ((*bed->elf_backend_grok_psinfo) (abfd, note))
9456 	  return TRUE;
9457 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9458       return elfcore_grok_psinfo (abfd, note);
9459 #else
9460       return TRUE;
9461 #endif
9462 
9463     case NT_AUXV:
9464       {
9465 	asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9466 							     SEC_HAS_CONTENTS);
9467 
9468 	if (sect == NULL)
9469 	  return FALSE;
9470 	sect->size = note->descsz;
9471 	sect->filepos = note->descpos;
9472 	sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9473 
9474 	return TRUE;
9475       }
9476 
9477     case NT_FILE:
9478       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
9479 					      note);
9480 
9481     case NT_SIGINFO:
9482       return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
9483 					      note);
9484 
9485     }
9486 }
9487 
9488 static bfd_boolean
elfobj_grok_gnu_build_id(bfd * abfd,Elf_Internal_Note * note)9489 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
9490 {
9491   struct bfd_build_id* build_id;
9492 
9493   if (note->descsz == 0)
9494     return FALSE;
9495 
9496   build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz);
9497   if (build_id == NULL)
9498     return FALSE;
9499 
9500   build_id->size = note->descsz;
9501   memcpy (build_id->data, note->descdata, note->descsz);
9502   abfd->build_id = build_id;
9503 
9504   return TRUE;
9505 }
9506 
9507 static bfd_boolean
elfobj_grok_gnu_note(bfd * abfd,Elf_Internal_Note * note)9508 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
9509 {
9510   switch (note->type)
9511     {
9512     default:
9513       return TRUE;
9514 
9515     case NT_GNU_BUILD_ID:
9516       return elfobj_grok_gnu_build_id (abfd, note);
9517     }
9518 }
9519 
9520 static bfd_boolean
elfobj_grok_stapsdt_note_1(bfd * abfd,Elf_Internal_Note * note)9521 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
9522 {
9523   struct sdt_note *cur =
9524     (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
9525 				   + note->descsz);
9526 
9527   cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
9528   cur->size = (bfd_size_type) note->descsz;
9529   memcpy (cur->data, note->descdata, note->descsz);
9530 
9531   elf_tdata (abfd)->sdt_note_head = cur;
9532 
9533   return TRUE;
9534 }
9535 
9536 static bfd_boolean
elfobj_grok_stapsdt_note(bfd * abfd,Elf_Internal_Note * note)9537 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
9538 {
9539   switch (note->type)
9540     {
9541     case NT_STAPSDT:
9542       return elfobj_grok_stapsdt_note_1 (abfd, note);
9543 
9544     default:
9545       return TRUE;
9546     }
9547 }
9548 
9549 static bfd_boolean
elfcore_grok_freebsd_psinfo(bfd * abfd,Elf_Internal_Note * note)9550 elfcore_grok_freebsd_psinfo (bfd *abfd, Elf_Internal_Note *note)
9551 {
9552   size_t offset;
9553 
9554   /* Check for version 1 in pr_version. */
9555   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
9556     return FALSE;
9557   offset = 4;
9558 
9559   /* Skip over pr_psinfosz. */
9560   switch (abfd->arch_info->bits_per_word)
9561     {
9562     case 32:
9563       offset += 4;
9564       break;
9565 
9566     case 64:
9567       offset += 4;	/* Padding before pr_psinfosz. */
9568       offset += 8;
9569       break;
9570 
9571     default:
9572       return FALSE;
9573     }
9574 
9575   /* pr_fname is PRFNAMESZ (16) + 1 bytes in size.  */
9576   elf_tdata (abfd)->core->program
9577     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 17);
9578   offset += 17;
9579 
9580   /* pr_psargs is PRARGSZ (80) + 1 bytes in size.  */
9581   elf_tdata (abfd)->core->command
9582     = _bfd_elfcore_strndup (abfd, note->descdata + offset, 81);
9583 
9584   return TRUE;
9585 }
9586 
9587 static bfd_boolean
elfcore_grok_freebsd_prstatus(bfd * abfd,Elf_Internal_Note * note)9588 elfcore_grok_freebsd_prstatus (bfd *abfd, Elf_Internal_Note *note)
9589 {
9590   size_t offset;
9591   size_t size;
9592 
9593   /* Check for version 1 in pr_version. */
9594   if (bfd_h_get_32 (abfd, (bfd_byte *) note->descdata) != 1)
9595     return FALSE;
9596   offset = 4;
9597 
9598   /* Skip over pr_statussz.  */
9599   switch (abfd->arch_info->bits_per_word)
9600     {
9601     case 32:
9602       offset += 4;
9603       break;
9604 
9605     case 64:
9606       offset += 4;	/* Padding before pr_statussz. */
9607       offset += 8;
9608       break;
9609 
9610     default:
9611       return FALSE;
9612     }
9613 
9614   /* Extract size of pr_reg from pr_gregsetsz.  */
9615   if (abfd->arch_info->bits_per_word == 32)
9616     size = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
9617   else
9618     size = bfd_h_get_64 (abfd, (bfd_byte *) note->descdata + offset);
9619 
9620   /* Skip over pr_gregsetsz and pr_fpregsetsz. */
9621   offset += (abfd->arch_info->bits_per_word / 8) * 2;
9622 
9623   /* Skip over pr_osreldate. */
9624   offset += 4;
9625 
9626   /* Read signal from pr_cursig. */
9627   if (elf_tdata (abfd)->core->signal == 0)
9628     elf_tdata (abfd)->core->signal
9629       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
9630   offset += 4;
9631 
9632   /* Read TID from pr_pid. */
9633   elf_tdata (abfd)->core->lwpid
9634       = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + offset);
9635   offset += 4;
9636 
9637   /* Padding before pr_reg. */
9638   if (abfd->arch_info->bits_per_word == 64)
9639     offset += 4;
9640 
9641   /* Make a ".reg/999" section and a ".reg" section.  */
9642   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
9643 					  size, note->descpos + offset);
9644 }
9645 
9646 static bfd_boolean
elfcore_grok_freebsd_note(bfd * abfd,Elf_Internal_Note * note)9647 elfcore_grok_freebsd_note (bfd *abfd, Elf_Internal_Note *note)
9648 {
9649   switch (note->type)
9650     {
9651     case NT_PRSTATUS:
9652       return elfcore_grok_freebsd_prstatus (abfd, note);
9653 
9654     case NT_FPREGSET:
9655       return elfcore_grok_prfpreg (abfd, note);
9656 
9657     case NT_PRPSINFO:
9658       return elfcore_grok_freebsd_psinfo (abfd, note);
9659 
9660     case NT_FREEBSD_THRMISC:
9661       if (note->namesz == 8)
9662 	return elfcore_make_note_pseudosection (abfd, ".thrmisc", note);
9663       else
9664 	return TRUE;
9665 
9666     case NT_FREEBSD_PROCSTAT_AUXV:
9667       {
9668 	asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9669 							     SEC_HAS_CONTENTS);
9670 
9671 	if (sect == NULL)
9672 	  return FALSE;
9673 	sect->size = note->descsz - 4;
9674 	sect->filepos = note->descpos + 4;
9675 	sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9676 
9677 	return TRUE;
9678       }
9679 
9680     case NT_X86_XSTATE:
9681       if (note->namesz == 8)
9682 	return elfcore_grok_xstatereg (abfd, note);
9683       else
9684 	return TRUE;
9685 
9686     default:
9687       return TRUE;
9688     }
9689 }
9690 
9691 static bfd_boolean
elfcore_netbsd_get_lwpid(Elf_Internal_Note * note,int * lwpidp)9692 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
9693 {
9694   char *cp;
9695 
9696   cp = strchr (note->namedata, '@');
9697   if (cp != NULL)
9698     {
9699       *lwpidp = atoi(cp + 1);
9700       return TRUE;
9701     }
9702   return FALSE;
9703 }
9704 
9705 static bfd_boolean
elfcore_grok_netbsd_procinfo(bfd * abfd,Elf_Internal_Note * note)9706 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
9707 {
9708   /* Signal number at offset 0x08. */
9709   elf_tdata (abfd)->core->signal
9710     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
9711 
9712   /* Process ID at offset 0x50. */
9713   elf_tdata (abfd)->core->pid
9714     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
9715 
9716   /* Command name at 0x7c (max 32 bytes, including nul). */
9717   elf_tdata (abfd)->core->command
9718     = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
9719 
9720   return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
9721 					  note);
9722 }
9723 
9724 static bfd_boolean
elfcore_grok_netbsd_note(bfd * abfd,Elf_Internal_Note * note)9725 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
9726 {
9727   int lwp;
9728 
9729   if (elfcore_netbsd_get_lwpid (note, &lwp))
9730     elf_tdata (abfd)->core->lwpid = lwp;
9731 
9732   if (note->type == NT_NETBSDCORE_PROCINFO)
9733     {
9734       /* NetBSD-specific core "procinfo".  Note that we expect to
9735 	 find this note before any of the others, which is fine,
9736 	 since the kernel writes this note out first when it
9737 	 creates a core file.  */
9738 
9739       return elfcore_grok_netbsd_procinfo (abfd, note);
9740     }
9741 
9742   /* As of Jan 2002 there are no other machine-independent notes
9743      defined for NetBSD core files.  If the note type is less
9744      than the start of the machine-dependent note types, we don't
9745      understand it.  */
9746 
9747   if (note->type < NT_NETBSDCORE_FIRSTMACH)
9748     return TRUE;
9749 
9750 
9751   switch (bfd_get_arch (abfd))
9752     {
9753       /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
9754 	 PT_GETFPREGS == mach+2.  */
9755 
9756     case bfd_arch_alpha:
9757     case bfd_arch_sparc:
9758       switch (note->type)
9759 	{
9760 	case NT_NETBSDCORE_FIRSTMACH+0:
9761 	  return elfcore_make_note_pseudosection (abfd, ".reg", note);
9762 
9763 	case NT_NETBSDCORE_FIRSTMACH+2:
9764 	  return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9765 
9766 	default:
9767 	  return TRUE;
9768 	}
9769 
9770       /* On all other arch's, PT_GETREGS == mach+1 and
9771 	 PT_GETFPREGS == mach+3.  */
9772 
9773     default:
9774       switch (note->type)
9775 	{
9776 	case NT_NETBSDCORE_FIRSTMACH+1:
9777 	  return elfcore_make_note_pseudosection (abfd, ".reg", note);
9778 
9779 	case NT_NETBSDCORE_FIRSTMACH+3:
9780 	  return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9781 
9782 	default:
9783 	  return TRUE;
9784 	}
9785     }
9786     /* NOTREACHED */
9787 }
9788 
9789 static bfd_boolean
elfcore_grok_openbsd_procinfo(bfd * abfd,Elf_Internal_Note * note)9790 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
9791 {
9792   /* Signal number at offset 0x08. */
9793   elf_tdata (abfd)->core->signal
9794     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
9795 
9796   /* Process ID at offset 0x20. */
9797   elf_tdata (abfd)->core->pid
9798     = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
9799 
9800   /* Command name at 0x48 (max 32 bytes, including nul). */
9801   elf_tdata (abfd)->core->command
9802     = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
9803 
9804   return TRUE;
9805 }
9806 
9807 static bfd_boolean
elfcore_grok_openbsd_note(bfd * abfd,Elf_Internal_Note * note)9808 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
9809 {
9810   if (note->type == NT_OPENBSD_PROCINFO)
9811     return elfcore_grok_openbsd_procinfo (abfd, note);
9812 
9813   if (note->type == NT_OPENBSD_REGS)
9814     return elfcore_make_note_pseudosection (abfd, ".reg", note);
9815 
9816   if (note->type == NT_OPENBSD_FPREGS)
9817     return elfcore_make_note_pseudosection (abfd, ".reg2", note);
9818 
9819   if (note->type == NT_OPENBSD_XFPREGS)
9820     return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
9821 
9822   if (note->type == NT_OPENBSD_AUXV)
9823     {
9824       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
9825 							   SEC_HAS_CONTENTS);
9826 
9827       if (sect == NULL)
9828 	return FALSE;
9829       sect->size = note->descsz;
9830       sect->filepos = note->descpos;
9831       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9832 
9833       return TRUE;
9834     }
9835 
9836   if (note->type == NT_OPENBSD_WCOOKIE)
9837     {
9838       asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
9839 							   SEC_HAS_CONTENTS);
9840 
9841       if (sect == NULL)
9842 	return FALSE;
9843       sect->size = note->descsz;
9844       sect->filepos = note->descpos;
9845       sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
9846 
9847       return TRUE;
9848     }
9849 
9850   return TRUE;
9851 }
9852 
9853 static bfd_boolean
elfcore_grok_nto_status(bfd * abfd,Elf_Internal_Note * note,long * tid)9854 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
9855 {
9856   void *ddata = note->descdata;
9857   char buf[100];
9858   char *name;
9859   asection *sect;
9860   short sig;
9861   unsigned flags;
9862 
9863   /* nto_procfs_status 'pid' field is at offset 0.  */
9864   elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
9865 
9866   /* nto_procfs_status 'tid' field is at offset 4.  Pass it back.  */
9867   *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
9868 
9869   /* nto_procfs_status 'flags' field is at offset 8.  */
9870   flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
9871 
9872   /* nto_procfs_status 'what' field is at offset 14.  */
9873   if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
9874     {
9875       elf_tdata (abfd)->core->signal = sig;
9876       elf_tdata (abfd)->core->lwpid = *tid;
9877     }
9878 
9879   /* _DEBUG_FLAG_CURTID (current thread) is 0x80.  Some cores
9880      do not come from signals so we make sure we set the current
9881      thread just in case.  */
9882   if (flags & 0x00000080)
9883     elf_tdata (abfd)->core->lwpid = *tid;
9884 
9885   /* Make a ".qnx_core_status/%d" section.  */
9886   sprintf (buf, ".qnx_core_status/%ld", *tid);
9887 
9888   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
9889   if (name == NULL)
9890     return FALSE;
9891   strcpy (name, buf);
9892 
9893   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9894   if (sect == NULL)
9895     return FALSE;
9896 
9897   sect->size            = note->descsz;
9898   sect->filepos         = note->descpos;
9899   sect->alignment_power = 2;
9900 
9901   return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
9902 }
9903 
9904 static bfd_boolean
elfcore_grok_nto_regs(bfd * abfd,Elf_Internal_Note * note,long tid,char * base)9905 elfcore_grok_nto_regs (bfd *abfd,
9906 		       Elf_Internal_Note *note,
9907 		       long tid,
9908 		       char *base)
9909 {
9910   char buf[100];
9911   char *name;
9912   asection *sect;
9913 
9914   /* Make a "(base)/%d" section.  */
9915   sprintf (buf, "%s/%ld", base, tid);
9916 
9917   name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
9918   if (name == NULL)
9919     return FALSE;
9920   strcpy (name, buf);
9921 
9922   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9923   if (sect == NULL)
9924     return FALSE;
9925 
9926   sect->size            = note->descsz;
9927   sect->filepos         = note->descpos;
9928   sect->alignment_power = 2;
9929 
9930   /* This is the current thread.  */
9931   if (elf_tdata (abfd)->core->lwpid == tid)
9932     return elfcore_maybe_make_sect (abfd, base, sect);
9933 
9934   return TRUE;
9935 }
9936 
9937 #define BFD_QNT_CORE_INFO	7
9938 #define BFD_QNT_CORE_STATUS	8
9939 #define BFD_QNT_CORE_GREG	9
9940 #define BFD_QNT_CORE_FPREG	10
9941 
9942 static bfd_boolean
elfcore_grok_nto_note(bfd * abfd,Elf_Internal_Note * note)9943 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
9944 {
9945   /* Every GREG section has a STATUS section before it.  Store the
9946      tid from the previous call to pass down to the next gregs
9947      function.  */
9948   static long tid = 1;
9949 
9950   switch (note->type)
9951     {
9952     case BFD_QNT_CORE_INFO:
9953       return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
9954     case BFD_QNT_CORE_STATUS:
9955       return elfcore_grok_nto_status (abfd, note, &tid);
9956     case BFD_QNT_CORE_GREG:
9957       return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
9958     case BFD_QNT_CORE_FPREG:
9959       return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
9960     default:
9961       return TRUE;
9962     }
9963 }
9964 
9965 static bfd_boolean
elfcore_grok_spu_note(bfd * abfd,Elf_Internal_Note * note)9966 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
9967 {
9968   char *name;
9969   asection *sect;
9970   size_t len;
9971 
9972   /* Use note name as section name.  */
9973   len = note->namesz;
9974   name = (char *) bfd_alloc (abfd, len);
9975   if (name == NULL)
9976     return FALSE;
9977   memcpy (name, note->namedata, len);
9978   name[len - 1] = '\0';
9979 
9980   sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9981   if (sect == NULL)
9982     return FALSE;
9983 
9984   sect->size            = note->descsz;
9985   sect->filepos         = note->descpos;
9986   sect->alignment_power = 1;
9987 
9988   return TRUE;
9989 }
9990 
9991 /* Function: elfcore_write_note
9992 
9993    Inputs:
9994      buffer to hold note, and current size of buffer
9995      name of note
9996      type of note
9997      data for note
9998      size of data for note
9999 
10000    Writes note to end of buffer.  ELF64 notes are written exactly as
10001    for ELF32, despite the current (as of 2006) ELF gabi specifying
10002    that they ought to have 8-byte namesz and descsz field, and have
10003    8-byte alignment.  Other writers, eg. Linux kernel, do the same.
10004 
10005    Return:
10006    Pointer to realloc'd buffer, *BUFSIZ updated.  */
10007 
10008 char *
elfcore_write_note(bfd * abfd,char * buf,int * bufsiz,const char * name,int type,const void * input,int size)10009 elfcore_write_note (bfd *abfd,
10010 		    char *buf,
10011 		    int *bufsiz,
10012 		    const char *name,
10013 		    int type,
10014 		    const void *input,
10015 		    int size)
10016 {
10017   Elf_External_Note *xnp;
10018   size_t namesz;
10019   size_t newspace;
10020   char *dest;
10021 
10022   namesz = 0;
10023   if (name != NULL)
10024     namesz = strlen (name) + 1;
10025 
10026   newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
10027 
10028   buf = (char *) realloc (buf, *bufsiz + newspace);
10029   if (buf == NULL)
10030     return buf;
10031   dest = buf + *bufsiz;
10032   *bufsiz += newspace;
10033   xnp = (Elf_External_Note *) dest;
10034   H_PUT_32 (abfd, namesz, xnp->namesz);
10035   H_PUT_32 (abfd, size, xnp->descsz);
10036   H_PUT_32 (abfd, type, xnp->type);
10037   dest = xnp->name;
10038   if (name != NULL)
10039     {
10040       memcpy (dest, name, namesz);
10041       dest += namesz;
10042       while (namesz & 3)
10043 	{
10044 	  *dest++ = '\0';
10045 	  ++namesz;
10046 	}
10047     }
10048   memcpy (dest, input, size);
10049   dest += size;
10050   while (size & 3)
10051     {
10052       *dest++ = '\0';
10053       ++size;
10054     }
10055   return buf;
10056 }
10057 
10058 char *
elfcore_write_prpsinfo(bfd * abfd,char * buf,int * bufsiz,const char * fname,const char * psargs)10059 elfcore_write_prpsinfo (bfd  *abfd,
10060 			char *buf,
10061 			int  *bufsiz,
10062 			const char *fname,
10063 			const char *psargs)
10064 {
10065   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10066 
10067   if (bed->elf_backend_write_core_note != NULL)
10068     {
10069       char *ret;
10070       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10071 						 NT_PRPSINFO, fname, psargs);
10072       if (ret != NULL)
10073 	return ret;
10074     }
10075 
10076 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10077 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10078   if (bed->s->elfclass == ELFCLASS32)
10079     {
10080 #if defined (HAVE_PSINFO32_T)
10081       psinfo32_t data;
10082       int note_type = NT_PSINFO;
10083 #else
10084       prpsinfo32_t data;
10085       int note_type = NT_PRPSINFO;
10086 #endif
10087 
10088       memset (&data, 0, sizeof (data));
10089       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10090       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10091       return elfcore_write_note (abfd, buf, bufsiz,
10092 				 "CORE", note_type, &data, sizeof (data));
10093     }
10094   else
10095 #endif
10096     {
10097 #if defined (HAVE_PSINFO_T)
10098       psinfo_t data;
10099       int note_type = NT_PSINFO;
10100 #else
10101       prpsinfo_t data;
10102       int note_type = NT_PRPSINFO;
10103 #endif
10104 
10105       memset (&data, 0, sizeof (data));
10106       strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
10107       strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
10108       return elfcore_write_note (abfd, buf, bufsiz,
10109 				 "CORE", note_type, &data, sizeof (data));
10110     }
10111 #endif	/* PSINFO_T or PRPSINFO_T */
10112 
10113   free (buf);
10114   return NULL;
10115 }
10116 
10117 char *
elfcore_write_linux_prpsinfo32(bfd * abfd,char * buf,int * bufsiz,const struct elf_internal_linux_prpsinfo * prpsinfo)10118 elfcore_write_linux_prpsinfo32
10119   (bfd *abfd, char *buf, int *bufsiz,
10120    const struct elf_internal_linux_prpsinfo *prpsinfo)
10121 {
10122   struct elf_external_linux_prpsinfo32 data;
10123 
10124   swap_linux_prpsinfo32_out (abfd, prpsinfo, &data);
10125   return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
10126 			     &data, sizeof (data));
10127 }
10128 
10129 char *
elfcore_write_linux_prpsinfo64(bfd * abfd,char * buf,int * bufsiz,const struct elf_internal_linux_prpsinfo * prpsinfo)10130 elfcore_write_linux_prpsinfo64
10131   (bfd *abfd, char *buf, int *bufsiz,
10132    const struct elf_internal_linux_prpsinfo *prpsinfo)
10133 {
10134   struct elf_external_linux_prpsinfo64 data;
10135 
10136   swap_linux_prpsinfo64_out (abfd, prpsinfo, &data);
10137   return elfcore_write_note (abfd, buf, bufsiz,
10138 			     "CORE", NT_PRPSINFO, &data, sizeof (data));
10139 }
10140 
10141 char *
elfcore_write_prstatus(bfd * abfd,char * buf,int * bufsiz,long pid,int cursig,const void * gregs)10142 elfcore_write_prstatus (bfd *abfd,
10143 			char *buf,
10144 			int *bufsiz,
10145 			long pid,
10146 			int cursig,
10147 			const void *gregs)
10148 {
10149   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10150 
10151   if (bed->elf_backend_write_core_note != NULL)
10152     {
10153       char *ret;
10154       ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
10155 						 NT_PRSTATUS,
10156 						 pid, cursig, gregs);
10157       if (ret != NULL)
10158 	return ret;
10159     }
10160 
10161 #if defined (HAVE_PRSTATUS_T)
10162 #if defined (HAVE_PRSTATUS32_T)
10163   if (bed->s->elfclass == ELFCLASS32)
10164     {
10165       prstatus32_t prstat;
10166 
10167       memset (&prstat, 0, sizeof (prstat));
10168       prstat.pr_pid = pid;
10169       prstat.pr_cursig = cursig;
10170       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10171       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10172 				 NT_PRSTATUS, &prstat, sizeof (prstat));
10173     }
10174   else
10175 #endif
10176     {
10177       prstatus_t prstat;
10178 
10179       memset (&prstat, 0, sizeof (prstat));
10180       prstat.pr_pid = pid;
10181       prstat.pr_cursig = cursig;
10182       memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
10183       return elfcore_write_note (abfd, buf, bufsiz, "CORE",
10184 				 NT_PRSTATUS, &prstat, sizeof (prstat));
10185     }
10186 #endif /* HAVE_PRSTATUS_T */
10187 
10188   free (buf);
10189   return NULL;
10190 }
10191 
10192 #if defined (HAVE_LWPSTATUS_T)
10193 char *
elfcore_write_lwpstatus(bfd * abfd,char * buf,int * bufsiz,long pid,int cursig,const void * gregs)10194 elfcore_write_lwpstatus (bfd *abfd,
10195 			 char *buf,
10196 			 int *bufsiz,
10197 			 long pid,
10198 			 int cursig,
10199 			 const void *gregs)
10200 {
10201   lwpstatus_t lwpstat;
10202   const char *note_name = "CORE";
10203 
10204   memset (&lwpstat, 0, sizeof (lwpstat));
10205   lwpstat.pr_lwpid  = pid >> 16;
10206   lwpstat.pr_cursig = cursig;
10207 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10208   memcpy (&lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
10209 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10210 #if !defined(gregs)
10211   memcpy (lwpstat.pr_context.uc_mcontext.gregs,
10212 	  gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
10213 #else
10214   memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
10215 	  gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
10216 #endif
10217 #endif
10218   return elfcore_write_note (abfd, buf, bufsiz, note_name,
10219 			     NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
10220 }
10221 #endif /* HAVE_LWPSTATUS_T */
10222 
10223 #if defined (HAVE_PSTATUS_T)
10224 char *
elfcore_write_pstatus(bfd * abfd,char * buf,int * bufsiz,long pid,int cursig ATTRIBUTE_UNUSED,const void * gregs ATTRIBUTE_UNUSED)10225 elfcore_write_pstatus (bfd *abfd,
10226 		       char *buf,
10227 		       int *bufsiz,
10228 		       long pid,
10229 		       int cursig ATTRIBUTE_UNUSED,
10230 		       const void *gregs ATTRIBUTE_UNUSED)
10231 {
10232   const char *note_name = "CORE";
10233 #if defined (HAVE_PSTATUS32_T)
10234   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10235 
10236   if (bed->s->elfclass == ELFCLASS32)
10237     {
10238       pstatus32_t pstat;
10239 
10240       memset (&pstat, 0, sizeof (pstat));
10241       pstat.pr_pid = pid & 0xffff;
10242       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10243 				NT_PSTATUS, &pstat, sizeof (pstat));
10244       return buf;
10245     }
10246   else
10247 #endif
10248     {
10249       pstatus_t pstat;
10250 
10251       memset (&pstat, 0, sizeof (pstat));
10252       pstat.pr_pid = pid & 0xffff;
10253       buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
10254 				NT_PSTATUS, &pstat, sizeof (pstat));
10255       return buf;
10256     }
10257 }
10258 #endif /* HAVE_PSTATUS_T */
10259 
10260 char *
elfcore_write_prfpreg(bfd * abfd,char * buf,int * bufsiz,const void * fpregs,int size)10261 elfcore_write_prfpreg (bfd *abfd,
10262 		       char *buf,
10263 		       int *bufsiz,
10264 		       const void *fpregs,
10265 		       int size)
10266 {
10267   const char *note_name = "CORE";
10268   return elfcore_write_note (abfd, buf, bufsiz,
10269 			     note_name, NT_FPREGSET, fpregs, size);
10270 }
10271 
10272 char *
elfcore_write_prxfpreg(bfd * abfd,char * buf,int * bufsiz,const void * xfpregs,int size)10273 elfcore_write_prxfpreg (bfd *abfd,
10274 			char *buf,
10275 			int *bufsiz,
10276 			const void *xfpregs,
10277 			int size)
10278 {
10279   char *note_name = "LINUX";
10280   return elfcore_write_note (abfd, buf, bufsiz,
10281 			     note_name, NT_PRXFPREG, xfpregs, size);
10282 }
10283 
10284 char *
elfcore_write_xstatereg(bfd * abfd,char * buf,int * bufsiz,const void * xfpregs,int size)10285 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
10286 			 const void *xfpregs, int size)
10287 {
10288   char *note_name;
10289   if (get_elf_backend_data (abfd)->elf_osabi == ELFOSABI_FREEBSD)
10290     note_name = "FreeBSD";
10291   else
10292     note_name = "LINUX";
10293   return elfcore_write_note (abfd, buf, bufsiz,
10294 			     note_name, NT_X86_XSTATE, xfpregs, size);
10295 }
10296 
10297 char *
elfcore_write_ppc_vmx(bfd * abfd,char * buf,int * bufsiz,const void * ppc_vmx,int size)10298 elfcore_write_ppc_vmx (bfd *abfd,
10299 		       char *buf,
10300 		       int *bufsiz,
10301 		       const void *ppc_vmx,
10302 		       int size)
10303 {
10304   char *note_name = "LINUX";
10305   return elfcore_write_note (abfd, buf, bufsiz,
10306 			     note_name, NT_PPC_VMX, ppc_vmx, size);
10307 }
10308 
10309 char *
elfcore_write_ppc_vsx(bfd * abfd,char * buf,int * bufsiz,const void * ppc_vsx,int size)10310 elfcore_write_ppc_vsx (bfd *abfd,
10311                        char *buf,
10312                        int *bufsiz,
10313                        const void *ppc_vsx,
10314                        int size)
10315 {
10316   char *note_name = "LINUX";
10317   return elfcore_write_note (abfd, buf, bufsiz,
10318                              note_name, NT_PPC_VSX, ppc_vsx, size);
10319 }
10320 
10321 static char *
elfcore_write_s390_high_gprs(bfd * abfd,char * buf,int * bufsiz,const void * s390_high_gprs,int size)10322 elfcore_write_s390_high_gprs (bfd *abfd,
10323 			      char *buf,
10324 			      int *bufsiz,
10325 			      const void *s390_high_gprs,
10326 			      int size)
10327 {
10328   char *note_name = "LINUX";
10329   return elfcore_write_note (abfd, buf, bufsiz,
10330                              note_name, NT_S390_HIGH_GPRS,
10331 			     s390_high_gprs, size);
10332 }
10333 
10334 char *
elfcore_write_s390_timer(bfd * abfd,char * buf,int * bufsiz,const void * s390_timer,int size)10335 elfcore_write_s390_timer (bfd *abfd,
10336                           char *buf,
10337                           int *bufsiz,
10338                           const void *s390_timer,
10339                           int size)
10340 {
10341   char *note_name = "LINUX";
10342   return elfcore_write_note (abfd, buf, bufsiz,
10343                              note_name, NT_S390_TIMER, s390_timer, size);
10344 }
10345 
10346 char *
elfcore_write_s390_todcmp(bfd * abfd,char * buf,int * bufsiz,const void * s390_todcmp,int size)10347 elfcore_write_s390_todcmp (bfd *abfd,
10348                            char *buf,
10349                            int *bufsiz,
10350                            const void *s390_todcmp,
10351                            int size)
10352 {
10353   char *note_name = "LINUX";
10354   return elfcore_write_note (abfd, buf, bufsiz,
10355                              note_name, NT_S390_TODCMP, s390_todcmp, size);
10356 }
10357 
10358 char *
elfcore_write_s390_todpreg(bfd * abfd,char * buf,int * bufsiz,const void * s390_todpreg,int size)10359 elfcore_write_s390_todpreg (bfd *abfd,
10360                             char *buf,
10361                             int *bufsiz,
10362                             const void *s390_todpreg,
10363                             int size)
10364 {
10365   char *note_name = "LINUX";
10366   return elfcore_write_note (abfd, buf, bufsiz,
10367                              note_name, NT_S390_TODPREG, s390_todpreg, size);
10368 }
10369 
10370 char *
elfcore_write_s390_ctrs(bfd * abfd,char * buf,int * bufsiz,const void * s390_ctrs,int size)10371 elfcore_write_s390_ctrs (bfd *abfd,
10372                          char *buf,
10373                          int *bufsiz,
10374                          const void *s390_ctrs,
10375                          int size)
10376 {
10377   char *note_name = "LINUX";
10378   return elfcore_write_note (abfd, buf, bufsiz,
10379                              note_name, NT_S390_CTRS, s390_ctrs, size);
10380 }
10381 
10382 char *
elfcore_write_s390_prefix(bfd * abfd,char * buf,int * bufsiz,const void * s390_prefix,int size)10383 elfcore_write_s390_prefix (bfd *abfd,
10384                            char *buf,
10385                            int *bufsiz,
10386                            const void *s390_prefix,
10387                            int size)
10388 {
10389   char *note_name = "LINUX";
10390   return elfcore_write_note (abfd, buf, bufsiz,
10391                              note_name, NT_S390_PREFIX, s390_prefix, size);
10392 }
10393 
10394 char *
elfcore_write_s390_last_break(bfd * abfd,char * buf,int * bufsiz,const void * s390_last_break,int size)10395 elfcore_write_s390_last_break (bfd *abfd,
10396 			       char *buf,
10397 			       int *bufsiz,
10398 			       const void *s390_last_break,
10399 			       int size)
10400 {
10401   char *note_name = "LINUX";
10402   return elfcore_write_note (abfd, buf, bufsiz,
10403                              note_name, NT_S390_LAST_BREAK,
10404 			     s390_last_break, size);
10405 }
10406 
10407 char *
elfcore_write_s390_system_call(bfd * abfd,char * buf,int * bufsiz,const void * s390_system_call,int size)10408 elfcore_write_s390_system_call (bfd *abfd,
10409 				char *buf,
10410 				int *bufsiz,
10411 				const void *s390_system_call,
10412 				int size)
10413 {
10414   char *note_name = "LINUX";
10415   return elfcore_write_note (abfd, buf, bufsiz,
10416                              note_name, NT_S390_SYSTEM_CALL,
10417 			     s390_system_call, size);
10418 }
10419 
10420 char *
elfcore_write_s390_tdb(bfd * abfd,char * buf,int * bufsiz,const void * s390_tdb,int size)10421 elfcore_write_s390_tdb (bfd *abfd,
10422 			char *buf,
10423 			int *bufsiz,
10424 			const void *s390_tdb,
10425 			int size)
10426 {
10427   char *note_name = "LINUX";
10428   return elfcore_write_note (abfd, buf, bufsiz,
10429                              note_name, NT_S390_TDB, s390_tdb, size);
10430 }
10431 
10432 char *
elfcore_write_s390_vxrs_low(bfd * abfd,char * buf,int * bufsiz,const void * s390_vxrs_low,int size)10433 elfcore_write_s390_vxrs_low (bfd *abfd,
10434 			     char *buf,
10435 			     int *bufsiz,
10436 			     const void *s390_vxrs_low,
10437 			     int size)
10438 {
10439   char *note_name = "LINUX";
10440   return elfcore_write_note (abfd, buf, bufsiz,
10441 			     note_name, NT_S390_VXRS_LOW, s390_vxrs_low, size);
10442 }
10443 
10444 char *
elfcore_write_s390_vxrs_high(bfd * abfd,char * buf,int * bufsiz,const void * s390_vxrs_high,int size)10445 elfcore_write_s390_vxrs_high (bfd *abfd,
10446 			     char *buf,
10447 			     int *bufsiz,
10448 			     const void *s390_vxrs_high,
10449 			     int size)
10450 {
10451   char *note_name = "LINUX";
10452   return elfcore_write_note (abfd, buf, bufsiz,
10453 			     note_name, NT_S390_VXRS_HIGH,
10454 			     s390_vxrs_high, size);
10455 }
10456 
10457 char *
elfcore_write_arm_vfp(bfd * abfd,char * buf,int * bufsiz,const void * arm_vfp,int size)10458 elfcore_write_arm_vfp (bfd *abfd,
10459 		       char *buf,
10460 		       int *bufsiz,
10461 		       const void *arm_vfp,
10462 		       int size)
10463 {
10464   char *note_name = "LINUX";
10465   return elfcore_write_note (abfd, buf, bufsiz,
10466 			     note_name, NT_ARM_VFP, arm_vfp, size);
10467 }
10468 
10469 char *
elfcore_write_aarch_tls(bfd * abfd,char * buf,int * bufsiz,const void * aarch_tls,int size)10470 elfcore_write_aarch_tls (bfd *abfd,
10471 		       char *buf,
10472 		       int *bufsiz,
10473 		       const void *aarch_tls,
10474 		       int size)
10475 {
10476   char *note_name = "LINUX";
10477   return elfcore_write_note (abfd, buf, bufsiz,
10478 			     note_name, NT_ARM_TLS, aarch_tls, size);
10479 }
10480 
10481 char *
elfcore_write_aarch_hw_break(bfd * abfd,char * buf,int * bufsiz,const void * aarch_hw_break,int size)10482 elfcore_write_aarch_hw_break (bfd *abfd,
10483 			    char *buf,
10484 			    int *bufsiz,
10485 			    const void *aarch_hw_break,
10486 			    int size)
10487 {
10488   char *note_name = "LINUX";
10489   return elfcore_write_note (abfd, buf, bufsiz,
10490 			     note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
10491 }
10492 
10493 char *
elfcore_write_aarch_hw_watch(bfd * abfd,char * buf,int * bufsiz,const void * aarch_hw_watch,int size)10494 elfcore_write_aarch_hw_watch (bfd *abfd,
10495 			    char *buf,
10496 			    int *bufsiz,
10497 			    const void *aarch_hw_watch,
10498 			    int size)
10499 {
10500   char *note_name = "LINUX";
10501   return elfcore_write_note (abfd, buf, bufsiz,
10502 			     note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
10503 }
10504 
10505 char *
elfcore_write_register_note(bfd * abfd,char * buf,int * bufsiz,const char * section,const void * data,int size)10506 elfcore_write_register_note (bfd *abfd,
10507 			     char *buf,
10508 			     int *bufsiz,
10509 			     const char *section,
10510 			     const void *data,
10511 			     int size)
10512 {
10513   if (strcmp (section, ".reg2") == 0)
10514     return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
10515   if (strcmp (section, ".reg-xfp") == 0)
10516     return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
10517   if (strcmp (section, ".reg-xstate") == 0)
10518     return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
10519   if (strcmp (section, ".reg-ppc-vmx") == 0)
10520     return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
10521   if (strcmp (section, ".reg-ppc-vsx") == 0)
10522     return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
10523   if (strcmp (section, ".reg-s390-high-gprs") == 0)
10524     return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
10525   if (strcmp (section, ".reg-s390-timer") == 0)
10526     return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
10527   if (strcmp (section, ".reg-s390-todcmp") == 0)
10528     return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
10529   if (strcmp (section, ".reg-s390-todpreg") == 0)
10530     return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
10531   if (strcmp (section, ".reg-s390-ctrs") == 0)
10532     return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
10533   if (strcmp (section, ".reg-s390-prefix") == 0)
10534     return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
10535   if (strcmp (section, ".reg-s390-last-break") == 0)
10536     return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
10537   if (strcmp (section, ".reg-s390-system-call") == 0)
10538     return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
10539   if (strcmp (section, ".reg-s390-tdb") == 0)
10540     return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
10541   if (strcmp (section, ".reg-s390-vxrs-low") == 0)
10542     return elfcore_write_s390_vxrs_low (abfd, buf, bufsiz, data, size);
10543   if (strcmp (section, ".reg-s390-vxrs-high") == 0)
10544     return elfcore_write_s390_vxrs_high (abfd, buf, bufsiz, data, size);
10545   if (strcmp (section, ".reg-arm-vfp") == 0)
10546     return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
10547   if (strcmp (section, ".reg-aarch-tls") == 0)
10548     return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
10549   if (strcmp (section, ".reg-aarch-hw-break") == 0)
10550     return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
10551   if (strcmp (section, ".reg-aarch-hw-watch") == 0)
10552     return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
10553   return NULL;
10554 }
10555 
10556 static bfd_boolean
elf_parse_notes(bfd * abfd,char * buf,size_t size,file_ptr offset)10557 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
10558 {
10559   char *p;
10560 
10561   p = buf;
10562   while (p < buf + size)
10563     {
10564       /* FIXME: bad alignment assumption.  */
10565       Elf_External_Note *xnp = (Elf_External_Note *) p;
10566       Elf_Internal_Note in;
10567 
10568       if (offsetof (Elf_External_Note, name) > buf - p + size)
10569 	return FALSE;
10570 
10571       in.type = H_GET_32 (abfd, xnp->type);
10572 
10573       in.namesz = H_GET_32 (abfd, xnp->namesz);
10574       in.namedata = xnp->name;
10575       if (in.namesz > buf - in.namedata + size)
10576 	return FALSE;
10577 
10578       in.descsz = H_GET_32 (abfd, xnp->descsz);
10579       in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
10580       in.descpos = offset + (in.descdata - buf);
10581       if (in.descsz != 0
10582 	  && (in.descdata >= buf + size
10583 	      || in.descsz > buf - in.descdata + size))
10584 	return FALSE;
10585 
10586       switch (bfd_get_format (abfd))
10587         {
10588 	default:
10589 	  return TRUE;
10590 
10591 	case bfd_core:
10592 	  {
10593 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
10594 	    struct
10595 	    {
10596 	      const char * string;
10597 	      size_t len;
10598 	      bfd_boolean (* func)(bfd *, Elf_Internal_Note *);
10599 	    }
10600 	    grokers[] =
10601 	    {
10602 	      GROKER_ELEMENT ("", elfcore_grok_note),
10603 	      GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note),
10604 	      GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note),
10605 	      GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note),
10606 	      GROKER_ELEMENT ("QNX", elfcore_grok_nto_note),
10607 	      GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note)
10608 	    };
10609 #undef GROKER_ELEMENT
10610 	    int i;
10611 
10612 	    for (i = ARRAY_SIZE (grokers); i--;)
10613 	      {
10614 		if (in.namesz >= grokers[i].len
10615 		    && strncmp (in.namedata, grokers[i].string,
10616 				grokers[i].len) == 0)
10617 		  {
10618 		    if (! grokers[i].func (abfd, & in))
10619 		      return FALSE;
10620 		    break;
10621 		  }
10622 	      }
10623 	    break;
10624 	  }
10625 
10626 	case bfd_object:
10627 	  if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
10628 	    {
10629 	      if (! elfobj_grok_gnu_note (abfd, &in))
10630 		return FALSE;
10631 	    }
10632 	  else if (in.namesz == sizeof "stapsdt"
10633 		   && strcmp (in.namedata, "stapsdt") == 0)
10634 	    {
10635 	      if (! elfobj_grok_stapsdt_note (abfd, &in))
10636 		return FALSE;
10637 	    }
10638 	  break;
10639 	}
10640 
10641       p = in.descdata + BFD_ALIGN (in.descsz, 4);
10642     }
10643 
10644   return TRUE;
10645 }
10646 
10647 static bfd_boolean
elf_read_notes(bfd * abfd,file_ptr offset,bfd_size_type size)10648 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
10649 {
10650   char *buf;
10651 
10652   if (size <= 0)
10653     return TRUE;
10654 
10655   if (bfd_seek (abfd, offset, SEEK_SET) != 0)
10656     return FALSE;
10657 
10658   buf = (char *) bfd_malloc (size + 1);
10659   if (buf == NULL)
10660     return FALSE;
10661 
10662   /* PR 17512: file: ec08f814
10663      0-termintate the buffer so that string searches will not overflow.  */
10664   buf[size] = 0;
10665 
10666   if (bfd_bread (buf, size, abfd) != size
10667       || !elf_parse_notes (abfd, buf, size, offset))
10668     {
10669       free (buf);
10670       return FALSE;
10671     }
10672 
10673   free (buf);
10674   return TRUE;
10675 }
10676 
10677 /* Providing external access to the ELF program header table.  */
10678 
10679 /* Return an upper bound on the number of bytes required to store a
10680    copy of ABFD's program header table entries.  Return -1 if an error
10681    occurs; bfd_get_error will return an appropriate code.  */
10682 
10683 long
bfd_get_elf_phdr_upper_bound(bfd * abfd)10684 bfd_get_elf_phdr_upper_bound (bfd *abfd)
10685 {
10686   if (abfd->xvec->flavour != bfd_target_elf_flavour)
10687     {
10688       bfd_set_error (bfd_error_wrong_format);
10689       return -1;
10690     }
10691 
10692   return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
10693 }
10694 
10695 /* Copy ABFD's program header table entries to *PHDRS.  The entries
10696    will be stored as an array of Elf_Internal_Phdr structures, as
10697    defined in include/elf/internal.h.  To find out how large the
10698    buffer needs to be, call bfd_get_elf_phdr_upper_bound.
10699 
10700    Return the number of program header table entries read, or -1 if an
10701    error occurs; bfd_get_error will return an appropriate code.  */
10702 
10703 int
bfd_get_elf_phdrs(bfd * abfd,void * phdrs)10704 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
10705 {
10706   int num_phdrs;
10707 
10708   if (abfd->xvec->flavour != bfd_target_elf_flavour)
10709     {
10710       bfd_set_error (bfd_error_wrong_format);
10711       return -1;
10712     }
10713 
10714   num_phdrs = elf_elfheader (abfd)->e_phnum;
10715   memcpy (phdrs, elf_tdata (abfd)->phdr,
10716 	  num_phdrs * sizeof (Elf_Internal_Phdr));
10717 
10718   return num_phdrs;
10719 }
10720 
10721 enum elf_reloc_type_class
_bfd_elf_reloc_type_class(const struct bfd_link_info * info ATTRIBUTE_UNUSED,const asection * rel_sec ATTRIBUTE_UNUSED,const Elf_Internal_Rela * rela ATTRIBUTE_UNUSED)10722 _bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
10723 			   const asection *rel_sec ATTRIBUTE_UNUSED,
10724 			   const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
10725 {
10726   return reloc_class_normal;
10727 }
10728 
10729 /* For RELA architectures, return the relocation value for a
10730    relocation against a local symbol.  */
10731 
10732 bfd_vma
_bfd_elf_rela_local_sym(bfd * abfd,Elf_Internal_Sym * sym,asection ** psec,Elf_Internal_Rela * rel)10733 _bfd_elf_rela_local_sym (bfd *abfd,
10734 			 Elf_Internal_Sym *sym,
10735 			 asection **psec,
10736 			 Elf_Internal_Rela *rel)
10737 {
10738   asection *sec = *psec;
10739   bfd_vma relocation;
10740 
10741   relocation = (sec->output_section->vma
10742 		+ sec->output_offset
10743 		+ sym->st_value);
10744   if ((sec->flags & SEC_MERGE)
10745       && ELF_ST_TYPE (sym->st_info) == STT_SECTION
10746       && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
10747     {
10748       rel->r_addend =
10749 	_bfd_merged_section_offset (abfd, psec,
10750 				    elf_section_data (sec)->sec_info,
10751 				    sym->st_value + rel->r_addend);
10752       if (sec != *psec)
10753 	{
10754 	  /* If we have changed the section, and our original section is
10755 	     marked with SEC_EXCLUDE, it means that the original
10756 	     SEC_MERGE section has been completely subsumed in some
10757 	     other SEC_MERGE section.  In this case, we need to leave
10758 	     some info around for --emit-relocs.  */
10759 	  if ((sec->flags & SEC_EXCLUDE) != 0)
10760 	    sec->kept_section = *psec;
10761 	  sec = *psec;
10762 	}
10763       rel->r_addend -= relocation;
10764       rel->r_addend += sec->output_section->vma + sec->output_offset;
10765     }
10766   return relocation;
10767 }
10768 
10769 bfd_vma
_bfd_elf_rel_local_sym(bfd * abfd,Elf_Internal_Sym * sym,asection ** psec,bfd_vma addend)10770 _bfd_elf_rel_local_sym (bfd *abfd,
10771 			Elf_Internal_Sym *sym,
10772 			asection **psec,
10773 			bfd_vma addend)
10774 {
10775   asection *sec = *psec;
10776 
10777   if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
10778     return sym->st_value + addend;
10779 
10780   return _bfd_merged_section_offset (abfd, psec,
10781 				     elf_section_data (sec)->sec_info,
10782 				     sym->st_value + addend);
10783 }
10784 
10785 /* Adjust an address within a section.  Given OFFSET within SEC, return
10786    the new offset within the section, based upon changes made to the
10787    section.  Returns -1 if the offset is now invalid.
10788    The offset (in abnd out) is in target sized bytes, however big a
10789    byte may be.  */
10790 
10791 bfd_vma
_bfd_elf_section_offset(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_vma offset)10792 _bfd_elf_section_offset (bfd *abfd,
10793 			 struct bfd_link_info *info,
10794 			 asection *sec,
10795 			 bfd_vma offset)
10796 {
10797   switch (sec->sec_info_type)
10798     {
10799     case SEC_INFO_TYPE_STABS:
10800       return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
10801 				       offset);
10802     case SEC_INFO_TYPE_EH_FRAME:
10803       return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
10804 
10805     default:
10806       if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
10807 	{
10808 	  /* Reverse the offset.  */
10809 	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10810 	  bfd_size_type address_size = bed->s->arch_size / 8;
10811 
10812 	  /* address_size and sec->size are in octets.  Convert
10813 	     to bytes before subtracting the original offset.  */
10814 	  offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset;
10815 	}
10816       return offset;
10817     }
10818 }
10819 
10820 /* Create a new BFD as if by bfd_openr.  Rather than opening a file,
10821    reconstruct an ELF file by reading the segments out of remote memory
10822    based on the ELF file header at EHDR_VMA and the ELF program headers it
10823    points to.  If not null, *LOADBASEP is filled in with the difference
10824    between the VMAs from which the segments were read, and the VMAs the
10825    file headers (and hence BFD's idea of each section's VMA) put them at.
10826 
10827    The function TARGET_READ_MEMORY is called to copy LEN bytes from the
10828    remote memory at target address VMA into the local buffer at MYADDR; it
10829    should return zero on success or an `errno' code on failure.  TEMPL must
10830    be a BFD for an ELF target with the word size and byte order found in
10831    the remote memory.  */
10832 
10833 bfd *
bfd_elf_bfd_from_remote_memory(bfd * templ,bfd_vma ehdr_vma,bfd_size_type size,bfd_vma * loadbasep,int (* target_read_memory)(bfd_vma,bfd_byte *,bfd_size_type))10834 bfd_elf_bfd_from_remote_memory
10835   (bfd *templ,
10836    bfd_vma ehdr_vma,
10837    bfd_size_type size,
10838    bfd_vma *loadbasep,
10839    int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
10840 {
10841   return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
10842     (templ, ehdr_vma, size, loadbasep, target_read_memory);
10843 }
10844 
10845 long
_bfd_elf_get_synthetic_symtab(bfd * abfd,long symcount ATTRIBUTE_UNUSED,asymbol ** syms ATTRIBUTE_UNUSED,long dynsymcount,asymbol ** dynsyms,asymbol ** ret)10846 _bfd_elf_get_synthetic_symtab (bfd *abfd,
10847 			       long symcount ATTRIBUTE_UNUSED,
10848 			       asymbol **syms ATTRIBUTE_UNUSED,
10849 			       long dynsymcount,
10850 			       asymbol **dynsyms,
10851 			       asymbol **ret)
10852 {
10853   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
10854   asection *relplt;
10855   asymbol *s;
10856   const char *relplt_name;
10857   bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
10858   arelent *p;
10859   long count, i, n;
10860   size_t size;
10861   Elf_Internal_Shdr *hdr;
10862   char *names;
10863   asection *plt;
10864 
10865   *ret = NULL;
10866 
10867   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
10868     return 0;
10869 
10870   if (dynsymcount <= 0)
10871     return 0;
10872 
10873   if (!bed->plt_sym_val)
10874     return 0;
10875 
10876   relplt_name = bed->relplt_name;
10877   if (relplt_name == NULL)
10878     relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
10879   relplt = bfd_get_section_by_name (abfd, relplt_name);
10880   if (relplt == NULL)
10881     return 0;
10882 
10883   hdr = &elf_section_data (relplt)->this_hdr;
10884   if (hdr->sh_link != elf_dynsymtab (abfd)
10885       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
10886     return 0;
10887 
10888   plt = bfd_get_section_by_name (abfd, ".plt");
10889   if (plt == NULL)
10890     return 0;
10891 
10892   slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
10893   if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
10894     return -1;
10895 
10896   count = relplt->size / hdr->sh_entsize;
10897   size = count * sizeof (asymbol);
10898   p = relplt->relocation;
10899   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
10900     {
10901       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
10902       if (p->addend != 0)
10903 	{
10904 #ifdef BFD64
10905 	  size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
10906 #else
10907 	  size += sizeof ("+0x") - 1 + 8;
10908 #endif
10909 	}
10910     }
10911 
10912   s = *ret = (asymbol *) bfd_malloc (size);
10913   if (s == NULL)
10914     return -1;
10915 
10916   names = (char *) (s + count);
10917   p = relplt->relocation;
10918   n = 0;
10919   for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
10920     {
10921       size_t len;
10922       bfd_vma addr;
10923 
10924       addr = bed->plt_sym_val (i, plt, p);
10925       if (addr == (bfd_vma) -1)
10926 	continue;
10927 
10928       *s = **p->sym_ptr_ptr;
10929       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
10930 	 we are defining a symbol, ensure one of them is set.  */
10931       if ((s->flags & BSF_LOCAL) == 0)
10932 	s->flags |= BSF_GLOBAL;
10933       s->flags |= BSF_SYNTHETIC;
10934       s->section = plt;
10935       s->value = addr - plt->vma;
10936       s->name = names;
10937       s->udata.p = NULL;
10938       len = strlen ((*p->sym_ptr_ptr)->name);
10939       memcpy (names, (*p->sym_ptr_ptr)->name, len);
10940       names += len;
10941       if (p->addend != 0)
10942 	{
10943 	  char buf[30], *a;
10944 
10945 	  memcpy (names, "+0x", sizeof ("+0x") - 1);
10946 	  names += sizeof ("+0x") - 1;
10947 	  bfd_sprintf_vma (abfd, buf, p->addend);
10948 	  for (a = buf; *a == '0'; ++a)
10949 	    ;
10950 	  len = strlen (a);
10951 	  memcpy (names, a, len);
10952 	  names += len;
10953 	}
10954       memcpy (names, "@plt", sizeof ("@plt"));
10955       names += sizeof ("@plt");
10956       ++s, ++n;
10957     }
10958 
10959   return n;
10960 }
10961 
10962 /* It is only used by x86-64 so far.  */
10963 asection _bfd_elf_large_com_section
10964   = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
10965 		      SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
10966 
10967 void
_bfd_elf_post_process_headers(bfd * abfd,struct bfd_link_info * link_info ATTRIBUTE_UNUSED)10968 _bfd_elf_post_process_headers (bfd * abfd,
10969 			       struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
10970 {
10971   Elf_Internal_Ehdr * i_ehdrp;	/* ELF file header, internal form.  */
10972 
10973   i_ehdrp = elf_elfheader (abfd);
10974 
10975   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
10976 
10977   /* To make things simpler for the loader on Linux systems we set the
10978      osabi field to ELFOSABI_GNU if the binary contains symbols of
10979      the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding.  */
10980   if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
10981       && elf_tdata (abfd)->has_gnu_symbols)
10982     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
10983 }
10984 
10985 
10986 /* Return TRUE for ELF symbol types that represent functions.
10987    This is the default version of this function, which is sufficient for
10988    most targets.  It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC.  */
10989 
10990 bfd_boolean
_bfd_elf_is_function_type(unsigned int type)10991 _bfd_elf_is_function_type (unsigned int type)
10992 {
10993   return (type == STT_FUNC
10994 	  || type == STT_GNU_IFUNC);
10995 }
10996 
10997 /* If the ELF symbol SYM might be a function in SEC, return the
10998    function size and set *CODE_OFF to the function's entry point,
10999    otherwise return zero.  */
11000 
11001 bfd_size_type
_bfd_elf_maybe_function_sym(const asymbol * sym,asection * sec,bfd_vma * code_off)11002 _bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
11003 			     bfd_vma *code_off)
11004 {
11005   bfd_size_type size;
11006 
11007   if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
11008 		     | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
11009       || sym->section != sec)
11010     return 0;
11011 
11012   *code_off = sym->value;
11013   size = 0;
11014   if (!(sym->flags & BSF_SYNTHETIC))
11015     size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
11016   if (size == 0)
11017     size = 1;
11018   return size;
11019 }
11020