1 /* Assorted BFD support routines, only used internally.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
10 (at your option) any later version.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
30 This file contains various routines which are used within BFD.
31 They are not intended for export, but are documented here for
36 DEFUN(_bfd_dummy_new_section_hook,(ignore, ignore_newsect),
38 asection *ignore_newsect)
44 DEFUN(bfd_false ,(ignore),
51 DEFUN(bfd_true,(ignore),
58 DEFUN(bfd_nullvoidptr,(ignore),
72 DEFUN(bfd_0u,(ignore),
79 DEFUN(bfd_void,(ignore),
85 DEFUN(_bfd_dummy_core_file_matches_executable_p,(ignore_core_bfd, ignore_exec_bfd),
86 bfd *ignore_core_bfd AND
89 bfd_error = invalid_operation;
93 /* of course you can't initialize a function to be the same as another, grr */
96 DEFUN(_bfd_dummy_core_file_failing_command,(ignore_abfd),
103 DEFUN(_bfd_dummy_core_file_failing_signal,(ignore_abfd),
110 DEFUN(_bfd_dummy_target,(ignore_abfd),
116 /** zalloc -- allocate and clear storage */
124 char *ptr = (char *) malloc ((int)size);
126 if ((ptr != NULL) && (size != 0))
138 PTR bfd_xmalloc( bfd_size_type size);
141 Like malloc, but exit if no more memory.
145 /** There is major inconsistency in how running out of memory is handled.
146 Some routines return a NULL, and set bfd_error to no_memory.
147 However, obstack routines can't do this ... */
150 DEFUN(PTR bfd_xmalloc,(size),
153 static CONST char no_memory_message[] = "Virtual memory exhausted!\n";
155 if (size == 0) size = 1;
156 ptr = (PTR)malloc(size);
159 write (2, no_memory_message, sizeof(no_memory_message)-1);
168 /* Note that archive entries don't have streams; they share their parent's.
169 This allows someone to play with the iostream behind BFD's back.
171 Also, note that the origin pointer points to the beginning of a file's
172 contents (0 for non-archive elements). For archive entries this is the
173 first octet in the file, NOT the beginning of the archive header. */
176 int DEFUN(real_read,(where, a,b, file),
182 return fread(where, a,b,file);
185 DEFUN(bfd_read,(ptr, size, nitems, abfd),
187 bfd_size_type size AND
188 bfd_size_type nitems AND
192 nread = real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
193 #ifdef FILE_OFFSET_IS_CHAR_INDEX
195 abfd->where += nread;
201 DEFUN(bfd_write,(ptr, size, nitems, abfd),
203 bfd_size_type size AND
204 bfd_size_type nitems AND
207 int nwrote = fwrite (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
208 #ifdef FILE_OFFSET_IS_CHAR_INDEX
210 abfd->where += nwrote;
217 bfd_write_bigendian_4byte_int
220 void bfd_write_bigendian_4byte_int(bfd *abfd, int i);
223 Writes a 4 byte integer to the outputing bfd, in big endian
224 mode regardless of what else is going on. This is usefull in
229 DEFUN(bfd_write_bigendian_4byte_int,(abfd, i),
234 _do_putb32(i, buffer);
235 bfd_write((PTR)buffer, 4, 1, abfd);
239 DEFUN(bfd_tell,(abfd),
244 ptr = ftell (bfd_cache_lookup(abfd));
246 if (abfd->my_archive)
253 DEFUN(bfd_seek,(abfd, position, direction),
255 CONST file_ptr position AND
260 file_ptr file_position;
261 /* For the time being, a BFD may not seek to it's end. The problem
262 is that we don't easily have a way to recognize the end of an
263 element in an archive. */
265 BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
267 if (direction == SEEK_CUR && position == 0)
269 #ifdef FILE_OFFSET_IS_CHAR_INDEX
270 if (direction == SEEK_SET && position == abfd->where)
274 f = bfd_cache_lookup (abfd);
275 file_position = position;
276 if (direction == SEEK_SET && abfd->my_archive != NULL)
277 file_position += abfd->origin;
279 result = fseek (f, file_position, direction);
282 /* Force redetermination of `where' field. */
286 #ifdef FILE_OFFSET_IS_CHAR_INDEX
287 /* Adjust `where' field. */
288 if (direction == SEEK_SET)
289 abfd->where = position;
291 abfd->where += position;
297 /** Make a string table */
300 Add string to table pointed to by table, at location starting with free_ptr.
301 resizes the table if necessary (if it's NULL, creates it, ignoring
302 table_length). Updates free_ptr, table, table_length */
305 DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
308 unsigned int *table_length AND
311 size_t string_length = strlen (new_string) + 1; /* include null here */
313 size_t space_length = *table_length;
314 unsigned int offset = (base ? *free_ptr - base : 0);
317 /* Avoid a useless regrow if we can (but of course we still
319 space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
320 DEFAULT_STRING_SPACE_SIZE : string_length+1);
321 base = zalloc (space_length);
324 bfd_error = no_memory;
329 if ((size_t)(offset + string_length) >= space_length) {
330 /* Make sure we will have enough space */
331 while ((size_t)(offset + string_length) >= space_length)
332 space_length += space_length/2; /* grow by 50% */
334 base = (char *) realloc (base, space_length);
336 bfd_error = no_memory;
342 memcpy (base + offset, new_string, string_length);
344 *table_length = space_length;
345 *free_ptr = base + offset + string_length;
350 /** The do-it-yourself (byte) sex-change kit */
352 /* The middle letter e.g. get<b>short indicates Big or Little endian
353 target machine. It doesn't matter what the byte order of the host
354 machine is; these routines work for either. */
356 /* FIXME: Should these take a count argument?
357 Answer (gnu@cygnus.com): No, but perhaps they should be inline
358 functions in swap.h #ifdef __GNUC__.
359 Gprof them later and find out. */
368 These macros as used for reading and writing raw data in
369 sections; each access (except for bytes) is vectored through
370 the target format of the BFD and mangled accordingly. The
371 mangling performs any necessary endian translations and
372 removes alignment restrictions.
374 .#define bfd_put_8(abfd, val, ptr) \
375 . (*((char *)ptr) = (char)val)
376 .#define bfd_get_8(abfd, ptr) \
378 .#define bfd_put_16(abfd, val, ptr) \
379 . BFD_SEND(abfd, bfd_putx16, (val,ptr))
380 .#define bfd_get_16(abfd, ptr) \
381 . BFD_SEND(abfd, bfd_getx16, (ptr))
382 .#define bfd_put_32(abfd, val, ptr) \
383 . BFD_SEND(abfd, bfd_putx32, (val,ptr))
384 .#define bfd_get_32(abfd, ptr) \
385 . BFD_SEND(abfd, bfd_getx32, (ptr))
386 .#define bfd_put_64(abfd, val, ptr) \
387 . BFD_SEND(abfd, bfd_putx64, (val, ptr))
388 .#define bfd_get_64(abfd, ptr) \
389 . BFD_SEND(abfd, bfd_getx64, (ptr))
400 These macros have the same function as their <<bfd_get_x>>
401 bretherin, except that they are used for removing information
402 for the header records of object files. Believe it or not,
403 some object files keep their header records in big endian
404 order, and their data in little endan order.
406 .#define bfd_h_put_8(abfd, val, ptr) \
407 . (*((char *)ptr) = (char)val)
408 .#define bfd_h_get_8(abfd, ptr) \
410 .#define bfd_h_put_16(abfd, val, ptr) \
411 . BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
412 .#define bfd_h_get_16(abfd, ptr) \
413 . BFD_SEND(abfd, bfd_h_getx16,(ptr))
414 .#define bfd_h_put_32(abfd, val, ptr) \
415 . BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
416 .#define bfd_h_get_32(abfd, ptr) \
417 . BFD_SEND(abfd, bfd_h_getx32,(ptr))
418 .#define bfd_h_put_64(abfd, val, ptr) \
419 . BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
420 .#define bfd_h_get_64(abfd, ptr) \
421 . BFD_SEND(abfd, bfd_h_getx64,(ptr))
426 DEFUN(_do_getb16,(addr),
427 register bfd_byte *addr)
429 return (addr[0] << 8) | addr[1];
433 DEFUN(_do_getl16,(addr),
434 register bfd_byte *addr)
436 return (addr[1] << 8) | addr[0];
440 DEFUN(_do_putb16,(data, addr),
442 register bfd_byte *addr)
444 addr[0] = (bfd_byte)(data >> 8);
445 addr[1] = (bfd_byte )data;
449 DEFUN(_do_putl16,(data, addr),
451 register bfd_byte *addr)
453 addr[0] = (bfd_byte )data;
454 addr[1] = (bfd_byte)(data >> 8);
458 DEFUN(_do_getb32,(addr),
459 register bfd_byte *addr)
461 return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3];
466 register bfd_byte *addr;
468 return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0];
472 DEFUN(_do_getb64,(addr),
473 register bfd_byte *addr)
476 bfd_64_type low, high;
478 high= ((((((((addr[0]) << 8) |
483 low = ((((((((addr[4]) << 8) |
488 return high << 32 | low;
497 DEFUN(_do_getl64,(addr),
498 register bfd_byte *addr)
502 bfd_64_type low, high;
503 high= (((((((addr[7] << 8) |
508 low = (((((((addr[3] << 8) |
513 return high << 32 | low;
522 DEFUN(_do_putb32,(data, addr),
524 register bfd_byte *addr)
526 addr[0] = (bfd_byte)(data >> 24);
527 addr[1] = (bfd_byte)(data >> 16);
528 addr[2] = (bfd_byte)(data >> 8);
529 addr[3] = (bfd_byte)data;
533 DEFUN(_do_putl32,(data, addr),
535 register bfd_byte *addr)
537 addr[0] = (bfd_byte)data;
538 addr[1] = (bfd_byte)(data >> 8);
539 addr[2] = (bfd_byte)(data >> 16);
540 addr[3] = (bfd_byte)(data >> 24);
543 DEFUN(_do_putb64,(data, addr),
545 register bfd_byte *addr)
548 addr[0] = (bfd_byte)(data >> (7*8));
549 addr[1] = (bfd_byte)(data >> (6*8));
550 addr[2] = (bfd_byte)(data >> (5*8));
551 addr[3] = (bfd_byte)(data >> (4*8));
552 addr[4] = (bfd_byte)(data >> (3*8));
553 addr[5] = (bfd_byte)(data >> (2*8));
554 addr[6] = (bfd_byte)(data >> (1*8));
555 addr[7] = (bfd_byte)(data >> (0*8));
563 DEFUN(_do_putl64,(data, addr),
565 register bfd_byte *addr)
568 addr[7] = (bfd_byte)(data >> (7*8));
569 addr[6] = (bfd_byte)(data >> (6*8));
570 addr[5] = (bfd_byte)(data >> (5*8));
571 addr[4] = (bfd_byte)(data >> (4*8));
572 addr[3] = (bfd_byte)(data >> (3*8));
573 addr[2] = (bfd_byte)(data >> (2*8));
574 addr[1] = (bfd_byte)(data >> (1*8));
575 addr[0] = (bfd_byte)(data >> (0*8));
583 /* Default implementation */
586 DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count),
595 if ((bfd_size_type)(offset+count) > section->_raw_size
596 || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
597 || bfd_read(location, (bfd_size_type)1, count, abfd) != count)
598 return (false); /* on error */
602 /* This generic function can only be used in implementations where creating
603 NEW sections is disallowed. It is useful in patching existing sections
604 in read-write files, though. See other set_section_contents functions
605 to see why it doesn't work for new sections. */
607 DEFUN(bfd_generic_set_section_contents, (abfd, section, location, offset, count),
616 if ((bfd_size_type)(offset+count) > bfd_get_section_size_after_reloc(section)
617 || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
618 || bfd_write(location, (bfd_size_type)1, count, abfd) != count)
619 return (false); /* on error */
628 Return the log base 2 of the value supplied, rounded up. eg an
629 arg of 1025 would return 11.
632 bfd_vma bfd_log2(bfd_vma x);
639 while ( (bfd_vma)(1<< result) < x)