Add debug_printf! and debug_printfln! macros that uses the DebugPrintf extension

crates/spirv-std/macros/src/lib.rs

@@ -350,3 +350,123 @@ fn path_from_ident(ident: Ident) -> syn::Type {
         path: syn::Path::from(ident),
     })
 }
+
+/// Print a formatted string with a newline using the debug printf extension.
+///
+/// Examples:
+///
+/// ```rust,ignore
+/// printfln!("uv: %v2f", uv);
+/// printfln!("pos.x: %f, pos.z: %f, int: %i", pos.x, pos.z, int);
+/// ```
+///
+/// See <https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/master/docs/debug_printf.md#debug-printf-format-string> for formatting rules.
+#[proc_macro]
+pub fn printf(input: TokenStream) -> TokenStream {
+    printf_inner(syn::parse_macro_input!(input as PrintfInput))
+}
+
+/// Similar to `printf` but appends a newline to the format string.
+#[proc_macro]
+pub fn printfln(input: TokenStream) -> TokenStream {
+    let mut input = syn::parse_macro_input!(input as PrintfInput);
+    input.format_string.push_str("\\n");
+    printf_inner(input)
+}
+
+struct PrintfInput {
+    span: proc_macro2::Span,
+    format_string: String,
+    variables: Vec<syn::Expr>,
+}
+
+impl syn::parse::Parse for PrintfInput {
+    fn parse(input: syn::parse::ParseStream<'_>) -> syn::parse::Result<Self> {
+        let span = input.span();
+
+        if input.is_empty() {
+            return Ok(Self {
+                span,
+                format_string: Default::default(),
+                variables: Default::default(),
+            });
+        }
+
+        Ok(Self {
+            span,
+            format_string: input.parse::<syn::LitStr>()?.value(),
+            variables: {
+                let mut variables = Vec::new();
+                while !input.is_empty() {
+                    input.parse::<syn::Token![,]>()?;
+                    variables.push(input.parse()?);
+                }
+                variables
+            },
+        })
+    }
+}
+
+fn printf_inner(input: PrintfInput) -> TokenStream {
+    let PrintfInput {
+        format_string,
+        variables,
+        span,
+    } = input;
+
+    let number_of_arguments =
+        format_string.matches('%').count() - format_string.matches("%%").count() * 2;
+
+    if number_of_arguments != variables.len() {
+        return syn::Error::new(
+            span,
+            &format!(
+                "{} % arguments were found, but {} variables were given",
+                number_of_arguments,
+                variables.len()
+            ),
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let mut variable_idents = String::new();
+    let mut input_registers = Vec::new();
+    let mut op_loads = Vec::new();
+
+    for (i, variable) in variables.into_iter().enumerate() {
+        let ident = quote::format_ident!("_{}", i);
+
+        variable_idents.push_str(&format!("%{} ", ident));
+
+        input_registers.push(quote::quote! {
+            #ident = in(reg) &{#variable},
+        });
+
+        let op_load = format!("%{ident} = OpLoad _ {{{ident}}}", ident = ident);
+
+        op_loads.push(quote::quote! {
+            #op_load,
+        });
+    }
+
+    let input_registers = input_registers
+        .into_iter()
+        .collect::<proc_macro2::TokenStream>();
+    let op_loads = op_loads.into_iter().collect::<proc_macro2::TokenStream>();
+
+    let op_string = format!("%string = OpString \"{}\"", format_string);
+
+    let output = quote::quote! {
+        asm!(
+            "%void = OpTypeVoid",
+            #op_string,
+            "%debug_printf = OpExtInstImport \"NonSemantic.DebugPrintf\"",
+            #op_loads
+            concat!("%result = OpExtInst %void %debug_printf 1 %string ", #variable_idents),
+            #input_registers
+        )
+    };
+
+    output.into()
+}

tests/ui/arch/printf.rs

@@ -0,0 +1,26 @@
+// build-pass
+// compile-flags: -Ctarget-feature=+ext:SPV_KHR_non_semantic_info
+
+use spirv_std::{
+    glam::Vec2,
+    macros::{printf, printfln},
+};
+
+#[spirv(fragment)]
+pub fn main() {
+    unsafe {
+        printf!();
+        printfln!();
+        printfln!("Hello World");
+    }
+
+    let vec = Vec2::new(1.52, 25.1);
+
+    unsafe {
+        printfln!("%v2f", vec);
+        printfln!("%v2f", { vec * 2.0 });
+        printfln!("%v2f", vec * 3.0);
+        printfln!("%% %v2f %%", vec * 4.0);
+        printfln!("%u %i %f 🐉", 11_u32, -11_i32, 11.0_f32);
+    }
+}