G++: Order of static destructors ?

[Nick Clifton]

Hi Guys,

  There appears to be a discrepancy in the way that G++ orders its
  static destructors.  Given this test program:

#include <iostream>
using namespace std;

class A 
{
public:
    int     i;
    A(int j) : i(j) { cout << "constructor A" << endl; }
    ~A() { cout << "destructor A : i = " << i << endl; }
};

class B 
{
public:
    A *n;
    B() {
        static A p(1);
        n = &p;
        cout << "constructor B" << endl;
    }
    ~B() {
        cout << "destructor B : i = " << n->i << endl;
        n->i = 10;
    }
};

class B x1;

int main (void) { return 0; }

  When compiled and run using an x86_64 native gcc built from today's
  sources this program will produce this output:
  
constructor A
constructor B
destructor A : i = 1
destructor B : i = 1

  However when compiled using a 3.4.4 native x86_64 compiler the
  following is produced when the program is run:
  
constructor A
constructor B
destructor B : i = 1
destructor A : i = 10

  Looking at what I hope is the right part of the C++ language
  specification:

3.6.3 - Termination [basic.start.term]
-1- Destructors (class.dtor) for initialized objects of static storage duration 
(declared at block scope or at namespace scope) are called as a result of 
returning from main and as a result of calling exit (lib.support.start.term). 
These objects are destroyed in the reverse order of the completion of their 
constructor or of the completion of their dynamic initialization. If an object 
is initialized statically, the object is destroyed in the same order as if the 
object was dynamically initialized. For an object of array or class type, all 
subobjects of that object are destroyed before any local object with static 
storage duration initialized during the construction of the subobjects is 
destroyed.

  This appears to state that the 3.4.4 compiler got it right.

  The problem I believe is that the destructor for class A is
  registered to run using atexit() when the constructor for class B is
  run, but the destructor for class B is permanently recorded in the
  .dtors section.  Since the exit() function runs the things recorded
  with atexit() first, before calling _exit() which runs the
  destructors in the .dtors section, the destructor for A is called
  before the destructor for B.

  Can anyone clarify this for me ?  Is this a bug with the current G++
  implementation ?

Cheers
  Nick