Skip to content

Commit e8e718f

Browse files
ftynseftynse
committed
Revert "[mlir] Switch segment size attributes to DenseI32ArrayAttr"
This reverts commit 30171e7. Breaks Python tests in MLIR, missing C API and Python changes.
1 parent e6db064 commit e8e718f

File tree

45 files changed

+272
-244
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

45 files changed

+272
-244
lines changed

‎flang/include/flang/Optimizer/Dialect/FIROps.td‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -417,7 +417,7 @@ def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
417417
let results = (outs AnyType:$intype);
418418

419419
let assemblyFormat = "type($intype) attr-dict";
420-
420+
421421
// Note: we allow `undef : ref<T>` since it is a possible from transformations.
422422
let hasVerifier = 0;
423423
}
@@ -538,9 +538,9 @@ class fir_IntegralSwitchTerminatorOp<string mnemonic,
538538
}
539539
}
540540
$_state.addAttribute(getOperandSegmentSizeAttr(),
541-
$_builder.getDenseI32ArrayAttr({1, 0, sumArgs}));
541+
$_builder.getI32VectorAttr({1, 0, sumArgs}));
542542
$_state.addAttribute(getTargetOffsetAttr(),
543-
$_builder.getDenseI32ArrayAttr(argOffs));
543+
$_builder.getI32VectorAttr(argOffs));
544544
$_state.addAttributes(attributes);
545545
}]
546546
>];

‎flang/lib/Lower/OpenACC.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -113,7 +113,7 @@ createRegionOp(fir::FirOpBuilder &builder, mlir::Location loc,
113113
builder.create<Terminator>(loc);
114114

115115
op->setAttr(Op::getOperandSegmentSizeAttr(),
116-
builder.getDenseI32ArrayAttr(operandSegments));
116+
builder.getI32VectorAttr(operandSegments));
117117

118118
// Place the insertion point to the start of the first block.
119119
builder.setInsertionPointToStart(&block);
@@ -129,7 +129,7 @@ createSimpleOp(fir::FirOpBuilder &builder, mlir::Location loc,
129129
llvm::ArrayRef<mlir::Type> argTy;
130130
Op op = builder.create<Op>(loc, argTy, operands);
131131
op->setAttr(Op::getOperandSegmentSizeAttr(),
132-
builder.getDenseI32ArrayAttr(operandSegments));
132+
builder.getI32VectorAttr(operandSegments));
133133
return op;
134134
}
135135

‎flang/lib/Optimizer/Dialect/FIROps.cpp‎

Lines changed: 55 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -126,9 +126,8 @@ static mlir::ParseResult parseAllocatableOp(FN wrapResultType,
126126
parser.emitError(parser.getNameLoc(), "invalid allocate type: ") << intype;
127127
return mlir::failure();
128128
}
129-
result.addAttribute(
130-
"operand_segment_sizes",
131-
builder.getDenseI32ArrayAttr({typeparamsSize, shapeSize}));
129+
result.addAttribute("operand_segment_sizes",
130+
builder.getI32VectorAttr({typeparamsSize, shapeSize}));
132131
if (parser.parseOptionalAttrDict(result.attributes) ||
133132
parser.addTypeToList(restype, result.types))
134133
return mlir::failure();
@@ -2432,8 +2431,8 @@ static mlir::ParseResult parseIntegralSwitchTerminator(
24322431
sumArgs += argSize;
24332432
}
24342433
result.addAttribute(operandSegmentAttr,
2435-
bld.getDenseI32ArrayAttr({1, 0, sumArgs}));
2436-
result.addAttribute(getTargetOffsetAttr(), bld.getDenseI32ArrayAttr(argOffs));
2434+
bld.getI32VectorAttr({1, 0, sumArgs}));
2435+
result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
24372436
return mlir::success();
24382437
}
24392438

@@ -2481,12 +2480,13 @@ void fir::SelectOp::print(mlir::OpAsmPrinter &p) {
24812480
}
24822481

24832482
template <typename A, typename... AdditionalArgs>
2484-
static A getSubOperands(unsigned pos, A allArgs, mlir::DenseI32ArrayAttr ranges,
2483+
static A getSubOperands(unsigned pos, A allArgs,
2484+
mlir::DenseIntElementsAttr ranges,
24852485
AdditionalArgs &&...additionalArgs) {
24862486
unsigned start = 0;
24872487
for (unsigned i = 0; i < pos; ++i)
2488-
start += ranges[i];
2489-
return allArgs.slice(start, ranges[pos],
2488+
start += (*(ranges.begin() + i)).getZExtValue();
2489+
return allArgs.slice(start, (*(ranges.begin() + pos)).getZExtValue(),
24902490
std::forward<AdditionalArgs>(additionalArgs)...);
24912491
}
24922492

@@ -2498,10 +2498,14 @@ getMutableSuccessorOperands(unsigned pos, mlir::MutableOperandRange operands,
24982498
*owner->getAttrDictionary().getNamed(offsetAttr);
24992499
return getSubOperands(
25002500
pos, operands,
2501-
targetOffsetAttr.getValue().cast<mlir::DenseI32ArrayAttr>(),
2501+
targetOffsetAttr.getValue().cast<mlir::DenseIntElementsAttr>(),
25022502
mlir::MutableOperandRange::OperandSegment(pos, targetOffsetAttr));
25032503
}
25042504

2505+
static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
2506+
return attr.getNumElements();
2507+
}
2508+
25052509
llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
25062510
return {};
25072511
}
@@ -2520,25 +2524,24 @@ llvm::Optional<llvm::ArrayRef<mlir::Value>>
25202524
fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
25212525
unsigned oper) {
25222526
auto a =
2523-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2524-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2527+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2528+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25252529
getOperandSegmentSizeAttr());
25262530
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
25272531
}
25282532

25292533
llvm::Optional<mlir::ValueRange>
25302534
fir::SelectOp::getSuccessorOperands(mlir::ValueRange operands, unsigned oper) {
25312535
auto a =
2532-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2533-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2536+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2537+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25342538
getOperandSegmentSizeAttr());
25352539
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
25362540
}
25372541

25382542
unsigned fir::SelectOp::targetOffsetSize() {
2539-
return (*this)
2540-
->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr())
2541-
.size();
2543+
return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2544+
getTargetOffsetAttr()));
25422545
}
25432546

25442547
//===----------------------------------------------------------------------===//
@@ -2547,27 +2550,27 @@ unsigned fir::SelectOp::targetOffsetSize() {
25472550

25482551
llvm::Optional<mlir::OperandRange>
25492552
fir::SelectCaseOp::getCompareOperands(unsigned cond) {
2550-
auto a =
2551-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getCompareOffsetAttr());
2553+
auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2554+
getCompareOffsetAttr());
25522555
return {getSubOperands(cond, getCompareArgs(), a)};
25532556
}
25542557

25552558
llvm::Optional<llvm::ArrayRef<mlir::Value>>
25562559
fir::SelectCaseOp::getCompareOperands(llvm::ArrayRef<mlir::Value> operands,
25572560
unsigned cond) {
2558-
auto a =
2559-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getCompareOffsetAttr());
2560-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2561+
auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2562+
getCompareOffsetAttr());
2563+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25612564
getOperandSegmentSizeAttr());
25622565
return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
25632566
}
25642567

25652568
llvm::Optional<mlir::ValueRange>
25662569
fir::SelectCaseOp::getCompareOperands(mlir::ValueRange operands,
25672570
unsigned cond) {
2568-
auto a =
2569-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getCompareOffsetAttr());
2570-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2571+
auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2572+
getCompareOffsetAttr());
2573+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25712574
getOperandSegmentSizeAttr());
25722575
return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
25732576
}
@@ -2581,8 +2584,8 @@ llvm::Optional<llvm::ArrayRef<mlir::Value>>
25812584
fir::SelectCaseOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
25822585
unsigned oper) {
25832586
auto a =
2584-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2585-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2587+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2588+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25862589
getOperandSegmentSizeAttr());
25872590
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
25882591
}
@@ -2591,8 +2594,8 @@ llvm::Optional<mlir::ValueRange>
25912594
fir::SelectCaseOp::getSuccessorOperands(mlir::ValueRange operands,
25922595
unsigned oper) {
25932596
auto a =
2594-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2595-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2597+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2598+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
25962599
getOperandSegmentSizeAttr());
25972600
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
25982601
}
@@ -2665,11 +2668,9 @@ mlir::ParseResult fir::SelectCaseOp::parse(mlir::OpAsmParser &parser,
26652668
}
26662669
auto &bld = parser.getBuilder();
26672670
result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
2668-
bld.getDenseI32ArrayAttr({1, offSize, toffSize}));
2669-
result.addAttribute(getCompareOffsetAttr(),
2670-
bld.getDenseI32ArrayAttr(argOffs));
2671-
result.addAttribute(getTargetOffsetAttr(),
2672-
bld.getDenseI32ArrayAttr(targOffs));
2671+
bld.getI32VectorAttr({1, offSize, toffSize}));
2672+
result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
2673+
result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
26732674
return mlir::success();
26742675
}
26752676

@@ -2702,15 +2703,13 @@ void fir::SelectCaseOp::print(mlir::OpAsmPrinter &p) {
27022703
}
27032704

27042705
unsigned fir::SelectCaseOp::compareOffsetSize() {
2705-
return (*this)
2706-
->getAttrOfType<mlir::DenseI32ArrayAttr>(getCompareOffsetAttr())
2707-
.size();
2706+
return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2707+
getCompareOffsetAttr()));
27082708
}
27092709

27102710
unsigned fir::SelectCaseOp::targetOffsetSize() {
2711-
return (*this)
2712-
->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr())
2713-
.size();
2711+
return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2712+
getTargetOffsetAttr()));
27142713
}
27152714

27162715
void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
@@ -2739,7 +2738,7 @@ void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
27392738
for (auto ops : cmpOperands)
27402739
result.addOperands(ops);
27412740
result.addAttribute(getCompareOffsetAttr(),
2742-
builder.getDenseI32ArrayAttr(operOffs));
2741+
builder.getI32VectorAttr(operOffs));
27432742
const auto count = destinations.size();
27442743
for (auto d : destinations)
27452744
result.addSuccessors(d);
@@ -2757,9 +2756,8 @@ void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
27572756
}
27582757
}
27592758
result.addAttribute(getOperandSegmentSizeAttr(),
2760-
builder.getDenseI32ArrayAttr({1, operSize, sumArgs}));
2761-
result.addAttribute(getTargetOffsetAttr(),
2762-
builder.getDenseI32ArrayAttr(argOffs));
2759+
builder.getI32VectorAttr({1, operSize, sumArgs}));
2760+
result.addAttribute(getTargetOffsetAttr(), builder.getI32VectorAttr(argOffs));
27632761
result.addAttributes(attributes);
27642762
}
27652763

@@ -2856,8 +2854,8 @@ llvm::Optional<llvm::ArrayRef<mlir::Value>>
28562854
fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
28572855
unsigned oper) {
28582856
auto a =
2859-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2860-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2857+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2858+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
28612859
getOperandSegmentSizeAttr());
28622860
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
28632861
}
@@ -2866,16 +2864,15 @@ llvm::Optional<mlir::ValueRange>
28662864
fir::SelectRankOp::getSuccessorOperands(mlir::ValueRange operands,
28672865
unsigned oper) {
28682866
auto a =
2869-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2870-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2867+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2868+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
28712869
getOperandSegmentSizeAttr());
28722870
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
28732871
}
28742872

28752873
unsigned fir::SelectRankOp::targetOffsetSize() {
2876-
return (*this)
2877-
->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr())
2878-
.size();
2874+
return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2875+
getTargetOffsetAttr()));
28792876
}
28802877

28812878
//===----------------------------------------------------------------------===//
@@ -2901,8 +2898,8 @@ llvm::Optional<llvm::ArrayRef<mlir::Value>>
29012898
fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
29022899
unsigned oper) {
29032900
auto a =
2904-
(*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr());
2905-
auto segments = (*this)->getAttrOfType<mlir::DenseI32ArrayAttr>(
2901+
(*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
2902+
auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
29062903
getOperandSegmentSizeAttr());
29072904
return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
29082905
}
@@ -2947,15 +2944,14 @@ mlir::ParseResult fir::SelectTypeOp::parse(mlir::OpAsmParser &parser,
29472944
offSize += argSize;
29482945
}
29492946
result.addAttribute(fir::SelectTypeOp::getOperandSegmentSizeAttr(),
2950-
bld.getDenseI32ArrayAttr({1, 0, offSize}));
2951-
result.addAttribute(getTargetOffsetAttr(), bld.getDenseI32ArrayAttr(argOffs));
2947+
bld.getI32VectorAttr({1, 0, offSize}));
2948+
result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(argOffs));
29522949
return mlir::success();
29532950
}
29542951

29552952
unsigned fir::SelectTypeOp::targetOffsetSize() {
2956-
return (*this)
2957-
->getAttrOfType<mlir::DenseI32ArrayAttr>(getTargetOffsetAttr())
2958-
.size();
2953+
return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
2954+
getTargetOffsetAttr()));
29592955
}
29602956

29612957
void fir::SelectTypeOp::print(mlir::OpAsmPrinter &p) {
@@ -3025,9 +3021,8 @@ void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
30253021
}
30263022
}
30273023
result.addAttribute(getOperandSegmentSizeAttr(),
3028-
builder.getDenseI32ArrayAttr({1, 0, sumArgs}));
3029-
result.addAttribute(getTargetOffsetAttr(),
3030-
builder.getDenseI32ArrayAttr(argOffs));
3024+
builder.getI32VectorAttr({1, 0, sumArgs}));
3025+
result.addAttribute(getTargetOffsetAttr(), builder.getI32VectorAttr(argOffs));
30313026
result.addAttributes(attributes);
30323027
}
30333028

‎flang/test/Fir/convert-to-llvm-openmp-and-fir.fir‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ func.func @_QPsb1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref<!
2828
// CHECK: %[[ONE_2:.*]] = llvm.mlir.constant(1 : i32) : i32
2929
// CHECK: omp.parallel {
3030
// CHECK: %[[ONE_3:.*]] = llvm.mlir.constant(1 : i64) : i64
31-
// CHECK: %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {adapt.valuebyref, in_type = i32, operand_segment_sizes = array<i32: 0, 0>, pinned} : (i64) -> !llvm.ptr<i32>
31+
// CHECK: %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {adapt.valuebyref, in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>, pinned} : (i64) -> !llvm.ptr<i32>
3232
// CHECK: %[[N:.*]] = llvm.load %[[N_REF]] : !llvm.ptr<i32>
3333
// CHECK: omp.wsloop nowait
3434
// CHECK-SAME: for (%[[I:.*]]) : i32 = (%[[ONE_2]]) to (%[[N]]) inclusive step (%[[ONE_2]]) {
@@ -201,7 +201,7 @@ func.func @_QPsimd1(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}, %arg1: !fir.ref
201201
// CHECK: %[[ONE_2:.*]] = llvm.mlir.constant(1 : i32) : i32
202202
// CHECK: omp.parallel {
203203
// CHECK: %[[ONE_3:.*]] = llvm.mlir.constant(1 : i64) : i64
204-
// CHECK: %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {adapt.valuebyref, in_type = i32, operand_segment_sizes = array<i32: 0, 0>, pinned} : (i64) -> !llvm.ptr<i32>
204+
// CHECK: %[[I_VAR:.*]] = llvm.alloca %[[ONE_3]] x i32 {adapt.valuebyref, in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>, pinned} : (i64) -> !llvm.ptr<i32>
205205
// CHECK: %[[N:.*]] = llvm.load %[[N_REF]] : !llvm.ptr<i32>
206206
// CHECK: omp.simdloop
207207
// CHECK-SAME: (%[[I:.*]]) : i32 = (%[[ONE_2]]) to (%[[N]]) step (%[[ONE_2]]) {

‎flang/test/Fir/convert-to-llvm.fir‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1701,7 +1701,7 @@ func.func @no_reassoc(%arg0: !fir.ref<i32>) {
17011701
// CHECK-LABEL: llvm.func @no_reassoc(
17021702
// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<i32>) {
17031703
// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
1704-
// CHECK: %[[ALLOC:.*]] = llvm.alloca %[[C1]] x i32 {in_type = i32, operand_segment_sizes = array<i32: 0, 0>} : (i64) -> !llvm.ptr<i32>
1704+
// CHECK: %[[ALLOC:.*]] = llvm.alloca %[[C1]] x i32 {in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>} : (i64) -> !llvm.ptr<i32>
17051705
// CHECK: %[[LOAD:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32>
17061706
// CHECK: llvm.store %[[LOAD]], %[[ALLOC]] : !llvm.ptr<i32>
17071707
// CHECK: llvm.return
@@ -1821,7 +1821,7 @@ func.func private @_QPxb(!fir.box<!fir.array<?x?xf64>>)
18211821
// CHECK: %[[C1_0:.*]] = llvm.mlir.constant(1 : i64) : i64
18221822
// CHECK: %[[ARR_SIZE_TMP1:.*]] = llvm.mul %[[C1_0]], %[[N1]] : i64
18231823
// CHECK: %[[ARR_SIZE:.*]] = llvm.mul %[[ARR_SIZE_TMP1]], %[[N2]] : i64
1824-
// CHECK: %[[ARR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr", in_type = !fir.array<?x?xf64>, operand_segment_sizes = array<i32: 0, 2>, uniq_name = "_QFsbEarr"} : (i64) -> !llvm.ptr<f64>
1824+
// CHECK: %[[ARR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr", in_type = !fir.array<?x?xf64>, operand_segment_sizes = dense<[0, 2]> : vector<2xi32>, uniq_name = "_QFsbEarr"} : (i64) -> !llvm.ptr<f64>
18251825
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
18261826
// CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(8 : i32) : i32
18271827
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(28 : i32) : i32
@@ -1898,9 +1898,9 @@ func.func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>)
18981898
// CHECK: %[[C10:.*]] = llvm.mlir.constant(10 : i64) : i64
18991899
// CHECK: %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i64
19001900
// CHECK: %[[ALLOCA_SIZE_V:.*]] = llvm.mlir.constant(1 : i64) : i64
1901-
// CHECK: %[[V:.*]] = llvm.alloca %[[ALLOCA_SIZE_V]] x i32 {bindc_name = "v", in_type = i32, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFtest_dt_sliceEv"} : (i64) -> !llvm.ptr<i32>
1901+
// CHECK: %[[V:.*]] = llvm.alloca %[[ALLOCA_SIZE_V]] x i32 {bindc_name = "v", in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>, uniq_name = "_QFtest_dt_sliceEv"} : (i64) -> !llvm.ptr<i32>
19021902
// CHECK: %[[ALLOCA_SIZE_X:.*]] = llvm.mlir.constant(1 : i64) : i64
1903-
// CHECK: %[[X:.*]] = llvm.alloca %[[ALLOCA_SIZE_X]] x !llvm.array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>> {bindc_name = "x", in_type = !fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFtest_dt_sliceEx"} : (i64) -> !llvm.ptr<array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>>>
1903+
// CHECK: %[[X:.*]] = llvm.alloca %[[ALLOCA_SIZE_X]] x !llvm.array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>> {bindc_name = "x", in_type = !fir.array<20x!fir.type<_QFtest_dt_sliceTt{i:i32,j:i32}>>, operand_segment_sizes = dense<0> : vector<2xi32>, uniq_name = "_QFtest_dt_sliceEx"} : (i64) -> !llvm.ptr<array<20 x struct<"_QFtest_dt_sliceTt", (i32, i32)>>>
19041904
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
19051905
// CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(4 : i32) : i32
19061906
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32

‎mlir/docs/PatternRewriter.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -357,7 +357,7 @@ Example output is shown below:
357357
```
358358
//===-------------------------------------------===//
359359
Processing operation : 'cf.cond_br'(0x60f000001120) {
360-
"cf.cond_br"(%arg0)[^bb2, ^bb2] {operand_segment_sizes = array<i32: 1, 0, 0>} : (i1) -> ()
360+
"cf.cond_br"(%arg0)[^bb2, ^bb2] {operand_segment_sizes = dense<[1, 0, 0]> : vector<3xi32>} : (i1) -> ()
361361
362362
* Pattern SimplifyConstCondBranchPred : 'cf.cond_br -> ()' {
363363
} -> failure : pattern failed to match

‎mlir/include/mlir/Dialect/ControlFlow/IR/ControlFlowOps.td‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -254,7 +254,7 @@ def SwitchOp : CF_Op<"switch",
254254
Variadic<AnyType>:$defaultOperands,
255255
VariadicOfVariadic<AnyType, "case_operand_segments">:$caseOperands,
256256
OptionalAttr<AnyIntElementsAttr>:$case_values,
257-
DenseI32ArrayAttr:$case_operand_segments
257+
I32ElementsAttr:$case_operand_segments
258258
);
259259
let successors = (successor
260260
AnySuccessor:$defaultDestination,

0 commit comments

Comments
 (0)