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
diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index 6fabc5c..d0c6409 100644
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -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);
diff --git a/lib/Archive/ArchiveInternals.h b/lib/Archive/ArchiveInternals.h
index 4642f7a..8648bbb 100644
--- a/lib/Archive/ArchiveInternals.h
+++ b/lib/Archive/ArchiveInternals.h
@@ -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
diff --git a/lib/Archive/ArchiveReader.cpp b/lib/Archive/ArchiveReader.cpp
index c38389e..93eaac1 100644
--- a/lib/Archive/ArchiveReader.cpp
+++ b/lib/Archive/ArchiveReader.cpp
@@ -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;
}
diff --git a/lib/Archive/ArchiveWriter.cpp b/lib/Archive/ArchiveWriter.cpp
index 051d31f..d67937e 100644
--- a/lib/Archive/ArchiveWriter.cpp
+++ b/lib/Archive/ArchiveWriter.cpp
@@ -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;
}
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 7408580..b040df3 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -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;
}
diff --git a/lib/CodeGen/ELFWriter.h b/lib/CodeGen/ELFWriter.h
index 04cd177..f27d78f 100644
--- a/lib/CodeGen/ELFWriter.h
+++ b/lib/CodeGen/ELFWriter.h
@@ -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;
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index cb698c3..603f8ec 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -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();
}
}
diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp
index fc746d6..840af59 100644
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -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)
diff --git a/lib/Linker/LinkArchives.cpp b/lib/Linker/LinkArchives.cpp
index 416b285..381d0e7 100644
--- a/lib/Linker/LinkArchives.cpp
+++ b/lib/Linker/LinkArchives.cpp
@@ -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;
}
diff --git a/lib/Linker/LinkItems.cpp b/lib/Linker/LinkItems.cpp
index 50efe46..e66fa5b 100644
--- a/lib/Linker/LinkItems.cpp
+++ b/lib/Linker/LinkItems.cpp
@@ -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.
diff --git a/lib/Linker/Linker.cpp b/lib/Linker/Linker.cpp
index 077bcd7..4604305 100644
--- a/lib/Linker/Linker.cpp
+++ b/lib/Linker/Linker.cpp
@@ -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>();
diff --git a/lib/Support/SystemUtils.cpp b/lib/Support/SystemUtils.cpp
index 30b9f8d..afa0d7e 100644
--- a/lib/Support/SystemUtils.cpp
+++ b/lib/Support/SystemUtils.cpp
@@ -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;
diff --git a/lib/System/Unix/Path.inc b/lib/System/Unix/Path.inc
index db95e3c..e4916ba 100644
--- a/lib/System/Unix/Path.inc
+++ b/lib/System/Unix/Path.inc
@@ -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);
diff --git a/lib/Target/ARM/ARMISelLowering.cpp b/lib/Target/ARM/ARMISelLowering.cpp
index 6f67d66..6f63fbd 100644
--- a/lib/Target/ARM/ARMISelLowering.cpp
+++ b/lib/Target/ARM/ARMISelLowering.cpp
@@ -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,
diff --git a/lib/Target/PowerPC/PPCCodeEmitter.cpp b/lib/Target/PowerPC/PPCCodeEmitter.cpp
index 446e031..5dceffd 100644
--- a/lib/Target/PowerPC/PPCCodeEmitter.cpp
+++ b/lib/Target/PowerPC/PPCCodeEmitter.cpp
@@ -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.
//
//===----------------------------------------------------------------------===//
diff --git a/lib/Target/PowerPC/PPCSubtarget.cpp b/lib/Target/PowerPC/PPCSubtarget.cpp
index 62f8995..4419d20 100644
--- a/lib/Target/PowerPC/PPCSubtarget.cpp
+++ b/lib/Target/PowerPC/PPCSubtarget.cpp
@@ -137,5 +137,5 @@
return false;
return GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
- (GV->isDeclaration() && !GV->hasNotBeenReadFromBytecode());
+ (GV->isDeclaration() && !GV->hasNotBeenReadFromBitcode());
}
diff --git a/lib/Target/X86/X86Subtarget.cpp b/lib/Target/X86/X86Subtarget.cpp
index 124c97a..1a75e04 100644
--- a/lib/Target/X86/X86Subtarget.cpp
+++ b/lib/Target/X86/X86Subtarget.cpp
@@ -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 &&
diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index f257a07..23e45c0b 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -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);