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