1 /* ELF program property support.
2 Copyright (C) 2017-2018 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
21 /* GNU program property draft is at:
23 https://github.com/hjl-tools/linux-abi/wiki/property-draft.pdf
31 /* Get a property, allocate a new one if needed. */
34 _bfd_elf_get_property (bfd
*abfd
, unsigned int type
, unsigned int datasz
)
36 elf_property_list
*p
, **lastp
;
38 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
40 /* Never should happen. */
44 /* Keep the property list in order of type. */
45 lastp
= &elf_properties (abfd
);
46 for (p
= *lastp
; p
; p
= p
->next
)
48 /* Reuse the existing entry. */
49 if (type
== p
->property
.pr_type
)
51 if (datasz
> p
->property
.pr_datasz
)
53 /* This can happen when mixing 32-bit and 64-bit objects. */
54 p
->property
.pr_datasz
= datasz
;
58 else if (type
< p
->property
.pr_type
)
62 p
= (elf_property_list
*) bfd_alloc (abfd
, sizeof (*p
));
65 _bfd_error_handler (_("%pB: out of memory in _bfd_elf_get_property"),
69 memset (p
, 0, sizeof (*p
));
70 p
->property
.pr_type
= type
;
71 p
->property
.pr_datasz
= datasz
;
77 /* Parse GNU properties. */
80 _bfd_elf_parse_gnu_properties (bfd
*abfd
, Elf_Internal_Note
*note
)
82 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
83 unsigned int align_size
= bed
->s
->elfclass
== ELFCLASS64
? 8 : 4;
84 bfd_byte
*ptr
= (bfd_byte
*) note
->descdata
;
85 bfd_byte
*ptr_end
= ptr
+ note
->descsz
;
87 if (note
->descsz
< 8 || (note
->descsz
% align_size
) != 0)
91 (_("warning: %pB: corrupt GNU_PROPERTY_TYPE (%ld) size: %#lx"),
92 abfd
, note
->type
, note
->descsz
);
96 while (ptr
!= ptr_end
)
102 if ((size_t) (ptr_end
- ptr
) < 8)
105 type
= bfd_h_get_32 (abfd
, ptr
);
106 datasz
= bfd_h_get_32 (abfd
, ptr
+ 4);
109 if (datasz
> (size_t) (ptr_end
- ptr
))
112 (_("warning: %pB: corrupt GNU_PROPERTY_TYPE (%ld) type (0x%x) datasz: 0x%x"),
113 abfd
, note
->type
, type
, datasz
);
114 /* Clear all properties. */
115 elf_properties (abfd
) = NULL
;
119 if (type
>= GNU_PROPERTY_LOPROC
)
121 if (bed
->elf_machine_code
== EM_NONE
)
123 /* Ignore processor-specific properties with generic ELF
124 target vector. They should be handled by the matching
125 ELF target vector. */
128 else if (type
< GNU_PROPERTY_LOUSER
129 && bed
->parse_gnu_properties
)
131 enum elf_property_kind kind
132 = bed
->parse_gnu_properties (abfd
, type
, ptr
, datasz
);
133 if (kind
== property_corrupt
)
135 /* Clear all properties. */
136 elf_properties (abfd
) = NULL
;
139 else if (kind
!= property_ignored
)
147 case GNU_PROPERTY_STACK_SIZE
:
148 if (datasz
!= align_size
)
151 (_("warning: %pB: corrupt stack size: 0x%x"),
153 /* Clear all properties. */
154 elf_properties (abfd
) = NULL
;
157 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
159 prop
->u
.number
= bfd_h_get_64 (abfd
, ptr
);
161 prop
->u
.number
= bfd_h_get_32 (abfd
, ptr
);
162 prop
->pr_kind
= property_number
;
165 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
169 (_("warning: %pB: corrupt no copy on protected size: 0x%x"),
171 /* Clear all properties. */
172 elf_properties (abfd
) = NULL
;
175 prop
= _bfd_elf_get_property (abfd
, type
, datasz
);
176 elf_has_no_copy_on_protected (abfd
) = TRUE
;
177 prop
->pr_kind
= property_number
;
186 (_("warning: %pB: unsupported GNU_PROPERTY_TYPE (%ld) type: 0x%x"),
187 abfd
, note
->type
, type
);
190 ptr
+= (datasz
+ (align_size
- 1)) & ~ (align_size
- 1);
196 /* Merge GNU property BPROP with APROP. If APROP isn't NULL, return TRUE
197 if APROP is updated. Otherwise, return TRUE if BPROP should be merged
201 elf_merge_gnu_properties (struct bfd_link_info
*info
, bfd
*abfd
,
202 elf_property
*aprop
, elf_property
*bprop
)
204 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
205 unsigned int pr_type
= aprop
!= NULL
? aprop
->pr_type
: bprop
->pr_type
;
207 if (bed
->merge_gnu_properties
!= NULL
208 && pr_type
>= GNU_PROPERTY_LOPROC
209 && pr_type
< GNU_PROPERTY_LOUSER
)
210 return bed
->merge_gnu_properties (info
, abfd
, aprop
, bprop
);
214 case GNU_PROPERTY_STACK_SIZE
:
215 if (aprop
!= NULL
&& bprop
!= NULL
)
217 if (bprop
->u
.number
> aprop
->u
.number
)
219 aprop
->u
.number
= bprop
->u
.number
;
226 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
227 /* Return TRUE if APROP is NULL to indicate that BPROP should
229 return aprop
== NULL
;
232 /* Never should happen. */
239 /* Return the property of TYPE on *LISTP and remove it from *LISTP.
240 Return NULL if not found. */
242 static elf_property
*
243 elf_find_and_remove_property (elf_property_list
**listp
,
246 elf_property_list
*list
;
248 for (list
= *listp
; list
; list
= list
->next
)
250 if (type
== list
->property
.pr_type
)
252 /* Remove this property. */
254 return &list
->property
;
256 else if (type
< list
->property
.pr_type
)
264 /* Merge GNU property list *LISTP with ABFD. */
267 elf_merge_gnu_property_list (struct bfd_link_info
*info
, bfd
*abfd
,
268 elf_property_list
**listp
)
270 elf_property_list
*p
, **lastp
;
273 /* Merge each GNU property in ABFD with the one on *LISTP. */
274 lastp
= &elf_properties (abfd
);
275 for (p
= *lastp
; p
; p
= p
->next
)
277 pr
= elf_find_and_remove_property (listp
, p
->property
.pr_type
);
278 /* Pass NULL to elf_merge_gnu_properties for the property which
280 elf_merge_gnu_properties (info
, abfd
, &p
->property
, pr
);
281 if (p
->property
.pr_kind
== property_remove
)
283 /* Remove this property. */
290 /* Merge the remaining properties on *LISTP with ABFD. */
291 for (p
= *listp
; p
!= NULL
; p
= p
->next
)
292 if (elf_merge_gnu_properties (info
, abfd
, NULL
, &p
->property
))
294 if (p
->property
.pr_type
== GNU_PROPERTY_NO_COPY_ON_PROTECTED
)
295 elf_has_no_copy_on_protected (abfd
) = TRUE
;
297 pr
= _bfd_elf_get_property (abfd
, p
->property
.pr_type
,
298 p
->property
.pr_datasz
);
299 /* It must be a new property. */
300 if (pr
->pr_kind
!= property_unknown
)
302 /* Add a new property. */
307 /* Get GNU property section size. */
310 elf_get_gnu_property_section_size (elf_property_list
*list
,
311 unsigned int align_size
)
316 /* Compute the output section size. */
317 descsz
= offsetof (Elf_External_Note
, name
[sizeof "GNU"]);
318 descsz
= (descsz
+ 3) & -(unsigned int) 4;
320 for (; list
!= NULL
; list
= list
->next
)
322 /* There are 4 byte type + 4 byte datasz for each property. */
323 size
+= 4 + 4 + list
->property
.pr_datasz
;
324 /* Align each property. */
325 size
= (size
+ (align_size
- 1)) & ~(align_size
- 1);
331 /* Write GNU properties. */
334 elf_write_gnu_properties (bfd
*abfd
, bfd_byte
*contents
,
335 elf_property_list
*list
, unsigned int size
,
336 unsigned int align_size
)
339 Elf_External_Note
*e_note
;
341 e_note
= (Elf_External_Note
*) contents
;
342 descsz
= offsetof (Elf_External_Note
, name
[sizeof "GNU"]);
343 descsz
= (descsz
+ 3) & -(unsigned int) 4;
344 bfd_h_put_32 (abfd
, sizeof "GNU", &e_note
->namesz
);
345 bfd_h_put_32 (abfd
, size
- descsz
, &e_note
->descsz
);
346 bfd_h_put_32 (abfd
, NT_GNU_PROPERTY_TYPE_0
, &e_note
->type
);
347 memcpy (e_note
->name
, "GNU", sizeof "GNU");
350 for (; list
!= NULL
; list
= list
->next
)
352 /* There are 4 byte type + 4 byte datasz for each property. */
353 bfd_h_put_32 (abfd
, list
->property
.pr_type
,
355 bfd_h_put_32 (abfd
, list
->property
.pr_datasz
,
356 contents
+ size
+ 4);
359 /* Write out property value. */
360 switch (list
->property
.pr_kind
)
362 case property_number
:
363 switch (list
->property
.pr_datasz
)
366 /* Never should happen. */
373 bfd_h_put_32 (abfd
, list
->property
.u
.number
,
378 bfd_h_put_64 (abfd
, list
->property
.u
.number
,
385 /* Never should happen. */
388 size
+= list
->property
.pr_datasz
;
390 /* Align each property. */
391 size
= (size
+ (align_size
- 1)) & ~ (align_size
- 1);
395 /* Set up GNU properties. Return the first relocatable ELF input with
396 GNU properties if found. Otherwise, return NULL. */
399 _bfd_elf_link_setup_gnu_properties (struct bfd_link_info
*info
)
401 bfd
*abfd
, *first_pbfd
= NULL
;
402 elf_property_list
*list
;
404 bfd_boolean has_properties
= FALSE
;
405 const struct elf_backend_data
*bed
406 = get_elf_backend_data (info
->output_bfd
);
407 unsigned int elfclass
= bed
->s
->elfclass
;
408 int elf_machine_code
= bed
->elf_machine_code
;
410 /* Find the first relocatable ELF input with GNU properties. */
411 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
412 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
413 && (abfd
->flags
& DYNAMIC
) == 0
414 && elf_properties (abfd
) != NULL
)
416 has_properties
= TRUE
;
418 /* Ignore GNU properties from ELF objects with different machine
419 code or class. Also skip objects without a GNU_PROPERTY note
421 if ((elf_machine_code
422 == get_elf_backend_data (abfd
)->elf_machine_code
)
424 == get_elf_backend_data (abfd
)->s
->elfclass
)
425 && bfd_get_section_by_name (abfd
,
426 NOTE_GNU_PROPERTY_SECTION_NAME
) != NULL
429 /* Keep .note.gnu.property section in FIRST_PBFD. */
435 /* Do nothing if there is no .note.gnu.property section. */
439 /* Merge .note.gnu.property sections. */
440 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
441 if (abfd
!= first_pbfd
&& (abfd
->flags
& DYNAMIC
) == 0)
443 elf_property_list
*null_ptr
= NULL
;
444 elf_property_list
**listp
= &null_ptr
;
446 /* Merge .note.gnu.property section in relocatable ELF input. */
447 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
449 list
= elf_properties (abfd
);
451 /* Ignore GNU properties from ELF objects with different
455 == get_elf_backend_data (abfd
)->elf_machine_code
))
456 listp
= &elf_properties (abfd
);
461 /* Merge properties with FIRST_PBFD. FIRST_PBFD can be NULL
462 when all properties are from ELF objects with different
463 machine code or class. */
464 if (first_pbfd
!= NULL
)
465 elf_merge_gnu_property_list (info
, first_pbfd
, listp
);
469 /* Discard the .note.gnu.property section in this bfd. */
470 sec
= bfd_get_section_by_name (abfd
,
471 NOTE_GNU_PROPERTY_SECTION_NAME
);
473 sec
->output_section
= bfd_abs_section_ptr
;
477 /* Rewrite .note.gnu.property section so that GNU properties are
478 always sorted by type even if input GNU properties aren't sorted. */
479 if (first_pbfd
!= NULL
)
483 unsigned int align_size
= bed
->s
->elfclass
== ELFCLASS64
? 8 : 4;
485 sec
= bfd_get_section_by_name (first_pbfd
,
486 NOTE_GNU_PROPERTY_SECTION_NAME
);
487 BFD_ASSERT (sec
!= NULL
);
489 /* Update stack size in .note.gnu.property with -z stack-size=N
491 if (info
->stacksize
> 0)
494 bfd_vma stacksize
= info
->stacksize
;
496 p
= _bfd_elf_get_property (first_pbfd
, GNU_PROPERTY_STACK_SIZE
,
498 if (p
->pr_kind
== property_unknown
)
500 /* Create GNU_PROPERTY_STACK_SIZE. */
501 p
->u
.number
= stacksize
;
502 p
->pr_kind
= property_number
;
504 else if (stacksize
> p
->u
.number
)
505 p
->u
.number
= stacksize
;
507 else if (elf_properties (first_pbfd
) == NULL
)
509 /* Discard .note.gnu.property section if all properties have
511 sec
->output_section
= bfd_abs_section_ptr
;
515 /* Compute the section size. */
516 list
= elf_properties (first_pbfd
);
517 size
= elf_get_gnu_property_section_size (list
, align_size
);
519 /* Update .note.gnu.property section now. */
521 contents
= (bfd_byte
*) bfd_zalloc (first_pbfd
, size
);
523 elf_write_gnu_properties (first_pbfd
, contents
, list
, size
,
526 /* Cache the section contents for elf_link_input_bfd. */
527 elf_section_data (sec
)->this_hdr
.contents
= contents
;
529 /* If GNU_PROPERTY_NO_COPY_ON_PROTECTED is set, protected data
530 symbol is defined in the shared object. */
531 if (elf_has_no_copy_on_protected (first_pbfd
))
532 info
->extern_protected_data
= FALSE
;
538 /* Convert GNU property size. */
541 _bfd_elf_convert_gnu_property_size (bfd
*ibfd
, bfd
*obfd
)
543 unsigned int align_size
;
544 const struct elf_backend_data
*bed
;
545 elf_property_list
*list
= elf_properties (ibfd
);
547 bed
= get_elf_backend_data (obfd
);
548 align_size
= bed
->s
->elfclass
== ELFCLASS64
? 8 : 4;
550 /* Get the output .note.gnu.property section size. */
551 return elf_get_gnu_property_section_size (list
, align_size
);
554 /* Convert GNU properties. */
557 _bfd_elf_convert_gnu_properties (bfd
*ibfd
, asection
*isec
,
558 bfd
*obfd
, bfd_byte
**ptr
,
559 bfd_size_type
*ptr_size
)
563 unsigned int align_shift
;
564 const struct elf_backend_data
*bed
;
565 elf_property_list
*list
= elf_properties (ibfd
);
567 bed
= get_elf_backend_data (obfd
);
568 align_shift
= bed
->s
->elfclass
== ELFCLASS64
? 3 : 2;
570 /* Get the output .note.gnu.property section size. */
571 size
= bfd_get_section_size (isec
->output_section
);
573 /* Update the output .note.gnu.property section alignment. */
574 bfd_set_section_alignment (obfd
, isec
->output_section
, align_shift
);
576 if (size
> bfd_get_section_size (isec
))
578 contents
= (bfd_byte
*) bfd_malloc (size
);
587 /* Generate the output .note.gnu.property section. */
588 elf_write_gnu_properties (ibfd
, contents
, list
, size
, 1 << align_shift
);