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