Fix compilation of the BFD sub-directory with a gcc v8 compiler by adding extra casts.
[external/binutils.git] / bfd / libbfd.c
1 /* Assorted BFD support routines, only used internally.
2    Copyright (C) 1990-2018 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
26 #ifndef HAVE_GETPAGESIZE
27 #define getpagesize() 2048
28 #endif
29
30 /*
31 SECTION
32         Implementation details
33
34 SUBSECTION
35         Internal functions
36
37 DESCRIPTION
38         These routines are used within BFD.
39         They are not intended for export, but are documented here for
40         completeness.
41 */
42
43 /* A routine which is used in target vectors for unsupported
44    operations.  */
45
46 bfd_boolean
47 bfd_false (bfd *ignore ATTRIBUTE_UNUSED)
48 {
49   bfd_set_error (bfd_error_invalid_operation);
50   return FALSE;
51 }
52
53 /* A routine which is used in target vectors for supported operations
54    which do not actually do anything.  */
55
56 bfd_boolean
57 bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
58 {
59   return TRUE;
60 }
61
62 /* A routine which is used in target vectors for unsupported
63    operations which return a pointer value.  */
64
65 void *
66 bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED)
67 {
68   bfd_set_error (bfd_error_invalid_operation);
69   return NULL;
70 }
71
72 int
73 bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
74 {
75   return 0;
76 }
77
78 unsigned int
79 bfd_0u (bfd *ignore ATTRIBUTE_UNUSED)
80 {
81    return 0;
82 }
83
84 long
85 bfd_0l (bfd *ignore ATTRIBUTE_UNUSED)
86 {
87   return 0l;
88 }
89
90 /* A routine which is used in target vectors for unsupported
91    operations which return -1 on error.  */
92
93 long
94 _bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED)
95 {
96   bfd_set_error (bfd_error_invalid_operation);
97   return -1;
98 }
99
100 void
101 bfd_void (bfd *ignore ATTRIBUTE_UNUSED)
102 {
103 }
104
105 long
106 _bfd_norelocs_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
107                                      asection *sec ATTRIBUTE_UNUSED)
108 {
109   return sizeof (arelent *);
110 }
111
112 long
113 _bfd_norelocs_canonicalize_reloc (bfd *abfd ATTRIBUTE_UNUSED,
114                                   asection *sec ATTRIBUTE_UNUSED,
115                                   arelent **relptr,
116                                   asymbol **symbols ATTRIBUTE_UNUSED)
117 {
118   *relptr = NULL;
119   return 0;
120 }
121
122 void
123 _bfd_norelocs_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
124                          asection *sec ATTRIBUTE_UNUSED,
125                          arelent **relptr ATTRIBUTE_UNUSED,
126                          unsigned int count ATTRIBUTE_UNUSED)
127 {
128   /* Do nothing.  */
129 }
130
131 bfd_boolean
132 _bfd_nocore_core_file_matches_executable_p
133   (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
134    bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
135 {
136   bfd_set_error (bfd_error_invalid_operation);
137   return FALSE;
138 }
139
140 /* Routine to handle core_file_failing_command entry point for targets
141    without core file support.  */
142
143 char *
144 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
145 {
146   bfd_set_error (bfd_error_invalid_operation);
147   return NULL;
148 }
149
150 /* Routine to handle core_file_failing_signal entry point for targets
151    without core file support.  */
152
153 int
154 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
155 {
156   bfd_set_error (bfd_error_invalid_operation);
157   return 0;
158 }
159
160 /* Routine to handle the core_file_pid entry point for targets without
161    core file support.  */
162
163 int
164 _bfd_nocore_core_file_pid (bfd *ignore_abfd ATTRIBUTE_UNUSED)
165 {
166   bfd_set_error (bfd_error_invalid_operation);
167   return 0;
168 }
169
170 const bfd_target *
171 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
172 {
173   bfd_set_error (bfd_error_wrong_format);
174   return 0;
175 }
176 \f
177 /* Allocate memory using malloc.  */
178
179 void *
180 bfd_malloc (bfd_size_type size)
181 {
182   void *ptr;
183   size_t sz = (size_t) size;
184
185   if (size != sz
186       /* This is to pacify memory checkers like valgrind.  */
187       || ((signed long) sz) < 0)
188     {
189       bfd_set_error (bfd_error_no_memory);
190       return NULL;
191     }
192
193   ptr = malloc (sz);
194   if (ptr == NULL && sz != 0)
195     bfd_set_error (bfd_error_no_memory);
196
197   return ptr;
198 }
199
200 /* Allocate memory using malloc, nmemb * size with overflow checking.  */
201
202 void *
203 bfd_malloc2 (bfd_size_type nmemb, bfd_size_type size)
204 {
205   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
206       && size != 0
207       && nmemb > ~(bfd_size_type) 0 / size)
208     {
209       bfd_set_error (bfd_error_no_memory);
210       return NULL;
211     }
212
213   return bfd_malloc (size * nmemb);
214 }
215
216 /* Reallocate memory using realloc.  */
217
218 void *
219 bfd_realloc (void *ptr, bfd_size_type size)
220 {
221   void *ret;
222   size_t sz = (size_t) size;
223
224   if (ptr == NULL)
225     return bfd_malloc (size);
226
227   if (size != sz
228       /* This is to pacify memory checkers like valgrind.  */
229       || ((signed long) sz) < 0)
230     {
231       bfd_set_error (bfd_error_no_memory);
232       return NULL;
233     }
234
235   ret = realloc (ptr, sz);
236
237   if (ret == NULL && sz != 0)
238     bfd_set_error (bfd_error_no_memory);
239
240   return ret;
241 }
242
243 /* Reallocate memory using realloc, nmemb * size with overflow checking.  */
244
245 void *
246 bfd_realloc2 (void *ptr, bfd_size_type nmemb, bfd_size_type size)
247 {
248   if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
249       && size != 0
250       && nmemb > ~(bfd_size_type) 0 / size)
251     {
252       bfd_set_error (bfd_error_no_memory);
253       return NULL;
254     }
255
256   return bfd_realloc (ptr, size * nmemb);
257 }
258
259 /* Reallocate memory using realloc.
260    If this fails the pointer is freed before returning.  */
261
262 void *
263 bfd_realloc_or_free (void *ptr, bfd_size_type size)
264 {
265   void *ret = bfd_realloc (ptr, size);
266
267   if (ret == NULL && ptr != NULL)
268     free (ptr);
269
270   return ret;
271 }
272
273 /* Allocate memory using malloc and clear it.  */
274
275 void *
276 bfd_zmalloc (bfd_size_type size)
277 {
278   void *ptr = bfd_malloc (size);
279
280   if (ptr != NULL && size > 0)
281     memset (ptr, 0, (size_t) size);
282
283   return ptr;
284 }
285
286 /* Allocate memory using malloc (nmemb * size) with overflow checking
287    and clear it.  */
288
289 void *
290 bfd_zmalloc2 (bfd_size_type nmemb, bfd_size_type size)
291 {
292   void *ptr = bfd_malloc2 (nmemb, size);
293
294   if (ptr != NULL)
295     {
296       size_t sz = nmemb * size;
297
298       if (sz > 0)
299         memset (ptr, 0, sz);
300     }
301
302   return ptr;
303 }
304
305 /*
306 INTERNAL_FUNCTION
307         bfd_write_bigendian_4byte_int
308
309 SYNOPSIS
310         bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
311
312 DESCRIPTION
313         Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
314         endian order regardless of what else is going on.  This is useful in
315         archives.
316
317 */
318 bfd_boolean
319 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
320 {
321   bfd_byte buffer[4];
322   bfd_putb32 ((bfd_vma) i, buffer);
323   return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
324 }
325
326 \f
327 /** The do-it-yourself (byte) sex-change kit */
328
329 /* The middle letter e.g. get<b>short indicates Big or Little endian
330    target machine.  It doesn't matter what the byte order of the host
331    machine is; these routines work for either.  */
332
333 /* FIXME: Should these take a count argument?
334    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
335                              functions in swap.h #ifdef __GNUC__.
336                              Gprof them later and find out.  */
337
338 /*
339 FUNCTION
340         bfd_put_size
341 FUNCTION
342         bfd_get_size
343
344 DESCRIPTION
345         These macros as used for reading and writing raw data in
346         sections; each access (except for bytes) is vectored through
347         the target format of the BFD and mangled accordingly. The
348         mangling performs any necessary endian translations and
349         removes alignment restrictions.  Note that types accepted and
350         returned by these macros are identical so they can be swapped
351         around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
352         to either <<bfd_get_32>> or <<bfd_get_64>>.
353
354         In the put routines, @var{val} must be a <<bfd_vma>>.  If we are on a
355         system without prototypes, the caller is responsible for making
356         sure that is true, with a cast if necessary.  We don't cast
357         them in the macro definitions because that would prevent <<lint>>
358         or <<gcc -Wall>> from detecting sins such as passing a pointer.
359         To detect calling these with less than a <<bfd_vma>>, use
360         <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
361
362 .
363 .{* Byte swapping macros for user section data.  *}
364 .
365 .#define bfd_put_8(abfd, val, ptr) \
366 .  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
367 .#define bfd_put_signed_8 \
368 .  bfd_put_8
369 .#define bfd_get_8(abfd, ptr) \
370 .  (*(const unsigned char *) (ptr) & 0xff)
371 .#define bfd_get_signed_8(abfd, ptr) \
372 .  (((*(const unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
373 .
374 .#define bfd_put_16(abfd, val, ptr) \
375 .  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
376 .#define bfd_put_signed_16 \
377 .  bfd_put_16
378 .#define bfd_get_16(abfd, ptr) \
379 .  BFD_SEND (abfd, bfd_getx16, (ptr))
380 .#define bfd_get_signed_16(abfd, ptr) \
381 .  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
382 .
383 .#define bfd_put_32(abfd, val, ptr) \
384 .  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
385 .#define bfd_put_signed_32 \
386 .  bfd_put_32
387 .#define bfd_get_32(abfd, ptr) \
388 .  BFD_SEND (abfd, bfd_getx32, (ptr))
389 .#define bfd_get_signed_32(abfd, ptr) \
390 .  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
391 .
392 .#define bfd_put_64(abfd, val, ptr) \
393 .  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
394 .#define bfd_put_signed_64 \
395 .  bfd_put_64
396 .#define bfd_get_64(abfd, ptr) \
397 .  BFD_SEND (abfd, bfd_getx64, (ptr))
398 .#define bfd_get_signed_64(abfd, ptr) \
399 .  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
400 .
401 .#define bfd_get(bits, abfd, ptr)                       \
402 .  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \
403 .   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \
404 .   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \
405 .   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \
406 .   : (abort (), (bfd_vma) - 1))
407 .
408 .#define bfd_put(bits, abfd, val, ptr)                  \
409 .  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \
410 .   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)        \
411 .   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)        \
412 .   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)        \
413 .   : (abort (), (void) 0))
414 .
415 */
416
417 /*
418 FUNCTION
419         bfd_h_put_size
420         bfd_h_get_size
421
422 DESCRIPTION
423         These macros have the same function as their <<bfd_get_x>>
424         brethren, except that they are used for removing information
425         for the header records of object files. Believe it or not,
426         some object files keep their header records in big endian
427         order and their data in little endian order.
428 .
429 .{* Byte swapping macros for file header data.  *}
430 .
431 .#define bfd_h_put_8(abfd, val, ptr) \
432 .  bfd_put_8 (abfd, val, ptr)
433 .#define bfd_h_put_signed_8(abfd, val, ptr) \
434 .  bfd_put_8 (abfd, val, ptr)
435 .#define bfd_h_get_8(abfd, ptr) \
436 .  bfd_get_8 (abfd, ptr)
437 .#define bfd_h_get_signed_8(abfd, ptr) \
438 .  bfd_get_signed_8 (abfd, ptr)
439 .
440 .#define bfd_h_put_16(abfd, val, ptr) \
441 .  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
442 .#define bfd_h_put_signed_16 \
443 .  bfd_h_put_16
444 .#define bfd_h_get_16(abfd, ptr) \
445 .  BFD_SEND (abfd, bfd_h_getx16, (ptr))
446 .#define bfd_h_get_signed_16(abfd, ptr) \
447 .  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
448 .
449 .#define bfd_h_put_32(abfd, val, ptr) \
450 .  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
451 .#define bfd_h_put_signed_32 \
452 .  bfd_h_put_32
453 .#define bfd_h_get_32(abfd, ptr) \
454 .  BFD_SEND (abfd, bfd_h_getx32, (ptr))
455 .#define bfd_h_get_signed_32(abfd, ptr) \
456 .  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
457 .
458 .#define bfd_h_put_64(abfd, val, ptr) \
459 .  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
460 .#define bfd_h_put_signed_64 \
461 .  bfd_h_put_64
462 .#define bfd_h_get_64(abfd, ptr) \
463 .  BFD_SEND (abfd, bfd_h_getx64, (ptr))
464 .#define bfd_h_get_signed_64(abfd, ptr) \
465 .  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
466 .
467 .{* Aliases for the above, which should eventually go away.  *}
468 .
469 .#define H_PUT_64  bfd_h_put_64
470 .#define H_PUT_32  bfd_h_put_32
471 .#define H_PUT_16  bfd_h_put_16
472 .#define H_PUT_8   bfd_h_put_8
473 .#define H_PUT_S64 bfd_h_put_signed_64
474 .#define H_PUT_S32 bfd_h_put_signed_32
475 .#define H_PUT_S16 bfd_h_put_signed_16
476 .#define H_PUT_S8  bfd_h_put_signed_8
477 .#define H_GET_64  bfd_h_get_64
478 .#define H_GET_32  bfd_h_get_32
479 .#define H_GET_16  bfd_h_get_16
480 .#define H_GET_8   bfd_h_get_8
481 .#define H_GET_S64 bfd_h_get_signed_64
482 .#define H_GET_S32 bfd_h_get_signed_32
483 .#define H_GET_S16 bfd_h_get_signed_16
484 .#define H_GET_S8  bfd_h_get_signed_8
485 .
486 .*/
487
488 /* Sign extension to bfd_signed_vma.  */
489 #define COERCE16(x) (((bfd_vma) (x) ^ 0x8000) - 0x8000)
490 #define COERCE32(x) (((bfd_vma) (x) ^ 0x80000000) - 0x80000000)
491 #define COERCE64(x) \
492   (((bfd_uint64_t) (x) ^ ((bfd_uint64_t) 1 << 63)) - ((bfd_uint64_t) 1 << 63))
493
494 bfd_vma
495 bfd_getb16 (const void *p)
496 {
497   const bfd_byte *addr = (const bfd_byte *) p;
498   return (addr[0] << 8) | addr[1];
499 }
500
501 bfd_vma
502 bfd_getl16 (const void *p)
503 {
504   const bfd_byte *addr = (const bfd_byte *) p;
505   return (addr[1] << 8) | addr[0];
506 }
507
508 bfd_signed_vma
509 bfd_getb_signed_16 (const void *p)
510 {
511   const bfd_byte *addr = (const bfd_byte *) p;
512   return COERCE16 ((addr[0] << 8) | addr[1]);
513 }
514
515 bfd_signed_vma
516 bfd_getl_signed_16 (const void *p)
517 {
518   const bfd_byte *addr = (const bfd_byte *) p;
519   return COERCE16 ((addr[1] << 8) | addr[0]);
520 }
521
522 void
523 bfd_putb16 (bfd_vma data, void *p)
524 {
525   bfd_byte *addr = (bfd_byte *) p;
526   addr[0] = (data >> 8) & 0xff;
527   addr[1] = data & 0xff;
528 }
529
530 void
531 bfd_putl16 (bfd_vma data, void *p)
532 {
533   bfd_byte *addr = (bfd_byte *) p;
534   addr[0] = data & 0xff;
535   addr[1] = (data >> 8) & 0xff;
536 }
537
538 bfd_vma
539 bfd_getb32 (const void *p)
540 {
541   const bfd_byte *addr = (const bfd_byte *) p;
542   unsigned long v;
543
544   v = (unsigned long) addr[0] << 24;
545   v |= (unsigned long) addr[1] << 16;
546   v |= (unsigned long) addr[2] << 8;
547   v |= (unsigned long) addr[3];
548   return v;
549 }
550
551 bfd_vma
552 bfd_getl32 (const void *p)
553 {
554   const bfd_byte *addr = (const bfd_byte *) p;
555   unsigned long v;
556
557   v = (unsigned long) addr[0];
558   v |= (unsigned long) addr[1] << 8;
559   v |= (unsigned long) addr[2] << 16;
560   v |= (unsigned long) addr[3] << 24;
561   return v;
562 }
563
564 bfd_signed_vma
565 bfd_getb_signed_32 (const void *p)
566 {
567   const bfd_byte *addr = (const bfd_byte *) p;
568   unsigned long v;
569
570   v = (unsigned long) addr[0] << 24;
571   v |= (unsigned long) addr[1] << 16;
572   v |= (unsigned long) addr[2] << 8;
573   v |= (unsigned long) addr[3];
574   return COERCE32 (v);
575 }
576
577 bfd_signed_vma
578 bfd_getl_signed_32 (const void *p)
579 {
580   const bfd_byte *addr = (const bfd_byte *) p;
581   unsigned long v;
582
583   v = (unsigned long) addr[0];
584   v |= (unsigned long) addr[1] << 8;
585   v |= (unsigned long) addr[2] << 16;
586   v |= (unsigned long) addr[3] << 24;
587   return COERCE32 (v);
588 }
589
590 bfd_uint64_t
591 bfd_getb64 (const void *p ATTRIBUTE_UNUSED)
592 {
593 #ifdef BFD_HOST_64_BIT
594   const bfd_byte *addr = (const bfd_byte *) p;
595   bfd_uint64_t v;
596
597   v  = addr[0]; v <<= 8;
598   v |= addr[1]; v <<= 8;
599   v |= addr[2]; v <<= 8;
600   v |= addr[3]; v <<= 8;
601   v |= addr[4]; v <<= 8;
602   v |= addr[5]; v <<= 8;
603   v |= addr[6]; v <<= 8;
604   v |= addr[7];
605
606   return v;
607 #else
608   BFD_FAIL();
609   return 0;
610 #endif
611 }
612
613 bfd_uint64_t
614 bfd_getl64 (const void *p ATTRIBUTE_UNUSED)
615 {
616 #ifdef BFD_HOST_64_BIT
617   const bfd_byte *addr = (const bfd_byte *) p;
618   bfd_uint64_t v;
619
620   v  = addr[7]; v <<= 8;
621   v |= addr[6]; v <<= 8;
622   v |= addr[5]; v <<= 8;
623   v |= addr[4]; v <<= 8;
624   v |= addr[3]; v <<= 8;
625   v |= addr[2]; v <<= 8;
626   v |= addr[1]; v <<= 8;
627   v |= addr[0];
628
629   return v;
630 #else
631   BFD_FAIL();
632   return 0;
633 #endif
634
635 }
636
637 bfd_int64_t
638 bfd_getb_signed_64 (const void *p ATTRIBUTE_UNUSED)
639 {
640 #ifdef BFD_HOST_64_BIT
641   const bfd_byte *addr = (const bfd_byte *) p;
642   bfd_uint64_t v;
643
644   v  = addr[0]; v <<= 8;
645   v |= addr[1]; v <<= 8;
646   v |= addr[2]; v <<= 8;
647   v |= addr[3]; v <<= 8;
648   v |= addr[4]; v <<= 8;
649   v |= addr[5]; v <<= 8;
650   v |= addr[6]; v <<= 8;
651   v |= addr[7];
652
653   return COERCE64 (v);
654 #else
655   BFD_FAIL();
656   return 0;
657 #endif
658 }
659
660 bfd_int64_t
661 bfd_getl_signed_64 (const void *p ATTRIBUTE_UNUSED)
662 {
663 #ifdef BFD_HOST_64_BIT
664   const bfd_byte *addr = (const bfd_byte *) p;
665   bfd_uint64_t v;
666
667   v  = addr[7]; v <<= 8;
668   v |= addr[6]; v <<= 8;
669   v |= addr[5]; v <<= 8;
670   v |= addr[4]; v <<= 8;
671   v |= addr[3]; v <<= 8;
672   v |= addr[2]; v <<= 8;
673   v |= addr[1]; v <<= 8;
674   v |= addr[0];
675
676   return COERCE64 (v);
677 #else
678   BFD_FAIL();
679   return 0;
680 #endif
681 }
682
683 void
684 bfd_putb32 (bfd_vma data, void *p)
685 {
686   bfd_byte *addr = (bfd_byte *) p;
687   addr[0] = (data >> 24) & 0xff;
688   addr[1] = (data >> 16) & 0xff;
689   addr[2] = (data >>  8) & 0xff;
690   addr[3] = data & 0xff;
691 }
692
693 void
694 bfd_putl32 (bfd_vma data, void *p)
695 {
696   bfd_byte *addr = (bfd_byte *) p;
697   addr[0] = data & 0xff;
698   addr[1] = (data >>  8) & 0xff;
699   addr[2] = (data >> 16) & 0xff;
700   addr[3] = (data >> 24) & 0xff;
701 }
702
703 void
704 bfd_putb64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
705 {
706 #ifdef BFD_HOST_64_BIT
707   bfd_byte *addr = (bfd_byte *) p;
708   addr[0] = (data >> (7*8)) & 0xff;
709   addr[1] = (data >> (6*8)) & 0xff;
710   addr[2] = (data >> (5*8)) & 0xff;
711   addr[3] = (data >> (4*8)) & 0xff;
712   addr[4] = (data >> (3*8)) & 0xff;
713   addr[5] = (data >> (2*8)) & 0xff;
714   addr[6] = (data >> (1*8)) & 0xff;
715   addr[7] = (data >> (0*8)) & 0xff;
716 #else
717   BFD_FAIL();
718 #endif
719 }
720
721 void
722 bfd_putl64 (bfd_uint64_t data ATTRIBUTE_UNUSED, void *p ATTRIBUTE_UNUSED)
723 {
724 #ifdef BFD_HOST_64_BIT
725   bfd_byte *addr = (bfd_byte *) p;
726   addr[7] = (data >> (7*8)) & 0xff;
727   addr[6] = (data >> (6*8)) & 0xff;
728   addr[5] = (data >> (5*8)) & 0xff;
729   addr[4] = (data >> (4*8)) & 0xff;
730   addr[3] = (data >> (3*8)) & 0xff;
731   addr[2] = (data >> (2*8)) & 0xff;
732   addr[1] = (data >> (1*8)) & 0xff;
733   addr[0] = (data >> (0*8)) & 0xff;
734 #else
735   BFD_FAIL();
736 #endif
737 }
738
739 void
740 bfd_put_bits (bfd_uint64_t data, void *p, int bits, bfd_boolean big_p)
741 {
742   bfd_byte *addr = (bfd_byte *) p;
743   int i;
744   int bytes;
745
746   if (bits % 8 != 0)
747     abort ();
748
749   bytes = bits / 8;
750   for (i = 0; i < bytes; i++)
751     {
752       int addr_index = big_p ? bytes - i - 1 : i;
753
754       addr[addr_index] = data & 0xff;
755       data >>= 8;
756     }
757 }
758
759 bfd_uint64_t
760 bfd_get_bits (const void *p, int bits, bfd_boolean big_p)
761 {
762   const bfd_byte *addr = (const bfd_byte *) p;
763   bfd_uint64_t data;
764   int i;
765   int bytes;
766
767   if (bits % 8 != 0)
768     abort ();
769
770   data = 0;
771   bytes = bits / 8;
772   for (i = 0; i < bytes; i++)
773     {
774       int addr_index = big_p ? i : bytes - i - 1;
775
776       data = (data << 8) | addr[addr_index];
777     }
778
779   return data;
780 }
781 \f
782 /* Default implementation */
783
784 bfd_boolean
785 _bfd_generic_get_section_contents (bfd *abfd,
786                                    sec_ptr section,
787                                    void *location,
788                                    file_ptr offset,
789                                    bfd_size_type count)
790 {
791   bfd_size_type sz;
792   if (count == 0)
793     return TRUE;
794
795   if (section->compress_status != COMPRESS_SECTION_NONE)
796     {
797       _bfd_error_handler
798         /* xgettext:c-format */
799         (_("%B: unable to get decompressed section %A"),
800          abfd, section);
801       bfd_set_error (bfd_error_invalid_operation);
802       return FALSE;
803     }
804
805   /* We do allow reading of a section after bfd_final_link has
806      written the contents out to disk.  In that situation, rawsize is
807      just a stale version of size, so ignore it.  Otherwise we must be
808      reading an input section, where rawsize, if different to size,
809      is the on-disk size.  */
810   if (abfd->direction != write_direction && section->rawsize != 0)
811     sz = section->rawsize;
812   else
813     sz = section->size;
814   if (offset + count < count
815       || offset + count > sz
816       || (abfd->my_archive != NULL
817           && !bfd_is_thin_archive (abfd->my_archive)
818           && ((ufile_ptr) section->filepos + offset + count
819               > arelt_size (abfd))))
820     {
821       bfd_set_error (bfd_error_invalid_operation);
822       return FALSE;
823     }
824
825   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
826       || bfd_bread (location, count, abfd) != count)
827     return FALSE;
828
829   return TRUE;
830 }
831
832 bfd_boolean
833 _bfd_generic_get_section_contents_in_window
834   (bfd *abfd ATTRIBUTE_UNUSED,
835    sec_ptr section ATTRIBUTE_UNUSED,
836    bfd_window *w ATTRIBUTE_UNUSED,
837    file_ptr offset ATTRIBUTE_UNUSED,
838    bfd_size_type count ATTRIBUTE_UNUSED)
839 {
840 #ifdef USE_MMAP
841   bfd_size_type sz;
842
843   if (count == 0)
844     return TRUE;
845   if (abfd->xvec->_bfd_get_section_contents
846       != _bfd_generic_get_section_contents)
847     {
848       /* We don't know what changes the bfd's get_section_contents
849          method may have to make.  So punt trying to map the file
850          window, and let get_section_contents do its thing.  */
851       /* @@ FIXME : If the internal window has a refcount of 1 and was
852          allocated with malloc instead of mmap, just reuse it.  */
853       bfd_free_window (w);
854       w->i = bfd_zmalloc (sizeof (bfd_window_internal));
855       if (w->i == NULL)
856         return FALSE;
857       w->i->data = bfd_malloc (count);
858       if (w->i->data == NULL)
859         {
860           free (w->i);
861           w->i = NULL;
862           return FALSE;
863         }
864       w->i->mapped = 0;
865       w->i->refcount = 1;
866       w->size = w->i->size = count;
867       w->data = w->i->data;
868       return bfd_get_section_contents (abfd, section, w->data, offset, count);
869     }
870   if (abfd->direction != write_direction && section->rawsize != 0)
871     sz = section->rawsize;
872   else
873     sz = section->size;
874   if (offset + count < count
875       || offset + count > sz
876       || (abfd->my_archive != NULL
877           && !bfd_is_thin_archive (abfd->my_archive)
878           && ((ufile_ptr) section->filepos + offset + count
879               > arelt_size (abfd)))
880       || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
881                                 TRUE))
882     return FALSE;
883   return TRUE;
884 #else
885   abort ();
886 #endif
887 }
888
889 /* This generic function can only be used in implementations where creating
890    NEW sections is disallowed.  It is useful in patching existing sections
891    in read-write files, though.  See other set_section_contents functions
892    to see why it doesn't work for new sections.  */
893 bfd_boolean
894 _bfd_generic_set_section_contents (bfd *abfd,
895                                    sec_ptr section,
896                                    const void *location,
897                                    file_ptr offset,
898                                    bfd_size_type count)
899 {
900   if (count == 0)
901     return TRUE;
902
903   if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
904       || bfd_bwrite (location, count, abfd) != count)
905     return FALSE;
906
907   return TRUE;
908 }
909
910 /*
911 INTERNAL_FUNCTION
912         bfd_log2
913
914 SYNOPSIS
915         unsigned int bfd_log2 (bfd_vma x);
916
917 DESCRIPTION
918         Return the log base 2 of the value supplied, rounded up.  E.g., an
919         @var{x} of 1025 returns 11.  A @var{x} of 0 returns 0.
920 */
921
922 unsigned int
923 bfd_log2 (bfd_vma x)
924 {
925   unsigned int result = 0;
926
927   if (x <= 1)
928     return result;
929   --x;
930   do
931     ++result;
932   while ((x >>= 1) != 0);
933   return result;
934 }
935
936 bfd_boolean
937 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
938 {
939   char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
940
941   return name[0] == locals_prefix;
942 }
943
944 /* Give a warning at runtime if someone compiles code which calls
945    old routines.  */
946
947 void
948 _bfd_warn_deprecated (const char *what,
949                       const char *file,
950                       int line,
951                       const char *func)
952 {
953   /* Poor man's tracking of functions we've already warned about.  */
954   static size_t mask = 0;
955
956   if (~(size_t) func & ~mask)
957     {
958       fflush (stdout);
959       /* Note: separate sentences in order to allow
960          for translation into other languages.  */
961       if (func)
962         /* xgettext:c-format */
963         fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
964                  what, file, line, func);
965       else
966         fprintf (stderr, _("Deprecated %s called\n"), what);
967       fflush (stderr);
968       mask |= ~(size_t) func;
969     }
970 }
971
972 /* Helper function for reading uleb128 encoded data.  */
973
974 bfd_vma
975 _bfd_read_unsigned_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
976                            bfd_byte *buf,
977                            unsigned int *bytes_read_ptr)
978 {
979   bfd_vma result;
980   unsigned int num_read;
981   unsigned int shift;
982   unsigned char byte;
983
984   result = 0;
985   shift = 0;
986   num_read = 0;
987   do
988     {
989       byte = bfd_get_8 (abfd, buf);
990       buf++;
991       num_read++;
992       result |= (((bfd_vma) byte & 0x7f) << shift);
993       shift += 7;
994     }
995   while (byte & 0x80);
996   *bytes_read_ptr = num_read;
997   return result;
998 }
999
1000 /* Read in a LEB128 encoded value from ABFD starting at DATA.
1001    If SIGN is true, return a signed LEB128 value.
1002    If LENGTH_RETURN is not NULL, return in it the number of bytes read.
1003    No bytes will be read at address END or beyond.  */
1004
1005 bfd_vma
1006 _bfd_safe_read_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1007                        bfd_byte *data,
1008                        unsigned int *length_return,
1009                        bfd_boolean sign,
1010                        const bfd_byte * const end)
1011 {
1012   bfd_vma result = 0;
1013   unsigned int num_read = 0;
1014   unsigned int shift = 0;
1015   unsigned char byte = 0;
1016
1017   while (data < end)
1018     {
1019       byte = bfd_get_8 (abfd, data);
1020       data++;
1021       num_read++;
1022
1023       result |= ((bfd_vma) (byte & 0x7f)) << shift;
1024
1025       shift += 7;
1026       if ((byte & 0x80) == 0)
1027         break;
1028     }
1029
1030   if (length_return != NULL)
1031     *length_return = num_read;
1032
1033   if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40))
1034     result |= -((bfd_vma) 1 << shift);
1035
1036   return result;
1037 }
1038
1039 /* Helper function for reading sleb128 encoded data.  */
1040
1041 bfd_signed_vma
1042 _bfd_read_signed_leb128 (bfd *abfd ATTRIBUTE_UNUSED,
1043                          bfd_byte *buf,
1044                          unsigned int *bytes_read_ptr)
1045 {
1046   bfd_vma result;
1047   unsigned int shift;
1048   unsigned int num_read;
1049   unsigned char byte;
1050
1051   result = 0;
1052   shift = 0;
1053   num_read = 0;
1054   do
1055     {
1056       byte = bfd_get_8 (abfd, buf);
1057       buf ++;
1058       num_read ++;
1059       result |= (((bfd_vma) byte & 0x7f) << shift);
1060       shift += 7;
1061     }
1062   while (byte & 0x80);
1063   if (shift < 8 * sizeof (result) && (byte & 0x40))
1064     result |= (((bfd_vma) -1) << shift);
1065   *bytes_read_ptr = num_read;
1066   return result;
1067 }
1068
1069 bfd_boolean
1070 _bfd_generic_init_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
1071                                         asection *isec ATTRIBUTE_UNUSED,
1072                                         bfd *obfd ATTRIBUTE_UNUSED,
1073                                         asection *osec ATTRIBUTE_UNUSED,
1074                                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1075 {
1076   return TRUE;
1077 }