Add rs_allocate_debug_closure renderer customization point

Add a new free function rs_allocate_debug_closure that is called
instead of rs_allocate_closure specifically when allocating the OSL
debug() closure. This allows renderers to handle debug closure
allocation differently from regular closures -- for example, allocating
from a separate pool, returning nullptr to suppress debug closures in
production, or tracking debug closure usage separately.

The closure name is known at JIT compile time, so both the scalar
(llvm_gen.cpp) and batched (batched_llvm_gen.cpp) codegen paths check
for closure_name == "debug" and emit calls to the new
osl_allocate_debug_closure_component /
osl_allocate_weighted_debug_closure_component functions, which in turn
call rs_allocate_debug_closure instead of rs_allocate_closure.

All default/fallback implementations simply delegate to
rs_allocate_closure, preserving existing behavior.

Signed-off-by: Larry Gritz <lg@larrygritz.com>
Assisted-by: Claude Code / Opus 4.6

Author: lgritz

src/include/OSL/rs_free_function.h

@@ -323,6 +323,16 @@ OSL_RSOP OSL_HOSTDEVICE void*
 rs_allocate_closure(OSL::OpaqueExecContextPtr oec, size_t size,
                     size_t alignment);
 
+/// Allocates memory for a debug closure specifically. This is called instead
+/// of rs_allocate_closure when the closure being allocated is the OSL
+/// `debug()` closure. Renderers can override this to handle debug closures
+/// differently (e.g., allocate from a separate pool, or return nullptr to
+/// suppress debug closures in production builds). The default fallback
+/// implementation simply delegates to rs_allocate_closure.
+OSL_RSOP OSL_HOSTDEVICE void*
+rs_allocate_debug_closure(OSL::OpaqueExecContextPtr oec, size_t size,
+                          size_t alignment);
+
 /// Report errors, warnings, printf, and fprintf.
 /// Fmtlib style format specifier is used (vs. printf style)
 /// Arguments are represented as EncodedTypes (encodedtypes.h) and

src/liboslexec/batched_llvm_gen.cpp

@@ -7347,8 +7347,13 @@ LLVMGEN(llvm_gen_closure)
     llvm::Value* sg_ptr     = rop.sg_void_ptr();
     llvm::Value* id_int     = rop.ll.constant(clentry->id);
     llvm::Value* size_int   = rop.ll.constant(clentry->struct_size);
-    FuncSpec func_spec(weighted ? "allocate_weighted_closure_component"
-                                : "allocate_closure_component");
+    bool is_debug = (closure_name == "debug");
+    FuncSpec func_spec(weighted
+                           ? (is_debug
+                                  ? "allocate_weighted_debug_closure_component"
+                                  : "allocate_weighted_closure_component")
+                           : (is_debug ? "allocate_debug_closure_component"
+                                       : "allocate_closure_component"));
     func_spec.mask();
 
     // make sure that any temps created to widen uniform values

src/liboslexec/builtindecl.h

@@ -114,6 +114,8 @@ DECL(osl_mul_closure_float, "XXXf")
 DECL(osl_mul_closure_color, "XXXX")
 DECL(osl_allocate_closure_component, "XXii")
 DECL(osl_allocate_weighted_closure_component, "XXiiX")
+DECL(osl_allocate_debug_closure_component, "XXii")
+DECL(osl_allocate_weighted_debug_closure_component, "XXiiX")
 DECL(osl_closure_to_string, "sXX")
 DECL(osl_closure_to_ustringhash, "hXX")
 

src/liboslexec/builtindecl_wide_xmacro.h

@@ -170,6 +170,8 @@
 
 DECL(__OSL_MASKED_OP(allocate_closure_component), "xXXiii")
 DECL(__OSL_MASKED_OP(allocate_weighted_closure_component), "xXXiiXi")
+DECL(__OSL_MASKED_OP(allocate_debug_closure_component), "xXXiii")
+DECL(__OSL_MASKED_OP(allocate_weighted_debug_closure_component), "xXXiiXi")
 DECL(__OSL_MASKED_OP(add_closure_closure), "xXXXXi")
 DECL(__OSL_MASKED_OP(mul_closure_float), "xXXXXi")
 DECL(__OSL_MASKED_OP(mul_closure_color), "xXXXXi")

src/liboslexec/llvm_gen.cpp

@@ -3854,13 +3854,18 @@ LLVMGEN(llvm_gen_closure)
     llvm::Value* sg_ptr     = rop.sg_void_ptr();
     llvm::Value* id_int     = rop.ll.constant(clentry->id);
     llvm::Value* size_int   = rop.ll.constant(clentry->struct_size);
+    bool is_debug = (closure_name == "debug");
     llvm::Value* return_ptr
         = weighted
-              ? rop.ll.call_function("osl_allocate_weighted_closure_component",
+              ? rop.ll.call_function(is_debug
+                                         ? "osl_allocate_weighted_debug_closure_component"
+                                         : "osl_allocate_weighted_closure_component",
                                      sg_ptr, id_int, size_int,
                                      rop.llvm_void_ptr(*weight))
-              : rop.ll.call_function("osl_allocate_closure_component", sg_ptr,
-                                     id_int, size_int);
+              : rop.ll.call_function(is_debug
+                                         ? "osl_allocate_debug_closure_component"
+                                         : "osl_allocate_closure_component",
+                                     sg_ptr, id_int, size_int);
     llvm::Value* comp_void_ptr = return_ptr;
 
     // We need a surrounding "if" so that it's safe for closure allocation to

src/liboslexec/opclosure.cpp

@@ -115,6 +115,41 @@ osl_allocate_weighted_closure_component(OpaqueExecContextPtr oec, int id,
     return comp;
 }
 
+OSL_SHADEOP OSL_HOSTDEVICE void*
+osl_allocate_debug_closure_component(OpaqueExecContextPtr oec, int id, int size)
+{
+    const size_t needed = sizeof(ClosureComponent) + size;
+    ClosureComponent* comp
+        = (ClosureComponent*)rs_allocate_debug_closure(oec, needed,
+                                                       alignof(ClosureComponent));
+    if (comp) {
+        comp->id = id;
+        comp->w  = Color3(1.0f);
+    }
+    return comp;
+}
+
+
+
+OSL_SHADEOP OSL_HOSTDEVICE void*
+osl_allocate_weighted_debug_closure_component(OpaqueExecContextPtr oec, int id,
+                                              int size, const void* w_)
+{
+    const Color3* w = (const Color3*)w_;
+    if (w->x == 0.0f && w->y == 0.0f && w->z == 0.0f)
+        return NULL;
+    const size_t needed = sizeof(ClosureComponent) + size;
+    ClosureComponent* comp
+        = (ClosureComponent*)rs_allocate_debug_closure(oec, needed,
+                                                       alignof(ClosureComponent));
+    if (comp) {
+        comp->id = id;
+        comp->w  = *w;
+    }
+    return comp;
+}
+
+
 // Deprecated, remove when conversion from ustring to ustringhash is finished
 OSL_SHADEOP const char*
 osl_closure_to_string(OpaqueExecContextPtr oec, const void* c_)

src/liboslexec/rs_fallback.cpp

@@ -329,6 +329,13 @@ rs_allocate_closure(OSL::OpaqueExecContextPtr exec_ctx, size_t size,
 #endif
 }
 
+OSL_RSOP OSL_HOSTDEVICE void*
+rs_allocate_debug_closure(OSL::OpaqueExecContextPtr exec_ctx, size_t size,
+                          size_t alignment)
+{
+    return rs_allocate_closure(exec_ctx, size, alignment);
+}
+
 OSL_RSOP OSL_HOSTDEVICE void
 rs_errorfmt(OSL::OpaqueExecContextPtr exec_ctx,
             OSL::ustringhash fmt_specification, int32_t count,

src/liboslexec/wide/wide_opclosure.cpp

@@ -200,6 +200,40 @@ __OSL_MASKED_OP(allocate_weighted_closure_component)(void* bsg_,
     init_closure_component(wComp, id, size, wWeight, comp_mem);
 }
 
+OSL_BATCHOP void
+__OSL_MASKED_OP(allocate_debug_closure_component)(void* bsg_, void* wide_out_,
+                                                  int id, int size,
+                                                  unsigned int mask_value)
+{
+    auto* bsg = reinterpret_cast<BatchedShaderGlobals*>(bsg_);
+
+    Masked<ClosureComponentPtr> wComp(wide_out_, Mask(mask_value));
+    Block<Color3> one_block;
+    assign_all(one_block, Color3(1.0f));
+    Wide<const Color3> wWeight(&one_block);
+    ClosureComponent* comp_mem
+        = bsg->uniform.context->batched<__OSL_WIDTH>().closure_component_allot(
+            size);
+    init_closure_component(wComp, id, size, wWeight, comp_mem);
+}
+
+
+
+OSL_BATCHOP void
+__OSL_MASKED_OP(allocate_weighted_debug_closure_component)(
+    void* bsg_, void* wide_out_, int id, int size, void* wide_weight_,
+    unsigned int mask_value)
+{
+    // TODO return nullptr if all are 0 or masked?
+    auto* bsg = reinterpret_cast<BatchedShaderGlobals*>(bsg_);
+    Masked<ClosureComponentPtr> wComp(wide_out_, Mask(mask_value));
+    Wide<const Color3> wWeight(wide_weight_);
+    ClosureComponent* comp_mem
+        = bsg->uniform.context->batched<__OSL_WIDTH>().closure_component_allot(
+            size);
+    init_closure_component(wComp, id, size, wWeight, comp_mem);
+}
+
 // This currently duplicates the scalar version of the op, but
 // accesses the context through BatchedShaderGlobals instead of ShaderGlobals
 // future work would extend this to operate on a whole batch of closures at once

src/testshade/rs_simplerend.cpp

@@ -391,6 +391,13 @@ rs_allocate_closure(OSL::OpaqueExecContextPtr ec, size_t size, size_t alignment)
     return rs->closure_pool->allocate(size, alignment);
 }
 
+OSL_RSOP OSL_HOSTDEVICE void*
+rs_allocate_debug_closure(OSL::OpaqueExecContextPtr ec, size_t size,
+                          size_t alignment)
+{
+    return rs_allocate_closure(ec, size, alignment);
+}
+
 OSL_RSOP OSL_HOSTDEVICE bool
 rs_get_attribute_constant_string(OSL::ustringhash value, void* result)
 {