Automatic date update in version.in
[binutils-gdb.git] / bfd / libbfd.c
blobd33f3416206d5047c7ce3ea6b8588b3e87c518d8
1 /* Assorted BFD support routines, only used internally.
2 Copyright (C) 1990-2022 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. */
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
26 #ifndef HAVE_GETPAGESIZE
27 #define getpagesize() 2048
28 #endif
31 SECTION
32 Implementation details
34 SUBSECTION
35 Internal functions
37 DESCRIPTION
38 These routines are used within BFD.
39 They are not intended for export, but are documented here for
40 completeness.
43 bool
44 _bfd_bool_bfd_false (bfd *abfd ATTRIBUTE_UNUSED)
46 return false;
49 bool
50 _bfd_bool_bfd_asymbol_false (bfd *abfd ATTRIBUTE_UNUSED,
51 asymbol *sym ATTRIBUTE_UNUSED)
53 return false;
56 /* A routine which is used in target vectors for unsupported
57 operations. */
59 bool
60 _bfd_bool_bfd_false_error (bfd *ignore ATTRIBUTE_UNUSED)
62 bfd_set_error (bfd_error_invalid_operation);
63 return false;
66 bool
67 _bfd_bool_bfd_link_false_error (bfd *abfd,
68 struct bfd_link_info *info ATTRIBUTE_UNUSED)
70 return _bfd_bool_bfd_false_error (abfd);
73 /* A routine which is used in target vectors for supported operations
74 which do not actually do anything. */
76 bool
77 _bfd_bool_bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
79 return true;
82 bool
83 _bfd_bool_bfd_link_true (bfd *abfd ATTRIBUTE_UNUSED,
84 struct bfd_link_info *info ATTRIBUTE_UNUSED)
86 return true;
89 bool
90 _bfd_bool_bfd_bfd_true (bfd *ibfd ATTRIBUTE_UNUSED,
91 bfd *obfd ATTRIBUTE_UNUSED)
93 return true;
96 bool
97 _bfd_bool_bfd_uint_true (bfd *abfd ATTRIBUTE_UNUSED,
98 unsigned int flags ATTRIBUTE_UNUSED)
100 return true;
103 bool
104 _bfd_bool_bfd_asection_bfd_asection_true (bfd *ibfd ATTRIBUTE_UNUSED,
105 asection *isec ATTRIBUTE_UNUSED,
106 bfd *obfd ATTRIBUTE_UNUSED,
107 asection *osec ATTRIBUTE_UNUSED)
109 return true;
112 bool
113 _bfd_bool_bfd_asymbol_bfd_asymbol_true (bfd *ibfd ATTRIBUTE_UNUSED,
114 asymbol *isym ATTRIBUTE_UNUSED,
115 bfd *obfd ATTRIBUTE_UNUSED,
116 asymbol *osym ATTRIBUTE_UNUSED)
118 return true;
121 bool
122 _bfd_bool_bfd_ptr_true (bfd *abfd ATTRIBUTE_UNUSED,
123 void *ptr ATTRIBUTE_UNUSED)
125 return true;
128 /* A routine which is used in target vectors for unsupported
129 operations which return a pointer value. */
131 void *
132 _bfd_ptr_bfd_null_error (bfd *ignore ATTRIBUTE_UNUSED)
134 bfd_set_error (bfd_error_invalid_operation);
135 return NULL;
139 _bfd_int_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
141 return 0;
144 unsigned int
145 _bfd_uint_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
147 return 0;
150 long
151 _bfd_long_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
153 return 0;
156 /* A routine which is used in target vectors for unsupported
157 operations which return -1 on error. */
159 long
160 _bfd_long_bfd_n1_error (bfd *ignore_abfd ATTRIBUTE_UNUSED)
162 bfd_set_error (bfd_error_invalid_operation);
163 return -1;
166 void
167 _bfd_void_bfd (bfd *ignore ATTRIBUTE_UNUSED)
171 void
172 _bfd_void_bfd_link (bfd *abfd ATTRIBUTE_UNUSED,
173 struct bfd_link_info *info ATTRIBUTE_UNUSED)
177 void
178 _bfd_void_bfd_asection (bfd *abfd ATTRIBUTE_UNUSED,
179 asection *sec ATTRIBUTE_UNUSED)
183 long
184 _bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
185 asection *sec ATTRIBUTE_UNUSED)
187 return sizeof (arelent *);
190 long
191 _bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
192 asection *sec ATTRIBUTE_UNUSED,
193 arelent **relptr,
194 asymbol **symbols ATTRIBUTE_UNUSED)
196 *relptr = NULL;
197 return 0;
200 void
201 _bfd_norelocs_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
202 asection *sec ATTRIBUTE_UNUSED,
203 arelent **relptr ATTRIBUTE_UNUSED,
204 unsigned int count ATTRIBUTE_UNUSED)
206 /* Do nothing. */
209 bool
210 _bfd_nocore_core_file_matches_executable_p
211 (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
212 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
214 bfd_set_error (bfd_error_invalid_operation);
215 return false;
218 /* Routine to handle core_file_failing_command entry point for targets
219 without core file support. */
221 char *
222 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
224 bfd_set_error (bfd_error_invalid_operation);
225 return NULL;
228 /* Routine to handle core_file_failing_signal entry point for targets
229 without core file support. */
232 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
234 bfd_set_error (bfd_error_invalid_operation);
235 return 0;
238 /* Routine to handle the core_file_pid entry point for targets without
239 core file support. */
242 _bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
244 bfd_set_error (bfd_error_invalid_operation);
245 return 0;
248 bfd_cleanup
249 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
251 bfd_set_error (bfd_error_wrong_format);
252 return 0;
255 /* Allocate memory using malloc. */
257 #ifndef SSIZE_MAX
258 #define SSIZE_MAX ((size_t) -1 >> 1)
259 #endif
262 INTERNAL_FUNCTION
263 bfd_malloc
265 SYNOPSIS
266 extern void * bfd_malloc (bfd_size_type SIZE) ATTRIBUTE_HIDDEN;
268 DESCRIPTION
269 Returns a pointer to an allocated block of memory that is at least
270 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
271 1. If SIZE is too big then NULL will be returned.
273 Returns NULL upon error and sets bfd_error.
275 void *
276 bfd_malloc (bfd_size_type size)
278 void *ptr;
279 size_t sz = (size_t) size;
281 if (size != sz
282 /* This is to pacify memory checkers like valgrind. */
283 || sz > SSIZE_MAX)
285 bfd_set_error (bfd_error_no_memory);
286 return NULL;
289 ptr = malloc (sz ? sz : 1);
290 if (ptr == NULL)
291 bfd_set_error (bfd_error_no_memory);
293 return ptr;
297 INTERNAL_FUNCTION
298 bfd_realloc
300 SYNOPSIS
301 extern void * bfd_realloc (void * MEM, bfd_size_type SIZE) ATTRIBUTE_HIDDEN;
303 DESCRIPTION
304 Returns a pointer to an allocated block of memory that is at least
305 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
306 1. If SIZE is too big then NULL will be returned.
308 If MEM is not NULL then it must point to an allocated block of memory.
309 If this block is large enough then MEM may be used as the return
310 value for this function, but this is not guaranteed.
312 If MEM is not returned then the first N bytes in the returned block
313 will be identical to the first N bytes in region pointed to by MEM,
314 where N is the lessor of SIZE and the length of the region of memory
315 currently addressed by MEM.
317 Returns NULL upon error and sets bfd_error.
319 void *
320 bfd_realloc (void *ptr, bfd_size_type size)
322 void *ret;
323 size_t sz = (size_t) size;
325 if (ptr == NULL)
326 return bfd_malloc (size);
328 if (size != sz
329 /* This is to pacify memory checkers like valgrind. */
330 || sz > SSIZE_MAX)
332 bfd_set_error (bfd_error_no_memory);
333 return NULL;
336 /* The behaviour of realloc(0) is implementation defined,
337 but for this function we always allocate memory. */
338 ret = realloc (ptr, sz ? sz : 1);
340 if (ret == NULL)
341 bfd_set_error (bfd_error_no_memory);
343 return ret;
347 INTERNAL_FUNCTION
348 bfd_realloc_or_free
350 SYNOPSIS
351 extern void * bfd_realloc_or_free (void * MEM, bfd_size_type SIZE) ATTRIBUTE_HIDDEN;
353 DESCRIPTION
354 Returns a pointer to an allocated block of memory that is at least
355 SIZE bytes long. If SIZE is 0 then no memory will be allocated,
356 MEM will be freed, and NULL will be returned. This will not cause
357 bfd_error to be set.
359 If SIZE is too big then NULL will be returned and bfd_error will be
360 set.
362 If MEM is not NULL then it must point to an allocated block of memory.
363 If this block is large enough then MEM may be used as the return
364 value for this function, but this is not guaranteed.
366 If MEM is not returned then the first N bytes in the returned block
367 will be identical to the first N bytes in region pointed to by MEM,
368 where N is the lessor of SIZE and the length of the region of memory
369 currently addressed by MEM.
371 void *
372 bfd_realloc_or_free (void *ptr, bfd_size_type size)
374 void *ret;
376 /* The behaviour of realloc(0) is implementation defined, but
377 for this function we treat it is always freeing the memory. */
378 if (size == 0)
380 free (ptr);
381 return NULL;
384 ret = bfd_realloc (ptr, size);
385 if (ret == NULL)
386 free (ptr);
388 return ret;
392 INTERNAL_FUNCTION
393 bfd_zmalloc
395 SYNOPSIS
396 extern void * bfd_zmalloc (bfd_size_type SIZE) ATTRIBUTE_HIDDEN;
398 DESCRIPTION
399 Returns a pointer to an allocated block of memory that is at least
400 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
401 1. If SIZE is too big then NULL will be returned.
403 Returns NULL upon error and sets bfd_error.
405 If NULL is not returned then the allocated block of memory will
406 have been cleared.
408 void *
409 bfd_zmalloc (bfd_size_type size)
411 void *ptr = bfd_malloc (size);
413 if (ptr != NULL)
414 memset (ptr, 0, size ? (size_t) size : 1);
416 return ptr;
420 INTERNAL_FUNCTION
421 bfd_write_bigendian_4byte_int
423 SYNOPSIS
424 bool bfd_write_bigendian_4byte_int (bfd *, unsigned int);
426 DESCRIPTION
427 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
428 endian order regardless of what else is going on. This is useful in
429 archives.
432 bool
433 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
435 bfd_byte buffer[4];
436 bfd_putb32 ((bfd_vma) i, buffer);
437 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
441 /** The do-it-yourself (byte) sex-change kit */
443 /* The middle letter e.g. get<b>short indicates Big or Little endian
444 target machine. It doesn't matter what the byte order of the host
445 machine is; these routines work for either. */
447 /* FIXME: Should these take a count argument?
448 Answer (gnu@cygnus.com): No, but perhaps they should be inline
449 functions in swap.h #ifdef __GNUC__.
450 Gprof them later and find out. */
453 FUNCTION
454 bfd_put_size
455 FUNCTION
456 bfd_get_size
458 DESCRIPTION
459 These macros as used for reading and writing raw data in
460 sections; each access (except for bytes) is vectored through
461 the target format of the BFD and mangled accordingly. The
462 mangling performs any necessary endian translations and
463 removes alignment restrictions. Note that types accepted and
464 returned by these macros are identical so they can be swapped
465 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
466 to either <<bfd_get_32>> or <<bfd_get_64>>.
468 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
469 system without prototypes, the caller is responsible for making
470 sure that is true, with a cast if necessary. We don't cast
471 them in the macro definitions because that would prevent <<lint>>
472 or <<gcc -Wall>> from detecting sins such as passing a pointer.
473 To detect calling these with less than a <<bfd_vma>>, use
474 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
477 .{* Byte swapping macros for user section data. *}
479 .#define bfd_put_8(abfd, val, ptr) \
480 . ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
481 .#define bfd_put_signed_8 \
482 . bfd_put_8
483 .#define bfd_get_8(abfd, ptr) \
484 . ((bfd_vma) *(const unsigned char *) (ptr) & 0xff)
485 .#define bfd_get_signed_8(abfd, ptr) \
486 . ((((bfd_signed_vma) *(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
488 .#define bfd_put_16(abfd, val, ptr) \
489 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
490 .#define bfd_put_signed_16 \
491 . bfd_put_16
492 .#define bfd_get_16(abfd, ptr) \
493 . BFD_SEND (abfd, bfd_getx16, (ptr))
494 .#define bfd_get_signed_16(abfd, ptr) \
495 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
497 .#define bfd_put_24(abfd, val, ptr) \
498 . do \
499 . if (bfd_big_endian (abfd)) \
500 . bfd_putb24 ((val), (ptr)); \
501 . else \
502 . bfd_putl24 ((val), (ptr)); \
503 . while (0)
505 .bfd_vma bfd_getb24 (const void *p);
506 .bfd_vma bfd_getl24 (const void *p);
508 .#define bfd_get_24(abfd, ptr) \
509 . (bfd_big_endian (abfd) ? bfd_getb24 (ptr) : bfd_getl24 (ptr))
511 .#define bfd_put_32(abfd, val, ptr) \
512 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
513 .#define bfd_put_signed_32 \
514 . bfd_put_32
515 .#define bfd_get_32(abfd, ptr) \
516 . BFD_SEND (abfd, bfd_getx32, (ptr))
517 .#define bfd_get_signed_32(abfd, ptr) \
518 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
520 .#define bfd_put_64(abfd, val, ptr) \
521 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
522 .#define bfd_put_signed_64 \
523 . bfd_put_64
524 .#define bfd_get_64(abfd, ptr) \
525 . BFD_SEND (abfd, bfd_getx64, (ptr))
526 .#define bfd_get_signed_64(abfd, ptr) \
527 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
529 .#define bfd_get(bits, abfd, ptr) \
530 . ((bits) == 8 ? bfd_get_8 (abfd, ptr) \
531 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
532 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
533 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
534 . : (abort (), (bfd_vma) - 1))
536 .#define bfd_put(bits, abfd, val, ptr) \
537 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
538 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
539 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
540 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
541 . : (abort (), (void) 0))
546 FUNCTION
547 bfd_h_put_size
548 bfd_h_get_size
550 DESCRIPTION
551 These macros have the same function as their <<bfd_get_x>>
552 brethren, except that they are used for removing information
553 for the header records of object files. Believe it or not,
554 some object files keep their header records in big endian
555 order and their data in little endian order.
557 .{* Byte swapping macros for file header data. *}
559 .#define bfd_h_put_8(abfd, val, ptr) \
560 . bfd_put_8 (abfd, val, ptr)
561 .#define bfd_h_put_signed_8(abfd, val, ptr) \
562 . bfd_put_8 (abfd, val, ptr)
563 .#define bfd_h_get_8(abfd, ptr) \
564 . bfd_get_8 (abfd, ptr)
565 .#define bfd_h_get_signed_8(abfd, ptr) \
566 . bfd_get_signed_8 (abfd, ptr)
568 .#define bfd_h_put_16(abfd, val, ptr) \
569 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
570 .#define bfd_h_put_signed_16 \
571 . bfd_h_put_16
572 .#define bfd_h_get_16(abfd, ptr) \
573 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
574 .#define bfd_h_get_signed_16(abfd, ptr) \
575 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
577 .#define bfd_h_put_32(abfd, val, ptr) \
578 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
579 .#define bfd_h_put_signed_32 \
580 . bfd_h_put_32
581 .#define bfd_h_get_32(abfd, ptr) \
582 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
583 .#define bfd_h_get_signed_32(abfd, ptr) \
584 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
586 .#define bfd_h_put_64(abfd, val, ptr) \
587 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
588 .#define bfd_h_put_signed_64 \
589 . bfd_h_put_64
590 .#define bfd_h_get_64(abfd, ptr) \
591 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
592 .#define bfd_h_get_signed_64(abfd, ptr) \
593 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
595 .{* Aliases for the above, which should eventually go away. *}
597 .#define H_PUT_64 bfd_h_put_64
598 .#define H_PUT_32 bfd_h_put_32
599 .#define H_PUT_16 bfd_h_put_16
600 .#define H_PUT_8 bfd_h_put_8
601 .#define H_PUT_S64 bfd_h_put_signed_64
602 .#define H_PUT_S32 bfd_h_put_signed_32
603 .#define H_PUT_S16 bfd_h_put_signed_16
604 .#define H_PUT_S8 bfd_h_put_signed_8
605 .#define H_GET_64 bfd_h_get_64
606 .#define H_GET_32 bfd_h_get_32
607 .#define H_GET_16 bfd_h_get_16
608 .#define H_GET_8 bfd_h_get_8
609 .#define H_GET_S64 bfd_h_get_signed_64
610 .#define H_GET_S32 bfd_h_get_signed_32
611 .#define H_GET_S16 bfd_h_get_signed_16
612 .#define H_GET_S8 bfd_h_get_signed_8
616 /* Sign extension to bfd_signed_vma. */
617 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
618 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
619 #define COERCE64(x) \
620 (((uint64_t) (x) ^ ((uint64_t) 1 << 63)) - ((uint64_t) 1 << 63))
622 bfd_vma
623 bfd_getb16 (const void *p)
625 const bfd_byte *addr = (const bfd_byte *) p;
626 return (addr[0] << 8) | addr[1];
629 bfd_vma
630 bfd_getl16 (const void *p)
632 const bfd_byte *addr = (const bfd_byte *) p;
633 return (addr[1] << 8) | addr[0];
636 bfd_signed_vma
637 bfd_getb_signed_16 (const void *p)
639 const bfd_byte *addr = (const bfd_byte *) p;
640 return COERCE16 ((addr[0] << 8) | addr[1]);
643 bfd_signed_vma
644 bfd_getl_signed_16 (const void *p)
646 const bfd_byte *addr = (const bfd_byte *) p;
647 return COERCE16 ((addr[1] << 8) | addr[0]);
650 void
651 bfd_putb16 (bfd_vma data, void *p)
653 bfd_byte *addr = (bfd_byte *) p;
654 addr[0] = (data >> 8) & 0xff;
655 addr[1] = data & 0xff;
658 void
659 bfd_putl16 (bfd_vma data, void *p)
661 bfd_byte *addr = (bfd_byte *) p;
662 addr[0] = data & 0xff;
663 addr[1] = (data >> 8) & 0xff;
666 void
667 bfd_putb24 (bfd_vma data, void *p)
669 bfd_byte *addr = (bfd_byte *) p;
670 addr[0] = (data >> 16) & 0xff;
671 addr[1] = (data >> 8) & 0xff;
672 addr[2] = data & 0xff;
675 void
676 bfd_putl24 (bfd_vma data, void *p)
678 bfd_byte *addr = (bfd_byte *) p;
679 addr[0] = data & 0xff;
680 addr[1] = (data >> 8) & 0xff;
681 addr[2] = (data >> 16) & 0xff;
684 bfd_vma
685 bfd_getb24 (const void *p)
687 const bfd_byte *addr = (const bfd_byte *) p;
688 unsigned long v;
690 v = (unsigned long) addr[0] << 16;
691 v |= (unsigned long) addr[1] << 8;
692 v |= (unsigned long) addr[2];
693 return v;
696 bfd_vma
697 bfd_getl24 (const void *p)
699 const bfd_byte *addr = (const bfd_byte *) p;
700 unsigned long v;
702 v = (unsigned long) addr[0];
703 v |= (unsigned long) addr[1] << 8;
704 v |= (unsigned long) addr[2] << 16;
705 return v;
708 bfd_vma
709 bfd_getb32 (const void *p)
711 const bfd_byte *addr = (const bfd_byte *) p;
712 unsigned long v;
714 v = (unsigned long) addr[0] << 24;
715 v |= (unsigned long) addr[1] << 16;
716 v |= (unsigned long) addr[2] << 8;
717 v |= (unsigned long) addr[3];
718 return v;
721 bfd_vma
722 bfd_getl32 (const void *p)
724 const bfd_byte *addr = (const bfd_byte *) p;
725 unsigned long v;
727 v = (unsigned long) addr[0];
728 v |= (unsigned long) addr[1] << 8;
729 v |= (unsigned long) addr[2] << 16;
730 v |= (unsigned long) addr[3] << 24;
731 return v;
734 bfd_signed_vma
735 bfd_getb_signed_32 (const void *p)
737 const bfd_byte *addr = (const bfd_byte *) p;
738 unsigned long v;
740 v = (unsigned long) addr[0] << 24;
741 v |= (unsigned long) addr[1] << 16;
742 v |= (unsigned long) addr[2] << 8;
743 v |= (unsigned long) addr[3];
744 return COERCE32 (v);
747 bfd_signed_vma
748 bfd_getl_signed_32 (const void *p)
750 const bfd_byte *addr = (const bfd_byte *) p;
751 unsigned long v;
753 v = (unsigned long) addr[0];
754 v |= (unsigned long) addr[1] << 8;
755 v |= (unsigned long) addr[2] << 16;
756 v |= (unsigned long) addr[3] << 24;
757 return COERCE32 (v);
760 uint64_t
761 bfd_getb64 (const void *p)
763 const bfd_byte *addr = (const bfd_byte *) p;
764 uint64_t v;
766 v = addr[0]; v <<= 8;
767 v |= addr[1]; v <<= 8;
768 v |= addr[2]; v <<= 8;
769 v |= addr[3]; v <<= 8;
770 v |= addr[4]; v <<= 8;
771 v |= addr[5]; v <<= 8;
772 v |= addr[6]; v <<= 8;
773 v |= addr[7];
775 return v;
778 uint64_t
779 bfd_getl64 (const void *p)
781 const bfd_byte *addr = (const bfd_byte *) p;
782 uint64_t v;
784 v = addr[7]; v <<= 8;
785 v |= addr[6]; v <<= 8;
786 v |= addr[5]; v <<= 8;
787 v |= addr[4]; v <<= 8;
788 v |= addr[3]; v <<= 8;
789 v |= addr[2]; v <<= 8;
790 v |= addr[1]; v <<= 8;
791 v |= addr[0];
793 return v;
796 int64_t
797 bfd_getb_signed_64 (const void *p)
799 const bfd_byte *addr = (const bfd_byte *) p;
800 uint64_t v;
802 v = addr[0]; v <<= 8;
803 v |= addr[1]; v <<= 8;
804 v |= addr[2]; v <<= 8;
805 v |= addr[3]; v <<= 8;
806 v |= addr[4]; v <<= 8;
807 v |= addr[5]; v <<= 8;
808 v |= addr[6]; v <<= 8;
809 v |= addr[7];
811 return COERCE64 (v);
814 int64_t
815 bfd_getl_signed_64 (const void *p)
817 const bfd_byte *addr = (const bfd_byte *) p;
818 uint64_t v;
820 v = addr[7]; v <<= 8;
821 v |= addr[6]; v <<= 8;
822 v |= addr[5]; v <<= 8;
823 v |= addr[4]; v <<= 8;
824 v |= addr[3]; v <<= 8;
825 v |= addr[2]; v <<= 8;
826 v |= addr[1]; v <<= 8;
827 v |= addr[0];
829 return COERCE64 (v);
832 void
833 bfd_putb32 (bfd_vma data, void *p)
835 bfd_byte *addr = (bfd_byte *) p;
836 addr[0] = (data >> 24) & 0xff;
837 addr[1] = (data >> 16) & 0xff;
838 addr[2] = (data >> 8) & 0xff;
839 addr[3] = data & 0xff;
842 void
843 bfd_putl32 (bfd_vma data, void *p)
845 bfd_byte *addr = (bfd_byte *) p;
846 addr[0] = data & 0xff;
847 addr[1] = (data >> 8) & 0xff;
848 addr[2] = (data >> 16) & 0xff;
849 addr[3] = (data >> 24) & 0xff;
852 void
853 bfd_putb64 (uint64_t data, void *p)
855 bfd_byte *addr = (bfd_byte *) p;
856 addr[0] = (data >> (7*8)) & 0xff;
857 addr[1] = (data >> (6*8)) & 0xff;
858 addr[2] = (data >> (5*8)) & 0xff;
859 addr[3] = (data >> (4*8)) & 0xff;
860 addr[4] = (data >> (3*8)) & 0xff;
861 addr[5] = (data >> (2*8)) & 0xff;
862 addr[6] = (data >> (1*8)) & 0xff;
863 addr[7] = (data >> (0*8)) & 0xff;
866 void
867 bfd_putl64 (uint64_t data, void *p)
869 bfd_byte *addr = (bfd_byte *) p;
870 addr[7] = (data >> (7*8)) & 0xff;
871 addr[6] = (data >> (6*8)) & 0xff;
872 addr[5] = (data >> (5*8)) & 0xff;
873 addr[4] = (data >> (4*8)) & 0xff;
874 addr[3] = (data >> (3*8)) & 0xff;
875 addr[2] = (data >> (2*8)) & 0xff;
876 addr[1] = (data >> (1*8)) & 0xff;
877 addr[0] = (data >> (0*8)) & 0xff;
880 void
881 bfd_put_bits (uint64_t data, void *p, int bits, bool big_p)
883 bfd_byte *addr = (bfd_byte *) p;
884 int i;
885 int bytes;
887 if (bits % 8 != 0)
888 abort ();
890 bytes = bits / 8;
891 for (i = 0; i < bytes; i++)
893 int addr_index = big_p ? bytes - i - 1 : i;
895 addr[addr_index] = data & 0xff;
896 data >>= 8;
900 uint64_t
901 bfd_get_bits (const void *p, int bits, bool big_p)
903 const bfd_byte *addr = (const bfd_byte *) p;
904 uint64_t data;
905 int i;
906 int bytes;
908 if (bits % 8 != 0)
909 abort ();
911 data = 0;
912 bytes = bits / 8;
913 for (i = 0; i < bytes; i++)
915 int addr_index = big_p ? i : bytes - i - 1;
917 data = (data << 8) | addr[addr_index];
920 return data;
923 /* Default implementation */
925 bool
926 _bfd_generic_get_section_contents (bfd *abfd,
927 sec_ptr section,
928 void *location,
929 file_ptr offset,
930 bfd_size_type count)
932 bfd_size_type sz;
933 if (count == 0)
934 return true;
936 if (section->compress_status != COMPRESS_SECTION_NONE)
938 _bfd_error_handler
939 /* xgettext:c-format */
940 (_("%pB: unable to get decompressed section %pA"),
941 abfd, section);
942 bfd_set_error (bfd_error_invalid_operation);
943 return false;
946 /* We do allow reading of a section after bfd_final_link has
947 written the contents out to disk. In that situation, rawsize is
948 just a stale version of size, so ignore it. Otherwise we must be
949 reading an input section, where rawsize, if different to size,
950 is the on-disk size. */
951 if (abfd->direction != write_direction && section->rawsize != 0)
952 sz = section->rawsize;
953 else
954 sz = section->size;
955 if (offset + count < count
956 || offset + count > sz
957 || (abfd->my_archive != NULL
958 && !bfd_is_thin_archive (abfd->my_archive)
959 && ((ufile_ptr) section->filepos + offset + count
960 > arelt_size (abfd))))
962 bfd_set_error (bfd_error_invalid_operation);
963 return false;
966 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
967 || bfd_bread (location, count, abfd) != count)
968 return false;
970 return true;
973 bool
974 _bfd_generic_get_section_contents_in_window
975 (bfd *abfd ATTRIBUTE_UNUSED,
976 sec_ptr section ATTRIBUTE_UNUSED,
977 bfd_window *w ATTRIBUTE_UNUSED,
978 file_ptr offset ATTRIBUTE_UNUSED,
979 bfd_size_type count ATTRIBUTE_UNUSED)
981 #ifdef USE_MMAP
982 bfd_size_type sz;
984 if (count == 0)
985 return true;
986 if (abfd->xvec->_bfd_get_section_contents
987 != _bfd_generic_get_section_contents)
989 /* We don't know what changes the bfd's get_section_contents
990 method may have to make. So punt trying to map the file
991 window, and let get_section_contents do its thing. */
992 /* @@ FIXME : If the internal window has a refcount of 1 and was
993 allocated with malloc instead of mmap, just reuse it. */
994 bfd_free_window (w);
995 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
996 if (w->i == NULL)
997 return false;
998 w->i->data = bfd_malloc (count);
999 if (w->i->data == NULL)
1001 free (w->i);
1002 w->i = NULL;
1003 return false;
1005 w->i->mapped = 0;
1006 w->i->refcount = 1;
1007 w->size = w->i->size = count;
1008 w->data = w->i->data;
1009 return bfd_get_section_contents (abfd, section, w->data, offset, count);
1011 if (abfd->direction != write_direction && section->rawsize != 0)
1012 sz = section->rawsize;
1013 else
1014 sz = section->size;
1015 if (offset + count < count
1016 || offset + count > sz
1017 || (abfd->my_archive != NULL
1018 && !bfd_is_thin_archive (abfd->my_archive)
1019 && ((ufile_ptr) section->filepos + offset + count
1020 > arelt_size (abfd)))
1021 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
1022 true))
1023 return false;
1024 return true;
1025 #else
1026 abort ();
1027 #endif
1030 /* This generic function can only be used in implementations where creating
1031 NEW sections is disallowed. It is useful in patching existing sections
1032 in read-write files, though. See other set_section_contents functions
1033 to see why it doesn't work for new sections. */
1034 bool
1035 _bfd_generic_set_section_contents (bfd *abfd,
1036 sec_ptr section,
1037 const void *location,
1038 file_ptr offset,
1039 bfd_size_type count)
1041 if (count == 0)
1042 return true;
1044 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1045 || bfd_bwrite (location, count, abfd) != count)
1046 return false;
1048 return true;
1052 INTERNAL_FUNCTION
1053 bfd_log2
1055 SYNOPSIS
1056 unsigned int bfd_log2 (bfd_vma x);
1058 DESCRIPTION
1059 Return the log base 2 of the value supplied, rounded up. E.g., an
1060 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
1063 unsigned int
1064 bfd_log2 (bfd_vma x)
1066 unsigned int result = 0;
1068 if (x <= 1)
1069 return result;
1070 --x;
1072 ++result;
1073 while ((x >>= 1) != 0);
1074 return result;
1077 bool
1078 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
1080 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1082 return name[0] == locals_prefix;
1085 /* Give a warning at runtime if someone compiles code which calls
1086 old routines. */
1088 void
1089 _bfd_warn_deprecated (const char *what,
1090 const char *file,
1091 int line,
1092 const char *func)
1094 /* Poor man's tracking of functions we've already warned about. */
1095 static size_t mask = 0;
1097 if (~(size_t) func & ~mask)
1099 fflush (stdout);
1100 /* Note: separate sentences in order to allow
1101 for translation into other languages. */
1102 if (func)
1103 /* xgettext:c-format */
1104 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
1105 what, file, line, func);
1106 else
1107 fprintf (stderr, _("Deprecated %s called\n"), what);
1108 fflush (stderr);
1109 mask |= ~(size_t) func;
1113 /* Helper function for reading uleb128 encoded data. */
1115 bfd_vma
1116 _bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1117 bfd_byte *buf,
1118 unsigned int *bytes_read_ptr)
1120 bfd_vma result;
1121 unsigned int num_read;
1122 unsigned int shift;
1123 unsigned char byte;
1125 result = 0;
1126 shift = 0;
1127 num_read = 0;
1130 byte = bfd_get_8 (abfd, buf);
1131 buf++;
1132 num_read++;
1133 if (shift < 8 * sizeof (result))
1135 result |= (((bfd_vma) byte & 0x7f) << shift);
1136 shift += 7;
1139 while (byte & 0x80);
1140 *bytes_read_ptr = num_read;
1141 return result;
1144 /* Read in a LEB128 encoded value from ABFD starting at *PTR.
1145 If SIGN is true, return a signed LEB128 value.
1146 *PTR is incremented by the number of bytes read.
1147 No bytes will be read at address END or beyond. */
1149 bfd_vma
1150 _bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1151 bfd_byte **ptr,
1152 bool sign,
1153 const bfd_byte * const end)
1155 bfd_vma result = 0;
1156 unsigned int shift = 0;
1157 unsigned char byte = 0;
1158 bfd_byte *data = *ptr;
1160 while (data < end)
1162 byte = bfd_get_8 (abfd, data);
1163 data++;
1164 if (shift < 8 * sizeof (result))
1166 result |= ((bfd_vma) (byte & 0x7f)) << shift;
1167 shift += 7;
1169 if ((byte & 0x80) == 0)
1170 break;
1173 *ptr = data;
1175 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1176 result |= -((bfd_vma) 1 << shift);
1178 return result;
1181 /* Helper function for reading sleb128 encoded data. */
1183 bfd_signed_vma
1184 _bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1185 bfd_byte *buf,
1186 unsigned int *bytes_read_ptr)
1188 bfd_vma result;
1189 unsigned int shift;
1190 unsigned int num_read;
1191 unsigned char byte;
1193 result = 0;
1194 shift = 0;
1195 num_read = 0;
1198 byte = bfd_get_8 (abfd, buf);
1199 buf ++;
1200 num_read ++;
1201 if (shift < 8 * sizeof (result))
1203 result |= (((bfd_vma) byte & 0x7f) << shift);
1204 shift += 7;
1207 while (byte & 0x80);
1208 if (shift < 8 * sizeof (result) && (byte & 0x40))
1209 result |= (((bfd_vma) -1) << shift);
1210 *bytes_read_ptr = num_read;
1211 return result;
1214 /* Write VAL in uleb128 format to P.
1215 END indicates the last byte of allocated space for the uleb128 value to fit
1217 Return a pointer to the byte following the last byte that was written, or
1218 NULL if the uleb128 value does not fit in the allocated space between P and
1219 END. */
1220 bfd_byte *
1221 _bfd_write_unsigned_leb128 (bfd_byte *p, bfd_byte *end, bfd_vma val)
1223 bfd_byte c;
1226 if (p > end)
1227 return NULL;
1228 c = val & 0x7f;
1229 val >>= 7;
1230 if (val)
1231 c |= 0x80;
1232 *(p++) = c;
1234 while (val);
1235 return p;
1238 bool
1239 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1240 asection *isec ATTRIBUTE_UNUSED,
1241 bfd *obfd ATTRIBUTE_UNUSED,
1242 asection *osec ATTRIBUTE_UNUSED,
1243 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1245 return true;