Debug printf in shaders

naga/hlsl-snapshots/src/lib.rs

@@ -94,4 +94,5 @@ pub struct ConfigItem {
     /// See also
     /// <https://learn.microsoft.com/en-us/windows/win32/direct3dtools/dx-graphics-tools-fxc-using>.
     pub target_profile: String,
+    pub debug_printf: bool,
 }

naga/src/back/dot/mod.rs

@@ -279,6 +279,12 @@ impl StatementGraph {
                         crate::RayQueryFunction::Terminate => "RayQueryTerminate",
                     }
                 }
+                S::DebugPrintf { ref arguments, .. } => {
+                    for &arg in arguments {
+                        self.dependencies.push((id, arg, "arg"));
+                    }
+                    "DebugPrintf"
+                }
             };
             // Set the last node to the merge node
             last_node = merge_id;

naga/src/back/glsl/features.rs

@@ -48,6 +48,8 @@ bitflags::bitflags! {
         ///
         /// We can always support this, either through the language or a polyfill
         const INSTANCE_INDEX = 1 << 22;
+        /// Debug Printf
+        const DEBUG_PRINTF = 1 << 23;
     }
 }
 
@@ -243,6 +245,10 @@ impl FeaturesManager {
             // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_blend_func_extended.txt
             writeln!(out, "#extension GL_EXT_blend_func_extended : require")?;
         }
+        if self.0.contains(Features::DEBUG_PRINTF) {
+            // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GLSL_EXT_debug_printf.txt
+            writeln!(out, "#extension GL_EXT_debug_printf : enable")?;
+        }
 
         if self.0.contains(Features::INSTANCE_INDEX) {
             if options.writer_flags.contains(WriterFlags::DRAW_PARAMETERS) {
@@ -420,6 +426,22 @@ impl<'a, W> Writer<'a, W> {
             ..
         } = self;
 
+        for block in module
+            .functions
+            .iter()
+            .map(|(_, f)| &f.body)
+            .chain(std::iter::once(&entry_point.function.body))
+        {
+            for statement in block.iter() {
+                match *statement {
+                    crate::Statement::DebugPrintf { .. } => {
+                        features.request(Features::DEBUG_PRINTF)
+                    }
+                    _ => {}
+                }
+            }
+        }
+
         // Loop trough all expressions in both functions and the entry point
         // to check for needed features
         for (expressions, info) in module

naga/src/back/glsl/mod.rs

@@ -252,6 +252,8 @@ bitflags::bitflags! {
         /// The variable gl_PointSize is intended for a shader to write the size of the point to be rasterized. It is measured in pixels.
         /// If gl_PointSize is not written to, its value is undefined in subsequent pipe stages.
         const FORCE_POINT_SIZE = 0x20;
+        /// Emit debug printf statements
+        const EMIT_DEBUG_PRINTF = 0x40;
     }
 }
 
@@ -2379,6 +2381,21 @@ impl<'a, W: Write> Writer<'a, W> {
                 writeln!(self.out, ");")?;
             }
             Statement::RayQuery { .. } => unreachable!(),
+            Statement::DebugPrintf {
+                ref format,
+                ref arguments,
+            } => {
+                if self
+                    .options
+                    .writer_flags
+                    .contains(WriterFlags::EMIT_DEBUG_PRINTF)
+                {
+                    write!(self.out, "{level}")?;
+                    write!(self.out, "debugPrintfEXT(\"{format}\",")?;
+                    self.write_slice(arguments, |this, _, arg| this.write_expr(*arg, ctx))?;
+                    writeln!(self.out, ");")?
+                }
+            }
         }
 
         Ok(())

naga/src/back/hlsl/mod.rs

@@ -175,11 +175,23 @@ pub enum EntryPointError {
     MissingBinding(crate::ResourceBinding),
 }
 
+bitflags::bitflags! {
+    #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+    #[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+    #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Default)]
+    pub struct WriterFlags: u32 {
+        /// Emit debug printf statements
+        const EMIT_DEBUG_PRINTF = 0x1;
+    }
+}
+
 /// Configuration used in the [`Writer`].
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
 #[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
 pub struct Options {
+    /// Configuration flags for the writer.
+    pub flags: WriterFlags,
     /// The hlsl shader model to be used
     pub shader_model: ShaderModel,
     /// Map of resources association to binding locations.
@@ -198,6 +210,7 @@ pub struct Options {
 impl Default for Options {
     fn default() -> Self {
         Options {
+            flags: WriterFlags::empty(),
             shader_model: ShaderModel::V5_1,
             binding_map: BindingMap::default(),
             fake_missing_bindings: true,

naga/src/back/hlsl/writer.rs

@@ -4,7 +4,7 @@ use super::{
     BackendResult, Error, Options,
 };
 use crate::{
-    back,
+    back::{self, hlsl::WriterFlags},
     proc::{self, NameKey},
     valid, Handle, Module, ScalarKind, ShaderStage, TypeInner,
 };
@@ -2000,6 +2000,22 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                 writeln!(self.out, "{level}}}")?
             }
             Statement::RayQuery { .. } => unreachable!(),
+            Statement::DebugPrintf {
+                ref format,
+                ref arguments,
+            } => {
+                if self.options.flags.contains(WriterFlags::EMIT_DEBUG_PRINTF) {
+                    write!(self.out, "{level}")?;
+                    write!(self.out, "printf(\"{format}\",")?;
+                    for (index, argument) in arguments.iter().enumerate() {
+                        if index != 0 {
+                            write!(self.out, ", ")?;
+                        }
+                        self.write_expr(module, *argument, func_ctx)?;
+                    }
+                    writeln!(self.out, ");")?
+                }
+            }
         }
 
         Ok(())

naga/src/back/msl/writer.rs

@@ -3040,6 +3040,9 @@ impl<W: Write> Writer<W> {
                         }
                     }
                 }
+                crate::Statement::DebugPrintf { .. } => {
+                    // metal doesn't provide a debug printf implementation
+                }
             }
         }
 

naga/src/back/spv/block.rs

@@ -133,8 +133,9 @@ impl Writer {
         ));
 
         let clamp_id = self.id_gen.next();
-        body.push(Instruction::ext_inst(
-            self.gl450_ext_inst_id,
+
+        body.push(Instruction::ext_inst_glsl_std(
+            self.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::FClamp,
             float_type_id,
             clamp_id,
@@ -765,8 +766,8 @@ impl<'w> BlockContext<'w> {
                             arg2_id = self.writer.get_constant_composite(ty, &self.temp_list);
                         }
 
-                        MathOp::Custom(Instruction::ext_inst(
-                            self.writer.gl450_ext_inst_id,
+                        MathOp::Custom(Instruction::ext_inst_glsl_std(
+                            self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::FClamp,
                             result_type_id,
                             id,
@@ -884,8 +885,8 @@ impl<'w> BlockContext<'w> {
                                     &self.temp_list,
                                 ));
 
-                                MathOp::Custom(Instruction::ext_inst(
-                                    self.writer.gl450_ext_inst_id,
+                                MathOp::Custom(Instruction::ext_inst_glsl_std(
+                                    self.writer.extension_inst_import("GLSL.std.450"),
                                     spirv::GLOp::FMix,
                                     result_type_id,
                                     id,
@@ -940,16 +941,16 @@ impl<'w> BlockContext<'w> {
                         };
 
                         let lsb_id = self.gen_id();
-                        block.body.push(Instruction::ext_inst(
-                            self.writer.gl450_ext_inst_id,
+                        block.body.push(Instruction::ext_inst_glsl_std(
+                            self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::FindILsb,
                             result_type_id,
                             lsb_id,
                             &[arg0_id],
                         ));
 
-                        MathOp::Custom(Instruction::ext_inst(
-                            self.writer.gl450_ext_inst_id,
+                        MathOp::Custom(Instruction::ext_inst_glsl_std(
+                            self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::UMin,
                             result_type_id,
                             id,
@@ -993,8 +994,8 @@ impl<'w> BlockContext<'w> {
                         };
 
                         let msb_id = self.gen_id();
-                        block.body.push(Instruction::ext_inst(
-                            self.writer.gl450_ext_inst_id,
+                        block.body.push(Instruction::ext_inst_glsl_std(
+                            self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::FindUMsb,
                             int_type_id,
                             msb_id,
@@ -1058,8 +1059,8 @@ impl<'w> BlockContext<'w> {
                 };
 
                 block.body.push(match math_op {
-                    MathOp::Ext(op) => Instruction::ext_inst(
-                        self.writer.gl450_ext_inst_id,
+                    MathOp::Ext(op) => Instruction::ext_inst_glsl_std(
+                        self.writer.extension_inst_import("GLSL.std.450"),
                         op,
                         result_type_id,
                         id,
@@ -2333,6 +2334,34 @@ impl<'w> BlockContext<'w> {
                 crate::Statement::RayQuery { query, ref fun } => {
                     self.write_ray_query_function(query, fun, &mut block);
                 }
+                crate::Statement::DebugPrintf {
+                    ref format,
+                    ref arguments,
+                } => {
+                    if self.writer.flags.contains(WriterFlags::EMIT_DEBUG_PRINTF) {
+                        self.writer.use_extension("SPV_KHR_non_semantic_info");
+                        let format_id = self.gen_id();
+                        self.writer
+                            .strings
+                            .push(Instruction::string(format, format_id));
+                        let id = self.gen_id();
+
+                        self.temp_list.clear();
+                        self.temp_list.push(format_id);
+                        for &argument in arguments {
+                            self.temp_list.push(self.cached[argument]);
+                        }
+
+                        let set_id = self.writer.extension_inst_import("NonSemantic.DebugPrintf");
+                        block.body.push(Instruction::ext_inst(
+                            set_id,
+                            1,
+                            self.writer.void_type,
+                            id,
+                            &self.temp_list,
+                        ));
+                    }
+                }
             }
         }
 

naga/src/back/spv/image.rs

@@ -452,8 +452,8 @@ impl<'w> BlockContext<'w> {
         // and negative values in a single instruction: negative values of
         // `input_id` get treated as very large positive values.
         let restricted_id = self.gen_id();
-        block.body.push(Instruction::ext_inst(
-            self.writer.gl450_ext_inst_id,
+        block.body.push(Instruction::ext_inst_glsl_std(
+            self.writer.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::UMin,
             type_id,
             restricted_id,
@@ -590,8 +590,8 @@ impl<'w> BlockContext<'w> {
         // and negative values in a single instruction: negative values of
         // `coordinates` get treated as very large positive values.
         let restricted_coordinates_id = self.gen_id();
-        block.body.push(Instruction::ext_inst(
-            self.writer.gl450_ext_inst_id,
+        block.body.push(Instruction::ext_inst_glsl_std(
+            self.writer.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::UMin,
             coordinates.type_id,
             restricted_coordinates_id,

naga/src/back/spv/index.rs

@@ -199,8 +199,8 @@ impl<'w> BlockContext<'w> {
         // One or the other of the index or length is dynamic, so emit code for
         // BoundsCheckPolicy::Restrict.
         let restricted_index_id = self.gen_id();
-        block.body.push(Instruction::ext_inst(
-            self.writer.gl450_ext_inst_id,
+        block.body.push(Instruction::ext_inst_glsl_std(
+            self.writer.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::UMin,
             self.writer.get_uint_type_id(),
             restricted_index_id,

naga/src/back/spv/instructions.rs

@@ -121,18 +121,28 @@ impl super::Instruction {
         instruction
     }
 
-    pub(super) fn ext_inst(
+    pub(super) fn ext_inst_glsl_std(
         set_id: Word,
         op: spirv::GLOp,
         result_type_id: Word,
         id: Word,
         operands: &[Word],
+    ) -> Self {
+        Self::ext_inst(set_id, op as Word, result_type_id, id, operands)
+    }
+
+    pub(super) fn ext_inst(
+        set_id: Word,
+        op: Word,
+        result_type_id: Word,
+        id: Word,
+        operands: &[Word],
     ) -> Self {
         let mut instruction = Self::new(Op::ExtInst);
         instruction.set_type(result_type_id);
         instruction.set_result(id);
         instruction.add_operand(set_id);
-        instruction.add_operand(op as u32);
+        instruction.add_operand(op);
         for operand in operands {
             instruction.add_operand(*operand)
         }

naga/src/back/spv/mod.rs

@@ -603,6 +603,7 @@ pub struct Writer {
     /// The set of spirv extensions used.
     extensions_used: crate::FastIndexSet<&'static str>,
 
+    strings: Vec<Instruction>,
     debugs: Vec<Instruction>,
     annotations: Vec<Instruction>,
     flags: WriterFlags,
@@ -623,14 +624,16 @@ pub struct Writer {
     // retain the table here between functions to save heap allocations.
     saved_cached: CachedExpressions,
 
-    gl450_ext_inst_id: Word,
+    ext_inst_ids: crate::FastHashMap<&'static str, Word>,
 
     // Just a temporary list of SPIR-V ids
     temp_list: Vec<Word>,
 }
 
 bitflags::bitflags! {
-    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+    #[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq, Default)]
     pub struct WriterFlags: u32 {
         /// Include debug labels for everything.
         const DEBUG = 0x1;
@@ -645,6 +648,8 @@ bitflags::bitflags! {
         const FORCE_POINT_SIZE = 0x8;
         /// Clamp `BuiltIn::FragDepth` output between 0 and 1.
         const CLAMP_FRAG_DEPTH = 0x10;
+        /// Emit debug printf statements
+        const EMIT_DEBUG_PRINTF = 0x20;
     }
 }