Here is the bulk of the sanitizing.

Almost all occurrences of "bytecode" in the sources have been eliminated.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37913 91177308-0d34-0410-b5e6-96231b3b80d8

8 files changed, 29 insertions, 29 deletions

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index fe51eff..2b643ab 100644
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -41,7 +41,7 @@ class DerivedType;
 ///
 /// 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.
diff --git a/include/llvm/Analysis/ConstantsScanner.h b/include/llvm/Analysis/ConstantsScanner.h
index 1f71f39..9ea9ed6 100644
--- a/include/llvm/Analysis/ConstantsScanner.h
+++ b/include/llvm/Analysis/ConstantsScanner.h
@@ -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.
 //
 //===----------------------------------------------------------------------===//
diff --git a/include/llvm/Bitcode/Archive.h b/include/llvm/Bitcode/Archive.h
index 26dcf60..eee3922 100644
--- a/include/llvm/Bitcode/Archive.h
+++ b/include/llvm/Bitcode/Archive.h
@@ -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 @@ class Archive {
     /// @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 @@ class Archive {
     );
 
     /// 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 @@ class Archive {
     /// 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 @@ class Archive {
     /// @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
diff --git a/include/llvm/GlobalValue.h b/include/llvm/GlobalValue.h
index d2d9130..6735cb5 100644
--- a/include/llvm/GlobalValue.h
+++ b/include/llvm/GlobalValue.h
@@ -108,12 +108,12 @@ public:
   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.
diff --git a/include/llvm/Linker.h b/include/llvm/Linker.h
index 66a8483..cc0372d 100644
--- a/include/llvm/Linker.h
+++ b/include/llvm/Linker.h
@@ -28,7 +28,7 @@ class Module;
 /// 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 @@ class Linker {
       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 @@ class Linker {
       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 @@ class Linker {
       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 @@ class Linker {
   /// @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);
 
diff --git a/include/llvm/Support/SystemUtils.h b/include/llvm/Support/SystemUtils.h
index 93432b5..6dc5c27 100644
--- a/include/llvm/Support/SystemUtils.h
+++ b/include/llvm/Support/SystemUtils.h
@@ -21,10 +21,10 @@ namespace llvm {
 
 /// 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
 );
diff --git a/include/llvm/System/Path.h b/include/llvm/System/Path.h
index 97876a3..537a5af 100644
--- a/include/llvm/System/Path.h
+++ b/include/llvm/System/Path.h
@@ -112,15 +112,15 @@ namespace sys {
       /// @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.
diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index d19bec2..cf1c64f 100644
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -52,7 +52,7 @@ class TypeMapBase;
 ///
 /// 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 @@ public:
     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