// dirsearch.cc -- directory searching for gold
+// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
#include "gold.h"
#include <cerrno>
+#include <cstring>
#include <sys/types.h>
#include <dirent.h>
+#include "debug.h"
#include "gold-threads.h"
+#include "options.h"
+#include "workqueue.h"
#include "dirsearch.h"
namespace
if (d == NULL)
{
// We ignore directories which do not exist.
- if (errno == ENOENT)
- return;
-
- char *s = NULL;
- if (asprintf(&s, _("can not read directory %s"), this->dirname_) < 0)
- gold::gold_nomem();
- gold::gold_fatal(s, true);
+ if (errno != ENOENT)
+ gold::gold_error(_("%s: can not read directory: %s"),
+ this->dirname_, strerror(errno));
+ return;
}
dirent* de;
this->files_.insert(std::string(de->d_name));
if (closedir(d) != 0)
- gold::gold_fatal("closedir failed", true);
+ gold::gold_warning("%s: closedir failed: %s", this->dirname_,
+ strerror(errno));
}
bool
// The caches.
-Dir_caches caches;
+Dir_caches* caches;
// A Task to read the directory.
: dir_(dir), token_(token)
{ }
- Is_runnable_type is_runnable(gold::Workqueue*);
+ gold::Task_token*
+ is_runnable();
+
+ void
+ locks(gold::Task_locker*);
- gold::Task_locker* locks(gold::Workqueue*);
+ void
+ run(gold::Workqueue*);
- void run(gold::Workqueue*);
+ std::string
+ get_name() const
+ { return std::string("Dir_cache_task ") + this->dir_; }
private:
const char* dir_;
// 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.
void
Dir_cache_task::run(gold::Workqueue*)
{
- caches.add(this->dir_);
+ caches->add(this->dir_);
}
}
namespace gold
{
-Dirsearch::Dirsearch()
- : directories_(), token_()
-{
-}
-
void
-Dirsearch::add(Workqueue* workqueue, const char* d)
+Dirsearch::initialize(Workqueue* workqueue,
+ const General_options::Dir_list* directories)
{
- this->directories_.push_back(d);
- this->token_.add_blocker();
- workqueue->queue(new Dir_cache_task(d, this->token_));
-}
-
-void
-Dirsearch::add(Workqueue* workqueue, const General_options::Dir_list& list)
-{
- for (General_options::Dir_list::const_iterator p = list.begin();
- p != list.end();
+ gold_assert(caches == NULL);
+ caches = new Dir_caches;
+ this->directories_ = directories;
+ for (General_options::Dir_list::const_iterator p = directories->begin();
+ p != directories->end();
++p)
- this->add(workqueue, *p);
+ {
+ this->token_.add_blocker();
+ workqueue->queue(new Dir_cache_task(p->name().c_str(), this->token_));
+ }
}
+// 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) const
+Dirsearch::find(const std::string& n1, const std::string& n2,
+ bool *is_in_sysroot) const
{
gold_assert(!this->token_.is_blocked());
- for (std::list<const char*>::const_iterator p = this->directories_.begin();
- p != this->directories_.end();
+ for (General_options::Dir_list::const_iterator p =
+ this->directories_->begin();
+ p != this->directories_->end();
++p)
{
- Dir_cache* pdc = caches.lookup(*p);
+ Dir_cache* pdc = caches->lookup(p->name().c_str());
gold_assert(pdc != NULL);
if (pdc->find(n1))
- return std::string(*p) + '/' + n1;
- if (!n2.empty() && pdc->find(n2))
- return std::string(*p) + '/' + n2;
+ {
+ *is_in_sysroot = p->is_in_sysroot();
+ return p->name() + '/' + n1;
+ }
+ 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();
+ return p->name() + '/' + n2;
+ }
+ else
+ gold_debug(DEBUG_FILES, "Attempt to open %s/%s failed",
+ p->name().c_str(), n2.c_str());
+ }
}
return std::string();