qt - 如何从 C++ 函数/Qt 方法按需加载动态库

Question

我创建的动态库如下

cat myfile.cc

struct Tcl_Interp;
extern "C" int My_Init(Tcl_Interp *) { return 0; }

1)编译cc文件

g++ -fPIC -c myfile.cc

2)创建共享库

g++ -static-libstdc++ -static-libgcc -shared -o libmy.so myfile.o -L/tools/linux64/qt-4.6.0/lib -lQtCore -lQtGui

3) 从 TCL 处理器加载库 然后我发出命令

tclsh 并给出命令 % 加载 libmy.so

是否有任何与 load 等效的 C++ 函数/Qt 可以根据另一个 C++ 函数的需要加载共享库。

我的要求是在函数内部运行时加载动态库，然后直接使用qt函数

1) 加载qt共享库(对于lib1.so) 2)直接调用函数，无需调用resolve

例如，我们有 dopen，但对于每个函数调用，我们必须调用 dsym。我的要求只是调用共享库，然后直接调用这些函数。

Answer 1

您想要无样板的延迟加载。在 Windows 上，MSVC 实现 delay loading通过发出一个通过函数指针解析函数的 stub 。你也可以做到的。首先，让我们观察一下，如果您所做的只是调用函数指针和函数，那么它们是可以互换的。调用函数或函数指针的语法是相同的:

void foo_impl() {}
void (*foo)() = foo_impl;

int main() {
  foo_impl();
  foo();
}

这个想法是将函数指针最初设置为一个将在运行时解析实际函数的 thunk:

extern void (*foo)();
void foo_thunk() {
  foo = QLibrary::resolve("libmylib", "foo");
  if (!foo) abort();
  return foo();
}
void (*foo)() = foo_thunk;

int main() {
  foo(); // calls foo_thunk to resolve foo and calls foo from libmylib
  foo(); // calls foo from libmylib
}

当你第一次调用foo时，它会真正调用foo_thunk，解析函数地址，并调用真正的foo实现。

为此，您可以将库拆分为两个库:

1. 库实现。它不知道需求加载。
2. 按需加载 stub 。

可执行文件将链接到按需加载 stub 库；这是静态的或动态的。需求加载 stub 将在运行时自动解析符号并调用实现。

如果您足够聪明，您可以为实现设计 header ，以便 header 本身可用于生成所有 stub ，而无需输入两次详细信息。

完整示例

一切如下，也可以从 https://github.com/KubaO/stackoverflown/tree/master/questions/demand-load-39291032 获取

顶级项目包括:

• lib1 - 动态库
• lib1_demand - lib1 的静态需求加载 thunk
• main - 使用lib1_demand的应用程序

需求加载-39291032.pro

TEMPLATE = subdirs
SUBDIRS = lib1 lib1_demand main
main.depends = lib1_demand
lib1_demand.depends = lib1

我们可以将聪明之处分解到一个单独的 header 中。该 header 允许我们定义库接口(interface)，以便自动生成 thunk。

由于 C 的限制，需要大量使用预处理器和稍微冗余的语法。如果您只想为 C++ 实现此功能，则无需重复参数列表。

需求_load.h

// Configuration macros:
// DEMAND_NAME - must be set to a unique identifier of the library
// DEMAND_LOAD - if defined, the functions are declared as function pointers, **or**
// DEMAND_BUILD - if defined, the thunks and function pointers are defined

#if defined(DEMAND_FUN)
#error Multiple inclusion of demand_load.h without undefining DEMAND_FUN first.
#endif

#if !defined(DEMAND_NAME)
#error DEMAND_NAME must be defined
#endif

#if defined(DEMAND_LOAD)
// Interface via a function pointer
#define DEMAND_FUN(ret,name,args,arg_call) \
    extern ret (*name)args;

#elif defined(DEMAND_BUILD)
// Implementation of the demand loader stub
#ifndef DEMAND_CAT
#define DEMAND_CAT_(x,y) x##y
#define DEMAND_CAT(x,y) DEMAND_CAT_(x,y)
#endif
void (* DEMAND_CAT(resolve_,DEMAND_NAME)(const char *))();
#if defined(__cplusplus)
#define DEMAND_FUN(ret,name,args,arg_call) \
    extern ret (*name)args; \
    ret name##_thunk args { \
        name = reinterpret_cast<decltype(name)>(DEMAND_CAT(resolve_,DEMAND_NAME)(#name)); \
        return name arg_call; \
    }\
    ret (*name)args = name##_thunk;
#else
#define DEMAND_FUN(ret,name,args,arg_call) \
    extern ret (*name)args; \
    ret name##_impl args { \
        name = (void*)DEMAND_CAT(resolve_,DEMAND_NAME)(#name); \
        name arg_call; \
    }\
    ret (*name)args = name##_impl;
#endif // __cplusplus

#else
// Interface via a function
#define DEMAND_FUN(ret,name,args,arg_call) \
    ret name args;
#endif

然后，动态库本身:

lib1/lib1.pro

TEMPLATE = lib
SOURCES = lib1.c
HEADERS = lib1.h
INCLUDEPATH += ..
DEPENDPATH += ..

我们将使用 demand_load.h 中的 DEMAND_FUN，而不是直接声明函数。如果在包含 header 时定义了 DEMAND_LOAD_LIB1，它将为库提供按需加载接口(interface)。如果定义了DEMAND_BUILD，它将定义需求加载thunk。如果两者都没有定义，它将提供一个普通的接口(interface)。

我们小心地取消定义特定于实现的宏，以便全局 namespace 不被污染。然后，我们可以在项目中包含多个库，每个库都可以在按需加载和非按需加载之间单独选择。

lib1/lib1.h

#ifndef LIB_H
#define LIB_H

#ifdef __cplusplus
extern "C" {
#endif

#define DEMAND_NAME LIB1
#ifdef DEMAND_LOAD_LIB1
#define DEMAND_LOAD
#endif
#include "demand_load.h"
#undef DEMAND_LOAD

DEMAND_FUN(int, My_Add, (int i, int j), (i,j))
DEMAND_FUN(int, My_Subtract, (int i, int j), (i,j))

#undef DEMAND_FUN
#undef DEMAND_NAME

#ifdef __cplusplus
}
#endif

#endif

实现是没有争议的:

lib1/lib1.c

#include "lib1.h"

int My_Add(int i, int j) {
    return i+j;
}

int My_Subtract(int i, int j) {
    return i-j;
}

对于此类库的用户，需求加载被简化为定义一个宏并使用 thunk 库 lib1_demand 而不是动态库 lib1。

main/main.pro

if (true) {
   # Use demand-loaded lib1
   DEFINES += DEMAND_LOAD_LIB1
   LIBS += -L../lib1_demand -llib1_demand
} else {
   # Use direct-loaded lib1
   LIBS += -L../lib1 -llib1
}
QT = core
CONFIG += console c++11
CONFIG -= app_bundle
TARGET = demand-load-39291032
TEMPLATE = app
INCLUDEPATH += ..
DEPENDPATH += ..
SOURCES = main.cpp

主/main.cpp

#include "lib1/lib1.h"
#include <QtCore>

int main() {
    auto a = My_Add(1, 2);
    Q_ASSERT(a == 3);
    auto b = My_Add(3, 4);
    Q_ASSERT(b == 7);
    auto c = My_Subtract(5, 7);
    Q_ASSERT(c == -2);
}

最后，执行thunk。这里我们可以选择使用dlopen+dlsym或QLibrary。为了简单起见，我选择了后者:

lib1_demand/lib1_demand.pro

QT = core
TEMPLATE = lib
CONFIG += staticlib
INCLUDEPATH += ..
DEPENDPATH += ..

SOURCES = lib1_demand.cpp
HEADERS = ../demand_load.h

lib1_demand/lib1_demand.cpp

#define DEMAND_BUILD
#include "lib1/lib1.h"
#include <QLibrary>

void (* resolve_LIB1(const char * name))() {
    auto f = QLibrary::resolve("../lib1/liblib1", name);
    return f;
}