=pod

=head1 NAME

llvm-config - Print LLVM compilation options

=head1 SYNOPSIS

B<llvm-config> I<option> [I<components>...]

=head1 DESCRIPTION

B<llvm-config> makes it easier to build applications that use LLVM.  It can
print the compiler flags, linker flags and object libraries needed to link
against LLVM.

=head1 EXAMPLES

To link against the JIT:

  g++ `llvm-config --cxxflags` -o HowToUseJIT.o -c HowToUseJIT.cpp
  g++ `llvm-config --ldflags` -o HowToUseJIT HowToUseJIT.o \
      `llvm-config --libs engine bcreader scalaropts`

=head1 OPTIONS

=over

=item B<--version>

Print the version number of LLVM.

=item B<-help>

Print a summary of B<llvm-config> arguments.

=item B<--prefix>

Print the installation prefix for LLVM.

=item B<--src-root>

Print the source root from which LLVM was built.

=item B<--obj-root>

Print the object root used to build LLVM.

=item B<--bindir>

Print the installation directory for LLVM binaries.

=item B<--includedir>

Print the installation directory for LLVM headers.

=item B<--libdir>

Print the installation directory for LLVM libraries.

=item B<--cxxflags>

Print the C++ compiler flags needed to use LLVM headers.

=item B<--ldflags>

Print the flags needed to link against LLVM libraries.

=item B<--libs>

Print all the libraries needed to link against the specified LLVM
I<components>, including any dependencies.

=item B<--libnames>

Similar to B<--libs>, but prints the bare filenames of the libraries
without B<-l> or pathnames.  Useful for linking against a not-yet-installed
copy of LLVM.

=item B<--libfiles>

Similar to B<--libs>, but print the full path to each library file.  This is
useful when creating makefile dependencies, to ensure that a tool is relinked if
any library it uses changes.

=item B<--components>

Print all valid component names.

=item B<--targets-built>

Print the component names for all targets supported by this copy of LLVM.

=item B<--build-mode>

Print the build mode used when LLVM was built (e.g. Debug or Release)

=back

=head1 COMPONENTS

To print a list of all available components, run B<llvm-config
--components>.  In most cases, components correspond directly to LLVM
libraries.  Useful "virtual" components include:

=over

=item B<all>

Includes all LLVM libaries.  The default if no components are specified.

=item B<backend>

Includes either a native backend or the C backend.

=item B<engine>

Includes either a native JIT or the bitcode interpreter.

=back

=head1 EXIT STATUS

If B<llvm-config> 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
