1 /* Assorted BFD support routines, only used internally.
2 Copyright (C) 1990-2023 Free Software Foundation, Inc.
3 Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "objalloc.h"
26
27 #ifndef HAVE_GETPAGESIZE
28 #define getpagesize() 2048
29 #endif
30
31 /*
32 SECTION
33 Implementation details
34
35 SUBSECTION
36 Internal functions
37
38 DESCRIPTION
39 These routines are used within BFD.
40 They are not intended for export, but are documented here for
41 completeness.
42 */
43
44 bool
45 _bfd_bool_bfd_false (bfd *abfd ATTRIBUTE_UNUSED)
46 {
47 return false;
48 }
49
50 bool
51 _bfd_bool_bfd_asymbol_false (bfd *abfd ATTRIBUTE_UNUSED,
52 asymbol *sym ATTRIBUTE_UNUSED)
53 {
54 return false;
55 }
56
57 /* A routine which is used in target vectors for unsupported
58 operations. */
59
60 bool
61 _bfd_bool_bfd_false_error (bfd *ignore ATTRIBUTE_UNUSED)
62 {
63 bfd_set_error (bfd_error_invalid_operation);
64 return false;
65 }
66
67 bool
68 _bfd_bool_bfd_link_false_error (bfd *abfd,
69 struct bfd_link_info *info ATTRIBUTE_UNUSED)
70 {
71 return _bfd_bool_bfd_false_error (abfd);
72 }
73
74 /* A routine which is used in target vectors for supported operations
75 which do not actually do anything. */
76
77 bool
78 _bfd_bool_bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
79 {
80 return true;
81 }
82
83 bool
84 _bfd_bool_bfd_link_true (bfd *abfd ATTRIBUTE_UNUSED,
85 struct bfd_link_info *info ATTRIBUTE_UNUSED)
86 {
87 return true;
88 }
89
90 bool
91 _bfd_bool_bfd_bfd_true (bfd *ibfd ATTRIBUTE_UNUSED,
92 bfd *obfd ATTRIBUTE_UNUSED)
93 {
94 return true;
95 }
96
97 bool
98 _bfd_bool_bfd_uint_true (bfd *abfd ATTRIBUTE_UNUSED,
99 unsigned int flags ATTRIBUTE_UNUSED)
100 {
101 return true;
102 }
103
104 bool
105 _bfd_bool_bfd_asection_bfd_asection_true (bfd *ibfd ATTRIBUTE_UNUSED,
106 asection *isec ATTRIBUTE_UNUSED,
107 bfd *obfd ATTRIBUTE_UNUSED,
108 asection *osec ATTRIBUTE_UNUSED)
109 {
110 return true;
111 }
112
113 bool
114 _bfd_bool_bfd_asymbol_bfd_asymbol_true (bfd *ibfd ATTRIBUTE_UNUSED,
115 asymbol *isym ATTRIBUTE_UNUSED,
116 bfd *obfd ATTRIBUTE_UNUSED,
117 asymbol *osym ATTRIBUTE_UNUSED)
118 {
119 return true;
120 }
121
122 bool
123 _bfd_bool_bfd_ptr_true (bfd *abfd ATTRIBUTE_UNUSED,
124 void *ptr ATTRIBUTE_UNUSED)
125 {
126 return true;
127 }
128
129 /* A routine which is used in target vectors for unsupported
130 operations which return a pointer value. */
131
132 void *
133 _bfd_ptr_bfd_null_error (bfd *ignore ATTRIBUTE_UNUSED)
134 {
135 bfd_set_error (bfd_error_invalid_operation);
136 return NULL;
137 }
138
139 int
140 _bfd_int_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
141 {
142 return 0;
143 }
144
145 unsigned int
146 _bfd_uint_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
147 {
148 return 0;
149 }
150
151 long
152 _bfd_long_bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
153 {
154 return 0;
155 }
156
157 /* A routine which is used in target vectors for unsupported
158 operations which return -1 on error. */
159
160 long
161 _bfd_long_bfd_n1_error (bfd *ignore_abfd ATTRIBUTE_UNUSED)
162 {
163 bfd_set_error (bfd_error_invalid_operation);
164 return -1;
165 }
166
167 void
168 _bfd_void_bfd (bfd *ignore ATTRIBUTE_UNUSED)
169 {
170 }
171
172 void
173 _bfd_void_bfd_link (bfd *abfd ATTRIBUTE_UNUSED,
174 struct bfd_link_info *info ATTRIBUTE_UNUSED)
175 {
176 }
177
178 void
179 _bfd_void_bfd_asection (bfd *abfd ATTRIBUTE_UNUSED,
180 asection *sec ATTRIBUTE_UNUSED)
181 {
182 }
183
184 long
185 _bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
186 asection *sec ATTRIBUTE_UNUSED)
187 {
188 return sizeof (arelent *);
189 }
190
191 long
192 _bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
193 asection *sec ATTRIBUTE_UNUSED,
194 arelent **relptr,
195 asymbol **symbols ATTRIBUTE_UNUSED)
196 {
197 *relptr = NULL;
198 return 0;
199 }
200
201 void
202 _bfd_norelocs_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
203 asection *sec ATTRIBUTE_UNUSED,
204 arelent **relptr ATTRIBUTE_UNUSED,
205 unsigned int count ATTRIBUTE_UNUSED)
206 {
207 /* Do nothing. */
208 }
209
210 bool
211 _bfd_nocore_core_file_matches_executable_p
212 (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
213 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
214 {
215 bfd_set_error (bfd_error_invalid_operation);
216 return false;
217 }
218
219 /* Routine to handle core_file_failing_command entry point for targets
220 without core file support. */
221
222 char *
223 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
224 {
225 bfd_set_error (bfd_error_invalid_operation);
226 return NULL;
227 }
228
229 /* Routine to handle core_file_failing_signal entry point for targets
230 without core file support. */
231
232 int
233 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
234 {
235 bfd_set_error (bfd_error_invalid_operation);
236 return 0;
237 }
238
239 /* Routine to handle the core_file_pid entry point for targets without
240 core file support. */
241
242 int
243 _bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
244 {
245 bfd_set_error (bfd_error_invalid_operation);
246 return 0;
247 }
248
249 bfd_cleanup
250 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
251 {
252 bfd_set_error (bfd_error_wrong_format);
253 return 0;
254 }
255
256 /* Allocate memory using malloc. */
257
258 #ifndef SSIZE_MAX
259 #define SSIZE_MAX ((size_t) -1 >> 1)
260 #endif
261
262 /*
263 INTERNAL_FUNCTION
264 bfd_malloc
265
266 SYNOPSIS
267 void *bfd_malloc (bfd_size_type {*size*});
268
269 DESCRIPTION
270 Returns a pointer to an allocated block of memory that is at least
271 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
272 1. If SIZE is too big then NULL will be returned.
273
274 Returns NULL upon error and sets bfd_error.
275 */
276 void *
277 bfd_malloc (bfd_size_type size)
278 {
279 void *ptr;
280 size_t sz = (size_t) size;
281
282 if (size != sz
283 /* This is to pacify memory checkers like valgrind. */
284 || sz > SSIZE_MAX)
285 {
286 bfd_set_error (bfd_error_no_memory);
287 return NULL;
288 }
289
290 ptr = malloc (sz ? sz : 1);
291 if (ptr == NULL)
292 bfd_set_error (bfd_error_no_memory);
293
294 return ptr;
295 }
296
297 /*
298 INTERNAL_FUNCTION
299 bfd_realloc
300
301 SYNOPSIS
302 void *bfd_realloc (void *{*mem*}, bfd_size_type {*size*});
303
304 DESCRIPTION
305 Returns a pointer to an allocated block of memory that is at least
306 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
307 1. If SIZE is too big then NULL will be returned.
308
309 If MEM is not NULL then it must point to an allocated block of memory.
310 If this block is large enough then MEM may be used as the return
311 value for this function, but this is not guaranteed.
312
313 If MEM is not returned then the first N bytes in the returned block
314 will be identical to the first N bytes in region pointed to by MEM,
315 where N is the lessor of SIZE and the length of the region of memory
316 currently addressed by MEM.
317
318 Returns NULL upon error and sets bfd_error.
319 */
320 void *
321 bfd_realloc (void *ptr, bfd_size_type size)
322 {
323 void *ret;
324 size_t sz = (size_t) size;
325
326 if (ptr == NULL)
327 return bfd_malloc (size);
328
329 if (size != sz
330 /* This is to pacify memory checkers like valgrind. */
331 || sz > SSIZE_MAX)
332 {
333 bfd_set_error (bfd_error_no_memory);
334 return NULL;
335 }
336
337 /* The behaviour of realloc(0) is implementation defined,
338 but for this function we always allocate memory. */
339 ret = realloc (ptr, sz ? sz : 1);
340
341 if (ret == NULL)
342 bfd_set_error (bfd_error_no_memory);
343
344 return ret;
345 }
346
347 /*
348 INTERNAL_FUNCTION
349 bfd_realloc_or_free
350
351 SYNOPSIS
352 void *bfd_realloc_or_free (void *{*mem*}, bfd_size_type {*size*});
353
354 DESCRIPTION
355 Returns a pointer to an allocated block of memory that is at least
356 SIZE bytes long. If SIZE is 0 then no memory will be allocated,
357 MEM will be freed, and NULL will be returned. This will not cause
358 bfd_error to be set.
359
360 If SIZE is too big then NULL will be returned and bfd_error will be
361 set.
362
363 If MEM is not NULL then it must point to an allocated block of memory.
364 If this block is large enough then MEM may be used as the return
365 value for this function, but this is not guaranteed.
366
367 If MEM is not returned then the first N bytes in the returned block
368 will be identical to the first N bytes in region pointed to by MEM,
369 where N is the lessor of SIZE and the length of the region of memory
370 currently addressed by MEM.
371 */
372 void *
373 bfd_realloc_or_free (void *ptr, bfd_size_type size)
374 {
375 void *ret;
376
377 /* The behaviour of realloc(0) is implementation defined, but
378 for this function we treat it is always freeing the memory. */
379 if (size == 0)
380 {
381 free (ptr);
382 return NULL;
383 }
384
385 ret = bfd_realloc (ptr, size);
386 if (ret == NULL)
387 free (ptr);
388
389 return ret;
390 }
391
392 /*
393 INTERNAL_FUNCTION
394 bfd_zmalloc
395
396 SYNOPSIS
397 void *bfd_zmalloc (bfd_size_type {*size*});
398
399 DESCRIPTION
400 Returns a pointer to an allocated block of memory that is at least
401 SIZE bytes long. If SIZE is 0 then it will be treated as if it were
402 1. If SIZE is too big then NULL will be returned.
403
404 Returns NULL upon error and sets bfd_error.
405
406 If NULL is not returned then the allocated block of memory will
407 have been cleared.
408 */
409 void *
410 bfd_zmalloc (bfd_size_type size)
411 {
412 void *ptr = bfd_malloc (size);
413
414 if (ptr != NULL)
415 memset (ptr, 0, size ? (size_t) size : 1);
416
417 return ptr;
418 }
419
420 /*
421 FUNCTION
422 bfd_alloc
423
424 SYNOPSIS
425 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
426
427 DESCRIPTION
428 Allocate a block of @var{wanted} bytes of memory attached to
429 <<abfd>> and return a pointer to it.
430 */
431
432 void *
433 bfd_alloc (bfd *abfd, bfd_size_type size)
434 {
435 void *ret;
436 unsigned long ul_size = (unsigned long) size;
437
438 if (size != ul_size
439 /* Note - although objalloc_alloc takes an unsigned long as its
440 argument, internally the size is treated as a signed long. This can
441 lead to problems where, for example, a request to allocate -1 bytes
442 can result in just 1 byte being allocated, rather than
443 ((unsigned long) -1) bytes. Also memory checkers will often
444 complain about attempts to allocate a negative amount of memory.
445 So to stop these problems we fail if the size is negative. */
446 || ((signed long) ul_size) < 0)
447 {
448 bfd_set_error (bfd_error_no_memory);
449 return NULL;
450 }
451
452 ret = objalloc_alloc ((struct objalloc *) abfd->memory, ul_size);
453 if (ret == NULL)
454 bfd_set_error (bfd_error_no_memory);
455 else
456 abfd->alloc_size += size;
457 return ret;
458 }
459
460 /*
461 FUNCTION
462 bfd_zalloc
463
464 SYNOPSIS
465 void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
466
467 DESCRIPTION
468 Allocate a block of @var{wanted} bytes of zeroed memory
469 attached to <<abfd>> and return a pointer to it.
470 */
471
472 void *
473 bfd_zalloc (bfd *abfd, bfd_size_type size)
474 {
475 void *res;
476
477 res = bfd_alloc (abfd, size);
478 if (res)
479 memset (res, 0, (size_t) size);
480 return res;
481 }
482
483 /*
484 FUNCTION
485 bfd_release
486
487 SYNOPSIS
488 void bfd_release (bfd *, void *);
489
490 DESCRIPTION
491 Free a block allocated for a BFD.
492 Note: Also frees all more recently allocated blocks!
493 */
494
495 void
496 bfd_release (bfd *abfd, void *block)
497 {
498 objalloc_free_block ((struct objalloc *) abfd->memory, block);
499 }
500
501 /*
502 INTERNAL_FUNCTION
503 bfd_write_bigendian_4byte_int
504
505 SYNOPSIS
506 bool bfd_write_bigendian_4byte_int (bfd *, unsigned int);
507
508 DESCRIPTION
509 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
510 endian order regardless of what else is going on. This is useful in
511 archives.
512
513 */
514 bool
515 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
516 {
517 bfd_byte buffer[4];
518 bfd_putb32 ((bfd_vma) i, buffer);
519 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
520 }
521
522
523 /** The do-it-yourself (byte) sex-change kit */
524
525 /* The middle letter e.g. get<b>short indicates Big or Little endian
526 target machine. It doesn't matter what the byte order of the host
527 machine is; these routines work for either. */
528
529 /* FIXME: Should these take a count argument?
530 Answer (gnu@cygnus.com): No, but perhaps they should be inline
531 functions in swap.h #ifdef __GNUC__.
532 Gprof them later and find out. */
533
534 /*
535 FUNCTION
536 bfd_put_size
537 FUNCTION
538 bfd_get_size
539
540 DESCRIPTION
541 These macros as used for reading and writing raw data in
542 sections; each access (except for bytes) is vectored through
543 the target format of the BFD and mangled accordingly. The
544 mangling performs any necessary endian translations and
545 removes alignment restrictions. Note that types accepted and
546 returned by these macros are identical so they can be swapped
547 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
548 to either <<bfd_get_32>> or <<bfd_get_64>>.
549
550 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
551 system without prototypes, the caller is responsible for making
552 sure that is true, with a cast if necessary. We don't cast
553 them in the macro definitions because that would prevent <<lint>>
554 or <<gcc -Wall>> from detecting sins such as passing a pointer.
555 To detect calling these with less than a <<bfd_vma>>, use
556 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
557
558 .
559 .{* Byte swapping macros for user section data. *}
560 .
561 .#define bfd_put_8(abfd, val, ptr) \
562 . ((void) (*((bfd_byte *) (ptr)) = (val) & 0xff))
563 .#define bfd_put_signed_8 \
564 . bfd_put_8
565 .#define bfd_get_8(abfd, ptr) \
566 . ((bfd_vma) *(const bfd_byte *) (ptr) & 0xff)
567 .#define bfd_get_signed_8(abfd, ptr) \
568 . ((((bfd_signed_vma) *(const bfd_byte *) (ptr) & 0xff) ^ 0x80) - 0x80)
569 .
570 .#define bfd_put_16(abfd, val, ptr) \
571 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
572 .#define bfd_put_signed_16 \
573 . bfd_put_16
574 .#define bfd_get_16(abfd, ptr) \
575 . BFD_SEND (abfd, bfd_getx16, (ptr))
576 .#define bfd_get_signed_16(abfd, ptr) \
577 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
578 .
579 .#define bfd_put_24(abfd, val, ptr) \
580 . do \
581 . if (bfd_big_endian (abfd)) \
582 . bfd_putb24 ((val), (ptr)); \
583 . else \
584 . bfd_putl24 ((val), (ptr)); \
585 . while (0)
586 .
587 .bfd_vma bfd_getb24 (const void *p);
588 .bfd_vma bfd_getl24 (const void *p);
589 .
590 .#define bfd_get_24(abfd, ptr) \
591 . (bfd_big_endian (abfd) ? bfd_getb24 (ptr) : bfd_getl24 (ptr))
592 .
593 .#define bfd_put_32(abfd, val, ptr) \
594 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
595 .#define bfd_put_signed_32 \
596 . bfd_put_32
597 .#define bfd_get_32(abfd, ptr) \
598 . BFD_SEND (abfd, bfd_getx32, (ptr))
599 .#define bfd_get_signed_32(abfd, ptr) \
600 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
601 .
602 .#define bfd_put_64(abfd, val, ptr) \
603 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
604 .#define bfd_put_signed_64 \
605 . bfd_put_64
606 .#define bfd_get_64(abfd, ptr) \
607 . BFD_SEND (abfd, bfd_getx64, (ptr))
608 .#define bfd_get_signed_64(abfd, ptr) \
609 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
610 .
611 .#define bfd_get(bits, abfd, ptr) \
612 . ((bits) == 8 ? bfd_get_8 (abfd, ptr) \
613 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
614 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
615 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
616 . : (abort (), (bfd_vma) - 1))
617 .
618 .#define bfd_put(bits, abfd, val, ptr) \
619 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
620 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
621 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
622 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
623 . : (abort (), (void) 0))
624 .
625 */
626
627 /*
628 FUNCTION
629 bfd_h_put_size
630 bfd_h_get_size
631
632 DESCRIPTION
633 These macros have the same function as their <<bfd_get_x>>
634 brethren, except that they are used for removing information
635 for the header records of object files. Believe it or not,
636 some object files keep their header records in big endian
637 order and their data in little endian order.
638 .
639 .{* Byte swapping macros for file header data. *}
640 .
641 .#define bfd_h_put_8(abfd, val, ptr) \
642 . bfd_put_8 (abfd, val, ptr)
643 .#define bfd_h_put_signed_8(abfd, val, ptr) \
644 . bfd_put_8 (abfd, val, ptr)
645 .#define bfd_h_get_8(abfd, ptr) \
646 . bfd_get_8 (abfd, ptr)
647 .#define bfd_h_get_signed_8(abfd, ptr) \
648 . bfd_get_signed_8 (abfd, ptr)
649 .
650 .#define bfd_h_put_16(abfd, val, ptr) \
651 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
652 .#define bfd_h_put_signed_16 \
653 . bfd_h_put_16
654 .#define bfd_h_get_16(abfd, ptr) \
655 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
656 .#define bfd_h_get_signed_16(abfd, ptr) \
657 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
658 .
659 .#define bfd_h_put_32(abfd, val, ptr) \
660 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
661 .#define bfd_h_put_signed_32 \
662 . bfd_h_put_32
663 .#define bfd_h_get_32(abfd, ptr) \
664 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
665 .#define bfd_h_get_signed_32(abfd, ptr) \
666 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
667 .
668 .#define bfd_h_put_64(abfd, val, ptr) \
669 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
670 .#define bfd_h_put_signed_64 \
671 . bfd_h_put_64
672 .#define bfd_h_get_64(abfd, ptr) \
673 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
674 .#define bfd_h_get_signed_64(abfd, ptr) \
675 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
676 .
677 .{* Aliases for the above, which should eventually go away. *}
678 .
679 .#define H_PUT_64 bfd_h_put_64
680 .#define H_PUT_32 bfd_h_put_32
681 .#define H_PUT_16 bfd_h_put_16
682 .#define H_PUT_8 bfd_h_put_8
683 .#define H_PUT_S64 bfd_h_put_signed_64
684 .#define H_PUT_S32 bfd_h_put_signed_32
685 .#define H_PUT_S16 bfd_h_put_signed_16
686 .#define H_PUT_S8 bfd_h_put_signed_8
687 .#define H_GET_64 bfd_h_get_64
688 .#define H_GET_32 bfd_h_get_32
689 .#define H_GET_16 bfd_h_get_16
690 .#define H_GET_8 bfd_h_get_8
691 .#define H_GET_S64 bfd_h_get_signed_64
692 .#define H_GET_S32 bfd_h_get_signed_32
693 .#define H_GET_S16 bfd_h_get_signed_16
694 .#define H_GET_S8 bfd_h_get_signed_8
695 .
696 .*/
697
698 /* Sign extension to bfd_signed_vma. */
699 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
700 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
701 #define COERCE64(x) \
702 (((uint64_t) (x) ^ ((uint64_t) 1 << 63)) - ((uint64_t) 1 << 63))
703
704 /*
705 FUNCTION
706 Byte swapping routines.
707
708 SYNOPSIS
709 uint64_t bfd_getb64 (const void *);
710 uint64_t bfd_getl64 (const void *);
711 int64_t bfd_getb_signed_64 (const void *);
712 int64_t bfd_getl_signed_64 (const void *);
713 bfd_vma bfd_getb32 (const void *);
714 bfd_vma bfd_getl32 (const void *);
715 bfd_signed_vma bfd_getb_signed_32 (const void *);
716 bfd_signed_vma bfd_getl_signed_32 (const void *);
717 bfd_vma bfd_getb16 (const void *);
718 bfd_vma bfd_getl16 (const void *);
719 bfd_signed_vma bfd_getb_signed_16 (const void *);
720 bfd_signed_vma bfd_getl_signed_16 (const void *);
721 void bfd_putb64 (uint64_t, void *);
722 void bfd_putl64 (uint64_t, void *);
723 void bfd_putb32 (bfd_vma, void *);
724 void bfd_putl32 (bfd_vma, void *);
725 void bfd_putb24 (bfd_vma, void *);
726 void bfd_putl24 (bfd_vma, void *);
727 void bfd_putb16 (bfd_vma, void *);
728 void bfd_putl16 (bfd_vma, void *);
729 uint64_t bfd_get_bits (const void *, int, bool);
730 void bfd_put_bits (uint64_t, void *, int, bool);
731 */
732
733 bfd_vma
734 bfd_getb16 (const void *p)
735 {
736 const bfd_byte *addr = (const bfd_byte *) p;
737 return (addr[0] << 8) | addr[1];
738 }
739
740 bfd_vma
741 bfd_getl16 (const void *p)
742 {
743 const bfd_byte *addr = (const bfd_byte *) p;
744 return (addr[1] << 8) | addr[0];
745 }
746
747 bfd_signed_vma
748 bfd_getb_signed_16 (const void *p)
749 {
750 const bfd_byte *addr = (const bfd_byte *) p;
751 return COERCE16 ((addr[0] << 8) | addr[1]);
752 }
753
754 bfd_signed_vma
755 bfd_getl_signed_16 (const void *p)
756 {
757 const bfd_byte *addr = (const bfd_byte *) p;
758 return COERCE16 ((addr[1] << 8) | addr[0]);
759 }
760
761 void
762 bfd_putb16 (bfd_vma data, void *p)
763 {
764 bfd_byte *addr = (bfd_byte *) p;
765 addr[0] = (data >> 8) & 0xff;
766 addr[1] = data & 0xff;
767 }
768
769 void
770 bfd_putl16 (bfd_vma data, void *p)
771 {
772 bfd_byte *addr = (bfd_byte *) p;
773 addr[0] = data & 0xff;
774 addr[1] = (data >> 8) & 0xff;
775 }
776
777 void
778 bfd_putb24 (bfd_vma data, void *p)
779 {
780 bfd_byte *addr = (bfd_byte *) p;
781 addr[0] = (data >> 16) & 0xff;
782 addr[1] = (data >> 8) & 0xff;
783 addr[2] = data & 0xff;
784 }
785
786 void
787 bfd_putl24 (bfd_vma data, void *p)
788 {
789 bfd_byte *addr = (bfd_byte *) p;
790 addr[0] = data & 0xff;
791 addr[1] = (data >> 8) & 0xff;
792 addr[2] = (data >> 16) & 0xff;
793 }
794
795 bfd_vma
796 bfd_getb24 (const void *p)
797 {
798 const bfd_byte *addr = (const bfd_byte *) p;
799 uint32_t v;
800
801 v = (uint32_t) addr[0] << 16;
802 v |= (uint32_t) addr[1] << 8;
803 v |= (uint32_t) addr[2];
804 return v;
805 }
806
807 bfd_vma
808 bfd_getl24 (const void *p)
809 {
810 const bfd_byte *addr = (const bfd_byte *) p;
811 uint32_t v;
812
813 v = (uint32_t) addr[0];
814 v |= (uint32_t) addr[1] << 8;
815 v |= (uint32_t) addr[2] << 16;
816 return v;
817 }
818
819 bfd_vma
820 bfd_getb32 (const void *p)
821 {
822 const bfd_byte *addr = (const bfd_byte *) p;
823 uint32_t v;
824
825 v = (uint32_t) addr[0] << 24;
826 v |= (uint32_t) addr[1] << 16;
827 v |= (uint32_t) addr[2] << 8;
828 v |= (uint32_t) addr[3];
829 return v;
830 }
831
832 bfd_vma
833 bfd_getl32 (const void *p)
834 {
835 const bfd_byte *addr = (const bfd_byte *) p;
836 uint32_t v;
837
838 v = (uint32_t) addr[0];
839 v |= (uint32_t) addr[1] << 8;
840 v |= (uint32_t) addr[2] << 16;
841 v |= (uint32_t) addr[3] << 24;
842 return v;
843 }
844
845 bfd_signed_vma
846 bfd_getb_signed_32 (const void *p)
847 {
848 const bfd_byte *addr = (const bfd_byte *) p;
849 uint32_t v;
850
851 v = (uint32_t) addr[0] << 24;
852 v |= (uint32_t) addr[1] << 16;
853 v |= (uint32_t) addr[2] << 8;
854 v |= (uint32_t) addr[3];
855 return COERCE32 (v);
856 }
857
858 bfd_signed_vma
859 bfd_getl_signed_32 (const void *p)
860 {
861 const bfd_byte *addr = (const bfd_byte *) p;
862 uint32_t v;
863
864 v = (uint32_t) addr[0];
865 v |= (uint32_t) addr[1] << 8;
866 v |= (uint32_t) addr[2] << 16;
867 v |= (uint32_t) addr[3] << 24;
868 return COERCE32 (v);
869 }
870
871 uint64_t
872 bfd_getb64 (const void *p)
873 {
874 const bfd_byte *addr = (const bfd_byte *) p;
875 uint64_t v;
876
877 v = addr[0]; v <<= 8;
878 v |= addr[1]; v <<= 8;
879 v |= addr[2]; v <<= 8;
880 v |= addr[3]; v <<= 8;
881 v |= addr[4]; v <<= 8;
882 v |= addr[5]; v <<= 8;
883 v |= addr[6]; v <<= 8;
884 v |= addr[7];
885
886 return v;
887 }
888
889 uint64_t
890 bfd_getl64 (const void *p)
891 {
892 const bfd_byte *addr = (const bfd_byte *) p;
893 uint64_t v;
894
895 v = addr[7]; v <<= 8;
896 v |= addr[6]; v <<= 8;
897 v |= addr[5]; v <<= 8;
898 v |= addr[4]; v <<= 8;
899 v |= addr[3]; v <<= 8;
900 v |= addr[2]; v <<= 8;
901 v |= addr[1]; v <<= 8;
902 v |= addr[0];
903
904 return v;
905 }
906
907 int64_t
908 bfd_getb_signed_64 (const void *p)
909 {
910 const bfd_byte *addr = (const bfd_byte *) p;
911 uint64_t v;
912
913 v = addr[0]; v <<= 8;
914 v |= addr[1]; v <<= 8;
915 v |= addr[2]; v <<= 8;
916 v |= addr[3]; v <<= 8;
917 v |= addr[4]; v <<= 8;
918 v |= addr[5]; v <<= 8;
919 v |= addr[6]; v <<= 8;
920 v |= addr[7];
921
922 return COERCE64 (v);
923 }
924
925 int64_t
926 bfd_getl_signed_64 (const void *p)
927 {
928 const bfd_byte *addr = (const bfd_byte *) p;
929 uint64_t v;
930
931 v = addr[7]; v <<= 8;
932 v |= addr[6]; v <<= 8;
933 v |= addr[5]; v <<= 8;
934 v |= addr[4]; v <<= 8;
935 v |= addr[3]; v <<= 8;
936 v |= addr[2]; v <<= 8;
937 v |= addr[1]; v <<= 8;
938 v |= addr[0];
939
940 return COERCE64 (v);
941 }
942
943 void
944 bfd_putb32 (bfd_vma data, void *p)
945 {
946 bfd_byte *addr = (bfd_byte *) p;
947 addr[0] = (data >> 24) & 0xff;
948 addr[1] = (data >> 16) & 0xff;
949 addr[2] = (data >> 8) & 0xff;
950 addr[3] = data & 0xff;
951 }
952
953 void
954 bfd_putl32 (bfd_vma data, void *p)
955 {
956 bfd_byte *addr = (bfd_byte *) p;
957 addr[0] = data & 0xff;
958 addr[1] = (data >> 8) & 0xff;
959 addr[2] = (data >> 16) & 0xff;
960 addr[3] = (data >> 24) & 0xff;
961 }
962
963 void
964 bfd_putb64 (uint64_t data, void *p)
965 {
966 bfd_byte *addr = (bfd_byte *) p;
967 addr[0] = (data >> (7*8)) & 0xff;
968 addr[1] = (data >> (6*8)) & 0xff;
969 addr[2] = (data >> (5*8)) & 0xff;
970 addr[3] = (data >> (4*8)) & 0xff;
971 addr[4] = (data >> (3*8)) & 0xff;
972 addr[5] = (data >> (2*8)) & 0xff;
973 addr[6] = (data >> (1*8)) & 0xff;
974 addr[7] = (data >> (0*8)) & 0xff;
975 }
976
977 void
978 bfd_putl64 (uint64_t data, void *p)
979 {
980 bfd_byte *addr = (bfd_byte *) p;
981 addr[7] = (data >> (7*8)) & 0xff;
982 addr[6] = (data >> (6*8)) & 0xff;
983 addr[5] = (data >> (5*8)) & 0xff;
984 addr[4] = (data >> (4*8)) & 0xff;
985 addr[3] = (data >> (3*8)) & 0xff;
986 addr[2] = (data >> (2*8)) & 0xff;
987 addr[1] = (data >> (1*8)) & 0xff;
988 addr[0] = (data >> (0*8)) & 0xff;
989 }
990
991 void
992 bfd_put_bits (uint64_t data, void *p, int bits, bool big_p)
993 {
994 bfd_byte *addr = (bfd_byte *) p;
995 int i;
996 int bytes;
997
998 if (bits % 8 != 0)
999 abort ();
1000
1001 bytes = bits / 8;
1002 for (i = 0; i < bytes; i++)
1003 {
1004 int addr_index = big_p ? bytes - i - 1 : i;
1005
1006 addr[addr_index] = data & 0xff;
1007 data >>= 8;
1008 }
1009 }
1010
1011 uint64_t
1012 bfd_get_bits (const void *p, int bits, bool big_p)
1013 {
1014 const bfd_byte *addr = (const bfd_byte *) p;
1015 uint64_t data;
1016 int i;
1017 int bytes;
1018
1019 if (bits % 8 != 0)
1020 abort ();
1021
1022 data = 0;
1023 bytes = bits / 8;
1024 for (i = 0; i < bytes; i++)
1025 {
1026 int addr_index = big_p ? i : bytes - i - 1;
1027
1028 data = (data << 8) | addr[addr_index];
1029 }
1030
1031 return data;
1032 }
1033
1034 /* Default implementation */
1035
1036 bool
1037 _bfd_generic_get_section_contents (bfd *abfd,
1038 sec_ptr section,
1039 void *location,
1040 file_ptr offset,
1041 bfd_size_type count)
1042 {
1043 bfd_size_type sz;
1044 if (count == 0)
1045 return true;
1046
1047 if (section->compress_status != COMPRESS_SECTION_NONE)
1048 {
1049 _bfd_error_handler
1050 /* xgettext:c-format */
1051 (_("%pB: unable to get decompressed section %pA"),
1052 abfd, section);
1053 bfd_set_error (bfd_error_invalid_operation);
1054 return false;
1055 }
1056
1057 sz = bfd_get_section_limit_octets (abfd, section);
1058 if (offset + count < count
1059 || offset + count > sz
1060 || (abfd->my_archive != NULL
1061 && !bfd_is_thin_archive (abfd->my_archive)
1062 && ((ufile_ptr) section->filepos + offset + count
1063 > arelt_size (abfd))))
1064 {
1065 bfd_set_error (bfd_error_invalid_operation);
1066 return false;
1067 }
1068
1069 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1070 || bfd_bread (location, count, abfd) != count)
1071 return false;
1072
1073 return true;
1074 }
1075
1076 bool
1077 _bfd_generic_get_section_contents_in_window
1078 (bfd *abfd ATTRIBUTE_UNUSED,
1079 sec_ptr section ATTRIBUTE_UNUSED,
1080 bfd_window *w ATTRIBUTE_UNUSED,
1081 file_ptr offset ATTRIBUTE_UNUSED,
1082 bfd_size_type count ATTRIBUTE_UNUSED)
1083 {
1084 #ifdef USE_MMAP
1085 bfd_size_type sz;
1086
1087 if (count == 0)
1088 return true;
1089 if (abfd->xvec->_bfd_get_section_contents
1090 != _bfd_generic_get_section_contents)
1091 {
1092 /* We don't know what changes the bfd's get_section_contents
1093 method may have to make. So punt trying to map the file
1094 window, and let get_section_contents do its thing. */
1095 /* @@ FIXME : If the internal window has a refcount of 1 and was
1096 allocated with malloc instead of mmap, just reuse it. */
1097 bfd_free_window (w);
1098 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
1099 if (w->i == NULL)
1100 return false;
1101 w->i->data = bfd_malloc (count);
1102 if (w->i->data == NULL)
1103 {
1104 free (w->i);
1105 w->i = NULL;
1106 return false;
1107 }
1108 w->i->mapped = 0;
1109 w->i->refcount = 1;
1110 w->size = w->i->size = count;
1111 w->data = w->i->data;
1112 return bfd_get_section_contents (abfd, section, w->data, offset, count);
1113 }
1114 if (abfd->direction != write_direction && section->rawsize != 0)
1115 sz = section->rawsize;
1116 else
1117 sz = section->size;
1118 if (offset + count < count
1119 || offset + count > sz
1120 || (abfd->my_archive != NULL
1121 && !bfd_is_thin_archive (abfd->my_archive)
1122 && ((ufile_ptr) section->filepos + offset + count
1123 > arelt_size (abfd)))
1124 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
1125 true))
1126 return false;
1127 return true;
1128 #else
1129 abort ();
1130 #endif
1131 }
1132
1133 /* This generic function can only be used in implementations where creating
1134 NEW sections is disallowed. It is useful in patching existing sections
1135 in read-write files, though. See other set_section_contents functions
1136 to see why it doesn't work for new sections. */
1137 bool
1138 _bfd_generic_set_section_contents (bfd *abfd,
1139 sec_ptr section,
1140 const void *location,
1141 file_ptr offset,
1142 bfd_size_type count)
1143 {
1144 if (count == 0)
1145 return true;
1146
1147 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1148 || bfd_bwrite (location, count, abfd) != count)
1149 return false;
1150
1151 return true;
1152 }
1153
1154 /*
1155 INTERNAL_FUNCTION
1156 bfd_log2
1157
1158 SYNOPSIS
1159 unsigned int bfd_log2 (bfd_vma x);
1160
1161 DESCRIPTION
1162 Return the log base 2 of the value supplied, rounded up. E.g., an
1163 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
1164 */
1165
1166 unsigned int
1167 bfd_log2 (bfd_vma x)
1168 {
1169 unsigned int result = 0;
1170
1171 if (x <= 1)
1172 return result;
1173 --x;
1174 do
1175 ++result;
1176 while ((x >>= 1) != 0);
1177 return result;
1178 }
1179
1180 bool
1181 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
1182 {
1183 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
1184
1185 return name[0] == locals_prefix;
1186 }
1187
1188 /* Helper function for reading uleb128 encoded data. */
1189
1190 bfd_vma
1191 _bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1192 bfd_byte *buf,
1193 unsigned int *bytes_read_ptr)
1194 {
1195 bfd_vma result;
1196 unsigned int num_read;
1197 unsigned int shift;
1198 bfd_byte byte;
1199
1200 result = 0;
1201 shift = 0;
1202 num_read = 0;
1203 do
1204 {
1205 byte = bfd_get_8 (abfd, buf);
1206 buf++;
1207 num_read++;
1208 if (shift < 8 * sizeof (result))
1209 {
1210 result |= (((bfd_vma) byte & 0x7f) << shift);
1211 shift += 7;
1212 }
1213 }
1214 while (byte & 0x80);
1215 *bytes_read_ptr = num_read;
1216 return result;
1217 }
1218
1219 /* Read in a LEB128 encoded value from ABFD starting at *PTR.
1220 If SIGN is true, return a signed LEB128 value.
1221 *PTR is incremented by the number of bytes read.
1222 No bytes will be read at address END or beyond. */
1223
1224 bfd_vma
1225 _bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1226 bfd_byte **ptr,
1227 bool sign,
1228 const bfd_byte * const end)
1229 {
1230 bfd_vma result = 0;
1231 unsigned int shift = 0;
1232 bfd_byte byte = 0;
1233 bfd_byte *data = *ptr;
1234
1235 while (data < end)
1236 {
1237 byte = bfd_get_8 (abfd, data);
1238 data++;
1239 if (shift < 8 * sizeof (result))
1240 {
1241 result |= ((bfd_vma) (byte & 0x7f)) << shift;
1242 shift += 7;
1243 }
1244 if ((byte & 0x80) == 0)
1245 break;
1246 }
1247
1248 *ptr = data;
1249
1250 if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1251 result |= -((bfd_vma) 1 << shift);
1252
1253 return result;
1254 }
1255
1256 /* Helper function for reading sleb128 encoded data. */
1257
1258 bfd_signed_vma
1259 _bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1260 bfd_byte *buf,
1261 unsigned int *bytes_read_ptr)
1262 {
1263 bfd_vma result;
1264 unsigned int shift;
1265 unsigned int num_read;
1266 bfd_byte byte;
1267
1268 result = 0;
1269 shift = 0;
1270 num_read = 0;
1271 do
1272 {
1273 byte = bfd_get_8 (abfd, buf);
1274 buf ++;
1275 num_read ++;
1276 if (shift < 8 * sizeof (result))
1277 {
1278 result |= (((bfd_vma) byte & 0x7f) << shift);
1279 shift += 7;
1280 }
1281 }
1282 while (byte & 0x80);
1283 if (shift < 8 * sizeof (result) && (byte & 0x40))
1284 result |= (((bfd_vma) -1) << shift);
1285 *bytes_read_ptr = num_read;
1286 return result;
1287 }
1288
1289 /* Write VAL in uleb128 format to P.
1290 END indicates the last byte of allocated space for the uleb128 value to fit
1291 in.
1292 Return a pointer to the byte following the last byte that was written, or
1293 NULL if the uleb128 value does not fit in the allocated space between P and
1294 END. */
1295 bfd_byte *
1296 _bfd_write_unsigned_leb128 (bfd_byte *p, bfd_byte *end, bfd_vma val)
1297 {
1298 bfd_byte c;
1299 do
1300 {
1301 if (p > end)
1302 return NULL;
1303 c = val & 0x7f;
1304 val >>= 7;
1305 if (val)
1306 c |= 0x80;
1307 *(p++) = c;
1308 }
1309 while (val);
1310 return p;
1311 }
1312
1313 bool
1314 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1315 asection *isec ATTRIBUTE_UNUSED,
1316 bfd *obfd ATTRIBUTE_UNUSED,
1317 asection *osec ATTRIBUTE_UNUSED,
1318 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1319 {
1320 return true;
1321 }