Access static class members from dynamic library in c++

Question

First of all, this is my first question, I normally found the answer looking for it, so sorry if I make some mistakes.

I am trying to access to a member of a static class from a dynamic library. The problem is, I do not know why, the memory of this static class member is not the same depending how I access to it.

I have a main program performing multiple things and calling multiple dynamic libraries (using dlopen / dlsym). These dynamic libraries should access to some variables that belongs to the main program. If these variables are not static, I can share a pointer, so I do not have problems with those. But, when these variables are static, I found some problems.

I am running this program under linux, with g++ 7.5.0 and glibc 2.27.

This is an small example showing the problem I have: The main program main.cpp modifies the static variable value and calls dynamic library libShare.so to create a ShareDerived object. This object access to the static variable value to print it.

/*** Main.cpp ***/
#include <dlfcn.h>
#include "ShareBase.hpp"

int StaticClass::value = 1;

int main() {
    StaticClass::value = 3;
    void* hdl = dlopen("./lib/libShare.so", RTLD_LAZY | RTLD_GLOBAL);
    ShareBase*(*obj)() = (ShareBase*(*)())dlsym(hdl,"createObject");
    obj()->BaseValue();
    obj()->DerivedValue();
    delete (obj());
    dlclose(hdl);
    return 0;
}

/*** ShareBase.hpp ***/
#pragma once

class StaticClass {
    public:
    StaticClass() = delete;
    ~StaticClass() = delete;
    static int value;
};
class ShareBase {
    public:
    ShareBase();
    virtual ~ShareBase();
    void BaseValue();
    virtual void DerivedValue() = 0;
};

/*** ShareBase.cpp ***/
#include "ShareBase.hpp"
#include <stdio.h>

ShareBase::ShareBase() {}
ShareBase::~ShareBase() {}
void ShareBase::BaseValue() {
    printf("Base: %d --> %p\n", StaticClass::value, (void*)&StaticClass::value);
}

/*** ShareDerived.hpp ***/
#pragma once
#include "ShareBase.hpp"

class ShareDerived:public ShareBase {
    public:
    ShareDerived();
    virtual ~ShareDerived();
    void DerivedValue();
};

extern "C" {
    ShareBase* createObject() {
        auto *m = new ShareDerived();
        return (ShareBase*)m;
    }
}

/*** ShareDerived.cpp ***/
#include "ShareDerived.hpp"
#include <stdio.h>

ShareDerived::ShareDerived() {}
ShareDerived::~ShareDerived() {}
void ShareDerived::DerivedValue() {
    printf("Derived: %d --> %p\n", StaticClass::value, (void*)&StaticClass::value);
    printf("Derived: ");
    BaseValue();
}

This is the makefile I use to compile this example:

CXX         := g++
CXX_FLAGS   := -Wall -Wextra -std=c++17 -ggdb

BIN         := bin
SRC         := src
INC         := include
LIB         := lib

EXE         := test

all: main lib

main: $(BIN)/$(EXE)
    ar rcs $(LIB)/libMain.a $(BIN)/Main.o $(BIN)/ShareBase.o

lib: $(LIB)/libShare.so

$(BIN)/$(EXE): $(BIN)/Main.o $(BIN)/ShareBase.o
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) $^ -o $@ -ldl

$(LIB)/libShare.so: $(BIN)/ShareDerived.o
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -shared $^ -o $@ -lMain

$(BIN)/%.o: $(SRC)/%.cpp
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -fPIC -c -o $@ $<

clean:
    -rm $(BIN)/* $(LIB)/*

And this is the output I obtain:

Base: 3 --> 0x55e8df87f010 <-- Calling base function from main, static member value is OK.
Derived: 1 --> 0x7f40b5918090 <-- Why this value (and pointer) is not the same as previous one?
Derived: Base: 1 --> 0x7f40b5918090 <-- Accessing to this value calling Base function from Derived class is neither OK.

So, where is my fault? Can I do this? Why the behaviour is different depending on how you access to the static member? With the same pointer, calling to any derived class function, the value of the static variable is the one saved before main is called. However, calling to the base function, the value of the static variable is the one you modify during the execution.

In case the problem is conceptual; How can I have a main program performing multiple things and calling dynamic libraries which need to access to some main program variables?

This is my first post, so maybe it is not clear. In this case, please told me and I will edit trying to make it more clear.

EDIT: After, @sam answer, I modify makefile, and now it is working as expected:

CXX         := g++
CXX_FLAGS   := -Wall -Wextra -std=c++17 -ggdb

BIN         := bin
SRC         := src
INC         := include
LIB         := lib

EXE         := test

all: main lib exec

exec: $(BIN)/$(EXE)

main: $(LIB)/libMain.so

lib: $(LIB)/libShare.so

$(BIN)/$(EXE): $(BIN)/Main.o
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -Wl,-rpath,$(LIB) $^ -o $@ -ldl -lMain

$(LIB)/libMain.so: $(BIN)/ShareBase.o
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -shared $^ -o $@

$(LIB)/libShare.so: $(BIN)/ShareDerived.o
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -Wl,-rpath,$(LIB) -shared $^ -o $@ -lMain

$(BIN)/%.o: $(SRC)/%.cpp
    $(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -fPIC -c -o $@ $<

clean:
    -rm $(BIN)/* $(LIB)/*

Answer 1

$(CXX) $(CXX_FLAGS) -I$(INC) -L$(LIB) -shared $^ -o $@ -lMain

You are linking Main.cpp directly into the shared library.

And you are running Main.cpp as part of your executable.

As a result, there are duplicate instantions of the static class member. This violates the One Definition Rule, and results in undefined behavior. This is the explanation for the behavior you observed.

You most likely did that because without linking -lMain the shown program segfaults. The reason this happens is completely unrelated -- the inlined C-linkage function never gets instantiated in the shared library, because the compiler had no reason to instantiate it, when compiling the shared library. You probably could not figure out why, but discovered that linking Main resolved the segfault, but resulted in this behavior. This is a classical XY problem. Your question should've been why you were getting a segfault, originally.