2163 lines
80 KiB
Plaintext
2163 lines
80 KiB
Plaintext
\input texinfo
|
|
@setfilename ld.info
|
|
@c $Id$
|
|
@syncodeindex ky cp
|
|
@c @smallbook
|
|
@c @cropmarks
|
|
@ifinfo
|
|
This file documents the GNU linker GLD.
|
|
|
|
Copyright (C) 1991 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
@ignore
|
|
Permission is granted to process this file through Tex and print the
|
|
results, provided the printed document carries copying permission
|
|
notice identical to this one except for the removal of this paragraph
|
|
(this paragraph not being relevant to the printed manual).
|
|
|
|
@end ignore
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided also that the
|
|
section entitled ``GNU General Public License'' is included exactly as
|
|
in the original, and provided that the entire resulting derived work is
|
|
distributed under the terms of a permission notice identical to this
|
|
one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions,
|
|
except that the section entitled ``GNU General Public License'' may be
|
|
included in a translation approved by the author instead of in the
|
|
original English.
|
|
@end ifinfo
|
|
@iftex
|
|
@finalout
|
|
@setchapternewpage odd
|
|
@settitle GLD, the GNU linker
|
|
@titlepage
|
|
@title gld
|
|
@subtitle The GNU linker
|
|
@sp 1
|
|
@subtitle Second Edition---@code{gld} version 2.0
|
|
@subtitle April 1991
|
|
@author Steve Chamberlain and Roland Pesch
|
|
@author Cygnus Support
|
|
@page
|
|
|
|
@tex
|
|
\def\$#1${{#1}} % Kluge: collect RCS revision info without $...$
|
|
\xdef\manvers{\$Revision$} % For use in headers, footers too
|
|
{\parskip=0pt
|
|
\hfill Cygnus Support\par
|
|
\hfill steve\@cygnus.com, pesch\@cygnus.com\par
|
|
\hfill {\it GLD, the GNU linker}, \manvers\par
|
|
\hfill \TeX{}info \texinfoversion\par
|
|
}
|
|
\global\parindent=0pt % Steve likes it this way.
|
|
@end tex
|
|
|
|
@vskip 0pt plus 1filll
|
|
Copyright @copyright{} 1991 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to make and distribute verbatim copies of
|
|
this manual provided the copyright notice and this permission notice
|
|
are preserved on all copies.
|
|
|
|
Permission is granted to copy and distribute modified versions of this
|
|
manual under the conditions for verbatim copying, provided also that
|
|
the entire resulting derived work is distributed under the terms of a
|
|
permission notice identical to this one.
|
|
|
|
Permission is granted to copy and distribute translations of this manual
|
|
into another language, under the above conditions for modified versions.
|
|
@end titlepage
|
|
@end iftex
|
|
@c FIXME: Talk about importance of *order* of args, cmds to linker!
|
|
|
|
@node Top, Overview, (dir), (dir)
|
|
@ifinfo
|
|
This file documents the GNU linker gld.
|
|
@end ifinfo
|
|
|
|
@menu
|
|
* Overview:: Overview
|
|
* Invocation:: Invocation
|
|
* Commands:: Command Language
|
|
* BFD:: BFD
|
|
* Index:: Index
|
|
|
|
--- The Detailed Node Listing ---
|
|
|
|
Invocation
|
|
|
|
* Options:: Command Line Options
|
|
* Environment:: Environment Variables
|
|
|
|
Command Language
|
|
|
|
* Scripts:: Linker Scripts
|
|
* Expressions:: Expressions
|
|
* MEMORY:: MEMORY Command
|
|
* SECTIONS:: SECTIONS Command
|
|
* Entry Point:: The Entry Point
|
|
* Other Commands:: Other Commands
|
|
|
|
Expressions
|
|
|
|
* Integers:: Integers
|
|
* Symbols:: Symbol Names
|
|
* Location Counter:: The Location Counter
|
|
* Operators:: Operators
|
|
* Evaluation:: Evaluation
|
|
* Assignment:: Assignment: Defining Symbols
|
|
* Built-ins:: Built-In Functions
|
|
|
|
SECTIONS Command
|
|
|
|
* Section Definition:: Section Definitions
|
|
* Section Contents:: Section Contents
|
|
* Section Options:: Optional Section Attributes
|
|
|
|
BFD
|
|
|
|
* BFD outline:: How it works: an outline of BFD
|
|
* BFD information loss:: Information Loss
|
|
* Mechanism:: Mechanism
|
|
@end menu
|
|
|
|
@node Overview, Invocation, Top, Top
|
|
@chapter Overview
|
|
|
|
@cindex GNU linker
|
|
@cindex what is this?
|
|
@code{gld} combines a number of object and archive files, relocates
|
|
their data and ties up symbol references. Often the last step in
|
|
building a new compiled program to run is a call to @code{gld}.
|
|
|
|
@code{gld} accepts Linker Command Language files written in
|
|
a superset of AT&T's Link Editor Command Language syntax,
|
|
to provide explicit and total control over the linking process.
|
|
|
|
This version of @code{gld} uses the general purpose BFD libraries
|
|
to operate on object files. This allows @code{gld} to read, combine, and
|
|
write object files in many different formats---for example, COFF or
|
|
@code{a.out}. Different formats may be linked together to produce any
|
|
available kind of object file. @xref{BFD} for a list of formats
|
|
supported on various architectures.
|
|
|
|
Aside from its flexibility, the GNU linker is more helpful than other
|
|
linkers in providing diagnostic information. Many linkers abandon
|
|
execution immediately upon encountering an error; whenever possible,
|
|
@code{gld} continues executing, allowing you to identify other errors
|
|
(or, in some cases, to get an output file in spite of the error).
|
|
|
|
@node Invocation, Commands, Overview, Top
|
|
@chapter Invocation
|
|
|
|
The GNU linker @code{gld} is meant to cover a broad range of situations,
|
|
and to be as compatible as possible with other linkers. As a result,
|
|
you have many choices to control its behavior through the command line,
|
|
and through environment variables.
|
|
|
|
@menu
|
|
* Options:: Command Line Options
|
|
* Environment:: Environment Variables
|
|
@end menu
|
|
|
|
@node Options, Environment, Invocation, Invocation
|
|
@section Command Line Options
|
|
|
|
@cindex command line
|
|
@cindex options
|
|
Here is a sketch of the options you can use on the @code{gld} command
|
|
line:
|
|
|
|
@smallexample
|
|
gld [-o @var{output} ] @var{objfiles}@dots{}
|
|
[ -A@var{architecture} ] [ -b @var{input-format} ] [ -Bstatic ]
|
|
[ -c @var{commandfile} ] [ -d | -dc | -dp ]
|
|
[ -defsym @var{symbol} = @var{expression} ]
|
|
[ -e @var{entry} ] [ -F ] [ -F @var{format} ]
|
|
@c -f was in old GNU linker, not currently in new
|
|
@c [ -f @var{fill} ]
|
|
[ -format @var{input-format} ] [ -g ] [ -i ]
|
|
[ -l@var{ar} ] [ -L@var{searchdir} ] [ -M | -m ]
|
|
[ -n ] [ -noinhibit-exec ] [ -R @var{filename} ]
|
|
@c -N and -z were alternatives to -n in old GNU linker, not curr in new
|
|
@c [ -N | -n | -z ] [ -noinhibit-exec ] [ -R @var{filename} ]
|
|
[ -r | -Ur ] [ -S ] [ -s ] [ -T @var{commandfile} ]
|
|
[ -Ttext @var{textorg} ] [ -Tdata @var{dataorg} ] [ -Tbss @var{bssorg} ]
|
|
[ -t ] [ -u @var{sym}] [-v] [ -X ] [ -x ]
|
|
[ @{ @var{script} @} ]
|
|
@end smallexample
|
|
|
|
This plethora of command-line options may seem intimidating, but in
|
|
actual practice few of them are used in any particular context.
|
|
@cindex standard Unix system
|
|
For instance, a frequent use of @code{gld} is to link standard Unix
|
|
object files on a standard, supported Unix system. On such a system, to
|
|
link a file @code{hello.o}:
|
|
@example
|
|
$ gld -o output /lib/crt0.o hello.o -lc
|
|
@end example
|
|
This tells @code{gld} to produce a file called @code{output} as the
|
|
result of linking the file @code{/lib/crt0.o} with @code{hello.o} and
|
|
the library @code{libc.a} which will come from the standard search
|
|
directories.
|
|
|
|
The command-line options to @code{gld} may be specified in any order, and
|
|
may be repeated at will. For the most part, repeating an option with a
|
|
different argument will either have no further effect, or override prior
|
|
occurrences (those further to the left on the command line) of an
|
|
option.
|
|
|
|
The exceptions---which may meaningfully be used more than once---are
|
|
@code{-A}, @code{-b} (or its synonym @code{-format}), @code{-defsym},
|
|
@code{-L}, @code{-l}, @code{-R}, and @code{-u}.
|
|
|
|
@cindex object files
|
|
The list of object files to be linked together, shown as @var{objfiles},
|
|
may follow, precede, or be mixed in with command-line options; save that
|
|
an @var{objfiles} argument may not be placed between an option flag and
|
|
its argument.
|
|
|
|
Usually the linker is invoked with at least one object file, but other
|
|
forms of binary input files can also be specified with @code{-l},
|
|
@code{-R}, and the script command language. If @emph{no} binary input
|
|
files at all are specified, the linker does not produce any output, and
|
|
issues the message @samp{No input files}.
|
|
|
|
Option arguments must either follow the option letter without intervening
|
|
whitespace, or be given as separate arguments immediately following the
|
|
option that requires them.
|
|
|
|
@table @code
|
|
@item @var{objfiles}@dots{}
|
|
The object files @var{objfiles} to be linked.
|
|
|
|
@cindex architectures
|
|
@kindex -A@var{arch}
|
|
@item -A@var{architecture}
|
|
In the current release of @code{gld}, this option is useful only for the
|
|
Intel 960 family of architectures. In that @code{gld} configuration, the
|
|
@var{architecture} argument is one of the two-letter names identifying
|
|
members of the 960 family; the option specifies the desired output
|
|
target, and warns of any incompatible instructions in the input files.
|
|
It also modifies the linker's search strategy for archive libraries, to
|
|
support the use of libraries specific to each particular
|
|
architecture, by including in the search loop names suffixed with the
|
|
string identifying the architecture.
|
|
|
|
For example, if your @code{gld} command line included @w{@samp{-ACA}} as
|
|
well as @w{@samp{-ltry}}, the linker would look (in its built-in search
|
|
paths, and in any paths you specify with @code{-L}) for a library with
|
|
the names
|
|
@example
|
|
try
|
|
libtry.a
|
|
tryca
|
|
libtryca.a
|
|
@end example
|
|
@noindent
|
|
The first two possibilities would be considered in any event; the last
|
|
two are due to the use of @w{@samp{-ACA}}.
|
|
|
|
Future releases of @code{gld} may support similar functionality for
|
|
other architecture families.
|
|
|
|
You can meaningfully use @code{-A} more than once on a command line, if
|
|
an architecture family allows combination of target architectures; each
|
|
use will add another pair of name variants to search for when @w{@code{-l}}
|
|
specifies a library.
|
|
|
|
@cindex binary input format
|
|
@kindex -b @var{format}
|
|
@cindex input format
|
|
@item -b @var{input-format}
|
|
@cindex input format
|
|
Specify the binary format for input object files that follow this option
|
|
on the command line. You don't usually need to specify this, as
|
|
@code{gld} is configured to expect as a default input format the most
|
|
usual format on each machine. @var{input-format} is a text string, the
|
|
name of a particular format supported by the BFD libraries. @xref{BFD}.
|
|
@code{-format @var{input-format}} has the same effect.@refill
|
|
|
|
You may want to use this option if you are linking files with an unusual
|
|
binary format. You can also use @code{-b} to switch formats explicitly (when
|
|
linking object files of different formats), by including
|
|
@code{-b @var{input-format}} before each group of object files in a
|
|
particular format.
|
|
|
|
The default format is taken from the environment variable
|
|
@code{GNUTARGET}. @xref{Environment}. You can also define the input
|
|
format from a script, using the command @code{TARGET}.
|
|
|
|
@kindex -Bstatic
|
|
@item -Bstatic
|
|
This flag is accepted for command-line compatibility with the SunOS linker,
|
|
but has no effect on @code{gld}.
|
|
|
|
@kindex -c @var{cmdfile}
|
|
@cindex script files
|
|
@item -c @var{commandfile}
|
|
Directs @code{gld} to read link commands from the file
|
|
@var{commandfile}. These commands will completely override @code{gld}'s
|
|
default link format (rather than adding to it); @var{commandfile} must
|
|
specify everything necessary to describe the target format.
|
|
@xref{Commands}.
|
|
|
|
You may also include a script of link commands directly in the command
|
|
line by bracketing it between @samp{@{} and @samp{@}} characters.
|
|
|
|
@cindex common allocation
|
|
@kindex -d
|
|
@item -d
|
|
@kindex -dc
|
|
@itemx -dc
|
|
@kindex -dp
|
|
@itemx -dp
|
|
These three options are equivalent; multiple forms are supported for
|
|
compatibility with other linkers. Use any of them to make @code{ld}
|
|
assign space to common symbols even if a relocatable output file is
|
|
specified (@code{-r}). The script command
|
|
@code{FORCE_COMMON_ALLOCATION} has the same effect.
|
|
|
|
@cindex symbols, from command line
|
|
@kindex -defsym @var{symbol}=@var{exp}
|
|
@item -defsym @var{symbol} = @var{expression}
|
|
Create a global symbol in the output file, containing the absolute
|
|
address given by @var{expression}. You may use this option as many
|
|
times as necessary to define multiple symbols in the command line. A
|
|
limited form of arithmetic is supported for the @var{expression} in this
|
|
context: you may give a hexadecimal constant or the name of an existing
|
|
symbol, or use @code{+} and @code{-} to add or subtract hexadecimal
|
|
constants or symbols. If you need more elaborate expressions, consider
|
|
using the linker command language from a script.
|
|
|
|
@cindex entry point, from command line
|
|
@kindex -e @var{entry}
|
|
@item -e @var{entry}
|
|
Use @var{entry} as the explicit symbol for beginning execution of your
|
|
program, rather than the default entry point. @xref{Entry Point}, for a
|
|
discussion of defaults and other ways of specifying the
|
|
entry point.
|
|
|
|
@ignore
|
|
@cindex fill, from command line
|
|
@kindex -f @var{fill}
|
|
@c -f in older GNU linker, not in new
|
|
@item -f @var{fill}
|
|
Sets the default fill pattern for ``holes'' in the output file to
|
|
the lowest two bytes of the expression specified. Holes are created
|
|
when you advance the location counter (@xref{Location Counter}), or when
|
|
there is a gap between explicitly specified section addresses
|
|
(@xref{Section Options}).
|
|
@end ignore
|
|
|
|
@kindex -F
|
|
@item -F
|
|
@itemx -F@var{format}
|
|
Some older linkers used this option throughout a compilation toolchain
|
|
for specifying object-file format for both input and output object
|
|
files. @code{gld}'s mechanisms (the @code{-b} or @code{-format} options
|
|
for input files, the @code{TARGET} command in linker scripts for output
|
|
files, the @code{GNUTARGET} environment variable) are more flexible, but
|
|
but it accepts (and ignores) the @code{-F} option flag for compatibility
|
|
with scripts written to call the old linker.
|
|
|
|
@kindex -format
|
|
@item -format @var{input-format}
|
|
Synonym for @code{-b} @var{input-format}.
|
|
|
|
@kindex -g
|
|
@item -g
|
|
Accepted, but ignored; provided for compatibility with other tools.
|
|
|
|
@kindex -i
|
|
@cindex incremental link
|
|
@item -i
|
|
Perform an incremental link (same as option @code{-r}).
|
|
|
|
@cindex archive files, from cmd line
|
|
@kindex -l@var{ar}
|
|
@item -l@var{ar}
|
|
Add an archive file @var{ar} to the list of files to link. This
|
|
option may be used any number of times. @code{ld} will search its
|
|
path-list for occurrences of @code{lib@var{ar}.a} for every @var{ar}
|
|
specified.
|
|
|
|
@cindex search directory, from cmd line
|
|
@kindex -L@var{dir}
|
|
@item -L@var{searchdir}
|
|
This command adds path @var{searchdir} to the list of paths that
|
|
@code{gld} will search for archive libraries. You may use this option
|
|
any number of times.
|
|
|
|
The default set of paths searched (without being specified with
|
|
@code{-L}) depends on what emulation mode @code{gld} is using, and in
|
|
some cases also on how it was configured. @xref{Environment}. The
|
|
paths can also be specified in a link script with the @code{SEARCH_DIR}
|
|
command.
|
|
|
|
@cindex link map
|
|
@kindex -M
|
|
@item -M
|
|
@kindex -m
|
|
@itemx -m
|
|
Print (to the standard output file) a link map---diagnostic information
|
|
about where symbols are mapped by @code{ld}, and information on global
|
|
common storage allocation.
|
|
|
|
@ignore
|
|
@c -N in older GNU linker, not in new
|
|
@kindex -N
|
|
@cindex read/write from cmd line
|
|
@kindex OMAGIC
|
|
@item -N
|
|
specifies readable and writable @code{text} and @code{data} sections. If
|
|
the output format supports Unix style magic numbers, the output is
|
|
marked as @code{OMAGIC}.
|
|
@end ignore
|
|
|
|
@item -n
|
|
@kindex -n
|
|
@cindex read-only text
|
|
@kindex NMAGIC
|
|
sets the text segment to be read only, and @code{NMAGIC} is written
|
|
if possible.
|
|
|
|
@item -noinhibit-exec
|
|
@cindex output file after errors
|
|
@kindex -noinhibit-exec
|
|
Normally, the linker will not produce an output file if it encounters
|
|
errors during the link process. With this flag, you can specify that
|
|
you wish the output file retained even after non-fatal errors.
|
|
|
|
@item -o @var{output}
|
|
@kindex -o @var{output}
|
|
@cindex naming the output file
|
|
@var{output} is a name for the program produced by @code{ld}; if this
|
|
option is not specified, the name @samp{a.out} is used by default. The
|
|
script command @code{OUTPUT} can also specify the output file name.
|
|
|
|
@item -R @var{filename}
|
|
@kindex -R @var{file}
|
|
@cindex symbol-only input
|
|
Read symbol names and their addresses from @var{filename}, but do not
|
|
relocate it or include it in the output. This allows your output file
|
|
to refer symbolically to absolute locations of memory defined in other
|
|
programs.
|
|
|
|
@item -r
|
|
@cindex partial link
|
|
@cindex relocatable output
|
|
@kindex -r
|
|
Generates relocatable output---i.e., generate an output file that can in
|
|
turn serve as input to @code{gld}. This is often called @dfn{partial
|
|
linking}. As a side effect, in environments that support standard Unix
|
|
magic numbers, this option also sets the output file's magic number to
|
|
@code{OMAGIC}.
|
|
@c ; see @code{-N}.
|
|
If this option is not specified, an absolute file is produced. When
|
|
linking C++ programs, this option @emph{will not} resolve references to
|
|
constructors; @code{-Ur} is an alternative. @refill
|
|
|
|
This option does the same as @code{-i}.
|
|
|
|
@item -S
|
|
@kindex -S
|
|
@cindex strip debugger symbols
|
|
Omits debugger symbol information (but not all symbols) from the output file.
|
|
|
|
@item -s
|
|
@kindex -s
|
|
@cindex strip all symbols
|
|
Omits all symbol information from the output file.
|
|
|
|
@item @{ @var{script} @}
|
|
@kindex @{ @var{script} @}
|
|
@cindex scripts on command line
|
|
You can, if you wish, include a script of linker commands directly in
|
|
the command line instead of referring to it via an input file. When the
|
|
character @samp{@{} occurs on the command line, the linker switches to
|
|
interpreting the command language until the end of the list of commands
|
|
is reached---flagged with a closing brace @samp{@}}. Other command-line
|
|
options will not be recognized while parsing the script.
|
|
@xref{Commands} for a description of the command language.
|
|
|
|
@item -Tbss @var{org}
|
|
@kindex -Tbss @var{org}
|
|
@itemx -Tdata @var{org}
|
|
@kindex -Tdata @var{org}
|
|
@itemx -Ttext @var{org}
|
|
@kindex -Ttext @var{org}
|
|
@cindex segment origins, cmd line
|
|
Use @var{org} as the starting address for---respectively---the
|
|
@code{bss}, @code{data}, or the @code{text} segment of the output file.
|
|
@var{textorg} must be a hexadecimal integer.
|
|
|
|
@item -T @var{commandfile}
|
|
@itemx -T@var{commandfile}
|
|
@kindex -T @var{script}
|
|
Equivalent to @code{-c @var{commandfile}}; supported for compatibility with
|
|
other tools.
|
|
|
|
@item -t
|
|
@kindex -t
|
|
@cindex verbose
|
|
@cindex input files, displaying
|
|
Prints names of input files as @code{ld} processes them.
|
|
|
|
@item -u @var{sym}
|
|
@kindex -u @var{sym}
|
|
@cindex undefined symbol
|
|
Forces @var{sym} to be entered in the output file as an undefined symbol.
|
|
This may, for example, trigger linking of additional modules from
|
|
standard libraries. @code{-u} may be repeated with different option
|
|
arguments to enter additional undefined symbols.
|
|
@c Nice idea, but no such command: This option is equivalent
|
|
@c to the @code{EXTERN} linker command.
|
|
|
|
@item -Ur
|
|
@kindex -Ur
|
|
@cindex constructors
|
|
For anything other than C++ programs, this option is equivalent to
|
|
@code{-r}: it generates relocatable output---i.e., an output file that can in
|
|
turn serve as input to @code{gld}. When linking C++ programs, @code{-Ur}
|
|
@emph{will} resolve references to constructors, unlike @code{-r}.
|
|
|
|
@item -v
|
|
@kindex -v
|
|
@cindex version
|
|
Display the version number for @code{gld}.
|
|
|
|
@item -X
|
|
@kindex -X
|
|
@cindex local symbols, deleting
|
|
@cindex L, deleting symbols beginning
|
|
If @code{-s} or @code{-S} is also specified, delete only local symbols
|
|
beginning with @samp{L}.
|
|
|
|
@item -x
|
|
@kindex -x
|
|
@cindex deleting local symbols
|
|
If @code{-s} or @code{-S} is also specified, delete all local symbols,
|
|
not just those beginning with @samp{L}.
|
|
|
|
@ignore
|
|
@c -z in older GNU linker, not in new
|
|
@item -z
|
|
@kindex -z
|
|
@cindex read-only text
|
|
Specifies a read-only, demand pageable, and shared @code{text} segment.
|
|
If the output format supports Unix-style magic numbers, @code{-z} also
|
|
marks the output as @code{ZMAGIC}, the default.
|
|
|
|
@c why was following here?. Is it useful to say '-z -r' for
|
|
@c instance, or is this just a ref to other ways of setting
|
|
@c magic no?
|
|
Specifying a relocatable output file (@code{-r}) will also set the magic
|
|
number to @code{OMAGIC}.
|
|
|
|
See description of @code{-N}.
|
|
@end ignore
|
|
|
|
@end table
|
|
|
|
@node Environment, , Options, Invocation
|
|
@section Environment Variables
|
|
|
|
@code{gld} always consults two environment variables: @code{GNUTARGET}
|
|
and @code{LDEMULATION}. Depending on the setting of the latter, other
|
|
environment variables may be used as well.
|
|
|
|
@kindex GNUTARGET
|
|
@cindex default input format
|
|
@code{GNUTARGET} determines the input-file object format if you don't
|
|
use @code{-b} (or its synonym @code{-format}). Its value should be one
|
|
of the BFD names for an input format (@pxref{BFD}). If there is no
|
|
@code{GNUTARGET} in the environment, @code{gld} uses the natural format
|
|
of the host. If @code{GNUTARGET} is set to @code{default} then BFD attempts to discover the
|
|
input format by examining binary input files; this method often
|
|
succeeds, but there are potential ambiguities, since there is no method
|
|
of ensuring that the magic number used to flag object-file formats is
|
|
unique. However, the configuration procedure for BFD on each system
|
|
places the conventional format for that system first in the search-list,
|
|
so ambiguities are resolved in favor of convention.
|
|
|
|
@kindex LDEMULATION
|
|
@cindex emulation
|
|
@cindex environment vars
|
|
@code{LDEMULATION} controls some aspects of @code{gld}'s dominant
|
|
personality. Although @code{gld} is flexible enough to permit its use
|
|
in many contexts regardless of configuration, you can use this variable
|
|
to make it act more like one or another older linker by default.
|
|
|
|
@cindex defaults
|
|
@cindex library paths, default
|
|
In particular, the value of @code{LDEMULATION} controls what default
|
|
linker script is used (thereby controlling the default input and output
|
|
formats; @pxref{BFD}); what default paths are searched for
|
|
archive libraries; and in some cases whether additional linker script
|
|
commands are available.
|
|
|
|
Here is the current set of emulations available:
|
|
@table @code
|
|
|
|
@item LDEMULATION=gld
|
|
@kindex gld
|
|
@cindex emulating old GNU linker
|
|
Emulate the older GNU linker. When this emulation is selected, the
|
|
default library search paths are
|
|
@example
|
|
/lib
|
|
/usr/lib
|
|
/usr/local/lib/lib
|
|
@end example
|
|
@noindent
|
|
The default output format is set to @code{a.out-generic-big}, and the
|
|
default machine is the system's configured BFD default.
|
|
|
|
@item LDEMULATION=gld68k
|
|
@kindex gld68k
|
|
@cindex m68k
|
|
A variant of the @code{gld} emulation; only differs in specifically
|
|
setting the default BFD machine as @code{m68k}.
|
|
|
|
@item LDEMULATION=gld960
|
|
@kindex gld960
|
|
@kindex G960LIB
|
|
@kindex G960BASE
|
|
@cindex i960
|
|
Emulate the Intel port of the older @code{gld} for the i960
|
|
architectures. The default library search paths are taken from two
|
|
other environment variables, @code{G960LIB} and @code{G960BASE}. The
|
|
default architecture is @code{i960}. The default output format is set
|
|
to @code{b.out.big}, and in fact the default output file name (if
|
|
@code{-o} is not specified) is @code{b.out}, to reflect this variant
|
|
format, for this emulation.
|
|
|
|
@kindex GNU960
|
|
This emulation can behave slightly differently depending on the setting
|
|
of the @code{gld} compile-time switch @code{GNU960}. If @code{gld} is
|
|
compiled with @code{GNU960} defined, then an additional environment
|
|
variable---@code{GNUTARGET}---is available; its value, if available,
|
|
specifies some other default output format than @code{b.out.big}.
|
|
|
|
@item LDEMULATION=gldm88kbcs
|
|
@kindex gldm88kbcs
|
|
@cindex m88k
|
|
Sets the output format to @code{m88kbcs} and the architecture to
|
|
@code{m88k}. Default library search paths are
|
|
@example
|
|
/lib
|
|
/usr/lib
|
|
/usr/local/lib
|
|
@end example
|
|
|
|
@item LDEMULATION=lnk960
|
|
@kindex lnk960
|
|
@cindex i960
|
|
@cindex Architectures, i960 family
|
|
Emulate the Intel linker @code{lnk960}. The default output format is
|
|
@code{coff-Intel-big}. With this emulation, @code{gld}
|
|
supports the additional script commands @code{HLL} and @code{SYSLIB} for
|
|
specification of library archives. This is the only emulation with
|
|
extensive support for the @code{-A} (architecture) command-line option.
|
|
By default, the architecture @code{CORE} is assumed, but you can choose
|
|
additional features from the i960 architecture family by using one of
|
|
the following with @code{-A} (or by using the @code{OUTPUT_ARCH} command
|
|
from a script):
|
|
@example
|
|
CORE
|
|
KB
|
|
SB
|
|
MC
|
|
XA
|
|
CA
|
|
KA
|
|
SA
|
|
@end example
|
|
|
|
The default libraries are chosen with some attention to the architecture
|
|
selected; the core library @file{cg} is always included, but the library
|
|
@code{fpg} is also used if you've specified any of the architectures
|
|
@code{KA}, @code{SA}, or @code{CA}.
|
|
|
|
@kindex GNU960
|
|
Like @code{gld960}, this emulation uses additional environment variables
|
|
to set the default library search paths. Also like @code{gld960}, the
|
|
behavior of this emulation is slightly different depending on whether
|
|
@code{gld} itself was compiled with @code{GNU960} defined.
|
|
|
|
@kindex G960BASE
|
|
@kindex G960LIB
|
|
@kindex I960BASE
|
|
If your @code{gld} was compiled with @code{GNU960} defined, the default
|
|
paths are taken from all three of @code{G960LIB}, @code{G960BASE}, and
|
|
@code{I960BASE}. For the first two, paths you supply are automatically
|
|
suffixed with @samp{/lib/libcoff}; for the last, your path is
|
|
automatically suffixed with @samp{/lib}.
|
|
|
|
If your @code{gld} was @emph{not} compiled with @code{GNU960} defined,
|
|
the default paths are taken from @code{I960BASE}, and @code{G960BASE} is
|
|
only consulted if @code{I960BASE} is undefined. In this case
|
|
@code{G960LIB} is not used at all.
|
|
|
|
@item LDEMULATION=vanilla
|
|
@kindex vanilla
|
|
@cindex emulation, disabling
|
|
@cindex disabling emulation
|
|
This is the least specific setting for @code{gld}. You can set
|
|
@code{LDEMULATION=vanilla} to disable emulation of other linkers. This
|
|
setting makes @code{gld} take the default machine from the BFD
|
|
configuration on your system; @code{a.out-generic-big} is the default
|
|
target. No other defaults are specified.
|
|
|
|
@end table
|
|
|
|
@node Commands, BFD, Invocation, Top
|
|
@chapter Command Language
|
|
|
|
@cindex command files
|
|
The command language allows explicit control over the link process,
|
|
allowing complete specification of the mapping between the linker's
|
|
input files and its output. This includes:
|
|
@itemize @bullet
|
|
@item
|
|
input files
|
|
@item
|
|
file formats
|
|
@item
|
|
output file format
|
|
@item
|
|
addresses of sections
|
|
@item
|
|
placement of common blocks
|
|
@end itemize
|
|
|
|
You may supply a command file (also known as a link script) to the
|
|
linker either explicitly through the @code{-c} option, or implicitly as
|
|
an ordinary file. If the linker opens a file which it cannot recognize
|
|
as a supported object or archive format, it tries to interpret the file
|
|
as a command file.
|
|
|
|
You can also include a script directly on the @code{gld} command line,
|
|
delimited by the characters @samp{@{} and @samp{@}}.
|
|
|
|
@menu
|
|
* Scripts:: Linker Scripts
|
|
* Expressions:: Expressions
|
|
* MEMORY:: MEMORY Command
|
|
* SECTIONS:: SECTIONS Command
|
|
* Entry Point:: The Entry Point
|
|
* Other Commands:: Other Commands
|
|
@end menu
|
|
|
|
@node Scripts, Expressions, Commands, Commands
|
|
@section Linker Scripts
|
|
The @code{gld} command language is a collection of statements; some are
|
|
simple keywords setting a particular flag, some are used to select and
|
|
group input files or name output files; and two particular statement
|
|
types have a fundamental and pervasive impact on the linking process.
|
|
|
|
@cindex fundamental script commands
|
|
@cindex commands, fundamental
|
|
@cindex output file layout
|
|
@cindex layout of output file
|
|
The most fundamental command of the @code{gld} command language is the
|
|
@code{SECTIONS} command (@pxref{SECTIONS}). Every meaningful command
|
|
script must have a @code{SECTIONS} command: it specifies a
|
|
``picture'' of the output file's layout, in varying degrees of detail.
|
|
No other command is required in all cases.
|
|
|
|
The @code{MEMORY} command complements @code{SECTIONS} by describing the
|
|
available memory in the target architecture. This command is optional;
|
|
if you don't use a @code{MEMORY} command, @code{gld} assumes sufficient
|
|
memory is available in a contiguous block for all output.
|
|
@xref{MEMORY}.
|
|
|
|
@cindex comments
|
|
You may include comments in linker scripts just as in C: delimited
|
|
by @samp{/*} and @samp{*/}. As in C, comments are syntactically
|
|
equivalent to whitespace.
|
|
|
|
@node Expressions, MEMORY, Scripts, Commands
|
|
@section Expressions
|
|
@cindex expression syntax
|
|
@cindex arithmetic
|
|
Many useful commands involve arithmetic expressions. The syntax for
|
|
expressions in the command language is identical to that of C
|
|
expressions, with the following features:
|
|
@itemize @bullet
|
|
@item
|
|
All expressions evaluated as integers and
|
|
are of ``long'' or ``unsigned long'' type.
|
|
@item
|
|
All constants are integers.
|
|
@item
|
|
All of the C arithmetic operators are provided.
|
|
@item
|
|
You may reference, define, and create global variables.
|
|
@item
|
|
You may call special purpose built-in functions.
|
|
@end itemize
|
|
|
|
@menu
|
|
* Integers:: Integers
|
|
* Symbols:: Symbol Names
|
|
* Location Counter:: The Location Counter
|
|
* Operators:: Operators
|
|
* Evaluation:: Evaluation
|
|
* Assignment:: Assignment: Defining Symbols
|
|
* Built-ins:: Built-In Functions
|
|
@end menu
|
|
|
|
@node Integers, Symbols, Expressions, Expressions
|
|
@subsection Integers
|
|
@cindex integer notation
|
|
@cindex octal integers
|
|
An octal integer is @samp{0} followed by zero or more of the octal
|
|
digits (@samp{01234567}).
|
|
@example
|
|
_as_octal = 0157255;
|
|
@end example
|
|
|
|
@cindex decimal integers
|
|
A decimal integer starts with a non-zero digit followed by zero or
|
|
more digits (@samp{0123456789}).
|
|
@example
|
|
_as_decimal = 57005;
|
|
@end example
|
|
|
|
@cindex hexadecimal integers
|
|
@kindex 0x
|
|
A hexadecimal integer is @samp{0x} or @samp{0X} followed by one or
|
|
more hexadecimal digits chosen from @samp{0123456789abcdefABCDEF}.
|
|
@example
|
|
_as_hex = 0xdead;
|
|
@end example
|
|
|
|
@cindex negative integers
|
|
Decimal integers have the usual values. To write a negative integer, use
|
|
the prefix operator @samp{-}; @pxref{Operators}.
|
|
@example
|
|
_as_neg = -57005;
|
|
@end example
|
|
|
|
@cindex scaled integers
|
|
@cindex K and M integer suffixes
|
|
@cindex M and K integer suffixes
|
|
@cindex suffixes for integers
|
|
@cindex integer suffixes
|
|
Additionally the suffixes @code{K} and @code{M} may be used to scale a
|
|
constant by
|
|
@c TEXI2ROFF-KILL
|
|
@ifinfo
|
|
@c END TEXI2ROFF-KILL
|
|
@code{1024} or @code{1024*1024}
|
|
@c TEXI2ROFF-KILL
|
|
@end ifinfo
|
|
@tex
|
|
${\rm 1024}$ or ${\rm 1024}^2$
|
|
@end tex
|
|
@c END TEXI2ROFF-KILL
|
|
respectively. For example, the following all refer to the same quantity:@refill
|
|
|
|
@example
|
|
_fourk_1 = 4K;
|
|
_fourk_2 = 4096;
|
|
_fourk_3 = 0x1000;
|
|
@end example
|
|
|
|
@node Symbols, Location Counter, Integers, Expressions
|
|
@subsection Symbol Names
|
|
@cindex symbol names
|
|
@cindex names
|
|
@cindex quoted symbol names
|
|
@kindex "
|
|
Unless quoted, symbol names start with a letter, underscore, point or
|
|
hyphen and may include any letters, underscores, digits, points,
|
|
and minus signs. Unquoted symbol names must not conflict with any
|
|
keywords. You can specify a symbol which contains odd characters or has
|
|
the same name as a keyword, by surrounding the symbol name in double quotes:
|
|
@example
|
|
"SECTION" = 9;
|
|
"with a space" = "also with a space" + 10;
|
|
@end example
|
|
|
|
@node Location Counter, Operators, Symbols, Expressions
|
|
@subsection The Location Counter
|
|
@kindex .
|
|
@cindex dot
|
|
@cindex location counter
|
|
@cindex current output location
|
|
The special linker variable @dfn{dot} @samp{.} always contains the
|
|
current output location counter. Since the @code{.} always refers to
|
|
a location in an output section, it must always appear in an
|
|
expression within a @code{SECTIONS} command. The @code{.} symbol
|
|
may appear anywhere that an ordinary symbol is allowed in an
|
|
expression, but its assignments have a side effect. Assigning a value
|
|
to the @code{.} symbol will cause the location counter to be moved.
|
|
@cindex holes
|
|
This may be used to create holes in the output section. The location
|
|
counter may never be moved backwards.
|
|
@example
|
|
SECTIONS
|
|
@{
|
|
output :
|
|
@{
|
|
file1(.text)
|
|
. = . + 1000;
|
|
file2(.text)
|
|
. += 1000;
|
|
file3(.text)
|
|
@} = 0x1234;
|
|
@}
|
|
@end example
|
|
@noindent
|
|
In the previous example, @code{file1} is located at the beginning of the
|
|
output section, then there is a 1000 byte gap. Then @code{file2}
|
|
appears, also with a 1000 byte gap following before @code{file3} is
|
|
loaded. The notation @samp{= 0x1234} specifies what data to write in
|
|
the gaps (@pxref{Section Options}).
|
|
|
|
@node Operators, Evaluation, Location Counter, Expressions
|
|
@subsection Operators
|
|
@cindex Operators for arithmetic
|
|
@cindex arithmetic operators
|
|
@cindex precedence in expressions
|
|
The linker recognizes the standard C set of arithmetic operators, with
|
|
the standard bindings and precedence levels:
|
|
@c TEXI2ROFF-KILL
|
|
@ifinfo
|
|
@c END TEXI2ROFF-KILL
|
|
@example
|
|
precedence associativity Operators Notes
|
|
(highest)
|
|
1 left ! - ~ (1)
|
|
2 left * / %
|
|
3 left + -
|
|
4 left >> <<
|
|
5 left == != > < <= >=
|
|
6 left &
|
|
7 left |
|
|
8 left &&
|
|
9 left ||
|
|
10 right ? :
|
|
11 right &= += -= *= /= (2)
|
|
(lowest)
|
|
@end example
|
|
Notes:
|
|
(1) Prefix operators
|
|
(2) @xref{Assignment}
|
|
@c TEXI2ROFF-KILL
|
|
@end ifinfo
|
|
@tex
|
|
\vskip \baselineskip
|
|
%"lispnarrowing" is the extra indent used generally for @example
|
|
\hskip\lispnarrowing\vbox{\offinterlineskip
|
|
\hrule
|
|
\halign
|
|
{\vrule#&\strut\hfil\ #\ \hfil&\vrule#&\strut\hfil\ #\ \hfil&\vrule#&\strut\hfil\ {\tt #}\ \hfil&\vrule#\cr
|
|
height2pt&\omit&&\omit&&\omit&\cr
|
|
&Precedence&& Associativity &&{\rm Operators}&\cr
|
|
height2pt&\omit&&\omit&&\omit&\cr
|
|
\noalign{\hrule}
|
|
height2pt&\omit&&\omit&&\omit&\cr
|
|
&highest&&&&&\cr
|
|
% '176 is tilde, '~' in tt font
|
|
&1&&left&&\qquad- \char'176\ !\qquad\dag&\cr
|
|
&2&&left&&* / \%&\cr
|
|
&3&&left&&+ -&\cr
|
|
&4&&left&&>> <<&\cr
|
|
&5&&left&&== != > < <= >=&\cr
|
|
&6&&left&&\&&\cr
|
|
&7&&left&&|&\cr
|
|
&8&&left&&{\&\&}&\cr
|
|
&9&&left&&||&\cr
|
|
&10&&right&&? :&\cr
|
|
&11&&right&&\qquad\&= += -= *= /=\qquad\ddag&\cr
|
|
&lowest&&&&&\cr
|
|
height2pt&\omit&&\omit&&\omit&\cr}
|
|
\hrule}
|
|
@end tex
|
|
@iftex
|
|
{
|
|
@obeylines@parskip=0pt@parindent=0pt
|
|
@dag@quad Prefix operators.
|
|
@ddag@quad @xref{Assignment}.
|
|
}
|
|
@end iftex
|
|
@c END TEXI2ROFF-KILL
|
|
|
|
@node Evaluation, Assignment, Operators, Expressions
|
|
@subsection Evaluation
|
|
|
|
@cindex lazy evaluation
|
|
@cindex expression evaluation order
|
|
The linker uses ``lazy evaluation'' for expressions; it only calculates
|
|
an expression when absolutely necessary. The linker needs the value of
|
|
the start address, and the lengths of memory regions, in order to do any
|
|
linking at all; these values are computed as soon as possible when the
|
|
linker reads in the command file. However, other values (such as symbol
|
|
values) are not known or needed until after storage allocation. Such
|
|
values are evaluated later, when other information (such as the sizes of
|
|
output sections) is available for use in the symbol assignment
|
|
expression.
|
|
|
|
@node Assignment, Built-ins, Evaluation, Expressions
|
|
@subsection Assignment: Defining Symbols
|
|
@cindex assignment in scripts
|
|
@cindex symbol definition, scripts
|
|
@cindex variables, defining
|
|
You may create global symbols, and assign values (addresses) to global
|
|
symbols, using any of the C assignment operators:
|
|
|
|
@table @code
|
|
@item @var{symbol} = @var{expression} ;
|
|
@itemx @var{symbol} &= @var{expression} ;
|
|
@itemx @var{symbol} += @var{expression} ;
|
|
@itemx @var{symbol} -= @var{expression} ;
|
|
@itemx @var{symbol} *= @var{expression} ;
|
|
@itemx @var{symbol} /= @var{expression} ;
|
|
@end table
|
|
|
|
Two things distinguish assignment from other operators in @code{gld}
|
|
expressions.
|
|
@itemize @bullet
|
|
@item
|
|
Assignment may only be used at the root of an expression;
|
|
@samp{a=b+3;} is allowed, but @samp{a+b=3;} is an error.
|
|
|
|
@kindex ;
|
|
@cindex semicolon
|
|
@item
|
|
A trailing semicolon is required at the end of an assignment
|
|
statement.
|
|
@end itemize
|
|
|
|
Assignment statements may appear:
|
|
@itemize @bullet
|
|
@item
|
|
as commands in their own right in a @code{gld} script; or
|
|
@item
|
|
as independent statements within a @code{SECTIONS} command; or
|
|
@item
|
|
as part of the contents of a section definition in a
|
|
@code{SECTIONS} command.
|
|
@end itemize
|
|
|
|
The first two cases are equivalent in effect---both define a symbol with
|
|
an absolute address; the last case defines a symbol whose address is
|
|
relative to a particular section (@pxref{SECTIONS}).
|
|
|
|
@cindex absolute and relocatable symbols
|
|
@cindex relocatable and absolute symbols
|
|
@cindex symbols, relocatable and absolute
|
|
When a linker expression is evaluated and assigned to a variable, it is
|
|
given either an absolute or a relocatable type. An absolute expression
|
|
type is one in which the symbol contains the value that it will have in
|
|
the output file, a relocateable expression type is one in which the
|
|
value is expressed as a fixed offset from the base of a section.
|
|
|
|
The type of the expression is controlled by its position in the script
|
|
file. A symbol assigned within a section definition is created relative
|
|
to the base of the section; a symbol assigned in any other place is
|
|
created as an absolute symbol. Since a symbol created within a
|
|
section definition is relative to the base of the section, it
|
|
will remain relocatable if relocatable output is requested. A symbol
|
|
may be created with an absolute value even when assigned to within a
|
|
section definition by using the absolute assignment function
|
|
@code{ABSOLUTE}. For example, to create an absolute symbol whose address
|
|
is the last byte of an output section named @code{.data}:
|
|
@example
|
|
SECTIONS@{ @dots{}
|
|
.data :
|
|
@{
|
|
*(.data)
|
|
_edata = ABSOLUTE(.) ;
|
|
@}
|
|
@dots{} @}
|
|
@end example
|
|
|
|
The linker tries to put off the evaluation of an assignment until all
|
|
the terms in the source expression are known (@pxref{Evaluation}). For
|
|
instance the sizes of sections cannot be known until after allocation,
|
|
so assignments dependent upon these are not performed until after
|
|
allocation. Some expressions, such as those depending upon the location
|
|
counter @dfn{dot}, @samp{.} must be evaluated during allocation. If the
|
|
result of an expression is required, but the value is not available,
|
|
then an error results. For example, a script like the following
|
|
@example
|
|
SECTIONS @{ @dots{}
|
|
text 9+this_isnt_constant:
|
|
@{ @dots{}
|
|
@}
|
|
@dots{} @}
|
|
@end example
|
|
@kindex Non constant expression
|
|
@noindent
|
|
will cause the error message ``@code{Non constant expression for initial
|
|
address}''.
|
|
|
|
@node Built-ins, , Assignment, Expressions
|
|
@subsection Built-In Functions
|
|
@cindex functions in expression language
|
|
The command language includes a number of special purpose built-in
|
|
functions for use in link script expressions.
|
|
@table @code
|
|
@item ABSOLUTE(@var{exp})
|
|
@kindex ABSOLUTE(@var{exp})
|
|
@cindex expression, absolute
|
|
returns the absolute value of the expression @var{exp}. Primarily
|
|
useful to assign an absolute value to a symbol within a section
|
|
definition, where symbol values are normally section-relative.
|
|
|
|
@item ADDR(@var{section})
|
|
@kindex ADDR(@var{section})
|
|
@cindex section address
|
|
returns the absolute address of the named @var{section}. Your script must
|
|
previously have defined the location of that section. In the following
|
|
example the @code{symbol_1} and @code{symbol_2} are assigned identical
|
|
values:
|
|
@example
|
|
SECTIONS@{ @dots{}
|
|
.output1:
|
|
@{
|
|
start_of_output_1 = ABSOLUTE(.);
|
|
@dots{}
|
|
@}
|
|
.output:
|
|
@{
|
|
symbol_1 = ADDR(.output1);
|
|
symbol_2 = start_of_output_1;
|
|
@}
|
|
@dots{} @}
|
|
@end example
|
|
|
|
@item ALIGN(@var{exp})
|
|
@kindex ALIGN(@var{exp})
|
|
@cindex rounding up location counter
|
|
returns the result of the current location counter (@code{.}) aligned to
|
|
the next @var{exp} boundary. @var{exp} must be an expression whose
|
|
value is a power of two. This is equivalent to
|
|
@example
|
|
(. + @var{exp} -1) & ~(@var{exp}-1)
|
|
@end example
|
|
|
|
@code{ALIGN} doesn't change the value of the location counter---it just
|
|
does arithmetic on it. As an example, to align the output @code{.data}
|
|
section to the next @code{0x2000} byte boundary after the preceding
|
|
section and to set a variable within the section to the next
|
|
@code{0x8000} boundary after the input sections:
|
|
@example
|
|
SECTIONS@{ @dots{}
|
|
.data ALIGN(0x2000): @{
|
|
*(.data)
|
|
variable = ALIGN(0x8000);
|
|
@}
|
|
@dots{} @}
|
|
@end example
|
|
@noindent
|
|
The first use of @code{ALIGN} in this example specifies the location of
|
|
a section because it is used as the optional @var{start} attribute of a
|
|
section definition (@pxref{Section Options}). The second use simply
|
|
defines the value of a variable.
|
|
|
|
The built-in @code{NEXT} is closely related to @code{ALIGN}.
|
|
|
|
@item DEFINED(@var{symbol})
|
|
@kindex DEFINED(@var{symbol})
|
|
@cindex symbol defaults
|
|
Returns @code{1} if @var{symbol} is in the linker global symbol table and is
|
|
defined, otherwise it returns @code{0}. You can use this to provide default
|
|
values for symbols. For example, this command-file fragment shows how
|
|
to set a global symbol @code{begin} to the first location in the
|
|
@code{.text} section---but if a symbol called @code{begin} already
|
|
existed, its value is preserved:
|
|
@smallexample
|
|
SECTIONS@{ @dots{}
|
|
.text: @{
|
|
begin = DEFINED(begin) ? begin : . ;
|
|
@dots{}
|
|
@}
|
|
@dots{} @}
|
|
@end smallexample
|
|
|
|
@item NEXT(@var{exp})
|
|
@kindex NEXT(@var{exp})
|
|
@cindex unallocated address, next
|
|
Returns the next unallocated address that is a multiple of @var{exp}.
|
|
This command is closely related to @code{ALIGN(@var{exp})}; unless you
|
|
use the @code{MEMORY} command to define discontinuous memory for the
|
|
output file, the two commands are equivalent.
|
|
|
|
@item SIZEOF(@var{section})
|
|
@kindex SIZEOF(@var{section})
|
|
@cindex section size
|
|
returns the size in bytes of the named @var{section}, if the section has
|
|
been allocated. In the following example the @code{symbol_1} and
|
|
@code{symbol_2} are assigned identical values:
|
|
@example
|
|
SECTIONS@{ @dots{}
|
|
.output @{
|
|
.start = . ;
|
|
@dots{}
|
|
.end = .;
|
|
@}
|
|
symbol_1 = .end - .start;
|
|
symbol_2 = SIZEOF(.output);
|
|
@dots{} @}
|
|
|
|
@end example
|
|
|
|
@item SIZEOF_HEADERS
|
|
@kindex SIZEOF_HEADERS
|
|
@cindex header size
|
|
@itemx sizeof_headers
|
|
@kindex sizeof_headers
|
|
the size in bytes of the output file's headers. You can use this number
|
|
as the start address of the first section, if you choose, to facilitate
|
|
paging.
|
|
|
|
@end table
|
|
|
|
@node MEMORY, SECTIONS, Expressions, Commands
|
|
@section MEMORY Command
|
|
@kindex MEMORY
|
|
@cindex regions of memory
|
|
@cindex discontinuous memory
|
|
@cindex allocating memory
|
|
The linker's default configuration permits allocation of all memory.
|
|
You can override this by using the @code{MEMORY} command. The
|
|
@code{MEMORY} command describes the location and size of blocks of
|
|
memory in the target. By using it carefully, you can describe which
|
|
memory regions may be used by the linker, and which memory regions it
|
|
must avoid. The linker does not shuffle sections to fit into the
|
|
available regions, but does move the requested sections into the correct
|
|
regions and issue errors when the regions become too full.
|
|
|
|
Command files may contain at most one use of the @code{MEMORY}
|
|
command; however, you can define as many blocks of memory within it as
|
|
you wish. The syntax is:
|
|
|
|
@example
|
|
MEMORY
|
|
@{
|
|
@var{name} (@var{attr}): ORIGIN = @var{origin}, LENGTH = @var{len}
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
@table @code
|
|
@item @var{name}
|
|
@cindex naming memory regions
|
|
is a name used internally by the linker to refer to the region. Any
|
|
symbol name may be used. The region names are stored in a separate
|
|
name space, and will not conflict with symbols, filenames or section
|
|
names. Use distinct names to specify multiple regions.
|
|
@item (@var{attr})
|
|
@cindex memory region attributes
|
|
is an optional list of attributes, permitted for compatibility with the
|
|
AT&T linker but not used by @code{gld} beyond checking that the
|
|
attribute list is valid. Valid attribute lists must be made up of the
|
|
characters ``@code{LIRWX}''. If you omit the attribute list, you may
|
|
omit the parentheses around it as well.
|
|
@item @var{origin}
|
|
@kindex ORIGIN=
|
|
@kindex o=
|
|
@kindex org=
|
|
is the start address of the region in physical memory. It is expressed as
|
|
an expression, which must evaluate to a constant before
|
|
memory allocation is performed. The keyword @code{ORIGIN} may be
|
|
abbreviated to @code{org} or @code{o}.
|
|
@item @var{len}
|
|
@kindex LENGTH=
|
|
@kindex len=
|
|
@kindex l=
|
|
is the size in bytes of the region (an expression).
|
|
The keyword @code{LENGTH} may be abbreviated to @code{len} or @code{l}.
|
|
@end table
|
|
|
|
For example, to specify that memory has two regions available for
|
|
allocation---one starting at @code{0} for 256 kilobytes, and the other
|
|
starting at @code{0x40000000} for four megabytes:
|
|
|
|
@example
|
|
MEMORY
|
|
@{
|
|
rom : ORIGIN= 0, LENGTH = 256K
|
|
ram : org= 0x40000000, l = 4M
|
|
@}
|
|
@end example
|
|
|
|
Once you have defined a region of memory named @var{mem}, you can direct
|
|
specific output sections there by using a command ending in
|
|
@samp{>@var{mem}} within the @code{SECTIONS} command (@pxref{Section
|
|
Options}). If the combined output sections directed to a region are too
|
|
big for the region, the linker will issue an error message.
|
|
|
|
@node SECTIONS, Entry Point, MEMORY, Commands
|
|
@section SECTIONS Command
|
|
@kindex SECTIONS
|
|
The @code{SECTIONS} command controls exactly where input sections are
|
|
placed into output sections, their order and to which output sections
|
|
they are allocated.
|
|
|
|
You may use at most one @code{SECTIONS} command in a commands file,
|
|
but you can have as many statements within it as you wish. Statements
|
|
within the @code{SECTIONS} command can do one of three things:
|
|
@itemize @bullet
|
|
@item
|
|
define the entry point;
|
|
@item
|
|
assign a value to a symbol;
|
|
@item
|
|
describe the placement of a named output section, and what input
|
|
sections make it up.
|
|
@end itemize
|
|
|
|
The first two possibilities---defining the entry point, and defining
|
|
symbols---can also be done outside the @code{SECTIONS} command:
|
|
@pxref{Entry Point}, @pxref{Assignment}. They are permitted here as
|
|
well for your convenience in reading the script, so that symbols or the
|
|
entry point can be defined at meaningful points in your output-file
|
|
layout.
|
|
|
|
When no @code{SECTIONS} command is specified, the default action
|
|
of the linker is to place each input section into an identically named
|
|
output section in the order that the sections are first encountered in
|
|
the input files; if all input sections are present in the first file,
|
|
for example, the order of sections in the output file will match the
|
|
order in the first input file.
|
|
|
|
@menu
|
|
* Section Definition:: Section Definitions
|
|
* Section Contents:: Section Contents
|
|
* Section Options:: Optional Section Attributes
|
|
@end menu
|
|
|
|
@node Section Definition, Section Contents, SECTIONS, SECTIONS
|
|
@subsection Section Definitions
|
|
@cindex section definition
|
|
The most frequently used statement in the @code{SECTIONS} command is
|
|
the @dfn{section definition}, which you can use to specify the
|
|
properties of an output section: its location, alignment, contents,
|
|
fill pattern, and target memory region can all be specified. Most of
|
|
these specifications are optional; the simplest form of a section
|
|
definition is
|
|
@example
|
|
SECTIONS @{ @dots{}
|
|
@var{secname} : @{
|
|
@var{contents}
|
|
@}
|
|
@dots{} @}
|
|
@end example
|
|
@cindex naming output sections
|
|
@noindent
|
|
@var{secname} is the name of the output section, and @var{contents} a
|
|
specification of what goes there---for example a list of input files or
|
|
sections of input files. As you might assume, the whitespace shown is
|
|
optional; you do need the colon @samp{:} and the braces @samp{@{@}},
|
|
however.
|
|
|
|
@var{secname} must meet the constraints of your output format. In
|
|
formats which only support a limited number of sections, such as
|
|
@code{a.out}, the name must be one of the names supported by the format
|
|
(@code{a.out}, for example, allows only @code{.text}, @code{.data} or
|
|
@code{.bss}). If the output format supports any number of sections, but
|
|
with numbers and not names (as is the case for Oasys), the name should be
|
|
supplied as a quoted numeric string. A section name may consist of any
|
|
sequence characters, but any name which does not conform to the standard
|
|
@code{gld} symbol name syntax must be quoted.
|
|
|
|
@node Section Contents, Section Options, Section Definition, SECTIONS
|
|
@subsection Section Contents
|
|
@cindex contents of a section
|
|
In a section definition, you can specify the contents of an output section by
|
|
listing particular object files; by listing particular input-file
|
|
sections; or a combination of the two. You can also place arbitrary
|
|
data in the section, and define symbols relative to the beginning of the
|
|
section.
|
|
|
|
The @var{contents} of a section definition may include any of the
|
|
following kinds of statement. You can include as many of these as you
|
|
like in a single section definition, separated from one another by
|
|
whitespace.
|
|
|
|
@table @code
|
|
@item @var{filename}
|
|
@kindex @var{filename}
|
|
@cindex input files, section defn
|
|
@cindex files, including in output sections
|
|
You may simply name a particular input file to be placed in the current
|
|
output section; @emph{all} sections from that file are placed in the
|
|
current section definition. To specify a list of particular files by
|
|
name:
|
|
@example
|
|
.data: @{ afile.o bfile.o cfile.o @}
|
|
@end example
|
|
@noindent
|
|
The example also illustrates that multiple statements can be included in
|
|
the contents of a section definition, since each filename is a separate
|
|
statement.
|
|
|
|
If the file name has already been mentioned in another section
|
|
definition, with an explicit section name list, then only those sections
|
|
which have not yet been allocated are used.
|
|
|
|
@item @var{filename}( @var{section} )
|
|
@itemx @var{filename}( @var{section}, @var{section}, @dots{} )
|
|
@itemx @var{filename}( @var{section} @var{section} @dots{} )
|
|
@kindex @var{filename}(@var{section})
|
|
@cindex files and sections, section defn
|
|
You can name one or more sections from your input files, for
|
|
insertion in the current output section. If you wish to specify a list
|
|
of input-file sections inside the parentheses, you may separate the
|
|
section names by either commas or whitespace.
|
|
|
|
@item * (@var{section})
|
|
@itemx * (@var{section}, @var{section}, @dots{})
|
|
@itemx * (@var{section} @var{section} @dots{}
|
|
@cindex input sections to output section
|
|
@kindex *(@var{section})
|
|
Instead of explicitly naming particular input files in a link control
|
|
script, you can refer to @emph{all} files from the @code{gld} command
|
|
line: use @samp{*} instead of a particular filename before the
|
|
parenthesized input-file section list.
|
|
|
|
For example, to copy sections @code{1} through @code{4} from a Oasys file
|
|
into the @code{.text} section of an @code{a.out} file, and sections @code{13}
|
|
and @code{14} into the @code{.data} section:
|
|
@example
|
|
SECTIONS @{
|
|
.text :@{
|
|
*("1" "2" "3" "4")
|
|
@}
|
|
|
|
.data :@{
|
|
*("13" "14")
|
|
@}
|
|
@}
|
|
@end example
|
|
|
|
If you have already explicitly included some files by name, @samp{*}
|
|
refers to all @emph{remaining} files---those whose places in the output
|
|
file have not yet been defined.
|
|
|
|
@item [ @var{section} ]
|
|
@itemx [ @var{section}, @var{section}, @dots{} ]
|
|
@itemx [ @var{section} @var{section} @dots{} ]
|
|
@kindex [ @var{sections} ]
|
|
This is an alternate notation to specify named sections from all
|
|
unallocated input files; its effect is exactly the same as that of
|
|
@samp{* (@var{section}@dots{})}
|
|
|
|
@item @var{filename}@code{( COMMON )}
|
|
@itemx [ COMMON ]
|
|
@kindex [COMMON]
|
|
@cindex uninitialized data
|
|
@cindex commons in output
|
|
Specify where in your output file to place uninitialized data
|
|
with this notation. @code{[COMMON]} by itself refers to all
|
|
uninitialized data from all input files (so far as it is not yet
|
|
allocated); @var{filename}@code{(COMMON)} refers to uninitialized data
|
|
from a particular file. Both are special cases of the general
|
|
mechanisms for specifying where to place input-file sections:
|
|
@code{gld} permits you to refer to uninitialized data as if it
|
|
were in an input-file section named @code{COMMON}, regardless of the
|
|
input file's format.
|
|
@end table
|
|
|
|
For example, the following command script arranges the output file into
|
|
three consecutive sections, named @code{.text}, @code{.data}, and
|
|
@code{.bss}, taking the input for each from the correspondingly named
|
|
sections of all the input files:
|
|
@example
|
|
SECTIONS @{
|
|
.text: @{ *(.text) @}
|
|
.data: @{ *(.data) @}
|
|
.bss: @{ *(.bss) [COMMON] @}
|
|
@}
|
|
@end example
|
|
|
|
The following example reads all of the sections from file @code{all.o}
|
|
and places them at the start of output section @code{outputa} which
|
|
starts at location @code{0x10000}. All of section @code{.input1} from
|
|
file @code{foo.o} follows immediately, in the same output section. All
|
|
of section @code{.input2} from @code{foo.o} goes into output section
|
|
@code{outputb}, followed by section @code{.input1} from @code{foo1.o}.
|
|
All of the remaining @code{.input1} and @code{.input2} sections from any
|
|
files are written to output section @code{outputc}.
|
|
|
|
@example
|
|
SECTIONS @{
|
|
outputa 0x10000 :
|
|
@{
|
|
all.o
|
|
foo.o (.input1)
|
|
@}
|
|
outputb :
|
|
@{
|
|
foo.o (.input2)
|
|
foo1.o (.input1)
|
|
@}
|
|
outputc :
|
|
@{
|
|
*(.input1)
|
|
*(.input2)
|
|
@}
|
|
@}
|
|
@end example
|
|
|
|
There are still more kinds of statements permitted in the contents of
|
|
output section definitions. The foregoing statements permitted you to
|
|
arrange, in your output file, data originating from your input files.
|
|
You can also place data directly in an output section from the link
|
|
command script. Most of these additional statements involve
|
|
expressions; @pxref{Expressions}. Although these statements are shown
|
|
separately here for ease of presentation, no such segregation is needed
|
|
within a section definition in the @code{SECTIONS} command; you can
|
|
intermix them freely with any of the statements we've just described.
|
|
|
|
@table @code
|
|
@item CREATE_OBJECT_SYMBOLS
|
|
@kindex CREATE_OBJECT_SYMBOLS
|
|
@cindex input filename symbols
|
|
@cindex filename symbols
|
|
instructs the linker to create a symbol for each input file
|
|
in the current section, set with the address of the first byte of
|
|
data written from the input file. For instance, with @code{a.out}
|
|
files it is conventional to have a symbol for each input file. You can
|
|
accomplish this by defining the output @code{.text} section as follows:
|
|
@example
|
|
SECTIONS @{
|
|
.text 0x2020 :
|
|
@{
|
|
CREATE_OBJECT_SYMBOLS
|
|
*(.text)
|
|
_etext = ALIGN(0x2000);
|
|
@}
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
If @code{objsym} is a file containing this script, and @code{a.o},
|
|
@code{b.o}, @code{c.o}, and @code{d.o} are four input files with
|
|
contents like the following---
|
|
@example
|
|
/* a.c */
|
|
|
|
afunction() @{ @}
|
|
int adata=1;
|
|
int abss;
|
|
@end example
|
|
|
|
@noindent
|
|
@samp{gld -M sample a.o b.o c.o d.o} would create a map like this,
|
|
containing symbols matching the object file names:
|
|
@example
|
|
00000000 A __DYNAMIC
|
|
00004020 B _abss
|
|
00004000 D _adata
|
|
00002020 T _afunction
|
|
00004024 B _bbss
|
|
00004008 D _bdata
|
|
00002038 T _bfunction
|
|
00004028 B _cbss
|
|
00004010 D _cdata
|
|
00002050 T _cfunction
|
|
0000402c B _dbss
|
|
00004018 D _ddata
|
|
00002068 T _dfunction
|
|
00004020 D _edata
|
|
00004030 B _end
|
|
00004000 T _etext
|
|
00002020 t a.o
|
|
00002038 t b.o
|
|
00002050 t c.o
|
|
00002068 t d.o
|
|
@end example
|
|
|
|
@item @var{symbol} = @var{expression} ;
|
|
@kindex @var{symbol} = @var{expression} ;
|
|
@itemx @var{symbol} @var{f}= @var{expression} ;
|
|
@kindex @var{symbol} @var{f}= @var{expression} ;
|
|
@var{symbol} is any symbol name (@pxref{Symbols}). ``@var{f}=''
|
|
refers to any of the operators @code{&= += -= *= /=} which combine
|
|
arithmetic and assignment.
|
|
|
|
@cindex assignment, in section defn
|
|
When you assign a value to a symbol within a particular section
|
|
definition, the value is relative to the beginning of the section
|
|
(@pxref{Assignment}). If you write
|
|
@example
|
|
SECTIONS @{
|
|
abs = 14 ;
|
|
@dots{}
|
|
.data: @{ @dots{} rel = 14 ; @dots{} @}
|
|
abs2 = 14 + ADDR(.data);
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
@c FIXME: Try above example!
|
|
@noindent
|
|
@code{abs} and @var{rel} do not have the same value; @code{rel} has the
|
|
same value as @code{abs2}.
|
|
|
|
@item BYTE(@var{expression})
|
|
@kindex BYTE(@var{expression})
|
|
@itemx SHORT(@var{expression})
|
|
@kindex SHORT(@var{expression})
|
|
@itemx LONG(@var{expression})
|
|
@kindex LONG(@var{expression})
|
|
@cindex direct output
|
|
By including one of these three statements in a section definition, you
|
|
can explicitly place one, two, or four bytes (respectively) at the
|
|
current address of that section. Multiple-byte quantities are
|
|
represented in whatever byte order is appropriate for the output file
|
|
format (@pxref{BFD}).
|
|
|
|
@item FILL(@var{expression})
|
|
@kindex FILL(@var{expression})
|
|
@cindex holes, filling
|
|
@cindex unspecified memory
|
|
Specifies the ``fill pattern'' for the current section. Any otherwise
|
|
unspecified regions of memory within the section (for example, regions
|
|
you skip over by assigning a new value to the location counter @samp{.})
|
|
are filled with the two least significant bytes from the
|
|
@var{expression} argument. A @code{FILL} statement covers memory
|
|
locations @emph{after} the point it occurs in the section definition; by
|
|
including more than one @code{FILL} statement, you can have different
|
|
fill patterns in different parts of an output section.
|
|
@end table
|
|
|
|
@node Section Options, , Section Contents, SECTIONS
|
|
@subsection Optional Section Attributes
|
|
@cindex section defn, full syntax
|
|
Here is the full syntax of a section definition, including all the
|
|
optional portions:
|
|
|
|
@example
|
|
SECTIONS @{
|
|
@dots{}
|
|
@var{secname} @var{start} BLOCK(@var{align}) : @{ @var{contents} @} =@var{fill} >@var{region}
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
@var{secname} and @var{contents} are required. @xref{Section
|
|
Definition}, and @pxref{Section Contents} for details on @var{contents}.
|
|
The remaining elements---@var{start}, @code{BLOCK(@var{align)}},
|
|
@code{=@var{fill}}, and @code{>@var{region}}---are all optional.
|
|
|
|
@table @code
|
|
@item @var{start}
|
|
@cindex start address, section
|
|
@cindex section start
|
|
@cindex section address
|
|
You can force the output section to be loaded at a specified address by
|
|
specifying @var{start} immediately following the section name.
|
|
@var{start} can be represented as any expression. The following
|
|
example generates section @var{output} at location
|
|
@code{0x40000000}:
|
|
@example
|
|
SECTIONS @{
|
|
@dots{}
|
|
output 0x40000000: @{
|
|
@dots{}
|
|
@}
|
|
@dots{}
|
|
@}
|
|
@end example
|
|
|
|
@item BLOCK(@var{align})
|
|
@kindex BLOCK(@var{align})
|
|
@cindex section alignment
|
|
@cindex aligning sections
|
|
You can include @code{BLOCK()} specification to advance the location of
|
|
the location counter @code{.} prior to the beginning of the section, so
|
|
that the section will begin at the specified alignment. @var{align} is
|
|
an expression.
|
|
|
|
@item =@var{fill}
|
|
@kindex =@var{fill}
|
|
@cindex section fill pattern
|
|
@cindex fill pattern, entire section
|
|
You may use any expression to specify @var{fill}. Including
|
|
@code{=@var{fill}} in a section definition specifies the initial fill
|
|
value for that section. Any unallocated holes in the current output
|
|
section when written to the output file will be filled with the two
|
|
least significant bytes of the value, repeated as necessary. You can
|
|
also change the fill value with a @code{FILL} statement in the
|
|
@var{contents} of a section definition.
|
|
|
|
@item >@var{region}
|
|
@kindex >@var{region}
|
|
@cindex section, assigning to memory region
|
|
@cindex memory regions and sections
|
|
Assign this section to a previously defined region of memory.
|
|
@xref{MEMORY}.
|
|
|
|
@end table
|
|
|
|
@node Entry Point, Other Commands, SECTIONS, Commands
|
|
@section The Entry Point
|
|
@kindex ENTRY(@var{symbol})
|
|
@cindex start of execution
|
|
@cindex first instruction
|
|
The linker command language includes a command specifically for
|
|
defining the first executable instruction in an output file (its
|
|
@dfn{entry point}). Its argument is a symbol name:
|
|
@example
|
|
ENTRY(@var{symbol})
|
|
@end example
|
|
|
|
Like symbol assignments, the @code{ENTRY} command may be placed either
|
|
as an independent command in the command file, or among the section
|
|
definitions within the @code{SECTIONS} command---whatever makes the most
|
|
sense for your layout.
|
|
|
|
@cindex entry point, defaults
|
|
@code{ENTRY} is only one of several ways of choosing the entry point.
|
|
You may indicate it in any of the following ways (shown in descending
|
|
order of priority: methods higher in the list override methods lower down).
|
|
@itemize @bullet
|
|
@item
|
|
the @code{-e} @var{entry} command-line option;
|
|
@item
|
|
the @code{ENTRY(@var{symbol}} command in a linker control script;
|
|
@item
|
|
the value of the symbol @code{start}, if present;
|
|
@item
|
|
the value of the symbol @code{_main}, if present;
|
|
@item
|
|
the address of the first byte of the @code{.text} section, if present;
|
|
@item
|
|
The address @code{0}.
|
|
@end itemize
|
|
|
|
For example, you can use these rules to generate an entry point with an
|
|
assignment statement: if no symbol @code{start} is defined within your
|
|
input files, you can simply define it, assigning it an appropriate
|
|
value---
|
|
@example
|
|
start = 0x2020;
|
|
@end example
|
|
|
|
@noindent
|
|
The example shows an absolute address, but you can use any expression.
|
|
For example, if your input object files use some other symbol-name
|
|
convention for the entry point, you can just assign the value of
|
|
whatever symbol contains the start address to @code{start}:
|
|
@example
|
|
start = other_symbol;
|
|
@end example
|
|
|
|
@node Other Commands, , Entry Point, Commands
|
|
@section Other Commands
|
|
The command language includes a number of other commands that you can
|
|
use for specialized purposes. They are similar in purpose to
|
|
command-line options.
|
|
|
|
@table @code
|
|
@item FLOAT
|
|
@kindex FLOAT
|
|
@itemx NOFLOAT
|
|
@kindex NOFLOAT
|
|
These keywords were used in some older linkers to request a particular
|
|
math subroutine library. @code{gld} doesn't use the keywords, assuming
|
|
instead that any necessary subroutines are in libraries specified using
|
|
the general mechanisms for linking to archives; but to permit the use of
|
|
scripts that were written for the older linkers, the keywords
|
|
@code{FLOAT} and @code{NOFLOAT} are accepted and ignored.
|
|
|
|
@item FORCE_COMMON_ALLOCATION
|
|
@kindex FORCE_COMMON_ALLOCATION
|
|
@cindex common allocation
|
|
This command has the same effect as the @code{-d} command-line option:
|
|
to make @code{ld} assign space to common symbols even if a relocatable
|
|
output file is specified (@code{-r}).
|
|
|
|
@item HLL ( @var{file}, @var{file}, @dots{} )
|
|
@kindex HLL ( @var{files} )
|
|
@itemx HLL ( @var{file} @var{file} @dots{} )
|
|
@itemx HLL ( )
|
|
Include ``high-level libraries'' or archives as input files in the link.
|
|
Using @code{HLL(@var{file}} in a linker script is equivalent to
|
|
including @code{-l}@var{file} on the command line.
|
|
|
|
@cindex @code{lnk960} command @code{HLL}
|
|
The @code{HLL} command is only supported when @code{gld} emulates
|
|
@code{lnk960}, as specified by the @code{LDEMULATION} environment
|
|
variable.
|
|
|
|
@item INPUT ( @var{file}, @var{file}, @dots{} )
|
|
@kindex INPUT ( @var{files} )
|
|
@itemx INPUT ( @var{file} @var{file} @dots{} )
|
|
@cindex binary input files
|
|
Use this command to include binary input files in the link, without
|
|
including them in a particular section definition. Files specified this
|
|
way are treated identically to object files listed on the command line.
|
|
|
|
@ignore
|
|
@item MAP ( @var{name} )
|
|
@kindex MAP ( @var{name} )
|
|
@c MAP(...) appears to look for an F in the arg, ignoring all other
|
|
@c chars; if it finds one, it sets "map_option_f" to true. But nothing
|
|
@c checks map_option_f. Apparently a stub for the future...
|
|
@end ignore
|
|
|
|
@item OUTPUT ( @var{filename} )
|
|
@kindex OUTPUT ( @var{filename} )
|
|
@cindex naming the output file
|
|
Name the link output file @var{filename}. The effect of
|
|
@code{OUTPUT(@var{filename})} is identical to the effect of
|
|
@w{@code{-o @var{filename}}}, and whichever is encountered last will
|
|
control the name actually used to name the output file. In particular,
|
|
you can use this command to supply a default output-file name other than
|
|
@code{a.out}.
|
|
|
|
@item OUTPUT_ARCH ( @var{bfdname} )
|
|
@kindex OUTPUT_ARCH ( @var{bfdname} )
|
|
@cindex machine architecture, output
|
|
Specify a particular output machine architecture, with one of the names
|
|
used by the BFD back-end routines (@pxref{BFD}). This command is often
|
|
unnecessary; the architecture is most often set implicitly by either the
|
|
system BFD configuration or as a side effect of the @code{OUTPUT_FORMAT}
|
|
command. @refill
|
|
|
|
@item OUTPUT_FORMAT ( @var{bfdname} )
|
|
@kindex OUTPUT_FORMAT ( @var{bfdname} )
|
|
@cindex format, output file
|
|
Specify a particular output format, with one of the names used by the
|
|
BFD back-end routines (@pxref{BFD}). This selection will only affect
|
|
the output file; the related command @code{TARGET} affects primarily
|
|
input files.@refill
|
|
|
|
@item SEARCH_DIR ( @var{path} )
|
|
@kindex SEARCH_DIR ( @var{path} )
|
|
@cindex path for libraries
|
|
@cindex search path, libraries
|
|
Add @var{path} to the list of paths where @code{gld} looks for
|
|
archive libraries. @code{SEARCH_DIR(@var{path})} has the same
|
|
effect as @code{-L@var{path})} on the command line.
|
|
|
|
@item STARTUP ( @var{filename} )
|
|
@kindex STARTUP ( @var{filename} )
|
|
@cindex first input file
|
|
Ensure that @var{filename} is the first input file used in the link
|
|
process.
|
|
|
|
@item SYSLIB ( @var{file}, @var{file}, @dots{} )
|
|
@kindex SYSLIB ( @var{file}, @var{file}, @dots{} )
|
|
@itemx SYSLIB ( @var{file} @var{file} @dots{} )
|
|
Use the named @var{file}s as binary input files, searching for them in
|
|
the same list of paths as archives.
|
|
|
|
@cindex @code{lnk960} command @code{SYSLIB}
|
|
The @code{SYSLIB} command is only supported when @code{gld} emulates
|
|
@code{lnk960}, as specified by the @code{LDEMULATION} environment
|
|
variable.
|
|
|
|
@item TARGET ( @var{format} )
|
|
@cindex input file format
|
|
@kindex TARGET ( @var{format} )
|
|
Change the input-file object code format (like the command-line option
|
|
@code{-b} or its synonym @code{-format}). The argument @var{format} is
|
|
one of the strings used by BFD to name binary formats. In the current
|
|
@code{gld} implementation, if @code{TARGET} is specified but
|
|
@code{OUTPUT_FORMAT} is not, the last @code{TARGET} argument is also
|
|
used as the default format for the @code{gld} output file.
|
|
@xref{BFD}.@refill
|
|
|
|
@kindex GNUTARGET
|
|
If you don't use the @code{TARGET} command, @code{gld} uses the value of
|
|
the environment variable @code{GNUTARGET}, if available, to select the
|
|
output file format. If that variable is also absent, @code{gld} uses
|
|
the default format configured for your machine in the BFD libraries.
|
|
|
|
@end table
|
|
|
|
@node BFD, Index, Commands, Top
|
|
@chapter BFD
|
|
|
|
@cindex back end
|
|
@cindex object file management
|
|
The linker accesses object and archive files using the BFD libraries.
|
|
These libraries allow the linker to use the same routines to operate on
|
|
object files whatever the object file format. A different object file
|
|
format can be supported simply by creating a new BFD back end and adding
|
|
it to the library. BFD supports the following combinations of
|
|
architectures (row labels below) and object formats (column headings):
|
|
@cindex formats available
|
|
@cindex architectures available
|
|
@c TEXI2ROFF-KILL
|
|
@ifinfo
|
|
@c END TEXI2ROFF-KILL
|
|
@example
|
|
|ieee
|
|
| |oasys
|
|
| | |a.out-generic-little
|
|
| | | |a.out-generic-big
|
|
| | | | |m88kbcs
|
|
| | | | | |srec
|
|
| | | | | | |coff-Intel-little
|
|
| | | | | | | |coff-Intel-big
|
|
| | | | | | | | |b.out.little
|
|
| | | | | | | | | |b.out.big
|
|
| | | | | | | | | |
|
|
m68k|**|**| | | |**| | | |
|
|
vax|**|**| | | |**| | | |
|
|
i960|**|**| | | |**|**|**|**|**
|
|
a29k|**|**|**|**| |**| | | |
|
|
sparc|**|**|**|**| |**| | | |
|
|
mips|**|**| | | |**| | | |
|
|
i386|**|**|**|**| |**| | | |
|
|
ns32k|**|**| | | |**| | | |
|
|
tahoe|**|**| | | |**| | | |
|
|
i860|**|**| | | |**| | | |
|
|
romp|**|**| | | |**| | | |
|
|
alliant|**|**| | | |**| | | |
|
|
convex|**|**| | | |**| | | |
|
|
m88k|**|**| | |**|**| | | |
|
|
pyramid|**|**| | | |**| | | |
|
|
H8/300|**|**| | | |**| | | |
|
|
|
|
@end example
|
|
@c TEXI2ROFF-KILL
|
|
@end ifinfo
|
|
@tex
|
|
\def\sqbull{\vrule height12pt width 10pt depth 4pt}
|
|
\vskip\baselineskip
|
|
\vbox{\offinterlineskip
|
|
\halign
|
|
{\strut\hfil #\ &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em
|
|
&\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#&\hskip .5em #\hskip .5em &\vrule#\cr
|
|
&&\multispan{20}\quad\vbox{\hrule}\cr
|
|
&&\multispan{20}\quad\code{ieee}\hfil\cr
|
|
&& &&\multispan{18}\quad\code{oasys}\hfil\cr
|
|
&& && &&\multispan{16}\quad\code{a.out-generic-little}\hfil\cr
|
|
&& && && &&\multispan{14}\quad\code{a.out-generic-big}\hfil\cr
|
|
&& && && && &&\multispan{12}\quad\code{m88kbcs}\hfil\cr
|
|
&& && && && && &&\multispan{10}\quad\code{srec}\hfil\cr
|
|
&& && && && && && &&\multispan8\quad\code{coff-Intel-little}\hfil\cr
|
|
&& && && && && && && &&\multispan6\quad\code{coff-Intel-big}\hfil\cr
|
|
&& && && && && && && &&
|
|
&&\multispan4\quad\code{b.out.little}\hfil \cr
|
|
&& && && && && && && && && &&\multispan2\quad\code{b.out.big}\hidewidth\cr
|
|
\code{m68k}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{vax}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{i960}&&\sqbull&&\sqbull&& && && &&\sqbull&&\sqbull&&\sqbull&&\sqbull&&\sqbull &\cr
|
|
\code{a29k}&&\sqbull&&\sqbull&&\sqbull&&\sqbull&& &&\sqbull&& && && && &\cr
|
|
\code{sparc}&&\sqbull&&\sqbull&&\sqbull&&\sqbull&& &&\sqbull&& && && && &\cr
|
|
\code{mips}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{i386}&&\sqbull&&\sqbull&&\sqbull&&\sqbull&& &&\sqbull&& && && && &\cr
|
|
\code{ns32k}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{tahoe}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{i860}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{romp}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{alliant}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{convex}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{m88k}&&\sqbull&&\sqbull&& && &&\sqbull&&\sqbull&& && && && &\cr
|
|
\code{pyramid}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
\code{H8/300}&&\sqbull&&\sqbull&& && && &&\sqbull&& && && && &\cr
|
|
}}
|
|
@end tex
|
|
@c END TEXI2ROFF-KILL
|
|
|
|
@cindex BFD requirements
|
|
@cindex requirements for BFD
|
|
As with most implementations, BFD is a compromise between
|
|
several conflicting requirements. The major factor influencing
|
|
BFD design was efficiency: any time used converting between
|
|
formats is time which would not have been spent had BFD not
|
|
been involved. This is partly offset by abstraction payback; since
|
|
BFD simplifies applications and back ends, more time and care
|
|
may be spent optimizing algorithms for a greater speed.
|
|
|
|
One minor artifact of the BFD solution which you should bear in
|
|
mind is the potential for information loss. There are two places where
|
|
useful information can be lost using the BFD mechanism; during
|
|
conversion and during output. @xref{BFD information loss}.
|
|
|
|
@menu
|
|
* BFD outline:: How it works: an outline of BFD
|
|
* BFD information loss:: Information Loss
|
|
* Mechanism:: Mechanism
|
|
@end menu
|
|
|
|
@node BFD outline, BFD information loss, BFD, BFD
|
|
@section How it works: an outline of BFD
|
|
@cindex opening object files
|
|
When an object file is opened, BFD subroutines automatically
|
|
determine the format of the input object file, and build a descriptor in
|
|
memory with pointers to routines that will be used to access elements of
|
|
the object file's data structures.
|
|
|
|
As different information from the the object files is required
|
|
BFD reads from different sections of the file and processes them.
|
|
For example a very common operation for the linker is processing symbol
|
|
tables. Each BFD back end provides a routine for converting
|
|
between the object file's representation of symbols and an internal
|
|
canonical format. When the linker asks for the symbol table of an object
|
|
file, it calls through the memory pointer to the relevant BFD
|
|
back end routine which reads and converts the table into a canonical
|
|
form. The linker then operates upon the common form. When the link is
|
|
finished and the linker writes the symbol table of the output file,
|
|
another BFD back end routine is called which takes the newly
|
|
created symbol table and converts it into the chosen output format.
|
|
|
|
@node BFD information loss, Mechanism, BFD outline, BFD
|
|
@section Information Loss
|
|
@emph{Information can be lost during output.} The output formats
|
|
supported by BFD do not provide identical facilities, and
|
|
information which may be described in one form has nowhere to go in
|
|
another format. One example of this is alignment information in
|
|
@code{b.out}. There is nowhere in an @code{a.out} format file to store
|
|
alignment information on the contained data, so when a file is linked
|
|
from @code{b.out} and an @code{a.out} image is produced, alignment
|
|
information will not propagate to the output file. (The linker will
|
|
still use the alignment information internally, so the link is performed
|
|
correctly).
|
|
|
|
Another example is COFF section names. COFF files may contain an
|
|
unlimited number of sections, each one with a textual section name. If
|
|
the target of the link is a format which does not have many sections (eg
|
|
@code{a.out}) or has sections without names (eg the Oasys format) the
|
|
link cannot be done simply. You can circumvent this problem by
|
|
describing the desired input-to-output section mapping with the command
|
|
language.
|
|
|
|
@emph{Information can be lost during canonicalization.} The BFD
|
|
internal canonical form of the external formats is not exhaustive; there
|
|
are structures in input formats for which there is no direct
|
|
representation internally. This means that the BFD back ends
|
|
cannot maintain all possible data richness through the transformation
|
|
between external to internal and back to external formats.
|
|
|
|
This limitation is only a problem when using the linker to read one
|
|
format and write another. Each BFD back end is responsible for
|
|
maintaining as much data as possible, and the internal BFD
|
|
canonical form has structures which are opaque to the BFD core,
|
|
and exported only to the back ends. When a file is read in one format,
|
|
the canonical form is generated for BFD and the linker. At the
|
|
same time, the back end saves away any information which may otherwise
|
|
be lost. If the data is then written back in the same format, the back
|
|
end routine will be able to use the canonical form provided by the
|
|
BFD core as well as the information it prepared earlier. Since
|
|
there is a great deal of commonality between back ends, this mechanism
|
|
is very useful. There is no information lost for this reason when
|
|
linking big endian COFF to little endian COFF, or from @code{a.out} to
|
|
@code{b.out}. When a mixture of formats is linked, the information is
|
|
only lost from the files whose format differs from the destination.
|
|
|
|
@node Mechanism, , BFD information loss, BFD
|
|
@section Mechanism
|
|
The greatest potential for loss of information is when there is least
|
|
overlap between the information provided by the source format, that
|
|
stored by the canonical format, and the information needed by the
|
|
destination format. A brief description of the canonical form may help
|
|
you appreciate what kinds of data you can count on preserving across
|
|
conversions.
|
|
@cindex BFD canonical format
|
|
@cindex internal object-file format
|
|
|
|
@table @emph
|
|
@item files
|
|
Information on target machine architecture, particular implementation
|
|
and format type are stored on a per-file basis. Other information
|
|
includes a demand pageable bit and a write protected bit. Note that
|
|
information like Unix magic numbers is not stored here---only the magic
|
|
numbers' meaning, so a @code{ZMAGIC} file would have both the demand pageable
|
|
bit and the write protected text bit set.
|
|
|
|
The byte order of the target is stored on a per-file basis, so that big-
|
|
and little-endian object files may be linked with one another.
|
|
|
|
@item sections
|
|
Each section in the input file contains the name of the section, the
|
|
original address in the object file, various flags, size and alignment
|
|
information and pointers into other BFD data structures.
|
|
|
|
@item symbols
|
|
Each symbol contains a pointer to the object file which originally
|
|
defined it, its name, its value, and various flag bits. When a
|
|
BFD back end reads in a symbol table, the back end relocates all
|
|
symbols to make them relative to the base of the section where they were
|
|
defined. This ensures that each symbol points to its containing
|
|
section. Each symbol also has a varying amount of hidden data to contain
|
|
private data for the BFD back end. Since the symbol points to the
|
|
original file, the private data format for that symbol is accessible.
|
|
@code{gld} can operate on a collection of symbols of wildly different
|
|
formats without problems.
|
|
|
|
Normal global and simple local symbols are maintained on output, so an
|
|
output file (no matter its format) will retain symbols pointing to
|
|
functions and to global, static, and common variables. Some symbol
|
|
information is not worth retaining; in @code{a.out} type information is
|
|
stored in the symbol table as long symbol names. This information would
|
|
be useless to most COFF debuggers and may be thrown away with
|
|
appropriate command line switches. (The GNU debugger @code{gdb} does
|
|
support @code{a.out} style debugging information in COFF).
|
|
|
|
There is one word of type information within the symbol, so if the
|
|
format supports symbol type information within symbols (for example COFF,
|
|
IEEE, Oasys) and the type is simple enough to fit within one word
|
|
(nearly everything but aggregates) the information will be preserved.
|
|
|
|
@item relocation level
|
|
Each canonical BFD relocation record contains a pointer to the symbol to
|
|
relocate to, the offset of the data to relocate, the section the data
|
|
is in and a pointer to a relocation type descriptor. Relocation is
|
|
performed effectively by message passing through the relocation type
|
|
descriptor and symbol pointer. It allows relocations to be performed
|
|
on output data using a relocation method only available in one of the
|
|
input formats. For instance, Oasys provides a byte relocation format.
|
|
A relocation record requesting this relocation type would point
|
|
indirectly to a routine to perform this, so the relocation may be
|
|
performed on a byte being written to a COFF file, even though 68k COFF
|
|
has no such relocation type.
|
|
|
|
@item line numbers
|
|
Object formats can contain, for debugging purposes, some form of mapping
|
|
between symbols, source line numbers, and addresses in the output file.
|
|
These addresses have to be relocated along with the symbol information.
|
|
Each symbol with an associated list of line number records points to the
|
|
first record of the list. The head of a line number list consists of a
|
|
pointer to the symbol, which allows divination of the address of the
|
|
function whose line number is being described. The rest of the list is
|
|
made up of pairs: offsets into the section and line numbers. Any format
|
|
which can simply derive this information can pass it successfully
|
|
between formats (COFF, IEEE and Oasys).
|
|
@end table
|
|
|
|
@node Index, , BFD, Top
|
|
@unnumbered Index
|
|
|
|
@printindex cp
|
|
|
|
@tex
|
|
% I think something like @colophon should be in texinfo. In the
|
|
% meantime:
|
|
\long\def\colophon{\hbox to0pt{}\vfill
|
|
\centerline{The body of this manual is set in}
|
|
\centerline{\fontname\tenrm,}
|
|
\centerline{with headings in {\bf\fontname\tenbf}}
|
|
\centerline{and examples in {\tt\fontname\tentt}.}
|
|
\centerline{{\it\fontname\tenit\/} and}
|
|
\centerline{{\sl\fontname\tensl\/}}
|
|
\centerline{are used for emphasis.}\vfill}
|
|
\page\colophon
|
|
% Blame: pesch@cygnus.com, 28mar91.
|
|
@end tex
|
|
|
|
|
|
@contents
|
|
@bye
|
|
|
|
|