1 /* Assorted BFD support routines, only used internally.
2 Copyright (C) 1990-2014 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. */
26 #ifndef HAVE_GETPAGESIZE
27 #define getpagesize() 2048
32 Implementation details
38 These routines are used within BFD.
39 They are not intended for export, but are documented here for
43 /* A routine which is used in target vectors for unsupported
47 bfd_false (bfd *ignore ATTRIBUTE_UNUSED)
49 bfd_set_error (bfd_error_invalid_operation);
53 /* A routine which is used in target vectors for supported operations
54 which do not actually do anything. */
57 bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
62 /* A routine which is used in target vectors for unsupported
63 operations which return a pointer value. */
66 bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED)
68 bfd_set_error (bfd_error_invalid_operation);
73 bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
79 bfd_0u (bfd *ignore ATTRIBUTE_UNUSED)
85 bfd_0l (bfd *ignore ATTRIBUTE_UNUSED)
90 /* A routine which is used in target vectors for unsupported
91 operations which return -1 on error. */
94 _bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED)
96 bfd_set_error (bfd_error_invalid_operation);
101 bfd_void (bfd *ignore ATTRIBUTE_UNUSED)
106 _bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
107 asection *sec ATTRIBUTE_UNUSED)
109 return sizeof (arelent *);
113 _bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
114 asection *sec ATTRIBUTE_UNUSED,
116 asymbol **symbols ATTRIBUTE_UNUSED)
123 _bfd_nocore_core_file_matches_executable_p
124 (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
125 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
127 bfd_set_error (bfd_error_invalid_operation);
131 /* Routine to handle core_file_failing_command entry point for targets
132 without core file support. */
135 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
137 bfd_set_error (bfd_error_invalid_operation);
141 /* Routine to handle core_file_failing_signal entry point for targets
142 without core file support. */
145 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
147 bfd_set_error (bfd_error_invalid_operation);
151 /* Routine to handle the core_file_pid entry point for targets without
152 core file support. */
155 _bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
157 bfd_set_error (bfd_error_invalid_operation);
162 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
164 bfd_set_error (bfd_error_wrong_format);
168 /* Allocate memory using malloc. */
171 bfd_malloc (bfd_size_type size)
175 if (size != (size_t) size)
177 bfd_set_error (bfd_error_no_memory);
181 ptr = malloc ((size_t) size);
182 if (ptr == NULL && (size_t) size != 0)
183 bfd_set_error (bfd_error_no_memory);
188 /* Allocate memory using malloc, nmemb * size with overflow checking. */
191 bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
195 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
197 && nmemb > ~(bfd_size_type) 0 / size)
199 bfd_set_error (bfd_error_no_memory);
205 if (size != (size_t) size)
207 bfd_set_error (bfd_error_no_memory);
211 ptr = malloc ((size_t) size);
212 if (ptr == NULL && (size_t) size != 0)
213 bfd_set_error (bfd_error_no_memory);
218 /* Reallocate memory using realloc. */
221 bfd_realloc (void *ptr, bfd_size_type size)
225 if (size != (size_t) size)
227 bfd_set_error (bfd_error_no_memory);
232 ret = malloc ((size_t) size);
234 ret = realloc (ptr, (size_t) size);
236 if (ret == NULL && (size_t) size != 0)
237 bfd_set_error (bfd_error_no_memory);
242 /* Reallocate memory using realloc, nmemb * size with overflow checking. */
245 bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
249 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
251 && nmemb > ~(bfd_size_type) 0 / size)
253 bfd_set_error (bfd_error_no_memory);
259 if (size != (size_t) size)
261 bfd_set_error (bfd_error_no_memory);
266 ret = malloc ((size_t) size);
268 ret = realloc (ptr, (size_t) size);
270 if (ret == NULL && (size_t) size != 0)
271 bfd_set_error (bfd_error_no_memory);
276 /* Reallocate memory using realloc.
277 If this fails the pointer is freed before returning. */
280 bfd_realloc_or_free (void *ptr, bfd_size_type size)
282 size_t amount = (size_t) size;
287 else if (ptr == NULL)
288 ret = malloc (amount);
290 ret = realloc (ptr, amount);
295 bfd_set_error (bfd_error_no_memory);
304 /* Allocate memory using malloc and clear it. */
307 bfd_zmalloc (bfd_size_type size)
311 if (size != (size_t) size)
313 bfd_set_error (bfd_error_no_memory);
317 ptr = malloc ((size_t) size);
319 if ((size_t) size != 0)
322 bfd_set_error (bfd_error_no_memory);
324 memset (ptr, 0, (size_t) size);
330 /* Allocate memory using malloc (nmemb * size) with overflow checking
334 bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
338 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
340 && nmemb > ~(bfd_size_type) 0 / size)
342 bfd_set_error (bfd_error_no_memory);
348 if (size != (size_t) size)
350 bfd_set_error (bfd_error_no_memory);
354 ptr = malloc ((size_t) size);
356 if ((size_t) size != 0)
359 bfd_set_error (bfd_error_no_memory);
361 memset (ptr, 0, (size_t) size);
369 bfd_write_bigendian_4byte_int
372 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
375 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
376 endian order regardless of what else is going on. This is useful in
381 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
384 bfd_putb32 ((bfd_vma) i, buffer);
385 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
389 /** The do-it-yourself (byte) sex-change kit */
391 /* The middle letter e.g. get<b>short indicates Big or Little endian
392 target machine. It doesn't matter what the byte order of the host
393 machine is; these routines work for either. */
395 /* FIXME: Should these take a count argument?
396 Answer (gnu@cygnus.com): No, but perhaps they should be inline
397 functions in swap.h #ifdef __GNUC__.
398 Gprof them later and find out. */
407 These macros as used for reading and writing raw data in
408 sections; each access (except for bytes) is vectored through
409 the target format of the BFD and mangled accordingly. The
410 mangling performs any necessary endian translations and
411 removes alignment restrictions. Note that types accepted and
412 returned by these macros are identical so they can be swapped
413 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
414 to either <<bfd_get_32>> or <<bfd_get_64>>.
416 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
417 system without prototypes, the caller is responsible for making
418 sure that is true, with a cast if necessary. We don't cast
419 them in the macro definitions because that would prevent <<lint>>
420 or <<gcc -Wall>> from detecting sins such as passing a pointer.
421 To detect calling these with less than a <<bfd_vma>>, use
422 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
425 .{* Byte swapping macros for user section data. *}
427 .#define bfd_put_8(abfd, val, ptr) \
428 . ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
429 .#define bfd_put_signed_8 \
431 .#define bfd_get_8(abfd, ptr) \
432 . (*(const unsigned char *) (ptr) & 0xff)
433 .#define bfd_get_signed_8(abfd, ptr) \
434 . (((*(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
436 .#define bfd_put_16(abfd, val, ptr) \
437 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
438 .#define bfd_put_signed_16 \
440 .#define bfd_get_16(abfd, ptr) \
441 . BFD_SEND (abfd, bfd_getx16, (ptr))
442 .#define bfd_get_signed_16(abfd, ptr) \
443 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
445 .#define bfd_put_32(abfd, val, ptr) \
446 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
447 .#define bfd_put_signed_32 \
449 .#define bfd_get_32(abfd, ptr) \
450 . BFD_SEND (abfd, bfd_getx32, (ptr))
451 .#define bfd_get_signed_32(abfd, ptr) \
452 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
454 .#define bfd_put_64(abfd, val, ptr) \
455 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
456 .#define bfd_put_signed_64 \
458 .#define bfd_get_64(abfd, ptr) \
459 . BFD_SEND (abfd, bfd_getx64, (ptr))
460 .#define bfd_get_signed_64(abfd, ptr) \
461 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
463 .#define bfd_get(bits, abfd, ptr) \
464 . ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \
465 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
466 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
467 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
468 . : (abort (), (bfd_vma) - 1))
470 .#define bfd_put(bits, abfd, val, ptr) \
471 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
472 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
473 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
474 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
475 . : (abort (), (void) 0))
485 These macros have the same function as their <<bfd_get_x>>
486 brethren, except that they are used for removing information
487 for the header records of object files. Believe it or not,
488 some object files keep their header records in big endian
489 order and their data in little endian order.
491 .{* Byte swapping macros for file header data. *}
493 .#define bfd_h_put_8(abfd, val, ptr) \
494 . bfd_put_8 (abfd, val, ptr)
495 .#define bfd_h_put_signed_8(abfd, val, ptr) \
496 . bfd_put_8 (abfd, val, ptr)
497 .#define bfd_h_get_8(abfd, ptr) \
498 . bfd_get_8 (abfd, ptr)
499 .#define bfd_h_get_signed_8(abfd, ptr) \
500 . bfd_get_signed_8 (abfd, ptr)
502 .#define bfd_h_put_16(abfd, val, ptr) \
503 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
504 .#define bfd_h_put_signed_16 \
506 .#define bfd_h_get_16(abfd, ptr) \
507 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
508 .#define bfd_h_get_signed_16(abfd, ptr) \
509 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
511 .#define bfd_h_put_32(abfd, val, ptr) \
512 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
513 .#define bfd_h_put_signed_32 \
515 .#define bfd_h_get_32(abfd, ptr) \
516 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
517 .#define bfd_h_get_signed_32(abfd, ptr) \
518 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
520 .#define bfd_h_put_64(abfd, val, ptr) \
521 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
522 .#define bfd_h_put_signed_64 \
524 .#define bfd_h_get_64(abfd, ptr) \
525 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
526 .#define bfd_h_get_signed_64(abfd, ptr) \
527 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
529 .{* Aliases for the above, which should eventually go away. *}
531 .#define H_PUT_64 bfd_h_put_64
532 .#define H_PUT_32 bfd_h_put_32
533 .#define H_PUT_16 bfd_h_put_16
534 .#define H_PUT_8 bfd_h_put_8
535 .#define H_PUT_S64 bfd_h_put_signed_64
536 .#define H_PUT_S32 bfd_h_put_signed_32
537 .#define H_PUT_S16 bfd_h_put_signed_16
538 .#define H_PUT_S8 bfd_h_put_signed_8
539 .#define H_GET_64 bfd_h_get_64
540 .#define H_GET_32 bfd_h_get_32
541 .#define H_GET_16 bfd_h_get_16
542 .#define H_GET_8 bfd_h_get_8
543 .#define H_GET_S64 bfd_h_get_signed_64
544 .#define H_GET_S32 bfd_h_get_signed_32
545 .#define H_GET_S16 bfd_h_get_signed_16
546 .#define H_GET_S8 bfd_h_get_signed_8
550 /* Sign extension to bfd_signed_vma. */
551 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
552 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
553 #define COERCE64(x) \
554 (((bfd_uint64_t) (x) ^ ((bfd_uint64_t) 1 << 63)) - ((bfd_uint64_t) 1 << 63))
557 bfd_getb16 (const void *p)
559 const bfd_byte *addr = (const bfd_byte *) p;
560 return (addr[0] << 8) | addr[1];
564 bfd_getl16 (const void *p)
566 const bfd_byte *addr = (const bfd_byte *) p;
567 return (addr[1] << 8) | addr[0];
571 bfd_getb_signed_16 (const void *p)
573 const bfd_byte *addr = (const bfd_byte *) p;
574 return COERCE16 ((addr[0] << 8) | addr[1]);
578 bfd_getl_signed_16 (const void *p)
580 const bfd_byte *addr = (const bfd_byte *) p;
581 return COERCE16 ((addr[1] << 8) | addr[0]);
585 bfd_putb16 (bfd_vma data, void *p)
587 bfd_byte *addr = (bfd_byte *) p;
588 addr[0] = (data >> 8) & 0xff;
589 addr[1] = data & 0xff;
593 bfd_putl16 (bfd_vma data, void *p)
595 bfd_byte *addr = (bfd_byte *) p;
596 addr[0] = data & 0xff;
597 addr[1] = (data >> 8) & 0xff;
601 bfd_getb32 (const void *p)
603 const bfd_byte *addr = (const bfd_byte *) p;
606 v = (unsigned long) addr[0] << 24;
607 v |= (unsigned long) addr[1] << 16;
608 v |= (unsigned long) addr[2] << 8;
609 v |= (unsigned long) addr[3];
614 bfd_getl32 (const void *p)
616 const bfd_byte *addr = (const bfd_byte *) p;
619 v = (unsigned long) addr[0];
620 v |= (unsigned long) addr[1] << 8;
621 v |= (unsigned long) addr[2] << 16;
622 v |= (unsigned long) addr[3] << 24;
627 bfd_getb_signed_32 (const void *p)
629 const bfd_byte *addr = (const bfd_byte *) p;
632 v = (unsigned long) addr[0] << 24;
633 v |= (unsigned long) addr[1] << 16;
634 v |= (unsigned long) addr[2] << 8;
635 v |= (unsigned long) addr[3];
640 bfd_getl_signed_32 (const void *p)
642 const bfd_byte *addr = (const bfd_byte *) p;
645 v = (unsigned long) addr[0];
646 v |= (unsigned long) addr[1] << 8;
647 v |= (unsigned long) addr[2] << 16;
648 v |= (unsigned long) addr[3] << 24;
653 bfd_getb64 (const void *p ATTRIBUTE_UNUSED)
655 #ifdef BFD_HOST_64_BIT
656 const bfd_byte *addr = (const bfd_byte *) p;
659 v = addr[0]; v <<= 8;
660 v |= addr[1]; v <<= 8;
661 v |= addr[2]; v <<= 8;
662 v |= addr[3]; v <<= 8;
663 v |= addr[4]; v <<= 8;
664 v |= addr[5]; v <<= 8;
665 v |= addr[6]; v <<= 8;
676 bfd_getl64 (const void *p ATTRIBUTE_UNUSED)
678 #ifdef BFD_HOST_64_BIT
679 const bfd_byte *addr = (const bfd_byte *) p;
682 v = addr[7]; v <<= 8;
683 v |= addr[6]; v <<= 8;
684 v |= addr[5]; v <<= 8;
685 v |= addr[4]; v <<= 8;
686 v |= addr[3]; v <<= 8;
687 v |= addr[2]; v <<= 8;
688 v |= addr[1]; v <<= 8;
700 bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED)
702 #ifdef BFD_HOST_64_BIT
703 const bfd_byte *addr = (const bfd_byte *) p;
706 v = addr[0]; v <<= 8;
707 v |= addr[1]; v <<= 8;
708 v |= addr[2]; v <<= 8;
709 v |= addr[3]; v <<= 8;
710 v |= addr[4]; v <<= 8;
711 v |= addr[5]; v <<= 8;
712 v |= addr[6]; v <<= 8;
723 bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED)
725 #ifdef BFD_HOST_64_BIT
726 const bfd_byte *addr = (const bfd_byte *) p;
729 v = addr[7]; v <<= 8;
730 v |= addr[6]; v <<= 8;
731 v |= addr[5]; v <<= 8;
732 v |= addr[4]; v <<= 8;
733 v |= addr[3]; v <<= 8;
734 v |= addr[2]; v <<= 8;
735 v |= addr[1]; v <<= 8;
746 bfd_putb32 (bfd_vma data, void *p)
748 bfd_byte *addr = (bfd_byte *) p;
749 addr[0] = (data >> 24) & 0xff;
750 addr[1] = (data >> 16) & 0xff;
751 addr[2] = (data >> 8) & 0xff;
752 addr[3] = data & 0xff;
756 bfd_putl32 (bfd_vma data, void *p)
758 bfd_byte *addr = (bfd_byte *) p;
759 addr[0] = data & 0xff;
760 addr[1] = (data >> 8) & 0xff;
761 addr[2] = (data >> 16) & 0xff;
762 addr[3] = (data >> 24) & 0xff;
766 bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
768 #ifdef BFD_HOST_64_BIT
769 bfd_byte *addr = (bfd_byte *) p;
770 addr[0] = (data >> (7*8)) & 0xff;
771 addr[1] = (data >> (6*8)) & 0xff;
772 addr[2] = (data >> (5*8)) & 0xff;
773 addr[3] = (data >> (4*8)) & 0xff;
774 addr[4] = (data >> (3*8)) & 0xff;
775 addr[5] = (data >> (2*8)) & 0xff;
776 addr[6] = (data >> (1*8)) & 0xff;
777 addr[7] = (data >> (0*8)) & 0xff;
784 bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
786 #ifdef BFD_HOST_64_BIT
787 bfd_byte *addr = (bfd_byte *) p;
788 addr[7] = (data >> (7*8)) & 0xff;
789 addr[6] = (data >> (6*8)) & 0xff;
790 addr[5] = (data >> (5*8)) & 0xff;
791 addr[4] = (data >> (4*8)) & 0xff;
792 addr[3] = (data >> (3*8)) & 0xff;
793 addr[2] = (data >> (2*8)) & 0xff;
794 addr[1] = (data >> (1*8)) & 0xff;
795 addr[0] = (data >> (0*8)) & 0xff;
802 bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p)
804 bfd_byte *addr = (bfd_byte *) p;
812 for (i = 0; i < bytes; i++)
814 int addr_index = big_p ? bytes - i - 1 : i;
816 addr[addr_index] = data & 0xff;
822 bfd_get_bits (const void *p, int bits, bfd_boolean big_p)
824 const bfd_byte *addr = (const bfd_byte *) p;
834 for (i = 0; i < bytes; i++)
836 int addr_index = big_p ? i : bytes - i - 1;
838 data = (data << 8) | addr[addr_index];
844 /* Default implementation */
847 _bfd_generic_get_section_contents (bfd *abfd,
857 if (section->compress_status != COMPRESS_SECTION_NONE)
859 (*_bfd_error_handler)
860 (_("%B: unable to get decompressed section %A"),
862 bfd_set_error (bfd_error_invalid_operation);
866 /* We do allow reading of a section after bfd_final_link has
867 written the contents out to disk. In that situation, rawsize is
868 just a stale version of size, so ignore it. Otherwise we must be
869 reading an input section, where rawsize, if different to size,
870 is the on-disk size. */
871 if (abfd->direction != write_direction && section->rawsize != 0)
872 sz = section->rawsize;
875 if (offset + count < count
876 || offset + count > sz)
878 bfd_set_error (bfd_error_invalid_operation);
882 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
883 || bfd_bread (location, count, abfd) != count)
890 _bfd_generic_get_section_contents_in_window
891 (bfd *abfd ATTRIBUTE_UNUSED,
892 sec_ptr section ATTRIBUTE_UNUSED,
893 bfd_window *w ATTRIBUTE_UNUSED,
894 file_ptr offset ATTRIBUTE_UNUSED,
895 bfd_size_type count ATTRIBUTE_UNUSED)
902 if (abfd->xvec->_bfd_get_section_contents
903 != _bfd_generic_get_section_contents)
905 /* We don't know what changes the bfd's get_section_contents
906 method may have to make. So punt trying to map the file
907 window, and let get_section_contents do its thing. */
908 /* @@ FIXME : If the internal window has a refcount of 1 and was
909 allocated with malloc instead of mmap, just reuse it. */
911 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
914 w->i->data = bfd_malloc (count);
915 if (w->i->data == NULL)
923 w->size = w->i->size = count;
924 w->data = w->i->data;
925 return bfd_get_section_contents (abfd, section, w->data, offset, count);
927 if (abfd->direction != write_direction && section->rawsize != 0)
928 sz = section->rawsize;
931 if (offset + count > sz
932 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
941 /* This generic function can only be used in implementations where creating
942 NEW sections is disallowed. It is useful in patching existing sections
943 in read-write files, though. See other set_section_contents functions
944 to see why it doesn't work for new sections. */
946 _bfd_generic_set_section_contents (bfd *abfd,
948 const void *location,
955 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
956 || bfd_bwrite (location, count, abfd) != count)
967 unsigned int bfd_log2 (bfd_vma x);
970 Return the log base 2 of the value supplied, rounded up. E.g., an
971 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
977 unsigned int result = 0;
984 while ((x >>= 1) != 0);
989 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
991 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
993 return name[0] == locals_prefix;
996 /* Can be used from / for bfd_merge_private_bfd_data to check that
997 endianness matches between input and output file. Returns
998 TRUE for a match, otherwise returns FALSE and emits an error. */
1000 _bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd)
1002 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1003 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1004 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1008 if (bfd_big_endian (ibfd))
1009 msg = _("%B: compiled for a big endian system and target is little endian");
1011 msg = _("%B: compiled for a little endian system and target is big endian");
1013 (*_bfd_error_handler) (msg, ibfd);
1015 bfd_set_error (bfd_error_wrong_format);
1022 /* Give a warning at runtime if someone compiles code which calls
1026 warn_deprecated (const char *what,
1031 /* Poor man's tracking of functions we've already warned about. */
1032 static size_t mask = 0;
1034 if (~(size_t) func & ~mask)
1037 /* Note: separate sentences in order to allow
1038 for translation into other languages. */
1040 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
1041 what, file, line, func);
1043 fprintf (stderr, _("Deprecated %s called\n"), what);
1045 mask |= ~(size_t) func;
1049 /* Helper function for reading uleb128 encoded data. */
1052 read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1054 unsigned int *bytes_read_ptr)
1057 unsigned int num_read;
1066 byte = bfd_get_8 (abfd, buf);
1069 result |= (((bfd_vma) byte & 0x7f) << shift);
1072 while (byte & 0x80);
1073 *bytes_read_ptr = num_read;
1077 /* Helper function for reading sleb128 encoded data. */
1080 read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1082 unsigned int *bytes_read_ptr)
1086 unsigned int num_read;
1094 byte = bfd_get_8 (abfd, buf);
1097 result |= (((bfd_vma) byte & 0x7f) << shift);
1100 while (byte & 0x80);
1101 if (shift < 8 * sizeof (result) && (byte & 0x40))
1102 result |= (((bfd_vma) -1) << shift);
1103 *bytes_read_ptr = num_read;
1108 _bfd_generic_find_nearest_line_discriminator (bfd *abfd ATTRIBUTE_UNUSED,
1109 asection *section ATTRIBUTE_UNUSED,
1110 asymbol **symbols ATTRIBUTE_UNUSED,
1111 bfd_vma offset ATTRIBUTE_UNUSED,
1112 const char **filename_ptr ATTRIBUTE_UNUSED,
1113 const char **functionname_ptr ATTRIBUTE_UNUSED,
1114 unsigned int *line_ptr ATTRIBUTE_UNUSED,
1115 unsigned int *discriminator_ptr ATTRIBUTE_UNUSED)
1121 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1122 asection *isec ATTRIBUTE_UNUSED,
1123 bfd *obfd ATTRIBUTE_UNUSED,
1124 asection *osec ATTRIBUTE_UNUSED,
1125 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)