1999-05-03 09:29:11 +02:00
|
|
|
|
/* linker.c -- BFD linker routines
|
2004-03-22 23:58:04 +01:00
|
|
|
|
Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
|
2008-02-15 04:35:53 +01:00
|
|
|
|
2003, 2004, 2005, 2006, 2007, 2008
|
2007-04-26 16:47:00 +02:00
|
|
|
|
Free Software Foundation, Inc.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support
|
|
|
|
|
|
2003-03-31 20:13:25 +02:00
|
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-03-31 20:13:25 +02:00
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
2007-07-03 16:26:43 +02:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
2003-03-31 20:13:25 +02:00
|
|
|
|
(at your option) any later version.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-03-31 20:13:25 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-03-31 20:13:25 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
2007-07-03 16:26:43 +02:00
|
|
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
|
|
|
MA 02110-1301, USA. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
#include "sysdep.h"
|
2007-04-26 16:47:00 +02:00
|
|
|
|
#include "bfd.h"
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#include "libbfd.h"
|
|
|
|
|
#include "bfdlink.h"
|
|
|
|
|
#include "genlink.h"
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
SECTION
|
|
|
|
|
Linker Functions
|
|
|
|
|
|
|
|
|
|
@cindex Linker
|
|
|
|
|
The linker uses three special entry points in the BFD target
|
|
|
|
|
vector. It is not necessary to write special routines for
|
|
|
|
|
these entry points when creating a new BFD back end, since
|
|
|
|
|
generic versions are provided. However, writing them can
|
|
|
|
|
speed up linking and make it use significantly less runtime
|
|
|
|
|
memory.
|
|
|
|
|
|
|
|
|
|
The first routine creates a hash table used by the other
|
|
|
|
|
routines. The second routine adds the symbols from an object
|
|
|
|
|
file to the hash table. The third routine takes all the
|
|
|
|
|
object files and links them together to create the output
|
|
|
|
|
file. These routines are designed so that the linker proper
|
|
|
|
|
does not need to know anything about the symbols in the object
|
|
|
|
|
files that it is linking. The linker merely arranges the
|
|
|
|
|
sections as directed by the linker script and lets BFD handle
|
|
|
|
|
the details of symbols and relocs.
|
|
|
|
|
|
|
|
|
|
The second routine and third routines are passed a pointer to
|
|
|
|
|
a <<struct bfd_link_info>> structure (defined in
|
|
|
|
|
<<bfdlink.h>>) which holds information relevant to the link,
|
|
|
|
|
including the linker hash table (which was created by the
|
|
|
|
|
first routine) and a set of callback functions to the linker
|
|
|
|
|
proper.
|
|
|
|
|
|
|
|
|
|
The generic linker routines are in <<linker.c>>, and use the
|
|
|
|
|
header file <<genlink.h>>. As of this writing, the only back
|
|
|
|
|
ends which have implemented versions of these routines are
|
|
|
|
|
a.out (in <<aoutx.h>>) and ECOFF (in <<ecoff.c>>). The a.out
|
|
|
|
|
routines are used as examples throughout this section.
|
|
|
|
|
|
2001-01-03 20:26:07 +01:00
|
|
|
|
@menu
|
1999-05-03 09:29:11 +02:00
|
|
|
|
@* Creating a Linker Hash Table::
|
|
|
|
|
@* Adding Symbols to the Hash Table::
|
|
|
|
|
@* Performing the Final Link::
|
|
|
|
|
@end menu
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Creating a Linker Hash Table, Adding Symbols to the Hash Table, Linker Functions, Linker Functions
|
|
|
|
|
SUBSECTION
|
|
|
|
|
Creating a linker hash table
|
|
|
|
|
|
|
|
|
|
@cindex _bfd_link_hash_table_create in target vector
|
|
|
|
|
@cindex target vector (_bfd_link_hash_table_create)
|
|
|
|
|
The linker routines must create a hash table, which must be
|
|
|
|
|
derived from <<struct bfd_link_hash_table>> described in
|
1999-06-04 15:25:23 +02:00
|
|
|
|
<<bfdlink.c>>. @xref{Hash Tables}, for information on how to
|
1999-05-03 09:29:11 +02:00
|
|
|
|
create a derived hash table. This entry point is called using
|
|
|
|
|
the target vector of the linker output file.
|
|
|
|
|
|
|
|
|
|
The <<_bfd_link_hash_table_create>> entry point must allocate
|
|
|
|
|
and initialize an instance of the desired hash table. If the
|
|
|
|
|
back end does not require any additional information to be
|
|
|
|
|
stored with the entries in the hash table, the entry point may
|
|
|
|
|
simply create a <<struct bfd_link_hash_table>>. Most likely,
|
|
|
|
|
however, some additional information will be needed.
|
|
|
|
|
|
|
|
|
|
For example, with each entry in the hash table the a.out
|
|
|
|
|
linker keeps the index the symbol has in the final output file
|
2003-06-25 08:40:27 +02:00
|
|
|
|
(this index number is used so that when doing a relocatable
|
1999-05-03 09:29:11 +02:00
|
|
|
|
link the symbol index used in the output file can be quickly
|
|
|
|
|
filled in when copying over a reloc). The a.out linker code
|
|
|
|
|
defines the required structures and functions for a hash table
|
|
|
|
|
derived from <<struct bfd_link_hash_table>>. The a.out linker
|
|
|
|
|
hash table is created by the function
|
|
|
|
|
<<NAME(aout,link_hash_table_create)>>; it simply allocates
|
|
|
|
|
space for the hash table, initializes it, and returns a
|
|
|
|
|
pointer to it.
|
|
|
|
|
|
|
|
|
|
When writing the linker routines for a new back end, you will
|
|
|
|
|
generally not know exactly which fields will be required until
|
|
|
|
|
you have finished. You should simply create a new hash table
|
|
|
|
|
which defines no additional fields, and then simply add fields
|
|
|
|
|
as they become necessary.
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Adding Symbols to the Hash Table, Performing the Final Link, Creating a Linker Hash Table, Linker Functions
|
|
|
|
|
SUBSECTION
|
|
|
|
|
Adding symbols to the hash table
|
|
|
|
|
|
|
|
|
|
@cindex _bfd_link_add_symbols in target vector
|
|
|
|
|
@cindex target vector (_bfd_link_add_symbols)
|
|
|
|
|
The linker proper will call the <<_bfd_link_add_symbols>>
|
|
|
|
|
entry point for each object file or archive which is to be
|
|
|
|
|
linked (typically these are the files named on the command
|
|
|
|
|
line, but some may also come from the linker script). The
|
|
|
|
|
entry point is responsible for examining the file. For an
|
|
|
|
|
object file, BFD must add any relevant symbol information to
|
|
|
|
|
the hash table. For an archive, BFD must determine which
|
|
|
|
|
elements of the archive should be used and adding them to the
|
|
|
|
|
link.
|
|
|
|
|
|
|
|
|
|
The a.out version of this entry point is
|
|
|
|
|
<<NAME(aout,link_add_symbols)>>.
|
|
|
|
|
|
|
|
|
|
@menu
|
|
|
|
|
@* Differing file formats::
|
|
|
|
|
@* Adding symbols from an object file::
|
|
|
|
|
@* Adding symbols from an archive::
|
|
|
|
|
@end menu
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Differing file formats, Adding symbols from an object file, Adding Symbols to the Hash Table, Adding Symbols to the Hash Table
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Differing file formats
|
|
|
|
|
|
|
|
|
|
Normally all the files involved in a link will be of the same
|
|
|
|
|
format, but it is also possible to link together different
|
|
|
|
|
format object files, and the back end must support that. The
|
|
|
|
|
<<_bfd_link_add_symbols>> entry point is called via the target
|
|
|
|
|
vector of the file to be added. This has an important
|
|
|
|
|
consequence: the function may not assume that the hash table
|
|
|
|
|
is the type created by the corresponding
|
|
|
|
|
<<_bfd_link_hash_table_create>> vector. All the
|
|
|
|
|
<<_bfd_link_add_symbols>> function can assume about the hash
|
|
|
|
|
table is that it is derived from <<struct
|
|
|
|
|
bfd_link_hash_table>>.
|
|
|
|
|
|
|
|
|
|
Sometimes the <<_bfd_link_add_symbols>> function must store
|
|
|
|
|
some information in the hash table entry to be used by the
|
2008-02-15 04:35:53 +01:00
|
|
|
|
<<_bfd_final_link>> function. In such a case the output bfd
|
|
|
|
|
xvec must be checked to make sure that the hash table was
|
|
|
|
|
created by an object file of the same format.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
The <<_bfd_final_link>> routine must be prepared to handle a
|
|
|
|
|
hash entry without any extra information added by the
|
|
|
|
|
<<_bfd_link_add_symbols>> function. A hash entry without
|
|
|
|
|
extra information will also occur when the linker script
|
|
|
|
|
directs the linker to create a symbol. Note that, regardless
|
|
|
|
|
of how a hash table entry is added, all the fields will be
|
|
|
|
|
initialized to some sort of null value by the hash table entry
|
|
|
|
|
initialization function.
|
|
|
|
|
|
|
|
|
|
See <<ecoff_link_add_externals>> for an example of how to
|
2008-02-15 04:35:53 +01:00
|
|
|
|
check the output bfd before saving information (in this
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case, the ECOFF external symbol debugging information) in a
|
|
|
|
|
hash table entry.
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Adding symbols from an object file, Adding symbols from an archive, Differing file formats, Adding Symbols to the Hash Table
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Adding symbols from an object file
|
|
|
|
|
|
|
|
|
|
When the <<_bfd_link_add_symbols>> routine is passed an object
|
|
|
|
|
file, it must add all externally visible symbols in that
|
|
|
|
|
object file to the hash table. The actual work of adding the
|
|
|
|
|
symbol to the hash table is normally handled by the function
|
|
|
|
|
<<_bfd_generic_link_add_one_symbol>>. The
|
|
|
|
|
<<_bfd_link_add_symbols>> routine is responsible for reading
|
|
|
|
|
all the symbols from the object file and passing the correct
|
|
|
|
|
information to <<_bfd_generic_link_add_one_symbol>>.
|
|
|
|
|
|
|
|
|
|
The <<_bfd_link_add_symbols>> routine should not use
|
|
|
|
|
<<bfd_canonicalize_symtab>> to read the symbols. The point of
|
|
|
|
|
providing this routine is to avoid the overhead of converting
|
|
|
|
|
the symbols into generic <<asymbol>> structures.
|
|
|
|
|
|
|
|
|
|
@findex _bfd_generic_link_add_one_symbol
|
|
|
|
|
<<_bfd_generic_link_add_one_symbol>> handles the details of
|
|
|
|
|
combining common symbols, warning about multiple definitions,
|
|
|
|
|
and so forth. It takes arguments which describe the symbol to
|
|
|
|
|
add, notably symbol flags, a section, and an offset. The
|
|
|
|
|
symbol flags include such things as <<BSF_WEAK>> or
|
|
|
|
|
<<BSF_INDIRECT>>. The section is a section in the object
|
|
|
|
|
file, or something like <<bfd_und_section_ptr>> for an undefined
|
|
|
|
|
symbol or <<bfd_com_section_ptr>> for a common symbol.
|
|
|
|
|
|
|
|
|
|
If the <<_bfd_final_link>> routine is also going to need to
|
|
|
|
|
read the symbol information, the <<_bfd_link_add_symbols>>
|
|
|
|
|
routine should save it somewhere attached to the object file
|
|
|
|
|
BFD. However, the information should only be saved if the
|
2002-11-30 09:39:46 +01:00
|
|
|
|
<<keep_memory>> field of the <<info>> argument is TRUE, so
|
1999-05-03 09:29:11 +02:00
|
|
|
|
that the <<-no-keep-memory>> linker switch is effective.
|
|
|
|
|
|
|
|
|
|
The a.out function which adds symbols from an object file is
|
|
|
|
|
<<aout_link_add_object_symbols>>, and most of the interesting
|
|
|
|
|
work is in <<aout_link_add_symbols>>. The latter saves
|
|
|
|
|
pointers to the hash tables entries created by
|
|
|
|
|
<<_bfd_generic_link_add_one_symbol>> indexed by symbol number,
|
|
|
|
|
so that the <<_bfd_final_link>> routine does not have to call
|
|
|
|
|
the hash table lookup routine to locate the entry.
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Adding symbols from an archive, , Adding symbols from an object file, Adding Symbols to the Hash Table
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Adding symbols from an archive
|
|
|
|
|
|
|
|
|
|
When the <<_bfd_link_add_symbols>> routine is passed an
|
|
|
|
|
archive, it must look through the symbols defined by the
|
|
|
|
|
archive and decide which elements of the archive should be
|
|
|
|
|
included in the link. For each such element it must call the
|
|
|
|
|
<<add_archive_element>> linker callback, and it must add the
|
|
|
|
|
symbols from the object file to the linker hash table.
|
|
|
|
|
|
|
|
|
|
@findex _bfd_generic_link_add_archive_symbols
|
|
|
|
|
In most cases the work of looking through the symbols in the
|
|
|
|
|
archive should be done by the
|
|
|
|
|
<<_bfd_generic_link_add_archive_symbols>> function. This
|
|
|
|
|
function builds a hash table from the archive symbol table and
|
|
|
|
|
looks through the list of undefined symbols to see which
|
|
|
|
|
elements should be included.
|
|
|
|
|
<<_bfd_generic_link_add_archive_symbols>> is passed a function
|
|
|
|
|
to call to make the final decision about adding an archive
|
|
|
|
|
element to the link and to do the actual work of adding the
|
|
|
|
|
symbols to the linker hash table.
|
|
|
|
|
|
|
|
|
|
The function passed to
|
|
|
|
|
<<_bfd_generic_link_add_archive_symbols>> must read the
|
|
|
|
|
symbols of the archive element and decide whether the archive
|
|
|
|
|
element should be included in the link. If the element is to
|
|
|
|
|
be included, the <<add_archive_element>> linker callback
|
|
|
|
|
routine must be called with the element as an argument, and
|
|
|
|
|
the elements symbols must be added to the linker hash table
|
|
|
|
|
just as though the element had itself been passed to the
|
|
|
|
|
<<_bfd_link_add_symbols>> function.
|
|
|
|
|
|
|
|
|
|
When the a.out <<_bfd_link_add_symbols>> function receives an
|
|
|
|
|
archive, it calls <<_bfd_generic_link_add_archive_symbols>>
|
|
|
|
|
passing <<aout_link_check_archive_element>> as the function
|
|
|
|
|
argument. <<aout_link_check_archive_element>> calls
|
|
|
|
|
<<aout_link_check_ar_symbols>>. If the latter decides to add
|
|
|
|
|
the element (an element is only added if it provides a real,
|
|
|
|
|
non-common, definition for a previously undefined or common
|
|
|
|
|
symbol) it calls the <<add_archive_element>> callback and then
|
|
|
|
|
<<aout_link_check_archive_element>> calls
|
|
|
|
|
<<aout_link_add_symbols>> to actually add the symbols to the
|
|
|
|
|
linker hash table.
|
|
|
|
|
|
|
|
|
|
The ECOFF back end is unusual in that it does not normally
|
|
|
|
|
call <<_bfd_generic_link_add_archive_symbols>>, because ECOFF
|
|
|
|
|
archives already contain a hash table of symbols. The ECOFF
|
|
|
|
|
back end searches the archive itself to avoid the overhead of
|
|
|
|
|
creating a new hash table.
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Performing the Final Link, , Adding Symbols to the Hash Table, Linker Functions
|
|
|
|
|
SUBSECTION
|
|
|
|
|
Performing the final link
|
|
|
|
|
|
|
|
|
|
@cindex _bfd_link_final_link in target vector
|
|
|
|
|
@cindex target vector (_bfd_final_link)
|
|
|
|
|
When all the input files have been processed, the linker calls
|
|
|
|
|
the <<_bfd_final_link>> entry point of the output BFD. This
|
|
|
|
|
routine is responsible for producing the final output file,
|
|
|
|
|
which has several aspects. It must relocate the contents of
|
|
|
|
|
the input sections and copy the data into the output sections.
|
|
|
|
|
It must build an output symbol table including any local
|
|
|
|
|
symbols from the input files and the global symbols from the
|
2003-06-25 08:40:27 +02:00
|
|
|
|
hash table. When producing relocatable output, it must
|
1999-05-03 09:29:11 +02:00
|
|
|
|
modify the input relocs and write them into the output file.
|
|
|
|
|
There may also be object format dependent work to be done.
|
|
|
|
|
|
|
|
|
|
The linker will also call the <<write_object_contents>> entry
|
|
|
|
|
point when the BFD is closed. The two entry points must work
|
|
|
|
|
together in order to produce the correct output file.
|
|
|
|
|
|
|
|
|
|
The details of how this works are inevitably dependent upon
|
|
|
|
|
the specific object file format. The a.out
|
|
|
|
|
<<_bfd_final_link>> routine is <<NAME(aout,final_link)>>.
|
|
|
|
|
|
|
|
|
|
@menu
|
|
|
|
|
@* Information provided by the linker::
|
|
|
|
|
@* Relocating the section contents::
|
|
|
|
|
@* Writing the symbol table::
|
|
|
|
|
@end menu
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Information provided by the linker, Relocating the section contents, Performing the Final Link, Performing the Final Link
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Information provided by the linker
|
|
|
|
|
|
|
|
|
|
Before the linker calls the <<_bfd_final_link>> entry point,
|
|
|
|
|
it sets up some data structures for the function to use.
|
|
|
|
|
|
|
|
|
|
The <<input_bfds>> field of the <<bfd_link_info>> structure
|
|
|
|
|
will point to a list of all the input files included in the
|
|
|
|
|
link. These files are linked through the <<link_next>> field
|
|
|
|
|
of the <<bfd>> structure.
|
|
|
|
|
|
|
|
|
|
Each section in the output file will have a list of
|
2005-05-04 13:00:28 +02:00
|
|
|
|
<<link_order>> structures attached to the <<map_head.link_order>>
|
1999-05-03 09:29:11 +02:00
|
|
|
|
field (the <<link_order>> structure is defined in
|
|
|
|
|
<<bfdlink.h>>). These structures describe how to create the
|
|
|
|
|
contents of the output section in terms of the contents of
|
|
|
|
|
various input sections, fill constants, and, eventually, other
|
|
|
|
|
types of information. They also describe relocs that must be
|
|
|
|
|
created by the BFD backend, but do not correspond to any input
|
|
|
|
|
file; this is used to support -Ur, which builds constructors
|
2003-06-25 08:40:27 +02:00
|
|
|
|
while generating a relocatable object file.
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Relocating the section contents, Writing the symbol table, Information provided by the linker, Performing the Final Link
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Relocating the section contents
|
|
|
|
|
|
|
|
|
|
The <<_bfd_final_link>> function should look through the
|
|
|
|
|
<<link_order>> structures attached to each section of the
|
|
|
|
|
output file. Each <<link_order>> structure should either be
|
|
|
|
|
handled specially, or it should be passed to the function
|
|
|
|
|
<<_bfd_default_link_order>> which will do the right thing
|
|
|
|
|
(<<_bfd_default_link_order>> is defined in <<linker.c>>).
|
|
|
|
|
|
|
|
|
|
For efficiency, a <<link_order>> of type
|
|
|
|
|
<<bfd_indirect_link_order>> whose associated section belongs
|
|
|
|
|
to a BFD of the same format as the output BFD must be handled
|
|
|
|
|
specially. This type of <<link_order>> describes part of an
|
|
|
|
|
output section in terms of a section belonging to one of the
|
|
|
|
|
input files. The <<_bfd_final_link>> function should read the
|
|
|
|
|
contents of the section and any associated relocs, apply the
|
|
|
|
|
relocs to the section contents, and write out the modified
|
2003-06-25 08:40:27 +02:00
|
|
|
|
section contents. If performing a relocatable link, the
|
1999-05-03 09:29:11 +02:00
|
|
|
|
relocs themselves must also be modified and written out.
|
|
|
|
|
|
|
|
|
|
@findex _bfd_relocate_contents
|
|
|
|
|
@findex _bfd_final_link_relocate
|
|
|
|
|
The functions <<_bfd_relocate_contents>> and
|
|
|
|
|
<<_bfd_final_link_relocate>> provide some general support for
|
|
|
|
|
performing the actual relocations, notably overflow checking.
|
|
|
|
|
Their arguments include information about the symbol the
|
|
|
|
|
relocation is against and a <<reloc_howto_type>> argument
|
|
|
|
|
which describes the relocation to perform. These functions
|
|
|
|
|
are defined in <<reloc.c>>.
|
|
|
|
|
|
|
|
|
|
The a.out function which handles reading, relocating, and
|
|
|
|
|
writing section contents is <<aout_link_input_section>>. The
|
|
|
|
|
actual relocation is done in <<aout_link_input_section_std>>
|
|
|
|
|
and <<aout_link_input_section_ext>>.
|
|
|
|
|
|
|
|
|
|
INODE
|
|
|
|
|
Writing the symbol table, , Relocating the section contents, Performing the Final Link
|
|
|
|
|
SUBSUBSECTION
|
|
|
|
|
Writing the symbol table
|
|
|
|
|
|
|
|
|
|
The <<_bfd_final_link>> function must gather all the symbols
|
|
|
|
|
in the input files and write them out. It must also write out
|
|
|
|
|
all the symbols in the global hash table. This must be
|
|
|
|
|
controlled by the <<strip>> and <<discard>> fields of the
|
|
|
|
|
<<bfd_link_info>> structure.
|
|
|
|
|
|
|
|
|
|
The local symbols of the input files will not have been
|
|
|
|
|
entered into the linker hash table. The <<_bfd_final_link>>
|
|
|
|
|
routine must consider each input file and include the symbols
|
|
|
|
|
in the output file. It may be convenient to do this when
|
|
|
|
|
looking through the <<link_order>> structures, or it may be
|
|
|
|
|
done by stepping through the <<input_bfds>> list.
|
|
|
|
|
|
|
|
|
|
The <<_bfd_final_link>> routine must also traverse the global
|
|
|
|
|
hash table to gather all the externally visible symbols. It
|
|
|
|
|
is possible that most of the externally visible symbols may be
|
|
|
|
|
written out when considering the symbols of each input file,
|
|
|
|
|
but it is still necessary to traverse the hash table since the
|
|
|
|
|
linker script may have defined some symbols that are not in
|
|
|
|
|
any of the input files.
|
|
|
|
|
|
|
|
|
|
The <<strip>> field of the <<bfd_link_info>> structure
|
|
|
|
|
controls which symbols are written out. The possible values
|
|
|
|
|
are listed in <<bfdlink.h>>. If the value is <<strip_some>>,
|
|
|
|
|
then the <<keep_hash>> field of the <<bfd_link_info>>
|
|
|
|
|
structure is a hash table of symbols to keep; each symbol
|
|
|
|
|
should be looked up in this hash table, and only symbols which
|
|
|
|
|
are present should be included in the output file.
|
|
|
|
|
|
|
|
|
|
If the <<strip>> field of the <<bfd_link_info>> structure
|
|
|
|
|
permits local symbols to be written out, the <<discard>> field
|
|
|
|
|
is used to further controls which local symbols are included
|
|
|
|
|
in the output file. If the value is <<discard_l>>, then all
|
|
|
|
|
local symbols which begin with a certain prefix are discarded;
|
|
|
|
|
this is controlled by the <<bfd_is_local_label_name>> entry point.
|
|
|
|
|
|
|
|
|
|
The a.out backend handles symbols by calling
|
|
|
|
|
<<aout_link_write_symbols>> on each input BFD and then
|
|
|
|
|
traversing the global hash table with the function
|
|
|
|
|
<<aout_link_write_other_symbol>>. It builds a string table
|
|
|
|
|
while writing out the symbols, which is written to the output
|
|
|
|
|
file at the end of <<NAME(aout,final_link)>>.
|
|
|
|
|
*/
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_link_add_object_symbols
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_boolean collect);
|
|
|
|
|
static bfd_boolean generic_link_add_symbols
|
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_boolean);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_link_check_archive_element_no_collect
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_boolean *);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_link_check_archive_element_collect
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_boolean *);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_link_check_archive_element
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_boolean *, bfd_boolean);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_link_add_symbol_list
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **,
|
|
|
|
|
bfd_boolean);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean generic_add_output_symbol
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, size_t *psymalloc, asymbol *);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean default_data_link_order
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean default_indirect_link_order
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd *, struct bfd_link_info *, asection *, struct bfd_link_order *,
|
|
|
|
|
bfd_boolean);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* The link hash table structure is defined in bfdlink.h. It provides
|
|
|
|
|
a base hash table which the backend specific hash tables are built
|
|
|
|
|
upon. */
|
|
|
|
|
|
|
|
|
|
/* Routine to create an entry in the link hash table. */
|
|
|
|
|
|
|
|
|
|
struct bfd_hash_entry *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_link_hash_newfunc (struct bfd_hash_entry *entry,
|
|
|
|
|
struct bfd_hash_table *table,
|
|
|
|
|
const char *string)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Allocate the structure if it has not already been allocated by a
|
|
|
|
|
subclass. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
if (entry == NULL)
|
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
entry = bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry));
|
2001-09-29 08:21:59 +02:00
|
|
|
|
if (entry == NULL)
|
|
|
|
|
return entry;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Call the allocation method of the superclass. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
entry = bfd_hash_newfunc (entry, table, string);
|
|
|
|
|
if (entry)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2001-09-29 08:21:59 +02:00
|
|
|
|
struct bfd_link_hash_entry *h = (struct bfd_link_hash_entry *) entry;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Initialize the local fields. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
h->type = bfd_link_hash_new;
|
2005-02-03 14:54:30 +01:00
|
|
|
|
memset (&h->u.undef.next, 0,
|
|
|
|
|
(sizeof (struct bfd_link_hash_entry)
|
|
|
|
|
- offsetof (struct bfd_link_hash_entry, u.undef.next)));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2001-09-29 08:21:59 +02:00
|
|
|
|
return entry;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Initialize a link hash table. The BFD argument is the one
|
|
|
|
|
responsible for creating this table. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_link_hash_table_init
|
|
|
|
|
(struct bfd_link_hash_table *table,
|
2008-02-15 04:35:53 +01:00
|
|
|
|
bfd *abfd ATTRIBUTE_UNUSED,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
|
|
|
|
|
struct bfd_hash_table *,
|
2006-03-16 13:20:16 +01:00
|
|
|
|
const char *),
|
|
|
|
|
unsigned int entsize)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
table->undefs = NULL;
|
|
|
|
|
table->undefs_tail = NULL;
|
2001-08-24 18:36:04 +02:00
|
|
|
|
table->type = bfd_link_generic_hash_table;
|
|
|
|
|
|
2006-03-16 13:20:16 +01:00
|
|
|
|
return bfd_hash_table_init (&table->table, newfunc, entsize);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
/* Look up a symbol in a link hash table. If follow is TRUE, we
|
1999-05-03 09:29:11 +02:00
|
|
|
|
follow bfd_link_hash_indirect and bfd_link_hash_warning links to
|
|
|
|
|
the real symbol. */
|
|
|
|
|
|
|
|
|
|
struct bfd_link_hash_entry *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_link_hash_lookup (struct bfd_link_hash_table *table,
|
|
|
|
|
const char *string,
|
|
|
|
|
bfd_boolean create,
|
|
|
|
|
bfd_boolean copy,
|
|
|
|
|
bfd_boolean follow)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry *ret;
|
|
|
|
|
|
|
|
|
|
ret = ((struct bfd_link_hash_entry *)
|
|
|
|
|
bfd_hash_lookup (&table->table, string, create, copy));
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (follow && ret != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
while (ret->type == bfd_link_hash_indirect
|
|
|
|
|
|| ret->type == bfd_link_hash_warning)
|
|
|
|
|
ret = ret->u.i.link;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Look up a symbol in the main linker hash table if the symbol might
|
|
|
|
|
be wrapped. This should only be used for references to an
|
|
|
|
|
undefined symbol, not for definitions of a symbol. */
|
|
|
|
|
|
|
|
|
|
struct bfd_link_hash_entry *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_wrapped_link_hash_lookup (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
const char *string,
|
|
|
|
|
bfd_boolean create,
|
|
|
|
|
bfd_boolean copy,
|
|
|
|
|
bfd_boolean follow)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (info->wrap_hash != NULL)
|
|
|
|
|
{
|
|
|
|
|
const char *l;
|
2004-03-22 23:58:04 +01:00
|
|
|
|
char prefix = '\0';
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
l = string;
|
2004-03-22 23:58:04 +01:00
|
|
|
|
if (*l == bfd_get_symbol_leading_char (abfd) || *l == info->wrap_char)
|
|
|
|
|
{
|
|
|
|
|
prefix = *l;
|
|
|
|
|
++l;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
#undef WRAP
|
|
|
|
|
#define WRAP "__wrap_"
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
if (bfd_hash_lookup (info->wrap_hash, l, FALSE, FALSE) != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char *n;
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
|
|
|
|
|
|
|
|
|
/* This symbol is being wrapped. We want to replace all
|
|
|
|
|
references to SYM with references to __wrap_SYM. */
|
|
|
|
|
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
amt = strlen (l) + sizeof WRAP + 1;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
n = bfd_malloc (amt);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (n == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2004-03-22 23:58:04 +01:00
|
|
|
|
n[0] = prefix;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
n[1] = '\0';
|
|
|
|
|
strcat (n, WRAP);
|
|
|
|
|
strcat (n, l);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h = bfd_link_hash_lookup (info->hash, n, create, TRUE, follow);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
free (n);
|
|
|
|
|
return h;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#undef WRAP
|
|
|
|
|
|
2006-09-16 20:12:17 +02:00
|
|
|
|
#undef REAL
|
1999-05-03 09:29:11 +02:00
|
|
|
|
#define REAL "__real_"
|
|
|
|
|
|
|
|
|
|
if (*l == '_'
|
2006-09-16 20:12:17 +02:00
|
|
|
|
&& CONST_STRNEQ (l, REAL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
&& bfd_hash_lookup (info->wrap_hash, l + sizeof REAL - 1,
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE) != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char *n;
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
|
|
|
|
|
|
|
|
|
/* This is a reference to __real_SYM, where SYM is being
|
|
|
|
|
wrapped. We want to replace all references to __real_SYM
|
|
|
|
|
with references to SYM. */
|
|
|
|
|
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
amt = strlen (l + sizeof REAL - 1) + 2;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
n = bfd_malloc (amt);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (n == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2004-03-22 23:58:04 +01:00
|
|
|
|
n[0] = prefix;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
n[1] = '\0';
|
|
|
|
|
strcat (n, l + sizeof REAL - 1);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h = bfd_link_hash_lookup (info->hash, n, create, TRUE, follow);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
free (n);
|
|
|
|
|
return h;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#undef REAL
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return bfd_link_hash_lookup (info->hash, string, create, copy, follow);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Traverse a generic link hash table. The only reason this is not a
|
|
|
|
|
macro is to do better type checking. This code presumes that an
|
|
|
|
|
argument passed as a struct bfd_hash_entry * may be caught as a
|
|
|
|
|
struct bfd_link_hash_entry * with no explicit cast required on the
|
|
|
|
|
call. */
|
|
|
|
|
|
2001-01-03 20:26:07 +01:00
|
|
|
|
void
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_link_hash_traverse
|
|
|
|
|
(struct bfd_link_hash_table *table,
|
|
|
|
|
bfd_boolean (*func) (struct bfd_link_hash_entry *, void *),
|
|
|
|
|
void *info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
bfd_hash_traverse (&table->table,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(bfd_boolean (*) (struct bfd_hash_entry *, void *)) func,
|
1999-05-03 09:29:11 +02:00
|
|
|
|
info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add a symbol to the linker hash table undefs list. */
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
void
|
|
|
|
|
bfd_link_add_undef (struct bfd_link_hash_table *table,
|
|
|
|
|
struct bfd_link_hash_entry *h)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2004-09-17 09:14:33 +02:00
|
|
|
|
BFD_ASSERT (h->u.undef.next == NULL);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (table->undefs_tail != NULL)
|
2004-09-17 09:14:33 +02:00
|
|
|
|
table->undefs_tail->u.undef.next = h;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (table->undefs == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
table->undefs = h;
|
|
|
|
|
table->undefs_tail = h;
|
|
|
|
|
}
|
2005-02-01 02:11:27 +01:00
|
|
|
|
|
|
|
|
|
/* The undefs list was designed so that in normal use we don't need to
|
|
|
|
|
remove entries. However, if symbols on the list are changed from
|
|
|
|
|
bfd_link_hash_undefined to either bfd_link_hash_undefweak or
|
|
|
|
|
bfd_link_hash_new for some reason, then they must be removed from the
|
|
|
|
|
list. Failure to do so might result in the linker attempting to add
|
|
|
|
|
the symbol to the list again at a later stage. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
bfd_link_repair_undef_list (struct bfd_link_hash_table *table)
|
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry **pun;
|
|
|
|
|
|
|
|
|
|
pun = &table->undefs;
|
|
|
|
|
while (*pun != NULL)
|
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry *h = *pun;
|
|
|
|
|
|
|
|
|
|
if (h->type == bfd_link_hash_new
|
|
|
|
|
|| h->type == bfd_link_hash_undefweak)
|
|
|
|
|
{
|
|
|
|
|
*pun = h->u.undef.next;
|
|
|
|
|
h->u.undef.next = NULL;
|
|
|
|
|
if (h == table->undefs_tail)
|
|
|
|
|
{
|
|
|
|
|
if (pun == &table->undefs)
|
|
|
|
|
table->undefs_tail = NULL;
|
|
|
|
|
else
|
|
|
|
|
/* pun points at an u.undef.next field. Go back to
|
|
|
|
|
the start of the link_hash_entry. */
|
|
|
|
|
table->undefs_tail = (struct bfd_link_hash_entry *)
|
|
|
|
|
((char *) pun - ((char *) &h->u.undef.next - (char *) h));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pun = &h->u.undef.next;
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-12-20 23:41:13 +01:00
|
|
|
|
/* Routine to create an entry in a generic link hash table. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
struct bfd_hash_entry *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_hash_newfunc (struct bfd_hash_entry *entry,
|
|
|
|
|
struct bfd_hash_table *table,
|
|
|
|
|
const char *string)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Allocate the structure if it has not already been allocated by a
|
|
|
|
|
subclass. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
if (entry == NULL)
|
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
entry =
|
* aoutx.h (NAME(aout,swap_ext_reloc_in)): Cast bytes->r_index to
unsigned int. Cast RELOC_BASE10, RELOC_BASE13 and RELOC_BASE22 to
unsigned int.
(NAME(aout,final_link)): Cast enum used in assignment.
(aout_link_write_symbols): Cast enums in comparisons, int values to
boolean, enums in assignments to int.
(aout_link_input_section_std): Cast rel->r_index to unsigned int.
(aout_link_input_section_ext): Likewise. Cast enums used in comparisons
with unsigned ints.
(aout_link_reloc_link_order): Cast enum to int in assignment.
* archive.c (_bfd_generic_read_ar_hdr_mag): Cast result of memchr
calls to char *.
* bfd-in.h (bfd_set_section_vma): Cast enum true to unsigned int in
assignment.
* bfd-in2.h (bfd_set_section_vma): Likewise.
* bfd.c (bfd_record_phdr): Cast enums in assignments.
* binary.c (bfd_alloc): Cast enum to long.
* coffgen.c (_bfd_coff_is_local_label_name): Cast return to boolean.
* dwarf2.c (read_abbrevs): Add casts to enum types.
(read_attribute_value): Likewise.
(arange_add): Cast result of bfd_zalloc call.
(comp_unit_contains_address): Return true and false.
(comp_unit_find_nearest_line): Cast return to boolean.
* format.c (bfd_check_format_matches, bfd_set_format): Likewise.
* gen-aout.c: define macro '_' if not defined.
* libbfd.c (bfd_realloc): Cast malloc and realloc to PTR.
(bfd_bwrite): Cast bfd_realloc to bfd_byte *.
(bfd_write_bigendian_4byte_int): Cast return to boolean.
(bfd_seek): Cast bfd_realloc to bfd_byte *.
(bfd_generic_is_local_label_name): Cast return to boolean.
* libcoff.h (_bfd_coff_adjust_symndx): Remove extraneous '\'.
* linker.c (_bfd_link_hash_newfunc): Cast bfd_hash_allocate result to
struct bfd_hash_entry *.
(_bfd_generic_link_hash_newfunc): likewise.
(_bfd_generic_final_link): Cast enum to unsigned int.
* merge.c (sec_merge_emit): Cast return to boolean.
(merge_strings): Add casts to const unsigned char *.
* reloc.c (bfd_get_reloc_code_name): Cast enums in comparison to int.
(bfd_generic_get_relocated_section_content): Cast enum to unsigned int.
* section.c (bfd_section_hash_newfunc): Cast bfd_hash_allocate result to
struct bfd_hash_entry *.
(bfd_set_section_content): Add cast to PTR in comparison.
* simple.c (simple_dummy_warning, simple_dummy_undefined_symbol,
simple_dummy_reloc_overflow, simple_dummy_reloc_dangerous,
simple_dummy_unattached_reloc,
bfd_simple_get_relocated_section_contents): Add K&R declarations and
function definitions.
* srec.c (S3Forced): Initialize to false.
(srec_get_symtab): Cast return value from bfd_alloc to asymbol *.
* stabs.c (_bfd_link_section_stabs): Cast enum to int in comparisons.
(_bfd_discard_section_stabs): Likewise. Also cast return to boolean.
* syms.c (bfd_is_undefined_symclass): Cast return to boolean.
(_bfd_stab_section_find_nearest_line): Cast enum to bfd_byte in
comparisons.
2002-10-25 04:45:54 +02:00
|
|
|
|
bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry));
|
2001-09-29 08:21:59 +02:00
|
|
|
|
if (entry == NULL)
|
|
|
|
|
return entry;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Call the allocation method of the superclass. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
entry = _bfd_link_hash_newfunc (entry, table, string);
|
|
|
|
|
if (entry)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2001-09-29 08:21:59 +02:00
|
|
|
|
struct generic_link_hash_entry *ret;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Set local fields. */
|
2001-09-29 08:21:59 +02:00
|
|
|
|
ret = (struct generic_link_hash_entry *) entry;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
ret->written = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
ret->sym = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2001-09-29 08:21:59 +02:00
|
|
|
|
return entry;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2002-12-20 23:41:13 +01:00
|
|
|
|
/* Create a generic link hash table. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
struct bfd_link_hash_table *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_hash_table_create (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct generic_link_hash_table *ret;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt = sizeof (struct generic_link_hash_table);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
ret = bfd_malloc (amt);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (ret == NULL)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
return NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (! _bfd_link_hash_table_init (&ret->root, abfd,
|
2006-03-16 13:20:16 +01:00
|
|
|
|
_bfd_generic_link_hash_newfunc,
|
|
|
|
|
sizeof (struct generic_link_hash_entry)))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
free (ret);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
return NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
return &ret->root;
|
|
|
|
|
}
|
|
|
|
|
|
2002-04-04 21:53:38 +02:00
|
|
|
|
void
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_hash_table_free (struct bfd_link_hash_table *hash)
|
2002-04-04 21:53:38 +02:00
|
|
|
|
{
|
|
|
|
|
struct generic_link_hash_table *ret
|
|
|
|
|
= (struct generic_link_hash_table *) hash;
|
|
|
|
|
|
|
|
|
|
bfd_hash_table_free (&ret->root.table);
|
|
|
|
|
free (ret);
|
|
|
|
|
}
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Grab the symbols for an object file when doing a generic link. We
|
|
|
|
|
store the symbols in the outsymbols field. We need to keep them
|
|
|
|
|
around for the entire link to ensure that we only read them once.
|
|
|
|
|
If we read them multiple times, we might wind up with relocs and
|
|
|
|
|
the hash table pointing to different instances of the symbol
|
|
|
|
|
structure. */
|
|
|
|
|
|
2008-08-17 05:12:50 +02:00
|
|
|
|
bfd_boolean
|
|
|
|
|
bfd_generic_link_read_symbols (bfd *abfd)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (bfd_get_outsymbols (abfd) == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
long symsize;
|
|
|
|
|
long symcount;
|
|
|
|
|
|
|
|
|
|
symsize = bfd_get_symtab_upper_bound (abfd);
|
|
|
|
|
if (symsize < 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_get_outsymbols (abfd) = bfd_alloc (abfd, symsize);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (bfd_get_outsymbols (abfd) == NULL && symsize != 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
symcount = bfd_canonicalize_symtab (abfd, bfd_get_outsymbols (abfd));
|
|
|
|
|
if (symcount < 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_get_symcount (abfd) = symcount;
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generic function to add symbols to from an object file to the
|
|
|
|
|
global hash table. This version does not automatically collect
|
|
|
|
|
constructors by name. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return generic_link_add_symbols (abfd, info, FALSE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generic function to add symbols from an object file to the global
|
|
|
|
|
hash table. This version automatically collects constructors by
|
|
|
|
|
name, as the collect2 program does. It should be used for any
|
|
|
|
|
target which does not provide some other mechanism for setting up
|
|
|
|
|
constructors and destructors; these are approximately those targets
|
|
|
|
|
for which gcc uses collect2 and do not support stabs. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_add_symbols_collect (bfd *abfd, struct bfd_link_info *info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return generic_link_add_symbols (abfd, info, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2002-05-15 02:18:58 +02:00
|
|
|
|
/* Indicate that we are only retrieving symbol values from this
|
|
|
|
|
section. We want the symbols to act as though the values in the
|
|
|
|
|
file are absolute. */
|
|
|
|
|
|
|
|
|
|
void
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_just_syms (asection *sec,
|
|
|
|
|
struct bfd_link_info *info ATTRIBUTE_UNUSED)
|
2002-05-15 02:18:58 +02:00
|
|
|
|
{
|
|
|
|
|
sec->output_section = bfd_abs_section_ptr;
|
|
|
|
|
sec->output_offset = sec->vma;
|
|
|
|
|
}
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Add symbols from an object file to the global hash table. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_add_symbols (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean collect)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean ret;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
switch (bfd_get_format (abfd))
|
|
|
|
|
{
|
|
|
|
|
case bfd_object:
|
|
|
|
|
ret = generic_link_add_object_symbols (abfd, info, collect);
|
|
|
|
|
break;
|
|
|
|
|
case bfd_archive:
|
|
|
|
|
ret = (_bfd_generic_link_add_archive_symbols
|
|
|
|
|
(abfd, info,
|
|
|
|
|
(collect
|
|
|
|
|
? generic_link_check_archive_element_collect
|
|
|
|
|
: generic_link_check_archive_element_no_collect)));
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
bfd_set_error (bfd_error_wrong_format);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
ret = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add symbols from an object file to the global hash table. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_add_object_symbols (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean collect)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type symcount;
|
Index: sim/frv/ChangeLog
2003-10-30 Andrew Cagney <cagney@redhat.com>
* traps.c: Replace "struct symbol_cache_entry" with "struct
bfd_symbol".
Index: sim/d10v/ChangeLog
2003-10-30 Andrew Cagney <cagney@redhat.com>
* simops.c: Replace "struct symbol_cache_entry" with "struct
bfd_symbol".
Index: sim/common/ChangeLog
2003-10-30 Andrew Cagney <cagney@redhat.com>
* sim-trace.c, sim-base.h: Replace "struct symbol_cache_entry"
with "struct bfd_symbol".
Index: ld/ChangeLog
2003-10-30 Andrew Cagney <cagney@redhat.com>
* emultempl/pe.em, pe-dll.c: Replace "struct symbol_cache_entry"
with "struct bfd_symbol".
Index: bfd/ChangeLog
2003-10-30 Andrew Cagney <cagney@redhat.com>
* syms.c: Replace "struct symbol_cache_entry" with "struct
bfd_symbol".
* vms.h, targets.c, section.c, reloc.c, peicode.h: Ditto.
* mipsbsd.c, elf.c, linker.c, elf-bfd.h, ecoff.c: Ditto.
* cpu-z8k.c, cpu-ns32k.c, cpu-h8500.c, bfd.c, bfd-in.h: Ditto.
* bfd-in2.h: Re-generate.
2003-10-31 06:32:46 +01:00
|
|
|
|
struct bfd_symbol **outsyms;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
|
2008-08-17 05:12:50 +02:00
|
|
|
|
if (!bfd_generic_link_read_symbols (abfd))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
symcount = _bfd_generic_link_get_symcount (abfd);
|
|
|
|
|
outsyms = _bfd_generic_link_get_symbols (abfd);
|
|
|
|
|
return generic_link_add_symbol_list (abfd, info, symcount, outsyms, collect);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We build a hash table of all symbols defined in an archive. */
|
|
|
|
|
|
|
|
|
|
/* An archive symbol may be defined by multiple archive elements.
|
|
|
|
|
This linked list is used to hold the elements. */
|
|
|
|
|
|
|
|
|
|
struct archive_list
|
|
|
|
|
{
|
|
|
|
|
struct archive_list *next;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
unsigned int indx;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* An entry in an archive hash table. */
|
|
|
|
|
|
|
|
|
|
struct archive_hash_entry
|
|
|
|
|
{
|
|
|
|
|
struct bfd_hash_entry root;
|
|
|
|
|
/* Where the symbol is defined. */
|
|
|
|
|
struct archive_list *defs;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* An archive hash table itself. */
|
|
|
|
|
|
|
|
|
|
struct archive_hash_table
|
|
|
|
|
{
|
|
|
|
|
struct bfd_hash_table table;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Create a new entry for an archive hash table. */
|
|
|
|
|
|
|
|
|
|
static struct bfd_hash_entry *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
archive_hash_newfunc (struct bfd_hash_entry *entry,
|
|
|
|
|
struct bfd_hash_table *table,
|
|
|
|
|
const char *string)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct archive_hash_entry *ret = (struct archive_hash_entry *) entry;
|
|
|
|
|
|
|
|
|
|
/* Allocate the structure if it has not already been allocated by a
|
|
|
|
|
subclass. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (ret == NULL)
|
|
|
|
|
ret = bfd_hash_allocate (table, sizeof (struct archive_hash_entry));
|
|
|
|
|
if (ret == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
/* Call the allocation method of the superclass. */
|
|
|
|
|
ret = ((struct archive_hash_entry *)
|
|
|
|
|
bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
/* Initialize the local fields. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
ret->defs = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
return &ret->root;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Initialize an archive hash table. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
archive_hash_table_init
|
|
|
|
|
(struct archive_hash_table *table,
|
|
|
|
|
struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
|
|
|
|
|
struct bfd_hash_table *,
|
2006-03-16 13:20:16 +01:00
|
|
|
|
const char *),
|
|
|
|
|
unsigned int entsize)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2006-03-16 13:20:16 +01:00
|
|
|
|
return bfd_hash_table_init (&table->table, newfunc, entsize);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Look up an entry in an archive hash table. */
|
|
|
|
|
|
|
|
|
|
#define archive_hash_lookup(t, string, create, copy) \
|
|
|
|
|
((struct archive_hash_entry *) \
|
|
|
|
|
bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
|
|
|
|
|
|
|
|
|
|
/* Allocate space in an archive hash table. */
|
|
|
|
|
|
|
|
|
|
#define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
|
|
|
|
|
|
|
|
|
|
/* Free an archive hash table. */
|
|
|
|
|
|
|
|
|
|
#define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
|
|
|
|
|
|
|
|
|
|
/* Generic function to add symbols from an archive file to the global
|
|
|
|
|
hash file. This function presumes that the archive symbol table
|
|
|
|
|
has already been read in (this is normally done by the
|
|
|
|
|
bfd_check_format entry point). It looks through the undefined and
|
|
|
|
|
common symbols and searches the archive symbol table for them. If
|
|
|
|
|
it finds an entry, it includes the associated object file in the
|
|
|
|
|
link.
|
|
|
|
|
|
|
|
|
|
The old linker looked through the archive symbol table for
|
|
|
|
|
undefined symbols. We do it the other way around, looking through
|
|
|
|
|
undefined symbols for symbols defined in the archive. The
|
|
|
|
|
advantage of the newer scheme is that we only have to look through
|
|
|
|
|
the list of undefined symbols once, whereas the old method had to
|
|
|
|
|
re-search the symbol table each time a new object file was added.
|
|
|
|
|
|
|
|
|
|
The CHECKFN argument is used to see if an object file should be
|
2002-11-30 09:39:46 +01:00
|
|
|
|
included. CHECKFN should set *PNEEDED to TRUE if the object file
|
1999-05-03 09:29:11 +02:00
|
|
|
|
should be included, and must also call the bfd_link_info
|
|
|
|
|
add_archive_element callback function and handle adding the symbols
|
2002-11-30 09:39:46 +01:00
|
|
|
|
to the global hash table. CHECKFN should only return FALSE if some
|
1999-05-03 09:29:11 +02:00
|
|
|
|
sort of error occurs.
|
|
|
|
|
|
|
|
|
|
For some formats, such as a.out, it is possible to look through an
|
|
|
|
|
object file but not actually include it in the link. The
|
|
|
|
|
archive_pass field in a BFD is used to avoid checking the symbols
|
|
|
|
|
of an object files too many times. When an object is included in
|
|
|
|
|
the link, archive_pass is set to -1. If an object is scanned but
|
|
|
|
|
not included, archive_pass is set to the pass number. The pass
|
|
|
|
|
number is incremented each time a new object file is included. The
|
|
|
|
|
pass number is used because when a new object file is included it
|
|
|
|
|
may create new undefined symbols which cause a previously examined
|
|
|
|
|
object file to be included. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_add_archive_symbols
|
|
|
|
|
(bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean (*checkfn) (bfd *, struct bfd_link_info *, bfd_boolean *))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
carsym *arsyms;
|
|
|
|
|
carsym *arsym_end;
|
|
|
|
|
register carsym *arsym;
|
|
|
|
|
int pass;
|
|
|
|
|
struct archive_hash_table arsym_hash;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
unsigned int indx;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
struct bfd_link_hash_entry **pundef;
|
|
|
|
|
|
|
|
|
|
if (! bfd_has_map (abfd))
|
|
|
|
|
{
|
|
|
|
|
/* An empty archive is a special case. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_set_error (bfd_error_no_armap);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
arsyms = bfd_ardata (abfd)->symdefs;
|
|
|
|
|
arsym_end = arsyms + bfd_ardata (abfd)->symdef_count;
|
|
|
|
|
|
|
|
|
|
/* In order to quickly determine whether an symbol is defined in
|
|
|
|
|
this archive, we build a hash table of the symbols. */
|
2006-03-16 13:20:16 +01:00
|
|
|
|
if (! archive_hash_table_init (&arsym_hash, archive_hash_newfunc,
|
|
|
|
|
sizeof (struct archive_hash_entry)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++)
|
|
|
|
|
{
|
|
|
|
|
struct archive_hash_entry *arh;
|
|
|
|
|
struct archive_list *l, **pp;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
arh = archive_hash_lookup (&arsym_hash, arsym->name, TRUE, FALSE);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (arh == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
goto error_return;
|
|
|
|
|
l = ((struct archive_list *)
|
|
|
|
|
archive_hash_allocate (&arsym_hash, sizeof (struct archive_list)));
|
|
|
|
|
if (l == NULL)
|
|
|
|
|
goto error_return;
|
|
|
|
|
l->indx = indx;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (pp = &arh->defs; *pp != NULL; pp = &(*pp)->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
;
|
|
|
|
|
*pp = l;
|
|
|
|
|
l->next = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The archive_pass field in the archive itself is used to
|
|
|
|
|
initialize PASS, sine we may search the same archive multiple
|
|
|
|
|
times. */
|
|
|
|
|
pass = abfd->archive_pass + 1;
|
|
|
|
|
|
|
|
|
|
/* New undefined symbols are added to the end of the list, so we
|
|
|
|
|
only need to look through it once. */
|
|
|
|
|
pundef = &info->hash->undefs;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
while (*pundef != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
|
|
|
|
struct archive_hash_entry *arh;
|
|
|
|
|
struct archive_list *l;
|
|
|
|
|
|
|
|
|
|
h = *pundef;
|
|
|
|
|
|
|
|
|
|
/* When a symbol is defined, it is not necessarily removed from
|
|
|
|
|
the list. */
|
|
|
|
|
if (h->type != bfd_link_hash_undefined
|
|
|
|
|
&& h->type != bfd_link_hash_common)
|
|
|
|
|
{
|
|
|
|
|
/* Remove this entry from the list, for general cleanliness
|
|
|
|
|
and because we are going to look through the list again
|
|
|
|
|
if we search any more libraries. We can't remove the
|
|
|
|
|
entry if it is the tail, because that would lose any
|
|
|
|
|
entries we add to the list later on (it would also cause
|
|
|
|
|
us to lose track of whether the symbol has been
|
|
|
|
|
referenced). */
|
|
|
|
|
if (*pundef != info->hash->undefs_tail)
|
2004-09-17 09:14:33 +02:00
|
|
|
|
*pundef = (*pundef)->u.undef.next;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2004-09-17 09:14:33 +02:00
|
|
|
|
pundef = &(*pundef)->u.undef.next;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Look for this symbol in the archive symbol map. */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
arh = archive_hash_lookup (&arsym_hash, h->root.string, FALSE, FALSE);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (arh == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
/* If we haven't found the exact symbol we're looking for,
|
2001-08-03 01:05:54 +02:00
|
|
|
|
let's look for its import thunk */
|
|
|
|
|
if (info->pei386_auto_import)
|
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt = strlen (h->root.string) + 10;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
char *buf = bfd_malloc (amt);
|
2001-08-24 05:56:28 +02:00
|
|
|
|
if (buf == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2001-08-24 05:56:28 +02:00
|
|
|
|
|
2001-08-03 01:05:54 +02:00
|
|
|
|
sprintf (buf, "__imp_%s", h->root.string);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
arh = archive_hash_lookup (&arsym_hash, buf, FALSE, FALSE);
|
2001-08-24 05:56:28 +02:00
|
|
|
|
free(buf);
|
2001-08-03 01:05:54 +02:00
|
|
|
|
}
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (arh == NULL)
|
2001-08-03 01:05:54 +02:00
|
|
|
|
{
|
2004-09-17 09:14:33 +02:00
|
|
|
|
pundef = &(*pundef)->u.undef.next;
|
2001-08-03 01:05:54 +02:00
|
|
|
|
continue;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
/* Look at all the objects which define this symbol. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (l = arh->defs; l != NULL; l = l->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
bfd *element;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean needed;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* If the symbol has gotten defined along the way, quit. */
|
|
|
|
|
if (h->type != bfd_link_hash_undefined
|
|
|
|
|
&& h->type != bfd_link_hash_common)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
element = bfd_get_elt_at_index (abfd, l->indx);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (element == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
|
|
/* If we've already included this element, or if we've
|
|
|
|
|
already checked it on this pass, continue. */
|
|
|
|
|
if (element->archive_pass == -1
|
|
|
|
|
|| element->archive_pass == pass)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* If we can't figure this element out, just ignore it. */
|
|
|
|
|
if (! bfd_check_format (element, bfd_object))
|
|
|
|
|
{
|
|
|
|
|
element->archive_pass = -1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* CHECKFN will see if this element should be included, and
|
|
|
|
|
go ahead and include it if appropriate. */
|
|
|
|
|
if (! (*checkfn) (element, info, &needed))
|
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
|
|
if (! needed)
|
|
|
|
|
element->archive_pass = pass;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
element->archive_pass = -1;
|
|
|
|
|
|
|
|
|
|
/* Increment the pass count to show that we may need to
|
|
|
|
|
recheck object files which were already checked. */
|
|
|
|
|
++pass;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-09-17 09:14:33 +02:00
|
|
|
|
pundef = &(*pundef)->u.undef.next;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
archive_hash_table_free (&arsym_hash);
|
|
|
|
|
|
|
|
|
|
/* Save PASS in case we are called again. */
|
|
|
|
|
abfd->archive_pass = pass;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
|
archive_hash_table_free (&arsym_hash);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* See if we should include an archive element. This version is used
|
|
|
|
|
when we do not want to automatically collect constructors based on
|
|
|
|
|
the symbol name, presumably because we have some other mechanism
|
|
|
|
|
for finding them. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_check_archive_element_no_collect (
|
|
|
|
|
bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean *pneeded)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return generic_link_check_archive_element (abfd, info, pneeded, FALSE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* See if we should include an archive element. This version is used
|
|
|
|
|
when we want to automatically collect constructors based on the
|
|
|
|
|
symbol name, as collect2 does. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_check_archive_element_collect (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean *pneeded)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return generic_link_check_archive_element (abfd, info, pneeded, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* See if we should include an archive element. Optionally collect
|
|
|
|
|
constructors. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_check_archive_element (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_boolean *pneeded,
|
|
|
|
|
bfd_boolean collect)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asymbol **pp, **ppend;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
*pneeded = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2008-08-17 05:12:50 +02:00
|
|
|
|
if (!bfd_generic_link_read_symbols (abfd))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
pp = _bfd_generic_link_get_symbols (abfd);
|
|
|
|
|
ppend = pp + _bfd_generic_link_get_symcount (abfd);
|
|
|
|
|
for (; pp < ppend; pp++)
|
|
|
|
|
{
|
|
|
|
|
asymbol *p;
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
|
|
|
|
|
|
|
|
|
p = *pp;
|
|
|
|
|
|
|
|
|
|
/* We are only interested in globally visible symbols. */
|
|
|
|
|
if (! bfd_is_com_section (p->section)
|
|
|
|
|
&& (p->flags & (BSF_GLOBAL | BSF_INDIRECT | BSF_WEAK)) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* We are only interested if we know something about this
|
|
|
|
|
symbol, and it is undefined or common. An undefined weak
|
|
|
|
|
symbol (type bfd_link_hash_undefweak) is not considered to be
|
|
|
|
|
a reference when pulling files out of an archive. See the
|
|
|
|
|
SVR4 ABI, p. 4-27. */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), FALSE,
|
|
|
|
|
FALSE, TRUE);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h == NULL
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|| (h->type != bfd_link_hash_undefined
|
|
|
|
|
&& h->type != bfd_link_hash_common))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* P is a symbol we are looking for. */
|
|
|
|
|
|
|
|
|
|
if (! bfd_is_com_section (p->section))
|
|
|
|
|
{
|
|
|
|
|
bfd_size_type symcount;
|
|
|
|
|
asymbol **symbols;
|
|
|
|
|
|
|
|
|
|
/* This object file defines this symbol, so pull it in. */
|
|
|
|
|
if (! (*info->callbacks->add_archive_element) (info, abfd,
|
|
|
|
|
bfd_asymbol_name (p)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
symcount = _bfd_generic_link_get_symcount (abfd);
|
|
|
|
|
symbols = _bfd_generic_link_get_symbols (abfd);
|
|
|
|
|
if (! generic_link_add_symbol_list (abfd, info, symcount,
|
|
|
|
|
symbols, collect))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
|
|
|
|
*pneeded = TRUE;
|
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* P is a common symbol. */
|
|
|
|
|
|
|
|
|
|
if (h->type == bfd_link_hash_undefined)
|
|
|
|
|
{
|
|
|
|
|
bfd *symbfd;
|
|
|
|
|
bfd_vma size;
|
|
|
|
|
unsigned int power;
|
|
|
|
|
|
|
|
|
|
symbfd = h->u.undef.abfd;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (symbfd == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* This symbol was created as undefined from outside
|
|
|
|
|
BFD. We assume that we should link in the object
|
|
|
|
|
file. This is for the -u option in the linker. */
|
|
|
|
|
if (! (*info->callbacks->add_archive_element)
|
|
|
|
|
(info, abfd, bfd_asymbol_name (p)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
|
|
|
|
*pneeded = TRUE;
|
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Turn the symbol into a common symbol but do not link in
|
|
|
|
|
the object file. This is how a.out works. Object
|
|
|
|
|
formats that require different semantics must implement
|
|
|
|
|
this function differently. This symbol is already on the
|
|
|
|
|
undefs list. We add the section to a common section
|
|
|
|
|
attached to symbfd to ensure that it is in a BFD which
|
|
|
|
|
will be linked in. */
|
|
|
|
|
h->type = bfd_link_hash_common;
|
|
|
|
|
h->u.c.p =
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_hash_allocate (&info->hash->table,
|
|
|
|
|
sizeof (struct bfd_link_hash_common_entry));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (h->u.c.p == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
size = bfd_asymbol_value (p);
|
|
|
|
|
h->u.c.size = size;
|
|
|
|
|
|
|
|
|
|
power = bfd_log2 (size);
|
|
|
|
|
if (power > 4)
|
|
|
|
|
power = 4;
|
|
|
|
|
h->u.c.p->alignment_power = power;
|
|
|
|
|
|
|
|
|
|
if (p->section == bfd_com_section_ptr)
|
|
|
|
|
h->u.c.p->section = bfd_make_section_old_way (symbfd, "COMMON");
|
|
|
|
|
else
|
|
|
|
|
h->u.c.p->section = bfd_make_section_old_way (symbfd,
|
|
|
|
|
p->section->name);
|
|
|
|
|
h->u.c.p->section->flags = SEC_ALLOC;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Adjust the size of the common symbol if necessary. This
|
|
|
|
|
is how a.out works. Object formats that require
|
|
|
|
|
different semantics must implement this function
|
|
|
|
|
differently. */
|
|
|
|
|
if (bfd_asymbol_value (p) > h->u.c.size)
|
|
|
|
|
h->u.c.size = bfd_asymbol_value (p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This archive element is not needed. */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add the symbols from an object file to the global hash table. ABFD
|
|
|
|
|
is the object file. INFO is the linker information. SYMBOL_COUNT
|
|
|
|
|
is the number of symbols. SYMBOLS is the list of symbols. COLLECT
|
2002-11-30 09:39:46 +01:00
|
|
|
|
is TRUE if constructors should be automatically collected by name
|
1999-05-03 09:29:11 +02:00
|
|
|
|
as is done by collect2. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_link_add_symbol_list (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
bfd_size_type symbol_count,
|
|
|
|
|
asymbol **symbols,
|
|
|
|
|
bfd_boolean collect)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asymbol **pp, **ppend;
|
|
|
|
|
|
|
|
|
|
pp = symbols;
|
|
|
|
|
ppend = symbols + symbol_count;
|
|
|
|
|
for (; pp < ppend; pp++)
|
|
|
|
|
{
|
|
|
|
|
asymbol *p;
|
|
|
|
|
|
|
|
|
|
p = *pp;
|
|
|
|
|
|
|
|
|
|
if ((p->flags & (BSF_INDIRECT
|
|
|
|
|
| BSF_WARNING
|
|
|
|
|
| BSF_GLOBAL
|
|
|
|
|
| BSF_CONSTRUCTOR
|
|
|
|
|
| BSF_WEAK)) != 0
|
|
|
|
|
|| bfd_is_und_section (bfd_get_section (p))
|
|
|
|
|
|| bfd_is_com_section (bfd_get_section (p))
|
|
|
|
|
|| bfd_is_ind_section (bfd_get_section (p)))
|
|
|
|
|
{
|
|
|
|
|
const char *name;
|
|
|
|
|
const char *string;
|
|
|
|
|
struct generic_link_hash_entry *h;
|
2002-10-11 10:33:11 +02:00
|
|
|
|
struct bfd_link_hash_entry *bh;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2007-07-25 01:38:13 +02:00
|
|
|
|
string = name = bfd_asymbol_name (p);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (((p->flags & BSF_INDIRECT) != 0
|
|
|
|
|
|| bfd_is_ind_section (p->section))
|
|
|
|
|
&& pp + 1 < ppend)
|
|
|
|
|
{
|
|
|
|
|
pp++;
|
|
|
|
|
string = bfd_asymbol_name (*pp);
|
|
|
|
|
}
|
|
|
|
|
else if ((p->flags & BSF_WARNING) != 0
|
|
|
|
|
&& pp + 1 < ppend)
|
|
|
|
|
{
|
|
|
|
|
/* The name of P is actually the warning string, and the
|
|
|
|
|
next symbol is the one to warn about. */
|
|
|
|
|
pp++;
|
|
|
|
|
name = bfd_asymbol_name (*pp);
|
|
|
|
|
}
|
|
|
|
|
|
2002-10-11 10:33:11 +02:00
|
|
|
|
bh = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (! (_bfd_generic_link_add_one_symbol
|
|
|
|
|
(info, abfd, name, p->flags, bfd_get_section (p),
|
2002-11-30 09:39:46 +01:00
|
|
|
|
p->value, string, FALSE, collect, &bh)))
|
|
|
|
|
return FALSE;
|
2002-10-11 10:33:11 +02:00
|
|
|
|
h = (struct generic_link_hash_entry *) bh;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* If this is a constructor symbol, and the linker didn't do
|
|
|
|
|
anything with it, then we want to just pass the symbol
|
|
|
|
|
through to the output file. This will happen when
|
|
|
|
|
linking with -r. */
|
|
|
|
|
if ((p->flags & BSF_CONSTRUCTOR) != 0
|
|
|
|
|
&& (h == NULL || h->root.type == bfd_link_hash_new))
|
|
|
|
|
{
|
|
|
|
|
p->udata.p = NULL;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Save the BFD symbol so that we don't lose any backend
|
|
|
|
|
specific information that may be attached to it. We only
|
|
|
|
|
want this one if it gives more information than the
|
|
|
|
|
existing one; we don't want to replace a defined symbol
|
|
|
|
|
with an undefined one. This routine may be called with a
|
|
|
|
|
hash table other than the generic hash table, so we only
|
|
|
|
|
do this if we are certain that the hash table is a
|
|
|
|
|
generic one. */
|
2008-02-15 04:35:53 +01:00
|
|
|
|
if (info->output_bfd->xvec == abfd->xvec)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h->sym == NULL
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|| (! bfd_is_und_section (bfd_get_section (p))
|
|
|
|
|
&& (! bfd_is_com_section (bfd_get_section (p))
|
|
|
|
|
|| bfd_is_und_section (bfd_get_section (h->sym)))))
|
|
|
|
|
{
|
|
|
|
|
h->sym = p;
|
|
|
|
|
/* BSF_OLD_COMMON is a hack to support COFF reloc
|
|
|
|
|
reading, and it should go away when the COFF
|
|
|
|
|
linker is switched to the new version. */
|
|
|
|
|
if (bfd_is_com_section (bfd_get_section (p)))
|
|
|
|
|
p->flags |= BSF_OLD_COMMON;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Store a back pointer from the symbol to the hash
|
|
|
|
|
table entry for the benefit of relaxation code until
|
|
|
|
|
it gets rewritten to not use asymbol structures.
|
|
|
|
|
Setting this is also used to check whether these
|
|
|
|
|
symbols were set up by the generic linker. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
p->udata.p = h;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We use a state table to deal with adding symbols from an object
|
|
|
|
|
file. The first index into the state table describes the symbol
|
|
|
|
|
from the object file. The second index into the state table is the
|
|
|
|
|
type of the symbol in the hash table. */
|
|
|
|
|
|
|
|
|
|
/* The symbol from the object file is turned into one of these row
|
|
|
|
|
values. */
|
|
|
|
|
|
|
|
|
|
enum link_row
|
|
|
|
|
{
|
|
|
|
|
UNDEF_ROW, /* Undefined. */
|
|
|
|
|
UNDEFW_ROW, /* Weak undefined. */
|
|
|
|
|
DEF_ROW, /* Defined. */
|
|
|
|
|
DEFW_ROW, /* Weak defined. */
|
|
|
|
|
COMMON_ROW, /* Common. */
|
|
|
|
|
INDR_ROW, /* Indirect. */
|
|
|
|
|
WARN_ROW, /* Warning. */
|
|
|
|
|
SET_ROW /* Member of set. */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* apparently needed for Hitachi 3050R(HI-UX/WE2)? */
|
|
|
|
|
#undef FAIL
|
|
|
|
|
|
|
|
|
|
/* The actions to take in the state table. */
|
|
|
|
|
|
|
|
|
|
enum link_action
|
|
|
|
|
{
|
2001-01-03 20:26:07 +01:00
|
|
|
|
FAIL, /* Abort. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
UND, /* Mark symbol undefined. */
|
|
|
|
|
WEAK, /* Mark symbol weak undefined. */
|
|
|
|
|
DEF, /* Mark symbol defined. */
|
|
|
|
|
DEFW, /* Mark symbol weak defined. */
|
|
|
|
|
COM, /* Mark symbol common. */
|
|
|
|
|
REF, /* Mark defined symbol referenced. */
|
|
|
|
|
CREF, /* Possibly warn about common reference to defined symbol. */
|
|
|
|
|
CDEF, /* Define existing common symbol. */
|
|
|
|
|
NOACT, /* No action. */
|
|
|
|
|
BIG, /* Mark symbol common using largest size. */
|
|
|
|
|
MDEF, /* Multiple definition error. */
|
|
|
|
|
MIND, /* Multiple indirect symbols. */
|
|
|
|
|
IND, /* Make indirect symbol. */
|
|
|
|
|
CIND, /* Make indirect symbol from existing common symbol. */
|
|
|
|
|
SET, /* Add value to set. */
|
|
|
|
|
MWARN, /* Make warning symbol. */
|
|
|
|
|
WARN, /* Issue warning. */
|
|
|
|
|
CWARN, /* Warn if referenced, else MWARN. */
|
|
|
|
|
CYCLE, /* Repeat with symbol pointed to. */
|
|
|
|
|
REFC, /* Mark indirect symbol referenced and then CYCLE. */
|
|
|
|
|
WARNC /* Issue warning and then CYCLE. */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* The state table itself. The first index is a link_row and the
|
|
|
|
|
second index is a bfd_link_hash_type. */
|
|
|
|
|
|
|
|
|
|
static const enum link_action link_action[8][8] =
|
|
|
|
|
{
|
|
|
|
|
/* current\prev new undef undefw def defw com indr warn */
|
|
|
|
|
/* UNDEF_ROW */ {UND, NOACT, UND, REF, REF, NOACT, REFC, WARNC },
|
|
|
|
|
/* UNDEFW_ROW */ {WEAK, NOACT, NOACT, REF, REF, NOACT, REFC, WARNC },
|
|
|
|
|
/* DEF_ROW */ {DEF, DEF, DEF, MDEF, DEF, CDEF, MDEF, CYCLE },
|
|
|
|
|
/* DEFW_ROW */ {DEFW, DEFW, DEFW, NOACT, NOACT, NOACT, NOACT, CYCLE },
|
2001-09-11 20:10:20 +02:00
|
|
|
|
/* COMMON_ROW */ {COM, COM, COM, CREF, COM, BIG, REFC, WARNC },
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* INDR_ROW */ {IND, IND, IND, MDEF, IND, CIND, MIND, CYCLE },
|
2002-03-28 04:27:46 +01:00
|
|
|
|
/* WARN_ROW */ {MWARN, WARN, WARN, CWARN, CWARN, WARN, CWARN, NOACT },
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* SET_ROW */ {SET, SET, SET, SET, SET, SET, CYCLE, CYCLE }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Most of the entries in the LINK_ACTION table are straightforward,
|
|
|
|
|
but a few are somewhat subtle.
|
|
|
|
|
|
|
|
|
|
A reference to an indirect symbol (UNDEF_ROW/indr or
|
|
|
|
|
UNDEFW_ROW/indr) is counted as a reference both to the indirect
|
|
|
|
|
symbol and to the symbol the indirect symbol points to.
|
|
|
|
|
|
|
|
|
|
A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn)
|
|
|
|
|
causes the warning to be issued.
|
|
|
|
|
|
|
|
|
|
A common definition of an indirect symbol (COMMON_ROW/indr) is
|
|
|
|
|
treated as a multiple definition error. Likewise for an indirect
|
|
|
|
|
definition of a common symbol (INDR_ROW/com).
|
|
|
|
|
|
|
|
|
|
An indirect definition of a warning (INDR_ROW/warn) does not cause
|
|
|
|
|
the warning to be issued.
|
|
|
|
|
|
|
|
|
|
If a warning is created for an indirect symbol (WARN_ROW/indr) no
|
|
|
|
|
warning is created for the symbol the indirect symbol points to.
|
|
|
|
|
|
|
|
|
|
Adding an entry to a set does not count as a reference to a set,
|
|
|
|
|
and no warning is issued (SET_ROW/warn). */
|
|
|
|
|
|
|
|
|
|
/* Return the BFD in which a hash entry has been defined, if known. */
|
|
|
|
|
|
|
|
|
|
static bfd *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
hash_entry_bfd (struct bfd_link_hash_entry *h)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
while (h->type == bfd_link_hash_warning)
|
|
|
|
|
h = h->u.i.link;
|
|
|
|
|
switch (h->type)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
return NULL;
|
|
|
|
|
case bfd_link_hash_undefined:
|
|
|
|
|
case bfd_link_hash_undefweak:
|
|
|
|
|
return h->u.undef.abfd;
|
|
|
|
|
case bfd_link_hash_defined:
|
|
|
|
|
case bfd_link_hash_defweak:
|
|
|
|
|
return h->u.def.section->owner;
|
|
|
|
|
case bfd_link_hash_common:
|
|
|
|
|
return h->u.c.p->section->owner;
|
|
|
|
|
}
|
|
|
|
|
/*NOTREACHED*/
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add a symbol to the global hash table.
|
|
|
|
|
ABFD is the BFD the symbol comes from.
|
|
|
|
|
NAME is the name of the symbol.
|
|
|
|
|
FLAGS is the BSF_* bits associated with the symbol.
|
|
|
|
|
SECTION is the section in which the symbol is defined; this may be
|
|
|
|
|
bfd_und_section_ptr or bfd_com_section_ptr.
|
|
|
|
|
VALUE is the value of the symbol, relative to the section.
|
|
|
|
|
STRING is used for either an indirect symbol, in which case it is
|
|
|
|
|
the name of the symbol to indirect to, or a warning symbol, in
|
|
|
|
|
which case it is the warning string.
|
2002-11-30 09:39:46 +01:00
|
|
|
|
COPY is TRUE if NAME or STRING must be copied into locally
|
1999-05-03 09:29:11 +02:00
|
|
|
|
allocated memory if they need to be saved.
|
2002-11-30 09:39:46 +01:00
|
|
|
|
COLLECT is TRUE if we should automatically collect gcc constructor
|
1999-05-03 09:29:11 +02:00
|
|
|
|
or destructor names as collect2 does.
|
|
|
|
|
HASHP, if not NULL, is a place to store the created hash table
|
|
|
|
|
entry; if *HASHP is not NULL, the caller has already looked up
|
2001-01-03 20:26:07 +01:00
|
|
|
|
the hash table entry, and stored it in *HASHP. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_add_one_symbol (struct bfd_link_info *info,
|
|
|
|
|
bfd *abfd,
|
|
|
|
|
const char *name,
|
|
|
|
|
flagword flags,
|
|
|
|
|
asection *section,
|
|
|
|
|
bfd_vma value,
|
|
|
|
|
const char *string,
|
|
|
|
|
bfd_boolean copy,
|
|
|
|
|
bfd_boolean collect,
|
|
|
|
|
struct bfd_link_hash_entry **hashp)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
enum link_row row;
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean cycle;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (bfd_is_ind_section (section)
|
|
|
|
|
|| (flags & BSF_INDIRECT) != 0)
|
|
|
|
|
row = INDR_ROW;
|
|
|
|
|
else if ((flags & BSF_WARNING) != 0)
|
|
|
|
|
row = WARN_ROW;
|
|
|
|
|
else if ((flags & BSF_CONSTRUCTOR) != 0)
|
|
|
|
|
row = SET_ROW;
|
|
|
|
|
else if (bfd_is_und_section (section))
|
|
|
|
|
{
|
|
|
|
|
if ((flags & BSF_WEAK) != 0)
|
|
|
|
|
row = UNDEFW_ROW;
|
|
|
|
|
else
|
|
|
|
|
row = UNDEF_ROW;
|
|
|
|
|
}
|
|
|
|
|
else if ((flags & BSF_WEAK) != 0)
|
|
|
|
|
row = DEFW_ROW;
|
|
|
|
|
else if (bfd_is_com_section (section))
|
|
|
|
|
row = COMMON_ROW;
|
|
|
|
|
else
|
|
|
|
|
row = DEF_ROW;
|
|
|
|
|
|
|
|
|
|
if (hashp != NULL && *hashp != NULL)
|
|
|
|
|
h = *hashp;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (row == UNDEF_ROW || row == UNDEFW_ROW)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h = bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, copy, FALSE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h = bfd_link_hash_lookup (info->hash, name, TRUE, copy, FALSE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (h == NULL)
|
|
|
|
|
{
|
|
|
|
|
if (hashp != NULL)
|
|
|
|
|
*hashp = NULL;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (info->notice_all
|
2003-06-29 12:06:40 +02:00
|
|
|
|
|| (info->notice_hash != NULL
|
|
|
|
|
&& bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (! (*info->callbacks->notice) (info, h->root.string, abfd, section,
|
|
|
|
|
value))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (hashp != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
*hashp = h;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
enum link_action action;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
cycle = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
action = link_action[(int) row][(int) h->type];
|
|
|
|
|
switch (action)
|
|
|
|
|
{
|
|
|
|
|
case FAIL:
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
case NOACT:
|
|
|
|
|
/* Do nothing. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UND:
|
|
|
|
|
/* Make a new undefined symbol. */
|
|
|
|
|
h->type = bfd_link_hash_undefined;
|
|
|
|
|
h->u.undef.abfd = abfd;
|
|
|
|
|
bfd_link_add_undef (info->hash, h);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WEAK:
|
|
|
|
|
/* Make a new weak undefined symbol. */
|
|
|
|
|
h->type = bfd_link_hash_undefweak;
|
|
|
|
|
h->u.undef.abfd = abfd;
|
2005-02-03 04:30:49 +01:00
|
|
|
|
h->u.undef.weak = abfd;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CDEF:
|
|
|
|
|
/* We have found a definition for a symbol which was
|
|
|
|
|
previously common. */
|
|
|
|
|
BFD_ASSERT (h->type == bfd_link_hash_common);
|
|
|
|
|
if (! ((*info->callbacks->multiple_common)
|
|
|
|
|
(info, h->root.string,
|
|
|
|
|
h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
abfd, bfd_link_hash_defined, 0)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Fall through. */
|
|
|
|
|
case DEF:
|
|
|
|
|
case DEFW:
|
|
|
|
|
{
|
|
|
|
|
enum bfd_link_hash_type oldtype;
|
|
|
|
|
|
|
|
|
|
/* Define a symbol. */
|
|
|
|
|
oldtype = h->type;
|
|
|
|
|
if (action == DEFW)
|
|
|
|
|
h->type = bfd_link_hash_defweak;
|
|
|
|
|
else
|
|
|
|
|
h->type = bfd_link_hash_defined;
|
|
|
|
|
h->u.def.section = section;
|
|
|
|
|
h->u.def.value = value;
|
|
|
|
|
|
|
|
|
|
/* If we have been asked to, we act like collect2 and
|
|
|
|
|
identify all functions that might be global
|
|
|
|
|
constructors and destructors and pass them up in a
|
|
|
|
|
callback. We only do this for certain object file
|
|
|
|
|
types, since many object file types can handle this
|
|
|
|
|
automatically. */
|
|
|
|
|
if (collect && name[0] == '_')
|
|
|
|
|
{
|
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
|
|
/* A constructor or destructor name starts like this:
|
|
|
|
|
_+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
|
|
|
|
|
the second are the same character (we accept any
|
|
|
|
|
character there, in case a new object file format
|
|
|
|
|
comes along with even worse naming restrictions). */
|
|
|
|
|
|
|
|
|
|
#define CONS_PREFIX "GLOBAL_"
|
|
|
|
|
#define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
|
|
|
|
|
|
|
|
|
|
s = name + 1;
|
|
|
|
|
while (*s == '_')
|
|
|
|
|
++s;
|
2006-09-16 20:12:17 +02:00
|
|
|
|
if (s[0] == 'G' && CONST_STRNEQ (s, CONS_PREFIX))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
char c;
|
|
|
|
|
|
|
|
|
|
c = s[CONS_PREFIX_LEN + 1];
|
|
|
|
|
if ((c == 'I' || c == 'D')
|
|
|
|
|
&& s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
|
|
|
|
|
{
|
|
|
|
|
/* If this is a definition of a symbol which
|
|
|
|
|
was previously weakly defined, we are in
|
|
|
|
|
trouble. We have already added a
|
|
|
|
|
constructor entry for the weak defined
|
|
|
|
|
symbol, and now we are trying to add one
|
|
|
|
|
for the new symbol. Fortunately, this case
|
|
|
|
|
should never arise in practice. */
|
|
|
|
|
if (oldtype == bfd_link_hash_defweak)
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
if (! ((*info->callbacks->constructor)
|
2002-06-25 08:21:54 +02:00
|
|
|
|
(info, c == 'I',
|
1999-05-03 09:29:11 +02:00
|
|
|
|
h->root.string, abfd, section, value)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case COM:
|
|
|
|
|
/* We have found a common definition for a symbol. */
|
|
|
|
|
if (h->type == bfd_link_hash_new)
|
|
|
|
|
bfd_link_add_undef (info->hash, h);
|
|
|
|
|
h->type = bfd_link_hash_common;
|
|
|
|
|
h->u.c.p =
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_hash_allocate (&info->hash->table,
|
|
|
|
|
sizeof (struct bfd_link_hash_common_entry));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (h->u.c.p == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
h->u.c.size = value;
|
|
|
|
|
|
|
|
|
|
/* Select a default alignment based on the size. This may
|
|
|
|
|
be overridden by the caller. */
|
|
|
|
|
{
|
|
|
|
|
unsigned int power;
|
|
|
|
|
|
|
|
|
|
power = bfd_log2 (value);
|
|
|
|
|
if (power > 4)
|
|
|
|
|
power = 4;
|
|
|
|
|
h->u.c.p->alignment_power = power;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The section of a common symbol is only used if the common
|
|
|
|
|
symbol is actually allocated. It basically provides a
|
|
|
|
|
hook for the linker script to decide which output section
|
|
|
|
|
the common symbols should be put in. In most cases, the
|
|
|
|
|
section of a common symbol will be bfd_com_section_ptr,
|
|
|
|
|
the code here will choose a common symbol section named
|
|
|
|
|
"COMMON", and the linker script will contain *(COMMON) in
|
|
|
|
|
the appropriate place. A few targets use separate common
|
|
|
|
|
sections for small symbols, and they require special
|
|
|
|
|
handling. */
|
|
|
|
|
if (section == bfd_com_section_ptr)
|
|
|
|
|
{
|
|
|
|
|
h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON");
|
|
|
|
|
h->u.c.p->section->flags = SEC_ALLOC;
|
|
|
|
|
}
|
|
|
|
|
else if (section->owner != abfd)
|
|
|
|
|
{
|
|
|
|
|
h->u.c.p->section = bfd_make_section_old_way (abfd,
|
|
|
|
|
section->name);
|
|
|
|
|
h->u.c.p->section->flags = SEC_ALLOC;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
h->u.c.p->section = section;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case REF:
|
|
|
|
|
/* A reference to a defined symbol. */
|
2004-09-17 09:14:33 +02:00
|
|
|
|
if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
|
|
|
|
|
h->u.undef.next = h;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BIG:
|
|
|
|
|
/* We have found a common definition for a symbol which
|
|
|
|
|
already had a common definition. Use the maximum of the
|
2001-07-06 00:40:16 +02:00
|
|
|
|
two sizes, and use the section required by the larger symbol. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
BFD_ASSERT (h->type == bfd_link_hash_common);
|
|
|
|
|
if (! ((*info->callbacks->multiple_common)
|
|
|
|
|
(info, h->root.string,
|
|
|
|
|
h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
|
|
|
|
|
abfd, bfd_link_hash_common, value)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (value > h->u.c.size)
|
|
|
|
|
{
|
|
|
|
|
unsigned int power;
|
|
|
|
|
|
|
|
|
|
h->u.c.size = value;
|
|
|
|
|
|
|
|
|
|
/* Select a default alignment based on the size. This may
|
|
|
|
|
be overridden by the caller. */
|
|
|
|
|
power = bfd_log2 (value);
|
|
|
|
|
if (power > 4)
|
|
|
|
|
power = 4;
|
|
|
|
|
h->u.c.p->alignment_power = power;
|
2001-07-06 00:40:16 +02:00
|
|
|
|
|
|
|
|
|
/* Some systems have special treatment for small commons,
|
|
|
|
|
hence we want to select the section used by the larger
|
|
|
|
|
symbol. This makes sure the symbol does not go in a
|
|
|
|
|
small common section if it is now too large. */
|
|
|
|
|
if (section == bfd_com_section_ptr)
|
|
|
|
|
{
|
|
|
|
|
h->u.c.p->section
|
|
|
|
|
= bfd_make_section_old_way (abfd, "COMMON");
|
|
|
|
|
h->u.c.p->section->flags = SEC_ALLOC;
|
|
|
|
|
}
|
|
|
|
|
else if (section->owner != abfd)
|
|
|
|
|
{
|
|
|
|
|
h->u.c.p->section
|
|
|
|
|
= bfd_make_section_old_way (abfd, section->name);
|
|
|
|
|
h->u.c.p->section->flags = SEC_ALLOC;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
h->u.c.p->section = section;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CREF:
|
|
|
|
|
{
|
|
|
|
|
bfd *obfd;
|
|
|
|
|
|
|
|
|
|
/* We have found a common definition for a symbol which
|
|
|
|
|
was already defined. FIXME: It would nice if we could
|
|
|
|
|
report the BFD which defined an indirect symbol, but we
|
|
|
|
|
don't have anywhere to store the information. */
|
|
|
|
|
if (h->type == bfd_link_hash_defined
|
|
|
|
|
|| h->type == bfd_link_hash_defweak)
|
|
|
|
|
obfd = h->u.def.section->owner;
|
|
|
|
|
else
|
|
|
|
|
obfd = NULL;
|
|
|
|
|
if (! ((*info->callbacks->multiple_common)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(info, h->root.string, obfd, h->type, 0,
|
1999-05-03 09:29:11 +02:00
|
|
|
|
abfd, bfd_link_hash_common, value)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MIND:
|
|
|
|
|
/* Multiple indirect symbols. This is OK if they both point
|
|
|
|
|
to the same symbol. */
|
|
|
|
|
if (strcmp (h->u.i.link->root.string, string) == 0)
|
|
|
|
|
break;
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
case MDEF:
|
|
|
|
|
/* Handle a multiple definition. */
|
2002-05-22 07:06:18 +02:00
|
|
|
|
if (!info->allow_multiple_definition)
|
|
|
|
|
{
|
|
|
|
|
asection *msec = NULL;
|
|
|
|
|
bfd_vma mval = 0;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-05-22 07:06:18 +02:00
|
|
|
|
switch (h->type)
|
|
|
|
|
{
|
|
|
|
|
case bfd_link_hash_defined:
|
|
|
|
|
msec = h->u.def.section;
|
|
|
|
|
mval = h->u.def.value;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_indirect:
|
|
|
|
|
msec = bfd_ind_section_ptr;
|
|
|
|
|
mval = 0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Ignore a redefinition of an absolute symbol to the
|
|
|
|
|
same value; it's harmless. */
|
|
|
|
|
if (h->type == bfd_link_hash_defined
|
|
|
|
|
&& bfd_is_abs_section (msec)
|
|
|
|
|
&& bfd_is_abs_section (section)
|
|
|
|
|
&& value == mval)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
2002-05-22 07:06:18 +02:00
|
|
|
|
if (! ((*info->callbacks->multiple_definition)
|
|
|
|
|
(info, h->root.string, msec->owner, msec, mval,
|
|
|
|
|
abfd, section, value)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2002-05-22 07:06:18 +02:00
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CIND:
|
|
|
|
|
/* Create an indirect symbol from an existing common symbol. */
|
|
|
|
|
BFD_ASSERT (h->type == bfd_link_hash_common);
|
|
|
|
|
if (! ((*info->callbacks->multiple_common)
|
|
|
|
|
(info, h->root.string,
|
|
|
|
|
h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
abfd, bfd_link_hash_indirect, 0)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Fall through. */
|
|
|
|
|
case IND:
|
|
|
|
|
/* Create an indirect symbol. */
|
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry *inh;
|
|
|
|
|
|
|
|
|
|
/* STRING is the name of the symbol we want to indirect
|
|
|
|
|
to. */
|
2002-11-30 09:39:46 +01:00
|
|
|
|
inh = bfd_wrapped_link_hash_lookup (abfd, info, string, TRUE,
|
|
|
|
|
copy, FALSE);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (inh == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2001-05-11 00:59:29 +02:00
|
|
|
|
if (inh->type == bfd_link_hash_indirect
|
|
|
|
|
&& inh->u.i.link == h)
|
|
|
|
|
{
|
|
|
|
|
(*_bfd_error_handler)
|
bfd/
* bfd.c (_bfd_default_error_handler): Handle %A and %B.
(bfd_archive_filename, bfd_get_section_ident): Delete.
* ecofflink.c (bfd_ecoff_debug_accumulate_other): Don't call
bfd_archive_filename.
* elflink.c (elf_link_input_bfd): Don't use callbacks->error_handler
to warn about symbols in discarded sections. Use _bfd_error_handler.
* aout-adobe.c (aout_adobe_callback): See below.
* aout-cris.c (swap_ext_reloc_in): ..
* coff-arm.c (find_thumb_glue, find_arm_glue,
coff_arm_relocate_section, bfd_arm_process_before_allocation,
coff_arm_merge_private_bfd_data, _bfd_coff_arm_set_private_flags,
coff_arm_copy_private_bfd_data): ..
* coff-i860.c (i860_reloc_processing): ..
* coff-mcore.c (mcore_coff_unsupported_reloc,
coff_mcore_relocate_section): ..
* coff-ppc.c (coff_ppc_relocate_section): ..
* coff-rs6000.c (xcoff_create_csect_from_smclas
* coff-sh.c (sh_relax_section, sh_relax_delete_bytes,
sh_swap_insns, sh_relocate_section): ..
* coff-tic54x.c (tic54x_reloc_processing): ..
* coff-tic80.c (coff_tic80_relocate_section): ..
* coff64-rs6000.c (xcoff64_create_csect_from_smclas): ..
* coffcode.h (styp_to_sec_flags, coff_slurp_line_table,
coff_slurp_symbol_table, coff_classify_symbol,
coff_slurp_reloc_table): ..
* coffgen.c (_bfd_coff_read_string_table): ..
* cofflink.c (coff_link_add_symbols, _bfd_coff_link_input_bfd,
_bfd_coff_generic_relocate_section): ..
* cpu-arm.c (bfd_arm_merge_machines): ..
* cpu-sh.c (sh_merge_bfd_arch): ..
* elf-hppa.h (elf_hppa_relocate_section): ..
* elf.c (bfd_elf_string_from_elf_section, setup_group,
_bfd_elf_setup_group_pointers, bfd_section_from_shdr,
assign_section_numbers, _bfd_elf_symbol_from_bfd_symbol,
copy_private_bfd_data, _bfd_elf_validate_reloc): ..
* elf32-arm.h (find_thumb_glue, find_arm_glue,
bfd_elf32_arm_process_before_allocation, elf32_thumb_to_arm_stub,
elf32_arm_to_thumb_stub, elf32_arm_final_link_relocate,
elf32_arm_relocate_section, elf32_arm_set_private_flags,
elf32_arm_copy_private_bfd_data, elf32_arm_merge_private_bfd_data): ..
* elf32-cris.c (cris_elf_relocate_section, cris_elf_check_relocs,
cris_elf_merge_private_bfd_data
* elf32-frv.c (elf32_frv_relocate_section, elf32_frv_check_relocs): ..
* elf32-gen.c (elf32_generic_link_add_symbols): ..
* elf32-hppa.c (hppa_add_stub, hppa_build_one_stub,
elf32_hppa_check_relocs, get_local_syms, final_link_relocate,
elf32_hppa_relocate_section): ..
* elf32-i370.c (i370_elf_merge_private_bfd_data,
i370_elf_check_relocs, i370_elf_relocate_section): ..
* elf32-i386.c (elf_i386_info_to_howto_rel, elf_i386_check_relocs,
elf_i386_relocate_section): ..
* elf32-m32r.c (m32r_elf_relocate_section,
m32r_elf_merge_private_bfd_data): ..
* elf32-m68hc1x.c (m68hc12_add_stub,
_bfd_m68hc11_elf_merge_private_bfd_data): ..
* elf32-m68k.c (elf_m68k_relocate_section): ..
* elf32-mcore.c (mcore_elf_unsupported_reloc,
mcore_elf_relocate_section): ..
* elf32-ppc.c (ppc_elf_merge_private_bfd_data, bad_shared_reloc,
ppc_elf_check_relocs, ppc_elf_relocate_section,
ppc_elf_begin_write_processing): ..
* elf32-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf32-sh-symbian.c (sh_symbian_import_as,
sh_symbian_process_embedded_commands,
sh_symbian_relocate_section): ..
* elf32-sh.c (sh_elf_relax_section, sh_elf_relax_delete_bytes,
sh_elf_swap_insns, sh_elf_relocate_section, sh_elf_check_relocs,
sh_elf_merge_private_data): ..
* elf32-sparc.c (elf32_sparc_check_relocs,
elf32_sparc_relocate_section,
elf32_sparc_merge_private_bfd_data): ..
* elf32-v850.c (v850_elf_check_relocs,
v850_elf_merge_private_bfd_data): ..
* elf32-xtensa.c (elf_xtensa_check_relocs,
elf_xtensa_relocate_section, elf_xtensa_merge_private_bfd_data): ..
* elf64-alpha.c (elf64_alpha_relax_with_lituse,
elf64_alpha_relax_got_load, elf64_alpha_size_got_sections,
elf64_alpha_relocate_section_r, elf64_alpha_relocate_section): ..
* elf64-gen.c (elf64_generic_link_add_symbols): ..
* elf64-ppc.c (ppc64_elf_merge_private_bfd_data, ppc_add_stub,
ppc64_elf_check_relocs, ppc64_elf_edit_opd,
ppc64_elf_relocate_section): ..
* elf64-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf64-sh64.c (sh_elf64_relocate_section): ..
* elf64-sparc.c (sparc64_elf_check_relocs,
sparc64_elf_add_symbol_hook, sparc64_elf_relocate_section,
sparc64_elf_merge_private_bfd_data): ..
* elf64-x86-64.c (elf64_x86_64_check_relocs,
elf64_x86_64_relocate_section): ..
* elflink.c (_bfd_elf_add_default_symbol,
_bfd_elf_link_assign_sym_version, elf_link_read_relocs_from_section,
_bfd_elf_link_output_relocs, elf_link_add_object_symbols,
bfd_elf_size_dynamic_sections, elf_link_output_extsym,
elf_get_linked_section_vma, elf_fixup_link_order,
bfd_elf_final_link, bfd_elf_gc_record_vtinherit,
bfd_elf_gc_record_vtinherit, _bfd_elf_section_already_linked): ..
* elfxx-ia64.c (elfNN_ia64_relax_section,
elfNN_ia64_relocate_section, elfNN_ia64_merge_private_bfd_data): ..
* elfxx-mips.c (mips_elf_perform_relocation,
_bfd_mips_elf_check_relocs,
_bfd_mips_elf_merge_private_bfd_data): ..
* ieee.c (ieee_slurp_external_symbols): ..
* ihex.c (ihex_bad_byte, ihex_scan, ihex_read_section): ..
* libbfd.c (_bfd_generic_verify_endian_match): ..
* linker.c (_bfd_generic_link_add_one_symbol,
_bfd_generic_section_already_linked): ..
* pdp11.c (translate_to_native_sym_flags): ..
* pe-mips.c (coff_pe_mips_relocate_section): ..
* peicode.h (pe_ILF_build_a_bfd): ..
* srec.c (srec_bad_byte): ..
* stabs.c (_bfd_link_section_stabs): ..
* xcofflink.c (xcoff_link_add_symbols, xcoff_link_input_bfd): ..
Replace all uses of bfd_archive_filename and bfd_get_section_ident
with corresponding %B and %A in _bfd_error_handler format string.
Replace occurrences of "fprintf (stderr," with _bfd_error_handler
calls to use %A and %B. Fix "against symbol .. from section" and
similar error messages. Combine multiple _bfd_error_handler calls
where they were separated due to bfd_archive_filename deficiencies.
* bfd-in2.h: Regenerate.
include/
* bfdlink.h (struct bfd_link_callbacks): Remove "error_handler".
(LD_DEFINITION_IN_DISCARDED_SECTION): Delete.
ld/
* ldmain.c (link_callbacks): Remove "error_handler".
* ldmisc.c: Include elf-bfd.h.
(vfinfo): Sort comment. Handle %A. Use %A instead of
bfd_get_section_indent.
(error_handler): Delete.
* ldmisc.h (error_handler): Delete declaration.
2004-08-13 05:16:01 +02:00
|
|
|
|
(_("%B: indirect symbol `%s' to `%s' is a loop"),
|
|
|
|
|
abfd, name, string);
|
2001-05-11 00:59:29 +02:00
|
|
|
|
bfd_set_error (bfd_error_invalid_operation);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2001-05-11 00:59:29 +02:00
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (inh->type == bfd_link_hash_new)
|
|
|
|
|
{
|
|
|
|
|
inh->type = bfd_link_hash_undefined;
|
|
|
|
|
inh->u.undef.abfd = abfd;
|
|
|
|
|
bfd_link_add_undef (info->hash, inh);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the indirect symbol has been referenced, we need to
|
|
|
|
|
push the reference down to the symbol we are
|
|
|
|
|
referencing. */
|
|
|
|
|
if (h->type != bfd_link_hash_new)
|
|
|
|
|
{
|
|
|
|
|
row = UNDEF_ROW;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
cycle = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
h->type = bfd_link_hash_indirect;
|
|
|
|
|
h->u.i.link = inh;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SET:
|
|
|
|
|
/* Add an entry to a set. */
|
|
|
|
|
if (! (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
|
|
|
|
|
abfd, section, value))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WARNC:
|
|
|
|
|
/* Issue a warning and cycle. */
|
|
|
|
|
if (h->u.i.warning != NULL)
|
|
|
|
|
{
|
|
|
|
|
if (! (*info->callbacks->warning) (info, h->u.i.warning,
|
|
|
|
|
h->root.string, abfd,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
NULL, 0))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
/* Only issue a warning once. */
|
|
|
|
|
h->u.i.warning = NULL;
|
|
|
|
|
}
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
case CYCLE:
|
|
|
|
|
/* Try again with the referenced symbol. */
|
|
|
|
|
h = h->u.i.link;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
cycle = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case REFC:
|
|
|
|
|
/* A reference to an indirect symbol. */
|
2004-09-17 09:14:33 +02:00
|
|
|
|
if (h->u.undef.next == NULL && info->hash->undefs_tail != h)
|
|
|
|
|
h->u.undef.next = h;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
h = h->u.i.link;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
cycle = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case WARN:
|
|
|
|
|
/* Issue a warning. */
|
|
|
|
|
if (! (*info->callbacks->warning) (info, string, h->root.string,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
hash_entry_bfd (h), NULL, 0))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CWARN:
|
|
|
|
|
/* Warn if this symbol has been referenced already,
|
|
|
|
|
otherwise add a warning. A symbol has been referenced if
|
2004-09-17 09:14:33 +02:00
|
|
|
|
the u.undef.next field is not NULL, or it is the tail of the
|
1999-05-03 09:29:11 +02:00
|
|
|
|
undefined symbol list. The REF case above helps to
|
|
|
|
|
ensure this. */
|
2004-09-17 09:14:33 +02:00
|
|
|
|
if (h->u.undef.next != NULL || info->hash->undefs_tail == h)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (! (*info->callbacks->warning) (info, string, h->root.string,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
hash_entry_bfd (h), NULL, 0))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
case MWARN:
|
|
|
|
|
/* Make a warning symbol. */
|
|
|
|
|
{
|
|
|
|
|
struct bfd_link_hash_entry *sub;
|
|
|
|
|
|
|
|
|
|
/* STRING is the warning to give. */
|
|
|
|
|
sub = ((struct bfd_link_hash_entry *)
|
|
|
|
|
((*info->hash->table.newfunc)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(NULL, &info->hash->table, h->root.string)));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (sub == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
*sub = *h;
|
|
|
|
|
sub->type = bfd_link_hash_warning;
|
|
|
|
|
sub->u.i.link = h;
|
|
|
|
|
if (! copy)
|
|
|
|
|
sub->u.i.warning = string;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *w;
|
2002-06-25 11:40:45 +02:00
|
|
|
|
size_t len = strlen (string) + 1;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-06-25 11:40:45 +02:00
|
|
|
|
w = bfd_hash_allocate (&info->hash->table, len);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (w == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2002-06-25 11:40:45 +02:00
|
|
|
|
memcpy (w, string, len);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
sub->u.i.warning = w;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bfd_hash_replace (&info->hash->table,
|
|
|
|
|
(struct bfd_hash_entry *) h,
|
|
|
|
|
(struct bfd_hash_entry *) sub);
|
|
|
|
|
if (hashp != NULL)
|
|
|
|
|
*hashp = sub;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
while (cycle);
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generic final link routine. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
bfd *sub;
|
|
|
|
|
asection *o;
|
|
|
|
|
struct bfd_link_order *p;
|
|
|
|
|
size_t outsymalloc;
|
|
|
|
|
struct generic_write_global_symbol_info wginfo;
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_get_outsymbols (abfd) = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_get_symcount (abfd) = 0;
|
|
|
|
|
outsymalloc = 0;
|
|
|
|
|
|
|
|
|
|
/* Mark all sections which will be included in the output file. */
|
|
|
|
|
for (o = abfd->sections; o != NULL; o = o->next)
|
2005-05-04 13:00:28 +02:00
|
|
|
|
for (p = o->map_head.link_order; p != NULL; p = p->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (p->type == bfd_indirect_link_order)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
p->u.indirect.section->linker_mark = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Build the output symbol table. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Accumulate the global symbols. */
|
|
|
|
|
wginfo.info = info;
|
|
|
|
|
wginfo.output_bfd = abfd;
|
|
|
|
|
wginfo.psymalloc = &outsymalloc;
|
|
|
|
|
_bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
|
|
|
|
|
_bfd_generic_link_write_global_symbol,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
&wginfo);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Make sure we have a trailing NULL pointer on OUTSYMBOLS. We
|
|
|
|
|
shouldn't really need one, since we have SYMCOUNT, but some old
|
|
|
|
|
code still expects one. */
|
|
|
|
|
if (! generic_add_output_symbol (abfd, &outsymalloc, NULL))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-25 08:40:27 +02:00
|
|
|
|
if (info->relocatable)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Allocate space for the output relocs for each section. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (o = abfd->sections; o != NULL; o = o->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
o->reloc_count = 0;
|
2005-05-04 13:00:28 +02:00
|
|
|
|
for (p = o->map_head.link_order; p != NULL; p = p->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (p->type == bfd_section_reloc_link_order
|
|
|
|
|
|| p->type == bfd_symbol_reloc_link_order)
|
|
|
|
|
++o->reloc_count;
|
|
|
|
|
else if (p->type == bfd_indirect_link_order)
|
|
|
|
|
{
|
|
|
|
|
asection *input_section;
|
|
|
|
|
bfd *input_bfd;
|
|
|
|
|
long relsize;
|
|
|
|
|
arelent **relocs;
|
|
|
|
|
asymbol **symbols;
|
|
|
|
|
long reloc_count;
|
|
|
|
|
|
|
|
|
|
input_section = p->u.indirect.section;
|
|
|
|
|
input_bfd = input_section->owner;
|
|
|
|
|
relsize = bfd_get_reloc_upper_bound (input_bfd,
|
|
|
|
|
input_section);
|
|
|
|
|
if (relsize < 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
relocs = bfd_malloc (relsize);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (!relocs && relsize != 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
symbols = _bfd_generic_link_get_symbols (input_bfd);
|
|
|
|
|
reloc_count = bfd_canonicalize_reloc (input_bfd,
|
|
|
|
|
input_section,
|
|
|
|
|
relocs,
|
|
|
|
|
symbols);
|
2003-03-31 20:13:25 +02:00
|
|
|
|
free (relocs);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (reloc_count < 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
BFD_ASSERT ((unsigned long) reloc_count
|
|
|
|
|
== input_section->reloc_count);
|
|
|
|
|
o->reloc_count += reloc_count;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (o->reloc_count > 0)
|
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt;
|
|
|
|
|
|
|
|
|
|
amt = o->reloc_count;
|
|
|
|
|
amt *= sizeof (arelent *);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
o->orelocation = bfd_alloc (abfd, amt);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (!o->orelocation)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
o->flags |= SEC_RELOC;
|
|
|
|
|
/* Reset the count so that it can be used as an index
|
|
|
|
|
when putting in the output relocs. */
|
|
|
|
|
o->reloc_count = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Handle all the link order information for the sections. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (o = abfd->sections; o != NULL; o = o->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2005-05-04 13:00:28 +02:00
|
|
|
|
for (p = o->map_head.link_order; p != NULL; p = p->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
switch (p->type)
|
|
|
|
|
{
|
|
|
|
|
case bfd_section_reloc_link_order:
|
|
|
|
|
case bfd_symbol_reloc_link_order:
|
|
|
|
|
if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case bfd_indirect_link_order:
|
2002-11-30 09:39:46 +01:00
|
|
|
|
if (! default_indirect_link_order (abfd, info, o, p, TRUE))
|
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (! _bfd_default_link_order (abfd, info, o, p))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2001-01-03 20:26:07 +01:00
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add an output symbol to the output BFD. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
generic_add_output_symbol (bfd *output_bfd, size_t *psymalloc, asymbol *sym)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (bfd_get_symcount (output_bfd) >= *psymalloc)
|
|
|
|
|
{
|
|
|
|
|
asymbol **newsyms;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (*psymalloc == 0)
|
|
|
|
|
*psymalloc = 124;
|
|
|
|
|
else
|
|
|
|
|
*psymalloc *= 2;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
amt = *psymalloc;
|
|
|
|
|
amt *= sizeof (asymbol *);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
newsyms = bfd_realloc (bfd_get_outsymbols (output_bfd), amt);
|
|
|
|
|
if (newsyms == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_get_outsymbols (output_bfd) = newsyms;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym;
|
|
|
|
|
if (sym != NULL)
|
|
|
|
|
++ bfd_get_symcount (output_bfd);
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Handle the symbols for an input BFD. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_output_symbols (bfd *output_bfd,
|
|
|
|
|
bfd *input_bfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
size_t *psymalloc)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asymbol **sym_ptr;
|
|
|
|
|
asymbol **sym_end;
|
|
|
|
|
|
2008-08-17 05:12:50 +02:00
|
|
|
|
if (!bfd_generic_link_read_symbols (input_bfd))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Create a filename symbol if we are supposed to. */
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (info->create_object_symbols_section != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asection *sec;
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (sec = input_bfd->sections; sec != NULL; sec = sec->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (sec->output_section == info->create_object_symbols_section)
|
|
|
|
|
{
|
|
|
|
|
asymbol *newsym;
|
|
|
|
|
|
|
|
|
|
newsym = bfd_make_empty_symbol (input_bfd);
|
|
|
|
|
if (!newsym)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
newsym->name = input_bfd->filename;
|
|
|
|
|
newsym->value = 0;
|
|
|
|
|
newsym->flags = BSF_LOCAL | BSF_FILE;
|
|
|
|
|
newsym->section = sec;
|
|
|
|
|
|
|
|
|
|
if (! generic_add_output_symbol (output_bfd, psymalloc,
|
|
|
|
|
newsym))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Adjust the values of the globally visible symbols, and write out
|
|
|
|
|
local symbols. */
|
|
|
|
|
sym_ptr = _bfd_generic_link_get_symbols (input_bfd);
|
|
|
|
|
sym_end = sym_ptr + _bfd_generic_link_get_symcount (input_bfd);
|
|
|
|
|
for (; sym_ptr < sym_end; sym_ptr++)
|
|
|
|
|
{
|
|
|
|
|
asymbol *sym;
|
|
|
|
|
struct generic_link_hash_entry *h;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean output;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
h = NULL;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
sym = *sym_ptr;
|
|
|
|
|
if ((sym->flags & (BSF_INDIRECT
|
|
|
|
|
| BSF_WARNING
|
|
|
|
|
| BSF_GLOBAL
|
|
|
|
|
| BSF_CONSTRUCTOR
|
|
|
|
|
| BSF_WEAK)) != 0
|
|
|
|
|
|| bfd_is_und_section (bfd_get_section (sym))
|
|
|
|
|
|| bfd_is_com_section (bfd_get_section (sym))
|
|
|
|
|
|| bfd_is_ind_section (bfd_get_section (sym)))
|
|
|
|
|
{
|
|
|
|
|
if (sym->udata.p != NULL)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
h = sym->udata.p;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if ((sym->flags & BSF_CONSTRUCTOR) != 0)
|
|
|
|
|
{
|
|
|
|
|
/* This case normally means that the main linker code
|
|
|
|
|
deliberately ignored this constructor symbol. We
|
|
|
|
|
should just pass it through. This will screw up if
|
|
|
|
|
the constructor symbol is from a different,
|
|
|
|
|
non-generic, object file format, but the case will
|
|
|
|
|
only arise when linking with -r, which will probably
|
|
|
|
|
fail anyhow, since there will be no way to represent
|
|
|
|
|
the relocs in the output format being used. */
|
|
|
|
|
h = NULL;
|
|
|
|
|
}
|
|
|
|
|
else if (bfd_is_und_section (bfd_get_section (sym)))
|
|
|
|
|
h = ((struct generic_link_hash_entry *)
|
|
|
|
|
bfd_wrapped_link_hash_lookup (output_bfd, info,
|
|
|
|
|
bfd_asymbol_name (sym),
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE, TRUE));
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
|
|
|
|
|
bfd_asymbol_name (sym),
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Force all references to this symbol to point to
|
|
|
|
|
the same area in memory. It is possible that
|
|
|
|
|
this routine will be called with a hash table
|
|
|
|
|
other than a generic hash table, so we double
|
|
|
|
|
check that. */
|
2008-02-15 04:35:53 +01:00
|
|
|
|
if (info->output_bfd->xvec == input_bfd->xvec)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h->sym != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
*sym_ptr = sym = h->sym;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (h->root.type)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
case bfd_link_hash_new:
|
|
|
|
|
abort ();
|
|
|
|
|
case bfd_link_hash_undefined:
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_undefweak:
|
|
|
|
|
sym->flags |= BSF_WEAK;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_indirect:
|
|
|
|
|
h = (struct generic_link_hash_entry *) h->root.u.i.link;
|
|
|
|
|
/* fall through */
|
|
|
|
|
case bfd_link_hash_defined:
|
|
|
|
|
sym->flags |= BSF_GLOBAL;
|
|
|
|
|
sym->flags &=~ BSF_CONSTRUCTOR;
|
|
|
|
|
sym->value = h->root.u.def.value;
|
|
|
|
|
sym->section = h->root.u.def.section;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_defweak:
|
|
|
|
|
sym->flags |= BSF_WEAK;
|
|
|
|
|
sym->flags &=~ BSF_CONSTRUCTOR;
|
|
|
|
|
sym->value = h->root.u.def.value;
|
|
|
|
|
sym->section = h->root.u.def.section;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_common:
|
|
|
|
|
sym->value = h->root.u.c.size;
|
|
|
|
|
sym->flags |= BSF_GLOBAL;
|
|
|
|
|
if (! bfd_is_com_section (sym->section))
|
|
|
|
|
{
|
|
|
|
|
BFD_ASSERT (bfd_is_und_section (sym->section));
|
|
|
|
|
sym->section = bfd_com_section_ptr;
|
|
|
|
|
}
|
|
|
|
|
/* We do not set the section of the symbol to
|
|
|
|
|
h->root.u.c.p->section. That value was saved so
|
|
|
|
|
that we would know where to allocate the symbol
|
|
|
|
|
if it was defined. In this case the type is
|
|
|
|
|
still bfd_link_hash_common, so we did not define
|
|
|
|
|
it, so we do not want to use that section. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This switch is straight from the old code in
|
|
|
|
|
write_file_locals in ldsym.c. */
|
|
|
|
|
if (info->strip == strip_all
|
|
|
|
|
|| (info->strip == strip_some
|
2003-06-29 12:06:40 +02:00
|
|
|
|
&& bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
|
|
|
|
|
FALSE, FALSE) == NULL))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
|
|
|
|
|
{
|
|
|
|
|
/* If this symbol is marked as occurring now, rather
|
|
|
|
|
than at the end, output it now. This is used for
|
|
|
|
|
COFF C_EXT FCN symbols. FIXME: There must be a
|
|
|
|
|
better way. */
|
|
|
|
|
if (bfd_asymbol_bfd (sym) == input_bfd
|
|
|
|
|
&& (sym->flags & BSF_NOT_AT_END) != 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else if (bfd_is_ind_section (sym->section))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if ((sym->flags & BSF_DEBUGGING) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (info->strip == strip_none)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else if (bfd_is_und_section (sym->section)
|
|
|
|
|
|| bfd_is_com_section (sym->section))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if ((sym->flags & BSF_LOCAL) != 0)
|
|
|
|
|
{
|
|
|
|
|
if ((sym->flags & BSF_WARNING) != 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
switch (info->discard)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
case discard_all:
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
2001-04-13 02:34:36 +02:00
|
|
|
|
case discard_sec_merge:
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
2003-06-25 08:40:27 +02:00
|
|
|
|
if (info->relocatable
|
2001-04-13 02:34:36 +02:00
|
|
|
|
|| ! (sym->section->flags & SEC_MERGE))
|
|
|
|
|
break;
|
|
|
|
|
/* FALLTHROUGH */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case discard_l:
|
|
|
|
|
if (bfd_is_local_label (input_bfd, sym))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
case discard_none:
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ((sym->flags & BSF_CONSTRUCTOR))
|
|
|
|
|
{
|
|
|
|
|
if (info->strip != strip_all)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
/* If this symbol is in a section which is not being included
|
2005-04-12 00:21:23 +02:00
|
|
|
|
in the output file, then we don't want to output the
|
2005-10-24 13:24:31 +02:00
|
|
|
|
symbol. */
|
|
|
|
|
if (!bfd_is_abs_section (sym->section)
|
|
|
|
|
&& bfd_section_removed_from_list (output_bfd,
|
2005-04-12 00:21:23 +02:00
|
|
|
|
sym->section->output_section))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
output = FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (output)
|
|
|
|
|
{
|
|
|
|
|
if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h != NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h->written = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the section and value of a generic BFD symbol based on a linker
|
|
|
|
|
hash table entry. */
|
|
|
|
|
|
|
|
|
|
static void
|
2003-06-29 12:06:40 +02:00
|
|
|
|
set_symbol_from_hash (asymbol *sym, struct bfd_link_hash_entry *h)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
switch (h->type)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_new:
|
|
|
|
|
/* This can happen when a constructor symbol is seen but we are
|
|
|
|
|
not building constructors. */
|
|
|
|
|
if (sym->section != NULL)
|
|
|
|
|
{
|
|
|
|
|
BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
sym->flags |= BSF_CONSTRUCTOR;
|
|
|
|
|
sym->section = bfd_abs_section_ptr;
|
|
|
|
|
sym->value = 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_undefined:
|
|
|
|
|
sym->section = bfd_und_section_ptr;
|
|
|
|
|
sym->value = 0;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_undefweak:
|
|
|
|
|
sym->section = bfd_und_section_ptr;
|
|
|
|
|
sym->value = 0;
|
|
|
|
|
sym->flags |= BSF_WEAK;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_defined:
|
|
|
|
|
sym->section = h->u.def.section;
|
|
|
|
|
sym->value = h->u.def.value;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_defweak:
|
|
|
|
|
sym->flags |= BSF_WEAK;
|
|
|
|
|
sym->section = h->u.def.section;
|
|
|
|
|
sym->value = h->u.def.value;
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_common:
|
|
|
|
|
sym->value = h->u.c.size;
|
|
|
|
|
if (sym->section == NULL)
|
|
|
|
|
sym->section = bfd_com_section_ptr;
|
|
|
|
|
else if (! bfd_is_com_section (sym->section))
|
|
|
|
|
{
|
|
|
|
|
BFD_ASSERT (bfd_is_und_section (sym->section));
|
|
|
|
|
sym->section = bfd_com_section_ptr;
|
|
|
|
|
}
|
|
|
|
|
/* Do not set the section; see _bfd_generic_link_output_symbols. */
|
|
|
|
|
break;
|
|
|
|
|
case bfd_link_hash_indirect:
|
|
|
|
|
case bfd_link_hash_warning:
|
|
|
|
|
/* FIXME: What should we do here? */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write out a global symbol, if it hasn't already been written out.
|
|
|
|
|
This is called for each symbol in the hash table. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_write_global_symbol (struct generic_link_hash_entry *h,
|
|
|
|
|
void *data)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2003-06-29 12:06:40 +02:00
|
|
|
|
struct generic_write_global_symbol_info *wginfo = data;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
asymbol *sym;
|
|
|
|
|
|
2002-03-28 04:27:46 +01:00
|
|
|
|
if (h->root.type == bfd_link_hash_warning)
|
|
|
|
|
h = (struct generic_link_hash_entry *) h->root.u.i.link;
|
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (h->written)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
h->written = TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
if (wginfo->info->strip == strip_all
|
|
|
|
|
|| (wginfo->info->strip == strip_some
|
|
|
|
|
&& bfd_hash_lookup (wginfo->info->keep_hash, h->root.root.string,
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE) == NULL))
|
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h->sym != NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
sym = h->sym;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
sym = bfd_make_empty_symbol (wginfo->output_bfd);
|
|
|
|
|
if (!sym)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
sym->name = h->root.root.string;
|
|
|
|
|
sym->flags = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
set_symbol_from_hash (sym, &h->root);
|
|
|
|
|
|
|
|
|
|
sym->flags |= BSF_GLOBAL;
|
|
|
|
|
|
|
|
|
|
if (! generic_add_output_symbol (wginfo->output_bfd, wginfo->psymalloc,
|
|
|
|
|
sym))
|
|
|
|
|
{
|
|
|
|
|
/* FIXME: No way to return failure. */
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create a relocation. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_reloc_link_order (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
asection *sec,
|
|
|
|
|
struct bfd_link_order *link_order)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
arelent *r;
|
|
|
|
|
|
2003-06-25 08:40:27 +02:00
|
|
|
|
if (! info->relocatable)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
abort ();
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (sec->orelocation == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
abort ();
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
r = bfd_alloc (abfd, sizeof (arelent));
|
|
|
|
|
if (r == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2001-01-03 20:26:07 +01:00
|
|
|
|
|
1999-05-03 09:29:11 +02:00
|
|
|
|
r->address = link_order->offset;
|
|
|
|
|
r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
|
|
|
|
|
if (r->howto == 0)
|
|
|
|
|
{
|
|
|
|
|
bfd_set_error (bfd_error_bad_value);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Get the symbol to use for the relocation. */
|
|
|
|
|
if (link_order->type == bfd_section_reloc_link_order)
|
|
|
|
|
r->sym_ptr_ptr = link_order->u.reloc.p->u.section->symbol_ptr_ptr;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
struct generic_link_hash_entry *h;
|
|
|
|
|
|
|
|
|
|
h = ((struct generic_link_hash_entry *)
|
|
|
|
|
bfd_wrapped_link_hash_lookup (abfd, info,
|
|
|
|
|
link_order->u.reloc.p->u.name,
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE, TRUE));
|
2003-06-29 12:06:40 +02:00
|
|
|
|
if (h == NULL
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|| ! h->written)
|
|
|
|
|
{
|
|
|
|
|
if (! ((*info->callbacks->unattached_reloc)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
(info, link_order->u.reloc.p->u.name, NULL, NULL, 0)))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_set_error (bfd_error_bad_value);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
r->sym_ptr_ptr = &h->sym;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If this is an inplace reloc, write the addend to the object file.
|
|
|
|
|
Otherwise, store it in the reloc addend. */
|
|
|
|
|
if (! r->howto->partial_inplace)
|
|
|
|
|
r->addend = link_order->u.reloc.p->addend;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
bfd_size_type size;
|
|
|
|
|
bfd_reloc_status_type rstat;
|
|
|
|
|
bfd_byte *buf;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean ok;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
file_ptr loc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
size = bfd_get_reloc_size (r->howto);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
buf = bfd_zmalloc (size);
|
|
|
|
|
if (buf == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
rstat = _bfd_relocate_contents (r->howto, abfd,
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
(bfd_vma) link_order->u.reloc.p->addend,
|
|
|
|
|
buf);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
switch (rstat)
|
|
|
|
|
{
|
|
|
|
|
case bfd_reloc_ok:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
case bfd_reloc_outofrange:
|
|
|
|
|
abort ();
|
|
|
|
|
case bfd_reloc_overflow:
|
|
|
|
|
if (! ((*info->callbacks->reloc_overflow)
|
2004-10-21 17:28:33 +02:00
|
|
|
|
(info, NULL,
|
1999-05-03 09:29:11 +02:00
|
|
|
|
(link_order->type == bfd_section_reloc_link_order
|
|
|
|
|
? bfd_section_name (abfd, link_order->u.reloc.p->u.section)
|
|
|
|
|
: link_order->u.reloc.p->u.name),
|
|
|
|
|
r->howto->name, link_order->u.reloc.p->addend,
|
2003-06-29 12:06:40 +02:00
|
|
|
|
NULL, NULL, 0)))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
free (buf);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
loc = link_order->offset * bfd_octets_per_byte (abfd);
|
2003-06-29 12:06:40 +02:00
|
|
|
|
ok = bfd_set_section_contents (abfd, sec, buf, loc, size);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
free (buf);
|
|
|
|
|
if (! ok)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
r->addend = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sec->orelocation[sec->reloc_count] = r;
|
|
|
|
|
++sec->reloc_count;
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Allocate a new link_order for a section. */
|
|
|
|
|
|
|
|
|
|
struct bfd_link_order *
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_new_link_order (bfd *abfd, asection *section)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type amt = sizeof (struct bfd_link_order);
|
2002-02-15 03:10:35 +01:00
|
|
|
|
struct bfd_link_order *new;
|
|
|
|
|
|
2003-06-29 12:06:40 +02:00
|
|
|
|
new = bfd_zalloc (abfd, amt);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (!new)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
new->type = bfd_undefined_link_order;
|
|
|
|
|
|
2005-05-04 13:00:28 +02:00
|
|
|
|
if (section->map_tail.link_order != NULL)
|
|
|
|
|
section->map_tail.link_order->next = new;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
2005-05-04 13:00:28 +02:00
|
|
|
|
section->map_head.link_order = new;
|
|
|
|
|
section->map_tail.link_order = new;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Default link order processing routine. Note that we can not handle
|
|
|
|
|
the reloc_link_order types here, since they depend upon the details
|
|
|
|
|
of how the particular backends generates relocs. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_default_link_order (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
asection *sec,
|
|
|
|
|
struct bfd_link_order *link_order)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
switch (link_order->type)
|
|
|
|
|
{
|
|
|
|
|
case bfd_undefined_link_order:
|
|
|
|
|
case bfd_section_reloc_link_order:
|
|
|
|
|
case bfd_symbol_reloc_link_order:
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
case bfd_indirect_link_order:
|
|
|
|
|
return default_indirect_link_order (abfd, info, sec, link_order,
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
case bfd_data_link_order:
|
2002-02-15 03:10:35 +01:00
|
|
|
|
return default_data_link_order (abfd, info, sec, link_order);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-02-15 03:10:35 +01:00
|
|
|
|
/* Default routine to handle a bfd_data_link_order. */
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
default_data_link_order (bfd *abfd,
|
|
|
|
|
struct bfd_link_info *info ATTRIBUTE_UNUSED,
|
|
|
|
|
asection *sec,
|
|
|
|
|
struct bfd_link_order *link_order)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type size;
|
2002-02-15 03:10:35 +01:00
|
|
|
|
size_t fill_size;
|
|
|
|
|
bfd_byte *fill;
|
2001-08-17 11:50:05 +02:00
|
|
|
|
file_ptr loc;
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean result;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
|
|
|
|
|
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
size = link_order->size;
|
2001-08-17 11:50:05 +02:00
|
|
|
|
if (size == 0)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
2001-08-17 11:50:05 +02:00
|
|
|
|
|
2002-02-15 03:10:35 +01:00
|
|
|
|
fill = link_order->u.data.contents;
|
|
|
|
|
fill_size = link_order->u.data.size;
|
|
|
|
|
if (fill_size != 0 && fill_size < size)
|
|
|
|
|
{
|
|
|
|
|
bfd_byte *p;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
fill = bfd_malloc (size);
|
2002-02-15 03:10:35 +01:00
|
|
|
|
if (fill == NULL)
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
2002-02-15 03:10:35 +01:00
|
|
|
|
p = fill;
|
|
|
|
|
if (fill_size == 1)
|
|
|
|
|
memset (p, (int) link_order->u.data.contents[0], (size_t) size);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
memcpy (p, link_order->u.data.contents, fill_size);
|
|
|
|
|
p += fill_size;
|
|
|
|
|
size -= fill_size;
|
|
|
|
|
}
|
|
|
|
|
while (size >= fill_size);
|
|
|
|
|
if (size != 0)
|
|
|
|
|
memcpy (p, link_order->u.data.contents, (size_t) size);
|
|
|
|
|
size = link_order->size;
|
|
|
|
|
}
|
|
|
|
|
}
|
2001-08-17 11:50:05 +02:00
|
|
|
|
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
loc = link_order->offset * bfd_octets_per_byte (abfd);
|
2002-02-15 03:10:35 +01:00
|
|
|
|
result = bfd_set_section_contents (abfd, sec, fill, loc, size);
|
2001-08-17 11:50:05 +02:00
|
|
|
|
|
2002-02-15 03:10:35 +01:00
|
|
|
|
if (fill != link_order->u.data.contents)
|
|
|
|
|
free (fill);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Default routine to handle a bfd_indirect_link_order. */
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
static bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
default_indirect_link_order (bfd *output_bfd,
|
|
|
|
|
struct bfd_link_info *info,
|
|
|
|
|
asection *output_section,
|
|
|
|
|
struct bfd_link_order *link_order,
|
|
|
|
|
bfd_boolean generic_linker)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
asection *input_section;
|
|
|
|
|
bfd *input_bfd;
|
|
|
|
|
bfd_byte *contents = NULL;
|
|
|
|
|
bfd_byte *new_contents;
|
Touches most files in bfd/, so likely will be blamed for everything..
o bfd_read and bfd_write lose an unnecessary param and become
bfd_bread and bfd_bwrite.
o bfd_*alloc now all take a bfd_size_type arg, and will error if
size_t is too small. eg. 32 bit host, 64 bit bfd, verrry big files
or bugs in linker scripts etc.
o file_ptr becomes a bfd_signed_vma. Besides matching sizes with
various other types involved in handling sections, this should make
it easier for bfd to support a 64 bit off_t on 32 bit hosts that
provide it.
o I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
generally available. They now cast their args to bfd_vma and
bfd_byte * as appropriate, which removes a swag of casts from the
source.
o Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
aout-encap.c.
o Zillions of formatting and -Wconversion fixes.
2001-09-18 11:57:26 +02:00
|
|
|
|
bfd_size_type sec_size;
|
|
|
|
|
file_ptr loc;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
|
|
|
|
|
|
|
|
|
|
input_section = link_order->u.indirect.section;
|
|
|
|
|
input_bfd = input_section->owner;
|
2005-12-27 04:06:27 +01:00
|
|
|
|
if (input_section->size == 0)
|
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
BFD_ASSERT (input_section->output_section == output_section);
|
|
|
|
|
BFD_ASSERT (input_section->output_offset == link_order->offset);
|
bfd/
* section.c (struct sec): Rename "_cooked_size" to "size".
Rename "_raw_size" to "rawsize".
(STD_SECTION): Adjust comments.
(bfd_set_section_size, bfd_get_section_contents): Use size.
(bfd_malloc_and_get_section): New function.
* bfd-in.h (bfd_section_size, bfd_get_section_size): Use size.
* coff-sh.c (sh_relax_section): Alloc coff_section_data struct early.
Correctly free reloc and contents memory.
* elf-eh-frame.c (_bfd_elf_discard_section_eh_frame): Delete FIXME
and fake CIE now that we can shink section size to zero.
(_bfd_elf_write_section_eh_frame): Likewise..
* elf32-ppc.c (ppc_elf_relax_section): Delay reading section contents.
* elf-m10300.c (mn10300_elf_final_link_relocate): Don't use
_bfd_stab_section_offset. Use _bfd_elf_section_offset.
* stabs.c (_bfd_stab_section_offset_): Remove unused args and
unneeded indirection.
* elf.c (_bfd_elf_section_offset): .. and update call.
* libbfd-in.h (_bfd_stab_section_offset): Update prototype.
* libbfd.h: Regenerate.
* bfd-in2.h: Regenerate.
Replace occurrences of "_raw_size" and "_cooked_size" in most places
with "size". Set new "rawsize" for stabs, eh_frame, and SEC_MERGE
sections. Use "rawsize", if non-zero, for bfd_get_section_contents
calls if the section might be a stabs, eh_frame, or SEC_MERGE section.
Similarly use "rawsize", if non-zero, in reloc functions to validate
reloc addresses. Use new bfd_malloc_and_get_section in most places
where bfd_get_section_contents was called. Expand all occurrences of
bfd_section_size and bfd_get_section_size. Rename "raw_size" var in
grok_prstatus and similar functions to "size".
* aix386-core.c (aix386_core_file_p): ..
* aix5ppc-core.c (xcoff64_core_p): ..
* aout-adobe.c (aout_adobe_callback, aout_adobe_write_object_contents,
aout_adobe_set_section_contents): ..
* aout-target.h (callback): ..
* aout-tic30.c (tic30_aout_callback, tic30_aout_final_link_relocate,
MY_bfd_final_link): ..
* aoutf1.h (sunos4_core_file_p): ..
* aoutx.h (some_aout_object_p, adjust_o_magic, adjust_z_magic,
adjust_n_magic, adjust_sizes_and_vmas, translate_from_native_sym_flags,
final_link, aout_link_input_section): ..
* binary.c (binary_object_p, binary_canonicalize_symtab,
binary_set_section_contents): ..
* bout.c (b_out_callback, b_out_write_object_contents,
b_out_set_section_contents, b_out_bfd_relax_section,
b_out_bfd_get_relocated_section_contents): ..
* cisco-core.c (cisco_core_file_validate): ..
* coff-alpha.c (alpha_ecoff_object_p,
alpha_ecoff_get_relocated_section_conten, alpha_relocate_section): ..
* coff-arm.c (coff_arm_relocate_section,
bfd_arm_allocate_interworking_sections): ..
* coff-h8300.c (h8300_reloc16_extra_cases,
h8300_bfd_link_add_symbols): ..
* coff-mips.c (mips_refhi_reloc, mips_gprel_reloc): ..
* coff-ppc.c (coff_ppc_relocate_section, ppc_allocate_toc_section,
ppc_bfd_coff_final_link): ..
* coff-rs6000.c (xcoff_reloc_type_br, xcoff_ppc_relocate_section): ..
* coff-sh.c (sh_relax_section, sh_relax_delete_bytes,
sh_align_loads, sh_coff_get_relocated_section_contents): ..
* coff64-rs6000.c (xcoff64_write_object_contents,
xcoff64_reloc_type_br, xcoff64_ppc_relocate_section): ..
* coffcode.h (coff_compute_section_file_positions,
coff_write_object_contents): ..
* coffgen.c (make_a_section_from_file, coff_write_symbols,
coff_section_symbol, build_debug_section): ..
* cofflink.c (coff_link_add_symbols, _bfd_coff_final_link,
process_embedded_commands, _bfd_coff_link_input_bfd,
_bfd_coff_write_global_sym): ..
* cpu-arm.c (bfd_arm_update_notes, bfd_arm_get_mach_from_notes): ..
* cpu-ns32k.c (do_ns32k_reloc, _bfd_ns32k_final_link_relocate): ..
* dwarf1.c (parse_line_table, _bfd_dwarf1_find_nearest_line): ..
* dwarf2.c (read_indirect_string, read_abbrevs, decode_line_info,
_bfd_dwarf2_find_nearest_line): ..
* ecoff.c (bfd_debug_section, ecoff_set_symbol_info,
ecoff_compute_section_file_positions,
_bfd_ecoff_write_object_contents, ecoff_indirect_link_order): ..
* elf-eh-frame.c (_bfd_elf_discard_section_eh_frame,
_bfd_elf_discard_section_eh_frame_hdr,
_bfd_elf_maybe_strip_eh_frame_hdr, _bfd_elf_eh_frame_section_offset,
_bfd_elf_write_section_eh_frame,
_bfd_elf_write_section_eh_frame_hdr): ..
* elf-hppa.h (elf_hppa_sort_unwind): ..
* elf-m10200.c (mn10200_elf_relax_section,
mn10200_elf_relax_delete_bytes,
mn10200_elf_get_relocated_section_contents): ..
* elf-m10300.c (_bfd_mn10300_elf_create_got_section,
mn10300_elf_check_relocs, mn10300_elf_relax_section,
mn10300_elf_relax_delete_bytes,
mn10300_elf_get_relocated_section_contents,
_bfd_mn10300_elf_adjust_dynamic_symbol,
_bfd_mn10300_elf_discard_copies,
_bfd_mn10300_elf_size_dynamic_sections,
_bfd_mn10300_elf_finish_dynamic_sections): ..
* elf.c (_bfd_elf_print_private_bfd_data, bfd_elf_get_bfd_needed_list,
_bfd_elf_make_section_from_phdr, elf_fake_sections,
bfd_elf_set_group_contents, map_sections_to_segments,
elf_sort_sections, assign_file_positions_for_segments,
SECTION_SIZE, copy_private_bfd_data,
_bfd_elf_get_dynamic_reloc_upper_bound,
_bfd_elf_canonicalize_dynamic_reloc, elfcore_maybe_make_sect,
_bfd_elfcore_make_pseudosection, elfcore_grok_prstatus,
elfcore_grok_lwpstatus, elfcore_grok_win32pstatus,
elfcore_grok_note, elfcore_grok_nto_status, elfcore_grok_nto_gregs,
_bfd_elf_rel_local_sym, _bfd_elf_get_synthetic_symtab): ..
* elf32-arm.h (bfd_elf32_arm_allocate_interworking_sect,
bfd_elf32_arm_process_before_allocation,
elf32_arm_adjust_dynamic_symbol, allocate_dynrelocs,
elf32_arm_size_dynamic_sections, elf32_arm_finish_dynamic_sections,
elf32_arm_write_section): ..
* elf32-cris.c (cris_elf_grok_prstatus,
elf_cris_finish_dynamic_sections, cris_elf_gc_sweep_hook,
elf_cris_adjust_gotplt_to_got, elf_cris_adjust_dynamic_symbol,
cris_elf_check_relocs, elf_cris_size_dynamic_sections,
elf_cris_discard_excess_dso_dynamics,
elf_cris_discard_excess_program_dynamics): ..
* elf32-d30v.c (bfd_elf_d30v_reloc, bfd_elf_d30v_reloc_21): ..
* elf32-dlx.c (_bfd_dlx_elf_hi16_reloc): ..
* elf32-frv.c (_frvfdpic_add_dyn_reloc, _frvfdpic_add_rofixup,
_frv_create_got_section, _frvfdpic_assign_plt_entries,
elf32_frvfdpic_size_dynamic_sections,
elf32_frvfdpic_modify_segment_map,
elf32_frvfdpic_finish_dynamic_sections): ..
* elf32-h8300.c (elf32_h8_relax_section, elf32_h8_relax_delete_bytes,
elf32_h8_get_relocated_section_contents): ..
* elf32-hppa.c (hppa_build_one_stub, hppa_size_one_stub,
elf32_hppa_adjust_dynamic_symbol, allocate_plt_static,
allocate_dynrelocs, elf32_hppa_size_dynamic_sections, group_sections,
elf32_hppa_size_stubs, elf32_hppa_set_gp, elf32_hppa_build_stubs,
elf32_hppa_finish_dynamic_sections): ..
* elf32-i370.c (i370_elf_adjust_dynamic_symbol,
i370_elf_size_dynamic_sections, i370_elf_check_relocs,
i370_elf_finish_dynamic_sections): ..
* elf32-i386.c (elf_i386_grok_prstatus, elf_i386_adjust_dynamic_symbol,
allocate_dynrelocs, elf_i386_size_dynamic_sections,
elf_i386_relocate_section, elf_i386_finish_dynamic_sections): ..
* elf32-i860.c (i860_howto_pc26_reloc, i860_howto_pc16_reloc,
i860_howto_highadj_reloc, i860_howto_splitn_reloc): ..
* elf32-ip2k.c (ip2k_is_switch_table_128,
ip2k_relax_switch_table_128, ip2k_is_switch_table_256,
ip2k_relax_switch_table_256, ip2k_elf_relax_section,
adjust_all_relocations, ip2k_elf_relax_delete_bytes): ..
* elf32-m32r.c (m32r_elf_do_10_pcrel_reloc, m32r_elf_hi16_reloc,
m32r_elf_generic_reloc, m32r_elf_adjust_dynamic_symbol,
allocate_dynrelocs, m32r_elf_size_dynamic_sections,
m32r_elf_relocate_section, m32r_elf_finish_dynamic_sections,
m32r_elf_relax_section, m32r_elf_relax_delete_bytes,
m32r_elf_get_relocated_section_contents): ..
* elf32-m68hc11.c (m68hc11_elf_build_one_stub,
m68hc11_elf_size_one_stub, m68hc11_elf_relax_section,
m68hc11_elf_relax_delete_bytes): ..
* elf32-m68hc12.c (m68hc12_elf_build_one_stub,
m68hc12_elf_size_one_stub): ..
* elf32-m68hc1x.c (elf32_m68hc11_size_stubs,
elf32_m68hc11_build_stubs, m68hc11_elf_special_reloc): ..
* elf32-m68k.c (elf_m68k_check_relocs, elf_m68k_gc_sweep_hook,
elf_m68k_adjust_dynamic_symbol, elf_m68k_size_dynamic_sections,
elf_m68k_discard_copies, elf_m68k_finish_dynamic_sections): ..
* elf32-mips.c (gprel32_with_gp, mips16_gprel_reloc,
elf32_mips_grok_prstatus): ..
* elf32-or32.c (or32_elf_consth_reloc): ..
* elf32-ppc.c (ppc_elf_relax_section, ppc_elf_addr16_ha_reloc,
elf_create_pointer_linker_section, ppc_elf_create_linker_section,
ppc_elf_additional_program_headers, ppc_elf_adjust_dynamic_symbol,
allocate_dynrelocs, ppc_elf_size_dynamic_sections,
ppc_elf_finish_dynamic_sections, ppc_elf_grok_prstatus,
ppc_elf_final_write_processing): ..
* elf32-s390.c (s390_elf_ldisp_reloc, elf_s390_adjust_dynamic_symbol,
allocate_dynrelocs, elf_s390_size_dynamic_sections,
elf_s390_finish_dynamic_sections, elf_s390_grok_prstatus): ..
* elf32-sh.c (sh_elf_reloc_loop, sh_elf_relax_section,
sh_elf_relax_delete_bytes, sh_elf_align_loads,
sh_elf_adjust_dynamic_symbol, allocate_dynrelocs,
sh_elf_size_dynamic_sections, sh_elf_get_relocated_section_contents,
sh_elf_finish_dynamic_sections, elf32_shlin_grok_prstatus): ..
* elf32-sh64-com.c (sh64_address_in_cranges,
sh64_get_contents_type): ..
* elf32-sh64.c (sh64_find_section_for_address,
sh64_elf_final_write_processing): ..
* elf32-sparc.c (sparc_elf_wdisp16_reloc, sparc_elf_hix22_reloc,
sparc_elf_lox10_reloc, elf32_sparc_adjust_dynamic_symbol,
allocate_dynrelocs, elf32_sparc_size_dynamic_sections,
elf32_sparc_relocate_section, elf32_sparc_finish_dynamic_sections): ..
* elf32-v850.c (v850_elf_reloc, v850_elf_relax_section): ..
* elf32-vax.c (elf_vax_check_relocs, elf_vax_adjust_dynamic_symbol,
elf_vax_size_dynamic_sections, elf_vax_discard_copies,
elf_vax_instantiate_got_entries, elf_vax_relocate_section,
elf_vax_finish_dynamic_sections): ..
* elf32-xstormy16.c (xstormy16_elf_24_reloc,
xstormy16_elf_check_relocs, xstormy16_relax_plt_check,
xstormy16_elf_relax_section, xstormy16_elf_always_size_sections,
xstormy16_elf_finish_dynamic_sections): ..
* elf32-xtensa.c (xtensa_read_table_entries,
elf_xtensa_allocate_got_size, elf_xtensa_allocate_local_got_size,
elf_xtensa_size_dynamic_sections, elf_xtensa_do_reloc,
bfd_elf_xtensa_reloc, elf_xtensa_relocate_section,
elf_xtensa_combine_prop_entries, elf_xtensa_finish_dynamic_sections,
elf_xtensa_discard_info_for_section, elf_xtensa_grok_prstatus,
get_relocation_opcode, retrieve_contents, find_relaxable_sections,
collect_source_relocs, is_resolvable_asm_expansion, remove_literals,
relax_section, shrink_dynamic_reloc_sections, relax_property_section,
xtensa_callback_required_dependence): ..
* elf64-alpha.c (elf64_alpha_reloc_gpdisp, elf64_alpha_relax_section,
elf64_alpha_check_relocs, elf64_alpha_adjust_dynamic_symbol,
elf64_alpha_calc_got_offsets_for_symbol, elf64_alpha_calc_got_offsets,
elf64_alpha_size_plt_section, elf64_alpha_size_plt_section_1,
elf64_alpha_always_size_sections, elf64_alpha_calc_dynrel_sizes,
elf64_alpha_size_rela_got_section, elf64_alpha_size_rela_got_1,
elf64_alpha_size_dynamic_sections, elf64_alpha_emit_dynrel,
elf64_alpha_finish_dynamic_sections, elf64_alpha_final_link): ..
* elf64-hppa.c (allocate_dynrel_entries,
elf64_hppa_size_dynamic_sections,
elf64_hppa_finish_dynamic_sections): ..
* elf64-mips.c (mips_elf64_gprel32_reloc, mips16_gprel_reloc,
mips_elf64_canonicalize_dynamic_reloc, mips_elf64_slurp_reloc_table,
elf64_mips_grok_prstatus): ..
* elf64-mmix.c (mmix_elf_perform_relocation, mmix_elf_reloc,
mmix_elf_relocate_section, mmix_elf_final_link,
mmix_set_relaxable_size, _bfd_mmix_after_linker_allocation,
mmix_elf_relax_section, mmix_elf_get_section_contents): ..
* elf64-ppc.c (ppc64_elf_object_p, ppc64_elf_grok_prstatus,
ppc64_elf_check_relocs, ppc64_elf_func_desc_adjust,
ppc64_elf_adjust_dynamic_symbol, ppc64_elf_edit_opd,
allocate_dynrelocs, ppc64_elf_size_dynamic_sections,
ppc_build_one_stub, ppc_size_one_stub, ppc64_elf_next_toc_section,
toc_adjusting_stub_needed, group_sections, ppc64_elf_size_stubs,
ppc64_elf_build_stubs, ppc64_elf_relocate_section,
ppc64_elf_finish_dynamic_sections): ..
* elf64-s390.c (s390_elf_ldisp_reloc, elf_s390_adjust_dynamic_symbol,
allocate_dynrelocs, elf_s390_size_dynamic_sections,
elf_s390_finish_dynamic_sections): ..
* elf64-sh64.c (sh_elf64_get_relocated_section_contents,
sh_elf64_check_relocs, sh64_elf64_adjust_dynamic_symbol,
sh64_elf64_discard_copies, sh64_elf64_size_dynamic_sections,
sh64_elf64_finish_dynamic_sections): ..
* elf64-sparc.c (sparc64_elf_slurp_reloc_table, init_insn_reloc,
sparc64_elf_check_relocs, sparc64_elf_adjust_dynamic_symbol,
sparc64_elf_size_dynamic_sections, sparc64_elf_relocate_section,
sparc64_elf_finish_dynamic_symbol,
sparc64_elf_finish_dynamic_sections): ..
* elf64-x86-64.c (elf64_x86_64_grok_prstatus,
elf64_x86_64_adjust_dynamic_symbol, allocate_dynrelocs,
elf64_x86_64_size_dynamic_sections, elf64_x86_64_relocate_section,
elf64_x86_64_finish_dynamic_sections): ..
* elfarm-nabi.c (elf32_arm_nabi_grok_prstatus): ..
* elfcode.h (elf_slurp_reloc_table): ..
* elflink.c (_bfd_elf_create_got_section, elf_add_dt_needed_tag,
elf_finalize_dynstr, elf_link_add_object_symbols,
bfd_elf_size_dynamic_sections, elf_link_sort_relocs,
elf_link_input_bfd, bfd_elf_final_link, bfd_elf_discard_info): ..
* elfn32-mips.c (gprel32_with_gp, mips16_gprel_reloc,
elf32_mips_grok_prstatus): ..
* elfxx-ia64.c (elfNN_ia64_relax_section, allocate_dynrel_entries,
elfNN_ia64_size_dynamic_sections, elfNN_ia64_install_dyn_reloc,
elfNN_ia64_choose_gp, elfNN_ia64_final_link,
elfNN_ia64_finish_dynamic_sections): ..
* elfxx-mips.c (mips_elf_create_procedure_table,
mips_elf_check_mips16_stubs, _bfd_mips_elf_gprel16_with_gp,
_bfd_mips_elf_hi16_reloc, _bfd_mips_elf_generic_reloc,
mips_elf_global_got_index, mips_elf_multi_got,
mips_elf_create_compact_rel_section, mips_elf_calculate_relocation,
mips_elf_allocate_dynamic_relocations,
mips_elf_create_dynamic_relocation, _bfd_mips_elf_fake_sections,
_bfd_mips_relax_section, _bfd_mips_elf_adjust_dynamic_symbol,
_bfd_mips_elf_always_size_sections,
_bfd_mips_elf_size_dynamic_sections,
_bfd_mips_elf_finish_dynamic_symbol,
_bfd_mips_elf_finish_dynamic_sections,
_bfd_mips_elf_modify_segment_map, _bfd_mips_elf_discard_info,
_bfd_mips_elf_write_section, _bfd_mips_elf_set_section_contents,
_bfd_elf_mips_get_relocated_section_contents,
_bfd_mips_elf_final_link, _bfd_mips_elf_merge_private_bfd_data): ..
* hp300hpux.c (callback): ..
* hppabsd-core.c (make_bfd_asection): ..
* hpux-core.c (make_bfd_asection): ..
* i386linux.c (linux_link_create_dynamic_sections,
bfd_i386linux_size_dynamic_sections, linux_finish_dynamic_link): ..
* i386msdos.c (msdos_write_object_contents): ..
* i386os9k.c (os9k_callback, os9k_write_object_contents,
os9k_set_section_contents): ..
* ieee.c (parse_expression, ieee_slurp_external_symbols,
ieee_slurp_sections, ieee_slurp_debug, ieee_slurp_section_data,
ieee_write_section_part, do_with_relocs, do_as_repeat,
do_without_relocs, ieee_write_debug_part, init_for_output,
ieee_set_section_contents): ..
* ihex.c (ihex_scan, ihex_read_section, ihex_get_section_contents): ..
* irix-core.c (do_sections, make_bfd_asection): ..
* libaout.h (aout_section_merge_with_text_p): ..
* libbfd.c (_bfd_generic_get_section_contents,
_bfd_generic_get_section_contents_in_window): ..
* linker.c (default_indirect_link_order): ..
* lynx-core.c (make_bfd_asection): ..
* m68klinux.c (linux_link_create_dynamic_sections,
bfd_m68klinux_size_dynamic_sections, linux_finish_dynamic_link): ..
* mach-o.c (bfd_mach_o_make_bfd_section,
bfd_mach_o_scan_read_dylinker, bfd_mach_o_scan_read_dylib,
bfd_mach_o_scan_read_thread, bfd_mach_o_scan_read_symtab,
bfd_mach_o_scan_read_segment): ..
* merge.c (_bfd_add_merge_section, record_section, merge_strings,
_bfd_merge_sections): ..
* mmo.c (mmo_find_sec_w_addr, mmo_get_spec_section, mmo_get_loc,
mmo_map_set_sizes, mmo_canonicalize_symtab,
mmo_internal_write_section, mmo_write_object_contents): ..
* netbsd-core.c (netbsd_core_file_p): ..
* nlm32-alpha.c (nlm_alpha_read_reloc, nlm_alpha_write_import,
nlm_alpha_set_public_section): ..
* nlm32-ppc.c (nlm_powerpc_read_reloc, nlm_powerpc_write_reloc): ..
* nlm32-sparc.c (nlm_sparc_write_import): ..
* nlmcode.h (add_bfd_section, nlm_swap_auxiliary_headers_in,
nlm_compute_section_file_positions): ..
* oasys.c (oasys_object_p, oasys_slurp_section_data,
oasys_write_sections, oasys_write_data, oasys_set_section_contents): ..
* opncls.c (get_debug_link_info): ..
* osf-core.c (make_bfd_asection): ..
* pdp11.c (some_aout_object_p, adjust_o_magic, adjust_z_magic,
adjust_n_magic, adjust_sizes_and_vmas, squirt_out_relocs,
final_link, aout_link_input_section): ..
* peXXigen.c (_bfd_XXi_swap_sym_in, _bfd_XXi_swap_aouthdr_out,
pe_print_idata, pe_print_edata, pe_print_pdata, pe_print_reloc): ..
* pef.c (bfd_pef_make_bfd_section, bfd_pef_print_loader_section,
bfd_pef_scan_start_address, bfd_pef_parse_symbols): ..
* ppcboot.c (ppcboot_object_p, ppcboot_canonicalize_symtab): ..
* ptrace-core.c (ptrace_unix_core_file_p): ..
* reloc.c (bfd_perform_relocation, bfd_install_relocation,
_bfd_final_link_relocate, bfd_generic_relax_section,
bfd_generic_get_relocated_section_contents): ..
* reloc16.c (bfd_coff_reloc16_relax_section,
bfd_coff_reloc16_get_relocated_section_c): ..
* riscix.c (riscix_some_aout_object_p): ..
* rs6000-core.c (read_hdr, make_bfd_asection): ..
* sco5-core.c (make_bfd_asection): ..
* simple.c (bfd_simple_get_relocated_section_contents): ..
* som.c (som_object_setup, setup_sections, som_prep_headers,
som_write_fixups, som_begin_writing, bfd_section_from_som_symbol,
som_set_reloc_info, som_get_section_contents,
som_bfd_link_split_section): ..
* sparclinux.c (linux_link_create_dynamic_sections,
bfd_sparclinux_size_dynamic_sections, linux_finish_dynamic_link): ..
* srec.c (srec_scan, srec_read_section, srec_get_section_contents): ..
* stabs.c (_bfd_link_section_stabs, _bfd_discard_section_stabs,
_bfd_write_stab_strings, _bfd_stab_section_offset): ..
* sunos.c (sunos_read_dynamic_info, sunos_create_dynamic_sections,
bfd_sunos_size_dynamic_sections, sunos_scan_std_relocs,
sunos_scan_ext_relocs, sunos_scan_dynamic_symbol,
sunos_write_dynamic_symbol, sunos_check_dynamic_reloc,
sunos_finish_dynamic_link): ..
* syms.c (_bfd_stab_section_find_nearest_line): ..
* tekhex.c (first_phase, tekhex_set_section_contents,
tekhex_write_object_contents): ..
* trad-core.c (trad_unix_core_file_p): ..
* versados.c (process_esd, process_otr, process_otr): ..
* vms-gsd.c (_bfd_vms_slurp_gsd, _bfd_vms_write_gsd): ..
* vms-misc.c (add_new_contents): ..
* vms-tir.c (check_section, new_section, _bfd_vms_write_tir): ..
* vms.c (vms_set_section_contents): ..
* xcofflink.c (xcoff_get_section_contents, xcoff_link_add_symbols,
xcoff_sweep, bfd_xcoff_size_dynamic_sections, xcoff_build_ldsyms,
_bfd_xcoff_bfd_final_link, xcoff_link_input_bfd): ..
* xsym.c (bfd_sym_scan): .. See above.
binutils/
* objcopy.c (copy_section): Don't set _cooked_size.
include/
* bfdlink.h (struct bfd_link_order): Update comment.
ld/
* ldlang.c (print_output_section_statement): Don't print size before
relaxation.
(IGNORE_SECTION): Remove bfd arg. Update all callers.
* ldexp.c (fold_name): .. See below.
* ldlang.c (section_already_linked, print_output_section_statement,
print_input_section, insert_pad, size_input_section,
lang_check_section_addresses, lang_size_sections_1,
lang_size_sections, lang_do_assignments_1, lang_set_startof,
lang_one_common, lang_reset_memory_regions, lang_process,
lang_abs_symbol_at_end_of, lang_do_version_exports_section): ..
* ldwrite.c (build_link_order, clone_section, ds, split_sections): ..
* pe-dll.c (process_def_file, generate_reloc): ..
* emultempl/elf32.em (gld${EMULATION_NAME}_find_statement_assignment,
gld${EMULATION_NAME}_before_allocation): ..
* emultempl/mmix-elfnmmo.em (mmix_after_allocation): ..
* emultempl/sh64elf.em (sh64_elf_${EMULATION_NAME}_before_allocation,
sh64_elf_${EMULATION_NAME}_after_allocation): ..
* emultempl/sunos.em (gld${EMULATION_NAME}_before_allocation): ..
* emultempl/xtensaelf.em (ld_assign_relative_paged_dot,
ld_local_file_relocations_fit, ld_xtensa_insert_page_offsets): Use
"size" instead of "_raw_size" and "_cooked_size". Expand
bfd_section_size macro invocations.
2004-06-24 06:46:28 +02:00
|
|
|
|
BFD_ASSERT (input_section->size == link_order->size);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
2003-06-25 08:40:27 +02:00
|
|
|
|
if (info->relocatable
|
1999-05-03 09:29:11 +02:00
|
|
|
|
&& input_section->reloc_count > 0
|
2003-06-29 12:06:40 +02:00
|
|
|
|
&& output_section->orelocation == NULL)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
/* Space has not been allocated for the output relocations.
|
|
|
|
|
This can happen when we are called by a specific backend
|
|
|
|
|
because somebody is attempting to link together different
|
|
|
|
|
types of object files. Handling this case correctly is
|
|
|
|
|
difficult, and sometimes impossible. */
|
|
|
|
|
(*_bfd_error_handler)
|
2003-06-25 08:40:27 +02:00
|
|
|
|
(_("Attempt to do relocatable link with %s input and %s output"),
|
1999-05-03 09:29:11 +02:00
|
|
|
|
bfd_get_target (input_bfd), bfd_get_target (output_bfd));
|
|
|
|
|
bfd_set_error (bfd_error_wrong_format);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (! generic_linker)
|
|
|
|
|
{
|
|
|
|
|
asymbol **sympp;
|
|
|
|
|
asymbol **symppend;
|
|
|
|
|
|
|
|
|
|
/* Get the canonical symbols. The generic linker will always
|
|
|
|
|
have retrieved them by this point, but we are being called by
|
|
|
|
|
a specific linker, presumably because we are linking
|
|
|
|
|
different types of object files together. */
|
2008-08-17 05:12:50 +02:00
|
|
|
|
if (!bfd_generic_link_read_symbols (input_bfd))
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Since we have been called by a specific linker, rather than
|
|
|
|
|
the generic linker, the values of the symbols will not be
|
|
|
|
|
right. They will be the values as seen in the input file,
|
|
|
|
|
not the values of the final link. We need to fix them up
|
|
|
|
|
before we can relocate the section. */
|
|
|
|
|
sympp = _bfd_generic_link_get_symbols (input_bfd);
|
|
|
|
|
symppend = sympp + _bfd_generic_link_get_symcount (input_bfd);
|
|
|
|
|
for (; sympp < symppend; sympp++)
|
|
|
|
|
{
|
|
|
|
|
asymbol *sym;
|
|
|
|
|
struct bfd_link_hash_entry *h;
|
|
|
|
|
|
|
|
|
|
sym = *sympp;
|
|
|
|
|
|
|
|
|
|
if ((sym->flags & (BSF_INDIRECT
|
|
|
|
|
| BSF_WARNING
|
|
|
|
|
| BSF_GLOBAL
|
|
|
|
|
| BSF_CONSTRUCTOR
|
|
|
|
|
| BSF_WEAK)) != 0
|
|
|
|
|
|| bfd_is_und_section (bfd_get_section (sym))
|
|
|
|
|
|| bfd_is_com_section (bfd_get_section (sym))
|
|
|
|
|
|| bfd_is_ind_section (bfd_get_section (sym)))
|
|
|
|
|
{
|
|
|
|
|
/* sym->udata may have been set by
|
|
|
|
|
generic_link_add_symbol_list. */
|
|
|
|
|
if (sym->udata.p != NULL)
|
2003-06-29 12:06:40 +02:00
|
|
|
|
h = sym->udata.p;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else if (bfd_is_und_section (bfd_get_section (sym)))
|
|
|
|
|
h = bfd_wrapped_link_hash_lookup (output_bfd, info,
|
|
|
|
|
bfd_asymbol_name (sym),
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
else
|
|
|
|
|
h = bfd_link_hash_lookup (info->hash,
|
|
|
|
|
bfd_asymbol_name (sym),
|
2002-11-30 09:39:46 +01:00
|
|
|
|
FALSE, FALSE, TRUE);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (h != NULL)
|
|
|
|
|
set_symbol_from_hash (sym, h);
|
|
|
|
|
}
|
2001-01-03 20:26:07 +01:00
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-10-03 11:40:49 +02:00
|
|
|
|
if ((output_section->flags & (SEC_GROUP | SEC_LINKER_CREATED)) == SEC_GROUP
|
|
|
|
|
&& input_section->size != 0)
|
|
|
|
|
{
|
|
|
|
|
/* Group section contents are set by bfd_elf_set_group_contents. */
|
|
|
|
|
if (!output_bfd->output_has_begun)
|
|
|
|
|
{
|
|
|
|
|
/* FIXME: This hack ensures bfd_elf_set_group_contents is called. */
|
|
|
|
|
if (!bfd_set_section_contents (output_bfd, output_section, "", 0, 1))
|
|
|
|
|
goto error_return;
|
|
|
|
|
}
|
|
|
|
|
new_contents = output_section->contents;
|
|
|
|
|
BFD_ASSERT (new_contents != NULL);
|
|
|
|
|
BFD_ASSERT (input_section->output_offset == 0);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Get and relocate the section contents. */
|
|
|
|
|
sec_size = (input_section->rawsize > input_section->size
|
|
|
|
|
? input_section->rawsize
|
|
|
|
|
: input_section->size);
|
|
|
|
|
contents = bfd_malloc (sec_size);
|
|
|
|
|
if (contents == NULL && sec_size != 0)
|
|
|
|
|
goto error_return;
|
|
|
|
|
new_contents = (bfd_get_relocated_section_contents
|
|
|
|
|
(output_bfd, info, link_order, contents,
|
|
|
|
|
info->relocatable,
|
|
|
|
|
_bfd_generic_link_get_symbols (input_bfd)));
|
|
|
|
|
if (!new_contents)
|
|
|
|
|
goto error_return;
|
|
|
|
|
}
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
/* Output the section contents. */
|
2005-12-27 04:06:27 +01:00
|
|
|
|
loc = input_section->output_offset * bfd_octets_per_byte (output_bfd);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
if (! bfd_set_section_contents (output_bfd, output_section,
|
2005-12-27 04:06:27 +01:00
|
|
|
|
new_contents, loc, input_section->size))
|
1999-05-03 09:29:11 +02:00
|
|
|
|
goto error_return;
|
|
|
|
|
|
|
|
|
|
if (contents != NULL)
|
|
|
|
|
free (contents);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return TRUE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
|
if (contents != NULL)
|
|
|
|
|
free (contents);
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A little routine to count the number of relocs in a link_order
|
|
|
|
|
list. */
|
|
|
|
|
|
|
|
|
|
unsigned int
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_count_link_order_relocs (struct bfd_link_order *link_order)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
register unsigned int c;
|
|
|
|
|
register struct bfd_link_order *l;
|
|
|
|
|
|
|
|
|
|
c = 0;
|
2003-06-29 12:06:40 +02:00
|
|
|
|
for (l = link_order; l != NULL; l = l->next)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
|
|
|
|
if (l->type == bfd_section_reloc_link_order
|
|
|
|
|
|| l->type == bfd_symbol_reloc_link_order)
|
|
|
|
|
++c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
FUNCTION
|
|
|
|
|
bfd_link_split_section
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2003-06-29 12:06:40 +02:00
|
|
|
|
bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
|
1999-05-03 09:29:11 +02:00
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Return nonzero if @var{sec} should be split during a
|
|
|
|
|
reloceatable or final link.
|
|
|
|
|
|
|
|
|
|
.#define bfd_link_split_section(abfd, sec) \
|
|
|
|
|
. BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
|
|
|
|
|
.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2002-11-30 09:39:46 +01:00
|
|
|
|
bfd_boolean
|
2003-06-29 12:06:40 +02:00
|
|
|
|
_bfd_generic_link_split_section (bfd *abfd ATTRIBUTE_UNUSED,
|
|
|
|
|
asection *sec ATTRIBUTE_UNUSED)
|
1999-05-03 09:29:11 +02:00
|
|
|
|
{
|
2002-11-30 09:39:46 +01:00
|
|
|
|
return FALSE;
|
1999-05-03 09:29:11 +02:00
|
|
|
|
}
|
2004-07-21 17:42:58 +02:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
FUNCTION
|
|
|
|
|
bfd_section_already_linked
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
2006-10-31 00:25:51 +01:00
|
|
|
|
void bfd_section_already_linked (bfd *abfd, asection *sec,
|
|
|
|
|
struct bfd_link_info *info);
|
2004-07-21 17:42:58 +02:00
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Check if @var{sec} has been already linked during a reloceatable
|
|
|
|
|
or final link.
|
|
|
|
|
|
2006-10-31 00:25:51 +01:00
|
|
|
|
.#define bfd_section_already_linked(abfd, sec, info) \
|
|
|
|
|
. BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))
|
2004-07-21 17:42:58 +02:00
|
|
|
|
.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Sections marked with the SEC_LINK_ONCE flag should only be linked
|
|
|
|
|
once into the output. This routine checks each section, and
|
|
|
|
|
arrange to discard it if a section of the same name has already
|
|
|
|
|
been linked. This code assumes that all relevant sections have the
|
|
|
|
|
SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
|
|
|
|
|
section name. bfd_section_already_linked is called via
|
|
|
|
|
bfd_map_over_sections. */
|
|
|
|
|
|
|
|
|
|
/* The hash table. */
|
|
|
|
|
|
|
|
|
|
static struct bfd_hash_table _bfd_section_already_linked_table;
|
|
|
|
|
|
|
|
|
|
/* Support routines for the hash table used by section_already_linked,
|
2004-07-27 16:20:49 +02:00
|
|
|
|
initialize the table, traverse, lookup, fill in an entry and remove
|
|
|
|
|
the table. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
bfd_section_already_linked_table_traverse
|
|
|
|
|
(bfd_boolean (*func) (struct bfd_section_already_linked_hash_entry *,
|
|
|
|
|
void *), void *info)
|
|
|
|
|
{
|
|
|
|
|
bfd_hash_traverse (&_bfd_section_already_linked_table,
|
|
|
|
|
(bfd_boolean (*) (struct bfd_hash_entry *,
|
|
|
|
|
void *)) func,
|
|
|
|
|
info);
|
|
|
|
|
}
|
2004-07-21 17:42:58 +02:00
|
|
|
|
|
|
|
|
|
struct bfd_section_already_linked_hash_entry *
|
|
|
|
|
bfd_section_already_linked_table_lookup (const char *name)
|
|
|
|
|
{
|
|
|
|
|
return ((struct bfd_section_already_linked_hash_entry *)
|
|
|
|
|
bfd_hash_lookup (&_bfd_section_already_linked_table, name,
|
|
|
|
|
TRUE, FALSE));
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-27 03:04:29 +02:00
|
|
|
|
bfd_boolean
|
2004-07-21 17:42:58 +02:00
|
|
|
|
bfd_section_already_linked_table_insert
|
|
|
|
|
(struct bfd_section_already_linked_hash_entry *already_linked_list,
|
|
|
|
|
asection *sec)
|
|
|
|
|
{
|
|
|
|
|
struct bfd_section_already_linked *l;
|
|
|
|
|
|
|
|
|
|
/* Allocate the memory from the same obstack as the hash table is
|
|
|
|
|
kept in. */
|
|
|
|
|
l = bfd_hash_allocate (&_bfd_section_already_linked_table, sizeof *l);
|
2007-07-27 03:04:29 +02:00
|
|
|
|
if (l == NULL)
|
|
|
|
|
return FALSE;
|
2004-07-21 17:42:58 +02:00
|
|
|
|
l->sec = sec;
|
|
|
|
|
l->next = already_linked_list->entry;
|
|
|
|
|
already_linked_list->entry = l;
|
2007-07-27 03:04:29 +02:00
|
|
|
|
return TRUE;
|
2004-07-21 17:42:58 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct bfd_hash_entry *
|
|
|
|
|
already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
|
|
|
|
|
struct bfd_hash_table *table,
|
|
|
|
|
const char *string ATTRIBUTE_UNUSED)
|
|
|
|
|
{
|
|
|
|
|
struct bfd_section_already_linked_hash_entry *ret =
|
|
|
|
|
bfd_hash_allocate (table, sizeof *ret);
|
|
|
|
|
|
2007-07-26 23:53:35 +02:00
|
|
|
|
if (ret == NULL)
|
2007-07-27 03:04:29 +02:00
|
|
|
|
return NULL;
|
2007-07-26 23:53:35 +02:00
|
|
|
|
|
2007-07-26 23:58:44 +02:00
|
|
|
|
ret->entry = NULL;
|
|
|
|
|
|
2004-07-21 17:42:58 +02:00
|
|
|
|
return &ret->root;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bfd_boolean
|
|
|
|
|
bfd_section_already_linked_table_init (void)
|
|
|
|
|
{
|
|
|
|
|
return bfd_hash_table_init_n (&_bfd_section_already_linked_table,
|
2006-03-16 13:20:16 +01:00
|
|
|
|
already_linked_newfunc,
|
|
|
|
|
sizeof (struct bfd_section_already_linked_hash_entry),
|
|
|
|
|
42);
|
2004-07-21 17:42:58 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
bfd_section_already_linked_table_free (void)
|
|
|
|
|
{
|
|
|
|
|
bfd_hash_table_free (&_bfd_section_already_linked_table);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is used on non-ELF inputs. */
|
|
|
|
|
|
|
|
|
|
void
|
2006-10-31 00:25:51 +01:00
|
|
|
|
_bfd_generic_section_already_linked (bfd *abfd, asection *sec,
|
2007-07-27 03:04:29 +02:00
|
|
|
|
struct bfd_link_info *info)
|
2004-07-21 17:42:58 +02:00
|
|
|
|
{
|
|
|
|
|
flagword flags;
|
|
|
|
|
const char *name;
|
|
|
|
|
struct bfd_section_already_linked *l;
|
|
|
|
|
struct bfd_section_already_linked_hash_entry *already_linked_list;
|
|
|
|
|
|
|
|
|
|
flags = sec->flags;
|
|
|
|
|
if ((flags & SEC_LINK_ONCE) == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* FIXME: When doing a relocatable link, we may have trouble
|
|
|
|
|
copying relocations in other sections that refer to local symbols
|
|
|
|
|
in the section being discarded. Those relocations will have to
|
|
|
|
|
be converted somehow; as of this writing I'm not sure that any of
|
|
|
|
|
the backends handle that correctly.
|
|
|
|
|
|
|
|
|
|
It is tempting to instead not discard link once sections when
|
|
|
|
|
doing a relocatable link (technically, they should be discarded
|
|
|
|
|
whenever we are building constructors). However, that fails,
|
|
|
|
|
because the linker winds up combining all the link once sections
|
|
|
|
|
into a single large link once section, which defeats the purpose
|
|
|
|
|
of having link once sections in the first place. */
|
|
|
|
|
|
|
|
|
|
name = bfd_get_section_name (abfd, sec);
|
|
|
|
|
|
|
|
|
|
already_linked_list = bfd_section_already_linked_table_lookup (name);
|
|
|
|
|
|
|
|
|
|
for (l = already_linked_list->entry; l != NULL; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
bfd_boolean skip = FALSE;
|
|
|
|
|
struct coff_comdat_info *s_comdat
|
|
|
|
|
= bfd_coff_get_comdat_section (abfd, sec);
|
|
|
|
|
struct coff_comdat_info *l_comdat
|
|
|
|
|
= bfd_coff_get_comdat_section (l->sec->owner, l->sec);
|
|
|
|
|
|
|
|
|
|
/* We may have 3 different sections on the list: group section,
|
|
|
|
|
comdat section and linkonce section. SEC may be a linkonce or
|
|
|
|
|
comdat section. We always ignore group section. For non-COFF
|
|
|
|
|
inputs, we also ignore comdat section.
|
|
|
|
|
|
|
|
|
|
FIXME: Is that safe to match a linkonce section with a comdat
|
|
|
|
|
section for COFF inputs? */
|
|
|
|
|
if ((l->sec->flags & SEC_GROUP) != 0)
|
|
|
|
|
skip = TRUE;
|
|
|
|
|
else if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
|
|
|
|
|
{
|
|
|
|
|
if (s_comdat != NULL
|
|
|
|
|
&& l_comdat != NULL
|
|
|
|
|
&& strcmp (s_comdat->name, l_comdat->name) != 0)
|
|
|
|
|
skip = TRUE;
|
|
|
|
|
}
|
|
|
|
|
else if (l_comdat != NULL)
|
|
|
|
|
skip = TRUE;
|
|
|
|
|
|
|
|
|
|
if (!skip)
|
|
|
|
|
{
|
|
|
|
|
/* The section has already been linked. See if we should
|
|
|
|
|
issue a warning. */
|
|
|
|
|
switch (flags & SEC_LINK_DUPLICATES)
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
case SEC_LINK_DUPLICATES_DISCARD:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SEC_LINK_DUPLICATES_ONE_ONLY:
|
bfd/
* bfd.c (_bfd_default_error_handler): Handle %A and %B.
(bfd_archive_filename, bfd_get_section_ident): Delete.
* ecofflink.c (bfd_ecoff_debug_accumulate_other): Don't call
bfd_archive_filename.
* elflink.c (elf_link_input_bfd): Don't use callbacks->error_handler
to warn about symbols in discarded sections. Use _bfd_error_handler.
* aout-adobe.c (aout_adobe_callback): See below.
* aout-cris.c (swap_ext_reloc_in): ..
* coff-arm.c (find_thumb_glue, find_arm_glue,
coff_arm_relocate_section, bfd_arm_process_before_allocation,
coff_arm_merge_private_bfd_data, _bfd_coff_arm_set_private_flags,
coff_arm_copy_private_bfd_data): ..
* coff-i860.c (i860_reloc_processing): ..
* coff-mcore.c (mcore_coff_unsupported_reloc,
coff_mcore_relocate_section): ..
* coff-ppc.c (coff_ppc_relocate_section): ..
* coff-rs6000.c (xcoff_create_csect_from_smclas
* coff-sh.c (sh_relax_section, sh_relax_delete_bytes,
sh_swap_insns, sh_relocate_section): ..
* coff-tic54x.c (tic54x_reloc_processing): ..
* coff-tic80.c (coff_tic80_relocate_section): ..
* coff64-rs6000.c (xcoff64_create_csect_from_smclas): ..
* coffcode.h (styp_to_sec_flags, coff_slurp_line_table,
coff_slurp_symbol_table, coff_classify_symbol,
coff_slurp_reloc_table): ..
* coffgen.c (_bfd_coff_read_string_table): ..
* cofflink.c (coff_link_add_symbols, _bfd_coff_link_input_bfd,
_bfd_coff_generic_relocate_section): ..
* cpu-arm.c (bfd_arm_merge_machines): ..
* cpu-sh.c (sh_merge_bfd_arch): ..
* elf-hppa.h (elf_hppa_relocate_section): ..
* elf.c (bfd_elf_string_from_elf_section, setup_group,
_bfd_elf_setup_group_pointers, bfd_section_from_shdr,
assign_section_numbers, _bfd_elf_symbol_from_bfd_symbol,
copy_private_bfd_data, _bfd_elf_validate_reloc): ..
* elf32-arm.h (find_thumb_glue, find_arm_glue,
bfd_elf32_arm_process_before_allocation, elf32_thumb_to_arm_stub,
elf32_arm_to_thumb_stub, elf32_arm_final_link_relocate,
elf32_arm_relocate_section, elf32_arm_set_private_flags,
elf32_arm_copy_private_bfd_data, elf32_arm_merge_private_bfd_data): ..
* elf32-cris.c (cris_elf_relocate_section, cris_elf_check_relocs,
cris_elf_merge_private_bfd_data
* elf32-frv.c (elf32_frv_relocate_section, elf32_frv_check_relocs): ..
* elf32-gen.c (elf32_generic_link_add_symbols): ..
* elf32-hppa.c (hppa_add_stub, hppa_build_one_stub,
elf32_hppa_check_relocs, get_local_syms, final_link_relocate,
elf32_hppa_relocate_section): ..
* elf32-i370.c (i370_elf_merge_private_bfd_data,
i370_elf_check_relocs, i370_elf_relocate_section): ..
* elf32-i386.c (elf_i386_info_to_howto_rel, elf_i386_check_relocs,
elf_i386_relocate_section): ..
* elf32-m32r.c (m32r_elf_relocate_section,
m32r_elf_merge_private_bfd_data): ..
* elf32-m68hc1x.c (m68hc12_add_stub,
_bfd_m68hc11_elf_merge_private_bfd_data): ..
* elf32-m68k.c (elf_m68k_relocate_section): ..
* elf32-mcore.c (mcore_elf_unsupported_reloc,
mcore_elf_relocate_section): ..
* elf32-ppc.c (ppc_elf_merge_private_bfd_data, bad_shared_reloc,
ppc_elf_check_relocs, ppc_elf_relocate_section,
ppc_elf_begin_write_processing): ..
* elf32-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf32-sh-symbian.c (sh_symbian_import_as,
sh_symbian_process_embedded_commands,
sh_symbian_relocate_section): ..
* elf32-sh.c (sh_elf_relax_section, sh_elf_relax_delete_bytes,
sh_elf_swap_insns, sh_elf_relocate_section, sh_elf_check_relocs,
sh_elf_merge_private_data): ..
* elf32-sparc.c (elf32_sparc_check_relocs,
elf32_sparc_relocate_section,
elf32_sparc_merge_private_bfd_data): ..
* elf32-v850.c (v850_elf_check_relocs,
v850_elf_merge_private_bfd_data): ..
* elf32-xtensa.c (elf_xtensa_check_relocs,
elf_xtensa_relocate_section, elf_xtensa_merge_private_bfd_data): ..
* elf64-alpha.c (elf64_alpha_relax_with_lituse,
elf64_alpha_relax_got_load, elf64_alpha_size_got_sections,
elf64_alpha_relocate_section_r, elf64_alpha_relocate_section): ..
* elf64-gen.c (elf64_generic_link_add_symbols): ..
* elf64-ppc.c (ppc64_elf_merge_private_bfd_data, ppc_add_stub,
ppc64_elf_check_relocs, ppc64_elf_edit_opd,
ppc64_elf_relocate_section): ..
* elf64-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf64-sh64.c (sh_elf64_relocate_section): ..
* elf64-sparc.c (sparc64_elf_check_relocs,
sparc64_elf_add_symbol_hook, sparc64_elf_relocate_section,
sparc64_elf_merge_private_bfd_data): ..
* elf64-x86-64.c (elf64_x86_64_check_relocs,
elf64_x86_64_relocate_section): ..
* elflink.c (_bfd_elf_add_default_symbol,
_bfd_elf_link_assign_sym_version, elf_link_read_relocs_from_section,
_bfd_elf_link_output_relocs, elf_link_add_object_symbols,
bfd_elf_size_dynamic_sections, elf_link_output_extsym,
elf_get_linked_section_vma, elf_fixup_link_order,
bfd_elf_final_link, bfd_elf_gc_record_vtinherit,
bfd_elf_gc_record_vtinherit, _bfd_elf_section_already_linked): ..
* elfxx-ia64.c (elfNN_ia64_relax_section,
elfNN_ia64_relocate_section, elfNN_ia64_merge_private_bfd_data): ..
* elfxx-mips.c (mips_elf_perform_relocation,
_bfd_mips_elf_check_relocs,
_bfd_mips_elf_merge_private_bfd_data): ..
* ieee.c (ieee_slurp_external_symbols): ..
* ihex.c (ihex_bad_byte, ihex_scan, ihex_read_section): ..
* libbfd.c (_bfd_generic_verify_endian_match): ..
* linker.c (_bfd_generic_link_add_one_symbol,
_bfd_generic_section_already_linked): ..
* pdp11.c (translate_to_native_sym_flags): ..
* pe-mips.c (coff_pe_mips_relocate_section): ..
* peicode.h (pe_ILF_build_a_bfd): ..
* srec.c (srec_bad_byte): ..
* stabs.c (_bfd_link_section_stabs): ..
* xcofflink.c (xcoff_link_add_symbols, xcoff_link_input_bfd): ..
Replace all uses of bfd_archive_filename and bfd_get_section_ident
with corresponding %B and %A in _bfd_error_handler format string.
Replace occurrences of "fprintf (stderr," with _bfd_error_handler
calls to use %A and %B. Fix "against symbol .. from section" and
similar error messages. Combine multiple _bfd_error_handler calls
where they were separated due to bfd_archive_filename deficiencies.
* bfd-in2.h: Regenerate.
include/
* bfdlink.h (struct bfd_link_callbacks): Remove "error_handler".
(LD_DEFINITION_IN_DISCARDED_SECTION): Delete.
ld/
* ldmain.c (link_callbacks): Remove "error_handler".
* ldmisc.c: Include elf-bfd.h.
(vfinfo): Sort comment. Handle %A. Use %A instead of
bfd_get_section_indent.
(error_handler): Delete.
* ldmisc.h (error_handler): Delete declaration.
2004-08-13 05:16:01 +02:00
|
|
|
|
(*_bfd_error_handler)
|
|
|
|
|
(_("%B: warning: ignoring duplicate section `%A'\n"),
|
|
|
|
|
abfd, sec);
|
2004-07-21 17:42:58 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SEC_LINK_DUPLICATES_SAME_CONTENTS:
|
|
|
|
|
/* FIXME: We should really dig out the contents of both
|
|
|
|
|
sections and memcmp them. The COFF/PE spec says that
|
|
|
|
|
the Microsoft linker does not implement this
|
|
|
|
|
correctly, so I'm not going to bother doing it
|
|
|
|
|
either. */
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
case SEC_LINK_DUPLICATES_SAME_SIZE:
|
|
|
|
|
if (sec->size != l->sec->size)
|
|
|
|
|
(*_bfd_error_handler)
|
bfd/
* bfd.c (_bfd_default_error_handler): Handle %A and %B.
(bfd_archive_filename, bfd_get_section_ident): Delete.
* ecofflink.c (bfd_ecoff_debug_accumulate_other): Don't call
bfd_archive_filename.
* elflink.c (elf_link_input_bfd): Don't use callbacks->error_handler
to warn about symbols in discarded sections. Use _bfd_error_handler.
* aout-adobe.c (aout_adobe_callback): See below.
* aout-cris.c (swap_ext_reloc_in): ..
* coff-arm.c (find_thumb_glue, find_arm_glue,
coff_arm_relocate_section, bfd_arm_process_before_allocation,
coff_arm_merge_private_bfd_data, _bfd_coff_arm_set_private_flags,
coff_arm_copy_private_bfd_data): ..
* coff-i860.c (i860_reloc_processing): ..
* coff-mcore.c (mcore_coff_unsupported_reloc,
coff_mcore_relocate_section): ..
* coff-ppc.c (coff_ppc_relocate_section): ..
* coff-rs6000.c (xcoff_create_csect_from_smclas
* coff-sh.c (sh_relax_section, sh_relax_delete_bytes,
sh_swap_insns, sh_relocate_section): ..
* coff-tic54x.c (tic54x_reloc_processing): ..
* coff-tic80.c (coff_tic80_relocate_section): ..
* coff64-rs6000.c (xcoff64_create_csect_from_smclas): ..
* coffcode.h (styp_to_sec_flags, coff_slurp_line_table,
coff_slurp_symbol_table, coff_classify_symbol,
coff_slurp_reloc_table): ..
* coffgen.c (_bfd_coff_read_string_table): ..
* cofflink.c (coff_link_add_symbols, _bfd_coff_link_input_bfd,
_bfd_coff_generic_relocate_section): ..
* cpu-arm.c (bfd_arm_merge_machines): ..
* cpu-sh.c (sh_merge_bfd_arch): ..
* elf-hppa.h (elf_hppa_relocate_section): ..
* elf.c (bfd_elf_string_from_elf_section, setup_group,
_bfd_elf_setup_group_pointers, bfd_section_from_shdr,
assign_section_numbers, _bfd_elf_symbol_from_bfd_symbol,
copy_private_bfd_data, _bfd_elf_validate_reloc): ..
* elf32-arm.h (find_thumb_glue, find_arm_glue,
bfd_elf32_arm_process_before_allocation, elf32_thumb_to_arm_stub,
elf32_arm_to_thumb_stub, elf32_arm_final_link_relocate,
elf32_arm_relocate_section, elf32_arm_set_private_flags,
elf32_arm_copy_private_bfd_data, elf32_arm_merge_private_bfd_data): ..
* elf32-cris.c (cris_elf_relocate_section, cris_elf_check_relocs,
cris_elf_merge_private_bfd_data
* elf32-frv.c (elf32_frv_relocate_section, elf32_frv_check_relocs): ..
* elf32-gen.c (elf32_generic_link_add_symbols): ..
* elf32-hppa.c (hppa_add_stub, hppa_build_one_stub,
elf32_hppa_check_relocs, get_local_syms, final_link_relocate,
elf32_hppa_relocate_section): ..
* elf32-i370.c (i370_elf_merge_private_bfd_data,
i370_elf_check_relocs, i370_elf_relocate_section): ..
* elf32-i386.c (elf_i386_info_to_howto_rel, elf_i386_check_relocs,
elf_i386_relocate_section): ..
* elf32-m32r.c (m32r_elf_relocate_section,
m32r_elf_merge_private_bfd_data): ..
* elf32-m68hc1x.c (m68hc12_add_stub,
_bfd_m68hc11_elf_merge_private_bfd_data): ..
* elf32-m68k.c (elf_m68k_relocate_section): ..
* elf32-mcore.c (mcore_elf_unsupported_reloc,
mcore_elf_relocate_section): ..
* elf32-ppc.c (ppc_elf_merge_private_bfd_data, bad_shared_reloc,
ppc_elf_check_relocs, ppc_elf_relocate_section,
ppc_elf_begin_write_processing): ..
* elf32-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf32-sh-symbian.c (sh_symbian_import_as,
sh_symbian_process_embedded_commands,
sh_symbian_relocate_section): ..
* elf32-sh.c (sh_elf_relax_section, sh_elf_relax_delete_bytes,
sh_elf_swap_insns, sh_elf_relocate_section, sh_elf_check_relocs,
sh_elf_merge_private_data): ..
* elf32-sparc.c (elf32_sparc_check_relocs,
elf32_sparc_relocate_section,
elf32_sparc_merge_private_bfd_data): ..
* elf32-v850.c (v850_elf_check_relocs,
v850_elf_merge_private_bfd_data): ..
* elf32-xtensa.c (elf_xtensa_check_relocs,
elf_xtensa_relocate_section, elf_xtensa_merge_private_bfd_data): ..
* elf64-alpha.c (elf64_alpha_relax_with_lituse,
elf64_alpha_relax_got_load, elf64_alpha_size_got_sections,
elf64_alpha_relocate_section_r, elf64_alpha_relocate_section): ..
* elf64-gen.c (elf64_generic_link_add_symbols): ..
* elf64-ppc.c (ppc64_elf_merge_private_bfd_data, ppc_add_stub,
ppc64_elf_check_relocs, ppc64_elf_edit_opd,
ppc64_elf_relocate_section): ..
* elf64-s390.c (elf_s390_check_relocs, invalid_tls_insn,
elf_s390_relocate_section): ..
* elf64-sh64.c (sh_elf64_relocate_section): ..
* elf64-sparc.c (sparc64_elf_check_relocs,
sparc64_elf_add_symbol_hook, sparc64_elf_relocate_section,
sparc64_elf_merge_private_bfd_data): ..
* elf64-x86-64.c (elf64_x86_64_check_relocs,
elf64_x86_64_relocate_section): ..
* elflink.c (_bfd_elf_add_default_symbol,
_bfd_elf_link_assign_sym_version, elf_link_read_relocs_from_section,
_bfd_elf_link_output_relocs, elf_link_add_object_symbols,
bfd_elf_size_dynamic_sections, elf_link_output_extsym,
elf_get_linked_section_vma, elf_fixup_link_order,
bfd_elf_final_link, bfd_elf_gc_record_vtinherit,
bfd_elf_gc_record_vtinherit, _bfd_elf_section_already_linked): ..
* elfxx-ia64.c (elfNN_ia64_relax_section,
elfNN_ia64_relocate_section, elfNN_ia64_merge_private_bfd_data): ..
* elfxx-mips.c (mips_elf_perform_relocation,
_bfd_mips_elf_check_relocs,
_bfd_mips_elf_merge_private_bfd_data): ..
* ieee.c (ieee_slurp_external_symbols): ..
* ihex.c (ihex_bad_byte, ihex_scan, ihex_read_section): ..
* libbfd.c (_bfd_generic_verify_endian_match): ..
* linker.c (_bfd_generic_link_add_one_symbol,
_bfd_generic_section_already_linked): ..
* pdp11.c (translate_to_native_sym_flags): ..
* pe-mips.c (coff_pe_mips_relocate_section): ..
* peicode.h (pe_ILF_build_a_bfd): ..
* srec.c (srec_bad_byte): ..
* stabs.c (_bfd_link_section_stabs): ..
* xcofflink.c (xcoff_link_add_symbols, xcoff_link_input_bfd): ..
Replace all uses of bfd_archive_filename and bfd_get_section_ident
with corresponding %B and %A in _bfd_error_handler format string.
Replace occurrences of "fprintf (stderr," with _bfd_error_handler
calls to use %A and %B. Fix "against symbol .. from section" and
similar error messages. Combine multiple _bfd_error_handler calls
where they were separated due to bfd_archive_filename deficiencies.
* bfd-in2.h: Regenerate.
include/
* bfdlink.h (struct bfd_link_callbacks): Remove "error_handler".
(LD_DEFINITION_IN_DISCARDED_SECTION): Delete.
ld/
* ldmain.c (link_callbacks): Remove "error_handler".
* ldmisc.c: Include elf-bfd.h.
(vfinfo): Sort comment. Handle %A. Use %A instead of
bfd_get_section_indent.
(error_handler): Delete.
* ldmisc.h (error_handler): Delete declaration.
2004-08-13 05:16:01 +02:00
|
|
|
|
(_("%B: warning: duplicate section `%A' has different size\n"),
|
|
|
|
|
abfd, sec);
|
2004-07-21 17:42:58 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the output_section field so that lang_add_section
|
|
|
|
|
does not create a lang_input_section structure for this
|
|
|
|
|
section. Since there might be a symbol in the section
|
|
|
|
|
being discarded, we must retain a pointer to the section
|
|
|
|
|
which we are really going to use. */
|
|
|
|
|
sec->output_section = bfd_abs_section_ptr;
|
|
|
|
|
sec->kept_section = l->sec;
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This is the first section with this name. Record it. */
|
2007-07-27 03:04:29 +02:00
|
|
|
|
if (! bfd_section_already_linked_table_insert (already_linked_list, sec))
|
2009-04-07 22:04:08 +02:00
|
|
|
|
info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
|
2004-07-21 17:42:58 +02:00
|
|
|
|
}
|
2005-08-04 03:19:10 +02:00
|
|
|
|
|
2006-10-17 15:41:49 +02:00
|
|
|
|
/* Convert symbols in excluded output sections to use a kept section. */
|
2005-08-04 03:19:10 +02:00
|
|
|
|
|
|
|
|
|
static bfd_boolean
|
|
|
|
|
fix_syms (struct bfd_link_hash_entry *h, void *data)
|
|
|
|
|
{
|
|
|
|
|
bfd *obfd = (bfd *) data;
|
|
|
|
|
|
|
|
|
|
if (h->type == bfd_link_hash_warning)
|
|
|
|
|
h = h->u.i.link;
|
|
|
|
|
|
|
|
|
|
if (h->type == bfd_link_hash_defined
|
|
|
|
|
|| h->type == bfd_link_hash_defweak)
|
|
|
|
|
{
|
|
|
|
|
asection *s = h->u.def.section;
|
|
|
|
|
if (s != NULL
|
|
|
|
|
&& s->output_section != NULL
|
|
|
|
|
&& (s->output_section->flags & SEC_EXCLUDE) != 0
|
|
|
|
|
&& bfd_section_removed_from_list (obfd, s->output_section))
|
|
|
|
|
{
|
2006-10-23 04:35:38 +02:00
|
|
|
|
asection *op, *op1;
|
|
|
|
|
|
|
|
|
|
h->u.def.value += s->output_offset + s->output_section->vma;
|
|
|
|
|
|
|
|
|
|
/* Find preceding kept section. */
|
|
|
|
|
for (op1 = s->output_section->prev; op1 != NULL; op1 = op1->prev)
|
|
|
|
|
if ((op1->flags & SEC_EXCLUDE) == 0
|
|
|
|
|
&& !bfd_section_removed_from_list (obfd, op1))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Find following kept section. Start at prev->next because
|
|
|
|
|
other sections may have been added after S was removed. */
|
|
|
|
|
if (s->output_section->prev != NULL)
|
|
|
|
|
op = s->output_section->prev->next;
|
|
|
|
|
else
|
|
|
|
|
op = s->output_section->owner->sections;
|
|
|
|
|
for (; op != NULL; op = op->next)
|
2006-10-17 15:41:49 +02:00
|
|
|
|
if ((op->flags & SEC_EXCLUDE) == 0
|
|
|
|
|
&& !bfd_section_removed_from_list (obfd, op))
|
|
|
|
|
break;
|
2006-10-23 04:35:38 +02:00
|
|
|
|
|
|
|
|
|
/* Choose better of two sections, based on flags. The idea
|
|
|
|
|
is to choose a section that will be in the same segment
|
|
|
|
|
as S would have been if it was kept. */
|
|
|
|
|
if (op1 == NULL)
|
2006-10-17 15:41:49 +02:00
|
|
|
|
{
|
|
|
|
|
if (op == NULL)
|
|
|
|
|
op = bfd_abs_section_ptr;
|
|
|
|
|
}
|
2006-10-23 04:35:38 +02:00
|
|
|
|
else if (op == NULL)
|
|
|
|
|
op = op1;
|
|
|
|
|
else if (((op1->flags ^ op->flags)
|
|
|
|
|
& (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (((op->flags ^ s->flags)
|
|
|
|
|
& (SEC_ALLOC | SEC_THREAD_LOCAL)) != 0)
|
|
|
|
|
op = op1;
|
|
|
|
|
}
|
|
|
|
|
else if (((op1->flags ^ op->flags) & SEC_READONLY) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (((op->flags ^ s->flags) & SEC_READONLY) != 0)
|
|
|
|
|
op = op1;
|
|
|
|
|
}
|
|
|
|
|
else if (((op1->flags ^ op->flags) & SEC_CODE) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (((op->flags ^ s->flags) & SEC_CODE) != 0)
|
|
|
|
|
op = op1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Flags we care about are the same. Prefer the following
|
|
|
|
|
section if that will result in a positive valued sym. */
|
|
|
|
|
if (h->u.def.value < op->vma)
|
|
|
|
|
op = op1;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-17 15:41:49 +02:00
|
|
|
|
h->u.def.value -= op->vma;
|
|
|
|
|
h->u.def.section = op;
|
2005-08-04 03:19:10 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_bfd_fix_excluded_sec_syms (bfd *obfd, struct bfd_link_info *info)
|
|
|
|
|
{
|
|
|
|
|
bfd_link_hash_traverse (info->hash, fix_syms, obfd);
|
|
|
|
|
}
|
2009-04-17 01:07:00 +02:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
FUNCTION
|
|
|
|
|
bfd_generic_define_common_symbol
|
|
|
|
|
|
|
|
|
|
SYNOPSIS
|
|
|
|
|
bfd_boolean bfd_generic_define_common_symbol
|
|
|
|
|
(bfd *output_bfd, struct bfd_link_info *info,
|
|
|
|
|
struct bfd_link_hash_entry *h);
|
|
|
|
|
|
|
|
|
|
DESCRIPTION
|
|
|
|
|
Convert common symbol @var{h} into a defined symbol.
|
|
|
|
|
Return TRUE on success and FALSE on failure.
|
|
|
|
|
|
|
|
|
|
.#define bfd_define_common_symbol(output_bfd, info, h) \
|
|
|
|
|
. BFD_SEND (output_bfd, _bfd_define_common_symbol, (output_bfd, info, h))
|
|
|
|
|
.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bfd_boolean
|
|
|
|
|
bfd_generic_define_common_symbol (bfd *output_bfd,
|
|
|
|
|
struct bfd_link_info *info ATTRIBUTE_UNUSED,
|
|
|
|
|
struct bfd_link_hash_entry *h)
|
|
|
|
|
{
|
|
|
|
|
unsigned int power_of_two;
|
|
|
|
|
bfd_vma alignment, size;
|
|
|
|
|
asection *section;
|
|
|
|
|
|
|
|
|
|
BFD_ASSERT (h != NULL && h->type == bfd_link_hash_common);
|
|
|
|
|
|
|
|
|
|
size = h->u.c.size;
|
|
|
|
|
power_of_two = h->u.c.p->alignment_power;
|
|
|
|
|
section = h->u.c.p->section;
|
|
|
|
|
|
|
|
|
|
/* Increase the size of the section to align the common symbol.
|
|
|
|
|
The alignment must be a power of two. */
|
|
|
|
|
alignment = bfd_octets_per_byte (output_bfd) << power_of_two;
|
|
|
|
|
BFD_ASSERT (alignment != 0 && (alignment & -alignment) == alignment);
|
|
|
|
|
section->size += alignment - 1;
|
|
|
|
|
section->size &= -alignment;
|
|
|
|
|
|
|
|
|
|
/* Adjust the section's overall alignment if necessary. */
|
|
|
|
|
if (power_of_two > section->alignment_power)
|
|
|
|
|
section->alignment_power = power_of_two;
|
|
|
|
|
|
|
|
|
|
/* Change the symbol from common to defined. */
|
|
|
|
|
h->type = bfd_link_hash_defined;
|
|
|
|
|
h->u.def.section = section;
|
|
|
|
|
h->u.def.value = section->size;
|
|
|
|
|
|
|
|
|
|
/* Increase the size of the section. */
|
|
|
|
|
section->size += size;
|
|
|
|
|
|
|
|
|
|
/* Make sure the section is allocated in memory, and make sure that
|
|
|
|
|
it is no longer a common section. */
|
|
|
|
|
section->flags |= SEC_ALLOC;
|
|
|
|
|
section->flags &= ~SEC_IS_COMMON;
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|