c++ - 在链接时合并全局数组/从多个编译单元填充全局数组

Question

我想定义一组东西，比如事件处理程序。的内容这个数组在编译时是完全已知的，但是定义在多个编译单元，分布在多个库中是相当解耦的，至少在最终(静态)链接之前是这样。我想要也保持这种方式 - 所以添加或删除编译单元将还可以自动管理事件处理程序而无需修改事件处理程序的中央列表。

这是我想做的事情的一个例子(但行不通)。

中央.h:

typedef void (*callback_t)(void);

callback_t callbacks[];

中央.c:

#include "central.h"

void do_callbacks(void) {
    int i;
    for (i = 0; i < sizeof(callbacks) / sizeof(*callbacks); ++i)
        callbacks[i]();
}

foo.c:

#include "central.h"

void callback_foo(void) { }

callback_t callbacks[] = {
    &callback_foo
};

酒吧.c:

#include "central.h"

void callback_bar(void) { }

callback_t callbacks[] = {
    &callback_bar
};

我想要的是获得一个callbacks 数组，其中包含两个元素:&callback_foo 和 &callback_bar。使用上面的代码，有显然有两个问题:

• callbacks 数组被定义了多次。
• sizeof(callbacks) 在编译 central.c 时未知。

在我看来，第一点可以通过合并链接器来解决两个 callbacks 符号而不是抛出错误(可能通过一些变量上的属性)，但我不确定是否有类似的东西。即使有，sizeof 问题也应该以某种方式解决。

我意识到这个问题的一个常见解决方案是启动“注册”回调的函数或构造函数。然而，我只能看到两种实现方式:

• 为回调数组使用动态内存 (realloc)。
• 使用固定大小(比通常需要的大)的静态内存。

由于我在内存有限的微 Controller 平台 (Arduino) 上运行，这些方法都对我没有吸引力。鉴于该数组在编译时已知，我希望有一种方法让编译器也看到这个。

我找到了 this和 this解决方案，但那些需要自定义链接器脚本，这在我的编译环境中是不可行的运行(特别是因为这需要明确命名每个链接描述文件中的这些特殊数组，所以只需要一个链接描述文件添加在这里不起作用)。

This solution是迄今为止我发现的最好的。它使用链表在运行时填充，但使用每个静态分配的内存单独编译单元(例如，下一个指针分配给每个函数指针)。尽管如此，这些下一个指针的开销不应该需要 - 有没有更好的方法？

也许结合链接时间优化的动态解决方案可以以某种方式导致静态分配？

也欢迎就替代方法提出建议，尽管需要元素具有静态的事物列表和内存效率。

此外:

• 使用 C++ 没问题，我只是用上面的一些 C 代码来说明问题，反正大多数 Arduino 代码都是 C++。
• 我使用的是 gcc/avr-gcc，虽然我更喜欢可移植解决方案，但仅 gcc 也可以。
• 我有可用的模板支持，但没有 STL。
• 在我使用的 Arduino 环境中，我没有 Makefile 或其他方式可以在编译时轻松运行一些自定义代码，因此我正在寻找可以完全在代码中实现的东西。

Answer 1

正如在之前的一些回答中评论的那样，最好的选择是使用自定义链接描述文件(带有 KEEP(*(SORT(.whatever.*))) 输入部分)。

无论如何，它可以在不修改链接器脚本的情况下完成(下面的工作示例代码)，至少在某些带有 gcc 的平台上(在 xtensa 嵌入式设备和 cygwin 上测试)

假设:

• 我们希望尽可能避免使用 RAM(嵌入式)
• 我们不希望调用模块知道任何关于带有回调的模块的信息(它是一个库)
• 列表没有固定大小(库编译时大小未知)
• 我正在使用 GCC。原理可能在其他编译器上有效，但我没有测试过
• 此示例中的回调函数不接收任何参数，但如果需要修改起来非常简单

怎么做:

• 我们需要链接器以某种方式在链接时分配指向函数的指针数组
• 由于我们不知道数组的大小，我们还需要链接器以某种方式标记数组的结尾

这是非常具体的，因为正确的方法是使用自定义链接描述文件，但如果我们在标准链接描述文件中找到始终“保留”和“排序”的部分，则不这样做也是可行的。

通常，对于 .ctors.* 输入部分是这样的(标准要求 C++ 构造函数按函数名的顺序执行，在标准的 ld 脚本中是这样实现的)，所以我们可以破解并尝试一下。

请注意它可能不适用于所有平台(我已经在 xtensa 嵌入式架构和 CygWIN 中对其进行了测试，但这是一种黑客技巧，所以...)。

此外，由于我们将指针放在构造函数部分，我们需要使用一个字节的 RAM(对于整个程序)来跳过 C 运行时初始化期间的回调代码。

---

测试.c:

一个库，注册了一个名为test 的模块，并在某个时候调用它的回调

#include "callback.h"

CALLBACK_LIST(test);

void do_something_and_call_the_callbacks(void) {

        // ... doing something here ...

        CALLBACKS(test);

        // ... doing something else ...
}

callme1.c:

客户端代码为模块 test 注册两个回调。生成的函数没有名字(它们确实有名字，但它是神奇地生成的，在编译单元内是唯一的)

#include <stdio.h>
#include "callback.h"

CALLBACK(test) {
        printf("%s: %s\n", __FILE__, __FUNCTION__);
}

CALLBACK(test) {
        printf("%s: %s\n", __FILE__, __FUNCTION__);
}

void callme1(void) {} // stub to be called in the test sample to include the compilation unit. Not needed in real code...

callme2.c:

客户端代码正在为模块 test 注册另一个回调...

#include <stdio.h>
#include "callback.h"

CALLBACK(test) {
        printf("%s: %s\n", __FILE__, __FUNCTION__);
}

void callme2(void) {} // stub to be called in the test sample to include the compilation unit. Not needed in real code...

回调.h:

还有魔法……

#ifndef __CALLBACK_H__
#define __CALLBACK_H__

#ifdef __cplusplus
extern "C" {
#endif

typedef void (* callback)(void);
int __attribute__((weak)) _callback_ctor_stub = 0;

#ifdef __cplusplus
}
#endif

#define _PASTE(a, b)    a ## b
#define PASTE(a, b)     _PASTE(a, b)

#define CALLBACK(module) \
        static inline void PASTE(_ ## module ## _callback_, __LINE__)(void); \
        static void PASTE(_ ## module ## _callback_ctor_, __LINE__)(void); \
        static __attribute__((section(".ctors.callback." #module "$2"))) __attribute__((used)) const callback PASTE(__ ## module ## _callback_, __LINE__) = PASTE(_ ## module ## _callback_ctor_, __LINE__); \
        static void PASTE(_ ## module ## _callback_ctor_, __LINE__)(void) { \
                 if(_callback_ctor_stub) PASTE(_ ## module ## _callback_, __LINE__)(); \
        } \
        inline void PASTE(_ ## module ## _callback_, __LINE__)(void)

#define CALLBACK_LIST(module) \
        static __attribute__((section(".ctors.callback." #module "$1"))) const callback _ ## module ## _callbacks_start[0] = {}; \
        static __attribute__((section(".ctors.callback." #module "$3"))) const callback _ ## module ## _callbacks_end[0] = {}

#define CALLBACKS(module) do { \
        const callback *cb; \
        _callback_ctor_stub = 1; \
        for(cb =  _ ## module ## _callbacks_start ; cb <  _ ## module ## _callbacks_end ; cb++) (*cb)(); \
} while(0)

#endif

ma​​in.c:

如果你想试一试......这是一个独立程序的入口点(经过测试并在 gcc-cygwin 上工作)

void do_something_and_call_the_callbacks(void);

int main() {
    do_something_and_call_the_callbacks();
}

---

输出:

这是我的嵌入式设备中的(相关)输出。函数名称在 callback.h 中生成，并且可以重复，因为函数是静态的

app/callme1.c: _test_callback_8
app/callme1.c: _test_callback_4
app/callme2.c: _test_callback_4

在 CygWIN 中...

$ gcc -c -o callme1.o callme1.c
$ gcc -c -o callme2.o callme2.c
$ gcc -c -o test.o test.c
$ gcc -c -o main.o main.c
$ gcc -o testme test.o callme1.o callme2.o main.o
$ ./testme
callme1.c: _test_callback_4
callme1.c: _test_callback_8
callme2.c: _test_callback_4

链接器映射:

这是链接器生成的映射文件的相关部分

 *(SORT(.ctors.*))
 .ctors.callback.test$1    0x4024f040    0x0    .build/testme.a(test.o)
 .ctors.callback.test$2    0x4024f040    0x8    .build/testme.a(callme1.o)
 .ctors.callback.test$2    0x4024f048    0x4    .build/testme.a(callme2.o)
 .ctors.callback.test$3    0x4024f04c    0x0    .build/testme.a(test.o)