aboutsummaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/Archive/Archive.cpp16
-rw-r--r--lib/Archive/ArchiveInternals.h20
-rw-r--r--lib/Archive/ArchiveReader.cpp22
-rw-r--r--lib/Archive/ArchiveWriter.cpp12
-rw-r--r--lib/Bitcode/Reader/BitcodeReader.cpp6
-rw-r--r--lib/CodeGen/ELFWriter.h2
-rw-r--r--lib/ExecutionEngine/JIT/JIT.cpp6
-rw-r--r--lib/ExecutionEngine/JIT/JITEmitter.cpp4
-rw-r--r--lib/Linker/LinkArchives.cpp2
-rw-r--r--lib/Linker/LinkItems.cpp16
-rw-r--r--lib/Linker/Linker.cpp6
-rw-r--r--lib/Support/SystemUtils.cpp8
-rw-r--r--lib/System/Unix/Path.inc2
-rw-r--r--lib/Target/ARM/ARMISelLowering.cpp2
-rw-r--r--lib/Target/PowerPC/PPCCodeEmitter.cpp2
-rw-r--r--lib/Target/PowerPC/PPCSubtarget.cpp2
-rw-r--r--lib/Target/X86/X86Subtarget.cpp2
-rw-r--r--lib/VMCore/PassManager.cpp2
18 files changed, 66 insertions, 66 deletions
diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index 6fabc5c862..d0c64097a2 100644
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -210,10 +210,10 @@ static void getSymbols(Module*M, std::vector<std::string>& symbols) {
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 @@ bool llvm::GetBytecodeSymbols(const sys::Path& fName,
}
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 4642f7a30a..8648bbbf29 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 @@ namespace llvm {
}
};
- // 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 c38389e2d7..93eaac18f6 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 @@ Archive::parseMemberHeader(const char*& At, const char* End, std::string* error)
// 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 @@ Archive::OpenAndLoad(const sys::Path& file, std::string* ErrorMessage)
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 @@ Archive::findModuleDefiningSymbol(const std::string& symbol,
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 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
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 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
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 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
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 @@ bool Archive::isBytecodeArchive() {
// 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 @@ bool Archive::isBytecodeArchive() {
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 051d31fce9..d67937ea11 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 @@ Archive::writeMember(
}
// 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 @@ Archive::writeMember(
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 @@ Archive::writeMember(
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 7408580b23..b040df3383 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1564,7 +1564,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
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 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
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 @@ Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
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 04cd1773c1..f27d78f4f0 100644
--- a/lib/CodeGen/ELFWriter.h
+++ b/lib/CodeGen/ELFWriter.h
@@ -90,7 +90,7 @@ namespace llvm {
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 cb698c35d2..603f8ec14a 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 @@ void *JIT::getPointerToFunction(Function *F) {
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 @@ void *JIT::getPointerToFunction(Function *F) {
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 fc746d6df8..840af5997a 100644
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -543,7 +543,7 @@ void *JITResolver::getFunctionStub(Function *F) {
// 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 *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference,
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 416b2857db..381d0e7e5a 100644
--- a/lib/Linker/LinkArchives.cpp
+++ b/lib/Linker/LinkArchives.cpp
@@ -117,7 +117,7 @@ Linker::LinkInArchive(const sys::Path &Filename, bool &is_native) {
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 50efe46bd1..e66fa5b6e6 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 @@ using namespace llvm;
// 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 @@ bool Linker::LinkInLibrary(const std::string& Lib, bool& is_native) {
}
/// 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 @@ bool Linker::LinkInLibraries(const std::vector<std::string> &Libraries) {
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 @@ bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
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 @@ bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
/// 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 077bcd7ba6..4604305b6d 100644
--- a/lib/Linker/Linker.cpp
+++ b/lib/Linker/Linker.cpp
@@ -80,7 +80,7 @@ Linker::addPaths(const std::vector<std::string>& paths) {
void
Linker::addSystemPaths() {
- sys::Path::GetBytecodeLibraryPaths(LibPaths);
+ sys::Path::GetBitcodeLibraryPaths(LibPaths);
LibPaths.insert(LibPaths.begin(),sys::Path("./"));
}
@@ -94,7 +94,7 @@ Linker::releaseModule() {
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 @@ Linker::LoadObject(const sys::Path &FN) {
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 30b9f8d43d..afa0d7e961 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 db95e3c216..e4916baf28 100644
--- a/lib/System/Unix/Path.inc
+++ b/lib/System/Unix/Path.inc
@@ -218,7 +218,7 @@ Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
}
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 6f67d66e67..6f63fbdcb3 100644
--- a/lib/Target/ARM/ARMISelLowering.cpp
+++ b/lib/Target/ARM/ARMISelLowering.cpp
@@ -824,7 +824,7 @@ SDOperand ARMTargetLowering::LowerGlobalAddressELF(SDOperand Op,
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 446e0310fa..5dceffdb68 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 62f8995bb8..4419d200b9 100644
--- a/lib/Target/PowerPC/PPCSubtarget.cpp
+++ b/lib/Target/PowerPC/PPCSubtarget.cpp
@@ -137,5 +137,5 @@ bool PPCSubtarget::hasLazyResolverStub(const GlobalValue *GV) const {
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 124c97ac70..1a75e04511 100644
--- a/lib/Target/X86/X86Subtarget.cpp
+++ b/lib/Target/X86/X86Subtarget.cpp
@@ -40,7 +40,7 @@ bool X86Subtarget::GVRequiresExtraLoad(const GlobalValue* GV,
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 f257a07efb..23e45c0b95 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -1037,7 +1037,7 @@ void FunctionPassManager::add(Pass *P) {
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);
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-04-27 13:41:28 +0000