2003-10-08 Dave Brolley <brolley@redhat.com>
[binutils.git] / bfd / libbfd.c
blob50bd21551e30d6225df26789a4c28d7d285cb272
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
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
27 #ifndef HAVE_GETPAGESIZE
28 #define getpagesize() 2048
29 #endif
32 SECTION
33 Internal functions
35 DESCRIPTION
36 These routines are used within BFD.
37 They are not intended for export, but are documented here for
38 completeness.
41 /* A routine which is used in target vectors for unsupported
42 operations. */
44 bfd_boolean
45 bfd_false (bfd *ignore ATTRIBUTE_UNUSED)
47 bfd_set_error (bfd_error_invalid_operation);
48 return FALSE;
51 /* A routine which is used in target vectors for supported operations
52 which do not actually do anything. */
54 bfd_boolean
55 bfd_true (bfd *ignore ATTRIBUTE_UNUSED)
57 return TRUE;
60 /* A routine which is used in target vectors for unsupported
61 operations which return a pointer value. */
63 void *
64 bfd_nullvoidptr (bfd *ignore ATTRIBUTE_UNUSED)
66 bfd_set_error (bfd_error_invalid_operation);
67 return NULL;
70 int
71 bfd_0 (bfd *ignore ATTRIBUTE_UNUSED)
73 return 0;
76 unsigned int
77 bfd_0u (bfd *ignore ATTRIBUTE_UNUSED)
79 return 0;
82 long
83 bfd_0l (bfd *ignore ATTRIBUTE_UNUSED)
85 return 0;
88 /* A routine which is used in target vectors for unsupported
89 operations which return -1 on error. */
91 long
92 _bfd_n1 (bfd *ignore_abfd ATTRIBUTE_UNUSED)
94 bfd_set_error (bfd_error_invalid_operation);
95 return -1;
98 void
99 bfd_void (bfd *ignore ATTRIBUTE_UNUSED)
103 bfd_boolean
104 _bfd_nocore_core_file_matches_executable_p
105 (bfd *ignore_core_bfd ATTRIBUTE_UNUSED,
106 bfd *ignore_exec_bfd ATTRIBUTE_UNUSED)
108 bfd_set_error (bfd_error_invalid_operation);
109 return FALSE;
112 /* Routine to handle core_file_failing_command entry point for targets
113 without core file support. */
115 char *
116 _bfd_nocore_core_file_failing_command (bfd *ignore_abfd ATTRIBUTE_UNUSED)
118 bfd_set_error (bfd_error_invalid_operation);
119 return NULL;
122 /* Routine to handle core_file_failing_signal entry point for targets
123 without core file support. */
126 _bfd_nocore_core_file_failing_signal (bfd *ignore_abfd ATTRIBUTE_UNUSED)
128 bfd_set_error (bfd_error_invalid_operation);
129 return 0;
132 const bfd_target *
133 _bfd_dummy_target (bfd *ignore_abfd ATTRIBUTE_UNUSED)
135 bfd_set_error (bfd_error_wrong_format);
136 return 0;
139 /* Allocate memory using malloc. */
141 void *
142 bfd_malloc (bfd_size_type size)
144 void *ptr;
146 if (size != (size_t) size)
148 bfd_set_error (bfd_error_no_memory);
149 return NULL;
152 ptr = malloc ((size_t) size);
153 if (ptr == NULL && (size_t) size != 0)
154 bfd_set_error (bfd_error_no_memory);
156 return ptr;
159 /* Reallocate memory using realloc. */
161 void *
162 bfd_realloc (void *ptr, bfd_size_type size)
164 void *ret;
166 if (size != (size_t) size)
168 bfd_set_error (bfd_error_no_memory);
169 return NULL;
172 if (ptr == NULL)
173 ret = malloc ((size_t) size);
174 else
175 ret = realloc (ptr, (size_t) size);
177 if (ret == NULL && (size_t) size != 0)
178 bfd_set_error (bfd_error_no_memory);
180 return ret;
183 /* Allocate memory using malloc and clear it. */
185 void *
186 bfd_zmalloc (bfd_size_type size)
188 void *ptr;
190 if (size != (size_t) size)
192 bfd_set_error (bfd_error_no_memory);
193 return NULL;
196 ptr = malloc ((size_t) size);
198 if ((size_t) size != 0)
200 if (ptr == NULL)
201 bfd_set_error (bfd_error_no_memory);
202 else
203 memset (ptr, 0, (size_t) size);
206 return ptr;
209 INTERNAL_FUNCTION
210 bfd_write_bigendian_4byte_int
212 SYNOPSIS
213 bfd_boolean bfd_write_bigendian_4byte_int (bfd *, unsigned int);
215 DESCRIPTION
216 Write a 4 byte integer @var{i} to the output BFD @var{abfd}, in big
217 endian order regardless of what else is going on. This is useful in
218 archives.
221 bfd_boolean
222 bfd_write_bigendian_4byte_int (bfd *abfd, unsigned int i)
224 bfd_byte buffer[4];
225 bfd_putb32 ((bfd_vma) i, buffer);
226 return bfd_bwrite (buffer, (bfd_size_type) 4, abfd) == 4;
230 /** The do-it-yourself (byte) sex-change kit */
232 /* The middle letter e.g. get<b>short indicates Big or Little endian
233 target machine. It doesn't matter what the byte order of the host
234 machine is; these routines work for either. */
236 /* FIXME: Should these take a count argument?
237 Answer (gnu@cygnus.com): No, but perhaps they should be inline
238 functions in swap.h #ifdef __GNUC__.
239 Gprof them later and find out. */
242 FUNCTION
243 bfd_put_size
244 FUNCTION
245 bfd_get_size
247 DESCRIPTION
248 These macros as used for reading and writing raw data in
249 sections; each access (except for bytes) is vectored through
250 the target format of the BFD and mangled accordingly. The
251 mangling performs any necessary endian translations and
252 removes alignment restrictions. Note that types accepted and
253 returned by these macros are identical so they can be swapped
254 around in macros---for example, @file{libaout.h} defines <<GET_WORD>>
255 to either <<bfd_get_32>> or <<bfd_get_64>>.
257 In the put routines, @var{val} must be a <<bfd_vma>>. If we are on a
258 system without prototypes, the caller is responsible for making
259 sure that is true, with a cast if necessary. We don't cast
260 them in the macro definitions because that would prevent <<lint>>
261 or <<gcc -Wall>> from detecting sins such as passing a pointer.
262 To detect calling these with less than a <<bfd_vma>>, use
263 <<gcc -Wconversion>> on a host with 64 bit <<bfd_vma>>'s.
266 .{* Byte swapping macros for user section data. *}
268 .#define bfd_put_8(abfd, val, ptr) \
269 . ((void) (*((unsigned char *) (ptr)) = (unsigned char) (val)))
270 .#define bfd_put_signed_8 \
271 . bfd_put_8
272 .#define bfd_get_8(abfd, ptr) \
273 . (*(unsigned char *) (ptr) & 0xff)
274 .#define bfd_get_signed_8(abfd, ptr) \
275 . (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
277 .#define bfd_put_16(abfd, val, ptr) \
278 . BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
279 .#define bfd_put_signed_16 \
280 . bfd_put_16
281 .#define bfd_get_16(abfd, ptr) \
282 . BFD_SEND (abfd, bfd_getx16, (ptr))
283 .#define bfd_get_signed_16(abfd, ptr) \
284 . BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
286 .#define bfd_put_32(abfd, val, ptr) \
287 . BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
288 .#define bfd_put_signed_32 \
289 . bfd_put_32
290 .#define bfd_get_32(abfd, ptr) \
291 . BFD_SEND (abfd, bfd_getx32, (ptr))
292 .#define bfd_get_signed_32(abfd, ptr) \
293 . BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
295 .#define bfd_put_64(abfd, val, ptr) \
296 . BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
297 .#define bfd_put_signed_64 \
298 . bfd_put_64
299 .#define bfd_get_64(abfd, ptr) \
300 . BFD_SEND (abfd, bfd_getx64, (ptr))
301 .#define bfd_get_signed_64(abfd, ptr) \
302 . BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
304 .#define bfd_get(bits, abfd, ptr) \
305 . ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr) \
306 . : (bits) == 16 ? bfd_get_16 (abfd, ptr) \
307 . : (bits) == 32 ? bfd_get_32 (abfd, ptr) \
308 . : (bits) == 64 ? bfd_get_64 (abfd, ptr) \
309 . : (abort (), (bfd_vma) - 1))
311 .#define bfd_put(bits, abfd, val, ptr) \
312 . ((bits) == 8 ? bfd_put_8 (abfd, val, ptr) \
313 . : (bits) == 16 ? bfd_put_16 (abfd, val, ptr) \
314 . : (bits) == 32 ? bfd_put_32 (abfd, val, ptr) \
315 . : (bits) == 64 ? bfd_put_64 (abfd, val, ptr) \
316 . : (abort (), (void) 0))
321 FUNCTION
322 bfd_h_put_size
323 bfd_h_get_size
325 DESCRIPTION
326 These macros have the same function as their <<bfd_get_x>>
327 brethren, except that they are used for removing information
328 for the header records of object files. Believe it or not,
329 some object files keep their header records in big endian
330 order and their data in little endian order.
332 .{* Byte swapping macros for file header data. *}
334 .#define bfd_h_put_8(abfd, val, ptr) \
335 . bfd_put_8 (abfd, val, ptr)
336 .#define bfd_h_put_signed_8(abfd, val, ptr) \
337 . bfd_put_8 (abfd, val, ptr)
338 .#define bfd_h_get_8(abfd, ptr) \
339 . bfd_get_8 (abfd, ptr)
340 .#define bfd_h_get_signed_8(abfd, ptr) \
341 . bfd_get_signed_8 (abfd, ptr)
343 .#define bfd_h_put_16(abfd, val, ptr) \
344 . BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
345 .#define bfd_h_put_signed_16 \
346 . bfd_h_put_16
347 .#define bfd_h_get_16(abfd, ptr) \
348 . BFD_SEND (abfd, bfd_h_getx16, (ptr))
349 .#define bfd_h_get_signed_16(abfd, ptr) \
350 . BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
352 .#define bfd_h_put_32(abfd, val, ptr) \
353 . BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
354 .#define bfd_h_put_signed_32 \
355 . bfd_h_put_32
356 .#define bfd_h_get_32(abfd, ptr) \
357 . BFD_SEND (abfd, bfd_h_getx32, (ptr))
358 .#define bfd_h_get_signed_32(abfd, ptr) \
359 . BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
361 .#define bfd_h_put_64(abfd, val, ptr) \
362 . BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
363 .#define bfd_h_put_signed_64 \
364 . bfd_h_put_64
365 .#define bfd_h_get_64(abfd, ptr) \
366 . BFD_SEND (abfd, bfd_h_getx64, (ptr))
367 .#define bfd_h_get_signed_64(abfd, ptr) \
368 . BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
370 .{* Refinements on the above, which should eventually go away. Save
371 . cluttering the source with (bfd_vma) and (bfd_byte *) casts. *}
373 .#define H_PUT_64(abfd, val, where) \
374 . bfd_h_put_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
376 .#define H_PUT_32(abfd, val, where) \
377 . bfd_h_put_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
379 .#define H_PUT_16(abfd, val, where) \
380 . bfd_h_put_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
382 .#define H_PUT_8 bfd_h_put_8
384 .#define H_PUT_S64(abfd, val, where) \
385 . bfd_h_put_signed_64 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
387 .#define H_PUT_S32(abfd, val, where) \
388 . bfd_h_put_signed_32 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
390 .#define H_PUT_S16(abfd, val, where) \
391 . bfd_h_put_signed_16 ((abfd), (bfd_vma) (val), (bfd_byte *) (where))
393 .#define H_PUT_S8 bfd_h_put_signed_8
395 .#define H_GET_64(abfd, where) \
396 . bfd_h_get_64 ((abfd), (bfd_byte *) (where))
398 .#define H_GET_32(abfd, where) \
399 . bfd_h_get_32 ((abfd), (bfd_byte *) (where))
401 .#define H_GET_16(abfd, where) \
402 . bfd_h_get_16 ((abfd), (bfd_byte *) (where))
404 .#define H_GET_8 bfd_h_get_8
406 .#define H_GET_S64(abfd, where) \
407 . bfd_h_get_signed_64 ((abfd), (bfd_byte *) (where))
409 .#define H_GET_S32(abfd, where) \
410 . bfd_h_get_signed_32 ((abfd), (bfd_byte *) (where))
412 .#define H_GET_S16(abfd, where) \
413 . bfd_h_get_signed_16 ((abfd), (bfd_byte *) (where))
415 .#define H_GET_S8 bfd_h_get_signed_8
419 /* Sign extension to bfd_signed_vma. */
420 #define COERCE16(x) (((bfd_signed_vma) (x) ^ 0x8000) - 0x8000)
421 #define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
422 #define EIGHT_GAZILLION ((BFD_HOST_64_BIT) 1 << 63)
423 #define COERCE64(x) \
424 (((bfd_signed_vma) (x) ^ EIGHT_GAZILLION) - EIGHT_GAZILLION)
426 bfd_vma
427 bfd_getb16 (const bfd_byte *addr)
429 return (addr[0] << 8) | addr[1];
432 bfd_vma
433 bfd_getl16 (const bfd_byte *addr)
435 return (addr[1] << 8) | addr[0];
438 bfd_signed_vma
439 bfd_getb_signed_16 (const bfd_byte *addr)
441 return COERCE16 ((addr[0] << 8) | addr[1]);
444 bfd_signed_vma
445 bfd_getl_signed_16 (const bfd_byte *addr)
447 return COERCE16 ((addr[1] << 8) | addr[0]);
450 void
451 bfd_putb16 (bfd_vma data, bfd_byte *addr)
453 addr[0] = (bfd_byte) (data >> 8);
454 addr[1] = (bfd_byte) data;
457 void
458 bfd_putl16 (bfd_vma data, bfd_byte *addr)
460 addr[0] = (bfd_byte) data;
461 addr[1] = (bfd_byte) (data >> 8);
464 bfd_vma
465 bfd_getb32 (const bfd_byte *addr)
467 unsigned long v;
469 v = (unsigned long) addr[0] << 24;
470 v |= (unsigned long) addr[1] << 16;
471 v |= (unsigned long) addr[2] << 8;
472 v |= (unsigned long) addr[3];
473 return v;
476 bfd_vma
477 bfd_getl32 (const bfd_byte *addr)
479 unsigned long v;
481 v = (unsigned long) addr[0];
482 v |= (unsigned long) addr[1] << 8;
483 v |= (unsigned long) addr[2] << 16;
484 v |= (unsigned long) addr[3] << 24;
485 return v;
488 bfd_signed_vma
489 bfd_getb_signed_32 (const bfd_byte *addr)
491 unsigned long v;
493 v = (unsigned long) addr[0] << 24;
494 v |= (unsigned long) addr[1] << 16;
495 v |= (unsigned long) addr[2] << 8;
496 v |= (unsigned long) addr[3];
497 return COERCE32 (v);
500 bfd_signed_vma
501 bfd_getl_signed_32 (const bfd_byte *addr)
503 unsigned long v;
505 v = (unsigned long) addr[0];
506 v |= (unsigned long) addr[1] << 8;
507 v |= (unsigned long) addr[2] << 16;
508 v |= (unsigned long) addr[3] << 24;
509 return COERCE32 (v);
512 bfd_vma
513 bfd_getb64 (const bfd_byte *addr ATTRIBUTE_UNUSED)
515 #ifdef BFD64
516 bfd_vma v;
518 v = addr[0]; v <<= 8;
519 v |= addr[1]; v <<= 8;
520 v |= addr[2]; v <<= 8;
521 v |= addr[3]; v <<= 8;
522 v |= addr[4]; v <<= 8;
523 v |= addr[5]; v <<= 8;
524 v |= addr[6]; v <<= 8;
525 v |= addr[7];
527 return v;
528 #else
529 BFD_FAIL();
530 return 0;
531 #endif
534 bfd_vma
535 bfd_getl64 (const bfd_byte *addr ATTRIBUTE_UNUSED)
537 #ifdef BFD64
538 bfd_vma v;
540 v = addr[7]; v <<= 8;
541 v |= addr[6]; v <<= 8;
542 v |= addr[5]; v <<= 8;
543 v |= addr[4]; v <<= 8;
544 v |= addr[3]; v <<= 8;
545 v |= addr[2]; v <<= 8;
546 v |= addr[1]; v <<= 8;
547 v |= addr[0];
549 return v;
550 #else
551 BFD_FAIL();
552 return 0;
553 #endif
557 bfd_signed_vma
558 bfd_getb_signed_64 (addr)
559 register const bfd_byte *addr ATTRIBUTE_UNUSED;
561 #ifdef BFD64
562 bfd_vma v;
564 v = addr[0]; v <<= 8;
565 v |= addr[1]; v <<= 8;
566 v |= addr[2]; v <<= 8;
567 v |= addr[3]; v <<= 8;
568 v |= addr[4]; v <<= 8;
569 v |= addr[5]; v <<= 8;
570 v |= addr[6]; v <<= 8;
571 v |= addr[7];
573 return COERCE64 (v);
574 #else
575 BFD_FAIL();
576 return 0;
577 #endif
580 bfd_signed_vma
581 bfd_getl_signed_64 (addr)
582 register const bfd_byte *addr ATTRIBUTE_UNUSED;
584 #ifdef BFD64
585 bfd_vma v;
587 v = addr[7]; v <<= 8;
588 v |= addr[6]; v <<= 8;
589 v |= addr[5]; v <<= 8;
590 v |= addr[4]; v <<= 8;
591 v |= addr[3]; v <<= 8;
592 v |= addr[2]; v <<= 8;
593 v |= addr[1]; v <<= 8;
594 v |= addr[0];
596 return COERCE64 (v);
597 #else
598 BFD_FAIL();
599 return 0;
600 #endif
603 void
604 bfd_putb32 (bfd_vma data, bfd_byte *addr)
606 addr[0] = (bfd_byte) (data >> 24);
607 addr[1] = (bfd_byte) (data >> 16);
608 addr[2] = (bfd_byte) (data >> 8);
609 addr[3] = (bfd_byte) data;
612 void
613 bfd_putl32 (bfd_vma data, bfd_byte *addr)
615 addr[0] = (bfd_byte) data;
616 addr[1] = (bfd_byte) (data >> 8);
617 addr[2] = (bfd_byte) (data >> 16);
618 addr[3] = (bfd_byte) (data >> 24);
621 void
622 bfd_putb64 (bfd_vma data ATTRIBUTE_UNUSED, bfd_byte *addr ATTRIBUTE_UNUSED)
624 #ifdef BFD64
625 addr[0] = (bfd_byte) (data >> (7*8));
626 addr[1] = (bfd_byte) (data >> (6*8));
627 addr[2] = (bfd_byte) (data >> (5*8));
628 addr[3] = (bfd_byte) (data >> (4*8));
629 addr[4] = (bfd_byte) (data >> (3*8));
630 addr[5] = (bfd_byte) (data >> (2*8));
631 addr[6] = (bfd_byte) (data >> (1*8));
632 addr[7] = (bfd_byte) (data >> (0*8));
633 #else
634 BFD_FAIL();
635 #endif
638 void
639 bfd_putl64 (bfd_vma data ATTRIBUTE_UNUSED, bfd_byte *addr ATTRIBUTE_UNUSED)
641 #ifdef BFD64
642 addr[7] = (bfd_byte) (data >> (7*8));
643 addr[6] = (bfd_byte) (data >> (6*8));
644 addr[5] = (bfd_byte) (data >> (5*8));
645 addr[4] = (bfd_byte) (data >> (4*8));
646 addr[3] = (bfd_byte) (data >> (3*8));
647 addr[2] = (bfd_byte) (data >> (2*8));
648 addr[1] = (bfd_byte) (data >> (1*8));
649 addr[0] = (bfd_byte) (data >> (0*8));
650 #else
651 BFD_FAIL();
652 #endif
655 void
656 bfd_put_bits (bfd_vma data, bfd_byte *addr, int bits, bfd_boolean big_p)
658 int i;
659 int bytes;
661 if (bits % 8 != 0)
662 abort ();
664 bytes = bits / 8;
665 for (i = 0; i < bytes; i++)
667 int index = big_p ? bytes - i - 1 : i;
669 addr[index] = (bfd_byte) data;
670 data >>= 8;
674 bfd_vma
675 bfd_get_bits (bfd_byte *addr, int bits, bfd_boolean big_p)
677 bfd_vma data;
678 int i;
679 int bytes;
681 if (bits % 8 != 0)
682 abort ();
684 data = 0;
685 bytes = bits / 8;
686 for (i = 0; i < bytes; i++)
688 int index = big_p ? i : bytes - i - 1;
690 data = (data << 8) | addr[index];
693 return data;
696 /* Default implementation */
698 bfd_boolean
699 _bfd_generic_get_section_contents (bfd *abfd,
700 sec_ptr section,
701 void *location,
702 file_ptr offset,
703 bfd_size_type count)
705 if (count == 0)
706 return TRUE;
708 if (offset + count > section->_raw_size)
710 bfd_set_error (bfd_error_invalid_operation);
711 return FALSE;
714 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
715 || bfd_bread (location, count, abfd) != count)
716 return FALSE;
718 return TRUE;
721 bfd_boolean
722 _bfd_generic_get_section_contents_in_window
723 (bfd *abfd ATTRIBUTE_UNUSED,
724 sec_ptr section ATTRIBUTE_UNUSED,
725 bfd_window *w ATTRIBUTE_UNUSED,
726 file_ptr offset ATTRIBUTE_UNUSED,
727 bfd_size_type count ATTRIBUTE_UNUSED)
729 #ifdef USE_MMAP
730 if (count == 0)
731 return TRUE;
732 if (abfd->xvec->_bfd_get_section_contents
733 != _bfd_generic_get_section_contents)
735 /* We don't know what changes the bfd's get_section_contents
736 method may have to make. So punt trying to map the file
737 window, and let get_section_contents do its thing. */
738 /* @@ FIXME : If the internal window has a refcount of 1 and was
739 allocated with malloc instead of mmap, just reuse it. */
740 bfd_free_window (w);
741 w->i = bfd_zmalloc (sizeof (bfd_window_internal));
742 if (w->i == NULL)
743 return FALSE;
744 w->i->data = bfd_malloc (count);
745 if (w->i->data == NULL)
747 free (w->i);
748 w->i = NULL;
749 return FALSE;
751 w->i->mapped = 0;
752 w->i->refcount = 1;
753 w->size = w->i->size = count;
754 w->data = w->i->data;
755 return bfd_get_section_contents (abfd, section, w->data, offset, count);
757 if (offset + count > section->_raw_size
758 || ! bfd_get_file_window (abfd, section->filepos + offset, count, w,
759 TRUE))
760 return FALSE;
761 return TRUE;
762 #else
763 abort ();
764 #endif
767 /* This generic function can only be used in implementations where creating
768 NEW sections is disallowed. It is useful in patching existing sections
769 in read-write files, though. See other set_section_contents functions
770 to see why it doesn't work for new sections. */
771 bfd_boolean
772 _bfd_generic_set_section_contents (bfd *abfd,
773 sec_ptr section,
774 void *location,
775 file_ptr offset,
776 bfd_size_type count)
778 if (count == 0)
779 return TRUE;
781 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
782 || bfd_bwrite (location, count, abfd) != count)
783 return FALSE;
785 return TRUE;
789 INTERNAL_FUNCTION
790 bfd_log2
792 SYNOPSIS
793 unsigned int bfd_log2 (bfd_vma x);
795 DESCRIPTION
796 Return the log base 2 of the value supplied, rounded up. E.g., an
797 @var{x} of 1025 returns 11. A @var{x} of 0 returns 0.
800 unsigned int
801 bfd_log2 (bfd_vma x)
803 unsigned int result = 0;
805 while ((x = (x >> 1)) != 0)
806 ++result;
807 return result;
810 bfd_boolean
811 bfd_generic_is_local_label_name (bfd *abfd, const char *name)
813 char locals_prefix = (bfd_get_symbol_leading_char (abfd) == '_') ? 'L' : '.';
815 return name[0] == locals_prefix;
818 /* Can be used from / for bfd_merge_private_bfd_data to check that
819 endianness matches between input and output file. Returns
820 TRUE for a match, otherwise returns FALSE and emits an error. */
821 bfd_boolean
822 _bfd_generic_verify_endian_match (bfd *ibfd, bfd *obfd)
824 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
825 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
826 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
828 const char *msg;
830 if (bfd_big_endian (ibfd))
831 msg = _("%s: compiled for a big endian system and target is little endian");
832 else
833 msg = _("%s: compiled for a little endian system and target is big endian");
835 (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
837 bfd_set_error (bfd_error_wrong_format);
838 return FALSE;
841 return TRUE;
844 /* Give a warning at runtime if someone compiles code which calls
845 old routines. */
847 void
848 warn_deprecated (const char *what,
849 const char *file,
850 int line,
851 const char *func)
853 /* Poor man's tracking of functions we've already warned about. */
854 static size_t mask = 0;
856 if (~(size_t) func & ~mask)
858 /* Note: separate sentences in order to allow
859 for translation into other languages. */
860 if (func)
861 fprintf (stderr, _("Deprecated %s called at %s line %d in %s\n"),
862 what, file, line, func);
863 else
864 fprintf (stderr, _("Deprecated %s called\n"), what);
865 mask |= ~(size_t) func;