/*** *assert.c - Display a message and abort * * Copyright (c) Microsoft Corporation. All rights reserved. * *Purpose: * *******************************************************************************/ #include #include #include #include #include #include #undef NDEBUG #define _ASSERT_OK #include // Assertion string components: #define MAXLINELEN 64 /* max length for line in message box */ #define ASSERTBUFSZ (MAXLINELEN * 9) /* 9 lines in message box */ // Format of stderr for assertions: // // Assertion failed: , file c:\test\mytest\bar.c, line 69 // _GENERATE_TCHAR_STRING_FUNCTIONS(assert_format, "Assertion failed: %Ts, file %Ts, line %d\n") // Enclaves only support assertions sent to the debugger. // This mode could also be enabled for normal apps as well. #ifdef _UCRT_ENCLAVE_BUILD template __declspec(noreturn) static void __cdecl common_assert_to_debug( Character const* const expression, Character const* const file_name, unsigned const line_number ) throw() { using traits = __crt_char_traits; Character assert_buffer[ASSERTBUFSZ]; if (traits::sntprintf_s(assert_buffer, _countof(assert_buffer), _countof(assert_buffer), get_assert_format(Character()), expression, file_name, line_number) < 0) { abort(); } traits::output_debug_string(assert_buffer); abort(); } template static void __cdecl common_assert( Character const* const expression, Character const* const file_name, unsigned const line_number, void* const ) throw() { common_assert_to_debug(expression, file_name, line_number); } #else /* ^^^ _UCRT_ENCLAVE_BUILD ^^^ // vvv !_UCRT_ENCLAVE_BUILD vvv */ // Format of MessageBox for assertions: // // ================= Microsft Visual C++ Debug Library ================ // // Assertion Failed! // // Program: c:\test\mytest\foo.exe // File: c:\test\mytest\bar.c // Line: 69 // // Expression: // // For information on how your program can cause an assertion // failure, see the Visual C++ documentation on asserts // // (Press Retry to debug the application - JIT must be enabled) // // =================================================================== _GENERATE_TCHAR_STRING_FUNCTIONS(banner_text, "Microsoft Visual C++ Runtime Library") _GENERATE_TCHAR_STRING_FUNCTIONS(box_intro, "Assertion failed!") _GENERATE_TCHAR_STRING_FUNCTIONS(program_intro, "Program: ") _GENERATE_TCHAR_STRING_FUNCTIONS(file_intro, "File: ") _GENERATE_TCHAR_STRING_FUNCTIONS(line_intro, "Line: ") _GENERATE_TCHAR_STRING_FUNCTIONS(expression_intro, "Expression: ") _GENERATE_TCHAR_STRING_FUNCTIONS(info_intro, "For information on how your program can cause an assertion\nfailure, see the Visual C++ documentation on asserts") _GENERATE_TCHAR_STRING_FUNCTIONS(help_intro, "(Press Retry to debug the application - JIT must be enabled)") _GENERATE_TCHAR_STRING_FUNCTIONS(dot_dot_dot, "...") _GENERATE_TCHAR_STRING_FUNCTIONS(newline, "\n") _GENERATE_TCHAR_STRING_FUNCTIONS(double_newline, "\n\n") _GENERATE_TCHAR_STRING_FUNCTIONS(program_name_unknown_text, "") /*** *_assert() - Display a message and abort * *Purpose: * The assert macro calls this routine if the assert expression is * true. By placing the assert code in a subroutine instead of within * the body of the macro, programs that call assert multiple times will * save space. * *Entry: * *Exit: * *Exceptions: * *******************************************************************************/ static void __cdecl common_assert_to_stderr_direct(char const*, char const*, unsigned) throw() { // No action for narrow strings } static void __cdecl common_assert_to_stderr_direct( wchar_t const* const expression, wchar_t const* const file_name, unsigned const line_number ) throw() { HANDLE const stderr_handle = GetStdHandle(STD_ERROR_HANDLE); #pragma warning(suppress:__WARNING_REDUNDANT_POINTER_TEST) // 28922 if (stderr_handle == INVALID_HANDLE_VALUE || stderr_handle == nullptr) { return; } if (GetFileType(stderr_handle) != FILE_TYPE_CHAR) { return; } wchar_t assert_buffer[ASSERTBUFSZ]; #pragma warning(suppress:__WARNING_BANNED_API_USAGE) // 28719 if (swprintf(assert_buffer, _countof(assert_buffer), get_assert_format(wchar_t()), expression, file_name, line_number) < 0) { return; } DWORD const assert_buffer_length = static_cast(wcslen(assert_buffer)); DWORD characters_written = 0; if (WriteConsoleW(stderr_handle, assert_buffer, assert_buffer_length, &characters_written, nullptr) == 0) { return; } abort(); } template __declspec(noreturn) static void __cdecl common_assert_to_stderr( Character const* const expression, Character const* const file_name, unsigned const line_number ) throw() { using traits = __crt_char_traits; // Try to write directly to the console. This is only supported for wide // character strings. If we have a narrow character string or the write // fails, we fall back to call through stdio. common_assert_to_stderr_direct(expression, file_name, line_number); // If stderr does not yet have a buffer, set it to use single character // buffering to avoid dynamic allocation of a stream buffer: if (!__crt_stdio_stream(stderr).has_any_buffer()) { setvbuf(stderr, nullptr, _IONBF, 0); } traits::ftprintf(stderr, get_assert_format(Character()), expression, file_name, line_number); fflush(stderr); abort(); } template static void __cdecl common_assert_to_message_box_build_string( Character* const assert_buffer, size_t const assert_buffer_count, Character const* const expression, Character const* const file_name, unsigned const line_number, void* const return_address ) throw() { using traits = __crt_char_traits; // Line 1: Box introduction line: _ERRCHECK(traits::tcscpy_s(assert_buffer, assert_buffer_count, get_box_intro(Character()))); _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character()))); // Line 2: Program line: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_program_intro(Character()))); Character program_name[_MAX_PATH + 1]{}; HMODULE asserting_module = nullptr; if (!GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, static_cast(return_address), &asserting_module)) { asserting_module = nullptr; } #ifdef CRTDLL // If the assert came from within the CRT DLL, report it as having come // from the EXE instead: if (asserting_module == reinterpret_cast(&__ImageBase)) { asserting_module = nullptr; } #endif if (!traits::get_module_file_name(asserting_module, program_name, static_cast(_countof(program_name)))) { _ERRCHECK(traits::tcscpy_s(program_name, _countof(program_name), get_program_name_unknown_text(Character()))); } Character* pchProg = program_name; if (program_intro_count + traits::tcslen(program_name) + newline_length > MAXLINELEN) { pchProg += (program_intro_count + traits::tcslen(program_name) + newline_length) - MAXLINELEN; // Only replace first (sizeof(Character) * dot_dot_dot_length) bytes to ellipsis: _ERRCHECK(memcpy_s( pchProg, sizeof(Character) * ((MAX_PATH + 1) - (pchProg - program_name)), get_dot_dot_dot(Character()), sizeof(Character) * dot_dot_dot_length )); } _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, pchProg)); _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_newline(Character()))); // Line 3: File line _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_file_intro(Character()))); if (file_intro_count + traits::tcslen(file_name) + newline_length > MAXLINELEN) { size_t const ffn = MAXLINELEN - file_intro_count - newline_length; size_t p = 0; size_t len = 0; Character const* pch = file_name; for (len = traits::tcslen(file_name), p = 1; pch[len - p] != '\\' && pch[len - p] != '/' && p < len; p++) { } // Trim the path and file name so that they fit, using up to 2/3 of // the maximum number of characters for the path and the remaining // 1/3 for the file name: if ((ffn - ffn / 3) < (len - p) && ffn / 3 > p) { // The path is too long. Use the first part of the path and the // full file name: _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - dot_dot_dot_length - p)); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character()))); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - p)); } else if (ffn - ffn / 3 > len - p) { // The file name is too long. Use the full path and the first // and last part of the file name, with a ... in between: p = p / 2; _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - dot_dot_dot_length - p)); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character()))); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - p)); } else { // Both are too long. Use the first part of the path and the // first and last part of the file name, with ...s in between: _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch, ffn - ffn / 3 - dot_dot_dot_length)); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character()))); _ERRCHECK(traits::tcsncat_s(assert_buffer, assert_buffer_count, pch + len - p, ffn / 6 - 1)); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, get_dot_dot_dot(Character()))); _ERRCHECK(traits::tcscat_s (assert_buffer, assert_buffer_count, pch + len - (ffn / 3 - ffn / 6 - 2))); } } else { // Plenty of room on the line; just append the full path and file name: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, file_name)); } _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_newline(Character()))); // Line 4: Line Number line: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_line_intro(Character()))); _ERRCHECK(traits::itot_s( line_number, assert_buffer + traits::tcslen(assert_buffer), assert_buffer_count - traits::tcslen(assert_buffer), 10)); _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character()))); // Line 5: Message line: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_expression_intro(Character()))); size_t const characters_used = traits::tcslen(assert_buffer) + 2 * double_newline_length + info_intro_length + help_intro_count; if (characters_used + traits::tcslen(expression) > assert_buffer_count) { size_t const characters_to_write = assert_buffer_count - (characters_used + dot_dot_dot_length); _ERRCHECK(traits::tcsncat_s( assert_buffer, assert_buffer_count, expression, characters_to_write)); _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_dot_dot_dot(Character()))); } else { _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, expression)); } _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character()))); // Info line: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_info_intro(Character()))); _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_double_newline(Character()))); // Help line: _ERRCHECK(traits::tcscat_s(assert_buffer, assert_buffer_count, get_help_intro(Character()))); } template static void __cdecl common_assert_to_message_box( Character const* const expression, Character const* const file_name, unsigned const line_number, void* const return_address ) throw() { using traits = __crt_char_traits; Character assert_buffer[ASSERTBUFSZ]{}; common_assert_to_message_box_build_string( assert_buffer, _countof(assert_buffer), expression, file_name, line_number, return_address); int const action = traits::show_message_box( assert_buffer, get_banner_text(Character()), MB_TASKMODAL | MB_ICONHAND | MB_ABORTRETRYIGNORE | MB_SETFOREGROUND); switch (action) { case IDABORT: // Abort the program: { raise(SIGABRT); // We won't usually get here, but it's possible that a user-registered // abort handler returns, so exit the program immediately. Note that // even though we are "aborting," we do not call abort() because we do // not want to invoke Watson (the user has already had an opportunity // to debug the error and chose not to). _exit(3); } case IDRETRY: // Break into the debugger then return control to caller { __debugbreak(); return; } case IDIGNORE: // Return control to caller { return; } default: // This should not happen; treat as fatal error: { abort(); } } } template static void __cdecl common_assert( Character const* const expression, Character const* const file_name, unsigned const line_number, void* const return_address ) throw() { using traits = __crt_char_traits; int const current_error_mode = _set_error_mode(_REPORT_ERRMODE); if (current_error_mode == _OUT_TO_STDERR) { return common_assert_to_stderr(expression, file_name, line_number); } if (current_error_mode == _OUT_TO_DEFAULT && _query_app_type() == _crt_console_app) { return common_assert_to_stderr(expression, file_name, line_number); } return common_assert_to_message_box(expression, file_name, line_number, return_address); } #endif /* _UCRT_ENCLAVE_BUILD */ extern "C" void __cdecl _assert( char const* const expression, char const* const file_name, unsigned const line_number ) throw() { return common_assert(expression, file_name, line_number, _ReturnAddress()); } extern "C" void __cdecl _wassert( wchar_t const* const expression, wchar_t const* const file_name, unsigned const line_number ) { return common_assert(expression, file_name, line_number, _ReturnAddress()); }