Here is the bulk of the sanitizing.
Almost all occurrences of "bytecode" in the sources have been eliminated.
llvm-svn: 37913
diff --git a/llvm/include/llvm/AbstractTypeUser.h b/llvm/include/llvm/AbstractTypeUser.h
index fe51eff..2b643ab 100644
--- a/llvm/include/llvm/AbstractTypeUser.h
+++ b/llvm/include/llvm/AbstractTypeUser.h
@@ -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.
diff --git a/llvm/include/llvm/Analysis/ConstantsScanner.h b/llvm/include/llvm/Analysis/ConstantsScanner.h
index 1f71f39..9ea9ed6 100644
--- a/llvm/include/llvm/Analysis/ConstantsScanner.h
+++ b/llvm/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/llvm/include/llvm/Bitcode/Archive.h b/llvm/include/llvm/Bitcode/Archive.h
index 26dcf60..eee3922 100644
--- a/llvm/include/llvm/Bitcode/Archive.h
+++ b/llvm/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 @@
/// @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
diff --git a/llvm/include/llvm/GlobalValue.h b/llvm/include/llvm/GlobalValue.h
index d2d9130..6735cb5 100644
--- a/llvm/include/llvm/GlobalValue.h
+++ b/llvm/include/llvm/GlobalValue.h
@@ -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.
diff --git a/llvm/include/llvm/Linker.h b/llvm/include/llvm/Linker.h
index 66a8483..cc0372d 100644
--- a/llvm/include/llvm/Linker.h
+++ b/llvm/include/llvm/Linker.h
@@ -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);
diff --git a/llvm/include/llvm/Support/SystemUtils.h b/llvm/include/llvm/Support/SystemUtils.h
index 93432b5..6dc5c27 100644
--- a/llvm/include/llvm/Support/SystemUtils.h
+++ b/llvm/include/llvm/Support/SystemUtils.h
@@ -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
);
diff --git a/llvm/include/llvm/System/Path.h b/llvm/include/llvm/System/Path.h
index 97876a3..537a5af 100644
--- a/llvm/include/llvm/System/Path.h
+++ b/llvm/include/llvm/System/Path.h
@@ -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.
diff --git a/llvm/include/llvm/Type.h b/llvm/include/llvm/Type.h
index d19bec2..cf1c64f 100644
--- a/llvm/include/llvm/Type.h
+++ b/llvm/include/llvm/Type.h
@@ -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