* gold-threads.h (class Once): Define.

	(class Initialize_lock): Rewrite as child of Once.
	* gold-threads.cc (class Once_initialize): Define.
	(once_pointer_control): New static variable.
	(once_pointer, once_arg): New static variables.
	(c_run_once): New static function.
	(Once::Once, Once::run_once, Once::internal_run): New functions.
	(class Initialize_lock_once): Remove.
	(initialize_lock_control): Remove.
	(initialize_lock_pointer): Remove.
	(initialize_lock_once): Remove.
	(Initialize_lock::Initialize_lock): Move to gold-threads.h.
	(Initialize_lock::initialize): Rewrite.
	(Initialize_lock::do_run_once): New function.
	* archive.cc (Archive::interpret_header): Only clear name if it is
	not already empty.
	* fileread.cc: Include "gold-threads.h"
	(file_counts_lock): New static variable.
	(file_counts_initialize_lock): Likewise.
	(File_read::release): Only increment counts when using --stats.
	Use a lock around the increment.
	* parameters.cc (class Set_parameters_target_once): Define.
	(set_parameters_target_once): New static variable.
	(Parameters::Parameters): Move here from parameters.h.
	(Parameters::set_target): Rewrite.
	(Parameters::set_target_once): New function.
	(Parameters::clear_target): Move here and rewrite.
	* parameters.h (class Parameters): Update declarations.  Add
	set_parameters_target_once_ field.
	(Parameters::Parameters): Move to parameters.cc.
	(Parameters::clear_target): Likewise.
	* readsyms.cc (Read_symbols::do_group): Create a Start_group
	task.
	(Start_group::~Start_group): New function.
	(Start_group::is_runnable): New function.
	(Start_group::locks, Start_group::run): New functions.
	(Finish_group::run): Change saw_undefined to size_t.
	* readsyms.h (class Start_group): Define.
	(class Finish_group): Change saw_undefined_ field to size_t.
	(Finish_group::Finish_group): Remove saw_undefined and
	this_blocker parameters.  Change all callers.
	(Finish_group::set_saw_undefined): New function.
	(Finish_group::set_blocker): New function.
	* symtab.h (class Symbol_table): Change saw_undefined to return
	size_t.  Change saw_undefined_ field to size_t.
	* target-select.cc (Set_target_once::do_run_once): New function.
	(Target_selector::Target_selector): Initialize set_target_once_
	field.  Don't initialize lock_ and initialize_lock_ fields.
	(Target_selector::instantiate_target): Rewrite.
	(Target_selector::set_target): New function.
	* target-select.h (class Set_target_once): Define.
	(class Target_selector): Update declarations.  Make
	Set_target_once a friend.  Remove lock_ and initialize_lock_
	fields.  Add set_target_once_ field.

1 files changed, 43 insertions, 5 deletions

diff --git a/gold/gold-threads.h b/gold/gold-threads.h
index 9c49b57..78a87b2 100644
--- a/gold/gold-threads.h
+++ b/gold/gold-threads.h
@@ -1,6 +1,6 @@
 // gold-threads.h -- thread support for gold  -*- C++ -*-
 
-// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -35,6 +35,7 @@ namespace gold
 {
 
 class Condvar;
+class Once_initialize;
 class Initialize_lock_once;
 
 // The interface for the implementation of a Lock.
@@ -191,6 +192,39 @@ class Condvar
   Condvar_impl* condvar_;
 };
 
+// A class used to do something once.  This is an abstract parent
+// class; any actual use will involve a child of this.
+
+class Once
+{
+ public:
+  Once();
+
+  // Call this function to do whatever it is.  We pass an argument
+  // even though you have to use a child class because in some uses
+  // setting the argument would itself require a Once class.
+  void
+  run_once(void* arg);
+
+  // This is an internal function, which must be public because it is
+  // run by an extern "C" function called via pthread_once.
+  void
+  internal_run(void* arg);
+
+ protected:
+  // This must be implemented by the child class.
+  virtual void
+  do_run_once(void* arg) = 0;
+
+ private:
+  // True if we have already run the function.
+  bool was_run_;
+  // Internal compare-and-swap lock on was_run_;
+  uint32_t was_run_lock_;
+  // The lock to run the function only once.
+  Once_initialize* once_;
+};
+
 // A class used to initialize a lock exactly once, after the options
 // have been read.  This is needed because the implementation of locks
 // depends on whether we've seen the --threads option.  Before the
@@ -199,23 +233,27 @@ class Condvar
 // variable of the class which has a lock which needs to be
 // initialized.
 
-class Initialize_lock
+class Initialize_lock : public Once
 {
  public:
   // The class which uses this will have a pointer to a lock.  This
   // must be constructed with a pointer to that pointer.
-  Initialize_lock(Lock** pplock);
+  Initialize_lock(Lock** pplock)
+    : pplock_(pplock)
+  { }
 
   // Initialize the lock.  Return true if the lock is now initialized,
   // false if it is not (because the options have not yet been read).
   bool
   initialize();
 
+ protected:
+  void
+  do_run_once(void*);
+
  private:
   // A pointer to the lock pointer which must be initialized.
   Lock** const pplock_;
-  // If needed, a pointer to a pthread_once_t structure.
-  Initialize_lock_once* once_;
 };
 
 } // End namespace gold.