| 1 | /* Generic target-file-type support for the BFD library. |
| 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 | Targets |
| 28 | |
| 29 | DESCRIPTION |
| 30 | Each port of BFD to a different machine requries the creation |
| 31 | of a target back end. All the back end provides to the root |
| 32 | part of BFD is a structure containing pointers to functions |
| 33 | which perform certain low level operations on files. BFD |
| 34 | translates the applications's requests through a pointer into |
| 35 | calls to the back end routines. |
| 36 | |
| 37 | When a file is opened with <<bfd_openr>>, its format and |
| 38 | target are unknown. BFD uses various mechanisms to determine |
| 39 | how to interpret the file. The operations performed are: |
| 40 | |
| 41 | o First a BFD is created by calling the internal routine |
| 42 | <<new_bfd>>, then <<bfd_find_target>> is called with the |
| 43 | target string supplied to <<bfd_openr>> and the new BFD pointer. |
| 44 | |
| 45 | o If a null target string was provided to <<bfd_find_target>>, |
| 46 | it looks up the environment variable <<GNUTARGET>> and uses |
| 47 | that as the target string. |
| 48 | |
| 49 | o If the target string is still NULL, or the target string is |
| 50 | <<default>>, then the first item in the target vector is used |
| 51 | as the target type, and <<target_defaulted>> is set to |
| 52 | cause <<bfd_check_format>> to loop through all the targets. |
| 53 | @xref{bfd_target}. @xref{Formats}. |
| 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. |
| 68 | If <<target_defaulted>> has been set, each possible target |
| 69 | type is tried to see if it recognizes the specified format. The |
| 70 | routine returns <<true>> when the application guesses right. |
| 71 | @menu |
| 72 | @* bfd_target:: |
| 73 | @end menu |
| 74 | */ |
| 75 | |
| 76 | |
| 77 | /* |
| 78 | |
| 79 | INODE |
| 80 | bfd_target, , Targets, Targets |
| 81 | DOCDD |
| 82 | SUBSECTION |
| 83 | bfd_target |
| 84 | |
| 85 | DESCRIPTION |
| 86 | This structure contains everything that BFD knows about a |
| 87 | target. It includes things like its byte order, name, what |
| 88 | routines to call to do various operations, etc. |
| 89 | |
| 90 | Every BFD points to a target structure with its <<xvec>> |
| 91 | member. |
| 92 | |
| 93 | These macros are used to dispatch to functions through the |
| 94 | bfd_target vector. They are used in a number of macros further |
| 95 | down in @file{bfd.h}, and are also used when calling various |
| 96 | routines by hand inside the BFD implementation. The "arglist" |
| 97 | argument must be parenthesized; it contains all the arguments |
| 98 | to the called function. |
| 99 | |
| 100 | They make the documentation (more) unpleasant to read, so if |
| 101 | someone wants to fix this and not break the above, please do. |
| 102 | |
| 103 | .#define BFD_SEND(bfd, message, arglist) \ |
| 104 | . ((*((bfd)->xvec->message)) arglist) |
| 105 | |
| 106 | For operations which index on the BFD format |
| 107 | |
| 108 | .#define BFD_SEND_FMT(bfd, message, arglist) \ |
| 109 | . (((bfd)->xvec->message[(int)((bfd)->format)]) arglist) |
| 110 | |
| 111 | This is the struct which defines the type of BFD this is. The |
| 112 | <<xvec>> member of the struct <<bfd>> itself points here. Each |
| 113 | module that implements access to a different target under BFD, |
| 114 | defines one of these. |
| 115 | |
| 116 | |
| 117 | FIXME, these names should be rationalised with the names of |
| 118 | the entry points which call them. Too bad we can't have one |
| 119 | macro to define them both! |
| 120 | |
| 121 | .typedef struct bfd_target |
| 122 | .{ |
| 123 | |
| 124 | Identifies the kind of target, eg SunOS4, Ultrix, etc. |
| 125 | |
| 126 | . char *name; |
| 127 | |
| 128 | The "flavour" of a back end is a general indication about the contents |
| 129 | of a file. |
| 130 | |
| 131 | . enum target_flavour { |
| 132 | . bfd_target_unknown_flavour, |
| 133 | . bfd_target_aout_flavour, |
| 134 | . bfd_target_coff_flavour, |
| 135 | . bfd_target_elf_flavour, |
| 136 | . bfd_target_ieee_flavour, |
| 137 | . bfd_target_oasys_flavour, |
| 138 | . bfd_target_tekhex_flavour, |
| 139 | . bfd_target_srec_flavour, |
| 140 | . bfd_target_hppa_flavour} flavour; |
| 141 | |
| 142 | The order of bytes within the data area of a file. |
| 143 | |
| 144 | . boolean byteorder_big_p; |
| 145 | |
| 146 | The order of bytes within the header parts of a file. |
| 147 | |
| 148 | . boolean header_byteorder_big_p; |
| 149 | |
| 150 | This is a mask of all the flags which an executable may have set - |
| 151 | from the set <<NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>. |
| 152 | |
| 153 | . flagword object_flags; |
| 154 | |
| 155 | This is a mask of all the flags which a section may have set - from |
| 156 | the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>. |
| 157 | |
| 158 | . flagword section_flags; |
| 159 | |
| 160 | The character normally found at the front of a symbol |
| 161 | (if any), perhaps _. |
| 162 | |
| 163 | . char symbol_leading_char; |
| 164 | |
| 165 | The pad character for filenames within an archive header. |
| 166 | |
| 167 | . char ar_pad_char; |
| 168 | |
| 169 | The maximum number of characters in an archive header. |
| 170 | |
| 171 | . unsigned short ar_max_namelen; |
| 172 | |
| 173 | The minimum alignment restriction for any section. |
| 174 | |
| 175 | . unsigned int align_power_min; |
| 176 | |
| 177 | Entries for byte swapping for data. These are different to the other |
| 178 | entry points, since they don't take BFD as first arg. Certain other handlers |
| 179 | could do the same. |
| 180 | |
| 181 | . bfd_vma (*bfd_getx64) PARAMS ((bfd_byte *)); |
| 182 | . void (*bfd_putx64) PARAMS ((bfd_vma, bfd_byte *)); |
| 183 | . bfd_vma (*bfd_getx32) PARAMS ((bfd_byte *)); |
| 184 | . void (*bfd_putx32) PARAMS ((bfd_vma, bfd_byte *)); |
| 185 | . bfd_vma (*bfd_getx16) PARAMS ((bfd_byte *)); |
| 186 | . void (*bfd_putx16) PARAMS ((bfd_vma, bfd_byte *)); |
| 187 | |
| 188 | Byte swapping for the headers |
| 189 | |
| 190 | . bfd_vma (*bfd_h_getx64) PARAMS ((bfd_byte *)); |
| 191 | . void (*bfd_h_putx64) PARAMS ((bfd_vma, bfd_byte *)); |
| 192 | . bfd_vma (*bfd_h_getx32) PARAMS ((bfd_byte *)); |
| 193 | . void (*bfd_h_putx32) PARAMS ((bfd_vma, bfd_byte *)); |
| 194 | . bfd_vma (*bfd_h_getx16) PARAMS ((bfd_byte *)); |
| 195 | . void (*bfd_h_putx16) PARAMS ((bfd_vma, bfd_byte *)); |
| 196 | |
| 197 | Format dependent routines: these are vectors of entry points |
| 198 | within the target vector structure, one for each format to check. |
| 199 | |
| 200 | Check the format of a file being read. Return bfd_target * or zero. |
| 201 | |
| 202 | . struct bfd_target * (*_bfd_check_format[bfd_type_end]) PARAMS ((bfd *)); |
| 203 | |
| 204 | Set the format of a file being written. |
| 205 | |
| 206 | . boolean (*_bfd_set_format[bfd_type_end]) PARAMS ((bfd *)); |
| 207 | |
| 208 | Write cached information into a file being written, at bfd_close. |
| 209 | |
| 210 | . boolean (*_bfd_write_contents[bfd_type_end]) PARAMS ((bfd *)); |
| 211 | |
| 212 | The following functions are defined in <<JUMP_TABLE>>. The idea is |
| 213 | that the back end writer of <<foo>> names all the routines |
| 214 | <<foo_>>@var{entry_point}, <<JUMP_TABLE>> will built the entries |
| 215 | in this structure in the right order. |
| 216 | |
| 217 | Core file entry points |
| 218 | |
| 219 | . char * (*_core_file_failing_command) PARAMS ((bfd *)); |
| 220 | . int (*_core_file_failing_signal) PARAMS ((bfd *)); |
| 221 | . boolean (*_core_file_matches_executable_p) PARAMS ((bfd *, bfd *)); |
| 222 | |
| 223 | Archive entry points |
| 224 | |
| 225 | . boolean (*_bfd_slurp_armap) PARAMS ((bfd *)); |
| 226 | . boolean (*_bfd_slurp_extended_name_table) PARAMS ((bfd *)); |
| 227 | . void (*_bfd_truncate_arname) PARAMS ((bfd *, CONST char *, char *)); |
| 228 | . boolean (*write_armap) PARAMS ((bfd *arch, |
| 229 | . unsigned int elength, |
| 230 | . struct orl *map, |
| 231 | . unsigned int orl_count, |
| 232 | . int stridx)); |
| 233 | |
| 234 | Standard stuff. |
| 235 | |
| 236 | . boolean (*_close_and_cleanup) PARAMS ((bfd *)); |
| 237 | . boolean (*_bfd_set_section_contents) PARAMS ((bfd *, sec_ptr, PTR, |
| 238 | . file_ptr, bfd_size_type)); |
| 239 | . boolean (*_bfd_get_section_contents) PARAMS ((bfd *, sec_ptr, PTR, |
| 240 | . file_ptr, bfd_size_type)); |
| 241 | . boolean (*_new_section_hook) PARAMS ((bfd *, sec_ptr)); |
| 242 | |
| 243 | Symbols and relocations |
| 244 | |
| 245 | . unsigned int (*_get_symtab_upper_bound) PARAMS ((bfd *)); |
| 246 | . unsigned int (*_bfd_canonicalize_symtab) PARAMS ((bfd *, |
| 247 | . struct symbol_cache_entry **)); |
| 248 | . unsigned int (*_get_reloc_upper_bound) PARAMS ((bfd *, sec_ptr)); |
| 249 | . unsigned int (*_bfd_canonicalize_reloc) PARAMS ((bfd *, sec_ptr, arelent **, |
| 250 | . struct symbol_cache_entry **)); |
| 251 | . struct symbol_cache_entry * |
| 252 | . (*_bfd_make_empty_symbol) PARAMS ((bfd *)); |
| 253 | . void (*_bfd_print_symbol) PARAMS ((bfd *, PTR, |
| 254 | . struct symbol_cache_entry *, |
| 255 | . bfd_print_symbol_type)); |
| 256 | .#define bfd_print_symbol(b,p,s,e) BFD_SEND(b, _bfd_print_symbol, (b,p,s,e)) |
| 257 | |
| 258 | . alent * (*_get_lineno) PARAMS ((bfd *, struct symbol_cache_entry *)); |
| 259 | . |
| 260 | . boolean (*_bfd_set_arch_mach) PARAMS ((bfd *, enum bfd_architecture, |
| 261 | . unsigned long)); |
| 262 | . |
| 263 | . bfd * (*openr_next_archived_file) PARAMS ((bfd *arch, bfd *prev)); |
| 264 | . |
| 265 | . boolean (*_bfd_find_nearest_line) PARAMS ((bfd *abfd, |
| 266 | . struct sec *section, struct symbol_cache_entry **symbols, |
| 267 | . bfd_vma offset, CONST char **file, CONST char **func, |
| 268 | . unsigned int *line)); |
| 269 | . |
| 270 | . int (*_bfd_stat_arch_elt) PARAMS ((bfd *, struct stat *)); |
| 271 | . |
| 272 | . int (*_bfd_sizeof_headers) PARAMS ((bfd *, boolean)); |
| 273 | . |
| 274 | . void (*_bfd_debug_info_start) PARAMS ((bfd *)); |
| 275 | . void (*_bfd_debug_info_end) PARAMS ((bfd *)); |
| 276 | . void (*_bfd_debug_info_accumulate) PARAMS ((bfd *, struct sec *)); |
| 277 | . |
| 278 | . bfd_byte * (*_bfd_get_relocated_section_contents) PARAMS ((bfd *, |
| 279 | . struct bfd_seclet *, bfd_byte *data)); |
| 280 | . |
| 281 | . boolean (*_bfd_relax_section) PARAMS ((bfd *, struct sec *, |
| 282 | . struct symbol_cache_entry **)); |
| 283 | |
| 284 | . {* See documentation on reloc types. *} |
| 285 | . CONST struct reloc_howto_struct * |
| 286 | . (*reloc_type_lookup) PARAMS ((bfd *abfd, |
| 287 | . bfd_reloc_code_real_type code)); |
| 288 | . |
| 289 | . {* Back-door to allow format-aware applications to create debug symbols |
| 290 | . while using BFD for everything else. Currently used by the assembler |
| 291 | . when creating COFF files. *} |
| 292 | . asymbol * (*_bfd_make_debug_symbol) PARAMS (( |
| 293 | . bfd *abfd, |
| 294 | . void *ptr, |
| 295 | . unsigned long size)); |
| 296 | |
| 297 | Data for use by back-end routines; e.g., for a.out, includes whether |
| 298 | this particular target maps ZMAGIC files contiguously or with text and |
| 299 | data separated. Could perhaps also be used to eliminate some of the |
| 300 | above COFF-specific fields. |
| 301 | |
| 302 | . PTR backend_data; |
| 303 | .} bfd_target; |
| 304 | |
| 305 | */ |
| 306 | |
| 307 | /* The default is to define a target_vector containing all the targets. |
| 308 | By setting MINIMIZE=1 on the "make" command line, the user can change this |
| 309 | to a vector containing just DEFAULT_VECTOR and any required |
| 310 | traditional-core-file handler. (This is to save space in the executables.) |
| 311 | The config files can also override the default large vector by giving an |
| 312 | explicit SELECT_VECS macro. */ |
| 313 | |
| 314 | #if MINIMIZE && defined(DEFAULT_VECTOR) && !defined(SELECT_VECS) |
| 315 | #ifdef TRAD_CORE |
| 316 | #define SELECT_VECS &DEFAULT_VECTOR,&trad_core_vec |
| 317 | #else |
| 318 | #ifdef SCO_CORE |
| 319 | #define SELECT_VECS &DEFAULT_VECTOR,&sco_core_vec |
| 320 | #else |
| 321 | #ifdef AIX386_CORE |
| 322 | #define SELECT_VECS &DEFAULT_VECTOR,&aix386_core_vec |
| 323 | #else |
| 324 | #define SELECT_VECS &DEFAULT_VECTOR |
| 325 | #endif |
| 326 | #endif |
| 327 | #endif |
| 328 | #endif |
| 329 | |
| 330 | /* All known xvecs. They are listed a second time below, since |
| 331 | we can't intermix extern's and initializers. */ |
| 332 | extern bfd_target ecoff_little_vec; |
| 333 | extern bfd_target ecoff_big_vec; |
| 334 | extern bfd_target sunos_big_vec; |
| 335 | extern bfd_target demo_64_vec; |
| 336 | extern bfd_target srec_vec; |
| 337 | extern bfd_target tekhex_vec; |
| 338 | extern bfd_target a_out_adobe_vec; |
| 339 | extern bfd_target b_out_vec_little_host; |
| 340 | extern bfd_target b_out_vec_big_host; |
| 341 | extern bfd_target icoff_little_vec; |
| 342 | extern bfd_target icoff_big_vec; |
| 343 | extern bfd_target elf_little_vec; |
| 344 | extern bfd_target elf_big_vec; |
| 345 | extern bfd_target ieee_vec; |
| 346 | extern bfd_target oasys_vec; |
| 347 | extern bfd_target m88kbcs_vec; |
| 348 | extern bfd_target m68kcoff_vec; |
| 349 | extern bfd_target i386coff_vec; |
| 350 | extern bfd_target i386aout_vec; |
| 351 | extern bfd_target i386linux_vec; |
| 352 | extern bfd_target a29kcoff_big_vec; |
| 353 | extern bfd_target trad_core_vec; |
| 354 | extern bfd_target sco_core_vec; |
| 355 | extern bfd_target aix386_core_vec; |
| 356 | extern bfd_target rs6000coff_vec; |
| 357 | extern bfd_target h8300coff_vec; |
| 358 | extern bfd_target z8kcoff_vec; |
| 359 | extern bfd_target we32kcoff_vec; |
| 360 | #ifdef hp9000s800 |
| 361 | extern bfd_target hppa_vec; |
| 362 | #endif |
| 363 | |
| 364 | #ifdef DEFAULT_VECTOR |
| 365 | extern bfd_target DEFAULT_VECTOR; |
| 366 | #endif |
| 367 | |
| 368 | #ifdef SELECT_VECS |
| 369 | |
| 370 | bfd_target *target_vector[] = { |
| 371 | SELECT_VECS, |
| 372 | 0 |
| 373 | }; |
| 374 | |
| 375 | #else |
| 376 | |
| 377 | bfd_target *target_vector[] = { |
| 378 | |
| 379 | #ifdef DEFAULT_VECTOR |
| 380 | &DEFAULT_VECTOR, |
| 381 | #endif |
| 382 | |
| 383 | &i386coff_vec, |
| 384 | &i386aout_vec, |
| 385 | &ecoff_little_vec, |
| 386 | &ecoff_big_vec, |
| 387 | &ieee_vec, |
| 388 | #if 0 |
| 389 | /* We have no oasys tools anymore, so we can't test any of this |
| 390 | anymore. If you want to test the stuff yourself, go ahead... |
| 391 | steve@cygnus.com |
| 392 | Worse, since there is no magic number for archives, there |
| 393 | can annoying target mis-matches. */ |
| 394 | &oasys_vec, |
| 395 | #endif |
| 396 | &sunos_big_vec, |
| 397 | #ifdef HOST_64_BIT |
| 398 | &demo_64_vec, /* Only compiled if host has long-long support */ |
| 399 | #endif |
| 400 | &h8300coff_vec, |
| 401 | &z8kcoff_vec, |
| 402 | &m88kbcs_vec, |
| 403 | &srec_vec, |
| 404 | /* &tekhex_vec,*/ |
| 405 | &icoff_little_vec, |
| 406 | &icoff_big_vec, |
| 407 | &elf_little_vec, |
| 408 | &elf_big_vec, |
| 409 | &a_out_adobe_vec, |
| 410 | &b_out_vec_little_host, |
| 411 | &b_out_vec_big_host, |
| 412 | &m68kcoff_vec, |
| 413 | &a29kcoff_big_vec, |
| 414 | &rs6000coff_vec, |
| 415 | #ifdef hp9000s800 |
| 416 | &hppa_vec, |
| 417 | #endif |
| 418 | &we32kcoff_vec, |
| 419 | |
| 420 | #ifdef TRAD_CORE |
| 421 | &trad_core_vec, |
| 422 | #endif |
| 423 | #ifdef SCO_CORE |
| 424 | &sco_core_vec, |
| 425 | #endif |
| 426 | #ifdef AIX386_CORE |
| 427 | &aix386_core_vec, |
| 428 | #endif |
| 429 | NULL, /* end of list marker */ |
| 430 | }; |
| 431 | |
| 432 | #endif |
| 433 | |
| 434 | /* default_vector[0] contains either the address of the default vector, |
| 435 | if there is one, or zero if there isn't. */ |
| 436 | |
| 437 | bfd_target *default_vector[] = { |
| 438 | #ifdef DEFAULT_VECTOR |
| 439 | &DEFAULT_VECTOR, |
| 440 | #endif |
| 441 | 0, |
| 442 | }; |
| 443 | |
| 444 | |
| 445 | |
| 446 | |
| 447 | /* |
| 448 | FUNCTION |
| 449 | bfd_find_target |
| 450 | |
| 451 | DESCRIPTION |
| 452 | Returns a pointer to the transfer vector for the object target |
| 453 | named target_name. If target_name is NULL, chooses the one in |
| 454 | the environment variable GNUTARGET; if that is null or not |
| 455 | defined thenthe first entry in the target list is chosen. |
| 456 | Passing in the string "default" or setting the environment |
| 457 | variable to "default" will cause the first entry in the target |
| 458 | list to be returned, and "target_defaulted" will be set in the |
| 459 | BFD. This causes <<bfd_check_format>> to loop over all the |
| 460 | targets to find the one that matches the file being read. |
| 461 | |
| 462 | SYNOPSIS |
| 463 | bfd_target *bfd_find_target(CONST char *, bfd *); |
| 464 | */ |
| 465 | |
| 466 | bfd_target * |
| 467 | DEFUN(bfd_find_target,(target_name, abfd), |
| 468 | CONST char *target_name AND |
| 469 | bfd *abfd) |
| 470 | { |
| 471 | bfd_target **target; |
| 472 | extern char *getenv (); |
| 473 | CONST char *targname = (target_name ? target_name : |
| 474 | (CONST char *) getenv ("GNUTARGET")); |
| 475 | |
| 476 | /* This is safe; the vector cannot be null */ |
| 477 | if (targname == NULL || !strcmp (targname, "default")) { |
| 478 | abfd->target_defaulted = true; |
| 479 | return abfd->xvec = target_vector[0]; |
| 480 | } |
| 481 | |
| 482 | abfd->target_defaulted = false; |
| 483 | |
| 484 | for (target = &target_vector[0]; *target != NULL; target++) { |
| 485 | if (!strcmp (targname, (*target)->name)) |
| 486 | return abfd->xvec = *target; |
| 487 | } |
| 488 | |
| 489 | bfd_error = invalid_target; |
| 490 | return NULL; |
| 491 | } |
| 492 | |
| 493 | |
| 494 | /* |
| 495 | FUNCTION |
| 496 | bfd_target_list |
| 497 | |
| 498 | DESCRIPTION |
| 499 | This function returns a freshly malloced NULL-terminated |
| 500 | vector of the names of all the valid BFD targets. Do not |
| 501 | modify the names |
| 502 | |
| 503 | SYNOPSIS |
| 504 | CONST char **bfd_target_list(void); |
| 505 | |
| 506 | */ |
| 507 | |
| 508 | CONST char ** |
| 509 | DEFUN_VOID(bfd_target_list) |
| 510 | { |
| 511 | int vec_length= 0; |
| 512 | #ifdef NATIVE_HPPAHPUX_COMPILER |
| 513 | /* The native compiler on the HP9000/700 has a bug which causes it |
| 514 | to loop endlessly when compiling this file. This avoids it. */ |
| 515 | volatile |
| 516 | #endif |
| 517 | bfd_target **target; |
| 518 | CONST char **name_list, **name_ptr; |
| 519 | |
| 520 | for (target = &target_vector[0]; *target != NULL; target++) |
| 521 | vec_length++; |
| 522 | |
| 523 | name_ptr = |
| 524 | name_list = (CONST char **) zalloc ((vec_length + 1) * sizeof (char **)); |
| 525 | |
| 526 | if (name_list == NULL) { |
| 527 | bfd_error = no_memory; |
| 528 | return NULL; |
| 529 | } |
| 530 | |
| 531 | for (target = &target_vector[0]; *target != NULL; target++) |
| 532 | *(name_ptr++) = (*target)->name; |
| 533 | |
| 534 | return name_list; |
| 535 | } |