How do I get GNU __attribute__((constructor)) to work in a library?

Question

I can get GNU __attribute__((constructor)) to work (for a C++ program) if I link all object files together in a single link, but it doesn't work anymore if I store the object file containing the constructor function in a library and then link the library rather than the object file. What am I doing wrong?

Makefile.am:

SUBDIRS = src

src/Makefile.am:

bin_PROGRAMS = hello
hello_SOURCES = hello.cc register.cc register.hh myfunc.cc

src/hello.cc:

#include <iostream>             // for cout
#include <map>

#include "register.hh"

int main(int argc, char* argv[])
{
  std::cout << "Hello, World!" << std::endl;
  std::cout << "Have " << functions.size() << " functions registered."
    << std::endl;
  for (Function_map::iterator it = functions.begin(); it != functions.end(); ++it) {
    std::cout << "Registered " << (*it).first << std::endl;
    (*it).second();
  }
  return 0;
}

src/register.cc:

#include <map>
#include <string>

#include "register.hh"

Function_map functions;

void register_function(const std::string& name, Function f)
{
  functions[name] = f;
}

src/register.hh:

#ifndef REGISTER_H_
#define REGISTER_H_

#include <map>
#include <string>

typedef void (*Function)();

typedef std::map<const std::string, Function> Function_map;
extern Function_map functions;

void register_function(const std::string& name, Function f);

#endif

src/myfunc.cc:

#include "register.hh"

#include <iostream>

void myfunc()
{
  std::cout << "This is myfunc!" << std::endl;
}

__attribute__((constructor))
void register_myfunc()
{
  register_function("MYFUNC", myfunc);
}

configure.ac:

AC_PREREQ([2.69])
AC_INIT([hello], [1.4], [bugs@my.domain])
AC_CONFIG_SRCDIR([src/hello.cc])
AC_CONFIG_HEADERS([config.h])
AC_CONFIG_AUX_DIR([auxiliary])
AM_INIT_AUTOMAKE([-Wall -Werror])

AC_PROG_CXX
AM_PROG_AR

AC_CONFIG_FILES([Makefile
                 src/Makefile])
AC_OUTPUT

so all C++ files are compiled into object files which get linked together into the 'hello' executable.

The output from the resulting 'hello' program is:

Hello, World!
Have 1 functions registered.
Registered MYFUNC
This is myfunc!

If I change src/Makefile.am to

bin_PROGRAMS = hello
hello_SOURCES = hello.cc register.cc register.hh
hello_LDADD = liblibrary.a

noinst_LIBRARIES = liblibrary.a
liblibrary_a_SOURCES = myfunc.cc

(i.e., myfunc.cc compiles into myfunc.o which is stored in liblibrary.a which gets linked with the other object files into 'hello'), then the output from 'hello' is

Hello, World!
Have 0 functions registered.

so now the 'register_myfunc' function wasn't executed. Why not?

EDITED 2015-02-22 (in response to the answer from Basile Starynkevitch): I'm using a GNU/Linux (Fedora 20) system. I tried building a shared library using libtools, but without success. I adjusted the src/Makefile.am as follows:

bin_PROGRAMS = hello
hello_SOURCES = hello.cc register.cc register.hh
hello_LDADD = liblibrary.la

noinst_LTLIBRARIES = liblibrary.la
liblibrary_la_SOURCES = myfunc.cc
liblibrary_la_LDFLAGS = -shared -fPIC

(first with just -shared, later with -fPIC too) and added LT_INIT to configure.ac, but that did not change the outcome. I'll try the "static data with explicit constructor" trick that you mention for C++, but am still interested to know how to get my example to work with __attribute__((constructor)).

EDITED 2015-02-23 I tried the "static data with explicit constructor" trick but got the same results as before: it works if all objects files are linked together explicitly into an executable, but not if the thing that I want constructed automatically is linked into the executable through a library.

Adding hello_LDFLAGS = -Wl,--whole-archive (suggested by David Grayson) leads to many "multiple definition" errors. Automake places those flags near the beginning of the link command so it applies not just to the library. Automake recommends against including linker flags directly in hello_LDADD where the library to link with is specified. It is possible to override Automake rules with explicit Make rules (where I can put the linker flags exactly where I want them), but then I may run the risk of other standard Make rules (supplied by Automake) misbehaving.

I'll see if I can get it to work using dlopen.

Answer 1

I guess you have a Linux system. then ensure that the library is built as a shared library (see here), not a static one.

Functions with __attribute__(constructor) will be called when that shared library is loaded, e.g. at ld.so time, or at dlopen time if the library is a loaded plugin.

BTW the __attribute__(constructor) is more useful in C than in C++. In C++ you don't really need it, since you could have  static data with some explicitly defined constructor in its class to achieve the same result.

For details, read Drepper's paper: How to Write a Shared Library.