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 /* For the time being, a BFD may not seek to it's end. The problem
261 is that we don't easily have a way to recognize the end of an
262 element in an archive. */
264 BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
266 if (direction == SEEK_SET && position == 0)
268 #ifdef FILE_OFFSET_IS_CHAR_INDEX
269 if (x > 0 && direction == SEEK_SET && position == abfd->where)
273 f = bfd_cache_lookup (abfd);
274 if (direction == SEEK_SET && abfd->my_archive != NULL)
276 /* This is a set within an archive, so we need to
277 add the base of the object within the archive */
278 result = fseek (f, position + abfd->origin, direction);
282 result = fseek (f, position, direction);
284 /* Force redetermination of `where' field. */
288 /** Make a string table */
291 Add string to table pointed to by table, at location starting with free_ptr.
292 resizes the table if necessary (if it's NULL, creates it, ignoring
293 table_length). Updates free_ptr, table, table_length */
296 DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
299 unsigned int *table_length AND
302 size_t string_length = strlen (new_string) + 1; /* include null here */
304 size_t space_length = *table_length;
305 unsigned int offset = (base ? *free_ptr - base : 0);
308 /* Avoid a useless regrow if we can (but of course we still
310 space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
311 DEFAULT_STRING_SPACE_SIZE : string_length+1);
312 base = zalloc (space_length);
315 bfd_error = no_memory;
320 if ((size_t)(offset + string_length) >= space_length) {
321 /* Make sure we will have enough space */
322 while ((size_t)(offset + string_length) >= space_length)
323 space_length += space_length/2; /* grow by 50% */
325 base = (char *) realloc (base, space_length);
327 bfd_error = no_memory;
333 memcpy (base + offset, new_string, string_length);
335 *table_length = space_length;
336 *free_ptr = base + offset + string_length;
341 /** The do-it-yourself (byte) sex-change kit */
343 /* The middle letter e.g. get<b>short indicates Big or Little endian
344 target machine. It doesn't matter what the byte order of the host
345 machine is; these routines work for either. */
347 /* FIXME: Should these take a count argument?
348 Answer (gnu@cygnus.com): No, but perhaps they should be inline
349 functions in swap.h #ifdef __GNUC__.
350 Gprof them later and find out. */
359 These macros as used for reading and writing raw data in
360 sections; each access (except for bytes) is vectored through
361 the target format of the BFD and mangled accordingly. The
362 mangling performs any necessary endian translations and
363 removes alignment restrictions.
365 .#define bfd_put_8(abfd, val, ptr) \
366 . (*((char *)ptr) = (char)val)
367 .#define bfd_get_8(abfd, ptr) \
369 .#define bfd_put_16(abfd, val, ptr) \
370 . BFD_SEND(abfd, bfd_putx16, (val,ptr))
371 .#define bfd_get_16(abfd, ptr) \
372 . BFD_SEND(abfd, bfd_getx16, (ptr))
373 .#define bfd_put_32(abfd, val, ptr) \
374 . BFD_SEND(abfd, bfd_putx32, (val,ptr))
375 .#define bfd_get_32(abfd, ptr) \
376 . BFD_SEND(abfd, bfd_getx32, (ptr))
377 .#define bfd_put_64(abfd, val, ptr) \
378 . BFD_SEND(abfd, bfd_putx64, (val, ptr))
379 .#define bfd_get_64(abfd, ptr) \
380 . BFD_SEND(abfd, bfd_getx64, (ptr))
391 These macros have the same function as their <<bfd_get_x>>
392 bretherin, except that they are used for removing information
393 for the header records of object files. Believe it or not,
394 some object files keep their header records in big endian
395 order, and their data in little endan order.
397 .#define bfd_h_put_8(abfd, val, ptr) \
398 . (*((char *)ptr) = (char)val)
399 .#define bfd_h_get_8(abfd, ptr) \
401 .#define bfd_h_put_16(abfd, val, ptr) \
402 . BFD_SEND(abfd, bfd_h_putx16,(val,ptr))
403 .#define bfd_h_get_16(abfd, ptr) \
404 . BFD_SEND(abfd, bfd_h_getx16,(ptr))
405 .#define bfd_h_put_32(abfd, val, ptr) \
406 . BFD_SEND(abfd, bfd_h_putx32,(val,ptr))
407 .#define bfd_h_get_32(abfd, ptr) \
408 . BFD_SEND(abfd, bfd_h_getx32,(ptr))
409 .#define bfd_h_put_64(abfd, val, ptr) \
410 . BFD_SEND(abfd, bfd_h_putx64,(val, ptr))
411 .#define bfd_h_get_64(abfd, ptr) \
412 . BFD_SEND(abfd, bfd_h_getx64,(ptr))
417 DEFUN(_do_getb16,(addr),
418 register bfd_byte *addr)
420 return (addr[0] << 8) | addr[1];
424 DEFUN(_do_getl16,(addr),
425 register bfd_byte *addr)
427 return (addr[1] << 8) | addr[0];
431 DEFUN(_do_putb16,(data, addr),
433 register bfd_byte *addr)
435 addr[0] = (bfd_byte)(data >> 8);
436 addr[1] = (bfd_byte )data;
440 DEFUN(_do_putl16,(data, addr),
442 register bfd_byte *addr)
444 addr[0] = (bfd_byte )data;
445 addr[1] = (bfd_byte)(data >> 8);
449 DEFUN(_do_getb32,(addr),
450 register bfd_byte *addr)
452 return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3];
457 register bfd_byte *addr;
459 return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0];
463 DEFUN(_do_getb64,(addr),
464 register bfd_byte *addr)
467 bfd_64_type low, high;
469 high= ((((((((addr[0]) << 8) |
474 low = ((((((((addr[4]) << 8) |
479 return high << 32 | low;
488 DEFUN(_do_getl64,(addr),
489 register bfd_byte *addr)
493 bfd_64_type low, high;
494 high= (((((((addr[7] << 8) |
499 low = (((((((addr[3] << 8) |
504 return high << 32 | low;
513 DEFUN(_do_putb32,(data, addr),
515 register bfd_byte *addr)
517 addr[0] = (bfd_byte)(data >> 24);
518 addr[1] = (bfd_byte)(data >> 16);
519 addr[2] = (bfd_byte)(data >> 8);
520 addr[3] = (bfd_byte)data;
524 DEFUN(_do_putl32,(data, addr),
526 register bfd_byte *addr)
528 addr[0] = (bfd_byte)data;
529 addr[1] = (bfd_byte)(data >> 8);
530 addr[2] = (bfd_byte)(data >> 16);
531 addr[3] = (bfd_byte)(data >> 24);
534 DEFUN(_do_putb64,(data, addr),
536 register bfd_byte *addr)
539 addr[0] = (bfd_byte)(data >> (7*8));
540 addr[1] = (bfd_byte)(data >> (6*8));
541 addr[2] = (bfd_byte)(data >> (5*8));
542 addr[3] = (bfd_byte)(data >> (4*8));
543 addr[4] = (bfd_byte)(data >> (3*8));
544 addr[5] = (bfd_byte)(data >> (2*8));
545 addr[6] = (bfd_byte)(data >> (1*8));
546 addr[7] = (bfd_byte)(data >> (0*8));
554 DEFUN(_do_putl64,(data, addr),
556 register bfd_byte *addr)
559 addr[7] = (bfd_byte)(data >> (7*8));
560 addr[6] = (bfd_byte)(data >> (6*8));
561 addr[5] = (bfd_byte)(data >> (5*8));
562 addr[4] = (bfd_byte)(data >> (4*8));
563 addr[3] = (bfd_byte)(data >> (3*8));
564 addr[2] = (bfd_byte)(data >> (2*8));
565 addr[1] = (bfd_byte)(data >> (1*8));
566 addr[0] = (bfd_byte)(data >> (0*8));
574 /* Default implementation */
577 DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count),
586 if ((bfd_size_type)(offset+count) > section->_raw_size
587 || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
588 || bfd_read(location, (bfd_size_type)1, count, abfd) != count)
589 return (false); /* on error */
593 /* This generic function can only be used in implementations where creating
594 NEW sections is disallowed. It is useful in patching existing sections
595 in read-write files, though. See other set_section_contents functions
596 to see why it doesn't work for new sections. */
598 DEFUN(bfd_generic_set_section_contents, (abfd, section, location, offset, count),
607 if ((bfd_size_type)(offset+count) > bfd_get_section_size_after_reloc(section)
608 || bfd_seek(abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
609 || bfd_write(location, (bfd_size_type)1, count, abfd) != count)
610 return (false); /* on error */
619 Return the log base 2 of the value supplied, rounded up. eg an
620 arg of 1025 would return 11.
623 bfd_vma bfd_log2(bfd_vma x);
630 while ( (bfd_vma)(1<< result) < x)