gcc对open(2)支持重载吗

在Linux中，如果man -s2 open, 我们看到两种不同的函数原型声明：

$ man -s2 open
NAME
       open, creat - open and possibly create a file or device

SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fcntl.h>

       int open(const char *pathname, int flags);
       int open(const char *pathname, int flags, mode_t mode);

...<snip>...

大约14年前（刚迈出大学校园没多久），第一次看到这样的声明的时候，我很纳闷，难道gcc能像g++一样支持c++的重载(overload)？当时没搞明白，反正能编译通过，就没深究(当然那时候也没能力深究)。什么是重载？所谓重载，就是函数名相同，但是参数列表不同。

那么为什么gcc支持编译同一个函数名open但是具有不同的参数列表呢？

先用一个小例子证明gcc不支持重载但是g++支持（当然也必须支持）。

o jade.c

 int add(int a, int b)
 {
         return (a + b);
 }

 int add(int a, int b, int c)
 {
         return (a + b + c);
 }

 int main(int argc, char *argv[])
 {
         int m = add(, );
         int n = add(, , );
         return (m + n);
 }

o 用gcc编译看看，有报错哦

$ gcc -g -Wall -o jade jade.c
jade.c::: error: conflicting types for ‘add’
 int add(int a, int b, int c)
     ^
jade.c::: note: previous definition of ‘add’ was here
 int add(int a, int b)
     ^
jade.c: In function ‘main’:
jade.c::: error: too few arguments to function ‘add’
  int m = add(, );
  ^
jade.c::: note: declared here
 int add(int a, int b, int c)
     ^

看来gcc真的不支持重载啊, 让一个c编译器去支持c++的语法，怎么可能呢?! 当然没有这种可能。

o 改用g++编译看看

$ g++ -g -Wall -o jade jade.c
$ ./jade
$ echo $?

没得错，g++能正确处理重载函数。那么回到原来的问题，为什么gcc支持编译两种不同的open()函数原型? 还是先写个demo看看。

o foo.c

 /*
  * Demo to dig out how these two open() as follows are compiled by gcc.
  * o int open(const char *pathname, int flags);
  * o int open(const char *pathname, int flags, mode_t mode);
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>

 int
 main(int argc, char *argv[])
 {
         /* XXX: Do NOT have any error handling to make things simple */

         if (argc != )
                 return -;

         char *file1 = argv[];
         char *file2 = argv[];

         int fd1 = open(file1, O_RDWR|O_APPEND);
         int fd2 = open(file2, O_RDWR|O_APPEND|O_CREAT, );

         write(fd1, "hello\n", );
         write(fd2, "world\n", );

         close(fd1);
         close(fd2);

         return ;
 }

o 编译并测试

$ gcc -g -Wall -o foo foo.c
$ rm -f /tmp/f1 /tmp/f2
$ echo "world" > /tmp/f1 && cat /tmp/f1
world
$ ls -l /tmp/f1
-rw-r--r--  veli veli  Apr  : /tmp/f1
$ ./foo /tmp/f1 /tmp/f2
$ ls -l /tmp/f1 /tmp/f2
-rw-r--r--  veli veli  Apr  : /tmp/f1
-rwxr-xr-x  veli veli   Apr  : /tmp/f2
$ cat /tmp/f1
world
hello
$ cat /tmp/f2
world

神啦，gcc貌似支持重载。请注意，貌似！好了，反汇编看看。

(gdb) set disassembly-flavor intel
(gdb) disas /m main
Dump of assembler code for function main:
      {
   0x0804847d <+>:     push   ebp
   0x0804847e <+>:     mov    ebp,esp
   0x08048480 <+>:     and    esp,0xfffffff0
   0x08048483 <+>:     sub    esp,0x20

              /* XXX: Do NOT have any error handling to make things simple */

              if (argc != )
   0x08048486 <+>:     cmp    DWORD PTR [ebp+0x8],0x3
   0x0804848a <+>:    je     0x8048496 <main+>

                      return -;
   0x0804848c <+>:    mov    eax,0xffffffff
   0x08048491 <+>:    jmp    0x8048537 <main+>

              char *file1 = argv[];
   0x08048496 <+>:    mov    eax,DWORD PTR [ebp+0xc]
   0x08048499 <+>:    mov    eax,DWORD PTR [eax+0x4]
   0x0804849c <+>:    mov    DWORD PTR [esp+0x10],eax

              char *file2 = argv[];
   0x080484a3 <+>:    mov    eax,DWORD PTR [eax+0x8]
   0x080484a6 <+>:    mov    DWORD PTR [esp+0x14],eax

              int fd1 = open(file1, O_RDWR|O_APPEND);
   0x080484aa <+>:    mov    DWORD PTR [esp+0x4],0x402
   0x080484b2 <+>:    mov    eax,DWORD PTR [esp+0x10]
   0x080484b6 <+>:    mov    DWORD PTR [esp],eax
   0x080484b9 <+>:    call   0x8048340 <open@plt>
   0x080484be <+>:    mov    DWORD PTR [esp+0x18],eax

              int fd2 = open(file2, O_RDWR|O_APPEND|O_CREAT, );
   0x080484c2 <+>:    mov    DWORD PTR [esp+0x8],0x1ed
   0x080484ca <+>:    mov    DWORD PTR [esp+0x4],0x442
   0x080484d2 <+>:    mov    eax,DWORD PTR [esp+0x14]
   0x080484d6 <+>:    mov    DWORD PTR [esp],eax
   0x080484d9 <+>:    call   0x8048340 <open@plt>
   0x080484de <+>:    mov    DWORD PTR [esp+0x1c],eax

...<snip>...

              return ;
   0x08048532 <+>:   mov    eax,0x0

      }
   0x08048537 <+>:   leave
   0x08048538 <+>:   ret

End of assembler dump.
(gdb)

对于open()函数，L22有两个参数, L23则有三个参数，gcc都能将其优雅地压入栈(stack)中。这里我们就可以大胆地猜测一下了，open()函数一定是支持变参的！接下来就是找证据。用gcc -E foo.c看一看，

 $ gcc -E foo.c | egrep open
 extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ ()));
 extern int openat (int __fd, const char *__file, int __oflag, ...)
  int fd1 = open(file1, |);
  int fd2 = open(file2, ||, );

注意L2行，open() 果然支持变参，Bingo! 而open()的函数原型定义在fcntl.h中，

$ egrep -in " open .*nonnull.*" /usr/include/fcntl.h
:extern int open (const char *__file, int __oflag, ...) __nonnull (());

相比之下，ioctl（2）一看就知道其支持变参。

$ man -s2 ioctl
NAME
       ioctl - control device

SYNOPSIS
       #include <sys/ioctl.h>

       int ioctl(int d, int request, ...);

...<snip>...

小结：

乍一看，open(2)的man page确实给了我们这样一个假象，一个c编译器gcc竟然支持c++的重载，简直太不可思议啦。然而，透过现象看本质，gcc之所以能够友好地编译两种不同的open()函数原型，是因为，gcc不支持也不可能支持c++的重载，但是open()函数原型支持变参。（Aha, 原来是open(2)的man page误导了我！） 另外，如果对ABI有所了解，那么很容易想明白，open(2)作为一种系统调用(syscall)，支持变参，合情合理。