Skip to content

Fix ReturnOp exit predicate logic #220

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
guosran wants to merge 2 commits into from
Closed

Fix ReturnOp exit predicate logic #220

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4ee6738
Fixes ReturnOp exit predicate logic and addresses issue #209
guosran Dec 28, 2025
fb09c7c
Fix ReturnOp exit predicate logic and clean up Neura test outputs (ad…
guosran Dec 28, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
59 changes: 59 additions & 0 deletions lib/NeuraDialect/Transforms/TransformCtrlToDataFlowPass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -602,6 +602,62 @@ void transformControlFlowToDataFlow(Region &region, ControlFlowInfo &ctrl_info,
}
}

// Injects exit predicate for ReturnOp (only for void returns).
// Value-returning functions are not modified.
void injectExitPredicateForReturn(Region &region, ControlFlowInfo &ctrl_info,
OpBuilder &builder) {
Copy link

Copilot AI Dec 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The ctrl_info parameter is declared but never used in the function body. Consider removing this unused parameter to simplify the function signature.

Suggested change
OpBuilder &builder) {
OpBuilder &builder) {
(void)ctrl_info;

Copilot uses AI. Check for mistakes.
Block *entry_block = &region.front();

// Finds the ReturnOp.
neura::ReturnOp return_op = nullptr;
for (Operation &op : *entry_block) {
if (auto rt = dyn_cast<neura::ReturnOp>(op)) {
return_op = rt;
llvm::errs() << "[ctrl2data] ReturnOp found: " << *rt << "\n";
break;
}
}

if (!return_op) {
return; // No ReturnOp to process
}

// Checks if ReturnOp has operands (value return).
// Only injects exit predicate for void returns.
if (return_op.getNumOperands() > 0) {
llvm::errs() << "[ctrl2data] ReturnOp has return value, skipping exit predicate injection.\n";
return; // Skips modification for value-returning functions.
}

// Computes exit predicate: use a constant true predicate for now.
llvm::errs() << "[ctrl2data] Injecting exit predicate for void ReturnOp.\n";

builder.setInsertionPoint(return_op);

// Creates a constant true predicate.
auto i1_type = builder.getI1Type();
auto pred_type = neura::PredicatedValue::get(builder.getContext(), i1_type, i1_type);

Value true_constant = builder.create<neura::ConstantOp>(
return_op.getLoc(),
pred_type,
builder.getIntegerAttr(i1_type, 1));

Value granted_true = builder.create<neura::GrantOnceOp>(
return_op.getLoc(),
pred_type,
true_constant);

// Replaces the old ReturnOp with a new one that includes the exit predicate.
builder.setInsertionPoint(return_op);
Copy link

Copilot AI Dec 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The builder insertion point is set twice consecutively on the same operation. The first setInsertionPoint at line 635 is redundant since it's immediately followed by another setInsertionPoint at line 652 before creating the new return operation.

Suggested change
builder.setInsertionPoint(return_op);

Copilot uses AI. Check for mistakes.
auto new_return = builder.create<neura::ReturnOp>(
return_op.getLoc(),
ValueRange{granted_true});
return_op.erase();

llvm::errs() << "[ctrl2data] Injected exit predicate for ReturnOp.\n";
}

// Converts phi operations with reserve operands to phi_start operations.
void convertPhiToPhiStart(Region &region, OpBuilder &builder) {
llvm::errs() << "[ctrl2data] Converting phi operations to phi_start...\n";
Expand Down Expand Up @@ -697,6 +753,9 @@ struct TransformCtrlToDataFlowPass
buildControlFlowInfo(*region, ctrlInfo, domInfo);
transformControlFlowToDataFlow(*region, ctrlInfo, domInfo, builder);

// Injects exit predicate for void returns.
injectExitPredicateForReturn(*region, ctrlInfo, builder);

// Converts phi operations to phi_start operations.
convertPhiToPhiStart(*region, builder);
});
Expand Down
70 changes: 38 additions & 32 deletions test/affine2neura/bert/bert_node1/bert_node1.mlir
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,38 +31,41 @@ module attributes {} {
}
}

// CHECK: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura"} {
// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index
// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : index}> : () -> index
// CHECK-NEXT: %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %3 : i64 to ^bb1
// CHECK-NEXT: ^bb1(%4: i64): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %5 = "neura.cast"(%4) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %6 = "neura.icmp"(%5, %1) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %6 : i1 then to ^bb2 else to ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %7 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %7 : i64 to ^bb3
// CHECK-NEXT: ^bb3(%8: i64): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %9 = "neura.cast"(%8) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %10 = "neura.icmp"(%9, %1) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %10 : i1 then to ^bb4 else to ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %11 = neura.load_indexed %arg0[%2, %2, %2, %2, %2, %9 : index, index, index, index, index, index] memref<?x1x1x1x1x128xi8> : i8
// CHECK-NEXT: neura.store_indexed %11 to %arg1[%2, %2, %5, %2, %2, %9 : index, index, index, index, index, index] memref<?x1x128x1x1x128xi8> : i8
// CHECK-NEXT: %12 = "neura.add"(%9, %0) : (index, index) -> index
// CHECK-NEXT: %13 = "neura.cast"(%12) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %13 : i64 to ^bb3
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %14 = "neura.add"(%5, %0) : (index, index) -> index
// CHECK-NEXT: %15 = "neura.cast"(%14) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %15 : i64 to ^bb1
// CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: "neura.return"() : () -> ()
// CHECK: module {
// CHECK-NEXT: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura"} {
// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
// CHECK-NEXT: %1 = "neura.constant"() <{value = 128 : index}> : () -> index
// CHECK-NEXT: %2 = "neura.constant"() <{value = 0 : index}> : () -> index
// CHECK-NEXT: %3 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %3 : i64 to ^bb1
// CHECK-NEXT: ^bb1(%4: i64): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %5 = "neura.cast"(%4) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %6 = "neura.icmp"(%5, %1) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %6 : i1 then to ^bb2 else to ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %7 = "neura.cast"(%2) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %7 : i64 to ^bb3
// CHECK-NEXT: ^bb3(%8: i64): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %9 = "neura.cast"(%8) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %10 = "neura.icmp"(%9, %1) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %10 : i1 then to ^bb4 else to ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %11 = neura.load_indexed %arg0[%2, %2, %2, %2, %2, %9 : index, index, index, index, index, index] memref<?x1x1x1x1x128xi8> : i8
// CHECK-NEXT: neura.store_indexed %11 to %arg1[%2, %2, %5, %2, %2, %9 : index, index, index, index, index, index] memref<?x1x128x1x1x128xi8> : i8
// CHECK-NEXT: %12 = "neura.add"(%9, %0) : (index, index) -> index
// CHECK-NEXT: %13 = "neura.cast"(%12) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %13 : i64 to ^bb3
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %14 = "neura.add"(%5, %0) : (index, index) -> index
// CHECK-NEXT: %15 = "neura.cast"(%14) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %15 : i64 to ^bb1
// CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: "neura.return"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }

// CTRL2DATA: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura", dataflow_mode = "predicate"} {
// CTRL2DATA: module {
// CTRL2DATA-NEXT: func.func @_Z10bert_node1PA1_A1_A1_A1_A128_bPA1_A128_S1_(%arg0: memref<?x1x1x1x1x128xi8>, %arg1: memref<?x1x128x1x1x128xi8>) attributes {accelerator = "neura", dataflow_mode = "predicate"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x1x1x1x1x128xi8>, i1>) -> !neura.data<memref<?x1x1x1x1x128xi8>, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
Expand Down Expand Up @@ -138,5 +141,8 @@ module attributes {} {
// CTRL2DATA-NEXT: neura.ctrl_mov %47 -> %33 : !neura.data<memref<?x1x128x1x1x128xi8>, i1> !neura.data<memref<?x1x128x1x1x128xi8>, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %48 -> %31 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %49 -> %29 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"() : () -> ()
// CTRL2DATA-NEXT: }
// CTRL2DATA-NEXT: %61 = "neura.constant"() <{value = true}> : () -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %62 = "neura.grant_once"(%61) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: "neura.return"(%62) : (!neura.data<i1, i1>) -> ()
// CTRL2DATA-NEXT: }
// CTRL2DATA-NEXT: }
101 changes: 54 additions & 47 deletions test/affine2neura/bert/bert_node28/bert_node28.mlir
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,53 +36,57 @@ module attributes {} {
return
}
}
// CHECK: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index
// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index
// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index
// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
// CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %4 : i64 to ^bb1
// CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb8
// CHECK-NEXT: %6 = "neura.cast"(%5) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %7 = "neura.icmp"(%6, %2) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %7 : i1 then to ^bb2 else to ^bb9
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %8 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %8 : i64 to ^bb3
// CHECK-NEXT: ^bb3(%9: i64): // 2 preds: ^bb2, ^bb7
// CHECK-NEXT: %10 = "neura.cast"(%9) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %11 = "neura.icmp"(%10, %0) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %11 : i1 then to ^bb4 else to ^bb8
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %12 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %12 : i64 to ^bb5
// CHECK-NEXT: ^bb5(%13: i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: %14 = "neura.cast"(%13) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %15 = "neura.icmp"(%14, %0) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %15 : i1 then to ^bb6 else to ^bb7
// CHECK-NEXT: ^bb6: // pred: ^bb5
// CHECK-NEXT: %16 = neura.load_indexed %arg0[%3, %6, %14 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %17 = neura.load_indexed %arg1[%3, %14, %10 : index, index, index] memref<?x768x768xf32> : f32
// CHECK-NEXT: %18 = neura.load_indexed %arg2[%3, %6, %10 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %19 = "neura.fmul"(%16, %17) : (f32, f32) -> f32
// CHECK-NEXT: %20 = "neura.fadd"(%18, %19) : (f32, f32) -> f32
// CHECK-NEXT: neura.store_indexed %20 to %arg2[%3, %6, %10 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %21 = "neura.add"(%14, %1) : (index, index) -> index
// CHECK-NEXT: %22 = "neura.cast"(%21) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %22 : i64 to ^bb5
// CHECK-NEXT: ^bb7: // pred: ^bb5
// CHECK-NEXT: %23 = "neura.add"(%10, %1) : (index, index) -> index
// CHECK-NEXT: %24 = "neura.cast"(%23) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %24 : i64 to ^bb3
// CHECK-NEXT: ^bb8: // pred: ^bb3
// CHECK-NEXT: %25 = "neura.add"(%6, %1) : (index, index) -> index
// CHECK-NEXT: %26 = "neura.cast"(%25) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %26 : i64 to ^bb1
// CHECK-NEXT: ^bb9: // pred: ^bb1
// CHECK-NEXT: "neura.return"() : () -> ()
// CHECK: module {
// CHECK-NEXT: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura"} {
// CHECK-NEXT: %0 = "neura.constant"() <{value = 768 : index}> : () -> index
// CHECK-NEXT: %1 = "neura.constant"() <{value = 1 : index}> : () -> index
// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : index}> : () -> index
// CHECK-NEXT: %3 = "neura.constant"() <{value = 0 : index}> : () -> index
// CHECK-NEXT: %4 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %4 : i64 to ^bb1
// CHECK-NEXT: ^bb1(%5: i64): // 2 preds: ^bb0, ^bb8
// CHECK-NEXT: %6 = "neura.cast"(%5) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %7 = "neura.icmp"(%6, %2) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %7 : i1 then to ^bb2 else to ^bb9
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %8 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %8 : i64 to ^bb3
// CHECK-NEXT: ^bb3(%9: i64): // 2 preds: ^bb2, ^bb7
// CHECK-NEXT: %10 = "neura.cast"(%9) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %11 = "neura.icmp"(%10, %0) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %11 : i1 then to ^bb4 else to ^bb8
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: %12 = "neura.cast"(%3) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %12 : i64 to ^bb5
// CHECK-NEXT: ^bb5(%13: i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: %14 = "neura.cast"(%13) <{cast_type = "int_to_index"}> : (i64) -> index
// CHECK-NEXT: %15 = "neura.icmp"(%14, %0) <{cmpType = "slt"}> : (index, index) -> i1
// CHECK-NEXT: neura.cond_br %15 : i1 then to ^bb6 else to ^bb7
// CHECK-NEXT: ^bb6: // pred: ^bb5
// CHECK-NEXT: %16 = neura.load_indexed %arg0[%3, %6, %14 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %17 = neura.load_indexed %arg1[%3, %14, %10 : index, index, index] memref<?x768x768xf32> : f32
// CHECK-NEXT: %18 = neura.load_indexed %arg2[%3, %6, %10 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %19 = "neura.fmul"(%16, %17) : (f32, f32) -> f32
// CHECK-NEXT: %20 = "neura.fadd"(%18, %19) : (f32, f32) -> f32
// CHECK-NEXT: neura.store_indexed %20 to %arg2[%3, %6, %10 : index, index, index] memref<?x128x768xf32> : f32
// CHECK-NEXT: %21 = "neura.add"(%14, %1) : (index, index) -> index
// CHECK-NEXT: %22 = "neura.cast"(%21) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %22 : i64 to ^bb5
// CHECK-NEXT: ^bb7: // pred: ^bb5
// CHECK-NEXT: %23 = "neura.add"(%10, %1) : (index, index) -> index
// CHECK-NEXT: %24 = "neura.cast"(%23) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %24 : i64 to ^bb3
// CHECK-NEXT: ^bb8: // pred: ^bb3
// CHECK-NEXT: %25 = "neura.add"(%6, %1) : (index, index) -> index
// CHECK-NEXT: %26 = "neura.cast"(%25) <{cast_type = "index_to_int"}> : (index) -> i64
// CHECK-NEXT: neura.br %26 : i64 to ^bb1
// CHECK-NEXT: ^bb9: // pred: ^bb1
// CHECK-NEXT: "neura.return"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }

// CTRL2DATA: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura", dataflow_mode = "predicate"} {
// CTRL2DATA: module {
// CTRL2DATA-NEXT: func.func @_Z11bert_node28PA128_A768_KfPA768_S0_PA128_A768_f(%arg0: memref<?x128x768xf32>, %arg1: memref<?x768x768xf32>, %arg2: memref<?x128x768xf32>) attributes {accelerator = "neura", dataflow_mode = "predicate"} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x128x768xf32>, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x128x768xf32>, i1>) -> !neura.data<memref<?x128x768xf32>, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x768x768xf32>, i1>
Expand Down Expand Up @@ -236,5 +240,8 @@ module attributes {} {
// CTRL2DATA-NEXT: neura.ctrl_mov %104 -> %81 : !neura.data<memref<?x128x768xf32>, i1> !neura.data<memref<?x128x768xf32>, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %105 -> %79 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %107 -> %77 : !neura.data<i64, i1> !neura.data<i64, i1>
// CTRL2DATA-NEXT: "neura.return"() : () -> ()
// CTRL2DATA-NEXT: %125 = "neura.constant"() <{value = true}> : () -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %126 = "neura.grant_once"(%125) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: "neura.return"(%126) : (!neura.data<i1, i1>) -> ()
// CTRL2DATA-NEXT: }
// CTRL2DATA-NEXT: }
12 changes: 9 additions & 3 deletions test/controflow_fuse/complex_nested/complex_nested.mlir
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -66,7 +66,8 @@ module attributes {} {
}
}

// CHECK: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
// CHECK: module {
// CHECK-NEXT: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", llvm.linkage = #llvm.linkage<external>} {
// CHECK-NEXT: %0 = "neura.constant"() <{value = 1 : index}> : () -> index
// CHECK-NEXT: %1 = "neura.constant"() <{value = 32 : index}> : () -> index
// CHECK-NEXT: %2 = "neura.constant"() <{value = 128 : i32}> : () -> i32
Expand Down Expand Up @@ -175,8 +176,10 @@ module attributes {} {
// CHECK-NEXT: ^bb23: // pred: ^bb1
// CHECK-NEXT: "neura.return"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }

// CTRL2DATA: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", dataflow_mode = "predicate", llvm.linkage = #llvm.linkage<external>} {
// CTRL2DATA: module {
// CTRL2DATA-NEXT: func.func @_Z14complex_nestedPA32_A32_iPS_(%arg0: memref<?x32x32xi32>, %arg1: memref<?x32xi32>) attributes {accelerator = "neura", dataflow_mode = "predicate", llvm.linkage = #llvm.linkage<external>} {
// CTRL2DATA-NEXT: %0 = "neura.constant"() <{value = "%arg0"}> : () -> !neura.data<memref<?x32x32xi32>, i1>
// CTRL2DATA-NEXT: %1 = "neura.grant_once"(%0) : (!neura.data<memref<?x32x32xi32>, i1>) -> !neura.data<memref<?x32x32xi32>, i1>
// CTRL2DATA-NEXT: %2 = "neura.constant"() <{value = "%arg1"}> : () -> !neura.data<memref<?x32xi32>, i1>
Expand Down Expand Up @@ -668,5 +671,8 @@ module attributes {} {
// CTRL2DATA-NEXT: neura.ctrl_mov %384 -> %354 : !neura.data<i32, i1> !neura.data<i32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %385 -> %352 : !neura.data<i32, i1> !neura.data<i32, i1>
// CTRL2DATA-NEXT: neura.ctrl_mov %386 -> %350 : !neura.data<i32, i1> !neura.data<i32, i1>
// CTRL2DATA-NEXT: "neura.return"() : () -> ()
// CTRL2DATA-NEXT: %404 = "neura.constant"() <{value = true}> : () -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: %405 = "neura.grant_once"(%404) : (!neura.data<i1, i1>) -> !neura.data<i1, i1>
// CTRL2DATA-NEXT: "neura.return"(%405) : (!neura.data<i1, i1>) -> ()
// CTRL2DATA-NEXT: }
// CTRL2DATA-NEXT: }
Loading