eliminate residual cruft related to recognizing bytecode

files.
bitcode files are the only LLVM format left.


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

include/llvm/Bitcode/Archive.h

@@ -51,8 +51,7 @@ class ArchiveMember {
       SVR4SymbolTableFlag = 2,     ///< Member is a SVR4 symbol table
       BSD4SymbolTableFlag = 4,     ///< Member is a BSD4 symbol table
       LLVMSymbolTableFlag = 8,     ///< Member is an LLVM symbol table
-      BytecodeFlag = 16,           ///< Member is uncompressed bytecode
+      BitcodeFlag = 16,            ///< Member is uncompressed bytecode
-      CompressedBytecodeFlag = 32, ///< Member is compressed bytecode
       HasPathFlag = 64,            ///< Member has a full or partial path
       HasLongFilenameFlag = 128,   ///< Member uses the long filename syntax
       StringTableFlag = 256        ///< Member is an ar(1) format string table
@@ -112,7 +111,6 @@ class ArchiveMember {
 
     /// This method determines if the member is a regular compressed file. Note
     /// that compressed bytecode files will yield "false" for this method.
-    /// @see isCompressedBytecode()
     /// @returns true iff the archive member is a compressed regular file.
     /// @brief Determine if the member is a compressed regular file.
     bool isCompressed() const { return flags&CompressedFlag; }
@@ -135,11 +133,7 @@ class ArchiveMember {
 
     /// @returns true iff the archive member is an uncompressed bytecode file.
     /// @brief Determine if this member is a bytecode file.
-    bool isBytecode() const { return flags&BytecodeFlag; }
+    bool isBitcode() const { return flags&BitcodeFlag; }
-
-    /// @returns true iff the archive member is a compressed bytecode file.
-    /// @brief Determine if the member is a compressed bytecode file.
-    bool isCompressedBytecode() const { return flags&CompressedBytecodeFlag;}
 
     /// @returns true iff the file name contains a path (directory) component.
     /// @brief Determine if the member has a path

include/llvm/System/Path.h

@@ -306,13 +306,6 @@ namespace sys {
       /// @brief Determine if the path references an archive file.
       bool isArchive() const;
 
-      /// This function determines if the path name in the object references an
-      /// LLVM Bytecode file by looking at its magic number.
-      /// @returns true if the file starts with the magic number for LLVM
-      /// bytecode files.
-      /// @brief Determine if the path references a bytecode file.
-      bool isBytecodeFile() const;
-
       /// This function determines if the path name in the object references an
       /// LLVM Bitcode file by looking at its magic number.
       /// @returns true if the file starts with the magic number for LLVM
@@ -621,9 +614,7 @@ namespace sys {
   /// This enumeration delineates the kinds of files that LLVM knows about.
   enum LLVMFileType {
     Unknown_FileType = 0,              ///< Unrecognized file
-    Bytecode_FileType,                 ///< Uncompressed bytecode file
     Bitcode_FileType,                  ///< Bitcode file
-    CompressedBytecode_FileType,       ///< Compressed bytecode file
     Archive_FileType,                  ///< ar style archive file
     ELF_Relocatable_FileType,          ///< ELF Relocatable object file
     ELF_Executable_FileType,           ///< ELF Executable image

lib/Archive/Archive.cpp

@@ -126,15 +126,8 @@ bool ArchiveMember::replaceWith(const sys::Path& newFile, std::string* ErrMsg) {
 
   // Determine what kind of file it is
   switch (sys::IdentifyFileType(signature,4)) {
-    case sys::Bytecode_FileType:
-      flags |= BytecodeFlag;
-      break;
-    case sys::CompressedBytecode_FileType:
-      flags |= CompressedBytecodeFlag;
-      flags &= ~CompressedFlag;
-      break;
     default:
-      flags &= ~(BytecodeFlag|CompressedBytecodeFlag);
+      flags &= ~BitcodeFlag;
       break;
   }
   return false;

lib/Archive/ArchiveReader.cpp

@@ -207,16 +207,10 @@ Archive::parseMemberHeader(const char*& At, const char* End, std::string* error)
   // Determine if this is a bytecode file
   switch (sys::IdentifyFileType(At, 4)) {
     case sys::Bitcode_FileType:
-    case sys::Bytecode_FileType:
+      flags |= ArchiveMember::BitcodeFlag;
-      flags |= ArchiveMember::BytecodeFlag;
-      break;
-    case sys::CompressedBytecode_FileType:
-      flags |= ArchiveMember::CompressedBytecodeFlag;
-      flags &= ~ArchiveMember::CompressedFlag;
       break;
     default:
-      flags &= ~(ArchiveMember::BytecodeFlag|
+      flags &= ~ArchiveMember::BitcodeFlag;
-                 ArchiveMember::CompressedBytecodeFlag);
       break;
   }
 
@@ -349,7 +343,7 @@ bool
 Archive::getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage) {
 
   for (iterator I=begin(), E=end(); I != E; ++I) {
-    if (I->isBytecode() || I->isCompressedBytecode()) {
+    if (I->isBitcode()) {
       std::string FullMemberName = archPath.toString() +
         "(" + I->getPath().toString() + ")";
       MemoryBuffer *Buffer =
@@ -535,7 +529,7 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
         return false;
 
       // If it contains symbols
-      if (mbr->isBytecode() || mbr->isCompressedBytecode()) {
+      if (mbr->isBitcode()) {
         // Get the symbols
         std::vector<std::string> symbols;
         std::string FullMemberName = archPath.toString() + "(" +
@@ -612,7 +606,7 @@ bool Archive::isBitcodeArchive() {
   // 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())
+    if (!I->isBitcode())
       continue;
     
     std::string FullMemberName = 

lib/Archive/ArchiveWriter.cpp

@@ -179,11 +179,7 @@ Archive::addFileBefore(const sys::Path& filePath, iterator where,
   mbr->path.getMagicNumber(magic,4);
   switch (sys::IdentifyFileType(magic.c_str(),4)) {
     case sys::Bitcode_FileType:
-    case sys::Bytecode_FileType:
+      flags |= ArchiveMember::BitcodeFlag;
-      flags |= ArchiveMember::BytecodeFlag;
-      break;
-    case sys::CompressedBytecode_FileType:
-      flags |= ArchiveMember::CompressedBytecodeFlag;
       break;
     default:
       break;
@@ -223,8 +219,7 @@ Archive::writeMember(
 
   // Now that we have the data in memory, update the
   // symbol table if its a bitcode file.
-  if (CreateSymbolTable &&
+  if (CreateSymbolTable && member.isBitcode()) {
-      (member.isBytecode() || member.isCompressedBytecode())) {
     std::vector<std::string> symbols;
     std::string FullMemberName = archPath.toString() + "(" +
       member.getPath().toString()

lib/Linker/LinkItems.cpp

@@ -82,9 +82,7 @@ bool Linker::LinkInLibrary(const std::string& Lib, bool& is_native) {
     case sys::Unknown_FileType:
       return warning("Supposed library '" + Lib + "' isn't a library.");
 
-    case sys::Bytecode_FileType:
     case sys::Bitcode_FileType:
-    case sys::CompressedBytecode_FileType:
       // LLVM ".so" file.
       if (LinkInFile(Pathname, is_native))
         return error("Cannot link file '" + Pathname.toString() + "'");
@@ -176,9 +174,7 @@ bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
         return error("Cannot link archive '" + File.toString() + "'");
       break;
 
-    case sys::Bitcode_FileType:
+    case sys::Bitcode_FileType: {
-    case sys::Bytecode_FileType:
-    case sys::CompressedBytecode_FileType: {
       verbose("Linking bitcode file '" + File.toString() + "'");
       std::auto_ptr<Module> M(LoadObject(File));
       if (M.get() == 0)

lib/Linker/Linker.cpp

@@ -142,8 +142,6 @@ static inline sys::Path IsLibrary(const std::string& Name,
   FullPath.appendSuffix(&(LTDL_SHLIB_EXT[1]));
   if (FullPath.isDynamicLibrary())  // Native shared library?
     return FullPath;
-  if (FullPath.isBytecodeFile())    // .so file containing bytecode?
-    return FullPath;
   if (FullPath.isBitcodeFile())    // .so file containing bitcode?
     return FullPath;
 

lib/System/Path.cpp

@@ -47,14 +47,6 @@ sys::IdentifyFileType(const char*magic, unsigned length) {
       if (magic[1] == 'C' && magic[2] == (char)0xC0 && magic[3] == (char)0xDE)
         return Bitcode_FileType;
       break;
-    case 'l':
-      if (magic[1] == 'l' && magic[2] == 'v') {
-        if (magic[3] == 'c')
-          return CompressedBytecode_FileType;
-        else if (magic[3] == 'm')
-          return Bytecode_FileType;
-      }
-      break;
     case '!':
       if (length >= 8)
         if (memcmp(magic,"!<arch>\n",8) == 0)
@@ -164,14 +156,6 @@ std::string Path::GetDLLSuffix() {
   return LTDL_SHLIB_EXT;
 }
 
-bool
-Path::isBytecodeFile() const {
-  std::string actualMagic;
-  if (!getMagicNumber(actualMagic, 4))
-    return false;
-  return actualMagic == "llvc" || actualMagic == "llvm";
-}
-
 bool
 Path::isBitcodeFile() const {
   std::string actualMagic;

tools/llvm-ar/llvm-ar.cpp

@@ -356,8 +356,7 @@ bool doPrint(std::string* ErrMsg) {
 
         // Skip things that don't make sense to print
         if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() ||
-            I->isBSD4SymbolTable() || (!DontSkipBitcode &&
+            I->isBSD4SymbolTable() || (!DontSkipBitcode && I->isBitcode()))
-             (I->isBytecode() || I->isCompressedBytecode())))
           continue;
 
         if (Verbose)
@@ -406,10 +405,8 @@ doDisplayTable(std::string* ErrMsg) {
       if (Verbose) {
         // FIXME: Output should be this format:
         // Zrw-r--r--  500/ 500    525 Nov  8 17:42 2004 Makefile
-        if (I->isBytecode())
+        if (I->isBitcode())
           std::cout << "b";
-        else if (I->isCompressedBytecode())
-          std::cout << "B";
         else if (I->isCompressed())
           std::cout << "Z";
         else