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)
174 size_t sz = (size_t) size;
177 /* This is to pacify memory checkers like valgrind. */
178 || ((signed long) sz) < 0)
180 bfd_set_error (bfd_error_no_memory);
185 if (ptr == NULL && sz != 0)
186 bfd_set_error (bfd_error_no_memory);
191 /* Allocate memory using malloc, nmemb * size with overflow checking. */
194 bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
196 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
198 && nmemb > ~(bfd_size_type) 0 / size)
200 bfd_set_error (bfd_error_no_memory);
204 return bfd_malloc (size * nmemb);
207 /* Reallocate memory using realloc. */
210 bfd_realloc (void *ptr, bfd_size_type size)
213 size_t sz = (size_t) size;
216 return bfd_malloc (size);
219 /* This is to pacify memory checkers like valgrind. */
220 || ((signed long) sz) < 0)
222 bfd_set_error (bfd_error_no_memory);
226 ret = realloc (ptr, sz);
228 if (ret == NULL && sz != 0)
229 bfd_set_error (bfd_error_no_memory);
234 /* Reallocate memory using realloc, nmemb * size with overflow checking. */
237 bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
239 if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
241 && nmemb > ~(bfd_size_type) 0 / size)
243 bfd_set_error (bfd_error_no_memory);
247 return bfd_realloc (ptr, size * nmemb);
250 /* Reallocate memory using realloc.
251 If this fails the pointer is freed before returning. */
254 bfd_realloc_or_free (void *ptr, bfd_size_type size)
256 void *ret = bfd_realloc (ptr, size);
258 if (ret == NULL && ptr != NULL)
264 /* Allocate memory using malloc and clear it. */
267 bfd_zmalloc (bfd_size_type size)
269 void *ptr = bfd_malloc (size);
271 if (ptr != NULL && size > 0)
272 memset (ptr, 0, (size_t) size);
277 /* Allocate memory using malloc (nmemb * size) with overflow checking
281 bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
283 void *ptr = bfd_malloc2 (nmemb, size);
287 size_t sz = nmemb * size;
298 bfd_write_bigendian_4byte_int
301 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
304 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
305 endian order regardless of what else is going on. This is useful in
310 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
313 bfd_putb32 ((bfd_vma) i, buffer);
314 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
318 /** The do-it-yourself (byte) sex-change kit */
320 /* The middle letter e.g. get<b>short indicates Big or Little endian
321 target machine. It doesn't matter what the byte order of the host
322 machine is; these routines work for either. */
324 /* FIXME: Should these take a count argument?
325 Answer (gnu@cygnus.com): No, but perhaps they should be inline
326 functions in swap.h #ifdef __GNUC__.
327 Gprof them later and find out. */
336 These macros as used for reading and writing raw data in
337 sections; each access (except for bytes) is vectored through
338 the target format of the BFD and mangled accordingly. The
339 mangling performs any necessary endian translations and
340 removes alignment restrictions. Note that types accepted and
341 returned by these macros are identical so they can be swapped
342 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
343 to either <<bfd_get_32>> or <<bfd_get_64>>.
345 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
346 system without prototypes, the caller is responsible for making
347 sure that is true, with a cast if necessary. We don't cast
348 them in the macro definitions because that would prevent <<lint>>
349 or <<gcc -Wall>> from detecting sins such as passing a pointer.
350 To detect calling these with less than a <<bfd_vma>>, use
351 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
354 .{* Byte swapping macros for user section data. *}
356 .#define bfd_put_8(abfd, val, ptr) \
357 . ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
358 .#define bfd_put_signed_8 \
360 .#define bfd_get_8(abfd, ptr) \
361 . (*(const unsigned char *) (ptr) & 0xff)
362 .#define bfd_get_signed_8(abfd, ptr) \
363 . (((*(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
365 .#define bfd_put_16(abfd, val, ptr) \
366 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
367 .#define bfd_put_signed_16 \
369 .#define bfd_get_16(abfd, ptr) \
370 . BFD_SEND (abfd, bfd_getx16, (ptr))
371 .#define bfd_get_signed_16(abfd, ptr) \
372 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
374 .#define bfd_put_32(abfd, val, ptr) \
375 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
376 .#define bfd_put_signed_32 \
378 .#define bfd_get_32(abfd, ptr) \
379 . BFD_SEND (abfd, bfd_getx32, (ptr))
380 .#define bfd_get_signed_32(abfd, ptr) \
381 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
383 .#define bfd_put_64(abfd, val, ptr) \
384 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
385 .#define bfd_put_signed_64 \
387 .#define bfd_get_64(abfd, ptr) \
388 . BFD_SEND (abfd, bfd_getx64, (ptr))
389 .#define bfd_get_signed_64(abfd, ptr) \
390 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
392 .#define bfd_get(bits, abfd, ptr) \
393 . ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \
394 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
395 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
396 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
397 . : (abort (), (bfd_vma) - 1))
399 .#define bfd_put(bits, abfd, val, ptr) \
400 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
401 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
402 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
403 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
404 . : (abort (), (void) 0))
414 These macros have the same function as their <<bfd_get_x>>
415 brethren, except that they are used for removing information
416 for the header records of object files. Believe it or not,
417 some object files keep their header records in big endian
418 order and their data in little endian order.
420 .{* Byte swapping macros for file header data. *}
422 .#define bfd_h_put_8(abfd, val, ptr) \
423 . bfd_put_8 (abfd, val, ptr)
424 .#define bfd_h_put_signed_8(abfd, val, ptr) \
425 . bfd_put_8 (abfd, val, ptr)
426 .#define bfd_h_get_8(abfd, ptr) \
427 . bfd_get_8 (abfd, ptr)
428 .#define bfd_h_get_signed_8(abfd, ptr) \
429 . bfd_get_signed_8 (abfd, ptr)
431 .#define bfd_h_put_16(abfd, val, ptr) \
432 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
433 .#define bfd_h_put_signed_16 \
435 .#define bfd_h_get_16(abfd, ptr) \
436 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
437 .#define bfd_h_get_signed_16(abfd, ptr) \
438 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
440 .#define bfd_h_put_32(abfd, val, ptr) \
441 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
442 .#define bfd_h_put_signed_32 \
444 .#define bfd_h_get_32(abfd, ptr) \
445 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
446 .#define bfd_h_get_signed_32(abfd, ptr) \
447 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
449 .#define bfd_h_put_64(abfd, val, ptr) \
450 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
451 .#define bfd_h_put_signed_64 \
453 .#define bfd_h_get_64(abfd, ptr) \
454 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
455 .#define bfd_h_get_signed_64(abfd, ptr) \
456 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
458 .{* Aliases for the above, which should eventually go away. *}
460 .#define H_PUT_64 bfd_h_put_64
461 .#define H_PUT_32 bfd_h_put_32
462 .#define H_PUT_16 bfd_h_put_16
463 .#define H_PUT_8 bfd_h_put_8
464 .#define H_PUT_S64 bfd_h_put_signed_64
465 .#define H_PUT_S32 bfd_h_put_signed_32
466 .#define H_PUT_S16 bfd_h_put_signed_16
467 .#define H_PUT_S8 bfd_h_put_signed_8
468 .#define H_GET_64 bfd_h_get_64
469 .#define H_GET_32 bfd_h_get_32
470 .#define H_GET_16 bfd_h_get_16
471 .#define H_GET_8 bfd_h_get_8
472 .#define H_GET_S64 bfd_h_get_signed_64
473 .#define H_GET_S32 bfd_h_get_signed_32
474 .#define H_GET_S16 bfd_h_get_signed_16
475 .#define H_GET_S8 bfd_h_get_signed_8
479 /* Sign extension to bfd_signed_vma. */
480 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
481 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
482 #define COERCE64(x) \
483 (((bfd_uint64_t) (x) ^ ((bfd_uint64_t) 1 << 63)) - ((bfd_uint64_t) 1 << 63))
486 bfd_getb16 (const void *p)
488 const bfd_byte *addr = (const bfd_byte *) p;
489 return (addr[0] << 8) | addr[1];
493 bfd_getl16 (const void *p)
495 const bfd_byte *addr = (const bfd_byte *) p;
496 return (addr[1] << 8) | addr[0];
500 bfd_getb_signed_16 (const void *p)
502 const bfd_byte *addr = (const bfd_byte *) p;
503 return COERCE16 ((addr[0] << 8) | addr[1]);
507 bfd_getl_signed_16 (const void *p)
509 const bfd_byte *addr = (const bfd_byte *) p;
510 return COERCE16 ((addr[1] << 8) | addr[0]);
514 bfd_putb16 (bfd_vma data, void *p)
516 bfd_byte *addr = (bfd_byte *) p;
517 addr[0] = (data >> 8) & 0xff;
518 addr[1] = data & 0xff;
522 bfd_putl16 (bfd_vma data, void *p)
524 bfd_byte *addr = (bfd_byte *) p;
525 addr[0] = data & 0xff;
526 addr[1] = (data >> 8) & 0xff;
530 bfd_getb32 (const void *p)
532 const bfd_byte *addr = (const bfd_byte *) p;
535 v = (unsigned long) addr[0] << 24;
536 v |= (unsigned long) addr[1] << 16;
537 v |= (unsigned long) addr[2] << 8;
538 v |= (unsigned long) addr[3];
543 bfd_getl32 (const void *p)
545 const bfd_byte *addr = (const bfd_byte *) p;
548 v = (unsigned long) addr[0];
549 v |= (unsigned long) addr[1] << 8;
550 v |= (unsigned long) addr[2] << 16;
551 v |= (unsigned long) addr[3] << 24;
556 bfd_getb_signed_32 (const void *p)
558 const bfd_byte *addr = (const bfd_byte *) p;
561 v = (unsigned long) addr[0] << 24;
562 v |= (unsigned long) addr[1] << 16;
563 v |= (unsigned long) addr[2] << 8;
564 v |= (unsigned long) addr[3];
569 bfd_getl_signed_32 (const void *p)
571 const bfd_byte *addr = (const bfd_byte *) p;
574 v = (unsigned long) addr[0];
575 v |= (unsigned long) addr[1] << 8;
576 v |= (unsigned long) addr[2] << 16;
577 v |= (unsigned long) addr[3] << 24;
582 bfd_getb64 (const void *p ATTRIBUTE_UNUSED)
584 #ifdef BFD_HOST_64_BIT
585 const bfd_byte *addr = (const bfd_byte *) p;
588 v = addr[0]; v <<= 8;
589 v |= addr[1]; v <<= 8;
590 v |= addr[2]; v <<= 8;
591 v |= addr[3]; v <<= 8;
592 v |= addr[4]; v <<= 8;
593 v |= addr[5]; v <<= 8;
594 v |= addr[6]; v <<= 8;
605 bfd_getl64 (const void *p ATTRIBUTE_UNUSED)
607 #ifdef BFD_HOST_64_BIT
608 const bfd_byte *addr = (const bfd_byte *) p;
611 v = addr[7]; v <<= 8;
612 v |= addr[6]; v <<= 8;
613 v |= addr[5]; v <<= 8;
614 v |= addr[4]; v <<= 8;
615 v |= addr[3]; v <<= 8;
616 v |= addr[2]; v <<= 8;
617 v |= addr[1]; v <<= 8;
629 bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED)
631 #ifdef BFD_HOST_64_BIT
632 const bfd_byte *addr = (const bfd_byte *) p;
635 v = addr[0]; v <<= 8;
636 v |= addr[1]; v <<= 8;
637 v |= addr[2]; v <<= 8;
638 v |= addr[3]; v <<= 8;
639 v |= addr[4]; v <<= 8;
640 v |= addr[5]; v <<= 8;
641 v |= addr[6]; v <<= 8;
652 bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED)
654 #ifdef BFD_HOST_64_BIT
655 const bfd_byte *addr = (const bfd_byte *) p;
658 v = addr[7]; v <<= 8;
659 v |= addr[6]; v <<= 8;
660 v |= addr[5]; v <<= 8;
661 v |= addr[4]; v <<= 8;
662 v |= addr[3]; v <<= 8;
663 v |= addr[2]; v <<= 8;
664 v |= addr[1]; v <<= 8;
675 bfd_putb32 (bfd_vma data, void *p)
677 bfd_byte *addr = (bfd_byte *) p;
678 addr[0] = (data >> 24) & 0xff;
679 addr[1] = (data >> 16) & 0xff;
680 addr[2] = (data >> 8) & 0xff;
681 addr[3] = data & 0xff;
685 bfd_putl32 (bfd_vma data, void *p)
687 bfd_byte *addr = (bfd_byte *) p;
688 addr[0] = data & 0xff;
689 addr[1] = (data >> 8) & 0xff;
690 addr[2] = (data >> 16) & 0xff;
691 addr[3] = (data >> 24) & 0xff;
695 bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
697 #ifdef BFD_HOST_64_BIT
698 bfd_byte *addr = (bfd_byte *) p;
699 addr[0] = (data >> (7*8)) & 0xff;
700 addr[1] = (data >> (6*8)) & 0xff;
701 addr[2] = (data >> (5*8)) & 0xff;
702 addr[3] = (data >> (4*8)) & 0xff;
703 addr[4] = (data >> (3*8)) & 0xff;
704 addr[5] = (data >> (2*8)) & 0xff;
705 addr[6] = (data >> (1*8)) & 0xff;
706 addr[7] = (data >> (0*8)) & 0xff;
713 bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
715 #ifdef BFD_HOST_64_BIT
716 bfd_byte *addr = (bfd_byte *) p;
717 addr[7] = (data >> (7*8)) & 0xff;
718 addr[6] = (data >> (6*8)) & 0xff;
719 addr[5] = (data >> (5*8)) & 0xff;
720 addr[4] = (data >> (4*8)) & 0xff;
721 addr[3] = (data >> (3*8)) & 0xff;
722 addr[2] = (data >> (2*8)) & 0xff;
723 addr[1] = (data >> (1*8)) & 0xff;
724 addr[0] = (data >> (0*8)) & 0xff;
731 bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p)
733 bfd_byte *addr = (bfd_byte *) p;
741 for (i = 0; i < bytes; i++)
743 int addr_index = big_p ? bytes - i - 1 : i;
745 addr[addr_index] = data & 0xff;
751 bfd_get_bits (const void *p, int bits, bfd_boolean big_p)
753 const bfd_byte *addr = (const bfd_byte *) p;
763 for (i = 0; i < bytes; i++)
765 int addr_index = big_p ? i : bytes - i - 1;
767 data = (data << 8) | addr[addr_index];
773 /* Default implementation */
776 _bfd_generic_get_section_contents (bfd *abfd,
786 if (section->compress_status != COMPRESS_SECTION_NONE)
788 (*_bfd_error_handler)
789 (_("%B: unable to get decompressed section %A"),
791 bfd_set_error (bfd_error_invalid_operation);
795 /* We do allow reading of a section after bfd_final_link has
796 written the contents out to disk. In that situation, rawsize is
797 just a stale version of size, so ignore it. Otherwise we must be
798 reading an input section, where rawsize, if different to size,
799 is the on-disk size. */
800 if (abfd->direction != write_direction && section->rawsize != 0)
801 sz = section->rawsize;
804 if (offset + count < count
805 || offset + count > sz)
807 bfd_set_error (bfd_error_invalid_operation);
811 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
812 || bfd_bread (location, count, abfd) != count)
819 _bfd_generic_get_section_contents_in_window
820 (bfd *abfd ATTRIBUTE_UNUSED,
821 sec_ptr section ATTRIBUTE_UNUSED,
822 bfd_window *w ATTRIBUTE_UNUSED,
823 file_ptr offset ATTRIBUTE_UNUSED,
824 bfd_size_type count ATTRIBUTE_UNUSED)
831 if (abfd->xvec->_bfd_get_section_contents
832 != _bfd_generic_get_section_contents)
834 /* We don't know what changes the bfd's get_section_contents
835 method may have to make. So punt trying to map the file
836 window, and let get_section_contents do its thing. */
837 /* @@ FIXME : If the internal window has a refcount of 1 and was
838 allocated with malloc instead of mmap, just reuse it. */
840 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
843 w->i->data = bfd_malloc (count);
844 if (w->i->data == NULL)
852 w->size = w->i->size = count;
853 w->data = w->i->data;
854 return bfd_get_section_contents (abfd, section, w->data, offset, count);
856 if (abfd->direction != write_direction && section->rawsize != 0)
857 sz = section->rawsize;
860 if (offset + count > sz
861 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
870 /* This generic function can only be used in implementations where creating
871 NEW sections is disallowed. It is useful in patching existing sections
872 in read-write files, though. See other set_section_contents functions
873 to see why it doesn't work for new sections. */
875 _bfd_generic_set_section_contents (bfd *abfd,
877 const void *location,
884 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
885 || bfd_bwrite (location, count, abfd) != count)
896 unsigned int bfd_log2 (bfd_vma x);
899 Return the log base 2 of the value supplied, rounded up. E.g., an
900 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
906 unsigned int result = 0;
913 while ((x >>= 1) != 0);
918 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
920 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
922 return name[0] == locals_prefix;
925 /* Can be used from / for bfd_merge_private_bfd_data to check that
926 endianness matches between input and output file. Returns
927 TRUE for a match, otherwise returns FALSE and emits an error. */
929 _bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd)
931 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
932 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
933 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
937 if (bfd_big_endian (ibfd))
938 msg = _("%B: compiled for a big endian system and target is little endian");
940 msg = _("%B: compiled for a little endian system and target is big endian");
942 (*_bfd_error_handler) (msg, ibfd);
944 bfd_set_error (bfd_error_wrong_format);
951 /* Give a warning at runtime if someone compiles code which calls
955 warn_deprecated (const char *what,
960 /* Poor man's tracking of functions we've already warned about. */
961 static size_t mask = 0;
963 if (~(size_t) func & ~mask)
966 /* Note: separate sentences in order to allow
967 for translation into other languages. */
969 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
970 what, file, line, func);
972 fprintf (stderr, _("Deprecated %s called\n"), what);
974 mask |= ~(size_t) func;
978 /* Helper function for reading uleb128 encoded data. */
981 read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
983 unsigned int *bytes_read_ptr)
986 unsigned int num_read;
995 byte = bfd_get_8 (abfd, buf);
998 result |= (((bfd_vma) byte & 0x7f) << shift);
1001 while (byte & 0x80);
1002 *bytes_read_ptr = num_read;
1006 /* Helper function for reading sleb128 encoded data. */
1009 read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1011 unsigned int *bytes_read_ptr)
1015 unsigned int num_read;
1023 byte = bfd_get_8 (abfd, buf);
1026 result |= (((bfd_vma) byte & 0x7f) << shift);
1029 while (byte & 0x80);
1030 if (shift < 8 * sizeof (result) && (byte & 0x40))
1031 result |= (((bfd_vma) -1) << shift);
1032 *bytes_read_ptr = num_read;
1037 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1038 asection *isec ATTRIBUTE_UNUSED,
1039 bfd *obfd ATTRIBUTE_UNUSED,
1040 asection *osec ATTRIBUTE_UNUSED,
1041 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)