X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Fbfd.c;h=d98ad629ad6d56361f8ea955a780e3f242e308a2;hb=aca736871c2567ee38bd285afdff62d6339790e4;hp=21588408cf6033b9b44f40b2972934ed71bcf48d;hpb=3234eba0b28841b255ee3fd04934e73ff024c09a;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/bfd.c b/bfd/bfd.c index 21588408cf..d98ad629ad 100644 --- a/bfd/bfd.c +++ b/bfd/bfd.c @@ -1,5 +1,5 @@ /* Generic BFD library interface and support routines. - Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc. Written by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -16,14 +16,14 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* SECTION <> A BFD has type <>; objects of this type are the - cornerstone of any application using <>. Using BFD + cornerstone of any application using BFD. Using BFD consists of making references though the BFD and to data in the BFD. Here is the structure that defines the type <>. It @@ -38,7 +38,7 @@ CODE_FRAGMENT . CONST char *filename; . . {* A pointer to the target jump table. *} -. struct bfd_target *xvec; +. const struct bfd_target *xvec; . . {* To avoid dragging too many header files into every file that . includes `<>', IOSTREAM has been declared as a "char @@ -127,7 +127,7 @@ CODE_FRAGMENT . struct symbol_cache_entry **outsymbols; . . {* Pointer to structure which contains architecture information*} -. struct bfd_arch_info *arch_info; +. const struct bfd_arch_info *arch_info; . . {* Stuff only useful for archives:*} . PTR arelt_data; @@ -136,6 +136,13 @@ CODE_FRAGMENT . struct _bfd *archive_head; {* The first BFD in the archive. *} . boolean has_armap; . +. {* A chain of BFD structures involved in a link. *} +. struct _bfd *link_next; +. +. {* A field used by _bfd_generic_link_add_archive_symbols. This will +. be used only for archive elements. *} +. int archive_pass; +. . {* Used by the back end to hold private data. *} . . union @@ -145,6 +152,7 @@ CODE_FRAGMENT . struct _oasys_data *oasys_obj_data; . struct _oasys_ar_data *oasys_ar_data; . struct coff_tdata *coff_obj_data; +. struct pe_tdata *pe_obj_data; . struct ecoff_tdata *ecoff_obj_data; . struct ieee_data_struct *ieee_data; . struct ieee_ar_data_struct *ieee_ar_data; @@ -157,9 +165,12 @@ CODE_FRAGMENT . struct trad_core_struct *trad_core_data; . struct som_data_struct *som_data; . struct hpux_core_struct *hpux_core_data; +. struct hppabsd_core_struct *hppabsd_core_data; . struct sgi_core_struct *sgi_core_data; . struct lynx_core_struct *lynx_core_data; . struct osf_core_struct *osf_core_data; +. struct cisco_core_struct *cisco_core_data; +. struct versados_data_struct *versados_data; . PTR any; . } tdata; . @@ -168,15 +179,20 @@ CODE_FRAGMENT . . {* Where all the allocated stuff under this BFD goes *} . struct obstack memory; -. -. {* Is this really needed in addition to usrdata? *} -. asymbol **ld_symbols; .}; . */ #include "bfd.h" #include "sysdep.h" + +#ifdef ANSI_PROTOTYPES +#include +#else +#include +#endif + +#include "bfdlink.h" #include "libbfd.h" #include "coff/internal.h" #include "coff/sym.h" @@ -185,31 +201,79 @@ CODE_FRAGMENT #undef obj_symbols #include "libelf.h" -#undef strerror -extern char *strerror(); +#include + +/* provide storage for subsystem, stack and heap data which may have been + passed in on the command line. Ld puts this data into a bfd_link_info + struct which ultimately gets passed in to the bfd. When it arrives, copy + it to the following struct so that the data will be available in coffcode.h + where it is needed. The typedef's used are defined in bfd.h */ + + + +/* +SECTION + Error reporting -/** Error handling - o - Most functions return nonzero on success (check doc for - precise semantics); 0 or NULL on error. - o - Internal errors are documented by the value of bfd_error. - If that is system_call_error then check errno. - o - The easiest way to report this to the user is to use bfd_perror. + Most BFD functions return nonzero on success (check their + individual documentation for precise semantics). On an error, + they call <> to set an error condition that callers + can check by calling <>. + If that returns <>, then check + <>. + + The easiest way to report a BFD error to the user is to + use <>. + +SUBSECTION + Type <> + + The values returned by <> are defined by the + enumerated type <>. + +CODE_FRAGMENT +. +.typedef enum bfd_error +.{ +. bfd_error_no_error = 0, +. bfd_error_system_call, +. bfd_error_invalid_target, +. bfd_error_wrong_format, +. bfd_error_invalid_operation, +. bfd_error_no_memory, +. bfd_error_no_symbols, +. bfd_error_no_armap, +. bfd_error_no_more_archived_files, +. bfd_error_malformed_archive, +. bfd_error_file_not_recognized, +. bfd_error_file_ambiguously_recognized, +. bfd_error_no_contents, +. bfd_error_nonrepresentable_section, +. bfd_error_no_debug_section, +. bfd_error_bad_value, +. bfd_error_file_truncated, +. bfd_error_file_too_big, +. bfd_error_invalid_error_code +.} bfd_error_type; +. */ -bfd_ec bfd_error = no_error; +#undef strerror +extern char *strerror(); + +static bfd_error_type bfd_error = bfd_error_no_error; CONST char *CONST bfd_errmsgs[] = { "No error", "System call error", - "Invalid target", + "Invalid bfd target", "File in wrong format", "Invalid operation", "Memory exhausted", "No symbols", - "No relocation info", + "Archive has no index; run ranlib to add one", "No more archived files", "Malformed archive", - "Symbol not found", "File format not recognized", "File format is ambiguous", "Section has no contents", @@ -217,133 +281,252 @@ CONST char *CONST bfd_errmsgs[] = { "Symbol needs debug section which does not exist", "Bad value", "File truncated", + "File too big", "#" }; -static -void -DEFUN(bfd_nonrepresentable_section,(abfd, name), - CONST bfd * CONST abfd AND - CONST char * CONST name) -{ - fprintf(stderr, - "bfd error writing file %s, format %s can't represent section %s\n", - abfd->filename, - abfd->xvec->name, - name); - exit(1); -} +/* +FUNCTION + bfd_get_error -/*ARGSUSED*/ -static -void -DEFUN(bfd_undefined_symbol,(relent, seclet), - CONST arelent *relent AND - CONST struct bfd_seclet *seclet) -{ - asymbol *symbol = *(relent->sym_ptr_ptr); - fprintf(stderr, "bfd error relocating, symbol %s is undefined\n", - symbol->name); - exit(1); -} -/*ARGSUSED*/ -static -void -DEFUN(bfd_reloc_value_truncated,(relent, seclet), - CONST arelent *relent AND - struct bfd_seclet *seclet) +SYNOPSIS + bfd_error_type bfd_get_error (void); + +DESCRIPTION + Return the current BFD error condition. +*/ + +bfd_error_type +bfd_get_error () { - fprintf(stderr, "bfd error relocating, value truncated\n"); - exit(1); + return bfd_error; } -/*ARGSUSED*/ -static -void -DEFUN(bfd_reloc_is_dangerous,(relent, seclet), - CONST arelent *relent AND - CONST struct bfd_seclet *seclet) + +/* +FUNCTION + bfd_set_error + +SYNOPSIS + void bfd_set_error (bfd_error_type error_tag); + +DESCRIPTION + Set the BFD error condition to be @var{error_tag}. +*/ + +void +bfd_set_error (error_tag) + bfd_error_type error_tag; { - fprintf(stderr, "bfd error relocating, dangerous\n"); - exit(1); + bfd_error = error_tag; } -bfd_error_vector_type bfd_error_vector = - { - bfd_nonrepresentable_section , - bfd_undefined_symbol, - bfd_reloc_value_truncated, - bfd_reloc_is_dangerous, - }; +/* +FUNCTION + bfd_errmsg + +SYNOPSIS + CONST char *bfd_errmsg (bfd_error_type error_tag); +DESCRIPTION + Return a string describing the error @var{error_tag}, or + the system error if @var{error_tag} is <>. +*/ CONST char * bfd_errmsg (error_tag) - bfd_ec error_tag; + bfd_error_type error_tag; { #ifndef errno extern int errno; #endif - if (error_tag == system_call_error) + if (error_tag == bfd_error_system_call) return strerror (errno); - if ((((int)error_tag <(int) no_error) || - ((int)error_tag > (int)invalid_error_code))) - error_tag = invalid_error_code;/* sanity check */ + if ((((int)error_tag <(int) bfd_error_no_error) || + ((int)error_tag > (int)bfd_error_invalid_error_code))) + error_tag = bfd_error_invalid_error_code;/* sanity check */ return bfd_errmsgs [(int)error_tag]; } -void -DEFUN (bfd_default_error_trap, (error_tag), - bfd_ec error_tag) -{ - fprintf(stderr, "bfd assert fail (%s)\n", bfd_errmsg(error_tag)); -} +/* +FUNCTION + bfd_perror + +SYNOPSIS + void bfd_perror (CONST char *message); -void (*bfd_error_trap) PARAMS ((bfd_ec)) = bfd_default_error_trap; -void (*bfd_error_nonrepresentabltrap) PARAMS ((bfd_ec)) = bfd_default_error_trap; +DESCRIPTION + Print to the standard error stream a string describing the + last BFD error that occurred, or the last system error if + the last BFD error was a system call failure. If @var{message} + is non-NULL and non-empty, the error string printed is preceded + by @var{message}, a colon, and a space. It is followed by a newline. +*/ void -DEFUN(bfd_perror,(message), - CONST char *message) +bfd_perror (message) + CONST char *message; { - if (bfd_error == system_call_error) + if (bfd_get_error () == bfd_error_system_call) perror((char *)message); /* must be system error then... */ else { if (message == NULL || *message == '\0') - fprintf (stderr, "%s\n", bfd_errmsg (bfd_error)); + fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); else - fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_error)); + fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); } } - -/** Symbols */ +/* +SUBSECTION + BFD error handler + + Some BFD functions want to print messages describing the + problem. They call a BFD error handler function. This + function may be overriden by the program. + + The BFD error handler acts like printf. + +CODE_FRAGMENT +. +.typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...)); +. +*/ + +/* The program name used when printing BFD error messages. */ + +static const char *_bfd_error_program_name; + +/* This is the default routine to handle BFD error messages. */ + +#ifdef ANSI_PROTOTYPES + +static void _bfd_default_error_handler PARAMS ((const char *s, ...)); + +static void +_bfd_default_error_handler (const char *s, ...) +{ + va_list p; + + if (_bfd_error_program_name != NULL) + fprintf (stderr, "%s: ", _bfd_error_program_name); + + va_start (p, s); + + vfprintf (stderr, s, p); + + va_end (p); + + fprintf (stderr, "\n"); +} + +#else /* ! defined (ANSI_PROTOTYPES) */ + +static void _bfd_default_error_handler (); + +static void +_bfd_default_error_handler (va_alist) + va_dcl +{ + va_list p; + const char *s; + + if (_bfd_error_program_name != NULL) + fprintf (stderr, "%s: ", _bfd_error_program_name); + + va_start (p); + + s = va_arg (p, const char *); + vfprintf (stderr, s, p); + + va_end (p); + + fprintf (stderr, "\n"); +} + +#endif /* ! defined (ANSI_PROTOTYPES) */ + +/* This is a function pointer to the routine which should handle BFD + error messages. It is called when a BFD routine encounters an + error for which it wants to print a message. Going through a + function pointer permits a program linked against BFD to intercept + the messages and deal with them itself. */ +bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler; + +/* +FUNCTION + bfd_set_error_handler + +SYNOPSIS + bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); + +DESCRIPTION + Set the BFD error handler function. Returns the previous + function. +*/ + +bfd_error_handler_type +bfd_set_error_handler (pnew) + bfd_error_handler_type pnew; +{ + bfd_error_handler_type pold; + + pold = _bfd_error_handler; + _bfd_error_handler = pnew; + return pold; +} + +/* +FUNCTION + bfd_set_error_program_name + +SYNOPSIS + void bfd_set_error_program_name (const char *); + +DESCRIPTION + Set the program name to use when printing a BFD error. This + is printed before the error message followed by a colon and + space. The string must not be changed after it is passed to + this function. +*/ + +void +bfd_set_error_program_name (name) + const char *name; +{ + _bfd_error_program_name = name; +} + +/* +SECTION + Symbols +*/ /* FUNCTION bfd_get_reloc_upper_bound SYNOPSIS - unsigned int bfd_get_reloc_upper_bound(bfd *abfd, asection *sect); + long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect); DESCRIPTION Return the number of bytes required to store the relocation information associated with section @var{sect} - attached to bfd @var{abfd}. + attached to bfd @var{abfd}. If an error occurs, return -1. */ -unsigned int -DEFUN(bfd_get_reloc_upper_bound,(abfd, asect), - bfd *abfd AND - sec_ptr asect) +long +bfd_get_reloc_upper_bound (abfd, asect) + bfd *abfd; + sec_ptr asect; { if (abfd->format != bfd_object) { - bfd_error = invalid_operation; - return 0; + bfd_set_error (bfd_error_invalid_operation); + return -1; } return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); @@ -354,7 +537,7 @@ FUNCTION bfd_canonicalize_reloc SYNOPSIS - unsigned int bfd_canonicalize_reloc + long bfd_canonicalize_reloc (bfd *abfd, asection *sec, arelent **loc, @@ -366,23 +549,24 @@ DESCRIPTION information attached to @var{sec} into the internal canonical form. Place the table into memory at @var{loc}, which has been preallocated, usually by a call to - <>. + <>. Returns the number of relocs, or + -1 on error. The @var{syms} table is also needed for horrible internal magic reasons. */ -unsigned int -DEFUN(bfd_canonicalize_reloc,(abfd, asect, location, symbols), - bfd *abfd AND - sec_ptr asect AND - arelent **location AND - asymbol **symbols) +long +bfd_canonicalize_reloc (abfd, asect, location, symbols) + bfd *abfd; + sec_ptr asect; + arelent **location; + asymbol **symbols; { if (abfd->format != bfd_object) { - bfd_error = invalid_operation; - return 0; + bfd_set_error (bfd_error_invalid_operation); + return -1; } return BFD_SEND (abfd, _bfd_canonicalize_reloc, (abfd, asect, location, symbols)); @@ -425,12 +609,12 @@ DESCRIPTION Set the flag word in the BFD @var{abfd} to the value @var{flags}. Possible errors are: - o wrong_format - The target bfd was not of object format. - o invalid_operation - The target bfd was open for reading. - o invalid_operation - + o <> - The target bfd was not of object format. + o <> - The target bfd was open for reading. + o <> - The flag word contained a bit which was not applicable to the - type of file. E.g., an attempt was made to set the D_PAGED bit - on a bfd format which does not support demand paging. + type of file. E.g., an attempt was made to set the <> bit + on a BFD format which does not support demand paging. */ @@ -440,18 +624,18 @@ bfd_set_file_flags (abfd, flags) flagword flags; { if (abfd->format != bfd_object) { - bfd_error = wrong_format; + bfd_set_error (bfd_error_wrong_format); return false; } if (bfd_read_p (abfd)) { - bfd_error = invalid_operation; + bfd_set_error (bfd_error_invalid_operation); return false; } bfd_get_file_flags (abfd) = flags; if ((flags & bfd_applicable_file_flags (abfd)) != flags) { - bfd_error = invalid_operation; + bfd_set_error (bfd_error_invalid_operation); return false; } @@ -459,11 +643,11 @@ return true; } void -bfd_assert(file, line) -char *file; -int line; +bfd_assert (file, line) + const char *file; + int line; { - fprintf(stderr, "bfd assertion fail %s:%d\n",file,line); + (*_bfd_error_handler) ("bfd assertion fail %s:%d\n", file, line); } @@ -578,7 +762,7 @@ SYNOPSIS DESCRIPTION Return the maximum size of objects to be optimized using the GP - register under MIPS ECOFF. This is typically set by the -G + register under MIPS ECOFF. This is typically set by the <<-G>> argument to the compiler, assembler or linker. */ @@ -586,8 +770,13 @@ int bfd_get_gp_size (abfd) bfd *abfd; { - if (abfd->xvec->flavour == bfd_target_ecoff_flavour) - return ecoff_data (abfd)->gp_size; + if (abfd->format == bfd_object) + { + if (abfd->xvec->flavour == bfd_target_ecoff_flavour) + return ecoff_data (abfd)->gp_size; + else if (abfd->xvec->flavour == bfd_target_elf_flavour) + return elf_gp_size (abfd); + } return 0; } @@ -601,7 +790,7 @@ SYNOPSIS DESCRIPTION Set the maximum size of objects to be optimized using the GP register under ECOFF or MIPS ELF. This is typically set by - the -G argument to the compiler, assembler or linker. + the <<-G>> argument to the compiler, assembler or linker. */ void @@ -609,6 +798,9 @@ bfd_set_gp_size (abfd, i) bfd *abfd; int i; { + /* Don't try to set GP size on an archive or core file! */ + if (abfd->format != bfd_object) + return; if (abfd->xvec->flavour == bfd_target_ecoff_flavour) ecoff_data (abfd)->gp_size = i; else if (abfd->xvec->flavour == bfd_target_elf_flavour) @@ -624,9 +816,9 @@ SYNOPSIS DESCRIPTION Convert, like <>, a numerical expression - @var{string} into a bfd_vma integer, and returns that integer. + @var{string} into a <> integer, and return that integer. (Though without as many bells and whistles as <>.) - The expression is assumed to be unsigned (i.e. positive). + The expression is assumed to be unsigned (i.e., positive). If given a @var{base}, it is used as the base for conversion. A base of 0 causes the function to interpret the string in hex if a leading "0x" or "0X" is found, otherwise @@ -636,17 +828,17 @@ DESCRIPTION */ bfd_vma -DEFUN(bfd_scan_vma,(string, end, base), - CONST char *string AND - CONST char **end AND - int base) +bfd_scan_vma (string, end, base) + CONST char *string; + CONST char **end; + int base; { bfd_vma value; int digit; /* Let the host do it if possible. */ if (sizeof(bfd_vma) <= sizeof(unsigned long)) - return (bfd_vma) strtoul (string, 0, base); + return (bfd_vma) strtoul (string, (char **) end, base); /* A negative base makes no sense, and we only need to go as high as hex. */ if ((base < 0) || (base > 16)) @@ -689,6 +881,69 @@ DEFUN(bfd_scan_vma,(string, end, base), return value; } +/* +FUNCTION + bfd_copy_private_bfd_data + +SYNOPSIS + boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd); + +DESCRIPTION + Copy private BFD information from the BFD @var{ibfd} to the + the BFD @var{obfd}. Return <> on success, <> on error. + Possible error returns are: + + o <> - + Not enough memory exists to create private data for @var{obfd}. + +.#define bfd_copy_private_bfd_data(ibfd, obfd) \ +. BFD_SEND (ibfd, _bfd_copy_private_bfd_data, \ +. (ibfd, obfd)) + +*/ + +/* +FUNCTION + bfd_merge_private_bfd_data + +SYNOPSIS + boolean bfd_merge_private_bfd_data(bfd *ibfd, bfd *obfd); + +DESCRIPTION + Merge private BFD information from the BFD @var{ibfd} to the + the output file BFD @var{obfd} when linking. Return <> + on success, <> on error. Possible error returns are: + + o <> - + Not enough memory exists to create private data for @var{obfd}. + +.#define bfd_merge_private_bfd_data(ibfd, obfd) \ +. BFD_SEND (ibfd, _bfd_merge_private_bfd_data, \ +. (ibfd, obfd)) + +*/ + +/* +FUNCTION + bfd_set_private_flags + +SYNOPSIS + boolean bfd_set_private_flags(bfd *abfd, flagword flags); + +DESCRIPTION + Set private BFD flag information in the BFD @var{abfd}. + Return <> on success, <> on error. Possible error + returns are: + + o <> - + Not enough memory exists to create private data for @var{obfd}. + +.#define bfd_set_private_flags(abfd, flags) \ +. BFD_SEND (abfd, _bfd_set_private_flags, \ +. (abfd, flags)) + +*/ + /* FUNCTION stuff @@ -716,16 +971,77 @@ DESCRIPTION .#define bfd_stat_arch_elt(abfd, stat) \ . BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) . +.#define bfd_update_armap_timestamp(abfd) \ +. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) +. .#define bfd_set_arch_mach(abfd, arch, mach)\ . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) . -.#define bfd_get_relocated_section_contents(abfd, seclet, data, relocateable) \ -. BFD_SEND (abfd, _bfd_get_relocated_section_contents, (abfd, seclet, data, relocateable)) -. -.#define bfd_relax_section(abfd, section, symbols) \ -. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, symbols)) +.#define bfd_relax_section(abfd, section, link_info, again) \ +. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) +. +.#define bfd_link_hash_table_create(abfd) \ +. BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) +. +.#define bfd_link_add_symbols(abfd, info) \ +. BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) +. +.#define bfd_final_link(abfd, info) \ +. BFD_SEND (abfd, _bfd_final_link, (abfd, info)) +. +.#define bfd_free_cached_info(abfd) \ +. BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) +. +.#define bfd_get_dynamic_symtab_upper_bound(abfd) \ +. BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) +. +.#define bfd_print_private_bfd_data(abfd, file)\ +. BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) +. +.#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ +. BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) +. +.#define bfd_get_dynamic_reloc_upper_bound(abfd) \ +. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) +. +.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ +. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) +. +.extern bfd_byte *bfd_get_relocated_section_contents +. PARAMS ((bfd *, struct bfd_link_info *, +. struct bfd_link_order *, bfd_byte *, +. boolean, asymbol **)); . -.#define bfd_seclet_link(abfd, data, relocateable) \ -. BFD_SEND (abfd, _bfd_seclet_link, (abfd, data, relocateable)) */ + +bfd_byte * +bfd_get_relocated_section_contents (abfd, link_info, link_order, data, + relocateable, symbols) + bfd *abfd; + struct bfd_link_info *link_info; + struct bfd_link_order *link_order; + bfd_byte *data; + boolean relocateable; + asymbol **symbols; +{ + bfd *abfd2; + bfd_byte *(*fn) PARAMS ((bfd *, struct bfd_link_info *, + struct bfd_link_order *, bfd_byte *, boolean, + asymbol **)); + + if (link_order->type == bfd_indirect_link_order) + { + abfd2 = link_order->u.indirect.section->owner; + if (abfd2 == 0) + abfd2 = abfd; + } + else + abfd2 = abfd; + fn = abfd2->xvec->_bfd_get_relocated_section_contents; + + return (*fn) (abfd, link_info, link_order, data, relocateable, symbols); +} + + +