1 // dirsearch.cc -- directory searching for gold
3 // Copyright 2006, 2007, 2008, 2009, 2010 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.
27 #include <sys/types.h>
31 #include "gold-threads.h"
33 #include "workqueue.h"
34 #include "dirsearch.h"
39 // Read all the files in a directory.
44 Dir_cache(const char* dirname
)
45 : dirname_(dirname
), files_()
48 // Read the files in the directory.
51 // Return whether a file (a base name) is present in the directory.
52 bool find(const std::string
&) const;
55 // We can not copy this class.
56 Dir_cache(const Dir_cache
&);
57 Dir_cache
& operator=(const Dir_cache
&);
60 Unordered_set
<std::string
> files_
;
64 Dir_cache::read_files()
66 DIR* d
= opendir(this->dirname_
);
69 // We ignore directories which do not exist.
71 gold::gold_error(_("%s: can not read directory: %s"),
72 this->dirname_
, strerror(errno
));
77 while ((de
= readdir(d
)) != NULL
)
78 this->files_
.insert(std::string(de
->d_name
));
81 gold::gold_warning("%s: closedir failed: %s", this->dirname_
,
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
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
110 Dir_cache
* lookup(const char*) const;
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
;
123 Dir_caches::~Dir_caches()
125 for (Cache_hash::iterator p
= this->caches_
.begin();
126 p
!= this->caches_
.end();
132 Dir_caches::add(const char* dirname
)
135 gold::Hold_lock
hl(this->lock_
);
136 if (this->lookup(dirname
) != NULL
)
140 Dir_cache
* cache
= new Dir_cache(dirname
);
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
);
154 Dir_caches::lookup(const char* dirname
) const
156 Cache_hash::const_iterator p
= this->caches_
.find(dirname
);
157 if (p
== this->caches_
.end())
166 // A Task to read the directory.
168 class Dir_cache_task
: public gold::Task
171 Dir_cache_task(const char* dir
, gold::Task_token
& token
)
172 : dir_(dir
), token_(token
)
179 locks(gold::Task_locker
*);
182 run(gold::Workqueue
*);
186 { return std::string("Dir_cache_task ") + this->dir_
; }
190 gold::Task_token
& token_
;
193 // We can always run the task to read the directory.
196 Dir_cache_task::is_runnable()
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.
205 Dir_cache_task::locks(gold::Task_locker
* tl
)
207 tl
->add(this, &this->token_
);
210 // Run the task--read the directory contents.
213 Dir_cache_task::run(gold::Workqueue
*)
215 caches
->add(this->dir_
);
226 Dirsearch::initialize(Workqueue
* workqueue
,
227 const General_options::Dir_list
* directories
)
229 gold_assert(caches
== NULL
);
230 caches
= new Dir_caches
;
231 this->directories_
= directories
;
232 this->token_
.add_blockers(directories
->size());
233 for (General_options::Dir_list::const_iterator p
= directories
->begin();
234 p
!= directories
->end();
236 workqueue
->queue(new Dir_cache_task(p
->name().c_str(), this->token_
));
239 // Search for a file. NOTE: we only log failed file-lookup attempts
240 // here. Successfully lookups will eventually get logged in
244 Dirsearch::find(const std::string
& n1
, const std::string
& n2
,
245 bool* is_in_sysroot
, int* pindex
) const
247 gold_assert(!this->token_
.is_blocked());
248 gold_assert(*pindex
>= 0);
250 for (unsigned int i
= static_cast<unsigned int>(*pindex
);
251 i
< this->directories_
->size();
254 const Search_directory
* p
= &this->directories_
->at(i
);
255 Dir_cache
* pdc
= caches
->lookup(p
->name().c_str());
256 gold_assert(pdc
!= NULL
);
259 *is_in_sysroot
= p
->is_in_sysroot();
261 return p
->name() + '/' + n1
;
264 gold_debug(DEBUG_FILES
, "Attempt to open %s/%s failed",
265 p
->name().c_str(), n1
.c_str());
271 *is_in_sysroot
= p
->is_in_sysroot();
273 return p
->name() + '/' + n2
;
276 gold_debug(DEBUG_FILES
, "Attempt to open %s/%s failed",
277 p
->name().c_str(), n2
.c_str());
282 return std::string();
285 } // End namespace gold.
This page took 0.035324 seconds and 4 git commands to generate.