用gcc的-E选项来查看宏展开

最新推荐文章于 2023-09-28 22:36:14 发布
最新推荐文章于 2023-09-28 22:36:14 发布
阅读量1.7k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42992444/article/details/108592056
版权

有时代码中的宏挺复杂的, 人工去展开, 太费劲. 为了看复杂的宏 展开后的样子, 可以利用gcc -E选项来帮我们展开.

gcc -E选项的作用: 仅预编译

-E选项就是只做预编译处理, 不做编译, 汇编, 链接.

$ gcc --help
Usage: gcc [options] file...
Options:
  ...
  ...
  -v                       Display the programs invoked by the compiler.
  -###                     Like -v but options quoted and commands not executed.
  -E                       Preprocess only; do not compile, assemble or link.
  -S                       Compile only; do not assemble or link.
  -c                       Compile and assemble, but do not link.
  -o <file>                Place the output into <file>.
  ...
  ...

举例

比如要对, 系统调用open定义进行宏展开:

/* in file fs/open.c  */
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

而 SYSCALL_DEFINE3定义在 include/linux/syscalls.h 中


/* in file:  include/linux/syscalls.h */

#define SYSCALL_METADATA(sname, nb, ...)                        \
        static const char *types_##sname[] = {                  \
                __MAP(nb,__SC_STR_TDECL,__VA_ARGS__)            \
        };                                                      \
        static const char *args_##sname[] = {                   \
                __MAP(nb,__SC_STR_ADECL,__VA_ARGS__)            \
        };                                                      \
        SYSCALL_TRACE_ENTER_EVENT(sname);                       \
        SYSCALL_TRACE_EXIT_EVENT(sname);                        \
        static struct syscall_metadata __used                   \
          __syscall_meta_##sname = {                            \
                .name           = "sys"#sname,                  \
                .syscall_nr     = -1,   /* Filled in at boot */ \
                .nb_args        = nb,                           \
                .types          = nb ? types_##sname : NULL,    \
                .args           = nb ? args_##sname : NULL,     \
                .enter_event    = &event_enter_##sname,         \
                .exit_event     = &event_exit_##sname,          \
                .enter_fields   = LIST_HEAD_INIT(__syscall_meta_##sname.enter_fields), \
        };                                                      \
        static struct syscall_metadata __used                   \
          __attribute__((section("__syscalls_metadata")))       \
         *__p_syscall_meta_##sname = &__syscall_meta_##sname;




#define SYSCALL_DEFINE0(sname)                                  \
        SYSCALL_METADATA(_##sname, 0);                          \
        asmlinkage long sys_##sname(void)

#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)



#define SYSCALL_DEFINEx(x, sname, ...)                          \
        SYSCALL_METADATA(sname, x, __VA_ARGS__)                 \
        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

#define __PROTECT(...) asmlinkage_protect(__VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...)                                 \
        asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))       \
                __attribute__((alias(__stringify(SyS##name))));         \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__));  \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__));      \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))       \
        {                                                               \
                long ret = SYSC##name(__MAP(x,__SC_CAST,__VA_ARGS__));  \
                __MAP(x,__SC_TEST,__VA_ARGS__);                         \
                __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));       \
                return ret;                                             \
        }                                                               \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__))

为了看 SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode) {…} 究竟是什么样的, 可以这么干:

写个c文件, 包含上述内容:

$ cat foo.c

#define SYSCALL_METADATA(sname, nb, ...)                        \
        static const char *types_##sname[] = {                  \
                __MAP(nb,__SC_STR_TDECL,__VA_ARGS__)            \
        };                                                      \
        static const char *args_##sname[] = {                   \
                __MAP(nb,__SC_STR_ADECL,__VA_ARGS__)            \
        };                                                      \
        SYSCALL_TRACE_ENTER_EVENT(sname);                       \
        SYSCALL_TRACE_EXIT_EVENT(sname);                        \
        static struct syscall_metadata __used                   \
          __syscall_meta_##sname = {                            \
                .name           = "sys"#sname,                  \
                .syscall_nr     = -1,   /* Filled in at boot */ \
                .nb_args        = nb,                           \
                .types          = nb ? types_##sname : NULL,    \
                .args           = nb ? args_##sname : NULL,     \
                .enter_event    = &event_enter_##sname,         \
                .exit_event     = &event_exit_##sname,          \
                .enter_fields   = LIST_HEAD_INIT(__syscall_meta_##sname.enter_fields), \
        };                                                      \
        static struct syscall_metadata __used                   \
          __attribute__((section("__syscalls_metadata")))       \
         *__p_syscall_meta_##sname = &__syscall_meta_##sname;




#define SYSCALL_DEFINE0(sname)                                  \
        SYSCALL_METADATA(_##sname, 0);                          \
        asmlinkage long sys_##sname(void)

#define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
#define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)



#define SYSCALL_DEFINEx(x, sname, ...)                          \
        SYSCALL_METADATA(sname, x, __VA_ARGS__)                 \
        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

#define __PROTECT(...) asmlinkage_protect(__VA_ARGS__)
#define __SYSCALL_DEFINEx(x, name, ...)                                 \
        asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))       \
                __attribute__((alias(__stringify(SyS##name))));         \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__));  \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__));      \
        asmlinkage long SyS##name(__MAP(x,__SC_LONG,__VA_ARGS__))       \
        {                                                               \
                long ret = SYSC##name(__MAP(x,__SC_CAST,__VA_ARGS__));  \
                __MAP(x,__SC_TEST,__VA_ARGS__);                         \
                __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));       \
                return ret;                                             \
        }                                                               \
        static inline long SYSC##name(__MAP(x,__SC_DECL,__VA_ARGS__))



SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

然后对foo.c用gcc -E来操作, 可以直接输出到标准输出, 也可以输出到文件

## 输出到文件, 可以用gcc的-o选项,
$ gcc -E foo.c -o foo.cpp
$
$ cat foo.cpp
# 1 "foo.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "foo.c"
# 63 "foo.c"
static const char *types__open[] = { __MAP(3,__SC_STR_TDECL,const char __user *, filename, int, flags, umode_t, mode) }; static const char *args__open[] = { __MAP(3,__SC_STR_ADECL,const char __user *, filename, int, flags, umode_t, mode) }; SYSCALL_TRACE_ENTER_EVENT(_open); SYSCALL_TRACE_EXIT_EVENT(_open); static struct syscall_metadata __used __syscall_meta__open = { .name = "sys""_open", .syscall_nr = -1, .nb_args = 3, .types = 3 ? types__open : NULL, .args = 3 ? args__open : NULL, .enter_event = &event_enter__open, .exit_event = &event_exit__open, .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields), }; static struct syscall_metadata __used __attribute__((section("__syscalls_metadata"))) *__p_syscall_meta__open = &__syscall_meta__open; asmlinkage long sys_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode)) __attribute__((alias(__stringify(SyS_open)))); static inline long SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode)); asmlinkage long SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode)); asmlinkage long SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode)) { long ret = SYSC_open(__MAP(3,__SC_CAST,const char __user *, filename, int, flags, umode_t, mode)); __MAP(3,__SC_TEST,const char __user *, filename, int, flags, umode_t, mode); asmlinkage_protect(3, ret,__MAP(3,__SC_ARGS,const char __user *, filename, int, flags, umode_t, mode)); return ret; } static inline long SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode))
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

## 直接输出到标准输出:
$ gcc -E foo.c
# 1 "foo.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "foo.c"
# 63 "foo.c"
static const char *types__open[] = { __MAP(3,__SC_STR_TDECL,const char __user *, filename, int, flags, umode_t, mode) }; static const char *args__open[] = { __MAP(3,__SC_STR_ADECL,const char __user *, filename, int, flags, umode_t, mode) }; SYSCALL_TRACE_ENTER_EVENT(_open); SYSCALL_TRACE_EXIT_EVENT(_open); static struct syscall_metadata __used __syscall_meta__open = { .name = "sys""_open", .syscall_nr = -1, .nb_args = 3, .types = 3 ? types__open : NULL, .args = 3 ? args__open : NULL, .enter_event = &event_enter__open, .exit_event = &event_exit__open, .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields), }; static struct syscall_metadata __used __attribute__((section("__syscalls_metadata"))) *__p_syscall_meta__open = &__syscall_meta__open; asmlinkage long sys_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode)) __attribute__((alias(__stringify(SyS_open)))); static inline long SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode)); asmlinkage long SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode)); asmlinkage long SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode)) { long ret = SYSC_open(__MAP(3,__SC_CAST,const char __user *, filename, int, flags, umode_t, mode)); __MAP(3,__SC_TEST,const char __user *, filename, int, flags, umode_t, mode); asmlinkage_protect(3, ret,__MAP(3,__SC_ARGS,const char __user *, filename, int, flags, umode_t, mode)); return ret; } static inline long SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode))
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

由于输出的格式没有自动缩进与对齐, 不太好看, 可以将其缩进对齐后, 在查看:

$ cp foo.cpp  indent_foo.c
$ vim indent_foo.c   # 将其缩进并对齐
$ cat indent_foo.c
# 1 "foo.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "foo.c"
# 63 "foo.c"

static const char *types__open[] = {
        __MAP(3,__SC_STR_TDECL,const char __user *, filename, int, flags, umode_t, mode)
};

static const char *args__open[] = {
        __MAP(3,__SC_STR_ADECL,const char __user *, filename, int, flags, umode_t, mode)
};

SYSCALL_TRACE_ENTER_EVENT(_open);

SYSCALL_TRACE_EXIT_EVENT(_open);

static struct syscall_metadata __used __syscall_meta__open = {
        .name = "sys""_open",
        .syscall_nr = -1,
        .nb_args = 3,
        .types = 3 ? types__open : NULL,
        .args = 3 ? args__open : NULL,
        .enter_event = &event_enter__open,
        .exit_event = &event_exit__open,
        .enter_fields = LIST_HEAD_INIT(__syscall_meta__open.enter_fields),
};

static struct syscall_metadata
__used __attribute__((section("__syscalls_metadata")))
*__p_syscall_meta__open = &__syscall_meta__open;

asmlinkage long
sys_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode))
        __attribute__((alias(__stringify(SyS_open))));

static inline long
SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode));

asmlinkage long
SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode));

asmlinkage long
SyS_open(__MAP(3,__SC_LONG,const char __user *, filename, int, flags, umode_t, mode))
{
        long ret = SYSC_open(__MAP(3,__SC_CAST,const char __user *, filename, int, flags, umode_t, mode));
        __MAP(3,__SC_TEST,const char __user *, filename, int, flags, umode_t, mode);
        asmlinkage_protect(3, ret,__MAP(3,__SC_ARGS,const char __user *, filename, int, flags, umode_t, mode));
        return ret;
}

static inline long SYSC_open(__MAP(3,__SC_DECL,const char __user *, filename, int, flags, umode_t, mode))
{
        if (force_o_largefile())
                flags |= O_LARGEFILE;

        return do_sys_open(AT_FDCWD, filename, flags, mode);
}

由上述可见:
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode) {…}
展开后的样子是SYSC_open() (当然这还并没有最终彻底完全展开, 但已经可以看出open函数代码实际的样子了)
并在SYSC_open()定义之前, 做了很多额外的操作

open系统调用, 最后其实是 SYSC_open()函数.
而SYSC_open()被SyS_open()调用, 而SyS_open()是sys_open的别名.
即, open系统调用, 实际是
sys_open() == SyS_open() --> SYSC_open() --> do_sys_open().

问题

怎么让gcc -E输出, 自动缩进对齐?
关于这个, 涉及到 “自动统一格式化代码风格” 工具, 可以试试indent工具

$ sudo apt-get install indent

然后, 执行

$ indent -npro -kr -i8 -ts8 -sob -l80 -ss -bl  -bli 0 foo.cpp -o _foo.cpp

关于 代码风格格式化工具, 请参考:
/* TODO */

最快乐的寂寞是独处
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
arm-linux-gcc编译选项.pdf
07-25
- 预处理阶段：GCC会对源文件进行预处理，展开宏定义、处理条件编译指令、包含头文件等。 - 编译阶段：经过预处理的源文件会被转化为汇编代码。 - 汇编阶段：将汇编代码编译成机器可以理解的二进制代码（目标文件...
gcc编译选项之预处理之宏展开
软工电子行
08-13 339
gcc编译选项之预处理
gcc -E
mysee1989的专栏
03-19 6574
GCC编译C源代码有四个步骤：预处理---->编译---->汇编---->链接。可以利用GCC的参数来控制执行的过程，这样就可以更深入的了解编译C程序的过程。下面将通过对一个程序的编译来演示整个过程。 hello.c #include int main() {     printf("happy new year!\n");     return 0; } 1：预
【Linux】Linux编译器-gcc/g++使用
m0_68931081的博客
12-02 3141
全面了解gcc/g++的使用
Linux系统下的GCC编译过程、使用命令详解(多文件编译、动态库、静态库）
DZJ_Nirvana
03-18 8688
以上是学习中大多数时候使用的gcc编译指令，上面代码是一步到位的得到链接后的文件，其本质是要经过预处理 编译 汇编 链接这四步。gcc -S -o hello.s hello.c，可直接将hello.c文件编译为汇编形式，并。通常编译hello.c 使用-o参数可命名文件，将hello.c编译后命名为hello，即gcc命令后的。数据段合并 将生成的.obj文件与库文件.lib等文件链接，生成可执行文件（.exe文件） ，地址回填。文件， 展开宏、头文件，替换条件编译，删除注释、空行、空白。
gcc 对宏展开命令
arrow8209的专栏
04-14 1169
gcc 对宏展开命令
gcc -E 选项
无界编程
10-11 8021
-E 只激活预处理,这个不生成文件,你需要把它重定向到一个输出文件里面. 例子用法: gcc -E hello.c > pianoapan.txt gcc -E hello.c | more 慢慢看吧,一个hello word 也要与处理成800行的代码 -E选项，表示让gcc只进行“预处理”就行了。 所谓的预处理，就是把程序中的宏展开， 把头文件的内容展开包含进来等等一
Gcc 常用选项参数解释
12-04
2. `-E`：这个选项使得GCC仅执行预处理步骤，将源代码中的宏展开、条件编译处理后输出到标准输出，可以用来检查预处理后的代码。你也可以直接使用`cpp`命令来完成同样的工作。 3. `-Dmacro[=defn]`：定义一个宏，`...
arm-linux-gcc常用参数讲解gcc编译器使用方法参照.pdf
11-09
1. **预处理阶段**：在这一阶段，编译器执行`-E`参数，处理`#include`指令，展开宏定义，处理条件编译指令等，输出扩展后的源代码文件，如`example.i`。 2. **编译阶段**：在这个阶段，使用`-S`参数，GCC将预处理后...
GCC 编译c程序的方法及过程解析
09-04
GCC提供`-E`选项，可以在预处理后停止，生成扩展后的.i文件。 2. **编译(Compiling)**：编译阶段检查源代码的语法，确保代码符合语言规范。如果一切正常，GCC会将源代码转换为汇编语言。使用`-S`选项，GCC会在编译...
gcc选项及编译过程.pdf
10-02
1. **预处理(Pre-Processing)**：此阶段主要处理#include指令，展开宏定义，并生成.i扩展名的预处理文件。预处理器cpp负责这一任务。 2. **编译(Compiling)**：预处理后的文件会被编译成汇编代码，这一步由ccl完成...
GCC -E 选项
既然选择了远方 便只顾风雨兼程 - 永强
01-19 1359
GCC -E 选项 1. GCC Command Options - -E When you invoke GCC, it normally does preprocessing, compilation, assembly and linking. 调用 GCC 时，通常会进行预处理、编译、汇编和链接。 Stop after the preprocessing stage; do not run the compiler proper. The output is in the form of prepr
利用gcc -E -P 进行宏替换 宏展开 预处理文件
洲游
05-18 1239
背景： 有的时候，非源码中的文件，需要使用到源码头文件中的一些宏，如连接脚本（link.ld）中，会用到源码中定义分配的内存地址宏，此时就可以用 gcc -E -P 命令对link.ld中的宏进行替换，否则无法识别宏。 待展开文件：link.ld #include “memory.h" SECTIONS { . = MEM_TEXT_BASE; .text : { *(.text) } . = MEM_DATA_BASE; ...
宏开关-gcc中的宏开关
weixin_38066782的博客
05-31 565
请注意，宏的定义只在当前的源文件中有效，如果你想在多个源文件中使用同一个宏，那么每个源文件都需要定义这个宏，或者你可以在一个公共的头文件中定义这个宏，然后在需要使用这个宏的源文件中包含这个头文件。也就是说，开启宏开关就是使其生效，将其定义或者赋值。此外，编译命令行选项也可以定义宏，例如在GCC和Clang编译器中，你可以使用。只要在代码中定义了某个宏，我们就可以说这个宏开关被开启了。开启宏开关并不意味着这个宏有特定的值，它只是存在。"开启宏开关"通常意味着定义了相应的预处理器宏。的宏，等同于开启了名为。
Linux gcc常用命令
最新发布
qq_66160948的博客
09-28 176
编译示例test.c代码\n");return 0;一步到位编译指令。
【Linux】工具（3）——gcc/g++
m0_70811813的博客
03-01 2545
本期博客详细介绍了Linux环境下gcc/g++工具的使用，还有对Linux环境下静态库和动态库的理解
c语言section作用,[原创]代码二次开发 C语言实现给自己的PE文件添加一个section（区段）...
weixin_39846364的博客
05-16 842
#include#include#include//引入外部库,也可以在project----setting---link中设置#ifndef_IMAGEHLP_H#include"imagehlp.h"#pragmacomment(lib,"imagehlp.lib")#endif//根据传入的dwAlign粒度调整内存中或文件中对齐后的大小DWORDAlign(DWOR...
第 43 章 MDK 的编译过程及文件类型全解
C_say_easy_to_me的博客
08-22 4504
(1)编译，MDK 软件使用的编译器是 armcc 和 armasm，它们根据每个 c/c++ 和汇编源文件编译成对应的以“.o”为后缀名的对象文件 (Object Code，也称目标文件)，其内容主要是从源文件编译得到的机器码，包含了代码、数据以及调试使用的信息；(2)链接，链接器 armlink 把各个.o 文件及库文件链接成一个映像文件“.axf”或“.elf”；(3)格式转换。
C/C++ 中的宏 (macros) 与宏展开的可视化显示
既然选择了远方 便只顾风雨兼程 - 永强
02-10 3039
C/C++ 中的宏 (macros) 与宏展开的可视化显示
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值