c++ runtime - dtor (0) 原理篇

有正就有反, 有男就有女, 有前就有後, 東西南北, 凸與凹, 扯太多了, 有建構函式必有解構函式, 接續 ctor 的議題:
_GLOBAL__I_io call
_Z41__static_initialization_and_destruction_0ii

_Z41__static_initialization_and_destruction_0ii 除了呼叫 ctor 之外, 還為 dtor 做了準備。g++ 使用 __cxa_atexit 來註冊每一個 dtor, 所以 _Z41__static_initialization_and_destruction_0ii 還呼叫了 __cxa_atexit。

  1df:   66 b8 3c 03 00 00       mov    $0x33c,%eax
  1e5:   67 66 c7 44 24 08 6c    addr32 movl $0x106c,0x8(%esp)
  1ec:   10 00 00 
  1ef:   67 66 c7 44 24 04 60    addr32 movl $0x1060,0x4(%esp)
  1f6:   10 00 00 
  1f9:   67 66 89 04 24          addr32 mov %eax,(%esp)
  1fe:   66 e8 84 ff ff ff       calll  188 <__cxa_atexit>

__cxa_atexit function prototype:

int __cxa_atexit(void (*destructor) (void *), void *arg, void *__dso_handle)

1. L14, 0x33c 就是 <_ZN2IoD1Ev> (Io 的 destructor),
2. L17, $0x1060 則是 global io object 的位址 (in .bss section, use readelf -a cppb.elf to see), Io::~Io() 要把自己傳進去, 就是 this 指標, 所以會需要這個參數。
3. L15, $0x106c 自然是 __dso_handle。

因為有兩個 dtor, 所以 __cxa_atexit 呼叫了兩次。

dtor

 
 000001b4 <_Z41__static_initialization_and_destruction_0ii>:
  1b4:   66 55                   push   %ebp
  1b6:   66 89 e5                mov    %esp,%ebp
  1b9:   66 83 ec 18             sub    $0x18,%esp
  1bd:   67 66 83 7d 08 01       addr32 cmpl $0x1,0x8(%ebp)
  1c3:   75 7d                   jne    242 <_Z41__static_initialization_and_destruction_0ii+0x8e>
  1c5:   67 66 81 7d 0c ff ff    addr32 cmpl $0xffff,0xc(%ebp)
  1cc:   00 00 
  1ce:   75 72                   jne    242 <_Z41__static_initialization_and_destruction_0ii+0x8e>
  1d0:   67 66 c7 04 24 60 10    addr32 movl $0x1060,(%esp)
  1d7:   00 00 
  1d9:   66 e8 e1 00 00 00       calll  2c0 <_ZN2IoC1Ev>
  1df:   66 b8 3c 03 00 00       mov    $0x33c,%eax
  1e5:   67 66 c7 44 24 08 6c    addr32 movl $0x106c,0x8(%esp)
  1ec:   10 00 00 
  1ef:   67 66 c7 44 24 04 60    addr32 movl $0x1060,0x4(%esp)
  1f6:   10 00 00 
  1f9:   67 66 89 04 24          addr32 mov %eax,(%esp)
  1fe:   66 e8 84 ff ff ff       calll  188 <__cxa_atexit>
  204:   67 66 c7 44 24 04 07    addr32 movl $0x7,0x4(%esp)
  20b:   00 00 00 
  20e:   67 66 c7 04 24 64 10    addr32 movl $0x1064,(%esp)
  215:   00 00 
  217:   66 e8 c1 01 00 00       calll  3de <_ZN2AbC1Ei>
  21d:   66 b8 3c 04 00 00       mov    $0x43c,%eax
  223:   67 66 c7 44 24 08 6c    addr32 movl $0x106c,0x8(%esp)
  22a:   10 00 00 
  22d:   67 66 c7 44 24 04 64    addr32 movl $0x1064,0x4(%esp)
  234:   10 00 00 
  237:   67 66 89 04 24          addr32 mov %eax,(%esp)
  23c:   66 e8 46 ff ff ff       calll  188 <__cxa_atexit>
  242:   66 c9                   leavel 
  244:   66 c3                   retl   
 
 
 0000033c <_ZN2IoD1Ev>:
  33c:   66 55                   push   %ebp
  33e:   66 89 e5                mov    %esp,%ebp
  341:   66 83 ec 18             sub    $0x18,%esp
  345:   67 66 c7 44 24 04 4d    addr32 movl $0x104d,0x4(%esp)
  34c:   10 00 00 
  34f:   67 66 8b 45 08          addr32 mov 0x8(%ebp),%eax
  354:   67 66 89 04 24          addr32 mov %eax,(%esp)
  359:   66 e8 05 00 00 00       calll  364 <_ZN2Io5printEPKc>
  35f:   66 c9                   leavel 
  361:   66 c3                   retl   
  363:   90                      nop
 
 
 0000043c <_ZN2AbD1Ev>:
  43c:   66 55                   push   %ebp
  43e:   66 89 e5                mov    %esp,%ebp
  441:   66 83 ec 18             sub    $0x18,%esp
  445:   67 66 c7 44 24 04 4d    addr32 movl $0x104d,0x4(%esp)
  44c:   10 00 00 
  44f:   67 66 8b 45 08          addr32 mov 0x8(%ebp),%eax
  454:   67 66 89 04 24          addr32 mov %eax,(%esp)
  459:   66 e8 05 00 00 00       calll  464 <_ZN2Ab5printEPKc>
  45f:   66 c9                   leavel 
  461:   66 c3                   retl   
  463:   90                      nop

再來就是在 __cxa_atexit 裡頭把應該要存的東西存起來, 在適當的時候呼叫他們 (ex: 離開 c++ main()), 就完成解構了。

什麼是要存的東西?

• dtor
• dtor argument (this pointer)
• __dso_handle

這是兩種 dtor 的實作方式之一, 另外一種 g++ 新版已經不用了, 就是使用 .dtor section 來儲存每個 dtor function, 類似 ctor section,  然後一個一個 call 他們就好了, 說來簡單, 不過可能實際上的實作並不容易, 才會改用這種方式。

以上的 objdump 結果來自下面的程式碼。

cppb.cpp

 __asm__(".code16gcc\n");
 #include "io.h"
 
 /*
  * c bootloader
  */
 
 //#define POINTER_TEST
 
 
 #define BOCHS_MB __asm__ __volatile__("xchg %bx, %bx");
 
 
 Io io;
 Ab ab(7);
 
 extern int _start_ctors;
 extern int _end_ctors;
 
 extern "C" void WinMain(void)
 {
 
   BOCHS_MB  
   #if 1
   //__asm__ ("mov  %cs, %ax\n");
   //__asm__ ("mov  %ax, %ds\n");
   //__asm__ ("mov  %ax, %ss\n");
 
 #if 0
   int ctor_addr_start = _start_ctors;
   int ctor_addr_end = _end_ctors;
     typedef void (*FuncPtr)();
     FuncPtr fp = (FuncPtr)(ctor_addr_start);
     fp();
 #endif
 
 /* Test for GCC > 3.2.0 
  * ref: http://gcc.gnu.org/onlinedocs/gcc-3.4.6/cpp/Common-Predefined-Macros.html
   #if __GNUC__ > 3 || \
   (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || \
   (__GNUC_MINOR__ == 2 && \
   __GNUC_PATCHLEVEL__ > 0))
 */
 
   #if __GNUC__ >= 4 && __GNUC_MINOR__ <= 4
   extern void _GLOBAL__I_io();
   _GLOBAL__I_io();
   #else // for 4.7
   extern void _GLOBAL__sub_I_io();
   _GLOBAL__sub_I_io();
   #endif
     #if 0
   for (int i = ctor_addr_start; i < ctor_addr_end ; ++i)
   {
   }
 
 #endif
   //__asm__ ("mov  $0xfff0, %sp\n");
   {
   const char *ver=__VERSION__;
   io.print("hello cpp class\r\n");
   io.print("g++ version: ");
   io.print(ver);
   io.print("\r\n");
   }
   #if 0
   unsigned char *vb = (unsigned char *)0xb8000;
   *vb = 'A';
   *(unsigned char *)0xb8001 = 0xc;
   *(unsigned char *)0xb8002 = 'B';
   *(unsigned char *)0xb8003 = 0x9;
   *(unsigned char *)0xb8004 = '@';
   *(unsigned char *)0xb8005 = 0xc;
   #endif
   //while(1);
   __asm__ ("mov     $0x4c00, %ax\n");
   __asm__ ("int     $0x21\n"); //   回到 DOS
 
   #endif
 }
 
 
 
 void *__dso_handle;
 extern "C"
 {
 int __cxa_atexit(void (*destructor) (void *), void *arg, void *__dso_handle)
 {
   io.print("__cxa_atexit\r\n");
   return 0;
 }
 void __cxa_finalize(void *d)
 {
   io.print("hello dtor\r\n");
 }
 }

io.h

 __asm__(".code16gcc\n");
 #ifndef IO_H
 #define IO_H
 
 class Io
 {
   public:
     Io();
     ~Io();
     void print(const char   *s);
   private:
     const char *str_;
 };
 
 class Ab
 {
   public:
     Ab(int i);
     ~Ab();
     void print(const char   *s);
   private:
     const char *str_;
     int i_;
 };
 
 #endif

io.cpp

 #include "io.h"
 Io::Io():str_("data member\r\n")
 {
   print("ctor\r\n");
   print(str_);
 }
 Io::~Io()
 {
   print("dtor\r\n");
 }
 
 void Io::print(const char   *s)
 {
   while(*s)
   {
     __asm__ __volatile__ ("int  $0x10" : : "a"(0x0E00 | *s), "b"(7));
     s++;
   }
 }
 
 Ab::Ab(int i)
 {
   print("Ab::ctor\r\n");
   i_ = i ; 
 }
 
 Ab::~Ab()
 {
   print("dtor\r\n");
 }
 
 void Ab::print(const char   *s)
 {
   while(*s)
   {
     __asm__ __volatile__ ("int  $0x10" : : "a"(0x0E00 | *s), "b"(7));
     s++;
   }
 }

ref:
http://hilananufi.serw5.com/global-object-destructor-c.php