Functional Local Static Zero Initialization - When?

A working draft of the C++ standard I was able to obtain says the
following in section 6.7.4:
The zero-initialization (8.5) of all local objects with static storage
duration (3.7.1) or thread storage duration (3.7.2) is performed
before any other initialization takes place.

First, the only addition for C++0x is the thread storage duration, so
I assume the sentence was the following for previous versions of the
standard:
The zero-initialization (8.5) of all local objects with static storage
duration (3.7.1) is performed before any other initialization takes
place.

The criteria "before any other initialization" is a little ambiguous
here. Does this mean any other initialization inside the function the
static resides, or any other initialization the entire program may
perform.

Basically, I'm trying to implement something like the following to
allow for thread safe function local static initialization while
maintaining proper destructor ordering atexit.

template<class T>
struct Once
{
  T *_obj;
  long _once;
  Once()
  {
    while (1)
    {
      long prev = InterlockedCompareExchange(&_once, 1, 0);
      if (0 == prev) // got the lock
        break;
      else if (2 == prev) // The singleton has been initialized.
        return _obj;
      else {
        // Another thread is initializing the singleton: must wait.
        assert(1 == prev);
        sleep(1); // sleep 1 millisecond
      }
    }
    assert(_obj == 0);
    _obj = new T;
    InterlockedExchange(&_once, 2);
    return _obj;
  }

  ~Once() { delete _obj; }
  inline T& operator *() { return *_obj; }
  inline T* operator ->() { return _obj; }
  inline operator T* () { return operator ->(); }
};

If I can guarantee that the memory of the object is zero-initialized
during "static initialization", then I can safely use that zero value
to do mutual exclusion in the constructor of the object using atomic
operations. And the following code is then safe during either "dynamic
initialization" or multi-threaded execution.

Foo *GetMeyersSingletonFoo()
{
  static Once<Foo> foo;
  return foo;
}

Thanks, I've been trying to tackle this for months now, and I think
I'm finally on the last steps.