C++ / GCC - file-scope objects' constructors aren't being called - c++

Question

I'm beginning to develop for a Renesas RZ/A1L microcontroller. Renesas provide an IDE (e2 Studio - a modified version of Eclipse), set up to compile C / C++ with GCC. Everything works fine, but...
If I declare an object in file-scope (outside of any function), its constructor is never called. For instance:
class NewClass {
public:
int i;
NewClass() {
i = 4;
}
};
NewClass newInstance;
int main(void)
{
// My program...
}
I can tell that the constructor isn't being called because, using the in-circuit debugging setup supplied by Renesas, I can see that i is never set to 4 (even when I place further references to newInstance and i; I have optimisation switched off too). Sorry I can't do a simple cout of i's value - the code is being run in a microcontroller and I haven't worked out how to do that just yet.
If I instead place the NewClass newInstance; line inside of main(), then the problem goes away.
A further consequence of the problem is that, for inheriting classes, calling a virtual function on one (via a pointer of base-class type) causes a crash - I suspect due to the constructor having not executed and hence not written to memory some indicator of what class the object was.
By what mechanism would such a constructor normally be called? I did some Googling - would it be the ".ctors" list? (https://gcc.gnu.org/onlinedocs/gccint/Initialization.html)
Renesas's "template" C++ project does actually include code to call all of the ctors; however, from looking at my generated .map file for the project, I can see that no ctors are actually present. Does that narrow down the problem - is the GCC compiler not spitting them out when it should be?
Many thanks for your help.

Answer 1

Quoting the draft C++11 standard, N3337, we find that:
[basic.start.main]/1 A program shall contain a global function called
main, which is the designated start of the program. It is
implementation-defined whether a program in a freestanding environment
is required to define a main function. [ Note: In a freestanding
environment, start-up and termination is implementation-defined;
start-up contains the execution of constructors for objects of
namespace scope with static storage duration; termination contains the
execution of destructors for objects with static storage duration. —
end note ]
As you can see, it's implementation-defined in a free-standing environment. Therefore assuming you have a 32-bit x86 GCC toolchain...
It sounds like you're in a freestanding environment. If so, if you want to use global constructors, there is some boilerplate you need to implement. The initialization page you linked mentions a linker line, something that would look like this:
i686-elf-ld crt0.o crti.o crtbegin.o foo.o bar.o crtend.o crtn.o
Assuming foo.o and bar.o are part of your program, it's required that your linker line looks like this. Note that the compiler should provide its own crtbegin.o and crtend.o, so you can find the location of those using -print-file-name. In a Makefile, it'd look something like this:
CRTBEGIN_OBJ:=$(shell $(CC) $(CFLAGS) -print-file-name=crtbegin.o)
CRTEND_OBJ:=$(shell $(CC) $(CFLAGS) -print-file-name=crtend.o)
Now for the actual initialization function. In the same file as your kernel entry point, call _init before kernel_main (or whatever it's called.) Optionally _fini can be called after kernel_main but it's unlikely to be necessary. The exact code will depend on the architecture, but here is an example for 32-bit x86:
/* x86 crti.s */
.section .init
.global _init
.type _init, #function
_init:
push %ebp
movl %esp, %ebp
/* gcc will nicely put the contents of crtbegin.o's .init section here. */
.section .fini
.global _fini
.type _fini, #function
_fini:
push %ebp
movl %esp, %ebp
/* gcc will nicely put the contents of crtbegin.o's .fini section here. */
/* x86 crtn.s */
.section .init
/* gcc will nicely put the contents of crtend.o's .init section here. */
popl %ebp
ret
.section .fini
/* gcc will nicely put the contents of crtend.o's .fini section here. */
popl %ebp
ret