Skip to content

Commit 4213bca

Browse files
DominikAdamskiDominikAdamski
authored
[flang][OpenMP] Add alias analysis for omp private (#115155)
Enable alias analysis for omp private clause for code: ``` program main integer :: arrayA(10,10) integer :: tmp(2) integer :: i,j !$omp target teams distribute parallel do private(tmp) do j = 1, 10 do i = 1,10 tmp = [i,j] arrayA = tmp(1) end do end do end program main ``` This PR is based on: #113566 and it contains fix for Fujitsu test suite. Previous PR introduced regression in Fujitsu test suite. For some Fujitsu test cases `omp.yield` operation points to block argument. Alias analysis for such MLIR code will be added in separate PR.
1 parent 7665d3f commit 4213bca

File tree

3 files changed

+281
-14
lines changed

3 files changed

+281
-14
lines changed

‎flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

Lines changed: 58 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -380,6 +380,33 @@ getAttrsFromVariable(fir::FortranVariableOpInterface var) {
380380
return attrs;
381381
}
382382

383+
template <typename OMPTypeOp, typename DeclTypeOp>
384+
static Value getPrivateArg(omp::BlockArgOpenMPOpInterface &argIface,
385+
OMPTypeOp &op, DeclTypeOp &declOp) {
386+
Value privateArg;
387+
if (!op.getPrivateSyms().has_value())
388+
return privateArg;
389+
for (auto [opSym, blockArg] :
390+
llvm::zip_equal(*op.getPrivateSyms(), argIface.getPrivateBlockArgs())) {
391+
if (blockArg == declOp.getMemref()) {
392+
omp::PrivateClauseOp privateOp =
393+
SymbolTable::lookupNearestSymbolFrom<omp::PrivateClauseOp>(
394+
op, cast<SymbolRefAttr>(opSym));
395+
privateOp.walk([&](omp::YieldOp yieldOp) {
396+
// TODO Extend alias analysis if omp.yield points to
397+
// block argument value
398+
if (!yieldOp.getResults()[0].getDefiningOp())
399+
return;
400+
llvm::TypeSwitch<Operation *>(yieldOp.getResults()[0].getDefiningOp())
401+
.template Case<fir::DeclareOp, hlfir::DeclareOp>(
402+
[&](auto declOp) { privateArg = declOp.getMemref(); });
403+
});
404+
return privateArg;
405+
}
406+
}
407+
return privateArg;
408+
}
409+
383410
AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
384411
bool getInstantiationPoint) {
385412
auto *defOp = v.getDefiningOp();
@@ -478,20 +505,37 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
478505
breakFromLoop = true;
479506
})
480507
.Case<hlfir::DeclareOp, fir::DeclareOp>([&](auto op) {
481-
// If declare operation is inside omp target region,
482-
// continue alias analysis outside the target region
483-
if (auto targetOp =
484-
llvm::dyn_cast<omp::TargetOp>(op->getParentOp())) {
485-
auto argIface = cast<omp::BlockArgOpenMPOpInterface>(*targetOp);
486-
for (auto [opArg, blockArg] : llvm::zip_equal(
487-
targetOp.getMapVars(), argIface.getMapBlockArgs())) {
488-
if (blockArg == op.getMemref()) {
489-
omp::MapInfoOp mapInfo =
490-
llvm::cast<omp::MapInfoOp>(opArg.getDefiningOp());
491-
v = mapInfo.getVarPtr();
492-
defOp = v.getDefiningOp();
493-
return;
494-
}
508+
if (omp::BlockArgOpenMPOpInterface argIface =
509+
dyn_cast<omp::BlockArgOpenMPOpInterface>(op->getParentOp())) {
510+
Value ompValArg;
511+
llvm::TypeSwitch<Operation *>(op->getParentOp())
512+
.template Case<omp::TargetOp>([&](auto targetOp) {
513+
// If declare operation is inside omp target region,
514+
// continue alias analysis outside the target region
515+
for (auto [opArg, blockArg] : llvm::zip_equal(
516+
targetOp.getMapVars(), argIface.getMapBlockArgs())) {
517+
if (blockArg == op.getMemref()) {
518+
omp::MapInfoOp mapInfo =
519+
llvm::cast<omp::MapInfoOp>(opArg.getDefiningOp());
520+
ompValArg = mapInfo.getVarPtr();
521+
break;
522+
}
523+
}
524+
// If given operation does not reflect mapping item,
525+
// check private clause
526+
if (!ompValArg)
527+
ompValArg = getPrivateArg(argIface, targetOp, op);
528+
})
529+
.template Case<omp::DistributeOp, omp::ParallelOp,
530+
omp::SectionsOp, omp::SimdOp, omp::SingleOp,
531+
omp::TaskloopOp, omp::TaskOp, omp::WsloopOp>(
532+
[&](auto privateOp) {
533+
ompValArg = getPrivateArg(argIface, privateOp, op);
534+
});
535+
if (ompValArg) {
536+
v = ompValArg;
537+
defOp = ompValArg.getDefiningOp();
538+
return;
495539
}
496540
}
497541
auto varIf = llvm::cast<fir::FortranVariableOpInterface>(defOp);

‎flang/test/Analysis/AliasAnalysis/alias-analysis-omp-teams-distribute-private-ptr.mlir

Lines changed: 102 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,102 @@
1+
// Use --mlir-disable-threading so that the AA queries are serialized
2+
// as well as its diagnostic output.
3+
// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s
4+
5+
// Fortran code:
6+
// program main
7+
// integer, target :: arrayA(10)
8+
// integer, pointer, dimension(:) :: ptrA
9+
// integer :: i
10+
// ptrA => arrayA
11+
// !$omp teams distribute parallel do firstprivate(ptrA)
12+
// do i = 1, 10
13+
// arrayA(i) = arrayA(i) + ptrA(i);
14+
// end do
15+
// end program main
16+
17+
// CHECK-LABEL: Testing : "_QQmain"
18+
// CHECK-DAG: ptrA#0 <-> ArrayA#0: MayAlias
19+
20+
omp.private {type = private} @_QFEi_private_ref_i32 : !fir.ref<i32> alloc {
21+
^bb0(%arg0: !fir.ref<i32>):
22+
%0 = fir.alloca i32 {bindc_name = "i", pinned, uniq_name = "_QFEi"}
23+
%1:2 = hlfir.declare %0 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
24+
omp.yield(%1#0 : !fir.ref<i32>)
25+
}
26+
omp.private {type = firstprivate} @_QFEptra_firstprivate_ref_box_ptr_Uxi32 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>> alloc {
27+
^bb0(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>):
28+
%0 = fir.alloca !fir.box<!fir.ptr<!fir.array<?xi32>>> {bindc_name = "ptra", pinned, uniq_name = "_QFEptra"}
29+
%1:2 = hlfir.declare %0 {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFEptra"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
30+
omp.yield(%1#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
31+
} copy {
32+
^bb0(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>):
33+
%0 = fir.load %arg0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
34+
fir.store %0 to %arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
35+
omp.yield(%arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
36+
}
37+
func.func @_QQmain() attributes {fir.bindc_name = "main"} {
38+
%0 = fir.address_of(@_QFEarraya) : !fir.ref<!fir.array<10xi32>>
39+
%c10 = arith.constant 10 : index
40+
%1 = fir.shape %c10 : (index) -> !fir.shape<1>
41+
%2:2 = hlfir.declare %0(%1) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFEarraya"} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10xi32>>, !fir.ref<!fir.array<10xi32>>)
42+
%3 = fir.address_of(@_QFEarrayb) : !fir.ref<!fir.array<10xi32>>
43+
%c10_0 = arith.constant 10 : index
44+
%4 = fir.shape %c10_0 : (index) -> !fir.shape<1>
45+
%5:2 = hlfir.declare %3(%4) {uniq_name = "_QFEarrayb"} : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10xi32>>, !fir.ref<!fir.array<10xi32>>)
46+
%6 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
47+
%7:2 = hlfir.declare %6 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
48+
%8 = fir.address_of(@_QFEptra) : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
49+
%9:2 = hlfir.declare %8 {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFEptra"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
50+
%10 = fir.shape %c10 : (index) -> !fir.shape<1>
51+
%11 = fir.embox %2#1(%10) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>>
52+
fir.store %11 to %9#1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
53+
omp.teams {
54+
omp.parallel private(@_QFEptra_firstprivate_ref_box_ptr_Uxi32 %9#0 -> %arg0, @_QFEi_private_ref_i32 %7#0 -> %arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.ref<i32>) {
55+
%12:2 = hlfir.declare %arg0 {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFEptra"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) -> (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>)
56+
%13:2 = hlfir.declare %arg1 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
57+
%c1_i32 = arith.constant 1 : i32
58+
%c10_i32 = arith.constant 10 : i32
59+
%c1_i32_1 = arith.constant 1 : i32
60+
omp.distribute {
61+
omp.wsloop {
62+
omp.loop_nest (%arg2) : i32 = (%c1_i32) to (%c10_i32) inclusive step (%c1_i32_1) {
63+
fir.store %arg2 to %13#1 : !fir.ref<i32>
64+
%14 = fir.load %13#0 : !fir.ref<i32>
65+
%15 = fir.convert %14 : (i32) -> i64
66+
%16 = hlfir.designate %2#0 (%15) : (!fir.ref<!fir.array<10xi32>>, i64) -> !fir.ref<i32>
67+
%17 = fir.load %16 : !fir.ref<i32>
68+
%18 = fir.load %12#0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
69+
%19 = fir.load %13#0 : !fir.ref<i32>
70+
%20 = fir.convert %19 : (i32) -> i64
71+
%21 = hlfir.designate %18 (%20) {test.ptr = "ptrA" } : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, i64) -> !fir.ref<i32>
72+
%22 = fir.load %21 : !fir.ref<i32>
73+
%23 = arith.addi %17, %22 : i32
74+
%24 = fir.load %13#0 : !fir.ref<i32>
75+
%25 = fir.convert %24 : (i32) -> i64
76+
%26 = hlfir.designate %2#0 (%25) {test.ptr = "ArrayA"} : (!fir.ref<!fir.array<10xi32>>, i64) -> !fir.ref<i32>
77+
hlfir.assign %23 to %26 : i32, !fir.ref<i32>
78+
omp.yield
79+
}
80+
} {omp.composite}
81+
} {omp.composite}
82+
omp.terminator
83+
} {omp.composite}
84+
omp.terminator
85+
}
86+
return
87+
}
88+
fir.global internal @_QFEarraya target : !fir.array<10xi32> {
89+
%0 = fir.zero_bits !fir.array<10xi32>
90+
fir.has_value %0 : !fir.array<10xi32>
91+
}
92+
fir.global internal @_QFEarrayb : !fir.array<10xi32> {
93+
%0 = fir.zero_bits !fir.array<10xi32>
94+
fir.has_value %0 : !fir.array<10xi32>
95+
}
96+
fir.global internal @_QFEptra : !fir.box<!fir.ptr<!fir.array<?xi32>>> {
97+
%0 = fir.zero_bits !fir.ptr<!fir.array<?xi32>>
98+
%c0 = arith.constant 0 : index
99+
%1 = fir.shape %c0 : (index) -> !fir.shape<1>
100+
%2 = fir.embox %0(%1) : (!fir.ptr<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.ptr<!fir.array<?xi32>>>
101+
fir.has_value %2 : !fir.box<!fir.ptr<!fir.array<?xi32>>>
102+
}

‎flang/test/Analysis/AliasAnalysis/alias-analysis-omp-teams-distribute-private.mlir

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
// Use --mlir-disable-threading so that the AA queries are serialized
2+
// as well as its diagnostic output.
3+
// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s
4+
5+
// Fortran code:
6+
//
7+
// program main
8+
// integer :: arrayA(10,10)
9+
// integer :: tmp(2)
10+
// integer :: i,j
11+
// !$omp teams distribute parallel do private(tmp)
12+
// do j = 1, 10
13+
// do i = 1,10
14+
// tmp = [i,j]
15+
// arrayA = tmp(1)
16+
// end do
17+
// end do
18+
// end program main
19+
20+
// CHECK-LABEL: Testing : "_QQmain"
21+
// CHECK-DAG: tmp_private_array#0 <-> unnamed_array#0: NoAlias
22+
// CHECK-DAG: tmp_private_array#1 <-> unnamed_array#0: NoAlias
23+
24+
omp.private {type = private} @_QFEi_private_ref_i32 : !fir.ref<i32> alloc {
25+
^bb0(%arg0: !fir.ref<i32>):
26+
%0 = fir.alloca i32 {bindc_name = "i", pinned, uniq_name = "_QFEi"}
27+
%1:2 = hlfir.declare %0 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
28+
omp.yield(%1#0 : !fir.ref<i32>)
29+
}
30+
omp.private {type = private} @_QFEj_private_ref_i32 : !fir.ref<i32> alloc {
31+
^bb0(%arg0: !fir.ref<i32>):
32+
%0 = fir.alloca i32 {bindc_name = "j", pinned, uniq_name = "_QFEj"}
33+
%1:2 = hlfir.declare %0 {uniq_name = "_QFEj"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
34+
omp.yield(%1#0 : !fir.ref<i32>)
35+
}
36+
omp.private {type = private} @_QFEtmp_private_ref_2xi32 : !fir.ref<!fir.array<2xi32>> alloc {
37+
^bb0(%arg0: !fir.ref<!fir.array<2xi32>>):
38+
%c2 = arith.constant 2 : index
39+
%0 = fir.alloca !fir.array<2xi32> {bindc_name = "tmp", pinned, uniq_name = "_QFEtmp"}
40+
%1 = fir.shape %c2 : (index) -> !fir.shape<1>
41+
%2:2 = hlfir.declare %0(%1) {uniq_name = "_QFEtmp"} : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<2xi32>>, !fir.ref<!fir.array<2xi32>>)
42+
omp.yield(%2#0 : !fir.ref<!fir.array<2xi32>>)
43+
}
44+
func.func @_QQmain() attributes {fir.bindc_name = "main"} {
45+
%0 = fir.address_of(@_QFEarraya) : !fir.ref<!fir.array<10x10xi32>>
46+
%c10 = arith.constant 10 : index
47+
%c10_0 = arith.constant 10 : index
48+
%1 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>
49+
%2:2 = hlfir.declare %0(%1) {uniq_name = "_QFEarraya"} : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> (!fir.ref<!fir.array<10x10xi32>>, !fir.ref<!fir.array<10x10xi32>>)
50+
%3 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
51+
%4:2 = hlfir.declare %3 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
52+
%5 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFEj"}
53+
%6:2 = hlfir.declare %5 {uniq_name = "_QFEj"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
54+
%c2 = arith.constant 2 : index
55+
%7 = fir.alloca !fir.array<2xi32> {bindc_name = "tmp", uniq_name = "_QFEtmp"}
56+
%8 = fir.shape %c2 : (index) -> !fir.shape<1>
57+
%9:2 = hlfir.declare %7(%8) {uniq_name = "_QFEtmp"} : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<2xi32>>, !fir.ref<!fir.array<2xi32>>)
58+
omp.teams {
59+
omp.parallel private(@_QFEtmp_private_ref_2xi32 %9#0 -> %arg0, @_QFEj_private_ref_i32 %6#0 -> %arg1, @_QFEi_private_ref_i32 %4#0 -> %arg2 : !fir.ref<!fir.array<2xi32>>, !fir.ref<i32>, !fir.ref<i32>) {
60+
%c2_1 = arith.constant 2 : index
61+
%10 = fir.shape %c2_1 : (index) -> !fir.shape<1>
62+
%11:2 = hlfir.declare %arg0(%10) {uniq_name = "_QFEtmp", test.ptr = "tmp_private_array"} : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<2xi32>>, !fir.ref<!fir.array<2xi32>>)
63+
%12:2 = hlfir.declare %arg1 {uniq_name = "_QFEj"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
64+
%13:2 = hlfir.declare %arg2 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
65+
%c1_i32 = arith.constant 1 : i32
66+
%c10_i32 = arith.constant 10 : i32
67+
%c1_i32_2 = arith.constant 1 : i32
68+
omp.distribute {
69+
omp.wsloop {
70+
omp.loop_nest (%arg3) : i32 = (%c1_i32) to (%c10_i32) inclusive step (%c1_i32_2) {
71+
fir.store %arg3 to %12#1 : !fir.ref<i32>
72+
%c1_i32_3 = arith.constant 1 : i32
73+
%14 = fir.convert %c1_i32_3 : (i32) -> index
74+
%c10_i32_4 = arith.constant 10 : i32
75+
%15 = fir.convert %c10_i32_4 : (i32) -> index
76+
%c1 = arith.constant 1 : index
77+
%16 = fir.convert %14 : (index) -> i32
78+
%17:2 = fir.do_loop %arg4 = %14 to %15 step %c1 iter_args(%arg5 = %16) -> (index, i32) {
79+
fir.store %arg5 to %13#1 : !fir.ref<i32>
80+
%c2_5 = arith.constant 2 : index
81+
%c1_6 = arith.constant 1 : index
82+
%c1_7 = arith.constant 1 : index
83+
%18 = fir.allocmem !fir.array<2xi32> {bindc_name = ".tmp.arrayctor", uniq_name = ""}
84+
%19 = fir.shape %c2_5 : (index) -> !fir.shape<1>
85+
%20:2 = hlfir.declare %18(%19) {uniq_name = ".tmp.arrayctor"} : (!fir.heap<!fir.array<2xi32>>, !fir.shape<1>) -> (!fir.heap<!fir.array<2xi32>>, !fir.heap<!fir.array<2xi32>>)
86+
%21 = fir.load %13#0 : !fir.ref<i32>
87+
%22 = arith.addi %c1_6, %c1_7 : index
88+
%23 = hlfir.designate %20#0 (%c1_6) : (!fir.heap<!fir.array<2xi32>>, index) -> !fir.ref<i32>
89+
hlfir.assign %21 to %23 : i32, !fir.ref<i32>
90+
%24 = fir.load %12#0 : !fir.ref<i32>
91+
%25 = hlfir.designate %20#0 (%22) : (!fir.heap<!fir.array<2xi32>>, index) -> !fir.ref<i32>
92+
hlfir.assign %24 to %25 : i32, !fir.ref<i32>
93+
%true = arith.constant true
94+
%26 = hlfir.as_expr %20#0 move %true {test.ptr = "unnamed_array"} : (!fir.heap<!fir.array<2xi32>>, i1) -> !hlfir.expr<2xi32>
95+
hlfir.assign %26 to %11#0 : !hlfir.expr<2xi32>, !fir.ref<!fir.array<2xi32>>
96+
hlfir.destroy %26 : !hlfir.expr<2xi32>
97+
%c1_8 = arith.constant 1 : index
98+
%27 = hlfir.designate %11#0 (%c1_8) : (!fir.ref<!fir.array<2xi32>>, index) -> !fir.ref<i32>
99+
%28 = fir.load %27 : !fir.ref<i32>
100+
hlfir.assign %28 to %2#0 : i32, !fir.ref<!fir.array<10x10xi32>>
101+
%29 = arith.addi %arg4, %c1 : index
102+
%30 = fir.convert %c1 : (index) -> i32
103+
%31 = fir.load %13#1 : !fir.ref<i32>
104+
%32 = arith.addi %31, %30 : i32
105+
fir.result %29, %32 : index, i32
106+
}
107+
fir.store %17#1 to %13#1 : !fir.ref<i32>
108+
omp.yield
109+
}
110+
} {omp.composite}
111+
} {omp.composite}
112+
omp.terminator
113+
} {omp.composite}
114+
omp.terminator
115+
}
116+
return
117+
}
118+
fir.global internal @_QFEarraya : !fir.array<10x10xi32> {
119+
%0 = fir.zero_bits !fir.array<10x10xi32>
120+
fir.has_value %0 : !fir.array<10x10xi32>
121+
}

0 commit comments

Comments
 (0)