Receive "only print when ir has been modified" as a CLI parameter only_when_modified

Signed-off-by: Tomas Fabrizio Orsi <[email protected]>

Author: lima-limon-inc

hir/src/pass.rs

@@ -27,6 +27,7 @@ pub struct Print {
     filter: OpFilter,
     pass_filter: PassFilter,
     target: Option<compact_str::CompactString>,
+    only_when_modified: bool,
 }
 
 /// Filter for the different passes.
@@ -61,6 +62,7 @@ impl Print {
             filter: OpFilter::All,
             pass_filter: PassFilter::All,
             target: None,
+            only_when_modified: false,
         }
     }
 
@@ -72,22 +74,31 @@ impl Print {
             filter: OpFilter::Type { dialect, op },
             pass_filter: PassFilter::All,
             target: None,
+            only_when_modified: false,
         }
     }
 
+    // pub fn from_config(config: IRPrintingConfig) {
+    //     if config.print
+    // }
     /// Adds a PassFilter to Print. IR will only be printed before and after those passes are
     /// executed.
     pub fn with_pass_filter(mut self, passes: Vec<String>) -> Self {
         self.pass_filter = PassFilter::Certain(passes);
         self
     }
 
+    pub fn with_only_print_when_modified(&mut self) {
+        self.only_when_modified = true;
+    }
+
     /// Create a printer that only prints `Symbol` operations containing `name`
     pub fn symbol_matching(name: &'static str) -> Self {
         Self {
             filter: OpFilter::Symbol(Some(name)),
             pass_filter: PassFilter::All,
             target: None,
+            only_when_modified: false,
         }
     }
 
@@ -105,7 +116,7 @@ impl Print {
         match self.filter {
             OpFilter::All => {
                 let target = self.target.as_deref().unwrap_or("printer");
-                log::trace!(target: target, "{op}");
+                log::error!(target: target, "{op}");
             }
             OpFilter::Type {
                 dialect,
@@ -114,21 +125,21 @@ impl Print {
                 let name = op.name();
                 if name.dialect() == dialect && name.name() == op_name {
                     let target = self.target.as_deref().unwrap_or("printer");
-                    log::trace!(target: target, "{op}");
+                    log::error!(target: target, "{op}");
                 }
             }
             OpFilter::Symbol(None) => {
                 if let Some(sym) = op.as_symbol() {
                     let name = sym.name().as_str();
                     let target = self.target.as_deref().unwrap_or(name);
-                    log::trace!(target: target, "{}", sym.as_symbol_operation());
+                    log::error!(target: target, "{}", sym.as_symbol_operation());
                 }
             }
             OpFilter::Symbol(Some(filter)) => {
                 if let Some(sym) = op.as_symbol().filter(|sym| sym.name().as_str().contains(filter))
                 {
                     let target = self.target.as_deref().unwrap_or(filter);
-                    log::trace!(target: target, "{}", sym.as_symbol_operation());
+                    log::error!(target: target, "{}", sym.as_symbol_operation());
                 }
             }
         }
@@ -165,14 +176,35 @@ impl Pass for Print {
 }
 
 impl PassInstrumentation for Print {
-    fn run_after_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef, _changed: bool) {
-        if self.should_print(pass) {
+    fn run_after_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef, changed: bool) {
+        std::println!(
+            "
+------------------------------------DESPUES:\
+             {}-------------------------------------------------------
+",
+            pass.name()
+        );
+        std::println!("RESULTADO DE CHANGED: {}", changed);
+        #[allow(clippy::needless_bool)]
+        // Always print, unless "only_when_modified" has been set and there have not been changes.
+        let print_when_changed = if self.only_when_modified && !changed {
+            false
+        } else {
+            true
+        };
+        if self.should_print(pass) && print_when_changed {
             let op = op.borrow();
             self.print_ir(op);
         }
     }
 
     fn run_before_pass(&mut self, pass: &dyn OperationPass, op: &OperationRef) {
+        std::println!(
+            "
+------------------------------------ANTES:{}-------------------------------------------------------
+",
+            pass.name()
+        );
         if self.should_print(pass) {
             let op = op.borrow();
             self.print_ir(op);

hir/src/pass/manager.rs

@@ -44,14 +44,17 @@ pub struct IRPrintingConfig {
     // NOTE: Taken from the Options struct
     print_ir_after_all: bool,
     print_ir_after_pass: Vec<String>,
+    print_ir_after_modified: bool,
     flags: OpPrintingFlags,
 }
 
 impl From<&Options> for IRPrintingConfig {
     fn from(options: &Options) -> Self {
         let mut irprintconfig = IRPrintingConfig::default();
+
         irprintconfig.print_ir_after_all = options.print_ir_after_all;
         irprintconfig.print_ir_after_pass = options.print_ir_after_pass.clone();
+        irprintconfig.print_ir_after_modified = options.print_ir_after_modified;
 
         irprintconfig
     }
@@ -199,7 +202,12 @@ impl PassManager {
             None
         };
 
-        if let Some(print) = print {
+        //TODO: Refactor this
+        if let Some(mut print) = print {
+            if config.print_ir_after_modified {
+                std::dbg!("ONLY WHEN MODIFIED");
+                print.with_only_print_when_modified();
+            }
             let print = Box::new(print);
             self.add_instrumentation(print);
         }

midenc-compile/src/compiler.rs

@@ -339,6 +339,12 @@ pub struct UnstableOptions {
         )
     )]
     pub print_ir_after_pass: Vec<String>,
+    /// Only print the IR if the pass modified the IR structure.
+    #[cfg_attr(
+        feature = "std",
+        arg(long, default_value_t = false, help_heading = "Passes")
+    )]
+    pub print_ir_after_modified: bool,
 }
 
 impl CodegenOptions {
@@ -505,6 +511,7 @@ impl Compiler {
         options.print_cfg_after_pass = unstable.print_cfg_after_pass;
         options.print_ir_after_all = unstable.print_ir_after_all;
         options.print_ir_after_pass = unstable.print_ir_after_pass;
+        options.print_ir_after_modified = unstable.print_ir_after_modified;
 
         // Establish --target-dir
         let target_dir = if self.target_dir.is_absolute() {

midenc-session/src/options/mod.rs

@@ -52,6 +52,8 @@ pub struct Options {
     pub print_ir_after_all: bool,
     /// Print IR to stdout each time the named passes are applied
     pub print_ir_after_pass: Vec<String>,
+    /// Only print the IR if the pass modified the IR structure.
+    pub print_ir_after_modified: bool,
     /// Save intermediate artifacts in memory during compilation
     pub save_temps: bool,
     /// We store any leftover argument matches in the session options for use
@@ -126,6 +128,7 @@ impl Options {
             print_cfg_after_pass: vec![],
             print_ir_after_all: false,
             print_ir_after_pass: vec![],
+            print_ir_after_modified: false,
             flags: CompileFlags::default(),
         }
     }