Merge branch 'vendor/OPENSSL'
[dragonfly.git] / contrib / binutils-2.24 / gold / readsyms.h
1 // readsyms.h -- read input file symbols for gold   -*- C++ -*-
2
3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2013
4 // Free Software Foundation, Inc.
5 // Written by Ian Lance Taylor <iant@google.com>.
6
7 // This file is part of gold.
8
9 // This program is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 3 of the License, or
12 // (at your option) any later version.
13
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 // GNU General Public License for more details.
18
19 // You should have received a copy of the GNU General Public License
20 // along with this program; if not, write to the Free Software
21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 // MA 02110-1301, USA.
23
24 #ifndef GOLD_READSYMS_H
25 #define GOLD_READSYMS_H
26
27 #include <vector>
28
29 #include "workqueue.h"
30 #include "object.h"
31 #include "incremental.h"
32
33 namespace gold
34 {
35
36 class Input_objects;
37 class Symbol_table;
38 class Input_group;
39 class Archive;
40 class Finish_group;
41
42 // This Task is responsible for reading the symbols from an input
43 // file.  This also includes reading the relocations so that we can
44 // check for any that require a PLT and/or a GOT.  After the data has
45 // been read, this queues up another task to actually add the symbols
46 // to the symbol table.  The tasks are separated because the file
47 // reading can occur in parallel but adding the symbols must be done
48 // in the order of the input files.
49
50 class Read_symbols : public Task
51 {
52  public:
53   // DIRPATH is the list of directories to search for libraries.
54   // INPUT is the file to read.  INPUT_GROUP is not NULL if we are in
55   // the middle of an input group.  THIS_BLOCKER is used to prevent
56   // the associated Add_symbols task from running before the previous
57   // one has completed; it will be NULL for the first task.
58   // NEXT_BLOCKER is used to block the next input file from adding
59   // symbols.
60   Read_symbols(Input_objects* input_objects, Symbol_table* symtab,
61                Layout* layout, Dirsearch* dirpath, int dirindex,
62                Mapfile* mapfile, const Input_argument* input_argument,
63                Input_group* input_group, Archive_member* member,
64                Task_token* this_blocker, Task_token* next_blocker)
65     : input_objects_(input_objects), symtab_(symtab), layout_(layout),
66       dirpath_(dirpath), dirindex_(dirindex), mapfile_(mapfile),
67       input_argument_(input_argument), input_group_(input_group),
68       member_(member), this_blocker_(this_blocker),
69       next_blocker_(next_blocker)
70   { }
71
72   ~Read_symbols();
73
74   // If appropriate, issue a warning about skipping an incompatible
75   // object.
76   static void
77   incompatible_warning(const Input_argument*, const Input_file*);
78
79   // Requeue a Read_symbols task to search for the next object with
80   // the same name.
81   static void
82   requeue(Workqueue*, Input_objects*, Symbol_table*, Layout*, Dirsearch*,
83           int dirindex, Mapfile*, const Input_argument*, Input_group*,
84           Task_token* next_blocker);
85
86   // The standard Task methods.
87
88   Task_token*
89   is_runnable();
90
91   void
92   locks(Task_locker*);
93
94   void
95   run(Workqueue*);
96
97   std::string
98   get_name() const;
99
100  private:
101   // Handle an archive group.
102   void
103   do_group(Workqueue*);
104
105   // Handle --start-lib ... --end-lib
106   bool
107   do_lib_group(Workqueue*);
108
109   // Handle --whole-archive --start-lib ... --end-lib --no-whole-archive
110   bool
111   do_whole_lib_group(Workqueue*);
112
113   // Open and identify the file.
114   bool
115   do_read_symbols(Workqueue*);
116
117   Input_objects* input_objects_;
118   Symbol_table* symtab_;
119   Layout* layout_;
120   Dirsearch* dirpath_;
121   int dirindex_;
122   Mapfile* mapfile_;
123   const Input_argument* input_argument_;
124   Input_group* input_group_;
125   Archive_member* member_;
126   Task_token* this_blocker_;
127   Task_token* next_blocker_;
128 };
129
130 // This Task handles adding the symbols to the symbol table.  These
131 // tasks must be run in the same order as the arguments appear on the
132 // command line.
133
134 class Add_symbols : public Task
135 {
136  public:
137   // THIS_BLOCKER is used to prevent this task from running before the
138   // one for the previous input file.  NEXT_BLOCKER is used to prevent
139   // the next task from running.
140   Add_symbols(Input_objects* input_objects, Symbol_table* symtab,
141               Layout* layout, Dirsearch* /*dirpath*/, int /*dirindex*/,
142               Mapfile* /*mapfile*/, const Input_argument* input_argument,
143               Object* object, Incremental_library* library,
144               Read_symbols_data* sd, Task_token* this_blocker,
145               Task_token* next_blocker)
146     : input_objects_(input_objects), symtab_(symtab), layout_(layout),
147       input_argument_(input_argument), object_(object), library_(library),
148       sd_(sd), this_blocker_(this_blocker), next_blocker_(next_blocker)
149   { }
150
151   ~Add_symbols();
152
153   // The standard Task methods.
154
155   Task_token*
156   is_runnable();
157
158   void
159   locks(Task_locker*);
160
161   void
162   run(Workqueue*);
163
164   std::string
165   get_name() const
166   { return "Add_symbols " + this->object_->name(); }
167
168 private:
169   Input_objects* input_objects_;
170   Symbol_table* symtab_;
171   Layout* layout_;
172   const Input_argument* input_argument_;
173   Object* object_;
174   Incremental_library* library_;
175   Read_symbols_data* sd_;
176   Task_token* this_blocker_;
177   Task_token* next_blocker_;
178 };
179
180 // This Task is responsible for reading the symbols from an archive
181 // member that has changed since the last incremental link.
182
183 class Read_member : public Task
184 {
185  public:
186   // INPUT is the file to read.  INPUT_GROUP is not NULL if we are in
187   // the middle of an input group.  THIS_BLOCKER is used to prevent
188   // the associated Add_symbols task from running before the previous
189   // one has completed; it will be NULL for the first task.
190   // NEXT_BLOCKER is used to block the next input file from adding
191   // symbols.
192   Read_member(Input_objects* /*input_objects*/, Symbol_table* /*symtab*/,
193               Layout* /*layout*/, Mapfile* /*mapfile*/,
194               const Incremental_binary::Input_reader* input_reader,
195               Task_token* this_blocker, Task_token* next_blocker)
196     : input_reader_(input_reader),
197       this_blocker_(this_blocker), next_blocker_(next_blocker)
198   { }
199
200   ~Read_member();
201
202   // The standard Task methods.
203
204   Task_token*
205   is_runnable();
206
207   void
208   locks(Task_locker*);
209
210   void
211   run(Workqueue*);
212
213   std::string
214   get_name() const
215   {
216     return (std::string("Read_member ") + this->input_reader_->filename());
217   }
218
219  private:
220   const Incremental_binary::Input_reader* input_reader_;
221   Task_token* this_blocker_;
222   Task_token* next_blocker_;
223 };
224
225 // This Task is responsible for processing an input script file that has
226 // not changed since the last incremental link.
227
228 class Check_script : public Task
229 {
230  public:
231   Check_script(Layout* layout, Incremental_binary* ibase,
232                unsigned int input_file_index,
233                const Incremental_binary::Input_reader* input_reader,
234                Task_token* this_blocker, Task_token* next_blocker)
235     : layout_(layout), ibase_(ibase), input_file_index_(input_file_index),
236       input_reader_(input_reader), this_blocker_(this_blocker),
237       next_blocker_(next_blocker)
238   {
239     this->filename_ = std::string(this->input_reader_->filename());
240   }
241
242   ~Check_script();
243
244   // The standard Task methods.
245
246   Task_token*
247   is_runnable();
248
249   void
250   locks(Task_locker*);
251
252   void
253   run(Workqueue*);
254
255   std::string
256   get_name() const
257   {
258     return (std::string("Check_script ") + this->input_reader_->filename());
259   }
260
261  private:
262   std::string filename_;
263   Layout* layout_;
264   Incremental_binary* ibase_;
265   unsigned int input_file_index_;
266   const Incremental_binary::Input_reader* input_reader_;
267   Task_token* this_blocker_;
268   Task_token* next_blocker_;
269 };
270
271 // This Task is responsible for processing an archive library that has
272 // not changed since the last incremental link.
273
274 class Check_library : public Task
275 {
276  public:
277   Check_library(Symbol_table* /*symtab*/, Layout* layout,
278                 Incremental_binary* ibase,
279                 unsigned int input_file_index,
280                 const Incremental_binary::Input_reader* input_reader,
281                 Task_token* this_blocker, Task_token* next_blocker)
282     : layout_(layout), ibase_(ibase),
283       input_file_index_(input_file_index), input_reader_(input_reader),
284       this_blocker_(this_blocker), next_blocker_(next_blocker)
285   { }
286
287   ~Check_library();
288
289   // The standard Task methods.
290
291   Task_token*
292   is_runnable();
293
294   void
295   locks(Task_locker*);
296
297   void
298   run(Workqueue*);
299
300   std::string
301   get_name() const
302   {
303     return (std::string("Check_library ") + this->input_reader_->filename());
304   }
305
306  private:
307   Layout* layout_;
308   Incremental_binary* ibase_;
309   unsigned int input_file_index_;
310   const Incremental_binary::Input_reader* input_reader_;
311   Task_token* this_blocker_;
312   Task_token* next_blocker_;
313 };
314
315 // This class is used to track the archives in a group.
316
317 class Input_group
318 {
319  public:
320   typedef std::vector<Archive*> Archives;
321   typedef Archives::const_iterator const_iterator;
322
323   Input_group()
324     : archives_()
325   { }
326
327   ~Input_group();
328
329   // Add an archive to the group.
330   void
331   add_archive(Archive* arch)
332   { this->archives_.push_back(arch); }
333
334   // Loop over the archives in the group.
335
336   const_iterator
337   begin() const
338   { return this->archives_.begin(); }
339
340   const_iterator
341   end() const
342   { return this->archives_.end(); }
343
344  private:
345   Archives archives_;
346 };
347
348 // This class starts the handling of a group.  It exists only to pick
349 // up the number of undefined symbols at that point, so that we only
350 // run back through the group if we saw a new undefined symbol.
351
352 class Start_group : public Task
353 {
354  public:
355   Start_group(Symbol_table* symtab, Finish_group* finish_group,
356               Task_token* this_blocker, Task_token* next_blocker)
357     : symtab_(symtab), finish_group_(finish_group),
358       this_blocker_(this_blocker), next_blocker_(next_blocker)
359   { }
360
361   ~Start_group();
362
363   // The standard Task methods.
364
365   Task_token*
366   is_runnable();
367
368   void
369   locks(Task_locker*);
370
371   void
372   run(Workqueue*);
373
374   std::string
375   get_name() const
376   { return "Start_group"; }
377
378  private:
379   Symbol_table* symtab_;
380   Finish_group* finish_group_;
381   Task_token* this_blocker_;
382   Task_token* next_blocker_;
383 };
384
385 // This class is used to finish up handling a group.  It is just a
386 // closure.
387
388 class Finish_group : public Task
389 {
390  public:
391   Finish_group(Input_objects* input_objects, Symbol_table* symtab,
392                Layout* layout, Mapfile* mapfile, Input_group* input_group,
393                Task_token* next_blocker)
394     : input_objects_(input_objects), symtab_(symtab),
395       layout_(layout), mapfile_(mapfile), input_group_(input_group),
396       saw_undefined_(0), this_blocker_(NULL), next_blocker_(next_blocker)
397   { }
398
399   ~Finish_group();
400
401   // Set the number of undefined symbols when we start processing the
402   // group.  This is called by the Start_group task.
403   void
404   set_saw_undefined(size_t saw_undefined)
405   { this->saw_undefined_ = saw_undefined; }
406
407   // Set the blocker to use for this task.
408   void
409   set_blocker(Task_token* this_blocker)
410   {
411     gold_assert(this->this_blocker_ == NULL);
412     this->this_blocker_ = this_blocker;
413   }
414
415   // The standard Task methods.
416
417   Task_token*
418   is_runnable();
419
420   void
421   locks(Task_locker*);
422
423   void
424   run(Workqueue*);
425
426   std::string
427   get_name() const
428   { return "Finish_group"; }
429
430  private:
431   Input_objects* input_objects_;
432   Symbol_table* symtab_;
433   Layout* layout_;
434   Mapfile* mapfile_;
435   Input_group* input_group_;
436   size_t saw_undefined_;
437   Task_token* this_blocker_;
438   Task_token* next_blocker_;
439 };
440
441 // This class is used to read a file which was not recognized as an
442 // object or archive.  It tries to read it as a linker script, using
443 // the tokens to serialize with the calls to Add_symbols.
444
445 class Read_script : public Task
446 {
447  public:
448   Read_script(Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
449               int dirindex, Input_objects* input_objects, Mapfile* mapfile,
450               Input_group* input_group, const Input_argument* input_argument,
451               Input_file* input_file, Task_token* this_blocker,
452               Task_token* next_blocker)
453     : symtab_(symtab), layout_(layout), dirpath_(dirpath), dirindex_(dirindex),
454       input_objects_(input_objects), mapfile_(mapfile),
455       input_group_(input_group), input_argument_(input_argument),
456       input_file_(input_file), this_blocker_(this_blocker),
457       next_blocker_(next_blocker)
458   { }
459
460   ~Read_script();
461
462   // The standard Task methods.
463
464   Task_token*
465   is_runnable();
466
467   void
468   locks(Task_locker*);
469
470   void
471   run(Workqueue*);
472
473   std::string
474   get_name() const;
475
476  private:
477   Symbol_table* symtab_;
478   Layout* layout_;
479   Dirsearch* dirpath_;
480   int dirindex_;
481   Input_objects* input_objects_;
482   Mapfile* mapfile_;
483   Input_group* input_group_;
484   const Input_argument* input_argument_;
485   Input_file* input_file_;
486   Task_token* this_blocker_;
487   Task_token* next_blocker_;
488 };
489
490 } // end namespace gold
491
492 #endif // !defined(GOLD_READSYMS_H)