daily update
[binutils.git] / gold / dirsearch.cc
blobeb57f996fee1b84948f41946ab5809428295e76c
1 // dirsearch.cc -- directory searching for gold
3 // Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
23 #include "gold.h"
25 #include <cerrno>
26 #include <cstring>
27 #include <sys/types.h>
28 #include <dirent.h>
30 #include "debug.h"
31 #include "gold-threads.h"
32 #include "options.h"
33 #include "workqueue.h"
34 #include "dirsearch.h"
36 namespace
39 // Read all the files in a directory.
41 class Dir_cache
43 public:
44 Dir_cache(const char* dirname)
45 : dirname_(dirname), files_()
46 { }
48 // Read the files in the directory.
49 void read_files();
51 // Return whether a file (a base name) is present in the directory.
52 bool find(const std::string&) const;
54 private:
55 // We can not copy this class.
56 Dir_cache(const Dir_cache&);
57 Dir_cache& operator=(const Dir_cache&);
59 const char* dirname_;
60 Unordered_set<std::string> files_;
63 void
64 Dir_cache::read_files()
66 DIR* d = opendir(this->dirname_);
67 if (d == NULL)
69 // We ignore directories which do not exist.
70 if (errno != ENOENT)
71 gold::gold_error(_("%s: can not read directory: %s"),
72 this->dirname_, strerror(errno));
73 return;
76 dirent* de;
77 while ((de = readdir(d)) != NULL)
78 this->files_.insert(std::string(de->d_name));
80 if (closedir(d) != 0)
81 gold::gold_warning("%s: closedir failed: %s", this->dirname_,
82 strerror(errno));
85 bool
86 Dir_cache::find(const std::string& basename) const
88 return this->files_.find(basename) != this->files_.end();
91 // A mapping from directory names to caches. A lock permits
92 // concurrent update. There is no lock for read operations--some
93 // other mechanism must be used to prevent reads from conflicting with
94 // writes.
96 class Dir_caches
98 public:
99 Dir_caches()
100 : lock_(), caches_()
103 ~Dir_caches();
105 // Add a cache for a directory.
106 void add(const char*);
108 // Look up a directory in the cache. This much be locked against
109 // calls to Add.
110 Dir_cache* lookup(const char*) const;
112 private:
113 // We can not copy this class.
114 Dir_caches(const Dir_caches&);
115 Dir_caches& operator=(const Dir_caches&);
117 typedef Unordered_map<const char*, Dir_cache*> Cache_hash;
119 gold::Lock lock_;
120 Cache_hash caches_;
123 Dir_caches::~Dir_caches()
125 for (Cache_hash::iterator p = this->caches_.begin();
126 p != this->caches_.end();
127 ++p)
128 delete p->second;
131 void
132 Dir_caches::add(const char* dirname)
135 gold::Hold_lock hl(this->lock_);
136 if (this->lookup(dirname) != NULL)
137 return;
140 Dir_cache* cache = new Dir_cache(dirname);
142 cache->read_files();
145 gold::Hold_lock hl(this->lock_);
147 std::pair<const char*, Dir_cache*> v(dirname, cache);
148 std::pair<Cache_hash::iterator, bool> p = this->caches_.insert(v);
149 gold_assert(p.second);
153 Dir_cache*
154 Dir_caches::lookup(const char* dirname) const
156 Cache_hash::const_iterator p = this->caches_.find(dirname);
157 if (p == this->caches_.end())
158 return NULL;
159 return p->second;
162 // The caches.
164 Dir_caches* caches;
166 // A Task to read the directory.
168 class Dir_cache_task : public gold::Task
170 public:
171 Dir_cache_task(const char* dir, gold::Task_token& token)
172 : dir_(dir), token_(token)
175 gold::Task_token*
176 is_runnable();
178 void
179 locks(gold::Task_locker*);
181 void
182 run(gold::Workqueue*);
184 std::string
185 get_name() const
186 { return std::string("Dir_cache_task ") + this->dir_; }
188 private:
189 const char* dir_;
190 gold::Task_token& token_;
193 // We can always run the task to read the directory.
195 gold::Task_token*
196 Dir_cache_task::is_runnable()
198 return NULL;
201 // Return the locks to hold. We use a blocker lock to prevent file
202 // lookups from starting until the directory contents have been read.
204 void
205 Dir_cache_task::locks(gold::Task_locker* tl)
207 tl->add(this, &this->token_);
210 // Run the task--read the directory contents.
212 void
213 Dir_cache_task::run(gold::Workqueue*)
215 caches->add(this->dir_);
220 namespace gold
223 void
224 Dirsearch::initialize(Workqueue* workqueue,
225 const General_options::Dir_list* directories)
227 gold_assert(caches == NULL);
228 caches = new Dir_caches;
229 this->directories_ = directories;
230 for (General_options::Dir_list::const_iterator p = directories->begin();
231 p != directories->end();
232 ++p)
234 this->token_.add_blocker();
235 workqueue->queue(new Dir_cache_task(p->name().c_str(), this->token_));
239 // NOTE: we only log failed file-lookup attempts here. Successfully
240 // lookups will eventually get logged in File_read::open.
242 std::string
243 Dirsearch::find(const std::string& n1, const std::string& n2,
244 bool *is_in_sysroot) const
246 gold_assert(!this->token_.is_blocked());
248 for (General_options::Dir_list::const_iterator p =
249 this->directories_->begin();
250 p != this->directories_->end();
251 ++p)
253 Dir_cache* pdc = caches->lookup(p->name().c_str());
254 gold_assert(pdc != NULL);
255 if (pdc->find(n1))
257 *is_in_sysroot = p->is_in_sysroot();
258 return p->name() + '/' + n1;
260 else
261 gold_debug(DEBUG_FILES, "Attempt to open %s/%s failed",
262 p->name().c_str(), n1.c_str());
264 if (!n2.empty())
266 if (pdc->find(n2))
268 *is_in_sysroot = p->is_in_sysroot();
269 return p->name() + '/' + n2;
271 else
272 gold_debug(DEBUG_FILES, "Attempt to open %s/%s failed",
273 p->name().c_str(), n2.c_str());
277 return std::string();
280 } // End namespace gold.