+ Incremental_library* library_;
+ Read_symbols_data* sd_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This Task is responsible for reading the symbols from an archive
+// member that has changed since the last incremental link.
+
+class Read_member : public Task
+{
+ public:
+ // INPUT is the file to read. INPUT_GROUP is not NULL if we are in
+ // the middle of an input group. THIS_BLOCKER is used to prevent
+ // the associated Add_symbols task from running before the previous
+ // one has completed; it will be NULL for the first task.
+ // NEXT_BLOCKER is used to block the next input file from adding
+ // symbols.
+ Read_member(Input_objects* /*input_objects*/, Symbol_table* /*symtab*/,
+ Layout* /*layout*/, Mapfile* /*mapfile*/,
+ const Incremental_binary::Input_reader* input_reader,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : input_reader_(input_reader),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
+ { }
+
+ ~Read_member();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const
+ {
+ return (std::string("Read_member ") + this->input_reader_->filename());
+ }
+
+ private:
+ const Incremental_binary::Input_reader* input_reader_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This Task is responsible for processing an input script file that has
+// not changed since the last incremental link.
+
+class Check_script : public Task
+{
+ public:
+ Check_script(Layout* layout, Incremental_binary* ibase,
+ unsigned int input_file_index,
+ const Incremental_binary::Input_reader* input_reader,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : layout_(layout), ibase_(ibase), input_file_index_(input_file_index),
+ input_reader_(input_reader), this_blocker_(this_blocker),
+ next_blocker_(next_blocker)
+ {
+ this->filename_ = std::string(this->input_reader_->filename());
+ }
+
+ ~Check_script();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const
+ {
+ return (std::string("Check_script ") + this->input_reader_->filename());
+ }
+
+ private:
+ std::string filename_;
+ Layout* layout_;
+ Incremental_binary* ibase_;
+ unsigned int input_file_index_;
+ const Incremental_binary::Input_reader* input_reader_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This Task is responsible for processing an archive library that has
+// not changed since the last incremental link.
+
+class Check_library : public Task
+{
+ public:
+ Check_library(Symbol_table* /*symtab*/, Layout* layout,
+ Incremental_binary* ibase,
+ unsigned int input_file_index,
+ const Incremental_binary::Input_reader* input_reader,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : layout_(layout), ibase_(ibase),
+ input_file_index_(input_file_index), input_reader_(input_reader),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
+ { }
+
+ ~Check_library();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const
+ {
+ return (std::string("Check_library ") + this->input_reader_->filename());
+ }
+
+ private:
+ Layout* layout_;
+ Incremental_binary* ibase_;
+ unsigned int input_file_index_;
+ const Incremental_binary::Input_reader* input_reader_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This class is used to track the archives in a group.
+
+class Input_group
+{
+ public:
+ typedef std::vector<Archive*> Archives;
+ typedef Archives::const_iterator const_iterator;
+
+ Input_group()
+ : archives_()
+ { }
+
+ ~Input_group();
+
+ // Add an archive to the group.
+ void
+ add_archive(Archive* arch)
+ { this->archives_.push_back(arch); }
+
+ // Loop over the archives in the group.
+
+ const_iterator
+ begin() const
+ { return this->archives_.begin(); }
+
+ const_iterator
+ end() const
+ { return this->archives_.end(); }
+
+ private:
+ Archives archives_;
+};
+
+// This class starts the handling of a group. It exists only to pick
+// up the number of undefined symbols at that point, so that we only
+// run back through the group if we saw a new undefined symbol.
+
+class Start_group : public Task
+{
+ public:
+ Start_group(Symbol_table* symtab, Finish_group* finish_group,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : symtab_(symtab), finish_group_(finish_group),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
+ { }
+
+ ~Start_group();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const
+ { return "Start_group"; }
+
+ private:
+ Symbol_table* symtab_;
+ Finish_group* finish_group_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This class is used to finish up handling a group. It is just a
+// closure.
+
+class Finish_group : public Task
+{
+ public:
+ Finish_group(Input_objects* input_objects, Symbol_table* symtab,
+ Layout* layout, Mapfile* mapfile, Input_group* input_group,
+ Task_token* next_blocker)
+ : input_objects_(input_objects), symtab_(symtab),
+ layout_(layout), mapfile_(mapfile), input_group_(input_group),
+ saw_undefined_(0), this_blocker_(NULL), next_blocker_(next_blocker)
+ { }
+
+ ~Finish_group();
+
+ // Set the number of undefined symbols when we start processing the
+ // group. This is called by the Start_group task.
+ void
+ set_saw_undefined(size_t saw_undefined)
+ { this->saw_undefined_ = saw_undefined; }
+
+ // Set the blocker to use for this task.
+ void
+ set_blocker(Task_token* this_blocker)
+ {
+ gold_assert(this->this_blocker_ == NULL);
+ this->this_blocker_ = this_blocker;
+ }
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const
+ { return "Finish_group"; }
+
+ private:
+ Input_objects* input_objects_;
+ Symbol_table* symtab_;
+ Layout* layout_;
+ Mapfile* mapfile_;
+ Input_group* input_group_;
+ size_t saw_undefined_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// This class is used to read a file which was not recognized as an
+// object or archive. It tries to read it as a linker script, using
+// the tokens to serialize with the calls to Add_symbols.
+
+class Read_script : public Task
+{
+ public:
+ Read_script(Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
+ int dirindex, Input_objects* input_objects, Mapfile* mapfile,
+ Input_group* input_group, const Input_argument* input_argument,
+ Input_file* input_file, Task_token* this_blocker,
+ Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), dirpath_(dirpath), dirindex_(dirindex),
+ input_objects_(input_objects), mapfile_(mapfile),
+ input_group_(input_group), input_argument_(input_argument),
+ input_file_(input_file), this_blocker_(this_blocker),
+ next_blocker_(next_blocker)
+ { }
+
+ ~Read_script();
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const;
+
+ private:
+ Symbol_table* symtab_;
+ Layout* layout_;
+ Dirsearch* dirpath_;
+ int dirindex_;
+ Input_objects* input_objects_;
+ Mapfile* mapfile_;
+ Input_group* input_group_;
+ const Input_argument* input_argument_;
+ Input_file* input_file_;