=pod

=head1 NAME

llvm-link - LLVM linker

=head1 SYNOPSIS

B<llvm-link> [I<options>] I<filename ...>

=head1 DESCRIPTION

B<llvm-link> takes several LLVM bitcode files and links them together into a
single LLVM bitcode file.  It writes the output file to standard output, unless
the B<-o> option is used to specify a filename.

B<llvm-link> attempts to load the input files from the current directory.  If
that fails, it looks for each file in each of the directories specified by the
B<-L> options on the command line.  The library search paths are global; each
one is searched for every input file if necessary.  The directories are searched
in the order they were specified on the command line.

=head1 OPTIONS

=over

=item B<-L> F<directory>

Add the specified F<directory> to the library search path.  When looking for
libraries, B<llvm-link> will look in path name for libraries.  This option can be
specified multiple times; B<llvm-link> will search inside these directories in
the order in which they were specified on the command line.

=item B<-f>

Enable binary output on terminals.  Normally, B<llvm-link> will refuse to
write raw bitcode output if the output stream is a terminal. With this option,
B<llvm-link> will write raw bitcode regardless of the output device.

=item B<-o> F<filename>

Specify the output file name.  If F<filename> is C<->, then B<llvm-link> will
write its output to standard output.

=item B<-S>

Write output in LLVM intermediate language (instead of bitcode).

=item B<-d>

If specified, B<llvm-link> prints a human-readable version of the output
bitcode file to standard error.

=item B<-help>

Print a summary of command line options.

=item B<-v>

Verbose mode.  Print information about what B<llvm-link> is doing.  This
typically includes a message for each bitcode file linked in and for each
library found.

=back

=head1 EXIT STATUS

If B<llvm-link> succeeds, it will exit with 0.  Otherwise, if an error
occurs, it will exit with a non-zero value.

=head1 SEE ALSO

L<gccld|gccld>

=head1 AUTHORS

Maintained by the LLVM Team (L<http://llvm.org/>).

=cut
