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
[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
[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
- [LLVMdev] [patch] gccld not passing -export-dynamic to gcc for link
- [LLVMdev] Problem linking and JITing code through C++-API
- [LLVMdev] Problem linking and JITing code through C++-API
- [LLVMdev] Problem linking and JITing code through C++-API
- [LLVMdev] questions about context