gold patch committed: Unify ELF tests

[Ian Lance Taylor <iant at google dot com>]

I committed this gold patch from Rafael to unify two separate tests for
whether a file is an ELF file.

Ian


2009-03-24  Rafael Avila de Espindola  <espindola@google.com>

	* object.cc (is_elf_object): Define.
	* object.h (is_elf_object): Declare.
	* archive.cc (Archive::get_elf_object_for_member): Call
	is_elf_object.
	* readsymc.cc (Read_symbols::do_read_symbols): Likewise.


Index: archive.cc
===================================================================
RCS file: /cvs/src/src/gold/archive.cc,v
retrieving revision 1.42
diff -p -u -r1.42 archive.cc
--- archive.cc	18 Mar 2009 05:09:52 -0000	1.42
+++ archive.cc	24 Mar 2009 18:39:14 -0000
@@ -540,27 +540,9 @@ Archive::get_elf_object_for_member(off_t
         }
     }
 
-  off_t filesize = input_file->file().filesize();
-  int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
-  if (filesize - memoff < read_size)
-    read_size = filesize - memoff;
-
-  if (read_size < 4)
-    {
-      gold_error(_("%s: member at %zu is not an ELF object"),
-		 this->name().c_str(), static_cast<size_t>(off));
-      return NULL;
-    }
-
-  const unsigned char* ehdr = input_file->file().get_view(memoff, 0, read_size,
-							  true, false);
-
-  static unsigned char elfmagic[4] =
-    {
-      elfcpp::ELFMAG0, elfcpp::ELFMAG1,
-      elfcpp::ELFMAG2, elfcpp::ELFMAG3
-    };
-  if (memcmp(ehdr, elfmagic, 4) != 0)
+  const unsigned char* ehdr;
+  int read_size;
+  if (!is_elf_object(input_file, memoff, &ehdr, &read_size))
     {
       gold_error(_("%s: member at %zu is not an ELF object"),
 		 this->name().c_str(), static_cast<size_t>(off));
Index: object.cc
===================================================================
RCS file: /cvs/src/src/gold/object.cc,v
retrieving revision 1.89
diff -p -u -r1.89 object.cc
--- object.cc	14 Mar 2009 05:56:46 -0000	1.89
+++ object.cc	24 Mar 2009 18:39:14 -0000
@@ -2100,6 +2100,33 @@ make_elf_sized_object(const std::string&
 namespace gold
 {
 
+// Return whether INPUT_FILE is an ELF object.
+
+bool
+is_elf_object(Input_file* input_file, off_t offset,
+	      const unsigned char** start, int *read_size)
+{
+  off_t filesize = input_file->file().filesize();
+  int want = elfcpp::Elf_sizes<64>::ehdr_size;
+  if (filesize - offset < want)
+    want = filesize - offset;
+
+  const unsigned char* p = input_file->file().get_view(offset, 0, want,
+						       true, false);
+  *start = p;
+  *read_size = want;
+
+  if (want < 4)
+    return false;
+
+  static unsigned char elfmagic[4] =
+    {
+      elfcpp::ELFMAG0, elfcpp::ELFMAG1,
+      elfcpp::ELFMAG2, elfcpp::ELFMAG3
+    };
+  return memcmp(p, elfmagic, 4) == 0;
+}
+
 // Read an ELF file and return the appropriate instance of Object.
 
 Object*
Index: object.h
===================================================================
RCS file: /cvs/src/src/gold/object.h,v
retrieving revision 1.72
diff -p -u -r1.72 object.h
--- object.h	14 Mar 2009 05:56:46 -0000	1.72
+++ object.h	24 Mar 2009 18:39:14 -0000
@@ -1921,6 +1921,14 @@ struct Relocate_info
   location(size_t relnum, off_t reloffset) const;
 };
 
+// Return whether INPUT_FILE contains an ELF object start at file
+// offset OFFSET.  This sets *START to point to a view of the start of
+// the file.  It sets *READ_SIZE to the number of bytes in the view.
+
+extern bool
+is_elf_object(Input_file* input_file, off_t offset,
+	      const unsigned char** start, int *read_size);
+
 // Return an Object appropriate for the input file.  P is BYTES long,
 // and holds the ELF header.  If PUNCONFIGURED is not NULL, then if
 // this sees an object the linker is not configured to support, it
Index: readsyms.cc
===================================================================
RCS file: /cvs/src/src/gold/readsyms.cc,v
retrieving revision 1.35
diff -p -u -r1.35 readsyms.cc
--- readsyms.cc	14 Mar 2009 05:56:46 -0000	1.35
+++ readsyms.cc	24 Mar 2009 18:39:14 -0000
@@ -191,12 +191,9 @@ Read_symbols::do_read_symbols(Workqueue*
       return false;
     }
 
-  int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
-  if (filesize < read_size)
-    read_size = filesize;
-
-  const unsigned char* ehdr = input_file->file().get_view(0, 0, read_size,
-							  true, false);
+  const unsigned char* ehdr;
+  int read_size;
+  bool is_elf = is_elf_object(input_file, 0, &ehdr, &read_size);
 
   if (read_size >= Archive::sarmag)
     {
@@ -257,66 +254,58 @@ Read_symbols::do_read_symbols(Workqueue*
         }
     }
 
-  if (read_size >= 4)
+  if (is_elf)
     {
-      static unsigned char elfmagic[4] =
-	{
-	  elfcpp::ELFMAG0, elfcpp::ELFMAG1,
-	  elfcpp::ELFMAG2, elfcpp::ELFMAG3
-	};
-      if (memcmp(ehdr, elfmagic, 4) == 0)
-	{
-	  // This is an ELF object.
+      // This is an ELF object.
 
-	  bool unconfigured;
-	  Object* obj = make_elf_object(input_file->filename(),
-					input_file, 0, ehdr, read_size,
-					&unconfigured);
-	  if (obj == NULL)
+      bool unconfigured;
+      Object* obj = make_elf_object(input_file->filename(),
+				    input_file, 0, ehdr, read_size,
+				    &unconfigured);
+      if (obj == NULL)
+	{
+	  if (unconfigured && input_file->will_search_for())
 	    {
-	      if (unconfigured && input_file->will_search_for())
-		{
-		  Read_symbols::incompatible_warning(this->input_argument_,
-						     input_file);
-		  input_file->file().release();
-		  input_file->file().unlock(this);
-		  delete input_file;
-		  ++this->dirindex_;
-		  return this->do_read_symbols(workqueue);
-		}
-	      return false;
+	      Read_symbols::incompatible_warning(this->input_argument_,
+						 input_file);
+	      input_file->file().release();
+	      input_file->file().unlock(this);
+	      delete input_file;
+	      ++this->dirindex_;
+	      return this->do_read_symbols(workqueue);
 	    }
+	  return false;
+	}
 
-	  Read_symbols_data* sd = new Read_symbols_data;
-	  obj->read_symbols(sd);
-
-	  // Opening the file locked it, so now we need to unlock it.
-	  // We need to unlock it before queuing the Add_symbols task,
-	  // because the workqueue doesn't know about our lock on the
-	  // file.  If we queue the Add_symbols task first, it will be
-	  // stuck on the end of the file lock, but since the
-	  // workqueue doesn't know about that lock, it will never
-	  // release the Add_symbols task.
-
-	  input_file->file().unlock(this);
+      Read_symbols_data* sd = new Read_symbols_data;
+      obj->read_symbols(sd);
 
-	  // We use queue_next because everything is cached for this
-	  // task to run right away if possible.
+      // Opening the file locked it, so now we need to unlock it.  We
+      // need to unlock it before queuing the Add_symbols task,
+      // because the workqueue doesn't know about our lock on the
+      // file.  If we queue the Add_symbols task first, it will be
+      // stuck on the end of the file lock, but since the workqueue
+      // doesn't know about that lock, it will never release the
+      // Add_symbols task.
+
+      input_file->file().unlock(this);
+
+      // We use queue_next because everything is cached for this
+      // task to run right away if possible.
+
+      workqueue->queue_next(new Add_symbols(this->input_objects_,
+					    this->symtab_, this->layout_,
+					    this->dirpath_,
+					    this->dirindex_,
+					    this->mapfile_,
+					    this->input_argument_,
+					    this->input_group_,
+					    obj,
+					    sd,
+					    this->this_blocker_,
+					    this->next_blocker_));
 
-	  workqueue->queue_next(new Add_symbols(this->input_objects_,
-						this->symtab_, this->layout_,
-						this->dirpath_,
-						this->dirindex_,
-						this->mapfile_,
-						this->input_argument_,
-						this->input_group_,
-						obj,
-						sd,
-						this->this_blocker_,
-						this->next_blocker_));
-
-	  return true;
-	}
+      return true;
     }
 
   // Queue up a task to try to parse this file as a script.  We use a