Throw runtime error in GLSL when assertion fails for debugging - runtime-error

Question

In the function distSigned I am assuming that l.p != vec2(0). If this isn't the case, it could break the entire shader with a hard to find bug. Is there is any way of verifying this, and throwing a runtime-error if the parameters are invalid? This would make debugging a lot easier. I know GLSL doesn't have a throw like Java, but maybe theres some kind of hack?
struct parallel {
vec2 p;
vec2 d;
};
struct pt {vec2 v;};
float distSigned(pt p, parallel l) {
vec2 l2o = fromOrigo(l);
float d = length(l2o);
return dot(p.v, l2o/d) - d;
}
Edit: I had a look at the GLSL specification and found this:
"Compile-time errors must be returned for lexically or
grammatically incorrect shaders. Other errors are reported at compile time or link time as
indicated."
I guess this means GLSL doesn't have runtime errors? If so, maybe its possible for me to implement exceptions on my own? Is there some kind of design pattern for this?

Answer 1

Throw a runtime error to whom? When would it be thrown? How many shader invocations would throw, and how would the receiving code receive them?
Shaders get executed whenever the GPU gets around to it, not when you run a draw call. So the time when such errors would be "thrown" could be anywhere from "when you issue the draw call" to, well, arbitrarily far into the future. So how would you receive them, and who would do the receiving?
Plus, you're executing multiple shader invocations; every vertex and every fragment get their own individual invocation. And thus, every vertex and rasterized fragment could potentially "throw" some kind of runtime error. For a scene of size and complexity, that's potentially millions of such errors. How would you handle that?
No, if you want to debug shaders, you either need a specialized tool for that or you need to do the shader equivalent of printf debugging. That is, reduce your scene to the least complexity it can be reduced to, then write output values based on whether some error condition worked out one way or the other.

Answer 2

Error Pixel Implementation, Webgl2:
//:ES2_AA2_MAC_DEB: My debug macro, true if positive.
//: pix_err: PIXel ERRor ( Stores Hex Error Code )
//: pix_fra: PIXel FRAgment ( fragment color )
#if( ES2_AA2_MAC_DEB > 0 ) //:///////////////////////////://
//:ASSIGN_TO_ZERO_AT_TOP_OF_FUNCTION!!!!!!!!!!!!!!!!!!!!
uint pix_err =( 0x00000000 );
#endif //:///////////////////////////////////////////////://
//: ...Later when you want to error check....
#if( ES2_AA2_MAC_DEB > 0 ) //:///////////////////////////://
if( Ax1-Ax0+uint(1) != ES2_zoo_wid ||
Ay1-Ay0+uint(1) != ES2_zoo_hig ){
//: The first error encountered puts program ://
//: into invalid state, so we want to make sure ://
//: we never override the first error tripped. ://
//: So always guard with comparison to ://
//: 0x00000000 before setting to the error color.://
if( uint(0x00000000) == pix_err ){
pix_err=( uint(0xFF9000FF) );
};;
};;
#endif //:///////////////////////////////////////////////://
... Do more code.......................................
... DONT TRY TO EXIT EARLY if error is tripped ........
... that will just turn your code into spaghetti ......
#if( ES2_AA2_MAC_DEB > 0 ) //://////////////////////////://
if( uint(0x000000) != pix_err ){
#define F_F uint(0xFF)" //://////////////////////://
pix_fra=( vec4( //://///////////////////////////://
float( ( pix_err >> 24 ) & F_F ) / 255.0
,float( ( pix_err >> 16 ) & F_F ) / 255.0
,float( ( pix_err >> 8 ) & F_F ) / 255.0
,float( ( pix_err >> 0 ) & F_F ) / 255.0
));; //://///////////////////////////////////////://
#undef F_F //://////////////////////////////////://
};;
#endif //:///////////////////////////////////////////////://
//: Now in debug mode, you can color sample the pixel ://
//: and type in the hex code to find the exact error. ://
//: Might not be helpful for minor edge cases, but ://
//: should be very helpful for gross mistakes in ://
//: your programming logic. ://
return( pix_fra );

Answer 3

As it says in my edit, GLSL doesn't have runtime errors. It is possible to implement however. For something like try-catch one can do this:
#define assert(array, index, line, condition) if (!(condition)) array[index] = exception(line);
struct exception {int line;};
// In use
float distSigned(pt p, parallel l, out exception[1] errors) {
assert(errors, 0, __LINE__, l.p != vec2(0));
// rest of method ..
}
To log uncaught errors, one can use certain pixel-colors that each correspond to a specific error code, and maybe a pixel palette that hides these. When a fatal error occurs it's color is output.
In debug-mode the program can then look for pixels with these colors.
Problems with this method is that the __LINE__ can be offset if the shader is being included in another and that, in webGL, shader output can't be accessed by the CPU.
Perhaps there are GLSL debugers with this functionality, I haven't tried any.
Thanks to Nicol Bolas and LJᛃ for explaining most of this.