Correct dict_hash to our most recent version.

[deliverable/binutils-gdb.git] / gold / dirsearch.cc

diff --git a/gold/dirsearch.cc b/gold/dirsearch.cc
index dd1c7e6eb2c884d4cb47b6f49027741787822b9c..fac3b2c857ffb1d0c4608c6fc6710b0241de3f11 100644 (file)
--- a/gold/dirsearch.cc
+++ b/gold/dirsearch.cc
@@ -1,6 +1,6 @@
 // dirsearch.cc -- directory searching for gold
 
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -27,7 +27,10 @@
 #include <sys/types.h>
 #include <dirent.h>
 
+#include "debug.h"
 #include "gold-threads.h"
+#include "options.h"
+#include "workqueue.h"
 #include "dirsearch.h"
 
 namespace
@@ -169,11 +172,11 @@ class Dir_cache_task : public gold::Task
     : dir_(dir), token_(token)
   { }
 
-  Is_runnable_type
-  is_runnable(gold::Workqueue*);
+  gold::Task_token*
+  is_runnable();
 
-  gold::Task_locker*
-  locks(gold::Workqueue*);
+  void
+  locks(gold::Task_locker*);
 
   void
   run(gold::Workqueue*);
@@ -189,19 +192,19 @@ class Dir_cache_task : public gold::Task
 
 // We can always run the task to read the directory.
 
-gold::Task::Is_runnable_type
-Dir_cache_task::is_runnable(gold::Workqueue*)
+gold::Task_token*
+Dir_cache_task::is_runnable()
 {
-  return IS_RUNNABLE;
+  return NULL;
 }
 
 // Return the locks to hold.  We use a blocker lock to prevent file
 // lookups from starting until the directory contents have been read.
 
-gold::Task_locker*
-Dir_cache_task::locks(gold::Workqueue* workqueue)
+void
+Dir_cache_task::locks(gold::Task_locker* tl)
 {
-  return new gold::Task_locker_block(this->token_, workqueue);
+  tl->add(this, &this->token_);
 }
 
 // Run the task--read the directory contents.
@@ -217,6 +220,8 @@ Dir_cache_task::run(gold::Workqueue*)
 namespace gold
 {
 
+// Initialize.
+
 void
 Dirsearch::initialize(Workqueue* workqueue,
                      const General_options::Dir_list* directories)
@@ -224,40 +229,56 @@ Dirsearch::initialize(Workqueue* workqueue,
   gold_assert(caches == NULL);
   caches = new Dir_caches;
   this->directories_ = directories;
+  this->token_.add_blockers(directories->size());
   for (General_options::Dir_list::const_iterator p = directories->begin();
        p != directories->end();
        ++p)
-    {
-      this->token_.add_blocker();
-      workqueue->queue(new Dir_cache_task(p->name().c_str(), this->token_));
-    }
+    workqueue->queue(new Dir_cache_task(p->name().c_str(), this->token_));
 }
 
+// Search for a file.  NOTE: we only log failed file-lookup attempts
+// here.  Successfully lookups will eventually get logged in
+// File_read::open.
+
 std::string
 Dirsearch::find(const std::string& n1, const std::string& n2,
-               bool *is_in_sysroot) const
+               bool* is_in_sysroot, int* pindex) const
 {
   gold_assert(!this->token_.is_blocked());
+  gold_assert(*pindex >= 0);
 
-  for (General_options::Dir_list::const_iterator p =
-        this->directories_->begin();
-       p != this->directories_->end();
-       ++p)
+  for (unsigned int i = static_cast<unsigned int>(*pindex);
+       i < this->directories_->size();
+       ++i)
     {
+      const Search_directory* p = &this->directories_->at(i);
       Dir_cache* pdc = caches->lookup(p->name().c_str());
       gold_assert(pdc != NULL);
       if (pdc->find(n1))
        {
          *is_in_sysroot = p->is_in_sysroot();
+         *pindex = i;
          return p->name() + '/' + n1;
        }
-      if (!n2.empty() && pdc->find(n2))
-       {
-         *is_in_sysroot = p->is_in_sysroot();
-         return p->name() + '/' + n2;
+      else
+        gold_debug(DEBUG_FILES, "Attempt to open %s/%s failed",
+                   p->name().c_str(), n1.c_str());
+
+      if (!n2.empty())
+        {
+          if (pdc->find(n2))
+            {
+              *is_in_sysroot = p->is_in_sysroot();
+             *pindex = i;
+              return p->name() + '/' + n2;
+            }
+          else
+            gold_debug(DEBUG_FILES, "Attempt to open %s/%s failed",
+                       p->name().c_str(), n2.c_str());
        }
     }
 
+  *pindex = -2;
   return std::string();
 }