Linux C 语言之 Hello World 详解

Linux C 语言之 Hello World 详解

第一个 C 语言程序

学习 C 语言，大多数接触的第一个 C 语言程序便是经典的 Hello World 程序，程序的功能是在当前终端上打印 “Hello World” 字符串！

该程序的实现代码如下：

#include <stdio.h>

void main()

{

  printf("Hello World\n");

}

在 GNU/Linux 系统中，使用 gcc 编译器，编译并执行 helloworld 程序的指令为：

通过 vi 编辑器编写上面代码，并保存为 helloworld.c
使用 gcc 编译器编译源代码生成可执行文件 helloworld： gcc -o helloworld helloworld.c
执行当前目录中的 helloworld 程序：./helloworld

当前终端屏幕就会打印 Hello World，如下图：

程序运行原理

GNU/Linux 系统中可执行程序都是 elf 格式二进制文件，该文件跟 Windows 系统的 exe 文件类似，通过 Linux 的 Shell 比如 Bash 加载到内存，由操作系统启动

新线程，然后开始执行。我们可以通过 file 命令查看目标文件的格式：

:~$ file helloworld

helloworld: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=203388067920d237ab234e8eb97714f56919799f, not stripped

编译，链接

从源代码生成可执行文件，需要很多步骤，最主要的步骤就是编译和链接。在我们上述的过程中，编译和链接都是由 gcc 程序完成的。

当然我们也可以分开来执行编译和链接过程：

gcc -c helloworld.c

ld -o helloworld helloworld.o -dynamic-linker /lib64/ld-linux-x86-64.so.2 /usr/lib/x86_64-linux-gnu/crt1.o /usr/lib/x86_64-linux-gnu/crti.o /usr/lib/x86_64-linux-gnu/crtn.o -lc

可以看到，简单的 helloworld 程序依赖了大量的系统文件，其中主要的是程序运行环境相关的 crt （C RunTime Library）和系统 c 语言库 glibc。

当然不同的平台这个步骤可能不同，可以在 gcc 命令中添加 -v 参数，查看编译和链接的完整步骤。

运行时

我们从代码可见的程序起始是 main 函数，但是编译器在编译链接的过程中，在我们的程序中添加了运行时代码，所以程序的起始并不是 main 函数了，可以通过 nm 查看我们的程序的地址和符号：

$ nm helloworld

0000000000600734 D __bss_start

0000000000600730 D __data_start

0000000000600730 W data_start

0000000000600570 d _DYNAMIC

0000000000600734 D _edata

0000000000600738 D _end

0000000000400464 T _fini

0000000000600708 d _GLOBAL_OFFSET_TABLE_

                 w __gmon_start__

0000000000400340 T _init

0000000000600570 d __init_array_end

0000000000600570 d __init_array_start

000000000040047c R _IO_stdin_used

0000000000400460 T __libc_csu_fini

00000000004003f0 T __libc_csu_init

                 U __libc_start_main@@GLIBC_2.2.5

00000000004003a0 T main

                 U puts@@GLIBC_2.2.5

00000000004003c0 T _start

可以看到 main 函数已经不是在程序的代码段开头了。可以通过对 gcc 添加 -Map 参数，来生成程序的 map 文件，方便我们查看程序的代码段，数据段等信息：

gcc -o helloworld helloworld.c -Wl,-Map,helloworld.map

通过 helloworld.map 可以清晰的看到 main 函数所在的 text 段，和相关的地址信息。

链接库

gcc 默认动态库的搜索路径搜索的先后顺序是：

编译目标代码时指定的动态库搜索路径；
环境变量LD_LIBRARY_PATH指定的动态库搜索路径；
配置文件/etc/ld.so.conf中指定的动态库搜索路径；
默认的动态库搜索路径/lib、/usr/lib。

所以指定目标库的时候需要使用 -rpath 参数传递路径给 gcc。

我们这里只是使用了标准 c 库，版本为 ldd 展示的 /lib/x86_64-linux-gnu/libc.so.6 GLIBC_2.2.5

ldd helloworld

linux-vdso.so.1 => (0x00007ffd493f3000)

libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f5f12756000)

/lib64/ld-linux-x86-64.so.2 (0x00007f5f12b20000)

编译器优化

我们显示调用的 c 库函数是 printf，在 c 语言库中 stdio.h 中定义：

/* Write formatted output to stdout.

   This function is a possible cancellation point and therefore not

   marked with __THROW.  */

extern int printf (const char *__restrict __format, ...);

但是实际上，我们通过 nm 命令看到可执行文件中调用的 c 库的 puts，通过汇编更能清晰的看到这个调用的详细情况：

gcc -S helloworld.c

cat helloworld.s

        .file   "helloworld.c"

        .section        .rodata

.LC0:

        .string "Hello World"

        .text

        .globl  main

        .type   main, @function

main:

.LFB0:

        .cfi_startproc

        pushq   %rbp

        .cfi_def_cfa_offset 16

        .cfi_offset 6, -16

        movq    %rsp, %rbp

        .cfi_def_cfa_register 6

        movl    $.LC0, %edi

        call    puts

        nop

        popq    %rbp

        .cfi_def_cfa 7, 8

        ret

        .cfi_endproc

.LFE0:

        .size   main, .-main

        .ident  "GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609"

        .section        .note.GNU-stack,"",@progbits

当打印的全部是字符串，即没有需要转为字符串的操作的时候， gcc 会把 printf 优化成 puts。所以对于编译器的优化对程序员来说有时候是透明的。

我们需要仔细的检查编译器是否对我们的代码进行了优化。

Hello World 打印原理

从上面的分析，我们知道，我们的 helloworld 程序主要是调用了 puts 函数进行打印，puts 在 glibc 中的实现如下：

/* Write the string in S and a newline to stdout.  */

int

puts (const char *s)

{

  return fputs (s, stdout) || putchar ('\n') == EOF ? EOF : 0;

}

该函数主要是调用 fputs 将字符串送到 stdout （标注输出），并送出一个换行符！换行符同样是送到 stdout ：

/* Write the character C on stdout.  */

int

putchar (int c)

{

  return __putc (c, stdout);

}

stdout, stdin 和 stderr

那么 stdout 是什么，glibc 是如何通过 stdout 将我们的终端相连接的呢？

stdout 在 glibc 中是 FILE 类型的指针：

/* Standard streams.  */

extern FILE *stdin, *stdout, *stderr;

#ifdef __STRICT_ANSI__

/* ANSI says these are macros; satisfy pedants.  */

#define	stdin	stdin

#define	stdout	stdout

#define	stderr	stderr

#endif

这 3 个指针分别是对应 fd 号为 0,1,2 的 3 个标准 fd 的封装：

/* Standard streams.  */

#define	READ		1, 0

#define	WRITE		0, 1

#define	BUFFERED	0

#define	UNBUFFERED	1

#define	stdstream(name, next, fd, readwrite, unbuffered)		      \

    {									      \

      _IOMAGIC,								      \

      NULL, NULL, NULL, NULL, 0,					      \

      (void *) fd,							      \

      { readwrite, /* ... */ },						      \

      { NULL, NULL, NULL, NULL, NULL },					      \

      { NULL, NULL },							      \

      -1, -1,								      \

      (next),								      \

      NULL, '\0', 0,							      \

      0, 0, unbuffered, 0, 0, 0, 0					      \

    }

static FILE stdstreams[3] =

  {

    stdstream (&stdstreams[0], &stdstreams[1], STDIN_FILENO, READ, BUFFERED),

    stdstream (&stdstreams[1], &stdstreams[2], STDOUT_FILENO, WRITE, BUFFERED),

    stdstream (&stdstreams[2], NULL, STDERR_FILENO, WRITE, UNBUFFERED),

  };

FILE *stdin = &stdstreams[0];

FILE *stdout = &stdstreams[1];

FILE *stderr = &stdstreams[2];

其中可以明确的知道：

只有 stderr 是不缓冲的，stdin 和 stdout 都是缓冲的，那么输出到 stdout 的字符可能不会立即显示
stdin 是只读的， stdout 和 stderr 是只能写的，其他的操作，比如读 stdout 是不可预知的。
fd 是显示直接强制赋值的，就是说 0,1,2 应该是已经打开的描述符，否则会出现输入输出错误。

那么是在何时打开的标准描述符呢？

stdio 与 tty

stdio 是与 tty 对应的，一个系统中可以有很多用户，或者一个用户打开了多个终端，但是 printf 等输出都是在当前终端上。

stdio 是与 tty 一一对应。从 glibc 的代码我们可以找到打开标准描述符 0,1,2 的位置：

login_tty.c

int

login_tty(fd)

	int fd;

{

	(void) setsid();

#ifdef TIOCSCTTY

	if (ioctl(fd, TIOCSCTTY, (char *)NULL) == -1)

		return (-1);

#else

	{

	  /* This might work.  */

	  char *fdname = ttyname (fd);

	  int newfd;

	  if (fdname)

	    {

	      if (fd != 0)

		(void) close (0);

	      if (fd != 1)

		(void) close (1);

	      if (fd != 2)

		(void) close (2);

	      newfd = open (fdname, O_RDWR);

	      (void) close (newfd);

	    }

	}

#endif

	(void) dup2(fd, 0);

	(void) dup2(fd, 1);

	(void) dup2(fd, 2);

	if (fd > 2)

		(void) close(fd);

	return (0);

}

每次登陆的时候，系统会将当前的 login 程序传入的 fb， dump 出来 3 份，分别的 fb 值就是 0,1,2

因此， stdin、stdout、stderr 其实对应的是同一个文件，这个文件就是当前 login 使用的 tty 。

从内存到设备

我们的 helloworld 程序被 shell 加载到内存， “Hello World” 字符串也是在内存的位置，如何输出到 tty 设备呢？

我们 tty 设备是虚拟的设备，可能是 LCD 显示器，可能是串口，也可能是 LED 显示器。其中的对应和输出流，

那就是要牵涉到具体的设备驱动，那又是另一个领域才能讲清楚的了。大概的数据流就是：

输出设备和 tty 是绑定的，输出到 tty 就会把数据传递给显示设备驱动程序
设备驱动程序会把字符串数据最后通过 DMA 或者其他总线方式发给设备
最终的设备会显示我们需要看到的字符串 “Hello World”