return from catch - UB?

[Noah Roberts]

The following code does VERY strange things in the debugger. Is there
anything wrong with the following code, UB or anything else?

#include <iostream>
#include <exception>
#include <stdexcept>

int main()
{
int * parser;

try
{
parser = 0;
}
catch (std::out_of_ra nge & err)
{
}
catch (std::bad_alloc & err)
{
return 0; // debugger jumps to here after hitting final brace -
"runs" this statement as many times as there are returns in catches.
}
catch (std::domain_er ror & err)
{
return -1;
}
catch (std::exception & err)
{
std::cerr << err.what() << std::endl;
}
catch(...)
{
return -1;
} // debugger jumps to here after running code in try..
return 0; // debugger finally jumps to here and leaves...other code in
this area will run but has been removed for brevity.
}
Granted, it isn't a normal thing to do, but AFAICT the standard
explicitly allows it.

[Alan Johnson]

Noah Roberts wrote:

The following code does VERY strange things in the debugger. Is there
anything wrong with the following code, UB or anything else?

#include <iostream>
#include <exception>
#include <stdexcept>

int main()
{
int * parser;

try
{
parser = 0;
}
catch (std::out_of_ra nge & err)
{
}
catch (std::bad_alloc & err)
{
return 0; // debugger jumps to here after hitting final brace -
"runs" this statement as many times as there are returns in catches.
}
catch (std::domain_er ror & err)
{
return -1;
}
catch (std::exception & err)
{
std::cerr << err.what() << std::endl;
}
catch(...)
{
return -1;
} // debugger jumps to here after running code in try..
return 0; // debugger finally jumps to here and leaves...other code in
this area will run but has been removed for brevity.
}
Granted, it isn't a normal thing to do, but AFAICT the standard
explicitly allows it.

Have you tried turning off all optimizations? This sounds exactly like
the sort of weird behavior you'd expect to see when trying to debug
optimized code.

--
Alan Johnson

[Old Wolf]

Noah Roberts wrote:

catch (std::bad_alloc & err)
{
return 0; // debugger jumps to here after hitting final brace -
"runs" this statement as many times as there are returns in catches.
}

return 0; // debugger finally jumps to here and leaves...other code in
this area will run but has been removed for brevity.
}

Sounds like the second 'return 0' has been optimised to
jump to the earlier return 0, instead of repeating the code.

[Noah Roberts]

Old Wolf wrote:

Noah Roberts wrote:

catch (std::bad_alloc & err)
{
return 0; // debugger jumps to here after hitting final brace -
"runs" this statement as many times as there are returns in catches.
}

return 0; // debugger finally jumps to here and leaves...other code in
this area will run but has been removed for brevity.
}

Sounds like the second 'return 0' has been optimised to
jump to the earlier return 0, instead of repeating the code.

Ok, I am not sure if there are optimizations turned on, I'll check when
I get to work tomarro. However, even if the first return 0 is a -1 it
goes there. Also, when code lies between the last catch brace and the
return statement the debugger jumps to the last brace, then to the
first return in a catch and "runs" it once per return statement in a
catch (return value irrelivant) and then jumps to finish the code after
the try/catch and finally goes to the return at the end of the
function. Interestingly even though it jumps to the first return and
acts like it is stepping for each return in the try/catch, it doesn't
actually return....it loops through it and then acts like it never did
that.

Frankly the behavior makes no sense to me at all...

I will check ops though and see if it goes away. We were discussing
this and I am of the conclusion that so long as it doesn't execute any
extra code in the catch clauses, and it doesn't, and then executes all
code after the catch clauses and returns as if it never did these odd
things...well, then it follows the "as if" clause of the standard...no
matter how off the wall its true behavior seems it actually does do
what it is supposed to. Is it accurate to say it still complies?

[Noah Roberts]

Noah Roberts wrote:

Old Wolf wrote:

Noah Roberts wrote:

catch (std::bad_alloc & err)
{
return 0; // debugger jumps to here after hitting final brace -
"runs" this statement as many times as there are returns in catches.
}

return 0; // debugger finally jumps to here and leaves...other code in
this area will run but has been removed for brevity.
}

Sounds like the second 'return 0' has been optimised to
jump to the earlier return 0, instead of repeating the code.

Ok, I am not sure if there are optimizations turned on, I'll check when
I get to work tomarro.

Yeah, optimizations are totally disabled afaict. Strange stuff.