onexit.cpp File Reference

#include <corecrt_internal.h>

Include dependency graph for onexit.cpp:

Go to the source code of this file.

Enumerations
enum	: size_t { initial_table_count = 32 , minimum_table_increment = 4 , maximum_table_increment = 512 }

Functions
int __cdecl	_crt_atexit (_PVFV const function)
int __cdecl	_crt_at_quick_exit (_PVFV const function)
int __cdecl	_initialize_onexit_table (_onexit_table_t *const table)
int __cdecl	_register_onexit_function (_onexit_table_t *const table, _onexit_t const function)
int __cdecl	_execute_onexit_table (_onexit_table_t *const table)

Variables
_onexit_table_t	__acrt_atexit_table {}
_onexit_table_t	__acrt_at_quick_exit_table {}

Enumeration Type Documentation

anonymous enum

anonymous enum : size_t

Enumerator
initial_table_count
minimum_table_increment
maximum_table_increment

Definition at line 30 of file onexit.cpp.

{
    initial_table_count     = 32,
    minimum_table_increment = 4,
    maximum_table_increment = 512
};

Function Documentation

_crt_at_quick_exit()

int __cdecl _crt_at_quick_exit

(

_PVFV const

function

)

Definition at line 46 of file onexit.cpp.

{
    return _register_onexit_function(&__acrt_at_quick_exit_table, reinterpret_cast<_onexit_t>(function));
}

_crt_atexit()

int __cdecl _crt_atexit

(

_PVFV const

function

)

Definition at line 41 of file onexit.cpp.

{
    return _register_onexit_function(&__acrt_atexit_table, reinterpret_cast<_onexit_t>(function));
}

Referenced by atexit(), test_call_exit(), and test_call_quick_exit().

_execute_onexit_table()

int __cdecl _execute_onexit_table

(

_onexit_table_t *const

table

)

Definition at line 158 of file onexit.cpp.

{
    return __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
    {
        if (!table)
        {
            return -1;
        }
 
        _PVFV* first = __crt_fast_decode_pointer(table->_first);
        _PVFV* last  = __crt_fast_decode_pointer(table->_last);
        if (!first || first == reinterpret_cast<_PVFV*>(-1))
        {
            return 0;
        }
 
        // This loop calls through caller-provided function pointers.  We must
        // save and reset the global state mode before calling them, to maintain
        // proper mode nesting.  (These calls to caller-provided function pointers
        // are the only non-trivial calls, so we can do this once for the entire
        // loop.)
        {
            __crt_state_management::scoped_global_state_reset saved_state;
 
            _PVFV const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
 
            _PVFV* saved_first = first;
            _PVFV* saved_last  = last;
            for (;;)
            {
                // Find the last valid function pointer to call:
                while (--last >= first && *last == encoded_nullptr)
                {
                    // Keep going backwards
                }
 
                if (last < first)
                {
                    // There are no more valid entries in the list; we are done:
                    break;
                }
 
                // Store the function pointer and mark it as visited in the list:
                _PVFV const function = __crt_fast_decode_pointer(*last);
                *last = encoded_nullptr;
 
                function();
 
                _PVFV* const new_first = __crt_fast_decode_pointer(table->_first);
                _PVFV* const new_last  = __crt_fast_decode_pointer(table->_last);
 
                // Reset iteration if either the begin or end pointer has changed:
                if (new_first != saved_first || new_last != saved_last)
                {
                    first = saved_first = new_first;
                    last  = saved_last  = new_last;
                }
            }
        }
 
        if (first != reinterpret_cast<_PVFV*>(-1))
        {
            _free_crt(first);
        }
 
        _PVFV* const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
 
        table->_first = encoded_nullptr;
        table->_last  = encoded_nullptr;
        table->_end   = encoded_nullptr;
 
        return 0;
    });
}

_initialize_onexit_table()

int __cdecl _initialize_onexit_table

(

_onexit_table_t *const

table

)

Definition at line 53 of file onexit.cpp.

{
    if (!table)
    {
        return -1;
    }
 
    // If the table has already been initialized, do not do anything.  Note that
    // this handles both the case where the table was value initialized and where
    // the table was initialized with encoded null pointers.
    if (table->_first != table->_end)
    {
        return 0;
    }
 
    _PVFV* const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
 
    table->_first = encoded_nullptr;
    table->_last  = encoded_nullptr;
    table->_end   = encoded_nullptr;
 
    return 0;
}

_register_onexit_function()

int __cdecl _register_onexit_function	(	_onexit_table_t *const	table,
		_onexit_t const	function
	)

Definition at line 82 of file onexit.cpp.

{
    return __acrt_lock_and_call(__acrt_select_exit_lock(), [&]
    {
        if (!table)
        {
            return -1;
        }
 
        _PVFV* first = __crt_fast_decode_pointer(table->_first);
        _PVFV* last  = __crt_fast_decode_pointer(table->_last);
        _PVFV* end   = __crt_fast_decode_pointer(table->_end);
 
        // If there is no room for the new entry, reallocate a larger table:
        if (last == end)
        {
            size_t const old_count = end - first;
 
            size_t const increment = old_count > maximum_table_increment ? maximum_table_increment : old_count;
 
            // First, try to double the capacity of the table:
            size_t new_count = old_count + increment;
            if (new_count == 0)
            {
                new_count = initial_table_count;
            }
 
            _PVFV* new_first = nullptr;
            if (new_count >= old_count)
            {
                new_first = _recalloc_crt_t(_PVFV, first, new_count).detach();
            }
 
            // If that didn't work, try to allocate a smaller increment:
            if (new_first == nullptr)
            {
                new_count = old_count + minimum_table_increment;
                new_first = _recalloc_crt_t(_PVFV, first, new_count).detach();
            }
 
            if (new_first == nullptr)
            {
                return -1;
            }
 
            first = new_first;
            last  = new_first + old_count;
            end   = new_first + new_count;
 
            // The "additional" storage obtained from recalloc is sero-initialized.
            // The array holds encoded function pointers, so we need to fill the
            // storage with encoded nullptrs:
            _PVFV const encoded_nullptr = __crt_fast_encode_pointer(nullptr);
            for (auto it = last; it != end; ++it)
            {
                *it = encoded_nullptr;
            }
        }
 
        *last++ = reinterpret_cast<_PVFV>(__crt_fast_encode_pointer(function));
 
        table->_first = __crt_fast_encode_pointer(first);
        table->_last  = __crt_fast_encode_pointer(last);
        table->_end   = __crt_fast_encode_pointer(end);
 
        return 0;
    });
}

Referenced by _crt_at_quick_exit(), and _crt_atexit().

Variable Documentation

__acrt_at_quick_exit_table

_onexit_table_t __acrt_at_quick_exit_table {}

Definition at line 26 of file onexit.cpp.

Referenced by _crt_at_quick_exit(), and initialize_c().

__acrt_atexit_table

_onexit_table_t __acrt_atexit_table {}

Definition at line 25 of file onexit.cpp.

Referenced by _crt_atexit(), and initialize_c().