bfd/targets.c

   1 /* Generic target-file-type support for the BFD library.
   2    Copyright (C) 1990-1991 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 /* $Id$ */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26
  27 /*
  28 SECTION
  29         Targets
  30
  31 DESCRIPTION
  32         Each port of BFD to a different machine requries the creation
  33         of a target back end. All the back end provides to the root
  34         part of BFD is a structure containing pointers to functions
  35         which perform certain low level operations on files. BFD
  36         translates the applications's requests through a pointer into
  37         calls to the back end routines.
  38
  39         When a file is opened with <<bfd_openr>>, its format and
  40         target are unknown. BFD uses various mechanisms to determine
  41         how to interpret the file. The operations performed are:
  42
  43         o First a BFD is created by calling the internal routine
  44         <<new_bfd>>, then <<bfd_find_target>> is called with the
  45         target string supplied to <<bfd_openr>> and the new BFD pointer.
  46
  47         o If a null target string was provided to <<bfd_find_target>>,
  48         it looks up the environment variable <<GNUTARGET>> and uses
  49         that as the target string.
  50
  51         o If the target string is still NULL, or the target string is
  52         <<default>>, then the first item in the target vector is used
  53         as the target type. @xref{bfd_target}.
  54
  55         o Otherwise, the elements in the target vector are inspected
  56         one by one, until a match on target name is found. When found,
  57         that is used.
  58
  59         o Otherwise the error <<invalid_target>> is returned to
  60         <<bfd_openr>>.
  61
  62         o <<bfd_openr>> attempts to open the file using
  63         <<bfd_open_file>>, and returns the BFD.
  64
  65         Once the BFD has been opened and the target selected, the file
  66         format may be determined. This is done by calling
  67         <<bfd_check_format>> on the BFD with a suggested format. The
  68         routine returns <<true>> when the application guesses right.
  69 @menu
  70 * bfd_target::
  71 @end menu
  72 */
  73
  74
  75 /*
  76
  77 @node bfd_target,  , Targets, Targets
  78
  79 SUBSECTION
  80         bfd_target
  81
  82 DESCRIPTION
  83         This structure contains everything that BFD knows about a
  84         target. It includes things like its byte order, name, what
  85         routines to call to do various operations, etc.
  86
  87         Every BFD points to a target structure with its <<xvec>>
  88         member.
  89
  90         Shortcut for declaring fields which are prototyped function
  91         pointers, while avoiding anguish on compilers that don't
  92         support protos.
  93
  94 .#define SDEF(ret, name, arglist) \
  95 .                PROTO(ret,(*name),arglist)
  96 .#define SDEF_FMT(ret, name, arglist) \
  97 .                PROTO(ret,(*name[bfd_type_end]),arglist)
  98
  99         These macros are used to dispatch to functions through the
 100         bfd_target vector. They are used in a number of macros further
 101         down in @file{bfd.h}, and are also used when calling various
 102         routines by hand inside the BFD implementation.  The "arglist"
 103         argument must be parenthesized; it contains all the arguments
 104         to the called function.
 105
 106
 107 .#define BFD_SEND(bfd, message, arglist) \
 108 .               ((*((bfd)->xvec->message)) arglist)
 109
 110         For operations which index on the BFD format
 111
 112 .#define BFD_SEND_FMT(bfd, message, arglist) \
 113 .            (((bfd)->xvec->message[(int)((bfd)->format)]) arglist)
 114
 115         This is the struct which defines the type of BFD this is.  The
 116         <<xvec>> member of the struct <<bfd>> itself points here.  Each
 117         module that implements access to a different target under BFD,
 118         defines one of these.
 119
 120
 121         FIXME, these names should be rationalised with the names of
 122         the entry points which call them. Too bad we can't have one
 123         macro to define them both!
 124
 125 .typedef struct bfd_target
 126 .{
 127
 128 identifies the kind of target, eg SunOS4, Ultrix, etc
 129
 130 .  char *name;
 131
 132 The "flavour" of a back end is a general indication about the contents
 133 of a file.
 134
 135 .  enum target_flavour {
 136 .    bfd_target_unknown_flavour,
 137 .    bfd_target_aout_flavour,
 138 .    bfd_target_coff_flavour,
 139 .    bfd_target_elf_flavour,
 140 .    bfd_target_ieee_flavour,
 141 .    bfd_target_oasys_flavour,
 142 .    bfd_target_srec_flavour} flavour;
 143
 144 The order of bytes within the data area of a file.
 145
 146 .  boolean byteorder_big_p;
 147
 148 The order of bytes within the header parts of a file.
 149
 150 .  boolean header_byteorder_big_p;
 151
 152 This is a mask of all the flags which an executable may have set -
 153 from the set <<NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.
 154
 155 .  flagword object_flags;
 156
 157 This is a mask of all the flags which a section may have set - from
 158 the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.
 159
 160 .  flagword section_flags;
 161
 162 The pad character for filenames within an archive header.
 163
 164 .  char ar_pad_char;
 165
 166 The maximum number of characters in an archive header.
 167
 168 . unsigned short ar_max_namelen;
 169
 170 The minimum alignment restriction for any section.
 171
 172 .  unsigned int align_power_min;
 173
 174 Entries for byte swapping for data. These are different to the other
 175 entry points, since they don't take BFD as first arg.  Certain other handlers
 176 could do the same.
 177
 178 .  SDEF (bfd_vma,      bfd_getx64, (bfd_byte *));
 179 .  SDEF (void,         bfd_putx64, (bfd_vma, bfd_byte *));
 180 .  SDEF (bfd_vma, bfd_getx32, (bfd_byte *));
 181 .  SDEF (void,         bfd_putx32, (bfd_vma, bfd_byte *));
 182 .  SDEF (bfd_vma, bfd_getx16, (bfd_byte *));
 183 .  SDEF (void,         bfd_putx16, (bfd_vma, bfd_byte *));
 184
 185 Byte swapping for the headers
 186
 187 .  SDEF (bfd_vma,   bfd_h_getx64, (bfd_byte *));
 188 .  SDEF (void,          bfd_h_putx64, (bfd_vma, bfd_byte *));
 189 .  SDEF (bfd_vma,  bfd_h_getx32, (bfd_byte *));
 190 .  SDEF (void,          bfd_h_putx32, (bfd_vma, bfd_byte *));
 191 .  SDEF (bfd_vma,  bfd_h_getx16, (bfd_byte *));
 192 .  SDEF (void,          bfd_h_putx16, (bfd_vma, bfd_byte *));
 193
 194 Format dependent routines, these turn into vectors of entry points
 195 within the target vector structure; one for each format to check.
 196
 197 Check the format of a file being read.  Return bfd_target * or zero.
 198
 199 .  SDEF_FMT (struct bfd_target *, _bfd_check_format, (bfd *));
 200
 201 Set the format of a file being written.
 202
 203 .  SDEF_FMT (boolean,            _bfd_set_format, (bfd *));
 204
 205 Write cached information into a file being written, at bfd_close.
 206
 207 .  SDEF_FMT (boolean,            _bfd_write_contents, (bfd *));
 208
 209 The following functions are defined in <<JUMP_TABLE>>. The idea is
 210 that the back end writer of <<foo>> names all the routines
 211 <<foo_>>@var{entry_point}, <<JUMP_TABLE>> will built the entries
 212 in this structure in the right order.
 213
 214 Core file entry points
 215
 216 .  SDEF (char *, _core_file_failing_command, (bfd *));
 217 .  SDEF (int,    _core_file_failing_signal, (bfd *));
 218 .  SDEF (boolean, _core_file_matches_executable_p, (bfd *, bfd *));
 219
 220 Archive entry points
 221
 222 . SDEF (boolean, _bfd_slurp_armap, (bfd *));
 223 . SDEF (boolean, _bfd_slurp_extended_name_table, (bfd *));
 224 . SDEF (void,   _bfd_truncate_arname, (bfd *, CONST char *, char *));
 225 . SDEF (boolean, write_armap, (bfd *arch,
 226 .                              unsigned int elength,
 227 .                              struct orl *map,
 228 .                              unsigned int orl_count,
 229 .                              int stridx));
 230
 231 Standard stuff.
 232
 233 .  SDEF (boolean, _close_and_cleanup, (bfd *));
 234 .  SDEF (boolean, _bfd_set_section_contents, (bfd *, sec_ptr, PTR,
 235 .                                            file_ptr, bfd_size_type));
 236 .  SDEF (boolean, _bfd_get_section_contents, (bfd *, sec_ptr, PTR,
 237 .                                            file_ptr, bfd_size_type));
 238 .  SDEF (boolean, _new_section_hook, (bfd *, sec_ptr));
 239
 240 Symbols and reloctions
 241
 242 .  SDEF (unsigned int, _get_symtab_upper_bound, (bfd *));
 243 .  SDEF (unsigned int, _bfd_canonicalize_symtab,
 244 .           (bfd *, struct symbol_cache_entry **));
 245 .  SDEF (unsigned int, _get_reloc_upper_bound, (bfd *, sec_ptr));
 246 .  SDEF (unsigned int, _bfd_canonicalize_reloc, (bfd *, sec_ptr, arelent **,
 247 .                                               struct symbol_cache_entry**));
 248 .  SDEF (struct symbol_cache_entry  *, _bfd_make_empty_symbol, (bfd *));
 249 .  SDEF (void,     _bfd_print_symbol, (bfd *, PTR, struct symbol_cache_entry  *,
 250 .                                      bfd_print_symbol_type));
 251 .#define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e))
 252 .  SDEF (alent *,   _get_lineno, (bfd *, struct symbol_cache_entry  *));
 253 .
 254 .  SDEF (boolean,   _bfd_set_arch_mach, (bfd *, enum bfd_architecture,
 255 .                                       unsigned long));
 256 .
 257 .  SDEF (bfd *,  openr_next_archived_file, (bfd *arch, bfd *prev));
 258 .  SDEF (boolean, _bfd_find_nearest_line,
 259 .        (bfd *abfd, struct sec  *section,
 260 .         struct symbol_cache_entry  **symbols,bfd_vma offset,
 261 .        CONST char **file, CONST char **func, unsigned int *line));
 262 .  SDEF (int,    _bfd_stat_arch_elt, (bfd *, struct stat *));
 263 .
 264 .  SDEF (int,    _bfd_sizeof_headers, (bfd *, boolean));
 265 .
 266 .  SDEF (void, _bfd_debug_info_start, (bfd *));
 267 .  SDEF (void, _bfd_debug_info_end, (bfd *));
 268 .  SDEF (void, _bfd_debug_info_accumulate, (bfd *, struct sec  *));
 269
 270 Special entry points for gdb to swap in coff symbol table parts
 271
 272 .  SDEF(void, _bfd_coff_swap_aux_in,(
 273 .       bfd            *abfd ,
 274 .       PTR             ext,
 275 .       int             type,
 276 .       int             class ,
 277 .       PTR             in));
 278 .
 279 .  SDEF(void, _bfd_coff_swap_sym_in,(
 280 .       bfd            *abfd ,
 281 .       PTR             ext,
 282 .       PTR             in));
 283 .
 284 .  SDEF(void, _bfd_coff_swap_lineno_in,  (
 285 .       bfd            *abfd,
 286 .       PTR            ext,
 287 .       PTR             in));
 288 .
 289
 290 Special entry points for gas to swap coff parts
 291
 292 . SDEF(unsigned int, _bfd_coff_swap_aux_out,(
 293 .       bfd     *abfd,
 294 .       PTR     in,
 295 .       int     type,
 296 .       int     class,
 297 .       PTR     ext));
 298 .
 299 . SDEF(unsigned int, _bfd_coff_swap_sym_out,(
 300 .      bfd      *abfd,
 301 .      PTR      in,
 302 .      PTR      ext));
 303 .
 304 . SDEF(unsigned int, _bfd_coff_swap_lineno_out,(
 305 .       bfd     *abfd,
 306 .       PTR     in,
 307 .       PTR     ext));
 308 .
 309 . SDEF(unsigned int, _bfd_coff_swap_reloc_out,(
 310 .       bfd     *abfd,
 311 .       PTR     src,
 312 .       PTR     dst));
 313 .
 314 . SDEF(unsigned int, _bfd_coff_swap_filehdr_out,(
 315 .       bfd     *abfd,
 316 .       PTR     in,
 317 .       PTR     out));
 318 .
 319 . SDEF(unsigned int, _bfd_coff_swap_aouthdr_out,(
 320 .       bfd     *abfd,
 321 .       PTR     in,
 322 .       PTR     out));
 323 .
 324 . SDEF(unsigned int, _bfd_coff_swap_scnhdr_out,(
 325 .       bfd     *abfd,
 326 .       PTR     in,
 327 .       PTR     out));
 328 .
 329 .} bfd_target;
 330
 331 */
 332
 333 /* The default is to define a target_vector containing just the
 334    DEFAULT_TARGET.  (This is to save space in the executables.)
 335    You can override this by giving an explicit target_vector using
 336    the SELECT_VECTOR macro.
 337    Or define ALL_TARGETS macro to get all of the available targets. */
 338
 339
 340 #if MINIMIZE && defined(DEFAULT_VECTOR) && !defined(SELECT_VECS)
 341 #ifdef TRAD_CORE
 342 #define SELECT_VECS &DEFAULT_VECTOR,&trad_core_vec
 343 #else
 344 #define SELECT_VECS &DEFAULT_VECTOR
 345 #endif
 346 #endif
 347
 348 extern bfd_target ecoff_little_vec;
 349 extern bfd_target ecoff_big_vec;
 350 extern bfd_target sunos_big_vec;
 351 extern bfd_target demo_64_vec;
 352 extern bfd_target srec_vec;
 353 extern bfd_target b_out_vec_little_host;
 354 extern bfd_target b_out_vec_big_host;
 355 extern bfd_target icoff_little_vec;
 356 extern bfd_target icoff_big_vec;
 357 extern bfd_target elf_little_vec;
 358 extern bfd_target elf_big_vec;
 359 extern bfd_target ieee_vec;
 360 extern bfd_target oasys_vec;
 361 extern bfd_target m88kbcs_vec;
 362 extern bfd_target m68kcoff_vec;
 363 extern bfd_target i386coff_vec;
 364 extern bfd_target i386aout_vec;
 365 extern bfd_target a29kcoff_big_vec;
 366 extern bfd_target trad_core_vec;
 367 extern bfd_target rs6000coff_vec;
 368 extern bfd_target h8300coff_vec;
 369
 370 #ifdef DEFAULT_VECTOR
 371 extern bfd_target DEFAULT_VECTOR;
 372 #endif
 373
 374 #ifdef SELECT_VECS
 375
 376 bfd_target *target_vector[] = {
 377 SELECT_VECS,
 378 0
 379
 380 };
 381 #else
 382
 383 #ifdef GNU960
 384 #define ICOFF_LITTLE_VEC        icoff_little_vec
 385 #define ICOFF_BIG_VEC           icoff_big_vec
 386 #define B_OUT_VEC_LITTLE_HOST   b_out_vec_little_host
 387 #define B_OUT_VEC_BIG_HOST      b_out_vec_big_host
 388 #endif /* GNU960 */
 389
 390 #ifndef RESTRICTED
 391 #define ECOFF_LITTLE_VEC        ecoff_little_vec
 392 #define ECOFF_BIG_VEC           ecoff_big_vec
 393 #define ICOFF_LITTLE_VEC        icoff_little_vec
 394 #define ICOFF_BIG_VEC           icoff_big_vec
 395 #define ELF_LITTLE_VEC          elf_little_vec
 396 #define ELF_BIG_VEC             elf_big_vec
 397 #define ZB_OUT_VEC_LITTLE_HOST  b_out_vec_little_host
 398 #define ZB_OUT_VEC_BIG_HOST     b_out_vec_big_host
 399 #define SUNOS_VEC_BIG_HOST      sunos_big_vec
 400 #define DEMO_64_VEC             demo_64_vec
 401
 402 /* We have no oasys tools anymore, so we can't test any of this
 403    anymore. If you want to test the stuff yourself, go ahead...
 404    steve@cygnus.com */
 405 #if 0
 406 #define OASYS_VEC               oasys_vec
 407 #endif
 408
 409 #define IEEE_VEC                ieee_vec
 410 #define M88KBCS_VEC            m88kbcs_vec
 411 #define SREC_VEC                srec_vec
 412 #define M68KCOFF_VEC            m68kcoff_vec
 413 #define I386COFF_VEC            i386coff_vec
 414 #define I386AOUT_VEC            i386aout_vec
 415 #define A29KCOFF_BIG_VEC        a29kcoff_big_vec
 416 #define RS6000COFF_VEC          rs6000coff_vec
 417 #define H8300COFF_VEC           h8300coff_vec
 418 #endif
 419
 420 bfd_target *target_vector[] = {
 421
 422 #ifdef DEFAULT_VECTOR
 423         &DEFAULT_VECTOR,
 424 #endif
 425
 426 #ifdef  I386COFF_VEC
 427         &I386COFF_VEC,
 428 #endif
 429
 430 #ifdef  I386AOUT_VEC
 431         &I386AOUT_VEC,
 432 #endif
 433
 434 #ifdef ECOFF_LITTLE_VEC
 435         &ECOFF_LITTLE_VEC,
 436 #endif
 437
 438 #ifdef ECOFF_BIG_VEC
 439         &ECOFF_BIG_VEC,
 440 #endif
 441
 442 #ifdef IEEE_VEC
 443         &IEEE_VEC,
 444 #endif
 445
 446 #ifdef OASYS_VEC
 447         &OASYS_VEC,
 448 #endif
 449
 450 #ifdef SUNOS_VEC_BIG_HOST
 451         &SUNOS_VEC_BIG_HOST,
 452 #endif
 453
 454 #ifdef HOST_64_BIT
 455 #ifdef DEMO_64_VEC
 456         &DEMO_64_VEC,
 457 #endif
 458 #endif
 459
 460 #ifdef H300COFF_VEC
 461         &h8300coff_vec,
 462 #endif
 463 #ifdef M88KBCS_VEC
 464         &M88KBCS_VEC,
 465 #endif
 466
 467 #ifdef SREC_VEC
 468         &SREC_VEC,
 469 #endif
 470
 471 #ifdef ICOFF_LITTLE_VEC
 472         &ICOFF_LITTLE_VEC,
 473 #endif
 474
 475 #ifdef ICOFF_BIG_VEC
 476         &ICOFF_BIG_VEC,
 477 #endif
 478
 479 #ifdef ELF_LITTLE_VEC
 480         &ELF_LITTLE_VEC,
 481 #endif
 482
 483 #ifdef ELF_BIG_VEC
 484         &ELF_BIG_VEC,
 485 #endif
 486
 487 #ifdef B_OUT_VEC_LITTLE_HOST
 488         &B_OUT_VEC_LITTLE_HOST,
 489 #endif
 490
 491 #ifdef B_OUT_VEC_BIG_HOST
 492         &B_OUT_VEC_BIG_HOST,
 493 #endif
 494
 495 #ifdef  M68KCOFF_VEC
 496         &M68KCOFF_VEC,
 497 #endif
 498
 499 #ifdef  A29KCOFF_BIG_VEC
 500         &A29KCOFF_BIG_VEC,
 501 #endif
 502
 503 #ifdef  TRAD_CORE
 504         &trad_core_vec,
 505 #endif
 506
 507 #ifdef  RS6000COFF_VEC
 508         &RS6000COFF_VEC,
 509 #endif
 510
 511         NULL, /* end of list marker */
 512 };
 513
 514 #endif
 515
 516 /* default_vector[0] contains either the address of the default vector,
 517    if there is one, or zero if there isn't.  */
 518
 519 bfd_target *default_vector[] = {
 520 #ifdef DEFAULT_VECTOR
 521         &DEFAULT_VECTOR,
 522 #endif
 523         0,
 524 };
 525
 526
 527
 528
 529 /*
 530 FUNCTION
 531         bfd_find_target
 532
 533 DESCRIPTION
 534         Returns a pointer to the transfer vector for the object target
 535         named target_name.  If target_name is NULL, chooses the one in
 536         the environment variable GNUTARGET; if that is null or not
 537         defined thenthe first entry in the target list is chosen.
 538         Passing in the string "default" or setting the environment
 539         variable to "default" will cause the first entry in the target
 540         list to be returned, and "target_defaulted" will be set in the
 541         BFD.  This causes <<bfd_check_format>> to loop over all the
 542         targets to find the one that matches the file being read.
 543
 544 SYNOPSIS
 545         bfd_target *bfd_find_target(CONST char *, bfd *);
 546 */
 547
 548 bfd_target *
 549 DEFUN(bfd_find_target,(target_name, abfd),
 550       CONST char *target_name AND
 551       bfd *abfd)
 552 {
 553   bfd_target **target;
 554   extern char *getenv ();
 555   CONST char *targname = (target_name ? target_name :
 556                           (CONST char *) getenv ("GNUTARGET"));
 557
 558   /* This is safe; the vector cannot be null */
 559   if (targname == NULL || !strcmp (targname, "default")) {
 560     abfd->target_defaulted = true;
 561     return abfd->xvec = target_vector[0];
 562   }
 563
 564   abfd->target_defaulted = false;
 565
 566   for (target = &target_vector[0]; *target != NULL; target++) {
 567     if (!strcmp (targname, (*target)->name))
 568       return abfd->xvec = *target;
 569   }
 570
 571   bfd_error = invalid_target;
 572   return NULL;
 573 }
 574
 575
 576 /*
 577 FUNCTION
 578         bfd_target_list
 579
 580 DESCRIPTION
 581         This function returns a freshly malloced NULL-terminated
 582         vector of the names of all the valid BFD targets. Do not
 583         modify the names
 584
 585 SYNOPSIS
 586         CONST char **bfd_target_list();
 587
 588 */
 589
 590 CONST char **
 591 DEFUN_VOID(bfd_target_list)
 592 {
 593   int vec_length= 0;
 594   bfd_target **target;
 595   CONST  char **name_list, **name_ptr;
 596
 597   for (target = &target_vector[0]; *target != NULL; target++)
 598     vec_length++;
 599
 600   name_ptr =
 601     name_list = (CONST char **) zalloc ((vec_length + 1) * sizeof (char **));
 602
 603   if (name_list == NULL) {
 604     bfd_error = no_memory;
 605     return NULL;
 606   }
 607
 608   for (target = &target_vector[0]; *target != NULL; target++)
 609     *(name_ptr++) = (*target)->name;
 610
 611   return name_list;
 612 }