I think this is the right behaviour:
Regardless whether the user uses no flag, /EHsc, /EHs or /EHa; and whether the user registers a _set_se_translator() wrapper, your typeid_except (I also prefer `exception_typeid`; `_except` sounds more like except vs. noexcept) should take, what it gets.
Installing by default a new _set_se_translator( trans_func ); wrapper with changed defaults for C structured exceptions would possibly break things and would unnecessarily widen the scope of your paper.
If you or Microsoft see the necessity, they would probably use a new flag, e.g. /EHt for throw exception with RTTI type information by default.
Probably they won't, as currently they do not throw a C++ exception automatically, but offer to register the _set_se_translator(); wrapper. And then the user can choose, which C++ exception is thrown.
-----Ursprüngliche Nachricht-----
Von: Frederick Virchanza Gotham via Std-Proposals <std-proposals@lists.isocpp.org>
Gesendet: Mo 04.03.2024 11:19
Betreff: Re: [std-proposals] std::typeid_except ( Paper Attached )
An: std-proposals@lists.isocpp.org;
CC: Frederick Virchanza Gotham <cauldwell.thomas@gmail.com>;
On Sun, Mar 3, 2024 at 11:07 PM Sebastian Wittmeier wrote:
>
> The question is, whether "Microsoft could do it" and change the default
> for C structured exceptions under C++: Existing programs and libraries
> possibly rely on the current behaviour.
>
> It is a runtime setting per thread and not a setting per translation unit.
> So changing the default for a new C++ standard version would possibly
> lead to incompatibilities, when mixing standard version of TUs or
> incorporating static or dynamic libraries.
>
> The other question is, whether changing the behaviour of C structured
> exceptions is necessary at all for the proposal.
I have Microsoft Visual Studio 2022 installed here on my work laptop.
I compiled the following source file with:
cl /std:c++20 /EHa source_file.cpp
and the executable prints out:
Caught an unknown exception
We have an valid exception_ptr
0xc0000094
Here's the code:
// compile with: /EHa
#include <exception> // exception
#include <iomanip> // hex, setfill, setw
#include <iostream> // cout, endl
void DivideByZero(void) // Throws a SEH exception
{
int x, y = 0;
x = 5 / y;
}
int main(void)
{
using std::cout, std::endl, std::hex, std::setfill, std::setw;
try
{
DivideByZero();
}
catch(std::exception const &e)
{
cout << e.what() << endl;
}
catch(...)
{
cout << "Caught an unknown exception" << endl;
auto const ep = std::current_exception();
if ( false == static_cast<bool>(ep) )
{
cout << "We have an invalid exception_ptr" << endl;
return 0;
}
cout << "We have an valid exception_ptr" << endl;
unsigned const &n = **(unsigned**)&ep;
cout << "0x" << hex << setfill('0') << setw(8u) << n << endl;
}
}
So far, so good. So when you catch an SEH exception, the
'exception_ptr' is valid and you can get the SEH number from it. Now
let me try a more complicated program to also get the 'type_info'. The
following program is able to get the 'type_info' when you throw an
intrinsic such as "throw 58.2L", but it cannot get the 'type_info'
when an SEH exception is thrown. Therefore I think my proposed new
function 'std::typeid_except' would have to return "typeid(void)" when
it an SEH exception is caught inside a "catch(...)".
// compile with: /EHa
#include <exception> // exception
#include <iomanip> // hex, setfill, setw
#include <iostream> // cout, endl
#include <Windows.h> // AddVectoredExceptionHandler
#include <ehdata.h> // ThrowInfo
namespace std {
namespace detail {
thread_local std::type_info const *tl_ti = &typeid(void);
}
std::type_info const ¤t_exception_typeid(void) noexcept
{
return *detail::tl_ti;
}
}
void DivideByZero(void) // Throws a SEH exception
{
int x, y = 0;
x = 5 / y;
}
int main(void)
{
using std::cout, std::endl, std::hex, std::setfill, std::setw;
try
{
DivideByZero();
}
catch(std::exception const &e)
{
cout << e.what() << endl;
}
catch(...)
{
cout << "Caught an unknown exception" << endl;
auto const ep = std::current_exception();
if ( false == static_cast<bool>(ep) )
{
cout << "We have an invalid exception_ptr" << endl;
return 0;
}
cout << "We have an valid exception_ptr" << endl;
unsigned const &n = **(unsigned**)&ep;
cout << "SEH 0x" << hex << setfill('0') << setw(8u) << n << endl;
auto &ti = std::current_exception_typeid();
cout << "Name of type: " << ti.name() << endl;
}
cout << "==========================\n";
try
{
throw 58.2L;
}
catch(std::exception const &e)
{
cout << e.what() << endl;
}
catch(...)
{
cout << "Caught an unknown exception" << endl;
auto const ep = std::current_exception();
if ( false == static_cast<bool>(ep) )
{
cout << "We have an invalid exception_ptr" << endl;
return 0;
}
cout << "We have an valid exception_ptr" << endl;
auto const &ti = std::current_exception_typeid();
cout << "Name of type: " << ti.name() << endl;
}
}
namespace detail {
using std::type_info;
type_info const *VectoredExceptionHandler_Proper(EXCEPTION_POINTERS
const *const arg)
{
using std::uintptr_t;
if ( nullptr == arg ) return nullptr;
EXCEPTION_RECORD const *const pexc = arg->ExceptionRecord;
if ( nullptr == pexc ) return nullptr;
switch ( pexc->ExceptionCode )
{
case 0x40010006 /*EXCEPTION_OUTPUT_DEBUG_STRING*/:
case 0x406D1388 /*EXCEPTION_THREAD_NAME */:
return nullptr;
}
if ( 0x19930520 /* magic number */ != pexc->ExceptionInformation[0] )
return nullptr;
if ( pexc->NumberParameters < 3u ) return nullptr;
uintptr_t const module = (pexc->NumberParameters >= 4u)
? pexc->ExceptionInformation[3u]
: 0u;
ThrowInfo const *const pthri =
static_cast<ThrowInfo const*>(
reinterpret_cast<void const*>(
static_cast<uintptr_t>(pexc->ExceptionInformation[2u])));
if ( nullptr == pthri ) return nullptr;
if ( 0 == pthri->pCatchableTypeArray ) return nullptr;
if ( 0u == (0xFFFFFFFFu & pthri->pCatchableTypeArray) ) return nullptr;
_CatchableTypeArray const *const pcarr =
static_cast<_CatchableTypeArray const *>(
reinterpret_cast<void const*>(
static_cast<uintptr_t>(module + (0xFFFFFFFFu &
pthri->pCatchableTypeArray))));
if ( 0u == ( 0xFFFFFFFFu &
reinterpret_cast<uintptr_t>(pcarr->arrayOfCatchableTypes[0u]) ) )
return nullptr;
CatchableType const *const pct =
static_cast<CatchableType const*>(
reinterpret_cast<void const*>(
static_cast<uintptr_t>(module +
(0xFFFFFFFFu & reinterpret_cast<uintptr_t>(
pcarr->arrayOfCatchableTypes[0u])))));
if ( 0u == (0xFFFFFFFFu & pct->pType) ) return nullptr;
type_info const *const pti =
static_cast<type_info const *>(
reinterpret_cast<void const*>(
static_cast<uintptr_t>(module + (0xFFFFFFFFu & pct->pType))));
return pti;
}
long WINAPI VectoredExceptionHandler(EXCEPTION_POINTERS *const pointers)
{
type_info const *const retval = VectoredExceptionHandler_Proper(pointers);
if ( nullptr == retval ) std::detail::tl_ti = &typeid(void);
else std::detail::tl_ti = retval;
return EXCEPTION_CONTINUE_SEARCH;
}
void *const dummy = ::AddVectoredExceptionHandler(1u, VectoredExceptionHandler);
} // close namespace 'detail'
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals