1 /* Assorted BFD support routines, only used internally.
2 Copyright (C) 1990-2017 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)
789 /* xgettext:c-format */
790 (_("%B: unable to get decompressed section %A"),
792 bfd_set_error (bfd_error_invalid_operation);
796 /* We do allow reading of a section after bfd_final_link has
797 written the contents out to disk. In that situation, rawsize is
798 just a stale version of size, so ignore it. Otherwise we must be
799 reading an input section, where rawsize, if different to size,
800 is the on-disk size. */
801 if (abfd->direction != write_direction && section->rawsize != 0)
802 sz = section->rawsize;
805 if (offset + count < count
806 || offset + count > sz)
808 bfd_set_error (bfd_error_invalid_operation);
812 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
813 || bfd_bread (location, count, abfd) != count)
820 _bfd_generic_get_section_contents_in_window
821 (bfd *abfd ATTRIBUTE_UNUSED,
822 sec_ptr section ATTRIBUTE_UNUSED,
823 bfd_window *w ATTRIBUTE_UNUSED,
824 file_ptr offset ATTRIBUTE_UNUSED,
825 bfd_size_type count ATTRIBUTE_UNUSED)
832 if (abfd->xvec->_bfd_get_section_contents
833 != _bfd_generic_get_section_contents)
835 /* We don't know what changes the bfd's get_section_contents
836 method may have to make. So punt trying to map the file
837 window, and let get_section_contents do its thing. */
838 /* @@ FIXME : If the internal window has a refcount of 1 and was
839 allocated with malloc instead of mmap, just reuse it. */
841 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
844 w->i->data = bfd_malloc (count);
845 if (w->i->data == NULL)
853 w->size = w->i->size = count;
854 w->data = w->i->data;
855 return bfd_get_section_contents (abfd, section, w->data, offset, count);
857 if (abfd->direction != write_direction && section->rawsize != 0)
858 sz = section->rawsize;
861 if (offset + count > sz
862 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
871 /* This generic function can only be used in implementations where creating
872 NEW sections is disallowed. It is useful in patching existing sections
873 in read-write files, though. See other set_section_contents functions
874 to see why it doesn't work for new sections. */
876 _bfd_generic_set_section_contents (bfd *abfd,
878 const void *location,
885 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
886 || bfd_bwrite (location, count, abfd) != count)
897 unsigned int bfd_log2 (bfd_vma x);
900 Return the log base 2 of the value supplied, rounded up. E.g., an
901 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
907 unsigned int result = 0;
914 while ((x >>= 1) != 0);
919 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
921 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
923 return name[0] == locals_prefix;
926 /* Give a warning at runtime if someone compiles code which calls
930 warn_deprecated (const char *what,
935 /* Poor man's tracking of functions we've already warned about. */
936 static size_t mask = 0;
938 if (~(size_t) func & ~mask)
941 /* Note: separate sentences in order to allow
942 for translation into other languages. */
944 /* xgettext:c-format */
945 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
946 what, file, line, func);
948 fprintf (stderr, _("Deprecated %s called\n"), what);
950 mask |= ~(size_t) func;
954 /* Helper function for reading uleb128 encoded data. */
957 _bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
959 unsigned int *bytes_read_ptr)
962 unsigned int num_read;
971 byte = bfd_get_8 (abfd, buf);
974 result |= (((bfd_vma) byte & 0x7f) << shift);
978 *bytes_read_ptr = num_read;
982 /* Read in a LEB128 encoded value from ABFD starting at DATA.
983 If SIGN is true, return a signed LEB128 value.
984 If LENGTH_RETURN is not NULL, return in it the number of bytes read.
985 No bytes will be read at address END or beyond. */
988 _bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
990 unsigned int *length_return,
992 const bfd_byte * const end)
995 unsigned int num_read = 0;
996 unsigned int shift = 0;
997 unsigned char byte = 0;
1001 byte = bfd_get_8 (abfd, data);
1005 result |= ((bfd_vma) (byte & 0x7f)) << shift;
1008 if ((byte & 0x80) == 0)
1012 if (length_return != NULL)
1013 *length_return = num_read;
1015 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1016 result |= -((bfd_vma) 1 << shift);
1021 /* Helper function for reading sleb128 encoded data. */
1024 _bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1026 unsigned int *bytes_read_ptr)
1030 unsigned int num_read;
1038 byte = bfd_get_8 (abfd, buf);
1041 result |= (((bfd_vma) byte & 0x7f) << shift);
1044 while (byte & 0x80);
1045 if (shift < 8 * sizeof (result) && (byte & 0x40))
1046 result |= (((bfd_vma) -1) << shift);
1047 *bytes_read_ptr = num_read;
1052 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1053 asection *isec ATTRIBUTE_UNUSED,
1054 bfd *obfd ATTRIBUTE_UNUSED,
1055 asection *osec ATTRIBUTE_UNUSED,
1056 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)