fix: warns

Author: molikto

crates/rustc_codegen_spirv/src/linker/inline.rs

@@ -37,6 +37,12 @@ pub fn inline(sess: &Session, module: &mut Module) -> super::Result<()> {
     let mut dropped_ids = FxHashSet::default();
     module.functions.retain(|f| {
         if should_inline(&disallowed_argument_types, &disallowed_return_types, f) {
+            if has_dont_inline(f) {
+                sess.warn(&format!(
+                    "Function `{}` has `dont_inline` attribute, but need to be inlined because it has illegal argument or return types",
+                    get_name(&get_names(module), f.def_id().unwrap())
+                ));
+            }
             // TODO: We should insert all defined IDs in this function.
             dropped_ids.insert(f.def_id().unwrap());
             false
@@ -202,23 +208,28 @@ fn compute_disallowed_argument_and_return_types(
     (disallowed_argument_types, disallowed_return_types)
 }
 
+fn has_dont_inline(
+    function: &Function,
+) -> bool {
+    let def = function.def.as_ref().unwrap();
+    let control = def.operands[0].unwrap_function_control();
+    control.contains(FunctionControl::DONT_INLINE)
+}
+
+
 fn should_inline(
     disallowed_argument_types: &FxHashSet<Word>,
     disallowed_return_types: &FxHashSet<Word>,
     function: &Function,
 ) -> bool {
     let def = function.def.as_ref().unwrap();
     let control = def.operands[0].unwrap_function_control();
-    let should = control.contains(FunctionControl::INLINE)
+    control.contains(FunctionControl::INLINE)
         || function
             .parameters
             .iter()
             .any(|inst| disallowed_argument_types.contains(inst.result_type.as_ref().unwrap()))
-        || disallowed_return_types.contains(&function.def.as_ref().unwrap().result_type.unwrap());
-    // if should && control.contains(FunctionControl::DONT_INLINE) {
-    //     println!("should not be inlined!");
-    // }
-    should
+        || disallowed_return_types.contains(&function.def.as_ref().unwrap().result_type.unwrap())
 }
 
 // This should be more general, but a very common problem is passing an OpAccessChain to an

crates/rustc_codegen_spirv/src/linker/inline_globals.rs

@@ -80,11 +80,11 @@ enum FunctionArg {
 pub fn inline_global_varaibles(sess: &Session, module: &mut Module) -> super::Result<()> {
     let mut i = 0;
     let mut cont = true;
-    std::fs::write("res0.txt", module.disassemble());
+    //std::fs::write("res0.txt", module.disassemble());
     while cont {
         cont = inline_global_varaibles_rec(sess, module)?;
         i += 1;
-        std::fs::write(format!("res{}.txt", i), module.disassemble());
+        //std::fs::write(format!("res{}.txt", i), module.disassemble());
     }
     Ok(())
 }

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -321,8 +321,6 @@ pub fn link(sess: &Session, mut inputs: Vec<Module>, opts: &Options) -> Result<L
         let _timer = sess.timer("link_sort_globals");
         simple_passes::sort_globals(&mut output);
     }
-    
-    // std::fs::write("res.txt", output.disassemble());
 
     let mut output = if opts.emit_multiple_modules {
         let modules = output