diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp --- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp +++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp @@ -204,10 +204,10 @@ // Get the element type given an LLVM type that is of the form // [llvm.ptr](array|struct|vector)+ and the provided indexes. static mlir::Type getBoxEleTy(mlir::Type type, - llvm::ArrayRef indexes) { + llvm::ArrayRef indexes) { if (auto t = type.dyn_cast()) type = t.getElementType(); - for (auto i : indexes) { + for (unsigned i : indexes) { if (auto t = type.dyn_cast()) { assert(!t.isOpaque() && i < t.getBody().size()); type = t.getBody()[i]; @@ -408,17 +408,6 @@ }; } // namespace -/// Construct an `llvm.extractvalue` instruction. It will return value at -/// element \p x from \p tuple. -static mlir::LLVM::ExtractValueOp -genExtractValueWithIndex(mlir::Location loc, mlir::Value tuple, mlir::Type ty, - mlir::ConversionPatternRewriter &rewriter, - mlir::MLIRContext *ctx, int x) { - auto cx = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(x)); - auto xty = ty.cast().getBody()[x]; - return rewriter.create(loc, xty, tuple, cx); -} - namespace { /// Lower `fir.box_addr` to the sequence of operations to extract the first /// element of the box. @@ -434,10 +423,7 @@ if (auto argty = boxaddr.getVal().getType().dyn_cast()) { rewriter.replaceOp(boxaddr, loadBaseAddrFromBox(loc, ty, a, rewriter)); } else { - auto c0attr = rewriter.getI32IntegerAttr(0); - auto c0 = mlir::ArrayAttr::get(boxaddr.getContext(), c0attr); - rewriter.replaceOpWithNewOp(boxaddr, ty, a, - c0); + rewriter.replaceOpWithNewOp(boxaddr, a, 0); } return mlir::success(); } @@ -453,12 +439,11 @@ mlir::ConversionPatternRewriter &rewriter) const override { mlir::Value boxChar = adaptor.getOperands()[0]; mlir::Location loc = boxChar.getLoc(); - mlir::MLIRContext *ctx = boxChar.getContext(); mlir::Type returnValTy = boxCharLen.getResult().getType(); constexpr int boxcharLenIdx = 1; - mlir::LLVM::ExtractValueOp len = genExtractValueWithIndex( - loc, boxChar, boxChar.getType(), rewriter, ctx, boxcharLenIdx); + auto len = rewriter.create(loc, boxChar, + boxcharLenIdx); mlir::Value lenAfterCast = integerCast(loc, rewriter, returnValTy, len); rewriter.replaceOp(boxCharLen, lenAfterCast); @@ -637,10 +622,8 @@ a.value().cast().getValue().zextOrTrunc(bits)); auto elemCst = rewriter.create(loc, intTy, elemAttr); - auto index = mlir::ArrayAttr::get( - constop.getContext(), rewriter.getI32IntegerAttr(a.index())); - cst = rewriter.create(loc, ty, cst, elemCst, - index); + cst = rewriter.create(loc, cst, elemCst, + a.index()); } } else { return mlir::failure(); @@ -686,24 +669,16 @@ matchAndRewrite(fir::CmpcOp cmp, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { mlir::ValueRange operands = adaptor.getOperands(); - mlir::MLIRContext *ctxt = cmp.getContext(); - mlir::Type eleTy = convertType(getComplexEleTy(cmp.getLhs().getType())); mlir::Type resTy = convertType(cmp.getType()); mlir::Location loc = cmp.getLoc(); - auto pos0 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(0)); llvm::SmallVector rp = { - rewriter.create(loc, eleTy, operands[0], - pos0), - rewriter.create(loc, eleTy, operands[1], - pos0)}; + rewriter.create(loc, operands[0], 0), + rewriter.create(loc, operands[1], 0)}; auto rcp = rewriter.create(loc, resTy, rp, cmp->getAttrs()); - auto pos1 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(1)); llvm::SmallVector ip = { - rewriter.create(loc, eleTy, operands[0], - pos1), - rewriter.create(loc, eleTy, operands[1], - pos1)}; + rewriter.create(loc, operands[0], 1), + rewriter.create(loc, operands[1], 1)}; auto icp = rewriter.create(loc, resTy, ip, cmp->getAttrs()); llvm::SmallVector cp = {rcp, icp}; @@ -730,22 +705,17 @@ matchAndRewrite(fir::ConstcOp conc, OpAdaptor, mlir::ConversionPatternRewriter &rewriter) const override { mlir::Location loc = conc.getLoc(); - mlir::MLIRContext *ctx = conc.getContext(); mlir::Type ty = convertType(conc.getType()); mlir::Type ety = convertType(getComplexEleTy(conc.getType())); - auto realFloatAttr = mlir::FloatAttr::get(ety, getValue(conc.getReal())); - auto realPart = - rewriter.create(loc, ety, realFloatAttr); - auto imFloatAttr = mlir::FloatAttr::get(ety, getValue(conc.getImaginary())); - auto imPart = - rewriter.create(loc, ety, imFloatAttr); - auto realIndex = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - auto imIndex = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1)); + auto realPart = rewriter.create( + loc, ety, getValue(conc.getReal())); + auto imPart = rewriter.create( + loc, ety, getValue(conc.getImaginary())); auto undef = rewriter.create(loc, ty); - auto setReal = rewriter.create( - loc, ty, undef, realPart, realIndex); - rewriter.replaceOpWithNewOp(conc, ty, setReal, - imPart, imIndex); + auto setReal = + rewriter.create(loc, undef, realPart, 0); + rewriter.replaceOpWithNewOp(conc, setReal, + imPart, 1); return mlir::success(); } @@ -793,23 +763,18 @@ if (fir::isa_complex(fromFirTy) && fir::isa_complex(toFirTy)) { // Special case: handle the conversion of a complex such that both the // real and imaginary parts are converted together. - auto zero = mlir::ArrayAttr::get(convert.getContext(), - rewriter.getI32IntegerAttr(0)); - auto one = mlir::ArrayAttr::get(convert.getContext(), - rewriter.getI32IntegerAttr(1)); auto ty = convertType(getComplexEleTy(convert.getValue().getType())); - auto rp = rewriter.create(loc, ty, op0, zero); - auto ip = rewriter.create(loc, ty, op0, one); + auto rp = rewriter.create(loc, op0, 0); + auto ip = rewriter.create(loc, op0, 1); auto nt = convertType(getComplexEleTy(convert.getRes().getType())); auto fromBits = mlir::LLVM::getPrimitiveTypeSizeInBits(ty); auto toBits = mlir::LLVM::getPrimitiveTypeSizeInBits(nt); auto rc = convertFpToFp(rp, fromBits, toBits, nt); auto ic = convertFpToFp(ip, fromBits, toBits, nt); auto un = rewriter.create(loc, toTy); - auto i1 = - rewriter.create(loc, toTy, un, rc, zero); - rewriter.replaceOpWithNewOp(convert, toTy, i1, - ic, one); + auto i1 = rewriter.create(loc, un, rc, 0); + rewriter.replaceOpWithNewOp(convert, i1, ic, + 1); return mlir::success(); } @@ -956,7 +921,6 @@ matchAndRewrite(fir::EmboxCharOp emboxChar, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { mlir::ValueRange operands = adaptor.getOperands(); - auto *ctx = emboxChar.getContext(); mlir::Value charBuffer = operands[0]; mlir::Value charBufferLen = operands[1]; @@ -969,12 +933,10 @@ llvmStructTy.cast().getBody()[1]; mlir::Value lenAfterCast = integerCast(loc, rewriter, lenTy, charBufferLen); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - auto c1 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1)); auto insertBufferOp = rewriter.create( - loc, llvmStructTy, llvmStruct, charBuffer, c0); + loc, llvmStruct, charBuffer, 0); rewriter.replaceOpWithNewOp( - emboxChar, llvmStructTy, insertBufferOp, lenAfterCast, c1); + emboxChar, insertBufferOp, lenAfterCast, 1); return mlir::success(); } @@ -1261,7 +1223,7 @@ /// Basic pattern to write a field in the descriptor mlir::Value insertField(mlir::ConversionPatternRewriter &rewriter, mlir::Location loc, mlir::Value dest, - llvm::ArrayRef fldIndexes, + llvm::ArrayRef fldIndexes, mlir::Value value, bool bitcast = false) const { auto boxTy = dest.getType(); auto fldTy = this->getBoxEleTy(boxTy, fldIndexes); @@ -1269,12 +1231,8 @@ value = rewriter.create(loc, fldTy, value); else value = this->integerCast(loc, rewriter, fldTy, value); - llvm::SmallVector attrs; - for (auto i : fldIndexes) - attrs.push_back(rewriter.getI32IntegerAttr(i)); - auto indexesAttr = mlir::ArrayAttr::get(rewriter.getContext(), attrs); - return rewriter.create(loc, boxTy, dest, value, - indexesAttr); + return rewriter.create(loc, dest, value, + fldIndexes); } inline mlir::Value @@ -1953,43 +1911,43 @@ struct ValueOpCommon { // Translate the arguments pertaining to any multidimensional array to // row-major order for LLVM-IR. - static void toRowMajor(llvm::SmallVectorImpl &attrs, + static void toRowMajor(llvm::SmallVectorImpl &indices, mlir::Type ty) { assert(ty && "type is null"); - const auto end = attrs.size(); + const auto end = indices.size(); for (std::remove_const_t i = 0; i < end; ++i) { if (auto seq = ty.dyn_cast()) { const auto dim = getDimension(seq); if (dim > 1) { auto ub = std::min(i + dim, end); - std::reverse(attrs.begin() + i, attrs.begin() + ub); + std::reverse(indices.begin() + i, indices.begin() + ub); i += dim - 1; } ty = getArrayElementType(seq); } else if (auto st = ty.dyn_cast()) { - ty = st.getBody()[attrs[i].cast().getInt()]; + ty = st.getBody()[indices[i]]; } else { llvm_unreachable("index into invalid type"); } } } - static llvm::SmallVector + static llvm::SmallVector collectIndices(mlir::ConversionPatternRewriter &rewriter, mlir::ArrayAttr arrAttr) { - llvm::SmallVector attrs; + llvm::SmallVector indices; for (auto i = arrAttr.begin(), e = arrAttr.end(); i != e; ++i) { - if (i->isa()) { - attrs.push_back(*i); + if (auto intAttr = i->dyn_cast()) { + indices.push_back(intAttr.getInt()); } else { auto fieldName = i->cast().getValue(); ++i; auto ty = i->cast().getValue(); auto index = ty.cast().getFieldIndex(fieldName); - attrs.push_back(mlir::IntegerAttr::get(rewriter.getI32Type(), index)); + indices.push_back(index); } } - return attrs; + return indices; } private: @@ -2012,11 +1970,10 @@ doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { mlir::ValueRange operands = adaptor.getOperands(); - auto attrs = collectIndices(rewriter, extractVal.getCoor()); - toRowMajor(attrs, operands[0].getType()); - auto position = mlir::ArrayAttr::get(extractVal.getContext(), attrs); + auto indices = collectIndices(rewriter, extractVal.getCoor()); + toRowMajor(indices, operands[0].getType()); rewriter.replaceOpWithNewOp( - extractVal, ty, operands[0], position); + extractVal, operands[0], indices); return mlir::success(); } }; @@ -2032,11 +1989,10 @@ doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { mlir::ValueRange operands = adaptor.getOperands(); - auto attrs = collectIndices(rewriter, insertVal.getCoor()); - toRowMajor(attrs, operands[0].getType()); - auto position = mlir::ArrayAttr::get(insertVal.getContext(), attrs); + auto indices = collectIndices(rewriter, insertVal.getCoor()); + toRowMajor(indices, operands[0].getType()); rewriter.replaceOpWithNewOp( - insertVal, ty, operands[0], operands[1], position); + insertVal, operands[0], operands[1], indices); return mlir::success(); } }; @@ -2047,8 +2003,8 @@ using FIROpAndTypeConversion::FIROpAndTypeConversion; // Increments an array of subscripts in a row major fasion. - void incrementSubscripts(const llvm::SmallVector &dims, - llvm::SmallVector &subscripts) const { + void incrementSubscripts(llvm::ArrayRef dims, + llvm::SmallVectorImpl &subscripts) const { for (size_t i = dims.size(); i > 0; --i) { if (++subscripts[i - 1] < dims[i - 1]) { return; @@ -2061,7 +2017,7 @@ doRewrite(fir::InsertOnRangeOp range, mlir::Type ty, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { - llvm::SmallVector dims; + llvm::SmallVector dims; auto type = adaptor.getOperands()[0].getType(); // Iteratively extract the array dimensions from the type. @@ -2070,8 +2026,8 @@ type = t.getElementType(); } - llvm::SmallVector lBounds; - llvm::SmallVector uBounds; + llvm::SmallVector lBounds; + llvm::SmallVector uBounds; // Unzip the upper and lower bound and convert to a row major format. mlir::DenseIntElementsAttr coor = range.getCoor(); @@ -2086,29 +2042,15 @@ mlir::Value lastOp = adaptor.getOperands()[0]; mlir::Value insertVal = adaptor.getOperands()[1]; - auto i64Ty = rewriter.getI64Type(); while (subscripts != uBounds) { - // Convert uint64_t's to Attribute's. - llvm::SmallVector subscriptAttrs; - for (const auto &subscript : subscripts) - subscriptAttrs.push_back(mlir::IntegerAttr::get(i64Ty, subscript)); lastOp = rewriter.create( - loc, ty, lastOp, insertVal, - mlir::ArrayAttr::get(range.getContext(), subscriptAttrs)); + loc, lastOp, insertVal, subscripts); incrementSubscripts(dims, subscripts); } - // Convert uint64_t's to Attribute's. - llvm::SmallVector subscriptAttrs; - for (const auto &subscript : subscripts) - subscriptAttrs.push_back( - mlir::IntegerAttr::get(rewriter.getI64Type(), subscript)); - mlir::ArrayRef arrayRef(subscriptAttrs); - rewriter.replaceOpWithNewOp( - range, ty, lastOp, insertVal, - mlir::ArrayAttr::get(range.getContext(), arrayRef)); + range, lastOp, insertVal, subscripts); return mlir::success(); } @@ -3004,18 +2946,14 @@ mlir::LogicalResult matchAndRewrite(fir::UnboxCharOp unboxchar, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { - auto *ctx = unboxchar.getContext(); - mlir::Type lenTy = convertType(unboxchar.getType(1)); mlir::Value tuple = adaptor.getOperands()[0]; - mlir::Type tupleTy = tuple.getType(); mlir::Location loc = unboxchar.getLoc(); mlir::Value ptrToBuffer = - genExtractValueWithIndex(loc, tuple, tupleTy, rewriter, ctx, 0); + rewriter.create(loc, tuple, 0); - mlir::LLVM::ExtractValueOp len = - genExtractValueWithIndex(loc, tuple, tupleTy, rewriter, ctx, 1); + auto len = rewriter.create(loc, tuple, 1); mlir::Value lenAfterCast = integerCast(loc, rewriter, lenTy, len); rewriter.replaceOp(unboxchar, @@ -3108,10 +3046,7 @@ auto structTy = ptr.getType().cast(); assert(!structTy.isOpaque() && !structTy.getBody().empty()); - mlir::Type ty = structTy.getBody()[0]; - mlir::MLIRContext *ctx = isPresent.getContext(); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - ptr = rewriter.create(loc, ty, ptr, c0); + ptr = rewriter.create(loc, ptr, 0); } mlir::LLVM::ConstantOp c0 = genConstantIndex(isPresent.getLoc(), idxTy, rewriter, 0); @@ -3140,10 +3075,8 @@ auto undefStruct = rewriter.create(loc, ty); auto nullField = rewriter.create(loc, structTy.getBody()[0]); - mlir::MLIRContext *ctx = absent.getContext(); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); rewriter.replaceOpWithNewOp( - absent, ty, undefStruct, nullField, c0); + absent, undefStruct, nullField, 0); } else { rewriter.replaceOpWithNewOp(absent, ty); } @@ -3164,20 +3097,17 @@ mlir::Value a = opnds[0]; mlir::Value b = opnds[1]; auto loc = sumop.getLoc(); - auto ctx = sumop.getContext(); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - auto c1 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1)); mlir::Type eleTy = lowering.convertType(getComplexEleTy(sumop.getType())); mlir::Type ty = lowering.convertType(sumop.getType()); - auto x0 = rewriter.create(loc, eleTy, a, c0); - auto y0 = rewriter.create(loc, eleTy, a, c1); - auto x1 = rewriter.create(loc, eleTy, b, c0); - auto y1 = rewriter.create(loc, eleTy, b, c1); + auto x0 = rewriter.create(loc, a, 0); + auto y0 = rewriter.create(loc, a, 1); + auto x1 = rewriter.create(loc, b, 0); + auto y1 = rewriter.create(loc, b, 1); auto rx = rewriter.create(loc, eleTy, x0, x1); auto ry = rewriter.create(loc, eleTy, y0, y1); auto r0 = rewriter.create(loc, ty); - auto r1 = rewriter.create(loc, ty, r0, rx, c0); - return rewriter.create(loc, ty, r1, ry, c1); + auto r1 = rewriter.create(loc, r0, rx, 0); + return rewriter.create(loc, r1, ry, 1); } } // namespace @@ -3225,15 +3155,12 @@ mlir::Value a = adaptor.getOperands()[0]; mlir::Value b = adaptor.getOperands()[1]; auto loc = mulc.getLoc(); - auto *ctx = mulc.getContext(); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - auto c1 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1)); mlir::Type eleTy = convertType(getComplexEleTy(mulc.getType())); mlir::Type ty = convertType(mulc.getType()); - auto x0 = rewriter.create(loc, eleTy, a, c0); - auto y0 = rewriter.create(loc, eleTy, a, c1); - auto x1 = rewriter.create(loc, eleTy, b, c0); - auto y1 = rewriter.create(loc, eleTy, b, c1); + auto x0 = rewriter.create(loc, a, 0); + auto y0 = rewriter.create(loc, a, 1); + auto x1 = rewriter.create(loc, b, 0); + auto y1 = rewriter.create(loc, b, 1); auto xx = rewriter.create(loc, eleTy, x0, x1); auto yx = rewriter.create(loc, eleTy, y0, x1); auto xy = rewriter.create(loc, eleTy, x0, y1); @@ -3241,8 +3168,8 @@ auto yy = rewriter.create(loc, eleTy, y0, y1); auto rr = rewriter.create(loc, eleTy, xx, yy); auto ra = rewriter.create(loc, ty); - auto r1 = rewriter.create(loc, ty, ra, rr, c0); - auto r0 = rewriter.create(loc, ty, r1, ri, c1); + auto r1 = rewriter.create(loc, ra, rr, 0); + auto r0 = rewriter.create(loc, r1, ri, 1); rewriter.replaceOp(mulc, r0.getResult()); return mlir::success(); } @@ -3262,15 +3189,12 @@ mlir::Value a = adaptor.getOperands()[0]; mlir::Value b = adaptor.getOperands()[1]; auto loc = divc.getLoc(); - auto *ctx = divc.getContext(); - auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0)); - auto c1 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1)); mlir::Type eleTy = convertType(getComplexEleTy(divc.getType())); mlir::Type ty = convertType(divc.getType()); - auto x0 = rewriter.create(loc, eleTy, a, c0); - auto y0 = rewriter.create(loc, eleTy, a, c1); - auto x1 = rewriter.create(loc, eleTy, b, c0); - auto y1 = rewriter.create(loc, eleTy, b, c1); + auto x0 = rewriter.create(loc, a, 0); + auto y0 = rewriter.create(loc, a, 1); + auto x1 = rewriter.create(loc, b, 0); + auto y1 = rewriter.create(loc, b, 1); auto xx = rewriter.create(loc, eleTy, x0, x1); auto x1x1 = rewriter.create(loc, eleTy, x1, x1); auto yx = rewriter.create(loc, eleTy, y0, x1); @@ -3283,8 +3207,8 @@ auto rr = rewriter.create(loc, eleTy, rrn, d); auto ri = rewriter.create(loc, eleTy, rin, d); auto ra = rewriter.create(loc, ty); - auto r1 = rewriter.create(loc, ty, ra, rr, c0); - auto r0 = rewriter.create(loc, ty, r1, ri, c1); + auto r1 = rewriter.create(loc, ra, rr, 0); + auto r0 = rewriter.create(loc, r1, ri, 1); rewriter.replaceOp(divc, r0.getResult()); return mlir::success(); } @@ -3299,19 +3223,15 @@ mlir::ConversionPatternRewriter &rewriter) const override { // given: -(x + iy) // result: -x - iy - auto *ctxt = neg.getContext(); auto eleTy = convertType(getComplexEleTy(neg.getType())); - auto ty = convertType(neg.getType()); auto loc = neg.getLoc(); mlir::Value o0 = adaptor.getOperands()[0]; - auto c0 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(0)); - auto c1 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(1)); - auto rp = rewriter.create(loc, eleTy, o0, c0); - auto ip = rewriter.create(loc, eleTy, o0, c1); + auto rp = rewriter.create(loc, o0, 0); + auto ip = rewriter.create(loc, o0, 1); auto nrp = rewriter.create(loc, eleTy, rp); auto nip = rewriter.create(loc, eleTy, ip); - auto r = rewriter.create(loc, ty, o0, nrp, c0); - rewriter.replaceOpWithNewOp(neg, ty, r, nip, c1); + auto r = rewriter.create(loc, o0, nrp, 0); + rewriter.replaceOpWithNewOp(neg, r, nip, 1); return mlir::success(); } }; diff --git a/flang/test/Fir/convert-to-llvm-target.fir b/flang/test/Fir/convert-to-llvm-target.fir --- a/flang/test/Fir/convert-to-llvm-target.fir +++ b/flang/test/Fir/convert-to-llvm-target.fir @@ -19,8 +19,8 @@ // INT64-SAME: (%[[char_array:.*]]: !llvm.ptr) // INT64: %[[c10:.*]] = llvm.mlir.constant(10 : i64) : i64 // INT64: %[[empty_struct:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}})> -// INT64: %[[struct_with_buffer:.*]] = llvm.insertvalue %[[char_array]], %[[empty_struct]][0 : i32] : !llvm.struct<(ptr, i{{.*}})> -// INT64: %{{.*}} = llvm.insertvalue %[[c10]], %[[struct_with_buffer]][1 : i32] : !llvm.struct<(ptr, i{{.*}})> +// INT64: %[[struct_with_buffer:.*]] = llvm.insertvalue %[[char_array]], %[[empty_struct]][0] : !llvm.struct<(ptr, i{{.*}})> +// INT64: %{{.*}} = llvm.insertvalue %[[c10]], %[[struct_with_buffer]][1] : !llvm.struct<(ptr, i{{.*}})> // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @test_embox @@ -28,8 +28,8 @@ // INT32: %[[c10:.*]] = llvm.mlir.constant(10 : i64) : i64 // INT32: %[[empty_struct:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i32)> // INT32: %[[c10_truncated:.*]] = llvm.trunc %[[c10]] : i64 to i32 -// INT32: %[[struct_with_buffer:.*]] = llvm.insertvalue %[[char_array]], %[[empty_struct]][0 : i32] : !llvm.struct<(ptr, i32)> -// INT32: %{{.*}} = llvm.insertvalue %[[c10_truncated:.*]], %[[struct_with_buffer]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %[[struct_with_buffer:.*]] = llvm.insertvalue %[[char_array]], %[[empty_struct]][0] : !llvm.struct<(ptr, i32)> +// INT32: %{{.*}} = llvm.insertvalue %[[c10_truncated:.*]], %[[struct_with_buffer]][1] : !llvm.struct<(ptr, i32)> // INT32-NEXT: llvm.return // ----- @@ -43,14 +43,14 @@ // INT64-LABEL: llvm.func @unboxchar_i8 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][0] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @unboxchar_i8 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr, i32)> -// INT32: %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][0] : !llvm.struct<(ptr, i32)> +// INT32: %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32: %{{.*}} = llvm.sext %[[len_unextended]] : i32 to i64 // INT32-NEXT: llvm.return @@ -61,14 +61,14 @@ // INT64-LABEL: llvm.func @unboxchar_i32 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][0] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @unboxchar_i32 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr, i32)> -// INT32: %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][0] : !llvm.struct<(ptr, i32)> +// INT32: %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32: %{{.*}} = llvm.sext %[[len_unextended]] : i32 to i64 // INT32-NEXT: llvm.return @@ -83,13 +83,13 @@ // INT64-LABEL: llvm.func @boxchar_len_i8_i32 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %[[len:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32 // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @boxchar_len_i8_i32 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32-NOT: llvm.trunc // INT32-NOT: llvm.sext // INT32-NEXT: llvm.return @@ -101,14 +101,14 @@ // INT64-LABEL: llvm.func @boxchar_len_i8_i64 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64-NOT: llvm.trunc // INT64-NOT: llvm.sext // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @boxchar_len_i8_i64 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %[[len:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32: %{{.*}} = llvm.sext %0 : i32 to i64 // INT32-NEXT: llvm.return @@ -119,13 +119,13 @@ // INT64-LABEL: llvm.func @boxchar_len_i32_i32 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %[[len:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32 // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @boxchar_len_i32_i32 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32-NOT: llvm.trunc // INT32-NOT: llvm.sext // INT32-NEXT: llvm.return @@ -137,13 +137,13 @@ // INT64-LABEL: llvm.func @boxchar_len_i32_i64 // INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i64)> -// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i64)> +// INT64: %{{.*}} = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i64)> // INT64-NOT: llvm.trunc // INT64-NOT: llvm.sext // INT64-NEXT: llvm.return // INT32-LABEL: llvm.func @boxchar_len_i32_i64 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr, i32)> -// INT32: %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr, i32)> +// INT32: %[[len:.*]] = llvm.extractvalue %[[box_char]][1] : !llvm.struct<(ptr, i32)> // INT32: %{{.*}} = llvm.sext %0 : i32 to i64 // INT32-NEXT: llvm.return diff --git a/flang/test/Fir/convert-to-llvm.fir b/flang/test/Fir/convert-to-llvm.fir --- a/flang/test/Fir/convert-to-llvm.fir +++ b/flang/test/Fir/convert-to-llvm.fir @@ -124,13 +124,13 @@ // CHECK-LABEL: llvm.mlir.global internal @_QFEx() // CHECK-SAME: !llvm.struct<([[DES_FIELDS:.*]])> // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T1:.*]] = llvm.insertvalue %{{.*}}, %[[T0]][1 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T2:.*]] = llvm.insertvalue %{{.*}}, %[[T1]][2 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T3:.*]] = llvm.insertvalue %{{.*}}, %[[T2]][3 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T4:.*]] = llvm.insertvalue %{{.*}}, %[[T3]][4 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T5:.*]] = llvm.insertvalue %{{.*}}, %[[T4]][5 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[T6:.*]] = llvm.insertvalue %{{.*}}, %[[T5]][6 : i32] : !llvm.struct<([[DES_FIELDS]])> -// CHECK: %[[GDES:.*]] = llvm.insertvalue %{{.*}}, %[[T6]][0 : i32] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T1:.*]] = llvm.insertvalue %{{.*}}, %[[T0]][1] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T2:.*]] = llvm.insertvalue %{{.*}}, %[[T1]][2] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T3:.*]] = llvm.insertvalue %{{.*}}, %[[T2]][3] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T4:.*]] = llvm.insertvalue %{{.*}}, %[[T3]][4] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T5:.*]] = llvm.insertvalue %{{.*}}, %[[T4]][5] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[T6:.*]] = llvm.insertvalue %{{.*}}, %[[T5]][6] : !llvm.struct<([[DES_FIELDS]])> +// CHECK: %[[GDES:.*]] = llvm.insertvalue %{{.*}}, %[[T6]][0] : !llvm.struct<([[DES_FIELDS]])> // CHECK: llvm.return %[[GDES]] : !llvm.struct<([[DES_FIELDS]])> // ----- @@ -377,7 +377,7 @@ // CHECK-LABEL: llvm.func @extract_derived_type // CHECK: %[[STRUCT:.*]] = llvm.mlir.undef : !llvm.struct<"derived", (f32)> -// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0 : i32] : !llvm.struct<"derived", (f32)> +// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<"derived", (f32)> // CHECK: llvm.return %[[VALUE]] : f32 // ----- @@ -392,7 +392,7 @@ // CHECK-LABEL: llvm.func @extract_array( // CHECK-SAME: %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>> -// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> +// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4, 5, 1] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> // CHECK: llvm.return %[[VALUE]] : f32 // ----- @@ -410,8 +410,8 @@ // CHECK-LABEL: llvm.func @extract_array( // CHECK-SAME: %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>> -// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 0 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> -// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> +// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4, 5, 0] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> +// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4, 5, 1] : !llvm.array<10 x array<10 x struct<(i32, f32)>>> // CHECK: llvm.return // ----- @@ -426,7 +426,7 @@ // CHECK-LABEL: func @insert_tuple( // CHECK-SAME: %[[TUPLE:.*]]: !llvm.struct<(i32, f32)> -// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1 : index] : !llvm.struct<(i32, f32)> +// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1] : !llvm.struct<(i32, f32)> // CHECK: llvm.return // ----- @@ -497,15 +497,15 @@ // CHECK-LABEL: llvm.func @fir_complex_add( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, // CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { -// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> +// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]] : f128 // CHECK: %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]] : f128 // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> // ----- @@ -522,15 +522,15 @@ // CHECK-LABEL: llvm.func @fir_complex_sub( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, // CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { -// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> +// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[SUB_X0_X1:.*]] = llvm.fsub %[[X0]], %[[X1]] : f128 // CHECK: %[[SUB_Y0_Y1:.*]] = llvm.fsub %[[Y0]], %[[Y1]] : f128 // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_X0_X1]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_Y0_Y1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> // ----- @@ -547,10 +547,10 @@ // CHECK-LABEL: llvm.func @fir_complex_mul( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, // CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { -// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> +// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] : f128 // CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] : f128 // CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] : f128 @@ -558,8 +558,8 @@ // CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] : f128 // CHECK: %[[SUB:.*]] = llvm.fsub %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] : f128 // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[SUB]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[ADD]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[SUB]], %{{.*}}[0] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[ADD]], %{{.*}}[1] : !llvm.struct<(f128, f128)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> // ----- @@ -576,10 +576,10 @@ // CHECK-LABEL: llvm.func @fir_complex_div( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>, // CHECK-SAME: %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { -// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> +// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] : f128 // CHECK: %[[MUL_X1_X1:.*]] = llvm.fmul %[[X1]], %[[X1]] : f128 // CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] : f128 @@ -592,8 +592,8 @@ // CHECK: %[[DIV0:.*]] = llvm.fdiv %[[ADD_X0X1_Y0Y1]], %[[ADD_X1X1_Y1Y1]] : f128 // CHECK: %[[DIV1:.*]] = llvm.fdiv %[[SUB_Y0X1_X0Y1]], %[[ADD_X1X1_Y1Y1]] : f128 // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[DIV0]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[DIV1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[DIV0]], %{{.*}}[0] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[DIV1]], %{{.*}}[1] : !llvm.struct<(f128, f128)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> // ----- @@ -609,12 +609,12 @@ // CHECK-LABEL: llvm.func @fir_complex_neg( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> { -// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[NEGX:.*]] = llvm.fneg %[[X]] : f128 // CHECK: %[[NEGY:.*]] = llvm.fneg %[[Y]] : f128 -// CHECK: %{{.*}} = llvm.insertvalue %[[NEGX]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %{{.*}} = llvm.insertvalue %[[NEGY]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[NEGX]], %{{.*}}[0] : !llvm.struct<(f128, f128)> +// CHECK: %{{.*}} = llvm.insertvalue %[[NEGY]], %{{.*}}[1] : !llvm.struct<(f128, f128)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(f128, f128)> // ----- @@ -629,10 +629,10 @@ // CHECK-LABEL: llvm.func @compare_complex_eq // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1 : i32] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1] : !llvm.struct<(f64, f64)> // CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "oeq" [[RA]], [[RB]] : f64 // CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "oeq" [[IA]], [[IB]] : f64 // CHECK: [[RES:%.*]] = llvm.and [[RESR]], [[RESI]] : i1 @@ -646,10 +646,10 @@ // CHECK-LABEL: llvm.func @compare_complex_ne // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1 : i32] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[IA:%.*]] = llvm.extractvalue [[A]][1] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[IB:%.*]] = llvm.extractvalue [[B]][1] : !llvm.struct<(f64, f64)> // CHECK-DAG: [[RESR:%.*]] = llvm.fcmp "une" [[RA]], [[RB]] : f64 // CHECK-DAG: [[RESI:%.*]] = llvm.fcmp "une" [[IA]], [[IB]] : f64 // CHECK: [[RES:%.*]] = llvm.or [[RESR]], [[RESI]] : i1 @@ -663,8 +663,8 @@ // CHECK-LABEL: llvm.func @compare_complex_other // CHECK-SAME: [[A:%.*]]: !llvm.struct<(f64, f64)>, // CHECK-SAME: [[B:%.*]]: !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0 : i32] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RA:%.*]] = llvm.extractvalue [[A]][0] : !llvm.struct<(f64, f64)> +// CHECK-DAG: [[RB:%.*]] = llvm.extractvalue [[B]][0] : !llvm.struct<(f64, f64)> // CHECK: [[RESR:%.*]] = llvm.fcmp "ogt" [[RA]], [[RB]] : f64 // CHECK: return [[RESR]] : i1 @@ -759,13 +759,13 @@ // CHECK-LABEL: func @convert_complex4( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f32, f32)>) -> !llvm.struct<(f64, f64)> -// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f32, f32)> -// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f32, f32)> +// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f32, f32)> +// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f32, f32)> // CHECK: %[[CONVERTX:.*]] = llvm.fpext %[[X]] : f32 to f64 // CHECK: %[[CONVERTY:.*]] = llvm.fpext %[[Y]] : f32 to f64 // CHECK: %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)> -// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1 : i32] : !llvm.struct<(f64, f64)> +// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0] : !llvm.struct<(f64, f64)> +// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1] : !llvm.struct<(f64, f64)> // CHECK: llvm.return %[[STRUCT2]] : !llvm.struct<(f64, f64)> // Test `fir.convert` operation conversion between fir.complex types. @@ -777,13 +777,13 @@ // CHECK-LABEL: func @convert_complex16( // CHECK-SAME: %[[ARG0:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f16, f16)> -// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)> -// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)> +// CHECK: %[[X:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.struct<(f128, f128)> +// CHECK: %[[Y:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)> // CHECK: %[[CONVERTX:.*]] = llvm.fptrunc %[[X]] : f128 to f16 // CHECK: %[[CONVERTY:.*]] = llvm.fptrunc %[[Y]] : f128 to f16 // CHECK: %[[STRUCT0:.*]] = llvm.mlir.undef : !llvm.struct<(f16, f16)> -// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0 : i32] : !llvm.struct<(f16, f16)> -// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1 : i32] : !llvm.struct<(f16, f16)> +// CHECK: %[[STRUCT1:.*]] = llvm.insertvalue %[[CONVERTX]], %[[STRUCT0]][0] : !llvm.struct<(f16, f16)> +// CHECK: %[[STRUCT2:.*]] = llvm.insertvalue %[[CONVERTY]], %[[STRUCT1]][1] : !llvm.struct<(f16, f16)> // CHECK: llvm.return %[[STRUCT2]] : !llvm.struct<(f16, f16)> // ----- @@ -800,8 +800,8 @@ // CHECK-DAG: [[rp:%.*]] = llvm.mlir.constant(1.400000e+00 : f32) : f32 // CHECK-DAG: [[ip:%.*]] = llvm.mlir.constant(2.300000e+00 : f32) : f32 // CHECK: [[undef:%.*]] = llvm.mlir.undef : !llvm.struct<(f32, f32)> -// CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0 : i32] : !llvm.struct<(f32, f32)> -// CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1 : i32] : !llvm.struct<(f32, f32)> +// CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0] : !llvm.struct<(f32, f32)> +// CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1] : !llvm.struct<(f32, f32)> // CHECK: return [[full]] : !llvm.struct<(f32, f32)> func.func @test_constc8() -> !fir.complex<8> { @@ -814,8 +814,8 @@ // CHECK-DAG: [[rp:%.*]] = llvm.mlir.constant(1.800000e+00 : f64) : f64 // CHECK-DAG: [[ip:%.*]] = llvm.mlir.constant(2.300000e+00 : f64) : f64 // CHECK: [[undef:%.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)> -// CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0 : i32] : !llvm.struct<(f64, f64)> -// CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1 : i32] : !llvm.struct<(f64, f64)> +// CHECK: [[withr:%.*]] = llvm.insertvalue [[rp]], [[undef]][0] : !llvm.struct<(f64, f64)> +// CHECK: [[full:%.*]] = llvm.insertvalue [[ip]], [[withr]][1] : !llvm.struct<(f64, f64)> // CHECK: return [[full]] : !llvm.struct<(f64, f64)> // ----- @@ -1505,22 +1505,22 @@ // CHECK: %[[ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i32) : i32 // CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32 // CHECK: %[[I64_ELEM_SIZE:.*]] = llvm.sext %[[ELEM_SIZE]] : i32 to i64 -// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[I64_ELEM_SIZE]], %[[DESC]][1 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[I64_ELEM_SIZE]], %[[DESC]][1] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[CFI_VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32 -// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[DESC0]][2 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[DESC0]][2] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[RANK:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[RANK_I8]], %[[DESC1]][3 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[RANK_I8]], %[[DESC1]][3] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 -// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[DESC2]][4 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[DESC2]][4] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 -// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[DESC3]][5 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[DESC3]][5] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 -// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[DESC4]][6 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[DESC4]][6] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: %[[ADDR:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr> to !llvm.ptr> -// CHECK: %[[DESC6:.*]] = llvm.insertvalue %[[ADDR]], %[[DESC5]][0 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %[[DESC6:.*]] = llvm.insertvalue %[[ADDR]], %[[DESC5]][0] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // CHECK: llvm.store %[[DESC6]], %[[ALLOCA]] : !llvm.ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>> // Check `fir.embox` in a `fir.global`. Descriptors created by `fir.embox` @@ -1551,7 +1551,7 @@ // CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[CFI_ATTR_POINTER:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_POINTER]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // Check `fir.embox` conversion of an ALLOCATABLE entity. Make sure that the // attribute in the descriptor is set to 2 (value of CFI_attribute_allocatable @@ -1565,7 +1565,7 @@ // CHECK-LABEL: llvm.func @embox_allocatable // CHECK: %[[CFI_ATTR_ALLOCATABLE:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_ALLOCATABLE]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // Check `fir.embox` conversion of a type code. @@ -1577,7 +1577,7 @@ // CHECK-LABEL: llvm.func @embox_typecode0 // CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(10 : i32) : i32 // CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> func.func @embox_typecode1(%arg0: !fir.ref) { %0 = fir.embox %arg0 : (!fir.ref) -> !fir.box> @@ -1587,7 +1587,7 @@ // CHECK-LABEL: llvm.func @embox_typecode1 // CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(27 : i32) : i32 // CHECK: %[[TYPE_CODE_F32_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> func.func @embox_typecode2(%arg0: !fir.ref) { %0 = fir.embox %arg0 : (!fir.ref) -> !fir.box> @@ -1597,7 +1597,7 @@ // CHECK-LABEL: llvm.func @embox_typecode2 // CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(31 : i32) : i32 // CHECK: %[[TYPE_CODE_F128_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> func.func @embox_typecode3(%arg0: !fir.ref>) { %0 = fir.embox %arg0 : (!fir.ref>) -> !fir.box>> @@ -1607,7 +1607,7 @@ // CHECK-LABEL: llvm.func @embox_typecode3 // CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(34 : i32) : i32 // CHECK: %[[TYPE_CODE_CPLX4_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> func.func @embox_typecode4(%arg0: !fir.ref>) { %0 = fir.embox %arg0 : (!fir.ref>) -> !fir.box>> @@ -1617,7 +1617,7 @@ // CHECK-LABEL: llvm.func @embox_typecode4 // CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(39 : i32) : i32 // CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> // ----- @@ -1639,13 +1639,13 @@ // CHECK-LABEL: llvm.func @embox1 // CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(42 : i32) : i32 // CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> +// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> // CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 -// CHECK: %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %17[6 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> +// CHECK: %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %17[6] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> // CHECK: %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr // CHECK: %[[TDESC_CAST:.*]] = llvm.bitcast %21 : !llvm.ptr to !llvm.ptr -// CHECK: %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> +// CHECK: %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr, array<1 x i{{.*}}>)> // ----- @@ -1727,20 +1727,20 @@ // CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(4 : i32) : i32 // CHECK: %[[TYPE:.*]] = llvm.mlir.constant(9 : i32) : i32 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 -// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32 -// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE]] : i32 to i8 -// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 -// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 -// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 @@ -1752,15 +1752,15 @@ // CHECK: %[[EXTENT2:.*]] = llvm.sdiv %[[EXTENT1]], %[[C0]] : i64 // CHECK: %[[EXTENT_CMP:.*]] = llvm.icmp "sgt" %[[EXTENT2]], %[[ZERO]] : i64 // CHECK: %[[EXTENT:.*]] = llvm.select %[[EXTENT_CMP]], %[[EXTENT2]], %[[ZERO]] : i1, i64 -// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7 : i32, 0 : i32, 0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> -// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7 : i32, 0 : i32, 1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[STRIDE:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64 -// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[PREV_DIM:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64 // CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[C0]] : i64 // CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARG0]][%[[PTR_OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: %[[ADDR_BITCAST:.*]] = llvm.bitcast %[[BASE_PTR]] : !llvm.ptr to !llvm.ptr -// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX9]][0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX9]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>> // Check adjustment of element scaling factor. @@ -1775,7 +1775,7 @@ // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(10 : i32) : i32 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 -// CHECK: %{{.*}} = llvm.insertvalue %[[ELEM_LEN_I64]], %{{.*}}[1 : i32] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %{{.*}} = llvm.insertvalue %[[ELEM_LEN_I64]], %{{.*}}[1] : !llvm.struct<(ptr>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[PTR_OFFSET:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 // CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[PTR_OFFSET]], %[[C0]] : i64 @@ -1826,20 +1826,20 @@ // CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(8 : i32) : i32 // CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(28 : i32) : i32 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 -// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32 -// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[RANK:.*]] = llvm.mlir.constant(2 : i32) : i32 // CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[TYPE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 -// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 -// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 -// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 @@ -1851,10 +1851,10 @@ // CHECK: %[[EXTENT2:.*]] = llvm.sdiv %[[EXTENT1]], %[[C1]] : i64 // CHECK: %[[EXTENT_CMP:.*]] = llvm.icmp "sgt" %[[EXTENT2]], %[[ZERO]] : i64 // CHECK: %[[EXTENT:.*]] = llvm.select %[[EXTENT_CMP]], %[[EXTENT2]], %[[ZERO]] : i1, i64 -// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7 : i32, 0 : i32, 0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> -// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7 : i32, 0 : i32, 1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXTENT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[STRIDE:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C1]] : i64 -// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[PREV_DIM:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[N1]] : i64 // CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ONE]], %[[N1]] : i64 // CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C4]], %[[SH2]] : i64 @@ -1865,13 +1865,13 @@ // CHECK: %[[EXT_SDIV:.*]] = llvm.sdiv %[[EXT_ADD]], %[[C1]] : i64 // CHECK: %[[EXT_ICMP:.*]] = llvm.icmp "sgt" %[[EXT_SDIV]], %[[ZERO]] : i64 // CHECK: %[[EXT_SELECT:.*]] = llvm.select %[[EXT_ICMP]], %[[EXT_SDIV]], %[[ZERO]] : i1, i64 -// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ONE]], %[[BOX9]][7 : i32, 1 : i32, 0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> -// CHECK: %[[BOX11:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX10]][7 : i32, 1 : i32, 1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ONE]], %[[BOX9]][7, 1, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX11:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX10]][7, 1, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[STRIDE_MUL:.*]] = llvm.mul %[[PREV_DIM]], %[[C1]] : i64 -// CHECK: %[[BOX12:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX11]][7 : i32, 1 : i32, 2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX12:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX11]][7, 1, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[ARR]][%[[PTR_OFFSET0]]] : (!llvm.ptr, i64) -> !llvm.ptr // CHECK: %[[ADDR_BITCAST:.*]] = llvm.bitcast %[[BASE_PTR]] : !llvm.ptr to !llvm.ptr -// CHECK: %[[BOX13:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX12]][0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> +// CHECK: %[[BOX13:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX12]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)> // CHECK: llvm.store %[[BOX13]], %[[ALLOCA]] : !llvm.ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>> // Conversion with a subcomponent. @@ -1905,20 +1905,20 @@ // CHECK: %[[ELEM_LEN:.*]] = llvm.mlir.constant(4 : i32) : i32 // CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 -// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32 -// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX2:.*]] = llvm.insertvalue %[[VERSION]], %[[BOX1]][2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[BOX2]][3] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8 -// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[BOX3]][4 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX4:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[BOX3]][4] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8 -// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX5:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[BOX4]][5] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8 -// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: %[[ELEM_LEN_I64:.*]] = llvm.sext %[[ELEM_LEN]] : i32 to i64 @@ -1931,13 +1931,13 @@ // CHECK: %[[EXT_SDIV:.*]] = llvm.sdiv %[[EXT_ADD]], %[[C2]] : i64 // CHECK: %[[EXT_ICMP:.*]] = llvm.icmp "sgt" %[[EXT_SDIV]], %[[ZERO]] : i64 // CHECK: %[[EXT_SELECT:.*]] = llvm.select %[[EXT_ICMP]], %[[EXT_SDIV]], %[[ZERO]] : i1, i64 -// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7 : i32, 0 : i32, 0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> -// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX7]][7 : i32, 0 : i32, 1 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX7:.*]] = llvm.insertvalue %[[ONE]], %[[BOX6]][7, 0, 0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX8:.*]] = llvm.insertvalue %[[EXT_SELECT]], %[[BOX7]][7, 0, 1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[STRIDE_MUL:.*]] = llvm.mul %[[PTRTOINT_DTYPE_SIZE]], %[[C2]] : i64 -// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX8]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX9:.*]] = llvm.insertvalue %[[STRIDE_MUL]], %[[BOX8]][7, 0, 2] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: %[[BASE_PTR:.*]] = llvm.getelementptr %[[X]][%[[ZERO]], %[[ADJUSTED_OFFSET]], 0] : (!llvm.ptr>>, i64, i64) -> !llvm.ptr // CHECK: %[[ADDR_BITCAST:.*]] = llvm.bitcast %[[BASE_PTR]] : !llvm.ptr to !llvm.ptr -// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX9]][0 : i32] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> +// CHECK: %[[BOX10:.*]] = llvm.insertvalue %[[ADDR_BITCAST]], %[[BOX9]][0] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)> // CHECK: llvm.store %[[BOX10]], %[[ALLOCA]] : !llvm.ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>> // CHECK: llvm.call @_QPtest_dt_callee(%1) : (!llvm.ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>) -> () @@ -2182,20 +2182,20 @@ //CHECK: %[[ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i32) : i32 //CHECK: %[[FLOAT_TYPE:.*]] = llvm.mlir.constant(27 : i32) : i32 //CHECK: %[[ELEM_SIZE_I64:.*]] = llvm.sext %[[ELEM_SIZE]] : i32 to i64 -//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE_I64]], %[[RBOX]][1 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE_I64]], %[[RBOX]][1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[CFI_VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32 -//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[RBOX_TMP1]][2 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[RBOX_TMP1]][2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 //CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[FLOAT_TYPE_I8:.*]] = llvm.trunc %[[FLOAT_TYPE]] : i32 to i8 -//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[FLOAT_TYPE_I8]], %[[RBOX_TMP3]][4 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[FLOAT_TYPE_I8]], %[[RBOX_TMP3]][4] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[OTHER_ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32 //CHECK: %[[OTHER_ATTR_I8:.*]] = llvm.trunc %[[OTHER_ATTR]] : i32 to i8 -//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %[[OTHER_ATTR_I8]], %[[RBOX_TMP4]][5 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %[[OTHER_ATTR_I8]], %[[RBOX_TMP4]][5] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 //CHECK: %[[ADDENDUM_I8:.*]] = llvm.trunc %[[ADDENDUM]] : i32 to i8 -//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[ADDENDUM_I8]], %[[RBOX_TMP5]][6 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[ADDENDUM_I8]], %[[RBOX_TMP5]][6] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[DIM1:.*]] = llvm.mlir.constant(0 : i64) : i64 //CHECK: %[[DIM1_STRIDE_REF:.*]] = llvm.getelementptr %[[ARG0]][0, 7, %[[DIM1]], 2] : (!llvm.ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)>>, i64) -> !llvm.ptr //CHECK: %[[DIM1_STRIDE:.*]] = llvm.load %[[DIM1_STRIDE_REF]] : !llvm.ptr @@ -2219,11 +2219,11 @@ //CHECK: %[[RESULT_NELEMS:.*]] = llvm.select %[[RESULT_IF_NON_ZERO]], %[[RESULT_NELEMS_TMP]], %[[ZERO_ELEMS]] : i1, i64 //CHECK: %[[RESULT_STRIDE:.*]] = llvm.mul %[[THREE]], %[[DIM2_STRIDE]] : i64 //CHECK: %[[RESULT_LB:.*]] = llvm.mlir.constant(1 : i64) : i64 -//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7 : i32, 0 : i32, 0 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7 : i32, 0 : i32, 1 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_STRIDE]], %[[RBOX_TMP7_2]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7, 0, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7, 0, 1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_STRIDE]], %[[RBOX_TMP7_2]][7, 0, 2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[RESULT_PTR_F32:.*]] = llvm.bitcast %[[RESULT_PTR_I8]] : !llvm.ptr to !llvm.ptr -//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR_F32]], %[[RBOX_TMP7_3]][0 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR_F32]], %[[RBOX_TMP7_3]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: llvm.store %[[RESULT_BOX]], %[[RESULT_BOX_REF]] : !llvm.ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>> //CHECK: llvm.call @bar1(%[[RESULT_BOX_REF]]) : (!llvm.ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>) -> () @@ -2253,17 +2253,17 @@ //CHECK: %[[COMPONENT_OFFSET_1:.*]] = llvm.mlir.constant(1 : i64) : i64 //CHECK: %[[ELEM_SIZE:.*]] = llvm.mlir.constant(7 : i64) : i64 //CHECK: %[[TYPE_CHAR:.*]] = llvm.mlir.constant(40 : i32) : i32 -//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE]], %{{.*}}[1 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP1]][2 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP1:.*]] = llvm.insertvalue %[[ELEM_SIZE]], %{{.*}}[1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP2:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP1]][2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[RANK:.*]] = llvm.mlir.constant(1 : i32) : i32 //CHECK: %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8 -//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP3:.*]] = llvm.insertvalue %[[RANK_I8]], %[[RBOX_TMP2]][3] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[TYPE_CHAR_I8:.*]] = llvm.trunc %[[TYPE_CHAR]] : i32 to i8 -//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[TYPE_CHAR_I8]], %[[RBOX_TMP3]][4 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP4]][5 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP4:.*]] = llvm.insertvalue %[[TYPE_CHAR_I8]], %[[RBOX_TMP3]][4] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP5:.*]] = llvm.insertvalue %{{.*}}, %[[RBOX_TMP4]][5] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32 //CHECK: %[[ADDENDUM_I8:.*]] = llvm.trunc %[[ADDENDUM]] : i32 to i8 -//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[ADDENDUM_I8]], %[[RBOX_TMP5]][6 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP6:.*]] = llvm.insertvalue %[[ADDENDUM_I8]], %[[RBOX_TMP5]][6] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[DIM1:.*]] = llvm.mlir.constant(0 : i64) : i64 //CHECK: %[[SRC_STRIDE_PTR:.*]] = llvm.getelementptr %[[ARG0]][0, 7, %[[DIM1]], 2] : (!llvm.ptr)>>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>>, i64) -> !llvm.ptr //CHECK: %[[SRC_STRIDE:.*]] = llvm.load %[[SRC_STRIDE_PTR]] : !llvm.ptr @@ -2284,11 +2284,11 @@ //CHECK: %[[RESULT_NELEMS:.*]] = llvm.select %[[RESULT_TMP_PRED]], %[[RESULT_TMP3]], %[[ZERO_6]] : i1, i64 //CHECK: %[[RESULT_TOTAL_STRIDE:.*]] = llvm.mul %[[RESULT_STRIDE]], %[[SRC_STRIDE]] : i64 //CHECK: %[[RESULT_LB:.*]] = llvm.mlir.constant(1 : i64) : i64 -//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7 : i32, 0 : i32, 0 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7 : i32, 0 : i32, 1 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> -//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_TOTAL_STRIDE]], %[[RBOX_TMP7_2]][7 : i32, 0 : i32, 2 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_1:.*]] = llvm.insertvalue %[[RESULT_LB]], %[[RBOX_TMP6]][7, 0, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_2:.*]] = llvm.insertvalue %[[RESULT_NELEMS]], %[[RBOX_TMP7_1]][7, 0, 1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RBOX_TMP7_3:.*]] = llvm.insertvalue %[[RESULT_TOTAL_STRIDE]], %[[RBOX_TMP7_2]][7, 0, 2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: %[[RESULT_PTR_CAST:.*]] = llvm.bitcast %[[RESULT_PTR_I8]] : !llvm.ptr to !llvm.ptr -//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR_CAST]], %[[RBOX_TMP7_3]][0 : i32] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> +//CHECK: %[[RESULT_BOX:.*]] = llvm.insertvalue %[[RESULT_PTR_CAST]], %[[RBOX_TMP7_3]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)> //CHECK: llvm.store %[[RESULT_BOX]], %[[RESULT_BOX_REF]] : !llvm.ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>> //CHECK: llvm.call @bar(%[[RESULT_BOX_REF]]) : (!llvm.ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>) -> () //CHECK: llvm.return diff --git a/flang/test/Fir/global-initialization.fir b/flang/test/Fir/global-initialization.fir --- a/flang/test/Fir/global-initialization.fir +++ b/flang/test/Fir/global-initialization.fir @@ -63,8 +63,8 @@ // CHECK: [[STRUCT:%.*]] = llvm.mlir.undef : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> // CHECK: [[ARR1:%.*]] = llvm.mlir.undef : !llvm.array<500 x i32> // CHECK: [[DENSE1:%.*]] = llvm.mlir.constant(dense<2> : vector<500xi32>) : !llvm.array<500 x i32> -// CHECK: [[STRUCT1:%.*]] = llvm.insertvalue [[DENSE1]], [[STRUCT]][0 : i32] : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> +// CHECK: [[STRUCT1:%.*]] = llvm.insertvalue [[DENSE1]], [[STRUCT]][0] : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> // CHECK: [[DENSE2:%.*]] = llvm.mlir.constant(dense<52> : vector<500xi32>) : !llvm.array<500 x i32> -// CHECK: [[STRUCT2:%.*]] = llvm.insertvalue [[DENSE2]], [[STRUCT1]][1 : i32] : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> +// CHECK: [[STRUCT2:%.*]] = llvm.insertvalue [[DENSE2]], [[STRUCT1]][1] : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> // CHECK: llvm.return [[STRUCT2]] : !llvm.struct<"_QTt", (array<500 x i32>, array<500 x i32>)> // CHECK: } diff --git a/mlir/docs/SPIRVToLLVMDialectConversion.md b/mlir/docs/SPIRVToLLVMDialectConversion.md --- a/mlir/docs/SPIRVToLLVMDialectConversion.md +++ b/mlir/docs/SPIRVToLLVMDialectConversion.md @@ -396,7 +396,7 @@ llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> { %0 = llvm.mlir.undef : !llvm.struct<(i32)> %1 = llvm.mlir.constant(31 : i32) : i32 - %ret = llvm.insertvalue %1, %0[0 : i32] : !llvm.struct<(i32)> + %ret = llvm.insertvalue %1, %0[0] : !llvm.struct<(i32)> llvm.return %ret : !llvm.struct<(i32)> } ``` diff --git a/mlir/docs/Tutorials/Toy/Ch-6.md b/mlir/docs/Tutorials/Toy/Ch-6.md --- a/mlir/docs/Tutorials/Toy/Ch-6.md +++ b/mlir/docs/Tutorials/Toy/Ch-6.md @@ -141,7 +141,7 @@ ... ^bb16: - %221 = llvm.extractvalue %25[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> + %221 = llvm.extractvalue %25[0] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %222 = llvm.mlir.constant(0 : index) : i64 %223 = llvm.mlir.constant(2 : index) : i64 %224 = llvm.mul %214, %223 : i64 @@ -158,13 +158,13 @@ ... ^bb18: - %235 = llvm.extractvalue %65[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> + %235 = llvm.extractvalue %65[0] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %236 = llvm.bitcast %235 : !llvm<"double*"> to !llvm<"i8*"> llvm.call @free(%236) : (!llvm<"i8*">) -> () - %237 = llvm.extractvalue %45[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> + %237 = llvm.extractvalue %45[0] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %238 = llvm.bitcast %237 : !llvm<"double*"> to !llvm<"i8*"> llvm.call @free(%238) : (!llvm<"i8*">) -> () - %239 = llvm.extractvalue %25[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> + %239 = llvm.extractvalue %25[0] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %240 = llvm.bitcast %239 : !llvm<"double*"> to !llvm<"i8*"> llvm.call @free(%240) : (!llvm<"i8*">) -> () llvm.return diff --git a/mlir/include/mlir/Conversion/LLVMCommon/VectorPattern.h b/mlir/include/mlir/Conversion/LLVMCommon/VectorPattern.h --- a/mlir/include/mlir/Conversion/LLVMCommon/VectorPattern.h +++ b/mlir/include/mlir/Conversion/LLVMCommon/VectorPattern.h @@ -47,7 +47,7 @@ // Iterate of linear index, convert to coords space and insert splatted 1-D // vector in each position. void nDVectorIterate(const NDVectorTypeInfo &info, OpBuilder &builder, - function_ref fun); + function_ref)> fun); LogicalResult handleMultidimensionalVectors( Operation *op, ValueRange operands, LLVMTypeConverter &typeConverter, diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h b/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h @@ -276,6 +276,24 @@ SmallVector options; }; +/// Convert an array of integer attributes to a vector of integers that can be +/// used as indices in LLVM operations. +template +SmallVector convertArrayToIndices(ArrayRef attrs) { + SmallVector indices; + indices.reserve(attrs.size()); + for (Attribute attr : attrs) + indices.push_back(attr.cast().getInt()); + return indices; +} + +/// Convert an `ArrayAttr` of integer attributes to a vector of integers that +/// can be used as indices in LLVM operations. +template +SmallVector convertArrayToIndices(ArrayAttr attrs) { + return convertArrayToIndices(attrs.getValue()); +} + } // namespace LLVM } // namespace mlir diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td @@ -704,6 +704,10 @@ let hasCustomAssemblyFormat = 1; } +//===----------------------------------------------------------------------===// +// ExtractElementOp +//===----------------------------------------------------------------------===// + def LLVM_ExtractElementOp : LLVM_Op<"extractelement", [NoSideEffect]> { let arguments = (ins LLVM_AnyVector:$vector, AnyInteger:$position); let results = (outs LLVM_Type:$res); @@ -716,20 +720,42 @@ let hasCustomAssemblyFormat = 1; let hasVerifier = 1; } + +//===----------------------------------------------------------------------===// +// ExtractValueOp +//===----------------------------------------------------------------------===// + def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [NoSideEffect]> { - let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position); + let summary = "Extract a value from an LLVM struct."; + + let arguments = (ins LLVM_AnyAggregate:$container, DenseI64ArrayAttr:$position); let results = (outs LLVM_Type:$res); - string llvmBuilder = [{ - $res = builder.CreateExtractValue($container, extractPosition($position)); + + let builders = [ + OpBuilder<(ins "Value":$container, "ArrayRef":$position)> + ]; + + let assemblyFormat = [{ + $container `` $position attr-dict `:` type($container) + custom(type($res), ref(type($container)), + ref($position)) }]; - let builders = [LLVM_OneResultOpBuilder]; - let hasCustomAssemblyFormat = 1; + let hasFolder = 1; let hasVerifier = 1; + + string llvmBuilder = [{ + $res = builder.CreateExtractValue($container, extractPosition($position)); + }]; } + +//===----------------------------------------------------------------------===// +// InsertElementOp +//===----------------------------------------------------------------------===// + def LLVM_InsertElementOp : LLVM_Op<"insertelement", [NoSideEffect]> { let arguments = (ins LLVM_AnyVector:$vector, LLVM_PrimitiveType:$value, - AnyInteger:$position); + AnyInteger:$position); let results = (outs LLVM_AnyVector:$res); string llvmBuilder = [{ $res = builder.CreateInsertElement($vector, $value, $position); @@ -738,27 +764,44 @@ let hasCustomAssemblyFormat = 1; let hasVerifier = 1; } -def LLVM_InsertValueOp : LLVM_Op<"insertvalue", [NoSideEffect]> { + +//===----------------------------------------------------------------------===// +// InsertValueOp +//===----------------------------------------------------------------------===// + +def LLVM_InsertValueOp : LLVM_Op< + "insertvalue", [NoSideEffect, AllTypesMatch<["container", "res"]>]> { + let summary = "Insert a value into an LLVM struct."; + let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value, - ArrayAttr:$position); + DenseI64ArrayAttr:$position); let results = (outs LLVM_AnyAggregate:$res); + + let builders = [ + OpBuilder<(ins "Value":$container, "Value":$value, + "ArrayRef":$position)> + ]; + + let assemblyFormat = [{ + $value `,` $container `` $position attr-dict `:` type($container) + custom(type($value), ref(type($container)), + ref($position)) + }]; + + let hasVerifier = 1; + string llvmBuilder = [{ $res = builder.CreateInsertValue($container, $value, extractPosition($position)); }]; - let builders = [ - OpBuilder<(ins "Value":$container, "Value":$value, "ArrayAttr":$position), - [{ - build($_builder, $_state, container.getType(), container, value, position); - }]>]; - let hasCustomAssemblyFormat = 1; - let hasVerifier = 1; } + def LLVM_ShuffleVectorOp : LLVM_Op<"shufflevector", [NoSideEffect]> { let arguments = (ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2, ArrayAttr:$mask); let results = (outs LLVM_AnyVector:$res); string llvmBuilder = [{ - SmallVector position = extractPosition($mask); + SmallVector position = + LLVM::convertArrayToIndices($mask); SmallVector mask(position.begin(), position.end()); $res = builder.CreateShuffleVector($v1, $v2, mask); }]; diff --git a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp --- a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp +++ b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp @@ -517,11 +517,8 @@ // Extract individual results from the structure and return them as list. results.reserve(numResults); for (unsigned i = 0; i < numResults; ++i) { - auto type = - this->typeConverter->convertType(callOp.getResult(i).getType()); results.push_back(rewriter.create( - callOp.getLoc(), type, newOp->getResult(0), - rewriter.getI64ArrayAttr(i))); + callOp.getLoc(), newOp->getResult(0), i)); } } @@ -638,9 +635,8 @@ Value packed = rewriter.create(loc, packedType); for (unsigned i = 0; i < numArguments; ++i) { - packed = rewriter.create( - loc, packedType, packed, updatedOperands[i], - rewriter.getI64ArrayAttr(i)); + packed = rewriter.create(loc, packed, + updatedOperands[i], i); } rewriter.replaceOpWithNewOp(op, TypeRange(), packed, op->getAttrs()); diff --git a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp --- a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp +++ b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp @@ -74,9 +74,9 @@ /// %mask_and_clamp = llvm.sub %width, %one : i32 /// %shfl = nvvm.shfl.sync.bfly %active_mask, %value, %offset, /// %mask_and_clamp : !llvm<"{ float, i1 }"> - /// %shfl_value = llvm.extractvalue %shfl[0 : index] : + /// %shfl_value = llvm.extractvalue %shfl[0] : /// !llvm<"{ float, i1 }"> - /// %shfl_pred = llvm.extractvalue %shfl[1 : index] : + /// %shfl_pred = llvm.extractvalue %shfl[1] : /// !llvm<"{ float, i1 }"> LogicalResult matchAndRewrite(gpu::ShuffleOp op, OpAdaptor adaptor, @@ -111,10 +111,8 @@ Value shfl = rewriter.create( loc, resultTy, activeMask, adaptor.value(), adaptor.offset(), maskAndClamp, convertShflKind(op.mode()), returnValueAndIsValidAttr); - Value shflValue = rewriter.create( - loc, valueTy, shfl, rewriter.getIndexArrayAttr(0)); - Value isActiveSrcLane = rewriter.create( - loc, predTy, shfl, rewriter.getIndexArrayAttr(1)); + Value shflValue = rewriter.create(loc, shfl, 0); + Value isActiveSrcLane = rewriter.create(loc, shfl, 1); rewriter.replaceOp(op, {shflValue, isActiveSrcLane}); return success(); diff --git a/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp b/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp --- a/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp +++ b/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp @@ -159,9 +159,8 @@ auto matrixType = adaptor.src().getType().cast(); for (unsigned i = 0, e = matrixType.getBody().size(); i < e; ++i) { - Value toUse = rewriter.create( - loc, matrixType.getBody()[i], adaptor.src(), - rewriter.getI32ArrayAttr(i)); + Value toUse = + rewriter.create(loc, adaptor.src(), i); storeOpOperands.push_back(toUse); } @@ -203,8 +202,7 @@ auto unpackOp = [&](Value operand) { auto structType = operand.getType().cast(); for (size_t i = 0, e = structType.getBody().size(); i < e; ++i) { - Value toUse = rewriter.create( - loc, structType.getBody()[i], operand, rewriter.getI32ArrayAttr(i)); + Value toUse = rewriter.create(loc, operand, i); unpackedOps.push_back(toUse); } }; @@ -268,8 +266,8 @@ } Value matrixStruct = rewriter.create(loc, type); for (size_t i : llvm::seq(size_t(0), type.getBody().size())) { - matrixStruct = rewriter.create( - loc, matrixStruct, cst, rewriter.getI32ArrayAttr(i)); + matrixStruct = + rewriter.create(loc, matrixStruct, cst, i); } rewriter.replaceOp(subgroupMmaConstantOp, matrixStruct); return success(); @@ -336,19 +334,14 @@ for (size_t i = 0, e = destType.getBody().size(); i < e; ++i) { SmallVector extractedOperands; for (size_t opIdx = 0; opIdx < numOperands; opIdx++) { - Type elementType = adaptor.getOperands()[opIdx] - .getType() - .cast() - .getBody()[i]; extractedOperands.push_back(rewriter.create( - loc, elementType, adaptor.getOperands()[opIdx], - rewriter.getI32ArrayAttr(i))); + loc, adaptor.getOperands()[opIdx], i)); } Value element = createScalarOp(rewriter, loc, subgroupMmaElementwiseOp.operation(), extractedOperands); - matrixStruct = rewriter.create( - loc, matrixStruct, element, rewriter.getI32ArrayAttr(i)); + matrixStruct = + rewriter.create(loc, matrixStruct, element, i); } rewriter.replaceOp(subgroupMmaElementwiseOp, matrixStruct); return success(); diff --git a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp --- a/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp +++ b/mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp @@ -104,17 +104,15 @@ /// Builds IR extracting the offset from the descriptor. Value MemRefDescriptor::offset(OpBuilder &builder, Location loc) { - return builder.create( - loc, indexType, value, - builder.getI64ArrayAttr(kOffsetPosInMemRefDescriptor)); + return builder.create(loc, value, + kOffsetPosInMemRefDescriptor); } /// Builds IR inserting the offset into the descriptor. void MemRefDescriptor::setOffset(OpBuilder &builder, Location loc, Value offset) { - value = builder.create( - loc, structType, value, offset, - builder.getI64ArrayAttr(kOffsetPosInMemRefDescriptor)); + value = builder.create(loc, value, offset, + kOffsetPosInMemRefDescriptor); } /// Builds IR inserting the offset into the descriptor. @@ -127,8 +125,8 @@ /// Builds IR extracting the pos-th size from the descriptor. Value MemRefDescriptor::size(OpBuilder &builder, Location loc, unsigned pos) { return builder.create( - loc, indexType, value, - builder.getI64ArrayAttr({kSizePosInMemRefDescriptor, pos})); + loc, value, + llvm::makeArrayRef({kSizePosInMemRefDescriptor, pos})); } Value MemRefDescriptor::size(OpBuilder &builder, Location loc, Value pos, @@ -140,8 +138,7 @@ // Copy size values to stack-allocated memory. auto one = createIndexAttrConstant(builder, loc, indexType, 1); auto sizes = builder.create( - loc, arrayTy, value, - builder.getI64ArrayAttr({kSizePosInMemRefDescriptor})); + loc, value, llvm::makeArrayRef({kSizePosInMemRefDescriptor})); auto sizesPtr = builder.create(loc, arrayPtrTy, one, /*alignment=*/0); builder.create(loc, sizes, sizesPtr); @@ -156,8 +153,8 @@ void MemRefDescriptor::setSize(OpBuilder &builder, Location loc, unsigned pos, Value size) { value = builder.create( - loc, structType, value, size, - builder.getI64ArrayAttr({kSizePosInMemRefDescriptor, pos})); + loc, value, size, + llvm::makeArrayRef({kSizePosInMemRefDescriptor, pos})); } void MemRefDescriptor::setConstantSize(OpBuilder &builder, Location loc, @@ -169,16 +166,16 @@ /// Builds IR extracting the pos-th stride from the descriptor. Value MemRefDescriptor::stride(OpBuilder &builder, Location loc, unsigned pos) { return builder.create( - loc, indexType, value, - builder.getI64ArrayAttr({kStridePosInMemRefDescriptor, pos})); + loc, value, + llvm::makeArrayRef({kStridePosInMemRefDescriptor, pos})); } /// Builds IR inserting the pos-th stride into the descriptor void MemRefDescriptor::setStride(OpBuilder &builder, Location loc, unsigned pos, Value stride) { value = builder.create( - loc, structType, value, stride, - builder.getI64ArrayAttr({kStridePosInMemRefDescriptor, pos})); + loc, value, stride, + llvm::makeArrayRef({kStridePosInMemRefDescriptor, pos})); } void MemRefDescriptor::setConstantStride(OpBuilder &builder, Location loc, diff --git a/mlir/lib/Conversion/LLVMCommon/Pattern.cpp b/mlir/lib/Conversion/LLVMCommon/Pattern.cpp --- a/mlir/lib/Conversion/LLVMCommon/Pattern.cpp +++ b/mlir/lib/Conversion/LLVMCommon/Pattern.cpp @@ -334,9 +334,8 @@ SmallVector results; results.reserve(numResults); for (unsigned i = 0; i < numResults; ++i) { - auto type = typeConverter.convertType(op->getResult(i).getType()); results.push_back(rewriter.create( - op->getLoc(), type, newOp->getResult(0), rewriter.getI64ArrayAttr(i))); + op->getLoc(), newOp->getResult(0), i)); } rewriter.replaceOp(op, results); return success(); diff --git a/mlir/lib/Conversion/LLVMCommon/StructBuilder.cpp b/mlir/lib/Conversion/LLVMCommon/StructBuilder.cpp --- a/mlir/lib/Conversion/LLVMCommon/StructBuilder.cpp +++ b/mlir/lib/Conversion/LLVMCommon/StructBuilder.cpp @@ -24,13 +24,10 @@ Value StructBuilder::extractPtr(OpBuilder &builder, Location loc, unsigned pos) { - Type type = structType.cast().getBody()[pos]; - return builder.create(loc, type, value, - builder.getI64ArrayAttr(pos)); + return builder.create(loc, value, pos); } void StructBuilder::setPtr(OpBuilder &builder, Location loc, unsigned pos, Value ptr) { - value = builder.create(loc, structType, value, ptr, - builder.getI64ArrayAttr(pos)); + value = builder.create(loc, value, ptr, pos); } diff --git a/mlir/lib/Conversion/LLVMCommon/VectorPattern.cpp b/mlir/lib/Conversion/LLVMCommon/VectorPattern.cpp --- a/mlir/lib/Conversion/LLVMCommon/VectorPattern.cpp +++ b/mlir/lib/Conversion/LLVMCommon/VectorPattern.cpp @@ -63,7 +63,7 @@ // vector in each position. void LLVM::detail::nDVectorIterate(const LLVM::detail::NDVectorTypeInfo &info, OpBuilder &builder, - function_ref fun) { + function_ref)> fun) { unsigned ub = 1; for (auto s : info.arraySizes) ub *= s; @@ -73,8 +73,7 @@ if (coords.empty()) break; assert(coords.size() == info.arraySizes.size()); - auto position = builder.getI64ArrayAttr(coords); - fun(position); + fun(coords); } } @@ -97,18 +96,16 @@ auto resultNDVectoryTy = resultTypeInfo.llvmNDVectorTy; auto loc = op->getLoc(); Value desc = rewriter.create(loc, resultNDVectoryTy); - nDVectorIterate(resultTypeInfo, rewriter, [&](ArrayAttr position) { + nDVectorIterate(resultTypeInfo, rewriter, [&](ArrayRef position) { // For this unrolled `position` corresponding to the `linearIndex`^th // element, extract operand vectors SmallVector extractedOperands; for (const auto &operand : llvm::enumerate(operands)) { extractedOperands.push_back(rewriter.create( - loc, operand1DVectorTypes[operand.index()], operand.value(), - position)); + loc, operand.value(), position)); } Value newVal = createOperand(result1DVectorTy, extractedOperands); - desc = rewriter.create(loc, resultNDVectoryTy, desc, - newVal, position); + desc = rewriter.create(loc, desc, newVal, position); }); rewriter.replaceOp(op, desc); return success(); diff --git a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp --- a/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp +++ b/mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp @@ -533,10 +533,8 @@ loc, pairType, dataPtr, loopArgument, result, successOrdering, failureOrdering); // Extract the %new_loaded and %ok values from the pair. - Value newLoaded = rewriter.create( - loc, valueType, cmpxchg, rewriter.getI64ArrayAttr({0})); - Value ok = rewriter.create( - loc, boolType, cmpxchg, rewriter.getI64ArrayAttr({1})); + Value newLoaded = rewriter.create(loc, cmpxchg, 0); + Value ok = rewriter.create(loc, cmpxchg, 1); // Conditionally branch to the end or back to the loop depending on %ok. rewriter.create(loc, ok, endBlock, ArrayRef(), diff --git a/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp b/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp --- a/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp +++ b/mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp @@ -85,9 +85,8 @@ if (arrayType.getElementType() == f16x2Ty || arrayType.getElementType() == f32x1Ty) { for (unsigned i = 0; i < structType.getBody().size(); i++) { - Value el = rewriter.create( - loc, structType.getBody()[i], intrinsicResult, - rewriter.getI64ArrayAttr(i)); + Value el = + rewriter.create(loc, intrinsicResult, i); el = rewriter.createOrFold( loc, arrayType.getElementType(), el); elements.push_back(el); @@ -105,12 +104,10 @@ for (unsigned i = 0, e = structType.getBody().size() / 2; i < e; i++) { Value vec = rewriter.create(loc, arrayType.getElementType()); - Value x1 = rewriter.create( - loc, structType.getBody()[i * 2], intrinsicResult, - rewriter.getI64ArrayAttr(i * 2)); - Value x2 = rewriter.create( - loc, structType.getBody()[i * 2 + 1], intrinsicResult, - rewriter.getI64ArrayAttr(i * 2 + 1)); + Value x1 = + rewriter.create(loc, intrinsicResult, i * 2); + Value x2 = rewriter.create(loc, intrinsicResult, + i * 2 + 1); vec = rewriter.create(loc, vec.getType(), vec, x1, makeConst(0)); vec = rewriter.create(loc, vec.getType(), vec, @@ -122,9 +119,8 @@ // Create the final vectorized result. Value result = rewriter.create(loc, arrayType); for (const auto &el : llvm::enumerate(elements)) { - result = rewriter.create( - loc, arrayType, result, el.value(), - rewriter.getI64ArrayAttr(el.index())); + result = rewriter.create(loc, result, el.value(), + el.index()); } return result; } @@ -152,8 +148,7 @@ auto arrayTy = operand.getType().cast(); for (unsigned i = 0, e = arrayTy.getNumElements(); i < e; ++i) { - Value toUse = rewriter.create( - loc, arrayTy.getElementType(), operand, rewriter.getI64ArrayAttr(i)); + Value toUse = rewriter.create(loc, operand, i); // For 4xi8 vectors, the intrinsic expects these to be provided as i32 // scalar types. @@ -238,15 +233,13 @@ Type finalResultType = typeConverter->convertType(vectorResultType); Value result = rewriter.create(loc, finalResultType); for (int64_t i = 0, e = vectorResultType.getDimSize(0); i < e; i++) { - Value i32Register = num32BitRegs > 1 - ? rewriter.create( - loc, rewriter.getI32Type(), ldMatrixResult, - rewriter.getI64ArrayAttr(i)) - : ldMatrixResult; + Value i32Register = + num32BitRegs > 1 + ? rewriter.create(loc, ldMatrixResult, i) + : ldMatrixResult; Value casted = rewriter.create(loc, innerVectorType, i32Register); - result = rewriter.create( - loc, finalResultType, result, casted, rewriter.getI64ArrayAttr(i)); + result = rewriter.create(loc, result, casted, i); } rewriter.replaceOp(op, result); diff --git a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp --- a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp +++ b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp @@ -575,8 +575,9 @@ op, dstType, adaptor.composite(), index); return success(); } + rewriter.replaceOpWithNewOp( - op, dstType, adaptor.composite(), op.indices()); + op, adaptor.composite(), LLVM::convertArrayToIndices(op.indices())); return success(); } }; @@ -605,8 +606,10 @@ op, dstType, adaptor.composite(), adaptor.object(), index); return success(); } + rewriter.replaceOpWithNewOp( - op, dstType, adaptor.composite(), adaptor.object(), op.indices()); + op, adaptor.composite(), adaptor.object(), + LLVM::convertArrayToIndices(op.indices())); return success(); } }; @@ -689,20 +692,15 @@ loc, llvmI32Type, rewriter.getI32IntegerAttr( static_cast(executionModeAttr.getValue()))); - structValue = rewriter.create( - loc, structType, structValue, executionMode, - ArrayAttr::get(context, - {rewriter.getIntegerAttr(rewriter.getI32Type(), 0)})); + structValue = rewriter.create(loc, structValue, + executionMode, 0); // Insert extra operands if they exist into execution mode info struct. for (unsigned i = 0, e = values.size(); i < e; ++i) { auto attr = values.getValue()[i]; Value entry = rewriter.create(loc, llvmI32Type, attr); structValue = rewriter.create( - loc, structType, structValue, entry, - ArrayAttr::get(context, - {rewriter.getIntegerAttr(rewriter.getI32Type(), 1), - rewriter.getIntegerAttr(rewriter.getI32Type(), i)})); + loc, structValue, entry, llvm::makeArrayRef({1, i})); } rewriter.create(loc, ArrayRef({structValue})); rewriter.eraseOp(op); diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp --- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp +++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp @@ -58,8 +58,7 @@ return rewriter.create(loc, llvmType, val1, val2, constant); } - return rewriter.create(loc, llvmType, val1, val2, - rewriter.getI64ArrayAttr(pos)); + return rewriter.create(loc, val1, val2, pos); } // Helper that picks the proper sequence for extracting. @@ -74,8 +73,7 @@ return rewriter.create(loc, llvmType, val, constant); } - return rewriter.create(loc, llvmType, val, - rewriter.getI64ArrayAttr(pos)); + return rewriter.create(loc, val, pos); } // Helper that returns data layout alignment of a memref. @@ -647,7 +645,6 @@ matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { auto loc = extractOp->getLoc(); - auto vectorType = extractOp.getVectorType(); auto resultType = extractOp.getResult().getType(); auto llvmResultType = typeConverter->convertType(resultType); auto positionArrayAttr = extractOp.getPosition(); @@ -664,23 +661,24 @@ // One-shot extraction of vector from array (only requires extractvalue). if (resultType.isa()) { + SmallVector indices; + for (auto idx : positionArrayAttr.getAsRange()) + indices.push_back(idx.getInt()); Value extracted = rewriter.create( - loc, llvmResultType, adaptor.getVector(), positionArrayAttr); + loc, adaptor.getVector(), indices); rewriter.replaceOp(extractOp, extracted); return success(); } // Potential extraction of 1-D vector from array. - auto *context = extractOp->getContext(); Value extracted = adaptor.getVector(); auto positionAttrs = positionArrayAttr.getValue(); if (positionAttrs.size() > 1) { - auto oneDVectorType = reducedVectorTypeBack(vectorType); - auto nMinusOnePositionAttrs = - ArrayAttr::get(context, positionAttrs.drop_back()); - extracted = rewriter.create( - loc, typeConverter->convertType(oneDVectorType), extracted, - nMinusOnePositionAttrs); + SmallVector nMinusOnePosition; + for (auto idx : positionAttrs.drop_back()) + nMinusOnePosition.push_back(idx.cast().getInt()); + extracted = rewriter.create(loc, extracted, + nMinusOnePosition); } // Remaining extraction of element from 1-D LLVM vector @@ -786,25 +784,22 @@ // One-shot insertion of a vector into an array (only requires insertvalue). if (sourceType.isa()) { Value inserted = rewriter.create( - loc, llvmResultType, adaptor.getDest(), adaptor.getSource(), - positionArrayAttr); + loc, adaptor.getDest(), adaptor.getSource(), + LLVM::convertArrayToIndices(positionArrayAttr)); rewriter.replaceOp(insertOp, inserted); return success(); } // Potential extraction of 1-D vector from array. - auto *context = insertOp->getContext(); Value extracted = adaptor.getDest(); auto positionAttrs = positionArrayAttr.getValue(); auto position = positionAttrs.back().cast(); auto oneDVectorType = destVectorType; if (positionAttrs.size() > 1) { oneDVectorType = reducedVectorTypeBack(destVectorType); - auto nMinusOnePositionAttrs = - ArrayAttr::get(context, positionAttrs.drop_back()); extracted = rewriter.create( - loc, typeConverter->convertType(oneDVectorType), extracted, - nMinusOnePositionAttrs); + loc, extracted, + LLVM::convertArrayToIndices(positionAttrs.drop_back())); } // Insertion of an element into a 1-D LLVM vector. @@ -816,11 +811,9 @@ // Potential insertion of resulting 1-D vector into array. if (positionAttrs.size() > 1) { - auto nMinusOnePositionAttrs = - ArrayAttr::get(context, positionAttrs.drop_back()); inserted = rewriter.create( - loc, llvmResultType, adaptor.getDest(), inserted, - nMinusOnePositionAttrs); + loc, adaptor.getDest(), inserted, + LLVM::convertArrayToIndices(positionAttrs.drop_back())); } rewriter.replaceOp(insertOp, inserted); @@ -1269,9 +1262,8 @@ // Iterate of linear index, convert to coords space and insert splatted 1-D // vector in each position. - nDVectorIterate(vectorTypeInfo, rewriter, [&](ArrayAttr position) { - desc = rewriter.create(loc, llvmNDVectorTy, desc, v, - position); + nDVectorIterate(vectorTypeInfo, rewriter, [&](ArrayRef position) { + desc = rewriter.create(loc, desc, v, position); }); rewriter.replaceOp(splatOp, desc); return success(); diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp @@ -1403,67 +1403,18 @@ } //===----------------------------------------------------------------------===// -// Printing/parsing for LLVM::ExtractValueOp. +// ExtractValueOp //===----------------------------------------------------------------------===// -void ExtractValueOp::print(OpAsmPrinter &p) { - p << ' ' << getContainer() << getPosition(); - p.printOptionalAttrDict((*this)->getAttrs(), {"position"}); - p << " : " << getContainer().getType(); -} - -// Extract the type at `position` in the wrapped LLVM IR aggregate type -// `containerType`. Position is an integer array attribute where each value -// is a zero-based position of the element in the aggregate type. Return the -// resulting type wrapped in MLIR, or nullptr on error. -static Type getInsertExtractValueElementType(OpAsmParser &parser, - Type containerType, - ArrayAttr positionAttr, - SMLoc attributeLoc, - SMLoc typeLoc) { - Type llvmType = containerType; - if (!isCompatibleType(containerType)) - return parser.emitError(typeLoc, "expected LLVM IR Dialect type"), nullptr; - - // Infer the element type from the structure type: iteratively step inside the - // type by taking the element type, indexed by the position attribute for - // structures. Check the position index before accessing, it is supposed to - // be in bounds. - for (Attribute subAttr : positionAttr) { - auto positionElementAttr = subAttr.dyn_cast(); - if (!positionElementAttr) - return parser.emitError(attributeLoc, - "expected an array of integer literals"), - nullptr; - int position = positionElementAttr.getInt(); - if (auto arrayType = llvmType.dyn_cast()) { - if (position < 0 || - static_cast(position) >= arrayType.getNumElements()) - return parser.emitError(attributeLoc, "position out of bounds"), - nullptr; - llvmType = arrayType.getElementType(); - } else if (auto structType = llvmType.dyn_cast()) { - if (position < 0 || - static_cast(position) >= structType.getBody().size()) - return parser.emitError(attributeLoc, "position out of bounds"), - nullptr; - llvmType = structType.getBody()[position]; - } else { - return parser.emitError(typeLoc, "expected LLVM IR structure/array type"), - nullptr; - } - } - return llvmType; -} - -// Extract the type at `position` in the wrapped LLVM IR aggregate type -// `containerType`. Returns null on failure. -static Type getInsertExtractValueElementType(Type containerType, - ArrayAttr positionAttr, - Operation *op) { +/// Extract the type at `position` in the LLVM IR aggregate type +/// `containerType`. Each element of `position` is an index into a nested +/// aggregate type. Return the resulting type or emit an error. +static Type getInsertExtractValueElementType( + function_ref emitError, Type containerType, + ArrayRef position) { Type llvmType = containerType; if (!isCompatibleType(containerType)) { - op->emitError("expected LLVM IR Dialect type, got ") << containerType; + emitError("expected LLVM IR Dialect type, got ") << containerType; return {}; } @@ -1471,62 +1422,39 @@ // type by taking the element type, indexed by the position attribute for // structures. Check the position index before accessing, it is supposed to // be in bounds. - for (Attribute subAttr : positionAttr) { - auto positionElementAttr = subAttr.dyn_cast(); - if (!positionElementAttr) { - op->emitOpError("expected an array of integer literals, got: ") - << subAttr; - return {}; - } - int position = positionElementAttr.getInt(); + for (int64_t idx : position) { if (auto arrayType = llvmType.dyn_cast()) { - if (position < 0 || - static_cast(position) >= arrayType.getNumElements()) { - op->emitOpError("position out of bounds: ") << position; + if (idx < 0 || static_cast(idx) >= arrayType.getNumElements()) { + emitError("position out of bounds: ") << idx; return {}; } llvmType = arrayType.getElementType(); } else if (auto structType = llvmType.dyn_cast()) { - if (position < 0 || - static_cast(position) >= structType.getBody().size()) { - op->emitOpError("position out of bounds") << position; + if (idx < 0 || + static_cast(idx) >= structType.getBody().size()) { + emitError("position out of bounds: ") << idx; return {}; } - llvmType = structType.getBody()[position]; + llvmType = structType.getBody()[idx]; } else { - op->emitOpError("expected LLVM IR structure/array type, got: ") - << llvmType; + emitError("expected LLVM IR structure/array type, got: ") << llvmType; return {}; } } return llvmType; } -// ::= `llvm.extractvalue` ssa-use -// `[` integer-literal (`,` integer-literal)* `]` -// attribute-dict? `:` type -ParseResult ExtractValueOp::parse(OpAsmParser &parser, OperationState &result) { - OpAsmParser::UnresolvedOperand container; - Type containerType; - ArrayAttr positionAttr; - SMLoc attributeLoc, trailingTypeLoc; - - if (parser.parseOperand(container) || - parser.getCurrentLocation(&attributeLoc) || - parser.parseAttribute(positionAttr, "position", result.attributes) || - parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() || - parser.getCurrentLocation(&trailingTypeLoc) || - parser.parseType(containerType) || - parser.resolveOperand(container, containerType, result.operands)) - return failure(); - - auto elementType = getInsertExtractValueElementType( - parser, containerType, positionAttr, attributeLoc, trailingTypeLoc); - if (!elementType) - return failure(); - - result.addTypes(elementType); - return success(); +/// Extract the type at `position` in the wrapped LLVM IR aggregate type +/// `containerType`. +static Type getInsertExtractValueElementType(Type llvmType, + ArrayRef position) { + for (int64_t idx : position) { + if (auto structType = llvmType.dyn_cast()) + llvmType = structType.getBody()[idx]; + else + llvmType = llvmType.cast().getElementType(); + } + return llvmType; } OpFoldResult LLVM::ExtractValueOp::fold(ArrayRef operands) { @@ -1547,8 +1475,8 @@ // !llvm.array<4 x !llvm.array<4xf32>> // %3 = llvm.extractvalue %2[0, 0] : !llvm.array<4 x !llvm.array<4xf32>> // ``` - if (getPosition().getValue().take_front(min) == - insertValueOp.getPosition().getValue().take_front(min)) + if (getPosition().take_front(min) == + insertValueOp.getPosition().take_front(min)) return result; // If neither a prefix, nor the exact position, we can extract out of the @@ -1562,8 +1490,9 @@ } LogicalResult ExtractValueOp::verify() { - Type valueType = getInsertExtractValueElementType(getContainer().getType(), - getPositionAttr(), *this); + auto emitError = [this](StringRef msg) { return emitOpError(msg); }; + Type valueType = getInsertExtractValueElementType( + emitError, getContainer().getType(), getPosition()); if (!valueType) return failure(); @@ -1575,6 +1504,13 @@ return success(); } +void ExtractValueOp::build(OpBuilder &builder, OperationState &state, + Value container, ArrayRef position) { + build(builder, state, + getInsertExtractValueElementType(container.getType(), position), + container, builder.getAttr(position)); +} + //===----------------------------------------------------------------------===// // Printing/parsing for LLVM::InsertElementOp. //===----------------------------------------------------------------------===// @@ -1627,49 +1563,32 @@ } //===----------------------------------------------------------------------===// -// Printing/parsing for LLVM::InsertValueOp. +// InsertValueOp //===----------------------------------------------------------------------===// -void InsertValueOp::print(OpAsmPrinter &p) { - p << ' ' << getValue() << ", " << getContainer() << getPosition(); - p.printOptionalAttrDict((*this)->getAttrs(), {"position"}); - p << " : " << getContainer().getType(); +/// Infer the value type from the container type and position. +static ParseResult +parseInsertExtractValueElementType(AsmParser &parser, Type &valueType, + Type containerType, + DenseI64ArrayAttr position) { + valueType = getInsertExtractValueElementType( + [&](StringRef msg) { + return parser.emitError(parser.getCurrentLocation(), msg); + }, + containerType, position.asArrayRef()); + return success(!!valueType); } -// ::= `llvm.insertvaluevalue` ssa-use `,` ssa-use -// `[` integer-literal (`,` integer-literal)* `]` -// attribute-dict? `:` type -ParseResult InsertValueOp::parse(OpAsmParser &parser, OperationState &result) { - OpAsmParser::UnresolvedOperand container, value; - Type containerType; - ArrayAttr positionAttr; - SMLoc attributeLoc, trailingTypeLoc; - - if (parser.parseOperand(value) || parser.parseComma() || - parser.parseOperand(container) || - parser.getCurrentLocation(&attributeLoc) || - parser.parseAttribute(positionAttr, "position", result.attributes) || - parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() || - parser.getCurrentLocation(&trailingTypeLoc) || - parser.parseType(containerType)) - return failure(); - - auto valueType = getInsertExtractValueElementType( - parser, containerType, positionAttr, attributeLoc, trailingTypeLoc); - if (!valueType) - return failure(); - - if (parser.resolveOperand(container, containerType, result.operands) || - parser.resolveOperand(value, valueType, result.operands)) - return failure(); - - result.addTypes(containerType); - return success(); -} +/// Nothing to print for an inferred type. +static void printInsertExtractValueElementType(AsmPrinter &printer, + Operation *op, Type valueType, + Type containerType, + DenseI64ArrayAttr position) {} LogicalResult InsertValueOp::verify() { - Type valueType = getInsertExtractValueElementType(getContainer().getType(), - getPositionAttr(), *this); + auto emitError = [this](StringRef msg) { return emitOpError(msg); }; + Type valueType = getInsertExtractValueElementType( + emitError, getContainer().getType(), getPosition()); if (!valueType) return failure(); @@ -1681,6 +1600,13 @@ return success(); } +void InsertValueOp::build(OpBuilder &builder, OperationState &state, + Value container, Value value, + ArrayRef position) { + build(builder, state, container.getType(), container, value, + builder.getAttr(position)); +} + //===----------------------------------------------------------------------===// // Printing, parsing and verification for LLVM::ReturnOp. //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp --- a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp +++ b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp @@ -543,9 +543,8 @@ if (!elementValue) return nullptr; if (useInsertValue) { - ArrayAttr indexAttr = bEntry.getI32ArrayAttr({static_cast(i)}); - root = bEntry.create(UnknownLoc::get(context), rootType, - root, elementValue, indexAttr); + root = bEntry.create(UnknownLoc::get(context), root, + elementValue, i); } else { Attribute indexAttr = bEntry.getI32IntegerAttr(static_cast(i)); Value indexValue = bEntry.create( @@ -1100,11 +1099,8 @@ if (!aggOperand) return failure(); - SmallVector idxValues; - for (unsigned idx : ivInst->getIndices()) - idxValues.push_back(static_cast(idx)); - ArrayAttr indices = b.getI32ArrayAttr(idxValues); - + SmallVector indices; + llvm::append_range(indices, ivInst->getIndices()); instMap[inst] = b.create(loc, aggOperand, inserted, indices); return success(); } @@ -1118,12 +1114,9 @@ if (!type) return failure(); - SmallVector idxValues; - for (unsigned idx : evInst->getIndices()) - idxValues.push_back(static_cast(idx)); - ArrayAttr indices = b.getI32ArrayAttr(idxValues); - - instMap[inst] = b.create(loc, type, aggOperand, indices); + SmallVector indices; + llvm::append_range(indices, evInst->getIndices()); + instMap[inst] = b.create(loc, aggOperand, indices); return success(); } case llvm::Instruction::ShuffleVector: { diff --git a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp --- a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp @@ -251,16 +251,16 @@ } } +/// Convert the value of a DenseI64ArrayAttr to a vector of unsigned indices. +static SmallVector extractPosition(ArrayRef indices) { + SmallVector position; + llvm::append_range(position, indices); + return position; +} + static LogicalResult convertOperationImpl(Operation &opInst, llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation) { - auto extractPosition = [](ArrayAttr attr) { - SmallVector position; - position.reserve(attr.size()); - for (Attribute v : attr) - position.push_back(v.cast().getValue().getZExtValue()); - return position; - }; llvm::IRBuilder<>::FastMathFlagGuard fmfGuard(builder); if (auto fmf = dyn_cast(opInst)) diff --git a/mlir/test/Conversion/FuncToLLVM/calling-convention.mlir b/mlir/test/Conversion/FuncToLLVM/calling-convention.mlir --- a/mlir/test/Conversion/FuncToLLVM/calling-convention.mlir +++ b/mlir/test/Conversion/FuncToLLVM/calling-convention.mlir @@ -191,7 +191,7 @@ %0:2 = call @return_two_var_memref(%arg0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) // CHECK: %[[ALLOCA_1:.*]] = llvm.alloca %{{.*}} x i8 - // CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[RES_1:.*]][1] : ![[DESC_TYPE:.*]] + // CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[RES_1:.*]][1] : ![[DESC_TYPE:.*>]] // CHECK: "llvm.intr.memcpy"(%[[ALLOCA_1]], %[[SOURCE_1]], %{{.*}}, %[[FALSE:.*]]) // CHECK: llvm.call @free(%[[SOURCE_1]]) // CHECK: %[[DESC_1:.*]] = llvm.mlir.undef : ![[DESC_TYPE]] @@ -245,4 +245,3 @@ // CHECK-LABEL: @_mlir_ciface_return_two_var_memref // CHECK-SAME: (%{{.*}}: !llvm.ptr)>, struct<(i64, ptr)>)>>, // CHECK-SAME: %{{.*}}: !llvm.ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>>) - diff --git a/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir b/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir --- a/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir +++ b/mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir @@ -131,8 +131,8 @@ // CHECK: %[[#MASK:]] = llvm.lshr %[[#MINUS_ONE]], %[[#NUM_LANES]] : i32 // CHECK: %[[#CLAMP:]] = llvm.sub %[[#WIDTH]], %[[#ONE]] : i32 // CHECK: %[[#SHFL:]] = nvvm.shfl.sync bfly %[[#MASK]], %[[#VALUE]], %[[#OFFSET]], %[[#CLAMP]] {return_value_and_is_valid} : f32 -> !llvm.struct<(f32, i1)> - // CHECK: llvm.extractvalue %[[#SHFL]][0 : index] : !llvm.struct<(f32, i1)> - // CHECK: llvm.extractvalue %[[#SHFL]][1 : index] : !llvm.struct<(f32, i1)> + // CHECK: llvm.extractvalue %[[#SHFL]][0] : !llvm.struct<(f32, i1)> + // CHECK: llvm.extractvalue %[[#SHFL]][1] : !llvm.struct<(f32, i1)> %shfl, %pred = gpu.shuffle xor %arg0, %arg1, %arg2 : f32 // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[#MINUS_ONE:]] = llvm.mlir.constant(-1 : i32) : i32 @@ -140,8 +140,8 @@ // CHECK: %[[#NUM_LANES:]] = llvm.sub %[[#THIRTY_TWO]], %[[#WIDTH]] : i32 // CHECK: %[[#MASK:]] = llvm.lshr %[[#MINUS_ONE]], %[[#NUM_LANES]] : i32 // CHECK: %[[#SHFL:]] = nvvm.shfl.sync up %[[#MASK]], %[[#VALUE]], %[[#OFFSET]], %[[#NUM_LANES]] {return_value_and_is_valid} : f32 -> !llvm.struct<(f32, i1)> - // CHECK: llvm.extractvalue %[[#SHFL]][0 : index] : !llvm.struct<(f32, i1)> - // CHECK: llvm.extractvalue %[[#SHFL]][1 : index] : !llvm.struct<(f32, i1)> + // CHECK: llvm.extractvalue %[[#SHFL]][0] : !llvm.struct<(f32, i1)> + // CHECK: llvm.extractvalue %[[#SHFL]][1] : !llvm.struct<(f32, i1)> %shflu, %predu = gpu.shuffle up %arg0, %arg1, %arg2 : f32 // CHECK: nvvm.shfl.sync down {{.*}} {return_value_and_is_valid} : f32 -> !llvm.struct<(f32, i1)> %shfld, %predd = gpu.shuffle down %arg0, %arg1, %arg2 : f32 diff --git a/mlir/test/Conversion/GPUToNVVM/wmma-ops-to-nvvm.mlir b/mlir/test/Conversion/GPUToNVVM/wmma-ops-to-nvvm.mlir --- a/mlir/test/Conversion/GPUToNVVM/wmma-ops-to-nvvm.mlir +++ b/mlir/test/Conversion/GPUToNVVM/wmma-ops-to-nvvm.mlir @@ -53,10 +53,10 @@ gpu.subgroup_mma_store_matrix %arg0, %sg[%i,%j] {leadDimension= 32 : index} : !gpu.mma_matrix<16x16xf16, "COp">, memref<32x32xf16, 3> // CHECK: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i64 // CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}] - // CHECK: %[[EL1:.*]] = llvm.extractvalue %[[D]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[EL2:.*]] = llvm.extractvalue %[[D]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[EL3:.*]] = llvm.extractvalue %[[D]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[EL4:.*]] = llvm.extractvalue %[[D]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[EL1:.*]] = llvm.extractvalue %[[D]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[EL2:.*]] = llvm.extractvalue %[[D]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[EL3:.*]] = llvm.extractvalue %[[D]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[EL4:.*]] = llvm.extractvalue %[[D]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[BASE:.*]] = llvm.extractvalue %17[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[LDM:.*]] = llvm.mlir.constant(32 : index) : i64 // CHECK: %[[LI:.*]] = llvm.mul %[[INX]], %[[LDM]] : i64 @@ -69,10 +69,10 @@ // CHECK32: %[[INX:.*]] = llvm.mlir.constant(16 : index) : i32 // CHECK32: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[{{.*}}, {{.*}}] - // CHECK32: %[[EL1:.*]] = llvm.extractvalue %[[D]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK32: %[[EL2:.*]] = llvm.extractvalue %[[D]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK32: %[[EL3:.*]] = llvm.extractvalue %[[D]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK32: %[[EL4:.*]] = llvm.extractvalue %[[D]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK32: %[[EL1:.*]] = llvm.extractvalue %[[D]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK32: %[[EL2:.*]] = llvm.extractvalue %[[D]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK32: %[[EL3:.*]] = llvm.extractvalue %[[D]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK32: %[[EL4:.*]] = llvm.extractvalue %[[D]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK32: %[[BASE:.*]] = llvm.extractvalue %17[1] : !llvm.struct<(ptr, ptr, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[LDM:.*]] = llvm.mlir.constant(32 : index) : i32 // CHECK32: %[[LI:.*]] = llvm.mul %[[INX]], %[[LDM]] : i32 @@ -94,26 +94,26 @@ // CHECK-SAME: (%[[A:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[B:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>, %[[C:.*]]: !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) func.func @gpu_wmma_mma_op(%A : !gpu.mma_matrix<16x16xf16, "AOp">, %B : !gpu.mma_matrix<16x16xf16, "BOp">, %C : !gpu.mma_matrix<16x16xf16, "COp">) -> (!gpu.mma_matrix<16x16xf16, "COp">) { %D = gpu.subgroup_mma_compute %A, %B, %C : !gpu.mma_matrix<16x16xf16, "AOp">, !gpu.mma_matrix<16x16xf16, "BOp"> -> !gpu.mma_matrix<16x16xf16, "COp"> - // CHECK: %[[A1:.*]] = llvm.extractvalue %[[A]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A2:.*]] = llvm.extractvalue %[[A]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A3:.*]] = llvm.extractvalue %[[A]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A4:.*]] = llvm.extractvalue %[[A]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A5:.*]] = llvm.extractvalue %[[A]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A6:.*]] = llvm.extractvalue %[[A]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A7:.*]] = llvm.extractvalue %[[A]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[A8:.*]] = llvm.extractvalue %[[A]][7 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B1:.*]] = llvm.extractvalue %[[B]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B2:.*]] = llvm.extractvalue %[[B]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B3:.*]] = llvm.extractvalue %[[B]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B4:.*]] = llvm.extractvalue %[[B]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B5:.*]] = llvm.extractvalue %[[B]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B6:.*]] = llvm.extractvalue %[[B]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B7:.*]] = llvm.extractvalue %[[B]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[B8:.*]] = llvm.extractvalue %[[B]][7 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[C1:.*]] = llvm.extractvalue %[[C]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[C2:.*]] = llvm.extractvalue %[[C]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[C3:.*]] = llvm.extractvalue %[[C]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> - // CHECK: %[[C4:.*]] = llvm.extractvalue %[[C]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A2:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A3:.*]] = llvm.extractvalue %[[A]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A4:.*]] = llvm.extractvalue %[[A]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A5:.*]] = llvm.extractvalue %[[A]][4] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A6:.*]] = llvm.extractvalue %[[A]][5] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A7:.*]] = llvm.extractvalue %[[A]][6] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[A8:.*]] = llvm.extractvalue %[[A]][7] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B1:.*]] = llvm.extractvalue %[[B]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B2:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B3:.*]] = llvm.extractvalue %[[B]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B4:.*]] = llvm.extractvalue %[[B]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B5:.*]] = llvm.extractvalue %[[B]][4] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B6:.*]] = llvm.extractvalue %[[B]][5] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B7:.*]] = llvm.extractvalue %[[B]][6] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[B8:.*]] = llvm.extractvalue %[[B]][7] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[C1:.*]] = llvm.extractvalue %[[C]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[C2:.*]] = llvm.extractvalue %[[C]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[C3:.*]] = llvm.extractvalue %[[C]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> + // CHECK: %[[C4:.*]] = llvm.extractvalue %[[C]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[RES:.*]] = nvvm.wmma.mma %[[A1]], %[[A2]], %[[A3]], %[[A4]], %[[A5]], %[[A6]], %[[A7]], %[[A8]], %[[B1]], %[[B2]], %[[B3]], %[[B4]], %[[B5]], %[[B6]], %[[B7]], %[[B8]], %[[C1]], %[[C2]], %[[C3]], %[[C4]] // CHECK-SAME: {eltypeA = #nvvm.mma_type, eltypeB = #nvvm.mma_type, k = 16 : i32, layoutA = #nvvm.mma_layout, layoutB = #nvvm.mma_layout, m = 16 : i32, n = 16 : i32} : ( // CHECK-SAME: vector<2xf16>, {{.*}}) -> !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> @@ -134,33 +134,33 @@ // CHECK: ^bb2: // pred: ^bb1 // CHECK: %[[A:.+]] = nvvm.wmma.load %{{.*}}, %{{.*}} {eltype = #nvvm.mma_type, frag = #nvvm.mma_frag, k = 16 : i32, layout = #nvvm.mma_layout, m = 16 : i32, n = 16 : i32} : (!llvm.ptr) -> !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[B:.+]] = nvvm.wmma.load %{{.*}}, %{{.*}} {eltype = #nvvm.mma_type, frag = #nvvm.mma_frag, k = 16 : i32, layout = #nvvm.mma_layout, m = 16 : i32, n = 16 : i32} : (!llvm.ptr) -> !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A0:.+]] = llvm.extractvalue %[[A]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A1:.+]] = llvm.extractvalue %[[A]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A2:.+]] = llvm.extractvalue %[[A]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A3:.+]] = llvm.extractvalue %[[A]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A4:.+]] = llvm.extractvalue %[[A]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A5:.+]] = llvm.extractvalue %[[A]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A6:.+]] = llvm.extractvalue %[[A]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A7:.+]] = llvm.extractvalue %[[A]][7 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B0:.+]] = llvm.extractvalue %[[B]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B1:.+]] = llvm.extractvalue %[[B]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B2:.+]] = llvm.extractvalue %[[B]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B3:.+]] = llvm.extractvalue %[[B]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B4:.+]] = llvm.extractvalue %[[B]][4 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B5:.+]] = llvm.extractvalue %[[B]][5 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B6:.+]] = llvm.extractvalue %[[B]][6 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B7:.+]] = llvm.extractvalue %[[B]][7 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[ACC0:.+]] = llvm.extractvalue %[[ACC]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[ACC1:.+]] = llvm.extractvalue %[[ACC]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[ACC2:.+]] = llvm.extractvalue %[[ACC]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[ACC3:.+]] = llvm.extractvalue %[[ACC]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A0:.+]] = llvm.extractvalue %[[A]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A1:.+]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A2:.+]] = llvm.extractvalue %[[A]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A3:.+]] = llvm.extractvalue %[[A]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A4:.+]] = llvm.extractvalue %[[A]][4] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A5:.+]] = llvm.extractvalue %[[A]][5] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A6:.+]] = llvm.extractvalue %[[A]][6] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A7:.+]] = llvm.extractvalue %[[A]][7] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B0:.+]] = llvm.extractvalue %[[B]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B1:.+]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B2:.+]] = llvm.extractvalue %[[B]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B3:.+]] = llvm.extractvalue %[[B]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B4:.+]] = llvm.extractvalue %[[B]][4] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B5:.+]] = llvm.extractvalue %[[B]][5] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B6:.+]] = llvm.extractvalue %[[B]][6] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B7:.+]] = llvm.extractvalue %[[B]][7] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[ACC0:.+]] = llvm.extractvalue %[[ACC]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[ACC1:.+]] = llvm.extractvalue %[[ACC]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[ACC2:.+]] = llvm.extractvalue %[[ACC]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[ACC3:.+]] = llvm.extractvalue %[[ACC]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[ACC_MUL:.+]] = nvvm.wmma.mma %[[A0]], %[[A1]], %[[A2]], %[[A3]], %[[A4]], %[[A5]], %[[A6]], %[[A7]], %[[B0]], %[[B1]], %[[B2]], %[[B3]], %[[B4]], %[[B5]], %[[B6]], %[[B7]], %[[ACC0]], %[[ACC1]], %[[ACC2]], %[[ACC3]] {eltypeA = #nvvm.mma_type, eltypeB = #nvvm.mma_type, k = 16 : i32, layoutA = #nvvm.mma_layout, layoutB = #nvvm.mma_layout, m = 16 : i32, n = 16 : i32} : (vector<2xf16>, {{.*}} -> !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: llvm.br ^bb1(%{{.*}}, %[[ACC_MUL]] : i64, !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)>) // CHECK: ^bb3: // pred: ^bb1 -// CHECK: %[[E0:.+]] = llvm.extractvalue %[[ACC]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[E1:.+]] = llvm.extractvalue %[[ACC]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[E2:.+]] = llvm.extractvalue %[[ACC]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[E3:.+]] = llvm.extractvalue %[[ACC]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[E0:.+]] = llvm.extractvalue %[[ACC]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[E1:.+]] = llvm.extractvalue %[[ACC]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[E2:.+]] = llvm.extractvalue %[[ACC]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[E3:.+]] = llvm.extractvalue %[[ACC]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: nvvm.wmma.store %{{.*}}, %{{.*}}, %[[E0]], %[[E1]], %[[E2]], %[[E3]] {eltype = #nvvm.mma_type, k = 16 : i32, layout = #nvvm.mma_layout, m = 16 : i32, n = 16 : i32} : !llvm.ptr, vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16> func.func @gpu_wmma_mma_loop_op(%arg0: memref<128x128xf16>, %arg1: memref<128x128xf16>, %arg2: memref<128x128xf16>) { @@ -197,10 +197,10 @@ // CHECK: %[[C1:.+]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[V2:.+]] = llvm.insertelement %[[CST]], %[[V1]][%[[C1]] : i32] : vector<2xf16> // CHECK: %[[M0:.+]] = llvm.mlir.undef : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[M1:.+]] = llvm.insertvalue %[[V2]], %[[M0]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[M2:.+]] = llvm.insertvalue %[[V2]], %[[M1]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[M3:.+]] = llvm.insertvalue %[[V2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[M4:.+]] = llvm.insertvalue %[[V2]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M1:.+]] = llvm.insertvalue %[[V2]], %[[M0]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M2:.+]] = llvm.insertvalue %[[V2]], %[[M1]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M3:.+]] = llvm.insertvalue %[[V2]], %[[M2]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M4:.+]] = llvm.insertvalue %[[V2]], %[[M3]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: llvm.return %[[M4]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> func.func @gpu_wmma_constant_op() ->(!gpu.mma_matrix<16x16xf16, "COp">) { %cst = arith.constant 1.0 : f16 @@ -215,56 +215,56 @@ // CHECK-LABEL: func @gpu_wmma_elementwise // CHECK: %[[M0:.*]] = llvm.mlir.undef : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A0:.*]] = llvm.extractvalue %{{.*}}[0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B0:.*]] = llvm.extractvalue %{{.*}}[0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A0:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B0:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[C0:.*]] = llvm.fadd %[[A0]], %[[B0]] : vector<2xf16> -// CHECK: %[[M1:.*]] = llvm.insertvalue %[[C0]], %[[M0]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A1:.*]] = llvm.extractvalue %{{.*}}[1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B1:.*]] = llvm.extractvalue %{{.*}}[1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M1:.*]] = llvm.insertvalue %[[C0]], %[[M0]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A1:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B1:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[C1:.*]] = llvm.fadd %[[A1]], %[[B1]] : vector<2xf16> -// CHECK: %[[M2:.*]] = llvm.insertvalue %[[C1]], %[[M1]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M2:.*]] = llvm.insertvalue %[[C1]], %[[M1]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A2:.*]] = llvm.extractvalue %{{.*}}[2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[C2:.*]] = llvm.fadd %[[A2]], %[[B2]] : vector<2xf16> -// CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[C3:.*]] = llvm.fadd %[[A3]], %[[B3]] : vector<2xf16> -// CHECK: %[[M4:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M4:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[M0:.*]] = llvm.mlir.undef : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A0:.*]] = llvm.extractvalue %{{.*}}[0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B0:.*]] = llvm.extractvalue %{{.*}}[0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A0:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B0:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[CMP0:.*]] = llvm.fcmp "ogt" %[[A0]], %[[B0]] : vector<2xf16> // CHECK: %[[SEL0:.*]] = llvm.select %[[CMP0]], %[[A0]], %[[B0]] : vector<2xi1>, vector<2xf16> // CHECK: %[[CMP1:.*]] = llvm.fcmp "uno" %[[A0]], %[[B0]] : vector<2xf16> // CHECK: %[[NAN:.*]] = llvm.mlir.constant(0x7E00 : f16) : vector<2xf16> // CHECK: %[[C0:.*]] = llvm.select %[[CMP1]], %[[NAN]], %[[SEL0]] : vector<2xi1>, vector<2xf16> -// CHECK: %[[M1:.*]] = llvm.insertvalue %[[C0]], %[[M0]][0 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A1:.*]] = llvm.extractvalue %{{.*}}[1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B1:.*]] = llvm.extractvalue %{{.*}}[1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M1:.*]] = llvm.insertvalue %[[C0]], %[[M0]][0] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A1:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B1:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[CMP2:.*]] = llvm.fcmp "ogt" %[[A1]], %[[B1]] : vector<2xf16> // CHECK: %[[SEL1:.*]] = llvm.select %[[CMP2]], %[[A1]], %[[B1]] : vector<2xi1>, vector<2xf16> // CHECK: %[[CMP3:.*]] = llvm.fcmp "uno" %[[A1]], %[[B1]] : vector<2xf16> // CHECK: %[[NAN:.*]] = llvm.mlir.constant(0x7E00 : f16) : vector<2xf16> // CHECK: %[[C1:.*]] = llvm.select %[[CMP3]], %[[NAN]], %[[SEL1]] : vector<2xi1>, vector<2xf16> -// CHECK: %[[M2:.*]] = llvm.insertvalue %[[C1]], %[[M1]][1 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M2:.*]] = llvm.insertvalue %[[C1]], %[[M1]][1] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A2:.*]] = llvm.extractvalue %{{.*}}[2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B2:.*]] = llvm.extractvalue %{{.*}}[2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[CMP4:.*]] = llvm.fcmp "ogt" %[[A2]], %[[B2]] : vector<2xf16> // CHECK: %[[SEL2:.*]] = llvm.select %[[CMP4]], %[[A2]], %[[B2]] : vector<2xi1>, vector<2xf16> // CHECK: %[[CMP5:.*]] = llvm.fcmp "uno" %[[A2]], %[[B2]] : vector<2xf16> // CHECK: %[[NAN:.*]] = llvm.mlir.constant(0x7E00 : f16) : vector<2xf16> // CHECK: %[[C2:.*]] = llvm.select %[[CMP5]], %[[NAN]], %[[SEL2]] : vector<2xi1>, vector<2xf16> -// CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> -// CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M3:.*]] = llvm.insertvalue %[[C2]], %[[M2]][2] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[A3:.*]] = llvm.extractvalue %{{.*}}[3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[B3:.*]] = llvm.extractvalue %{{.*}}[3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: %[[CMP6:.*]] = llvm.fcmp "ogt" %[[A3]], %[[B3]] : vector<2xf16> // CHECK: %[[SEL3:.*]] = llvm.select %[[CMP6]], %[[A3]], %[[B3]] : vector<2xi1>, vector<2xf16> // CHECK: %[[CMP7:.*]] = llvm.fcmp "uno" %[[A3]], %[[B3]] : vector<2xf16> // CHECK: %[[NAN:.*]] = llvm.mlir.constant(0x7E00 : f16) : vector<2xf16> // CHECK: %[[C3:.*]] = llvm.select %[[CMP7]], %[[NAN]], %[[SEL3]] : vector<2xi1>, vector<2xf16> -// CHECK: %[[M5:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3 : i32] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> +// CHECK: %[[M5:.*]] = llvm.insertvalue %[[C3]], %[[M3]][3] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> // CHECK: llvm.return %[[M5]] : !llvm.struct<(vector<2xf16>, vector<2xf16>, vector<2xf16>, vector<2xf16>)> func.func @gpu_wmma_elementwise(%A : !gpu.mma_matrix<16x16xf16, "COp">, %B : !gpu.mma_matrix<16x16xf16, "COp">) ->(!gpu.mma_matrix<16x16xf16, "COp">) { diff --git a/mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir b/mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir --- a/mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir +++ b/mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir @@ -6,7 +6,7 @@ // CHECK-LABEL: @composite_extract_array spv.func @composite_extract_array(%arg: !spv.array<4x!spv.array<4xf32>>) "None" { - // CHECK: llvm.extractvalue %{{.*}}[1 : i32, 3 : i32] : !llvm.array<4 x array<4 x f32>> + // CHECK: llvm.extractvalue %{{.*}}[1, 3] : !llvm.array<4 x array<4 x f32>> %0 = spv.CompositeExtract %arg[1 : i32, 3 : i32] : !spv.array<4x!spv.array<4xf32>> spv.Return } @@ -25,7 +25,7 @@ // CHECK-LABEL: @composite_insert_struct spv.func @composite_insert_struct(%arg0: i32, %arg1: !spv.struct<(f32, !spv.array<4xi32>)>) "None" { - // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1 : i32, 3 : i32] : !llvm.struct)> + // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1, 3] : !llvm.struct)> %0 = spv.CompositeInsert %arg0, %arg1[1 : i32, 3 : i32] : i32 into !spv.struct<(f32, !spv.array<4xi32>)> spv.Return } @@ -92,7 +92,7 @@ // CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> { // CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32)> // CHECK-NEXT: %[[VAL:.*]] = llvm.mlir.constant(31 : i32) : i32 -// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[VAL]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32)> +// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[VAL]], %[[UNDEF]][0] : !llvm.struct<(i32)> // CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32)> // CHECK-NEXT: } // CHECK-NEXT: llvm.func @empty @@ -111,13 +111,13 @@ // CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32, array<3 x i32>)> { // CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[EM:.*]] = llvm.mlir.constant(18 : i32) : i32 -// CHECK-NEXT: %[[T0:.*]] = llvm.insertvalue %[[EM]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32, array<3 x i32>)> +// CHECK-NEXT: %[[T0:.*]] = llvm.insertvalue %[[EM]], %[[UNDEF]][0] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[C0:.*]] = llvm.mlir.constant(32 : i32) : i32 -// CHECK-NEXT: %[[T1:.*]] = llvm.insertvalue %[[C0]], %[[T0]][1 : i32, 0 : i32] : !llvm.struct<(i32, array<3 x i32>)> +// CHECK-NEXT: %[[T1:.*]] = llvm.insertvalue %[[C0]], %[[T0]][1, 0] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK-NEXT: %[[T2:.*]] = llvm.insertvalue %[[C1]], %[[T1]][1 : i32, 1 : i32] : !llvm.struct<(i32, array<3 x i32>)> +// CHECK-NEXT: %[[T2:.*]] = llvm.insertvalue %[[C1]], %[[T1]][1, 1] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[C2:.*]] = llvm.mlir.constant(1 : i32) : i32 -// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[C2]], %[[T2]][1 : i32, 2 : i32] : !llvm.struct<(i32, array<3 x i32>)> +// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[C2]], %[[T2]][1, 2] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: } // CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> { diff --git a/mlir/test/Dialect/LLVMIR/invalid.mlir b/mlir/test/Dialect/LLVMIR/invalid.mlir --- a/mlir/test/Dialect/LLVMIR/invalid.mlir +++ b/mlir/test/Dialect/LLVMIR/invalid.mlir @@ -385,44 +385,28 @@ // ----- func.func @insertvalue_non_llvm_type(%a : i32, %b : i32) { - // expected-error@+1 {{expected LLVM IR Dialect type}} + // expected-error@+2 {{expected LLVM IR Dialect type}} llvm.insertvalue %a, %b[0] : tensor<*xi32> } // ----- -func.func @insertvalue_non_array_position() { - // Note the double-type, otherwise attribute parsing consumes the trailing - // type of the op as the (wrong) attribute type. - // expected-error@+1 {{invalid kind of attribute specified}} - llvm.insertvalue %a, %b 0 : i32 : !llvm.struct<(i32)> -} - -// ----- - -func.func @insertvalue_non_integer_position() { - // expected-error@+1 {{expected an array of integer literals}} - llvm.insertvalue %a, %b[0.0] : !llvm.struct<(i32)> -} - -// ----- - func.func @insertvalue_struct_out_of_bounds() { - // expected-error@+1 {{position out of bounds}} + // expected-error@+2 {{position out of bounds}} llvm.insertvalue %a, %b[1] : !llvm.struct<(i32)> } // ----- func.func @insertvalue_array_out_of_bounds() { - // expected-error@+1 {{position out of bounds}} + // expected-error@+2 {{position out of bounds}} llvm.insertvalue %a, %b[1] : !llvm.array<1 x i32> } // ----- func.func @insertvalue_wrong_nesting() { - // expected-error@+1 {{expected LLVM IR structure/array type}} + // expected-error@+2 {{expected LLVM IR structure/array type}} llvm.insertvalue %a, %b[0,0] : !llvm.struct<(i32)> } @@ -430,7 +414,7 @@ func.func @insertvalue_invalid_type(%a : !llvm.array<1 x i32>) -> !llvm.array<1 x i32> { // expected-error@+1 {{'llvm.insertvalue' op Type mismatch: cannot insert '!llvm.array<1 x i32>' into '!llvm.array<1 x i32>'}} - %b = "llvm.insertvalue"(%a, %a) {position = [0]} : (!llvm.array<1 x i32>, !llvm.array<1 x i32>) -> !llvm.array<1 x i32> + %b = "llvm.insertvalue"(%a, %a) {position = [:i64 0]} : (!llvm.array<1 x i32>, !llvm.array<1 x i32>) -> !llvm.array<1 x i32> return %b : !llvm.array<1 x i32> } @@ -438,7 +422,7 @@ func.func @extractvalue_invalid_type(%a : !llvm.array<4 x vector<8xf32>>) -> !llvm.array<4 x vector<8xf32>> { // expected-error@+1 {{'llvm.extractvalue' op Type mismatch: extracting from '!llvm.array<4 x vector<8xf32>>' should produce 'vector<8xf32>' but this op returns '!llvm.array<4 x vector<8xf32>>'}} - %b = "llvm.extractvalue"(%a) {position = [1]} + %b = "llvm.extractvalue"(%a) {position = [:i64 1]} : (!llvm.array<4 x vector<8xf32>>) -> !llvm.array<4 x vector<8xf32>> return %b : !llvm.array<4 x vector<8xf32>> } @@ -447,44 +431,27 @@ // ----- func.func @extractvalue_non_llvm_type(%a : i32, %b : tensor<*xi32>) { - // expected-error@+1 {{expected LLVM IR Dialect type}} + // expected-error@+2 {{expected LLVM IR Dialect type}} llvm.extractvalue %b[0] : tensor<*xi32> } - -// ----- - -func.func @extractvalue_non_array_position() { - // Note the double-type, otherwise attribute parsing consumes the trailing - // type of the op as the (wrong) attribute type. - // expected-error@+1 {{invalid kind of attribute specified}} - llvm.extractvalue %b 0 : i32 : !llvm.struct<(i32)> -} - -// ----- - -func.func @extractvalue_non_integer_position() { - // expected-error@+1 {{expected an array of integer literals}} - llvm.extractvalue %b[0.0] : !llvm.struct<(i32)> -} - // ----- func.func @extractvalue_struct_out_of_bounds() { - // expected-error@+1 {{position out of bounds}} + // expected-error@+2 {{position out of bounds}} llvm.extractvalue %b[1] : !llvm.struct<(i32)> } // ----- func.func @extractvalue_array_out_of_bounds() { - // expected-error@+1 {{position out of bounds}} + // expected-error@+2 {{position out of bounds}} llvm.extractvalue %b[1] : !llvm.array<1 x i32> } // ----- func.func @extractvalue_wrong_nesting() { - // expected-error@+1 {{expected LLVM IR structure/array type}} + // expected-error@+2 {{expected LLVM IR structure/array type}} llvm.extractvalue %b[0,0] : !llvm.struct<(i32)> } diff --git a/mlir/test/Target/LLVMIR/Import/basic.ll b/mlir/test/Target/LLVMIR/Import/basic.ll --- a/mlir/test/Target/LLVMIR/Import/basic.ll +++ b/mlir/test/Target/LLVMIR/Import/basic.ll @@ -557,10 +557,10 @@ ; CHECK: %[[C0:.+]] = llvm.mlir.constant(2.000000e+00 : f64) ; CHECK: %[[VT:.+]] = llvm.load %{{.+}} %t = load {{i32},{float, double}}, {{i32},{float, double}}* %p - ; CHECK: %[[EV:.+]] = llvm.extractvalue %[[VT]][1 : i32, 0 : i32] : + ; CHECK: %[[EV:.+]] = llvm.extractvalue %[[VT]][1, 0] : ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)> %s = extractvalue {{i32},{float, double}} %t, 1, 0 - ; CHECK: %[[IV:.+]] = llvm.insertvalue %[[C0]], %[[VT]][1 : i32, 1 : i32] : + ; CHECK: %[[IV:.+]] = llvm.insertvalue %[[C0]], %[[VT]][1, 1] : ; CHECK-SAME: !llvm.struct<(struct<(i32)>, struct<(f32, f64)>)> %r = insertvalue {{i32},{float, double}} %t, double 2.0, 1, 1 ; CHECK: llvm.store %[[IV]], %{{.+}} @@ -572,11 +572,11 @@ ; CHECK-LABEL: llvm.func @insert_extract_value_array define void @insert_extract_value_array([4 x [4 x i8]] %x1) { ; CHECK: %[[C0:.+]] = llvm.mlir.constant(0 : i8) - ; CHECK: llvm.insertvalue %[[C0]], %{{.+}}[0 : i32, 0 : i32] : !llvm.array<4 x array<4 x i8>> + ; CHECK: llvm.insertvalue %[[C0]], %{{.+}}[0, 0] : !llvm.array<4 x array<4 x i8>> %res1 = insertvalue [4 x [4 x i8 ]] %x1, i8 0, 0, 0 - ; CHECK: llvm.extractvalue %{{.+}}[1 : i32] : !llvm.array<4 x array<4 x i8>> + ; CHECK: llvm.extractvalue %{{.+}}[1] : !llvm.array<4 x array<4 x i8>> %res2 = extractvalue [4 x [4 x i8 ]] %x1, 1 - ; CHECK: llvm.extractvalue %{{.+}}[0 : i32, 1 : i32] : !llvm.array<4 x array<4 x i8>> + ; CHECK: llvm.extractvalue %{{.+}}[0, 1] : !llvm.array<4 x array<4 x i8>> %res3 = extractvalue [4 x [4 x i8 ]] %x1, 0, 1 ret void } diff --git a/mlir/test/Target/LLVMIR/Import/constant-aggregate.ll b/mlir/test/Target/LLVMIR/Import/constant-aggregate.ll --- a/mlir/test/Target/LLVMIR/Import/constant-aggregate.ll +++ b/mlir/test/Target/LLVMIR/Import/constant-aggregate.ll @@ -5,10 +5,10 @@ ; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(4 : i8) : i8 ; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(9 : i32) : i32 ; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"SimpleAggType", (i32, i8, i16, i32)> -; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0 : i32] -; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1 : i32] -; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2 : i32] -; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3 : i32] +; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0] +; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1] +; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2] +; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3] ; CHECK: llvm.return %[[CHAIN3]] %SimpleAggType = type {i32, i8, i16, i32} @simpleAgg = global %SimpleAggType {i32 9, i8 4, i16 8, i32 7} @@ -19,13 +19,13 @@ ; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(2 : i8) : i8 ; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(1 : i32) : i32 ; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"SimpleAggType", (i32, i8, i16, i32)> -; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0 : i32] -; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1 : i32] -; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2 : i32] -; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3 : i32] +; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0] +; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1] +; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2] +; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3] ; CHECK: %[[ROOT2:.+]] = llvm.mlir.undef : !llvm.struct<"NestedAggType", (struct<"SimpleAggType", (i32, i8, i16, i32)>, ptr>)> -; CHECK: %[[CHAIN4:.+]] = llvm.insertvalue %[[CHAIN3]], %[[ROOT2]][0 : i32] -; CHECK: %[[CHAIN5:.+]] = llvm.insertvalue %[[NP]], %[[CHAIN4]][1 : i32] +; CHECK: %[[CHAIN4:.+]] = llvm.insertvalue %[[CHAIN3]], %[[ROOT2]][0] +; CHECK: %[[CHAIN5:.+]] = llvm.insertvalue %[[NP]], %[[CHAIN4]][1] ; CHECK: llvm.return %[[CHAIN5]] %NestedAggType = type {%SimpleAggType, %SimpleAggType*} @nestedAgg = global %NestedAggType { %SimpleAggType{i32 1, i8 2, i16 3, i32 4}, %SimpleAggType* null } diff --git a/mlir/test/Target/LLVMIR/Import/zeroinitializer.ll b/mlir/test/Target/LLVMIR/Import/zeroinitializer.ll --- a/mlir/test/Target/LLVMIR/Import/zeroinitializer.ll +++ b/mlir/test/Target/LLVMIR/Import/zeroinitializer.ll @@ -3,12 +3,11 @@ %Domain = type { %Domain**, %Domain* } ; CHECK: llvm.mlir.global external @D() : -; CHECK-SAME: !llvm.struct<"Domain", (ptr>>, ptr>)> +; CHECK-SAME: !llvm.struct<"Domain", (ptr>>, ptr>)> ; CHECK-DAG: %[[E0:.+]] = llvm.mlir.null : !llvm.ptr>>, ptr>)>> ; CHECK-DAG: %[[E1:.+]] = llvm.mlir.null : !llvm.ptr>>, ptr>)>>> ; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"Domain", (ptr>>, ptr>)> -; CHECK: %[[CHAIN:.+]] = llvm.insertvalue %[[E1]], %[[ROOT]][0 : i32] -; CHECK: %[[RES:.+]] = llvm.insertvalue %[[E0]], %[[CHAIN]][1 : i32] +; CHECK: %[[CHAIN:.+]] = llvm.insertvalue %[[E1]], %[[ROOT]][0] +; CHECK: %[[RES:.+]] = llvm.insertvalue %[[E0]], %[[CHAIN]][1] ; CHECK: llvm.return %[[RES]] @D = global %Domain zeroinitializer - diff --git a/mlir/test/Target/LLVMIR/llvmir.mlir b/mlir/test/Target/LLVMIR/llvmir.mlir --- a/mlir/test/Target/LLVMIR/llvmir.mlir +++ b/mlir/test/Target/LLVMIR/llvmir.mlir @@ -1506,8 +1506,8 @@ %0 = llvm.mlir.undef : !llvm.struct<(i32, !llvm.ptr)> %1 = llvm.mlir.addressof @take_self_address : !llvm.ptr)>> %2 = llvm.getelementptr %1[%z32, 0] : (!llvm.ptr)>>, i32) -> !llvm.ptr - %3 = llvm.insertvalue %z32, %0[0 : i32] : !llvm.struct<(i32, !llvm.ptr)> - %4 = llvm.insertvalue %2, %3[1 : i32] : !llvm.struct<(i32, !llvm.ptr)> + %3 = llvm.insertvalue %z32, %0[0] : !llvm.struct<(i32, !llvm.ptr)> + %4 = llvm.insertvalue %2, %3[1] : !llvm.struct<(i32, !llvm.ptr)> llvm.return %4 : !llvm.struct<(i32, !llvm.ptr)> }