1 /* Assorted BFD support routines, only used internally.
2 Copyright (C) 1990-2024 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
28 #ifndef HAVE_GETPAGESIZE
29 #define getpagesize() 2048
34 Implementation details
40 These routines are used within BFD.
41 They are not intended for export, but are documented here for
46 _bfd_bool_bfd_false (bfd
*abfd ATTRIBUTE_UNUSED
)
52 _bfd_bool_bfd_asymbol_false (bfd
*abfd ATTRIBUTE_UNUSED
,
53 asymbol
*sym ATTRIBUTE_UNUSED
)
58 /* A routine which is used in target vectors for unsupported
62 _bfd_bool_bfd_false_error (bfd
*ignore ATTRIBUTE_UNUSED
)
64 bfd_set_error (bfd_error_invalid_operation
);
69 _bfd_bool_bfd_link_false_error (bfd
*abfd
,
70 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
72 return _bfd_bool_bfd_false_error (abfd
);
75 /* A routine which is used in target vectors for supported operations
76 which do not actually do anything. */
79 _bfd_bool_bfd_true (bfd
*ignore ATTRIBUTE_UNUSED
)
85 _bfd_bool_bfd_link_true (bfd
*abfd ATTRIBUTE_UNUSED
,
86 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
92 _bfd_bool_bfd_bfd_true (bfd
*ibfd ATTRIBUTE_UNUSED
,
93 bfd
*obfd ATTRIBUTE_UNUSED
)
99 _bfd_bool_bfd_uint_true (bfd
*abfd ATTRIBUTE_UNUSED
,
100 unsigned int flags ATTRIBUTE_UNUSED
)
106 _bfd_bool_bfd_asection_bfd_asection_true (bfd
*ibfd ATTRIBUTE_UNUSED
,
107 asection
*isec ATTRIBUTE_UNUSED
,
108 bfd
*obfd ATTRIBUTE_UNUSED
,
109 asection
*osec ATTRIBUTE_UNUSED
)
115 _bfd_bool_bfd_asymbol_bfd_asymbol_true (bfd
*ibfd ATTRIBUTE_UNUSED
,
116 asymbol
*isym ATTRIBUTE_UNUSED
,
117 bfd
*obfd ATTRIBUTE_UNUSED
,
118 asymbol
*osym ATTRIBUTE_UNUSED
)
124 _bfd_bool_bfd_ptr_true (bfd
*abfd ATTRIBUTE_UNUSED
,
125 void *ptr ATTRIBUTE_UNUSED
)
130 /* A routine which is used in target vectors for unsupported
131 operations which return a pointer value. */
134 _bfd_ptr_bfd_null_error (bfd
*ignore ATTRIBUTE_UNUSED
)
136 bfd_set_error (bfd_error_invalid_operation
);
141 _bfd_int_bfd_0 (bfd
*ignore ATTRIBUTE_UNUSED
)
147 _bfd_uint_bfd_0 (bfd
*ignore ATTRIBUTE_UNUSED
)
153 _bfd_long_bfd_0 (bfd
*ignore ATTRIBUTE_UNUSED
)
158 /* A routine which is used in target vectors for unsupported
159 operations which return -1 on error. */
162 _bfd_long_bfd_n1_error (bfd
*ignore_abfd ATTRIBUTE_UNUSED
)
164 bfd_set_error (bfd_error_invalid_operation
);
169 _bfd_void_bfd (bfd
*ignore ATTRIBUTE_UNUSED
)
174 _bfd_void_bfd_link (bfd
*abfd ATTRIBUTE_UNUSED
,
175 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
180 _bfd_void_bfd_asection (bfd
*abfd ATTRIBUTE_UNUSED
,
181 asection
*sec ATTRIBUTE_UNUSED
)
186 _bfd_norelocs_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
187 asection
*sec ATTRIBUTE_UNUSED
)
189 return sizeof (arelent
*);
193 _bfd_norelocs_canonicalize_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
194 asection
*sec ATTRIBUTE_UNUSED
,
196 asymbol
**symbols ATTRIBUTE_UNUSED
)
203 _bfd_norelocs_set_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
204 asection
*sec ATTRIBUTE_UNUSED
,
205 arelent
**relptr ATTRIBUTE_UNUSED
,
206 unsigned int count ATTRIBUTE_UNUSED
)
212 _bfd_nocore_core_file_matches_executable_p
213 (bfd
*ignore_core_bfd ATTRIBUTE_UNUSED
,
214 bfd
*ignore_exec_bfd ATTRIBUTE_UNUSED
)
216 bfd_set_error (bfd_error_invalid_operation
);
220 /* Routine to handle core_file_failing_command entry point for targets
221 without core file support. */
224 _bfd_nocore_core_file_failing_command (bfd
*ignore_abfd ATTRIBUTE_UNUSED
)
226 bfd_set_error (bfd_error_invalid_operation
);
230 /* Routine to handle core_file_failing_signal entry point for targets
231 without core file support. */
234 _bfd_nocore_core_file_failing_signal (bfd
*ignore_abfd ATTRIBUTE_UNUSED
)
236 bfd_set_error (bfd_error_invalid_operation
);
240 /* Routine to handle the core_file_pid entry point for targets without
241 core file support. */
244 _bfd_nocore_core_file_pid (bfd
*ignore_abfd ATTRIBUTE_UNUSED
)
246 bfd_set_error (bfd_error_invalid_operation
);
251 _bfd_dummy_target (bfd
*ignore_abfd ATTRIBUTE_UNUSED
)
253 bfd_set_error (bfd_error_wrong_format
);
257 /* Allocate memory using malloc. */
260 #define SSIZE_MAX ((size_t) -1 >> 1)
268 void *bfd_malloc (bfd_size_type {*size*});
271 Returns a pointer to an allocated block of memory that is at least
272 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
273 1. If SIZE is too big then NULL will be returned.
275 Returns NULL upon error and sets bfd_error.
278 bfd_malloc (bfd_size_type size
)
281 size_t sz
= (size_t) size
;
284 /* This is to pacify memory checkers like valgrind. */
287 bfd_set_error (bfd_error_no_memory
);
291 ptr
= malloc (sz
? sz
: 1);
293 bfd_set_error (bfd_error_no_memory
);
303 void *bfd_realloc (void *{*mem*}, bfd_size_type {*size*});
306 Returns a pointer to an allocated block of memory that is at least
307 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
308 1. If SIZE is too big then NULL will be returned.
310 If MEM is not NULL then it must point to an allocated block of memory.
311 If this block is large enough then MEM may be used as the return
312 value for this function, but this is not guaranteed.
314 If MEM is not returned then the first N bytes in the returned block
315 will be identical to the first N bytes in region pointed to by MEM,
316 where N is the lessor of SIZE and the length of the region of memory
317 currently addressed by MEM.
319 Returns NULL upon error and sets bfd_error.
322 bfd_realloc (void *ptr
, bfd_size_type size
)
325 size_t sz
= (size_t) size
;
328 return bfd_malloc (size
);
331 /* This is to pacify memory checkers like valgrind. */
334 bfd_set_error (bfd_error_no_memory
);
338 /* The behaviour of realloc(0) is implementation defined,
339 but for this function we always allocate memory. */
340 ret
= realloc (ptr
, sz
? sz
: 1);
343 bfd_set_error (bfd_error_no_memory
);
353 void *bfd_realloc_or_free (void *{*mem*}, bfd_size_type {*size*});
356 Returns a pointer to an allocated block of memory that is at least
357 SIZE bytes long. If SIZE is 0 then no memory will be allocated,
358 MEM will be freed, and NULL will be returned. This will not cause
361 If SIZE is too big then NULL will be returned and bfd_error will be
364 If MEM is not NULL then it must point to an allocated block of memory.
365 If this block is large enough then MEM may be used as the return
366 value for this function, but this is not guaranteed.
368 If MEM is not returned then the first N bytes in the returned block
369 will be identical to the first N bytes in region pointed to by MEM,
370 where N is the lessor of SIZE and the length of the region of memory
371 currently addressed by MEM.
374 bfd_realloc_or_free (void *ptr
, bfd_size_type size
)
378 /* The behaviour of realloc(0) is implementation defined, but
379 for this function we treat it is always freeing the memory. */
386 ret
= bfd_realloc (ptr
, size
);
398 void *bfd_zmalloc (bfd_size_type {*size*});
401 Returns a pointer to an allocated block of memory that is at least
402 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
403 1. If SIZE is too big then NULL will be returned.
405 Returns NULL upon error and sets bfd_error.
407 If NULL is not returned then the allocated block of memory will
411 bfd_zmalloc (bfd_size_type size
)
413 void *ptr
= bfd_malloc (size
);
416 memset (ptr
, 0, size
? (size_t) size
: 1);
426 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
429 Allocate a block of @var{wanted} bytes of memory attached to
430 <<abfd>> and return a pointer to it.
434 bfd_alloc (bfd
*abfd
, bfd_size_type size
)
437 unsigned long ul_size
= (unsigned long) size
;
440 /* Note - although objalloc_alloc takes an unsigned long as its
441 argument, internally the size is treated as a signed long. This can
442 lead to problems where, for example, a request to allocate -1 bytes
443 can result in just 1 byte being allocated, rather than
444 ((unsigned long) -1) bytes. Also memory checkers will often
445 complain about attempts to allocate a negative amount of memory.
446 So to stop these problems we fail if the size is negative. */
447 || ((signed long) ul_size
) < 0)
449 bfd_set_error (bfd_error_no_memory
);
453 ret
= objalloc_alloc ((struct objalloc
*) abfd
->memory
, ul_size
);
455 bfd_set_error (bfd_error_no_memory
);
457 abfd
->alloc_size
+= size
;
466 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
469 Allocate a block of @var{wanted} bytes of zeroed memory
470 attached to <<abfd>> and return a pointer to it.
474 bfd_zalloc (bfd
*abfd
, bfd_size_type size
)
478 res
= bfd_alloc (abfd
, size
);
480 memset (res
, 0, (size_t) size
);
489 void bfd_release (bfd *, void *);
492 Free a block allocated for a BFD.
493 Note: Also frees all more recently allocated blocks!
497 bfd_release (bfd
*abfd
, void *block
)
499 objalloc_free_block ((struct objalloc
*) abfd
->memory
, block
);
504 bfd_write_bigendian_4byte_int
507 bool bfd_write_bigendian_4byte_int (bfd *, unsigned int);
510 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
511 endian order regardless of what else is going on. This is useful in
516 bfd_write_bigendian_4byte_int (bfd
*abfd
, unsigned int i
)
519 bfd_putb32 (i
, buffer
);
520 return bfd_write (buffer
, 4, abfd
) == 4;
524 /** The do-it-yourself (byte) sex-change kit */
526 /* The middle letter e.g. get<b>short indicates Big or Little endian
527 target machine. It doesn't matter what the byte order of the host
528 machine is; these routines work for either. */
530 /* FIXME: Should these take a count argument?
531 Answer (gnu@cygnus.com): No, but perhaps they should be inline
532 functions in swap.h #ifdef __GNUC__.
533 Gprof them later and find out. */
542 These macros as used for reading and writing raw data in
543 sections; each access (except for bytes) is vectored through
544 the target format of the BFD and mangled accordingly. The
545 mangling performs any necessary endian translations and
546 removes alignment restrictions. Note that types accepted and
547 returned by these macros are identical so they can be swapped
548 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
549 to either <<bfd_get_32>> or <<bfd_get_64>>.
551 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
552 system without prototypes, the caller is responsible for making
553 sure that is true, with a cast if necessary. We don't cast
554 them in the macro definitions because that would prevent <<lint>>
555 or <<gcc -Wall>> from detecting sins such as passing a pointer.
556 To detect calling these with less than a <<bfd_vma>>, use
557 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
560 .{* Byte swapping macros for user section data. *}
562 .#define bfd_put_8(abfd, val, ptr) \
563 . ((void) (*((bfd_byte *) (ptr)) = (val) & 0xff))
564 .#define bfd_put_signed_8 \
566 .#define bfd_get_8(abfd, ptr) \
567 . ((bfd_vma) *(const bfd_byte *) (ptr) & 0xff)
568 .#define bfd_get_signed_8(abfd, ptr) \
569 . ((((bfd_signed_vma) *(const bfd_byte *) (ptr) & 0xff) ^ 0x80) - 0x80)
571 .#define bfd_put_16(abfd, val, ptr) \
572 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
573 .#define bfd_put_signed_16 \
575 .#define bfd_get_16(abfd, ptr) \
576 . BFD_SEND (abfd, bfd_getx16, (ptr))
577 .#define bfd_get_signed_16(abfd, ptr) \
578 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
580 .#define bfd_put_24(abfd, val, ptr) \
582 . if (bfd_big_endian (abfd)) \
583 . bfd_putb24 ((val), (ptr)); \
585 . bfd_putl24 ((val), (ptr)); \
588 .bfd_vma bfd_getb24 (const void *p);
589 .bfd_vma bfd_getl24 (const void *p);
591 .#define bfd_get_24(abfd, ptr) \
592 . (bfd_big_endian (abfd) ? bfd_getb24 (ptr) : bfd_getl24 (ptr))
594 .#define bfd_put_32(abfd, val, ptr) \
595 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
596 .#define bfd_put_signed_32 \
598 .#define bfd_get_32(abfd, ptr) \
599 . BFD_SEND (abfd, bfd_getx32, (ptr))
600 .#define bfd_get_signed_32(abfd, ptr) \
601 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
603 .#define bfd_put_64(abfd, val, ptr) \
604 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
605 .#define bfd_put_signed_64 \
607 .#define bfd_get_64(abfd, ptr) \
608 . BFD_SEND (abfd, bfd_getx64, (ptr))
609 .#define bfd_get_signed_64(abfd, ptr) \
610 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
612 .#define bfd_get(bits, abfd, ptr) \
613 . ((bits) == 8 ? bfd_get_8 (abfd, ptr) \
614 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
615 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
616 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
617 . : (abort (), (bfd_vma) - 1))
619 .#define bfd_put(bits, abfd, val, ptr) \
620 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
621 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
622 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
623 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
624 . : (abort (), (void) 0))
634 These macros have the same function as their <<bfd_get_x>>
635 brethren, except that they are used for removing information
636 for the header records of object files. Believe it or not,
637 some object files keep their header records in big endian
638 order and their data in little endian order.
640 .{* Byte swapping macros for file header data. *}
642 .#define bfd_h_put_8(abfd, val, ptr) \
643 . bfd_put_8 (abfd, val, ptr)
644 .#define bfd_h_put_signed_8(abfd, val, ptr) \
645 . bfd_put_8 (abfd, val, ptr)
646 .#define bfd_h_get_8(abfd, ptr) \
647 . bfd_get_8 (abfd, ptr)
648 .#define bfd_h_get_signed_8(abfd, ptr) \
649 . bfd_get_signed_8 (abfd, ptr)
651 .#define bfd_h_put_16(abfd, val, ptr) \
652 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
653 .#define bfd_h_put_signed_16 \
655 .#define bfd_h_get_16(abfd, ptr) \
656 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
657 .#define bfd_h_get_signed_16(abfd, ptr) \
658 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
660 .#define bfd_h_put_32(abfd, val, ptr) \
661 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
662 .#define bfd_h_put_signed_32 \
664 .#define bfd_h_get_32(abfd, ptr) \
665 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
666 .#define bfd_h_get_signed_32(abfd, ptr) \
667 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
669 .#define bfd_h_put_64(abfd, val, ptr) \
670 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
671 .#define bfd_h_put_signed_64 \
673 .#define bfd_h_get_64(abfd, ptr) \
674 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
675 .#define bfd_h_get_signed_64(abfd, ptr) \
676 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
678 .{* Aliases for the above, which should eventually go away. *}
680 .#define H_PUT_64 bfd_h_put_64
681 .#define H_PUT_32 bfd_h_put_32
682 .#define H_PUT_16 bfd_h_put_16
683 .#define H_PUT_8 bfd_h_put_8
684 .#define H_PUT_S64 bfd_h_put_signed_64
685 .#define H_PUT_S32 bfd_h_put_signed_32
686 .#define H_PUT_S16 bfd_h_put_signed_16
687 .#define H_PUT_S8 bfd_h_put_signed_8
688 .#define H_GET_64 bfd_h_get_64
689 .#define H_GET_32 bfd_h_get_32
690 .#define H_GET_16 bfd_h_get_16
691 .#define H_GET_8 bfd_h_get_8
692 .#define H_GET_S64 bfd_h_get_signed_64
693 .#define H_GET_S32 bfd_h_get_signed_32
694 .#define H_GET_S16 bfd_h_get_signed_16
695 .#define H_GET_S8 bfd_h_get_signed_8
699 /* Sign extension to bfd_signed_vma. */
700 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
701 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
702 #define COERCE64(x) \
703 (((uint64_t) (x) ^ ((uint64_t) 1 << 63)) - ((uint64_t) 1 << 63))
707 Byte swapping routines.
710 uint64_t bfd_getb64 (const void *);
711 uint64_t bfd_getl64 (const void *);
712 int64_t bfd_getb_signed_64 (const void *);
713 int64_t bfd_getl_signed_64 (const void *);
714 bfd_vma bfd_getb32 (const void *);
715 bfd_vma bfd_getl32 (const void *);
716 bfd_signed_vma bfd_getb_signed_32 (const void *);
717 bfd_signed_vma bfd_getl_signed_32 (const void *);
718 bfd_vma bfd_getb16 (const void *);
719 bfd_vma bfd_getl16 (const void *);
720 bfd_signed_vma bfd_getb_signed_16 (const void *);
721 bfd_signed_vma bfd_getl_signed_16 (const void *);
722 void bfd_putb64 (uint64_t, void *);
723 void bfd_putl64 (uint64_t, void *);
724 void bfd_putb32 (bfd_vma, void *);
725 void bfd_putl32 (bfd_vma, void *);
726 void bfd_putb24 (bfd_vma, void *);
727 void bfd_putl24 (bfd_vma, void *);
728 void bfd_putb16 (bfd_vma, void *);
729 void bfd_putl16 (bfd_vma, void *);
730 uint64_t bfd_get_bits (const void *, int, bool);
731 void bfd_put_bits (uint64_t, void *, int, bool);
734 Read and write integers in a particular endian order. getb
735 and putb functions handle big-endian, getl and putl handle
736 little-endian. bfd_get_bits and bfd_put_bits specify
737 big-endian by passing TRUE in the last parameter,
738 little-endian by passing FALSE.
742 bfd_getb16 (const void *p
)
744 const bfd_byte
*addr
= (const bfd_byte
*) p
;
745 return (addr
[0] << 8) | addr
[1];
749 bfd_getl16 (const void *p
)
751 const bfd_byte
*addr
= (const bfd_byte
*) p
;
752 return (addr
[1] << 8) | addr
[0];
756 bfd_getb_signed_16 (const void *p
)
758 const bfd_byte
*addr
= (const bfd_byte
*) p
;
759 return COERCE16 ((addr
[0] << 8) | addr
[1]);
763 bfd_getl_signed_16 (const void *p
)
765 const bfd_byte
*addr
= (const bfd_byte
*) p
;
766 return COERCE16 ((addr
[1] << 8) | addr
[0]);
770 bfd_putb16 (bfd_vma data
, void *p
)
772 bfd_byte
*addr
= (bfd_byte
*) p
;
773 addr
[0] = (data
>> 8) & 0xff;
774 addr
[1] = data
& 0xff;
778 bfd_putl16 (bfd_vma data
, void *p
)
780 bfd_byte
*addr
= (bfd_byte
*) p
;
781 addr
[0] = data
& 0xff;
782 addr
[1] = (data
>> 8) & 0xff;
786 bfd_putb24 (bfd_vma data
, void *p
)
788 bfd_byte
*addr
= (bfd_byte
*) p
;
789 addr
[0] = (data
>> 16) & 0xff;
790 addr
[1] = (data
>> 8) & 0xff;
791 addr
[2] = data
& 0xff;
795 bfd_putl24 (bfd_vma data
, void *p
)
797 bfd_byte
*addr
= (bfd_byte
*) p
;
798 addr
[0] = data
& 0xff;
799 addr
[1] = (data
>> 8) & 0xff;
800 addr
[2] = (data
>> 16) & 0xff;
804 bfd_getb24 (const void *p
)
806 const bfd_byte
*addr
= (const bfd_byte
*) p
;
809 v
= (uint32_t) addr
[0] << 16;
810 v
|= (uint32_t) addr
[1] << 8;
811 v
|= (uint32_t) addr
[2];
816 bfd_getl24 (const void *p
)
818 const bfd_byte
*addr
= (const bfd_byte
*) p
;
821 v
= (uint32_t) addr
[0];
822 v
|= (uint32_t) addr
[1] << 8;
823 v
|= (uint32_t) addr
[2] << 16;
828 bfd_getb32 (const void *p
)
830 const bfd_byte
*addr
= (const bfd_byte
*) p
;
833 v
= (uint32_t) addr
[0] << 24;
834 v
|= (uint32_t) addr
[1] << 16;
835 v
|= (uint32_t) addr
[2] << 8;
836 v
|= (uint32_t) addr
[3];
841 bfd_getl32 (const void *p
)
843 const bfd_byte
*addr
= (const bfd_byte
*) p
;
846 v
= (uint32_t) addr
[0];
847 v
|= (uint32_t) addr
[1] << 8;
848 v
|= (uint32_t) addr
[2] << 16;
849 v
|= (uint32_t) addr
[3] << 24;
854 bfd_getb_signed_32 (const void *p
)
856 const bfd_byte
*addr
= (const bfd_byte
*) p
;
859 v
= (uint32_t) addr
[0] << 24;
860 v
|= (uint32_t) addr
[1] << 16;
861 v
|= (uint32_t) addr
[2] << 8;
862 v
|= (uint32_t) addr
[3];
867 bfd_getl_signed_32 (const void *p
)
869 const bfd_byte
*addr
= (const bfd_byte
*) p
;
872 v
= (uint32_t) addr
[0];
873 v
|= (uint32_t) addr
[1] << 8;
874 v
|= (uint32_t) addr
[2] << 16;
875 v
|= (uint32_t) addr
[3] << 24;
880 bfd_getb64 (const void *p
)
882 const bfd_byte
*addr
= (const bfd_byte
*) p
;
885 v
= addr
[0]; v
<<= 8;
886 v
|= addr
[1]; v
<<= 8;
887 v
|= addr
[2]; v
<<= 8;
888 v
|= addr
[3]; v
<<= 8;
889 v
|= addr
[4]; v
<<= 8;
890 v
|= addr
[5]; v
<<= 8;
891 v
|= addr
[6]; v
<<= 8;
898 bfd_getl64 (const void *p
)
900 const bfd_byte
*addr
= (const bfd_byte
*) p
;
903 v
= addr
[7]; v
<<= 8;
904 v
|= addr
[6]; v
<<= 8;
905 v
|= addr
[5]; v
<<= 8;
906 v
|= addr
[4]; v
<<= 8;
907 v
|= addr
[3]; v
<<= 8;
908 v
|= addr
[2]; v
<<= 8;
909 v
|= addr
[1]; v
<<= 8;
916 bfd_getb_signed_64 (const void *p
)
918 const bfd_byte
*addr
= (const bfd_byte
*) p
;
921 v
= addr
[0]; v
<<= 8;
922 v
|= addr
[1]; v
<<= 8;
923 v
|= addr
[2]; v
<<= 8;
924 v
|= addr
[3]; v
<<= 8;
925 v
|= addr
[4]; v
<<= 8;
926 v
|= addr
[5]; v
<<= 8;
927 v
|= addr
[6]; v
<<= 8;
934 bfd_getl_signed_64 (const void *p
)
936 const bfd_byte
*addr
= (const bfd_byte
*) p
;
939 v
= addr
[7]; v
<<= 8;
940 v
|= addr
[6]; v
<<= 8;
941 v
|= addr
[5]; v
<<= 8;
942 v
|= addr
[4]; v
<<= 8;
943 v
|= addr
[3]; v
<<= 8;
944 v
|= addr
[2]; v
<<= 8;
945 v
|= addr
[1]; v
<<= 8;
952 bfd_putb32 (bfd_vma data
, void *p
)
954 bfd_byte
*addr
= (bfd_byte
*) p
;
955 addr
[0] = (data
>> 24) & 0xff;
956 addr
[1] = (data
>> 16) & 0xff;
957 addr
[2] = (data
>> 8) & 0xff;
958 addr
[3] = data
& 0xff;
962 bfd_putl32 (bfd_vma data
, void *p
)
964 bfd_byte
*addr
= (bfd_byte
*) p
;
965 addr
[0] = data
& 0xff;
966 addr
[1] = (data
>> 8) & 0xff;
967 addr
[2] = (data
>> 16) & 0xff;
968 addr
[3] = (data
>> 24) & 0xff;
972 bfd_putb64 (uint64_t data
, void *p
)
974 bfd_byte
*addr
= (bfd_byte
*) p
;
975 addr
[0] = (data
>> (7*8)) & 0xff;
976 addr
[1] = (data
>> (6*8)) & 0xff;
977 addr
[2] = (data
>> (5*8)) & 0xff;
978 addr
[3] = (data
>> (4*8)) & 0xff;
979 addr
[4] = (data
>> (3*8)) & 0xff;
980 addr
[5] = (data
>> (2*8)) & 0xff;
981 addr
[6] = (data
>> (1*8)) & 0xff;
982 addr
[7] = (data
>> (0*8)) & 0xff;
986 bfd_putl64 (uint64_t data
, void *p
)
988 bfd_byte
*addr
= (bfd_byte
*) p
;
989 addr
[7] = (data
>> (7*8)) & 0xff;
990 addr
[6] = (data
>> (6*8)) & 0xff;
991 addr
[5] = (data
>> (5*8)) & 0xff;
992 addr
[4] = (data
>> (4*8)) & 0xff;
993 addr
[3] = (data
>> (3*8)) & 0xff;
994 addr
[2] = (data
>> (2*8)) & 0xff;
995 addr
[1] = (data
>> (1*8)) & 0xff;
996 addr
[0] = (data
>> (0*8)) & 0xff;
1000 bfd_put_bits (uint64_t data
, void *p
, int bits
, bool big_p
)
1002 bfd_byte
*addr
= (bfd_byte
*) p
;
1010 for (i
= 0; i
< bytes
; i
++)
1012 int addr_index
= big_p
? bytes
- i
- 1 : i
;
1014 addr
[addr_index
] = data
& 0xff;
1020 bfd_get_bits (const void *p
, int bits
, bool big_p
)
1022 const bfd_byte
*addr
= (const bfd_byte
*) p
;
1032 for (i
= 0; i
< bytes
; i
++)
1034 int addr_index
= big_p
? i
: bytes
- i
- 1;
1036 data
= (data
<< 8) | addr
[addr_index
];
1043 /* Allocate a page to track mmapped memory and return the page and
1044 the first entry. Return NULL if mmap fails. */
1046 static struct bfd_mmapped
*
1047 bfd_allocate_mmapped_page (bfd
*abfd
, struct bfd_mmapped_entry
**entry
)
1049 struct bfd_mmapped
* mmapped
1050 = (struct bfd_mmapped
*) mmap (NULL
, _bfd_pagesize
,
1051 PROT_READ
| PROT_WRITE
,
1052 MAP_PRIVATE
| MAP_ANONYMOUS
,
1054 if (mmapped
== MAP_FAILED
)
1057 mmapped
->next
= abfd
->mmapped
;
1059 = ((_bfd_pagesize
- offsetof (struct bfd_mmapped
, entries
))
1060 / sizeof (struct bfd_mmapped_entry
));
1061 mmapped
->next_entry
= 1;
1062 abfd
->mmapped
= mmapped
;
1063 *entry
= mmapped
->entries
;
1067 /* Mmap a memory region of RSIZE bytes with PROT at the current offset.
1068 Return mmap address and size in MAP_ADDR and MAP_SIZE. Return NULL
1069 on invalid input and MAP_FAILED for mmap failure. */
1072 bfd_mmap_local (bfd
*abfd
, size_t rsize
, int prot
, void **map_addr
,
1075 if (!_bfd_constant_p (rsize
))
1077 ufile_ptr filesize
= bfd_get_file_size (abfd
);
1078 if (filesize
!= 0 && rsize
> filesize
)
1080 bfd_set_error (bfd_error_file_truncated
);
1086 ufile_ptr offset
= bfd_tell (abfd
);
1087 mem
= bfd_mmap (abfd
, NULL
, rsize
, prot
, MAP_PRIVATE
, offset
,
1088 map_addr
, map_size
);
1092 /* Mmap a readonly memory region of RSIZE bytes at the current offset.
1093 Return mmap address and size in MAP_ADDR and MAP_SIZE. Return NULL
1094 on invalid input and MAP_FAILED for mmap failure. */
1097 _bfd_mmap_readonly_temporary (bfd
*abfd
, size_t rsize
, void **map_addr
,
1100 /* Use mmap only if section size >= the minimum mmap section size. */
1101 if (rsize
< _bfd_minimum_mmap_size
)
1103 void *mem
= _bfd_malloc_and_read (abfd
, rsize
, rsize
);
1104 /* NB: Set *MAP_ADDR to MEM and *MAP_SIZE to 0 to indicate that
1105 _bfd_malloc_and_read is called. */
1111 return bfd_mmap_local (abfd
, rsize
, PROT_READ
, map_addr
, map_size
);
1114 /* Munmap RSIZE bytes at PTR. */
1117 _bfd_munmap_readonly_temporary (void *ptr
, size_t rsize
)
1119 /* NB: Since _bfd_munmap_readonly_temporary is called like free, PTR
1120 may be NULL. Otherwise, PTR and RSIZE must be valid. If RSIZE is
1121 0, _bfd_malloc_and_read is called. */
1126 if (munmap (ptr
, rsize
) != 0)
1133 /* Mmap a readonly memory region of RSIZE bytes at the current offset.
1134 Return NULL on invalid input or mmap failure. */
1137 _bfd_mmap_readonly_persistent (bfd
*abfd
, size_t rsize
)
1139 /* Use mmap only if section size >= the minimum mmap section size. */
1140 if (rsize
< _bfd_minimum_mmap_size
)
1141 return _bfd_alloc_and_read (abfd
, rsize
, rsize
);
1143 void *mem
, *map_addr
;
1145 mem
= bfd_mmap_local (abfd
, rsize
, PROT_READ
, &map_addr
, &map_size
);
1148 if (mem
== MAP_FAILED
)
1149 return _bfd_alloc_and_read (abfd
, rsize
, rsize
);
1151 struct bfd_mmapped_entry
*entry
;
1152 unsigned int next_entry
;
1153 struct bfd_mmapped
*mmapped
= abfd
->mmapped
;
1155 && (next_entry
= mmapped
->next_entry
) < mmapped
->max_entry
)
1157 entry
= &mmapped
->entries
[next_entry
];
1158 mmapped
->next_entry
++;
1162 mmapped
= bfd_allocate_mmapped_page (abfd
, &entry
);
1163 if (mmapped
== NULL
)
1165 munmap (map_addr
, map_size
);
1170 entry
->addr
= map_addr
;
1171 entry
->size
= map_size
;
1177 /* Attempt to read *SIZE_P bytes from ABFD's iostream to *DATA_P.
1178 Return true if the full the amount has been read. If *DATA_P is
1179 NULL, mmap should be used, return the memory address at the
1180 current offset in *DATA_P as well as return mmap address and size
1181 in *MMAP_BASE and *SIZE_P. Otherwise, return NULL in *MMAP_BASE
1182 and 0 in *SIZE_P. If FINAL_LINK is true, this is called from
1183 elf_link_read_relocs_from_section. */
1186 _bfd_mmap_read_temporary (void **data_p
, size_t *size_p
,
1187 void **mmap_base
, bfd
*abfd
,
1188 bool final_link ATTRIBUTE_UNUSED
)
1190 void *data
= *data_p
;
1191 size_t size
= *size_p
;
1194 /* NB: When FINAL_LINK is true, the size of the preallocated buffer
1195 is _bfd_minimum_mmap_size and use mmap if the data size >=
1196 _bfd_minimum_mmap_size. Otherwise, use mmap if ABFD isn't an IR
1197 input or the data size >= _bfd_minimum_mmap_size. */
1199 bool mmap_size
= size
>= _bfd_minimum_mmap_size
;
1201 use_mmmap
= mmap_size
;
1203 use_mmmap
= (mmap_size
1205 && (abfd
->flags
& BFD_PLUGIN
) == 0);
1208 data
= _bfd_mmap_readonly_temporary (abfd
, size
, mmap_base
,
1210 if (data
== NULL
|| data
== MAP_FAILED
)
1219 data
= bfd_malloc (size
);
1226 return bfd_read (data
, size
, abfd
) == size
;
1229 /* Default implementation */
1232 _bfd_generic_get_section_contents (bfd
*abfd
,
1236 bfd_size_type count
)
1242 if (section
->compress_status
!= COMPRESS_SECTION_NONE
)
1245 /* xgettext:c-format */
1246 (_("%pB: unable to get decompressed section %pA"),
1248 bfd_set_error (bfd_error_invalid_operation
);
1253 if (section
->mmapped_p
1254 && (section
->contents
!= NULL
|| location
!= NULL
))
1257 /* xgettext:c-format */
1258 (_("%pB: mapped section %pA has non-NULL buffer"),
1260 bfd_set_error (bfd_error_invalid_operation
);
1265 sz
= bfd_get_section_limit_octets (abfd
, section
);
1266 if (offset
+ count
< count
1267 || offset
+ count
> sz
1268 || (abfd
->my_archive
!= NULL
1269 && !bfd_is_thin_archive (abfd
->my_archive
)
1270 && ((ufile_ptr
) section
->filepos
+ offset
+ count
1271 > arelt_size (abfd
))))
1273 bfd_set_error (bfd_error_invalid_operation
);
1277 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
1281 if (section
->mmapped_p
)
1284 || bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
1287 int prot
= ((section
->reloc_count
== 0)
1288 ? PROT_READ
: PROT_READ
| PROT_WRITE
);
1290 location
= bfd_mmap_local
1291 (abfd
, count
, prot
, &elf_section_data (section
)->contents_addr
,
1292 &elf_section_data (section
)->contents_size
);
1294 if (location
== NULL
)
1297 /* Check for iovec not supporting mmap. */
1298 if (location
!= MAP_FAILED
)
1300 section
->contents
= location
;
1304 /* Malloc the buffer and call bfd_read. */
1305 location
= (bfd_byte
*) bfd_malloc (count
);
1306 if (location
== NULL
)
1308 if (bfd_get_error () == bfd_error_no_memory
)
1310 /* xgettext:c-format */
1311 (_("error: %pB(%pA) is too large (%#" PRIx64
" bytes)"),
1312 abfd
, section
, (uint64_t) count
);
1315 section
->contents
= location
;
1319 if (bfd_read (location
, count
, abfd
) != count
)
1326 _bfd_generic_get_section_contents_in_window
1327 (bfd
*abfd ATTRIBUTE_UNUSED
,
1328 sec_ptr section ATTRIBUTE_UNUSED
,
1329 bfd_window
*w ATTRIBUTE_UNUSED
,
1330 file_ptr offset ATTRIBUTE_UNUSED
,
1331 bfd_size_type count ATTRIBUTE_UNUSED
)
1338 if (abfd
->xvec
->_bfd_get_section_contents
1339 != _bfd_generic_get_section_contents
)
1341 /* We don't know what changes the bfd's get_section_contents
1342 method may have to make. So punt trying to map the file
1343 window, and let get_section_contents do its thing. */
1344 /* @@ FIXME : If the internal window has a refcount of 1 and was
1345 allocated with malloc instead of mmap, just reuse it. */
1346 bfd_free_window (w
);
1347 w
->i
= bfd_zmalloc (sizeof (bfd_window_internal
));
1350 w
->i
->data
= bfd_malloc (count
);
1351 if (w
->i
->data
== NULL
)
1359 w
->size
= w
->i
->size
= count
;
1360 w
->data
= w
->i
->data
;
1361 return bfd_get_section_contents (abfd
, section
, w
->data
, offset
, count
);
1363 if (abfd
->direction
!= write_direction
&& section
->rawsize
!= 0)
1364 sz
= section
->rawsize
;
1367 if (offset
+ count
< count
1368 || offset
+ count
> sz
1369 || (abfd
->my_archive
!= NULL
1370 && !bfd_is_thin_archive (abfd
->my_archive
)
1371 && ((ufile_ptr
) section
->filepos
+ offset
+ count
1372 > arelt_size (abfd
)))
1373 || ! bfd_get_file_window (abfd
, section
->filepos
+ offset
, count
, w
,
1382 /* This generic function can only be used in implementations where creating
1383 NEW sections is disallowed. It is useful in patching existing sections
1384 in read-write files, though. See other set_section_contents functions
1385 to see why it doesn't work for new sections. */
1387 _bfd_generic_set_section_contents (bfd
*abfd
,
1389 const void *location
,
1391 bfd_size_type count
)
1396 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0
1397 || bfd_write (location
, count
, abfd
) != count
)
1408 unsigned int bfd_log2 (bfd_vma x);
1411 Return the log base 2 of the value supplied, rounded up. E.g., an
1412 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
1416 bfd_log2 (bfd_vma x
)
1418 unsigned int result
= 0;
1425 while ((x
>>= 1) != 0);
1430 bfd_generic_is_local_label_name (bfd
*abfd
, const char *name
)
1432 char locals_prefix
= (bfd_get_symbol_leading_char (abfd
) == '_') ? 'L' : '.';
1434 return name
[0] == locals_prefix
;
1437 /* Helper function for reading uleb128 encoded data. */
1440 _bfd_read_unsigned_leb128 (bfd
*abfd ATTRIBUTE_UNUSED
,
1442 unsigned int *bytes_read_ptr
)
1445 unsigned int num_read
;
1454 byte
= bfd_get_8 (abfd
, buf
);
1457 if (shift
< 8 * sizeof (result
))
1459 result
|= (((bfd_vma
) byte
& 0x7f) << shift
);
1463 while (byte
& 0x80);
1464 *bytes_read_ptr
= num_read
;
1468 /* Read in a LEB128 encoded value from ABFD starting at *PTR.
1469 If SIGN is true, return a signed LEB128 value.
1470 *PTR is incremented by the number of bytes read.
1471 No bytes will be read at address END or beyond. */
1474 _bfd_safe_read_leb128 (bfd
*abfd ATTRIBUTE_UNUSED
,
1477 const bfd_byte
* const end
)
1480 unsigned int shift
= 0;
1482 bfd_byte
*data
= *ptr
;
1486 byte
= bfd_get_8 (abfd
, data
);
1488 if (shift
< 8 * sizeof (result
))
1490 result
|= ((bfd_vma
) (byte
& 0x7f)) << shift
;
1493 if ((byte
& 0x80) == 0)
1499 if (sign
&& (shift
< 8 * sizeof (result
)) && (byte
& 0x40))
1500 result
|= -((bfd_vma
) 1 << shift
);
1505 /* Helper function for reading sleb128 encoded data. */
1508 _bfd_read_signed_leb128 (bfd
*abfd ATTRIBUTE_UNUSED
,
1510 unsigned int *bytes_read_ptr
)
1514 unsigned int num_read
;
1522 byte
= bfd_get_8 (abfd
, buf
);
1525 if (shift
< 8 * sizeof (result
))
1527 result
|= (((bfd_vma
) byte
& 0x7f) << shift
);
1531 while (byte
& 0x80);
1532 if (shift
< 8 * sizeof (result
) && (byte
& 0x40))
1533 result
|= (((bfd_vma
) -1) << shift
);
1534 *bytes_read_ptr
= num_read
;
1538 /* Write VAL in uleb128 format to P.
1539 END indicates the last byte of allocated space for the uleb128 value to fit
1541 Return a pointer to the byte following the last byte that was written, or
1542 NULL if the uleb128 value does not fit in the allocated space between P and
1545 _bfd_write_unsigned_leb128 (bfd_byte
*p
, bfd_byte
*end
, bfd_vma val
)
1563 _bfd_generic_init_private_section_data (bfd
*ibfd ATTRIBUTE_UNUSED
,
1564 asection
*isec ATTRIBUTE_UNUSED
,
1565 bfd
*obfd ATTRIBUTE_UNUSED
,
1566 asection
*osec ATTRIBUTE_UNUSED
,
1567 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
1572 uintptr_t _bfd_pagesize
;
1573 uintptr_t _bfd_pagesize_m1
;
1574 uintptr_t _bfd_minimum_mmap_size
;
1576 __attribute__ ((unused
, constructor
))
1578 bfd_init_pagesize (void)
1580 _bfd_pagesize
= getpagesize ();
1581 if (_bfd_pagesize
== 0)
1583 _bfd_pagesize_m1
= _bfd_pagesize
- 1;
1584 /* The minimum section size to use mmap. */
1585 _bfd_minimum_mmap_size
= _bfd_pagesize
* 4;