=pod

=head1 NAME

opt - LLVM optimizer

=head1 SYNOPSIS

B<opt> [I<options>] [I<filename>]

=head1 DESCRIPTION

The B<opt> command is the modular LLVM optimizer and analyzer.  It takes LLVM 
bytecode as input, runs the specified optimizations or analyses on it, and then
outputs the optimized LLVM bytecode or the analysis results.  The function of 
B<opt> depends on whether the B<-analyze> option is given. 

When B<-analyze> is specified, B<opt> performs various analyses of LLVM 
bytecode.  It will usually print the results on standard output, but in a few 
cases, it will print output to standard error or generate a file with the 
analysis output, which is usually done when the output is meant for another 
program.  

While B<-analyze> is I<not> given, B<opt> attempts to produce an optimized 
bytecode file.  The optimizations available via B<opt> depend upon what 
libraries were linked into it as well as any additional libraries that have 
been loaded with the B<-load> option.  Use the B<-help> option to determine 
what optimizations you can use.

If I<filename> is omitted from the command line or is I<->, B<opt> reads its
input from standard input. The input must be an LLVM bytecode file.

If an output filename is not specified with the B<-o> option, B<opt>
writes its output to the standard output.

=head1 OPTIONS

=over

=item B<-f>

Force overwrite.  Normally, B<opt> will refuse to overwrite an
output file that already exists.  With this option, B<opt> will
overwrite the output file and replace it with new bytecode.

=item B<-help>

Print a summary of command line options.

=item B<-o> I<filename>

Specify the output filename.

=item B<-profile-info-file> I<filename>

Specify the name of the file loaded by the -profile-loader option.

=item B<-stats>

Print statistics.

=item B<-time-passes>

Record the amount of time needed for each pass and print it to standard
error.

=item B<-debug>

If this is a debug build, this option will enable debug printouts
from passes which use the I<DEBUG()> macro.  See the B<LLVM Programmer's
Manual>, section I<#DEBUG> for more information.

=item B<-load>=I<plugin>

Load the dynamic object I<plugin>.  This object should register new optimization
or analysis passes. Once loaded, the object will add new command line options to
enable various optimizations or analyses.  To see the new complete list of 
optimizations, use the B<-help> and B<-load> options together. For example:

=over

B<opt -load>=I<plugin> B<-help>

=back

=item B<-p>

Print module after each transformation.

=back

=head1 EXIT STATUS

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

=head1 AUTHORS

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

=cut
