1 /* SEC_MERGE support.
2 Copyright (C) 2001-2022 Free Software Foundation, Inc.
3 Written by Jakub Jelinek <jakub@redhat.com>.
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 /* This file contains support for merging duplicate entities within sections,
24 as used in ELF SHF_MERGE. */
25
26 #include "sysdep.h"
27 #include <limits.h>
28 #include "bfd.h"
29 #include "elf-bfd.h"
30 #include "libbfd.h"
31 #include "hashtab.h"
32 #include "libiberty.h"
33
34 struct sec_merge_sec_info;
35
36 /* An entry in the section merge hash table. */
37
38 struct sec_merge_hash_entry
39 {
40 struct bfd_hash_entry root;
41 /* Length of this entry. This includes the zero terminator. */
42 unsigned int len;
43 /* Start of this string needs to be aligned to
44 alignment octets (not 1 << align). */
45 unsigned int alignment;
46 union
47 {
48 /* Index within the merged section. */
49 bfd_size_type index;
50 /* Entry this is a suffix of (if alignment is 0). */
51 struct sec_merge_hash_entry *suffix;
52 } u;
53 /* Which section is it in. */
54 struct sec_merge_sec_info *secinfo;
55 /* Next entity in the hash table. */
56 struct sec_merge_hash_entry *next;
57 };
58
59 /* The section merge hash table. */
60
61 struct sec_merge_hash
62 {
63 struct bfd_hash_table table;
64 /* Next available index. */
65 bfd_size_type size;
66 /* First entity in the SEC_MERGE sections of this type. */
67 struct sec_merge_hash_entry *first;
68 /* Last entity in the SEC_MERGE sections of this type. */
69 struct sec_merge_hash_entry *last;
70 /* Entity size. */
71 unsigned int entsize;
72 /* Are entries fixed size or zero terminated strings? */
73 bool strings;
74 };
75
76 struct sec_merge_info
77 {
78 /* Chain of sec_merge_infos. */
79 struct sec_merge_info *next;
80 /* Chain of sec_merge_sec_infos. */
81 struct sec_merge_sec_info *chain;
82 /* A hash table used to hold section content. */
83 struct sec_merge_hash *htab;
84 };
85
86 struct sec_merge_sec_info
87 {
88 /* Chain of sec_merge_sec_infos. */
89 struct sec_merge_sec_info *next;
90 /* The corresponding section. */
91 asection *sec;
92 /* Pointer to merge_info pointing to us. */
93 void **psecinfo;
94 /* A hash table used to hold section content. */
95 struct sec_merge_hash *htab;
96 /* First string in this section. */
97 struct sec_merge_hash_entry *first_str;
98 /* Original section content. */
99 unsigned char contents[1];
100 };
101
102
103 /* Routine to create an entry in a section merge hashtab. */
104
105 static struct bfd_hash_entry *
sec_merge_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)106 sec_merge_hash_newfunc (struct bfd_hash_entry *entry,
107 struct bfd_hash_table *table, const char *string)
108 {
109 /* Allocate the structure if it has not already been allocated by a
110 subclass. */
111 if (entry == NULL)
112 entry = (struct bfd_hash_entry *)
113 bfd_hash_allocate (table, sizeof (struct sec_merge_hash_entry));
114 if (entry == NULL)
115 return NULL;
116
117 /* Call the allocation method of the superclass. */
118 entry = bfd_hash_newfunc (entry, table, string);
119
120 if (entry != NULL)
121 {
122 /* Initialize the local fields. */
123 struct sec_merge_hash_entry *ret = (struct sec_merge_hash_entry *) entry;
124
125 ret->u.suffix = NULL;
126 ret->alignment = 0;
127 ret->secinfo = NULL;
128 ret->next = NULL;
129 }
130
131 return entry;
132 }
133
134 /* Look up an entry in a section merge hash table. */
135
136 static struct sec_merge_hash_entry *
sec_merge_hash_lookup(struct sec_merge_hash * table,const char * string,unsigned int alignment,bool create)137 sec_merge_hash_lookup (struct sec_merge_hash *table, const char *string,
138 unsigned int alignment, bool create)
139 {
140 const unsigned char *s;
141 unsigned long hash;
142 unsigned int c;
143 struct sec_merge_hash_entry *hashp;
144 unsigned int len, i;
145 unsigned int _index;
146
147 hash = 0;
148 len = 0;
149 s = (const unsigned char *) string;
150 if (table->strings)
151 {
152 if (table->entsize == 1)
153 {
154 while ((c = *s++) != '\0')
155 {
156 hash += c + (c << 17);
157 hash ^= hash >> 2;
158 ++len;
159 }
160 hash += len + (len << 17);
161 }
162 else
163 {
164 for (;;)
165 {
166 for (i = 0; i < table->entsize; ++i)
167 if (s[i] != '\0')
168 break;
169 if (i == table->entsize)
170 break;
171 for (i = 0; i < table->entsize; ++i)
172 {
173 c = *s++;
174 hash += c + (c << 17);
175 hash ^= hash >> 2;
176 }
177 ++len;
178 }
179 hash += len + (len << 17);
180 len *= table->entsize;
181 }
182 hash ^= hash >> 2;
183 len += table->entsize;
184 }
185 else
186 {
187 for (i = 0; i < table->entsize; ++i)
188 {
189 c = *s++;
190 hash += c + (c << 17);
191 hash ^= hash >> 2;
192 }
193 len = table->entsize;
194 }
195
196 _index = hash % table->table.size;
197 for (hashp = (struct sec_merge_hash_entry *) table->table.table[_index];
198 hashp != NULL;
199 hashp = (struct sec_merge_hash_entry *) hashp->root.next)
200 {
201 if (hashp->root.hash == hash
202 && len == hashp->len
203 && memcmp (hashp->root.string, string, len) == 0)
204 {
205 /* If the string we found does not have at least the required
206 alignment, we need to insert another copy. */
207 if (hashp->alignment < alignment)
208 {
209 if (create)
210 {
211 /* Mark the less aligned copy as deleted. */
212 hashp->len = 0;
213 hashp->alignment = 0;
214 }
215 break;
216 }
217 return hashp;
218 }
219 }
220
221 if (! create)
222 return NULL;
223
224 hashp = ((struct sec_merge_hash_entry *)
225 bfd_hash_insert (&table->table, string, hash));
226 if (hashp == NULL)
227 return NULL;
228 hashp->len = len;
229 hashp->alignment = alignment;
230 return hashp;
231 }
232
233 /* Create a new hash table. */
234
235 static struct sec_merge_hash *
sec_merge_init(unsigned int entsize,bool strings)236 sec_merge_init (unsigned int entsize, bool strings)
237 {
238 struct sec_merge_hash *table;
239
240 table = (struct sec_merge_hash *) bfd_malloc (sizeof (struct sec_merge_hash));
241 if (table == NULL)
242 return NULL;
243
244 if (! bfd_hash_table_init_n (&table->table, sec_merge_hash_newfunc,
245 sizeof (struct sec_merge_hash_entry), 16699))
246 {
247 free (table);
248 return NULL;
249 }
250
251 table->size = 0;
252 table->first = NULL;
253 table->last = NULL;
254 table->entsize = entsize;
255 table->strings = strings;
256
257 return table;
258 }
259
260 /* Get the index of an entity in a hash table, adding it if it is not
261 already present. */
262
263 static struct sec_merge_hash_entry *
sec_merge_add(struct sec_merge_hash * tab,const char * str,unsigned int alignment,struct sec_merge_sec_info * secinfo)264 sec_merge_add (struct sec_merge_hash *tab, const char *str,
265 unsigned int alignment, struct sec_merge_sec_info *secinfo)
266 {
267 struct sec_merge_hash_entry *entry;
268
269 entry = sec_merge_hash_lookup (tab, str, alignment, true);
270 if (entry == NULL)
271 return NULL;
272
273 if (entry->secinfo == NULL)
274 {
275 tab->size++;
276 entry->secinfo = secinfo;
277 if (tab->first == NULL)
278 tab->first = entry;
279 else
280 tab->last->next = entry;
281 tab->last = entry;
282 }
283
284 return entry;
285 }
286
287 static bool
sec_merge_emit(bfd * abfd,struct sec_merge_hash_entry * entry,unsigned char * contents,file_ptr offset)288 sec_merge_emit (bfd *abfd, struct sec_merge_hash_entry *entry,
289 unsigned char *contents, file_ptr offset)
290 {
291 struct sec_merge_sec_info *secinfo = entry->secinfo;
292 asection *sec = secinfo->sec;
293 char *pad = NULL;
294 bfd_size_type off = 0;
295 unsigned int opb = bfd_octets_per_byte (abfd, sec);
296 int alignment_power = sec->output_section->alignment_power * opb;
297 bfd_size_type pad_len; /* Octets. */
298
299 /* FIXME: If alignment_power is 0 then really we should scan the
300 entry list for the largest required alignment and use that. */
301 pad_len = alignment_power ? ((bfd_size_type) 1 << alignment_power) : 16;
302
303 pad = (char *) bfd_zmalloc (pad_len);
304 if (pad == NULL)
305 return false;
306
307 for (; entry != NULL && entry->secinfo == secinfo; entry = entry->next)
308 {
309 const char *str;
310 bfd_size_type len;
311
312 len = -off & (entry->alignment - 1);
313 if (len != 0)
314 {
315 BFD_ASSERT (len <= pad_len);
316 if (contents)
317 {
318 memcpy (contents + offset, pad, len);
319 offset += len;
320 }
321 else if (bfd_bwrite (pad, len, abfd) != len)
322 goto err;
323 off += len;
324 }
325
326 str = entry->root.string;
327 len = entry->len;
328
329 if (contents)
330 {
331 memcpy (contents + offset, str, len);
332 offset += len;
333 }
334 else if (bfd_bwrite (str, len, abfd) != len)
335 goto err;
336
337 off += len;
338 }
339
340 /* Trailing alignment needed? */
341 off = sec->size - off;
342 if (off != 0)
343 {
344 BFD_ASSERT (off <= pad_len);
345 if (contents)
346 memcpy (contents + offset, pad, off);
347 else if (bfd_bwrite (pad, off, abfd) != off)
348 goto err;
349 }
350
351 free (pad);
352 return true;
353
354 err:
355 free (pad);
356 return false;
357 }
358
359 /* Register a SEC_MERGE section as a candidate for merging.
360 This function is called for all non-dynamic SEC_MERGE input sections. */
361
362 bool
_bfd_add_merge_section(bfd * abfd,void ** psinfo,asection * sec,void ** psecinfo)363 _bfd_add_merge_section (bfd *abfd, void **psinfo, asection *sec,
364 void **psecinfo)
365 {
366 struct sec_merge_info *sinfo;
367 struct sec_merge_sec_info *secinfo;
368 unsigned int alignment_power; /* Octets. */
369 unsigned int align; /* Octets. */
370 bfd_size_type amt;
371 bfd_byte *contents;
372 unsigned int opb = bfd_octets_per_byte (abfd, sec);
373
374 if ((abfd->flags & DYNAMIC) != 0
375 || (sec->flags & SEC_MERGE) == 0)
376 abort ();
377
378 if (sec->size == 0
379 || (sec->flags & SEC_EXCLUDE) != 0
380 || sec->entsize == 0)
381 return true;
382
383 if (sec->size % sec->entsize != 0)
384 return true;
385
386 if ((sec->flags & SEC_RELOC) != 0)
387 {
388 /* We aren't prepared to handle relocations in merged sections. */
389 return true;
390 }
391
392 #ifndef CHAR_BIT
393 #define CHAR_BIT 8
394 #endif
395 alignment_power = sec->alignment_power * opb;
396 if (alignment_power >= sizeof (align) * CHAR_BIT)
397 return true;
398
399 align = 1u << alignment_power;
400 if ((sec->entsize < align
401 && ((sec->entsize & (sec->entsize - 1))
402 || !(sec->flags & SEC_STRINGS)))
403 || (sec->entsize > align
404 && (sec->entsize & (align - 1))))
405 {
406 /* Sanity check. If string character size is smaller than
407 alignment, then we require character size to be a power
408 of 2, otherwise character size must be integer multiple
409 of alignment. For non-string constants, alignment must
410 be smaller than or equal to entity size and entity size
411 must be integer multiple of alignment. */
412 return true;
413 }
414
415 for (sinfo = (struct sec_merge_info *) *psinfo; sinfo; sinfo = sinfo->next)
416 if ((secinfo = sinfo->chain)
417 && ! ((secinfo->sec->flags ^ sec->flags) & (SEC_MERGE | SEC_STRINGS))
418 && secinfo->sec->entsize == sec->entsize
419 && secinfo->sec->alignment_power == sec->alignment_power
420 && secinfo->sec->output_section == sec->output_section)
421 break;
422
423 if (sinfo == NULL)
424 {
425 /* Initialize the information we need to keep track of. */
426 sinfo = (struct sec_merge_info *)
427 bfd_alloc (abfd, sizeof (struct sec_merge_info));
428 if (sinfo == NULL)
429 goto error_return;
430 sinfo->next = (struct sec_merge_info *) *psinfo;
431 sinfo->chain = NULL;
432 *psinfo = sinfo;
433 sinfo->htab = sec_merge_init (sec->entsize, (sec->flags & SEC_STRINGS));
434 if (sinfo->htab == NULL)
435 goto error_return;
436 }
437
438 /* Read the section from abfd. */
439
440 amt = sizeof (struct sec_merge_sec_info) - 1 + sec->size;
441 if (sec->flags & SEC_STRINGS)
442 /* Some versions of gcc may emit a string without a zero terminator.
443 See http://gcc.gnu.org/ml/gcc-patches/2006-06/msg01004.html
444 Allocate space for an extra zero. */
445 amt += sec->entsize;
446 *psecinfo = bfd_alloc (abfd, amt);
447 if (*psecinfo == NULL)
448 goto error_return;
449
450 secinfo = (struct sec_merge_sec_info *) *psecinfo;
451 if (sinfo->chain)
452 {
453 secinfo->next = sinfo->chain->next;
454 sinfo->chain->next = secinfo;
455 }
456 else
457 secinfo->next = secinfo;
458 sinfo->chain = secinfo;
459 secinfo->sec = sec;
460 secinfo->psecinfo = psecinfo;
461 secinfo->htab = sinfo->htab;
462 secinfo->first_str = NULL;
463
464 sec->rawsize = sec->size;
465 if (sec->flags & SEC_STRINGS)
466 memset (secinfo->contents + sec->size, 0, sec->entsize);
467 contents = secinfo->contents;
468 if (! bfd_get_full_section_contents (sec->owner, sec, &contents))
469 goto error_return;
470
471 return true;
472
473 error_return:
474 *psecinfo = NULL;
475 return false;
476 }
477
478 /* Record one section into the hash table. */
479 static bool
record_section(struct sec_merge_info * sinfo,struct sec_merge_sec_info * secinfo)480 record_section (struct sec_merge_info *sinfo,
481 struct sec_merge_sec_info *secinfo)
482 {
483 asection *sec = secinfo->sec;
484 struct sec_merge_hash_entry *entry;
485 bool nul;
486 unsigned char *p, *end;
487 bfd_vma mask, eltalign;
488 unsigned int align, i;
489
490 align = sec->alignment_power;
491 end = secinfo->contents + sec->size;
492 nul = false;
493 mask = ((bfd_vma) 1 << align) - 1;
494 if (sec->flags & SEC_STRINGS)
495 {
496 for (p = secinfo->contents; p < end; )
497 {
498 eltalign = p - secinfo->contents;
499 eltalign = ((eltalign ^ (eltalign - 1)) + 1) >> 1;
500 if (!eltalign || eltalign > mask)
501 eltalign = mask + 1;
502 entry = sec_merge_add (sinfo->htab, (char *) p, (unsigned) eltalign,
503 secinfo);
504 if (! entry)
505 goto error_return;
506 p += entry->len;
507 if (sec->entsize == 1)
508 {
509 while (p < end && *p == 0)
510 {
511 if (!nul && !((p - secinfo->contents) & mask))
512 {
513 nul = true;
514 entry = sec_merge_add (sinfo->htab, "",
515 (unsigned) mask + 1, secinfo);
516 if (! entry)
517 goto error_return;
518 }
519 p++;
520 }
521 }
522 else
523 {
524 while (p < end)
525 {
526 for (i = 0; i < sec->entsize; i++)
527 if (p[i] != '\0')
528 break;
529 if (i != sec->entsize)
530 break;
531 if (!nul && !((p - secinfo->contents) & mask))
532 {
533 nul = true;
534 entry = sec_merge_add (sinfo->htab, (char *) p,
535 (unsigned) mask + 1, secinfo);
536 if (! entry)
537 goto error_return;
538 }
539 p += sec->entsize;
540 }
541 }
542 }
543 }
544 else
545 {
546 for (p = secinfo->contents; p < end; p += sec->entsize)
547 {
548 entry = sec_merge_add (sinfo->htab, (char *) p, 1, secinfo);
549 if (! entry)
550 goto error_return;
551 }
552 }
553
554 return true;
555
556 error_return:
557 for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
558 *secinfo->psecinfo = NULL;
559 return false;
560 }
561
562 /* qsort comparison function. Won't ever return zero as all entries
563 differ, so there is no issue with qsort stability here. */
564
565 static int
strrevcmp(const void * a,const void * b)566 strrevcmp (const void *a, const void *b)
567 {
568 struct sec_merge_hash_entry *A = *(struct sec_merge_hash_entry **) a;
569 struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
570 unsigned int lenA = A->len;
571 unsigned int lenB = B->len;
572 const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1;
573 const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1;
574 int l = lenA < lenB ? lenA : lenB;
575
576 while (l)
577 {
578 if (*s != *t)
579 return (int) *s - (int) *t;
580 s--;
581 t--;
582 l--;
583 }
584 return lenA - lenB;
585 }
586
587 /* Like strrevcmp, but for the case where all strings have the same
588 alignment > entsize. */
589
590 static int
strrevcmp_align(const void * a,const void * b)591 strrevcmp_align (const void *a, const void *b)
592 {
593 struct sec_merge_hash_entry *A = *(struct sec_merge_hash_entry **) a;
594 struct sec_merge_hash_entry *B = *(struct sec_merge_hash_entry **) b;
595 unsigned int lenA = A->len;
596 unsigned int lenB = B->len;
597 const unsigned char *s = (const unsigned char *) A->root.string + lenA - 1;
598 const unsigned char *t = (const unsigned char *) B->root.string + lenB - 1;
599 int l = lenA < lenB ? lenA : lenB;
600 int tail_align = (lenA & (A->alignment - 1)) - (lenB & (A->alignment - 1));
601
602 if (tail_align != 0)
603 return tail_align;
604
605 while (l)
606 {
607 if (*s != *t)
608 return (int) *s - (int) *t;
609 s--;
610 t--;
611 l--;
612 }
613 return lenA - lenB;
614 }
615
616 static inline int
is_suffix(const struct sec_merge_hash_entry * A,const struct sec_merge_hash_entry * B)617 is_suffix (const struct sec_merge_hash_entry *A,
618 const struct sec_merge_hash_entry *B)
619 {
620 if (A->len <= B->len)
621 /* B cannot be a suffix of A unless A is equal to B, which is guaranteed
622 not to be equal by the hash table. */
623 return 0;
624
625 return memcmp (A->root.string + (A->len - B->len),
626 B->root.string, B->len) == 0;
627 }
628
629 /* This is a helper function for _bfd_merge_sections. It attempts to
630 merge strings matching suffixes of longer strings. */
631 static struct sec_merge_sec_info *
merge_strings(struct sec_merge_info * sinfo)632 merge_strings (struct sec_merge_info *sinfo)
633 {
634 struct sec_merge_hash_entry **array, **a, *e;
635 struct sec_merge_sec_info *secinfo;
636 bfd_size_type size, amt;
637 unsigned int alignment = 0;
638
639 /* Now sort the strings */
640 amt = sinfo->htab->size * sizeof (struct sec_merge_hash_entry *);
641 array = (struct sec_merge_hash_entry **) bfd_malloc (amt);
642 if (array == NULL)
643 return NULL;
644
645 for (e = sinfo->htab->first, a = array; e; e = e->next)
646 if (e->alignment)
647 {
648 *a++ = e;
649 /* Adjust the length to not include the zero terminator. */
650 e->len -= sinfo->htab->entsize;
651 if (alignment != e->alignment)
652 {
653 if (alignment == 0)
654 alignment = e->alignment;
655 else
656 alignment = (unsigned) -1;
657 }
658 }
659
660 sinfo->htab->size = a - array;
661 if (sinfo->htab->size != 0)
662 {
663 qsort (array, (size_t) sinfo->htab->size,
664 sizeof (struct sec_merge_hash_entry *),
665 (alignment != (unsigned) -1 && alignment > sinfo->htab->entsize
666 ? strrevcmp_align : strrevcmp));
667
668 /* Loop over the sorted array and merge suffixes */
669 e = *--a;
670 e->len += sinfo->htab->entsize;
671 while (--a >= array)
672 {
673 struct sec_merge_hash_entry *cmp = *a;
674
675 cmp->len += sinfo->htab->entsize;
676 if (e->alignment >= cmp->alignment
677 && !((e->len - cmp->len) & (cmp->alignment - 1))
678 && is_suffix (e, cmp))
679 {
680 cmp->u.suffix = e;
681 cmp->alignment = 0;
682 }
683 else
684 e = cmp;
685 }
686 }
687
688 free (array);
689
690 /* Now assign positions to the strings we want to keep. */
691 size = 0;
692 secinfo = sinfo->htab->first->secinfo;
693 for (e = sinfo->htab->first; e; e = e->next)
694 {
695 if (e->secinfo != secinfo)
696 {
697 secinfo->sec->size = size;
698 secinfo = e->secinfo;
699 }
700 if (e->alignment)
701 {
702 if (e->secinfo->first_str == NULL)
703 {
704 e->secinfo->first_str = e;
705 size = 0;
706 }
707 size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1);
708 e->u.index = size;
709 size += e->len;
710 }
711 }
712 secinfo->sec->size = size;
713
714 /* And now adjust the rest, removing them from the chain (but not hashtable)
715 at the same time. */
716 for (a = &sinfo->htab->first, e = *a; e; e = e->next)
717 if (e->alignment)
718 a = &e->next;
719 else
720 {
721 *a = e->next;
722 if (e->len)
723 {
724 e->secinfo = e->u.suffix->secinfo;
725 e->alignment = e->u.suffix->alignment;
726 e->u.index = e->u.suffix->u.index + (e->u.suffix->len - e->len);
727 }
728 }
729 return secinfo;
730 }
731
732 /* This function is called once after all SEC_MERGE sections are registered
733 with _bfd_merge_section. */
734
735 bool
_bfd_merge_sections(bfd * abfd,struct bfd_link_info * info ATTRIBUTE_UNUSED,void * xsinfo,void (* remove_hook)(bfd *,asection *))736 _bfd_merge_sections (bfd *abfd,
737 struct bfd_link_info *info ATTRIBUTE_UNUSED,
738 void *xsinfo,
739 void (*remove_hook) (bfd *, asection *))
740 {
741 struct sec_merge_info *sinfo;
742
743 for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next)
744 {
745 struct sec_merge_sec_info *secinfo;
746 bfd_size_type align; /* Bytes. */
747
748 if (! sinfo->chain)
749 continue;
750
751 /* Move sinfo->chain to head of the chain, terminate it. */
752 secinfo = sinfo->chain;
753 sinfo->chain = secinfo->next;
754 secinfo->next = NULL;
755
756 /* Record the sections into the hash table. */
757 align = 1;
758 for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
759 if (secinfo->sec->flags & SEC_EXCLUDE)
760 {
761 *secinfo->psecinfo = NULL;
762 if (remove_hook)
763 (*remove_hook) (abfd, secinfo->sec);
764 }
765 else
766 {
767 if (!record_section (sinfo, secinfo))
768 return false;
769 if (align)
770 {
771 unsigned int opb = bfd_octets_per_byte (abfd, secinfo->sec);
772
773 align = (bfd_size_type) 1 << secinfo->sec->alignment_power;
774 if (((secinfo->sec->size / opb) & (align - 1)) != 0)
775 align = 0;
776 }
777 }
778
779 if (sinfo->htab->first == NULL)
780 continue;
781
782 if (sinfo->htab->strings)
783 {
784 secinfo = merge_strings (sinfo);
785 if (!secinfo)
786 return false;
787 }
788 else
789 {
790 struct sec_merge_hash_entry *e;
791 bfd_size_type size = 0; /* Octets. */
792
793 /* Things are much simpler for non-strings.
794 Just assign them slots in the section. */
795 secinfo = NULL;
796 for (e = sinfo->htab->first; e; e = e->next)
797 {
798 if (e->secinfo->first_str == NULL)
799 {
800 if (secinfo)
801 secinfo->sec->size = size;
802 e->secinfo->first_str = e;
803 size = 0;
804 }
805 size = (size + e->alignment - 1) & ~((bfd_vma) e->alignment - 1);
806 e->u.index = size;
807 size += e->len;
808 secinfo = e->secinfo;
809 }
810 secinfo->sec->size = size;
811 }
812
813 /* If the input sections were padded according to their alignments,
814 then pad the output too. */
815 if (align)
816 secinfo->sec->size = (secinfo->sec->size + align - 1) & -align;
817
818 /* Finally remove all input sections which have not made it into
819 the hash table at all. */
820 for (secinfo = sinfo->chain; secinfo; secinfo = secinfo->next)
821 if (secinfo->first_str == NULL)
822 secinfo->sec->flags |= SEC_EXCLUDE | SEC_KEEP;
823 }
824
825 return true;
826 }
827
828 /* Write out the merged section. */
829
830 bool
_bfd_write_merged_section(bfd * output_bfd,asection * sec,void * psecinfo)831 _bfd_write_merged_section (bfd *output_bfd, asection *sec, void *psecinfo)
832 {
833 struct sec_merge_sec_info *secinfo;
834 file_ptr pos;
835 unsigned char *contents;
836 Elf_Internal_Shdr *hdr;
837
838 secinfo = (struct sec_merge_sec_info *) psecinfo;
839
840 if (!secinfo)
841 return false;
842
843 if (secinfo->first_str == NULL)
844 return true;
845
846 /* FIXME: octets_per_byte. */
847 hdr = &elf_section_data (sec->output_section)->this_hdr;
848 if (hdr->sh_offset == (file_ptr) -1)
849 {
850 /* We must compress this section. Write output to the
851 buffer. */
852 contents = hdr->contents;
853 if ((sec->output_section->flags & SEC_ELF_COMPRESS) == 0
854 || contents == NULL)
855 abort ();
856 }
857 else
858 {
859 contents = NULL;
860 pos = sec->output_section->filepos + sec->output_offset;
861 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0)
862 return false;
863 }
864
865 if (! sec_merge_emit (output_bfd, secinfo->first_str, contents,
866 sec->output_offset))
867 return false;
868
869 return true;
870 }
871
872 /* Adjust an address in the SEC_MERGE section. Given OFFSET within
873 *PSEC, this returns the new offset in the adjusted SEC_MERGE
874 section and writes the new section back into *PSEC. */
875
876 bfd_vma
_bfd_merged_section_offset(bfd * output_bfd ATTRIBUTE_UNUSED,asection ** psec,void * psecinfo,bfd_vma offset)877 _bfd_merged_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED, asection **psec,
878 void *psecinfo, bfd_vma offset)
879 {
880 struct sec_merge_sec_info *secinfo;
881 struct sec_merge_hash_entry *entry;
882 unsigned char *p;
883 asection *sec = *psec;
884
885 secinfo = (struct sec_merge_sec_info *) psecinfo;
886
887 if (!secinfo)
888 return offset;
889
890 if (offset >= sec->rawsize)
891 {
892 if (offset > sec->rawsize)
893 _bfd_error_handler
894 /* xgettext:c-format */
895 (_("%pB: access beyond end of merged section (%" PRId64 ")"),
896 sec->owner, (int64_t) offset);
897 return secinfo->first_str ? sec->size : 0;
898 }
899
900 if (secinfo->htab->strings)
901 {
902 if (sec->entsize == 1)
903 {
904 p = secinfo->contents + offset - 1;
905 while (p >= secinfo->contents && *p)
906 --p;
907 ++p;
908 }
909 else
910 {
911 p = secinfo->contents + (offset / sec->entsize) * sec->entsize;
912 p -= sec->entsize;
913 while (p >= secinfo->contents)
914 {
915 unsigned int i;
916
917 for (i = 0; i < sec->entsize; ++i)
918 if (p[i] != '\0')
919 break;
920 if (i == sec->entsize)
921 break;
922 p -= sec->entsize;
923 }
924 p += sec->entsize;
925 }
926 }
927 else
928 {
929 p = secinfo->contents + (offset / sec->entsize) * sec->entsize;
930 }
931 entry = sec_merge_hash_lookup (secinfo->htab, (char *) p, 0, false);
932 if (!entry)
933 {
934 if (! secinfo->htab->strings)
935 abort ();
936 /* This should only happen if somebody points into the padding
937 after a NUL character but before next entity. */
938 if (*p)
939 abort ();
940 if (! secinfo->htab->first)
941 abort ();
942 entry = secinfo->htab->first;
943 p = (secinfo->contents + (offset / sec->entsize + 1) * sec->entsize
944 - entry->len);
945 }
946
947 *psec = entry->secinfo->sec;
948 return entry->u.index + (secinfo->contents + offset - p);
949 }
950
951 /* Tidy up when done. */
952
953 void
_bfd_merge_sections_free(void * xsinfo)954 _bfd_merge_sections_free (void *xsinfo)
955 {
956 struct sec_merge_info *sinfo;
957
958 for (sinfo = (struct sec_merge_info *) xsinfo; sinfo; sinfo = sinfo->next)
959 {
960 bfd_hash_table_free (&sinfo->htab->table);
961 free (sinfo->htab);
962 }
963 }
964