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

c++ runtime - dtor (1) 實作篇

在原理篇之後, 我們來實作如何喚起 global object dtor。

cpp_abi.h

 __asm__(".code16gcc\n");
 
 #ifndef CPP_ABI_H
 #define CPP_ABI_H
 
 #define DOBJS_SIZE 3
 
 struct DObjs
 {
   void (*dtor_) (void *);
   void *arg_;
   void *dso_handle_;
 };
 
 extern "C"
 {
   int __cxa_atexit(void (*destructor) (void *), void *arg, void *__dso_handle);
   void g_dtors(void);
 }
 
 #endif

cpp_abi.h 補上需要的資訊, struct DObjs, 用來紀錄要調用呼叫的 dtor。

 #define DOBJS_SIZE 3

我宣告 size 為 3 的 DObjs array, 目前要用到的只有 io, ab 這兩個 globle object, 正確實作的話, 應該要去知道有幾個 global objects, 不過這裡我們就偷懶一下, 寫死就好。

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

則是要資訊紀錄在 DObjs 裡頭, 把每一個 dtor, this pointer, 紀錄下來,  __dso_handle 沒有用到, 我目前還搞不定 share objects。

void g_dtors(void);
呼叫每一個 global object dtor (依照建構時相反的順序)

參考以下 cpp_abi.cpp 實作。

cpp_abi.cpp

 #include "cpp_abi.h"
 
 void *__dso_handle;
 
 static DObjs dobjs[DOBJS_SIZE];
 int obj_count=0;
 
 void print_str(const char   *s);
 void s16_print_int(int i, int radix);
 
 extern "C"
 {
 
   int __cxa_atexit(void (*destructor) (void *), void *arg, void *__dso_handle)
   {
     __asm__ __volatile__("xchg %bx, %bx");
     print_str("atexit\r\n");
     s16_print_int(obj_count, 10);
     print_str("\r\n");
 
     dobjs[obj_count].dtor_ = destructor;
     dobjs[obj_count].arg_ = arg;
     dobjs[obj_count].dso_handle_ = __dso_handle;
     ++obj_count;
     return 0;
   }
   void g_dtors(void)
   {
     for (int i=obj_count-1 ; i >= 0 ; --i)
     {
       dobjs[i].dtor_(dobjs[i].arg_);
     }
   }
 }

再來的程式就簡單了,  L84 就是呼叫 g_dtors, 直接把之前紀錄的 dtor 一個一個執行, 就完成在退出 cpp_main 時執行 global object 的解構。

整個 global objects ctor/dtor 的實作就是這樣, 沒有那麼神祕了吧！

cpp_init.S

 # init c++ runtime
 
 #define DOS
 
 .code16
 .extern __bss_start__
 .extern __bss_end__
 .extern __start_ctors
 .extern __end_ctors
 .extern cpp_main
 .extern obj_count
 
 
 .text
   jmp _start
 .global _start
 _start:
   xchg %bx, %bx
 #if 1
   mov %cs, %ax
   mov %ax, %ds
   mov %ax, %ss
 
 #endif

 
   call init_bss_asm # in dos need not init bss by myself
 

   # call _GLOBAL__I_XX invoke global object ctor, 
   # in dos environment use 16 or 32 bit address? look like 32 bit
   calll init_cpp_global_asm
   calll cpp_main
   calll g_dtors
 #  call disp_str2
   mov     $0x4c00, %ax
   int     $0x21   # 回到 DOS
 


 
 # call global object ctor
 init_cpp_global_asm:
 #if __GNUC__ >= 4 && __GNUC_MINOR__ >= 7
   mov $__end_global_ctor__, %edi    /* Destination */
   mov $__start_global_ctor__, %esi   /* Source */
 #else
   mov $__end_ctors, %edi    /* Destination */
   mov $__start_ctors, %esi   /* Source */
 #endif
   jmp 2f
 1:
   mov %esi, %ebx 
   calll *(%ebx)
   add $4, %esi
 2:
   cmp %edi, %esi
   jne 1b
   ret
 
 # init bss
 init_bss_asm:
   movw $__bss_end__, %di    /* Destination */
   movw $__bss_start__, %si   /* Source */
   movw %ds, %bx
   movw %bx, %es
   jmp 2f
 1:
   mov $0, %eax
   movw %si, %ax
   movb $0x0, %es:(%eax)
   add $1, %si
 
 
   # wait key
 #  xor %eax,%eax
 #  int $0x16
 
   
 2:
   cmpw %di, %si
   jne 1b
 
   ret
 

再來要聊聊 local static object。

完整程式碼:
simple os: git clone git@github.com:descent/simple_os.git
git branch: cpp_runtime
git commit: 92e0183c722166c84da8b28aa11fd8afeff0ff6c
directory: simple_os/cpp_runtime/global_object/dos_cpp