bfd/libbfd.c

   1 /* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
   2
   3 This file is part of BFD, the Binary File Diddler.
   4
   5 BFD is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 1, or (at your option)
   8 any later version.
   9
  10 BFD is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with BFD; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 /* $Id$ */
  20
  21 /*** libbfd.c -- random bfd support routines used internally only. */
  22 #include <sysdep.h>
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25
  26
  27 \f
  28 /** Dummies for targets that don't want or need to implement
  29    certain operations */
  30
  31 boolean
  32 DEFUN(_bfd_dummy_new_section_hook,(ignore, ignore_newsect),
  33       bfd *ignore AND
  34       asection *ignore_newsect)
  35 {
  36   return true;
  37 }
  38
  39 boolean
  40 DEFUN(bfd_false ,(ignore),
  41       bfd *ignore)
  42 {
  43   return false;
  44 }
  45
  46 boolean
  47 DEFUN(bfd_true,(ignore),
  48       bfd *ignore)
  49 {
  50   return true;
  51 }
  52
  53 PTR
  54 DEFUN(bfd_nullvoidptr,(ignore),
  55       bfd *ignore)
  56 {
  57   return (PTR)NULL;
  58 }
  59
  60 int
  61 DEFUN(bfd_0,(ignore),
  62       bfd *ignore)
  63 {
  64   return 0;
  65 }
  66
  67 unsigned int
  68 DEFUN(bfd_0u,(ignore),
  69       bfd *ignore)
  70 {
  71    return 0;
  72 }
  73
  74 void
  75 DEFUN(bfd_void,(ignore),
  76       bfd *ignore)
  77 {
  78 }
  79
  80 boolean
  81 DEFUN(_bfd_dummy_core_file_matches_executable_p,(ignore_core_bfd, ignore_exec_bfd),
  82       bfd *ignore_core_bfd AND
  83       bfd *ignore_exec_bfd)
  84 {
  85   bfd_error = invalid_operation;
  86   return false;
  87 }
  88
  89 /* of course you can't initialize a function to be the same as another, grr */
  90
  91 char *
  92 DEFUN(_bfd_dummy_core_file_failing_command,(ignore_abfd),
  93       bfd *ignore_abfd)
  94 {
  95   return (char *)NULL;
  96 }
  97
  98 int
  99 DEFUN(_bfd_dummy_core_file_failing_signal,(ignore_abfd),
 100      bfd *ignore_abfd)
 101 {
 102   return 0;
 103 }
 104
 105 bfd_target *
 106 DEFUN(_bfd_dummy_target,(ignore_abfd),
 107      bfd *ignore_abfd)
 108 {
 109   return 0;
 110 }
 111 \f
 112 /** zalloc -- allocate and clear storage */
 113
 114
 115 #ifndef zalloc
 116 char *
 117 DEFUN(zalloc,(size),
 118       bfd_size_type size)
 119 {
 120   char *ptr = (char *) malloc ((int)size);
 121
 122   if ((ptr != NULL) && (size != 0))
 123    memset(ptr,0, size);
 124
 125   return ptr;
 126 }
 127 #endif
 128 \f
 129 /* Some IO code */
 130
 131
 132 /* Note that archive entries don't have streams; they share their parent's.
 133    This allows someone to play with the iostream behind bfd's back.
 134
 135    Also, note that the origin pointer points to the beginning of a file's
 136    contents (0 for non-archive elements).  For archive entries this is the
 137    first octet in the file, NOT the beginning of the archive header. */
 138
 139 static
 140 int DEFUN(real_read,(where, a,b, file),
 141           PTR where AND
 142           int a AND
 143           int b AND
 144           FILE *file)
 145 {
 146   return fread(where, a,b,file);
 147 }
 148 bfd_size_type
 149 DEFUN(bfd_read,(ptr, size, nitems, abfd),
 150       PTR ptr AND
 151       bfd_size_type size AND
 152       bfd_size_type nitems AND
 153       bfd *abfd)
 154 {
 155   return (bfd_size_type)real_read (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
 156 }
 157
 158 bfd_size_type
 159 DEFUN(bfd_write,(ptr, size, nitems, abfd),
 160       PTR ptr AND
 161       bfd_size_type size AND
 162       bfd_size_type nitems AND
 163       bfd *abfd)
 164 {
 165   return fwrite (ptr, 1, (int)(size*nitems), bfd_cache_lookup(abfd));
 166 }
 167
 168 int
 169 DEFUN(bfd_seek,(abfd, position, direction),
 170       bfd * CONST abfd AND
 171       CONST file_ptr position AND
 172       CONST int direction)
 173 {
 174         /* For the time being, a bfd may not seek to it's end.  The
 175            problem is that we don't easily have a way to recognize
 176            the end of an element in an archive. */
 177
 178         BFD_ASSERT(direction == SEEK_SET
 179                    || direction == SEEK_CUR);
 180
 181         if (direction == SEEK_SET && abfd->my_archive != NULL)
 182             {
 183                     /* This is a set within an archive, so we need to
 184                        add the base of the object within the archive */
 185                     return(fseek(bfd_cache_lookup(abfd),
 186                                  position + abfd->origin,
 187                                  direction));
 188             }
 189         else
 190             {
 191                     return(fseek(bfd_cache_lookup(abfd),  position, direction));
 192             }
 193 }
 194
 195 long
 196 DEFUN(bfd_tell,(abfd),
 197       bfd *abfd)
 198 {
 199         file_ptr ptr;
 200
 201         ptr = ftell (bfd_cache_lookup(abfd));
 202
 203         if (abfd->my_archive)
 204             ptr -= abfd->origin;
 205         return ptr;
 206 }
 207 \f
 208 /** Make a string table */
 209
 210 /* Add string to table pointed to by table, at location starting with free_ptr.
 211    resizes the table if necessary (if it's NULL, creates it, ignoring
 212    table_length).  Updates free_ptr, table, table_length */
 213
 214 boolean
 215 DEFUN(bfd_add_to_string_table,(table, new_string, table_length, free_ptr),
 216       char **table AND
 217       char *new_string AND
 218       char **free_ptr AND
 219       unsigned int *table_length)
 220 {
 221   size_t string_length = strlen (new_string) + 1; /* include null here */
 222   char *base = *table;
 223   size_t space_length = *table_length;
 224   unsigned int offset = (base ? *free_ptr - base : 0);
 225
 226   if (base == NULL) {
 227     /* Avoid a useless regrow if we can (but of course we still
 228        take it next time */
 229     space_length = (string_length < DEFAULT_STRING_SPACE_SIZE ?
 230                     DEFAULT_STRING_SPACE_SIZE : string_length+1);
 231     base = zalloc (space_length);
 232
 233     if (base == NULL) {
 234       bfd_error = no_memory;
 235       return false;
 236     }
 237   }
 238
 239   if ((size_t)(offset + string_length) >= space_length) {
 240     /* Make sure we will have enough space */
 241     while ((size_t)(offset + string_length) >= space_length)
 242       space_length += space_length/2; /* grow by 50% */
 243
 244     base = (char *) realloc (base, space_length);
 245     if (base == NULL) {
 246       bfd_error = no_memory;
 247       return false;
 248     }
 249
 250   }
 251
 252   memcpy (base + offset, new_string, string_length);
 253   *table = base;
 254   *table_length = space_length;
 255   *free_ptr = base + offset + string_length;
 256
 257   return true;
 258 }
 259 \f
 260 /** The do-it-yourself (byte) sex-change kit */
 261
 262 /* The middle letter e.g. get<b>short indicates Big or Little endian
 263    target machine.  It doesn't matter what the byte order of the host
 264    machine is; these routines work for either.  */
 265
 266 /* FIXME: Should these take a count argument?
 267    Answer (gnu@cygnus.com):  No, but perhaps they should be inline
 268                              functions in swap.h #ifdef __GNUC__.
 269                              Gprof them later and find out.  */
 270
 271 unsigned int
 272 DEFUN(_do_getb16,(addr),
 273       register bfd_byte *addr)
 274 {
 275         return (addr[0] << 8) | addr[1];
 276 }
 277
 278 unsigned int
 279 DEFUN(_do_getl16,(addr),
 280       register bfd_byte *addr)
 281 {
 282         return (addr[1] << 8) | addr[0];
 283 }
 284
 285 void
 286 DEFUN(_do_putb16,(data, addr),
 287       int data AND
 288       register bfd_byte *addr)
 289 {
 290         addr[0] = (bfd_byte)(data >> 8);
 291         addr[1] = (bfd_byte )data;
 292 }
 293
 294 void
 295 DEFUN(_do_putl16,(data, addr),
 296       int data AND
 297       register bfd_byte *addr)
 298 {
 299         addr[0] = (bfd_byte )data;
 300         addr[1] = (bfd_byte)(data >> 8);
 301 }
 302
 303 unsigned int
 304 DEFUN(_do_getb32,(addr),
 305       register bfd_byte *addr)
 306 {
 307         return ((((addr[0] << 8) | addr[1]) << 8) | addr[2]) << 8 | addr[3];
 308 }
 309
 310 unsigned int
 311 _do_getl32 (addr)
 312         register bfd_byte *addr;
 313 {
 314         return ((((addr[3] << 8) | addr[2]) << 8) | addr[1]) << 8 | addr[0];
 315 }
 316
 317 bfd_64_type
 318 DEFUN(_do_getb64,(addr),
 319       register bfd_byte *addr)
 320 {
 321 #ifdef HOST_64_BIT
 322   bfd_64_type low, high;
 323
 324   high= ((((((((addr[0]) << 8) |
 325               addr[1]) << 8) |
 326             addr[2]) << 8) |
 327           addr[3]) );
 328
 329   low = ((((((((addr[4]) << 8) |
 330               addr[5]) << 8) |
 331             addr[6]) << 8) |
 332           addr[7]));
 333
 334   return high << 32 | low;
 335 #else
 336   BFD_FAIL();
 337 #endif
 338
 339 }
 340
 341 bfd_64_type
 342 DEFUN(do_getl64,(addr),
 343       register bfd_byte *addr)
 344 {
 345   bfd_64_type low, high;
 346 #ifdef HOST_64_BIT
 347   high= (((((((addr[7] << 8) |
 348               addr[6]) << 8) |
 349             addr[5]) << 8) |
 350           addr[4]));
 351
 352   low = (((((((addr[3] << 8) |
 353               addr[2]) << 8) |
 354             addr[1]) << 8) |
 355           addr[0]) );
 356
 357   return high << 32 | low;
 358 #else
 359   BFD_FAIL();
 360 #endif
 361 }
 362
 363 void
 364 DEFUN(_do_putb32,(data, addr),
 365       unsigned long data AND
 366       register bfd_byte *addr)
 367 {
 368         addr[0] = (bfd_byte)(data >> 24);
 369         addr[1] = (bfd_byte)(data >> 16);
 370         addr[2] = (bfd_byte)(data >>  8);
 371         addr[3] = (bfd_byte)data;
 372 }
 373
 374 void
 375 DEFUN(_do_putl32,(data, addr),
 376       unsigned long data AND
 377       register bfd_byte *addr)
 378 {
 379         addr[0] = (bfd_byte)data;
 380         addr[1] = (bfd_byte)(data >>  8);
 381         addr[2] = (bfd_byte)(data >> 16);
 382         addr[3] = (bfd_byte)(data >> 24);
 383 }
 384 void
 385 DEFUN(_do_putb64,(data, addr),
 386         bfd_64_type data AND
 387         register bfd_byte *addr)
 388 {
 389 #ifdef HOST_64_BIT
 390   addr[0] = (bfd_byte)(data >> (7*8));
 391   addr[1] = (bfd_byte)(data >> (6*8));
 392   addr[2] = (bfd_byte)(data >> (5*8));
 393   addr[3] = (bfd_byte)(data >> (4*8));
 394   addr[4] = (bfd_byte)(data >> (3*8));
 395   addr[5] = (bfd_byte)(data >> (2*8));
 396   addr[6] = (bfd_byte)(data >> (1*8));
 397   addr[7] = (bfd_byte)(data >> (0*8));
 398 #else
 399   BFD_FAIL();
 400 #endif
 401
 402 }
 403
 404 void
 405 DEFUN(_do_putl64,(data, addr),
 406       bfd_64_type data AND
 407       register bfd_byte *addr)
 408 {
 409 #ifdef HOST_64_BIT
 410   addr[7] = (bfd_byte)(data >> (7*8));
 411   addr[6] = (bfd_byte)(data >> (6*8));
 412   addr[5] = (bfd_byte)(data >> (5*8));
 413   addr[4] = (bfd_byte)(data >> (4*8));
 414   addr[3] = (bfd_byte)(data >> (3*8));
 415   addr[2] = (bfd_byte)(data >> (2*8));
 416   addr[1] = (bfd_byte)(data >> (1*8));
 417   addr[0] = (bfd_byte)(data >> (0*8));
 418 #else
 419   BFD_FAIL();
 420 #endif
 421
 422 }
 423
 424 \f
 425 /* Default implementation */
 426
 427 boolean
 428 DEFUN(bfd_generic_get_section_contents, (abfd, section, location, offset, count),
 429       bfd *abfd AND
 430       sec_ptr section AND
 431       PTR location AND
 432       file_ptr offset AND
 433       bfd_size_type count)
 434 {
 435     if (count == 0)
 436         return true;
 437     if ((bfd_size_type)offset >= section->size
 438         || bfd_seek(abfd,(file_ptr)( section->filepos + offset), SEEK_SET) == -1
 439         || bfd_read(location, (bfd_size_type)1, count, abfd) != count)
 440         return (false); /* on error */
 441     return (true);
 442 }