=head1 DESCRIPTION
-The B<llc> command compiles LLVM bytecode into assembly language for a
+The B<llc> command compiles LLVM bitcode into assembly language for a
specified architecture. The assembly language output can then be passed through
a native assembler and linker to generate a native executable.
The choice of architecture for the output assembly code is automatically
-determined from the input bytecode file, unless the B<-march> option is used to
+determined from the input bitcode file, unless the B<-march> option is used to
override the default.
=head1 OPTIONS
-If I<filename> is - or omitted, B<llc> reads LLVM bytecode from standard input.
-Otherwise, it will read LLVM bytecode from I<filename>.
+If I<filename> is - or omitted, B<llc> reads LLVM bitcode from standard input.
+Otherwise, it will read LLVM bitcode from I<filename>.
If the B<-o> option is omitted, then B<llc> will send its output to standard
output if the input is from standard input. If the B<-o> option specifies -,
=item B<-mtriple>=I<target triple>
-Override the target triple specified in the input bytecode file with the
+Override the target triple specified in the input bitcode file with the
specified string.
=item B<-march>=I<arch>
Specify the architecture for which to generate assembly, overriding the target
-encoded in the bytecode file. See the output of B<llc --help> for a list of
+encoded in the bitcode file. See the output of B<llc --help> for a list of
valid architectures. By default this is inferred from the target triple or
autodetected to the current architecture.
=head1 NAME
-lli - directly execute programs from LLVM bytecode
+lli - directly execute programs from LLVM bitcode
=head1 SYNOPSIS
=head1 DESCRIPTION
-B<lli> directly executes programs in LLVM bytecode format. It takes a program
-in LLVM bytecode format and executes it using a just-in-time compiler, if one is
+B<lli> directly executes programs in LLVM bitcode format. It takes a program
+in LLVM bitcode format and executes it using a just-in-time compiler, if one is
available for the current architecture, or an interpreter. B<lli> takes all of
the same code generator options as L<llc|llc>, but they are only effective when
B<lli> is using the just-in-time compiler.
-If I<filename> is not specified, then B<lli> reads the LLVM bytecode for the
+If I<filename> is not specified, then B<lli> reads the LLVM bitcode for the
program from standard input.
The optional I<args> specified on the command line are passed to the program as
=item B<-mtriple>=I<target triple>
-Override the target triple specified in the input bytecode file with the
+Override the target triple specified in the input bitcode file with the
specified string. This may result in a crash if you pick an
architecture which is not compatible with the current system.
=item B<-march>=I<arch>
Specify the architecture for which to generate assembly, overriding the target
-encoded in the bytecode file. See the output of B<llc --help> for a list of
+encoded in the bitcode file. See the output of B<llc --help> for a list of
valid architectures. By default this is inferred from the target triple or
autodetected to the current architecture.
The B<llvm-ar> command is similar to the common Unix utility, C<ar>. It
archives several files together into a single file. The intent for this is
-to produce archive libraries by LLVM bytecode that can be linked into an
+to produce archive libraries by LLVM bitcode that can be linked into an
LLVM program. However, the archive can contain any kind of file. By default,
B<llvm-ar> generates a symbol table that makes linking faster because
only the symbol table needs to be consulted, not each individual file member
=item I<Symbol Table>
-Since B<llvm-ar> is intended to archive bytecode files, the symbol table
+Since B<llvm-ar> is intended to archive bitcode files, the symbol table
won't make much sense to anything but LLVM. Consequently, the symbol table's
format has been simplified. It consists simply of a sequence of pairs
of a file member index number as an LSB 4byte integer and a null-terminated
When B<llvm-ar> prints out the verbose table of contents (C<tv> option), it
precedes the usual output with a character indicating the basic kind of
content in the file. A blank means the file is a regular file. A 'Z' means
-the file is compressed. A 'B' means the file is an LLVM bytecode file. An
+the file is compressed. A 'B' means the file is an LLVM bitcode file. An
'S' means the file is the symbol table.
=back
Print files to the standard output. The F<k> modifier applies to this
operation. This operation simply prints the F<files> indicated to the
standard output. If no F<files> are specified, the entire archive is printed.
-Printing bytecode files is ill-advised as they might confuse your terminal
+Printing bitcode files is ill-advised as they might confuse your terminal
settings. The F<p> operation never modifies the archive.
=item q[Rfz]
Print the table of contents. Without any modifiers, this operation just prints
the names of the members to the standard output. With the F<v> modifier,
-B<llvm-ar> also prints out the file type (B=bytecode, Z=compressed, S=symbol
+B<llvm-ar> also prints out the file type (B=bitcode, Z=compressed, S=symbol
table, blank=regular file), the permission mode, the owner and group, the
size, and the date. If any F<files> are specified, the listing is only for
those files. If no F<files> are specified, the table of contents for the
=item [k]
-Normally, B<llvm-ar> will not print the contents of bytecode files when the
+Normally, B<llvm-ar> will not print the contents of bitcode files when the
F<p> operation is used. This modifier defeats the default and allows the
-bytecode members to be printed.
+bitcode members to be printed.
=item [N]
When inserting or replacing any file in the archive, compress the file first.
This
-modifier is safe to use when (previously) compressed bytecode files are added to
-the archive; the compressed bytecode files will not be doubly compressed.
+modifier is safe to use when (previously) compressed bitcode files are added to
+the archive; the compressed bitcode files will not be doubly compressed.
=back
This modifier requests that an archive index (or symbol table) be added to the
archive. This is the default mode of operation. The symbol table will contain
all the externally visible functions and global variables defined by all the
-bytecode files in the archive. Using this modifier is more efficient that using
+bitcode files in the archive. Using this modifier is more efficient that using
L<llvm-ranlib|llvm-ranlib> which also creates the symbol table.
=item [S]
=item offset - vbr encoded 32-bit integer
-The offset item provides the offset into the archive file where the bytecode
+The offset item provides the offset into the archive file where the bitcode
member is stored that is associated with the symbol. The offset value is 0
based at the start of the first "normal" file member. To derive the actual
file offset of the member, you must add the number of bytes occupied by the file
=head1 DESCRIPTION
B<llvm-as> is the LLVM assembler. It reads a file containing human-readable
-LLVM assembly language, translates it to LLVM bytecode, and writes the result
+LLVM assembly language, translates it to LLVM bitcode, and writes the result
into a file or to standard output.
If F<filename> is omitted or is C<->, then B<llvm-as> reads its input from
Force overwrite. Normally, B<llvm-as> will refuse to overwrite an
output file that already exists. With this option, B<llvm-as>
-will overwrite the output file and replace it with new bytecode.
+will overwrite the output file and replace it with new bitcode.
=item B<--help>
=item B<engine>
-Includes either a native JIT or the bytecode interpreter.
+Includes either a native JIT or the bitcode interpreter.
=back
=head1 DESCRIPTION
The B<llvm-dis> command is the LLVM disassembler. It takes an LLVM
-bytecode file and converts it into human-readable LLVM assembly language.
+bitcode file and converts it into human-readable LLVM assembly language.
If filename is omitted or specified as C<->, B<llvm-dis> reads its
input from standard input.
=head1 DESCRIPTION
The B<llvm-extract> command takes the name of a function and extracts it from
-the specified LLVM bytecode file. It is primarily used as a debugging tool to
+the specified LLVM bitcode file. It is primarily used as a debugging tool to
reduce test cases from larger programs that are triggering a bug.
-In addition to extracting the bytecode of the specified function,
+In addition to extracting the bitcode of the specified function,
B<llvm-extract> will also remove unreachable global variables, prototypes, and
unused types.
Force overwrite. Normally, B<llvm-extract> will refuse to overwrite an
output file that already exists. With this option, B<llvm-extract>
-will overwrite the output file and replace it with new bytecode.
+will overwrite the output file and replace it with new bitcode.
=item B<--func> I<function-name>
-Extract the function named I<function-name> from the LLVM bytecode.
+Extract the function named I<function-name> from the LLVM bitcode.
=item B<--help>
=head1 DESCRIPTION
-The B<llvm-ld> tool takes a set of LLVM bytecode files and links them
-together into a single LLVM bytecode file. The output bytecode file can be
-another bytecode file or an executable bytecode program. Using additional
+The B<llvm-ld> tool takes a set of LLVM bitcode files and links them
+together into a single LLVM bitcode file. The output bitcode file can be
+another bitcode file or an executable bitcode program. Using additional
options, B<llvm-ld> is able to produce native code executables.
The B<llvm-ld> tool is the main linker for LLVM. It is used to link together
=head2 Link order
-All object and bytecode files are linked first in the order they were
+All object and bitcode files are linked first in the order they were
specified on the command line. All library files are linked next.
Some libraries may not be linked into the object program; see below.
=head2 Library Linkage
-Object files and static bytecode objects are always linked into the output
+Object files and static bitcode objects are always linked into the output
file. Library archives (.a files) load only the objects within the archive
that define symbols needed by the output file. Hence, libraries should be
listed after the object files and libraries which need them; otherwise, the
The B<llvm-ld> program has limited support for native code generation, when
using the B<-native> or B<-native-cbe> options. Native code generation is
-performed by converting the linked bytecode into native assembly (.s) or C code
+performed by converting the linked bitcode into native assembly (.s) or C code
and running the system compiler (typically gcc) on the result.
=head1 OPTIONS
=item B<-link-as-library>
-Link the bytecode files together as a library, not an executable. In this mode,
+Link the bitcode files together as a library, not an executable. In this mode,
undefined symbols will be permitted.
=item B<-r>
Generate a native machine code executable.
-When generating native executables, B<llvm-ld> first checks for a bytecode
+When generating native executables, B<llvm-ld> first checks for a bitcode
version of the library and links it in, if necessary. If the library is
missing, B<llvm-ld> skips it. Then, B<llvm-ld> links in the same
libraries as native code.
-In this way, B<llvm-ld> should be able to link in optimized bytecode
+In this way, B<llvm-ld> should be able to link in optimized bitcode
subsets of common libraries and then link in any part of the library that
-hasn't been converted to bytecode.
+hasn't been converted to bitcode.
=item B<-native-cbe>
=item B<-post-link-opt>F<Path>
-Run post-link optimization program. After linking is completed a bytecode file
+Run post-link optimization program. After linking is completed a bitcode file
will be generated. It will be passed to the program specified by F<Path> as the
first argument. The second argument to the program will be the name of a
temporary file into which the program should place its optimized output. For
=head1 ENVIRONMENT
-The C<LLVM_LIB_SEARCH_PATH> environment variable is used to find bytecode
+The C<LLVM_LIB_SEARCH_PATH> environment variable is used to find bitcode
libraries. Any paths specified in this variable will be searched after the C<-L>
options.
=head1 DESCRIPTION
-B<llvm-link> takes several LLVM bytecode files and links them together into a
-single LLVM bytecode file. It writes the output file to standard output, unless
+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
=item B<-d>
If specified, B<llvm-link> prints a human-readable version of the output
-bytecode file to standard error.
+bitcode file to standard error.
=item B<--help>
=item B<-v>
Verbose mode. Print information about what B<llvm-link> is doing. This
-typically includes a message for each bytecode file linked in and for each
+typically includes a message for each bitcode file linked in and for each
library found.
=back
=head1 NAME
-llvm-nm - list LLVM bytecode file's symbol table
+llvm-nm - list LLVM bitcode file's symbol table
=head1 SYNOPSIS
=head1 DESCRIPTION
-The B<llvm-nm> utility lists the names of symbols from the LLVM bytecode files,
-or B<ar> archives containing LLVM bytecode files, named on the command line.
+The B<llvm-nm> utility lists the names of symbols from the LLVM bitcode files,
+or B<ar> archives containing LLVM bitcode files, named on the command line.
Each symbol is listed along with some simple information about its provenance.
If no file name is specified, or I<-> is used as a file name, B<llvm-nm> will
-process a bytecode file on its standard input stream.
+process a bitcode file on its standard input stream.
B<llvm-nm>'s default output format is the traditional BSD B<nm> output format.
Each such output record consists of an (optional) 8-digit hexadecimal address,
=item U
-Named object is referenced but undefined in this bytecode file
+Named object is referenced but undefined in this bitcode file
=item C
=back
-Because LLVM bytecode files typically contain objects that are not considered to
+Because LLVM bitcode files typically contain objects that are not considered to
have addresses until they are linked into an executable image or dynamically
compiled "just-in-time", B<llvm-nm> does not print an address for any symbol,
-even symbols which are defined in the bytecode file.
+even symbols which are defined in the bitcode file.
=head1 OPTIONS
=item B<--defined-only>
-Print only symbols defined in this bytecode file (as opposed to
+Print only symbols defined in this bitcode file (as opposed to
symbols which may be referenced by objects in this file, but not
defined in this file.)
=item B<--extern-only>, B<-g>
Print only symbols whose definitions are external; that is, accessible
-from other bytecode files.
+from other bitcode files.
=item B<--undefined-only>, B<-u>
-Print only symbols referenced but not defined in this bytecode file.
+Print only symbols referenced but not defined in this bitcode file.
=item B<--format=>I<fmt>, B<-f>
=head1 SYNOPSIS
-B<llvm-prof> [I<options>] [I<bytecode file>] [I<llvmprof.out>]
+B<llvm-prof> [I<options>] [I<bitcode file>] [I<llvmprof.out>]
=head1 DESCRIPTION
The B<llvm-prof> tool reads in an F<llvmprof.out> file (which can
-optionally use a specific file with the third program argument), a bytecode file
+optionally use a specific file with the third program argument), a bitcode file
for the program, and produces a human readable report, suitable for determining
where the program hotspots are.
=head1 EXIT STATUS
-B<llvm-prof> returns 1 if it cannot load the bytecode file or the profile
+B<llvm-prof> returns 1 if it cannot load the bitcode file or the profile
information. Otherwise, it exits with zero.
=head1 AUTHOR
adds or updates the symbol table in an LLVM archive file. Note that using the
B<llvm-ar> modifier F<s> is usually more efficient than running B<llvm-ranlib>
which is only provided only for completness and compatibility. Unlike other
-implementations of C<ranlib>, B<llvm-ranlib> indexes LLVM bytecode files, not
+implementations of C<ranlib>, B<llvm-ranlib> indexes LLVM bitcode files, not
native object modules. You can list the contents of the symbol table with the
C<llvm-nm -s> command.
=head1 NAME
-llvm2xpp - LLVM bytecode to LLVM C++ IR translator
+llvm2xpp - LLVM bitcode to LLVM C++ IR translator
=head1 SYNOPSIS
=head1 DESCRIPTION
-B<llvm2cpp> translates from LLVM bytecode (.bc files) to a
+B<llvm2cpp> translates from LLVM bitcode (.bc files) to a
corresponding C++ source file that will make calls against the LLVM C++ API to
build the same module as the input. By default, the C++ output is a complete
program that builds the module, verifies it and then emits the module as
=item * Pre-processing: gathering/filtering compiler input (optional).
-=item * Translation: source language to bytecode conversion.
+=item * Translation: source language to bitcode conversion.
-=item * Assembly: bytecode to native code conversion.
+=item * Assembly: bitcode to native code conversion.
-=item * Optimization: conversion of bytecode to something that runs faster.
+=item * Optimization: conversion of bitcode to something that runs faster.
-=item * Linking: combining multiple bytecodes to produce executable program.
+=item * Linking: combining multiple bitcode files to produce executable program.
=back
This option specifies that the linking phase is not to be run. All
previous phases, if applicable will run. This is generally how a given
-bytecode file is compiled and optimized for a source language module.
+bitcode file is compiled and optimized for a source language module.
=item B<-k> or B<--link> or default
=item B<--native>
-Normally, B<llvmc> produces bytecode files at most stages of compilation.
+Normally, B<llvmc> produces bitcode files at most stages of compilation.
With this option, B<llvmc> will arrange for native object files to be
generated with the B<-c> option, native assembly files to be generated
with the B<-S> option, and native executables to be generated with the
The B<llvm-gcc> command is the LLVM C front end. It is a modified
version of gcc that compiles C/ObjC programs into native objects, LLVM
-bytecode or LLVM assembly language, depending upon the options.
+bitcode or LLVM assembly language, depending upon the options.
By default, B<llvm-gcc> compiles to native objects just like GCC does. If the
-B<-emit-llvm> option is given then it will generate LLVM bytecode files instead.
+B<-emit-llvm> option is given then it will generate LLVM bitcode files instead.
If B<-S> (assembly) is also given, then it will generate LLVM assembly.
Being derived from the GNU Compiler Collection, B<llvm-gcc> has many
=item B<-S>
-Do not generate an LLVM bytecode file. Rather, compile the source
+Do not generate an LLVM bitcode file. Rather, compile the source
file into an LLVM assembly language file.
=item B<-c>
Do not generate a linked executable. Rather, compile the source
-file into an LLVM bytecode file. This bytecode file can then be
-linked with other bytecode files later on to generate a full LLVM
+file into an LLVM bitcode file. This bitcode file can then be
+linked with other bitcode files later on to generate a full LLVM
executable.
=item B<-o> I<filename>
=item B<-l>I<name>
Link in the library libI<name>.[bc | a | so]. This library should
-be a bytecode library.
+be a bitcode library.
=item B<-emit-llvm>
-Make the output be LLVM bytecode (or assembly) instead of native object (or
+Make the output be LLVM bitcode (or assembly) instead of native object (or
assembly).
=back
The B<llvm-g++> command is the LLVM C++ front end. It is a modified
version of g++ that compiles C++/ObjC++ programs into native code,
-LLVM bytecode or assembly language, depending upon the options.
+LLVM bitcode or assembly language, depending upon the options.
By default, B<llvm-g++> compiles to native objects just like GCC does. If the
-B<-emit-llvm> option is given then it will generate LLVM bytecode files instead.
+B<-emit-llvm> option is given then it will generate LLVM bitcode files instead.
If B<-S> (assembly) is also given, then it will generate LLVM assembly.
Being derived from the GNU Compiler Collection, B<llvm-g++> has many
=item B<-S>
-Do not generate an LLVM bytecode file. Rather, compile the source
+Do not generate an LLVM bitcode file. Rather, compile the source
file into an LLVM assembly language file.
=item B<-c>
Do not generate a linked executable. Rather, compile the source
-file into an LLVM bytecode file. This bytecode file can then be
-linked with other bytecode files later on to generate a full LLVM
+file into an LLVM bitcode file. This bitcode file can then be
+linked with other bitcode files later on to generate a full LLVM
executable.
=item B<-o> I<filename>
=item B<-l>I<name>
Link in the library libI<name>.[bc | a | so]. This library should
-be a bytecode library.
+be a bitcode library.
=item B<-emit-llvm>
-Make the output be LLVM bytecode (or assembly) instead of native object (or
+Make the output be LLVM bitcode (or assembly) instead of native object (or
assembly).
=back
=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
+bitcode as input, runs the specified optimizations or analyses on it, and then
+outputs the optimized LLVM bitcode 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
+bitcode. 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
+bitcode 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.
+input from standard input. The input must be an LLVM bitcode file.
If an output filename is not specified with the B<-o> option, B<opt>
writes its output to the standard output.
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.
+overwrite the output file and replace it with new bitcode.
=item B<-help>
simple stack based, Forth-like language that was written as a demonstration
language for LLVM. For details on the language, please see
L<http://llvm.org/docs/Stacker.html> . The B<stkrc> compiler is fairly
-minimal. It compiles to bytecode only and doesn't perform any optimizations.
-The output of stkrc (a bytecode file) can be piped through other LLVM tools
+minimal. It compiles to bitcode only and doesn't perform any optimizations.
+The output of stkrc (a bitcode file) can be piped through other LLVM tools
for optimization and linking.
If F<filename> is omitted or is C<->, then B<stkrc> reads its input
=item B<-f>
Force the output to be written. Normally, B<stkrc> won't overwrite an existing
-bytecode file. This option overrides that behavior.
+bitcode file. This option overrides that behavior.
=item B<-s> F<stacksize>
projects / oota-llvm.git / commitdiff