static map not intialized correctly?

Question

I'm using some c++ code in a static library in a macOS App. The c++ code contains the following:

static map<char*, char*> aMap1;


__attribute__((constructor))
static void initialize() {
{
    static map<char*, char*> aMap2;
    printf("map1: %d, map2: %d\n", aMap1.begin() == aMap1.end(), aMap2.begin() == aMap2.end()); // prints map1: 0, map2: 1
}

aMap1.begin() does not equal aMap1.end(), even though aMap1.size() is 0. sizeof(aMap1) is 24, and the 24 bytes at &aMap1 are 0. Calling aMap1.clear() before the for loop makes begin() equal end().

aMap2.begin() does equal aMap2.end(), and the bytes are non-zero.

I was under the impression that aMap1 was initialized automatically, but this appears to be incorrect?

Answer 1

First of all, the __attribute__((constructor)) function is an implementation-defined compiler extension, so the C++ standard is no help in understanding its behaviour.

Clang's attribute reference doesn't actually mention it, so we have to go back to GCC's documentation, as clang implements this attribute in order to be compatible with the GNU dialects of C/C++/Objective-C.

The constructor attribute causes the function to be called automatically before execution enters main ().

No specified relative order vs C++ static initialisers so far. However, it soon becomes clear that the constructor function runs before static C++ initialisers:

You may provide an optional integer priority […] A constructor with a smaller priority number runs before a constructor with a larger priority number; […] The priorities for constructor and destructor functions are the same as those specified for namespace-scope C++ objects (see C++ Attributes).

If you then look at the documentation for the init_priority() attribute you find its priority argument to be:

[…] a constant integral expression currently bounded between 101 and 65535 inclusive. Lower numbers indicate a higher priority.

In other words, you can put multiple __attribute__((constructor)) functions in a specific relative order with priority 0…100, and statically initialised C++ objects in an order 101…65535 to override the default behaviour of objects being initialised in the order of definition in a compilation unit, and order being unspecified across compilation units. But this also means that the last constructor function always runs before the first C++ static initialiser.

This explains the behaviour you are seeing. Your constructor function runs before aMap1's constructor. aMap1 is automatically constructed, but not until after the constructor function has completed.

For ways to solve this problem, see the relevant entry in the C++ FAQ.

Answer 2

someFunc was being called from an __attribute__((constructor)) function, so it was being called before the aMap1 initializer. To resolve the issue I moved the code to a dispatch block. The function could also be called from main instead of being marked as a constructor.

static map<char*, char*> aMap1;

__attribute__((constructor))
static void initialize() {
    dispatch_async(dispatch_get_main_queue(), ^{
        static map<char*, char*> aMap2;
        printf("map1: %d, map2: %d\n", aMap1.begin() == aMap1.end(), aMap2.begin() == aMap2.end()); // prints map1: 1, map2: 1
    });
}