Derelict3 SDL2 and OpenGL weird SIGSEGV on DerelictGL.reload()

Question

Trying to get set with SDL and OpenGL on D. Specifically, SDL2 and OpenGL 3.3 core/forward compatible. (although I left the last two out in the example, because it breaks at the same point whether or not they're there). The equivalent to the following in GLFW works fine, so apparently I'm screwing something up on the SDL end, or SDL does some magic things that break Derelict - which seems hard to believe considering that Derelict-gl doesn't do all that much other than loading a few function pointers, but something goes wrong somewhere and I wouldn't exclude a bug in Derelict or SDL, though it's more likely my code.

I don't see it though, and here it is:

import std.stdio;
import std.c.stdlib;
import derelict.sdl2.sdl;
import derelict.opengl3.gl;

void fatal_error_if(Cond,Args...)(Cond cond, string format, Args args) {
    if(!!cond) {
        stderr.writefln(format,args);
        exit(1);
    }
}

void main()
{ 
    //set up D bindings to SDL and OpenGL 1.1
    DerelictGL.load();
    DerelictSDL2.load();
    fatal_error_if(SDL_Init(SDL_INIT_VIDEO),"Failed to initialize sdl!");

    // we want OpenGL 3.3
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION,3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION,3);

    auto window = SDL_CreateWindow(
            "An SDL2 window",
            SDL_WINDOWPOS_UNDEFINED,
            SDL_WINDOWPOS_UNDEFINED,
            800,
            600,
            SDL_WINDOW_OPENGL); // we want this window to support OpenGL
    fatal_error_if(window is null,"Failed to create SDL window!");

    auto glprof = SDL_GL_CreateContext(window); // Create the actual context and make it current
    fatal_error_if(glprof is null,"Failed to create GL context!");

    DerelictGL.reload(); //<-- BOOM SIGSEGV

    // just some stuff so we actually see something if nothing exploded
    glClearColor(1,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT);
    SDL_GL_SwapWindow(window);
    SDL_Delay(5000);
    SDL_DestroyWindow(window);
    SDL_Quit();
    writeln("If we got to this point everything went alright...");
}

Like the question title says, it breaks on DerelictGL.reload() (which is supposed to load OpenGL functions similar to GLEW). Here's the stacktrace...

#0  0x00007ffff71a398d in __strstr_sse2_unaligned () from /usr/lib/libc.so.6
#1  0x000000000048b8d5 in derelict.opengl3.internal.findEXT() (extname=..., extstr=0x0)
    at ../../../../.dub/packages/derelict-gl3-master/source/derelict/opengl3/internal.d:74
#2  0x000000000048b8b0 in derelict.opengl3.internal.isExtSupported() (name=..., glversion=<incomplete type>)
    at ../../../../.dub/packages/derelict-gl3-master/source/derelict/opengl3/internal.d:67
#3  0x0000000000487778 in derelict.opengl3.gl.DerelictGLLoader.reload() (this=0x7ffff7ec5e80)
    at ../../../../.dub/packages/derelict-gl3-master/source/derelict/opengl3/gl.d:48
#4  0x0000000000473bba in D main () at source/app.d:36
#5  0x00000000004980c8 in rt.dmain2._d_run_main() ()
#6  0x0000000000498022 in rt.dmain2._d_run_main() ()
#7  0x0000000000498088 in rt.dmain2._d_run_main() ()
#8  0x0000000000498022 in rt.dmain2._d_run_main() ()
#9  0x0000000000497fa3 in _d_run_main ()
#10 0x00000000004809e5 in main ()

The error here seems to occur because glGetString(GL_EXTENSIONS) returns null. Why I don't quite understand. If I remove the call to DerelictGL.reload the rest of the program runs, but that'd mean that post OpenGL1.1 functions don't get loaded.

To phrase this as an actual question - am I doing something wrong? If so, what?

Additional

I confirmed that an OpenGL 3.3 context was created - glGet returns 3 on GL_MAJOR_VERSION and GL_MINOR_VERSION respectively.

Answer 1

This seems to be a bug in Derelict-gl3 - if I change this line in gl.d

        if( maxVer >= GLVersion.GL12 && isExtSupported( GLVersion.GL12, "GL_ARB_imaging" ) ) {

to

        if( maxVer >= GLVersion.GL12 && isExtSupported( maxVer, "GL_ARB_imaging" ) ) {

it works fine. I'll submit an issue on the github repo, see if this is actually the case (I'm not that familiar with how Derelict works, but this appears fairly obvious to me).