feat: Implement AffineToNeura pass with loop nest analysis and valid signal optimization

include/Conversion/ConversionPasses.h

@@ -18,6 +18,7 @@ std::unique_ptr<mlir::Pass> createLowerArithToNeuraPass();
 std::unique_ptr<mlir::Pass> createLowerLlvmToNeuraPass();
 std::unique_ptr<mlir::Pass> createLowerMemRefToNeuraPass();
 std::unique_ptr<mlir::Pass> createLowerBuiltinToNeuraPass();
+std::unique_ptr<mlir::Pass> createLowerAffineToNeuraPass();
 
 #define GEN_PASS_REGISTRATION
 #include "Conversion/ConversionPasses.h.inc"

include/Conversion/ConversionPasses.td

@@ -32,4 +32,16 @@ def LowerBuiltinToNeura : Pass<"lower-builtin-to-neura", "ModuleOp">{
   let constructor = "mlir::createLowerBuiltinToNeuraPass()";
 }
 
+def LowerAffineToNeura : Pass<"lower-affine-to-neura", "func::FuncOp">{
+  let summary = "Lower Affine perfect nested loops to Neura loop_control operations";
+  let description = [{
+    Converts perfectly nested affine.for loops directly to Neura dialect using 
+    loop_control operations, avoiding the need to flatten to LLVM IR first.
+    This preserves loop structure information for better optimization on 
+    dataflow architectures.
+  }];
+  let constructor = "mlir::createLowerAffineToNeuraPass()";
+  let dependentDialects = ["mlir::neura::NeuraDialect", "mlir::affine::AffineDialect"];
+}
+
 #endif // CONVERSION_PASSES_TD

include/NeuraDialect/Architecture/Architecture.h

@@ -57,7 +57,9 @@ enum OperationKind {
   // Loop control operations.
   ILoopControl = 34,
   // Constant operations.
-  IConstant = 35
+  IConstant = 35,
+  // Steering control fused operations.
+  ICarryInvariant = 36, IConditionalSelect = 37, IInvariantGroup = 38
 };
 
 //===----------------------------------------------------------------------===//

include/NeuraDialect/NeuraOps.td

@@ -575,4 +575,133 @@ def Neura_InvariantOp : Op<NeuraDialect, "invariant">{
   let arguments = (ins AnyType:$initial, AnyType:$condition);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$initial `,` $condition attr-dict `:` type($initial) `,` type($condition) `->` type($result)";
+}
+
+// ============================================================================
+// FUSED OPERATIONS FOR RECMII OPTIMIZATION
+// ============================================================================
+
+// Defines the carry_invariant fused operation.
+def Neura_CarryInvariantOp : Op<NeuraDialect, "carry_invariant">{
+  let summary = "Fused carry and invariant operation for nested loops.";
+  let description = [{
+    Combines carry and invariant operations into a single operation to reduce RecMII.
+    This is optimized for nested loop patterns where an inner loop's carry result
+    is used as an invariant in the outer loop.
+
+    Semantics:
+    - If inner_condition is false (first inner iteration): return initial value
+    - Else if outer_condition is false (outer loop active, inner loop invariant): 
+        return initial value from inner carry
+    - Else: return carried value
+
+    Replaces the pattern:
+      %carry_result = neura.carry %init, %inner_cond, %carried
+      %inv_result = neura.invariant %carry_result, %outer_cond
+
+    With:
+      %result = neura.carry_invariant %init, %inner_cond, %outer_cond, %carried
+
+    RecMII Impact: Reduces 2 operations to 1 operation (-50% on critical path)
+
+    Example:
+      %out = neura.carry_invariant %init, %inner_cond, %outer_cond, %carried 
+             : i64, i1, i1, i64 -> i64
+  }];
+
+  let arguments = (ins 
+    AnyType:$initial,
+    AnyType:$inner_condition,
+    AnyType:$outer_condition,
+    AnyType:$carried
+  );
+  let results = (outs AnyType:$result);
+
+  let assemblyFormat = [{
+    $initial `,` $inner_condition `,` $outer_condition `,` $carried attr-dict 
+    `:` type($initial) `,` type($inner_condition) `,` type($outer_condition) `,` 
+    type($carried) `->` type($result)
+  }];
+}
+
+// Defines the conditional_select fused operation.
+def Neura_ConditionalSelectOp : Op<NeuraDialect, "cond_select">{
+  let summary = "Fused comparison and conditional selection operation.";
+  let description = [{
+    Combines comparison (icmp) and conditional selection (false_steer) into a 
+    single atomic operation to reduce RecMII.
+
+    Semantics:
+    - Performs comparison: result = (lhs <predicate> rhs)
+    - If result is false: return value
+    - If result is true: return default value (typically from hardware)
+
+    Replaces the pattern:
+      %cond = neura.icmp %lhs, %rhs <{cmpType = "slt"}>
+      %result = neura.false_steer %value, %cond
+
+    With:
+      %result = neura.cond_select %lhs, %rhs, %value <{predicate = "slt"}>
+
+    RecMII Impact: Reduces 2 operations to 1 operation (-50% on critical path)
+
+    Supported predicates: "eq", "ne", "slt", "sle", "sgt", "sge", "ult", "ule", "ugt", "uge"
+
+    Example:
+      %out = neura.cond_select %a, %b, %val <{predicate = "slt"}> 
+             : i64, i64, i64 -> i64
+  }];
+
+  let arguments = (ins 
+    AnyType:$lhs,
+    AnyType:$rhs,
+    AnyType:$value,
+    StrAttr:$predicate
+  );
+  let results = (outs AnyType:$result);
+
+  let assemblyFormat = [{
+    $lhs `,` $rhs `,` $value attr-dict `:` type($lhs) `,` type($rhs) `,` 
+    type($value) `->` type($result)
+  }];
+}
+
+// Defines the invariant_group batch operation.
+def Neura_InvariantGroupOp : Op<NeuraDialect, "invariant_group">{
+  let summary = "Batch invariant extraction for multiple values.";
+  let description = [{
+    Extracts multiple invariants with the same condition in a single operation.
+    This is optimized for nested loops where many values need to be marked as
+    invariant with respect to the outer loop.
+
+    Hardware can optimize this by:
+    - Sharing condition checking logic
+    - Parallel invariant extraction
+    - Reduced control overhead
+
+    Replaces multiple individual invariant operations:
+      %inv1 = neura.invariant %val1, %cond
+      %inv2 = neura.invariant %val2, %cond
+      %inv3 = neura.invariant %val3, %cond
+
+    With a single batch operation:
+      %inv1, %inv2, %inv3 = neura.invariant_group %val1, %val2, %val3, %cond
+
+    ResMII Impact: Reduces N operations to 1 operation (improves resource utilization)
+
+    Example:
+      %out1, %out2, %out3 = neura.invariant_group %in1, %in2, %in3, %cond
+             : i64, i64, i64, i1 -> i64, i64, i64
+  }];
+
+  let arguments = (ins 
+    Variadic<AnyType>:$inputs,
+    AnyType:$condition
+  );
+  let results = (outs Variadic<AnyType>:$outputs);
+
+  let assemblyFormat = [{
+    $inputs `,` $condition attr-dict `:` type($inputs) `,` type($condition) 
+    `->` type($outputs)
+  }];
 }

include/NeuraDialect/NeuraPasses.td

@@ -134,4 +134,5 @@ def RemovePredicatedType : Pass<"remove-predicated-type", "ModuleOp"> {
   }];
   let constructor = "neura::createRemovePredicatedTypePass()";
 }
+
 #endif // NEURA_PASSES_TD