如何检查我的所有 init 函数是否已被调用？

Question

我正在编写一个用于嵌入式使用的大型 C 程序。该程序中的每个模块都有一个 init() 函数（类似于构造函数）来设置其静态变量。

问题是我必须记住从 main() 调用所有这些 init 函数。如果我出于某种原因将它们注释掉，我还必须记住将它们放回去。

我有什么聪明的办法来确保所有这些函数都被调用吗？类似于在每个 init 函数中放置一个宏，当您稍后调用 check_inited() 函数时，如果未调用所有函数，则会向 STDOUT 发送警告。

我可以增加一个计数器，但我必须在某个地方维护正确数量的初始化函数，这也很容易出错。

想法？

以下是我决定的解决方案，根据该线程中几个人的意见

我的目标是确保我的所有 init 函数实际上都被调用。我想做 这无需维护多个文件中的模块列表或计数。我无法打电话 正如 Nick D 建议的那样自动调用它们，因为它们需要按一定的顺序调用。

为了实现这一点，每个模块中包含的宏使用 gcc constructor 属性来 将 init 函数名称添加到全局列表中。

init 函数体中包含的另一个宏更新全局列表以创建 请注意，该函数实际上被调用了。

最后，在所有初始化完成后，在 main() 中调用检查函数。

注意：

1. 我选择将字符串复制到数组中。这并不是绝对必要的，因为 在正常使用中，传递的函数名称始终是静态字符串。如果记忆力不够 您可以只存储指向传入字符串的指针。

2. 我的可重用实用程序函数库称为“my_lib”。因此，所有的“myl”名称都是如此。

3. 这不是世界上最高效的代码，但它仅称为启动时间，因此 对我来说不重要。

4. 每个模块需要添加两行代码。如果省略其中任何一个， 检查功能会让您知道。

5. 您可以将构造函数设为静态，这样就无需为其指定在整个项目中唯一的名称。

6. 此代码仅经过轻微测试，而且确实已经很晚了，因此请在信任它之前仔细检查。

感谢：

pierr，他向我介绍了 constructor 属性。

Nick D 演示了 ## 预处理器技巧并为我提供了框架。

tod Friede 提供了一种基于链接器的巧妙方法，可以与许多编译器一起使用。

其他人帮助并分享有用的花絮。

my_lib_public.h

这是我的库头文件的相关片段

#define MY_FUNC_RUN_CHECK_NAME_SIZE 20

typedef struct _myl_function_element{
  char func[MY_FUNC_RUN_CHECK_NAME_SIZE];
  BOOL called;
} myl_function_element;

void myl_func_run_check_add(char *func_name);
BOOL myl_func_run_check(void);
void myl_func_run_check_hit(char *func_name);

#define MYL_FUNC_RUN_CHECK_ADD(function_name) \
  void cons_ ## function_name() __attribute__((constructor)); \
  void cons_ ## function_name() { myl_func_run_check_add(#function_name); }

myl_func_run_check.c

这是调用以添加函数名称并稍后检查它们的库代码。

#define MAX_CHECKED_FUNCTIONS 100

static myl_function_element  m_functions[MAX_CHECKED_FUNCTIONS]; 
static int                   m_func_cnt = 0; 


// call automatically before main runs to register a function name.
void myl_func_run_check_add(char *func_name)
{
  // fail and complain if no more room.
  if (m_func_cnt >= MAX_CHECKED_FUNCTIONS) {
    print ("myl_func_run_check_add failed, out of space\r\n");
    return; 
  }

  strncpy (m_functions[m_func_cnt].func, func_name, 
           MY_FUNC_RUN_CHECK_NAME_SIZE);
       
  m_functions[m_func_cnt].func[MY_FUNC_RUN_CHECK_NAME_SIZE-1] = 0;

  m_functions[m_func_cnt++].called = FALSE;
}

// call from inside the init function
void myl_func_run_check_hit(char *func_name)
{
  int i;

  for (i=0; i< m_func_cnt; i++) {
    if (! strncmp(m_functions[i].func, func_name, 
                  MY_FUNC_RUN_CHECK_NAME_SIZE)) {
      m_functions[i].called = TRUE;   
      return;
    }
  }

  print("myl_func_run_check_hit(): error, unregistered function was hit\r\n");
}

// checks that all registered functions were called
BOOL myl_func_run_check(void) {
  int i;
  BOOL success=TRUE;

  for (i=0; i< m_func_cnt; i++) {
    if (m_functions[i].called == FALSE) {
      success = FALSE;
      xil_printf("myl_func_run_check error: %s() not called\r\n", 
                 m_functions[i].func);
     } 
  }
  return success;
}

solo.c

这是需要初始化的模块示例

#include "my_lib_public.h"

MYL_FUNC_RUN_CHECK_ADD(solo_init)
void solo_init(void)
{
  myl_func_run_check_hit((char *) __func__);

  /* do module initialization here */
}

Answer 1

您可以使用 gcc的扩展 __attribute__((constructor)) 如果 gcc 适合您的项目。

#include <stdio.h>
void func1() __attribute__((constructor));
void func2() __attribute__((constructor));

void func1()
{
    printf("%s\n",__func__);
}

void func2()
{
    printf("%s\n",__func__);
}

int main()
{
    printf("main\n");
    return 0;
}

//the output
func2
func1
main

Answer 2

我不知道下面的内容看起来有多难看，但我还是发布了:-)

（基本思想是注册函数指针，就像 atexit 函数可以。
当然 atexit 实现是不同的）

在主模块中我们可以有这样的东西：

typedef int (*function_t)(void);

static function_t  vfunctions[100]; // we can store max 100 function pointers
static int         vcnt = 0; // count the registered function pointers

int add2init(function_t f)
{
  // todo: error checks
  vfunctions[vcnt++] = f;
  return 0;
}
...

int main(void) {
 ...
 // iterate vfunctions[] and call the functions
 ...
}

...在其他模块中：

typedef int (*function_t)(void);
extern int add2init(function_t f);
#define M_add2init(function_name)  static int int_ ## function_name = add2init(function_name)

int foo(void)
{
   printf("foo\n");
   return 0;
}
M_add2init(foo); // <--- register foo function

Answer 3

为什么不编写一个后处理脚本来为您进行检查。然后运行该脚本作为构建过程的一部分...或者更好的是，将其作为您的测试之一。您正在编写测试，对吗？ :)

例如，如果每个模块都有一个头文件 modX.c。如果您的 init() 函数的签名是“void init()”...

让您的脚本 grep 遍历所有 .h 文件，并创建需要 init() 的模块名称列表。然后让脚本检查 main() 中的每个模块确实调用了 init() 。

Answer 4

如果您的单个模块表示“类”实体并具有实例构造函数，则可以使用以下构造：

static inline void init(void) { ... }
static int initialized = 0;
#define INIT if (__predict_false(!initialized)) { init(); initialized = 1; }
struct Foo *
foo_create(void)
{
    INIT;
    ...
}

其中“__predict_false”是编译器的分支预测提示。创建第一个对象时，模块会自动初始化（一次）。

Answer 5

Splint（可能还有其他 Lint 变体）可以对已定义但未调用的函数发出警告。

有趣的是，大多数编译器都会警告您未使用的变量，但不会警告您未使用的函数。

Answer 6

更长的运行时间不是问题

您可以想象为每个模块实现一种“状态机”，其中函数的操作取决于模块所处的状态。该状态可以设置为 BEFORE_INIT 或 INITIALIZED。

例如，假设我们有模块 A，其函数为 foo 和 bar。

函数的实际逻辑（即它们实际做什么）将像这样声明：

void foo_logic();
void bar_logic();

或者无论签名是什么。

然后，模块的实际函数（即声明的实际函数 foo()）将对模块的条件执行运行时检查，并决定做什么：

void foo() {
       if (module_state == BEFORE_INIT) {
           handle_not_initialized_error();
       }
       foo_logic();
}

对所有函数重复此逻辑。

需要注意的几点：

1. 这显然会导致性能方面的巨大损失，因此
   可能不是一个好主意（我发布了
   无论如何，因为你说运行时是
   不是问题）。
2. 这不是一个真正的状态机，因为只有两个状态可以使用基本的 if 来检查，而没有某种智能的通用逻辑。
3. 当您使用单独的线程/任务时，这种“设计模式”非常有效，并且您调用的函数实际上是使用某种 IPC 来调用的。
4. 状态机可以很好地用 C++ 实现，可能值得阅读。可以想象，同样的想法可以用函数指针数组用 C 语言编写，但这几乎肯定不值得您花时间。

Answer 7

您可以使用链接器部分按照这些思路做一些事情。每当定义 init 函数时，请将指向它的指针放置在链接器部分中，仅用于 init 函数指针。那么你至少可以知道编译了多少个init函数。

如果调用 init 函数的顺序并不重要，并且它们都具有相同的原型，那么您可以在 main 的循环中调用它们。

确切的细节我不记得了，但它的工作原理是这样的::
在模块文件中...

//this is the syntax in GCC..(or would be if the underscores came through in this text editor)
initFuncPtr thisInit __attribute((section(.myinits)))__= &moduleInit;

void moduleInit(void)
{
// so init here
}

这会将指向模块 init 函数的指针放置在 .myinits 部分中，但将代码保留在 .code 部分中。所以 .myinits 部分只不过是指针。您可以将其视为模块文件可以添加到的可变长度数组。

然后您可以从 main 访问该部分的开始和结束地址。然后从那里开始。

如果 init 函数都具有相同的原型，您可以迭代此部分，全部调用它们。

实际上，这就是在 C 中创建您自己的静态构造函数系统。

如果您正在做一个大型项目，并且您的链接器至少没有功能齐全，那么您可能会遇到问题...

Answer 8

我可以回答我的问题吗？

我的想法是让每个函数将其名称添加到全局函数列表中，就像 Nick D 的解决方案一样。

然后我将运行 -gstab 生成的符号表，并查找任何尚未调用的名为 init_* 的函数。

这是一个嵌入式应用程序，因此我在闪存中方便地保存了精灵图像。

然而我不喜欢这个想法，因为这意味着我总是必须在二进制文件中包含调试信息。