thr3ads.net - llvm dev - [LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode" [Jul 2007]

If this information is useful, please help other people find it:
Share via:

Gabor Greif

2007-Jul-05 10:44 UTC

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

Here is the bulk of the sanitizing.

My residual doubts center around the question
whether we still do/want to support (un)compressed *byte*code
in 2.0/2.1.

I need a definitive word on this to proceed.

My understanding is that bytecode is already gone, but there are
still some functions/enums that really deal with *byte*code
(instead of *bit*code).

I did not touch those areas, so the attached patch is
for review about the IMO undisputed changes.

What is still missing:

- removing any genuine bytecode stuff (magic/filetype detection, etc.)
- Configury/Makefiles related sanitizing
- doc changes (.pod and .html files)
- anything else grep comes up with (should be next to nothing)


If anybody feels the urge to review the attached patch, feel free
and concentrate on Path.h/cpp and friends.

I plan to commit this late today or tomorrow (given that all the tests pass).

Then I proceed with my plan.

Cheers,

	Gabor
-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: bitcode-changes.diff
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20070705/058edde1/attachment.ksh>

Reid Spencer

2007-Jul-05 14:48 UTC

head link

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

Hi Gabor,

I scanned the patches quickly.  Looks right to me.

Reid.

On Thu, 2007-07-05 at 12:44 +0200, Gabor Greif wrote:> Here is the bulk of the sanitizing.
> 
> My residual doubts center around the question
> whether we still do/want to support (un)compressed *byte*code
> in 2.0/2.1.
> 
> I need a definitive word on this to proceed.
> 
> My understanding is that bytecode is already gone, but there are
> still some functions/enums that really deal with *byte*code
> (instead of *bit*code).
> 
> I did not touch those areas, so the attached patch is
> for review about the IMO undisputed changes.
> 
> What is still missing:
> 
> - removing any genuine bytecode stuff (magic/filetype detection, etc.)
> - Configury/Makefiles related sanitizing
> - doc changes (.pod and .html files)
> - anything else grep comes up with (should be next to nothing)
> 
> 
> If anybody feels the urge to review the attached patch, feel free
> and concentrate on Path.h/cpp and friends.
> 
> I plan to commit this late today or tomorrow (given that all the tests
pass).
> 
> Then I proceed with my plan.
> 
> Cheers,
> 
> 	Gabor
> plain text document attachment (bitcode-changes.diff)
> Index: include/llvm/Analysis/ConstantsScanner.h
> ==================================================================> ---
include/llvm/Analysis/ConstantsScanner.h	(revision 37888)
> +++ include/llvm/Analysis/ConstantsScanner.h	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This class implements an iterator to walk through the constants
referenced by
> -// a method.  This is used by the Bytecode & Assembly writers to build
constant
> +// a method.  This is used by the Bitcode & Assembly writers to build
constant
>  // pools.
>  //
> 
//===----------------------------------------------------------------------===//
> Index: include/llvm/Linker.h
> ==================================================================> ---
include/llvm/Linker.h	(revision 37888)
> +++ include/llvm/Linker.h	(working copy)
> @@ -28,7 +28,7 @@
>  /// In this case the Linker still retains ownership of the Module. If the
>  /// releaseModule() method is used, the ownership of the Module is
transferred
>  /// to the caller and the Linker object is only suitable for destruction.
> -/// The Linker can link Modules from memory, bytecode files, or bytecode
> +/// The Linker can link Modules from memory, bitcode files, or bitcode
>  /// archives.  It retains a set of search paths in which to find any
libraries
>  /// presented to it. By default, the linker will generate error and
warning
>  /// messages to std::cerr but this capability can be turned off with the
> @@ -162,10 +162,10 @@
>        ItemList& NativeItems  ///< Output list of native files/libs
>      );
>  
> -    /// This function links the bytecode \p Files into the composite
module.
> +    /// This function links the bitcode \p Files into the composite
module.
>      /// Note that this does not do any linking of unresolved symbols. The
\p
>      /// Files are all completely linked into \p HeadModule regardless of
> -    /// unresolved symbols. This function just loads each bytecode file
and
> +    /// unresolved symbols. This function just loads each bitcode file and
>      /// calls LinkInModule on them.
>      /// @returns true if an error occurs, false otherwise
>      /// @see getLastError
> @@ -174,9 +174,9 @@
>        const std::vector<sys::Path> & Files ///< Files to link
in
>      );
>  
> -    /// This function links a single bytecode file, \p File, into the
composite
> +    /// This function links a single bitcode file, \p File, into the
composite
>      /// module. Note that this does not attempt to resolve symbols. This
method
> -    /// just loads the bytecode file and calls LinkInModule on it. If an
error
> +    /// just loads the bitcode file and calls LinkInModule on it. If an
error
>      /// occurs, the Linker's error string is set.
>      /// @returns true if an error occurs, false otherwise
>      /// @see getLastError
> @@ -216,7 +216,7 @@
>        bool& is_native             ///< Indicates if lib a native
library
>      );
>  
> -    /// This function links one bytecode archive, \p Filename, into the
module.
> +    /// This function links one bitcode archive, \p Filename, into the
module.
>      /// The archive is searched to resolve outstanding symbols. Any
modules in
>      /// the archive that resolve outstanding symbols will be linked in.
The
>      /// library is searched repeatedly until no more modules that resolve
> @@ -271,7 +271,7 @@
>    /// @name Implementation
>    /// @{
>    private:
> -    /// Read in and parse the bytecode file named by FN and return the
> +    /// Read in and parse the bitcode file named by FN and return the
>      /// Module it contains (wrapped in an auto_ptr), or 0 if an error
occurs.
>      std::auto_ptr<Module> LoadObject(const sys::Path& FN);
>  
> Index: include/llvm/Support/SystemUtils.h
> ==================================================================> ---
include/llvm/Support/SystemUtils.h	(revision 37888)
> +++ include/llvm/Support/SystemUtils.h	(working copy)
> @@ -21,10 +21,10 @@
>  
>  /// Determine if the ostream provided is connected to the std::cout and
>  /// displayed or not (to a console window). If so, generate a warning
message
> -/// advising against display of bytecode and return true. Otherwise just
return
> +/// advising against display of bitcode and return true. Otherwise just
return
>  /// false
>  /// @brief Check for output written to a console
> -bool CheckBytecodeOutputToConsole(
> +bool CheckBitcodeOutputToConsole(
>    std::ostream* stream_to_check, ///< The stream to be checked
>    bool print_warning = true ///< Control whether warnings are printed
>  );
> Index: include/llvm/GlobalValue.h
> ==================================================================> ---
include/llvm/GlobalValue.h	(revision 37888)
> +++ include/llvm/GlobalValue.h	(working copy)
> @@ -108,12 +108,12 @@
>    void setLinkage(LinkageTypes LT) { Linkage = LT; }
>    LinkageTypes getLinkage() const { return Linkage; }
>  
> -  /// hasNotBeenReadFromBytecode - If a module provider is being used to
lazily
> +  /// hasNotBeenReadFromBitcode - If a module provider is being used to
lazily
>    /// stream in functions from disk, this method can be used to check to
see if
>    /// the function has been read in yet or not.  Unless you are working on
the
>    /// JIT or something else that streams stuff in lazily, you don't
need to
>    /// worry about this.
> -  bool hasNotBeenReadFromBytecode() const { return Linkage ==
GhostLinkage; }
> +  bool hasNotBeenReadFromBitcode() const { return Linkage == GhostLinkage;
}
>  
>    /// Override from Constant class. No GlobalValue's are null values
so this
>    /// always returns false.
> Index: include/llvm/System/Path.h
> ==================================================================> ---
include/llvm/System/Path.h	(revision 37888)
> +++ include/llvm/System/Path.h	(working copy)
> @@ -112,15 +112,15 @@
>        /// @brief Construct a path to the system library directory
>        static void GetSystemLibraryPaths(std::vector<sys::Path>&
Paths);
>  
> -      /// Construct a vector of sys::Path that contains the
"standard" bytecode
> +      /// Construct a vector of sys::Path that contains the
"standard" bitcode
>        /// library paths suitable for linking into an llvm program. This
function
>        /// *must* return the value of LLVM_LIB_SEARCH_PATH as well as the
value
>        /// of LLVM_LIBDIR. It also must provide the System library paths as
>        /// returned by GetSystemLibraryPaths.
>        /// @see GetSystemLibraryPaths
> -      /// @brief Construct a list of directories in which bytecode could
be
> +      /// @brief Construct a list of directories in which bitcode could be
>        /// found.
> -      static void
GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths);
> +      static void GetBitcodeLibraryPaths(std::vector<sys::Path>&
Paths);
>  
>        /// Find the path to a library using its short name. Use the system
>        /// dependent library paths to locate the library.
> Index: include/llvm/AbstractTypeUser.h
> ==================================================================> ---
include/llvm/AbstractTypeUser.h	(revision 37888)
> +++ include/llvm/AbstractTypeUser.h	(working copy)
> @@ -41,7 +41,7 @@
>  ///
>  /// Classes must implement this interface so that they may be notified
when an
>  /// abstract type is resolved.  Abstract types may be resolved into more 
> -/// concrete types through: linking, parsing, and bytecode reading.  When
this
> +/// concrete types through: linking, parsing, and bitcode reading.  When
this
>  /// happens, all of the users of the type must be updated to reference the
new,
>  /// more concrete type.  They are notified through the AbstractTypeUser 
>  /// interface.
> Index: include/llvm/Type.h
> ==================================================================> ---
include/llvm/Type.h	(revision 37888)
> +++ include/llvm/Type.h	(working copy)
> @@ -52,7 +52,7 @@
>  ///
>  /// Opaque types are also kinda weird and scary and different because they
have
>  /// to keep a list of uses of the type.  When, through linking, parsing,
or
> -/// bytecode reading, they become resolved, they need to find and update
all
> +/// bitcode reading, they become resolved, they need to find and update
all
>  /// users of the unknown type, causing them to reference a new, more
concrete
>  /// type.  Opaque types are deleted when their use list dwindles to zero
users.
>  ///
> @@ -77,7 +77,7 @@
>      IntegerTyID,     ///<  4: Arbitrary bit width integers
>      FunctionTyID,    ///<  5: Functions
>      StructTyID,      ///<  6: Structures
> -    PackedStructTyID,///<  7: Packed Structure. This is for bytecode
only
> +    PackedStructTyID,///<  7: Packed Structure. This is for bitcode
only
>      ArrayTyID,       ///<  8: Arrays
>      PointerTyID,     ///<  9: Pointers
>      OpaqueTyID,      ///< 10: Opaque: type with unknown structure
> Index: include/llvm/Bitcode/Archive.h
> ==================================================================> ---
include/llvm/Bitcode/Archive.h	(revision 37888)
> +++ include/llvm/Bitcode/Archive.h	(working copy)
> @@ -14,8 +14,8 @@
>  //
> 
//===----------------------------------------------------------------------===//
>  
> -#ifndef LLVM_BITECODE_ARCHIVE_H
> -#define LLVM_BITECODE_ARCHIVE_H
> +#ifndef LLVM_BITCODE_ARCHIVE_H
> +#define LLVM_BITCODE_ARCHIVE_H
>  
>  #include "llvm/ADT/ilist"
>  #include "llvm/System/Path.h"
> @@ -377,13 +377,13 @@
>      /// @brief Get the offset to the first "real" file member 
in the archive.
>      unsigned getFirstFileOffset() { return firstFileOffset; }
>  
> -    /// This method will scan the archive for bytecode modules, interpret
them
> +    /// This method will scan the archive for bitcode modules, interpret
them
>      /// and return a vector of the instantiated modules in \p Modules. If
an
>      /// error occurs, this method will return true. If \p ErrMessage is
not null
>      /// and an error occurs, \p *ErrMessage will be set to a string
explaining
>      /// the error that occurred.
>      /// @returns true if an error occurred
> -    /// @brief Instantiate all the bytecode modules located in the archive
> +    /// @brief Instantiate all the bitcode modules located in the archive
>      bool getAllModules(std::vector<Module*>& Modules,
std::string* ErrMessage);
>  
>      /// This accessor looks up the \p symbol in the archive's symbol
table and
> @@ -418,13 +418,13 @@
>      );
>  
>      /// This method determines whether the archive is a properly formed
llvm
> -    /// bytecode archive.  It first makes sure the symbol table has been
loaded
> +    /// bitcode archive.  It first makes sure the symbol table has been
loaded
>      /// and has a non-zero size.  If it does, then it is an archive.  If
not,
> -    /// then it tries to load all the bytecode modules of the archive. 
Finally,
> +    /// then it tries to load all the bitcode modules of the archive. 
Finally,
>      /// it returns whether it was successfull.
> -    /// @returns true if the archive is a proper llvm bytecode archive
> -    /// @brief Determine whether the archive is a proper llvm bytecode
archive.
> -    bool isBytecodeArchive();
> +    /// @returns true if the archive is a proper llvm bitcode archive
> +    /// @brief Determine whether the archive is a proper llvm bitcode
archive.
> +    bool isBitcodeArchive();
>  
>    /// @}
>    /// @name Mutators
> @@ -433,7 +433,7 @@
>      /// This method is the only way to get the archive written to disk. It
>      /// creates or overwrites the file specified when \p this was created
>      /// or opened. The arguments provide options for writing the archive.
If
> -    /// \p CreateSymbolTable is true, the archive is scanned for bytecode
files
> +    /// \p CreateSymbolTable is true, the archive is scanned for bitcode
files
>      /// and a symbol table of the externally visible function and global
>      /// variable names is created. If \p TruncateNames is true, the names
of the
>      /// archive members will have their path component stripped and the
file
> @@ -525,7 +525,7 @@
>      /// @brief Frees all the members and unmaps the archive file.
>      void cleanUpMemory();
>  
> -    /// This type is used to keep track of bytecode modules loaded from
the
> +    /// This type is used to keep track of bitcode modules loaded from the
>      /// symbol table. It maps the file offset to a pair that consists of
the
>      /// associated ArchiveMember and the ModuleProvider.
>      /// @brief Module mapping type
> Index: tools/llvm-ranlib/llvm-ranlib.cpp
> ==================================================================> ---
tools/llvm-ranlib/llvm-ranlib.cpp	(revision 37888)
> +++ tools/llvm-ranlib/llvm-ranlib.cpp	(working copy)
> @@ -48,7 +48,7 @@
>    // like --help and --version.
>    cl::ParseCommandLineOptions(argc, argv,
>      " LLVM Archive Index Generator (llvm-ranlib)\n\n"
> -    "  This program adds or updates an index of bytecode
symbols\n"
> +    "  This program adds or updates an index of bitcode
symbols\n"
>      "  to an LLVM archive file."
>    );
>  
> Index: tools/lli/lli.cpp
> ==================================================================> ---
tools/lli/lli.cpp	(revision 37888)
> +++ tools/lli/lli.cpp	(working copy)
> @@ -33,7 +33,7 @@
>  
>  namespace {
>    cl::opt<std::string>
> -  InputFile(cl::desc("<input bytecode>"), cl::Positional,
cl::init("-"));
> +  InputFile(cl::desc("<input bitcode>"), cl::Positional,
cl::init("-"));
>  
>    cl::list<std::string>
>    InputArgv(cl::ConsumeAfter, cl::desc("<program
arguments>..."));
> @@ -74,7 +74,7 @@
>    if (DisableCoreFiles)
>      sys::Process::PreventCoreFiles();
>    
> -  // Load the bytecode...
> +  // Load the bitcode...
>    std::string ErrorMsg;
>    ModuleProvider *MP = 0;
>    if (MemoryBuffer *Buffer =
MemoryBuffer::getFileOrSTDIN(InputFile,&ErrorMsg)){
> Index: tools/llvm-nm/llvm-nm.cpp
> ==================================================================> ---
tools/llvm-nm/llvm-nm.cpp	(revision 37888)
> +++ tools/llvm-nm/llvm-nm.cpp	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This program is a utility that works like traditional Unix
"nm",
> -// that is, it prints out the names of symbols in a bytecode file,
> +// that is, it prints out the names of symbols in a bitcode file,
>  // along with some information about each symbol.
>  //
>  // This "nm" does not print symbols' addresses. It supports
many of
> @@ -43,7 +43,7 @@
>                            cl::aliasopt(OutputFormat));
>  
>    cl::list<std::string>
> -  InputFilenames(cl::Positional, cl::desc("<input bytecode
files>"),
> +  InputFilenames(cl::Positional, cl::desc("<input bitcode
files>"),
>                   cl::ZeroOrMore);
>  
>    cl::opt<bool> UndefinedOnly("undefined-only",
> Index: tools/llvm-extract/llvm-extract.cpp
> ==================================================================> ---
tools/llvm-extract/llvm-extract.cpp	(revision 37888)
> +++ tools/llvm-extract/llvm-extract.cpp	(working copy)
> @@ -28,7 +28,7 @@
>  
>  // InputFilename - The filename to read from.
>  static cl::opt<std::string>
> -InputFilename(cl::Positional, cl::desc("<input bytecode
file>"),
> +InputFilename(cl::Positional, cl::desc("<input bitcode
file>"),
>                cl::init("-"),
cl::value_desc("filename"));
>  
>  static cl::opt<std::string>
> @@ -67,7 +67,7 @@
>    delete Buffer;
>    
>    if (M.get() == 0) {
> -    cerr << argv[0] << ": bytecode didn't read
correctly.\n";
> +    cerr << argv[0] << ": bitcode didn't read
correctly.\n";
>      return 1;
>    }
>  
> Index: tools/llvm-dis/llvm-dis.cpp
> ==================================================================> ---
tools/llvm-dis/llvm-dis.cpp	(revision 37888)
> +++ tools/llvm-dis/llvm-dis.cpp	(working copy)
> @@ -8,8 +8,8 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This utility may be invoked in the following manner:
> -//  llvm-dis [options]      - Read LLVM bytecode from stdin, write asm to
stdout
> -//  llvm-dis [options] x.bc - Read LLVM bytecode from the x.bc file, write
asm
> +//  llvm-dis [options]      - Read LLVM bitcode from stdin, write asm to
stdout
> +//  llvm-dis [options] x.bc - Read LLVM bitcode from the x.bc file, write
asm
>  //                            to the x.ll file.
>  //  Options:
>  //      --help   - Output information about command line switches
> @@ -31,7 +31,7 @@
>  using namespace llvm;
>  
>  static cl::opt<std::string>
> -InputFilename(cl::Positional, cl::desc("<input
bytecode>"), cl::init("-"));
> +InputFilename(cl::Positional, cl::desc("<input bitcode>"),
cl::init("-"));
>  
>  static cl::opt<std::string>
>  OutputFilename("o", cl::desc("Override output
filename"),
> @@ -65,7 +65,7 @@
>        if (ErrorMessage.size())
>          cerr << ErrorMessage << "\n";
>        else
> -        cerr << "bytecode didn't read correctly.\n";
> +        cerr << "bitcode didn't read correctly.\n";
>        return 1;
>      }
>      
> Index: tools/llvm-db/Commands.cpp
> ==================================================================> ---
tools/llvm-db/Commands.cpp	(revision 37888)
> +++ tools/llvm-db/Commands.cpp	(working copy)
> @@ -219,7 +219,7 @@
>  
> 
>  /// file command - If the user specifies an option, search the PATH for
the
> -/// specified program/bytecode file and load it.  If the user does not
specify
> +/// specified program/bitcode file and load it.  If the user does not
specify
>  /// an option, unload the current program.
>  void CLIDebugger::fileCommand(std::string &Options) {
>    std::string Prog = getToken(Options);
> Index: tools/lto/lto-c.cpp
> ==================================================================> ---
tools/lto/lto-c.cpp	(revision 37888)
> +++ tools/lto/lto-c.cpp	(working copy)
> @@ -30,7 +30,7 @@
>    delete (llvm::LTO*)lto;
>  }
>  
> -/// Read an LLVM bytecode file using LTO::readLLVMObjectFile.
> +/// Read an LLVM bitcode file using LTO::readLLVMObjectFile.
>  extern "C"
>  llvm_lto_status
>  llvm_read_object_file(llvm_lto_t lto, const char *input_filename) {
> Index: tools/lto/lto.cpp
> ==================================================================> ---
tools/lto/lto.cpp	(revision 37888)
> +++ tools/lto/lto.cpp	(working copy)
> @@ -107,7 +107,7 @@
>    delete m;
>  }
>  
> -/// InputFilename is a LLVM bytecode file. If Module with InputFilename is
> +/// InputFilename is a LLVM bitcode file. If Module with InputFilename is
>  /// available then return it. Otherwise parseInputFilename.
>  Module *
>  LTO::getModule(const std::string &InputFilename)
> @@ -128,7 +128,7 @@
>    return m;
>  }
>  
> -/// InputFilename is a LLVM bytecode file. Reade this bytecode file and 
> +/// InputFilename is a LLVM bitcode file. Reade this bitcode file and 
>  /// set corresponding target triplet string.
>  void
>  LTO::getTargetTriple(const std::string &InputFilename, 
> @@ -139,7 +139,7 @@
>      targetTriple = m->getTargetTriple();
>  }
>  
> -/// InputFilename is a LLVM bytecode file. Read it using bytecode reader.
> +/// InputFilename is a LLVM bitcode file. Read it using bitcode reader.
>  /// Collect global functions and symbol names in symbols vector.
>  /// Collect external references in references vector.
>  /// Return LTO_READ_SUCCESS if there is no error.
> Index: tools/llvm2cpp/llvm2cpp.cpp
> ==================================================================> ---
tools/llvm2cpp/llvm2cpp.cpp	(revision 37888)
> +++ tools/llvm2cpp/llvm2cpp.cpp	(working copy)
> @@ -31,7 +31,7 @@
>  using namespace llvm;
>  
>  static cl::opt<std::string>
> -InputFilename(cl::Positional, cl::desc("<input LLVM bytecode
file>"),
> +InputFilename(cl::Positional, cl::desc("<input LLVM bitcode
file>"),
>    cl::init("-"));
>  
>  static cl::opt<std::string>
> @@ -60,7 +60,7 @@
>      if (ErrorMessage.size())
>        std::cerr << ErrorMessage << "\n";
>      else
> -      std::cerr << "bytecode didn't read
correctly.\n";
> +      std::cerr << "bitcode didn't read correctly.\n";
>      return 1;
>    }
>  
> Index: tools/opt/opt.cpp
> ==================================================================> ---
tools/opt/opt.cpp	(revision 37888)
> +++ tools/opt/opt.cpp	(working copy)
> @@ -46,7 +46,7 @@
>  // Other command line options...
>  //
>  static cl::opt<std::string>
> -InputFilename(cl::Positional, cl::desc("<input bytecode
file>"),
> +InputFilename(cl::Positional, cl::desc("<input bitcode
file>"),
>      cl::init("-"), cl::value_desc("filename"));
>  
>  static cl::opt<std::string>
> @@ -61,7 +61,7 @@
>  
>  static cl::opt<bool>
>  NoOutput("disable-output",
> -         cl::desc("Do not write result bytecode file"),
cl::Hidden);
> +         cl::desc("Do not write result bitcode file"),
cl::Hidden);
>  
>  static cl::opt<bool>
>  NoVerify("disable-verify", cl::desc("Do not verify result
module"), cl::Hidden);
> @@ -303,7 +303,7 @@
>        if (ErrorMessage.size())
>          cerr << ErrorMessage << "\n";
>        else
> -        cerr << "bytecode didn't read correctly.\n";
> +        cerr << "bitcode didn't read correctly.\n";
>        return 1;
>      }
>  
> @@ -335,7 +335,7 @@
>      // If the output is set to be emitted to standard out, and standard
out is a
>      // console, print out a warning message and refuse to do it.  We
don't
>      // impress anyone by spewing tons of binary goo to a terminal.
> -    if (!Force && !NoOutput &&
CheckBytecodeOutputToConsole(Out,!Quiet)) {
> +    if (!Force && !NoOutput &&
CheckBitcodeOutputToConsole(Out,!Quiet)) {
>        NoOutput = true;
>      }
>  
> @@ -389,7 +389,7 @@
>      if (!NoVerify && !VerifyEach)
>        Passes.add(createVerifierPass());
>  
> -    // Write bytecode out to disk or cout as the last step...
> +    // Write bitcode out to disk or cout as the last step...
>      if (!NoOutput && !AnalyzeOnly)
>        Passes.add(CreateBitcodeWriterPass(*Out));
>  
> Index: tools/llvm-link/llvm-link.cpp
> ==================================================================> ---
tools/llvm-link/llvm-link.cpp	(revision 37888)
> +++ tools/llvm-link/llvm-link.cpp	(working copy)
> @@ -28,7 +28,7 @@
>  
>  static cl::list<std::string>
>  InputFilenames(cl::Positional, cl::OneOrMore,
> -               cl::desc("<input bytecode files>"));
> +               cl::desc("<input bitcode files>"));
>  
>  static cl::opt<std::string>
>  OutputFilename("o", cl::desc("Override output
filename"), cl::init("-"),
> @@ -42,7 +42,7 @@
>  static cl::opt<bool>
>  DumpAsm("d", cl::desc("Print assembly as linked"),
cl::Hidden);
>  
> -// LoadFile - Read the specified bytecode file in and return it.  This
routine
> +// LoadFile - Read the specified bitcode file in and return it.  This
routine
>  // searches the link path for the specified file to try to find it...
>  //
>  static inline std::auto_ptr<Module> LoadFile(const std::string
&FN) {
> @@ -66,12 +66,12 @@
>      if (Result) return std::auto_ptr<Module>(Result);   // Load
successful!
>  
>      if (Verbose) {
> -      cerr << "Error opening bytecode file: '"
<< Filename.c_str() << "'";
> +      cerr << "Error opening bitcode file: '" <<
Filename.c_str() << "'";
>        if (ErrorMessage.size()) cerr << ": " <<
ErrorMessage;
>        cerr << "\n";
>      }
>    } else {
> -    cerr << "Bytecode file: '" <<
Filename.c_str() << "' does not exist.\n";
> +    cerr << "Bitcode file: '" <<
Filename.c_str() << "' does not exist.\n";
>    }
>  
>    return std::auto_ptr<Module>();
> @@ -142,7 +142,7 @@
>      return 1;
>    }
>  
> -  if (Verbose) cerr << "Writing bytecode...\n";
> +  if (Verbose) cerr << "Writing bitcode...\n";
>    WriteBitcodeToFile(Composite.get(), *Out);
>  
>    if (Out != &std::cout) delete Out;
> Index: tools/llvm-ld/llvm-ld.cpp
> ==================================================================> ---
tools/llvm-ld/llvm-ld.cpp	(revision 37888)
> +++ tools/llvm-ld/llvm-ld.cpp	(working copy)
> @@ -11,7 +11,7 @@
>  // system 'ld' conventions.  As such, the default output file is
./a.out.
>  // Additionally, this program outputs a shell script that is used to
invoke LLI
>  // to execute the program.  In this manner, the generated executable
(a.out for
> -// example), is directly executable, whereas the bytecode file actually
lives in
> +// example), is directly executable, whereas the bitcode file actually
lives in
>  // the a.out.bc file generated by this program.  Also, Force is on by
default.
>  //
>  // Note that if someone (or a script) deletes the executable program
generated,
> @@ -42,7 +42,7 @@
>  
>  // Input/Output Options
>  static cl::list<std::string> InputFilenames(cl::Positional,
cl::OneOrMore,
> -  cl::desc("<input bytecode files>"));
> +  cl::desc("<input bitcode files>"));
>  
>  static cl::opt<std::string> OutputFilename("o",
cl::init("a.out"),
>    cl::desc("Override output filename"),
> @@ -203,11 +203,11 @@
>    return;
>  }
>  
> -/// GenerateBytecode - generates a bytecode file from the module provided
> -void GenerateBytecode(Module* M, const std::string& FileName) {
> +/// GenerateBitcode - generates a bitcode file from the module provided
> +void GenerateBitcode(Module* M, const std::string& FileName) {
>  
>    if (Verbose)
> -    cout << "Generating Bytecode To " << FileName
<< '\n';
> +    cout << "Generating Bitcode To " << FileName
<< '\n';
>  
>    // Create the output file.
>    std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
> @@ -216,22 +216,22 @@
>    if (!Out.good())
>      PrintAndExit("error opening '" + FileName + "'
for writing!");
>  
> -  // Ensure that the bytecode file gets removed from the disk if we get a
> +  // Ensure that the bitcode file gets removed from the disk if we get a
>    // terminating signal.
>    sys::RemoveFileOnSignal(sys::Path(FileName));
>  
>    // Write it out
>    WriteBitcodeToFile(M, Out);
>  
> -  // Close the bytecode file.
> +  // Close the bitcode file.
>    Out.close();
>  }
>  
>  /// GenerateAssembly - generates a native assembly language source file
from the
> -/// specified bytecode file.
> +/// specified bitcode file.
>  ///
>  /// Inputs:
> -///  InputFilename  - The name of the input bytecode file.
> +///  InputFilename  - The name of the input bitcode file.
>  ///  OutputFilename - The name of the file to generate.
>  ///  llc            - The pathname to use for LLC.
>  ///  envp           - The environment to use when running LLC.
> @@ -242,7 +242,7 @@
>                              const std::string &InputFilename,
>                              const sys::Path &llc,
>                              std::string &ErrMsg ) {
> -  // Run LLC to convert the bytecode file into assembly code.
> +  // Run LLC to convert the bitcode file into assembly code.
>    std::vector<const char*> args;
>    args.push_back(llc.c_str());
>    args.push_back("-f");
> @@ -259,12 +259,12 @@
>    return sys::Program::ExecuteAndWait(llc, &args[0], 0, 0, 0, 0,
&ErrMsg);
>  }
>  
> -/// GenerateCFile - generates a C source file from the specified bytecode
file.
> +/// GenerateCFile - generates a C source file from the specified bitcode
file.
>  static int GenerateCFile(const std::string &OutputFile,
>                           const std::string &InputFile,
>                           const sys::Path &llc,
>                           std::string& ErrMsg) {
> -  // Run LLC to convert the bytecode file into C.
> +  // Run LLC to convert the bitcode file into C.
>    std::vector<const char*> args;
>    args.push_back(llc.c_str());
>    args.push_back("-march=c");
> @@ -283,10 +283,10 @@
>  }
>  
>  /// GenerateNative - generates a native object file from the
> -/// specified bytecode file.
> +/// specified bitcode file.
>  ///
>  /// Inputs:
> -///  InputFilename   - The name of the input bytecode file.
> +///  InputFilename   - The name of the input bitcode file.
>  ///  OutputFilename  - The name of the file to generate.
>  ///  NativeLinkItems - The native libraries, files, code with which to
link
>  ///  LibPaths        - The list of directories in which to find libraries.
> @@ -377,7 +377,7 @@
>  }
>  
>  /// EmitShellScript - Output the wrapper file that invokes the JIT on the
LLVM
> -/// bytecode file for the program.
> +/// bitcode file for the program.
>  static void EmitShellScript(char **argv) {
>    if (Verbose)
>      cout << "Emitting Shell Script\n";
> @@ -478,7 +478,7 @@
>      // Construct a Linker (now that Verbose is set)
>      Linker TheLinker(progname, OutputFilename, Verbose);
>  
> -    // Keep track of the native link items (versus the bytecode items)
> +    // Keep track of the native link items (versus the bitcode items)
>      Linker::ItemList NativeLinkItems;
>  
>      // Add library paths to the linker
> @@ -517,10 +517,10 @@
>      // Optimize the module
>      Optimize(Composite.get());
>  
> -    // Generate the bytecode for the optimized module.
> -    std::string RealBytecodeOutput = OutputFilename;
> -    if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
> -    GenerateBytecode(Composite.get(), RealBytecodeOutput);
> +    // Generate the bitcode for the optimized module.
> +    std::string RealBitcodeOutput = OutputFilename;
> +    if (!LinkAsLibrary) RealBitcodeOutput += ".bc";
> +    GenerateBitcode(Composite.get(), RealBitcodeOutput);
>  
>      // If we are not linking a library, generate either a native
executable
>      // or a JIT shell script, depending upon what the user wants.
> @@ -545,17 +545,17 @@
>  
>            const char* args[4];
>            args[0] = I->c_str();
> -          args[1] = RealBytecodeOutput.c_str();
> +          args[1] = RealBitcodeOutput.c_str();
>            args[2] = tmp_output.c_str();
>            args[3] = 0;
>            if (0 == sys::Program::ExecuteAndWait(prog, args, 0,0,0,0,
&ErrMsg)) {
> -            if (tmp_output.isBytecodeFile() || tmp_output.isBitcodeFile())
{
> -              sys::Path target(RealBytecodeOutput);
> +            if (tmp_output.isBitcodeFile() || tmp_output.isBitcodeFile())
{
> +              sys::Path target(RealBitcodeOutput);
>                target.eraseFromDisk();
>                if (tmp_output.renamePathOnDisk(target, &ErrMsg))
>                  PrintAndExit(ErrMsg, 2);
>              } else
> -              PrintAndExit("Post-link optimization output is not
bytecode");
> +              PrintAndExit("Post-link optimization output is not
bitcode");
>            } else {
>              PrintAndExit(ErrMsg);
>            }
> @@ -563,9 +563,9 @@
>        }
>  
>        // If the user wants to generate a native executable, compile it
from the
> -      // bytecode file.
> +      // bitcode file.
>        //
> -      // Otherwise, create a script that will run the bytecode through the
JIT.
> +      // Otherwise, create a script that will run the bitcode through the
JIT.
>        if (Native) {
>          // Name of the Assembly Language output file
>          sys::Path AssemblyFile ( OutputFilename);
> @@ -584,9 +584,9 @@
>          if (gcc.isEmpty())
>            PrintAndExit("Failed to find gcc");
>  
> -        // Generate an assembly language file for the bytecode.
> +        // Generate an assembly language file for the bitcode.
>          std::string ErrMsg;
> -        if (0 != GenerateAssembly(AssemblyFile.toString(),
RealBytecodeOutput,
> +        if (0 != GenerateAssembly(AssemblyFile.toString(),
RealBitcodeOutput,
>              llc, ErrMsg))
>            PrintAndExit(ErrMsg);
>  
> @@ -613,10 +613,10 @@
>          if (gcc.isEmpty())
>            PrintAndExit("Failed to find gcc");
>  
> -        // Generate an assembly language file for the bytecode.
> +        // Generate an assembly language file for the bitcode.
>          std::string ErrMsg;
>          if (0 != GenerateCFile(
> -            CFile.toString(), RealBytecodeOutput, llc, ErrMsg))
> +            CFile.toString(), RealBitcodeOutput, llc, ErrMsg))
>            PrintAndExit(ErrMsg);
>  
>          if (0 != GenerateNative(OutputFilename, CFile.toString(), 
> @@ -635,11 +635,11 @@
>        if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg))
>          PrintAndExit(ErrMsg);
>  
> -      // Make the bytecode file readable and directly executable in LLEE
as well
> -      if (sys::Path(RealBytecodeOutput).makeExecutableOnDisk(&ErrMsg))
> +      // Make the bitcode file readable and directly executable in LLEE as
well
> +      if (sys::Path(RealBitcodeOutput).makeExecutableOnDisk(&ErrMsg))
>          PrintAndExit(ErrMsg);
>  
> -      if (sys::Path(RealBytecodeOutput).makeReadableOnDisk(&ErrMsg))
> +      if (sys::Path(RealBitcodeOutput).makeReadableOnDisk(&ErrMsg))
>          PrintAndExit(ErrMsg);
>      }
>    } catch (const std::string& msg) {
> Index: tools/llvm-ar/llvm-ar.cpp
> ==================================================================> ---
tools/llvm-ar/llvm-ar.cpp	(revision 37888)
> +++ tools/llvm-ar/llvm-ar.cpp	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // Builds up (relatively) standard unix archive files (.a) containing LLVM
> -// bytecode or other files.
> +// bitcode or other files.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> @@ -54,7 +54,7 @@
>    "  [b] - put file(s) before [relpos] (same as [i])\n"
>    "  [f] - truncate inserted file names\n"
>    "  [i] - put file(s) before [relpos] (same as [b])\n"
> -  "  [k] - always print bytecode files (default is to skip
them)\n"
> +  "  [k] - always print bitcode files (default is to skip
them)\n"
>    "  [N] - use instance [count] of name\n"
>    "  [o] - preserve original dates\n"
>    "  [P] - use full path names when matching\n"
> @@ -88,7 +88,7 @@
>  bool Create = false;             ///< 'c' modifier
>  bool TruncateNames = false;      ///< 'f' modifier
>  bool InsertBefore = false;       ///< 'i' modifier
> -bool DontSkipBytecode = false;   ///< 'k' modifier
> +bool DontSkipBitcode = false;    ///< 'k' modifier
>  bool UseCount = false;           ///< 'N' modifier
>  bool OriginalDates = false;      ///< 'o' modifier
>  bool FullPath = false;           ///< 'P' modifier
> @@ -193,7 +193,7 @@
>      case 'x': ++NumOperations; Operation = Extract; break;
>      case 'c': Create = true; break;
>      case 'f': TruncateNames = true; break;
> -    case 'k': DontSkipBytecode = true; break;
> +    case 'k': DontSkipBitcode = true; break;
>      case 'l': /* accepted but unused */ break;
>      case 'o': OriginalDates = true; break;
>      case 'P': FullPath = true; break;
> @@ -341,7 +341,7 @@
>  
>  // doPrint - Implements the 'p' operation. This function traverses
the archive
>  // looking for members that match the path list. It is careful to
uncompress
> -// things that should be and to skip bytecode files unless the 'k'
modifier was
> +// things that should be and to skip bitcode files unless the 'k'
modifier was
>  // given.
>  bool doPrint(std::string* ErrMsg) {
>    if (buildPaths(false, ErrMsg))
> @@ -356,7 +356,7 @@
>  
>          // Skip things that don't make sense to print
>          if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() ||
> -            I->isBSD4SymbolTable() || (!DontSkipBytecode &&
> +            I->isBSD4SymbolTable() || (!DontSkipBitcode &&
>               (I->isBytecode() || I->isCompressedBytecode())))
>            continue;
>  
> @@ -694,7 +694,7 @@
>    // like --help and --version.
>    cl::ParseCommandLineOptions(argc, argv,
>      " LLVM Archiver (llvm-ar)\n\n"
> -    "  This program archives bytecode files into single
libraries\n"
> +    "  This program archives bitcode files into single
libraries\n"
>    );
>  
>    // Print a stack trace if we signal out.
> Index: tools/llc/llc.cpp
> ==================================================================> ---
tools/llc/llc.cpp	(revision 37888)
> +++ tools/llc/llc.cpp	(working copy)
> @@ -9,7 +9,7 @@
>  //
>  // This is the llc code generator driver. It provides a convenient
>  // command-line interface for generating native assembly-language code
> -// or C code, given LLVM bytecode.
> +// or C code, given LLVM bitcode.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> @@ -44,7 +44,7 @@
>  // and back-end code generation options are specified with the target
machine.
>  //
>  static cl::opt<std::string>
> -InputFilename(cl::Positional, cl::desc("<input
bytecode>"), cl::init("-"));
> +InputFilename(cl::Positional, cl::desc("<input bitcode>"),
cl::init("-"));
>  
>  static cl::opt<std::string>
>  OutputFilename("o", cl::desc("Output filename"),
cl::value_desc("filename"));
> @@ -184,7 +184,7 @@
>    if (Buffer.get())
>      M.reset(ParseBitcodeFile(Buffer.get(), &ErrorMessage));
>    if (M.get() == 0) {
> -    std::cerr << argv[0] << ": bytecode didn't read
correctly.\n";
> +    std::cerr << argv[0] << ": bitcode didn't read
correctly.\n";
>      std::cerr << "Reason: " << ErrorMessage <<
"\n";
>      return 1;
>    }
> Index: tools/llvm-as/llvm-as.cpp
> ==================================================================> ---
tools/llvm-as/llvm-as.cpp	(revision 37888)
> +++ tools/llvm-as/llvm-as.cpp	(working copy)
> @@ -125,7 +125,7 @@
>        return 1;
>      }
>  
> -    if (Force || !CheckBytecodeOutputToConsole(Out,true))
> +    if (Force || !CheckBitcodeOutputToConsole(Out,true))
>        WriteBitcodeToFile(M.get(), *Out);
>    } catch (const std::string& msg) {
>      cerr << argv[0] << ": " << msg <<
"\n";
> Index: tools/llvmc/Configuration.cpp
> ==================================================================> ---
tools/llvmc/Configuration.cpp	(revision 37888)
> +++ tools/llvmc/Configuration.cpp	(working copy)
> @@ -291,8 +291,8 @@
>            case ASSEMBLY:
>              str += "assembly";
>              break;
> -          case BYTECODE:
> -            str += "bytecode";
> +          case BITCODE:
> +            str += "bitcode";
>              break;
>            case TRUETOK:
>              str += "true";
> @@ -340,8 +340,8 @@
>                case ASSEMBLY:
>                  anOption += "assembly";
>                  break;
> -              case BYTECODE:
> -                anOption += "bytecode";
> +              case BITCODE:
> +                anOption += "bitcode";
>                  break;
>                case TRUETOK:
>                  anOption += "true";
> @@ -392,7 +392,7 @@
>            next();
>          if (token == ASSEMBLY) {
>            return true;
> -        } else if (token == BYTECODE) {
> +        } else if (token == BITCODE) {
>            return false;
>          } else {
>            error("Expecting output type value");
> Index: tools/llvmc/ConfigLexer.h
> ==================================================================> ---
tools/llvmc/ConfigLexer.h	(revision 37888)
> +++ tools/llvmc/ConfigLexer.h	(working copy)
> @@ -56,7 +56,7 @@
>    BINDIR_SUBST,      ///< The substitution item %bindir%
>    ASSEMBLY,          ///< The value "assembly" (and variants)
>    ASSEMBLER,         ///< The name "assembler" (and variants)
> -  BYTECODE,          ///< The value "bytecode" (and variants)
> +  BITCODE,           ///< The value "bitcode" (and variants)
>    COMMAND,           ///< The name "command" (and variants)
>    DEFS_SUBST,        ///< The substitution item %defs%
>    EQUALS,            ///< The equals sign, > Index:
tools/llvmc/llvmc.cpp
> ==================================================================> ---
tools/llvmc/llvmc.cpp	(revision 37888)
> +++ tools/llvmc/llvmc.cpp	(working copy)
> @@ -143,7 +143,7 @@
>    cl::desc("Specify a target machine"),
cl::value_desc("machine"));
>  
>  static cl::opt<bool> Native("native", cl::init(false),
> -  cl::desc("Generative native code instead of bytecode"));
> +  cl::desc("Generative native code instead of bitcode"));
>  
>  static cl::opt<bool> DebugOutput("g", cl::init(false),
>    cl::desc("Generate objects that include debug symbols"));
> Index: tools/llvmc/ConfigLexer.l
> ==================================================================> ---
tools/llvmc/ConfigLexer.l	(revision 37888)
> +++ tools/llvmc/ConfigLexer.l	(working copy)
> @@ -79,7 +79,7 @@
>  COMMAND         command|Command|COMMAND
>  LANG            lang|Lang|LANG
>  LIBS            libs|Libs|LIBS
> -LINKER		linker|Linker|LINKER
> +LINKER          linker|Linker|LINKER
>  NAME            name|Name|NAME
>  OPT1            opt1|Opt1|OPT1
>  OPT2            opt2|Opt2|OPT2
> @@ -97,7 +97,7 @@
>  
>  True            true|True|TRUE|on|On|ON|yes|Yes|YES
>  False           false|False|FALSE|off|Off|OFF|no|No|NO
> -Bytecode        bc|BC|bytecode|Bytecode|BYTECODE
> +Bitcode         bc|BC|bitcode|Bitcode|BITCODE
>  Assembly        asm|ASM|assembly|Assembly|ASSEMBLY
>  
>  BadSubst        \%[a-zA-Z]*\%
> @@ -186,7 +186,7 @@
>  %WOpts%         { return handleSubstitution(WOPTS_SUBST); }
>  
>  {Assembly}      { return handleValueContext(ASSEMBLY); }
> -{Bytecode}      { return handleValueContext(BYTECODE); }
> +{Bitcode}       { return handleValueContext(BITCODE); }
>  {True}          { return handleValueContext(TRUETOK); }
>  {False}         { return handleValueContext(FALSETOK); }
>  
> Index: tools/llvmc/CompilerDriver.cpp
> ==================================================================> ---
tools/llvmc/CompilerDriver.cpp	(revision 37888)
> +++ tools/llvmc/CompilerDriver.cpp	(working copy)
> @@ -65,9 +65,9 @@
>    DumpAction(&cd->Linker);
>  }
>  
> -static bool GetBytecodeDependentLibraries(const std::string &fname,
> -                                          Module::LibraryListType&
deplibs,
> -                                          std::string* ErrMsg) {
> +static bool GetBitcodeDependentLibraries(const std::string &fname,
> +                                         Module::LibraryListType&
deplibs,
> +                                         std::string* ErrMsg) {
>    ModuleProvider *MP = 0;
>    if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(fname)) {
>      MP = getBitcodeModuleProvider(Buffer);
> @@ -558,8 +558,8 @@
>    }
>  
>    /// This method processes a linkage item. The item could be a
> -  /// Bytecode file needing translation to native code and that is
> -  /// dependent on other bytecode libraries, or a native code
> +  /// Bitcode file needing translation to native code and that is
> +  /// dependent on other bitcode libraries, or a native code
>    /// library that should just be linked into the program.
>    bool ProcessLinkageItem(const llvm::sys::Path& link_item,
>                            SetVector<sys::Path>& set,
> @@ -586,11 +586,11 @@
>      // If we got here fullpath is the path to the file, and its readable.
>      set.insert(fullpath);
>  
> -    // If its an LLVM bytecode file ...
> -    if (fullpath.isBytecodeFile()) {
> +    // If its an LLVM bitcode file ...
> +    if (fullpath.isBitcodeFile()) {
>        // Process the dependent libraries recursively
>        Module::LibraryListType modlibs;
> -      if (GetBytecodeDependentLibraries(fullpath.toString(),modlibs,
&err)) {
> +      if (GetBitcodeDependentLibraries(fullpath.toString(),modlibs,
&err)) {
>          // Traverse the dependent libraries list
>          Module::lib_iterator LI = modlibs.begin();
>          Module::lib_iterator LE = modlibs.end();
> @@ -675,7 +675,7 @@
>          // Get the suffix of the file name
>          const std::string& ftype = I->second;
>  
> -        // If its a library, bytecode file, or object file, save
> +        // If its a library, bitcode file, or object file, save
>          // it for linking below and short circuit the
>          // pre-processing/translation/assembly phases
>          if (ftype.empty() ||  ftype == "o" || ftype ==
"bc" || ftype=="a") {
> @@ -771,7 +771,7 @@
>              // ll -> bc Helper
>              if (action.isSet(OUTPUT_IS_ASM_FLAG)) {
>                /// The output of the translator is an LLVM Assembly program
> -              /// We need to translate it to bytecode
> +              /// We need to translate it to bitcode
>                Action* action = new Action();
>                action->program.set("llvm-as");
>                action->args.push_back(InFile.toString());
> @@ -816,7 +816,7 @@
>                // ll -> bc Helper
>                if (action.isSet(OUTPUT_IS_ASM_FLAG)) {
>                  /// The output of the optimizer is an LLVM Assembly
program
> -                /// We need to translate it to bytecode with llvm-as
> +                /// We need to translate it to bitcode with llvm-as
>                  Action* action = new Action();
>                  action->program.set("llvm-as");
>                  action->args.push_back(InFile.toString());
> Index: tools/llvmc/CompilerDriver.h
> ==================================================================> ---
tools/llvmc/CompilerDriver.h	(revision 37888)
> +++ tools/llvmc/CompilerDriver.h	(working copy)
> @@ -43,10 +43,10 @@
>        /// @brief The phases of processing that llvmc understands
>        enum Phases {
>          PREPROCESSING, ///< Source language combining, filtering,
substitution
> -        TRANSLATION,   ///< Translate source -> LLVM
bytecode/assembly
> +        TRANSLATION,   ///< Translate source -> LLVM
bitcode/assembly
>          OPTIMIZATION,  ///< Optimize translation result
>          ASSEMBLY,      ///< Convert program to executable
> -        LINKING,       ///< Link bytecode and native code
> +        LINKING,       ///< Link bitcode and native code
>          NUM_PHASES     ///< Always last!
>        };
>  
> @@ -129,7 +129,7 @@
>          TIME_ACTIONS_FLAG    = 0x0010, ///< Time the actions as they
execute
>          SHOW_STATS_FLAG      = 0x0020, ///< Show pass statistics
>          EMIT_NATIVE_FLAG     = 0x0040, ///< Emit native code instead of
bc
> -        EMIT_RAW_FLAG        = 0x0080, ///< Emit raw, unoptimized
bytecode
> +        EMIT_RAW_FLAG        = 0x0080, ///< Emit raw, unoptimized
bitcode
>          KEEP_TEMPS_FLAG      = 0x0100, ///< Don't delete temporary
files
>          STRIP_OUTPUT_FLAG    = 0x0200, ///< Strip symbols from linked
output
>          DRIVER_FLAGS_MASK    = 0x03FF  ///< Union of the above flags
> Index: tools/llvm-prof/llvm-prof.cpp
> ==================================================================> ---
tools/llvm-prof/llvm-prof.cpp	(revision 37888)
> +++ tools/llvm-prof/llvm-prof.cpp	(working copy)
> @@ -32,8 +32,8 @@
>  
>  namespace {
>    cl::opt<std::string>
> -  BytecodeFile(cl::Positional, cl::desc("<program bytecode
file>"),
> -               cl::Required);
> +  BitcodeFile(cl::Positional, cl::desc("<program bitcode
file>"),
> +              cl::Required);
>  
>    cl::opt<std::string>
>    ProfileDataFile(cl::Positional, cl::desc("<llvmprof.out
file>"),
> @@ -115,16 +115,16 @@
>      cl::ParseCommandLineOptions(argc, argv, " llvm profile dump
decoder\n");
>      sys::PrintStackTraceOnErrorSignal();
>  
> -    // Read in the bytecode file...
> +    // Read in the bitcode file...
>      std::string ErrorMessage;
>      Module *M = 0;
> -    if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(BytecodeFile,
> +    if (MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(BitcodeFile,
>                                                             
&ErrorMessage)) {
>        M = ParseBitcodeFile(Buffer, &ErrorMessage);
>        delete Buffer;
>      }
>      if (M == 0) {
> -      std::cerr << argv[0] << ": " <<
BytecodeFile << ": "
> +      std::cerr << argv[0] << ": " <<
BitcodeFile << ": "
>          << ErrorMessage << "\n";
>        return 1;
>      }
> Index: lib/Archive/ArchiveWriter.cpp
> ==================================================================> ---
lib/Archive/ArchiveWriter.cpp	(revision 37888)
> +++ lib/Archive/ArchiveWriter.cpp	(working copy)
> @@ -7,7 +7,7 @@
>  //
> 
//===----------------------------------------------------------------------===//
>  //
> -// Builds up an LLVM archive file (.a) containing LLVM bytecode.
> +// Builds up an LLVM archive file (.a) containing LLVM bitcode.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> @@ -222,7 +222,7 @@
>    }
>  
>    // Now that we have the data in memory, update the
> -  // symbol table if its a bytecode file.
> +  // symbol table if its a bitcode file.
>    if (CreateSymbolTable &&
>        (member.isBytecode() || member.isCompressedBytecode())) {
>      std::vector<std::string> symbols;
> @@ -230,10 +230,10 @@
>        member.getPath().toString()
>        + ")";
>      ModuleProvider* MP = 
> -      GetBytecodeSymbols((const unsigned char*)data,fSize,
> -                         FullMemberName, symbols, ErrMsg);
> +      GetBitcodeSymbols((const unsigned char*)data,fSize,
> +                        FullMemberName, symbols, ErrMsg);
>  
> -    // If the bytecode parsed successfully
> +    // If the bitcode parsed successfully
>      if ( MP ) {
>        for (std::vector<std::string>::iterator SI = symbols.begin(),
>             SE = symbols.end(); SI != SE; ++SI) {
> @@ -255,7 +255,7 @@
>          delete mFile;
>        }
>        if (ErrMsg)
> -        *ErrMsg = "Can't parse bytecode member: " +
member.getPath().toString()
> +        *ErrMsg = "Can't parse bitcode member: " +
member.getPath().toString()
>            + ": " + *ErrMsg;
>        return true;
>      }
> Index: lib/Archive/Archive.cpp
> ==================================================================> ---
lib/Archive/Archive.cpp	(revision 37888)
> +++ lib/Archive/Archive.cpp	(working copy)
> @@ -210,10 +210,10 @@
>          symbols.push_back(FI->getName());
>  }
>  
> -// Get just the externally visible defined symbols from the bytecode
> -bool llvm::GetBytecodeSymbols(const sys::Path& fName,
> -                              std::vector<std::string>& symbols,
> -                              std::string* ErrMsg) {
> +// Get just the externally visible defined symbols from the bitcode
> +bool llvm::GetBitcodeSymbols(const sys::Path& fName,
> +                             std::vector<std::string>& symbols,
> +                             std::string* ErrMsg) {
>    std::auto_ptr<MemoryBuffer> Buffer(
>                        
MemoryBuffer::getFileOrSTDIN(&fName.toString()[0],
>                                                     
fName.toString().size()));
> @@ -242,10 +242,10 @@
>  }
>  
>  ModuleProvider*
> -llvm::GetBytecodeSymbols(const unsigned char *BufPtr, unsigned Length,
> -                         const std::string& ModuleID,
> -                         std::vector<std::string>& symbols,
> -                         std::string* ErrMsg) {
> +llvm::GetBitcodeSymbols(const unsigned char *BufPtr, unsigned Length,
> +                        const std::string& ModuleID,
> +                        std::vector<std::string>& symbols,
> +                        std::string* ErrMsg) {
>    // Get the module provider
>    MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(Length,
ModuleID.c_str());
>    memcpy((char*)Buffer->getBufferStart(), BufPtr, Length);
> Index: lib/Archive/ArchiveReader.cpp
> ==================================================================> ---
lib/Archive/ArchiveReader.cpp	(revision 37888)
> +++ lib/Archive/ArchiveReader.cpp	(working copy)
> @@ -7,7 +7,7 @@
>  //
> 
//===----------------------------------------------------------------------===//
>  //
> -// Builds up standard unix archive files (.a) containing LLVM bytecode.
> +// Builds up standard unix archive files (.a) containing LLVM bitcode.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> @@ -109,7 +109,7 @@
>    // it will accept them. If the name starts with #1/ and the remainder is
>    // digits, then those digits specify the length of the name that is
>    // stored immediately following the header. The special name
> -  // __LLVM_SYM_TAB__ identifies the symbol table for LLVM bytecode.
> +  // __LLVM_SYM_TAB__ identifies the symbol table for LLVM bitcode.
>    // Anything else is a regular, short filename that is terminated with
>    // a '/' and blanks.
>  
> @@ -344,7 +344,7 @@
>    return result.release();
>  }
>  
> -// Get all the bytecode modules from the archive
> +// Get all the bitcode modules from the archive
>  bool
>  Archive::getAllModules(std::vector<Module*>& Modules,
std::string* ErrMessage) {
>  
> @@ -487,7 +487,7 @@
>    if (!mbr)
>      return 0;
>  
> -  // Now, load the bytecode module to get the ModuleProvider
> +  // Now, load the bitcode module to get the ModuleProvider
>    std::string FullMemberName = archPath.toString() + "(" +
>      mbr->getPath().toString() + ")";
>    MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(mbr->getSize(),
> @@ -541,8 +541,8 @@
>          std::string FullMemberName = archPath.toString() + "(" +
>            mbr->getPath().toString() + ")";
>          ModuleProvider* MP = 
> -          GetBytecodeSymbols((const unsigned char*)At, mbr->getSize(),
> -                             FullMemberName, symbols, error);
> +          GetBitcodeSymbols((const unsigned char*)At, mbr->getSize(),
> +                            FullMemberName, symbols, error);
>  
>          if (MP) {
>            // Insert the module's symbols into the symbol table
> @@ -555,7 +555,7 @@
>            modules.insert(std::make_pair(offset, std::make_pair(MP, mbr)));
>          } else {
>            if (error)
> -            *error = "Can't parse bytecode member: " + 
> +            *error = "Can't parse bitcode member: " + 
>                mbr->getPath().toString() + ": " + *error;
>            delete mbr;
>            return false;
> @@ -591,7 +591,7 @@
>    return true;
>  }
>  
> -bool Archive::isBytecodeArchive() {
> +bool Archive::isBitcodeArchive() {
>    // Make sure the symTab has been loaded. In most cases this should have
been
>    // done when the archive was constructed, but still,  this is just in
case.
>    if (!symTab.size())
> @@ -602,14 +602,14 @@
>    // if it has a size
>    if (symTab.size()) return true;
>  
> -  //We still can't be sure it isn't a bytecode archive
> +  // We still can't be sure it isn't a bitcode archive
>    if (!loadArchive(0))
>      return false;
>  
>    std::vector<Module *> Modules;
>    std::string ErrorMessage;
>  
> -  // Scan the archive, trying to load a bytecode member.  We only load one
to
> +  // Scan the archive, trying to load a bitcode member.  We only load one
to
>    // see if this works.
>    for (iterator I = begin(), E = end(); I != E; ++I) {
>      if (!I->isBytecode() && !I->isCompressedBytecode())
> @@ -624,7 +624,7 @@
>      Module *M = ParseBitcodeFile(Buffer);
>      delete Buffer;
>      if (!M)
> -      return false;  // Couldn't parse bytecode, not a bytecode
archive.
> +      return false;  // Couldn't parse bitcode, not a bitcode archive.
>      delete M;
>      return true;
>    }
> Index: lib/Archive/ArchiveInternals.h
> ==================================================================> ---
lib/Archive/ArchiveInternals.h	(revision 37888)
> +++ lib/Archive/ArchiveInternals.h	(working copy)
> @@ -1,4 +1,4 @@
> -//===-- lib/Bytecode/ArchiveInternals.h -------------------------*- C++
-*-===//
> +//===-- lib/Archive/ArchiveInternals.h -------------------------*- C++
-*-===//
>  //
>  //                     The LLVM Compiler Infrastructure
>  //
> @@ -11,8 +11,8 @@
>  //
> 
//===----------------------------------------------------------------------===//
>  
> -#ifndef LIB_BYTECODE_ARCHIVEINTERNALS_H
> -#define LIB_BYTECODE_ARCHIVEINTERNALS_H
> +#ifndef LIB_ARCHIVE_ARCHIVEINTERNALS_H
> +#define LIB_ARCHIVE_ARCHIVEINTERNALS_H
>  
>  #include "llvm/Bitcode/Archive.h"
>  #include "llvm/System/TimeValue.h"
> @@ -29,7 +29,7 @@
>  
>  namespace llvm {
>  
> -  /// The ArchiveMemberHeader structure is used internally for bytecode
> +  /// The ArchiveMemberHeader structure is used internally for bitcode
>    /// archives.
>    /// The header precedes each file member in the archive. This structure
is
>    /// defined using character arrays for direct and correct interpretation
> @@ -67,15 +67,15 @@
>      }
>    };
>    
> -  // Get just the externally visible defined symbols from the bytecode
> -  bool GetBytecodeSymbols(const sys::Path& fName,
> +  // Get just the externally visible defined symbols from the bitcode
> +  bool GetBitcodeSymbols(const sys::Path& fName,
>                            std::vector<std::string>& symbols,
>                            std::string* ErrMsg);
>    
> -  ModuleProvider* GetBytecodeSymbols(const unsigned char*Buffer,unsigned
Length,
> -                                     const std::string& ModuleID,
> -                                     std::vector<std::string>&
symbols,
> -                                     std::string* ErrMsg);
> +  ModuleProvider* GetBitcodeSymbols(const unsigned char*Buffer,unsigned
Length,
> +                                    const std::string& ModuleID,
> +                                    std::vector<std::string>&
symbols,
> +                                    std::string* ErrMsg);
>  }
>  
>  #endif
> Index: lib/CodeGen/ELFWriter.h
> ==================================================================> ---
lib/CodeGen/ELFWriter.h	(revision 37888)
> +++ lib/CodeGen/ELFWriter.h	(working copy)
> @@ -90,7 +90,7 @@
>  
>    private:
>      // The buffer we accumulate the file header into.  Note that this
should be
> -    // changed into something much more efficient later (and the bytecode
writer
> +    // changed into something much more efficient later (and the bitcode
writer
>      // as well!).
>      DataBuffer FileHeader;
>  
> Index: lib/Linker/LinkItems.cpp
> ==================================================================> ---
lib/Linker/LinkItems.cpp	(revision 37888)
> +++ lib/Linker/LinkItems.cpp	(working copy)
> @@ -7,7 +7,7 @@
>  //
> 
//===----------------------------------------------------------------------===//
>  //
> -// This file contains routines to handle linking together LLVM bytecode
files,
> +// This file contains routines to handle linking together LLVM bitcode
files,
>  // and to handle annoying things like static libraries.
>  //
> 
//===----------------------------------------------------------------------===//
> @@ -20,7 +20,7 @@
>  // LinkItems - This function is the main entry point into linking. It
takes a
>  // list of LinkItem which indicates the order the files should be linked
and
>  // how each file should be treated (plain file or with library search).
The
> -// function only links bytecode and produces a result list of items that
are
> +// function only links bitcode and produces a result list of items that
are
>  // native objects. 
>  bool
>  Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems)
{
> @@ -109,7 +109,7 @@
>  }
>  
>  /// LinkLibraries - takes the specified library files and links them into
the
> -/// main bytecode object file.
> +/// main bitcode object file.
>  ///
>  /// Inputs:
>  ///  Libraries  - The list of libraries to link into the module.
> @@ -140,11 +140,11 @@
>    return false;
>  }
>  
> -/// LinkInFile - opens a bytecode file and links in all objects which
> +/// LinkInFile - opens a bitcode file and links in all objects which
>  /// provide symbols that are currently undefined.
>  ///
>  /// Inputs:
> -///  File - The pathname of the bytecode file.
> +///  File - The pathname of the bitcode file.
>  ///
>  /// Outputs:
>  ///  ErrorMessage - A C++ string detailing what error occurred, if any.
> @@ -179,7 +179,7 @@
>      case sys::Bitcode_FileType:
>      case sys::Bytecode_FileType:
>      case sys::CompressedBytecode_FileType: {
> -      verbose("Linking bytecode file '" + File.toString() +
"'");
> +      verbose("Linking bitcode file '" + File.toString() +
"'");
>        std::auto_ptr<Module> M(LoadObject(File));
>        if (M.get() == 0)
>          return error("Cannot load file '" + File.toString()
+ "'" + Error);
> @@ -208,9 +208,9 @@
>  /// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH.
>  ///
>  /// Inputs:
> -///  Files      - A vector of sys::Path indicating the LLVM bytecode
filenames
> +///  Files      - A vector of sys::Path indicating the LLVM bitcode
filenames
>  ///               to be linked.  The names can refer to a mixture of pure
LLVM
> -///               bytecode files and archive (ar) formatted files.
> +///               bitcode files and archive (ar) formatted files.
>  ///
>  /// Return value:
>  ///  FALSE - No errors.
> Index: lib/Linker/LinkArchives.cpp
> ==================================================================> ---
lib/Linker/LinkArchives.cpp	(revision 37888)
> +++ lib/Linker/LinkArchives.cpp	(working copy)
> @@ -117,7 +117,7 @@
>    if (!arch)
>      return error("Cannot read archive '" +
Filename.toString() +
>                   "': " + ErrMsg);
> -  if (!arch->isBytecodeArchive()) {
> +  if (!arch->isBitcodeArchive()) {
>      is_native = true;
>      return false;
>    }
> Index: lib/Linker/Linker.cpp
> ==================================================================> ---
lib/Linker/Linker.cpp	(revision 37888)
> +++ lib/Linker/Linker.cpp	(working copy)
> @@ -80,7 +80,7 @@
>  
>  void
>  Linker::addSystemPaths() {
> -  sys::Path::GetBytecodeLibraryPaths(LibPaths);
> +  sys::Path::GetBitcodeLibraryPaths(LibPaths);
>    LibPaths.insert(LibPaths.begin(),sys::Path("./"));
>  }
>  
> @@ -94,7 +94,7 @@
>    return result;
>  }
>  
> -// LoadObject - Read in and parse the bytecode file named by FN and return
the
> +// LoadObject - Read in and parse the bitcode file named by FN and return
the
>  // module it contains (wrapped in an auto_ptr), or
auto_ptr<Module>() and set
>  // Error if an error occurs.
>  std::auto_ptr<Module>
> @@ -112,7 +112,7 @@
>      
>    if (Result)
>      return std::auto_ptr<Module>(Result);
> -  Error = "Bytecode file '" + FN.toString() + "'
could not be loaded";
> +  Error = "Bitcode file '" + FN.toString() + "'
could not be loaded";
>    if (ParseErrorMessage.size())
>      Error += ": " + ParseErrorMessage;
>    return std::auto_ptr<Module>();
> Index: lib/System/Unix/Path.inc
> ==================================================================> ---
lib/System/Unix/Path.inc	(revision 37888)
> +++ lib/System/Unix/Path.inc	(working copy)
> @@ -218,7 +218,7 @@
>  }
>  
>  void
> -Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
> +Path::GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths) {
>    char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
>    if (env_var != 0) {
>      getPathList(env_var,Paths);
> Index: lib/Target/PowerPC/PPCCodeEmitter.cpp
> ==================================================================> ---
lib/Target/PowerPC/PPCCodeEmitter.cpp	(revision 37888)
> +++ lib/Target/PowerPC/PPCCodeEmitter.cpp	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This file defines the PowerPC 32-bit CodeEmitter and associated
machinery to
> -// JIT-compile bytecode to native PowerPC.
> +// JIT-compile bitcode to native PowerPC.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> Index: lib/Target/PowerPC/PPCSubtarget.cpp
> ==================================================================> ---
lib/Target/PowerPC/PPCSubtarget.cpp	(revision 37888)
> +++ lib/Target/PowerPC/PPCSubtarget.cpp	(working copy)
> @@ -137,5 +137,5 @@
>      return false;
>    
>    return GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
> -         (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBytecode());
> +         (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBitcode());
>  }
> Index: lib/Target/ARM/ARMISelLowering.cpp
> ==================================================================> ---
lib/Target/ARM/ARMISelLowering.cpp	(revision 37888)
> +++ lib/Target/ARM/ARMISelLowering.cpp	(working copy)
> @@ -824,7 +824,7 @@
>  static bool GVIsIndirectSymbol(GlobalValue *GV, Reloc::Model RelocM) {
>    return RelocM != Reloc::Static &&
>      (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
> -     (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBytecode()));
> +     (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBitcode()));
>  }
>  
>  SDOperand ARMTargetLowering::LowerGlobalAddressDarwin(SDOperand Op,
> Index: lib/Target/X86/X86Subtarget.cpp
> ==================================================================> ---
lib/Target/X86/X86Subtarget.cpp	(revision 37888)
> +++ lib/Target/X86/X86Subtarget.cpp	(working copy)
> @@ -40,7 +40,7 @@
>      if (isTargetDarwin()) {
>        return (!isDirectCall &&
>                (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
> -               (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBytecode())));
> +               (GV->isDeclaration() &&
!GV->hasNotBeenReadFromBitcode())));
>      } else if (TM.getRelocationModel() == Reloc::PIC_ &&
isPICStyleGOT()) {
>        // Extra load is needed for all non-statics.
>        return (!isDirectCall &&
> Index: lib/Bitcode/Reader/BitcodeReader.cpp
> ==================================================================> ---
lib/Bitcode/Reader/BitcodeReader.cpp	(revision 37888)
> +++ lib/Bitcode/Reader/BitcodeReader.cpp	(working copy)
> @@ -1564,7 +1564,7 @@
>  
>  bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo)
{
>    // If it already is material, ignore the request.
> -  if (!F->hasNotBeenReadFromBytecode()) return false;
> +  if (!F->hasNotBeenReadFromBitcode()) return false;
>    
>    DenseMap<Function*, std::pair<uint64_t, unsigned>
>::iterator DFII =
>      DeferredFunctionInfo.find(F);
> @@ -1585,7 +1585,7 @@
>  
>  void BitcodeReader::dematerializeFunction(Function *F) {
>    // If this function isn't materialized, or if it is a proto, this is
a noop.
> -  if (F->hasNotBeenReadFromBytecode() || F->isDeclaration())
> +  if (F->hasNotBeenReadFromBitcode() || F->isDeclaration())
>      return;
>    
>    assert(DeferredFunctionInfo.count(F) && "No info to read
function later?");
> @@ -1601,7 +1601,7 @@
>         DeferredFunctionInfo.begin(), E = DeferredFunctionInfo.end(); I !=
E;
>         ++I) {
>      Function *F = I->first;
> -    if (F->hasNotBeenReadFromBytecode() &&
> +    if (F->hasNotBeenReadFromBitcode() &&
>          materializeFunction(F, ErrInfo))
>        return 0;
>    }
> Index: lib/ExecutionEngine/JIT/JITEmitter.cpp
> ==================================================================> ---
lib/ExecutionEngine/JIT/JITEmitter.cpp	(revision 37888)
> +++ lib/ExecutionEngine/JIT/JITEmitter.cpp	(working copy)
> @@ -543,7 +543,7 @@
>    // Call the lazy resolver function unless we already KNOW it is an
external
>    // function, in which case we just skip the lazy resolution step.
>    void *Actual = (void*)(intptr_t)LazyResolverFn;
> -  if (F->isDeclaration() &&
!F->hasNotBeenReadFromBytecode())
> +  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode())
>      Actual = TheJIT->getPointerToFunction(F);
>  
>    // Otherwise, codegen a new stub.  For now, the stub will call the lazy
> @@ -762,7 +762,7 @@
>    void *ResultPtr = TheJIT->getPointerToGlobalIfAvailable(F);
>    if (ResultPtr) return ResultPtr;
>  
> -  if (F->isDeclaration() &&
!F->hasNotBeenReadFromBytecode()) {
> +  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode())
{
>      // If this is an external function pointer, we can force the JIT to
>      // 'compile' it, which really just adds it to the map.
>      if (DoesntNeedStub)
> Index: lib/ExecutionEngine/JIT/JIT.cpp
> ==================================================================> ---
lib/ExecutionEngine/JIT/JIT.cpp	(revision 37888)
> +++ lib/ExecutionEngine/JIT/JIT.cpp	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This tool implements a just-in-time compiler for LLVM, allowing direct
> -// execution of LLVM bytecode in an efficient manner.
> +// execution of LLVM bitcode in an efficient manner.
>  //
> 
//===----------------------------------------------------------------------===//
>  
> @@ -258,7 +258,7 @@
>      return Addr;   // Check if function already code gen'd
>  
>    // Make sure we read in the function if it exists in this Module.
> -  if (F->hasNotBeenReadFromBytecode()) {
> +  if (F->hasNotBeenReadFromBitcode()) {
>      // Determine the module provider this function is provided by.
>      Module *M = F->getParent();
>      ModuleProvider *MP = 0;
> @@ -273,7 +273,7 @@
>      std::string ErrorMsg;
>      if (MP->materializeFunction(F, &ErrorMsg)) {
>        cerr << "Error reading function '" <<
F->getName()
> -           << "' from bytecode file: " <<
ErrorMsg << "\n";
> +           << "' from bitcode file: " <<
ErrorMsg << "\n";
>        abort();
>      }
>    }
> Index: lib/VMCore/PassManager.cpp
> ==================================================================> ---
lib/VMCore/PassManager.cpp	(revision 37888)
> +++ lib/VMCore/PassManager.cpp	(working copy)
> @@ -1037,7 +1037,7 @@
>  bool FunctionPassManager::run(Function &F) {
>    std::string errstr;
>    if (MP->materializeFunction(&F, &errstr)) {
> -    cerr << "Error reading bytecode file: " <<
errstr << "\n";
> +    cerr << "Error reading bitcode file: " << errstr
<< "\n";
>      abort();
>    }
>    return FPM->run(F);
> Index: lib/Support/SystemUtils.cpp
> ==================================================================> ---
lib/Support/SystemUtils.cpp	(revision 37888)
> +++ lib/Support/SystemUtils.cpp	(working copy)
> @@ -19,14 +19,14 @@
>  #include <ostream>
>  using namespace llvm;
>  
> -bool llvm::CheckBytecodeOutputToConsole(std::ostream* stream_to_check,
> -                                        bool print_warning) {
> +bool llvm::CheckBitcodeOutputToConsole(std::ostream* stream_to_check,
> +                                       bool print_warning) {
>    if (stream_to_check == cout.stream() &&
>        sys::Process::StandardOutIsDisplayed()) {
>      if (print_warning) {
> -      cerr << "WARNING: You're attempting to print out a
bytecode file.\n"
> +      cerr << "WARNING: You're attempting to print out a
bitcode file.\n"
>             << "This is inadvisable as it may cause display
problems. If\n"
> -           << "you REALLY want to taste LLVM bytecode
first-hand, you\n"
> +           << "you REALLY want to taste LLVM bitcode
first-hand, you\n"
>             << "can force output with the `-f'
option.\n\n";
>      }
>      return true;
> Index: examples/ModuleMaker/ModuleMaker.cpp
> ==================================================================> ---
examples/ModuleMaker/ModuleMaker.cpp	(revision 37888)
> +++ examples/ModuleMaker/ModuleMaker.cpp	(working copy)
> @@ -8,7 +8,7 @@
> 
//===----------------------------------------------------------------------===//
>  //
>  // This programs is a simple example that creates an LLVM module
"from scratch",
> -// emitting it as a bytecode file to standard out.  This is just to show
how
> +// emitting it as a bitcode file to standard out.  This is just to show
how
>  // LLVM projects work and to demonstrate some of the LLVM APIs.
>  //
> 
//===----------------------------------------------------------------------===//
> @@ -52,7 +52,7 @@
>    // Create the return instruction and add it to the basic block
>    BB->getInstList().push_back(new ReturnInst(Add));
>  
> -  // Output the bytecode file to stdout
> +  // Output the bitcode file to stdout
>    WriteBitcodeToFile(M, std::cout);
>  
>    // Delete the module and all of its contents.
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

Chris Lattner

2007-Jul-05 15:30 UTC

head link

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

On Thu, 5 Jul 2007, Gabor Greif wrote:> Here is the bulk of the sanitizing.
Nice, thanks Gabor!
> My residual doubts center around the question
> whether we still do/want to support (un)compressed *byte*code
> in 2.0/2.1.
> I need a definitive word on this to proceed.
There is now no longer a distinction between compressed and uncompressed 
bitcode.  We just have bitcode, which has one format.
> My understanding is that bytecode is already gone, but there are still 
> some functions/enums that really deal with *byte*code (instead of 
> *bit*code). I did not touch those areas, so the attached patch is for 
> review about the IMO undisputed changes.
Ok.  These sorts of changes are also good to do.
> If anybody feels the urge to review the attached patch, feel free
> and concentrate on Path.h/cpp and friends.
>
> I plan to commit this late today or tomorrow (given that all the tests 
> pass).
This looks good to me!

-Chris

-- 
http://nondot.org/sabre/
http://llvm.org/

Maybe Matching Threads

Search for more maybe matching threads

llvm dev - Jul 2007 - [LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

[LLVMdev] PATCH (rest of code changes) "bytecode" --> "bitcode"

Maybe Matching Threads