goto-cc: support thin ar archives, refactoring

The Linux kernel uses thin ar archives during the build process, which must be
extracted the same way this was already done for .a files. To implement this,
the file-type detection was factored out into a separate procedure.

Additional behavioural change: files without extension are no longer ignored,
but are instead tested for being goto binaries.

Author: tautschnig

src/goto-cc/compile.cpp

@@ -13,6 +13,7 @@ Date: June 2006
 
 #include "compile.h"
 
+#include <cstring>
 #include <fstream>
 #include <sstream>
 #include <iostream>
@@ -135,56 +136,114 @@ bool compilet::doit()
     warnings_before;
 }
 
-/// puts input file names into a list and does preprocessing for libraries.
-/// \return false on success, true on error.
-bool compilet::add_input_file(const std::string &file_name)
+enum class file_typet
+{
+  FAILED_TO_OPEN_FILE,
+  UNKNOWN,
+  SOURCE_FILE,
+  NORMAL_ARCHIVE,
+  THIN_ARCHIVE,
+  GOTO_BINARY,
+  ELF_OBJECT
+};
+
+static file_typet detect_file_type(const std::string &file_name)
 {
   // first of all, try to open the file
-  {
-    std::ifstream in(file_name);
-    if(!in)
-    {
-      warning() << "failed to open file `" << file_name << "'" << eom;
-      return warning_is_fatal; // generously ignore unless -Werror
-    }
-  }
+  std::ifstream in(file_name);
+  if(!in)
+    return file_typet::FAILED_TO_OPEN_FILE;
+
+  const std::string::size_type r = file_name.rfind('.');
 
-  size_t r=file_name.rfind('.', file_name.length()-1);
+  const std::string ext =
+    r == std::string::npos ? "" : file_name.substr(r + 1, file_name.length());
 
-  if(r==std::string::npos)
+  if(
+    ext == "c" || ext == "cc" || ext == "cp" || ext == "cpp" || ext == "CPP" ||
+    ext == "c++" || ext == "C" || ext == "i" || ext == "ii" || ext == "class" ||
+    ext == "jar" || ext == "jsil")
   {
-    // a file without extension; will ignore
-    warning() << "input file `" << file_name
-              << "' has no extension, not considered" << eom;
-    return warning_is_fatal;
+    return file_typet::SOURCE_FILE;
   }
 
-  std::string ext = file_name.substr(r+1, file_name.length());
-
-  if(ext=="c" ||
-     ext=="cc" ||
-     ext=="cp" ||
-     ext=="cpp" ||
-     ext=="CPP" ||
-     ext=="c++" ||
-     ext=="C" ||
-     ext=="i" ||
-     ext=="ii" ||
-     ext=="class" ||
-     ext=="jar" ||
-     ext=="jsil")
+  char hdr[8];
+  in.get(hdr, 8);
+  if((ext == "a" || ext == "o") && strncmp(hdr, "!<thin>", 8) == 0)
+    return file_typet::THIN_ARCHIVE;
+
+  if(ext == "a")
+    return file_typet::NORMAL_ARCHIVE;
+
+  if(is_goto_binary(file_name))
+    return file_typet::GOTO_BINARY;
+
+  if(hdr[0] == 0x7f && memcmp(hdr + 1, "ELF", 3) == 0)
+    return file_typet::ELF_OBJECT;
+
+  return file_typet::UNKNOWN;
+}
+
+/// puts input file names into a list and does preprocessing for libraries.
+/// \return false on success, true on error.
+bool compilet::add_input_file(const std::string &file_name)
+{
+  switch(detect_file_type(file_name))
   {
+  case file_typet::FAILED_TO_OPEN_FILE:
+    warning() << "failed to open file `" << file_name
+              << "': " << std::strerror(errno) << eom;
+    return warning_is_fatal; // generously ignore unless -Werror
+
+  case file_typet::UNKNOWN:
+    // unknown extension, not a goto binary, will silently ignore
+    debug() << "unknown file type in `" << file_name << "'" << eom;
+    return false;
+
+  case file_typet::ELF_OBJECT:
+    // ELF file without goto-cc section, silently ignore
+    debug() << "ELF object without goto-cc section: `" << file_name << "'"
+            << eom;
+    return false;
+
+  case file_typet::SOURCE_FILE:
     source_files.push_back(file_name);
+    return false;
+
+  case file_typet::NORMAL_ARCHIVE:
+    return add_files_from_archive(file_name, false);
+
+  case file_typet::THIN_ARCHIVE:
+    return add_files_from_archive(file_name, true);
+
+  case file_typet::GOTO_BINARY:
+    object_files.push_back(file_name);
+    return false;
   }
-  else if(ext=="a")
-  {
-    #ifdef _WIN32
-    char td[MAX_PATH+1];
-    #else
-    char td[] = "goto-cc.XXXXXX";
-    #endif
 
-    std::string tstr=get_temporary_directory(td);
+  UNREACHABLE;
+}
+
+/// extracts goto binaries from AR archive and add them as input files.
+/// \return false on success, true on error.
+bool compilet::add_files_from_archive(
+  const std::string &file_name,
+  bool thin_archive)
+{
+#ifdef _WIN32
+  char td[MAX_PATH + 1];
+#else
+  char td[] = "goto-cc.XXXXXX";
+#endif
+
+  std::stringstream cmd;
+  FILE *stream;
+
+  std::string tstr = working_directory;
+
+  if(!thin_archive)
+  {
+    tstr = get_temporary_directory(td);
 
     if(tstr=="")
     {
@@ -193,7 +252,6 @@ bool compilet::add_input_file(const std::string &file_name)
     }
 
     tmp_dirs.push_back(tstr);
-    std::stringstream cmd("");
     if(chdir(tmp_dirs.back().c_str())!=0)
     {
       error() << "Cannot switch to temporary directory" << eom;
@@ -203,76 +261,47 @@ bool compilet::add_input_file(const std::string &file_name)
     // unpack now
     cmd << "ar x " << concat_dir_file(working_directory, file_name);
 
-    FILE *stream;
-
     stream=popen(cmd.str().c_str(), "r");
     pclose(stream);
 
     cmd.clear();
     cmd.str("");
+  }
 
-    // add the files from "ar t"
-    #ifdef _WIN32
-    if(file_name[0]!='/' && file_name[1]!=':') // NOLINT(readability/braces)
-    #else
-    if(file_name[0]!='/') // NOLINT(readability/braces)
-    #endif
-    {
-      cmd << "ar t " <<
-      #ifdef _WIN32
-        working_directory << "\\" << file_name;
-      #else
-        working_directory << "/" << file_name;
-      #endif
-    }
-    else
-    {
-      cmd << "ar t " << file_name;
-    }
+  // add the files from "ar t"
+  cmd << "ar t " << concat_dir_file(working_directory, file_name);
 
-    stream=popen(cmd.str().c_str(), "r");
+  stream = popen(cmd.str().c_str(), "r");
 
-    if(stream!=nullptr)
+  if(stream != nullptr)
+  {
+    std::string line;
+    int ch; // fgetc returns an int, not char
+    while((ch = fgetc(stream)) != EOF)
     {
-      std::string line;
-      int ch; // fgetc returns an int, not char
-      while((ch=fgetc(stream))!=EOF)
+      if(ch != '\n')
       {
-        if(ch!='\n')
-        {
-          line+=static_cast<char>(ch);
-        }
-        else
-        {
-          std::string t;
-          #ifdef _WIN32
-          t = tmp_dirs.back() + '\\' + line;
-          #else
-          t = tmp_dirs.back() + '/' + line;
-          #endif
-
-          if(is_goto_binary(t))
-            object_files.push_back(t);
-
-          line = "";
-        }
+        line += static_cast<char>(ch);
       }
+      else
+      {
+        std::string t = concat_dir_file(tstr, line);
 
-      pclose(stream);
-    }
+        if(is_goto_binary(t))
+          object_files.push_back(t);
+        else
+          debug() << "Object file is not a goto binary: " << line << eom;
 
-    cmd.str("");
+        line = "";
+      }
+    }
 
-    if(chdir(working_directory.c_str())!=0)
-      error() << "Could not change back to working directory" << eom;
-  }
-  else if(is_goto_binary(file_name))
-    object_files.push_back(file_name);
-  else
-  {
-    // unknown extension, not a goto binary, will silently ignore
+    pclose(stream);
   }
 
+  if(!thin_archive && chdir(working_directory.c_str()) != 0)
+    error() << "Could not change back to working directory" << eom;
+
   return false;
 }
 
@@ -302,41 +331,24 @@ bool compilet::find_library(const std::string &name)
     {
       std::string libname=tmp+name+".so";
 
-      if(is_goto_binary(libname))
-        return !add_input_file(libname);
-      else if(is_elf_file(libname))
+      switch(detect_file_type(libname))
       {
+      case file_typet::GOTO_BINARY:
+        return !add_input_file(libname);
+
+      case file_typet::ELF_OBJECT:
         warning() << "Warning: Cannot read ELF library " << libname << eom;
         return warning_is_fatal;
+
+      default:
+        break;
       }
     }
   }
 
   return false;
 }
 
-/// checking if we can load an object file
-/// \par parameters: file name
-/// \return true if the given file name exists and is an ELF file, false
-///   otherwise
-bool compilet::is_elf_file(const std::string &file_name)
-{
-  std::fstream in;
-
-  in.open(file_name, std::ios::in);
-  if(in.is_open())
-  {
-    char buf[4];
-    for(std::size_t i=0; i<4; i++)
-      buf[i]=static_cast<char>(in.get());
-    if(buf[0]==0x7f && buf[1]=='E' &&
-        buf[2]=='L' && buf[3]=='F')
-      return true;
-  }
-
-  return false;
-}
-
 /// parses object files and links them
 /// \return true on error, false otherwise
 bool compilet::link()

src/goto-cc/compile.h

@@ -53,7 +53,7 @@ class compilet:public language_uit
 
   bool add_input_file(const std::string &);
   bool find_library(const std::string &);
-  bool is_elf_file(const std::string &);
+  bool add_files_from_archive(const std::string &file_name, bool thin_archive);
 
   bool parse(const std::string &filename);
   bool parse_stdin();