diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp index f69e1637c665..8ec141e6b920 100644 --- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp +++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRLoopToSCF.cpp @@ -244,12 +244,24 @@ mlir::Value SCFLoop::findIVInitValue() { auto remapAddr = rewriter->getRemappedValue(ivAddr); if (!remapAddr) return nullptr; - if (!remapAddr.hasOneUse()) - return nullptr; - auto memrefStore = dyn_cast(*remapAddr.user_begin()); - if (!memrefStore) - return nullptr; - return memrefStore->getOperand(0); + if (auto castOp = + mlir::dyn_cast(remapAddr.getDefiningOp())) { + remapAddr = castOp->getOperand(0); + if (!remapAddr) + return nullptr; + // Alloca has two uses, one is the CastOp, and second is the StoreOp (which + // bypasses the CastOp) + if (remapAddr.getNumUses() > 2) + return nullptr; + } else { + if (!remapAddr.hasOneUse()) + return nullptr; + } + for (auto user : remapAddr.getUsers()) { + if (auto memrefStore = dyn_cast(user)) + return memrefStore->getOperand(0); + } + return nullptr; } void SCFLoop::analysis() { @@ -340,10 +352,13 @@ void SCFLoop::transferToSCFForOp() { // The operations before the loop have been transferred to MLIR. // So we need to go through getRemappedValue to find the operations. auto remapAddr = rewriter->getRemappedValue(ivAddr); - + if (auto castOp = + mlir::dyn_cast(remapAddr.getDefiningOp())) + remapAddr = castOp->getOperand(0); // Since this is a canonical loop we can remove the alloca + initial store op rewriter->eraseOp(remapAddr.getDefiningOp()); - rewriter->eraseOp(*remapAddr.user_begin()); + for (auto user : remapAddr.getUsers()) + rewriter->eraseOp(user); } void SCFLoop::transformToSCFWhileOp() { diff --git a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp index 275656a7f934..a4c43ecba3fb 100644 --- a/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp +++ b/clang/lib/CIR/Lowering/ThroughMLIR/LowerCIRToMLIR.cpp @@ -306,11 +306,22 @@ class CIRAllocaOpLowering : public mlir::OpConversionPattern { if (mlir::isa(adaptor.getAllocaType())) { if (!memreftype) return mlir::LogicalResult::failure(); + rewriter.replaceOpWithNewOp( + op, memreftype, op.getAlignmentAttr()); } else { - memreftype = mlir::MemRefType::get({}, mlirType); + memreftype = mlir::MemRefType::get({1}, mlirType); + auto allocaOp = mlir::memref::AllocaOp::create( + rewriter, op.getLoc(), memreftype, op.getAlignmentAttr()); + // Cast from memref<1xMlirType> to memref + // This is needed since Typeconverter produces memref for + // non-array cir.ptrs, The cast will be eliminated later in + // load/store-lowering. + auto targetType = + mlir::MemRefType::get({mlir::ShapedType::kDynamic}, mlirType); + auto castOp = mlir::memref::CastOp::create(rewriter, op.getLoc(), + targetType, allocaOp); + rewriter.replaceOp(op, castOp); } - rewriter.replaceOpWithNewOp(op, memreftype, - op.getAlignmentAttr()); return mlir::LogicalResult::success(); } }; @@ -327,9 +338,29 @@ static bool findBaseAndIndices(mlir::Value addr, mlir::Value &base, addr = addrOp->getOperand(0); eraseList.push_back(addrOp); } + if (auto castOp = addr.getDefiningOp()) { + auto castInput = castOp->getOperand(0); + if (castInput.getDefiningOp() || + castInput.getDefiningOp()) { + // AllocaOp and GetGlobalOp-lowerings produce 1-element memrefs + indices.push_back( + mlir::arith::ConstantIndexOp::create(rewriter, castOp.getLoc(), 0)); + addr = castInput; + eraseList.push_back(castOp); + } + } base = addr; - if (indices.size() == 0) + if (indices.size() == 0) { + auto memrefType = mlir::cast(base.getType()); + auto rank = memrefType.getRank(); + indices.reserve(rank); + for (unsigned d = 0; d < rank; ++d) { + mlir::Value zero = mlir::arith::ConstantIndexOp::create( + rewriter, base.getLoc(), /*value=*/0); + indices.push_back(zero); + } return false; + } std::reverse(indices.begin(), indices.end()); return true; } @@ -350,25 +381,33 @@ static void eraseIfSafe(mlir::Value oldAddr, mlir::Value newAddr, for (auto *user : newAddr.getUsers()) { if (auto loadOpUser = mlir::dyn_cast_or_null(*user)) { if (!loadOpUser.getIndices().empty()) { - auto strideVal = loadOpUser.getIndices()[0]; - if (strideVal == - mlir::dyn_cast(eraseList.back()) - .getOffsets()[0]) + if (auto reinterpretOp = + mlir::dyn_cast( + eraseList.back())) { + auto strideVal = loadOpUser.getIndices()[0]; + if (strideVal == reinterpretOp.getOffsets()[0]) + ++newUsedNum; + } else if (auto castOp = + mlir::dyn_cast(eraseList.back())) ++newUsedNum; } } else if (auto storeOpUser = mlir::dyn_cast_or_null(*user)) { if (!storeOpUser.getIndices().empty()) { - auto strideVal = storeOpUser.getIndices()[0]; - if (strideVal == - mlir::dyn_cast(eraseList.back()) - .getOffsets()[0]) + if (auto reinterpretOp = + mlir::dyn_cast( + eraseList.back())) { + auto strideVal = storeOpUser.getIndices()[0]; + if (strideVal == reinterpretOp.getOffsets()[0]) + ++newUsedNum; + } else if (auto castOp = + mlir::dyn_cast(eraseList.back())) ++newUsedNum; } } } - // If all load/store ops using forwarded offsets from the current - // memref.reinterpret_cast ops erase the memref.reinterpret_cast ops + // If all load/store ops are using forwarded offsets from the current + // memref.(reinterpret_)cast ops, erase them if (oldUsedNum == newUsedNum) { for (auto op : eraseList) rewriter.eraseOp(op); @@ -385,10 +424,6 @@ prepareReinterpretMetadata(mlir::MemRefType type, strides.clear(); for (int64_t dim : type.getShape()) { - if (mlir::ShapedType::isDynamic(dim)) { - anchorOp->emitError("dynamic memref sizes are not supported yet"); - return mlir::failure(); - } sizes.push_back(rewriter.getIndexAttr(dim)); } @@ -421,15 +456,12 @@ class CIRLoadOpLowering : public mlir::OpConversionPattern { SmallVector indices; SmallVector eraseList; mlir::memref::LoadOp newLoad; - if (findBaseAndIndices(adaptor.getAddr(), base, indices, eraseList, - rewriter)) { - newLoad = mlir::memref::LoadOp::create(rewriter, op.getLoc(), base, - indices, op.getIsNontemporal()); + bool eraseIntermediateOp = findBaseAndIndices(adaptor.getAddr(), base, + indices, eraseList, rewriter); + newLoad = mlir::memref::LoadOp::create(rewriter, op.getLoc(), base, indices, + op.getIsNontemporal()); + if (eraseIntermediateOp) eraseIfSafe(op.getAddr(), base, eraseList, rewriter); - } else - newLoad = mlir::memref::LoadOp::create( - rewriter, op.getLoc(), adaptor.getAddr(), mlir::ValueRange{}, - op.getIsNontemporal()); // Convert adapted result to its original type if needed. mlir::Value result = emitFromMemory(rewriter, op, newLoad.getResult()); @@ -451,15 +483,13 @@ class CIRStoreOpLowering : public mlir::OpConversionPattern { // Convert adapted value to its memory type if needed. mlir::Value value = emitToMemory(rewriter, op, adaptor.getValue()); - if (findBaseAndIndices(adaptor.getAddr(), base, indices, eraseList, - rewriter)) { - rewriter.replaceOpWithNewOp( - op, value, base, indices, op.getIsNontemporal()); + bool eraseIntermediateOp = findBaseAndIndices(adaptor.getAddr(), base, + indices, eraseList, rewriter); + rewriter.replaceOpWithNewOp(op, value, base, indices, + op.getIsNontemporal()); + if (eraseIntermediateOp) eraseIfSafe(op.getAddr(), base, eraseList, rewriter); - } else - rewriter.replaceOpWithNewOp( - op, value, adaptor.getAddr(), mlir::ValueRange{}, - op.getIsNontemporal()); + return mlir::LogicalResult::success(); } }; @@ -1157,7 +1187,7 @@ class CIRGlobalOpLowering : public mlir::OpConversionPattern { return mlir::failure(); auto memrefType = mlir::dyn_cast(convertedType); if (!memrefType) - memrefType = mlir::MemRefType::get({}, convertedType); + memrefType = mlir::MemRefType::get({1}, convertedType); // Add an optional alignment to the global memref. mlir::IntegerAttr memrefAlignment = op.getAlignment() @@ -1196,7 +1226,7 @@ class CIRGlobalOpLowering : public mlir::OpConversionPattern { } else initialValue = mlir::Attribute(); } else { - auto rtt = mlir::RankedTensorType::get({}, convertedType); + auto rtt = mlir::RankedTensorType::get({1}, convertedType); if (mlir::isa(convertedType)) initialValue = mlir::DenseIntElementsAttr::get(rtt, 0); else if (mlir::isa(convertedType)) { @@ -1207,13 +1237,13 @@ class CIRGlobalOpLowering : public mlir::OpConversionPattern { initialValue = mlir::Attribute(); } } else if (auto intAttr = mlir::dyn_cast(init.value())) { - auto rtt = mlir::RankedTensorType::get({}, convertedType); + auto rtt = mlir::RankedTensorType::get({1}, convertedType); initialValue = mlir::DenseIntElementsAttr::get(rtt, intAttr.getValue()); } else if (auto fltAttr = mlir::dyn_cast(init.value())) { - auto rtt = mlir::RankedTensorType::get({}, convertedType); + auto rtt = mlir::RankedTensorType::get({1}, convertedType); initialValue = mlir::DenseFPElementsAttr::get(rtt, fltAttr.getValue()); } else if (auto boolAttr = mlir::dyn_cast(init.value())) { - auto rtt = mlir::RankedTensorType::get({}, convertedType); + auto rtt = mlir::RankedTensorType::get({1}, convertedType); initialValue = mlir::DenseIntElementsAttr::get(rtt, (char)boolAttr.getValue()); } else @@ -1249,10 +1279,29 @@ class CIRGetGlobalOpLowering rewriter.eraseOp(op); return mlir::success(); } + auto globalOpType = + convertTypeForMemory(*getTypeConverter(), op.getType().getPointee()); + if (!globalOpType) + return mlir::failure(); + auto memrefType = mlir::dyn_cast(globalOpType); + if (!memrefType) + memrefType = mlir::MemRefType::get({1}, globalOpType); - auto type = getTypeConverter()->convertType(op.getType()); auto symbol = op.getName(); - rewriter.replaceOpWithNewOp(op, type, symbol); + auto getGlobalOp = mlir::memref::GetGlobalOp::create(rewriter, op.getLoc(), + memrefType, symbol); + + if (isa(op.getType().getPointee())) { + rewriter.replaceOp(op, getGlobalOp); + } else { + // Cast from memref<1xmlirType> to memref. This is needed + // since Typeconverter produces memref for non-array cir.ptrs. + // The cast will be eliminated later in load/store-lowering. + auto targetType = getTypeConverter()->convertType(op.getType()); + auto castOp = mlir::memref::CastOp::create(rewriter, op.getLoc(), + targetType, getGlobalOp); + rewriter.replaceOp(op, castOp); + } return mlir::success(); } }; @@ -1630,6 +1679,30 @@ class CIRPtrStrideOpLowering return getTypeConverter()->convertType(ty); } + // Rewrite + // cir.ptr_stride(%base, %stride) + // to + // memref.reinterpret_cast (%base, %stride) + // + mlir::LogicalResult rewritePtrStrideToReinterpret( + cir::PtrStrideOp op, mlir::Value base, OpAdaptor adaptor, + mlir::ConversionPatternRewriter &rewriter) const { + auto ptrType = op.getType(); + auto memrefType = llvm::cast(convertTy(ptrType)); + auto stride = adaptor.getStride(); + auto indexType = rewriter.getIndexType(); + // Generate casting if the stride is not index type. + if (stride.getType() != indexType) + stride = mlir::arith::IndexCastOp::create(rewriter, op.getLoc(), + indexType, stride); + + rewriter.replaceOpWithNewOp( + op, memrefType, base, stride, mlir::ValueRange{}, mlir::ValueRange{}, + llvm::ArrayRef{}); + + return mlir::success(); + } + // Rewrite // %0 = cir.cast array_to_ptrdecay %base // cir.ptr_stride(%0, %stride) @@ -1647,20 +1720,9 @@ class CIRPtrStrideOpLowering if (!baseDefiningOp) return mlir::failure(); - auto base = baseDefiningOp->getOperand(0); - auto ptrType = op.getType(); - auto memrefType = llvm::cast(convertTy(ptrType)); - auto stride = adaptor.getStride(); - auto indexType = rewriter.getIndexType(); - - // Generate casting if the stride is not index type. - if (stride.getType() != indexType) - stride = mlir::arith::IndexCastOp::create(rewriter, op.getLoc(), - indexType, stride); - - rewriter.replaceOpWithNewOp( - op, memrefType, base, stride, mlir::ValueRange{}, mlir::ValueRange{}, - llvm::ArrayRef{}); + if (mlir::failed(rewritePtrStrideToReinterpret( + op, baseDefiningOp->getOperand(0), adaptor, rewriter))) + return mlir::failure(); rewriter.eraseOp(baseDefiningOp); return mlir::success(); @@ -1669,8 +1731,13 @@ class CIRPtrStrideOpLowering mlir::LogicalResult matchAndRewrite(cir::PtrStrideOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const override { - if (isCastArrayToPtrConsumer(op) && isLoadStoreOrCastArrayToPtrProduer(op)) - return rewriteArrayDecay(op, adaptor, rewriter); + if (isLoadStoreOrCastArrayToPtrProduer(op)) { + if (isCastArrayToPtrConsumer(op)) + return rewriteArrayDecay(op, adaptor, rewriter); + else + return rewritePtrStrideToReinterpret(op, adaptor.getBase(), adaptor, + rewriter); + } auto base = adaptor.getBase(); auto stride = adaptor.getStride(); @@ -1801,7 +1868,7 @@ static mlir::TypeConverter prepareTypeConverter() { return nullptr; if (isa(type.getPointee())) return ty; - return mlir::MemRefType::get({}, ty); + return mlir::MemRefType::get({mlir::ShapedType::kDynamic}, ty); }); converter.addConversion( [&](mlir::IntegerType type) -> mlir::Type { return type; }); diff --git a/clang/test/CIR/Lowering/ThroughMLIR/array.c b/clang/test/CIR/Lowering/ThroughMLIR/array.c index 3962968ca0c5..d551b0f4caae 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/array.c +++ b/clang/test/CIR/Lowering/ThroughMLIR/array.c @@ -9,7 +9,7 @@ int test_array1() { // CIR: %{{.*}} = cir.get_element %[[ARRAY]][{{.*}}] : (!cir.ptr>, !s32i) -> !cir.ptr // MLIR-LABEL: func @test_array1 - // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref + // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // MLIR: %[[ARRAY:.*]] = memref.alloca() {alignment = 4 : i64} : memref<3xi32> // MLIR: %{{.*}} = memref.load %[[ARRAY]][%{{.*}}] : memref<3xi32> int a[3]; @@ -23,7 +23,7 @@ int test_array2() { // CIR: %{{.*}} = cir.get_element %{{.*}}[%{{.*}}] : (!cir.ptr>, !s32i) -> !cir.ptr // MLIR-LABEL: func @test_array2 - // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref + // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // MLIR: %[[ARRAY:.*]] = memref.alloca() {alignment = 16 : i64} : memref<3x4xi32> // MLIR: %{{.*}} = memref.load %[[ARRAY]][%{{.*}}, %{{.*}}] : memref<3x4xi32> int a[3][4]; @@ -42,7 +42,7 @@ int test_array3() { // CIR: %{{.*}} = cir.load align(4) %[[ELEM3]] : !cir.ptr, !s32i // MLIR-LABEL: func @test_array3 - // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref + // MLIR: %{{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // MLIR: %[[ARRAY:.*]] = memref.alloca() {alignment = 4 : i64} : memref<3xi32> // MLIR: %[[IDX1:.*]] = arith.index_cast %{{.*}} : i32 to index // MLIR: %{{.*}} = memref.load %[[ARRAY]][%[[IDX1]]] : memref<3xi32> diff --git a/clang/test/CIR/Lowering/ThroughMLIR/bool.cir b/clang/test/CIR/Lowering/ThroughMLIR/bool.cir index 5383477255aa..7bd429c4e481 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/bool.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/bool.cir @@ -1,5 +1,5 @@ // RUN: cir-opt %s -cir-to-mlir -o - | FileCheck %s -check-prefix=MLIR -// RUN: cir-opt %s -cir-to-mlir -cir-mlir-to-llvm -o - | mlir-translate -mlir-to-llvmir | FileCheck %s -check-prefix=LLVM +// RUN: cir-opt %s -cir-to-mlir -cir-mlir-to-llvm -canonicalize -o - | mlir-translate -mlir-to-llvmir | FileCheck %s -check-prefix=LLVM #false = #cir.bool : !cir.bool #true = #cir.bool : !cir.bool @@ -13,12 +13,13 @@ module { } // MLIR: func @foo() { -// MLIR: [[Value:%[a-z0-9]+]] = memref.alloca() {alignment = 1 : i64} : memref +// MLIR: %[[VALUE:[a-z0-9]+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> // MLIR: %[[CONST:.*]] = arith.constant true // MLIR: %[[BOOL_TO_MEM:.*]] = arith.extui %[[CONST]] : i1 to i8 -// MLIR-NEXT: memref.store %[[BOOL_TO_MEM]], [[Value]][] : memref +// MLIR: %[[CONST0:[a-z0-9]+]] = arith.constant 0 : index +// MLIR-NEXT: memref.store %[[BOOL_TO_MEM]], %[[VALUE]][%[[CONST0]]] : memref<1xi8> // return // LLVM: = alloca i8, i64 -// LLVM: store i8 1, ptr %5 +// LLVM: store i8 1, ptr %1 // LLVM: ret diff --git a/clang/test/CIR/Lowering/ThroughMLIR/call.c b/clang/test/CIR/Lowering/ThroughMLIR/call.c index d130c10435b5..84dcfc4e64eb 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/call.c +++ b/clang/test/CIR/Lowering/ThroughMLIR/call.c @@ -23,30 +23,30 @@ void testfunc(short s, float X, char C, long long LL, int I, double D) { } // CHECK: func.func @testfunc(%[[ARG0:.*]]: i16 {{.*}}, %[[ARG1:.*]]: f32 {{.*}}, %[[ARG2:.*]]: i8 {{.*}}, %[[ARG3:.*]]: i64 {{.*}}, %[[ARG4:.*]]: i32 {{.*}}, %[[ARG5:.*]]: f64 {{.*}}) { -// CHECK: %[[ALLOCA_S:.*]] = memref.alloca() {alignment = 2 : i64} : memref -// CHECK: %[[ALLOCA_X:.*]] = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[ALLOCA_C:.*]] = memref.alloca() {alignment = 1 : i64} : memref -// CHECK: %[[ALLOCA_LL:.*]] = memref.alloca() {alignment = 8 : i64} : memref -// CHECK: %[[ALLOCA_I:.*]] = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[ALLOCA_D:.*]] = memref.alloca() {alignment = 8 : i64} : memref -// CHECK: memref.store %[[ARG0]], %[[ALLOCA_S]][] : memref -// CHECK: memref.store %[[ARG1]], %[[ALLOCA_X]][] : memref -// CHECK: memref.store %[[ARG2]], %[[ALLOCA_C]][] : memref -// CHECK: memref.store %[[ARG3]], %[[ALLOCA_LL]][] : memref -// CHECK: memref.store %[[ARG4]], %[[ALLOCA_I]][] : memref -// CHECK: memref.store %[[ARG5]], %[[ALLOCA_D]][] : memref +// CHECK: %[[ALLOCA_S:.*]] = memref.alloca() {alignment = 2 : i64} : memref<1xi16> +// CHECK: %[[ALLOCA_X:.*]] = memref.alloca() {alignment = 4 : i64} : memref<1xf32> +// CHECK: %[[ALLOCA_C:.*]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> +// CHECK: %[[ALLOCA_LL:.*]] = memref.alloca() {alignment = 8 : i64} : memref<1xi64> +// CHECK: %[[ALLOCA_I:.*]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[ALLOCA_D:.*]] = memref.alloca() {alignment = 8 : i64} : memref<1xf64> +// CHECK: memref.store %[[ARG0]], %[[ALLOCA_S]][{{%c0(_[0-9]+)?}}] : memref<1xi16> +// CHECK: memref.store %[[ARG1]], %[[ALLOCA_X]][{{%c0(_[0-9]+)?}}] : memref<1xf32> +// CHECK: memref.store %[[ARG2]], %[[ALLOCA_C]][{{%c0(_[0-9]+)?}}] : memref<1xi8> +// CHECK: memref.store %[[ARG3]], %[[ALLOCA_LL]][{{%c0(_[0-9]+)?}}] : memref<1xi64> +// CHECK: memref.store %[[ARG4]], %[[ALLOCA_I]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: memref.store %[[ARG5]], %[[ALLOCA_D]][{{%c0(_[0-9]+)?}}] : memref<1xf64> // CHECK: %[[FRMT_STR_ADDR:.*]] = llvm.mlir.addressof @[[FRMT_STR]] : !llvm.ptr // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i8 -// CHECK: %[[FRMT_STR_DATA:.*]] = llvm.getelementptr %[[FRMT_STR_ADDR]][%[[C0]], %[[C0]]] : (!llvm.ptr, i8, i8) -> !llvm.ptr, !llvm.array<26 x i8> -// CHECK: %[[S:.*]] = memref.load %[[ALLOCA_S]][] : memref +// CHECK: %[[FRMT_STR_DATA:.*]] = llvm.getelementptr %[[FRMT_STR_ADDR]][%[[C0]], %[[C0]]] : (!llvm.ptr, i8, i8) -> !llvm.ptr, !llvm.array<26 x i8> +// CHECK: %[[S:.*]] = memref.load %[[ALLOCA_S]][{{%c0(_[0-9]+)?}}] : memref<1xi16> // CHECK: %[[S_EXT:.*]] = arith.extsi %3 : i16 to i32 -// CHECK: %[[X:.*]] = memref.load %[[ALLOCA_X]][] : memref +// CHECK: %[[X:.*]] = memref.load %[[ALLOCA_X]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[X_EXT:.*]] = arith.extf %5 : f32 to f64 -// CHECK: %[[C:.*]] = memref.load %[[ALLOCA_C]][] : memref +// CHECK: %[[C:.*]] = memref.load %[[ALLOCA_C]][{{%c0(_[0-9]+)?}}] : memref<1xi8> // CHECK: %[[C_EXT:.*]] = arith.extsi %7 : i8 to i32 -// CHECK: %[[LL:.*]] = memref.load %[[ALLOCA_LL]][] : memref -// CHECK: %[[I:.*]] = memref.load %[[ALLOCA_I]][] : memref -// CHECK: %[[D:.*]] = memref.load %[[ALLOCA_D]][] : memref +// CHECK: %[[LL:.*]] = memref.load %[[ALLOCA_LL]][{{%c0(_[0-9]+)?}}] : memref<1xi64> +// CHECK: %[[I:.*]] = memref.load %[[ALLOCA_I]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[D:.*]] = memref.load %[[ALLOCA_D]][{{%c0(_[0-9]+)?}}] : memref<1xf64> // CHECK: {{.*}} = llvm.call @printf(%[[FRMT_STR_DATA]], %[[S_EXT]], %[[X_EXT]], %[[C_EXT]], %[[LL]], %[[I]], %[[D]]) vararg(!llvm.func) : (!llvm.ptr, i32, f64, i32, i64, i32, f64) -> i32 // CHECK: return // CHECK: } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/cmp.cpp b/clang/test/CIR/Lowering/ThroughMLIR/cmp.cpp index e5b2f0cb109f..4ea8511d7180 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/cmp.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/cmp.cpp @@ -2,180 +2,180 @@ // RUN: FileCheck --input-file=%t.mlir %s bool testSignedIntCmpOps(int a, int b) { - // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: memref.store %arg0, %[[ALLOC1]][] : memref - // CHECK: memref.store %arg1, %[[ALLOC2]][] : memref + // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: memref.store %arg0, %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: memref.store %arg1, %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> bool x = a == b; - // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP0:.+]] = arith.cmpi eq, %[[LOAD0]], %[[LOAD1]] : i32 // CHECK: %[[EXT0:.+]] = arith.extui %[[CMP0]] : i1 to i8 - // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a != b; - // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP1:.+]] = arith.cmpi ne, %[[LOAD2]], %[[LOAD3]] : i32 // CHECK: %[[EXT1:.+]] = arith.extui %[[CMP1]] : i1 to i8 - // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a < b; - // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP2:.+]] = arith.cmpi slt, %[[LOAD4]], %[[LOAD5]] : i32 // CHECK: %[[EXT2:.+]] = arith.extui %[[CMP2]] : i1 to i8 - // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a <= b; - // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP3:.+]] = arith.cmpi sle, %[[LOAD6]], %[[LOAD7]] : i32 // CHECK: %[[EXT3:.+]] = arith.extui %[[CMP3]] : i1 to i8 - // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a > b; - // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP4:.+]] = arith.cmpi sgt, %[[LOAD8]], %[[LOAD9]] : i32 // CHECK: %[[EXT4:.+]] = arith.extui %[[CMP4]] : i1 to i8 - // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a >= b; - // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP5:.+]] = arith.cmpi sge, %[[LOAD10]], %[[LOAD11]] : i32 // CHECK: %[[EXT5:.+]] = arith.extui %[[CMP5]] : i1 to i8 - // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> return x; // CHECK: return } bool testUnSignedIntBinOps(unsigned a, unsigned b) { - // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: memref.store %arg0, %[[ALLOC1]][] : memref - // CHECK: memref.store %arg1, %[[ALLOC2]][] : memref + // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: memref.store %arg0, %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: memref.store %arg1, %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> bool x = a == b; - // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP0:.+]] = arith.cmpi eq, %[[LOAD0]], %[[LOAD1]] : i32 // CHECK: %[[EXT0:.+]] = arith.extui %[[CMP0]] : i1 to i8 - // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a != b; - // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP1:.+]] = arith.cmpi ne, %[[LOAD2]], %[[LOAD3]] : i32 // CHECK: %[[EXT1:.+]] = arith.extui %[[CMP1]] : i1 to i8 - // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a < b; - // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP2:.+]] = arith.cmpi ult, %[[LOAD4]], %[[LOAD5]] : i32 // CHECK: %[[EXT2:.+]] = arith.extui %[[CMP2]] : i1 to i8 - // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a <= b; - // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP3:.+]] = arith.cmpi ule, %[[LOAD6]], %[[LOAD7]] : i32 // CHECK: %[[EXT3:.+]] = arith.extui %[[CMP3]] : i1 to i8 - // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a > b; - // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP4:.+]] = arith.cmpi ugt, %[[LOAD8]], %[[LOAD9]] : i32 // CHECK: %[[EXT4:.+]] = arith.extui %[[CMP4]] : i1 to i8 - // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a >= b; - // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[CMP5:.+]] = arith.cmpi uge, %[[LOAD10]], %[[LOAD11]] : i32 // CHECK: %[[EXT5:.+]] = arith.extui %[[CMP5]] : i1 to i8 - // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> return x; // CHECK: return } bool testFloatingPointCmpOps(float a, float b) { - // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref - // CHECK: memref.store %arg0, %[[ALLOC1]][] : memref - // CHECK: memref.store %arg1, %[[ALLOC2]][] : memref + // CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xf32> + // CHECK: %[[ALLOC2:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xf32> + // CHECK: %[[ALLOC3:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: %[[ALLOC4:.+]] = memref.alloca() {alignment = 1 : i64} : memref<1xi8> + // CHECK: memref.store %arg0, %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: memref.store %arg1, %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> bool x = a == b; - // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD0:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD1:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP0:.+]] = arith.cmpf oeq, %[[LOAD0]], %[[LOAD1]] : f32 // CHECK: %[[EXT0:.+]] = arith.extui %[[CMP0]] : i1 to i8 - // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT0]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a != b; - // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD2:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD3:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP1:.+]] = arith.cmpf une, %[[LOAD2]], %[[LOAD3]] : f32 // CHECK: %[[EXT1:.+]] = arith.extui %[[CMP1]] : i1 to i8 - // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT1]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a < b; - // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD4:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD5:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP2:.+]] = arith.cmpf olt, %[[LOAD4]], %[[LOAD5]] : f32 // CHECK: %[[EXT2:.+]] = arith.extui %[[CMP2]] : i1 to i8 - // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT2]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a <= b; - // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD6:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD7:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP3:.+]] = arith.cmpf ole, %[[LOAD6]], %[[LOAD7]] : f32 // CHECK: %[[EXT3:.+]] = arith.extui %[[CMP3]] : i1 to i8 - // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT3]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a > b; - // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD8:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD9:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP4:.+]] = arith.cmpf ogt, %[[LOAD8]], %[[LOAD9]] : f32 // CHECK: %[[EXT4:.+]] = arith.extui %[[CMP4]] : i1 to i8 - // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT4]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> x = a >= b; - // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][] : memref + // CHECK: %[[LOAD10:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xf32> + // CHECK: %[[LOAD11:.+]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xf32> // CHECK: %[[CMP5:.+]] = arith.cmpf oge, %[[LOAD10]], %[[LOAD11]] : f32 // CHECK: %[[EXT5:.+]] = arith.extui %[[CMP5]] : i1 to i8 - // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXT5]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi8> return x; // CHECK: return diff --git a/clang/test/CIR/Lowering/ThroughMLIR/doWhile.c b/clang/test/CIR/Lowering/ThroughMLIR/doWhile.c index 2a4adb1f0091..36b744acfe46 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/doWhile.c +++ b/clang/test/CIR/Lowering/ThroughMLIR/doWhile.c @@ -23,26 +23,26 @@ void nestedDoWhile() { } // CHECK: func.func @sum() -> i32 { -// CHECK: %[[ALLOC:.+]] = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[ALLOC0:.+]] = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref +// CHECK: %[[ALLOC:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[ALLOC0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[ALLOC1:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -// CHECK: memref.store %[[C0_I32]], %[[ALLOC0]][] : memref +// CHECK: memref.store %[[C0_I32]], %[[ALLOC0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C0_I32_2:.+]] = arith.constant 0 : i32 -// CHECK: memref.store %[[C0_I32_2]], %[[ALLOC1]][] : memref +// CHECK: memref.store %[[C0_I32_2]], %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: memref.alloca_scope { // CHECK: scf.while : () -> () { // CHECK: memref.alloca_scope { -// CHECK: %[[VAR1:.+]] = memref.load %[[ALLOC1]][] : memref -// CHECK: %[[VAR2:.+]] = memref.load %[[ALLOC0]][] : memref +// CHECK: %[[VAR1:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[VAR2:.+]] = memref.load %[[ALLOC0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[ADD:.+]] = arith.addi %[[VAR2]], %[[VAR1]] : i32 -// CHECK: memref.store %[[ADD]], %[[ALLOC0]][] : memref -// CHECK: %[[VAR3:.+]] = memref.load %[[ALLOC1]][] : memref +// CHECK: memref.store %[[ADD]], %[[ALLOC0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[VAR3:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 // CHECK: %[[ADD1:.+]] = arith.addi %[[VAR3]], %[[C1_I32]] : i32 -// CHECK: memref.store %[[ADD1]], %[[ALLOC1]][] : memref +// CHECK: memref.store %[[ADD1]], %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: } -// CHECK: %[[VAR4:.+]] = memref.load %[[ALLOC1]][] : memref +// CHECK: %[[VAR4:.+]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C10_I32:.+]] = arith.constant 10 : i32 // CHECK: %[[CMP:.+]] = arith.cmpi sle, %[[VAR4]], %[[C10_I32]] : i32 // CHECK: scf.condition(%[[CMP]]) @@ -50,41 +50,41 @@ void nestedDoWhile() { // CHECK: scf.yield // CHECK: } // CHECK: } -// CHECK: %[[LOAD:.+]] = memref.load %[[ALLOC0]][] : memref -// CHECK: memref.store %[[LOAD]], %[[ALLOC]][] : memref -// CHECK: %[[RET:.+]] = memref.load %[[ALLOC]][] : memref +// CHECK: %[[LOAD:.+]] = memref.load %[[ALLOC0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: memref.store %[[LOAD]], %[[ALLOC]][{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[RET:.+]] = memref.load %[[ALLOC]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: return %[[RET]] : i32 // CHECK: func.func @nestedDoWhile() { -// CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref +// CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -// CHECK: memref.store %[[C0_I32]], %[[alloca]][] : memref +// CHECK: memref.store %[[C0_I32]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: memref.alloca_scope { // CHECK: scf.while : () -> () { // CHECK: memref.alloca_scope { -// CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +// CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 // CHECK: %[[ONE:.+]] = arith.addi %[[ZERO]], %[[C1_I32]] : i32 -// CHECK: memref.store %[[ONE]], %[[alloca]][] : memref +// CHECK: memref.store %[[ONE]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C0_I32_1:.+]] = arith.constant 0 : i32 -// CHECK: memref.store %[[C0_I32_1]], %[[alloca_0]][] : memref +// CHECK: memref.store %[[C0_I32_1]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: memref.alloca_scope { // CHECK: scf.while : () -> () { -// CHECK: %[[EIGHT:.+]] = memref.load %[[alloca_0]][] : memref +// CHECK: %[[EIGHT:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C2_I32_3:.+]] = arith.constant 2 : i32 // CHECK: %[[NINE:.+]] = arith.cmpi slt, %[[EIGHT]], %[[C2_I32_3]] : i32 // CHECK: scf.condition(%[[NINE]]) // CHECK: } do { -// CHECK: %[[EIGHT]] = memref.load %[[alloca_0]][] : memref +// CHECK: %[[EIGHT]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1_I32_3:.+]] = arith.constant 1 : i32 // CHECK: %[[NINE]] = arith.addi %[[EIGHT]], %[[C1_I32_3]] : i32 -// CHECK: memref.store %[[NINE]], %[[alloca_0]][] : memref +// CHECK: memref.store %[[NINE]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: scf.yield // CHECK: } // CHECK: } // CHECK: } -// CHECK: %[[TWO:.+]] = memref.load %[[alloca]][] : memref +// CHECK: %[[TWO:.+]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 // CHECK: %[[THREE:.+]] = arith.cmpi slt, %[[TWO]], %[[C2_I32]] : i32 // CHECK: scf.condition(%[[THREE]]) diff --git a/clang/test/CIR/Lowering/ThroughMLIR/dot.cir b/clang/test/CIR/Lowering/ThroughMLIR/dot.cir index 5fc5311a65a9..0dbeec284514 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/dot.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/dot.cir @@ -17,13 +17,13 @@ module { } // CHECK: module { -// CHECK-NEXT: func.func @dot(%arg0: memref) -> i32 { -// CHECK-NEXT: %alloca = memref.alloca() {alignment = 8 : i64} : memref> -// CHECK-NEXT: %alloca_0 = memref.alloca() {alignment = 4 : i64} : memref -// CHECK-NEXT: %alloca_1 = memref.alloca() {alignment = 8 : i64} : memref> -// CHECK-NEXT: memref.store %arg0, %alloca[] : memref> -// CHECK-NEXT: %0 = memref.load %alloca[] : memref> -// CHECK-NEXT: memref.store %0, %alloca_1[] : memref> -// CHECK-NEXT: %c0_i32 = arith.constant 0 : i32 -// CHECK-NEXT: %1 = memref.load %alloca_0[] : memref +// CHECK-NEXT: func.func @dot(%arg0: memref) -> i32 { +// CHECK-NEXT: %alloca = memref.alloca() {alignment = 8 : i64} : memref<1xmemref> +// CHECK-NEXT: %alloca_0 = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK-NEXT: %alloca_1 = memref.alloca() {alignment = 8 : i64} : memref<1xmemref> +// CHECK: memref.store %arg0, %alloca[{{%c0(_[0-9]+)?}}] : memref<1xmemref> +// CHECK: %0 = memref.load %alloca[{{%c0(_[0-9]+)?}}] : memref<1xmemref> +// CHECK: memref.store %0, %alloca_1[{{%c0(_[0-9]+)?}}] : memref<1xmemref> +// CHECK: %c0_i32 = arith.constant 0 : i32 +// CHECK: %1 = memref.load %alloca_0[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK-NEXT: return %1 : i32 diff --git a/clang/test/CIR/Lowering/ThroughMLIR/for.cpp b/clang/test/CIR/Lowering/ThroughMLIR/for.cpp index 60922d18fbca..987978ccad6d 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/for.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/for.cpp @@ -9,9 +9,9 @@ void constantLoopBound() { } // CHECK-LABEL: func.func @_Z17constantLoopBoundv() { // CHECK: memref.alloca_scope { -// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref +// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // CHECK: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-NOT: memref.store %[[C0]], {{.*}}[] : memref +// CHECK-NOT: memref.store %[[C0]], {{.*}}[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C100:.*]] = arith.constant 100 : i32 // CHECK: %[[C1:.*]] = arith.constant 1 : i32 // CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[C100]] step %[[C1]] : i32 { @@ -28,9 +28,9 @@ void constantLoopBound_LE() { } // CHECK-LABEL: func.func @_Z20constantLoopBound_LEv() { // CHECK: memref.alloca_scope { -// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref +// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // CHECK: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-NOT: memref.store %[[C0]], {{.*}}[] : memref +// CHECK-NOT: memref.store %[[C0]], {{.*}}[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C100:.*]] = arith.constant 100 : i32 // CHECK: %[[C1:.*]] = arith.constant 1 : i32 // CHECK: %[[C101:.*]] = arith.addi %c100_i32, %c1_i32 : i32 @@ -48,13 +48,13 @@ void variableLoopBound(int l, int u) { a[i] = 3; } // CHECK-LABEL: func.func @_Z17variableLoopBoundii -// CHECK: memref.store %arg0, %alloca[] : memref -// CHECK: memref.store %arg1, %alloca_0[] : memref +// CHECK: memref.store %arg0, %alloca[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: memref.store %arg1, %alloca_0[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: memref.alloca_scope { -// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[LOWER:.*]] = memref.load %alloca[] : memref -// CHECK-NOT: memref.store %[[LOWER]], {{.*}}[] : memref -// CHECK: %[[UPPER:.*]] = memref.load %alloca_0[] : memref +// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[LOWER:.*]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK-NOT: memref.store %[[LOWER]], {{.*}}[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[UPPER:.*]] = memref.load %alloca_0[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1:.*]] = arith.constant 1 : i32 // CHECK: scf.for %[[I:.*]] = %[[LOWER]] to %[[UPPER]] step %[[C1]] : i32 { // CHECK: %[[C3:.*]] = arith.constant 3 : i32 @@ -69,13 +69,13 @@ void variableLoopBound_LE(int l, int u) { a[i] = 3; } // CHECK-LABEL: func.func @_Z20variableLoopBound_LEii -// CHECK: memref.store %arg0, %alloca[] : memref -// CHECK: memref.store %arg1, %alloca_0[] : memref +// CHECK: memref.store %arg0, %alloca[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: memref.store %arg1, %alloca_0[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: memref.alloca_scope { -// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref -// CHECK: %[[LOWER:.*]] = memref.load %alloca[] : memref -// CHECK-NOT: memref.store %[[LOWER]], {{.*}}[] : memref -// CHECK: %[[UPPER_DEC_1:.*]] = memref.load %alloca_0[] : memref +// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// CHECK: %[[LOWER:.*]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK-NOT: memref.store %[[LOWER]], {{.*}}[{{%c0(_[0-9]+)?}}] : memref<1xi32> +// CHECK: %[[UPPER_DEC_1:.*]] = memref.load %alloca_0[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1:.*]] = arith.constant 1 : i32 // CHECK: %[[UPPER:.*]] = arith.addi %[[UPPER_DEC_1]], %[[C1]] : i32 // CHECK: %[[C4:.*]] = arith.constant 4 : i32 @@ -93,9 +93,9 @@ void incArray() { } // CHECK-LABEL: func.func @_Z8incArrayv() { // CHECK: memref.alloca_scope { -// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref +// CHECK-NOT: {{.*}} = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // CHECK: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-NOT: memref.store %[[C0]], {{.*}}[] : memref +// CHECK-NOT: memref.store %[[C0]], {{.*}}[{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C100:.*]] = arith.constant 100 : i32 // CHECK: %[[C1:.*]] = arith.constant 1 : i32 // CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[C100]] step %[[C1]] : i32 { diff --git a/clang/test/CIR/Lowering/ThroughMLIR/for_with_continue.cpp b/clang/test/CIR/Lowering/ThroughMLIR/for_with_continue.cpp index aec0ef995504..7fa4cf0d738f 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/for_with_continue.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/for_with_continue.cpp @@ -6,14 +6,14 @@ void for_continue() { continue; // CHECK: scf.while : () -> () { - // CHECK: %[[IV:.+]] = memref.load %alloca[] + // CHECK: %[[IV:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[CMP:.+]] = arith.cmpi slt, %[[IV]], %c100_i32 // CHECK: scf.condition(%[[CMP]]) // CHECK: } do { - // CHECK: %[[IV2:.+]] = memref.load %alloca[] + // CHECK: %[[IV2:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[ONE:.+]] = arith.constant 1 // CHECK: %[[CMP2:.+]] = arith.addi %[[IV2]], %[[ONE]] - // CHECK: memref.store %[[CMP2]], %alloca[] + // CHECK: memref.store %[[CMP2]], %alloca[{{%c0(_[0-9]+)?}}] // CHECK: scf.yield // CHECK: } } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/global.cir b/clang/test/CIR/Lowering/ThroughMLIR/global.cir index 4415c6409a0b..e9ba9e42b2bc 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/global.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/global.cir @@ -34,20 +34,20 @@ module { } } -// MLIR: memref.global "public" @i : memref = dense<2> -// MLIR: memref.global "public" @f : memref = dense<3.000000e+00> -// MLIR: memref.global "public" @b : memref = dense<1> +// MLIR: memref.global "public" @i : memref<1xi32> = dense<2> +// MLIR: memref.global "public" @f : memref<1xf32> = dense<3.000000e+00> +// MLIR: memref.global "public" @b : memref<1xi8> = dense<1> // MLIR: memref.global "private" @a : memref<100xi32> // MLIR: memref.global "public" @aa : memref<256x256xi32> = dense<0> -// MLIR: memref.get_global @i : memref -// MLIR: memref.get_global @f : memref -// MLIR: memref.get_global @b : memref +// MLIR: memref.get_global @i : memref<1xi32> +// MLIR: memref.get_global @f : memref<1xf32> +// MLIR: memref.get_global @b : memref<1xi8> // MLIR: memref.get_global @a : memref<100xi32> // MLIR: memref.get_global @aa : memref<256x256xi32> -// LLVM: @i = global i32 2 -// LLVM: @f = global float 3.000000e+00 -// LLVM: @b = global i8 1 +// LLVM: @i = global [1 x i32] [i32 2] +// LLVM: @f = global [1 x float] [float 3.000000e+00] +// LLVM: @b = global [1 x i8] c"\01" // LLVM: @a = private global [100 x i32] undef // LLVM: @aa = global [256 x [256 x i32]] zeroinitializer // LLVM: load i32, ptr @i diff --git a/clang/test/CIR/Lowering/ThroughMLIR/global.cpp b/clang/test/CIR/Lowering/ThroughMLIR/global.cpp index a79707746eff..d64488a11d2e 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/global.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/global.cpp @@ -4,7 +4,7 @@ float f[32000]; // CHECK: memref.global "public" @f : memref<32000xf32> = dense<0.000000e+00> double d; -// CHECK: memref.global "public" @d : memref = dense<0.000000e+00> +// CHECK: memref.global "public" @d : memref<1xf64> = dense<0.000000e+00> float f_init[] = {1.0, 2.0}; // CHECK: memref.global "public" @f_init : memref<2xf32> = dense<[1.000000e+00, 2.000000e+00]> int i_init[2] = {0, 1}; diff --git a/clang/test/CIR/Lowering/ThroughMLIR/if.c b/clang/test/CIR/Lowering/ThroughMLIR/if.c index 142846d6a631..30b78bb8835d 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/if.c +++ b/clang/test/CIR/Lowering/ThroughMLIR/if.c @@ -12,26 +12,26 @@ void foo() { } //CHECK: func.func @foo() { -//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref -//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 -//CHECK: memref.store %[[C2_I32]], %[[alloca]][] : memref +//CHECK: memref.store %[[C2_I32]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { -//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C0_I32_1:.+]] = arith.constant 0 : i32 //CHECK: %[[ONE:.+]] = arith.cmpi sgt, %[[ZERO]], %[[C0_I32_1]] : i32 //CHECK: scf.if %[[ONE]] { -//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][] : memref +//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 //CHECK: %[[SEVEN:.+]] = arith.addi %[[SIX]], %[[C1_I32]] : i32 -//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } else { -//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][] : memref +//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant -1 : i32 //CHECK: %[[SEVEN:.+]] = arith.addi %[[SIX]], %[[C1_I32]] : i32 -//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } //CHECK: } //CHECK: return @@ -46,21 +46,21 @@ void foo2() { } //CHECK: func.func @foo2() { -//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref -//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 -//CHECK: memref.store %[[C2_I32]], %[[alloca]][] : memref +//CHECK: memref.store %[[C2_I32]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { -//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C3_I32:.+]] = arith.constant 3 : i32 //CHECK: %[[ONE:.+]] = arith.cmpi slt, %[[ZERO]], %[[C3_I32]] : i32 //CHECK: scf.if %[[ONE]] { -//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][] : memref +//CHECK: %[[SIX:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 //CHECK: %[[SEVEN:.+]] = arith.addi %[[SIX]], %[[C1_I32]] : i32 -//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[SEVEN]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } //CHECK: } //CHECK: return @@ -81,34 +81,34 @@ void foo3() { //CHECK: func.func @foo3() { -//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref -//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 -//CHECK: memref.store %[[C2_I32]], %[[alloca]][] : memref +//CHECK: memref.store %[[C2_I32]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[C0_I32]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { -//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C3_I32:.+]] = arith.constant 3 : i32 //CHECK: %[[ONE:.+]] = arith.cmpi slt, %[[ZERO]], %[[C3_I32]] : i32 //CHECK: scf.if %[[ONE]] { -//CHECK: %[[alloca_2:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca_2:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 -//CHECK: memref.store %[[C1_I32]], %[[alloca_2]][] : memref +//CHECK: memref.store %[[C1_I32]], %[[alloca_2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { -//CHECK: %[[SIX:.+]] = memref.load %[[alloca_2]][] : memref +//CHECK: %[[SIX:.+]] = memref.load %[[alloca_2]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C2_I32_3:.+]] = arith.constant 2 : i32 //CHECK: %[[SEVEN:.+]] = arith.cmpi sgt, %[[SIX]], %[[C2_I32_3]] : i32 //CHECK: scf.if %[[SEVEN]] { -//CHECK: %[[TWELVE:.+]] = memref.load %[[alloca_0]][] : memref +//CHECK: %[[TWELVE:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32_5:.+]] = arith.constant 1 : i32 //CHECK: %[[THIRTEEN:.+]] = arith.addi %[[TWELVE]], %[[C1_I32_5]] : i32 -//CHECK: memref.store %[[THIRTEEN]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[THIRTEEN]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } else { -//CHECK: %[[TWELVE:.+]] = memref.load %[[alloca_0]][] : memref +//CHECK: %[[TWELVE:.+]] = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32_5:.+]] = arith.constant -1 : i32 //CHECK: %[[THIRTEEN:.+]] = arith.addi %[[TWELVE]], %[[C1_I32_5]] : i32 -//CHECK: memref.store %[[THIRTEEN]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[THIRTEEN]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } //CHECK: } //CHECK: } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/memref.cir b/clang/test/CIR/Lowering/ThroughMLIR/memref.cir index 098a5f6edcb4..f2ab7f328bd0 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/memref.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/memref.cir @@ -14,21 +14,27 @@ module { // MLIR: module { // MLIR-NEXT: func @foo() -> i32 { -// MLIR-NEXT: [[alloca:%[a-z0-9]+]] = memref.alloca() {alignment = 4 : i64} : memref +// MLIR-NEXT: [[alloca:%[a-z0-9]+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // MLIR-NEXT: %c1_i32 = arith.constant 1 : i32 -// MLIR-NEXT: memref.store %c1_i32, [[alloca]][] : memref -// MLIR-NEXT: [[load:%[a-z0-9]+]] = memref.load [[alloca]][] : memref +// MLIR-NEXT: [[const0:%[a-z0-9_]+]] = arith.constant 0 : index +// MLIR-NEXT: memref.store %c1_i32, [[alloca]][[[const0]]] : memref<1xi32> +// MLIR-NEXT: [[const0_1:%[a-z0-9_]+]] = arith.constant 0 : index +// MLIR-NEXT: [[load:%[a-z0-9]+]] = memref.load [[alloca]][[[const0_1]]] : memref<1xi32> // MLIR-NEXT: return [[load]] : i32 // MLIR-NEXT: } // MLIR-NEXT: } // LLVM: define i32 @foo() // LLVM-NEXT: %1 = alloca i32, i64 -// LLVM-NEXT: %2 = insertvalue { ptr, ptr, i64 } poison, ptr %1, 0 -// LLVM-NEXT: %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 -// LLVM-NEXT: %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 -// LLVM-NEXT: %5 = extractvalue { ptr, ptr, i64 } %4, 1 -// LLVM-NEXT: store i32 1, ptr %5, align 4 -// LLVM-NEXT: %6 = extractvalue { ptr, ptr, i64 } %4, 1 -// LLVM-NEXT: %7 = load i32, ptr %6, align 4 -// LLVM-NEXT: ret i32 %7 +// LLVM-NEXT: %2 = insertvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } poison, ptr %1, 0 +// LLVM-NEXT: %3 = insertvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %2, ptr %1, 1 +// LLVM-NEXT: %4 = insertvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %3, i64 0, 2 +// LLVM-NEXT: %5 = insertvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %4, i64 1, 3, 0 +// LLVM-NEXT: %6 = insertvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %5, i64 1, 4, 0 +// LLVM-NEXT: %7 = extractvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %6, 1 +// LLVM-NEXT: %8 = getelementptr inbounds nuw i32, ptr %7, i64 0 +// LLVM-NEXT: store i32 1, ptr %8, align 4 +// LLVM-NEXT: %9 = extractvalue { ptr, ptr, i64, [1 x i64], [1 x i64] } %6, 1 +// LLVM-NEXT: %10 = getelementptr inbounds nuw i32, ptr %9, i64 0 +// LLVM-NEXT: %11 = load i32, ptr %10, align 4 +// LLVM-NEXT: ret i32 %11 diff --git a/clang/test/CIR/Lowering/ThroughMLIR/ptr-arg.cir b/clang/test/CIR/Lowering/ThroughMLIR/ptr-arg.cir new file mode 100644 index 000000000000..5e8da3ad9ce7 --- /dev/null +++ b/clang/test/CIR/Lowering/ThroughMLIR/ptr-arg.cir @@ -0,0 +1,46 @@ +// RUN: cir-opt %s -cir-to-mlir | FileCheck %s -check-prefix=MLIR + +!s32i = !cir.int +!u32i = !cir.int +module { + cir.func @ptrLoad(%arg0: !cir.ptr) -> !s32i { + %0 = cir.load align(4) %arg0 : !cir.ptr, !s32i + cir.return %0 : !s32i +// MLIR-LABEL: func.func @ptrLoad +// MLIR: %[[VALUE:.*]] = memref.load %arg0[{{%c0(_[0-9]+)?}}] : memref +// MLIR: return %[[VALUE]] : i32 + } + cir.func @ptrStore(%arg0: !cir.ptr, %arg1: !s32i) -> !s32i { + cir.store align(4) %arg1, %arg0 : !s32i, !cir.ptr + %0 = cir.load align(4) %arg0 : !cir.ptr, !s32i + cir.return %0 : !s32i +// MLIR-LABEL: func.func @ptrStore +// MLIR: memref.store %arg1, %arg0[{{%c0(_[0-9]+)?}}] : memref +// MLIR: %[[VALUE:.*]] = memref.load %arg0[{{%c0(_[0-9]+)?}}] : memref +// MLIR: return %[[VALUE]] : i32 + } + cir.func @arrayLoad(%arg0: !cir.ptr, %arg1: !u32i) -> !s32i { + %0 = cir.ptr_stride %arg0, %arg1 : (!cir.ptr, !u32i) -> !cir.ptr + %1 = cir.load align(4) %0 : !cir.ptr, !s32i + cir.return %1 : !s32i +// MLIR-LABEL: func.func @arrayLoad +// MLIR: %[[IDX:.*]] = arith.index_cast %arg1 : i32 to index +// MLIR: %[[VALUE:.*]] = memref.load %arg0[%[[IDX]]] : memref +// MLIR: return %[[VALUE]] : i32 + } + + cir.func @arrayStore(%arg0: !cir.ptr, %arg1: !s32i, %arg2: !u32i) -> !s32i { + %0 = cir.ptr_stride %arg0, %arg2 : (!cir.ptr, !u32i) -> !cir.ptr + cir.store align(4) %arg1, %0 : !s32i, !cir.ptr + %1 = cir.ptr_stride %arg0, %arg2 : (!cir.ptr, !u32i) -> !cir.ptr + %2 = cir.load align(4) %1 : !cir.ptr, !s32i + cir.return %2 : !s32i +// MLIR-LABEL: func.func @arrayStore +// MLIR: %[[IDX:.*]] = arith.index_cast %arg2 : i32 to index +// MLIR: memref.store %arg1, %arg0[%[[IDX]]] : memref +// MLIR: %[[IDX2:.*]] = arith.index_cast %arg2 : i32 to index +// MLIR: %[[VALUE:.*]] = memref.load %arg0[%[[IDX2]]] : memref +// MLIR: return %[[VALUE]] : i32 + } +} + diff --git a/clang/test/CIR/Lowering/ThroughMLIR/ptrstride-ptr.cir b/clang/test/CIR/Lowering/ThroughMLIR/ptrstride-ptr.cir index ffd9e9646e9d..12a1908fa697 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/ptrstride-ptr.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/ptrstride-ptr.cir @@ -3,17 +3,10 @@ !s32i = !cir.int module { cir.func @raw_pointer(%p : !cir.ptr) -> !s32i { - // MLIR: %[[TWO:.*]] = arith.constant 2 : i32 - // MLIR-NEXT: %[[TYPEOFFSET:.*]] = ptr.type_offset i32 : index + // MLIR: func.func @raw_pointer(%[[ARG0:.*]]: memref) -> i32 { + // MLIR: %[[TWO:.*]] = arith.constant 2 : i32 // MLIR-NEXT: %[[I:.*]] = arith.index_cast %[[TWO]] : i32 to index - // MLIR-NEXT: %[[OFFSET:.*]] = arith.muli %[[I]], %[[TYPEOFFSET]] : index - // MLIR-NEXT: %[[CAST1:.*]] = memref.memory_space_cast %arg0 : memref to memref - // MLIR-NEXT: %[[META:.*]] = ptr.get_metadata %[[CAST1]] : memref - // MLIR-NEXT: %[[P1:.*]] = ptr.to_ptr %[[CAST1]] : memref -> <#ptr.generic_space> - // MLIR-NEXT: %[[P2:.*]] = ptr.ptr_add %[[P1]], %[[OFFSET]] : !ptr.ptr<#ptr.generic_space>, index - // MLIR-NEXT: %[[PP:.*]] = ptr.from_ptr %[[P2]] metadata %[[META]] : <#ptr.generic_space> -> memref - // MLIR-NEXT: %[[CAST2:.*]] = memref.memory_space_cast %[[PP]] : memref to memref - // MLIR-NEXT: %[[R:.*]] = memref.load %[[CAST2]][] : memref + // MLIR-NEXT: %[[R:.*]] = memref.load %[[ARG0]][%[[I]]] : memref // MLIR-NEXT: return %[[R]] : i32 %0 = cir.const #cir.int<2> : !s32i @@ -21,4 +14,4 @@ module { %2 = cir.load %1 : !cir.ptr, !s32i cir.return %2 : !s32i } -} \ No newline at end of file +} diff --git a/clang/test/CIR/Lowering/ThroughMLIR/scope.cir b/clang/test/CIR/Lowering/ThroughMLIR/scope.cir index c258168ce93d..fddf16b09aee 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/scope.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/scope.cir @@ -14,9 +14,10 @@ module { // MLIR: func.func @foo() // MLIR-NEXT: memref.alloca_scope -// MLIR-NEXT: %alloca = memref.alloca() {alignment = 4 : i64} : memref +// MLIR-NEXT: %alloca = memref.alloca() {alignment = 4 : i64} : memref<1xi32> // MLIR-NEXT: %c4_i32 = arith.constant 4 : i32 -// MLIR-NEXT: memref.store %c4_i32, %alloca[] : memref +// MLIR-NEXT: %c0 = arith.constant 0 : index +// MLIR-NEXT: memref.store %c4_i32, %alloca[%c0] : memref<1xi32> // MLIR-NEXT: } // MLIR-NEXT: return @@ -28,9 +29,9 @@ module { // LLVM-NEXT: %3 = alloca i32, i64 1, align 4 // LLVM: store i32 4, ptr {{.*}}, align 4 // LLVM-NEXT: call void @llvm.stackrestore.p0(ptr %1) -// LLVM-NEXT: br label %8 +// LLVM-NEXT: br label %[[BRANCH:[0-9]+]] // LLVM-EMPTY: -// LLVM-NEXT: 8: +// LLVM-NEXT: [[BRANCH]]: // LLVM-NEXT: ret void // LLVM-NEXT: } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/select.cir b/clang/test/CIR/Lowering/ThroughMLIR/select.cir index c74acb99dbd2..8591d39d9fa3 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/select.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/select.cir @@ -17,12 +17,14 @@ module { // MLIR: module { // MLIR-NEXT: func.func @foo(%[[ARG0:.*]]: i32) -> i32 { -// MLIR-NEXT: %[[ALLOCA:.*]] = memref.alloca() {alignment = 4 : i64} : memref -// MLIR-NEXT: memref.store %[[ARG0]], %[[ALLOCA]][] : memref +// MLIR-NEXT: %[[ALLOCA:.*]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> +// MLIR-NEXT: %[[C0_IDX:.*]] = arith.constant 0 : index +// MLIR-NEXT: memref.store %[[ARG0]], %[[ALLOCA]][%[[C0_IDX]]] : memref<1xi32> // MLIR-NEXT: %[[C100_I32:.*]] = arith.constant 100 : i32 // MLIR-NEXT: %[[C10_I32:.*]] = arith.constant 10 : i32 // MLIR-NEXT: %[[C20_I32:.*]] = arith.constant 20 : i32 -// MLIR-NEXT: %[[V:.*]] = memref.load %[[ALLOCA]][] : memref +// MLIR-NEXT: %[[C0_IDX2:.*]] = arith.constant 0 : index +// MLIR-NEXT: %[[V:.*]] = memref.load %[[ALLOCA]][%[[C0_IDX2]]] : memref<1xi32> // MLIR-NEXT: %[[C:.*]] = arith.cmpi ugt, %[[V]], %[[C100_I32]] : i32 // MLIR-NEXT: %[[OP:.*]] = arith.select %[[C]], %[[C100_I32]], %[[C10_I32]] : i32 // MLIR-NEXT: return %[[OP]] : i32 diff --git a/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir b/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir index 819b4c3b941e..29ceb9ada51d 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir @@ -33,7 +33,8 @@ cir.func @_Z1xi(%arg0: !s32i) -> !s32i { // MLIR-NEXT: %c5_i32 = arith.constant 5 : i32 // MLIR-NEXT: scf.yield %c5_i32 : i32 // MLIR-NEXT: } -// MLIR-NEXT: memref.store %2, %alloca_0[] : memref +// MLIR-NEXT: %[[CONST0:[a-z0-9_]+]] = arith.constant 0 : index +// MLIR-NEXT: memref.store %2, %alloca_0[%[[CONST0]]] : memref<1xi32> // MLIR-CANONICALIZE: %[[CMP:.*]] = arith.cmpi sgt // MLIR-CANONICALIZE: arith.select %[[CMP]] diff --git a/clang/test/CIR/Lowering/ThroughMLIR/vectype.cpp b/clang/test/CIR/Lowering/ThroughMLIR/vectype.cpp index 94cea264fe93..5263e32ac846 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/vectype.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/vectype.cpp @@ -5,38 +5,38 @@ typedef int vi4 __attribute__((vector_size(16))); void vector_int_test(int x) { - // CHECK: %[[ALLOC1:.*]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC2:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC3:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC4:.*]] = memref.alloca() {alignment = 4 : i64} : memref - // CHECK: %[[ALLOC5:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC6:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC7:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC8:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC9:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC10:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC11:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC12:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC13:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC14:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC15:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC16:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC17:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - // CHECK: %[[ALLOC18:.*]] = memref.alloca() {alignment = 16 : i64} : memref> - - // CHECK: memref.store %arg0, %[[ALLOC1]][] : memref + // CHECK: %[[ALLOC1:.*]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC2:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC3:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC4:.*]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> + // CHECK: %[[ALLOC5:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC6:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC7:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC8:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC9:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC10:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC11:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC12:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC13:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC14:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC15:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC16:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC17:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC18:.*]] = memref.alloca() {alignment = 16 : i64} : memref<1xvector<4xi32>> + + // CHECK: memref.store %arg0, %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> vi4 a = { 1, 2, 3, 4 }; // CHECK: %[[CST:.*]] = arith.constant dense<[1, 2, 3, 4]> : vector<4xi32> - // CHECK: memref.store %[[CST]], %[[ALLOC2]][] : memref> + // CHECK: memref.store %[[CST]], %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 b = {x, 5, 6, x + 1}; - // CHECK: %[[VAL1:.*]] = memref.load %[[ALLOC1]][] : memref + // CHECK: %[[VAL1:.*]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C5:.*]] = arith.constant 5 : i32 // CHECK: %[[C6:.*]] = arith.constant 6 : i32 - // CHECK: %[[VAL2:.*]] = memref.load %[[ALLOC1]][] : memref + // CHECK: %[[VAL2:.*]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[C1_I32_2:.*]] = arith.constant 1 : i32 // CHECK: %[[SUM:.*]] = arith.addi %[[VAL2]], %[[C1_I32_2]] : i32 // CHECK: %[[CST2:.*]] = arith.constant dense<0> : vector<4xi32> @@ -44,80 +44,80 @@ void vector_int_test(int x) { // CHECK: %[[VEC5:.*]] = vector.insert %[[C5]], %[[VEC4]] [1] : i32 into vector<4xi32> // CHECK: %[[VEC6:.*]] = vector.insert %[[C6]], %[[VEC5]] [2] : i32 into vector<4xi32> // CHECK: %[[VEC7:.*]] = vector.insert %[[SUM]], %[[VEC6]] [3] : i32 into vector<4xi32> - // CHECK: memref.store %[[VEC7]], %[[ALLOC3]][] : memref> + // CHECK: memref.store %[[VEC7]], %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> a[x] = x; - // CHECK: %[[VAL3:.*]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[VAL4:.*]] = memref.load %[[ALLOC1]][] : memref - // CHECK: %[[VEC8:.*]] = memref.load %[[ALLOC2]][] : memref> + // CHECK: %[[VAL3:.*]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[VAL4:.*]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> + // CHECK: %[[VEC8:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[IDX_CAST:.*]] = arith.index_cast %[[VAL4]] : i32 to index // CHECK: %[[VEC9:.*]] = vector.insert %[[VAL3]], %[[VEC8]] [%[[IDX_CAST]]] : i32 into vector<4xi32> - // CHECK: memref.store %[[VEC9]], %[[ALLOC2]][] : memref> + // CHECK: memref.store %[[VEC9]], %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> int c = a[x]; - // CHECK: %[[VEC10:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL5:.*]] = memref.load %[[ALLOC1]][] : memref + // CHECK: %[[VEC10:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL5:.*]] = memref.load %[[ALLOC1]][{{%c0(_[0-9]+)?}}] : memref<1xi32> // CHECK: %[[IDX_CAST2:.*]] = arith.index_cast %[[VAL5]] : i32 to index // CHECK: %[[EXTRACT:.*]] = vector.extract %[[VEC10]][%[[IDX_CAST2]]] : i32 from vector<4xi32> - // CHECK: memref.store %[[EXTRACT]], %[[ALLOC4]][] : memref + // CHECK: memref.store %[[EXTRACT]], %[[ALLOC4]][{{%c0(_[0-9]+)?}}] : memref<1xi32> vi4 d = a + b; - // CHECK: %[[ALLOC0_1:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_1:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_1:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_1:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC2_1:.*]] = arith.addi %[[ALLOC0_1]], %[[ALLOC1_1]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC2_1]], %[[ALLOC5]][] : memref> + // CHECK: memref.store %[[ALLOC2_1]], %[[ALLOC5]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 e = a - b; - // CHECK: %[[ALLOC0_2:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_2:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_2:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_2:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC3_2:.*]] = arith.subi %[[ALLOC0_2]], %[[ALLOC1_2]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC3_2]], %[[ALLOC6]][] : memref> + // CHECK: memref.store %[[ALLOC3_2]], %[[ALLOC6]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 f = a * b; - // CHECK: %[[ALLOC0_3:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_3:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_3:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_3:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC4_1:.*]] = arith.muli %[[ALLOC0_3]], %[[ALLOC1_3]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC4_1]], %[[ALLOC7]][] : memref> + // CHECK: memref.store %[[ALLOC4_1]], %[[ALLOC7]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 g = a / b; - // CHECK: %[[ALLOC0_4:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_4:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_4:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_4:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC5_1:.*]] = arith.divsi %[[ALLOC0_4]], %[[ALLOC1_4]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC5_1]], %[[ALLOC8]][] : memref> + // CHECK: memref.store %[[ALLOC5_1]], %[[ALLOC8]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 h = a % b; - // CHECK: %[[ALLOC0_5:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_5:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_5:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_5:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC6_1:.*]] = arith.remsi %[[ALLOC0_5]], %[[ALLOC1_5]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC6_1]], %[[ALLOC9]][] : memref> + // CHECK: memref.store %[[ALLOC6_1]], %[[ALLOC9]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 i = a & b; - // CHECK: %[[ALLOC0_6:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_6:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_6:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_6:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC7_1:.*]] = arith.andi %[[ALLOC0_6]], %[[ALLOC1_6]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC7_1]], %[[ALLOC10]][] : memref> + // CHECK: memref.store %[[ALLOC7_1]], %[[ALLOC10]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 j = a | b; - // CHECK: %[[ALLOC0_7:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_7:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_7:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_7:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC8_1:.*]] = arith.ori %[[ALLOC0_7]], %[[ALLOC1_7]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC8_1]], %[[ALLOC11]][] : memref> + // CHECK: memref.store %[[ALLOC8_1]], %[[ALLOC11]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 k = a ^ b; - // CHECK: %[[ALLOC0_8:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[ALLOC1_8:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[ALLOC0_8:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[ALLOC1_8:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[ALLOC9_1:.*]] = arith.xori %[[ALLOC0_8]], %[[ALLOC1_8]] : vector<4xi32> - // CHECK: memref.store %[[ALLOC9_1]], %[[ALLOC12]][] : memref> + // CHECK: memref.store %[[ALLOC9_1]], %[[ALLOC12]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // TODO(cir) : Fix the lowering of unary operators // vi4 l = +a; @@ -126,51 +126,51 @@ void vector_int_test(int x) { vi4 o = a == b; - // CHECK: %[[VAL11:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL12:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL11:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL12:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_EQ:.*]] = arith.cmpi eq, %[[VAL11]], %[[VAL12]] : vector<4xi32> // CHECK: %[[EXT_EQ:.*]] = arith.extsi %[[CMP_EQ]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_EQ]], %[[ALLOC13]][] : memref> + // CHECK: memref.store %[[EXT_EQ]], %[[ALLOC13]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 p = a != b; - // CHECK: %[[VAL13:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL14:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL13:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL14:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_NE:.*]] = arith.cmpi ne, %[[VAL13]], %[[VAL14]] : vector<4xi32> // CHECK: %[[EXT_NE:.*]] = arith.extsi %[[CMP_NE]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_NE]], %[[ALLOC14]][] : memref> + // CHECK: memref.store %[[EXT_NE]], %[[ALLOC14]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 q = a < b; - // CHECK: %[[VAL15:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL16:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL15:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL16:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_SLT:.*]] = arith.cmpi slt, %[[VAL15]], %[[VAL16]] : vector<4xi32> // CHECK: %[[EXT_SLT:.*]] = arith.extsi %[[CMP_SLT]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_SLT]], %[[ALLOC15]][] : memref> + // CHECK: memref.store %[[EXT_SLT]], %[[ALLOC15]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 r = a > b; - // CHECK: %[[VAL17:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL18:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL17:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL18:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_SGT:.*]] = arith.cmpi sgt, %[[VAL17]], %[[VAL18]] : vector<4xi32> // CHECK: %[[EXT_SGT:.*]] = arith.extsi %[[CMP_SGT]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_SGT]], %[[ALLOC16]][] : memref> + // CHECK: memref.store %[[EXT_SGT]], %[[ALLOC16]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 s = a <= b; - // CHECK: %[[VAL19:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL20:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL19:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL20:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_SLE:.*]] = arith.cmpi sle, %[[VAL19]], %[[VAL20]] : vector<4xi32> // CHECK: %[[EXT_SLE:.*]] = arith.extsi %[[CMP_SLE]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_SLE]], %[[ALLOC17]][] : memref> + // CHECK: memref.store %[[EXT_SLE]], %[[ALLOC17]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> vi4 t = a >= b; - // CHECK: %[[VAL21:.*]] = memref.load %[[ALLOC2]][] : memref> - // CHECK: %[[VAL22:.*]] = memref.load %[[ALLOC3]][] : memref> + // CHECK: %[[VAL21:.*]] = memref.load %[[ALLOC2]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> + // CHECK: %[[VAL22:.*]] = memref.load %[[ALLOC3]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: %[[CMP_SGE:.*]] = arith.cmpi sge, %[[VAL21]], %[[VAL22]] : vector<4xi32> // CHECK: %[[EXT_SGE:.*]] = arith.extsi %[[CMP_SGE]] : vector<4xi1> to vector<4xi32> - // CHECK: memref.store %[[EXT_SGE]], %[[ALLOC18]][] : memref> + // CHECK: memref.store %[[EXT_SGE]], %[[ALLOC18]][{{%c0(_[0-9]+)?}}] : memref<1xvector<4xi32>> // CHECK: return } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/while-with-continue.cpp b/clang/test/CIR/Lowering/ThroughMLIR/while-with-continue.cpp index 5b17413f0971..541814506581 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/while-with-continue.cpp +++ b/clang/test/CIR/Lowering/ThroughMLIR/while-with-continue.cpp @@ -12,16 +12,16 @@ void while_continue() { // Only the first `i++` will be emitted. // CHECK: scf.while : () -> () { - // CHECK: %[[TMP0:.+]] = memref.load %alloca[] + // CHECK: %[[TMP0:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[HUNDRED:.+]] = arith.constant 100 // CHECK: %[[TMP1:.+]] = arith.cmpi slt, %[[TMP0]], %[[HUNDRED]] // CHECK: scf.condition(%[[TMP1]]) // CHECK: } do { // CHECK: memref.alloca_scope { - // CHECK: %[[TMP2:.+]] = memref.load %alloca[] + // CHECK: %[[TMP2:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[ONE:.+]] = arith.constant 1 // CHECK: %[[TMP3:.+]] = arith.addi %[[TMP2]], %[[ONE]] - // CHECK: memref.store %[[TMP3]], %alloca[] + // CHECK: memref.store %[[TMP3]], %alloca[{{%c0(_[0-9]+)?}}] // CHECK: } // CHECK: scf.yield // CHECK: } @@ -43,7 +43,7 @@ void while_continue_2() { // CHECK: %[[NOTALLOCA:.+]] = memref.alloca // CHECK: memref.alloca_scope { // CHECK: memref.alloca_scope { - // CHECK: %[[IV:.+]] = memref.load %[[IVADDR:.+]][] + // CHECK: %[[IV:.+]] = memref.load %[[IVADDR:.+]][{{%c0(_[0-9]+)?}}] // CHECK: %[[FIVE:.+]] = arith.constant 5 // CHECK: %[[COND:.+]] = arith.cmpi eq, %[[IV]], %[[FIVE]] // CHECK: %true = arith.constant true @@ -82,7 +82,7 @@ void while_continue_nested() { // The continue will only work on the inner while. // CHECK: scf.while : () -> () { - // CHECK: %[[IV:.+]] = memref.load %alloca[] + // CHECK: %[[IV:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[TEN:.+]] = arith.constant 10 // CHECK: %[[LT:.+]] = arith.cmpi slt, %[[IV]], %[[TEN]] // CHECK: scf.condition(%[[LT]]) @@ -96,10 +96,10 @@ void while_continue_nested() { // CHECK: scf.yield // CHECK: } // CHECK: } - // CHECK: %[[IV2:.+]] = memref.load %alloca[] + // CHECK: %[[IV2:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] // CHECK: %[[ONE:.+]] = arith.constant 1 // CHECK: %[[ADD:.+]] = arith.addi %[[IV2]], %[[ONE]] - // CHECK: memref.store %[[ADD]], %alloca[] + // CHECK: memref.store %[[ADD]], %alloca[{{%c0(_[0-9]+)?}}] // CHECK: } // CHECK: scf.yield // CHECK: } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/while.c b/clang/test/CIR/Lowering/ThroughMLIR/while.c index 983be1b1d1ea..463ace944c9c 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/while.c +++ b/clang/test/CIR/Lowering/ThroughMLIR/while.c @@ -20,21 +20,25 @@ void nestedWhile() { } //CHECK: func.func @singleWhile() { -//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32]], %[[alloca]][] : memref +//CHECK: %[[C0_IDX:.+]] = arith.constant 0 : index +//CHECK: memref.store %[[C0_I32]], %[[alloca]][%[[C0_IDX]]] : memref<1xi32> //CHECK: memref.alloca_scope { //CHECK: scf.while : () -> () { -//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +//CHECK: %[[C0_IDX2:.+]] = arith.constant 0 : index +//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][%[[C0_IDX2]]] : memref<1xi32> //CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 //CHECK: %[[ONE:.+]] = arith.cmpi slt, %[[ZERO:.+]], %[[C2_I32]] : i32 //CHECK: scf.condition(%[[ONE]]) //CHECK: } do { //CHECK: memref.alloca_scope { -//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][] : memref +//CHECK: %[[C0_IDX3:.+]] = arith.constant 0 : index +//CHECK: %[[ZERO:.+]] = memref.load %[[alloca]][%[[C0_IDX3]]] : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 //CHECK: %[[ONE:.+]] = arith.addi %0, %[[C1_I32:.+]] : i32 -//CHECK: memref.store %[[ONE:.+]], %[[alloca]][] : memref +//CHECK: %[[C0_IDX4:.+]] = arith.constant 0 : index +//CHECK: memref.store %[[ONE:.+]], %[[alloca]][%[[C0_IDX4]]] : memref<1xi32> //CHECK: } //CHECK: scf.yield //CHECK: } @@ -43,38 +47,38 @@ void nestedWhile() { //CHECK: } //CHECK: func.func @nestedWhile() { -//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C0_I32:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32]], %[[alloca]][] : memref +//CHECK: memref.store %[[C0_I32]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { //CHECK: scf.while : () -> () { -//CHECK: %[[ZERO:.+]] = memref.load %alloca[] : memref +//CHECK: %[[ZERO:.+]] = memref.load %alloca[{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C2_I32:.+]] = arith.constant 2 : i32 //CHECK: %[[ONE:.+]] = arith.cmpi slt, %[[ZERO]], %[[C2_I32]] : i32 //CHECK: scf.condition(%[[ONE]]) //CHECK: } do { //CHECK: memref.alloca_scope { -//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref +//CHECK: %[[alloca_0:.+]] = memref.alloca() {alignment = 4 : i64} : memref<1xi32> //CHECK: %[[C0_I32_1:.+]] = arith.constant 0 : i32 -//CHECK: memref.store %[[C0_I32_1]], %[[alloca_0]][] : memref +//CHECK: memref.store %[[C0_I32_1]], %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: memref.alloca_scope { //CHECK: scf.while : () -> () { -//CHECK: %{{.*}} = memref.load %[[alloca_0]][] : memref +//CHECK: %{{.*}} = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C2_I32]] = arith.constant 2 : i32 //CHECK: %[[SEVEN:.*]] = arith.cmpi slt, %{{.*}}, %[[C2_I32]] : i32 //CHECK: scf.condition(%[[SEVEN]]) //CHECK: } do { -//CHECK: %{{.*}} = memref.load %[[alloca_0]][] : memref +//CHECK: %{{.*}} = memref.load %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32_2:.+]] = arith.constant 1 : i32 //CHECK: %{{.*}} = arith.addi %{{.*}}, %[[C1_I32_2]] : i32 -//CHECK: memref.store %{{.*}}, %[[alloca_0]][] : memref +//CHECK: memref.store %{{.*}}, %[[alloca_0]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: scf.yield //CHECK: } //CHECK: } -//CHECK: %[[ZERO]] = memref.load %[[alloca]][] : memref +//CHECK: %[[ZERO]] = memref.load %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: %[[C1_I32:.+]] = arith.constant 1 : i32 //CHECK: %[[ONE]] = arith.addi %[[ZERO]], %[[C1_I32]] : i32 -//CHECK: memref.store %[[ONE]], %[[alloca]][] : memref +//CHECK: memref.store %[[ONE]], %[[alloca]][{{%c0(_[0-9]+)?}}] : memref<1xi32> //CHECK: } //CHECK: scf.yield //CHECK: }