bfd/libbfd.c

   1 /* Assorted BFD support routines, only used internally.
   2    Copyright 1990, 1991, 1992 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24
  25 /*
  26 SECTION
  27         libbfd
  28
  29 DESCRIPTION
  30         This file contains various routines which are used within BFD.
  31         They are not intended for export, but are documented here for
  32         completeness.
  33 */
  34
  35 boolean
  36 DEFUN(_bfd_dummy_new_section_hook,(ignore, ignore_newsect),
  37       bfd *ignore AND
  38       asection *ignore_newsect)
  39 {
  40   return true;
  41 }
  42
  43 boolean
  44 DEFUN(bfd_false ,(ignore),
  45       bfd *ignore)
  46 {
  47   return false;
  48 }
  49
  50 boolean
  51 DEFUN(bfd_true,(ignore),
  52       bfd *ignore)
  53 {
  54   return true;
  55 }
  56
  57 PTR
  58 DEFUN(bfd_nullvoidptr,(ignore),
  59       bfd *ignore)
  60 {
  61   return (PTR)NULL;
  62 }
  63
  64 int
  65 DEFUN(bfd_0,(ignore),
  66       bfd *ignore)
  67 {
  68   return 0;
  69 }
  70
  71 unsigned int
  72 DEFUN(bfd_0u,(ignore),
  73       bfd *ignore)
  74 {
  75    return 0;
  76 }
  77
  78 void
  79 DEFUN(bfd_void,(ignore),
  80       bfd *ignore)
  81 {
  82 }
  83
  84 boolean
  85 DEFUN(_bfd_dummy_core_file_matches_executable_p,(ignore_core_bfd, ignore_exec_bfd),
  86       bfd *ignore_core_bfd AND
  87       bfd *ignore_exec_bfd)
  88 {
  89   bfd_error = invalid_operation;
  90   return false;
  91 }
  92
  93 /* of course you can't initialize a function to be the same as another, grr */
  94
  95 char *
  96 DEFUN(_bfd_dummy_core_file_failing_command,(ignore_abfd),
  97       bfd *ignore_abfd)
  98 {
  99   return (char *)NULL;
 100 }
 101
 102 int
 103 DEFUN(_bfd_dummy_core_file_failing_signal,(ignore_abfd),
 104      bfd *ignore_abfd)
 105 {
 106   return 0;
 107 }
 108
 109 bfd_target *
 110 DEFUN(_bfd_dummy_target,(ignore_abfd),
 111      bfd *ignore_abfd)
 112 {
 113   return 0;
 114 }
 115 \f
 116 /** zalloc -- allocate and clear storage */
 117
 118
 119 #ifndef zalloc
 120 char *
 121 DEFUN(zalloc,(size),
 122       bfd_size_type size)
 123 {
 124   char *ptr = (char *) malloc ((int)size);
 125
 126   if ((ptr != NULL) && (size != 0))
 127    memset(ptr,0, size);
 128
 129   return ptr;
 130 }
 131 #endif
 132
 133 /*
 134 INTERNAL_FUNCTION
 135         bfd_xmalloc
 136
 137 SYNOPSIS
 138         PTR  bfd_xmalloc( bfd_size_type size);
 139
 140 DESCRIPTION
 141         Like malloc, but exit if no more memory.
 142
 143 */
 144
 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 ... */
 148
 149
 150 DEFUN(PTR bfd_xmalloc,(size),
 151       bfd_size_type size)
 152 {
 153   static CONST char no_memory_message[] = "Virtual memory exhausted!\n";
 154   PTR ptr;
 155   if (size == 0) size = 1;
 156   ptr = (PTR)malloc(size);
 157   if (!ptr)
 158     {
 159       write (2, no_memory_message, sizeof(no_memory_message)-1);
 160       exit (-1);
 161     }
 162   return ptr;
 163 }
 164 \f
 165 /* Some IO code */
 166
 167
 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.
 170
 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. */
 174
 175 static
 176 int DEFUN(real_read,(where, a,b, file),
 177           PTR where AND
 178           int a AND
 179           int b AND
 180           FILE *file)
 181 {
 182   return fread(where, a,b,file);
 183 }
 184 bfd_size_type
 185 DEFUN(bfd_read,(ptr, size, nitems, abfd),
 186       PTR ptr AND
 187       bfd_size_type size AND
 188       bfd_size_type nitems AND
 189       bfd *abfd)
 190 {
 191   int nread;
 192   nread = real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
 193 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 194   if (nread > 0)
 195     abfd->where += nread;
 196 #endif
 197   return nread;
 198 }
 199
 200 bfd_size_type
 201 DEFUN(bfd_write,(ptr, size, nitems, abfd),
 202       CONST PTR ptr AND
 203       bfd_size_type size AND
 204       bfd_size_type nitems AND
 205       bfd *abfd)
 206 {
 207   int nwrote = fwrite (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
 208 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 209   if (nwrote > 0)
 210     abfd->where += nwrote;
 211 #endif
 212   return nwrote;
 213 }
 214
 215 /*
 216 INTERNAL_FUNCTION
 217         bfd_write_bigendian_4byte_int
 218
 219 SYNOPSIS
 220         void bfd_write_bigendian_4byte_int(bfd *abfd,  int i);
 221
 222 DESCRIPTION
 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
 225         archives.
 226
 227 */
 228 void
 229 DEFUN(bfd_write_bigendian_4byte_int,(abfd, i),
 230       bfd *abfd AND
 231       int i)
 232 {
 233   bfd_byte buffer[4];
 234   _do_putb32(i, buffer);
 235   bfd_write((PTR)buffer, 4, 1, abfd);
 236 }
 237
 238 long
 239 DEFUN(bfd_tell,(abfd),
 240       bfd *abfd)
 241 {
 242   file_ptr ptr;
 243
 244   ptr = ftell (bfd_cache_lookup(abfd));
 245
 246   if (abfd->my_archive)
 247     ptr -= abfd->origin;
 248   abfd->where = ptr;
 249   return ptr;
 250 }
 251
 252 int
 253 DEFUN(bfd_seek,(abfd, position, direction),
 254       bfd * CONST abfd AND
 255       CONST file_ptr position AND
 256       CONST int direction)
 257 {
 258   int result;
 259   FILE *f;
 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. */
 264
 265   BFD_ASSERT (direction == SEEK_SET || direction == SEEK_CUR);
 266
 267   if (direction == SEEK_CUR && position == 0)
 268     return 0;
 269 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 270   if (direction == SEEK_SET && position == abfd->where)
 271     return 0;
 272 #endif
 273
 274   f = bfd_cache_lookup (abfd);
 275   file_position = position;
 276   if (direction == SEEK_SET && abfd->my_archive != NULL)
 277     file_position += abfd->origin;
 278
 279   result = fseek (f, file_position, direction);
 280
 281   if (result != 0)
 282     /* Force redetermination of `where' field.  */
 283     bfd_tell (abfd);
 284   else
 285     {
 286 #ifdef FILE_OFFSET_IS_CHAR_INDEX
 287       /* Adjust `where' field.  */
 288       if (direction == SEEK_SET)
 289         abfd->where = position;
 290       else
 291         abfd->where += position;
 292 #endif
 293     }
 294   return result;
 295 }
 296 \f
 297 /** Make a string table */
 298
 299 /*>bfd.h<
 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 */
 303
 304 boolean
 305 DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
 306       char **table AND
 307       char *new_string AND
 308       unsigned int *table_length AND
 309       char **free_ptr)
 310 {
 311   size_t string_length = strlen (new_string) + 1; /* include null here */
 312   char *base = *table;
 313   size_t space_length = *table_length;
 314   unsigned int offset = (base ? *free_ptr - base : 0);
 315
 316   if (base == NULL) {
 317     /* Avoid a useless regrow if we can (but of course we still
 318        take it next time */
 319     space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
 320                     DEFAULT_STRING_SPACE_SIZE : string_length+1);
 321     base = zalloc (space_length);
 322
 323     if (base == NULL) {
 324       bfd_error = no_memory;
 325       return false;
 326     }
 327   }
 328
 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% */
 333
 334     base = (char *) realloc (base, space_length);
 335     if (base == NULL) {
 336       bfd_error = no_memory;
 337       return false;
 338     }
 339
 340   }
 341
 342   memcpy (base + offset, new_string, string_length);
 343   *table = base;
 344   *table_length = space_length;
 345   *free_ptr = base + offset + string_length;
 346
 347   return true;
 348 }
 349 \f
 350 /** The do-it-yourself (byte) sex-change kit */
 351
 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.  */
 355
 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.  */
 360
 361 /*
 362 FUNCTION
 363         bfd_put_size
 364 FUNCTION
 365         bfd_get_size
 366
 367 DESCRIPTION
 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.
 373
 374 .#define bfd_put_8(abfd, val, ptr) \
 375 .                (*((char *)ptr) = (char)val)
 376 .#define bfd_get_8(abfd, ptr) \
 377 .                (*((char *)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))
 390
 391 */
 392
 393 /*
 394 FUNCTION
 395         bfd_h_put_size
 396 FUNCTION
 397         bfd_h_get_size
 398
 399 DESCRIPTION
 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.
 405
 406 .#define bfd_h_put_8(abfd, val, ptr) \
 407 .                (*((char *)ptr) = (char)val)
 408 .#define bfd_h_get_8(abfd, ptr) \
 409 .                (*((char *)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))
 422
 423 */
 424
 425 bfd_vma
 426 DEFUN(_do_getb16,(addr),
 427       register bfd_byte *addr)
 428 {
 429         return (addr[0] << 8) | addr[1];
 430 }
 431
 432 bfd_vma
 433 DEFUN(_do_getl16,(addr),
 434       register bfd_byte *addr)
 435 {
 436         return (addr[1] << 8) | addr[0];
 437 }
 438
 439 void
 440 DEFUN(_do_putb16,(data, addr),
 441       bfd_vma data AND
 442       register bfd_byte *addr)
 443 {
 444         addr[0] = (bfd_byte)(data >> 8);
 445         addr[1] = (bfd_byte )data;
 446 }
 447
 448 void
 449 DEFUN(_do_putl16,(data, addr),
 450       bfd_vma data AND
 451       register bfd_byte *addr)
 452 {
 453         addr[0] = (bfd_byte )data;
 454         addr[1] = (bfd_byte)(data >> 8);
 455 }
 456
 457 bfd_vma
 458 DEFUN(_do_getb32,(addr),
 459       register bfd_byte *addr)
 460 {
 461         return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3];
 462 }
 463
 464 bfd_vma
 465 _do_getl32 (addr)
 466         register bfd_byte *addr;
 467 {
 468         return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0];
 469 }
 470
 471 bfd_vma
 472 DEFUN(_do_getb64,(addr),
 473       register bfd_byte *addr)
 474 {
 475 #ifdef HOST_64_BIT
 476   bfd_64_type low, high;
 477
 478   high= ((((((((addr[0]) << 8) |
 479               addr[1]) << 8) |
 480             addr[2]) << 8) |
 481           addr[3]) );
 482
 483   low = ((((((((addr[4]) << 8) |
 484               addr[5]) << 8) |
 485             addr[6]) << 8) |
 486           addr[7]));
 487
 488   return high << 32 | low;
 489 #else
 490   BFD_FAIL();
 491   return 0;
 492 #endif
 493
 494 }
 495
 496 bfd_vma
 497 DEFUN(_do_getl64,(addr),
 498       register bfd_byte *addr)
 499 {
 500
 501 #ifdef HOST_64_BIT
 502   bfd_64_type low, high;
 503   high= (((((((addr[7] << 8) |
 504               addr[6]) << 8) |
 505             addr[5]) << 8) |
 506           addr[4]));
 507
 508   low = (((((((addr[3] << 8) |
 509               addr[2]) << 8) |
 510             addr[1]) << 8) |
 511           addr[0]) );
 512
 513   return high << 32 | low;
 514 #else
 515   BFD_FAIL();
 516   return 0;
 517 #endif
 518
 519 }
 520
 521 void
 522 DEFUN(_do_putb32,(data, addr),
 523       bfd_vma data AND
 524       register bfd_byte *addr)
 525 {
 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;
 530 }
 531
 532 void
 533 DEFUN(_do_putl32,(data, addr),
 534       bfd_vma data AND
 535       register bfd_byte *addr)
 536 {
 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);
 541 }
 542 void
 543 DEFUN(_do_putb64,(data, addr),
 544         bfd_vma data AND
 545         register bfd_byte *addr)
 546 {
 547 #ifdef HOST_64_BIT
 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));
 556 #else
 557   BFD_FAIL();
 558 #endif
 559
 560 }
 561
 562 void
 563 DEFUN(_do_putl64,(data, addr),
 564       bfd_vma data AND
 565       register bfd_byte *addr)
 566 {
 567 #ifdef HOST_64_BIT
 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));
 576 #else
 577   BFD_FAIL();
 578 #endif
 579
 580 }
 581
 582 \f
 583 /* Default implementation */
 584
 585 boolean
 586 DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count),
 587       bfd *abfd AND
 588       sec_ptr section AND
 589       PTR location AND
 590       file_ptr offset AND
 591       bfd_size_type count)
 592 {
 593     if (count == 0)
 594         return true;
 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 */
 599     return (true);
 600 }
 601
 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.  */
 606 boolean
 607 DEFUN(bfd_generic_set_section_contents, (abfd, section, location, offset, count),
 608       bfd *abfd AND
 609       sec_ptr section AND
 610       PTR location AND
 611       file_ptr offset AND
 612       bfd_size_type count)
 613 {
 614     if (count == 0)
 615         return true;
 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 */
 620     return (true);
 621 }
 622
 623 /*
 624 INTERNAL_FUNCTION
 625         bfd_log2
 626
 627 DESCRIPTION
 628         Return the log base 2 of the value supplied, rounded up. eg an
 629         arg of 1025 would return 11.
 630
 631 SYNOPSIS
 632         bfd_vma bfd_log2(bfd_vma x);
 633 */
 634
 635 bfd_vma bfd_log2(x)
 636 bfd_vma x;
 637 {
 638   bfd_vma  result = 0;
 639   while ( (bfd_vma)(1<< result) < x)
 640     result++;
 641   return result;
 642 }