Linking separate .slang files into single program (via Compilation APIs)

[joelongson]

I'm trying to do something that seems like it should be fairly simple. But I think I'm running into some confusion on how to properly use the Slang Compilation APIs. Essentially, I'm just trying to figure out how to get slang to handle "late-code-generation" for a system I'm working on. The crux of the problem is that I somehow need to combine the ShaderIR in Slang from separate input IModule objects prior to the slang target generation.

What I want to be able to do is pre-compile the majority of slang shader code once to into an IModule. I want to then later provide the implementation of certain functions that I have forward declared in that initial module as part of a separate slang IModule. The challenge is, that when I'm compiling the initial module I don't yet know all the forward declared functions that will eventually end up in the 'later' module (or I could just declare them and use an 'import' statement).

Here is my modified code from the example on using the Slang Compilation API documentation:
https://shader-slang.org/slang/user-guide/compiling.html#using-the-compilation-api

const char* shortestShader =
"RWStructuredBuffer<float> result;"
"float computeSomething(uint3 threadId);  // FORWARD DECLARED"
""
"[shader(\"compute\")]"
"[numthreads(1,1,1)]"
"void computeMain(uint3 threadId : SV_DispatchThreadID)"
"{"
"    result[threadId.x] = computeSomething(threadId);"
"}";

const char* laterShader =
"public float computeSomething(uint3 threadId)"
"{"
"    return sin(threadId.x);"
"}";

I'm running each of these through the loadModuleFromSourceString() method, creating separate IModule objects, then I'm trying to compose them into a single Slang Program and link them.

    // 5. Compose Modules + Entry Points
    std::vector<slang::IComponentType*> componentTypes =
        {
            shortestShaderModule,
            entryPoint,
            laterShaderModule
        };

    Slang::ComPtr<slang::IComponentType> composedProgram;
    {
        Slang::ComPtr<slang::IBlob> diagnosticsBlob;
        SlangResult result = session->createCompositeComponentType(
            componentTypes.data(),
            componentTypes.size(),
            composedProgram.writeRef(),
            diagnosticsBlob.writeRef());
        diagnoseIfNeeded(diagnosticsBlob);
        SLANG_RETURN_ON_FAIL(result);
    }

However, when I printout the GLSL code that the Compilation API produces, I'm just getting the forward declaration, but nothing included from the second slang module. (I am using different module names and fictitious paths for the .slang files when I'm compiling each module).

#version 450
layout(column_major) uniform;
layout(column_major) buffer;

#line 1 0
layout(std430, binding = 0) buffer StructuredBuffer_float_t_0 {
    float _data[];
} result_0;

#line 1
float computeSomething_0(uvec3 _0);


#line 1
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main()
{

#line 1
    float _S1 = computeSomething_0(gl_GlobalInvocationID);

#line 1
    result_0._data[uint(gl_GlobalInvocationID.x)] = _S1;

#line 1
    return;
}

Any suggestions? Thanks!

[joelongson]

I think I might have figured it out... You need to use an 'export' decorator to the "later shader module" function definition. Otherwise, slang doesn't seem to know what should be brought in during specialization.

const char* laterShader =
"export float computeSomething(uint3 threadId)"
"{"
"    return sin(threadId.x);"
"}";

Hopefully this helps someone else out that might be trying to do the same thing.

[joelongson]

Except that this generates a different function name mangle in the output (computeSomething_1 vs. computeSomething_0)

#line 1
float computeSomething_1(uvec3 threadId_0)
{

#line 1
    return sin(float(threadId_0.x));
}

[joelongson]

The answer seems to be that you need to put an "export" on both declaration and implementation, and then it seems to generate the expected function declaration and calling syntax. (even if I compiles the shaders in the order where "later.slang" compiles after "shader.slang").

const char* shortestShader =
"RWStructuredBuffer<float> result;"
"export float computeSomething(uint3 threadId);  // FORWARD DECLARATION"
""
"[shader(\"compute\")]"
"[numthreads(1,1,1)]"
"void computeMain(uint3 threadId : SV_DispatchThreadID)"
"{"
"    result[threadId.x] = computeSomething(threadId);"
"}";

const char* laterShader =
"export float computeSomething(uint3 threadId) // IMPLEMENTATION"
"{"
"    return sin(threadId.x);"
"}";

This gives the expected output.

#version 450
layout(column_major) uniform;
layout(column_major) buffer;

#line 1 0
layout(std430, binding = 0) buffer StructuredBuffer_float_t_0 {
    float _data[];
} result_0;

#line 1
float computeSomething_0(uvec3 threadId_0)
{

#line 2
    return sin(float(threadId_0.x));
}


layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
void main()
{

#line 8
    float _S1 = computeSomething_0(gl_GlobalInvocationID);

#line 8
    result_0._data[uint(gl_GlobalInvocationID.x)] = _S1;
    return;
}

[joelongson]

The question still remains.. Is this an expected/supported workflow that we can rely upon? I didn't much of anything in the documentation related to using the 'export' keyword for functions. Just for global variables.