mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
238 lines
4.7 KiB
C++
238 lines
4.7 KiB
C++
// dirsearch.cc -- directory searching for gold
|
|
|
|
#include "gold.h"
|
|
|
|
#include <cerrno>
|
|
#include <cassert>
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
|
|
#include "gold-threads.h"
|
|
#include "dirsearch.h"
|
|
|
|
namespace
|
|
{
|
|
|
|
// Read all the files in a directory.
|
|
|
|
class Dir_cache
|
|
{
|
|
public:
|
|
Dir_cache(const char* dirname)
|
|
: dirname_(dirname), files_()
|
|
{ }
|
|
|
|
// Read the files in the directory.
|
|
void read_files();
|
|
|
|
// Return whether a file (a base name) is present in the directory.
|
|
bool find(const std::string&) const;
|
|
|
|
private:
|
|
// We can not copy this class.
|
|
Dir_cache(const Dir_cache&);
|
|
Dir_cache& operator=(const Dir_cache&);
|
|
|
|
const char* dirname_;
|
|
Unordered_set<std::string> files_;
|
|
};
|
|
|
|
void
|
|
Dir_cache::read_files()
|
|
{
|
|
DIR* d = opendir(this->dirname_);
|
|
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);
|
|
}
|
|
|
|
dirent* de;
|
|
while ((de = readdir(d)) != NULL)
|
|
this->files_.insert(std::string(de->d_name));
|
|
|
|
if (closedir(d) != 0)
|
|
gold::gold_fatal("closedir failed", true);
|
|
}
|
|
|
|
bool
|
|
Dir_cache::find(const std::string& basename) const
|
|
{
|
|
return this->files_.find(basename) != this->files_.end();
|
|
}
|
|
|
|
// A mapping from directory names to caches. A lock permits
|
|
// concurrent update. There is no lock for read operations--some
|
|
// other mechanism must be used to prevent reads from conflicting with
|
|
// writes.
|
|
|
|
class Dir_caches
|
|
{
|
|
public:
|
|
Dir_caches()
|
|
: lock_(), caches_()
|
|
{ }
|
|
|
|
~Dir_caches();
|
|
|
|
// Add a cache for a directory.
|
|
void add(const char*);
|
|
|
|
// Look up a directory in the cache. This much be locked against
|
|
// calls to Add.
|
|
Dir_cache* lookup(const char*) const;
|
|
|
|
private:
|
|
// We can not copy this class.
|
|
Dir_caches(const Dir_caches&);
|
|
Dir_caches& operator=(const Dir_caches&);
|
|
|
|
typedef Unordered_map<const char*, Dir_cache*> Cache_hash;
|
|
|
|
gold::Lock lock_;
|
|
Cache_hash caches_;
|
|
};
|
|
|
|
Dir_caches::~Dir_caches()
|
|
{
|
|
for (Cache_hash::iterator p = this->caches_.begin();
|
|
p != this->caches_.end();
|
|
++p)
|
|
delete p->second;
|
|
}
|
|
|
|
void
|
|
Dir_caches::add(const char* dirname)
|
|
{
|
|
{
|
|
gold::Hold_lock hl(this->lock_);
|
|
if (this->lookup(dirname) != NULL)
|
|
return;
|
|
}
|
|
|
|
Dir_cache* cache = new Dir_cache(dirname);
|
|
|
|
cache->read_files();
|
|
|
|
{
|
|
gold::Hold_lock hl(this->lock_);
|
|
|
|
std::pair<const char*, Dir_cache*> v(dirname, cache);
|
|
std::pair<Cache_hash::iterator, bool> p = this->caches_.insert(v);
|
|
assert(p.second);
|
|
}
|
|
}
|
|
|
|
Dir_cache*
|
|
Dir_caches::lookup(const char* dirname) const
|
|
{
|
|
Cache_hash::const_iterator p = this->caches_.find(dirname);
|
|
if (p == this->caches_.end())
|
|
return NULL;
|
|
return p->second;
|
|
}
|
|
|
|
// The caches.
|
|
|
|
Dir_caches caches;
|
|
|
|
// A Task to read the directory.
|
|
|
|
class Dir_cache_task : public gold::Task
|
|
{
|
|
public:
|
|
Dir_cache_task(const char* dir, gold::Task_token& token)
|
|
: dir_(dir), token_(token)
|
|
{ }
|
|
|
|
Is_runnable_type is_runnable(gold::Workqueue*);
|
|
|
|
gold::Task_locker* locks(gold::Workqueue*);
|
|
|
|
void run(gold::Workqueue*);
|
|
|
|
private:
|
|
const char* dir_;
|
|
gold::Task_token& token_;
|
|
};
|
|
|
|
// We can always run the task to read the directory.
|
|
|
|
gold::Task::Is_runnable_type
|
|
Dir_cache_task::is_runnable(gold::Workqueue*)
|
|
{
|
|
return IS_RUNNABLE;
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
return new gold::Task_locker_block(this->token_, workqueue);
|
|
}
|
|
|
|
// Run the task--read the directory contents.
|
|
|
|
void
|
|
Dir_cache_task::run(gold::Workqueue*)
|
|
{
|
|
caches.add(this->dir_);
|
|
}
|
|
|
|
}
|
|
|
|
namespace gold
|
|
{
|
|
|
|
Dirsearch::Dirsearch()
|
|
: directories_(), token_()
|
|
{
|
|
}
|
|
|
|
void
|
|
Dirsearch::add(Workqueue* workqueue, const char* d)
|
|
{
|
|
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();
|
|
++p)
|
|
this->add(workqueue, *p);
|
|
}
|
|
|
|
std::string
|
|
Dirsearch::find(const std::string& n1, const std::string& n2) const
|
|
{
|
|
assert(!this->token_.is_blocked());
|
|
|
|
for (std::list<const char*>::const_iterator p = this->directories_.begin();
|
|
p != this->directories_.end();
|
|
++p)
|
|
{
|
|
Dir_cache* pdc = caches.lookup(*p);
|
|
assert(pdc != NULL);
|
|
if (pdc->find(n1))
|
|
return std::string(*p) + '/' + n1;
|
|
if (!n2.empty() && pdc->find(n2))
|
|
return std::string(*p) + '/' + n2;
|
|
}
|
|
|
|
return std::string();
|
|
}
|
|
|
|
} // End namespace gold.
|