debug_printf: wgsl-in, wgsl-out, spv-out

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;

src/back/glsl/mod.rs

@@ -2238,6 +2238,9 @@ impl<'a, W: Write> Writer<'a, W> {
                 writeln!(self.out, ");")?;
             }
             Statement::RayQuery { .. } => unreachable!(),
+            Statement::DebugPrintf { .. } => {
+                return Err(Error::Custom("debugPrintf is not implemented".to_string()));
+            }
         }
 
         Ok(())

src/back/hlsl/writer.rs

@@ -2008,6 +2008,9 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                 writeln!(self.out, "{level}}}")?
             }
             Statement::RayQuery { .. } => unreachable!(),
+            Statement::DebugPrint { .. } => {
+                return Err(Error::Unimplemented("debug printf".to_string()));
+            }
         }
 
         Ok(())

src/back/msl/writer.rs

@@ -2994,6 +2994,9 @@ impl<W: Write> Writer<W> {
                         }
                     }
                 }
+                crate::Statement::DebugPrintf { .. } => {
+                    return Err(Error::FeatureNotImplemented("debug printf".to_string()));
+                }
             }
         }
 

src/back/spv/block.rs

@@ -137,7 +137,7 @@ impl Writer {
 
         let clamp_id = self.id_gen.next();
 
-        body.push(Instruction::ext_inst(
+        body.push(Instruction::ext_inst_glsl_std(
             self.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::FClamp,
             float_type_id,
@@ -776,7 +776,7 @@ impl<'w> BlockContext<'w> {
                             arg2_id = self.writer.get_constant_composite(ty, &self.temp_list);
                         }
 
-                        MathOp::Custom(Instruction::ext_inst(
+                        MathOp::Custom(Instruction::ext_inst_glsl_std(
                             self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::FClamp,
                             result_type_id,
@@ -892,7 +892,7 @@ impl<'w> BlockContext<'w> {
                                     &self.temp_list,
                                 ));
 
-                                MathOp::Custom(Instruction::ext_inst(
+                                MathOp::Custom(Instruction::ext_inst_glsl_std(
                                     self.writer.extension_inst_import("GLSL.std.450"),
                                     spirv::GLOp::FMix,
                                     result_type_id,
@@ -949,15 +949,15 @@ impl<'w> BlockContext<'w> {
                         };
 
                         let lsb_id = self.gen_id();
-                        block.body.push(Instruction::ext_inst(
+                        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(
+                        MathOp::Custom(Instruction::ext_inst_glsl_std(
                             self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::UMin,
                             result_type_id,
@@ -1002,7 +1002,7 @@ impl<'w> BlockContext<'w> {
                         };
 
                         let msb_id = self.gen_id();
-                        block.body.push(Instruction::ext_inst(
+                        block.body.push(Instruction::ext_inst_glsl_std(
                             self.writer.extension_inst_import("GLSL.std.450"),
                             spirv::GLOp::FindUMsb,
                             int_type_id,
@@ -1067,7 +1067,7 @@ impl<'w> BlockContext<'w> {
                 };
 
                 block.body.push(match math_op {
-                    MathOp::Ext(op) => Instruction::ext_inst(
+                    MathOp::Ext(op) => Instruction::ext_inst_glsl_std(
                         self.writer.extension_inst_import("GLSL.std.450"),
                         op,
                         result_type_id,
@@ -2349,6 +2349,32 @@ 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,
+                } => {
+                    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,
+                    ));
+                }
             }
         }
 

src/back/spv/image.rs

@@ -453,7 +453,7 @@ 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(
+        block.body.push(Instruction::ext_inst_glsl_std(
             self.writer.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::UMin,
             type_id,
@@ -592,7 +592,7 @@ 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(
+        block.body.push(Instruction::ext_inst_glsl_std(
             self.writer.extension_inst_import("GLSL.std.450"),
             spirv::GLOp::UMin,
             coordinates.type_id,

src/back/spv/index.rs

@@ -199,7 +199,7 @@ 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(
+        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(),

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)
         }

src/back/spv/mod.rs

@@ -610,6 +610,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,

src/back/spv/writer.rs

@@ -63,6 +63,7 @@ impl Writer {
             capabilities_available: options.capabilities.clone(),
             capabilities_used,
             extensions_used: crate::FastIndexSet::default(),
+            strings: vec![],
             debugs: vec![],
             annotations: vec![],
             flags: options.flags,
@@ -119,6 +120,7 @@ impl Writer {
             extensions_used: take(&mut self.extensions_used).recycle(),
             physical_layout: self.physical_layout.clone().recycle(),
             logical_layout: take(&mut self.logical_layout).recycle(),
+            strings: take(&mut self.strings).recycle(),
             debugs: take(&mut self.debugs).recycle(),
             annotations: take(&mut self.annotations).recycle(),
             lookup_type: take(&mut self.lookup_type).recycle(),
@@ -2001,6 +2003,11 @@ impl Writer {
         Instruction::memory_model(addressing_model, memory_model)
             .to_words(&mut self.logical_layout.memory_model);
 
+        // Strings come before other debug instructions
+        for string in self.strings.iter() {
+            string.to_words(&mut self.logical_layout.debugs);
+        }
+
         if self.flags.contains(WriterFlags::DEBUG) {
             for debug in self.debugs.iter() {
                 debug.to_words(&mut self.logical_layout.debugs);

src/back/wgsl/writer.rs

@@ -921,6 +921,20 @@ impl<W: Write> Writer<W> {
                 }
             }
             Statement::RayQuery { .. } => unreachable!(),
+            Statement::DebugPrintf {
+                ref format,
+                ref arguments,
+            } => {
+                write!(self.out, "{level}")?;
+                write!(self.out, "debugPrintf(\"{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(())

src/compact/statements.rs

@@ -95,6 +95,14 @@ impl FunctionTracer<'_> {
                         self.trace_expression(query);
                         self.trace_ray_query_function(fun);
                     }
+                    St::DebugPrintf {
+                        format: _,
+                        ref arguments,
+                    } => {
+                        for expr in arguments {
+                            self.trace_expression(*expr);
+                        }
+                    }
 
                     // Trivial statements.
                     St::Break
@@ -244,6 +252,14 @@ impl FunctionMap {
                         adjust(query);
                         self.adjust_ray_query_function(fun);
                     }
+                    St::DebugPrintf {
+                        format: _,
+                        ref mut arguments,
+                    } => {
+                        for expr in arguments {
+                            adjust(expr);
+                        }
+                    }
 
                     // Trivial statements.
                     St::Break

src/front/spv/mod.rs

@@ -3692,7 +3692,8 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
                 | S::Store { .. }
                 | S::ImageStore { .. }
                 | S::Atomic { .. }
-                | S::RayQuery { .. } => {}
+                | S::RayQuery { .. }
+                | S::DebugPrintf { .. } => {}
                 S::Call {
                     function: ref mut callee,
                     ref arguments,

src/front/wgsl/error.rs

@@ -239,6 +239,8 @@ pub enum Error<'a> {
     ExpectedPositiveArrayLength(Span),
     MissingWorkgroupSize(Span),
     ConstantEvaluatorError(ConstantEvaluatorError, Span),
+    /// String literals are only used with debugPrintf
+    UnexpectedStringLiteral(Span),
 }
 
 impl<'a> Error<'a> {
@@ -253,6 +255,7 @@ impl<'a> Error<'a> {
                             Token::Attribute => "@".to_string(),
                             Token::Number(_) => "number".to_string(),
                             Token::Word(s) => s.to_string(),
+                            Token::String(_) => "string".to_string(),
                             Token::Operation(c) => format!("operation ('{c}')"),
                             Token::LogicalOperation(c) => format!("logical operation ('{c}')"),
                             Token::ShiftOperation(c) => format!("bitshift ('{c}{c}')"),
@@ -700,6 +703,14 @@ impl<'a> Error<'a> {
                 )],
                 notes: vec![],
             },
+            Error::UnexpectedStringLiteral(span) => ParseError {
+                message: "unexpected string literal".to_string(),
+                labels: vec![(
+                    span,
+                    "string literals can only be used as the first argument to debugPrintf".into(),
+                )],
+                notes: vec![],
+            },
         }
     }
 }

src/front/wgsl/lower/mod.rs

@@ -1485,6 +1485,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                         unreachable!("got abstract numeric type when not expected");
                     }
                     ast::Literal::Bool(b) => crate::Literal::Bool(b),
+                    ast::Literal::String(_) => {
+                        return Err(Error::UnexpectedStringLiteral(span));
+                    }
                 };
                 let handle = ctx.interrupt_emitter(crate::Expression::Literal(literal), span)?;
                 return Ok(TypedExpression::non_reference(handle));
@@ -2256,6 +2259,35 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
                             )?;
                             return Ok(Some(handle));
                         }
+                        "debugPrintf" => {
+                            let format = arguments.first().ok_or(Error::WrongArgumentCount {
+                                span,
+                                expected: 1..16,
+                                found: 0,
+                            })?;
+
+                            let format = match ctx.ast_expressions[*format] {
+                                ast::Expression::Literal(ast::Literal::String(format)) => {
+                                    format.to_string()
+                                }
+                                _ => return Err(Error::Other),
+                            };
+
+                            let arguments = arguments
+                                .iter()
+                                .skip(1)
+                                .map(|&arg| self.expression(arg, ctx.reborrow()))
+                                .collect::<Result<Vec<_>, _>>()?;
+                            let rctx = ctx.runtime_expression_ctx(span)?;
+                            rctx.block
+                                .extend(rctx.emitter.finish(rctx.naga_expressions));
+
+                            rctx.emitter.start(rctx.naga_expressions);
+                            rctx.block
+                                .push(crate::Statement::DebugPrintf { format, arguments }, span);
+
+                            return Ok(None);
+                        }
                         _ => return Err(Error::UnknownIdent(function.span, function.name)),
                     }
                 };

src/front/wgsl/parse/ast.rs

@@ -395,17 +395,18 @@ pub enum ConstructorType<'a> {
 }
 
 #[derive(Debug, Copy, Clone)]
-pub enum Literal {
+pub enum Literal<'a> {
     Bool(bool),
     Number(Number),
+    String(&'a str),
 }
 
 #[cfg(doc)]
 use crate::front::wgsl::lower::Lowerer;
 
 #[derive(Debug)]
 pub enum Expression<'a> {
-    Literal(Literal),
+    Literal(Literal<'a>),
     Ident(IdentExpr<'a>),
 
     /// A type constructor expression.